From fc79665d3a66505c77b87244bf372f866660e827 Mon Sep 17 00:00:00 2001 From: thrust26 Date: Sat, 25 May 2019 15:12:34 +0200 Subject: [PATCH] refactor key mapping using hash map key mapping now allows key + modifier combinations --- src/common/KeyMap.cxx | 167 +++++++++++++++++++++++++++++ src/common/KeyMap.hxx | 102 ++++++++++++++++++ src/common/PKeyboardHandler.cxx | 87 ++++----------- src/common/PKeyboardHandler.hxx | 13 ++- src/common/module.mk | 1 + src/emucore/EventHandler.cxx | 4 +- src/emucore/EventHandler.hxx | 3 +- src/emucore/Settings.cxx | 3 +- src/gui/EventMappingWidget.cxx | 6 +- src/gui/EventMappingWidget.hxx | 2 +- src/gui/InputDialog.cxx | 12 +-- src/gui/InputDialog.hxx | 2 +- src/windows/Stella.vcxproj | 4 +- src/windows/Stella.vcxproj.filters | 8 ++ 14 files changed, 326 insertions(+), 88 deletions(-) create mode 100644 src/common/KeyMap.cxx create mode 100644 src/common/KeyMap.hxx diff --git a/src/common/KeyMap.cxx b/src/common/KeyMap.cxx new file mode 100644 index 000000000..937f8d470 --- /dev/null +++ b/src/common/KeyMap.cxx @@ -0,0 +1,167 @@ +//============================================================================ +// +// SSSS tt lll lll +// SS SS tt ll ll +// SS tttttt eeee ll ll aaaa +// SSSS tt ee ee ll ll aa +// SS tt eeeeee ll ll aaaaa -- "An Atari 2600 VCS Emulator" +// SS SS tt ee ll ll aa aa +// SSSS ttt eeeee llll llll aaaaa +// +// Copyright (c) 1995-2019 by Bradford W. Mott, Stephen Anthony +// and the Stella Team +// +// See the file "License.txt" for information on usage and redistribution of +// this file, and for a DISCLAIMER OF ALL WARRANTIES. +//============================================================================ + +#include "KeyMap.hxx" + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +KeyMap::KeyMap(void) +{ +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +void KeyMap::add(const Event::Type event, const Mapping& input) +{ + myMap[convertMod(input)] = event; +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +void KeyMap::add(const Event::Type event, const int mode, const int key, const int mod) +{ + add(event, Mapping(mode, key, mod)); +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +void KeyMap::erase(const Mapping& input) +{ + myMap.erase(convertMod(input)); +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +void KeyMap::erase(const int mode, const int key, const int mod) +{ + erase(Mapping(mode, key, mod)); +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +Event::Type KeyMap::get(const Mapping& input) const +{ + auto find = myMap.find(convertMod(input)); + + if (find != myMap.end()) + return find->second; + + return Event::Type::NoType; +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +Event::Type KeyMap::get(const int mode, const int key, const int mod) const +{ + return get(Mapping(mode, key, mod)); +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +string KeyMap::getEventMappingDesc(const Event::Type event, const int mode) const +{ + ostringstream buf; +#ifndef BSPF_MACOS + string modifier = "Ctrl"; +#else + string modifier = "Cmd"; +#endif + + for (auto item : myMap) + { + if (item.second == event && item.first.mode == mode) + { + if (buf.str() != "") + buf << ", "; + if (item.first.mod & StellaMod::KBDM_CTRL) buf << modifier << "+"; + if (item.first.mod & StellaMod::KBDM_ALT) buf << "Alt+"; + if (item.first.mod & StellaMod::KBDM_SHIFT) buf << "Shift+"; + buf << StellaKeyName::forKey(item.first.key); + } + } + return buf.str(); +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +string KeyMap::saveMapping(const int mode) const +{ + ostringstream buf; + + for (auto item : myMap) + { + if (item.first.mode == mode) + { + if (buf.str() != "") + buf << "|"; + buf << item.second << ":" << item.first.key << "," << item.first.mod; + } + } + return buf.str(); +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +int KeyMap::loadMapping(string& list, const int mode) +{ + // Since istringstream swallows whitespace, we have to make the + // delimiters be spaces + std::replace(list.begin(), list.end(), '|', ' '); + std::replace(list.begin(), list.end(), ':', ' '); + std::replace(list.begin(), list.end(), ',', ' '); + istringstream buf(list); + int event, key, mod, i = 0; + + while (buf >> event && buf >> key && buf >> mod && ++i) + add(Event::Type(event), mode, key, mod); + + return i; +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +string KeyMap::getDesc(const Mapping& input) const +{ + return "TODO"; +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +string KeyMap::getDesc(const int mode, const int key, const int mod) const +{ + return getDesc(Mapping(mode, key, mod)); +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +void KeyMap::eraseMode(const int mode) +{ + for (auto item : myMap) + if (item.first.mode == mode) + erase(item.first); +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +void KeyMap::eraseEvent(const Event::Type event, const int mode) +{ + for (auto item : myMap) + if (item.second == event && item.first.mode == mode) + erase(item.first); +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +KeyMap::Mapping KeyMap::convertMod(const Mapping& input) const +{ + Mapping i = input; + + // limit to modifiers we want to support + i.mod = StellaMod(i.mod & (StellaMod::KBDM_SHIFT | StellaMod::KBDM_ALT | StellaMod::KBDM_CTRL)); + + // merge left and right modifiers + if (i.mod & KBDM_CTRL) i.mod = StellaMod(i.mod | KBDM_CTRL); + if (i.mod & KBDM_SHIFT) i.mod = StellaMod(i.mod | KBDM_SHIFT); + if (i.mod & KBDM_ALT) i.mod = StellaMod(i.mod | KBDM_ALT); + + return i; +} diff --git a/src/common/KeyMap.hxx b/src/common/KeyMap.hxx new file mode 100644 index 000000000..d1f828519 --- /dev/null +++ b/src/common/KeyMap.hxx @@ -0,0 +1,102 @@ +//============================================================================ +// +// SSSS tt lll lll +// SS SS tt ll ll +// SS tttttt eeee ll ll aaaa +// SSSS tt ee ee ll ll aa +// SS tt eeeeee ll ll aaaaa -- "An Atari 2600 VCS Emulator" +// SS SS tt ee ll ll aa aa +// SSSS ttt eeeee llll llll aaaaa +// +// Copyright (c) 1995-2019 by Bradford W. Mott, Stephen Anthony +// and the Stella Team +// +// See the file "License.txt" for information on usage and redistribution of +// this file, and for a DISCLAIMER OF ALL WARRANTIES. +//============================================================================ + +#ifndef KEYMAP_HXX +#define KEYMAP_HXX + +#include "Event.hxx" +#include "EventHandlerConstants.hxx" + +/** + This class handles keyboard mappings in Stella. + + @author Thomas Jentzsch +*/ +class KeyMap +{ + public: + + struct Mapping + { + EventMode mode; + StellaKey key; + StellaMod mod; + + Mapping() : mode(EventMode(0)), key(StellaKey(0)), mod(StellaMod(0)) { } + Mapping(const Mapping& k) : mode(k.mode), key(k.key), mod(k.mod) { } + explicit Mapping(EventMode mode, StellaKey key, StellaMod mod = StellaMod::KBDM_NONE) + : mode(mode), key(key), mod(mod) { } + explicit Mapping(int mode, int key, int mod = StellaMod::KBDM_NONE) + : mode(EventMode(mode)), key(StellaKey(key)), mod(StellaMod(mod)) { } + + bool operator==(const Mapping& other) const + { + return (mode == other.mode + && key == other.key + && mod == other.mod); + } + }; + + KeyMap(); + virtual ~KeyMap() = default; + + /** Add new mapping for given event */ + void add(const Event::Type event, const Mapping& input); + void add(const Event::Type event, const int mode, const int key, const int mod = StellaMod::KBDM_NONE); + + /** Erase mapping */ + void erase(const Mapping& input); + void erase(const int mode, const int key, const int mod = StellaMod::KBDM_NONE); + + /** Get event for mapping */ + Event::Type get(const Mapping& input) const; + Event::Type get(const int mode, const int key, const int mod = StellaMod::KBDM_NONE) const; + + /** Get the mapping(s) description for given event and mode */ + string getEventMappingDesc(const Event::Type event, const int mode) const; + + /** Get mapping description */ + string getDesc(const Mapping& input) const; + string getDesc(const int mode, const int key, const int mod = StellaMod::KBDM_NONE) const; + + string saveMapping(const int mode) const; + int loadMapping(string& list, const int mode); + + /** Erase all mappings for given mode */ + void eraseMode(const int mode); + /** Erase given event's mapping for given mode */ + void eraseEvent(const Event::Type event, const int mode); + /** clear all mappings for a modes */ + // void clear() { myMap.clear(); } + size_t size() { return myMap.size(); } + + private: + //** Convert modifiers */ + Mapping convertMod(const Mapping& input) const; + + struct KeyHash { + size_t operator()(const Mapping& k)const { + return std::hash()(((long long)k.mode) + ^ (((long long)k.key) << 16) + ^ (((long long)k.mod) << 32)); + } + }; + + std::unordered_map myMap; +}; + +#endif diff --git a/src/common/PKeyboardHandler.cxx b/src/common/PKeyboardHandler.cxx index 624a81769..d17ec9e7f 100644 --- a/src/common/PKeyboardHandler.cxx +++ b/src/common/PKeyboardHandler.cxx @@ -26,6 +26,7 @@ #include "TIASurface.hxx" #include "PNGLibrary.hxx" #include "PKeyboardHandler.hxx" +#include "KeyMap.hxx" #ifdef DEBUGGER_SUPPORT #include "Debugger.hxx" @@ -43,33 +44,12 @@ PhysicalKeyboardHandler::PhysicalKeyboardHandler( myAltKeyCounter(0), myUseCtrlKeyFlag(myOSystem.settings().getBool("ctrlcombo")) { - // Since istringstream swallows whitespace, we have to make the - // delimiters be spaces - string list = myOSystem.settings().getString("keymap"); - replace(list.begin(), list.end(), ':', ' '); - istringstream buf(list); + string list = myOSystem.settings().getString("keymap_emu"); + int i = myKeyMap.loadMapping(list, kEmulationMode); + list = myOSystem.settings().getString("keymap_ui"); + i += myKeyMap.loadMapping(list, kMenuMode); - IntArray map; - int value; - Event::Type e; - - // Get event count, which should be the first int in the list - buf >> value; - e = Event::Type(value); - if(e == Event::LastType) - while(buf >> value) - map.push_back(value); - - // Only fill the key mapping array if the data is valid - if(e == Event::LastType && map.size() == KBDK_LAST * kNumModes) - { - // Fill the keymap table with events - auto ev = map.cbegin(); - for(int mode = 0; mode < kNumModes; ++mode) - for(int i = 0; i < KBDK_LAST; ++i) - myKeyTable[i][mode] = Event::Type(*ev++); - } - else + if (!i) { setDefaultMapping(Event::NoType, kEmulationMode); setDefaultMapping(Event::NoType, kMenuMode); @@ -83,16 +63,13 @@ void PhysicalKeyboardHandler::setDefaultMapping(Event::Type event, EventMode mod // Otherwise, only reset the given event bool eraseAll = (event == Event::NoType); if(eraseAll) - { - // Erase all mappings - for(int i = 0; i < KBDK_LAST; ++i) - myKeyTable[i][mode] = Event::NoType; - } + // Erase all mappings of given mode + myKeyMap.eraseMode(mode); - auto setDefaultKey = [&](StellaKey key, Event::Type k_event) + auto setDefaultKey = [&](StellaKey key, Event::Type k_event, StellaMod mod = StellaMod::KBDM_NONE) { if(eraseAll || k_event == event) - myKeyTable[key][mode] = k_event; + myKeyMap.add(k_event, mode, key, mod); }; switch(mode) @@ -213,53 +190,33 @@ void PhysicalKeyboardHandler::setDefaultMapping(Event::Type event, EventMode mod // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - void PhysicalKeyboardHandler::eraseMapping(Event::Type event, EventMode mode) { - for(int i = 0; i < KBDK_LAST; ++i) - // This key cannot be remapped - if(myKeyTable[i][mode] == event && !(i == KBDK_TAB && mode == EventMode::kMenuMode)) - myKeyTable[i][mode] = Event::NoType; + // This key cannot be remapped + if (event != Event::UINavNext || mode != EventMode::kMenuMode) + myKeyMap.eraseEvent(event, mode); } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - void PhysicalKeyboardHandler::saveMapping() { - // Iterate through the keymap table and create a colon-separated list - // Prepend the event count, so we can check it on next load - ostringstream keybuf; - keybuf << Event::LastType; - for(int mode = 0; mode < kNumModes; ++mode) - for(int i = 0; i < KBDK_LAST; ++i) - keybuf << ":" << myKeyTable[i][mode]; - - myOSystem.settings().setValue("keymap", keybuf.str()); + myOSystem.settings().setValue("keymap_emu", myKeyMap.saveMapping(kEmulationMode)); + myOSystem.settings().setValue("keymap_ui", myKeyMap.saveMapping(kMenuMode)); } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - string PhysicalKeyboardHandler::getMappingDesc(Event::Type event, EventMode mode) const { - ostringstream buf; - - for(int k = 0; k < KBDK_LAST; ++k) - { - if(myKeyTable[k][mode] == event) - { - if(buf.str() != "") - buf << ", "; - buf << StellaKeyName::forKey(StellaKey(k)); - } - } - - return buf.str(); + return myKeyMap.getEventMappingDesc(event, mode); } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - bool PhysicalKeyboardHandler::addMapping(Event::Type event, EventMode mode, - StellaKey key) + StellaKey key, StellaMod mod) { // These keys cannot be remapped if((key == KBDK_TAB && mode == EventMode::kMenuMode) || Event::isAnalog(event)) return false; else - myKeyTable[key][mode] = event; + myKeyMap.add(event, mode, key, mod); return true; } @@ -317,7 +274,7 @@ void PhysicalKeyboardHandler::handleEvent(StellaKey key, StellaMod mod, bool pre } // Handle keys which switch eventhandler state - if(!pressed && myHandler.changeStateByEvent(myKeyTable[key][kEmulationMode])) + if (!pressed && myHandler.changeStateByEvent(myKeyMap.get(kEmulationMode, key, mod))) return; } @@ -325,15 +282,15 @@ void PhysicalKeyboardHandler::handleEvent(StellaKey key, StellaMod mod, bool pre switch(estate) { case EventHandlerState::EMULATION: - myHandler.handleEvent(myKeyTable[key][kEmulationMode], pressed); + myHandler.handleEvent(myKeyMap.get(kEmulationMode, key, mod), pressed); break; case EventHandlerState::PAUSE: - switch(myKeyTable[key][kEmulationMode]) + switch (myKeyMap.get(kEmulationMode, key, mod)) { case Event::TakeSnapshot: case Event::DebuggerMode: - myHandler.handleEvent(myKeyTable[key][kEmulationMode], pressed); + myHandler.handleEvent(myKeyMap.get(kEmulationMode, key, mod), pressed); break; default: diff --git a/src/common/PKeyboardHandler.hxx b/src/common/PKeyboardHandler.hxx index 5e0faaf73..a8dc6ad9b 100644 --- a/src/common/PKeyboardHandler.hxx +++ b/src/common/PKeyboardHandler.hxx @@ -26,6 +26,7 @@ class Event; #include "bspf.hxx" #include "EventHandlerConstants.hxx" +#include "KeyMap.hxx" /** This class handles all physical keyboard-related operations in Stella. @@ -41,6 +42,7 @@ class Event; class PhysicalKeyboardHandler { public: + PhysicalKeyboardHandler(OSystem& system, EventHandler& handler, Event& event); void setDefaultMapping(Event::Type type, EventMode mode); @@ -49,13 +51,13 @@ class PhysicalKeyboardHandler string getMappingDesc(Event::Type, EventMode mode) const; /** Bind a physical keyboard event to a virtual event/action. */ - bool addMapping(Event::Type event, EventMode mode, StellaKey key); + bool addMapping(Event::Type event, EventMode mode, StellaKey key, StellaMod mod); /** Handle a physical keyboard event. */ void handleEvent(StellaKey key, StellaMod mod, bool pressed); Event::Type eventForKey(StellaKey key, EventMode mode) const { - return myKeyTable[key][mode]; + return myKeyMap.get(mode, key); } /** See comments on 'myAltKeyCounter' for more information. */ @@ -72,11 +74,8 @@ class PhysicalKeyboardHandler EventHandler& myHandler; Event& myEvent; - // Array of key events, indexed by StellaKey - Event::Type myKeyTable[KBDK_LAST][kNumModes]; - // Array of mod keys, indexed by StellaKey - // TODO - uncomment when this is ready - //StellaMod myModKeyTable[KBDK_LAST][kNumModes]; + // Hashmap of key events + KeyMap myKeyMap; // Sometimes key combos with the Alt key become 'stuck' after the // window changes state, and we want to ignore that event diff --git a/src/common/module.mk b/src/common/module.mk index a1bf5dcb2..dc24e6886 100644 --- a/src/common/module.mk +++ b/src/common/module.mk @@ -6,6 +6,7 @@ MODULE_OBJS := \ src/common/FBSurfaceSDL2.o \ src/common/FrameBufferSDL2.o \ src/common/FSNodeZIP.o \ + src/common/KeyMap.o \ src/common/Logger.o \ src/common/main.o \ src/common/MouseControl.o \ diff --git a/src/emucore/EventHandler.cxx b/src/emucore/EventHandler.cxx index 1a8d944bb..91f28e8ca 100644 --- a/src/emucore/EventHandler.cxx +++ b/src/emucore/EventHandler.cxx @@ -848,9 +848,9 @@ void EventHandler::removePhysicalJoystickFromDatabase(const string& name) } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -bool EventHandler::addKeyMapping(Event::Type event, EventMode mode, StellaKey key) +bool EventHandler::addKeyMapping(Event::Type event, EventMode mode, StellaKey key, StellaMod mod) { - bool mapped = myPKeyHandler->addMapping(event, mode, key); + bool mapped = myPKeyHandler->addMapping(event, mode, key, mod); if(mapped) setActionMappings(mode); diff --git a/src/emucore/EventHandler.hxx b/src/emucore/EventHandler.hxx index 4bfb0c432..4b280e995 100644 --- a/src/emucore/EventHandler.hxx +++ b/src/emucore/EventHandler.hxx @@ -181,8 +181,9 @@ class EventHandler @param event The event we are remapping @param mode The mode where this event is active @param key The key to bind to this event + @param mod The modifier to bind to this event */ - bool addKeyMapping(Event::Type event, EventMode mode, StellaKey key); + bool addKeyMapping(Event::Type event, EventMode mode, StellaKey key, StellaMod mod); /** Bind a physical joystick axis direction to an event/action and regenerate diff --git a/src/emucore/Settings.cxx b/src/emucore/Settings.cxx index d1870407e..87196ab4e 100644 --- a/src/emucore/Settings.cxx +++ b/src/emucore/Settings.cxx @@ -82,7 +82,8 @@ Settings::Settings() setPermanent(AudioSettings::SETTING_STEREO, AudioSettings::DEFAULT_STEREO); // Input event options - setPermanent("keymap", ""); + setPermanent("keymap_emu", ""); + setPermanent("keymap_ui", ""); setPermanent("joymap", ""); setPermanent("combomap", ""); setPermanent("joydeadzone", "13"); diff --git a/src/gui/EventMappingWidget.cxx b/src/gui/EventMappingWidget.cxx index 21edc2d6a..40bcaf50b 100644 --- a/src/gui/EventMappingWidget.cxx +++ b/src/gui/EventMappingWidget.cxx @@ -254,14 +254,14 @@ void EventMappingWidget::enableButtons(bool state) } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -bool EventMappingWidget::handleKeyDown(StellaKey key, StellaMod mod) +bool EventMappingWidget::handleKeyUp(StellaKey key, StellaMod mod) { // Remap keys in remap mode - if(myRemapStatus && myActionSelected >= 0) + if (myRemapStatus && myActionSelected >= 0) { Event::Type event = instance().eventHandler().eventAtIndex(myActionSelected, myEventMode); - if(instance().eventHandler().addKeyMapping(event, myEventMode, key)) + if (instance().eventHandler().addKeyMapping(event, myEventMode, key, mod)) stopRemapping(); } return true; diff --git a/src/gui/EventMappingWidget.hxx b/src/gui/EventMappingWidget.hxx index 379bfdcc9..9e9a11bd9 100644 --- a/src/gui/EventMappingWidget.hxx +++ b/src/gui/EventMappingWidget.hxx @@ -57,7 +57,7 @@ class EventMappingWidget : public Widget, public CommandSender kComboCmd = 'cmbo' }; - bool handleKeyDown(StellaKey key, StellaMod mod) override; + bool handleKeyUp(StellaKey key, StellaMod mod) override; void handleJoyDown(int stick, int button) override; void handleJoyAxis(int stick, int axis, int value) override; bool handleJoyHat(int stick, int hat, JoyHat value) override; diff --git a/src/gui/InputDialog.cxx b/src/gui/InputDialog.cxx index 7d76501dc..1a107a939 100644 --- a/src/gui/InputDialog.cxx +++ b/src/gui/InputDialog.cxx @@ -448,15 +448,15 @@ void InputDialog::setDefaults() } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -void InputDialog::handleKeyDown(StellaKey key, StellaMod mod) +void InputDialog::handleKeyUp(StellaKey key, StellaMod mod) { // Remap key events in remap mode, otherwise pass to parent dialog - if(myEmulEventMapper->remapMode()) - myEmulEventMapper->handleKeyDown(key, mod); - else if(myMenuEventMapper->remapMode()) - myMenuEventMapper->handleKeyDown(key, mod); + if (myEmulEventMapper->remapMode()) + myEmulEventMapper->handleKeyUp(key, mod); + else if (myMenuEventMapper->remapMode()) + myMenuEventMapper->handleKeyUp(key, mod); else - Dialog::handleKeyDown(key, mod); + Dialog::handleKeyUp(key, mod); } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/src/gui/InputDialog.hxx b/src/gui/InputDialog.hxx index 16c794370..1460b6751 100644 --- a/src/gui/InputDialog.hxx +++ b/src/gui/InputDialog.hxx @@ -43,7 +43,7 @@ class InputDialog : public Dialog virtual ~InputDialog(); private: - void handleKeyDown(StellaKey key, StellaMod mod) override; + void handleKeyUp(StellaKey key, StellaMod mod) override; void handleJoyDown(int stick, int button) override; void handleJoyAxis(int stick, int axis, int value) override; bool handleJoyHat(int stick, int hat, JoyHat value) override; diff --git a/src/windows/Stella.vcxproj b/src/windows/Stella.vcxproj index 23c629144..9ef2b4b25 100644 --- a/src/windows/Stella.vcxproj +++ b/src/windows/Stella.vcxproj @@ -374,8 +374,9 @@ - + + @@ -1072,6 +1073,7 @@ + diff --git a/src/windows/Stella.vcxproj.filters b/src/windows/Stella.vcxproj.filters index 6c3bdfce7..faa5eaf99 100644 --- a/src/windows/Stella.vcxproj.filters +++ b/src/windows/Stella.vcxproj.filters @@ -903,6 +903,9 @@ Source Files + + Source Files + Source Files\emucore\tia @@ -1994,12 +1997,17 @@ Header Files\gui + + Header Files + Resource Files + Source Files +