empathicqubit/lsnes
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 'rr1-maint'

Browse source
This commit is contained in:
Ilari Liusvaara 2012-04-08 16:06:15 +03:00
commit 4b352d57ae
28 changed files with 1763 additions and 1729 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
include/core/keymapper.hpp
View file

@ -214,10 +214,11 @@ public:
* Create a new key group.
*
* parameter name: Name of the key group.
* parameter _clazz: The key class.
* parameter t: Initial type of the key group.
* throws std::bad_alloc: Not enough memory.
*/
keygroup(const std::string& name, enum type t) throw(std::bad_alloc);
keygroup(const std::string& name, const std::string& _clazz, enum type t) throw(std::bad_alloc);
/**
* Destructor
*/
@ -331,6 +332,10 @@ public:
* Get status value.
*/
signed get_value();
/**
* Get class.
*/
const std::string& get_class();
private:
signed state;
enum type ktype;
@ -343,6 +348,7 @@ private:
double compensate2(double value);
void run_listeners(const modifier_set& modifiers, unsigned subkey, bool polarity, bool really, double x);
std::string keyname;
std::string clazz;
bool requests_hook;
};

2
include/core/moviedata.hpp
View file

@ -28,7 +28,7 @@ void do_save_movie(const std::string& filename) throw(std::bad_alloc, std::runti
void do_load_beginning() throw(std::bad_alloc, std::runtime_error);
void do_load_state(struct moviefile& _movie, int lmode);
bool do_load_state(const std::string& filename, int lmode);
std::string translate_name_mprefix(std::string original);
std::string translate_name_mprefix(std::string original, bool forio = false);
extern std::string last_save;
extern movie_logic movb;

18
include/core/settings.hpp
View file

@ -204,4 +204,22 @@ private:
bool value;
};
/**
* Setting having path value.
*/
class path_setting : public setting
{
public:
path_setting(const std::string& sname) throw(std::bad_alloc);
void blank() throw(std::bad_alloc, std::runtime_error);
bool is_set() throw();
void set(const std::string& value) throw(std::bad_alloc, std::runtime_error);
std::string get() throw(std::bad_alloc);
operator std::string();
private:
bool _default;
std::string path;
};
#endif

2
include/platform/wxwidgets/platform.hpp
View file

@ -34,10 +34,8 @@ void _runuifun_async(void (*fn)(void*), void* arg);
//Editor dialogs.
void wxeditor_authors_display(wxWindow* parent);
void wxeditor_settings_display(wxWindow* parent);
void wxeditor_hotkeys_display(wxWindow* parent);
std::string wxeditor_keyselect(wxWindow* parent, bool clearable);
void wxeditor_screen_display(wxWindow* parent);
void wxsetingsdialog_display(wxWindow* parent);
//Auxillary windows.

8
manual.lyx
View file

@ -1654,14 +1654,6 @@ cycle-jukebox-forward
Cycle save jukebox forwards
\end_layout
\begin_layout Subsubsection
add-jukebox-save <filename>
\end_layout
\begin_layout Standard
Add <filename> to jukebox saves.
\end_layout
\begin_layout Subsubsection
load-jukebox
\end_layout

8
manual.txt
View file

@ -794,15 +794,11 @@ Cycle save jukebox backwards.
Cycle save jukebox forwards
6.8.3 add-jukebox-save <filename>
Add <filename> to jukebox saves.
6.8.4 load-jukebox
6.8.3 load-jukebox
Do load from jukebox (current mode).
6.8.5 save-jukebox
6.8.4 save-jukebox
Do state save to jukebox.

4
src/core/controller.cpp
View file

@ -197,7 +197,7 @@ namespace
};
x << (k + 1) << get_logical_button_name(i);
y << (k + 1) << get_logical_button_name(i);
expx << "Controller " << (k + 1) << " " << get_logical_button_name(i);
expx << "Controller‣" << (k + 1) << "‣" << get_logical_button_name(i);
our_commands.insert(new button_action(x.str(), j, k, y.str()));
if(j == 0)
our_icommands.insert(new inverse_key(x.str(), expx.str()));
@ -205,7 +205,7 @@ namespace
for(unsigned k = 0; k < 8; ++k) {
stringfmt x, expx;
x << "controller" << (k + 1) << "analog";
expx << "Controller " << (k + 1) << " analog function";
expx << "Controller‣" << (k + 1) << "‣Analog function";
our_commands.insert(new analog_action(x.str(), k));
our_icommands.insert(new inverse_key(x.str(), expx.str()));
}

7
src/core/framerate.cpp
View file

@ -12,7 +12,6 @@
#include <sys/time.h>
#include <unistd.h>
#define DEFAULT_NOMINAL_RATE 60
#define HISTORY_FRAMES 10
namespace
@ -22,7 +21,7 @@ namespace
bool time_frozen = true;
uint64_t frame_number = 0;
uint64_t frame_start_times[HISTORY_FRAMES];
double nominal_rate = DEFAULT_NOMINAL_RATE;
double nominal_rate = 100;
bool target_nominal = true;
double target_fps = 100.0;
bool target_infinite = false;
@ -130,8 +129,8 @@ namespace
turboed = false;
});
inverse_key turboh("+turbo", "Turbo on hold");
inverse_key turbot("toggle-turbo", "Toggle turbo");
inverse_key turboh("+turbo", "Speed‣Turbo hold");
inverse_key turbot("toggle-turbo", "Speed‣Turbo toggle");
}
void freeze_time(uint64_t curtime)

10
src/core/keymapper.cpp
View file

@ -257,6 +257,11 @@ std::string keygroup::name() throw(std::bad_alloc)
return keyname;
}
const std::string& keygroup::get_class()
{
return clazz;
}
struct keygroup::parameters keygroup::get_parameters()
{
parameters p;
@ -277,9 +282,10 @@ std::map<std::string, struct keygroup::parameters> keygroup::get_all_parameters(
return ret;
}
keygroup::keygroup(const std::string& name, enum type t) throw(std::bad_alloc)
keygroup::keygroup(const std::string& name, const std::string& _clazz, enum type t) throw(std::bad_alloc)
{
keygroups()[keyname = name] = this;
clazz = _clazz;
ktype = t;
state = 0;
last_rawval = 0;
@ -846,10 +852,12 @@ std::string inverse_key::get(bool primary) throw(std::bad_alloc)
void inverse_key::clear(bool primary) throw(std::bad_alloc)
{
if(primary) {
if(primary_spec != "")
keymapper::bind_for(primary_spec, "");
primary_spec = secondary_spec;
secondary_spec = "";
} else {
if(secondary_spec != "")
keymapper::bind_for(secondary_spec, "");
secondary_spec = "";
}

270
src/core/mainloop.cpp
View file

@ -6,6 +6,7 @@
#include "core/framebuffer.hpp"
#include "core/framerate.hpp"
#include "lua/lua.hpp"
#include "library/string.hpp"
#include "core/mainloop.hpp"
#include "core/movie.hpp"
#include "core/moviedata.hpp"
@ -62,7 +63,7 @@ namespace
std::set<std::string> queued_saves;
bool stepping_into_save;
//Save jukebox.
std::vector<std::string> save_jukebox;
numeric_setting jukebox_size("jukebox-size", 0, 999, 12);
size_t save_jukebox_pointer;
//Pending reset cycles. -1 if no reset pending, otherwise, cycle count for reset.
long pending_reset_cycles = -1;
@ -76,45 +77,14 @@ namespace
//Last frame params.
bool last_hires = false;
bool last_interlace = false;
std::string save_jukebox_name(size_t i)
{
return (stringfmt() << "${project}" << (i + 1) << ".lsmv").str();
}
}
class firmware_path_setting : public setting
{
public:
firmware_path_setting() : setting("firmwarepath") { _firmwarepath = "."; default_firmware = true; }
void blank() throw(std::bad_alloc, std::runtime_error)
{
_firmwarepath = ".";
default_firmware = true;
}
bool is_set() throw()
{
return !default_firmware;
}
void set(const std::string& value) throw(std::bad_alloc, std::runtime_error)
{
if(value != "") {
_firmwarepath = value;
default_firmware = false;
} else
blank();
}
std::string get() throw(std::bad_alloc)
{
return _firmwarepath;
}
operator std::string() throw(std::bad_alloc)
{
return _firmwarepath;
}
private:
std::string _firmwarepath;
bool default_firmware;
} firmwarepath_setting;
path_setting firmwarepath_setting("firmwarepath");
controller_frame movie_logic::update_controls(bool subframe) throw(std::bad_alloc, std::runtime_error)
{
@ -273,8 +243,8 @@ void update_movie_state()
x << "F";
_status.set("Flags", x.str());
}
if(save_jukebox.size() > 0)
_status.set("Saveslot", translate_name_mprefix(save_jukebox[save_jukebox_pointer]));
if(jukebox_size > 0)
_status.set("Saveslot", translate_name_mprefix(save_jukebox_name(save_jukebox_pointer)));
else
_status.erase("Saveslot");
{
@ -378,6 +348,20 @@ class my_interface : public SNES::Interface
namespace
{
class jukebox_size_listener : public information_dispatch
{
public:
jukebox_size_listener() : information_dispatch("jukebox-size-listener") {};
void on_setting_change(const std::string& setting, const std::string& value)
{
if(setting == "jukebox-size") {
if(save_jukebox_pointer >= jukebox_size)
save_jukebox_pointer = 0;
update_movie_state();
}
}
} _jukebox_size_listener;
function_ptr_command<> count_rerecords("count-rerecords", "Count rerecords",
"Syntax: count-rerecords\nCounts rerecords.\n",
[]() throw(std::bad_alloc, std::runtime_error) {
@ -413,11 +397,13 @@ namespace
function_ptr_command<> save_jukebox_prev("cycle-jukebox-backward", "Cycle save jukebox backwards",
"Syntax: cycle-jukebox-backward\nCycle save jukebox backwards\n",
[]() throw(std::bad_alloc, std::runtime_error) {
if(jukebox_size == 0)
return;
if(save_jukebox_pointer == 0)
save_jukebox_pointer = save_jukebox.size() - 1;
save_jukebox_pointer = jukebox_size - 1;
else
save_jukebox_pointer--;
if(save_jukebox_pointer >= save_jukebox.size())
if(save_jukebox_pointer >= jukebox_size)
save_jukebox_pointer = 0;
update_movie_state();
information_dispatch::do_status_update();
@ -426,38 +412,32 @@ namespace
function_ptr_command<> save_jukebox_next("cycle-jukebox-forward", "Cycle save jukebox forwards",
"Syntax: cycle-jukebox-forward\nCycle save jukebox forwards\n",
[]() throw(std::bad_alloc, std::runtime_error) {
if(save_jukebox_pointer == save_jukebox.size() - 1)
if(jukebox_size == 0)
return;
if(save_jukebox_pointer == jukebox_size - 1)
save_jukebox_pointer = 0;
else
save_jukebox_pointer++;
if(save_jukebox_pointer >= save_jukebox.size())
if(save_jukebox_pointer >= jukebox_size)
save_jukebox_pointer = 0;
update_movie_state();
information_dispatch::do_status_update();
});
function_ptr_command<arg_filename> add_jukebox("add-jukebox-save", "Add save to jukebox",
"Syntax: add-jukebox-save\nAdd save to jukebox\n",
[](arg_filename filename) throw(std::bad_alloc, std::runtime_error) {
save_jukebox.push_back(filename);
update_movie_state();
information_dispatch::do_status_update();
});
function_ptr_command<> load_jukebox("load-jukebox", "Load save from jukebox",
"Syntax: load-jukebox\nLoad save from jukebox\n",
[]() throw(std::bad_alloc, std::runtime_error) {
if(!save_jukebox.size())
throw std::runtime_error("No saves in jukebox");
mark_pending_load(save_jukebox[save_jukebox_pointer], LOAD_STATE_CURRENT);
if(jukebox_size == 0)
throw std::runtime_error("No slot selected");
mark_pending_load(save_jukebox_name(save_jukebox_pointer), LOAD_STATE_CURRENT);
});
function_ptr_command<> save_jukebox_c("save-jukebox", "Save save to jukebox",
"Syntax: save-jukebox\nSave save to jukebox\n",
[]() throw(std::bad_alloc, std::runtime_error) {
if(!save_jukebox.size())
throw std::runtime_error("No saves in jukebox");
mark_pending_save(save_jukebox[save_jukebox_pointer], SAVE_STATE);
if(jukebox_size == 0)
throw std::runtime_error("No slot selected");
mark_pending_save(save_jukebox_name(save_jukebox_pointer), SAVE_STATE);
});
function_ptr_command<> padvance_frame("+advance-frame", "Advance one frame",
@ -625,87 +605,86 @@ namespace
while(1);
});
inverse_key ipause_emulator("pause-emulator", "(Un)pause");
inverse_key ijback("cycle-jukebox-backward", "Cycle slot backwards");
inverse_key ijforward("cycle-jukebox-forward", "Cycle slot forwards");
inverse_key iloadj("load-jukebox", "load selected slot");
inverse_key isavej("save-jukebox", "Save selected slot");
inverse_key iadvframe("+advance-frame", "Advance frame");
inverse_key iadvsubframe("+advance-poll", "Advance subframe");
inverse_key iskiplag("advance-skiplag", "Advance to next poll");
inverse_key ireset("reset", "System reset");
inverse_key iset_rwmode("set-rwmode", "Switch to read/write");
inverse_key itoggle_romode("set-romode", "Switch to read-only");
inverse_key itoggle_rwmode("toggle-rwmode", "Toggle read-only");
inverse_key irepaint("repaint", "Repaint screen");
inverse_key itogglepause("toggle-pause-on-end", "Toggle pause-on-end");
inverse_key irewind_movie("rewind-movie", "Rewind movie");
inverse_key icancel_saves("cancel-saves", "Cancel pending saves");
inverse_key iload1("load ${project}1.lsmv", "Load slot 1");
inverse_key iload2("load ${project}2.lsmv", "Load slot 2");
inverse_key iload3("load ${project}3.lsmv", "Load slot 3");
inverse_key iload4("load ${project}4.lsmv", "Load slot 4");
inverse_key iload5("load ${project}5.lsmv", "Load slot 5");
inverse_key iload6("load ${project}6.lsmv", "Load slot 6");
inverse_key iload7("load ${project}7.lsmv", "Load slot 7");
inverse_key iload8("load ${project}8.lsmv", "Load slot 8");
inverse_key iload9("load ${project}9.lsmv", "Load slot 9");
inverse_key iload10("load ${project}10.lsmv", "Load slot 10");
inverse_key iload11("load ${project}11.lsmv", "Load slot 11");
inverse_key iload12("load ${project}12.lsmv", "Load slot 12");
inverse_key iload13("load ${project}13.lsmv", "Load slot 13");
inverse_key iload14("load ${project}14.lsmv", "Load slot 14");
inverse_key iload15("load ${project}15.lsmv", "Load slot 15");
inverse_key iload16("load ${project}16.lsmv", "Load slot 16");
inverse_key iload17("load ${project}17.lsmv", "Load slot 17");
inverse_key iload18("load ${project}18.lsmv", "Load slot 18");
inverse_key iload19("load ${project}19.lsmv", "Load slot 19");
inverse_key iload20("load ${project}20.lsmv", "Load slot 20");
inverse_key iload21("load ${project}21.lsmv", "Load slot 21");
inverse_key iload22("load ${project}22.lsmv", "Load slot 22");
inverse_key iload23("load ${project}23.lsmv", "Load slot 23");
inverse_key iload24("load ${project}24.lsmv", "Load slot 24");
inverse_key iload25("load ${project}25.lsmv", "Load slot 25");
inverse_key iload26("load ${project}26.lsmv", "Load slot 26");
inverse_key iload27("load ${project}27.lsmv", "Load slot 27");
inverse_key iload28("load ${project}28.lsmv", "Load slot 28");
inverse_key iload29("load ${project}29.lsmv", "Load slot 29");
inverse_key iload30("load ${project}30.lsmv", "Load slot 30");
inverse_key iload31("load ${project}31.lsmv", "Load slot 31");
inverse_key iload32("load ${project}32.lsmv", "Load slot 32");
inverse_key isave1("save-state ${project}1.lsmv", "Save slot 1");
inverse_key isave2("save-state ${project}2.lsmv", "Save slot 2");
inverse_key isave3("save-state ${project}3.lsmv", "Save slot 3");
inverse_key isave4("save-state ${project}4.lsmv", "Save slot 4");
inverse_key isave5("save-state ${project}5.lsmv", "Save slot 5");
inverse_key isave6("save-state ${project}6.lsmv", "Save slot 6");
inverse_key isave7("save-state ${project}7.lsmv", "Save slot 7");
inverse_key isave8("save-state ${project}8.lsmv", "Save slot 8");
inverse_key isave9("save-state ${project}9.lsmv", "Save slot 9");
inverse_key isave10("save-state ${project}10.lsmv", "Save slot 10");
inverse_key isave11("save-state ${project}11.lsmv", "Save slot 11");
inverse_key isave12("save-state ${project}12.lsmv", "Save slot 12");
inverse_key isave13("save-state ${project}13.lsmv", "Save slot 13");
inverse_key isave14("save-state ${project}14.lsmv", "Save slot 14");
inverse_key isave15("save-state ${project}15.lsmv", "Save slot 15");
inverse_key isave16("save-state ${project}16.lsmv", "Save slot 16");
inverse_key isave17("save-state ${project}17.lsmv", "Save slot 17");
inverse_key isave18("save-state ${project}18.lsmv", "Save slot 18");
inverse_key isave19("save-state ${project}19.lsmv", "Save slot 19");
inverse_key isave20("save-state ${project}20.lsmv", "Save slot 20");
inverse_key isave21("save-state ${project}21.lsmv", "Save slot 21");
inverse_key isave22("save-state ${project}22.lsmv", "Save slot 22");
inverse_key isave23("save-state ${project}23.lsmv", "Save slot 23");
inverse_key isave24("save-state ${project}24.lsmv", "Save slot 24");
inverse_key isave25("save-state ${project}25.lsmv", "Save slot 25");
inverse_key isave26("save-state ${project}26.lsmv", "Save slot 26");
inverse_key isave27("save-state ${project}27.lsmv", "Save slot 27");
inverse_key isave28("save-state ${project}28.lsmv", "Save slot 28");
inverse_key isave29("save-state ${project}29.lsmv", "Save slot 29");
inverse_key isave30("save-state ${project}30.lsmv", "Save slot 30");
inverse_key isave31("save-state ${project}31.lsmv", "Save slot 31");
inverse_key isave32("save-state ${project}32.lsmv", "Save slot 32");
inverse_key ipause_emulator("pause-emulator", "Speed‣(Un)pause");
inverse_key ijback("cycle-jukebox-backward", "Slot select‣Cycle backwards");
inverse_key ijforward("cycle-jukebox-forward", "Slot select‣Cycle forwards");
inverse_key iloadj("load-jukebox", "Load‣Selected slot");
inverse_key isavej("save-jukebox", "Save‣Selected slot");
inverse_key iadvframe("+advance-frame", "Speed‣Advance frame");
inverse_key iadvsubframe("+advance-poll", "Speed‣Advance subframe");
inverse_key iskiplag("advance-skiplag", "Speed‣Advance poll");
inverse_key ireset("reset", "System‣Reset");
inverse_key iset_rwmode("set-rwmode", "Movie‣Switch to read/write");
inverse_key itoggle_romode("set-romode", "Movie‣Switch to read-only");
inverse_key itoggle_rwmode("toggle-rwmode", "Movie‣Toggle read-only");
inverse_key irepaint("repaint", "System‣Repaint screen");
inverse_key itogglepause("toggle-pause-on-end", "Movie‣Toggle pause-on-end");
inverse_key irewind_movie("rewind-movie", "Movie‣Rewind movie");
inverse_key icancel_saves("cancel-saves", "Save‣Cancel pending saves");
inverse_key iload1("load ${project}1.lsmv", "Load‣Slot 1");
inverse_key iload2("load ${project}2.lsmv", "Load‣Slot 2");
inverse_key iload3("load ${project}3.lsmv", "Load‣Slot 3");
inverse_key iload4("load ${project}4.lsmv", "Load‣Slot 4");
inverse_key iload5("load ${project}5.lsmv", "Load‣Slot 5");
inverse_key iload6("load ${project}6.lsmv", "Load‣Slot 6");
inverse_key iload7("load ${project}7.lsmv", "Load‣Slot 7");
inverse_key iload8("load ${project}8.lsmv", "Load‣Slot 8");
inverse_key iload9("load ${project}9.lsmv", "Load‣Slot 9");
inverse_key iload10("load ${project}10.lsmv", "Load‣Slot 10");
inverse_key iload11("load ${project}11.lsmv", "Load‣Slot 11");
inverse_key iload12("load ${project}12.lsmv", "Load‣Slot 12");
inverse_key iload13("load ${project}13.lsmv", "Load‣Slot 13");
inverse_key iload14("load ${project}14.lsmv", "Load‣Slot 14");
inverse_key iload15("load ${project}15.lsmv", "Load‣Slot 15");
inverse_key iload16("load ${project}16.lsmv", "Load‣Slot 16");
inverse_key iload17("load ${project}17.lsmv", "Load‣Slot 17");
inverse_key iload18("load ${project}18.lsmv", "Load‣Slot 18");
inverse_key iload19("load ${project}19.lsmv", "Load‣Slot 19");
inverse_key iload20("load ${project}20.lsmv", "Load‣Slot 20");
inverse_key iload21("load ${project}21.lsmv", "Load‣Slot 21");
inverse_key iload22("load ${project}22.lsmv", "Load‣Slot 22");
inverse_key iload23("load ${project}23.lsmv", "Load‣Slot 23");
inverse_key iload24("load ${project}24.lsmv", "Load‣Slot 24");
inverse_key iload25("load ${project}25.lsmv", "Load‣Slot 25");
inverse_key iload26("load ${project}26.lsmv", "Load‣Slot 26");
inverse_key iload27("load ${project}27.lsmv", "Load‣Slot 27");
inverse_key iload28("load ${project}28.lsmv", "Load‣Slot 28");
inverse_key iload29("load ${project}29.lsmv", "Load‣Slot 29");
inverse_key iload30("load ${project}30.lsmv", "Load‣Slot 30");
inverse_key iload31("load ${project}31.lsmv", "Load‣Slot 31");
inverse_key iload32("load ${project}32.lsmv", "Load‣Slot 32");
inverse_key isave1("save-state ${project}1.lsmv", "Save‣Slot 1");
inverse_key isave2("save-state ${project}2.lsmv", "Save‣Slot 2");
inverse_key isave3("save-state ${project}3.lsmv", "Save‣Slot 3");
inverse_key isave4("save-state ${project}4.lsmv", "Save‣Slot 4");
inverse_key isave5("save-state ${project}5.lsmv", "Save‣Slot 5");
inverse_key isave6("save-state ${project}6.lsmv", "Save‣Slot 6");
inverse_key isave7("save-state ${project}7.lsmv", "Save‣Slot 7");
inverse_key isave8("save-state ${project}8.lsmv", "Save‣Slot 8");
inverse_key isave9("save-state ${project}9.lsmv", "Save‣Slot 9");
inverse_key isave10("save-state ${project}10.lsmv", "Save‣Slot 10");
inverse_key isave11("save-state ${project}11.lsmv", "Save‣Slot 11");
inverse_key isave12("save-state ${project}12.lsmv", "Save‣Slot 12");
inverse_key isave13("save-state ${project}13.lsmv", "Save‣Slot 13");
inverse_key isave14("save-state ${project}14.lsmv", "Save‣Slot 14");
inverse_key isave15("save-state ${project}15.lsmv", "Save‣Slot 15");
inverse_key isave16("save-state ${project}16.lsmv", "Save‣Slot 16");
inverse_key isave17("save-state ${project}17.lsmv", "Save‣Slot 17");
inverse_key isave18("save-state ${project}18.lsmv", "Save‣Slot 18");
inverse_key isave19("save-state ${project}19.lsmv", "Save‣Slot 19");
inverse_key isave20("save-state ${project}20.lsmv", "Save‣Slot 20");
inverse_key isave21("save-state ${project}21.lsmv", "Save‣Slot 21");
inverse_key isave22("save-state ${project}22.lsmv", "Save‣Slot 22");
inverse_key isave23("save-state ${project}23.lsmv", "Save‣Slot 23");
inverse_key isave24("save-state ${project}24.lsmv", "Save‣Slot 24");
inverse_key isave25("save-state ${project}25.lsmv", "Save‣Slot 25");
inverse_key isave26("save-state ${project}26.lsmv", "Save‣Slot 26");
inverse_key isave27("save-state ${project}27.lsmv", "Save‣Slot 27");
inverse_key isave28("save-state ${project}28.lsmv", "Save‣Slot 28");
inverse_key isave29("save-state ${project}29.lsmv", "Save‣Slot 29");
inverse_key isave30("save-state ${project}30.lsmv", "Save‣Slot 30");
inverse_key isave31("save-state ${project}31.lsmv", "Save‣Slot 31");
inverse_key isave32("save-state ${project}32.lsmv", "Save‣Slot 32");
bool on_quit_prompt = false;
class mywindowcallbacks : public information_dispatch
@ -832,19 +811,6 @@ namespace
}
}
std::vector<std::string> get_jukebox_names()
{
return save_jukebox;
}
void set_jukebox_names(const std::vector<std::string>& newj)
{
save_jukebox = newj;
if(save_jukebox_pointer >= save_jukebox.size())
save_jukebox_pointer = 0;
update_movie_state();
}
void main_loop(struct loaded_rom& rom, struct moviefile& initial, bool load_has_to_succeed) throw(std::bad_alloc,
std::runtime_error)
{

18
src/core/moviedata.cpp
View file

@ -49,6 +49,8 @@ namespace
{
numeric_setting savecompression("savecompression", 0, 9, 7);
path_setting slotpath_setting("slotpath");
class projectprefix_setting : public setting
{
public:
@ -169,13 +171,17 @@ namespace
}
}
std::string translate_name_mprefix(std::string original)
std::string translate_name_mprefix(std::string original, bool forio)
{
size_t prefixloc = original.find("${project}");
if(prefixloc < original.length())
if(prefixloc < original.length()) {
std::string pprf = forio ? (slotpath_setting.get() + "/") : std::string("");
if(prefixloc == 0)
return pprf + static_cast<std::string>(mprefix) + original.substr(prefixloc + 10);
else
return original.substr(0, prefixloc) + static_cast<std::string>(mprefix) +
original.substr(prefixloc + 10);
else
} else
return original;
}
@ -202,7 +208,7 @@ std::pair<std::string, std::string> split_author(const std::string& author) thro
void do_save_state(const std::string& filename) throw(std::bad_alloc,
std::runtime_error)
{
std::string filename2 = translate_name_mprefix(filename);
std::string filename2 = translate_name_mprefix(filename, true);
lua_callback_pre_save(filename2, true);
try {
uint64_t origtime = get_utime();
@ -237,7 +243,7 @@ void do_save_state(const std::string& filename) throw(std::bad_alloc,
//Save movie.
void do_save_movie(const std::string& filename) throw(std::bad_alloc, std::runtime_error)
{
std::string filename2 = translate_name_mprefix(filename);
std::string filename2 = translate_name_mprefix(filename, true);
lua_callback_pre_save(filename2, false);
try {
uint64_t origtime = get_utime();
@ -458,7 +464,7 @@ void do_load_state(struct moviefile& _movie, int lmode)
//Load state
bool do_load_state(const std::string& filename, int lmode)
{
std::string filename2 = translate_name_mprefix(filename);
std::string filename2 = translate_name_mprefix(filename, true);
uint64_t origtime = get_utime();
lua_callback_pre_load(filename2);
struct moviefile mfile;

39
src/core/settings.cpp
View file

@ -196,3 +196,42 @@ boolean_setting::operator bool() throw()
{
return value;
}
path_setting::path_setting(const std::string& sname) throw(std::bad_alloc)
: setting(sname)
{
path = ".";
_default = true;
}
void path_setting::blank() throw(std::bad_alloc, std::runtime_error)
{
path = ".";
_default = true;
}
bool path_setting::is_set() throw()
{
return !_default;
}
void path_setting::set(const std::string& value) throw(std::bad_alloc, std::runtime_error)
{
if(value == "") {
path = ".";
_default = true;
} else {
path = value;
_default = false;
}
}
std::string path_setting::get() throw(std::bad_alloc)
{
return path;
}
path_setting::operator std::string()
{
return path;
}

4
src/core/window.cpp
View file

@ -148,8 +148,8 @@ namespace
}
});
inverse_key ienable_sound("enable-sound on", "Enable sound");
inverse_key idisable_sound("enable-sound off", "Disable sound");
inverse_key ienable_sound("enable-sound on", "Sound‣Enable");
inverse_key idisable_sound("enable-sound off", "Sound‣Disable");
function_ptr_command<const std::string&> set_sound_device("set-sound-device", "Set sound device",
"Syntax: set-sound-device <id>\nSet sound device to <id>.\n",

8
src/platform/evdev/joystick.cpp
View file

@ -93,7 +93,7 @@ namespace
std::ostringstream _name;
_name << "joystick" << joynum << "button" << buttonnum;
std::string name = _name.str();
keygroup* grp = new keygroup(name, keygroup::KT_KEY);
keygroup* grp = new keygroup(name, "joystick", keygroup::KT_KEY);
keygroups.insert(grp);
struct event_mapping evmap;
evmap.joystick = joynum;
@ -115,9 +115,9 @@ namespace
std::string name = _name.str();
keygroup* grp;
if(min < 0)
grp = new keygroup(name, keygroup::KT_AXIS_PAIR);
grp = new keygroup(name, "joystick", keygroup::KT_AXIS_PAIR);
else
grp = new keygroup(name, keygroup::KT_PRESSURE_MP);
grp = new keygroup(name, "joystick", keygroup::KT_PRESSURE_MP);
keygroups.insert(grp);
struct event_mapping evmap;
evmap.joystick = joynum;
@ -138,7 +138,7 @@ namespace
std::ostringstream _name;
_name << "joystick" << joynum << "hat" << hatnum;
std::string name = _name.str();
keygroup* grp = new keygroup(name, keygroup::KT_HAT);
keygroup* grp = new keygroup(name, "joystick", keygroup::KT_HAT);
keygroups.insert(grp);
struct event_mapping evmap1;
evmap1.joystick = joynum;

10
src/platform/sdl/graphicsfn.cpp
View file

@ -276,11 +276,11 @@ namespace
platform::queue(emu_handle_quit_signal, NULL, false);
}
keygroup mouse_x("mouse_x", keygroup::KT_MOUSE);
keygroup mouse_y("mouse_y", keygroup::KT_MOUSE);
keygroup mouse_l("mouse_left", keygroup::KT_KEY);
keygroup mouse_m("mouse_center", keygroup::KT_KEY);
keygroup mouse_r("mouse_right", keygroup::KT_KEY);
keygroup mouse_x("mouse_x", "mouse", keygroup::KT_MOUSE);
keygroup mouse_y("mouse_y", "mouse", keygroup::KT_MOUSE);
keygroup mouse_l("mouse_left", "mouse", keygroup::KT_KEY);
keygroup mouse_m("mouse_center", "mouse", keygroup::KT_KEY);
keygroup mouse_r("mouse_right", "mouse", keygroup::KT_KEY);
}
void notify_emulator_exit()

6
src/platform/sdl/joystick.cpp
View file

@ -71,19 +71,19 @@ void joystick_plugin::init() throw()
unsigned num = 256 * i + k;
std::ostringstream x;
x << "joystick" << i << "axis" << k;
joyaxis[num] = new keygroup(x.str(), keygroup::KT_AXIS_PAIR);
joyaxis[num] = new keygroup(x.str(), "joystick", keygroup::KT_AXIS_PAIR);
}
for(int k = 0; k < SDL_JoystickNumButtons(j); k++) {
unsigned num = 256 * i + k;
std::ostringstream x;
x << "joystick" << i << "button" << k;
joybutton[num] = new keygroup(x.str(), keygroup::KT_KEY);
joybutton[num] = new keygroup(x.str(), "joystick", keygroup::KT_KEY);
}
for(int k = 0; k < SDL_JoystickNumHats(j); k++) {
unsigned num = 256 * i + k;
std::ostringstream x;
x << "joystick" << i << "hat" << k;
joyhat[num] = new keygroup(x.str(), keygroup::KT_HAT);
joyhat[num] = new keygroup(x.str(), "joystick", keygroup::KT_HAT);
}
}
}

467
src/platform/sdl/keyboard.cpp
View file

@ -34,239 +34,240 @@ namespace
struct sdl_key
{
const char* name;
const char* clazz;
unsigned symbol;
} keys_table[] = {
{"backspace", SDLK_BACKSPACE },
{"tab", SDLK_TAB },
{"clear", SDLK_CLEAR },
{"return", SDLK_RETURN },
{"pause", SDLK_PAUSE },
{"escape", SDLK_ESCAPE },
{"space", SDLK_SPACE },
{"exclaim", SDLK_EXCLAIM },
{"quotedbl", SDLK_QUOTEDBL },
{"hash", SDLK_HASH },
{"dollar", SDLK_DOLLAR },
{"ampersand", SDLK_AMPERSAND },
{"quote", SDLK_QUOTE },
{"leftparen", SDLK_LEFTPAREN },
{"rightparen", SDLK_RIGHTPAREN },
{"asterisk", SDLK_ASTERISK },
{"plus", SDLK_PLUS },
{"comma", SDLK_COMMA },
{"minus", SDLK_MINUS },
{"period", SDLK_PERIOD },
{"slash", SDLK_SLASH },
{"0", SDLK_0 },
{"1", SDLK_1 },
{"2", SDLK_2 },
{"3", SDLK_3 },
{"4", SDLK_4 },
{"5", SDLK_5 },
{"6", SDLK_6 },
{"7", SDLK_7 },
{"8", SDLK_8 },
{"9", SDLK_9 },
{"colon", SDLK_COLON },
{"semicolon", SDLK_SEMICOLON },
{"less", SDLK_LESS },
{"equals", SDLK_EQUALS },
{"greater", SDLK_GREATER },
{"question", SDLK_QUESTION },
{"at", SDLK_AT },
{"leftbracket", SDLK_LEFTBRACKET },
{"backslash", SDLK_BACKSLASH },
{"rightbracket", SDLK_RIGHTBRACKET },
{"caret", SDLK_CARET },
{"underscore", SDLK_UNDERSCORE },
{"backquote", SDLK_BACKQUOTE },
{"a", SDLK_a },
{"b", SDLK_b },
{"c", SDLK_c },
{"d", SDLK_d },
{"e", SDLK_e },
{"f", SDLK_f },
{"g", SDLK_g },
{"h", SDLK_h },
{"i", SDLK_i },
{"j", SDLK_j },
{"k", SDLK_k },
{"l", SDLK_l },
{"m", SDLK_m },
{"n", SDLK_n },
{"o", SDLK_o },
{"p", SDLK_p },
{"q", SDLK_q },
{"r", SDLK_r },
{"s", SDLK_s },
{"t", SDLK_t },
{"u", SDLK_u },
{"v", SDLK_v },
{"w", SDLK_w },
{"x", SDLK_x },
{"y", SDLK_y },
{"z", SDLK_z },
{"delete", SDLK_DELETE },
{"world_0", SDLK_WORLD_0 },
{"world_1", SDLK_WORLD_1 },
{"world_2", SDLK_WORLD_2 },
{"world_3", SDLK_WORLD_3 },
{"world_4", SDLK_WORLD_4 },
{"world_5", SDLK_WORLD_5 },
{"world_6", SDLK_WORLD_6 },
{"world_7", SDLK_WORLD_7 },
{"world_8", SDLK_WORLD_8 },
{"world_9", SDLK_WORLD_9 },
{"world_10", SDLK_WORLD_10 },
{"world_11", SDLK_WORLD_11 },
{"world_12", SDLK_WORLD_12 },
{"world_13", SDLK_WORLD_13 },
{"world_14", SDLK_WORLD_14 },
{"world_15", SDLK_WORLD_15 },
{"world_16", SDLK_WORLD_16 },
{"world_17", SDLK_WORLD_17 },
{"world_18", SDLK_WORLD_18 },
{"world_19", SDLK_WORLD_19 },
{"world_20", SDLK_WORLD_20 },
{"world_21", SDLK_WORLD_21 },
{"world_22", SDLK_WORLD_22 },
{"world_23", SDLK_WORLD_23 },
{"world_24", SDLK_WORLD_24 },
{"world_25", SDLK_WORLD_25 },
{"world_26", SDLK_WORLD_26 },
{"world_27", SDLK_WORLD_27 },
{"world_28", SDLK_WORLD_28 },
{"world_29", SDLK_WORLD_29 },
{"world_30", SDLK_WORLD_30 },
{"world_31", SDLK_WORLD_31 },
{"world_32", SDLK_WORLD_32 },
{"world_33", SDLK_WORLD_33 },
{"world_34", SDLK_WORLD_34 },
{"world_35", SDLK_WORLD_35 },
{"world_36", SDLK_WORLD_36 },
{"world_37", SDLK_WORLD_37 },
{"world_38", SDLK_WORLD_38 },
{"world_39", SDLK_WORLD_39 },
{"world_40", SDLK_WORLD_40 },
{"world_41", SDLK_WORLD_41 },
{"world_42", SDLK_WORLD_42 },
{"world_43", SDLK_WORLD_43 },
{"world_44", SDLK_WORLD_44 },
{"world_45", SDLK_WORLD_45 },
{"world_46", SDLK_WORLD_46 },
{"world_47", SDLK_WORLD_47 },
{"world_48", SDLK_WORLD_48 },
{"world_49", SDLK_WORLD_49 },
{"world_50", SDLK_WORLD_50 },
{"world_51", SDLK_WORLD_51 },
{"world_52", SDLK_WORLD_52 },
{"world_53", SDLK_WORLD_53 },
{"world_54", SDLK_WORLD_54 },
{"world_55", SDLK_WORLD_55 },
{"world_56", SDLK_WORLD_56 },
{"world_57", SDLK_WORLD_57 },
{"world_58", SDLK_WORLD_58 },
{"world_59", SDLK_WORLD_59 },
{"world_60", SDLK_WORLD_60 },
{"world_61", SDLK_WORLD_61 },
{"world_62", SDLK_WORLD_62 },
{"world_63", SDLK_WORLD_63 },
{"world_64", SDLK_WORLD_64 },
{"world_65", SDLK_WORLD_65 },
{"world_66", SDLK_WORLD_66 },
{"world_67", SDLK_WORLD_67 },
{"world_68", SDLK_WORLD_68 },
{"world_69", SDLK_WORLD_69 },
{"world_70", SDLK_WORLD_70 },
{"world_71", SDLK_WORLD_71 },
{"world_72", SDLK_WORLD_72 },
{"world_73", SDLK_WORLD_73 },
{"world_74", SDLK_WORLD_74 },
{"world_75", SDLK_WORLD_75 },
{"world_76", SDLK_WORLD_76 },
{"world_77", SDLK_WORLD_77 },
{"world_78", SDLK_WORLD_78 },
{"world_79", SDLK_WORLD_79 },
{"world_80", SDLK_WORLD_80 },
{"world_81", SDLK_WORLD_81 },
{"world_82", SDLK_WORLD_82 },
{"world_83", SDLK_WORLD_83 },
{"world_84", SDLK_WORLD_84 },
{"world_85", SDLK_WORLD_85 },
{"world_86", SDLK_WORLD_86 },
{"world_87", SDLK_WORLD_87 },
{"world_88", SDLK_WORLD_88 },
{"world_89", SDLK_WORLD_89 },
{"world_90", SDLK_WORLD_90 },
{"world_91", SDLK_WORLD_91 },
{"world_92", SDLK_WORLD_92 },
{"world_93", SDLK_WORLD_93 },
{"world_94", SDLK_WORLD_94 },
{"world_95", SDLK_WORLD_95 },
{"kp0", SDLK_KP0 },
{"kp1", SDLK_KP1 },
{"kp2", SDLK_KP2 },
{"kp3", SDLK_KP3 },
{"kp4", SDLK_KP4 },
{"kp5", SDLK_KP5 },
{"kp6", SDLK_KP6 },
{"kp7", SDLK_KP7 },
{"kp8", SDLK_KP8 },
{"kp9", SDLK_KP9 },
{"kp_period", SDLK_KP_PERIOD },
{"kp_divide", SDLK_KP_DIVIDE },
{"kp_multiply", SDLK_KP_MULTIPLY },
{"kp_minus", SDLK_KP_MINUS },
{"kp_plus", SDLK_KP_PLUS },
{"kp_enter", SDLK_KP_ENTER },
{"kp_equals", SDLK_KP_EQUALS },
{"up", SDLK_UP },
{"down", SDLK_DOWN },
{"right", SDLK_RIGHT },
{"left", SDLK_LEFT },
{"insert", SDLK_INSERT },
{"home", SDLK_HOME },
{"end", SDLK_END },
{"pageup", SDLK_PAGEUP },
{"pagedown", SDLK_PAGEDOWN },
{"f1", SDLK_F1 },
{"f2", SDLK_F2 },
{"f3", SDLK_F3 },
{"f4", SDLK_F4 },
{"f5", SDLK_F5 },
{"f6", SDLK_F6 },
{"f7", SDLK_F7 },
{"f8", SDLK_F8 },
{"f9", SDLK_F9 },
{"f10", SDLK_F10 },
{"f11", SDLK_F11 },
{"f12", SDLK_F12 },
{"f13", SDLK_F13 },
{"f14", SDLK_F14 },
{"f15", SDLK_F15 },
{"numlock", SDLK_NUMLOCK },
{"capslock", SDLK_CAPSLOCK },
{"scrollock", SDLK_SCROLLOCK },
{"rshift", SDLK_RSHIFT },
{"lshift", SDLK_LSHIFT },
{"rctrl", SDLK_RCTRL },
{"lctrl", SDLK_LCTRL },
{"ralt", SDLK_RALT },
{"lalt", SDLK_LALT },
{"rmeta", SDLK_RMETA },
{"lmeta", SDLK_LMETA },
{"lsuper", SDLK_LSUPER },
{"rsuper", SDLK_RSUPER },
{"mode", SDLK_MODE },
{"compose", SDLK_COMPOSE },
{"help", SDLK_HELP },
{"print", SDLK_PRINT },
{"sysreq", SDLK_SYSREQ },
{"break", SDLK_BREAK },
{"menu", SDLK_MENU },
{"power", SDLK_POWER },
{"euro", SDLK_EURO },
{"undo", SDLK_UNDO },
{"backspace", "editing", SDLK_BACKSPACE },
{"tab", "editing", SDLK_TAB },
{"clear", "editing", SDLK_CLEAR },
{"return", "editing", SDLK_RETURN },
{"pause", "special", SDLK_PAUSE },
{"escape", "editing", SDLK_ESCAPE },
{"space", "characters", SDLK_SPACE },
{"exclaim", "characters", SDLK_EXCLAIM },
{"quotedbl", "characters", SDLK_QUOTEDBL },
{"hash", "characters", SDLK_HASH },
{"dollar", "characters", SDLK_DOLLAR },
{"ampersand", "characters", SDLK_AMPERSAND },
{"quote", "characters", SDLK_QUOTE },
{"leftparen", "characters", SDLK_LEFTPAREN },
{"rightparen", "characters", SDLK_RIGHTPAREN },
{"asterisk", "characters", SDLK_ASTERISK },
{"plus", "characters", SDLK_PLUS },
{"comma", "characters", SDLK_COMMA },
{"minus", "characters", SDLK_MINUS },
{"period", "characters", SDLK_PERIOD },
{"slash", "characters", SDLK_SLASH },
{"0", "numeric", SDLK_0 },
{"1", "numeric", SDLK_1 },
{"2", "numeric", SDLK_2 },
{"3", "numeric", SDLK_3 },
{"4", "numeric", SDLK_4 },
{"5", "numeric", SDLK_5 },
{"6", "numeric", SDLK_6 },
{"7", "numeric", SDLK_7 },
{"8", "numeric", SDLK_8 },
{"9", "numeric", SDLK_9 },
{"colon", "characters", SDLK_COLON },
{"semicolon", "characters", SDLK_SEMICOLON },
{"less", "characters", SDLK_LESS },
{"equals", "characters", SDLK_EQUALS },
{"greater", "characters", SDLK_GREATER },
{"question", "characters", SDLK_QUESTION },
{"at", "characters", SDLK_AT },
{"leftbracket", "characters", SDLK_LEFTBRACKET },
{"backslash", "characters", SDLK_BACKSLASH },
{"rightbracket", "characters", SDLK_RIGHTBRACKET },
{"caret", "characters", SDLK_CARET },
{"underscore", "characters", SDLK_UNDERSCORE },
{"backquote", "characters", SDLK_BACKQUOTE },
{"a", "alphabetic", SDLK_a },
{"b", "alphabetic", SDLK_b },
{"c", "alphabetic", SDLK_c },
{"d", "alphabetic", SDLK_d },
{"e", "alphabetic", SDLK_e },
{"f", "alphabetic", SDLK_f },
{"g", "alphabetic", SDLK_g },
{"h", "alphabetic", SDLK_h },
{"i", "alphabetic", SDLK_i },
{"j", "alphabetic", SDLK_j },
{"k", "alphabetic", SDLK_k },
{"l", "alphabetic", SDLK_l },
{"m", "alphabetic", SDLK_m },
{"n", "alphabetic", SDLK_n },
{"o", "alphabetic", SDLK_o },
{"p", "alphabetic", SDLK_p },
{"q", "alphabetic", SDLK_q },
{"r", "alphabetic", SDLK_r },
{"s", "alphabetic", SDLK_s },
{"t", "alphabetic", SDLK_t },
{"u", "alphabetic", SDLK_u },
{"v", "alphabetic", SDLK_v },
{"w", "alphabetic", SDLK_w },
{"x", "alphabetic", SDLK_x },
{"y", "alphabetic", SDLK_y },
{"z", "alphabetic", SDLK_z },
{"delete", "editing", SDLK_DELETE },
{"world_0", "international",SDLK_WORLD_0 },
{"world_1", "international",SDLK_WORLD_1 },
{"world_2", "international",SDLK_WORLD_2 },
{"world_3", "international",SDLK_WORLD_3 },
{"world_4", "international",SDLK_WORLD_4 },
{"world_5", "international",SDLK_WORLD_5 },
{"world_6", "international",SDLK_WORLD_6 },
{"world_7", "international",SDLK_WORLD_7 },
{"world_8", "international",SDLK_WORLD_8 },
{"world_9", "international",SDLK_WORLD_9 },
{"world_10", "international",SDLK_WORLD_10 },
{"world_11", "international",SDLK_WORLD_11 },
{"world_12", "international",SDLK_WORLD_12 },
{"world_13", "international",SDLK_WORLD_13 },
{"world_14", "international",SDLK_WORLD_14 },
{"world_15", "international",SDLK_WORLD_15 },
{"world_16", "international",SDLK_WORLD_16 },
{"world_17", "international",SDLK_WORLD_17 },
{"world_18", "international",SDLK_WORLD_18 },
{"world_19", "international",SDLK_WORLD_19 },
{"world_20", "international",SDLK_WORLD_20 },
{"world_21", "international",SDLK_WORLD_21 },
{"world_22", "international",SDLK_WORLD_22 },
{"world_23", "international",SDLK_WORLD_23 },
{"world_24", "international",SDLK_WORLD_24 },
{"world_25", "international",SDLK_WORLD_25 },
{"world_26", "international",SDLK_WORLD_26 },
{"world_27", "international",SDLK_WORLD_27 },
{"world_28", "international",SDLK_WORLD_28 },
{"world_29", "international",SDLK_WORLD_29 },
{"world_30", "international",SDLK_WORLD_30 },
{"world_31", "international",SDLK_WORLD_31 },
{"world_32", "international",SDLK_WORLD_32 },
{"world_33", "international",SDLK_WORLD_33 },
{"world_34", "international",SDLK_WORLD_34 },
{"world_35", "international",SDLK_WORLD_35 },
{"world_36", "international",SDLK_WORLD_36 },
{"world_37", "international",SDLK_WORLD_37 },
{"world_38", "international",SDLK_WORLD_38 },
{"world_39", "international",SDLK_WORLD_39 },
{"world_40", "international",SDLK_WORLD_40 },
{"world_41", "international",SDLK_WORLD_41 },
{"world_42", "international",SDLK_WORLD_42 },
{"world_43", "international",SDLK_WORLD_43 },
{"world_44", "international",SDLK_WORLD_44 },
{"world_45", "international",SDLK_WORLD_45 },
{"world_46", "international",SDLK_WORLD_46 },
{"world_47", "international",SDLK_WORLD_47 },
{"world_48", "international",SDLK_WORLD_48 },
{"world_49", "international",SDLK_WORLD_49 },
{"world_50", "international",SDLK_WORLD_50 },
{"world_51", "international",SDLK_WORLD_51 },
{"world_52", "international",SDLK_WORLD_52 },
{"world_53", "international",SDLK_WORLD_53 },
{"world_54", "international",SDLK_WORLD_54 },
{"world_55", "international",SDLK_WORLD_55 },
{"world_56", "international",SDLK_WORLD_56 },
{"world_57", "international",SDLK_WORLD_57 },
{"world_58", "international",SDLK_WORLD_58 },
{"world_59", "international",SDLK_WORLD_59 },
{"world_60", "international",SDLK_WORLD_60 },
{"world_61", "international",SDLK_WORLD_61 },
{"world_62", "international",SDLK_WORLD_62 },
{"world_63", "international",SDLK_WORLD_63 },
{"world_64", "international",SDLK_WORLD_64 },
{"world_65", "international",SDLK_WORLD_65 },
{"world_66", "international",SDLK_WORLD_66 },
{"world_67", "international",SDLK_WORLD_67 },
{"world_68", "international",SDLK_WORLD_68 },
{"world_69", "international",SDLK_WORLD_69 },
{"world_70", "international",SDLK_WORLD_70 },
{"world_71", "international",SDLK_WORLD_71 },
{"world_72", "international",SDLK_WORLD_72 },
{"world_73", "international",SDLK_WORLD_73 },
{"world_74", "international",SDLK_WORLD_74 },
{"world_75", "international",SDLK_WORLD_75 },
{"world_76", "international",SDLK_WORLD_76 },
{"world_77", "international",SDLK_WORLD_77 },
{"world_78", "international",SDLK_WORLD_78 },
{"world_79", "international",SDLK_WORLD_79 },
{"world_80", "international",SDLK_WORLD_80 },
{"world_81", "international",SDLK_WORLD_81 },
{"world_82", "international",SDLK_WORLD_82 },
{"world_83", "international",SDLK_WORLD_83 },
{"world_84", "international",SDLK_WORLD_84 },
{"world_85", "international",SDLK_WORLD_85 },
{"world_86", "international",SDLK_WORLD_86 },
{"world_87", "international",SDLK_WORLD_87 },
{"world_88", "international",SDLK_WORLD_88 },
{"world_89", "international",SDLK_WORLD_89 },
{"world_90", "international",SDLK_WORLD_90 },
{"world_91", "international",SDLK_WORLD_91 },
{"world_92", "international",SDLK_WORLD_92 },
{"world_93", "international",SDLK_WORLD_93 },
{"world_94", "international",SDLK_WORLD_94 },
{"world_95", "international",SDLK_WORLD_95 },
{"kp0", "numeric", SDLK_KP0 },
{"kp1", "numeric", SDLK_KP1 },
{"kp2", "numeric", SDLK_KP2 },
{"kp3", "numeric", SDLK_KP3 },
{"kp4", "numeric", SDLK_KP4 },
{"kp5", "numeric", SDLK_KP5 },
{"kp6", "numeric", SDLK_KP6 },
{"kp7", "numeric", SDLK_KP7 },
{"kp8", "numeric", SDLK_KP8 },
{"kp9", "numeric", SDLK_KP9 },
{"kp_period", "characters", SDLK_KP_PERIOD },
{"kp_divide", "characters", SDLK_KP_DIVIDE },
{"kp_multiply", "characters", SDLK_KP_MULTIPLY },
{"kp_minus", "characters", SDLK_KP_MINUS },
{"kp_plus", "characters", SDLK_KP_PLUS },
{"kp_enter", "characters", SDLK_KP_ENTER },
{"kp_equals", "characters", SDLK_KP_EQUALS },
{"up", "editing", SDLK_UP },
{"down", "editing", SDLK_DOWN },
{"right", "editing", SDLK_RIGHT },
{"left", "editing", SDLK_LEFT },
{"insert", "editing", SDLK_INSERT },
{"home", "editing", SDLK_HOME },
{"end", "editing", SDLK_END },
{"pageup", "editing", SDLK_PAGEUP },
{"pagedown", "editing", SDLK_PAGEDOWN },
{"f1", "F-keys", SDLK_F1 },
{"f2", "F-keys", SDLK_F2 },
{"f3", "F-keys", SDLK_F3 },
{"f4", "F-keys", SDLK_F4 },
{"f5", "F-keys", SDLK_F5 },
{"f6", "F-keys", SDLK_F6 },
{"f7", "F-keys", SDLK_F7 },
{"f8", "F-keys", SDLK_F8 },
{"f9", "F-keys", SDLK_F9 },
{"f10", "F-keys", SDLK_F10 },
{"f11", "F-keys", SDLK_F11 },
{"f12", "F-keys", SDLK_F12 },
{"f13", "F-keys", SDLK_F13 },
{"f14", "F-keys", SDLK_F14 },
{"f15", "F-keys", SDLK_F15 },
{"numlock", "locks", SDLK_NUMLOCK },
{"capslock", "locks", SDLK_CAPSLOCK },
{"scrollock", "locks", SDLK_SCROLLOCK },
{"rshift", "modifiers", SDLK_RSHIFT },
{"lshift", "modifiers", SDLK_LSHIFT },
{"rctrl", "modifiers", SDLK_RCTRL },
{"lctrl", "modifiers", SDLK_LCTRL },
{"ralt", "modifiers", SDLK_RALT },
{"lalt", "modifiers", SDLK_LALT },
{"rmeta", "modifiers", SDLK_RMETA },
{"lmeta", "modifiers", SDLK_LMETA },
{"lsuper", "modifiers", SDLK_LSUPER },
{"rsuper", "modifiers", SDLK_RSUPER },
{"mode", "modifiers", SDLK_MODE },
{"compose", "modifiers", SDLK_COMPOSE },
{"help", "special", SDLK_HELP },
{"print", "special", SDLK_PRINT },
{"sysreq", "special", SDLK_SYSREQ },
{"break", "special", SDLK_BREAK },
{"menu", "special", SDLK_MENU },
{"power", "special", SDLK_POWER },
{"euro", "characters", SDLK_EURO },
{"undo", "special", SDLK_UNDO },
{NULL, 0 }
};
@ -366,13 +367,13 @@ void init_sdl_keys()
}
struct sdl_key* k = keys_table;
while(k->name) {
symbolkeys[k->symbol] = new keygroup(k->name, keygroup::KT_KEY);
symbolkeys[k->symbol] = new keygroup(k->name, k->clazz, keygroup::KT_KEY);
k++;
}
for(unsigned i = 0; i < 256; i++) {
std::ostringstream x;
x << "key" << i;
scancodekeys[i] = new keygroup(x.str(), keygroup::KT_KEY);
scancodekeys[i] = new keygroup(x.str(), "scancode", keygroup::KT_KEY);
}
}

6
src/platform/win32mm/joystick.cpp
View file

@ -33,14 +33,14 @@ namespace
void create_hat(unsigned i)
{
std::string n = (stringfmt() << "joystick" << i << "hat").str();
keygroup* k = new keygroup(n, keygroup::KT_HAT);
keygroup* k = new keygroup(n, "joystick", keygroup::KT_HAT);
hats[i] = k;
}
void create_button(unsigned i, unsigned j)
{
std::string n = (stringfmt() << "joystick" << i << "button" << j).str();
keygroup* k = new keygroup(n, keygroup::KT_KEY);
keygroup* k = new keygroup(n, "joystick", keygroup::KT_KEY);
buttons[std::make_pair(i, j)] = k;
}
@ -48,7 +48,7 @@ namespace
{
std::string n = (stringfmt() << "joystick" << i << "axis" << j).str();
keygroup* k;
k = new keygroup(n, keygroup::KT_AXIS_PAIR);
k = new keygroup(n, "joystick", keygroup::KT_AXIS_PAIR);
axes[std::make_pair(i, j)] = k;
}

428
src/platform/wxwidgets/editor-keyselect.cpp
View file

@ -1,428 +0,0 @@
#include "platform/wxwidgets/platform.hpp"
#include "core/keymapper.hpp"
#include <wx/wx.h>
namespace
{
struct keyentry_mod_data
{
wxCheckBox* pressed;
wxCheckBox* unmasked;
unsigned tmpflags;
};
class wxdialog_keyentry : public wxDialog
{
public:
wxdialog_keyentry(wxWindow* parent, const std::string& title, const std::string& spec,
bool clearable);
void on_change_setting(wxCommandEvent& e);
void on_ok(wxCommandEvent& e);
void on_cancel(wxCommandEvent& e);
void on_clear(wxCommandEvent& e);
std::string getkey();
private:
void set_mask(const std::string& mod);
void set_mod(const std::string& mod);
void set_set(const std::string& mset,
void (wxdialog_keyentry::*fn)(const std::string& mod));
void load_spec(const std::string& spec);
std::map<std::string, keyentry_mod_data> modifiers;
wxComboBox* mainkey;
wxButton* ok;
wxButton* cancel;
wxButton* clear;
bool cleared;
};
class wxdialog_hotkeys;
class hotkey
{
public:
hotkey(wxdialog_hotkeys* h, wxWindow* win, wxSizer* s, inverse_key* ikey, unsigned o);
void update(const std::string& primary, const std::string& secondary);
inverse_key* get_associated();
std::string get_title();
private:
wxButton* primaryb;
wxButton* secondaryb;
inverse_key* associated;
std::string title;
};
class wxdialog_hotkeys : public wxDialog
{
public:
wxdialog_hotkeys(wxWindow* parent);
~wxdialog_hotkeys();
void on_close(wxCommandEvent& e);
void on_reconfig(wxCommandEvent& e);
private:
void update();
wxScrolledWindow* scroll;
wxSizer* scroll_sizer;
std::map<unsigned, hotkey*> hotkeys;
wxButton* close;
};
wxdialog_keyentry::wxdialog_keyentry(wxWindow* parent, const std::string& title, const std::string& spec,
bool clearable)
: wxDialog(parent, wxID_ANY, towxstring(title), wxDefaultPosition, wxSize(-1, -1))
{
std::vector<wxString> keych;
std::set<std::string> mods, keys;
cleared = false;
runemufn([&mods, &keys]() { mods = modifier::get_set(); keys = keygroup::get_keys(); });
Centre();
wxFlexGridSizer* top_s = new wxFlexGridSizer(2, 1, 0, 0);
SetSizer(top_s);
wxFlexGridSizer* t_s = new wxFlexGridSizer(mods.size() + 1, 3, 0, 0);
for(auto i : mods) {
t_s->Add(new wxStaticText(this, wxID_ANY, towxstring(i)), 0, wxGROW);
keyentry_mod_data m;
t_s->Add(m.pressed = new wxCheckBox(this, wxID_ANY, wxT("Pressed")), 0, wxGROW);
t_s->Add(m.unmasked = new wxCheckBox(this, wxID_ANY, wxT("Unmasked")), 0, wxGROW);
m.pressed->Disable();
modifiers[i] = m;
m.pressed->Connect(wxEVT_COMMAND_CHECKBOX_CLICKED,
wxCommandEventHandler(wxdialog_keyentry::on_change_setting), NULL, this);
m.unmasked->Connect(wxEVT_COMMAND_CHECKBOX_CLICKED,
wxCommandEventHandler(wxdialog_keyentry::on_change_setting), NULL, this);
}
for(auto i : keys)
keych.push_back(towxstring(i));
t_s->Add(new wxStaticText(this, wxID_ANY, wxT("Key")), 0, wxGROW);
t_s->Add(mainkey = new wxComboBox(this, wxID_ANY, keych[0], wxDefaultPosition, wxDefaultSize,
keych.size(), &keych[0], wxCB_READONLY), 1, wxGROW);
mainkey->Connect(wxEVT_COMMAND_COMBOBOX_SELECTED,
wxCommandEventHandler(wxdialog_keyentry::on_change_setting), NULL, this);
top_s->Add(t_s);
wxBoxSizer* pbutton_s = new wxBoxSizer(wxHORIZONTAL);
if(clearable)
pbutton_s->Add(clear = new wxButton(this, wxID_OK, wxT("Clear")), 0, wxGROW);
pbutton_s->AddStretchSpacer();
pbutton_s->Add(ok = new wxButton(this, wxID_OK, wxT("OK")), 0, wxGROW);
pbutton_s->Add(cancel = new wxButton(this, wxID_CANCEL, wxT("Cancel")), 0, wxGROW);
ok->Connect(wxEVT_COMMAND_BUTTON_CLICKED,
wxCommandEventHandler(wxdialog_keyentry::on_ok), NULL, this);
cancel->Connect(wxEVT_COMMAND_BUTTON_CLICKED,
wxCommandEventHandler(wxdialog_keyentry::on_cancel), NULL, this);
if(clearable)
clear->Connect(wxEVT_COMMAND_BUTTON_CLICKED,
wxCommandEventHandler(wxdialog_keyentry::on_clear), NULL, this);
top_s->Add(pbutton_s, 0, wxGROW);
t_s->SetSizeHints(this);
top_s->SetSizeHints(this);
Fit();
if(spec != "")
load_spec(spec);
}
#define TMPFLAG_UNMASKED 65
#define TMPFLAG_UNMASKED_LINK_CHILD 2
#define TMPFLAG_UNMASKED_LINK_PARENT 68
#define TMPFLAG_PRESSED 8
#define TMPFLAG_PRESSED_LINK_CHILD 16
#define TMPFLAG_PRESSED_LINK_PARENT 32
void wxdialog_keyentry::set_mask(const std::string& mod)
{
if(!modifiers.count(mod))
return;
if(modifiers[mod].unmasked->IsEnabled()) {
wxCommandEvent e;
modifiers[mod].unmasked->SetValue(true);
on_change_setting(e);
}
}
void wxdialog_keyentry::set_mod(const std::string& mod)
{
if(!modifiers.count(mod))
return;
if(modifiers[mod].pressed->IsEnabled()) {
wxCommandEvent e;
modifiers[mod].pressed->SetValue(true);
on_change_setting(e);
}
}
void wxdialog_keyentry::set_set(const std::string& mset,
void (wxdialog_keyentry::*fn)(const std::string& mod))
{
std::string rem = mset;
while(rem != "") {
size_t s = rem.find_first_of(",");
if(s >= rem.length()) {
(this->*fn)(rem);
break;
} else {
(this->*fn)(rem.substr(0, s));
rem = rem.substr(s + 1);
}
}
}
void wxdialog_keyentry::load_spec(const std::string& spec)
{
std::string _spec = spec;
size_t s1 = _spec.find_first_of("/");
size_t s2 = _spec.find_first_of("|");
if(s1 >= _spec.length() || s2 >= _spec.length())
return; //Bad.
std::string mod = _spec.substr(0, s1);
std::string mask = _spec.substr(s1 + 1, s2 - s1 - 1);
std::string key = _spec.substr(s2 + 1);
set_set(mask, &wxdialog_keyentry::set_mask);
set_set(mod, &wxdialog_keyentry::set_mod);
mainkey->SetValue(towxstring(key));
}
void wxdialog_keyentry::on_change_setting(wxCommandEvent& e)
{
for(auto& i : modifiers)
i.second.tmpflags = 0;
for(auto& i : modifiers) {
modifier* m = NULL;
try {
m = &modifier::lookup(i.first);
} catch(...) {
i.second.pressed->Disable();
i.second.unmasked->Disable();
continue;
}
std::string j = m->linked_name();
if(i.second.unmasked->GetValue())
i.second.tmpflags |= TMPFLAG_UNMASKED;
if(j != "") {
if(modifiers[j].unmasked->GetValue())
i.second.tmpflags |= TMPFLAG_UNMASKED_LINK_PARENT;
if(i.second.unmasked->GetValue())
modifiers[j].tmpflags |= TMPFLAG_UNMASKED_LINK_CHILD;
}
if(i.second.pressed->GetValue())
i.second.tmpflags |= TMPFLAG_PRESSED;
if(j != "") {
if(modifiers[j].pressed->GetValue())
i.second.tmpflags |= TMPFLAG_PRESSED_LINK_PARENT;
if(i.second.pressed->GetValue())
modifiers[j].tmpflags |= TMPFLAG_PRESSED_LINK_CHILD;
}
}
for(auto& i : modifiers) {
//Unmasked is to be enabled if neither unmasked link flag is set.
if(i.second.tmpflags & ((TMPFLAG_UNMASKED_LINK_CHILD | TMPFLAG_UNMASKED_LINK_PARENT) & ~64)) {
i.second.unmasked->SetValue(false);
i.second.unmasked->Disable();
} else
i.second.unmasked->Enable();
//Pressed is to be enabled if:
//- This modifier is unmasked or parent is unmasked.
//- Parent nor child is not pressed.
if(((i.second.tmpflags & (TMPFLAG_UNMASKED | TMPFLAG_UNMASKED_LINK_PARENT |
TMPFLAG_PRESSED_LINK_CHILD | TMPFLAG_PRESSED_LINK_PARENT)) & 112) == 64)
i.second.pressed->Enable();
else {
i.second.pressed->SetValue(false);
i.second.pressed->Disable();
}
}
}
void wxdialog_keyentry::on_ok(wxCommandEvent& e)
{
EndModal(wxID_OK);
}
void wxdialog_keyentry::on_clear(wxCommandEvent& e)
{
cleared = true;
EndModal(wxID_OK);
}
void wxdialog_keyentry::on_cancel(wxCommandEvent& e)
{
EndModal(wxID_CANCEL);
}
std::string wxdialog_keyentry::getkey()
{
if(cleared)
return "";
std::string x;
bool f;
f = true;
for(auto i : modifiers) {
if(i.second.pressed->GetValue()) {
if(!f)
x = x + ",";
f = false;
x = x + i.first;
}
}
x = x + "/";
f = true;
for(auto i : modifiers) {
if(i.second.unmasked->GetValue()) {
if(!f)
x = x + ",";
f = false;
x = x + i.first;
}
}
x = x + "|" + tostdstring(mainkey->GetValue());
return x;
}
wxdialog_hotkeys::wxdialog_hotkeys(wxWindow* parent)
: wxDialog(parent, wxID_ANY, wxT("Hotkeys"), wxDefaultPosition, wxSize(-1, -1))
{
scroll = new wxScrolledWindow(this, wxID_ANY, wxDefaultPosition, wxSize(-1, -1));
scroll->SetMinSize(wxSize(-1, 500));
Centre();
wxFlexGridSizer* top_s = new wxFlexGridSizer(2, 1, 0, 0);
SetSizer(top_s);
scroll_sizer = new wxFlexGridSizer(0, 3, 0, 0);
scroll->SetSizer(scroll_sizer);
//Obtain all the inverses.
std::set<inverse_key*> inverses;
runemufn([&inverses]() {
auto x = inverse_key::get_ikeys();
for(auto y : x)
inverses.insert(y);
});
unsigned y = 0;
for(auto x : inverses) {
hotkeys[y] = new hotkey(this, scroll, scroll_sizer, x, y);
y++;
}
update();
top_s->Add(scroll);
scroll->SetScrollRate(0, 20);
wxBoxSizer* pbutton_s = new wxBoxSizer(wxHORIZONTAL);
pbutton_s->AddStretchSpacer();
pbutton_s->Add(close = new wxButton(this, wxID_CANCEL, wxT("Close")), 0, wxGROW);
close->Connect(wxEVT_COMMAND_BUTTON_CLICKED,
wxCommandEventHandler(wxdialog_hotkeys::on_close), NULL, this);
top_s->Add(pbutton_s, 0, wxGROW);
scroll_sizer->SetSizeHints(this);
top_s->SetSizeHints(this);
scroll_sizer->Layout();
top_s->Layout();
Fit();
}
void wxdialog_hotkeys::on_reconfig(wxCommandEvent& e)
{
int id = e.GetId();
if(id <= wxID_HIGHEST)
return;
unsigned button = (id - wxID_HIGHEST - 1) / 2;
bool primflag = (((id - wxID_HIGHEST - 1) % 2) == 0);
if(!hotkeys.count(button))
return;
wxdialog_keyentry* d = new wxdialog_keyentry(this, "Specify key for " + hotkeys[button]->
get_title(), hotkeys[button]->get_associated()->get(primflag), true);
if(d->ShowModal() == wxID_CANCEL) {
d->Destroy();
return;
}
std::string key = d->getkey();
d->Destroy();
if(key != "")
hotkeys[button]->get_associated()->set(key, primflag);
else
hotkeys[button]->get_associated()->clear(primflag);
update();
}
void wxdialog_hotkeys::update()
{
std::map<inverse_key*, std::pair<std::string, std::string>> data;
runemufn([&data]() {
auto x = inverse_key::get_ikeys();
for(auto y : x)
data[y] = std::make_pair(y->get(true), y->get(false));
});
for(auto i : hotkeys) {
inverse_key* j = i.second->get_associated();
if(!data.count(j))
continue;
auto y = data[j];
i.second->update(y.first, y.second);
}
}
wxdialog_hotkeys::~wxdialog_hotkeys()
{
for(auto i : hotkeys)
delete i.second;
}
void wxdialog_hotkeys::on_close(wxCommandEvent& e)
{
EndModal(wxID_OK);
}
hotkey::hotkey(wxdialog_hotkeys* h, wxWindow* win, wxSizer* s, inverse_key* ikey, unsigned o)
{
title = ikey->getname();
s->Add(new wxStaticText(win, wxID_ANY, towxstring(title)), 0, wxGROW);
s->Add(primaryb = new wxButton(win, wxID_HIGHEST + 1 + 2 * o, wxT("(none)"), wxDefaultPosition,
wxSize(200, -1)), 0, wxGROW);
s->Add(secondaryb = new wxButton(win, wxID_HIGHEST + 2 + 2 * o, wxT("(none)"), wxDefaultPosition,
wxSize(200, -1)), 0, wxGROW);
primaryb->Connect(wxEVT_COMMAND_BUTTON_CLICKED,
wxCommandEventHandler(wxdialog_hotkeys::on_reconfig), NULL, h);
secondaryb->Connect(wxEVT_COMMAND_BUTTON_CLICKED,
wxCommandEventHandler(wxdialog_hotkeys::on_reconfig), NULL, h);
associated = ikey;
}
inverse_key* hotkey::get_associated()
{
return associated;
}
std::string hotkey::get_title()
{
return title;
}
void hotkey::update(const std::string& primary, const std::string& secondary)
{
primaryb->SetLabel((primary != "") ? towxstring(primary) : towxstring("(none)"));
secondaryb->SetLabel((secondary != "") ? towxstring(secondary) : towxstring("(none)"));
}
}
std::string wxeditor_keyselect(wxWindow* parent, bool clearable)
{
wxdialog_keyentry* d = new wxdialog_keyentry(parent, "Specify key", "", clearable);
if(d->ShowModal() == wxID_CANCEL) {
d->Destroy();
throw canceled_exception();
}
std::string key = d->getkey();
d->Destroy();
return key;
}
void wxeditor_hotkeys_display(wxWindow* parent)
{
modal_pause_holder hld;
wxdialog_hotkeys* d = new wxdialog_hotkeys(parent);
d->ShowModal();
d->Destroy();
}

179
src/platform/wxwidgets/editor-screen.cpp
View file

@ -1,179 +0,0 @@
#include "platform/wxwidgets/platform.hpp"
#include "library/string.hpp"
#include <wx/wx.h>
#include <wx/event.h>
#include <wx/control.h>
#include <wx/combobox.h>
#include <vector>
#include <string>
#include <boost/lexical_cast.hpp>
#include <sstream>
extern "C"
{
#ifndef UINT64_C
#define UINT64_C(val) val##ULL
#endif
#include <libswscale/swscale.h>
}
const char* algo_choices[] = {"Fast Bilinear", "Bilinear", "Bicubic", "Experimential", "Point", "Area",
"Bicubic-Linear", "Gauss", "Sinc", "Lanczos", "Spline"};
class wxeditor_screen : public wxDialog
{
public:
wxeditor_screen(wxWindow* parent);
~wxeditor_screen();
bool ShouldPreventAppExit() const;
void on_value_change(wxCommandEvent& e);
void on_cancel(wxCommandEvent& e);
void on_ok(wxCommandEvent& e);
private:
wxButton* okbutton;
wxButton* cancel;
wxTextCtrl* horizbox;
wxTextCtrl* vertbox;
wxComboBox* algo;
};
wxeditor_screen::wxeditor_screen(wxWindow* parent)
: wxDialog(parent, wxID_ANY, wxT("lsnes: Screen scaling"), wxDefaultPosition, wxSize(-1, -1))
{
std::set<std::string> axisnames;
std::string h_x, v_x;
int algoidx;
wxString _algo_choices[sizeof(algo_choices) / sizeof(algo_choices[0])];
for(size_t i = 0; i < sizeof(_algo_choices) / sizeof(_algo_choices[0]); i++)
_algo_choices[i] = towxstring(algo_choices[i]);
h_x = (stringfmt() << horizontal_scale_factor).str();
v_x = (stringfmt() << vertical_scale_factor).str();
algoidx = 0;
for(size_t i = 0; i < sizeof(algo_choices) / sizeof(_algo_choices[0]); i++)
if(scaling_flags & (1 << i)) {
algoidx = i;
break;
}
Centre();
wxFlexGridSizer* top_s = new wxFlexGridSizer(2, 1, 0, 0);
SetSizer(top_s);
wxFlexGridSizer* t_s = new wxFlexGridSizer(3, 2, 0, 0);
t_s->Add(new wxStaticText(this, wxID_ANY, wxT("Horizontal factor:")), 0, wxGROW);
t_s->Add(horizbox = new wxTextCtrl(this, wxID_ANY, towxstring(h_x), wxDefaultPosition, wxSize(100, -1)), 1,
wxGROW);
t_s->Add(new wxStaticText(this, wxID_ANY, wxT("Vertical factor:")), 0, wxGROW);
t_s->Add(vertbox = new wxTextCtrl(this, wxID_ANY, towxstring(v_x), wxDefaultPosition, wxSize(100, -1)), 1,
wxGROW);
t_s->Add(new wxStaticText(this, wxID_ANY, wxT("Method:")), 0, wxGROW);
t_s->Add(algo = new wxComboBox(this, wxID_ANY, _algo_choices[algoidx], wxDefaultPosition,
wxDefaultSize, sizeof(_algo_choices) / sizeof(_algo_choices[0]), _algo_choices, wxCB_READONLY), 1,
wxGROW);
top_s->Add(t_s);
horizbox->Connect(wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler(wxeditor_screen::on_value_change), NULL,
this);
vertbox->Connect(wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler(wxeditor_screen::on_value_change), NULL,
this);
algo->Connect(wxEVT_COMMAND_COMBOBOX_SELECTED,
wxCommandEventHandler(wxeditor_screen::on_value_change), NULL, this);
wxBoxSizer* pbutton_s = new wxBoxSizer(wxHORIZONTAL);
pbutton_s->AddStretchSpacer();
pbutton_s->Add(okbutton = new wxButton(this, wxID_OK, wxT("OK")), 0, wxGROW);
pbutton_s->Add(cancel = new wxButton(this, wxID_CANCEL, wxT("Cancel")), 0, wxGROW);
okbutton->Connect(wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(wxeditor_screen::on_ok), NULL, this);
cancel->Connect(wxEVT_COMMAND_BUTTON_CLICKED,
wxCommandEventHandler(wxeditor_screen::on_cancel), NULL, this);
top_s->Add(pbutton_s, 0, wxGROW);
t_s->SetSizeHints(this);
top_s->SetSizeHints(this);
Fit();
}
wxeditor_screen::~wxeditor_screen()
{
}
bool wxeditor_screen::ShouldPreventAppExit() const
{
return false;
}
void wxeditor_screen::on_value_change(wxCommandEvent& e)
{
double hscale;
double vscale;
int newflags = 0;
bool valid = true;
try {
hscale = parse_value<double>(tostdstring(horizbox->GetValue()));
vscale = parse_value<double>(tostdstring(vertbox->GetValue()));
if(hscale < 0.25 || hscale > 10)
throw std::runtime_error("Specified scale out of range");
if(vscale < 0.25 || vscale > 10)
throw std::runtime_error("Specified scale out of range");
std::string a = tostdstring(algo->GetValue());
for(size_t i = 0; i < sizeof(algo_choices) / sizeof(algo_choices[0]); i++)
if(a == algo_choices[i])
newflags = (1 << i);
if(newflags == 0)
throw std::runtime_error("Specified algorithm invalid");
} catch(...) {
valid = false;
}
okbutton->Enable(valid);
}
void wxeditor_screen::on_cancel(wxCommandEvent& e)
{
EndModal(wxID_CANCEL);
}
void wxeditor_screen::on_ok(wxCommandEvent& e)
{
double hscale;
double vscale;
int newflags = 0;
try {
hscale = parse_value<double>(tostdstring(horizbox->GetValue()));
vscale = parse_value<double>(tostdstring(vertbox->GetValue()));
if(hscale < 0.25 || hscale > 10)
throw std::runtime_error("Specified scale out of range");
if(vscale < 0.25 || vscale > 10)
throw std::runtime_error("Specified scale out of range");
std::string a = tostdstring(algo->GetValue());
for(size_t i = 0; i < sizeof(algo_choices) / sizeof(algo_choices[0]); i++)
if(a == algo_choices[i])
newflags = (1 << i);
if(newflags == 0)
throw std::runtime_error("Specified algorithm invalid");
} catch(...) {
return;
}
horizontal_scale_factor = hscale;
vertical_scale_factor = vscale;
scaling_flags = newflags;
EndModal(wxID_OK);
}
void wxeditor_screen_display(wxWindow* parent)
{
modal_pause_holder hld;
wxDialog* editor;
try {
editor = new wxeditor_screen(parent);
editor->ShowModal();
} catch(...) {
}
editor->Destroy();
}

267
src/platform/wxwidgets/editor-settings.cpp
View file

@ -1,267 +0,0 @@
#include "core/command.hpp"
#include "core/dispatch.hpp"
#include "core/mainloop.hpp"
#include "core/misc.hpp"
#include "core/moviefile.hpp"
#include "core/settings.hpp"
#include "core/window.hpp"
#include "platform/wxwidgets/platform.hpp"
#include <fstream>
#include <stdexcept>
#include <vector>
#include <string>
#include <wx/wx.h>
#include <wx/event.h>
#include <wx/control.h>
#include <wx/combobox.h>
class wxeditor_settings_setting : public wxEvtHandler
{
public:
wxeditor_settings_setting(wxSizer* sizer, wxWindow* window, const std::string& name);
void on_clear_click(wxCommandEvent& e);
void on_edit_click(wxCommandEvent& e);
void change_setting(const std::string& setting, const std::string& value);
void clear_setting(const std::string& setting);
private:
std::string a_name;
wxWindow* parent;
wxStaticText* label;
wxButton* clear;
wxButton* edit;
};
class wxeditor_settings;
class wxeditor_settings_listener : public information_dispatch
{
public:
wxeditor_settings_listener(wxeditor_settings* _editor);
~wxeditor_settings_listener() throw();
void on_setting_change(const std::string& setting, const std::string& value);
void on_setting_clear(const std::string& setting);
private:
wxeditor_settings* editor;
};
class wxeditor_settings : public wxDialog
{
public:
wxeditor_settings(wxWindow* parent);
~wxeditor_settings();
bool ShouldPreventAppExit() const;
void on_close(wxCommandEvent& e);
void change_setting(const std::string& setting, const std::string& value);
void clear_setting(const std::string& setting);
private:
wxeditor_settings_listener listener;
std::vector<wxeditor_settings_setting*> esettings;
wxScrolledWindow* scrollwin;
wxButton* close;
};
wxeditor_settings_setting::wxeditor_settings_setting(wxSizer* sizer, wxWindow* window, const std::string& name)
{
a_name = name;
parent = window;
std::string pvalue = "<unknown>";
runemufn([&pvalue, a_name]() {
try {
if(!setting::is_set(a_name))
pvalue = "<unset>";
else
pvalue = setting::get(a_name);
} catch(...) {
}
});
sizer->Add(new wxStaticText(window, wxID_ANY, towxstring(name)), 0, wxGROW);
sizer->Add(label = new wxStaticText(window, wxID_ANY, towxstring(pvalue)), 0, wxGROW);
sizer->Add(edit = new wxButton(window, wxID_ANY, wxT("Edit")), 0, wxGROW);
sizer->Add(clear = new wxButton(window, wxID_ANY, wxT("Clear")), 0, wxGROW);
edit->Connect(wxEVT_COMMAND_BUTTON_CLICKED,
wxCommandEventHandler(wxeditor_settings_setting::on_edit_click), NULL, this);
clear->Connect(wxEVT_COMMAND_BUTTON_CLICKED,
wxCommandEventHandler(wxeditor_settings_setting::on_clear_click), NULL, this);
}
void wxeditor_settings_setting::on_clear_click(wxCommandEvent& e)
{
try {
bool fault = false;;
std::string faulttext;
runemufn([a_name, &fault, &faulttext]() {
try {
setting::blank(a_name);
} catch(std::exception& e) {
fault = true;
faulttext = e.what();
}
});
if(fault) {
wxMessageDialog* d = new wxMessageDialog(parent,
towxstring(std::string("Can't clear setting: ") + faulttext), wxT("Error"), wxOK |
wxICON_EXCLAMATION);
d->ShowModal();
d->Destroy();
}
}catch(std::exception& e) {
wxMessageDialog* d = new wxMessageDialog(parent, towxstring(std::string("Can't clear setting: ") +
e.what()), wxT("Error"), wxOK | wxICON_EXCLAMATION);
d->ShowModal();
d->Destroy();
}
}
void wxeditor_settings_setting::on_edit_click(wxCommandEvent& e)
{
try {
std::string newsetting;
std::string oldvalue = setting::get(a_name);
wxTextEntryDialog* d = new wxTextEntryDialog(parent, towxstring("Enter new value for " + a_name),
wxT("Enter new value for setting"), towxstring(oldvalue));
if(d->ShowModal() == wxID_CANCEL) {
d->Destroy();
return;
}
newsetting = tostdstring(d->GetValue());
bool fault = false;;
std::string faulttext;
runemufn([a_name, newsetting, &fault, &faulttext]() {
try {
setting::set(a_name, newsetting);
} catch(std::exception& e) {
fault = true;
faulttext = e.what();
}
});
if(fault) {
wxMessageDialog* d = new wxMessageDialog(parent,
towxstring(std::string("Can't set setting: ") + faulttext), wxT("Error"), wxOK |
wxICON_EXCLAMATION);
d->ShowModal();
d->Destroy();
}
} catch(std::exception& e) {
wxMessageDialog* d = new wxMessageDialog(parent, towxstring(std::string("Can't set setting: ") +
e.what()), wxT("Error"), wxOK | wxICON_EXCLAMATION);
d->ShowModal();
d->Destroy();
}
}
void wxeditor_settings_setting::change_setting(const std::string& _setting, const std::string& value)
{
runuifun([_setting, label, a_name, value]() {
if(_setting != a_name)
return;
label->SetLabel(towxstring(value));
});
}
void wxeditor_settings_setting::clear_setting(const std::string& _setting)
{
runuifun([_setting, label, a_name]() {
if(_setting != a_name)
return;
label->SetLabel(wxT("<unset>"));
});
}
wxeditor_settings::wxeditor_settings(wxWindow* parent)
: wxDialog(parent, wxID_ANY, wxT("lsnes: Edit settings"), wxDefaultPosition, wxSize(-1, -1)), listener(this)
{
std::set<std::string> settings_set;
runemufn([&settings_set]() { settings_set = setting::get_settings_set(); });
scrollwin = new wxScrolledWindow(this, wxID_ANY, wxDefaultPosition, wxSize(-1, -1), wxVSCROLL);
scrollwin->SetMinSize(wxSize(-1, 500));
Centre();
wxFlexGridSizer* top_s = new wxFlexGridSizer(2, 1, 0, 0);
SetSizer(top_s);
wxFlexGridSizer* t_s = new wxFlexGridSizer(settings_set.size(), 4, 0, 0);
for(auto i : settings_set)
esettings.push_back(new wxeditor_settings_setting(t_s, scrollwin, i));
scrollwin->SetSizer(t_s);
top_s->Add(scrollwin);
scrollwin->SetScrollRate(0, 20);
wxBoxSizer* pbutton_s = new wxBoxSizer(wxHORIZONTAL);
pbutton_s->AddStretchSpacer();
pbutton_s->Add(close = new wxButton(this, wxID_CANCEL, wxT("Close")), 0, wxGROW);
close->Connect(wxEVT_COMMAND_BUTTON_CLICKED,
wxCommandEventHandler(wxeditor_settings::on_close), NULL, this);
top_s->Add(pbutton_s, 0, wxGROW);
t_s->SetSizeHints(this);
top_s->SetSizeHints(this);
t_s->Layout();
top_s->Layout();
Fit();
}
wxeditor_settings::~wxeditor_settings()
{
for(auto i : esettings)
delete i;
}
bool wxeditor_settings::ShouldPreventAppExit() const
{
return false;
}
void wxeditor_settings::on_close(wxCommandEvent& e)
{
EndModal(wxID_OK);
}
void wxeditor_settings::change_setting(const std::string& _setting, const std::string& value)
{
for(auto i : esettings)
i->change_setting(_setting, value);
}
void wxeditor_settings::clear_setting(const std::string& _setting)
{
for(auto i : esettings)
i->clear_setting(_setting);
}
wxeditor_settings_listener::wxeditor_settings_listener(wxeditor_settings* _editor)
: information_dispatch("wxeditor_settings-listener")
{
editor = _editor;
}
wxeditor_settings_listener::~wxeditor_settings_listener() throw()
{
}
void wxeditor_settings_listener::on_setting_change(const std::string& _setting, const std::string& value)
{
editor->change_setting(_setting, value);
}
void wxeditor_settings_listener::on_setting_clear(const std::string& _setting)
{
editor->clear_setting(_setting);
}
void wxeditor_settings_display(wxWindow* parent)
{
modal_pause_holder hld;
wxDialog* editor;
try {
editor = new wxeditor_settings(parent);
editor->ShowModal();
} catch(...) {
}
editor->Destroy();
}

439
src/platform/wxwidgets/keyboard.cpp
View file

@ -33,226 +33,227 @@ namespace
{
int keynum;
const char* name;
const char* clazz;
keygroup* allocated;
} keys[] = {
{ WXK_BACK, "back", NULL },
{ WXK_TAB, "tab", NULL },
{ WXK_RETURN, "return", NULL },
{ WXK_ESCAPE, "escape", NULL },
{ WXK_SPACE, "space", NULL },
{ 33, "exclaim", NULL },
{ 34, "quotedbl", NULL },
{ 35, "hash", NULL },
{ 36, "dollar", NULL },
{ 37, "percent", NULL },
{ 38, "ampersand", NULL },
{ 39, "quote", NULL },
{ 40, "leftparen", NULL },
{ 41, "rightparen", NULL },
{ 42, "asterisk", NULL },
{ 43, "plus", NULL },
{ 44, "comma", NULL },
{ 45, "minus", NULL },
{ 46, "period", NULL },
{ 47, "slash", NULL },
{ 48, "0", NULL },
{ 49, "1", NULL },
{ 50, "2", NULL },
{ 51, "3", NULL },
{ 52, "4", NULL },
{ 53, "5", NULL },
{ 54, "6", NULL },
{ 55, "7", NULL },
{ 56, "8", NULL },
{ 57, "9", NULL },
{ 58, "colon", NULL },
{ 59, "semicolon", NULL },
{ 60, "less", NULL },
{ 61, "equals", NULL },
{ 62, "greater", NULL },
{ 63, "question", NULL },
{ 64, "at", NULL },
{ 65, "a", NULL },
{ 66, "b", NULL },
{ 67, "c", NULL },
{ 68, "d", NULL },
{ 69, "e", NULL },
{ 70, "f", NULL },
{ 71, "g", NULL },
{ 72, "h", NULL },
{ 73, "i", NULL },
{ 74, "j", NULL },
{ 75, "k", NULL },
{ 76, "l", NULL },
{ 77, "m", NULL },
{ 78, "n", NULL },
{ 79, "o", NULL },
{ 80, "p", NULL },
{ 81, "q", NULL },
{ 82, "r", NULL },
{ 83, "s", NULL },
{ 84, "t", NULL },
{ 85, "u", NULL },
{ 86, "v", NULL },
{ 87, "w", NULL },
{ 88, "x", NULL },
{ 89, "y", NULL },
{ 90, "z", NULL },
{ 91, "leftbracket", NULL },
{ 92, "backslash", NULL },
{ 93, "rightbracket", NULL },
{ 94, "caret", NULL },
{ 95, "underscore", NULL },
{ 96, "backquote", NULL },
{ 97, "a", NULL },
{ 98, "b", NULL },
{ 99, "c", NULL },
{ 100, "d", NULL },
{ 101, "e", NULL },
{ 102, "f", NULL },
{ 103, "g", NULL },
{ 104, "h", NULL },
{ 105, "i", NULL },
{ 106, "j", NULL },
{ 107, "k", NULL },
{ 108, "l", NULL },
{ 109, "m", NULL },
{ 110, "n", NULL },
{ 111, "o", NULL },
{ 112, "p", NULL },
{ 113, "q", NULL },
{ 114, "r", NULL },
{ 115, "s", NULL },
{ 116, "t", NULL },
{ 117, "u", NULL },
{ 118, "v", NULL },
{ 119, "w", NULL },
{ 120, "x", NULL },
{ 121, "y", NULL },
{ 122, "z", NULL },
{ 123, "leftcurly", NULL },
{ 124, "pipe", NULL },
{ 125, "rightcurly", NULL },
{ 126, "tilde", NULL },
{ WXK_DELETE, "delete", NULL },
{ WXK_START, "start", NULL },
{ WXK_LBUTTON, "lbutton", NULL },
{ WXK_RBUTTON, "rbutton", NULL },
{ WXK_CANCEL, "cancel", NULL },
{ WXK_MBUTTON, "mbutton", NULL },
{ WXK_CLEAR, "clear", NULL },
{ WXK_SHIFT, "shift", NULL },
{ WXK_ALT, "alt", NULL },
{ WXK_CONTROL, "control", NULL },
{ WXK_MENU, "menu", NULL },
{ WXK_PAUSE, "pause", NULL },
{ WXK_CAPITAL, "capital", NULL },
{ WXK_END, "end", NULL },
{ WXK_HOME, "home", NULL },
{ WXK_LEFT, "lefT", NULL },
{ WXK_UP, "up", NULL },
{ WXK_RIGHT, "right", NULL },
{ WXK_DOWN, "down", NULL },
{ WXK_SELECT, "select", NULL },
{ WXK_PRINT, "print", NULL },
{ WXK_EXECUTE, "execute", NULL },
{ WXK_SNAPSHOT, "snapshot", NULL },
{ WXK_INSERT, "insert", NULL },
{ WXK_HELP, "help", NULL },
{ WXK_NUMPAD0, "numpad0", NULL },
{ WXK_NUMPAD1, "numpad1", NULL },
{ WXK_NUMPAD2, "numpad2", NULL },
{ WXK_NUMPAD3, "numpad3", NULL },
{ WXK_NUMPAD4, "numpad4", NULL },
{ WXK_NUMPAD5, "numpad5", NULL },
{ WXK_NUMPAD6, "numpad6", NULL },
{ WXK_NUMPAD7, "numpad7", NULL },
{ WXK_NUMPAD8, "numpad8", NULL },
{ WXK_NUMPAD9, "numpad9", NULL },
{ WXK_MULTIPLY, "multiply", NULL },
{ WXK_ADD, "add", NULL },
{ WXK_SEPARATOR, "separator", NULL },
{ WXK_SUBTRACT, "subtract", NULL },
{ WXK_DECIMAL, "decimal", NULL },
{ WXK_DIVIDE, "divide", NULL },
{ WXK_F1, "f1", NULL },
{ WXK_F2, "f2", NULL },
{ WXK_F3, "f3", NULL },
{ WXK_F4, "f4", NULL },
{ WXK_F5, "f5", NULL },
{ WXK_F6, "f6", NULL },
{ WXK_F7, "f7", NULL },
{ WXK_F8, "f8", NULL },
{ WXK_F9, "f9", NULL },
{ WXK_F10, "f10", NULL },
{ WXK_F11, "f11", NULL },
{ WXK_F12, "f12", NULL },
{ WXK_F13, "f13", NULL },
{ WXK_F14, "f14", NULL },
{ WXK_F15, "f15", NULL },
{ WXK_F16, "f16", NULL },
{ WXK_F17, "f17", NULL },
{ WXK_F18, "f18", NULL },
{ WXK_F19, "f19", NULL },
{ WXK_F20, "f20", NULL },
{ WXK_F21, "f21", NULL },
{ WXK_F22, "f22", NULL },
{ WXK_F23, "f23", NULL },
{ WXK_F24, "f24", NULL },
{ WXK_NUMLOCK, "numlock", NULL },
{ WXK_SCROLL, "scroll", NULL },
{ WXK_PAGEUP, "pageup", NULL },
{ WXK_PAGEDOWN, "pagedown", NULL },
{ WXK_NUMPAD_SPACE, "numpad_space", NULL },
{ WXK_NUMPAD_TAB, "numpad_tab", NULL },
{ WXK_NUMPAD_ENTER, "numpad_enter", NULL },
{ WXK_NUMPAD_F1, "numpad_f1", NULL },
{ WXK_NUMPAD_F2, "numpad_f2", NULL },
{ WXK_NUMPAD_F3, "numpad_f3", NULL },
{ WXK_NUMPAD_F4, "numpad_f4", NULL },
{ WXK_NUMPAD_HOME, "numpad_home", NULL },
{ WXK_NUMPAD_LEFT, "numpad_left", NULL },
{ WXK_NUMPAD_UP, "numpad_up", NULL },
{ WXK_NUMPAD_RIGHT, "numpad_right", NULL },
{ WXK_NUMPAD_DOWN, "numpad_down", NULL },
{ WXK_NUMPAD_PAGEUP, "numpad_pageup", NULL },
{ WXK_NUMPAD_PAGEDOWN, "numpad_pagedown", NULL },
{ WXK_NUMPAD_END, "numpad_end", NULL },
{ WXK_NUMPAD_BEGIN, "numpad_begin", NULL },
{ WXK_NUMPAD_INSERT, "numpad_insert", NULL },
{ WXK_NUMPAD_DELETE, "numpad_delete", NULL },
{ WXK_NUMPAD_EQUAL, "numpad_equal", NULL },
{ WXK_NUMPAD_MULTIPLY, "numpad_multiply", NULL },
{ WXK_NUMPAD_ADD, "numpad_add", NULL },
{ WXK_NUMPAD_SEPARATOR, "numpad_separator", NULL },
{ WXK_NUMPAD_SUBTRACT, "numpad_subtract", NULL },
{ WXK_NUMPAD_DECIMAL, "numpad_decimal", NULL },
{ WXK_NUMPAD_DIVIDE, "numpad_divide", NULL },
{ WXK_WINDOWS_LEFT, "windows_left", NULL },
{ WXK_WINDOWS_RIGHT, "windows_right", NULL },
{ WXK_WINDOWS_MENU, "windows_menu", NULL },
{ WXK_COMMAND, "command", NULL },
{ WXK_SPECIAL1, "special1", NULL },
{ WXK_SPECIAL2, "special2", NULL },
{ WXK_SPECIAL3, "special3", NULL },
{ WXK_SPECIAL4, "special4", NULL },
{ WXK_SPECIAL5, "special5", NULL },
{ WXK_SPECIAL6, "special6", NULL },
{ WXK_SPECIAL7, "special7", NULL },
{ WXK_SPECIAL8, "special8", NULL },
{ WXK_SPECIAL9, "special9", NULL },
{ WXK_SPECIAL10, "special10", NULL },
{ WXK_SPECIAL11, "special11", NULL },
{ WXK_SPECIAL12, "special12", NULL },
{ WXK_SPECIAL13, "special13", NULL },
{ WXK_SPECIAL14, "special14", NULL },
{ WXK_SPECIAL15, "special15", NULL },
{ WXK_SPECIAL16, "special16", NULL },
{ WXK_SPECIAL17, "special17", NULL },
{ WXK_SPECIAL18, "special18", NULL },
{ WXK_SPECIAL19, "special19", NULL },
{ WXK_SPECIAL20, "special20", NULL },
{ 0, NULL, NULL }
{ WXK_BACK, "back", "editing", NULL },
{ WXK_TAB, "tab", "editing", NULL },
{ WXK_RETURN, "return", "editing", NULL },
{ WXK_ESCAPE, "escape", "editing", NULL },
{ WXK_SPACE, "space", "characters", NULL },
{ 33, "exclaim", "characters", NULL },
{ 34, "quotedbl", "characters", NULL },
{ 35, "hash", "characters", NULL },
{ 36, "dollar", "characters", NULL },
{ 37, "percent", "characters", NULL },
{ 38, "ampersand", "characters", NULL },
{ 39, "quote", "characters", NULL },
{ 40, "leftparen", "characters", NULL },
{ 41, "rightparen", "characters", NULL },
{ 42, "asterisk", "characters", NULL },
{ 43, "plus", "characters", NULL },
{ 44, "comma", "characters", NULL },
{ 45, "minus", "characters", NULL },
{ 46, "period", "characters", NULL },
{ 47, "slash", "characters", NULL },
{ 48, "0", "numeric", NULL },
{ 49, "1", "numeric", NULL },
{ 50, "2", "numeric", NULL },
{ 51, "3", "numeric", NULL },
{ 52, "4", "numeric", NULL },
{ 53, "5", "numeric", NULL },
{ 54, "6", "numeric", NULL },
{ 55, "7", "numeric", NULL },
{ 56, "8", "numeric", NULL },
{ 57, "9", "numeric", NULL },
{ 58, "colon", "characters", NULL },
{ 59, "semicolon", "characters", NULL },
{ 60, "less", "characters", NULL },
{ 61, "equals", "characters", NULL },
{ 62, "greater", "characters", NULL },
{ 63, "question", "characters", NULL },
{ 64, "at", "characters", NULL },
{ 65, "a", "alphabetic", NULL },
{ 66, "b", "alphabetic", NULL },
{ 67, "c", "alphabetic", NULL },
{ 68, "d", "alphabetic", NULL },
{ 69, "e", "alphabetic", NULL },
{ 70, "f", "alphabetic", NULL },
{ 71, "g", "alphabetic", NULL },
{ 72, "h", "alphabetic", NULL },
{ 73, "i", "alphabetic", NULL },
{ 74, "j", "alphabetic", NULL },
{ 75, "k", "alphabetic", NULL },
{ 76, "l", "alphabetic", NULL },
{ 77, "m", "alphabetic", NULL },
{ 78, "n", "alphabetic", NULL },
{ 79, "o", "alphabetic", NULL },
{ 80, "p", "alphabetic", NULL },
{ 81, "q", "alphabetic", NULL },
{ 82, "r", "alphabetic", NULL },
{ 83, "s", "alphabetic", NULL },
{ 84, "t", "alphabetic", NULL },
{ 85, "u", "alphabetic", NULL },
{ 86, "v", "alphabetic", NULL },
{ 87, "w", "alphabetic", NULL },
{ 88, "x", "alphabetic", NULL },
{ 89, "y", "alphabetic", NULL },
{ 90, "z", "alphabetic", NULL },
{ 91, "leftbracket", "characters", NULL },
{ 92, "backslash", "characters", NULL },
{ 93, "rightbracket", "characters", NULL },
{ 94, "caret", "characters", NULL },
{ 95, "underscore", "characters", NULL },
{ 96, "backquote", "characters", NULL },
{ 97, "a", "alphabetic", NULL },
{ 98, "b", "alphabetic", NULL },
{ 99, "c", "alphabetic", NULL },
{ 100, "d", "alphabetic", NULL },
{ 101, "e", "alphabetic", NULL },
{ 102, "f", "alphabetic", NULL },
{ 103, "g", "alphabetic", NULL },
{ 104, "h", "alphabetic", NULL },
{ 105, "i", "alphabetic", NULL },
{ 106, "j", "alphabetic", NULL },
{ 107, "k", "alphabetic", NULL },
{ 108, "l", "alphabetic", NULL },
{ 109, "m", "alphabetic", NULL },
{ 110, "n", "alphabetic", NULL },
{ 111, "o", "alphabetic", NULL },
{ 112, "p", "alphabetic", NULL },
{ 113, "q", "alphabetic", NULL },
{ 114, "r", "alphabetic", NULL },
{ 115, "s", "alphabetic", NULL },
{ 116, "t", "alphabetic", NULL },
{ 117, "u", "alphabetic", NULL },
{ 118, "v", "alphabetic", NULL },
{ 119, "w", "alphabetic", NULL },
{ 120, "x", "alphabetic", NULL },
{ 121, "y", "alphabetic", NULL },
{ 122, "z", "alphabetic", NULL },
{ 123, "leftcurly", "characters", NULL },
{ 124, "pipe", "characters", NULL },
{ 125, "rightcurly", "characters", NULL },
{ 126, "tilde", "characters", NULL },
{ WXK_DELETE, "delete", "editing", NULL },
{ WXK_START, "start", "special", NULL },
{ WXK_LBUTTON, "lbutton", "special", NULL },
{ WXK_RBUTTON, "rbutton", "special", NULL },
{ WXK_CANCEL, "cancel", "special", NULL },
{ WXK_MBUTTON, "mbutton", "special", NULL },
{ WXK_CLEAR, "clear", "editing", NULL },
{ WXK_SHIFT, "shift", "modifiers", NULL },
{ WXK_ALT, "alt", "modifiers", NULL },
{ WXK_CONTROL, "control", "modifiers", NULL },
{ WXK_MENU, "menu", "special", NULL },
{ WXK_PAUSE, "pause", "special", NULL },
{ WXK_CAPITAL, "capital", "locks", NULL },
{ WXK_END, "end", "editing", NULL },
{ WXK_HOME, "home", "editing", NULL },
{ WXK_LEFT, "lefT", "editing", NULL },
{ WXK_UP, "up", "editing", NULL },
{ WXK_RIGHT, "right", "editing", NULL },
{ WXK_DOWN, "down", "editing", NULL },
{ WXK_SELECT, "select", "special", NULL },
{ WXK_PRINT, "print", "special", NULL },
{ WXK_EXECUTE, "execute", "special", NULL },
{ WXK_SNAPSHOT, "snapshot", "special", NULL },
{ WXK_INSERT, "insert", "editing", NULL },
{ WXK_HELP, "help", "special", NULL },
{ WXK_NUMPAD0, "numpad0", "numeric", NULL },
{ WXK_NUMPAD1, "numpad1", "numeric", NULL },
{ WXK_NUMPAD2, "numpad2", "numeric", NULL },
{ WXK_NUMPAD3, "numpad3", "numeric", NULL },
{ WXK_NUMPAD4, "numpad4", "numeric", NULL },
{ WXK_NUMPAD5, "numpad5", "numeric", NULL },
{ WXK_NUMPAD6, "numpad6", "numeric", NULL },
{ WXK_NUMPAD7, "numpad7", "numeric", NULL },
{ WXK_NUMPAD8, "numpad8", "numeric", NULL },
{ WXK_NUMPAD9, "numpad9", "numeric", NULL },
{ WXK_MULTIPLY, "multiply", "characters", NULL },
{ WXK_ADD, "add", "characters", NULL },
{ WXK_SEPARATOR, "separator", "characters", NULL },
{ WXK_SUBTRACT, "subtract", "characters", NULL },
{ WXK_DECIMAL, "decimal", "characters", NULL },
{ WXK_DIVIDE, "divide", "characters", NULL },
{ WXK_F1, "f1", "F-keys", NULL },
{ WXK_F2, "f2", "F-keys", NULL },
{ WXK_F3, "f3", "F-keys", NULL },
{ WXK_F4, "f4", "F-keys", NULL },
{ WXK_F5, "f5", "F-keys", NULL },
{ WXK_F6, "f6", "F-keys", NULL },
{ WXK_F7, "f7", "F-keys", NULL },
{ WXK_F8, "f8", "F-keys", NULL },
{ WXK_F9, "f9", "F-keys", NULL },
{ WXK_F10, "f10", "F-keys", NULL },
{ WXK_F11, "f11", "F-keys", NULL },
{ WXK_F12, "f12", "F-keys", NULL },
{ WXK_F13, "f13", "F-keys", NULL },
{ WXK_F14, "f14", "F-keys", NULL },
{ WXK_F15, "f15", "F-keys", NULL },
{ WXK_F16, "f16", "F-keys", NULL },
{ WXK_F17, "f17", "F-keys", NULL },
{ WXK_F18, "f18", "F-keys", NULL },
{ WXK_F19, "f19", "F-keys", NULL },
{ WXK_F20, "f20", "F-keys", NULL },
{ WXK_F21, "f21", "F-keys", NULL },
{ WXK_F22, "f22", "F-keys", NULL },
{ WXK_F23, "f23", "F-keys", NULL },
{ WXK_F24, "f24", "F-keys", NULL },
{ WXK_NUMLOCK, "numlock", "locks", NULL },
{ WXK_SCROLL, "scroll", "locks", NULL },
{ WXK_PAGEUP, "pageup", "editing", NULL },
{ WXK_PAGEDOWN, "pagedown", "editing", NULL },
{ WXK_NUMPAD_SPACE, "numpad_space", "editing", NULL },
{ WXK_NUMPAD_TAB, "numpad_tab", "editing", NULL },
{ WXK_NUMPAD_ENTER, "numpad_enter", "editing", NULL },
{ WXK_NUMPAD_F1, "numpad_f1", "F-keys", NULL },
{ WXK_NUMPAD_F2, "numpad_f2", "F-keys", NULL },
{ WXK_NUMPAD_F3, "numpad_f3", "F-keys", NULL },
{ WXK_NUMPAD_F4, "numpad_f4", "F-keys", NULL },
{ WXK_NUMPAD_HOME, "numpad_home", "editing", NULL },
{ WXK_NUMPAD_LEFT, "numpad_left", "editing", NULL },
{ WXK_NUMPAD_UP, "numpad_up", "editing", NULL },
{ WXK_NUMPAD_RIGHT, "numpad_right", "editing", NULL },
{ WXK_NUMPAD_DOWN, "numpad_down", "editing", NULL },
{ WXK_NUMPAD_PAGEUP, "numpad_pageup", "editing", NULL },
{ WXK_NUMPAD_PAGEDOWN, "numpad_pagedown", "editing", NULL },
{ WXK_NUMPAD_END, "numpad_end", "editing", NULL },
{ WXK_NUMPAD_BEGIN, "numpad_begin", "editing", NULL },
{ WXK_NUMPAD_INSERT, "numpad_insert", "editing", NULL },
{ WXK_NUMPAD_DELETE, "numpad_delete", "editing", NULL },
{ WXK_NUMPAD_EQUAL, "numpad_equal", "characters", NULL },
{ WXK_NUMPAD_MULTIPLY, "numpad_multiply", "characters", NULL },
{ WXK_NUMPAD_ADD, "numpad_add", "characters", NULL },
{ WXK_NUMPAD_SEPARATOR, "numpad_separator", "characters", NULL },
{ WXK_NUMPAD_SUBTRACT, "numpad_subtract", "characters", NULL },
{ WXK_NUMPAD_DECIMAL, "numpad_decimal", "characters", NULL },
{ WXK_NUMPAD_DIVIDE, "numpad_divide", "characters", NULL },
{ WXK_WINDOWS_LEFT, "windows_left", "modifiers", NULL },
{ WXK_WINDOWS_RIGHT, "windows_right", "modifiers", NULL },
{ WXK_WINDOWS_MENU, "windows_menu", "modifiers", NULL },
{ WXK_COMMAND, "command", "special", NULL },
{ WXK_SPECIAL1, "special1", "special", NULL },
{ WXK_SPECIAL2, "special2", "special", NULL },
{ WXK_SPECIAL3, "special3", "special", NULL },
{ WXK_SPECIAL4, "special4", "special", NULL },
{ WXK_SPECIAL5, "special5", "special", NULL },
{ WXK_SPECIAL6, "special6", "special", NULL },
{ WXK_SPECIAL7, "special7", "special", NULL },
{ WXK_SPECIAL8, "special8", "special", NULL },
{ WXK_SPECIAL9, "special9", "special", NULL },
{ WXK_SPECIAL10, "special10", "special", NULL },
{ WXK_SPECIAL11, "special11", "special", NULL },
{ WXK_SPECIAL12, "special12", "special", NULL },
{ WXK_SPECIAL13, "special13", "special", NULL },
{ WXK_SPECIAL14, "special14", "special", NULL },
{ WXK_SPECIAL15, "special15", "special", NULL },
{ WXK_SPECIAL16, "special16", "special", NULL },
{ WXK_SPECIAL17, "special17", "special", NULL },
{ WXK_SPECIAL18, "special18", "special", NULL },
{ WXK_SPECIAL19, "special19", "special", NULL },
{ WXK_SPECIAL20, "special20", "special", NULL },
{ 0, NULL, NULL, NULL }
};
std::map<int, modifier*> modifier_map;
@ -333,7 +334,7 @@ void initialize_wx_keyboard()
key_entry* k = keys;
while(k->name) {
if(!keys_allocated.count(k->name)) {
k->allocated = new keygroup(k->name, keygroup::KT_KEY);
k->allocated = new keygroup(k->name, k->clazz, keygroup::KT_KEY);
key_map[k->keynum] = k->allocated;
keys_allocated[k->name] = k->keynum;
} else

3
src/platform/wxwidgets/main.cpp
View file

@ -165,9 +165,6 @@ end:
{
std::string cfg = get_config_path() + "/lsneswxw.rc";
std::ofstream cfgfile(cfg.c_str());
//Jukebox.
for(auto i : get_jukebox_names())
cfgfile << "add-jukebox-save " << i << std::endl;
//Joystick axis.
for(auto i : keygroup::get_axis_set()) {
keygroup* k = keygroup::lookup_by_name(i);

155
src/platform/wxwidgets/mainwindow.cpp
View file

@ -64,23 +64,17 @@ enum
wxID_EDIT_AUTHORS,
wxID_AUTOHOLD_FIRST,
wxID_AUTOHOLD_LAST = wxID_AUTOHOLD_FIRST + 1023,
wxID_EDIT_SETTINGS,
wxID_EDIT_KEYBINDINGS,
wxID_EDIT_ALIAS,
wxID_EDIT_MEMORYWATCH,
wxID_SAVE_MEMORYWATCH,
wxID_LOAD_MEMORYWATCH,
wxID_DUMP_FIRST,
wxID_DUMP_LAST = wxID_DUMP_FIRST + 1023,
wxID_REWIND_MOVIE,
wxID_EDIT_JUKEBOX,
wxID_MEMORY_SEARCH,
wxID_CANCEL_SAVES,
wxID_EDIT_HOTKEYS,
wxID_SHOW_STATUS,
wxID_SET_SPEED,
wxID_SET_VOLUME,
wxID_SET_SCREEN,
wxID_SPEED_5,
wxID_SPEED_10,
wxID_SPEED_17,
@ -149,12 +143,12 @@ namespace
emulation_thread->join();
}
keygroup mouse_x("mouse_x", keygroup::KT_MOUSE);
keygroup mouse_y("mouse_y", keygroup::KT_MOUSE);
keygroup mouse_l("mouse_left", keygroup::KT_KEY);
keygroup mouse_m("mouse_center", keygroup::KT_KEY);
keygroup mouse_r("mouse_right", keygroup::KT_KEY);
keygroup mouse_i("mouse_inwindow", keygroup::KT_KEY);
keygroup mouse_x("mouse_x", "mouse", keygroup::KT_MOUSE);
keygroup mouse_y("mouse_y", "mouse", keygroup::KT_MOUSE);
keygroup mouse_l("mouse_left", "mouse", keygroup::KT_KEY);
keygroup mouse_m("mouse_center", "mouse", keygroup::KT_KEY);
keygroup mouse_r("mouse_right", "mouse", keygroup::KT_KEY);
keygroup mouse_i("mouse_inwindow", "mouse", keygroup::KT_KEY);
void handle_wx_mouse(wxMouseEvent& e)
{
@ -449,44 +443,7 @@ namespace
runuifun([ahmenu]() { ahmenu->reconfigure(); });
}
class movie_path_setting : public setting
{
public:
movie_path_setting() : setting("moviepath") { _moviepath = "."; default_movie = true; }
void blank() throw(std::bad_alloc, std::runtime_error)
{
_moviepath = ".";
default_movie = true;
}
bool is_set() throw()
{
return !default_movie;
}
void set(const std::string& value) throw(std::bad_alloc, std::runtime_error)
{
if(value != "") {
_moviepath = value;
default_movie = false;
} else
blank();
}
std::string get() throw(std::bad_alloc)
{
return _moviepath;
}
operator std::string() throw(std::bad_alloc)
{
return _moviepath;
}
private:
std::string _moviepath;
bool default_movie;
} moviepath_setting;
path_setting moviepath_setting("moviepath");
std::string movie_path()
{
@ -768,15 +725,6 @@ wxwin_mainwindow::wxwin_mainwindow()
menu_special(wxT("Capture"), reinterpret_cast<dumper_menu*>(dmenu = new dumper_menu(this,
wxID_DUMP_FIRST, wxID_DUMP_LAST)));
menu_start(wxT("Settings"));
menu_entry(wxID_EDIT_SETTINGS, wxT("Configure settings..."));
menu_entry(wxID_EDIT_KEYBINDINGS, wxT("Configure keybindings..."));
menu_entry(wxID_EDIT_ALIAS, wxT("Configure aliases..."));
menu_entry(wxID_EDIT_JUKEBOX, wxT("Configure jukebox..."));
menu_separator();
menu_entry(wxID_SET_SCREEN, wxT("Set screen scaling..."));
menu_entry(wxID_EDIT_HOTKEYS, wxT("Configure hotkeys..."));
}
void wxwin_mainwindow::request_paint()
@ -919,92 +867,6 @@ void wxwin_mainwindow::handle_menu_click_cancelable(wxCommandEvent& e)
case wxID_EDIT_AUTHORS:
wxeditor_authors_display(this);
return;
case wxID_EDIT_SETTINGS:
wxeditor_settings_display(this);
return;
case wxID_EDIT_HOTKEYS:
wxeditor_hotkeys_display(this);
return;
case wxID_EDIT_KEYBINDINGS: {
modal_pause_holder hld;
std::set<std::string> bind;
runemufn([&bind]() { bind = keymapper::get_bindings(); });
std::vector<std::string> choices;
choices.push_back(NEW_KEYBINDING);
for(auto i : bind)
choices.push_back(i);
std::string key = pick_among(this, "Select binding", "Select keybinding to edit", choices);
if(key == NEW_KEYBINDING)
key = wxeditor_keyselect(this, false);
std::string old_command_value;
runemufn([&old_command_value, key]() { old_command_value = keymapper::get_command_for(key); });
std::string newcommand = pick_text(this, "Edit binding", "Enter new command for binding:",
old_command_value);
bool fault = false;
std::string faulttext;
runemufn([&fault, &faulttext, key, newcommand]() {
try {
keymapper::bind_for(key, newcommand);
} catch(std::exception& e) {
fault = true;
faulttext = e.what();
}
});
if(fault)
show_message_ok(this, "Error", "Can't bind key: " + faulttext, wxICON_EXCLAMATION);
return;
}
case wxID_EDIT_ALIAS: {
modal_pause_holder hld;
std::set<std::string> bind;
runemufn([&bind]() { bind = command::get_aliases(); });
std::vector<std::string> choices;
choices.push_back(NEW_ALIAS);
for(auto i : bind)
choices.push_back(i);
std::string alias = pick_among(this, "Select alias", "Select alias to edit", choices);
if(alias == NEW_ALIAS) {
alias = pick_text(this, "Enter alias name", "Enter name for the new alias:");
if(!command::valid_alias_name(alias)) {
show_message_ok(this, "Error", "Not a valid alias name: " + alias,
wxICON_EXCLAMATION);
throw canceled_exception();
}
}
std::string old_alias_value;
runemufn([alias, &old_alias_value]() { old_alias_value = command::get_alias_for(alias); });
std::string newcmd = pick_text(this, "Edit alias", "Enter new commands for alias:",
old_alias_value, true);
runemufn([alias, newcmd]() { command::set_alias_for(alias, newcmd); });
return;
}
case wxID_EDIT_JUKEBOX: {
modal_pause_holder hld;
std::vector<std::string> new_jukebox;
std::string x;
runemufn([&x]() {
for(auto i : get_jukebox_names())
x = x + i + "\n";
});
x = pick_text(this, "Configure jukebox", "List jukebox entries", x, true);
while(x != "") {
size_t split = x.find_first_of("\n");
std::string l;
if(split < x.length()) {
l = x.substr(0, split);
x = x.substr(split + 1);
} else {
l = x;
x = "";
}
istrip_CR(l);
if(l != "")
new_jukebox.push_back(l);
}
runemufn([&new_jukebox]() { set_jukebox_names(new_jukebox); });
notify_update_status();
return;
}
case wxID_EDIT_MEMORYWATCH: {
modal_pause_holder hld;
std::set<std::string> bind;
@ -1124,9 +986,6 @@ void wxwin_mainwindow::handle_menu_click_cancelable(wxCommandEvent& e)
runemufn([parsed]() { platform::global_volume = parsed; });
return;
}
case wxID_SET_SCREEN:
wxeditor_screen_display(this);
return;
case wxID_SPEED_5:
set_speed(5);
break;

40
src/platform/wxwidgets/romselect.cpp
View file

@ -247,48 +247,12 @@ namespace
wxTextCtrl* ctrl;
};
class rom_path_setting : public setting
{
public:
rom_path_setting() : setting("rompath") { _rompath = "."; default_rom = true; }
void blank() throw(std::bad_alloc, std::runtime_error)
{
_rompath = ".";
default_rom = true;
}
bool is_set() throw()
{
return !default_rom;
}
void set(const std::string& value) throw(std::bad_alloc, std::runtime_error)
{
if(value != "") {
_rompath = value;
default_rom = false;
} else
blank();
}
std::string get() throw(std::bad_alloc)
{
return _rompath;
}
operator std::string() throw(std::bad_alloc)
{
return _rompath;
}
private:
std::string _rompath;
bool default_rom;
} rompath_setting;
path_setting rompath_setting("rompath");
std::string rom_path()
{
//This is pre-boot, so read directly.
return setting::get("rompath");
return rompath_setting;
}
}

1072
src/platform/wxwidgets/settings.cpp
View file

File diff suppressed because it is too large Load diff

2
src/video/avi/codec/video/cscd.cpp
View file

@ -11,7 +11,7 @@
namespace
{
numeric_setting clvl("avi-cscd-compression", 0, 9, 7);
numeric_setting kint("avi-cscd-keyint", 1, 999999999, 0);
numeric_setting kint("avi-cscd-keyint", 0, 999999999, 0);
struct avi_codec_cscd : public avi_video_codec
{

2
src/video/avi/codec/video/tscc.cpp
View file

@ -15,7 +15,7 @@ const void* check;
namespace
{
numeric_setting clvl("avi-tscc-compression", 0, 9, 7);
numeric_setting kint("avi-tscc-keyint", 1, 999999999, 0);
numeric_setting kint("avi-tscc-keyint", 0, 999999999, 0);
struct msrle_compressor
{