ShuriZma
/
stella
mirror of https://github.com/stella-emu/stella.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

More fixes for warnings from clang-tidy, in `src/cheat` and `src/common`.

This commit is contained in:
Stephen Anthony 2024-08-01 12:20:40 -02:30
parent 2fd4756f2d
commit c48f03b2a1
65 changed files with 306 additions and 289 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/cheat/Cheat.hxx
View File

@ -27,7 +27,7 @@ class Cheat
public: public:
Cheat(OSystem& osystem, string_view name, string_view code) Cheat(OSystem& osystem, string_view name, string_view code)
: myOSystem{osystem}, : myOSystem{osystem},
myName{name == "" ? code : name}, myName{name.empty() ? code : name},
myCode{code} { } myCode{code} { }
virtual ~Cheat() = default; virtual ~Cheat() = default;

1
src/cheat/CheatManager.hxx
View File

@ -38,6 +38,7 @@ class CheatManager
{ {
public: public:
explicit CheatManager(OSystem& osystem); explicit CheatManager(OSystem& osystem);
~CheatManager() = default;
/** /**
Adds the specified cheat to an internal list. Adds the specified cheat to an internal list.

2
src/common/AudioQueue.hxx
View File

@ -46,6 +46,7 @@ class AudioQueue
@param isStereo Whether samples are stereo or mono. @param isStereo Whether samples are stereo or mono.
*/ */
AudioQueue(uInt32 fragmentSize, uInt32 capacity, bool isStereo); AudioQueue(uInt32 fragmentSize, uInt32 capacity, bool isStereo);
~AudioQueue() = default;
/** /**
Capacity getter. Capacity getter.
@ -133,7 +134,6 @@ class AudioQueue
StaggeredLogger myOverflowLogger{"audio buffer overflow", Logger::Level::INFO}; StaggeredLogger myOverflowLogger{"audio buffer overflow", Logger::Level::INFO};
private: private:
AudioQueue() = delete; AudioQueue() = delete;
AudioQueue(const AudioQueue&) = delete; AudioQueue(const AudioQueue&) = delete;
AudioQueue(AudioQueue&&) = delete; AudioQueue(AudioQueue&&) = delete;

4
src/common/AudioSettings.hxx
View File

@ -26,7 +26,7 @@ class AudioSettings
{ {
public: public:
enum class Preset { enum class Preset: uInt8 {
custom = 1, custom = 1,
lowQualityMediumLag = 2, lowQualityMediumLag = 2,
highQualityMediumLag = 3, highQualityMediumLag = 3,
@ -34,7 +34,7 @@ class AudioSettings
ultraQualityMinimalLag = 5 ultraQualityMinimalLag = 5
}; };
enum class ResamplingQuality { enum class ResamplingQuality: uInt8 {
nearestNeighbour = 1, nearestNeighbour = 1,
lanczos_2 = 2, lanczos_2 = 2,
lanczos_3 = 3 lanczos_3 = 3

2
src/common/Base.cxx
View File

@ -24,7 +24,7 @@ string Base::toString(int value, Common::Base::Fmt outputBase)
{ {
static char vToS_buf[32]; // NOLINT : One place where C-style is acceptable static char vToS_buf[32]; // NOLINT : One place where C-style is acceptable
if(outputBase == Base::Fmt::_DEFAULT) if(outputBase == Base::Fmt::DEFAULT)
outputBase = myDefaultBase; outputBase = myDefaultBase;
switch(outputBase) switch(outputBase)

17
src/common/Base.hxx
View File

@ -38,7 +38,7 @@ class Base
// The base to use for conversion from integers to strings // The base to use for conversion from integers to strings
// Note that the actual number of places will be determined by // Note that the actual number of places will be determined by
// the magnitude of the value itself in the general case // the magnitude of the value itself in the general case
enum class Fmt { enum class Fmt: uInt8 {
_16, // base 16: 2, 4, 8 bytes (depending on value) _16, // base 16: 2, 4, 8 bytes (depending on value)
_16_1, // base 16: 1 byte wide _16_1, // base 16: 1 byte wide
_16_2, // base 16: 2 bytes wide _16_2, // base 16: 2 bytes wide
@ -56,7 +56,7 @@ class Base
_2, // base 2: 8 or 16 bits (depending on value) _2, // base 2: 8 or 16 bits (depending on value)
_2_8, // base 2: 1 byte (8 bits) wide _2_8, // base 2: 1 byte (8 bits) wide
_2_16, // base 2: 2 bytes (16 bits) wide _2_16, // base 2: 2 bytes (16 bits) wide
_DEFAULT DEFAULT
}; };
public: public:
@ -72,31 +72,31 @@ class Base
static bool hexUppercase() { return myHexflags & std::ios_base::uppercase; } static bool hexUppercase() { return myHexflags & std::ios_base::uppercase; }
/** Output HEX digits in 0.5/1/2/4 byte format */ /** Output HEX digits in 0.5/1/2/4 byte format */
static inline std::ostream& HEX1(std::ostream& os) { static std::ostream& HEX1(std::ostream& os) {
os.flags(myHexflags); os.flags(myHexflags);
return os << std::setw(1); return os << std::setw(1);
} }
static inline std::ostream& HEX2(std::ostream& os) { static std::ostream& HEX2(std::ostream& os) {
os.flags(myHexflags); os.flags(myHexflags);
return os << std::setw(2) << std::setfill('0'); return os << std::setw(2) << std::setfill('0');
} }
static inline std::ostream& HEX3(std::ostream& os) static std::ostream& HEX3(std::ostream& os)
{ {
os.flags(myHexflags); os.flags(myHexflags);
return os << std::setw(3) << std::setfill('0'); return os << std::setw(3) << std::setfill('0');
} }
static inline std::ostream& HEX4(std::ostream& os) { static std::ostream& HEX4(std::ostream& os) {
os.flags(myHexflags); os.flags(myHexflags);
return os << std::setw(4) << std::setfill('0'); return os << std::setw(4) << std::setfill('0');
} }
static inline std::ostream& HEX8(std::ostream& os) { static std::ostream& HEX8(std::ostream& os) {
os.flags(myHexflags); os.flags(myHexflags);
return os << std::setw(8) << std::setfill('0'); return os << std::setw(8) << std::setfill('0');
} }
/** Convert integer to a string in the given base format */ /** Convert integer to a string in the given base format */
static string toString(int value, static string toString(int value,
Common::Base::Fmt outputBase = Common::Base::Fmt::_DEFAULT); Common::Base::Fmt outputBase = Common::Base::Fmt::DEFAULT);
private: private:
// Default format to use when none is specified // Default format to use when none is specified
@ -108,6 +108,7 @@ class Base
private: private:
// Following constructors and assignment operators not supported // Following constructors and assignment operators not supported
Base() = delete; Base() = delete;
~Base() = delete;
Base(const Base&) = delete; Base(const Base&) = delete;
Base(Base&&) = delete; Base(Base&&) = delete;
Base& operator=(const Base&) = delete; Base& operator=(const Base&) = delete;

4
src/common/DevSettingsHandler.hxx
View File

@ -21,6 +21,7 @@
class OSystem; class OSystem;
#include <array> #include <array>
#include "bspf.hxx"
/** /**
This class takes care of developer settings sets. This class takes care of developer settings sets.
@ -30,13 +31,14 @@ class OSystem;
class DevSettingsHandler class DevSettingsHandler
{ {
public: public:
enum SettingsSet { enum SettingsSet: uInt8 {
player, player,
developer, developer,
numSets numSets
}; };
explicit DevSettingsHandler(OSystem& osystem); explicit DevSettingsHandler(OSystem& osystem);
~DevSettingsHandler() = default;
void loadSettings(SettingsSet set); void loadSettings(SettingsSet set);
void saveSettings(SettingsSet set); void saveSettings(SettingsSet set);

4
src/common/FBBackendSDL2.hxx
View File

@ -120,7 +120,7 @@ class FBBackendSDL2 : public FBBackend
@param g The green component of the color. @param g The green component of the color.
@param b The blue component of the color. @param b The blue component of the color.
*/ */
inline uInt32 mapRGB(uInt8 r, uInt8 g, uInt8 b) const override uInt32 mapRGB(uInt8 r, uInt8 g, uInt8 b) const override
{ return SDL_MapRGB(myPixelFormat, r, g, b); } { return SDL_MapRGB(myPixelFormat, r, g, b); }
/** /**
@ -131,7 +131,7 @@ class FBBackendSDL2 : public FBBackend
@param b The blue component of the color. @param b The blue component of the color.
@param a The alpha component of the color. @param a The alpha component of the color.
*/ */
inline uInt32 mapRGBA(uInt8 r, uInt8 g, uInt8 b, uInt8 a) const override uInt32 mapRGBA(uInt8 r, uInt8 g, uInt8 b, uInt8 a) const override
{ return SDL_MapRGBA(myPixelFormat, r, g, b, a); } { return SDL_MapRGBA(myPixelFormat, r, g, b, a); }
/** /**

8
src/common/FBSurfaceSDL2.hxx
View File

@ -69,7 +69,7 @@ class FBSurfaceSDL2 : public FBSurface
void applyAttributes() override; void applyAttributes() override;
private: private:
inline bool setSrcPosInternal(uInt32 x, uInt32 y) { bool setSrcPosInternal(uInt32 x, uInt32 y) {
if(x != static_cast<uInt32>(mySrcR.x) || y != static_cast<uInt32>(mySrcR.y)) if(x != static_cast<uInt32>(mySrcR.x) || y != static_cast<uInt32>(mySrcR.y))
{ {
mySrcR.x = x; mySrcR.y = y; mySrcR.x = x; mySrcR.y = y;
@ -78,7 +78,7 @@ class FBSurfaceSDL2 : public FBSurface
} }
return false; return false;
} }
inline bool setSrcSizeInternal(uInt32 w, uInt32 h) { bool setSrcSizeInternal(uInt32 w, uInt32 h) {
if(w != static_cast<uInt32>(mySrcR.w) || h != static_cast<uInt32>(mySrcR.h)) if(w != static_cast<uInt32>(mySrcR.w) || h != static_cast<uInt32>(mySrcR.h))
{ {
mySrcR.w = w; mySrcR.h = h; mySrcR.w = w; mySrcR.h = h;
@ -87,7 +87,7 @@ class FBSurfaceSDL2 : public FBSurface
} }
return false; return false;
} }
inline bool setDstPosInternal(uInt32 x, uInt32 y) { bool setDstPosInternal(uInt32 x, uInt32 y) {
if(x != static_cast<uInt32>(myDstR.x) || y != static_cast<uInt32>(myDstR.y)) if(x != static_cast<uInt32>(myDstR.x) || y != static_cast<uInt32>(myDstR.y))
{ {
myDstR.x = x; myDstR.y = y; myDstR.x = x; myDstR.y = y;
@ -96,7 +96,7 @@ class FBSurfaceSDL2 : public FBSurface
} }
return false; return false;
} }
inline bool setDstSizeInternal(uInt32 w, uInt32 h) { bool setDstSizeInternal(uInt32 w, uInt32 h) {
if(w != static_cast<uInt32>(myDstR.w) || h != static_cast<uInt32>(myDstR.h)) if(w != static_cast<uInt32>(myDstR.w) || h != static_cast<uInt32>(myDstR.h))
{ {
myDstR.w = w; myDstR.h = h; myDstR.w = w; myDstR.h = h;

3
src/common/FSNodeFactory.hxx
View File

@ -41,7 +41,7 @@ class AbstractFSNode;
class FSNodeFactory class FSNodeFactory
{ {
public: public:
enum class Type { SYSTEM, ZIP }; enum class Type: uInt8 { SYSTEM, ZIP };
public: public:
static unique_ptr<AbstractFSNode> create(string_view path, Type type) static unique_ptr<AbstractFSNode> create(string_view path, Type type)
@ -71,6 +71,7 @@ class FSNodeFactory
private: private:
// Following constructors and assignment operators not supported // Following constructors and assignment operators not supported
FSNodeFactory() = delete; FSNodeFactory() = delete;
~FSNodeFactory() = delete;
FSNodeFactory(const FSNodeFactory&) = delete; FSNodeFactory(const FSNodeFactory&) = delete;
FSNodeFactory(FSNodeFactory&&) = delete; FSNodeFactory(FSNodeFactory&&) = delete;
FSNodeFactory& operator=(const FSNodeFactory&) = delete; FSNodeFactory& operator=(const FSNodeFactory&) = delete;

2
src/common/FSNodeZIP.hxx
View File

@ -88,7 +88,7 @@ class FSNodeZIP : public AbstractFSNode
private: private:
/* Error types */ /* Error types */
enum class zip_error enum class zip_error: uInt8
{ {
NONE, NONE,
NOT_A_FILE, NOT_A_FILE,

1
src/common/FpsMeter.hxx
View File

@ -27,6 +27,7 @@ class FpsMeter
public: public:
explicit FpsMeter(uInt32 queueSize); explicit FpsMeter(uInt32 queueSize);
~FpsMeter() = default;
void reset(uInt32 garbageFrameLimit = 0); void reset(uInt32 garbageFrameLimit = 0);

4
src/common/JPGLibrary.hxx
View File

@ -23,6 +23,9 @@
class OSystem; class OSystem;
class FBSurface; class FBSurface;
#include "Variant.hxx"
#include "bspf.hxx"
/** /**
This class implements a thin wrapper around the nanojpeg library, and This class implements a thin wrapper around the nanojpeg library, and
abstracts all the irrelevant details other loading an actual image. abstracts all the irrelevant details other loading an actual image.
@ -33,6 +36,7 @@ class JPGLibrary
{ {
public: public:
explicit JPGLibrary(OSystem& osystem); explicit JPGLibrary(OSystem& osystem);
~JPGLibrary() = default;
/** /**
Read a JPG image from the specified file into a FBSurface structure, Read a JPG image from the specified file into a FBSurface structure,

46
src/common/JoyMap.cxx
View File

@ -22,22 +22,21 @@
using json = nlohmann::json; using json = nlohmann::json;
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void JoyMap::add(const Event::Type event, const JoyMapping& mapping) void JoyMap::add(Event::Type event, const JoyMapping& mapping)
{ {
myMap[mapping] = event; myMap[mapping] = event;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void JoyMap::add(const Event::Type event, const EventMode mode, const int button, void JoyMap::add(Event::Type event, EventMode mode, int button,
const JoyAxis axis, const JoyDir adir, JoyAxis axis, JoyDir adir, int hat, JoyHatDir hdir)
const int hat, const JoyHatDir hdir)
{ {
add(event, JoyMapping(mode, button, axis, adir, hat, hdir)); add(event, JoyMapping(mode, button, axis, adir, hat, hdir));
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void JoyMap::add(const Event::Type event, const EventMode mode, const int button, void JoyMap::add(Event::Type event, EventMode mode, int button,
const int hat, const JoyHatDir hdir) int hat, JoyHatDir hdir)
{ {
add(event, JoyMapping(mode, button, hat, hdir)); add(event, JoyMapping(mode, button, hat, hdir));
} }
@ -49,15 +48,13 @@ void JoyMap::erase(const JoyMapping& mapping)
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void JoyMap::erase(const EventMode mode, const int button, void JoyMap::erase(EventMode mode, int button, JoyAxis axis, JoyDir adir)
const JoyAxis axis, const JoyDir adir)
{ {
erase(JoyMapping(mode, button, axis, adir)); erase(JoyMapping(mode, button, axis, adir));
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void JoyMap::erase(const EventMode mode, const int button, void JoyMap::erase(EventMode mode, int button, int hat, JoyHatDir hdir)
const int hat, const JoyHatDir hdir)
{ {
erase(JoyMapping(mode, button, hat, hdir)); erase(JoyMapping(mode, button, hat, hdir));
} }
@ -82,15 +79,15 @@ Event::Type JoyMap::get(const JoyMapping& mapping) const
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Event::Type JoyMap::get(const EventMode mode, const int button, Event::Type JoyMap::get(EventMode mode, int button,
const JoyAxis axis, const JoyDir adir) const JoyAxis axis, JoyDir adir) const
{ {
return get(JoyMapping(mode, button, axis, adir)); return get(JoyMapping(mode, button, axis, adir));
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Event::Type JoyMap::get(const EventMode mode, const int button, Event::Type JoyMap::get(EventMode mode, int button,
const int hat, const JoyHatDir hdir) const int hat, JoyHatDir hdir) const
{ {
return get(JoyMapping(mode, button, hat, hdir)); return get(JoyMapping(mode, button, hat, hdir));
} }
@ -102,15 +99,14 @@ bool JoyMap::check(const JoyMapping& mapping) const
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool JoyMap::check(const EventMode mode, const int button, bool JoyMap::check(EventMode mode, int button, JoyAxis axis, JoyDir adir,
const JoyAxis axis, const JoyDir adir, int hat, JoyHatDir hdir) const
const int hat, const JoyHatDir hdir) const
{ {
return check(JoyMapping(mode, button, axis, adir, hat, hdir)); return check(JoyMapping(mode, button, axis, adir, hat, hdir));
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
string JoyMap::getDesc(const Event::Type event, const JoyMapping& mapping) string JoyMap::getDesc(Event::Type event, const JoyMapping& mapping)
{ {
ostringstream buf; ostringstream buf;
@ -156,7 +152,8 @@ string JoyMap::getDesc(const Event::Type event, const JoyMapping& mapping)
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
string JoyMap::getEventMappingDesc(int stick, const Event::Type event, const EventMode mode) const string JoyMap::getEventMappingDesc(int stick, Event::Type event,
EventMode mode) const
{ {
ostringstream buf; ostringstream buf;
@ -173,7 +170,8 @@ string JoyMap::getEventMappingDesc(int stick, const Event::Type event, const Eve
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
JoyMap::JoyMappingArray JoyMap::getEventMapping(const Event::Type event, const EventMode mode) const JoyMap::JoyMappingArray JoyMap::getEventMapping(Event::Type event,
EventMode mode) const
{ {
JoyMappingArray map; JoyMappingArray map;
@ -185,7 +183,7 @@ JoyMap::JoyMappingArray JoyMap::getEventMapping(const Event::Type event, const E
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
json JoyMap::saveMapping(const EventMode mode) const json JoyMap::saveMapping(EventMode mode) const
{ {
using MapType = std::pair<JoyMapping, Event::Type>; using MapType = std::pair<JoyMapping, Event::Type>;
std::vector<MapType> sortedMap(myMap.begin(), myMap.end()); std::vector<MapType> sortedMap(myMap.begin(), myMap.end());
@ -241,7 +239,7 @@ json JoyMap::saveMapping(const EventMode mode) const
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
int JoyMap::loadMapping(const json& eventMappings, const EventMode mode) int JoyMap::loadMapping(const json& eventMappings, EventMode mode)
{ {
int i = 0; int i = 0;
@ -327,7 +325,7 @@ json JoyMap::convertLegacyMapping(string list)
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void JoyMap::eraseMode(const EventMode mode) void JoyMap::eraseMode(EventMode mode)
{ {
for(auto item = myMap.begin(); item != myMap.end();) for(auto item = myMap.begin(); item != myMap.end();)
if(item->first.mode == mode) { if(item->first.mode == mode) {
@ -338,7 +336,7 @@ void JoyMap::eraseMode(const EventMode mode)
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void JoyMap::eraseEvent(const Event::Type event, const EventMode mode) void JoyMap::eraseEvent(Event::Type event, EventMode mode)
{ {
for(auto item = myMap.begin(); item != myMap.end();) for(auto item = myMap.begin(); item != myMap.end();)
if(item->second == event && item->first.mode == mode) { if(item->second == event && item->first.mode == mode) {

58
src/common/JoyMap.hxx
View File

@ -58,6 +58,7 @@ class JoyMap
axis{JoyAxis::NONE}, adir{JoyDir::NONE}, axis{JoyAxis::NONE}, adir{JoyDir::NONE},
hat{c_hat}, hdir{c_hdir} { } hat{c_hat}, hdir{c_hdir} { }
~JoyMapping() = default;
JoyMapping(const JoyMapping&) = default; JoyMapping(const JoyMapping&) = default;
JoyMapping& operator=(const JoyMapping&) = default; JoyMapping& operator=(const JoyMapping&) = default;
JoyMapping(JoyMapping&&) = default; JoyMapping(JoyMapping&&) = default;
@ -77,64 +78,61 @@ class JoyMap
using JoyMappingArray = std::vector<JoyMapping>; using JoyMappingArray = std::vector<JoyMapping>;
JoyMap() = default; JoyMap() = default;
~JoyMap() = default;
/** Add new mapping for given event */ /** Add new mapping for given event */
void add(const Event::Type event, const JoyMapping& mapping); void add(Event::Type event, const JoyMapping& mapping);
void add(const Event::Type event, const EventMode mode, const int button, void add(Event::Type event, EventMode mode, int button,
const JoyAxis axis, const JoyDir adir, JoyAxis axis, JoyDir adir,
const int hat = JOY_CTRL_NONE, const JoyHatDir hdir = JoyHatDir::CENTER); int hat = JOY_CTRL_NONE, JoyHatDir hdir = JoyHatDir::CENTER);
void add(const Event::Type event, const EventMode mode, const int button, void add(Event::Type event, EventMode mode, int button,
const int hat, const JoyHatDir hdir); int hat, JoyHatDir hdir);
/** Erase mapping */ /** Erase mapping */
void erase(const JoyMapping& mapping); void erase(const JoyMapping& mapping);
void erase(const EventMode mode, const int button, void erase(EventMode mode, int button, JoyAxis axis, JoyDir adir);
const JoyAxis axis, const JoyDir adir); void erase(EventMode mode, int button, int hat, JoyHatDir hdir);
void erase(const EventMode mode, const int button,
const int hat, const JoyHatDir hdir);
/** Get event for mapping */ /** Get event for mapping */
Event::Type get(const JoyMapping& mapping) const; Event::Type get(const JoyMapping& mapping) const;
Event::Type get(const EventMode mode, const int button, Event::Type get(EventMode mode, int button, JoyAxis axis = JoyAxis::NONE,
const JoyAxis axis = JoyAxis::NONE, const JoyDir adir = JoyDir::NONE) const; JoyDir adir = JoyDir::NONE) const;
Event::Type get(const EventMode mode, const int button, Event::Type get(EventMode mode, int button, int hat, JoyHatDir hdir) const;
const int hat, const JoyHatDir hdir) const;
/** Check if a mapping exists */ /** Check if a mapping exists */
bool check(const JoyMapping& mapping) const; bool check(const JoyMapping& mapping) const;
bool check(const EventMode mode, const int button, bool check(EventMode mode, int button, JoyAxis axis, JoyDir adir,
const JoyAxis axis, const JoyDir adir, int hat = JOY_CTRL_NONE, JoyHatDir hdir = JoyHatDir::CENTER) const;
const int hat = JOY_CTRL_NONE, const JoyHatDir hdir = JoyHatDir::CENTER) const;
/** Get mapping description */ /** Get mapping description */
string getEventMappingDesc(int stick, const Event::Type event, const EventMode mode) const; string getEventMappingDesc(int stick, Event::Type event, EventMode mode) const;
JoyMappingArray getEventMapping(const Event::Type event, const EventMode mode) const; JoyMappingArray getEventMapping(Event::Type event, EventMode mode) const;
nlohmann::json saveMapping(const EventMode mode) const; nlohmann::json saveMapping(EventMode mode) const;
int loadMapping(const nlohmann::json& eventMappings, const EventMode mode); int loadMapping(const nlohmann::json& eventMappings, EventMode mode);
static nlohmann::json convertLegacyMapping(string list); static nlohmann::json convertLegacyMapping(string list);
/** Erase all mappings for given mode */ /** Erase all mappings for given mode */
void eraseMode(const EventMode mode); void eraseMode(EventMode mode);
/** Erase given event's mapping for given mode */ /** Erase given event's mapping for given mode */
void eraseEvent(const Event::Type event, const EventMode mode); void eraseEvent(Event::Type event, EventMode mode);
/** clear all mappings for a modes */ /** clear all mappings for a modes */
// void clear() { myMap.clear(); } // void clear() { myMap.clear(); }
size_t size() const { return myMap.size(); } size_t size() const { return myMap.size(); }
private: private:
static string getDesc(const Event::Type event, const JoyMapping& mapping); static string getDesc(Event::Type event, const JoyMapping& mapping);
struct JoyHash { struct JoyHash {
size_t operator()(const JoyMapping& m)const { size_t operator()(const JoyMapping& m)const {
return std::hash<uInt64>()((uInt64(m.mode)) // 3 bits return std::hash<uInt64>()((static_cast<uInt64>(m.mode)) // 3 bits
+ ((uInt64(m.button)) * 7) // 3 bits + ((static_cast<uInt64>(m.button)) * 7) // 3 bits
+ (((uInt64(m.axis)) << 0) // 2 bits + (((static_cast<uInt64>(m.axis)) << 0) // 2 bits
| ((uInt64(m.adir)) << 2) // 2 bits | ((static_cast<uInt64>(m.adir)) << 2) // 2 bits
| ((uInt64(m.hat )) << 4) // 1 bit | ((static_cast<uInt64>(m.hat )) << 4) // 1 bit
| ((uInt64(m.hdir)) << 5) // 2 bits | ((static_cast<uInt64>(m.hdir)) << 5) // 2 bits
) * 61 ) * 61
); );
} }

27
src/common/KeyMap.cxx
View File

@ -68,13 +68,13 @@ namespace {
} // namespace } // namespace
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void KeyMap::add(const Event::Type event, const Mapping& mapping) void KeyMap::add(Event::Type event, const Mapping& mapping)
{ {
myMap[convertMod(mapping)] = event; myMap[convertMod(mapping)] = event;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void KeyMap::add(const Event::Type event, const EventMode mode, const int key, const int mod) void KeyMap::add(Event::Type event, EventMode mode, int key, int mod)
{ {
add(event, Mapping(mode, key, mod)); add(event, Mapping(mode, key, mod));
} }
@ -86,7 +86,7 @@ void KeyMap::erase(const Mapping& mapping)
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void KeyMap::erase(const EventMode mode, const int key, const int mod) void KeyMap::erase(EventMode mode, int key, int mod)
{ {
erase(Mapping(mode, key, mod)); erase(Mapping(mode, key, mod));
} }
@ -114,7 +114,7 @@ Event::Type KeyMap::get(const Mapping& mapping) const
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Event::Type KeyMap::get(const EventMode mode, const int key, const int mod) const Event::Type KeyMap::get(EventMode mode, int key, int mod) const
{ {
return get(Mapping(mode, key, mod)); return get(Mapping(mode, key, mod));
} }
@ -126,7 +126,7 @@ bool KeyMap::check(const Mapping& mapping) const
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool KeyMap::check(const EventMode mode, const int key, const int mod) const bool KeyMap::check(EventMode mode, int key, int mod) const
{ {
return check(Mapping(mode, key, mod)); return check(Mapping(mode, key, mod));
} }
@ -181,13 +181,13 @@ string KeyMap::getDesc(const Mapping& mapping)
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
string KeyMap::getDesc(const EventMode mode, const int key, const int mod) string KeyMap::getDesc(EventMode mode, int key, int mod)
{ {
return getDesc(Mapping(mode, key, mod)); return getDesc(Mapping(mode, key, mod));
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
string KeyMap::getEventMappingDesc(const Event::Type event, const EventMode mode) const string KeyMap::getEventMappingDesc(Event::Type event, EventMode mode) const
{ {
ostringstream buf; ostringstream buf;
@ -204,8 +204,8 @@ string KeyMap::getEventMappingDesc(const Event::Type event, const EventMode mode
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
KeyMap::MappingArray KeyMap::getEventMapping(const Event::Type event, KeyMap::MappingArray KeyMap::getEventMapping(Event::Type event,
const EventMode mode) const EventMode mode) const
{ {
MappingArray ma; MappingArray ma;
@ -217,7 +217,7 @@ KeyMap::MappingArray KeyMap::getEventMapping(const Event::Type event,
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
json KeyMap::saveMapping(const EventMode mode) const json KeyMap::saveMapping(EventMode mode) const
{ {
using MapType = std::pair<Mapping, Event::Type>; using MapType = std::pair<Mapping, Event::Type>;
std::vector<MapType> sortedMap(myMap.begin(), myMap.end()); std::vector<MapType> sortedMap(myMap.begin(), myMap.end());
@ -256,7 +256,8 @@ json KeyMap::saveMapping(const EventMode mode) const
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
int KeyMap::loadMapping(const json& mappings, const EventMode mode) { int KeyMap::loadMapping(const json& mappings, EventMode mode)
{
int i = 0; int i = 0;
for(const json& mapping : mappings) for(const json& mapping : mappings)
@ -313,7 +314,7 @@ json KeyMap::convertLegacyMapping(string_view lm)
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void KeyMap::eraseMode(const EventMode mode) void KeyMap::eraseMode(EventMode mode)
{ {
for(auto item = myMap.begin(); item != myMap.end();) for(auto item = myMap.begin(); item != myMap.end();)
if(item->first.mode == mode) { if(item->first.mode == mode) {
@ -324,7 +325,7 @@ void KeyMap::eraseMode(const EventMode mode)
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void KeyMap::eraseEvent(const Event::Type event, const EventMode mode) void KeyMap::eraseEvent(Event::Type event, EventMode mode)
{ {
for(auto item = myMap.begin(); item != myMap.end();) for(auto item = myMap.begin(); item != myMap.end();)
if(item->second == event && item->first.mode == mode) { if(item->second == event && item->first.mode == mode) {

38
src/common/KeyMap.hxx
View File

@ -42,6 +42,7 @@ class KeyMap
: mode{c_mode}, key{c_key}, mod{c_mod} { } : mode{c_mode}, key{c_key}, mod{c_mod} { }
explicit Mapping(EventMode c_mode, int c_key, int c_mod) explicit Mapping(EventMode c_mode, int c_key, int c_mod)
: mode{c_mode}, key{static_cast<StellaKey>(c_key)}, mod{static_cast<StellaMod>(c_mod)} { } : mode{c_mode}, key{static_cast<StellaKey>(c_key)}, mod{static_cast<StellaMod>(c_mod)} { }
~Mapping() = default;
Mapping(const Mapping&) = default; Mapping(const Mapping&) = default;
Mapping& operator=(const Mapping&) = default; Mapping& operator=(const Mapping&) = default;
Mapping(Mapping&&) = default; Mapping(Mapping&&) = default;
@ -61,41 +62,42 @@ class KeyMap
using MappingArray = std::vector<Mapping>; using MappingArray = std::vector<Mapping>;
KeyMap() = default; KeyMap() = default;
~KeyMap() = default;
/** Add new mapping for given event */ /** Add new mapping for given event */
void add(const Event::Type event, const Mapping& mapping); void add(Event::Type event, const Mapping& mapping);
void add(const Event::Type event, const EventMode mode, const int key, const int mod); void add(Event::Type event, EventMode mode, int key, int mod);
/** Erase mapping */ /** Erase mapping */
void erase(const Mapping& mapping); void erase(const Mapping& mapping);
void erase(const EventMode mode, const int key, const int mod); void erase(EventMode mode, int key, int mod);
/** Get event for mapping */ /** Get event for mapping */
Event::Type get(const Mapping& mapping) const; Event::Type get(const Mapping& mapping) const;
Event::Type get(const EventMode mode, const int key, const int mod) const; Event::Type get(EventMode mode, int key, int mod) const;
/** Check if a mapping exists */ /** Check if a mapping exists */
bool check(const Mapping& mapping) const; bool check(const Mapping& mapping) const;
bool check(const EventMode mode, const int key, const int mod) const; bool check(EventMode mode, int key, int mod) const;
/** Get mapping description */ /** Get mapping description */
static string getDesc(const Mapping& mapping); static string getDesc(const Mapping& mapping);
static string getDesc(const EventMode mode, const int key, const int mod); static string getDesc(EventMode mode, int key, int mod);
/** Get the mapping description(s) for given event and mode */ /** Get the mapping description(s) for given event and mode */
string getEventMappingDesc(const Event::Type event, const EventMode mode) const; string getEventMappingDesc(Event::Type event, EventMode mode) const;
MappingArray getEventMapping(const Event::Type event, const EventMode mode) const; MappingArray getEventMapping(Event::Type event, EventMode mode) const;
nlohmann::json saveMapping(const EventMode mode) const; nlohmann::json saveMapping(EventMode mode) const;
int loadMapping(const nlohmann::json& mapping, const EventMode mode); int loadMapping(const nlohmann::json& mapping, EventMode mode);
static nlohmann::json convertLegacyMapping(string_view lm); static nlohmann::json convertLegacyMapping(string_view lm);
/** Erase all mappings for given mode */ /** Erase all mappings for given mode */
void eraseMode(const EventMode mode); void eraseMode(EventMode mode);
/** Erase given event's mapping for given mode */ /** Erase given event's mapping for given mode */
void eraseEvent(const Event::Type event, const EventMode mode); void eraseEvent(Event::Type event, EventMode mode);
/** clear all mappings for a modes */ /** clear all mappings for a modes */
// void clear() { myMap.clear(); } // void clear() { myMap.clear(); }
size_t size() { return myMap.size(); } size_t size() { return myMap.size(); }
@ -108,12 +110,12 @@ class KeyMap
struct KeyHash { struct KeyHash {
size_t operator()(const Mapping& m) const { size_t operator()(const Mapping& m) const {
return std::hash<uInt64>()((uInt64(m.mode)) // 3 bits return std::hash<uInt64>()((static_cast<uInt64>(m.mode)) // 3 bits
+ ((uInt64(m.key)) * 7) // 8 bits + ((static_cast<uInt64>(m.key)) * 7) // 8 bits
+ (((uInt64((m.mod & KBDM_SHIFT) != 0) << 0)) // 1 bit + (((static_cast<uInt64>((m.mod & KBDM_SHIFT) != 0) << 0)) // 1 bit
| ((uInt64((m.mod & KBDM_ALT ) != 0) << 1)) // 1 bit | ((static_cast<uInt64>((m.mod & KBDM_ALT ) != 0) << 1)) // 1 bit
| ((uInt64((m.mod & KBDM_GUI ) != 0) << 2)) // 1 bit | ((static_cast<uInt64>((m.mod & KBDM_GUI ) != 0) << 2)) // 1 bit
| ((uInt64((m.mod & KBDM_CTRL ) != 0) << 3)) // 1 bit | ((static_cast<uInt64>((m.mod & KBDM_CTRL ) != 0) << 3)) // 1 bit
) * 2047 ) * 2047
); );
} }

1
src/common/LinkedObjectPool.hxx
View File

@ -60,6 +60,7 @@ class LinkedObjectPool
Create a pool of size CAPACITY; the active list starts out empty. Create a pool of size CAPACITY; the active list starts out empty.
*/ */
LinkedObjectPool() { resize(CAPACITY); } LinkedObjectPool() { resize(CAPACITY); }
~LinkedObjectPool() = default;
/** /**
Return node data that the 'current' iterator points to. Return node data that the 'current' iterator points to.

3
src/common/Logger.hxx
View File

@ -27,7 +27,7 @@ class Logger {
public: public:
enum class Level { enum class Level: uInt8 {
ERR = 0, // cannot use ERROR??? ERR = 0, // cannot use ERROR???
INFO = 1, INFO = 1,
DEBUG = 2, DEBUG = 2,
@ -55,6 +55,7 @@ class Logger {
protected: protected:
Logger() = default; Logger() = default;
~Logger() = default;
private: private:
int myLogLevel{static_cast<int>(Level::MAX)}; int myLogLevel{static_cast<int>(Level::MAX)};

1
src/common/MediaFactory.hxx
View File

@ -202,6 +202,7 @@ class MediaFactory
private: private:
// Following constructors and assignment operators not supported // Following constructors and assignment operators not supported
MediaFactory() = delete; MediaFactory() = delete;
~MediaFactory() = delete;
MediaFactory(const MediaFactory&) = delete; MediaFactory(const MediaFactory&) = delete;
MediaFactory(MediaFactory&&) = delete; MediaFactory(MediaFactory&&) = delete;
MediaFactory& operator=(const MediaFactory&) = delete; MediaFactory& operator=(const MediaFactory&) = delete;

5
src/common/MouseControl.hxx
View File

@ -19,9 +19,9 @@
#define MOUSE_CONTROL_HXX #define MOUSE_CONTROL_HXX
class Console; class Console;
class Controller;
class Properties; class Properties;
#include "Control.hxx"
#include "bspf.hxx" #include "bspf.hxx"
/** /**
@ -41,7 +41,7 @@ class MouseControl
/** /**
Enumeration of mouse axis control types Enumeration of mouse axis control types
*/ */
enum class Type enum class Type: uInt8
{ {
LeftPaddleA = 0, LeftPaddleB, RightPaddleA, RightPaddleB, LeftPaddleA = 0, LeftPaddleB, RightPaddleA, RightPaddleB,
LeftDriving, RightDriving, LeftMindLink, RightMindLink, LeftDriving, RightDriving, LeftMindLink, RightMindLink,
@ -56,6 +56,7 @@ class MouseControl
@param mode Contains information about how to use the mouse axes/buttons @param mode Contains information about how to use the mouse axes/buttons
*/ */
MouseControl(Console& console, string_view mode); MouseControl(Console& console, string_view mode);
~MouseControl() = default;
/** /**
Cycle through each available mouse control mode Cycle through each available mouse control mode

22
src/common/PKeyboardHandler.cxx
View File

@ -235,7 +235,7 @@ void PhysicalKeyboardHandler::setDefaultMapping(Event::Type event, EventMode mod
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void PhysicalKeyboardHandler::defineControllerMappings( void PhysicalKeyboardHandler::defineControllerMappings(
const Controller::Type type, Controller::Jack port, const Properties& properties, Controller::Type type, Controller::Jack port, const Properties& properties,
Controller::Type qtType1, Controller::Type qtType2) Controller::Type qtType1, Controller::Type qtType2)
{ {
// Determine controller events to use // Determine controller events to use
@ -265,7 +265,7 @@ void PhysicalKeyboardHandler::defineControllerMappings(
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
EventMode PhysicalKeyboardHandler::getMode(const Properties& properties, EventMode PhysicalKeyboardHandler::getMode(const Properties& properties,
const PropType propType) PropType propType)
{ {
const string& propName = properties.get(propType); const string& propName = properties.get(propType);
@ -276,7 +276,7 @@ EventMode PhysicalKeyboardHandler::getMode(const Properties& properties,
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
EventMode PhysicalKeyboardHandler::getMode(const Controller::Type type) EventMode PhysicalKeyboardHandler::getMode(Controller::Type type)
{ {
switch(type) switch(type)
{ {
@ -408,8 +408,7 @@ void PhysicalKeyboardHandler::enableMappings(const Event::EventSet& events,
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void PhysicalKeyboardHandler::enableMapping(const Event::Type event, void PhysicalKeyboardHandler::enableMapping(Event::Type event, EventMode mode)
EventMode mode)
{ {
// copy from controller mode into emulation mode // copy from controller mode into emulation mode
const KeyMap::MappingArray mappings = myKeyMap.getEventMapping(event, mode); const KeyMap::MappingArray mappings = myKeyMap.getEventMapping(event, mode);
@ -419,8 +418,7 @@ void PhysicalKeyboardHandler::enableMapping(const Event::Type event,
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
EventMode PhysicalKeyboardHandler::getEventMode(const Event::Type event, EventMode PhysicalKeyboardHandler::getEventMode(Event::Type event, EventMode mode)
const EventMode mode)
{ {
if (mode == EventMode::kEmulationMode) if (mode == EventMode::kEmulationMode)
{ {
@ -444,7 +442,7 @@ EventMode PhysicalKeyboardHandler::getEventMode(const Event::Type event,
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool PhysicalKeyboardHandler::isJoystickEvent(const Event::Type event) bool PhysicalKeyboardHandler::isJoystickEvent(Event::Type event)
{ {
return LeftJoystickEvents.contains(event) return LeftJoystickEvents.contains(event)
|| QTJoystick3Events.contains(event) || QTJoystick3Events.contains(event)
@ -453,7 +451,7 @@ bool PhysicalKeyboardHandler::isJoystickEvent(const Event::Type event)
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool PhysicalKeyboardHandler::isPaddleEvent(const Event::Type event) bool PhysicalKeyboardHandler::isPaddleEvent(Event::Type event)
{ {
return LeftPaddlesEvents.contains(event) return LeftPaddlesEvents.contains(event)
|| QTPaddles3Events.contains(event) || QTPaddles3Events.contains(event)
@ -462,21 +460,21 @@ bool PhysicalKeyboardHandler::isPaddleEvent(const Event::Type event)
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool PhysicalKeyboardHandler::isKeyboardEvent(const Event::Type event) bool PhysicalKeyboardHandler::isKeyboardEvent(Event::Type event)
{ {
return LeftKeyboardEvents.contains(event) return LeftKeyboardEvents.contains(event)
|| RightKeyboardEvents.contains(event); || RightKeyboardEvents.contains(event);
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool PhysicalKeyboardHandler::isDrivingEvent(const Event::Type event) bool PhysicalKeyboardHandler::isDrivingEvent(Event::Type event)
{ {
return LeftDrivingEvents.contains(event) return LeftDrivingEvents.contains(event)
|| RightDrivingEvents.contains(event); || RightDrivingEvents.contains(event);
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool PhysicalKeyboardHandler::isCommonEvent(const Event::Type event) bool PhysicalKeyboardHandler::isCommonEvent(Event::Type event)
{ {
return !(isJoystickEvent(event) || isPaddleEvent(event) return !(isJoystickEvent(event) || isPaddleEvent(event)
|| isKeyboardEvent(event) || isDrivingEvent(event)); || isKeyboardEvent(event) || isDrivingEvent(event));

21
src/common/PKeyboardHandler.hxx
View File

@ -24,6 +24,7 @@ class OSystem;
class EventHandler; class EventHandler;
#include "bspf.hxx" #include "bspf.hxx"
#include "Control.hxx"
#include "Event.hxx" #include "Event.hxx"
#include "EventHandlerConstants.hxx" #include "EventHandlerConstants.hxx"
#include "Props.hxx" #include "Props.hxx"
@ -52,7 +53,7 @@ class PhysicalKeyboardHandler
bool updateDefaults = false); bool updateDefaults = false);
/** define mappings for current controllers */ /** define mappings for current controllers */
void defineControllerMappings(const Controller::Type type, void defineControllerMappings(Controller::Type type,
Controller::Jack port, Controller::Jack port,
const Properties& properties, const Properties& properties,
Controller::Type qtType1 = Controller::Type::Unknown, Controller::Type qtType1 = Controller::Type::Unknown,
@ -108,23 +109,23 @@ class PhysicalKeyboardHandler
EventMode mode = EventMode::kEmulationMode, bool updateDefaults = false); EventMode mode = EventMode::kEmulationMode, bool updateDefaults = false);
/** returns the event's controller mode */ /** returns the event's controller mode */
static EventMode getEventMode(const Event::Type event, const EventMode mode); static EventMode getEventMode(Event::Type event, EventMode mode);
/** Checks event type. */ /** Checks event type. */
static bool isJoystickEvent(const Event::Type event); static bool isJoystickEvent(Event::Type event);
static bool isPaddleEvent(const Event::Type event); static bool isPaddleEvent(Event::Type event);
static bool isKeyboardEvent(const Event::Type event); static bool isKeyboardEvent(Event::Type event);
static bool isDrivingEvent(const Event::Type event); static bool isDrivingEvent(Event::Type event);
static bool isCommonEvent(const Event::Type event); static bool isCommonEvent(Event::Type event);
void enableCommonMappings(); void enableCommonMappings();
void enableMappings(const Event::EventSet& events, EventMode mode); void enableMappings(const Event::EventSet& events, EventMode mode);
void enableMapping(const Event::Type event, EventMode mode); void enableMapping(Event::Type event, EventMode mode);
/** return event mode for given property */ /** return event mode for given property */
static EventMode getMode(const Properties& properties, const PropType propType); static EventMode getMode(const Properties& properties, PropType propType);
/** return event mode for given controller type */ /** return event mode for given controller type */
static EventMode getMode(const Controller::Type type); static EventMode getMode(Controller::Type type);
#ifdef DEBUG_BUILD #ifdef DEBUG_BUILD
void verifyDefaultMapping(PhysicalKeyboardHandler::EventMappingArray mapping, void verifyDefaultMapping(PhysicalKeyboardHandler::EventMappingArray mapping,

24
src/common/PNGLibrary.cxx
View File

@ -442,9 +442,8 @@ void PNGLibrary::loadImagetoSurface(FBSurface& surface, bool hasAlpha)
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void PNGLibrary::writeMetaData( void PNGLibrary::writeMetaData(png_structp png_ptr, png_infop info_ptr,
const png_structp png_ptr, png_infop info_ptr, // NOLINT const VariantList& metaData)
const VariantList& metaData)
{ {
const size_t numMetaData = metaData.size(); const size_t numMetaData = metaData.size();
if(numMetaData == 0) if(numMetaData == 0)
@ -462,9 +461,8 @@ void PNGLibrary::writeMetaData(
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void PNGLibrary::readMetaData( void PNGLibrary::readMetaData(png_structp png_ptr, png_infop info_ptr,
const png_structp png_ptr, png_infop info_ptr, // NOLINT VariantList& metaData)
VariantList& metaData)
{ {
png_textp text_ptr{nullptr}; png_textp text_ptr{nullptr};
int numMetaData{0}; int numMetaData{0};
@ -479,37 +477,33 @@ void PNGLibrary::readMetaData(
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void PNGLibrary::png_read_data(const png_structp ctx, // NOLINT void PNGLibrary::png_read_data(png_structp ctx, png_bytep area, png_size_t size)
png_bytep area, png_size_t size)
{ {
(static_cast<std::ifstream*>(png_get_io_ptr(ctx)))->read( (static_cast<std::ifstream*>(png_get_io_ptr(ctx)))->read(
reinterpret_cast<char *>(area), size); reinterpret_cast<char *>(area), size);
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void PNGLibrary::png_write_data(const png_structp ctx, // NOLINT void PNGLibrary::png_write_data(png_structp ctx, png_bytep area, png_size_t size)
png_bytep area, png_size_t size)
{ {
(static_cast<std::ofstream*>(png_get_io_ptr(ctx)))->write( (static_cast<std::ofstream*>(png_get_io_ptr(ctx)))->write(
reinterpret_cast<const char *>(area), size); reinterpret_cast<const char *>(area), size);
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void PNGLibrary::png_io_flush(const png_structp ctx) // NOLINT void PNGLibrary::png_io_flush(png_structp ctx)
{ {
(static_cast<std::ofstream*>(png_get_io_ptr(ctx)))->flush(); (static_cast<std::ofstream*>(png_get_io_ptr(ctx)))->flush();
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void PNGLibrary::png_user_warn(const png_structp ctx, // NOLINT void PNGLibrary::png_user_warn(png_structp ctx, png_const_charp str)
png_const_charp str)
{ {
throw runtime_error(string("PNGLibrary warning: ") + str); throw runtime_error(string("PNGLibrary warning: ") + str);
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void PNGLibrary::png_user_error(const png_structp ctx, // NOLINT void PNGLibrary::png_user_error(png_structp ctx, png_const_charp str)
png_const_charp str)
{ {
throw runtime_error(string("PNGLibrary error: ") + str); throw runtime_error(string("PNGLibrary error: ") + str);
} }

22
src/common/PNGLibrary.hxx
View File

@ -22,6 +22,9 @@
#include <png.h> #include <png.h>
#include "bspf.hxx"
#include "Variant.hxx"
class OSystem; class OSystem;
class FBSurface; class FBSurface;
@ -36,6 +39,7 @@ class PNGLibrary
{ {
public: public:
explicit PNGLibrary(OSystem& osystem); explicit PNGLibrary(OSystem& osystem);
~PNGLibrary() = default;
/** /**
Read a PNG image from the specified file into a FBSurface structure, Read a PNG image from the specified file into a FBSurface structure,
@ -178,25 +182,21 @@ class PNGLibrary
/** /**
Write PNG tEXt chunks to the image. Write PNG tEXt chunks to the image.
*/ */
static void writeMetaData(const png_structp png_ptr, png_infop info_ptr, static void writeMetaData(png_structp png_ptr, png_infop info_ptr,
const VariantList& metaData); const VariantList& metaData);
/** /**
Read PNG tEXt chunks from the image. Read PNG tEXt chunks from the image.
*/ */
static void readMetaData(const png_structp png_ptr, png_infop info_ptr, static void readMetaData(png_structp png_ptr, png_infop info_ptr,
VariantList& metaData); VariantList& metaData);
/** PNG library callback functions */ /** PNG library callback functions */
static void png_read_data(const png_structp ctx, png_bytep area, static void png_read_data(png_structp ctx, png_bytep area, png_size_t size);
png_size_t size); static void png_write_data(png_structp ctx, png_bytep area, png_size_t size);
static void png_write_data(const png_structp ctx, png_bytep area, static void png_io_flush(png_structp ctx);
png_size_t size); [[noreturn]] static void png_user_warn(png_structp ctx, png_const_charp str);
static void png_io_flush(const png_structp ctx); [[noreturn]] static void png_user_error(png_structp ctx, png_const_charp str);
[[noreturn]] static void png_user_warn(const png_structp ctx,
png_const_charp str);
[[noreturn]] static void png_user_error(const png_structp ctx,
png_const_charp str);
private: private:
// Following constructors and assignment operators not supported // Following constructors and assignment operators not supported

5
src/common/PaletteHandler.hxx
View File

@ -39,7 +39,7 @@ class PaletteHandler
static constexpr float DEF_RGB_SHIFT = 0.0F; static constexpr float DEF_RGB_SHIFT = 0.0F;
static constexpr float MAX_RGB_SHIFT = 22.5F; static constexpr float MAX_RGB_SHIFT = 22.5F;
enum Adjustables : uInt32 { enum Adjustables : uInt8 {
PHASE_SHIFT, PHASE_SHIFT,
RED_SCALE, RED_SCALE,
GREEN_SCALE, GREEN_SCALE,
@ -66,6 +66,7 @@ class PaletteHandler
public: public:
explicit PaletteHandler(OSystem& system); explicit PaletteHandler(OSystem& system);
~PaletteHandler() = default;
/** /**
Cycle through available palettes. Cycle through available palettes.
@ -124,7 +125,7 @@ class PaletteHandler
private: private:
static constexpr char DEGREE = 0x1c; static constexpr char DEGREE = 0x1c;
enum PaletteType { enum PaletteType: uInt8 {
Standard, Standard,
Z26, Z26,
User, User,

15
src/common/PhosphorHandler.hxx
View File

@ -33,7 +33,7 @@ class PhosphorHandler
static constexpr string_view VALUE_AUTO_ON = "autoon"; static constexpr string_view VALUE_AUTO_ON = "autoon";
static constexpr string_view VALUE_AUTO = "auto"; static constexpr string_view VALUE_AUTO = "auto";
enum PhosphorMode { enum PhosphorMode: uInt8 {
ByRom, ByRom,
Always, Always,
Auto_on, Auto_on,
@ -44,6 +44,7 @@ class PhosphorHandler
static constexpr string_view DEFAULT_BLEND = "50"; // align with myPhosphorPercent! static constexpr string_view DEFAULT_BLEND = "50"; // align with myPhosphorPercent!
PhosphorHandler() = default; PhosphorHandler() = default;
~PhosphorHandler() = default;
bool initialize(bool enable, int blend); bool initialize(bool enable, int blend);
@ -63,12 +64,12 @@ class PhosphorHandler
static constexpr uInt32 getPixel(const uInt32 c, const uInt32 p) static constexpr uInt32 getPixel(const uInt32 c, const uInt32 p)
{ {
// Mix current calculated frame with previous displayed frame // Mix current calculated frame with previous displayed frame
const uInt8 rc = static_cast<uInt8>(c >> 16), const auto rc = static_cast<uInt8>(c >> 16),
gc = static_cast<uInt8>(c >> 8), gc = static_cast<uInt8>(c >> 8),
bc = static_cast<uInt8>(c), bc = static_cast<uInt8>(c),
rp = static_cast<uInt8>(p >> 16), rp = static_cast<uInt8>(p >> 16),
gp = static_cast<uInt8>(p >> 8), gp = static_cast<uInt8>(p >> 8),
bp = static_cast<uInt8>(p); bp = static_cast<uInt8>(p);
return (ourPhosphorLUT[rc][rp] << 16) | (ourPhosphorLUT[gc][gp] << 8) | return (ourPhosphorLUT[rc][rp] << 16) | (ourPhosphorLUT[gc][gp] << 8) |
ourPhosphorLUT[bc][bp]; ourPhosphorLUT[bc][bp];

2
src/common/PhysicalJoystick.cxx
View File

@ -111,7 +111,7 @@ bool PhysicalJoystick::setMap(const json& map)
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
json PhysicalJoystick::convertLegacyMapping(string_view mapping, string_view name) json PhysicalJoystick::convertLegacyMapping(string_view mapping, string_view name)
{ {
istringstream buf(string{mapping}); // TODO: fixed in C++20 istringstream buf(string{mapping}); // TODO: fixed in C++23
json convertedMapping = json::object(); json convertedMapping = json::object();
string map; string map;

13
src/common/PhysicalJoystick.hxx
View File

@ -43,7 +43,7 @@ class PhysicalJoystick
static constexpr char MODE_DELIM = '>'; // must not be '^', '|' or '#' static constexpr char MODE_DELIM = '>'; // must not be '^', '|' or '#'
public: public:
enum class Port { enum class Port: uInt8 {
AUTO, AUTO,
LEFT, LEFT,
RIGHT, RIGHT,
@ -51,10 +51,11 @@ class PhysicalJoystick
}; };
PhysicalJoystick() = default; PhysicalJoystick() = default;
~PhysicalJoystick() = default;
nlohmann::json getMap() const; nlohmann::json getMap() const;
bool setMap(const nlohmann::json& map); bool setMap(const nlohmann::json& map);
void setPort(const Port _port) { port = _port; } void setPort(Port _port) { port = _port; }
static nlohmann::json convertLegacyMapping(string_view mapping, static nlohmann::json convertLegacyMapping(string_view mapping,
string_view name); string_view name);
@ -68,7 +69,7 @@ class PhysicalJoystick
int axes, int buttons, int hats, int balls); int axes, int buttons, int hats, int balls);
private: private:
enum class Type { enum class Type: uInt8 {
REGULAR, REGULAR,
LEFT_STELLADAPTOR, RIGHT_STELLADAPTOR, LEFT_STELLADAPTOR, RIGHT_STELLADAPTOR,
LEFT_2600DAPTOR, RIGHT_2600DAPTOR LEFT_2600DAPTOR, RIGHT_2600DAPTOR
@ -89,7 +90,7 @@ class PhysicalJoystick
// Convert from string to Port type and vice versa // Convert from string to Port type and vice versa
static string getName(const Port _port) { static string getName(const Port _port) {
static constexpr std::array<string_view, static constexpr std::array<string_view,
static_cast<int>(PhysicalJoystick::Port::NUM_PORTS)> NAMES = { static_cast<uInt8>(PhysicalJoystick::Port::NUM_PORTS)> NAMES = {
"Auto", "Left", "Right" "Auto", "Left", "Right"
}; };
@ -98,11 +99,11 @@ class PhysicalJoystick
static Port getPort(string_view portName) { static Port getPort(string_view portName) {
static constexpr std::array<string_view, static constexpr std::array<string_view,
static_cast<int>(PhysicalJoystick::Port::NUM_PORTS)> NAMES = { static_cast<uInt8>(PhysicalJoystick::Port::NUM_PORTS)> NAMES = {
"Auto", "Left", "Right" "Auto", "Left", "Right"
}; };
for(int i = 0; i < static_cast<int>(PhysicalJoystick::Port::NUM_PORTS); ++i) for(uInt8 i = 0; i < static_cast<uInt8>(PhysicalJoystick::Port::NUM_PORTS); ++i)
if (BSPF::equalsIgnoreCase(portName, NAMES[i])) if (BSPF::equalsIgnoreCase(portName, NAMES[i]))
return PhysicalJoystick::Port{i}; return PhysicalJoystick::Port{i};

8
src/common/RewindManager.hxx
View File

@ -22,6 +22,7 @@ class OSystem;
class StateManager; class StateManager;
#include "LinkedObjectPool.hxx" #include "LinkedObjectPool.hxx"
#include "Serializer.hxx"
#include "bspf.hxx" #include "bspf.hxx"
/** /**
@ -47,12 +48,13 @@ class RewindManager
{ {
public: public:
RewindManager(OSystem& system, StateManager& statemgr); RewindManager(OSystem& system, StateManager& statemgr);
~RewindManager() = default;
public: public:
static constexpr uInt32 MAX_BUF_SIZE = 1000; static constexpr uInt32 MAX_BUF_SIZE = 1000;
static constexpr int NUM_INTERVALS = 7; static constexpr int NUM_INTERVALS = 7;
// cycle values for the intervals // cycle values for the intervals
const std::array<uInt32, NUM_INTERVALS> INTERVAL_CYCLES = { static constexpr std::array<uInt32, NUM_INTERVALS> INTERVAL_CYCLES = {
76 * 262, 76 * 262,
76 * 262 * 3, 76 * 262 * 3,
76 * 262 * 10, 76 * 262 * 10,
@ -74,7 +76,7 @@ class RewindManager
static constexpr int NUM_HORIZONS = 8; static constexpr int NUM_HORIZONS = 8;
// cycle values for the horzions // cycle values for the horzions
const std::array<uInt64, NUM_HORIZONS> HORIZON_CYCLES = { static constexpr std::array<uInt64, NUM_HORIZONS> HORIZON_CYCLES = {
uInt64{76} * 262 * 60 * 3, uInt64{76} * 262 * 60 * 3,
uInt64{76} * 262 * 60 * 10, uInt64{76} * 262 * 60 * 10,
uInt64{76} * 262 * 60 * 30, uInt64{76} * 262 * 60 * 30,
@ -187,7 +189,7 @@ class RewindManager
RewindState() = default; RewindState() = default;
~RewindState() = default; ~RewindState() = default;
RewindState(const RewindState& rs) : cycles(rs.cycles) { } RewindState(const RewindState& rs) : cycles(rs.cycles) { }
RewindState& operator= (const RewindState& rs) { cycles = rs.cycles; return *this; } RewindState& operator= (const RewindState& rs) { cycles = rs.cycles; return *this; } // NOLINT: we don't worry about self-assignment here
RewindState(RewindState&&) = default; RewindState(RewindState&&) = default;
RewindState& operator=(RewindState&&) = default; RewindState& operator=(RewindState&&) = default;

2
src/common/SDL_lib.hxx
View File

@ -63,7 +63,7 @@ static inline string SDLVersion()
static inline bool SDLSupportsURL() static inline bool SDLSupportsURL()
{ {
return static_cast<bool>(SDL_VERSION_ATLEAST(2,0,14)); return SDL_VERSION_ATLEAST(2,0,14);
} }
static inline bool SDLOpenURL(const string& url) static inline bool SDLOpenURL(const string& url)

7
src/common/SoundSDL2.cxx
View File

@ -385,8 +385,7 @@ void SoundSDL2::callback(void* object, uInt8* stream, int len)
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool SoundSDL2::playWav(const string& fileName, const uInt32 position, bool SoundSDL2::playWav(const string& fileName, uInt32 position, uInt32 length)
const uInt32 length)
{ {
const char* const device = myDeviceId const char* const device = myDeviceId
? myDevices.at(myDeviceId).first.c_str() ? myDevices.at(myDeviceId).first.c_str()
@ -409,9 +408,7 @@ uInt32 SoundSDL2::wavSize() const
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool SoundSDL2::WavHandlerSDL2::play( bool SoundSDL2::WavHandlerSDL2::play(
const string& fileName, const char* device, const string& fileName, const char* device, uInt32 position, uInt32 length)
const uInt32 position, const uInt32 length
)
{ {
// Load WAV file // Load WAV file
if(fileName != myFilename || myBuffer == nullptr) if(fileName != myFilename || myBuffer == nullptr)

10
src/common/SoundSDL2.hxx
View File

@ -44,10 +44,6 @@ class SoundSDL2 : public Sound
using the object. using the object.
*/ */
SoundSDL2(OSystem& osystem, AudioSettings& audioSettings); SoundSDL2(OSystem& osystem, AudioSettings& audioSettings);
/**
Destructor
*/
~SoundSDL2() override; ~SoundSDL2() override;
public: public:
@ -121,8 +117,8 @@ class SoundSDL2 : public Sound
@return True if the WAV file can be played, else false @return True if the WAV file can be played, else false
*/ */
bool playWav(const string& fileName, const uInt32 position = 0, bool playWav(const string& fileName, uInt32 position = 0,
const uInt32 length = 0) override; uInt32 length = 0) override;
/** /**
Stop any currently playing WAV file. Stop any currently playing WAV file.
@ -185,7 +181,7 @@ class SoundSDL2 : public Sound
~WavHandlerSDL2(); ~WavHandlerSDL2();
bool play(const string& fileName, const char* device, bool play(const string& fileName, const char* device,
const uInt32 position, const uInt32 length); uInt32 position, uInt32 length);
void stop(); void stop();
uInt32 size() const { return myBuffer ? myRemaining : 0; } uInt32 size() const { return myBuffer ? myRemaining : 0; }

1
src/common/Stack.hxx
View File

@ -38,6 +38,7 @@ class FixedStack
using StackFunction = std::function<void(T&)>; using StackFunction = std::function<void(T&)>;
FixedStack() = default; FixedStack() = default;
~FixedStack() = default;
bool empty() const { return _size == 0; } bool empty() const { return _size == 0; }
bool full() const { return _size >= CAPACITY; } bool full() const { return _size >= CAPACITY; }

2
src/common/StateManager.hxx
View File

@ -35,7 +35,7 @@ class RewindManager;
class StateManager class StateManager
{ {
public: public:
enum class Mode { enum class Mode: uInt8 {
Off, Off,
TimeMachine, TimeMachine,
MovieRecord, MovieRecord,

10
src/common/StellaKeys.hxx
View File

@ -417,7 +417,7 @@ enum StellaMod
// Test if specified modifier is pressed // Test if specified modifier is pressed
namespace StellaModTest namespace StellaModTest
{ {
inline constexpr bool isAlt(int mod) constexpr bool isAlt(int mod)
{ {
#if defined(BSPF_MACOS) || defined(MACOS_KEYS) #if defined(BSPF_MACOS) || defined(MACOS_KEYS)
return (mod & KBDM_GUI); return (mod & KBDM_GUI);
@ -426,16 +426,16 @@ namespace StellaModTest
#endif #endif
} }
inline constexpr bool isControl(int mod) constexpr bool isControl(int mod)
{ {
return (mod & KBDM_CTRL); return (mod & KBDM_CTRL);
} }
inline constexpr bool isShift(int mod) constexpr bool isShift(int mod)
{ {
return (mod & KBDM_SHIFT); return (mod & KBDM_SHIFT);
} }
} } // namespace StellaModTest
namespace StellaKeyName namespace StellaKeyName
{ {
@ -447,6 +447,6 @@ namespace StellaKeyName
return string_view{}; return string_view{};
#endif #endif
} }
} } // namespace StellaKeyName
#endif /* StellaKeys */ #endif /* StellaKeys */

5
src/common/StringParser.hxx
View File

@ -36,12 +36,13 @@ class StringParser
*/ */
explicit StringParser(string_view str) explicit StringParser(string_view str)
{ {
istringstream buf(string{str}); // TODO: fixed in C++20 istringstream buf(string{str}); // TODO: fixed in C++23
string line; string line;
while(std::getline(buf, line, '\n')) while(std::getline(buf, line, '\n'))
myStringList.push_back(line); myStringList.push_back(line);
} }
~StringParser() = default;
/** /**
Split the given string based on the newline character, making sure that Split the given string based on the newline character, making sure that
@ -52,7 +53,7 @@ class StringParser
*/ */
StringParser(string_view str, uInt32 maxlen) StringParser(string_view str, uInt32 maxlen)
{ {
istringstream buf(string{str}); // TODO: fixed in C++20 istringstream buf(string{str}); // TODO: fixed in C++23
string line; string line;
while(std::getline(buf, line, '\n')) while(std::getline(buf, line, '\n'))

1
src/common/ThreadDebugging.hxx
View File

@ -49,6 +49,7 @@ class ThreadDebuggingHelper {
[[noreturn]] static void fail(const string& message); [[noreturn]] static void fail(const string& message);
ThreadDebuggingHelper() = default; ThreadDebuggingHelper() = default;
~ThreadDebuggingHelper() = default;
std::thread::id myMainThreadId; std::thread::id myMainThreadId;

2
src/common/TimerManager.hxx
View File

@ -205,7 +205,7 @@ class TimerManager
bool done{false}; bool done{false};
// Valid IDs are guaranteed not to be this value // Valid IDs are guaranteed not to be this value
static TimerId constexpr no_timer = TimerId(0); static TimerId constexpr no_timer = static_cast<TimerId>(0);
private: private:
// Following constructors and assignment operators not supported // Following constructors and assignment operators not supported

4
src/common/Variant.hxx
View File

@ -42,7 +42,7 @@ class Variant
} }
public: public:
Variant() = default; // NOLINT Variant() = default;
Variant(const string& s) : data{s} { } Variant(const string& s) : data{s} { }
Variant(string_view s) : data{s} { } Variant(string_view s) : data{s} { }
@ -89,6 +89,6 @@ namespace VarList {
{ {
list.emplace_back(name.toString(), tag); list.emplace_back(name.toString(), tag);
} }
} } // namespace VarList
#endif #endif

3
src/common/VideoModeHandler.hxx
View File

@ -34,7 +34,7 @@ class VideoModeHandler
// 'screen' are the dimensions of the screen itself // 'screen' are the dimensions of the screen itself
struct Mode struct Mode
{ {
enum class Stretch { enum class Stretch: uInt8 {
Preserve, // Stretch to fill all available space; preserve aspect ratio Preserve, // Stretch to fill all available space; preserve aspect ratio
Fill, // Stretch to fill all available space Fill, // Stretch to fill all available space
None // No stretching (1x zoom) None // No stretching (1x zoom)
@ -70,6 +70,7 @@ class VideoModeHandler
public: public:
VideoModeHandler() = default; VideoModeHandler() = default;
~VideoModeHandler() = default;
/** /**
Set the base size of the image. Scaling can be applied to this, Set the base size of the image. Scaling can be applied to this,

5
src/common/ZipHandler.hxx
View File

@ -35,6 +35,7 @@ class ZipHandler
{ {
public: public:
ZipHandler() = default; ZipHandler() = default;
~ZipHandler() = default;
// Open ZIP file for processing // Open ZIP file for processing
// An exception will be thrown on any errors // An exception will be thrown on any errors
@ -54,7 +55,7 @@ class ZipHandler
private: private:
// Error types // Error types
enum class ZipError enum class ZipError: uInt8
{ {
NONE = 0, NONE = 0,
OUT_OF_MEMORY, OUT_OF_MEMORY,
@ -182,7 +183,7 @@ class ZipHandler
} }
string read_string(size_t offs, size_t len = string::npos) const string read_string(size_t offs, size_t len = string::npos) const
{ {
return string(reinterpret_cast<char const *>(myBuf + offs), len); return {reinterpret_cast<char const *>(myBuf + offs), len};
} }
private: private:

5
src/common/audio/ConvolutionBuffer.hxx
View File

@ -23,12 +23,12 @@
class ConvolutionBuffer class ConvolutionBuffer
{ {
public: public:
explicit ConvolutionBuffer(uInt32 size); explicit ConvolutionBuffer(uInt32 size);
~ConvolutionBuffer() = default;
void shift(float nextValue); void shift(float nextValue);
float convoluteWith(const float* const kernel) const; float convoluteWith(const float* kernel) const;
private: private:
@ -39,7 +39,6 @@ class ConvolutionBuffer
uInt32 mySize{0}; uInt32 mySize{0};
private: private:
ConvolutionBuffer() = delete; ConvolutionBuffer() = delete;
ConvolutionBuffer(const ConvolutionBuffer&) = delete; ConvolutionBuffer(const ConvolutionBuffer&) = delete;
ConvolutionBuffer(ConvolutionBuffer&&) = delete; ConvolutionBuffer(ConvolutionBuffer&&) = delete;

1
src/common/audio/SimpleResampler.hxx
View File

@ -29,6 +29,7 @@ class SimpleResampler : public Resampler
Resampler::Format formatTo, Resampler::Format formatTo,
const Resampler::NextFragmentCallback& NextFragmentCallback const Resampler::NextFragmentCallback& NextFragmentCallback
); );
~SimpleResampler() override = default;
void fillFragment(float* fragment, uInt32 length) override; void fillFragment(float* fragment, uInt32 length) override;

26
src/common/bspf.hxx
View File

@ -88,8 +88,8 @@ using BoolArray = std::vector<bool>;
using ByteArray = std::vector<uInt8>; using ByteArray = std::vector<uInt8>;
using ShortArray = std::vector<uInt16>; using ShortArray = std::vector<uInt16>;
using StringList = std::vector<std::string>; using StringList = std::vector<std::string>;
using ByteBuffer = std::unique_ptr<uInt8[]>; // NOLINT using ByteBuffer = std::unique_ptr<uInt8[]>;
using DWordBuffer = std::unique_ptr<uInt32[]>; // NOLINT using DWordBuffer = std::unique_ptr<uInt32[]>;
// We use KB a lot; let's make a literal for it // We use KB a lot; let's make a literal for it
constexpr size_t operator "" _KB(unsigned long long size) constexpr size_t operator "" _KB(unsigned long long size)
@ -105,7 +105,7 @@ std::ostream& operator<< (std::ostream& out, const std::vector<T>& v) {
return out; return out;
} }
static const string EmptyString(""); static const string EmptyString;
// This is defined by some systems, but Stella has other uses for it // This is defined by some systems, but Stella has other uses for it
#undef PAGE_SIZE #undef PAGE_SIZE
@ -147,7 +147,7 @@ namespace BSPF
#endif #endif
// Get next power of two greater than or equal to the given value // Get next power of two greater than or equal to the given value
inline constexpr size_t nextPowerOfTwo(size_t size) { constexpr size_t nextPowerOfTwo(size_t size) {
if(size < 2) return 1; if(size < 2) return 1;
size_t power2 = 1; size_t power2 = 1;
while(power2 < size) while(power2 < size)
@ -157,7 +157,7 @@ namespace BSPF
// Get next multiple of the given value // Get next multiple of the given value
// Note that this only works when multiple is a power of two // Note that this only works when multiple is a power of two
inline constexpr size_t nextMultipleOf(size_t size, size_t multiple) { constexpr size_t nextMultipleOf(size_t size, size_t multiple) {
return (size + multiple - 1) & ~(multiple - 1); return (size + multiple - 1) & ~(multiple - 1);
} }
@ -167,15 +167,15 @@ namespace BSPF
// Combines 'max' and 'min', and clamps value to the upper/lower value // Combines 'max' and 'min', and clamps value to the upper/lower value
// if it is outside the specified range // if it is outside the specified range
template<typename T> inline constexpr T clamp(T val, T lower, T upper) template<typename T> constexpr T clamp(T val, T lower, T upper)
{ {
return std::clamp<T>(val, lower, upper); return std::clamp<T>(val, lower, upper);
} }
template<typename T> inline constexpr void clamp(T& val, T lower, T upper, T setVal) template<typename T> constexpr void clamp(T& val, T lower, T upper, T setVal)
{ {
if(val < lower || val > upper) val = setVal; if(val < lower || val > upper) val = setVal;
} }
template<typename T> inline constexpr T clampw(T val, T lower, T upper) template<typename T> constexpr T clampw(T val, T lower, T upper)
{ {
return (val < lower) ? upper : (val > upper) ? lower : val; return (val < lower) ? upper : (val > upper) ? lower : val;
} }
@ -204,7 +204,7 @@ namespace BSPF
{ {
try { try {
int i{}; int i{};
s = s.substr(s.find_first_not_of(" ")); s = s.substr(s.find_first_not_of(' '));
auto result = std::from_chars(s.data(), s.data() + s.size(), i, BASE); auto result = std::from_chars(s.data(), s.data() + s.size(), i, BASE);
return result.ec == std::errc() ? i : defaultValue; return result.ec == std::errc() ? i : defaultValue;
} }
@ -226,13 +226,13 @@ namespace BSPF
} }
// Test whether two strings are equal (case insensitive) // Test whether two strings are equal (case insensitive)
inline constexpr bool equalsIgnoreCase(string_view s1, string_view s2) constexpr bool equalsIgnoreCase(string_view s1, string_view s2)
{ {
return s1.size() == s2.size() ? (compareIgnoreCase(s1, s2) == 0) : false; return s1.size() == s2.size() ? (compareIgnoreCase(s1, s2) == 0) : false;
} }
// Test whether the first string starts with the second one (case insensitive) // Test whether the first string starts with the second one (case insensitive)
inline constexpr bool startsWithIgnoreCase(string_view s1, string_view s2) constexpr bool startsWithIgnoreCase(string_view s1, string_view s2)
{ {
if(s1.size() >= s2.size()) if(s1.size() >= s2.size())
return compareIgnoreCase(s1.substr(0, s2.size()), s2) == 0; return compareIgnoreCase(s1.substr(0, s2.size()), s2) == 0;
@ -241,7 +241,7 @@ namespace BSPF
} }
// Test whether the first string ends with the second one (case insensitive) // Test whether the first string ends with the second one (case insensitive)
inline constexpr bool endsWithIgnoreCase(string_view s1, string_view s2) constexpr bool endsWithIgnoreCase(string_view s1, string_view s2)
{ {
if(s1.size() >= s2.size()) if(s1.size() >= s2.size())
return compareIgnoreCase(s1.substr(s1.size() - s2.size()), s2) == 0; return compareIgnoreCase(s1.substr(s1.size() - s2.size()), s2) == 0;
@ -253,7 +253,7 @@ namespace BSPF
// starting from 'startpos' in the first string // starting from 'startpos' in the first string
static size_t findIgnoreCase(string_view s1, string_view s2, size_t startpos = 0) static size_t findIgnoreCase(string_view s1, string_view s2, size_t startpos = 0)
{ {
const auto pos = std::search(s1.cbegin()+startpos, s1.cend(), const auto *const pos = std::search(s1.cbegin()+startpos, s1.cend(),
s2.cbegin(), s2.cend(), [](char ch1, char ch2) { s2.cbegin(), s2.cend(), [](char ch1, char ch2) {
return toupper(static_cast<uInt8>(ch1)) == toupper(static_cast<uInt8>(ch2)); return toupper(static_cast<uInt8>(ch1)) == toupper(static_cast<uInt8>(ch2));
}); });

19
src/common/repository/KeyValueRepositoryFile.hxx
View File

@ -25,7 +25,7 @@
#include "FSNode.hxx" #include "FSNode.hxx"
#include "bspf.hxx" #include "bspf.hxx"
template<class T> template<typename T>
class KeyValueRepositoryFile : public KeyValueRepository { class KeyValueRepositoryFile : public KeyValueRepository {
public: public:
explicit KeyValueRepositoryFile(const FSNode& node); explicit KeyValueRepositoryFile(const FSNode& node);
@ -44,16 +44,17 @@ class KeyValueRepositoryFile : public KeyValueRepository {
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
template<class T> template<typename T>
KeyValueRepositoryFile<T>::KeyValueRepositoryFile(const FSNode& node) KeyValueRepositoryFile<T>::KeyValueRepositoryFile(const FSNode& node)
: myNode{node} : myNode{node}
{} {
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
template<class T> template<typename T>
KVRMap KeyValueRepositoryFile<T>::load() KVRMap KeyValueRepositoryFile<T>::load()
{ {
if (!myNode.exists()) return KVRMap(); if (!myNode.exists()) return {};
stringstream in; stringstream in;
@ -64,18 +65,18 @@ KVRMap KeyValueRepositoryFile<T>::load()
catch (const runtime_error& err) { catch (const runtime_error& err) {
Logger::error(err.what()); Logger::error(err.what());
return KVRMap(); return {};
} }
catch (...) { catch (...) {
return KVRMap(); return {};
} }
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
template<class T> template<typename T>
bool KeyValueRepositoryFile<T>::save(const KVRMap& values) bool KeyValueRepositoryFile<T>::save(const KVRMap& values)
{ {
if (values.size() == 0) return true; if (values.empty()) return true;
stringstream out; stringstream out;

2
src/common/repository/sqlite/CompositeKeyValueRepositorySqlite.hxx
View File

@ -37,6 +37,7 @@ class CompositeKeyValueRepositorySqlite : public CompositeKeyValueRepositoryAtom
string_view colKey2, string_view colKey2,
string_view colValue string_view colValue
); );
~CompositeKeyValueRepositorySqlite() override = default;
shared_ptr<KeyValueRepository> get(string_view key) override; shared_ptr<KeyValueRepository> get(string_view key) override;
@ -53,6 +54,7 @@ class CompositeKeyValueRepositorySqlite : public CompositeKeyValueRepositoryAtom
ProxyRepository(const CompositeKeyValueRepositorySqlite& repo, ProxyRepository(const CompositeKeyValueRepositorySqlite& repo,
string_view key); string_view key);
~ProxyRepository() override = default;
protected: protected:

1
src/common/repository/sqlite/KeyValueRepositorySqlite.hxx
View File

@ -29,6 +29,7 @@ class KeyValueRepositorySqlite : public AbstractKeyValueRepositorySqlite
KeyValueRepositorySqlite(SqliteDatabase& db, string_view tableName, KeyValueRepositorySqlite(SqliteDatabase& db, string_view tableName,
string_view colKey, string_view colValue); string_view colKey, string_view colValue);
~KeyValueRepositorySqlite() override = default;
void initialize(); void initialize();

2
src/common/repository/sqlite/SqliteDatabase.hxx
View File

@ -34,7 +34,7 @@ class SqliteDatabase
const string& fileName() const { return myDatabaseFile; } const string& fileName() const { return myDatabaseFile; }
operator sqlite3*() const { return myHandle; } operator sqlite3*() const { return myHandle; } // NOLINT: explicit not required
void exec(string_view sql); void exec(string_view sql);

2
src/common/repository/sqlite/SqliteError.hxx
View File

@ -30,7 +30,7 @@ class SqliteError : public std::exception
const char* what() const noexcept override { return myMessage.c_str(); } const char* what() const noexcept override { return myMessage.c_str(); }
private: private:
const string myMessage; string myMessage;
}; };
#endif // SQLITE_ERROR_HXX #endif // SQLITE_ERROR_HXX

2
src/common/repository/sqlite/SqliteStatement.hxx
View File

@ -32,7 +32,7 @@ class SqliteStatement {
~SqliteStatement(); ~SqliteStatement();
operator sqlite3_stmt*() const { return myStmt; } operator sqlite3_stmt*() const { return myStmt; } // NOLINT: explicit not required
SqliteStatement& bind(int index, string_view value); SqliteStatement& bind(int index, string_view value);
SqliteStatement& bind(int index, Int32 value); SqliteStatement& bind(int index, Int32 value);

2
src/common/sdl_blitter/BlitterFactory.hxx
View File

@ -27,7 +27,7 @@
class BlitterFactory { class BlitterFactory {
public: public:
enum class ScalingAlgorithm { enum class ScalingAlgorithm: uInt8 {
nearestNeighbour, nearestNeighbour,
bilinear, bilinear,
quasiInteger quasiInteger

16
src/common/smartmod.hxx
View File

@ -29,56 +29,56 @@ constexpr uInt8 smartmod(uInt8 x)
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
template<> template<>
inline constexpr uInt8 smartmod<2>(uInt8 x) constexpr uInt8 smartmod<2>(uInt8 x)
{ {
return x & 0x01; return x & 0x01;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
template<> template<>
inline constexpr uInt8 smartmod<4>(uInt8 x) constexpr uInt8 smartmod<4>(uInt8 x)
{ {
return x & 0x03; return x & 0x03;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
template<> template<>
inline constexpr uInt8 smartmod<8>(uInt8 x) constexpr uInt8 smartmod<8>(uInt8 x)
{ {
return x & 0x07; return x & 0x07;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
template<> template<>
inline constexpr uInt8 smartmod<16>(uInt8 x) constexpr uInt8 smartmod<16>(uInt8 x)
{ {
return x & 0x0F; return x & 0x0F;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
template<> template<>
inline constexpr uInt8 smartmod<32>(uInt8 x) constexpr uInt8 smartmod<32>(uInt8 x)
{ {
return x & 0x1F; return x & 0x1F;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
template<> template<>
inline constexpr uInt8 smartmod<64>(uInt8 x) constexpr uInt8 smartmod<64>(uInt8 x)
{ {
return x & 0x3F; return x & 0x3F;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
template<> template<>
inline constexpr uInt8 smartmod<128>(uInt8 x) constexpr uInt8 smartmod<128>(uInt8 x)
{ {
return x & 0x7F; return x & 0x7F;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
template<> template<>
inline constexpr uInt8 smartmod<256>(uInt8 x) constexpr uInt8 smartmod<256>(uInt8 x)
{ {
return x & 0xFF; return x & 0xFF;
} }

17
src/common/tv_filters/AtariNTSC.cxx
View File

@ -100,9 +100,8 @@ void AtariNTSC::enableThreading(bool enable)
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void AtariNTSC::render(const uInt8* atari_in, const uInt32 in_width, void AtariNTSC::render(const uInt8* atari_in, uInt32 in_width, uInt32 in_height,
const uInt32 in_height, void* rgb_out, void* rgb_out, uInt32 out_pitch, uInt32* rgb_in)
const uInt32 out_pitch, uInt32* rgb_in)
{ {
// Spawn the threads... // Spawn the threads...
for(uInt32 i = 0; i < myWorkerThreads; ++i) for(uInt32 i = 0; i < myWorkerThreads; ++i)
@ -130,9 +129,9 @@ void AtariNTSC::render(const uInt8* atari_in, const uInt32 in_width,
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void AtariNTSC::renderThread(const uInt8* atari_in, const uInt32 in_width, void AtariNTSC::renderThread(const uInt8* atari_in, uInt32 in_width,
const uInt32 in_height, const uInt32 numThreads, const uInt32 threadNum, uInt32 in_height, uInt32 numThreads, uInt32 threadNum,
void* rgb_out, const uInt32 out_pitch) void* rgb_out, uInt32 out_pitch)
{ {
// Adapt parameters to thread number // Adapt parameters to thread number
const uInt32 yStart = in_height * threadNum / numThreads; const uInt32 yStart = in_height * threadNum / numThreads;
@ -204,9 +203,9 @@ void AtariNTSC::renderThread(const uInt8* atari_in, const uInt32 in_width,
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void AtariNTSC::renderWithPhosphorThread(const uInt8* atari_in, const uInt32 in_width, void AtariNTSC::renderWithPhosphorThread(const uInt8* atari_in, uInt32 in_width,
const uInt32 in_height, const uInt32 numThreads, const uInt32 threadNum, uInt32 in_height, uInt32 numThreads, uInt32 threadNum, uInt32* rgb_in,
uInt32* rgb_in, void* rgb_out, const uInt32 out_pitch) void* rgb_out, uInt32 out_pitch)
{ {
// Adapt parameters to thread number // Adapt parameters to thread number
const uInt32 yStart = in_height * threadNum / numThreads; const uInt32 yStart = in_height * threadNum / numThreads;

28
src/common/tv_filters/AtariNTSC.hxx
View File

@ -94,8 +94,8 @@ class AtariNTSC
// palette colors. // palette colors.
// In_row_width is the number of pixels to get to the next input row. // In_row_width is the number of pixels to get to the next input row.
// Out_pitch is the number of *bytes* to get to the next output row. // Out_pitch is the number of *bytes* to get to the next output row.
void render(const uInt8* atari_in, const uInt32 in_width, const uInt32 in_height, void render(const uInt8* atari_in, uInt32 in_width, uInt32 in_height,
void* rgb_out, const uInt32 out_pitch, uInt32* rgb_in = nullptr); void* rgb_out, uInt32 out_pitch, uInt32* rgb_in = nullptr);
// Number of output pixels written by blitter for given input width. // Number of output pixels written by blitter for given input width.
// Width might be rounded down slightly; use inWidth() on result to // Width might be rounded down slightly; use inWidth() on result to
@ -109,10 +109,11 @@ class AtariNTSC
void generateKernels(); void generateKernels();
// Threaded rendering // Threaded rendering
void renderThread(const uInt8* atari_in, const uInt32 in_width, void renderThread(const uInt8* atari_in, uInt32 in_width, uInt32 in_height,
const uInt32 in_height, const uInt32 numThreads, const uInt32 threadNum, void* rgb_out, const uInt32 out_pitch); uInt32 numThreads, uInt32 threadNum, void* rgb_out, uInt32 out_pitch);
void renderWithPhosphorThread(const uInt8* atari_in, const uInt32 in_width, void renderWithPhosphorThread(const uInt8* atari_in, uInt32 in_width,
const uInt32 in_height, const uInt32 numThreads, const uInt32 threadNum, uInt32* rgb_in, void* rgb_out, const uInt32 out_pitch); uInt32 in_height, uInt32 numThreads, uInt32 threadNum, uInt32* rgb_in,
void* rgb_out, uInt32 out_pitch);
private: private:
static constexpr Int32 static constexpr Int32
@ -153,20 +154,21 @@ class AtariNTSC
luma_cutoff = 0.20F luma_cutoff = 0.20F
; ;
std::array<uInt8, palette_size*3> myRGBPalette; std::array<uInt8, palette_size * 3L> myRGBPalette;
BSPF::array2D<uInt32, palette_size, entry_size> myColorTable; BSPF::array2D<uInt32, palette_size, entry_size> myColorTable;
// Rendering threads // Rendering threads
unique_ptr<std::thread[]> myThreads; // NOLINT unique_ptr<std::thread[]> myThreads;
// Number of rendering and total threads // Number of rendering and total threads
uInt32 myWorkerThreads{0}, myTotalThreads{0}; uInt32 myWorkerThreads{0}, myTotalThreads{0};
struct init_t struct init_t
{ {
std::array<float, burst_count * 6> to_rgb{0.F}; std::array<float, burst_count * 6L> to_rgb{0.F};
float artifacts{0.F}; float artifacts{0.F};
float fringing{0.F}; float fringing{0.F};
std::array<float, rescale_out * kernel_size * 2> kernel{0.F}; std::array<float, static_cast<size_t>
(rescale_out * kernel_size * 2)> kernel{0.F};
init_t() { init_t() {
to_rgb.fill(0.0); to_rgb.fill(0.0);
@ -213,10 +215,10 @@ class AtariNTSC
// 8888: 00000000 RRRRRRRR GGGGGGGG BBBBBBBB (8-8-8-8 32-bit ARGB) // 8888: 00000000 RRRRRRRR GGGGGGGG BBBBBBBB (8-8-8-8 32-bit ARGB)
#define ATARI_NTSC_RGB_OUT_8888( index, rgb_out ) {\ #define ATARI_NTSC_RGB_OUT_8888( index, rgb_out ) {\
uInt32 raw_ =\ uInt32 raw_ =\
kernel0 [index ] + kernel1 [(index+10)%7+14] +\ kernel0 [(index) ] + kernel1 [((index)+10)%7+14] +\
kernelx0 [(index+7)%14] + kernelx1 [(index+ 3)%7+14+7];\ kernelx0 [((index)+7)%14] + kernelx1 [((index)+ 3)%7+14+7];\
ATARI_NTSC_CLAMP( raw_, 0 );\ ATARI_NTSC_CLAMP( raw_, 0 );\
rgb_out = (raw_>>5 & 0x00FF0000)|(raw_>>3 & 0x0000FF00)|(raw_>>1 & 0x000000FF);\ (rgb_out) = (raw_>>5 & 0x00FF0000)|(raw_>>3 & 0x0000FF00)|(raw_>>1 & 0x000000FF);\
} }
// Common ntsc macros // Common ntsc macros

15
src/common/tv_filters/NTSCFilter.hxx
View File

@ -36,10 +36,11 @@ class NTSCFilter
{ {
public: public:
NTSCFilter() = default; NTSCFilter() = default;
~NTSCFilter() = default;
public: public:
// Set one of the available preset adjustments (Composite, S-Video, RGB, etc) // Set one of the available preset adjustments (Composite, S-Video, RGB, etc)
enum class Preset { enum class Preset: uInt8 {
OFF, OFF,
RGB, RGB,
SVIDEO, SVIDEO,
@ -47,7 +48,7 @@ class NTSCFilter
BAD, BAD,
CUSTOM CUSTOM
}; };
enum class Adjustables { enum class Adjustables: uInt8 {
SHARPNESS, SHARPNESS,
RESOLUTION, RESOLUTION,
ARTIFACTS, ARTIFACTS,
@ -106,19 +107,19 @@ class NTSCFilter
// Perform Blargg filtering on input buffer, place results in // Perform Blargg filtering on input buffer, place results in
// output buffer // output buffer
inline void render(const uInt8* src_buf, uInt32 src_width, uInt32 src_height, void render(const uInt8* src_buf, uInt32 src_width, uInt32 src_height,
uInt32* dest_buf, uInt32 dest_pitch) uInt32* dest_buf, uInt32 dest_pitch)
{ {
myNTSC.render(src_buf, src_width, src_height, dest_buf, dest_pitch); myNTSC.render(src_buf, src_width, src_height, dest_buf, dest_pitch);
} }
inline void render(const uInt8* src_buf, uInt32 src_width, uInt32 src_height, void render(const uInt8* src_buf, uInt32 src_width, uInt32 src_height,
uInt32* dest_buf, uInt32 dest_pitch, uInt32* prev_buf) uInt32* dest_buf, uInt32 dest_pitch, uInt32* prev_buf)
{ {
myNTSC.render(src_buf, src_width, src_height, dest_buf, dest_pitch, prev_buf); myNTSC.render(src_buf, src_width, src_height, dest_buf, dest_pitch, prev_buf);
} }
// Enable threading for the NTSC rendering // Enable threading for the NTSC rendering
inline void enableThreading(bool enable) void enableThreading(bool enable)
{ {
myNTSC.enableThreading(enable); myNTSC.enableThreading(enable);
} }

2
src/debugger/CartDebug.cxx
View File

@ -200,7 +200,7 @@ string CartDebug::toString()
bytesPerLine = 0x04; bytesPerLine = 0x04;
break; break;
case Base::Fmt::_DEFAULT: case Base::Fmt::DEFAULT:
default: default:
return DebuggerParser::red("invalid base, this is a BUG"); return DebuggerParser::red("invalid base, this is a BUG");
} }

2
src/debugger/gui/DataGridRamWidget.hxx
View File

@ -30,7 +30,7 @@ class DataGridRamWidget : public DataGridWidget
const GUI::Font& font, const GUI::Font& font,
int x, int y, int cols, int rows, int x, int y, int cols, int rows,
int colchars, int bits, int colchars, int bits,
Common::Base::Fmt base = Common::Base::Fmt::_DEFAULT, Common::Base::Fmt base = Common::Base::Fmt::DEFAULT,
bool useScrollbar = false); bool useScrollbar = false);
~DataGridRamWidget() override = default; ~DataGridRamWidget() override = default;

2
src/debugger/gui/DataGridWidget.cxx
View File

@ -778,7 +778,7 @@ void DataGridWidget::endEditMode()
case Common::Base::Fmt::_10: case Common::Base::Fmt::_10:
editString().insert(0, 1, '#'); editString().insert(0, 1, '#');
break; break;
case Common::Base::Fmt::_DEFAULT: case Common::Base::Fmt::DEFAULT:
default: // TODO - properly handle all other cases default: // TODO - properly handle all other cases
break; break;
} }

2
src/debugger/gui/DataGridWidget.hxx
View File

@ -43,7 +43,7 @@ class DataGridWidget : public EditableWidget
DataGridWidget(GuiObject* boss, const GUI::Font& font, DataGridWidget(GuiObject* boss, const GUI::Font& font,
int x, int y, int cols, int rows, int x, int y, int cols, int rows,
int colchars, int bits, int colchars, int bits,
Common::Base::Fmt base = Common::Base::Fmt::_DEFAULT, Common::Base::Fmt base = Common::Base::Fmt::DEFAULT,
bool useScrollbar = false); bool useScrollbar = false);
~DataGridWidget() override = default; ~DataGridWidget() override = default;

2
src/debugger/gui/RomListWidget.cxx
View File

@ -109,7 +109,7 @@ RomListWidget::RomListWidget(GuiObject* boss, const GUI::Font& lfont,
case Common::Base::Fmt::_10: case Common::Base::Fmt::_10:
return (c >= '0' && c <= '9') || c == ' '; return (c >= '0' && c <= '9') || c == ' ';
case Common::Base::Fmt::_DEFAULT: case Common::Base::Fmt::DEFAULT:
default: // TODO - properly handle all other cases default: // TODO - properly handle all other cases
return false; return false;
} }

2
src/debugger/gui/RomListWidget.hxx
View File

@ -103,7 +103,7 @@ class RomListWidget : public EditableWidget
int _selectedItem{-1}; int _selectedItem{-1};
int _highlightedItem{-1}; int _highlightedItem{-1};
StellaKey _currentKeyDown{KBDK_UNKNOWN}; StellaKey _currentKeyDown{KBDK_UNKNOWN};
Common::Base::Fmt _base{Common::Base::Fmt::_DEFAULT}; // base used during editing Common::Base::Fmt _base{Common::Base::Fmt::DEFAULT}; // base used during editing
const CartDebug::Disassembly* myDisasm{nullptr}; const CartDebug::Disassembly* myDisasm{nullptr};
vector<CheckboxWidget*> myCheckList; vector<CheckboxWidget*> myCheckList;

2
src/debugger/gui/RomWidget.cxx
View File

@ -90,7 +90,7 @@ void RomWidget::handleCommand(CommandSender* sender, int cmd, int data, int id)
case RomListWidget::kRomChangedCmd: case RomListWidget::kRomChangedCmd:
// 'data' is the line in the disassemblylist to be accessed // 'data' is the line in the disassemblylist to be accessed
// 'id' is the base to use for the data to be changed // 'id' is the base to use for the data to be changed
patchROM(data, myRomList->getText(), Common::Base::Fmt{id}); patchROM(data, myRomList->getText(), Common::Base::Fmt(id));
break; break;
case RomListWidget::kSetPCCmd: case RomListWidget::kSetPCCmd:

22
src/emucore/EventHandlerConstants.hxx
View File

@ -18,6 +18,8 @@
#ifndef EVENTHANDLER_CONSTANTS_HXX #ifndef EVENTHANDLER_CONSTANTS_HXX
#define EVENTHANDLER_CONSTANTS_HXX #define EVENTHANDLER_CONSTANTS_HXX
#include <string>
// Enumeration representing the different states of operation // Enumeration representing the different states of operation
enum class EventHandlerState { enum class EventHandlerState {
EMULATION, EMULATION,
@ -93,17 +95,17 @@ enum class EventMode {
namespace GUI namespace GUI
{ {
#ifdef RETRON77 #ifdef RETRON77
static const string SELECT = "Mode"; static const std::string SELECT = "Mode";
static const string LEFT_DIFFICULTY = "P1 skill"; static const std::string LEFT_DIFFICULTY = "P1 skill";
static const string RIGHT_DIFFICULTY = "P2 skill"; static const std::string RIGHT_DIFFICULTY = "P2 skill";
static const string LEFT_DIFF = "P1 Skill"; static const std::string LEFT_DIFF = "P1 Skill";
static const string RIGHT_DIFF = "P2 Skill"; static const std::string RIGHT_DIFF = "P2 Skill";
#else #else
static const string SELECT = "Select"; static const std::string SELECT = "Select";
static const string LEFT_DIFFICULTY = "Left difficulty"; static const std::string LEFT_DIFFICULTY = "Left difficulty";
static const string RIGHT_DIFFICULTY = "Right difficulty"; static const std::string RIGHT_DIFFICULTY = "Right difficulty";
static const string LEFT_DIFF = "Left Diff"; static const std::string LEFT_DIFF = "Left Diff";
static const string RIGHT_DIFF = "Right Diff"; static const std::string RIGHT_DIFF = "Right Diff";
#endif #endif
} }

4
src/emucore/Sound.hxx
View File

@ -118,8 +118,8 @@ class Sound
@return True, if the WAV file can be played @return True, if the WAV file can be played
*/ */
virtual bool playWav(const string& fileName, const uInt32 position = 0, virtual bool playWav(const string& fileName, uInt32 position = 0,
const uInt32 length = 0) { return false; } uInt32 length = 0) { return false; }
/** /**
Stop any currently playing WAV file. Stop any currently playing WAV file.