From b497bd7ed6b918366a108298058a598c33bee983 Mon Sep 17 00:00:00 2001
From: Ilari Liusvaara <ilari.liusvaara@elisanet.fi>
Date: Sat, 5 Nov 2011 20:46:18 +0200
Subject: [PATCH] Wxwidgets graphics plugin

As opposed to SDL graphics plugin, this has full GUI.
---
 Makefile                                         |   10 +-
 generic/coroutine.cpp                            |  141 ++
 generic/coroutine.hpp                            |   59 +
 manual.lyx                                       |  108 +-
 platform/wxwidgets/main-wxwidgets.cpp            |   71 +
 platform/wxwidgets/src/authorseditor.cpp         |   81 ++
 platform/wxwidgets/src/authorseditor.hpp         |   24 +
 platform/wxwidgets/src/axeseditor.cpp            |  222 +++
 platform/wxwidgets/src/axeseditor.hpp            |   41 +
 platform/wxwidgets/src/callrom.cpp               |  195 +++
 platform/wxwidgets/src/callrom.hpp               |   26 +
 platform/wxwidgets/src/common.cpp                |   17 +
 platform/wxwidgets/src/common.hpp                |   45 +
 platform/wxwidgets/src/emufn.cpp                 | 1604 ++++++++++++++++++++++
 platform/wxwidgets/src/emufn.hpp                 |   10 +
 platform/wxwidgets/src/filenamebox.cpp           |  138 ++
 platform/wxwidgets/src/filenamebox.hpp           |   44 +
 platform/wxwidgets/src/keyentry.cpp              |  148 ++
 platform/wxwidgets/src/keyentry.hpp              |   35 +
 platform/wxwidgets/src/labelcombobox.cpp         |   48 +
 platform/wxwidgets/src/labelcombobox.hpp         |   31 +
 platform/wxwidgets/src/messages_window.cpp       |  143 ++
 platform/wxwidgets/src/messages_window.hpp       |   30 +
 platform/wxwidgets/src/project_select_window.cpp |  252 ++++
 platform/wxwidgets/src/project_select_window.hpp |   43 +
 platform/wxwidgets/src/rom_patch_window.cpp      |  159 +++
 platform/wxwidgets/src/rom_patch_window.hpp      |   31 +
 platform/wxwidgets/src/rom_select_window.cpp     |  139 ++
 platform/wxwidgets/src/rom_select_window.hpp     |   37 +
 platform/wxwidgets/src/settingseditor.cpp        |  147 ++
 platform/wxwidgets/src/settingseditor.hpp        |   56 +
 platform/wxwidgets/src/status_window.cpp         |   75 +
 platform/wxwidgets/src/status_window.hpp         |   24 +
 33 files changed, 4184 insertions(+), 50 deletions(-)
 create mode 100644 generic/coroutine.cpp
 create mode 100644 generic/coroutine.hpp
 create mode 100644 platform/wxwidgets/main-wxwidgets.cpp
 create mode 100644 platform/wxwidgets/src/authorseditor.cpp
 create mode 100644 platform/wxwidgets/src/authorseditor.hpp
 create mode 100644 platform/wxwidgets/src/axeseditor.cpp
 create mode 100644 platform/wxwidgets/src/axeseditor.hpp
 create mode 100644 platform/wxwidgets/src/callrom.cpp
 create mode 100644 platform/wxwidgets/src/callrom.hpp
 create mode 100644 platform/wxwidgets/src/common.cpp
 create mode 100644 platform/wxwidgets/src/common.hpp
 create mode 100644 platform/wxwidgets/src/emufn.cpp
 create mode 100644 platform/wxwidgets/src/emufn.hpp
 create mode 100644 platform/wxwidgets/src/filenamebox.cpp
 create mode 100644 platform/wxwidgets/src/filenamebox.hpp
 create mode 100644 platform/wxwidgets/src/keyentry.cpp
 create mode 100644 platform/wxwidgets/src/keyentry.hpp
 create mode 100644 platform/wxwidgets/src/labelcombobox.cpp
 create mode 100644 platform/wxwidgets/src/labelcombobox.hpp
 create mode 100644 platform/wxwidgets/src/messages_window.cpp
 create mode 100644 platform/wxwidgets/src/messages_window.hpp
 create mode 100644 platform/wxwidgets/src/project_select_window.cpp
 create mode 100644 platform/wxwidgets/src/project_select_window.hpp
 create mode 100644 platform/wxwidgets/src/rom_patch_window.cpp
 create mode 100644 platform/wxwidgets/src/rom_patch_window.hpp
 create mode 100644 platform/wxwidgets/src/rom_select_window.cpp
 create mode 100644 platform/wxwidgets/src/rom_select_window.hpp
 create mode 100644 platform/wxwidgets/src/settingseditor.cpp
 create mode 100644 platform/wxwidgets/src/settingseditor.hpp
 create mode 100644 platform/wxwidgets/src/status_window.cpp
 create mode 100644 platform/wxwidgets/src/status_window.hpp

diff --git a/Makefile b/Makefile
index 15dd7bc4..f5e70021 100644
--- a/Makefile
+++ b/Makefile
@@ -104,8 +104,16 @@ endif
 platform/SDL/%.$(OBJECT_SUFFIX): platform/SDL/%.cpp
 	$(REALCC) -I. -Igeneric -g -std=gnu++0x -I$(BSNES_PATH) -c -o $@ $< $(CFLAGS) $(PLATFORM_CFLAGS)
 else
+ifeq ($(GRAPHICS), WXWIDGETS)
+PLATFORM_OBJECTS += platform/wxwidgets/main-wxwidgets.$(OBJECT_SUFFIX) $(patsubst %.cpp,%.$(OBJECT_SUFFIX),$(wildcard platform/wxwidgets/src/*.cpp))
+PLATFORM_CFLAGS += $(shell $(CROSS_PREFIX)wx-config --cxxflags) $(shell $(CROSS_PREFIX)pkg-config libswscale --cflags)
+PLATFORM_LDFLAGS += $(shell $(CROSS_PREFIX)wx-config --libs) $(shell $(CROSS_PREFIX)pkg-config libswscale --libs)
+platform/wxwidgets/%.$(OBJECT_SUFFIX): platform/wxwidgets/%.cpp
+	$(REALCC) -I. -Igeneric -g -std=gnu++0x -I$(BSNES_PATH) -c -o $@ $< $(CFLAGS) $(PLATFORM_CFLAGS)
+else
 $(error "Unsupported graphics type")
 endif
+endif
 
 .PRECIOUS: %.$(EXECUTABLE_SUFFIX) %.$(OBJECT_SUFFIX)
 
@@ -129,4 +137,4 @@ fonts/parsehexfont.$(EXECUTABLE_SUFFIX): fonts/parsehexfont.cpp
 	$(HOSTCC) -std=gnu++0x $(HOSTCCFLAGS) -o $@ $^
 
 clean:
-	rm -f $(PROGRAMS) $(patsubst %.$(EXECUTABLE_SUFFIX),%.$(OBJECT_SUFFIX),$(PROGRAMS)) platform/*/*.$(OBJECT_SUFFIX) avidump/*.$(OBJECT_SUFFIX) generic/*.$(OBJECT_SUFFIX) lua/*.$(OBJECT_SUFFIX) fonts/font.o fonts/font.cpp
+	rm -f $(PROGRAMS) $(patsubst %.$(EXECUTABLE_SUFFIX),%.$(OBJECT_SUFFIX),$(PROGRAMS)) platform/*/*.$(OBJECT_SUFFIX) platform/*/src/*.$(OBJECT_SUFFIX) avidump/*.$(OBJECT_SUFFIX) generic/*.$(OBJECT_SUFFIX) lua/*.$(OBJECT_SUFFIX) fonts/font.o fonts/font.cpp
diff --git a/generic/coroutine.cpp b/generic/coroutine.cpp
new file mode 100644
index 00000000..0ad36985
--- /dev/null
+++ b/generic/coroutine.cpp
@@ -0,0 +1,141 @@
+#include "coroutine.hpp"
+#include <iostream>
+#include <cstdlib>
+#include <cstdio>
+#include <vector>
+namespace
+{
+#if defined(__amd64__)
+void trampoline_fn(void (*fn)(void* arg), void* arg) __attribute__((sysv_abi));
+#else
+#if defined(__i386__)
+void trampoline_fn(void (*fn)(void* arg), void* arg) __attribute__((stdcall));
+#else
+#error "This CPU is not supported"
+#endif
+#endif
+	void trampoline_fn(void (*fn)(void* arg), void* arg)
+	{
+		fn(arg);
+		coroutine::cexit();
+	}
+
+#ifdef __amd64__
+bool stacks_grow_down = true;
+void switch_stacks(void (*fn)(void* arg), void* arg, void* new_esp)
+{
+	__asm__ __volatile__("movq %%rax,%%rsp; call *%%rdx" :: "D"(fn), "S"(arg), "a"(new_esp), "d"(trampoline_fn));
+}
+#else
+#ifdef __i386__
+bool stacks_grow_down = true;
+void switch_stacks(void (*fn)(void* arg), void* arg, void* new_esp)
+{
+	__asm__ __volatile__("movl %%eax,%%esp; pushl %%esi; push %%edi ; call *%%edx" :: "D"(fn), "S"(arg),
+		"a"(new_esp), "d"(trampoline_fn));
+}
+#else
+#error "This CPU is not supported"
+#endif
+#endif
+	jmp_buf main_saved_env;
+	coroutine* executing_coroutine = NULL;
+}
+
+coroutine::coroutine(void (*fn)(void* arg), void* arg, size_t stacksize)
+{
+	dead = false;
+	if(executing_coroutine) {
+		std::cerr << "FATAL: Coroutine create only allowed from main coroutine!" << std::endl;
+		exit(1);
+	}
+	executing_coroutine = this;
+	if(setjmp(main_saved_env)) {
+		executing_coroutine = NULL;
+		return;
+	}
+	stackblock = new unsigned char[stacksize];
+	unsigned char* esp = stackblock;
+	if(stacks_grow_down)
+		esp = esp + stacksize;
+	switch_stacks(fn, arg, esp);
+}
+
+coroutine::~coroutine() throw()
+{
+	if(!dead) {
+		std::cerr << "FATAL: Trying to delete a live coroutine!" << std::endl;
+		exit(1);
+	}
+	delete[] stackblock;
+}
+
+void coroutine::resume()
+{
+	if(executing_coroutine) {
+		std::cerr << "FATAL: Coroutine resume only allowed from main coroutine!" << std::endl;
+		exit(1);
+	}
+	if(dead)
+		return;
+	executing_coroutine = this;
+	if(setjmp(main_saved_env)) {
+		executing_coroutine = NULL;
+		return;
+	}
+	longjmp(saved_env, 1);
+}
+
+void coroutine::yield()
+{
+	if(!executing_coroutine) {
+		std::cerr << "FATAL: Coroutine yield not allowed from main coroutine!" << std::endl;
+		exit(1);
+	}
+	if(setjmp(executing_coroutine->saved_env))
+		return;
+	longjmp(main_saved_env, 1);
+}
+
+bool coroutine::is_dead()
+{
+	return dead;
+}
+
+void coroutine::cexit()
+{
+	if(!executing_coroutine) {
+		std::cerr << "FATAL: Main coroutine can't exit!" << std::endl;
+		exit(1);
+	}
+	executing_coroutine->dead = true;
+	yield();
+}
+
+#ifdef TEST_COROUTINES
+
+void fn(void* arg)
+{
+	std::cout << "Print #1 from coroutine (" << arg << ")" << std::endl;
+	coroutine::yield();
+	std::cout << "Print #2 from coroutine (" << arg << ")" << std::endl;
+	coroutine::yield();
+	std::cout << "Print #3 from coroutine (" << arg << ")" << std::endl;
+}
+
+int main()
+{
+	int x;
+	coroutine c(fn, &x, 8 * 1024 * 1024);
+	std::cout << "Back to main thread" << std::endl;
+	std::cout << "Coroutine dead flag is " << c.is_dead() << std::endl;
+	c.resume();
+	std::cout << "Back to main thread" << std::endl;
+	std::cout << "Coroutine dead flag is " << c.is_dead() << std::endl;
+	c.resume();
+	std::cout << "Back to main thread" << std::endl;
+	std::cout << "Coroutine dead flag is " << c.is_dead() << std::endl;
+	return 0;
+}
+
+#endif
diff --git a/generic/coroutine.hpp b/generic/coroutine.hpp
new file mode 100644
index 00000000..554791be
--- /dev/null
+++ b/generic/coroutine.hpp
@@ -0,0 +1,59 @@
+#ifndef _coroutine__hpp__included__
+#define _coroutine__hpp__included__
+
+#include <cstdlib>
+#include <csetjmp>
+
+/**
+ * A coroutine.
+ */
+class coroutine
+{
+public:
+/**
+ * Create a new coroutine with specified starting function and stack size. The coroutine created will run until it
+ * yields for the first time.
+ *
+ * This can only be called from outside any coroutine.
+ *
+ * parameter fn: The function to call.
+ * parameter arg: Argument to pass to the function.
+ * parameter stacksize: Size of stack to allocate for function.
+ * throws std::bad:alloc: Not enough memory.
+ */
+	coroutine(void (*fn)(void* arg), void* arg, size_t stacksize);
+/**
+ * Destructor.
+ */
+	~coroutine() throw();
+/**
+ * Resume yielded coroutine.
+ *
+ * This can only be called from outside any coroutine.
+ */
+	void resume();
+/**
+ * Yield execution, causing coroutine::resume() or coroutine::coroutine() that called this coroutine to return.
+ *
+ * This can only be called from coroutine.
+ */
+	static void yield();
+
+/**
+ * Is the coroutine dead (has returned?)
+ */
+	bool is_dead();
+
+/**
+ * Exit the coroutine (yield and mark it dead).
+ */
+	static void cexit();
+private:
+	jmp_buf saved_env;
+	bool dead;
+	unsigned char* stackblock;
+};
+
+
+
+#endif
\ No newline at end of file
diff --git a/manual.lyx b/manual.lyx
index e3d48cc2..a3142acb 100644
--- a/manual.lyx
+++ b/manual.lyx
@@ -814,7 +814,7 @@ Print all aliases and their expansions in effect.
 \end_layout
 
 \begin_layout Subsection
-run-script <script>
+run-script <script> (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1076,7 +1076,7 @@ These commands are not available in lsnesrc, but are available after ROM
 \end_layout
 
 \begin_layout Subsubsection
-quit-emulator [/y]
+quit-emulator [/y] (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1085,7 +1085,7 @@ Quits the emulator (asking for confirmation).
 \end_layout
 
 \begin_layout Subsubsection
-pause-emulator
+pause-emulator (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1093,7 +1093,7 @@ Toggle paused/unpaused
 \end_layout
 
 \begin_layout Subsubsection
-+advance-frame
++advance-frame (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1103,7 +1103,7 @@ Advance frame.
 \end_layout
 
 \begin_layout Subsubsection
-+advance-poll
++advance-poll (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1113,7 +1113,7 @@ Advance subframe.
 \end_layout
 
 \begin_layout Subsubsection
-advance-skiplag
+advance-skiplag (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1121,7 +1121,7 @@ Skip to first poll in frame after current.
 \end_layout
 
 \begin_layout Subsubsection
-reset
+reset (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1129,7 +1129,7 @@ Reset the SNES after this frame.
 \end_layout
 
 \begin_layout Subsubsection
-load <filename>
+load <filename> (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1137,7 +1137,7 @@ Load savestate <filename> in current mode.
 \end_layout
 
 \begin_layout Subsubsection
-load-state <filename>
+load-state <filename> (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1145,7 +1145,7 @@ Load savestate <filename> in readwrite mode.
 \end_layout
 
 \begin_layout Subsubsection
-load-readonly <filename>
+load-readonly <filename> (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1153,7 +1153,7 @@ Load savestate <filename> in readonly mode.
 \end_layout
 
 \begin_layout Subsubsection
-load-preserve <filename>
+load-preserve <filename> (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1161,7 +1161,7 @@ Load savestate <filename> in readonly mode, preserving current events.
 \end_layout
 
 \begin_layout Subsubsection
-load-movie <filename>
+load-movie <filename> (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1169,7 +1169,7 @@ Load savestate <filename>, ignoring save part in readonly mode.
 \end_layout
 
 \begin_layout Subsubsection
-save-state <filename>
+save-state <filename> (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1177,7 +1177,7 @@ Save system state to <filename> as soon as possible.
 \end_layout
 
 \begin_layout Subsubsection
-save-movie <filename>
+save-movie <filename> (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1185,7 +1185,7 @@ Save movie to <filename>.
 \end_layout
 
 \begin_layout Subsubsection
-set-rwmode
+set-rwmode (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1193,7 +1193,7 @@ Set read-write mode.
 \end_layout
 
 \begin_layout Subsubsection
-set-romode
+set-romode (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1201,7 +1201,7 @@ Set read-only mode
 \end_layout
 
 \begin_layout Subsubsection
-toggle-rwmode
+toggle-rwmode (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1209,7 +1209,7 @@ Toggle between read-only and read-write modes.
 \end_layout
 
 \begin_layout Subsubsection
-set-gamename <name>
+set-gamename <name> (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1217,7 +1217,7 @@ Set name of the game to <name>
 \end_layout
 
 \begin_layout Subsubsection
-get-gamename
+get-gamename (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1225,7 +1225,7 @@ Print the name of the game.
 \end_layout
 
 \begin_layout Subsubsection
-add-author <author>
+add-author <author> (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1235,7 +1235,7 @@ Adds new author <author>.
 \end_layout
 
 \begin_layout Subsubsection
-edit-author <num> <author>
+edit-author <num> <author> (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1244,7 +1244,7 @@ Edit the author in slot <num> (0-based) to be <author> (see add-author for
 \end_layout
 
 \begin_layout Subsubsection
-remove-author <num>
+remove-author <num> (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1252,7 +1252,7 @@ Remove author in slot <num>
 \end_layout
 
 \begin_layout Subsubsection
-print-authors
+print-authors (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1260,7 +1260,7 @@ Print authors.
 \end_layout
 
 \begin_layout Subsubsection
-test-1, test-2, test-3
+test-1, test-2, test-3 (N/A for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1269,7 +1269,7 @@ Internal test commands.
 \end_layout
 
 \begin_layout Subsubsection
-take-screenshot <filename>
+take-screenshot <filename> (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1277,7 +1277,7 @@ Save screenshot to <filename>.
 \end_layout
 
 \begin_layout Subsubsection
-+controller<num><button>
++controller<num><button> (N/A for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1360,6 +1360,7 @@ Hold/unhold button <button> on controller <num> (1-8).
 
 \begin_layout Subsubsection
 autofire (<pattern>|-)...
+ (N/A for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1370,7 +1371,7 @@ Set autofire pattern.
 \end_layout
 
 \begin_layout Subsubsection
-repaint
+repaint (N/A for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1378,11 +1379,11 @@ Force a repaint.
 \end_layout
 
 \begin_layout Subsection
-Save jukebox
+Save jukebox (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Subsubsection
-cycle-jukebox-backward
+cycle-jukebox-backward (N/A for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1390,7 +1391,7 @@ Cycle save jukebox backwards.
 \end_layout
 
 \begin_layout Subsubsection
-cycle-jukebox-forward
+cycle-jukebox-forward (N/A for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1398,7 +1399,7 @@ Cycle save jukebox forwards
 \end_layout
 
 \begin_layout Subsubsection
-add-jukebox-save <filename>
+add-jukebox-save <filename> (N/A for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1406,7 +1407,7 @@ Add <filename> to jukebox saves.
 \end_layout
 
 \begin_layout Subsubsection
-load-jukebox
+load-jukebox (N/A for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1414,7 +1415,7 @@ Do load from jukebox (current mode).
 \end_layout
 
 \begin_layout Subsubsection
-save-jukebox
+save-jukebox (N/A for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1422,7 +1423,7 @@ Do state save to jukebox.
 \end_layout
 
 \begin_layout Subsection
-Lua
+Lua (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1430,7 +1431,8 @@ Only available if lua support is compiled in.
 \end_layout
 
 \begin_layout Subsubsection
-evaluate-lua <luacode>
+<<<<<<< HEADevaluate-lua <luacode>=======eval-lua <luacode> (implemented
+ for wxwidgets)>>>>>>> Wxwidgets Graphics plugin WIP
 \end_layout
 
 \begin_layout Standard
@@ -1438,7 +1440,7 @@ Run Lua code <luacode> using built-in Lua interpretter.
 \end_layout
 
 \begin_layout Subsubsection
-run-lua <script>
+run-lua <script> (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1466,11 +1468,11 @@ Remove a watch.
 \end_layout
 
 \begin_layout Subsection
-Sound
+Sound (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Subsubsection
-enable-sound <on/off>
+enable-sound <on/off> (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1478,7 +1480,7 @@ Enable/Disable sound.
 \end_layout
 
 \begin_layout Subsubsection
-set-sound-device <device>
+set-sound-device <device> (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1486,7 +1488,7 @@ Set sound device to <device>
 \end_layout
 
 \begin_layout Subsubsection
-show-sound-status
+show-sound-status (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1494,7 +1496,7 @@ Show status of sound system.
 \end_layout
 
 \begin_layout Subsubsection
-show-sound-devices
+show-sound-devices (N/A for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1502,7 +1504,7 @@ Show all available devices.
 \end_layout
 
 \begin_layout Subsection
-SDL Platform commands
+SDL Platform commands (implemented for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1510,7 +1512,7 @@ The following are valid on SDL platform.
 \end_layout
 
 \begin_layout Subsubsection
-identify-key
+identify-key (N/A for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1518,7 +1520,7 @@ Asks to press a key and then identifies that (pseudo-)key.
 \end_layout
 
 \begin_layout Subsubsection
-toggle-console
+toggle-console (N/A for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1526,7 +1528,7 @@ Toggle between windowed/fullscreen console.
 \end_layout
 
 \begin_layout Subsubsection
-scroll-fullup
+scroll-fullup (N/A for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1534,7 +1536,7 @@ Scroll messages window as far back as it goes.
 \end_layout
 
 \begin_layout Subsubsection
-scroll-fulldown
+scroll-fulldown (N/A for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1542,7 +1544,7 @@ Scroll messages window as far forward as it goes.
 \end_layout
 
 \begin_layout Subsubsection
-scroll-up
+scroll-up (N/A for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -1550,7 +1552,7 @@ Scroll messages window back one screenful.
 \end_layout
 
 \begin_layout Subsubsection
-scroll-down
+scroll-down (N/A for wxwidgets)
 \end_layout
 
 \begin_layout Standard
@@ -3773,7 +3775,7 @@ GRAPHICS=<plat>
 
 \begin_layout Standard
 Set graphics platform.
- Currently available choice is 
+ Currently available choices are 
 \begin_inset Quotes eld
 \end_inset
 
@@ -3781,6 +3783,14 @@ SDL
 \begin_inset Quotes erd
 \end_inset
 
+ and 
+\begin_inset Quotes eld
+\end_inset
+
+WXWIDGETS
+\begin_inset Quotes erd
+\end_inset
+
 .
 \end_layout
 
diff --git a/platform/wxwidgets/main-wxwidgets.cpp b/platform/wxwidgets/main-wxwidgets.cpp
new file mode 100644
index 00000000..dfce9d59
--- /dev/null
+++ b/platform/wxwidgets/main-wxwidgets.cpp
@@ -0,0 +1,71 @@
+#include "lsnes.hpp"
+#include <snes/snes.hpp>
+#include <ui-libsnes/libsnes.hpp>
+#include <wx/wx.h>
+#include <wx/event.h>
+#include <wx/control.h>
+#include <wx/combobox.h>
+#include <cassert>
+#include "rom.hpp"
+#include "avsnoop.hpp"
+#include "rrdata.hpp"
+#include "framerate.hpp"
+#include "zip.hpp"
+#include <boost/lexical_cast.hpp>
+#include "misc.hpp"
+#include "window.hpp"
+#include "lua.hpp"
+#include "src/rom_select_window.hpp"
+#include "src/messages_window.hpp"
+#include "src/status_window.hpp"
+
+class lsnes_app : public wxApp
+{
+public:
+	virtual bool OnInit();
+	virtual int OnExit();
+};
+
+IMPLEMENT_APP(lsnes_app)
+
+bool lsnes_app::OnInit()
+{
+	set_random_seed();
+
+	{
+		std::ostringstream x;
+		x << snes_library_id() << " (" << SNES::Info::Profile << " core)";
+		bsnes_core_version = x.str();
+	}
+	window::init();
+	init_lua();
+
+	messages << "BSNES version: " << bsnes_core_version << std::endl;
+	messages << "lsnes version: lsnes rr" << lsnes_version << std::endl;
+
+	std::string cfgpath = get_config_path();
+	messages << "Saving per-user data to: " << get_config_path() << std::endl;
+
+	wx_messages_window* msgs = new wx_messages_window();
+	window1 = msgs;
+	msgs->Show();
+
+	wx_rom_select_window* romwin = new wx_rom_select_window();
+	romwin->Show();
+
+	return true;
+}
+
+int lsnes_app::OnExit()
+{
+	av_snooper::_end();
+	rrdata::close();
+	window::quit();
+	return 0;
+}
+
+void window::notify_message() throw(std::bad_alloc, std::runtime_error)
+{
+	if(wx_messages_window::ptr)
+		wx_messages_window::ptr->notify_message();
+}
diff --git a/platform/wxwidgets/src/authorseditor.cpp b/platform/wxwidgets/src/authorseditor.cpp
new file mode 100644
index 00000000..5caf69c8
--- /dev/null
+++ b/platform/wxwidgets/src/authorseditor.cpp
@@ -0,0 +1,81 @@
+#include "authorseditor.hpp"
+#include "common.hpp"
+#include "moviedata.hpp"
+
+wx_authors_editor::wx_authors_editor(wxWindow* parent)
+	: wxDialog(parent, wxID_ANY, wxT("lsnes: Edit game name & authors"), wxDefaultPosition, wxSize(-1, -1))
+{
+	Centre();
+	wxFlexGridSizer* top_s = new wxFlexGridSizer(4, 1, 0, 0);
+	SetSizer(top_s);
+
+	wxFlexGridSizer* c_s = new wxFlexGridSizer(1, 2, 0, 0);
+	c_s->Add(new wxStaticText(this, wxID_ANY, wxT("Game name:")), 0, wxGROW);
+	c_s->Add(projectname = new wxTextCtrl(this, wxID_ANY, wxT(""), wxDefaultPosition, wxSize(400, -1)), 1, wxGROW);
+	top_s->Add(c_s);
+	
+	top_s->Add(new wxStaticText(this, wxID_ANY, wxT("Authors (one per line):")), 0, wxGROW);
+	top_s->Add(authors = new wxTextCtrl(this, wxID_ANY, wxT(""), wxDefaultPosition, wxDefaultSize,
+		wxTE_MULTILINE), 0, wxGROW);
+	authors->Connect(wxEVT_COMMAND_TEXT_UPDATED,
+		wxCommandEventHandler(wx_authors_editor::on_authors_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(wx_authors_editor::on_ok), NULL, this);
+	cancel->Connect(wxEVT_COMMAND_BUTTON_CLICKED,
+		wxCommandEventHandler(wx_authors_editor::on_cancel), NULL, this);
+	top_s->Add(pbutton_s, 0, wxGROW);
+
+	c_s->SetSizeHints(this);
+	top_s->SetSizeHints(this);
+	Fit();
+
+	projectname->SetValue(towxstring(our_movie.gamename));
+	std::string x;
+	for(auto i : our_movie.authors)
+		x = x + i.first + "|" + i.second + "\n";
+	authors->SetValue(towxstring(x));
+}
+
+bool wx_authors_editor::ShouldPreventAppExit() const
+{
+	return false;
+}
+
+void wx_authors_editor::on_authors_change(wxCommandEvent& e)
+{
+	try {
+		size_t lines = authors->GetNumberOfLines();
+		for(size_t i = 0; i < lines; i++) {
+			std::string l = tostdstring(authors->GetLineText(i));
+			if(l == "|")
+				throw 43;
+		}
+		okbutton->Enable();
+	} catch(...) {
+		okbutton->Disable();
+	}
+}
+
+void wx_authors_editor::on_cancel(wxCommandEvent& e)
+{
+	EndModal(wxID_CANCEL);
+}
+
+void wx_authors_editor::on_ok(wxCommandEvent& e)
+{
+	our_movie.gamename = tostdstring(projectname->GetValue());
+	std::vector<std::pair<std::string, std::string>> newauthors;
+	size_t lines = authors->GetNumberOfLines();
+	for(size_t i = 0; i < lines; i++) {
+		std::string l = tostdstring(authors->GetLineText(i));
+		if(l != "" && l != "|")
+			newauthors.push_back(split_author(l));
+	}
+	our_movie.authors = newauthors;
+	EndModal(wxID_OK);
+}
diff --git a/platform/wxwidgets/src/authorseditor.hpp b/platform/wxwidgets/src/authorseditor.hpp
new file mode 100644
index 00000000..e4424f3d
--- /dev/null
+++ b/platform/wxwidgets/src/authorseditor.hpp
@@ -0,0 +1,24 @@
+#ifndef _wxwidgets_authorseditor__hpp__included__
+#define _wxwidgets_authorseditor__hpp__included__
+
+#include <wx/wx.h>
+#include <wx/event.h>
+#include <wx/control.h>
+#include <wx/combobox.h>
+
+class wx_authors_editor : public wxDialog
+{
+public:
+	wx_authors_editor(wxWindow* parent);
+	bool ShouldPreventAppExit() const;
+	void on_authors_change(wxCommandEvent& e);
+	void on_cancel(wxCommandEvent& e);
+	void on_ok(wxCommandEvent& e);
+private:
+	wxTextCtrl* projectname;
+	wxTextCtrl* authors;
+	wxButton* okbutton;
+	wxButton* cancel;
+};
+
+#endif
diff --git a/platform/wxwidgets/src/axeseditor.cpp b/platform/wxwidgets/src/axeseditor.cpp
new file mode 100644
index 00000000..b1a50254
--- /dev/null
+++ b/platform/wxwidgets/src/axeseditor.cpp
@@ -0,0 +1,222 @@
+#include "axeseditor.hpp"
+#include "keymapper.hpp"
+#include "common.hpp"
+#include <boost/lexical_cast.hpp>
+#include <sstream>
+
+#define AMODE_DISABLED "Disabled"
+#define AMODE_AXIS_PAIR "Axis"
+#define AMODE_AXIS_PAIR_INVERSE "Axis (inverted)"
+#define AMODE_PRESSURE_M0 "Pressure - to 0"
+#define AMODE_PRESSURE_MP "Pressure - to +"
+#define AMODE_PRESSURE_0M "Pressure 0 to -"
+#define AMODE_PRESSURE_0P "Pressure 0 to +"
+#define AMODE_PRESSURE_PM "Pressure + to -"
+#define AMODE_PRESSURE_P0 "Pressure + to 0"
+
+wx_axes_editor_axis::wx_axes_editor_axis(wxSizer* sizer, wxWindow* window, const std::string& name)
+{
+	wxString choices[9];
+	choices[0] = wxT(AMODE_DISABLED);
+	choices[1] = wxT(AMODE_AXIS_PAIR);
+	choices[2] = wxT(AMODE_AXIS_PAIR_INVERSE);
+	choices[3] = wxT(AMODE_PRESSURE_M0);
+	choices[4] = wxT(AMODE_PRESSURE_MP);
+	choices[5] = wxT(AMODE_PRESSURE_0M);
+	choices[6] = wxT(AMODE_PRESSURE_0P);
+	choices[7] = wxT(AMODE_PRESSURE_PM);
+	choices[8] = wxT(AMODE_PRESSURE_P0);
+	size_t defaultidx = 0;
+	std::string low;
+	std::string mid;
+	std::string high;
+	std::string tolerance;
+	keygroup* k = keygroup::lookup_by_name(name);
+	if(!k)
+		return;
+	struct keygroup::parameters p = k->get_parameters();
+	{
+		switch(p.ktype) {
+		case keygroup::KT_DISABLED:		defaultidx = 0; break;
+		case keygroup::KT_AXIS_PAIR:		defaultidx = 1; break;
+		case keygroup::KT_AXIS_PAIR_INVERSE:	defaultidx = 2; break;
+		case keygroup::KT_PRESSURE_M0:		defaultidx = 3; break;
+		case keygroup::KT_PRESSURE_MP:		defaultidx = 4; break;
+		case keygroup::KT_PRESSURE_0M:		defaultidx = 5; break;
+		case keygroup::KT_PRESSURE_0P:		defaultidx = 6; break;
+		case keygroup::KT_PRESSURE_PM:		defaultidx = 7; break;
+		case keygroup::KT_PRESSURE_P0:		defaultidx = 8; break;
+		};
+		std::ostringstream x1;
+		std::ostringstream x2;
+		std::ostringstream x3;
+		std::ostringstream x4;
+		x1 << p.cal_left;
+		x2 << p.cal_center;
+		x3 << p.cal_right;
+		x4 << p.cal_tolerance;
+		low = x1.str();
+		mid = x2.str();
+		high = x3.str();
+		tolerance = x4.str();
+	}
+
+	a_name = name;
+	sizer->Add(new wxStaticText(window, wxID_ANY, towxstring(name)), 0, wxGROW);
+	sizer->Add(a_type = new wxComboBox(window, wxID_ANY, choices[defaultidx], wxDefaultPosition, wxDefaultSize,
+		9, choices, wxCB_READONLY), 0, wxGROW);
+	sizer->Add(a_low = new wxTextCtrl(window, wxID_ANY, towxstring(low)), 0, wxGROW);
+	sizer->Add(a_mid = new wxTextCtrl(window, wxID_ANY, towxstring(mid)), 0, wxGROW);
+	sizer->Add(a_high = new wxTextCtrl(window, wxID_ANY, towxstring(high)), 0, wxGROW);
+	sizer->Add(a_tolerance = new wxTextCtrl(window, wxID_ANY, towxstring(tolerance)), 0, wxGROW);
+	a_low->Connect(wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler(wx_axes_editor::on_value_change), NULL,
+		window);
+	a_mid->Connect(wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler(wx_axes_editor::on_value_change), NULL,
+		window);
+	a_high->Connect(wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler(wx_axes_editor::on_value_change), NULL,
+		window);
+	a_tolerance->Connect(wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler(wx_axes_editor::on_value_change), NULL,
+		window);
+}
+
+bool wx_axes_editor_axis::is_ok()
+{
+	int32_t low, mid, high;
+	double tolerance;
+
+	try {
+		low = boost::lexical_cast<int32_t>(tostdstring(a_low->GetValue()));
+		mid = boost::lexical_cast<int32_t>(tostdstring(a_mid->GetValue()));
+		high = boost::lexical_cast<int32_t>(tostdstring(a_high->GetValue()));
+		tolerance = boost::lexical_cast<double>(tostdstring(a_tolerance->GetValue()));
+	} catch(...) {
+		return false;
+	}
+
+	if(low < -32768 || low > 32767 || low > mid)
+		return false;
+	if(mid < -32768 || mid > 32767 || mid > high)
+		return false;
+	if(high < -32768 || high > 32767)
+		return false;
+	if(tolerance <= 0 || tolerance >= 1)
+		return false;
+	return true;
+}
+
+void wx_axes_editor_axis::apply()
+{
+	keygroup* k = keygroup::lookup_by_name(a_name);
+	if(!k)
+		return;
+
+	int32_t low, mid, high;
+	double tolerance;
+	enum keygroup::type ntype;
+	enum keygroup::type ctype = k->get_parameters().ktype;;
+
+	std::string amode = tostdstring(a_type->GetValue());
+	if(amode == AMODE_AXIS_PAIR)
+		ntype = keygroup::KT_AXIS_PAIR;
+	if(amode == AMODE_AXIS_PAIR_INVERSE)
+		ntype = keygroup::KT_AXIS_PAIR_INVERSE;
+	if(amode == AMODE_DISABLED)
+		ntype = keygroup::KT_DISABLED;
+	if(amode == AMODE_PRESSURE_0M)
+		ntype = keygroup::KT_PRESSURE_0M;
+	if(amode == AMODE_PRESSURE_0P)
+		ntype = keygroup::KT_PRESSURE_0P;
+	if(amode == AMODE_PRESSURE_M0)
+		ntype = keygroup::KT_PRESSURE_M0;
+	if(amode == AMODE_PRESSURE_MP)
+		ntype = keygroup::KT_PRESSURE_MP;
+	if(amode == AMODE_PRESSURE_PM)
+		ntype = keygroup::KT_PRESSURE_PM;
+	if(amode == AMODE_PRESSURE_P0)
+		ntype = keygroup::KT_PRESSURE_P0;
+	try {
+		low = boost::lexical_cast<int32_t>(tostdstring(a_low->GetValue()));
+		mid = boost::lexical_cast<int32_t>(tostdstring(a_mid->GetValue()));
+		high = boost::lexical_cast<int32_t>(tostdstring(a_high->GetValue()));
+		tolerance = boost::lexical_cast<double>(tostdstring(a_tolerance->GetValue()));
+	} catch(...) {
+		return;
+	}
+	if(low < -32768 || low > 32767 || low > mid)
+		return;
+	if(mid < -32768 || mid > 32767 || mid > high)
+		return;
+	if(high < -32768 || high > 32767)
+		return;
+	if(tolerance <= 0 || tolerance >= 1)
+		return;
+	if(ctype != ntype)
+		k->change_type(ntype);
+	k->change_calibration(low, mid, high, tolerance);
+}
+
+wx_axes_editor::wx_axes_editor(wxWindow* parent)
+	: wxDialog(parent, wxID_ANY, wxT("lsnes: Edit axes"), wxDefaultPosition, wxSize(-1, -1))
+{
+	std::set<std::string> axisnames = keygroup::get_axis_set();
+
+	Centre();
+	wxFlexGridSizer* top_s = new wxFlexGridSizer(2, 1, 0, 0);
+	SetSizer(top_s);
+	
+	wxFlexGridSizer* t_s = new wxFlexGridSizer(axisnames.size() + 1, 6, 0, 0);
+	t_s->Add(new wxStaticText(this, wxID_ANY, wxT("Name")), 0, wxGROW);
+	t_s->Add(new wxStaticText(this, wxID_ANY, wxT("Type")), 0, wxGROW);
+	t_s->Add(new wxStaticText(this, wxID_ANY, wxT("Low")), 0, wxGROW);
+	t_s->Add(new wxStaticText(this, wxID_ANY, wxT("Mid")), 0, wxGROW);
+	t_s->Add(new wxStaticText(this, wxID_ANY, wxT("High")), 0, wxGROW);
+	t_s->Add(new wxStaticText(this, wxID_ANY, wxT("Tolerance")), 0, wxGROW);
+	for(auto i : axisnames)
+		axes.push_back(new wx_axes_editor_axis(t_s, this, i));
+	top_s->Add(t_s);
+
+	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(wx_axes_editor::on_ok), NULL, this);
+	cancel->Connect(wxEVT_COMMAND_BUTTON_CLICKED,
+		wxCommandEventHandler(wx_axes_editor::on_cancel), NULL, this);
+	top_s->Add(pbutton_s, 0, wxGROW);
+
+	t_s->SetSizeHints(this);
+	top_s->SetSizeHints(this);
+	Fit();
+}
+
+wx_axes_editor::~wx_axes_editor()
+{
+	for(auto i : axes)
+		delete i;
+}
+
+bool wx_axes_editor::ShouldPreventAppExit() const
+{
+	return false;
+}
+
+void wx_axes_editor::on_value_change(wxCommandEvent& e)
+{
+	bool all_ok = true;
+	for(auto i : axes)
+		all_ok = all_ok && i->is_ok();
+	okbutton->Enable(all_ok);
+}
+
+void wx_axes_editor::on_cancel(wxCommandEvent& e)
+{
+	EndModal(wxID_CANCEL);
+}
+
+void wx_axes_editor::on_ok(wxCommandEvent& e)
+{
+	for(auto i : axes)
+		i->apply();
+	EndModal(wxID_OK);
+}
diff --git a/platform/wxwidgets/src/axeseditor.hpp b/platform/wxwidgets/src/axeseditor.hpp
new file mode 100644
index 00000000..1223f7d7
--- /dev/null
+++ b/platform/wxwidgets/src/axeseditor.hpp
@@ -0,0 +1,41 @@
+#ifndef _wxwidgets_axeseditor__hpp__included__
+#define _wxwidgets_axeseditor__hpp__included__
+
+#include <wx/wx.h>
+#include <wx/event.h>
+#include <wx/control.h>
+#include <wx/combobox.h>
+#include <vector>
+#include <string>
+
+class wx_axes_editor_axis
+{
+public:
+	wx_axes_editor_axis(wxSizer* sizer, wxWindow* window, const std::string& name);
+	bool is_ok();
+	void apply();
+private:
+	std::string a_name;
+	wxComboBox* a_type;
+	wxTextCtrl* a_low;
+	wxTextCtrl* a_mid;
+	wxTextCtrl* a_high;
+	wxTextCtrl* a_tolerance;
+};
+
+class wx_axes_editor : public wxDialog
+{
+public:
+	wx_axes_editor(wxWindow* parent);
+	~wx_axes_editor();
+	bool ShouldPreventAppExit() const;
+	void on_value_change(wxCommandEvent& e);
+	void on_cancel(wxCommandEvent& e);
+	void on_ok(wxCommandEvent& e);
+private:
+	std::vector<wx_axes_editor_axis*> axes;
+	wxButton* okbutton;
+	wxButton* cancel;
+};
+
+#endif
diff --git a/platform/wxwidgets/src/callrom.cpp b/platform/wxwidgets/src/callrom.cpp
new file mode 100644
index 00000000..f505ddb5
--- /dev/null
+++ b/platform/wxwidgets/src/callrom.cpp
@@ -0,0 +1,195 @@
+#include "callrom.hpp"
+#include "common.hpp"
+
+#define TNAME_SNES "SNES"
+#define TNAME_BSX_NS "BS-X (non-slotted)"
+#define TNAME_BSX_S "BS-X (slotted)"
+#define TNAME_SUFAMITURBO "Sufami Turbo"
+#define TNAME_SGB "SGB"
+#define RNAME_AUTO "Autodetect"
+#define RNAME_NTSC "NTSC"
+#define RNAME_PAL "PAL"
+#define WNAME_SNES_MAIN "ROM"
+#define WNAME_SNES_MAIN_XML "ROM XML"
+#define WNAME_BS_MAIN "BS-X BIOS"
+#define WNAME_BS_MAIN_XML "BS-X BIOS XML"
+#define WNAME_BS_SLOTA "BS FLASH"
+#define WNAME_BS_SLOTA_XML "BS FLASH XML"
+#define WNAME_ST_MAIN "ST BIOS"
+#define WNAME_ST_MAIN_XML "ST BIOS XML"
+#define WNAME_ST_SLOTA "SLOT A ROM"
+#define WNAME_ST_SLOTA_XML "SLOT A XML"
+#define WNAME_ST_SLOTB "SLOT B ROM"
+#define WNAME_ST_SLOTB_XML "SLOT B XML"
+#define WNAME_SGB_MAIN "SGB BIOS"
+#define WNAME_SGB_MAIN_XML "SGB BIOS XML"
+#define WNAME_SGB_SLOTA "DMG ROM"
+#define WNAME_SGB_SLOTA_XML "BMG XML"
+
+
+enum rom_type romtype_from_string(const std::string& str)
+{
+	if(str == TNAME_SNES)
+		return ROMTYPE_SNES;
+	if(str == TNAME_BSX_NS)
+		return ROMTYPE_BSX;
+	if(str == TNAME_BSX_S)
+		return ROMTYPE_BSXSLOTTED;
+	if(str == TNAME_SUFAMITURBO)
+		return ROMTYPE_SUFAMITURBO;
+	if(str == TNAME_SGB)
+		return ROMTYPE_SGB;
+	return ROMTYPE_NONE;
+}
+
+enum rom_type romtype_from_string(const wxString& str)
+{
+	return romtype_from_string(tostdstring(str));
+}
+
+wxString romname_wxs(enum rom_type rtype, unsigned index)
+{
+	return towxstring(romname_stds(rtype, index));
+}
+
+std::string romname_stds(enum rom_type rtype, unsigned index)
+{
+	switch(rtype) {
+	case ROMTYPE_SNES:
+		switch(index) {
+		case 0:		return WNAME_SNES_MAIN;
+		case 1:		return WNAME_SNES_MAIN_XML;
+		};
+		break;
+	case ROMTYPE_BSX:
+	case ROMTYPE_BSXSLOTTED:
+		switch(index) {
+		case 0:		return WNAME_BS_MAIN;
+		case 1:		return WNAME_BS_MAIN_XML;
+		case 2:		return WNAME_BS_SLOTA;
+		case 3:		return WNAME_BS_SLOTA_XML;
+		};
+		break;
+	case ROMTYPE_SUFAMITURBO:
+		switch(index) {
+		case 0:		return WNAME_ST_MAIN;
+		case 1:		return WNAME_ST_MAIN_XML;
+		case 2:		return WNAME_ST_SLOTA;
+		case 3:		return WNAME_ST_SLOTA_XML;
+		case 4:		return WNAME_ST_SLOTB;
+		case 5:		return WNAME_ST_SLOTB_XML;
+		};
+		break;
+	case ROMTYPE_SGB:
+		switch(index) {
+		case 0:		return WNAME_SGB_MAIN;
+		case 1:		return WNAME_SGB_MAIN_XML;
+		case 2:		return WNAME_SGB_SLOTA;
+		case 3:		return WNAME_SGB_SLOTA_XML;
+		};
+		break;
+	case ROMTYPE_NONE:
+		if(index == 0)	return "dummy";
+		break;
+	}
+	return "";
+}
+
+unsigned fill_rom_names(enum rom_type rtype, wxString* array)
+{
+	unsigned r = 0;
+	for(unsigned i = 0; i < 6; i++) {
+		wxString s = romname_wxs(rtype, i);
+		if(s.Length())
+			array[r++] = s;
+	}
+	return r;
+}
+
+unsigned romname_to_index(enum rom_type rtype, const wxString& name)
+{
+	std::string s = tostdstring(name);
+	for(unsigned i = 0; i < 6; i++)
+		if(romname_stds(rtype, i) == s)
+			return i;
+	return 6;
+
+}
+
+struct loaded_slot& get_rom_slot(struct loaded_rom& rom, unsigned index)
+{
+	switch(index) {
+	case 0:		return rom.rom;
+	case 1:		return rom.rom_xml;
+	case 2:		return rom.slota;
+	case 3:		return rom.slota_xml;
+	case 4:		return rom.slotb;
+	case 5:		return rom.slotb_xml;
+	}
+	return rom.rom;
+}
+
+enum rom_region region_from_string(const std::string& str)
+{
+	if(str == RNAME_NTSC)
+		return REGION_NTSC;
+	if(str == RNAME_PAL)
+		return REGION_PAL;
+	return REGION_AUTO;
+}
+
+enum rom_region region_from_string(const wxString& str)
+{
+	return region_from_string(tostdstring(str));
+}
+
+bool has_forced_region(enum rom_type rtype)
+{
+	return (rtype != ROMTYPE_SNES && rtype != ROMTYPE_SGB);
+}
+
+bool has_forced_region(const std::string& str)
+{
+	return has_forced_region(romtype_from_string(str));
+}
+
+bool has_forced_region(const wxString& str)
+{
+	return has_forced_region(romtype_from_string(str));
+}
+
+wxString forced_region_for_romtype(enum rom_type rtype)
+{
+	if(has_forced_region(rtype))
+		return wxT(RNAME_NTSC);
+	else
+		return wxT("");
+}
+
+wxString forced_region_for_romtype(const std::string& str)
+{
+	return forced_region_for_romtype(romtype_from_string(str));
+}
+
+wxString forced_region_for_romtype(const wxString& str)
+{
+	return forced_region_for_romtype(romtype_from_string(str));
+}
+
+unsigned populate_region_choices(wxString* array)
+{
+	array[0] = wxT(RNAME_AUTO);
+	array[1] = wxT(RNAME_NTSC);
+	array[2] = wxT(RNAME_PAL);
+	return 3;
+}
+
+unsigned populate_system_choices(wxString* array)
+{
+	array[0] = wxT(TNAME_SNES);
+	array[1] = wxT(TNAME_BSX_NS);
+	array[2] = wxT(TNAME_BSX_S);
+	array[3] = wxT(TNAME_SUFAMITURBO);
+	array[4] = wxT(TNAME_SGB);
+	return 5;
+}
diff --git a/platform/wxwidgets/src/callrom.hpp b/platform/wxwidgets/src/callrom.hpp
new file mode 100644
index 00000000..9a741471
--- /dev/null
+++ b/platform/wxwidgets/src/callrom.hpp
@@ -0,0 +1,26 @@
+#ifndef _wxwidgets_callrom__hpp__included__
+#define _wxwidgets_callrom__hpp__included__
+
+#include "rom.hpp"
+#include <wx/string.h>
+#include <string>
+
+enum rom_type romtype_from_string(const std::string& str);
+enum rom_type romtype_from_string(const wxString& str);
+wxString romname_wxs(enum rom_type rtype, unsigned index);
+std::string romname_stds(enum rom_type rtype, unsigned index);
+unsigned fill_rom_names(enum rom_type rtype, wxString* array);
+unsigned romname_to_index(enum rom_type rtype, const wxString& name);
+struct loaded_slot& get_rom_slot(struct loaded_rom& rom, unsigned index);
+enum rom_region region_from_string(const std::string& str);
+enum rom_region region_from_string(const wxString& str);
+bool has_forced_region(enum rom_type rtype);
+bool has_forced_region(const std::string& str);
+bool has_forced_region(const wxString& str);
+wxString forced_region_for_romtype(enum rom_type rtype);
+wxString forced_region_for_romtype(const std::string& str);
+wxString forced_region_for_romtype(const wxString& str);
+unsigned populate_region_choices(wxString* array);
+unsigned populate_system_choices(wxString* array);
+
+#endif
\ No newline at end of file
diff --git a/platform/wxwidgets/src/common.cpp b/platform/wxwidgets/src/common.cpp
new file mode 100644
index 00000000..c0ac5e3e
--- /dev/null
+++ b/platform/wxwidgets/src/common.cpp
@@ -0,0 +1,17 @@
+#include "common.hpp"
+
+wxString towxstring(const std::string& str)
+{
+	return wxString(str.c_str(), wxConvUTF8);
+}
+
+std::string tostdstring(const wxString& str)
+{
+	return std::string(str.mb_str(wxConvUTF8));
+}
+
+long primary_window_style = wxMINIMIZE_BOX | wxSYSTEM_MENU | wxCAPTION | wxCLIP_CHILDREN | wxCLOSE_BOX;
+long secondary_window_style = wxMINIMIZE_BOX | wxSYSTEM_MENU | wxCAPTION | wxCLIP_CHILDREN;
+
+wxFrame* window1;
+wxFrame* window2;
diff --git a/platform/wxwidgets/src/common.hpp b/platform/wxwidgets/src/common.hpp
new file mode 100644
index 00000000..c4a0a1cf
--- /dev/null
+++ b/platform/wxwidgets/src/common.hpp
@@ -0,0 +1,45 @@
+#ifndef _wxwidgets_common__hpp__included__
+#define _wxwidgets_common__hpp__included__
+
+#include <wx/string.h>
+#include <wx/wx.h>
+
+wxString towxstring(const std::string& str);
+std::string tostdstring(const wxString& str);
+extern long primary_window_style;
+extern long secondary_window_style;
+typedef wxStaticText* wxStaticText_ptr;
+
+extern wxFrame* window1;
+extern wxFrame* window2;
+
+template<class T>
+void cmdbutton_action(T* target, wxButton* button, void (T::*fptr)(wxCommandEvent& e))
+{
+	button->Connect(wxEVT_COMMAND_BUTTON_CLICKED, (wxObjectEventFunction)(wxEventFunction)
+		static_cast<wxCommandEventFunction>(fptr), NULL, target);
+}
+
+template<class T>
+void menu_action(T* target, int id, void (T::*fptr)(wxCommandEvent& e))
+{
+	target->Connect(id, wxEVT_COMMAND_MENU_SELECTED, (wxObjectEventFunction)(wxEventFunction)
+		static_cast<wxCommandEventFunction>(fptr), NULL, target);
+}
+
+template<class T>
+void menu_action(T* target, int id, void (T::*fptr)(wxCommandEvent& e), std::string subcmd)
+{
+	target->Connect(id, wxEVT_COMMAND_MENU_SELECTED, (wxObjectEventFunction)(wxEventFunction)
+		static_cast<wxCommandEventFunction>(fptr), NULL, target);
+}
+
+#define CNAME_NONE "None"
+#define CNAME_GAMEPAD "Gamepad"
+#define CNAME_MULTITAP "Multitap"
+#define CNAME_MOUSE "Mouse"
+#define CNAME_SUPERSCOPE "Superscope"
+#define CNAME_JUSTIFIER "Justifier"
+#define CNAME_JUSTIFIERS "2 Justifiers"
+
+#endif
diff --git a/platform/wxwidgets/src/emufn.cpp b/platform/wxwidgets/src/emufn.cpp
new file mode 100644
index 00000000..369f7f1f
--- /dev/null
+++ b/platform/wxwidgets/src/emufn.cpp
@@ -0,0 +1,1604 @@
+#include "lsnes.hpp"
+#include "emufn.hpp"
+#include "zip.hpp"
+#include "lua.hpp"
+#include "keyentry.hpp"
+#include "coroutine.hpp"
+#include "moviedata.hpp"
+#include "memorywatch.hpp"
+#include "misc.hpp"
+#include "command.hpp"
+#include "controller.hpp"
+#include "mainloop.hpp"
+#include "keymapper.hpp"
+#include "render.hpp"
+#include "window.hpp"
+#include "misc.hpp"
+#include "framerate.hpp"
+#include "common.hpp"
+#include "moviedata.hpp"
+#include "authorseditor.hpp"
+#include "settingseditor.hpp"
+#include "axeseditor.hpp"
+#include <wx/wx.h>
+#include <wx/event.h>
+#include <wx/control.h>
+#include <wx/combobox.h>
+#include "status_window.hpp"
+#include <cstdint>
+extern "C"
+{
+#ifndef UINT64_C
+#define UINT64_C(val) val##ULL
+#endif
+#include <libswscale/swscale.h>
+}
+#define STACKSIZE (8 * 1024 * 1024)
+#define REQ_POLL_JOYSTICK 1
+#define REQ_KEY_PRESS 2
+#define REQ_KEY_RELEASE 3
+#define REQ_CONTINUE 4
+#define REQ_COMMAND 5
+
+extern std::string lsnes_version;
+
+enum
+{
+	wxID_PAUSE = wxID_HIGHEST + 1,
+	wxID_FRAMEADVANCE,
+	wxID_SUBFRAMEADVANCE,
+	wxID_NEXTPOLL,
+	wxID_ERESET,
+	wxID_AUDIO_ENABLED,
+	wxID_SHOW_AUDIO_STATUS,
+	wxID_AUDIODEV_FIRST,
+	wxID_AUDIODEV_LAST = wxID_AUDIODEV_FIRST + 255,
+	wxID_SAVE_STATE,
+	wxID_SAVE_MOVIE,
+	wxID_LOAD_STATE,
+	wxID_LOAD_STATE_RO,
+	wxID_LOAD_STATE_RW,
+	wxID_LOAD_STATE_P,
+	wxID_LOAD_MOVIE,
+	wxID_RUN_SCRIPT,
+	wxID_RUN_LUA,
+	wxID_EVAL_LUA,
+	wxID_SAVE_SCREENSHOT,
+	wxID_READONLY_MODE,
+	wxID_EDIT_AUTHORS,
+	wxID_AUTOHOLD_FIRST,
+	wxID_AUTOHOLD_LAST = wxID_AUTOHOLD_FIRST + 127,
+	wxID_EDIT_AXES,
+	wxID_EDIT_SETTINGS,
+	wxID_EDIT_KEYBINDINGS,
+	wxID_EDIT_ALIAS,
+	wxID_EDIT_MEMORYWATCH,
+	wxID_SAVE_MEMORYWATCH,
+	wxID_LOAD_MEMORYWATCH,
+	wxID_DUMP_AVICSCD,
+	wxID_END_AVICSCD,
+	wxID_DUMP_JMD,
+	wxID_END_JMD,
+	wxID_DUMP_SDMP,
+	wxID_END_SDMP,
+};
+
+#define MAXCONTROLLERS 8
+#define CONTROLS_COUNT 16
+
+class controller_autohold_menu : public wxMenu
+{
+public:
+	controller_autohold_menu(unsigned lid, enum devicetype_t dtype);
+	void change_type(enum devicetype_t dtype);
+	bool is_dummy();
+	void on_select(wxCommandEvent& e);
+	void update(unsigned pid, unsigned ctrlnum, bool newstate);
+private:
+	unsigned our_lid;
+	devicetype_t devtype;
+	wxMenuItem* entries[CONTROLS_COUNT];
+};
+
+class autohold_menu : public wxMenu
+{
+public:
+	autohold_menu();
+	void reconfigure();
+	void on_select(wxCommandEvent& e);
+	void update(unsigned pid, unsigned ctrlnum, bool newstate);
+private:
+	controller_autohold_menu* menus[MAXCONTROLLERS];
+	wxMenuItem* entries[MAXCONTROLLERS];
+};
+
+controller_autohold_menu::controller_autohold_menu(unsigned lid, enum devicetype_t dtype)
+{
+	our_lid = lid;
+	devtype = DT_NONE;
+	for(unsigned i = 0; i < CONTROLS_COUNT; i++) {
+		int id = wxID_AUTOHOLD_FIRST + CONTROLS_COUNT * lid + i;
+		entries[i] = AppendCheckItem(id, towxstring(get_button_name(i)));
+	}
+	change_type(dtype);
+}
+
+void controller_autohold_menu::change_type(enum devicetype_t dtype)
+{
+	int pid = controller_index_by_logical(our_lid);
+	for(unsigned i = 0; i < CONTROLS_COUNT; i++) {
+		int pidx = get_physcial_id_for_control(dtype, i);
+		if(pidx >= 0) {
+			entries[i]->Check(pid > 0 && get_autohold(pid, pidx));
+			entries[i]->Enable();
+		} else {
+			entries[i]->Check(false);
+			entries[i]->Enable(false);
+		}
+	}
+	devtype = dtype;
+}
+
+bool controller_autohold_menu::is_dummy()
+{
+	return (devtype == DT_NONE);
+}
+
+void controller_autohold_menu::on_select(wxCommandEvent& e)
+{
+	int x = e.GetId();
+	if(x < wxID_AUTOHOLD_FIRST + our_lid * CONTROLS_COUNT || x >= wxID_AUTOHOLD_FIRST * (our_lid + 1) *
+		 CONTROLS_COUNT) {
+		return;
+	}
+	unsigned lidx = (x - wxID_AUTOHOLD_FIRST) % CONTROLS_COUNT;
+	int pidx = get_physcial_id_for_control(devtype, lidx);
+	int pid = controller_index_by_logical(our_lid);
+	if(pid < 0 || pidx < 0 || !entries[lidx]) {
+		return;
+	}
+	//Autohold change on pid=pid, ctrlindx=idx, state
+	bool newstate = entries[lidx]->IsChecked();
+	change_autohold(pid, pidx, newstate);
+}
+
+void controller_autohold_menu::update(unsigned pid, unsigned ctrlnum, bool newstate)
+{
+	int pid2 = controller_index_by_logical(our_lid);
+	if(pid2 < 0 || static_cast<unsigned>(pid) != pid2)
+		return;
+	for(unsigned i = 0; i < CONTROLS_COUNT; i++) {
+		int idx = get_physcial_id_for_control(devtype, i);
+		if(idx < 0 || static_cast<unsigned>(idx) != ctrlnum)
+			continue;
+		entries[i]->Check(newstate);
+	}
+}
+
+autohold_menu::autohold_menu()
+{
+	for(unsigned i = 0; i < MAXCONTROLLERS; i++) {
+		std::ostringstream str;
+		str << "Controller #&" << (i + 1);
+		menus[i] = new controller_autohold_menu(i, DT_NONE);
+		entries[i] = AppendSubMenu(menus[i], towxstring(str.str()));
+		entries[i]->Enable(!menus[i]->is_dummy());
+	}
+	reconfigure();
+}
+
+void autohold_menu::reconfigure()
+{
+	for(unsigned i = 0; i < MAXCONTROLLERS; i++) {
+		menus[i]->change_type(controller_type_by_logical(i));
+		entries[i]->Enable(!menus[i]->is_dummy());
+	}
+}
+
+void autohold_menu::on_select(wxCommandEvent& e)
+{
+	for(unsigned i = 0; i < MAXCONTROLLERS; i++)
+		menus[i]->on_select(e);
+}
+
+void autohold_menu::update(unsigned pid, unsigned ctrlnum, bool newstate)
+{
+	for(unsigned i = 0; i < MAXCONTROLLERS; i++)
+		menus[i]->update(pid, ctrlnum, newstate);
+}
+
+
+class emulator_main_window;
+
+class sound_listener : public window_callback
+{
+public:
+	sound_listener(emulator_main_window* w);
+	~sound_listener() throw();
+	void on_sound_unmute(bool unmute) throw();
+	void on_sound_change(const std::string& dev) throw();
+	void on_mode_change(bool readonly) throw();
+	void on_autohold_update(unsigned pid, unsigned ctrlnum, bool newstate);
+	void on_autohold_reconfigure();
+private:
+	emulator_main_window* win;
+};
+
+class emulator_main_panel : public wxPanel
+{
+public:
+	emulator_main_panel(wxWindow* win);
+	void on_paint(wxPaintEvent& e);
+	void on_erase(wxEraseEvent& e);
+	void on_keyboard_down(wxKeyEvent& e);
+	void on_keyboard_up(wxKeyEvent& e);
+	void on_mouse(wxMouseEvent& e);
+};
+
+class emulator_main_window : public wxFrame
+{
+public:
+	emulator_main_window(const std::string& name);
+	~emulator_main_window();
+	void on_idle(wxIdleEvent& e);
+	void on_close(wxCloseEvent& e);
+	void menu_pause(wxCommandEvent& e);
+	void menu_frameadvance(wxCommandEvent& e);
+	void menu_exit(wxCommandEvent& e);
+	void menu_subframeadvance(wxCommandEvent& e);
+	void menu_nextpoll(wxCommandEvent& e);
+	void menu_reset(wxCommandEvent& e);
+	void menu_audio_enable(wxCommandEvent& e);
+	void menu_audio_status(wxCommandEvent& e);
+	void menu_choose_audio_device(wxCommandEvent& e);
+	void menu_loadsave(wxCommandEvent& e);
+	void menu_scripting(wxCommandEvent& e);
+	void menu_readonly(wxCommandEvent& e);
+	void menu_edit_authors(wxCommandEvent& e);
+	void menu_edit_axes(wxCommandEvent& e);
+	void menu_edit_settings(wxCommandEvent& e);
+	void menu_edit_keybindings(wxCommandEvent& e);
+	void menu_edit_aliases(wxCommandEvent& e);
+	void menu_edit_memorywatch(wxCommandEvent& e);
+	void menu_load_memorywatch(wxCommandEvent& e);
+	void menu_save_memorywatch(wxCommandEvent& e);
+	void menu_handle_dump(wxCommandEvent& e);
+	void request_paint();
+	wxMenuItem* sound_enable;
+	wxMenuItem* readonly_enable;
+	autohold_menu* ahmenu;
+private:
+	emulator_main_panel* gpanel;
+	sound_listener* slistener;
+};
+
+namespace
+{
+
+	//Modifier table.
+	struct modifier_entry
+	{
+		int mod;
+		const char* name;
+		const char* lname;
+		modifier* allocated;
+	} modifiers[] = {
+		{ wxMOD_ALT, "alt", NULL, NULL },
+		{ wxMOD_CONTROL, "ctrl", NULL, NULL },
+		{ wxMOD_SHIFT, "shift", NULL, NULL },
+		{ wxMOD_META, "meta", NULL, NULL },
+#ifdef __WXMAC__
+		{ wxMOD_CMD, "cmd", NULL, NULL },
+#endif
+		{ 0, NULL, NULL }
+	};
+
+	struct key_entry
+	{
+		int keynum;
+		const char* name;
+		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 }
+	};
+
+	std::map<int, modifier*> modifier_map;
+	std::map<int, keygroup*> key_map;
+	std::map<std::string, int> keys_allocated;
+	std::set<int> keys_held;
+
+	void init_modifiers_and_keys()
+	{
+		static bool done = false;
+		if(done)
+			return;
+		modifier_entry* m = modifiers;
+		while(m->name) {
+			if(m->lname)
+				m->allocated = new modifier(m->name, m->lname);
+			else
+				m->allocated = new modifier(m->name);
+			modifier_map[m->mod] = m->allocated;
+			m++;
+		}
+		key_entry* k = keys;
+		while(k->name) {
+			if(!keys_allocated.count(k->name)) {
+				k->allocated = new keygroup(k->name, keygroup::KT_KEY);
+				key_map[k->keynum] = k->allocated;
+				keys_allocated[k->name] = k->keynum;
+			} else
+				key_map[k->keynum] = key_map[keys_allocated[k->name]];
+			k++;
+		}
+		done = true;
+	}
+
+	//The coroutine emulator itself runs in.
+	coroutine* emu_cr;
+	emulator_main_window* main_window = NULL;
+
+	struct emulator_boot_state
+	{
+		loaded_rom* rom;
+		moviefile* movie;
+	};
+
+	void emulator_bootup_fn(void* state)
+	{
+		try {
+			struct emulator_boot_state* boot_state = reinterpret_cast<struct emulator_boot_state*>(state);
+			main_loop(*boot_state->rom, *boot_state->movie);
+		} catch(std::bad_alloc& e) {
+			OOM_panic();
+		} catch(std::exception& e) {
+			messages << "FATAL: " << e.what() << std::endl;
+			fatal_error();
+			return;
+		}
+	}
+
+	void show_fps()
+	{
+		auto& emustatus = window::get_emustatus();
+		try {
+			std::ostringstream y;
+			y << get_framerate();
+			emustatus["FPS"] = y.str();
+		} catch(...) {
+		}
+	}
+
+	//Set to true if the emulator is in paused mode.
+	volatile bool e_paused;
+	//Set to true if the emulator is in waiting mode. wait_until is set to get_utime() time when emulator is
+	//to exit the wait.
+	volatile bool waiting;
+	volatile uint64_t wait_until;
+	//Set to true if the screen needs updating. screen_updated_full is set if update needs to be full.
+	volatile bool screen_updated;
+	volatile bool screen_updated_full;
+	//The backrequest type.
+	volatile int request;
+	//The modifier_set and the key (for REQ_KEY_PRESS and REQ_KEY_RELEASE).
+	modifier_set keypress_modifiers;
+	keygroup* presed_key;
+	//Command to send (for REQ_COMMAND).
+	std::string pending_command;
+	//The main screen
+	screen* main_screen;
+	unsigned char* screen_buffer;
+	uint32_t old_width = 0;
+	uint32_t old_height = 0;
+	//Message queue (undisplayed messages), and last message.
+	bool messages_need_painting;
+	std::string last_message;
+	//In modal dialog flag.
+	bool in_modal_dialog;
+	//Painting.
+	bool main_window_dirty = false;
+	//Audio devices.
+	std::map<int, std::string> audio_devs;
+	std::map<int, wxMenuItem*> audio_devitems;
+
+	void handle_idle(wxIdleEvent& e)
+	{
+		if(!emu_cr || in_modal_dialog) {
+			wxMilliSleep(1);
+			e.RequestMore();
+			return;
+		}
+		request = REQ_POLL_JOYSTICK;
+		emu_cr->resume();
+		if(e_paused || (waiting && wait_until > get_utime())) {
+			wxMilliSleep(1);
+			e.RequestMore();
+			return;
+		}
+		if(waiting)
+			waiting = false;
+		request = REQ_CONTINUE;
+		uint64_t exec_start = get_utime();
+loop:
+		emu_cr->resume();
+		if(emu_cr->is_dead()) {
+			//Bye!
+			if(window1)
+				window1->Destroy();
+			if(window2)
+				window2->Destroy();
+			delete emu_cr;
+			delete our_rom;
+			our_rom = NULL;
+			main_window->Destroy();
+			return;
+		}
+		if(get_utime() < exec_start + 10000 && !e_paused && !waiting)
+			goto loop;
+		show_fps();
+		e.RequestMore();
+	}
+
+	//Request keypress event to happen.
+	void do_keypress(modifier_set mods, keygroup& key, bool polarity)
+	{
+		if(!emu_cr)
+			return;
+		keypress_modifiers = mods;
+		presed_key = &key;
+		request = polarity ? REQ_KEY_PRESS : REQ_KEY_RELEASE;
+		emu_cr->resume();
+	}
+
+	void handle_wx_keyboard(wxKeyEvent& e, bool polarity)
+	{
+		int mods = e.GetModifiers();
+		int keyc = e.GetKeyCode();
+		modifier_set mset;
+		modifier_entry* m = modifiers;
+		while(m->name) {
+			if((keyc & m->mod) == m->mod) {
+				mset.add(*m->allocated);
+			}
+			m++;
+		}
+		if(polarity) {
+			if(keys_held.count(keyc)) {
+				e.Skip();
+				return;
+			}
+			keys_held.insert(keyc);
+		} else
+			keys_held.erase(keyc);
+		key_entry* k = keys;
+		keygroup* grp = NULL;
+		while(k->name) {
+			if(k->keynum == keyc) {
+				grp = k->allocated;
+				break;
+			}
+			k++;
+		}
+		if(grp)
+			do_keypress(mset, *grp, polarity);
+		e.Skip();
+	}
+
+	void handle_wx_mouse(wxMouseEvent& e)
+	{
+		static uint32_t mask = 0;
+		if(e.LeftDown())
+			mask |= 1;
+		if(e.LeftUp())
+			mask &= ~1;
+		if(e.MiddleDown())
+			mask |= 2;
+		if(e.MiddleUp())
+			mask &= ~2;
+		if(e.RightDown())
+			mask |= 4;
+		if(e.RightUp())
+			mask &= ~4;
+		window_callback::do_click(e.GetX(), e.GetY(), mask);
+	}
+}
+
+void emulator_main_panel::on_keyboard_down(wxKeyEvent& e)
+{
+	handle_wx_keyboard(e, true);
+}
+
+void emulator_main_panel::on_keyboard_up(wxKeyEvent& e)
+{
+	handle_wx_keyboard(e, false);
+}
+
+void emulator_main_panel::on_mouse(wxMouseEvent& e)
+{
+	handle_wx_mouse(e);
+}
+
+
+emulator_main_panel::emulator_main_panel(wxWindow* win)
+	: wxPanel(win)
+{
+	this->Connect(wxEVT_PAINT, wxPaintEventHandler(emulator_main_panel::on_paint), NULL, this);
+	this->Connect(wxEVT_ERASE_BACKGROUND, wxEraseEventHandler(emulator_main_panel::on_erase), NULL, this);
+	this->Connect(wxEVT_KEY_DOWN, wxKeyEventHandler(emulator_main_panel::on_keyboard_down), NULL, this);
+	this->Connect(wxEVT_KEY_UP, wxKeyEventHandler(emulator_main_panel::on_keyboard_up), NULL, this);
+	this->Connect(wxEVT_LEFT_DOWN, wxMouseEventHandler(emulator_main_panel::on_mouse), NULL, this);
+	this->Connect(wxEVT_LEFT_UP, wxMouseEventHandler(emulator_main_panel::on_mouse), NULL, this);
+	this->Connect(wxEVT_MIDDLE_DOWN, wxMouseEventHandler(emulator_main_panel::on_mouse), NULL, this);
+	this->Connect(wxEVT_MIDDLE_UP, wxMouseEventHandler(emulator_main_panel::on_mouse), NULL, this);
+	this->Connect(wxEVT_RIGHT_DOWN, wxMouseEventHandler(emulator_main_panel::on_mouse), NULL, this);
+	this->Connect(wxEVT_RIGHT_UP, wxMouseEventHandler(emulator_main_panel::on_mouse), NULL, this);
+	SetMinSize(wxSize(512, 448));
+}
+
+void emulator_main_panel::on_paint(wxPaintEvent& e)
+{
+	static struct SwsContext* ctx;
+	uint8_t* srcp[1];
+	int srcs[1];
+	uint8_t* dstp[1];
+	int dsts[1];
+	wxPaintDC dc(this);
+	if(!main_screen)
+		return;
+	if(main_screen->width != old_width || main_screen->height != old_height) {
+		delete[] screen_buffer;
+		screen_buffer = new unsigned char[main_screen->width * main_screen->height * 3];
+		old_height = main_screen->height;
+		old_width = main_screen->width;
+		uint32_t w = main_screen->width;
+		uint32_t h = main_screen->height;
+		ctx = sws_getCachedContext(ctx, w, h, PIX_FMT_RGBA, w, h, PIX_FMT_BGR24, SWS_POINT |
+			SWS_CPU_CAPS_MMX2, NULL, NULL, NULL);
+		if(w < 512)
+			w = 512;
+		if(h < 448)
+			h = 448;
+		SetMinSize(wxSize(w, h));
+	}
+	srcs[0] = 4 * main_screen->width;
+	dsts[0] = 3 * main_screen->width;
+	srcp[0] = reinterpret_cast<unsigned char*>(main_screen->memory);
+	dstp[0] = screen_buffer;
+	memset(screen_buffer, 0, main_screen->width * main_screen->height * 3);
+	uint64_t t1 = get_utime();
+	sws_scale(ctx, srcp, srcs, 0, main_screen->height, dstp, dsts);
+	uint64_t t2 = get_utime();
+	wxBitmap bmp(wxImage(main_screen->width, main_screen->height, screen_buffer, true));
+	uint64_t t3 = get_utime();
+	dc.DrawBitmap(bmp, 0, 0, false);
+	main_window_dirty = false;
+}
+
+void emulator_main_panel::on_erase(wxEraseEvent& e)
+{
+}
+
+emulator_main_window::emulator_main_window(const std::string& name)
+	: wxFrame(NULL, wxID_ANY, towxstring(name), wxDefaultPosition, wxSize(-1, -1), primary_window_style)
+{
+	Centre();
+	wxFlexGridSizer* top_s = new wxFlexGridSizer(1, 1, 0, 0);
+	top_s->Add(gpanel = new emulator_main_panel(this), 1, wxGROW);
+	top_s->SetSizeHints(this);
+	SetSizer(top_s);
+	Fit();
+	Connect(wxEVT_IDLE, wxIdleEventHandler(emulator_main_window::on_idle));
+	Connect(wxEVT_CLOSE_WINDOW, wxCloseEventHandler(emulator_main_window::on_close));
+	wxIdleEvent event;
+	event.SetEventObject(this);
+	AddPendingEvent(event);
+	gpanel->SetFocus();
+
+	wxMenuBar* menubar = new wxMenuBar;
+	wxMenu* system = new wxMenu;
+	wxMenu* sound = new wxMenu;
+	wxMenu* file = new wxMenu;
+	wxMenu* scripting = new wxMenu;
+	wxMenu* settings = new wxMenu;
+	wxMenu* dump = new wxMenu;
+	ahmenu = new autohold_menu();
+	SetMenuBar(menubar);
+	//Main menubar: ACFOS
+	menubar->Append(system, wxT("&System"));
+	menubar->Append(file, wxT("&File"));
+	menubar->Append(ahmenu, wxT("&Autohold"));
+	menubar->Append(scripting, wxT("S&cripting"));
+	menubar->Append(settings, wxT("Settings"));
+	if(window::sound_initialized())
+		menubar->Append(sound, wxT("S&ound"));
+	//System menu: EMNPQRU
+	system->Append(wxID_FRAMEADVANCE, wxT("Fra&me advance"));
+	system->Append(wxID_SUBFRAMEADVANCE, wxT("S&ubframe advance"));
+	system->Append(wxID_NEXTPOLL, wxT("&Next poll"));
+	system->Append(wxID_PAUSE, wxT("&Pause/Unpause"));
+	system->AppendSeparator();
+	system->Append(wxID_ERESET, wxT("&Reset"));
+	system->AppendSeparator();
+	system->Append(wxID_EDIT_AUTHORS, wxT("&Edit game name && authors"));
+	system->AppendSeparator();
+	system->Append(wxID_EXIT, wxT("&Quit"));
+	//File menu: DELMNPRTV
+	readonly_enable = file->AppendCheckItem(wxID_READONLY_MODE, wxT("Reado&nly mode"));
+	readonly_enable->Check(movb.get_movie().readonly_mode());
+	file->AppendSeparator();
+	file->Append(wxID_SAVE_STATE, wxT("Save stat&e"));
+	file->Append(wxID_SAVE_MOVIE, wxT("Sa&ve movie"));
+	file->AppendSeparator();
+	file->Append(wxID_LOAD_STATE, wxT("&Load state"));
+	file->Append(wxID_LOAD_STATE_RO, wxT("Loa&d state (readonly)"));
+	file->Append(wxID_LOAD_STATE_RW, wxT("Load s&tate (read-write)"));
+	file->Append(wxID_LOAD_STATE_P, wxT("Load state (&preserve)"));
+	file->Append(wxID_LOAD_MOVIE, wxT("Load &movie"));
+	file->AppendSeparator();
+	file->Append(wxID_SAVE_SCREENSHOT, wxT("Save sc&reenshot"));
+	file->AppendSeparator();
+	file->AppendSubMenu(dump, wxT("Video dump"));
+	dump->Append(wxID_DUMP_AVICSCD, wxT("Dump AVI(CSCD)"));
+	dump->Append(wxID_END_AVICSCD, wxT("End AVI(CSCD) dump"));
+	dump->AppendSeparator();
+	dump->Append(wxID_DUMP_JMD, wxT("Dump JMD"));
+	dump->Append(wxID_END_JMD, wxT("End JMD dump"));
+	dump->AppendSeparator();
+	dump->Append(wxID_DUMP_SDMP, wxT("Dump SDMP"));
+	dump->Append(wxID_END_SDMP, wxT("End SDMP dump"));
+	//Scripting menu: ERU
+	scripting->Append(wxID_RUN_SCRIPT, wxT("&Run script"));
+	if(lua_supported) {
+		scripting->AppendSeparator();
+		scripting->Append(wxID_EVAL_LUA, wxT("&Evaluate Lua statement"));
+		scripting->Append(wxID_RUN_LUA, wxT("R&un Lua script"));
+	}
+	scripting->AppendSeparator();
+	scripting->Append(wxID_EDIT_MEMORYWATCH, wxT("Edit memory watch"));
+	scripting->AppendSeparator();
+	scripting->Append(wxID_LOAD_MEMORYWATCH, wxT("Load memory watch"));
+	scripting->Append(wxID_SAVE_MEMORYWATCH, wxT("Save memory watch"));
+	//Settings menu.
+	settings->Append(wxID_EDIT_AXES, wxT("Configure axes"));
+	settings->Append(wxID_EDIT_SETTINGS, wxT("Configure settings"));
+	settings->Append(wxID_EDIT_KEYBINDINGS, wxT("Configure keybindings"));
+	settings->Append(wxID_EDIT_ALIAS, wxT("Configure aliases"));
+	//Sound menu U
+	sound_enable = NULL;
+	if(window::sound_initialized()) {
+		slistener = new sound_listener(this);
+		sound_enable = sound->AppendCheckItem(wxID_AUDIO_ENABLED, wxT("So&unds enabled"));
+		sound_enable->Check(window::is_sound_enabled());
+		sound->Append(wxID_SHOW_AUDIO_STATUS, wxT("Show audio status"));
+		sound->AppendSeparator();
+		int j = wxID_AUDIODEV_FIRST;
+		std::string curdev = window::get_current_sound_device();
+		for(auto i : window::get_sound_devices()) {
+			audio_devitems[j] = sound->AppendRadioItem(j, towxstring(i.first + "(" + i.second + ")"));
+			audio_devs[j] = i.first;
+			if(i.first == curdev)
+				audio_devitems[j]->Check();
+			j++;
+		}
+	}
+
+	menu_action(this, wxID_PAUSE, &emulator_main_window::menu_pause);
+	menu_action(this, wxID_FRAMEADVANCE, &emulator_main_window::menu_frameadvance);
+	menu_action(this, wxID_SUBFRAMEADVANCE, &emulator_main_window::menu_subframeadvance);
+	menu_action(this, wxID_NEXTPOLL, &emulator_main_window::menu_nextpoll);
+	menu_action(this, wxID_ERESET, &emulator_main_window::menu_reset);
+	menu_action(this, wxID_EXIT, &emulator_main_window::menu_exit);
+	menu_action(this, wxID_READONLY_MODE, &emulator_main_window::menu_readonly);
+	menu_action(this, wxID_SAVE_STATE, &emulator_main_window::menu_loadsave);
+	menu_action(this, wxID_SAVE_MOVIE, &emulator_main_window::menu_loadsave);
+	menu_action(this, wxID_LOAD_STATE, &emulator_main_window::menu_loadsave);
+	menu_action(this, wxID_LOAD_STATE_RO, &emulator_main_window::menu_loadsave);
+	menu_action(this, wxID_LOAD_STATE_RW, &emulator_main_window::menu_loadsave);
+	menu_action(this, wxID_LOAD_STATE_P, &emulator_main_window::menu_loadsave);
+	menu_action(this, wxID_LOAD_MOVIE, &emulator_main_window::menu_loadsave);
+	menu_action(this, wxID_SAVE_SCREENSHOT, &emulator_main_window::menu_loadsave);
+	menu_action(this, wxID_DUMP_AVICSCD, &emulator_main_window::menu_handle_dump);
+	menu_action(this, wxID_DUMP_JMD, &emulator_main_window::menu_handle_dump);
+	menu_action(this, wxID_DUMP_SDMP, &emulator_main_window::menu_handle_dump);
+	menu_action(this, wxID_END_AVICSCD, &emulator_main_window::menu_handle_dump);
+	menu_action(this, wxID_END_JMD, &emulator_main_window::menu_handle_dump);
+	menu_action(this, wxID_END_SDMP, &emulator_main_window::menu_handle_dump);
+	menu_action(this, wxID_RUN_SCRIPT, &emulator_main_window::menu_scripting);
+	menu_action(this, wxID_EDIT_AUTHORS, &emulator_main_window::menu_edit_authors);
+	Connect(wxID_AUTOHOLD_FIRST, wxID_AUTOHOLD_LAST, wxEVT_COMMAND_MENU_SELECTED,
+		wxCommandEventHandler(autohold_menu::on_select), NULL, ahmenu);
+	if(lua_supported) {
+		menu_action(this, wxID_EVAL_LUA, &emulator_main_window::menu_scripting);
+		menu_action(this, wxID_RUN_LUA, &emulator_main_window::menu_scripting);
+	}
+	menu_action(this, wxID_EDIT_MEMORYWATCH, &emulator_main_window::menu_edit_memorywatch);
+	menu_action(this, wxID_LOAD_MEMORYWATCH, &emulator_main_window::menu_load_memorywatch);
+	menu_action(this, wxID_SAVE_MEMORYWATCH, &emulator_main_window::menu_save_memorywatch);
+	menu_action(this, wxID_EDIT_AXES, &emulator_main_window::menu_edit_axes);
+	menu_action(this, wxID_EDIT_SETTINGS, &emulator_main_window::menu_edit_settings);
+	menu_action(this, wxID_EDIT_KEYBINDINGS, &emulator_main_window::menu_edit_keybindings);
+	menu_action(this, wxID_EDIT_ALIAS, &emulator_main_window::menu_edit_aliases);
+	if(window::sound_initialized()) {
+		menu_action(this, wxID_AUDIO_ENABLED, &emulator_main_window::menu_audio_enable);
+		menu_action(this, wxID_SHOW_AUDIO_STATUS, &emulator_main_window::menu_audio_status);
+		for(auto i : audio_devs)
+			menu_action(this, i.first, &emulator_main_window::menu_choose_audio_device);
+	}
+}
+
+emulator_main_window::~emulator_main_window()
+{
+	delete slistener;
+}
+
+void emulator_main_window::request_paint()
+{
+	gpanel->Refresh();
+}
+
+void emulator_main_window::on_idle(wxIdleEvent& e)
+{
+	handle_idle(e);
+}
+
+void emulator_main_window::on_close(wxCloseEvent& e)
+{
+	//Veto it for now, latter things will delete it.
+	e.Veto();
+	exec_command("quit-emulator");
+}
+
+void emulator_main_window::menu_pause(wxCommandEvent& e)
+{
+	exec_command("pause-emulator");
+}
+
+void emulator_main_window::menu_frameadvance(wxCommandEvent& e)
+{
+	exec_command("+advance-frame");
+	exec_command("-advance-frame");
+}
+
+void emulator_main_window::menu_subframeadvance(wxCommandEvent& e)
+{
+	exec_command("+advance-poll");
+	exec_command("-advance-poll");
+}
+
+void emulator_main_window::menu_nextpoll(wxCommandEvent& e)
+{
+	exec_command("advance-skiplag");
+}
+
+void emulator_main_window::menu_reset(wxCommandEvent& e)
+{
+	exec_command("reset");
+}
+
+void emulator_main_window::menu_exit(wxCommandEvent& e)
+{
+	exec_command("quit-emulator");
+}
+
+void emulator_main_window::menu_audio_enable(wxCommandEvent& e)
+{
+	window::sound_enable(sound_enable->IsChecked());
+}
+
+void emulator_main_window::menu_readonly(wxCommandEvent& e)
+{
+	bool s = readonly_enable->IsChecked();
+	movb.get_movie().readonly_mode(s);
+	if(!s)
+		lua_callback_do_readwrite();
+	update_movie_state();
+	window::notify_screen_update();
+}
+
+void emulator_main_window::menu_edit_authors(wxCommandEvent& e)
+{
+	wxDialog* editor = new wx_authors_editor(this);
+	editor->ShowModal();
+	editor->Destroy();
+}
+
+void emulator_main_window::menu_edit_axes(wxCommandEvent& e)
+{
+	wxDialog* editor = new wx_axes_editor(this);
+	editor->ShowModal();
+	editor->Destroy();
+}
+
+void emulator_main_window::menu_edit_settings(wxCommandEvent& e)
+{
+	wxDialog* editor = new wx_settings_editor(this);
+	editor->ShowModal();
+	editor->Destroy();
+}
+
+#define NEW_KEYBINDING "A new binding..."
+#define NEW_ALIAS "A new alias..."
+#define NEW_WATCH "A new watch..."
+
+void emulator_main_window::menu_edit_keybindings(wxCommandEvent& e)
+{
+	std::set<std::string> bind = keymapper::get_bindings();
+	std::vector<wxString> choices;
+	choices.push_back(wxT(NEW_KEYBINDING));
+	for(auto i : bind)
+		choices.push_back(towxstring(i));
+	wxSingleChoiceDialog* d = new wxSingleChoiceDialog(this, wxT("Select keybinding to edit"),
+		wxT("Select binding"), choices.size(), &choices[0]);
+	if(d->ShowModal() == wxID_CANCEL) {
+		d->Destroy();
+		return;
+	}
+	std::string key = tostdstring(d->GetStringSelection());
+	d->Destroy();
+	if(key == NEW_KEYBINDING) {
+		wx_key_entry* d2 = new wx_key_entry(this);
+		//wxTextEntryDialog* d2 = new wxTextEntryDialog(this, wxT("Enter key for binding:"),
+		//	wxT("Edit binding"), wxT(""));
+		if(d2->ShowModal() == wxID_CANCEL) {
+			d2->Destroy();
+			return;
+		}
+		key = d2->getkey();
+		//key = tostdstring(d2->GetValue());
+		d2->Destroy();
+	}
+	std::string old_command_value = keymapper::get_command_for(key);
+	wxTextEntryDialog* d4 = new wxTextEntryDialog(this, wxT("Enter new command for binding:"), wxT("Edit binding"),
+		towxstring(old_command_value));
+	if(d4->ShowModal() == wxID_CANCEL) {
+		d4->Destroy();
+		return;
+	}
+	try {
+		keymapper::bind_for(key, tostdstring(d4->GetValue()));
+	} catch(std::exception& e) {
+		wxMessageDialog* d3 = new wxMessageDialog(this, towxstring(std::string("Can't bind key: ") +
+			e.what()), wxT("Error"), wxOK | wxICON_EXCLAMATION);
+		d3->ShowModal();
+		d3->Destroy();
+	}
+	d4->Destroy();
+}
+
+void emulator_main_window::menu_edit_aliases(wxCommandEvent& e)
+{
+	std::set<std::string> bind = command::get_aliases();
+	std::vector<wxString> choices;
+	choices.push_back(wxT(NEW_ALIAS));
+	for(auto i : bind)
+		choices.push_back(towxstring(i));
+	wxSingleChoiceDialog* d = new wxSingleChoiceDialog(this, wxT("Select alias to edit"),
+		wxT("Select alias"), choices.size(), &choices[0]);
+	if(d->ShowModal() == wxID_CANCEL) {
+		d->Destroy();
+		return;
+	}
+	std::string alias = tostdstring(d->GetStringSelection());
+	d->Destroy();
+	if(alias == NEW_ALIAS) {
+		wxTextEntryDialog* d2 = new wxTextEntryDialog(this, wxT("Enter name for the new alias:"),
+			wxT("Enter alias name"));
+		if(d2->ShowModal() == wxID_CANCEL) {
+			d2->Destroy();
+			return;
+		}
+		alias = tostdstring(d2->GetValue());
+		d2->Destroy();
+		if(!command::valid_alias_name(alias)) {
+			wxMessageDialog* d3 = new wxMessageDialog(this, towxstring(std::string("Not a valid alias "
+			"name: ") + alias), wxT("Error"), wxOK | wxICON_EXCLAMATION);
+			d3->ShowModal();
+			d3->Destroy();
+			return;
+		}
+	}
+	std::string old_alias_value = command::get_alias_for(alias);
+	wxTextEntryDialog* d4 = new wxTextEntryDialog(this, wxT("Enter new commands for alias:"), wxT("Edit alias"),
+		towxstring(old_alias_value), wxOK | wxCANCEL | wxCENTRE | wxTE_MULTILINE);
+	if(d4->ShowModal() == wxID_CANCEL) {
+		d4->Destroy();
+		return;
+	}
+	command::set_alias_for(alias, tostdstring(d4->GetValue()));
+	d4->Destroy();
+}
+
+void emulator_main_window::menu_load_memorywatch(wxCommandEvent& e)
+{
+	std::set<std::string> old_watches = get_watches();
+	std::map<std::string, std::string> new_watches;
+	std::string filename;
+
+	wxFileDialog* d = new wxFileDialog(this, towxstring("Choose memory watch file"), wxT("."));
+	if(d->ShowModal() == wxID_CANCEL) {
+		d->Destroy();
+		return;
+	}
+	filename = tostdstring(d->GetPath());
+	d->Destroy();
+	//Did we pick a .zip file?
+	try {
+		zip_reader zr(filename);
+		std::vector<wxString> files;
+		for(auto i : zr)
+			files.push_back(towxstring(i));
+		wxSingleChoiceDialog* d2 = new wxSingleChoiceDialog(this, wxT("Select file within .zip"),
+			wxT("Select member"), files.size(), &files[0]);
+		if(d2->ShowModal() == wxID_CANCEL) {
+			d2->Destroy();
+			return;
+		}
+		filename = filename + "/" + tostdstring(d2->GetStringSelection());
+		d2->Destroy();
+	} catch(...) {
+		//Ignore error.
+	}
+
+	try {
+		std::istream& in = open_file_relative(filename, "");
+		while(in) {
+			std::string wname;
+			std::string wexpr;
+			std::getline(in, wname);
+			std::getline(in, wexpr);
+			new_watches[wname] = wexpr;
+		}
+		delete &in;
+	} catch(std::exception& e) {
+		wxMessageDialog* d3 = new wxMessageDialog(this, towxstring(std::string("Can't load memory "
+			"watch: ") + e.what()), wxT("Error"), wxOK | wxICON_EXCLAMATION);
+		d3->ShowModal();
+		d3->Destroy();
+	}
+
+	for(auto i : new_watches)
+		set_watchexpr_for(i.first, i.second);
+	for(auto i : old_watches)
+		if(!new_watches.count(i))
+			set_watchexpr_for(i, "");
+}
+
+void emulator_main_window::menu_save_memorywatch(wxCommandEvent& e)
+{
+	std::set<std::string> old_watches = get_watches();
+	std::string filename;
+
+	wxFileDialog* d = new wxFileDialog(this, towxstring("Save watches to file"), wxT("."));
+	if(d->ShowModal() == wxID_CANCEL) {
+		d->Destroy();
+		return;
+	}
+	filename = tostdstring(d->GetPath());
+	d->Destroy();
+
+	std::ofstream out(filename.c_str());
+	for(auto i : old_watches)
+		out << i << std::endl << get_watchexpr_for(i) << std::endl;
+	out.close();
+}
+
+
+void emulator_main_window::menu_edit_memorywatch(wxCommandEvent& e)
+{
+	std::set<std::string> bind = get_watches();
+	std::vector<wxString> choices;
+	choices.push_back(wxT(NEW_WATCH));
+	for(auto i : bind)
+		choices.push_back(towxstring(i));
+	wxSingleChoiceDialog* d = new wxSingleChoiceDialog(this, wxT("Select watch to edit"),
+		wxT("Select watch"), choices.size(), &choices[0]);
+	if(d->ShowModal() == wxID_CANCEL) {
+		d->Destroy();
+		return;
+	}
+	std::string watch = tostdstring(d->GetStringSelection());
+	d->Destroy();
+	if(watch == NEW_WATCH) {
+		wxTextEntryDialog* d2 = new wxTextEntryDialog(this, wxT("Enter name for the new watch:"),
+			wxT("Enter watch name"));
+		if(d2->ShowModal() == wxID_CANCEL) {
+			d2->Destroy();
+			return;
+		}
+		watch = tostdstring(d2->GetValue());
+		d2->Destroy();
+	}
+	std::string old_watch_value = get_watchexpr_for(watch);
+	wxTextEntryDialog* d4 = new wxTextEntryDialog(this, wxT("Enter new expression for watch:"), wxT("Edit watch"),
+		towxstring(old_watch_value), wxOK | wxCANCEL | wxCENTRE);
+	if(d4->ShowModal() == wxID_CANCEL) {
+		d4->Destroy();
+		return;
+	}
+	set_watchexpr_for(watch, tostdstring(d4->GetValue()));
+	d4->Destroy();
+}
+
+void emulator_main_window::menu_handle_dump(wxCommandEvent& e)
+{
+	wxString choices[19];
+	size_t choice_count = 0;
+	switch(e.GetId()) {
+	case wxID_END_AVICSCD:
+		exec_command("end-avi");
+		return;
+	case wxID_END_JMD:
+		exec_command("end-jmd");
+		return;
+	case wxID_END_SDMP:
+		exec_command("end-sdmp");
+		return;
+	default:
+		break;
+	};
+	bool is_prefix = false;
+	bool has_level = false;
+	std::string msg;
+	std::string caption;
+	std::string cmd;
+	switch(e.GetId()) {
+	case wxID_DUMP_AVICSCD:
+		choices[choice_count++] = wxT("Compression Level 0 intraframe-only");
+		choices[choice_count++] = wxT("Compression Level 1 intraframe-only");
+		choices[choice_count++] = wxT("Compression Level 2 intraframe-only");
+		choices[choice_count++] = wxT("Compression Level 3 intraframe-only");
+		choices[choice_count++] = wxT("Compression Level 4 intraframe-only");
+		choices[choice_count++] = wxT("Compression Level 5 intraframe-only");
+		choices[choice_count++] = wxT("Compression Level 6 intraframe-only");
+		choices[choice_count++] = wxT("Compression Level 7 intraframe-only");
+		choices[choice_count++] = wxT("Compression Level 8 intraframe-only");
+		choices[choice_count++] = wxT("Compression Level 9 intraframe-only");
+		choices[choice_count++] = wxT("Compression Level 1");
+		choices[choice_count++] = wxT("Compression Level 2");
+		choices[choice_count++] = wxT("Compression Level 3");
+		choices[choice_count++] = wxT("Compression Level 4");
+		choices[choice_count++] = wxT("Compression Level 5");
+		choices[choice_count++] = wxT("Compression Level 6");
+		choices[choice_count++] = wxT("Compression Level 7");
+		choices[choice_count++] = wxT("Compression Level 8");
+		choices[choice_count++] = wxT("Compression Level 9");
+		msg = "Choose CSCD compression level: ";
+		caption = "AVI(CSCD) dump";
+		is_prefix = true;
+		cmd = "dump-avi";
+		has_level = true;
+		break;
+	case wxID_DUMP_JMD:
+		choices[choice_count++] = wxT("Compression Level 0");
+		choices[choice_count++] = wxT("Compression Level 1");
+		choices[choice_count++] = wxT("Compression Level 2");
+		choices[choice_count++] = wxT("Compression Level 3");
+		choices[choice_count++] = wxT("Compression Level 4");
+		choices[choice_count++] = wxT("Compression Level 5");
+		choices[choice_count++] = wxT("Compression Level 6");
+		choices[choice_count++] = wxT("Compression Level 7");
+		choices[choice_count++] = wxT("Compression Level 8");
+		choices[choice_count++] = wxT("Compression Level 9");
+		msg = "Choose JMD compression level: ";
+		caption = "JMD dump";
+		is_prefix = false;
+		cmd = "dump-jmd";
+		has_level = true;
+		break;
+	case wxID_DUMP_SDMP:
+		choices[choice_count++] = wxT("Segmented");
+		choices[choice_count++] = wxT("Single segment");
+		msg = "Choose SDMP settings: ";
+		caption = "SDMP dump";
+		is_prefix = false;
+		cmd = "dump-sdmpss";
+		has_level = false;
+		break;
+	}
+	wxSingleChoiceDialog* d = new wxSingleChoiceDialog(this, towxstring(msg), towxstring(caption), choice_count,
+		choices);
+	if(d->ShowModal() == wxID_CANCEL) {
+		d->Destroy();
+		return;
+	}
+	int choice = d->GetSelection();
+	std::cerr << "choice=" << choice << std::endl;
+	if(e.GetId() == wxID_DUMP_SDMP && choice == 0) {
+		cmd = "dump-sdmp";
+		is_prefix = true;
+	}
+	d->Destroy();
+
+	std::string prefix;
+	wxFileDialog* d2 = new wxFileDialog(this, is_prefix ? wxT("Dump prefix") : wxT("Dump file"), wxT("."));
+	if(d2->ShowModal() == wxID_OK)
+		prefix = tostdstring(d2->GetPath());
+	d2->Destroy();
+
+	std::ostringstream str;
+	str << cmd;
+	if(has_level)
+		str << " " << choice;
+	str << " " << prefix;
+	exec_command(str.str());
+}
+
+
+void emulator_main_window::menu_audio_status(wxCommandEvent& e)
+{
+	exec_command("show-sound-status");
+}
+
+void emulator_main_window::menu_choose_audio_device(wxCommandEvent& e)
+{
+	if(!audio_devs.count(e.GetId()))
+		return;		//Not supposed to happen.
+	window::set_sound_device(audio_devs[e.GetId()]);
+}
+
+void emulator_main_window::menu_loadsave(wxCommandEvent& e)
+{
+	int id = e.GetId();
+	bool is_save = (id == wxID_SAVE_MOVIE || id == wxID_SAVE_STATE || id == wxID_SAVE_SCREENSHOT);
+	std::string filename;
+
+	wxFileDialog* d = new wxFileDialog(this, is_save ? wxT("Save") : wxT("Load"), wxT("."));
+	if(d->ShowModal() == wxID_OK)
+		filename = tostdstring(d->GetPath());
+	d->Destroy();
+	if(filename == "")
+		return;
+
+	switch(id) {
+	case wxID_LOAD_MOVIE:
+		exec_command("load-movie " + filename);
+		break;
+	case wxID_LOAD_STATE:
+		exec_command("load " + filename);
+		break;
+	case wxID_LOAD_STATE_RO:
+		exec_command("load-readonly " + filename);
+		break;
+	case wxID_LOAD_STATE_RW:
+		exec_command("load-state " + filename);
+		break;
+	case wxID_SAVE_MOVIE:
+		exec_command("save-movie " + filename);
+		break;
+	case wxID_SAVE_STATE:
+		exec_command("save-state " + filename);
+		break;
+	case wxID_SAVE_SCREENSHOT:
+		exec_command("take-screenshot " + filename);
+		break;
+	}
+}
+
+void emulator_main_window::menu_scripting(wxCommandEvent& e)
+{
+	int id = e.GetId();
+	bool file = (id == wxID_RUN_LUA || id == wxID_RUN_SCRIPT);
+	std::string name;
+	
+	if(file) {
+		wxFileDialog* d = new wxFileDialog(this, wxT("Select Script"), wxT("."));
+		if(d->ShowModal() == wxID_OK)
+			name = tostdstring(d->GetPath());
+		d->Destroy();
+	} else {
+		wxTextEntryDialog* d = new wxTextEntryDialog(this, wxT("Enter Lua statement:"),
+			wxT("Evaluate Lua"));
+		if(d->ShowModal() == wxID_OK)
+			name = tostdstring(d->GetValue());
+		d->Destroy();
+	}
+	if(name == "")
+		return;
+	
+	switch(id) {
+	case wxID_RUN_SCRIPT:
+		exec_command("run-script " + name);
+		break;
+	case wxID_EVAL_LUA:
+		exec_command("evaluate-lua " + name);
+		break;
+	case wxID_RUN_LUA:
+		exec_command("run-lua " + name);
+		break;
+	}
+}
+
+sound_listener::sound_listener(emulator_main_window* w)
+{
+	win = w;
+}
+
+sound_listener::~sound_listener() throw()
+{
+}
+
+void sound_listener::on_sound_unmute(bool unmute) throw()
+{
+	if(win && win->sound_enable)
+		win->sound_enable->Check(unmute);
+}
+
+void sound_listener::on_mode_change(bool readonly) throw()
+{
+	if(win && win->readonly_enable)
+		win->readonly_enable->Check(readonly);
+}
+
+void sound_listener::on_autohold_update(unsigned pid, unsigned ctrlnum, bool newstate)
+{
+	if(win && win->ahmenu)
+		win->ahmenu->update(pid, ctrlnum, newstate);
+}
+
+void sound_listener::on_autohold_reconfigure()
+{
+	if(win && win->ahmenu)
+		win->ahmenu->reconfigure();
+}
+
+void sound_listener::on_sound_change(const std::string& dev) throw()
+{
+	int j = wxID_ANY;
+	for(auto i : audio_devs) {
+		if(dev == i.second) {
+			j = i.first;
+			break;
+		}
+	}
+	if(j == wxID_ANY)
+		return;
+	audio_devitems[j]->Check();
+}
+
+void boot_emulator(loaded_rom& rom, moviefile& movie)
+{
+	wx_status_window* status = new wx_status_window();
+	window2 = status;
+	status->Show();
+	std::string windowname = "lsnes-" + lsnes_version + "[" + bsnes_core_version + "]";
+	main_window = new emulator_main_window(windowname);
+	struct emulator_boot_state s;
+	s.rom = &rom;
+	s.movie = &movie;
+	emu_cr = new coroutine(emulator_bootup_fn, &s, STACKSIZE);
+	messages << "Started emulator main coroutine" << std::endl;
+	//Delete the rom and movie. They aren't needed anymore.
+	delete &movie;
+	main_window->Show();
+}
+
+void exec_command(const std::string& cmd)
+{
+	if(!emu_cr)
+		return;
+	pending_command = cmd;
+	request = REQ_COMMAND;
+	emu_cr->resume();
+}
+
+
+void window::poll_inputs() throw(std::bad_alloc)
+{
+	do {
+		coroutine::yield();
+		if(request == REQ_POLL_JOYSTICK)
+			window::poll_joysticks();
+		if(request == REQ_KEY_PRESS)
+			presed_key->set_position(1, keypress_modifiers);
+		if(request == REQ_KEY_RELEASE)
+			presed_key->set_position(0, keypress_modifiers);
+		if(request == REQ_CONTINUE)
+			break;
+		if(request == REQ_COMMAND)
+			command::invokeC(pending_command);
+	} while(1);
+}
+
+void window::notify_screen_update(bool full) throw()
+{
+	screen_updated_full = true;
+	screen_updated = true;
+	if(main_window && !main_window_dirty) {
+		main_window_dirty = true;
+		main_window->request_paint();
+	}
+	if(wx_status_window::ptr)
+		wx_status_window::ptr->notify_status_change();
+}
+
+void window::set_main_surface(screen& scr) throw()
+{
+	main_screen = &scr;
+	screen_updated_full = true;
+	screen_updated = true;
+}
+
+void window::paused(bool enable) throw()
+{
+	e_paused = enable;
+	screen_updated = true;
+}
+
+void window::wait_usec(uint64_t usec) throw(std::bad_alloc)
+{
+	waiting = true;
+	wait_until = get_utime() + usec;
+	poll_inputs();
+}
+
+void window::cancel_wait() throw()
+{
+	waiting = false;
+}
+
+void window::fatal_error2() throw()
+{
+	in_modal_dialog = true;
+	std::string err = "Unknown fatal error occured";
+	if(window::msgbuf.get_msg_count() > 0)
+		err = window::msgbuf.get_message(window::msgbuf.get_msg_first() + window::msgbuf.get_msg_count() - 1);
+	wxMessageDialog* d = new wxMessageDialog(main_window, towxstring(err), wxT("Fatal Error"),
+		wxOK | wxICON_ERROR);
+	d->ShowModal();
+	exit(1);
+}
+
+bool window::modal_message(const std::string& msg, bool confirm) throw(std::bad_alloc)
+{
+	in_modal_dialog = true;
+	wxMessageDialog* d;
+	if(confirm)
+		d = new wxMessageDialog(main_window, towxstring(msg), wxT("Question"),
+			wxOK | wxCANCEL | wxICON_QUESTION);
+	else
+		d = new wxMessageDialog(main_window, towxstring(msg), wxT("Information"),
+			wxOK | wxICON_INFORMATION);
+	auto r = d->ShowModal();
+	d->Destroy();
+	in_modal_dialog = false;
+	if(r == wxID_OK)
+		return confirm;
+	return false;
+}
+
+void graphics_init()
+{
+	init_modifiers_and_keys();
+}
+
+void graphics_quit()
+{
+	for(auto i : modifier_map)
+		delete i.second;
+	for(auto i : keys_allocated)
+		delete key_map[i.second];
+	modifier_map.clear();
+	key_map.clear();
+	keys_allocated.clear();
+	keys_held.clear();
+}
+
+
+const char* graphics_plugin_name = "Wxwidgets graphics plugin";
diff --git a/platform/wxwidgets/src/emufn.hpp b/platform/wxwidgets/src/emufn.hpp
new file mode 100644
index 00000000..ca08228d
--- /dev/null
+++ b/platform/wxwidgets/src/emufn.hpp
@@ -0,0 +1,10 @@
+#ifndef _wxwdigets_emufn__hpp__included__
+#define _wxwdigets_emufn__hpp__included__
+
+#include "rom.hpp"
+#include "moviefile.hpp"
+
+void boot_emulator(loaded_rom& rom, moviefile& movie);
+void exec_command(const std::string& cmd);
+
+#endif
\ No newline at end of file
diff --git a/platform/wxwidgets/src/filenamebox.cpp b/platform/wxwidgets/src/filenamebox.cpp
new file mode 100644
index 00000000..6141e5b1
--- /dev/null
+++ b/platform/wxwidgets/src/filenamebox.cpp
@@ -0,0 +1,138 @@
+#include "filenamebox.hpp"
+#include "common.hpp"
+#include "zip.hpp"
+#include <wx/wx.h>
+#include <wx/event.h>
+#include <wx/control.h>
+#include <wx/combobox.h>
+
+filenamebox::filenamebox(wxSizer* sizer, wxWindow* parent, const std::string& initial_label, int flags,
+	wxEvtHandler* dispatch_to, wxObjectEventFunction on_fn_change)
+{
+	wxSizer* inner = sizer;
+	if(flags & FNBF_OI)
+		inner = new wxFlexGridSizer(1, 3, 0, 0);
+	given_flags = flags;
+	last_label = initial_label;
+	label = new wxStaticText(parent, wxID_ANY, towxstring(last_label));
+	filename = new wxTextCtrl(parent, wxID_ANY, wxT(""), wxDefaultPosition, wxSize(500, -1));
+	file_select = new wxButton(parent, wxID_ANY, wxT("..."));
+	inner->Add(label, 0, wxGROW);
+	inner->Add(filename, 1, wxGROW);
+	inner->Add(file_select, 0, wxGROW);
+	if((flags & FNBF_NN) == 0)
+		filename->Connect(wxEVT_COMMAND_TEXT_UPDATED, on_fn_change, NULL, dispatch_to);
+	file_select->Connect(wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(filenamebox::on_file_select), NULL,
+		this);
+	if(flags & FNBF_SD)
+		disable();
+	if(flags & FNBF_OI) {
+		inner->SetSizeHints(parent);
+		sizer->Add(inner, 0, wxGROW);
+	}
+	pwindow = parent;
+	enabled = ((flags & FNBF_SD) == 0);
+}
+
+filenamebox::~filenamebox()
+{
+	//Wxwidgets destroys the subwidgets.
+}
+
+
+void filenamebox::on_file_select(wxCommandEvent& e)
+{
+	std::string fname;
+	wxFileDialog* d = new wxFileDialog(pwindow, towxstring("Choose " + last_label), wxT("."));
+	if(d->ShowModal() == wxID_CANCEL) {
+		d->Destroy();
+		return;
+	}
+	fname = tostdstring(d->GetPath());
+	d->Destroy();
+	if(given_flags & FNBF_PZ) {
+		//Did we pick a .zip file?
+		try {
+			zip_reader zr(fname);
+			std::vector<wxString> files;
+			for(auto i : zr)
+				files.push_back(towxstring(i));
+			wxSingleChoiceDialog* d2 = new wxSingleChoiceDialog(pwindow, wxT("Select file within .zip"),
+				wxT("Select member"), files.size(), &files[0]);
+			if(d2->ShowModal() == wxID_CANCEL) {
+				d2->Destroy();
+				return;
+			}
+			fname = fname + "/" + tostdstring(d2->GetStringSelection());
+			d2->Destroy();
+		} catch(...) {
+			//Ignore error.
+		}
+	}
+	filename->SetValue(towxstring(fname));
+}
+
+std::string filenamebox::get_file()
+{
+	if(!enabled)
+		return "";
+	else
+		return tostdstring(filename->GetValue());
+}
+
+bool filenamebox::is_enabled()
+{
+	return enabled;
+}
+
+void filenamebox::enable(const std::string& new_label)
+{
+	change_label(new_label);
+	enable();
+}
+
+void filenamebox::change_label(const std::string& new_label)
+{
+	last_label = new_label;
+	if(enabled || (given_flags & FNBF_PL))
+		label->SetLabel(towxstring(last_label));
+}
+
+void filenamebox::disable()
+{
+	label->Disable();
+	filename->Disable();
+	file_select->Disable();
+	if((given_flags & FNBF_PL) == 0)
+		label->SetLabel(wxT(""));
+	enabled = false;
+}
+
+void filenamebox::enable()
+{
+	if((given_flags & FNBF_PL) == 0)
+		label->SetLabel(towxstring(last_label));
+	label->Enable();
+	filename->Enable();
+	file_select->Enable();
+	enabled = true;
+}
+
+bool filenamebox::is_nonblank()
+{
+	if(!enabled)
+		return false;
+	return (filename->GetValue().Length() != 0);
+}
+
+bool filenamebox::is_nonblank_or_disabled()
+{
+	if(!enabled)
+		return true;
+	return (filename->GetValue().Length() != 0);
+}
+
+void filenamebox::clear()
+{
+	filename->SetValue(wxT(""));
+}
diff --git a/platform/wxwidgets/src/filenamebox.hpp b/platform/wxwidgets/src/filenamebox.hpp
new file mode 100644
index 00000000..59ae9662
--- /dev/null
+++ b/platform/wxwidgets/src/filenamebox.hpp
@@ -0,0 +1,44 @@
+#ifndef _wxwidgets_filenamebox__hpp__included__
+#define _wxwidgets_filenamebox__hpp__included__
+
+//Permanent label.
+#define FNBF_PL 1
+//Start disabled.
+#define FNBF_SD 2
+//No notification on filename change.
+#define FNBF_NN 4
+//Insert as one item.
+#define FNBF_OI 8
+//Peek inside .zip files.
+#define FNBF_PZ 16
+
+#include <wx/wx.h>
+#include <wx/event.h>
+
+class filenamebox : public wxEvtHandler
+{
+public:
+	filenamebox(wxSizer* sizer, wxWindow* parent, const std::string& initial_label, int flags,
+		wxEvtHandler* dispatch_to, wxObjectEventFunction on_fn_change);
+	~filenamebox();
+	void disable();
+	void enable();
+	void change_label(const std::string& new_label);
+	void enable(const std::string& new_label);
+	bool is_enabled();
+	std::string get_file();
+	void on_file_select(wxCommandEvent& e);
+	bool is_nonblank();
+	bool is_nonblank_or_disabled();
+	void clear();
+private:
+	int given_flags;
+	std::string last_label;
+	bool enabled;
+	wxStaticText* label;
+	wxTextCtrl* filename;
+	wxButton* file_select;
+	wxWindow* pwindow;
+};
+
+#endif
\ No newline at end of file
diff --git a/platform/wxwidgets/src/keyentry.cpp b/platform/wxwidgets/src/keyentry.cpp
new file mode 100644
index 00000000..e476005b
--- /dev/null
+++ b/platform/wxwidgets/src/keyentry.cpp
@@ -0,0 +1,148 @@
+#include "keyentry.hpp"
+#include "common.hpp"
+#include "keymapper.hpp"
+
+#define S_DONT_CARE "Ignore"
+#define S_RELEASED "Released"
+#define S_PRESSED "Pressed"
+
+wx_key_entry::wx_key_entry(wxWindow* parent)
+	: wxDialog(parent, wxID_ANY, wxT("Specify key"), wxDefaultPosition, wxSize(-1, -1))
+{
+	std::vector<wxString> keych;
+
+	std::set<std::string> mods = modifier::get_set();
+	std::set<std::string> 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(wx_key_entry::on_change_setting), NULL, this);
+		m.unmasked->Connect(wxEVT_COMMAND_CHECKBOX_CLICKED,
+			wxCommandEventHandler(wx_key_entry::on_change_setting), NULL, this);
+	}
+	for(auto i : keys)
+		keych.push_back(towxstring(i));
+	mainkey = new labeledcombobox(t_s, this, "Key", &keych[0], keych.size(), 0, true, this,
+			(wxObjectEventFunction)(&wx_key_entry::on_change_setting));
+	t_s->Add(new wxStaticText(this, wxID_ANY, wxT("")), 0, wxGROW);
+	top_s->Add(t_s);
+
+	wxBoxSizer* pbutton_s = new wxBoxSizer(wxHORIZONTAL);
+	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(wx_key_entry::on_ok), NULL, this);
+	cancel->Connect(wxEVT_COMMAND_BUTTON_CLICKED,
+		wxCommandEventHandler(wx_key_entry::on_cancel), NULL, this);
+	top_s->Add(pbutton_s, 0, wxGROW);
+
+	t_s->SetSizeHints(this);
+	top_s->SetSizeHints(this);
+	Fit();
+}
+
+#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 wx_key_entry::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 wx_key_entry::on_ok(wxCommandEvent& e)
+{
+	EndModal(wxID_OK);
+}
+
+void wx_key_entry::on_cancel(wxCommandEvent& e)
+{
+	EndModal(wxID_CANCEL);
+}
+
+std::string wx_key_entry::getkey()
+{
+	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 + "|" + mainkey->get_choice();
+	return x;
+}
diff --git a/platform/wxwidgets/src/keyentry.hpp b/platform/wxwidgets/src/keyentry.hpp
new file mode 100644
index 00000000..3b680b7b
--- /dev/null
+++ b/platform/wxwidgets/src/keyentry.hpp
@@ -0,0 +1,35 @@
+#ifndef _wxwidgets_keyentry__hpp__included__
+#define _wxwidgets_keyentry__hpp__included__
+
+#include <wx/wx.h>
+#include <wx/event.h>
+#include <wx/control.h>
+#include <wx/combobox.h>
+#include <vector>
+#include <string>
+#include "window.hpp"
+#include "labelcombobox.hpp"
+
+struct keyentry_mod_data
+{
+	wxCheckBox* pressed;
+	wxCheckBox* unmasked;
+	unsigned tmpflags;
+};
+
+class wx_key_entry : public wxDialog
+{
+public:
+	wx_key_entry(wxWindow* parent);
+	void on_change_setting(wxCommandEvent& e);
+	void on_ok(wxCommandEvent& e);
+	void on_cancel(wxCommandEvent& e);
+	std::string getkey();
+private:
+	std::map<std::string, keyentry_mod_data> modifiers;
+	labeledcombobox* mainkey;
+	wxButton* ok;
+	wxButton* cancel;
+};
+
+#endif
diff --git a/platform/wxwidgets/src/labelcombobox.cpp b/platform/wxwidgets/src/labelcombobox.cpp
new file mode 100644
index 00000000..d15ca74d
--- /dev/null
+++ b/platform/wxwidgets/src/labelcombobox.cpp
@@ -0,0 +1,48 @@
+#include "labelcombobox.hpp"
+#include "command.hpp"
+
+labeledcombobox::labeledcombobox(wxSizer* sizer, wxWindow* parent, const std::string& label, wxString* choices,
+	size_t choice_count, size_t defaultidx, bool start_enabled, wxEvtHandler* dispatch_to,
+	wxObjectEventFunction on_fn_change)
+{
+	sizer->Add(new wxStaticText(parent, wxID_ANY, towxstring(label)), 0, wxGROW);
+	sizer->Add(combo = new wxComboBox(parent, wxID_ANY, choices[defaultidx], wxDefaultPosition, wxDefaultSize,
+		choice_count, choices, wxCB_READONLY), 0, wxGROW);
+	if(dispatch_to)
+		combo->Connect(wxEVT_COMMAND_COMBOBOX_SELECTED, on_fn_change, NULL, dispatch_to);
+	combo->Enable(start_enabled);
+	enabled = start_enabled;
+	forced = false;
+}
+
+std::string labeledcombobox::get_choice()
+{
+	return tostdstring(combo->GetValue());
+}
+
+void labeledcombobox::enable()
+{
+	if(forced && !enabled)
+		combo->SetValue(remembered);
+	combo->Enable();
+	enabled = true;
+}
+
+void labeledcombobox::disable(const wxString& choice)
+{
+	combo->Disable();
+	if(enabled)
+		remembered = combo->GetValue();
+	combo->SetValue(choice);
+	enabled = false;
+	forced = true;
+}
+
+void labeledcombobox::disable()
+{
+	combo->Disable();
+	if(enabled)
+		remembered = combo->GetValue();
+	enabled = false;
+	forced = false;
+}
diff --git a/platform/wxwidgets/src/labelcombobox.hpp b/platform/wxwidgets/src/labelcombobox.hpp
new file mode 100644
index 00000000..cd4233dc
--- /dev/null
+++ b/platform/wxwidgets/src/labelcombobox.hpp
@@ -0,0 +1,31 @@
+#ifndef _labelcombobox__hpp__included__
+#define _labelcombobox__hpp__included__
+
+#include <wx/wx.h>
+#include <wx/event.h>
+#include <wx/control.h>
+#include <wx/combobox.h>
+#include <wx/string.h>
+#include "filenamebox.hpp"
+#include "common.hpp"
+#include <string>
+
+class labeledcombobox
+{
+public:
+	labeledcombobox(wxSizer* sizer, wxWindow* parent, const std::string& label, wxString* choices,
+		size_t choice_count, size_t defaultidx, bool start_enabled, wxEvtHandler* dispatch_to,
+		wxObjectEventFunction on_fn_change);
+	std::string get_choice();
+	void enable();
+	void disable(const wxString& choice);
+	void disable();
+private:
+	wxStaticText* label;
+	wxComboBox* combo;
+	wxString remembered;
+	bool enabled;
+	bool forced;
+};
+
+#endif
diff --git a/platform/wxwidgets/src/messages_window.cpp b/platform/wxwidgets/src/messages_window.cpp
new file mode 100644
index 00000000..4f1c195f
--- /dev/null
+++ b/platform/wxwidgets/src/messages_window.cpp
@@ -0,0 +1,143 @@
+#include "messages_window.hpp"
+#include "window.hpp"
+#include "emufn.hpp"
+
+
+#define MAXMESSAGES 20
+
+class wx_message_panel : public wxPanel
+{
+public:
+	wx_message_panel(unsigned lines);
+	void on_paint(wxPaintEvent& e);
+};
+
+wx_messages_window* wx_messages_window::ptr;
+
+wx_message_panel::wx_message_panel(unsigned lines)
+	: wxPanel(wx_messages_window::ptr)
+{
+	wxMemoryDC d;
+	wxSize s = d.GetTextExtent(wxT("MMMMMM"));
+	SetMinSize(wxSize(12 * s.x, lines * s.y));
+	this->Connect(wxEVT_PAINT, wxPaintEventHandler(wx_message_panel::on_paint), NULL, this);
+}
+
+
+namespace {
+	wx_message_panel* mpanel;
+}
+
+wx_messages_window::wx_messages_window()
+	: wxFrame(NULL, wxID_ANY, wxT("lsnes: Messages"), wxDefaultPosition, wxSize(-1, -1), secondary_window_style)
+{
+	ptr = this;
+	wxFlexGridSizer* top_s = new wxFlexGridSizer(3, 1, 0, 0);
+	top_s->Add(mpanel = new wx_message_panel(MAXMESSAGES));
+	window::msgbuf.set_max_window_size(MAXMESSAGES);
+
+	wxFlexGridSizer* buttons_s = new wxFlexGridSizer(1, 6, 0, 0);
+	wxButton* beginning, * pageup, * lineup, * linedown, * pagedown, * end;
+	buttons_s->Add(beginning = new wxButton(this, wxID_ANY, wxT("Beginning")), 1, wxGROW);
+	buttons_s->Add(pageup = new wxButton(this, wxID_ANY, wxT("Page Up")), 1, wxGROW);
+	buttons_s->Add(lineup = new wxButton(this, wxID_ANY, wxT("Line Up")), 1, wxGROW);
+	buttons_s->Add(linedown = new wxButton(this, wxID_ANY, wxT("Line Down")), 1, wxGROW);
+	buttons_s->Add(pagedown = new wxButton(this, wxID_ANY, wxT("Page Down")), 1, wxGROW);
+	buttons_s->Add(end = new wxButton(this, wxID_ANY, wxT("End")), 1, wxGROW);
+	beginning->Connect(wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(wx_messages_window::on_scroll_home),
+		NULL, this);
+	pageup->Connect(wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(wx_messages_window::on_scroll_pageup),
+		NULL, this);
+	lineup->Connect(wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(wx_messages_window::on_scroll_lineup),
+		NULL, this);
+	linedown->Connect(wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(wx_messages_window::on_scroll_linedown),
+		NULL, this);
+	pagedown->Connect(wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(wx_messages_window::on_scroll_pagedown),
+		NULL, this);
+	end->Connect(wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(wx_messages_window::on_scroll_end),
+		NULL, this);
+	top_s->Add(buttons_s, 0, wxGROW);
+
+	wxBoxSizer* cmd_s = new wxBoxSizer(wxHORIZONTAL);
+	wxButton* execute;
+	cmd_s->Add(command = new wxTextCtrl(this, wxID_ANY, wxT(""), wxDefaultPosition, wxDefaultSize,
+		wxTE_PROCESS_ENTER), 1, wxEXPAND);
+	cmd_s->Add(execute = new wxButton(this, wxID_ANY, wxT("Execute")), 0, wxGROW);
+	command->Connect(wxEVT_COMMAND_TEXT_ENTER, wxCommandEventHandler(wx_messages_window::on_execute),
+		NULL, this);
+	execute->Connect(wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(wx_messages_window::on_execute),
+		NULL, this);
+	cmd_s->SetSizeHints(this);
+	top_s->Add(cmd_s, 0, wxGROW);
+
+	top_s->SetSizeHints(this);
+	SetSizer(top_s);
+	Fit();
+}
+
+wx_messages_window::~wx_messages_window()
+{
+	ptr = NULL;
+}
+
+void wx_message_panel::on_paint(wxPaintEvent& e)
+{
+	wxPaintDC dc(this);
+	dc.Clear();
+	int y = 0;
+	size_t lines = window::msgbuf.get_visible_count();
+	size_t first = window::msgbuf.get_visible_first();
+	for(size_t i = 0; i < lines; i++) {
+		wxSize s = dc.GetTextExtent(towxstring(window::msgbuf.get_message(first + i)));
+		dc.DrawText(towxstring(window::msgbuf.get_message(first + i)), 0, y);
+		y += s.y;
+	}
+}
+
+void wx_messages_window::on_scroll_home(wxCommandEvent& e)
+{
+	window::msgbuf.scroll_beginning();
+}
+
+void wx_messages_window::on_scroll_pageup(wxCommandEvent& e)
+{
+	window::msgbuf.scroll_up_page();
+}
+
+void wx_messages_window::on_scroll_lineup(wxCommandEvent& e)
+{
+	window::msgbuf.scroll_up_line();
+}
+
+void wx_messages_window::on_scroll_linedown(wxCommandEvent& e)
+{
+	window::msgbuf.scroll_down_line();
+}
+
+void wx_messages_window::on_scroll_pagedown(wxCommandEvent& e)
+{
+	window::msgbuf.scroll_down_page();
+}
+
+void wx_messages_window::on_scroll_end(wxCommandEvent& e)
+{
+	window::msgbuf.scroll_end();
+}
+
+void wx_messages_window::on_execute(wxCommandEvent& e)
+{
+	std::string cmd = tostdstring(command->GetValue());
+	if(cmd == "")
+		return;
+	exec_command(cmd);
+}
+
+void wx_messages_window::notify_message()
+{
+	mpanel->Refresh();
+}
+
+bool wx_messages_window::ShouldPreventAppExit() const
+{
+	return false;
+}
diff --git a/platform/wxwidgets/src/messages_window.hpp b/platform/wxwidgets/src/messages_window.hpp
new file mode 100644
index 00000000..a9ec7603
--- /dev/null
+++ b/platform/wxwidgets/src/messages_window.hpp
@@ -0,0 +1,30 @@
+#ifndef _wxwidgets_messages_window__hpp__included__
+#define _wxwidgets_messages_window__hpp__included__
+
+#include <wx/wx.h>
+#include <wx/event.h>
+#include <wx/control.h>
+#include <wx/combobox.h>
+#include "filenamebox.hpp"
+#include "common.hpp"
+
+class wx_messages_window : public wxFrame
+{
+public:
+	wx_messages_window();
+	~wx_messages_window();
+	bool ShouldPreventAppExit() const;
+	static wx_messages_window* ptr;
+	void notify_message();
+	void on_scroll_home(wxCommandEvent& e);
+	void on_scroll_pageup(wxCommandEvent& e);
+	void on_scroll_lineup(wxCommandEvent& e);
+	void on_scroll_linedown(wxCommandEvent& e);
+	void on_scroll_pagedown(wxCommandEvent& e);
+	void on_scroll_end(wxCommandEvent& e);
+	void on_execute(wxCommandEvent& e);
+private:
+	wxTextCtrl* command;
+};
+
+#endif
diff --git a/platform/wxwidgets/src/project_select_window.cpp b/platform/wxwidgets/src/project_select_window.cpp
new file mode 100644
index 00000000..50c2a742
--- /dev/null
+++ b/platform/wxwidgets/src/project_select_window.cpp
@@ -0,0 +1,252 @@
+#include "lsnes.hpp"
+#include <snes/snes.hpp>
+#include <ui-libsnes/libsnes.hpp>
+#include "project_select_window.hpp"
+#include "common.hpp"
+#include "zip.hpp"
+#include "moviedata.hpp"
+#include "emufn.hpp"
+#include <stdexcept>
+#include <boost/lexical_cast.hpp>
+
+namespace
+{
+	std::string sram_name(const nall::string& _id, SNES::Cartridge::Slot slotname)
+	{
+		std::string id(_id, _id.length());
+		if(slotname == SNES::Cartridge::Slot::SufamiTurboA)
+			return "slota." + id.substr(1);
+		if(slotname == SNES::Cartridge::Slot::SufamiTurboB)
+			return "slotb." + id.substr(1);
+		return id.substr(1);
+	}
+
+	porttype_t get_controller_type(const std::string& s)
+	{
+		if(s == CNAME_NONE)
+			return PT_NONE;
+		if(s == CNAME_GAMEPAD)
+			return PT_GAMEPAD;
+		if(s == CNAME_MULTITAP)
+			return PT_MULTITAP;
+		if(s == CNAME_MOUSE)
+			return PT_MOUSE;
+		if(s == CNAME_SUPERSCOPE)
+			return PT_SUPERSCOPE;
+		if(s == CNAME_JUSTIFIER)
+			return PT_JUSTIFIER;
+		if(s == CNAME_JUSTIFIERS)
+			return PT_JUSTIFIERS;
+		return PT_INVALID;
+	}
+}
+
+wx_project_select_window::wx_project_select_window(loaded_rom& rom)
+	: wxFrame(NULL, wxID_ANY, wxT("Project settings"), wxDefaultPosition, wxSize(-1, -1),
+		primary_window_style)
+{
+	our_rom = &rom;
+	wxString cchoices[7];
+	cchoices[0] = wxT(CNAME_NONE);
+	cchoices[1] = wxT(CNAME_GAMEPAD);
+	cchoices[2] = wxT(CNAME_MULTITAP);
+	cchoices[3] = wxT(CNAME_MOUSE);
+	cchoices[4] = wxT(CNAME_SUPERSCOPE);
+	cchoices[5] = wxT(CNAME_JUSTIFIER);
+	cchoices[6] = wxT(CNAME_JUSTIFIERS);
+
+	std::set<std::string> sram_set = get_sram_set();
+
+	Centre();
+	wxFlexGridSizer* top_s = new wxFlexGridSizer(7 + sram_set.size(), 1, 0, 0);
+	SetSizer(top_s);
+
+	wxRadioButton* file = new wxRadioButton(this, wxID_ANY, wxT("Load movie/savestate"), wxDefaultPosition,
+		wxDefaultSize, wxRB_GROUP);
+	wxRadioButton* newp = new wxRadioButton(this, wxID_ANY, wxT("New project"));
+	file->Connect(wxEVT_COMMAND_RADIOBUTTON_SELECTED,
+		wxCommandEventHandler(wx_project_select_window::on_file_select), NULL, this);
+	newp->Connect(wxEVT_COMMAND_RADIOBUTTON_SELECTED,
+		wxCommandEventHandler(wx_project_select_window::on_new_select), NULL, this);
+	top_s->Add(file, 0, wxGROW);
+	top_s->Add(newp, 0, wxGROW);
+	load_file = true;
+
+	filename = new filenamebox(top_s, this, "Movie/Savestate", FNBF_PL | FNBF_OI, this,
+		wxCommandEventHandler(wx_project_select_window::on_filename_change));
+
+	wxFlexGridSizer* c_s = new wxFlexGridSizer(4, 2, 0, 0);
+	controller1type = new labeledcombobox(c_s, this, "Controller 1 type:", cchoices, 4, 1, false, this,
+		wxCommandEventHandler(wx_project_select_window::on_filename_change));
+	controller2type = new labeledcombobox(c_s, this, "Controller 2 type:", cchoices, 7, 0, false, this,
+		wxCommandEventHandler(wx_project_select_window::on_filename_change));
+	c_s->Add(new wxStaticText(this, wxID_ANY, wxT("Initial RTC:")), 0, wxGROW);
+	wxFlexGridSizer* t_s = new wxFlexGridSizer(1, 3, 0, 0);
+	t_s->Add(rtc_sec = new wxTextCtrl(this, wxID_ANY, wxT("1000000000"), wxDefaultPosition, wxSize(150, -1)), 1,
+		 wxGROW);
+	t_s->Add(new wxStaticText(this, wxID_ANY, wxT(":")), 0, wxGROW);
+	t_s->Add(rtc_subsec = new wxTextCtrl(this, wxID_ANY, wxT("0"), wxDefaultPosition, wxSize(120, -1)), 0, wxGROW);
+	rtc_sec->Connect(wxEVT_COMMAND_TEXT_UPDATED,
+		wxCommandEventHandler(wx_project_select_window::on_filename_change), NULL, this);
+	rtc_subsec->Connect(wxEVT_COMMAND_TEXT_UPDATED,
+		wxCommandEventHandler(wx_project_select_window::on_filename_change), NULL, this);
+	c_s->Add(t_s, 0, wxGROW);
+	top_s->Add(c_s, 0, wxGROW);
+	c_s->Add(new wxStaticText(this, wxID_ANY, wxT("Game name:")), 0, wxGROW);
+	c_s->Add(projectname = new wxTextCtrl(this, wxID_ANY, wxT(""), wxDefaultPosition, wxSize(400, -1)), 1, wxGROW);
+
+	top_s->Add(new wxStaticText(this, wxID_ANY, wxT("Authors (one per line):")), 0, wxGROW);
+	top_s->Add(authors = new wxTextCtrl(this, wxID_ANY, wxT(""), wxDefaultPosition, wxDefaultSize,
+		wxTE_MULTILINE), 0, wxGROW);
+	authors->Connect(wxEVT_COMMAND_TEXT_UPDATED,
+		wxCommandEventHandler(wx_project_select_window::on_filename_change), NULL, this);
+
+	for(auto i : sram_set)
+		srams[i] = new filenamebox(top_s, this, "SRAM " + i + ":" , FNBF_PL | FNBF_OI, this,
+			wxCommandEventHandler(wx_project_select_window::on_filename_change));
+
+	wxBoxSizer* pbutton_s = new wxBoxSizer(wxHORIZONTAL);
+	pbutton_s->AddStretchSpacer();
+	pbutton_s->Add(load = new wxButton(this, wxID_ANY, wxT("Load")), 0, wxGROW);
+	pbutton_s->Add(quit = new wxButton(this, wxID_EXIT, wxT("Quit")), 0, wxGROW);
+	load->Connect(wxEVT_COMMAND_BUTTON_CLICKED,
+		wxCommandEventHandler(wx_project_select_window::on_load), NULL, this);
+	quit->Connect(wxEVT_COMMAND_BUTTON_CLICKED,
+		wxCommandEventHandler(wx_project_select_window::on_quit), NULL, this);
+	top_s->Add(pbutton_s, 0, wxGROW);
+
+	wxCommandEvent e;
+	on_file_select(e);
+
+	t_s->SetSizeHints(this);
+	c_s->SetSizeHints(this);
+	top_s->SetSizeHints(this);
+	Fit();
+}
+
+wx_project_select_window::~wx_project_select_window()
+{
+	delete controller1type;
+	delete controller2type;
+	delete filename;
+}
+
+void wx_project_select_window::on_file_select(wxCommandEvent& e)
+{
+	filename->enable();
+	controller1type->disable();
+	controller2type->disable();
+	rtc_sec->Disable();
+	rtc_subsec->Disable();
+	projectname->Disable();
+	authors->Disable();
+	load->SetLabel(wxT("Load"));
+	on_filename_change(e);
+	load_file = true;
+	for(auto i : srams)
+		i.second->disable();
+}
+
+void wx_project_select_window::on_new_select(wxCommandEvent& e)
+{
+	filename->disable();
+	controller1type->enable();
+	controller2type->enable();
+	rtc_sec->Enable();
+	rtc_subsec->Enable();
+	projectname->Enable();
+	authors->Enable();
+	load->SetLabel(wxT("Start"));
+	on_filename_change(e);
+	load_file = false;
+	for(auto i : srams)
+		i.second->enable();
+}
+
+void wx_project_select_window::on_filename_change(wxCommandEvent& e)
+{
+	if(filename->is_enabled()) {
+		load->Enable(filename->is_nonblank());
+	} else {
+		try {
+			boost::lexical_cast<int64_t>(tostdstring(rtc_sec->GetValue()));
+			if(boost::lexical_cast<int64_t>(tostdstring(rtc_subsec->GetValue())) < 0)
+				throw 42;
+			size_t lines = authors->GetNumberOfLines();
+			for(size_t i = 0; i < lines; i++) {
+				std::string l = tostdstring(authors->GetLineText(i));
+				if(l == "|")
+					throw 43;
+			}
+			load->Enable();
+		} catch(...) {
+			load->Disable();
+		}
+	}
+}
+
+void wx_project_select_window::on_quit(wxCommandEvent& e)
+{
+	Close(true);
+}
+
+void wx_project_select_window::on_load(wxCommandEvent& e)
+{
+	try {
+		if(load_file) {
+			boot_emulator(*our_rom, *new moviefile(filename->get_file()));
+		} else {
+			boot_emulator(*our_rom, *new moviefile(make_movie()));
+		}
+		Destroy();
+	} catch(std::exception& e) {
+		wxMessageDialog* d = new wxMessageDialog(this, towxstring(e.what()),
+			wxT("Error loading movie"), wxOK | wxICON_EXCLAMATION);
+		d->ShowModal();
+		return;
+	}
+}
+
+std::set<std::string> wx_project_select_window::get_sram_set()
+{
+	std::set<std::string> r;
+	for(unsigned i = 0; i < SNES::cartridge.nvram.size(); i++) {
+		SNES::Cartridge::NonVolatileRAM& s = SNES::cartridge.nvram[i];
+		r.insert(sram_name(s.id, s.slot));
+	}
+	return r;
+}
+
+struct moviefile wx_project_select_window::make_movie()
+{
+	moviefile f;
+	f.force_corrupt = false;
+	f.gametype = gtype::togametype(our_rom->rtype, our_rom->region);
+	f.port1 = get_controller_type(controller1type->get_choice());
+	f.port2 = get_controller_type(controller2type->get_choice());
+	f.coreversion = bsnes_core_version;
+	f.gamename = tostdstring(projectname->GetValue());
+	f.projectid = get_random_hexstring(40);
+	f.rerecords = "0";
+	f.rom_sha256 = our_rom->rom.sha256;
+	f.romxml_sha256 = our_rom->rom_xml.sha256;
+	f.slota_sha256 = our_rom->slota.sha256;
+	f.slotaxml_sha256 = our_rom->slota_xml.sha256;
+	f.slotb_sha256 = our_rom->slotb.sha256;
+	f.slotbxml_sha256 = our_rom->slotb_xml.sha256;
+	size_t lines = authors->GetNumberOfLines();
+	for(size_t i = 0; i < lines; i++) {
+		std::string l = tostdstring(authors->GetLineText(i));
+		if(l != "" && l != "|")
+			f.authors.push_back(split_author(l));
+	}
+	for(auto i : srams)
+		if(i.second->get_file() != "")
+			f.movie_sram[i.first] = read_file_relative(i.second->get_file(), "");
+	f.is_savestate = false;
+	f.movie_rtc_second = f.rtc_second = boost::lexical_cast<int64_t>(tostdstring(rtc_sec->GetValue()));
+	f.movie_rtc_subsecond = f.rtc_subsecond = boost::lexical_cast<int64_t>(tostdstring(rtc_subsec->GetValue()));
+	if(f.movie_rtc_subsecond < 0)
+		throw std::runtime_error("RTC subsecond must be positive");
+	return f;
+}
diff --git a/platform/wxwidgets/src/project_select_window.hpp b/platform/wxwidgets/src/project_select_window.hpp
new file mode 100644
index 00000000..38532509
--- /dev/null
+++ b/platform/wxwidgets/src/project_select_window.hpp
@@ -0,0 +1,43 @@
+#ifndef _wxwidgets_project_select_window__hpp__included__
+#define _wxwidgets_project_select_window__hpp__included__
+
+#include <wx/wx.h>
+#include <wx/event.h>
+#include <wx/control.h>
+#include <wx/combobox.h>
+#include "filenamebox.hpp"
+#include "rom.hpp"
+#include "moviefile.hpp"
+#include "labelcombobox.hpp"
+#include <set>
+#include <map>
+#include <string>
+
+class wx_project_select_window : public wxFrame
+{
+public:
+	wx_project_select_window(loaded_rom& rom);
+	~wx_project_select_window();
+	void on_file_select(wxCommandEvent& e);
+	void on_new_select(wxCommandEvent& e);
+	void on_filename_change(wxCommandEvent& e);
+	void on_quit(wxCommandEvent& e);
+	void on_load(wxCommandEvent& e);
+	loaded_rom* our_rom;
+private:
+	bool load_file;
+	std::set<std::string> get_sram_set();
+	struct moviefile make_movie();
+	filenamebox* filename;
+	std::map<std::string, filenamebox*> srams;
+	labeledcombobox* controller1type;
+	labeledcombobox* controller2type;
+	wxTextCtrl* projectname;
+	wxTextCtrl* rtc_sec;
+	wxTextCtrl* rtc_subsec;
+	wxTextCtrl* authors;
+	wxButton* load;
+	wxButton* quit;
+};
+
+#endif
\ No newline at end of file
diff --git a/platform/wxwidgets/src/rom_patch_window.cpp b/platform/wxwidgets/src/rom_patch_window.cpp
new file mode 100644
index 00000000..28b5d9da
--- /dev/null
+++ b/platform/wxwidgets/src/rom_patch_window.cpp
@@ -0,0 +1,159 @@
+#include "lsnes.hpp"
+#include <snes/snes.hpp>
+#include <ui-libsnes/libsnes.hpp>
+#include "rom_patch_window.hpp"
+#include "project_select_window.hpp"
+#include "callrom.hpp"
+#include "zip.hpp"
+#include "framerate.hpp"
+
+namespace
+{
+	class my_interfaced : public SNES::Interface
+	{
+		string path(SNES::Cartridge::Slot slot, const string &hint)
+		{
+			return "./";
+		}
+	} simple_interface;
+}
+
+wx_rom_patch_window::wx_rom_patch_window(loaded_rom& rom)
+	: wxFrame(NULL, wxID_ANY, wxT("Patch ROM"), wxDefaultPosition, wxSize(-1, -1),
+		primary_window_style)
+{
+	our_rom = &rom;
+	size_t target_count = fill_rom_names(rom.rtype, targets);
+
+	Centre();
+	wxFlexGridSizer* top_s = new wxFlexGridSizer(5, 1, 0, 0);
+	SetSizer(top_s);
+
+	wxFlexGridSizer* checksums_s = new wxFlexGridSizer(target_count, 2, 0, 0);
+	for(unsigned i = 0; i < 6; i++)
+		checksums[i] = NULL;
+	for(unsigned i = 0; i < target_count; i++) {
+		checksums_s->Add(new wxStaticText(this, wxID_ANY, targets[i]), 0, wxGROW);
+		checksums_s->Add(checksums[i] = new wxStaticText(this, wxID_ANY,
+			towxstring(get_rom_slot(*our_rom, i).sha256)), 0, wxGROW);
+	}
+	top_s->Add(checksums_s, 0, wxGROW);
+
+	wxFlexGridSizer* pwhat_s = new wxFlexGridSizer(1, 2, 0, 0);
+	pwhat_s->Add(new wxStaticText(this, wxID_ANY, wxT("Patch what:")), 0, wxGROW);
+	pwhat_s->Add(patch_what = new wxComboBox(this, wxID_ANY, targets[0], wxDefaultPosition, wxDefaultSize,
+		target_count, targets, wxCB_READONLY), 0, wxGROW);
+	top_s->Add(pwhat_s, 0, wxGROW);
+
+	patchfile = new filenamebox(top_s, this, "Patch file", FNBF_PL | FNBF_OI | FNBF_PZ, this,
+		wxCommandEventHandler(wx_rom_patch_window::on_patchfile_change));
+
+	wxFlexGridSizer* poffset_s = new wxFlexGridSizer(1, 2, 0, 0);
+	pwhat_s->Add(new wxStaticText(this, wxID_ANY, wxT("Patch offset:")), 0, wxGROW);
+	pwhat_s->Add(patch_offset = new wxTextCtrl(this, wxID_ANY, wxT("")), 0, wxGROW);
+	patch_offset->Connect(wxEVT_COMMAND_TEXT_UPDATED,
+		wxCommandEventHandler(wx_rom_patch_window::on_patchfile_change), NULL, this);
+	top_s->Add(poffset_s, 0, wxGROW);
+
+	wxBoxSizer* pbutton_s = new wxBoxSizer(wxHORIZONTAL);
+	pbutton_s->AddStretchSpacer();
+	wxButton* thats_enough = new wxButton(this, wxID_ANY, wxT("Enough"));
+	pbutton_s->Add(thats_enough, 0, wxGROW);
+	thats_enough->Connect(wxEVT_COMMAND_BUTTON_CLICKED,
+		wxCommandEventHandler(wx_rom_patch_window::on_done), NULL, this);
+	dopatch = new wxButton(this, wxID_ANY, wxT("Patch"));
+	pbutton_s->Add(dopatch, 0, wxGROW);
+	dopatch->Connect(wxEVT_COMMAND_BUTTON_CLICKED,
+		wxCommandEventHandler(wx_rom_patch_window::on_do_patch), NULL, this);
+	dopatch->Disable();
+	wxButton* quitbutton = new wxButton(this, wxID_EXIT, wxT("Quit"));
+	pbutton_s->Add(quitbutton, 0, wxGROW);
+	quitbutton->Connect(wxEVT_COMMAND_BUTTON_CLICKED,
+		wxCommandEventHandler(wx_rom_patch_window::on_quit), NULL, this);
+	top_s->Add(pbutton_s, 0, wxGROW);
+
+	patch_offset->SetValue(wxT("0"));
+
+	checksums_s->SetSizeHints(this);
+	pwhat_s->SetSizeHints(this);
+	pbutton_s->SetSizeHints(this);
+	top_s->SetSizeHints(this);
+	Fit();
+}
+
+wx_rom_patch_window::~wx_rom_patch_window()
+{
+	delete patchfile;
+}
+
+void wx_rom_patch_window::on_patchfile_change(wxCommandEvent& e)
+{
+	//std::cerr << "wx_rom_patch_window::on_patchfile_change" << std::endl;
+	bool ok = true;
+	//std::cerr << "wx_rom_patch_window::on_patchfile_change: #1: ok=" << ok << std::endl;
+	ok = ok && patchfile->is_nonblank();
+	//std::cerr << "wx_rom_patch_window::on_patchfile_change: #2: ok=" << ok << std::endl;
+	std::string offsetv = tostdstring(patch_offset->GetValue());
+	try {
+		int32_t offset = boost::lexical_cast<int32_t>(offsetv);
+	} catch(...) {
+		ok = false;
+	}
+	//std::cerr << "wx_rom_patch_window::on_patchfile_change: #3: ok=" << ok << std::endl;
+	if(dopatch) {
+		//std::cerr << "wx_rom_patch_window::on_patchfile_change: #4: ok=" << ok << std::endl;
+		dopatch->Enable(ok);
+	}
+	//std::cerr << "wx_rom_patch_window::on_patchfile_change: #5: ok=" << ok << std::endl;
+}
+
+void wx_rom_patch_window::on_do_patch(wxCommandEvent& e)
+{
+	try {
+		auto patch_contents = read_file_relative(patchfile->get_file(), "");
+		size_t patch_index = romname_to_index(our_rom->rtype, patch_what->GetValue());
+		if(patch_index == 6)
+			throw std::runtime_error("Internal error: Patch WHAT?");
+		loaded_slot& s = get_rom_slot(*our_rom, patch_index);
+		std::string offsetv = tostdstring(patch_offset->GetValue());
+		int32_t offset = boost::lexical_cast<int32_t>(offsetv);
+		s.patch(patch_contents, offset);
+		checksums[patch_index]->SetLabel(towxstring(s.sha256));
+	} catch(std::exception& e) {
+		wxMessageDialog* d = new wxMessageDialog(this, towxstring(e.what()),
+			wxT("Error patching ROM"), wxOK | wxICON_EXCLAMATION);
+		d->ShowModal();
+		return;
+	}
+	patchfile->clear();
+}
+
+void wx_rom_patch_window::on_quit(wxCommandEvent& e)
+{
+	Close(true);
+}
+
+void wx_rom_patch_window::on_done(wxCommandEvent& e)
+{
+	try {
+		SNES::interface = &simple_interface;
+		our_rom->load();
+	} catch(std::exception& e) {
+		wxMessageDialog* d = new wxMessageDialog(this, towxstring(e.what()),
+			wxT("Error loading ROM"), wxOK | wxICON_EXCLAMATION);
+		d->ShowModal();
+		return;
+	}
+	messages << "Detected region: " << gtype::tostring(our_rom->rtype, our_rom->region) << std::endl;
+	if(our_rom->region == REGION_PAL)
+		set_nominal_framerate(322445.0/6448.0);
+	else if(our_rom->region == REGION_NTSC)
+		set_nominal_framerate(10738636.0/178683.0);
+
+	messages << "--- Internal memory mappings ---" << std::endl;
+	dump_region_map();
+	messages << "--- End of Startup --- " << std::endl;
+	wx_project_select_window* projwin = new wx_project_select_window(*our_rom);
+	projwin->Show();
+	Destroy();
+}
diff --git a/platform/wxwidgets/src/rom_patch_window.hpp b/platform/wxwidgets/src/rom_patch_window.hpp
new file mode 100644
index 00000000..b8215705
--- /dev/null
+++ b/platform/wxwidgets/src/rom_patch_window.hpp
@@ -0,0 +1,31 @@
+#ifndef _wxwidgets_rom_patch_window__hpp__included__
+#define _wxwidgets_rom_patch_window__hpp__included__
+
+#include <wx/wx.h>
+#include <wx/event.h>
+#include <wx/control.h>
+#include <wx/combobox.h>
+#include "filenamebox.hpp"
+#include "rom.hpp"
+#include "common.hpp"
+
+class wx_rom_patch_window : public wxFrame
+{
+public:
+	wx_rom_patch_window(loaded_rom& rom);
+	~wx_rom_patch_window();
+	void on_patchfile_change(wxCommandEvent& e);
+	void on_do_patch(wxCommandEvent& e);
+	void on_quit(wxCommandEvent& e);
+	void on_done(wxCommandEvent& e);
+	loaded_rom* our_rom;
+private:
+	filenamebox* patchfile;
+	wxComboBox* patch_what;
+	wxButton* dopatch;
+	wxTextCtrl* patch_offset;
+	wxStaticText_ptr checksums[6];
+	wxString targets[6];
+};
+
+#endif
\ No newline at end of file
diff --git a/platform/wxwidgets/src/rom_select_window.cpp b/platform/wxwidgets/src/rom_select_window.cpp
new file mode 100644
index 00000000..e76dacd7
--- /dev/null
+++ b/platform/wxwidgets/src/rom_select_window.cpp
@@ -0,0 +1,139 @@
+#include "rom_select_window.hpp"
+#include "rom_patch_window.hpp"
+#include "callrom.hpp"
+
+wx_rom_select_window::wx_rom_select_window()
+	: wxFrame(NULL, wxID_ANY, wxT("Select ROM"), wxDefaultPosition, wxSize(-1, -1),
+		primary_window_style)
+{
+	wxString rtchoices[5];
+	wxString rrchoices[3];
+	size_t systems = populate_system_choices(rtchoices);
+	size_t regions = populate_region_choices(rrchoices);
+
+	Centre();
+	wxFlexGridSizer* top_s = new wxFlexGridSizer(3, 1, 0, 0);
+	SetSizer(top_s);
+
+	wxBoxSizer* selects_s = new wxBoxSizer(wxHORIZONTAL);
+	rtypec = new labeledcombobox(selects_s, this, "ROM type:", rtchoices, systems, 0, true, this,
+		wxCommandEventHandler(wx_rom_select_window::on_romtype_change));
+	regionc = new labeledcombobox(selects_s, this, "Region:", rrchoices, regions, 0, true, this,
+		wxCommandEventHandler(wx_rom_select_window::on_romtype_change));
+	top_s->Add(selects_s, 0, wxGROW);
+
+	//The XMLs don't matter, so don't notify those.
+	wxFlexGridSizer* romgrid_s = new wxFlexGridSizer(6, 3, 0, 0);
+	main_rom = new filenamebox(romgrid_s, this, "ROM", FNBF_PZ, this,
+		wxCommandEventHandler(wx_rom_select_window::on_filename_change));
+	main_xml = new filenamebox(romgrid_s, this, "ROM XML", FNBF_NN | FNBF_PZ, this,
+		wxCommandEventHandler(wx_rom_select_window::on_filename_change));
+	slota_rom = new filenamebox(romgrid_s, this, "SLOT A ROM", FNBF_PZ, this,
+		wxCommandEventHandler(wx_rom_select_window::on_filename_change));
+	slota_xml = new filenamebox(romgrid_s, this, "SLOT A XML", FNBF_NN | FNBF_PZ, this,
+		wxCommandEventHandler(wx_rom_select_window::on_filename_change));
+	slotb_rom = new filenamebox(romgrid_s, this, "SLOT A ROM", FNBF_PZ, this,
+		wxCommandEventHandler(wx_rom_select_window::on_filename_change));
+	slotb_xml = new filenamebox(romgrid_s, this, "SLOT A XML", FNBF_NN | FNBF_PZ, this,
+		wxCommandEventHandler(wx_rom_select_window::on_filename_change));
+
+	top_s->Add(romgrid_s, 1, wxGROW);
+	wxBoxSizer* button_s = new wxBoxSizer(wxHORIZONTAL);
+	button_s->AddStretchSpacer();
+	button_s->Add(open_rom = new wxButton(this, wxID_OPEN, wxT("Open ROM")), 0, wxALIGN_RIGHT);
+	button_s->Add(quit_button = new wxButton(this, wxID_EXIT, wxT("Quit")), 0, wxALIGN_RIGHT);
+	open_rom->Connect(wxEVT_COMMAND_BUTTON_CLICKED,
+		wxCommandEventHandler(wx_rom_select_window::on_open_rom), NULL, this);
+	open_rom->Disable();
+	quit_button->Connect(wxEVT_COMMAND_BUTTON_CLICKED,
+		wxCommandEventHandler(wx_rom_select_window::on_quit), NULL, this);
+	top_s->Add(button_s, 1, wxGROW);
+
+	set_rtype("");
+
+	top_s->SetSizeHints(this);
+	Fit();
+}
+
+wx_rom_select_window::~wx_rom_select_window()
+{
+	delete rtypec;
+	delete regionc;
+	delete main_rom;
+	delete main_xml;
+	delete slota_rom;
+	delete slota_xml;
+	delete slotb_rom;
+	delete slotb_xml;
+}
+
+
+void wx_rom_select_window::set_rtype(std::string rtype)
+{
+	bool no_rtype = (current_rtype == "");
+	if(rtype == "")
+		rtype = rtypec->get_choice();
+	if(rtype == current_rtype)
+		return;
+	if(has_forced_region(rtype))
+		regionc->disable(forced_region_for_romtype(rtype));
+	else
+		regionc->enable();
+	wxString tmp[6];
+	unsigned c = fill_rom_names(romtype_from_string(rtype), tmp);
+	if(c > 0)	main_rom->enable(tostdstring(tmp[0])); else main_rom->disable();
+	if(c > 1)	main_xml->enable(tostdstring(tmp[1])); else main_xml->disable();
+	if(c > 2)	slota_rom->enable(tostdstring(tmp[2])); else slota_rom->disable();
+	if(c > 3)	slota_xml->enable(tostdstring(tmp[3])); else slota_xml->disable();
+	if(c > 4)	slotb_rom->enable(tostdstring(tmp[4])); else slotb_rom->disable();
+	if(c > 5)	slotb_xml->enable(tostdstring(tmp[5])); else slotb_xml->disable();
+	current_rtype = rtype;
+	Fit();
+}
+
+void wx_rom_select_window::on_filename_change(wxCommandEvent& e)
+{
+	bool ok = true;
+	enum rom_type rtype = romtype_from_string(rtypec->get_choice());
+	ok = ok && main_rom->is_nonblank();
+	if(rtype == ROMTYPE_BSX || rtype == ROMTYPE_BSXSLOTTED || rtype == ROMTYPE_SGB)
+		ok = ok && slota_rom->is_nonblank();
+	if(rtype == ROMTYPE_SUFAMITURBO)
+		ok = ok && (slota_rom->is_nonblank() || slotb_rom->is_nonblank());
+	open_rom->Enable(ok);
+}
+
+void wx_rom_select_window::on_romtype_change(wxCommandEvent& e)
+{
+	set_rtype(rtypec->get_choice());
+	on_filename_change(e);
+}
+
+void wx_rom_select_window::on_quit(wxCommandEvent& e)
+{
+	Close(true);
+}
+
+void wx_rom_select_window::on_open_rom(wxCommandEvent& e)
+{
+	rom_files rfiles;
+	rfiles.base_file = "";
+	rfiles.rtype = romtype_from_string(rtypec->get_choice());
+	rfiles.region = region_from_string(regionc->get_choice());
+	rfiles.rom = main_rom->get_file();
+	rfiles.rom_xml = main_xml->get_file();
+	rfiles.slota = slota_rom->get_file();
+	rfiles.slota_xml = slota_xml->get_file();
+	rfiles.slotb = slotb_rom->get_file();
+	rfiles.slotb_xml = slotb_xml->get_file();
+	try {
+		our_rom = new loaded_rom(rfiles);
+	} catch(std::exception& e) {
+		wxMessageDialog* d = new wxMessageDialog(this, towxstring(e.what()),
+			wxT("Error loading ROM"), wxOK | wxICON_EXCLAMATION);
+		d->ShowModal();
+	}
+	wx_rom_patch_window* projwin = new wx_rom_patch_window(*our_rom);
+	projwin->Show();
+	Destroy();
+}
diff --git a/platform/wxwidgets/src/rom_select_window.hpp b/platform/wxwidgets/src/rom_select_window.hpp
new file mode 100644
index 00000000..7f2c0163
--- /dev/null
+++ b/platform/wxwidgets/src/rom_select_window.hpp
@@ -0,0 +1,37 @@
+#ifndef _wxwidgets_rom_select_window__hpp__included__
+#define _wxwidgets_rom_select_window__hpp__included__
+
+#include <wx/wx.h>
+#include <wx/event.h>
+#include <wx/control.h>
+#include <wx/combobox.h>
+#include "filenamebox.hpp"
+#include "rom.hpp"
+#include "labelcombobox.hpp"
+
+class wx_rom_select_window : public wxFrame
+{
+public:
+	wx_rom_select_window();
+	~wx_rom_select_window();
+	void on_filename_change(wxCommandEvent& e);
+	void on_romtype_change(wxCommandEvent& e);
+	void on_quit(wxCommandEvent& e);
+	void on_open_rom(wxCommandEvent& e);
+	loaded_rom* our_rom;
+private:
+	labeledcombobox* rtypec;
+	labeledcombobox* regionc;
+	filenamebox* main_rom;
+	filenamebox* main_xml;
+	filenamebox* slota_rom;
+	filenamebox* slota_xml;
+	filenamebox* slotb_rom;
+	filenamebox* slotb_xml;
+	wxButton* open_rom;
+	wxButton* quit_button;
+	std::string current_rtype;
+	void set_rtype(std::string rtype);
+};
+
+#endif
\ No newline at end of file
diff --git a/platform/wxwidgets/src/settingseditor.cpp b/platform/wxwidgets/src/settingseditor.cpp
new file mode 100644
index 00000000..0cb4f52b
--- /dev/null
+++ b/platform/wxwidgets/src/settingseditor.cpp
@@ -0,0 +1,147 @@
+#include "settingseditor.hpp"
+#include "settings.hpp"
+#include "common.hpp"
+#include "window.hpp"
+#include <stdexcept>
+
+wx_settings_editor_setting::wx_settings_editor_setting(wxSizer* sizer, wxWindow* window, const std::string& name)
+{
+	a_name = name;
+	parent = window;
+	std::string pvalue = "<unknown>";
+	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(wx_settings_editor_setting::on_edit_click), NULL, this);
+	clear->Connect(wxEVT_COMMAND_BUTTON_CLICKED,
+		wxCommandEventHandler(wx_settings_editor_setting::on_clear_click), NULL, this);
+}
+
+void wx_settings_editor_setting::on_clear_click(wxCommandEvent& e)
+{
+	try {
+		setting::blank(a_name);
+	}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 wx_settings_editor_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());
+		setting::set(a_name, newsetting);
+	} 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 wx_settings_editor_setting::change_setting(const std::string& _setting, const std::string& value)
+{
+	if(_setting != a_name)
+		return;
+	label->SetLabel(towxstring(value));
+}
+
+void wx_settings_editor_setting::clear_setting(const std::string& _setting)
+{
+	if(_setting != a_name)
+		return;
+	label->SetLabel(wxT("<unset>"));
+}
+
+wx_settings_editor::wx_settings_editor(wxWindow* parent)
+	: wxDialog(parent, wxID_ANY, wxT("lsnes: Edit settings"), wxDefaultPosition, wxSize(-1, -1)), listener(this)
+{
+	std::set<std::string> settings_set = setting::get_settings_set();
+
+	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 wx_settings_editor_setting(t_s, this, i));
+	top_s->Add(t_s);
+
+	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(wx_settings_editor::on_close), NULL, this);
+	top_s->Add(pbutton_s, 0, wxGROW);
+
+	t_s->SetSizeHints(this);
+	top_s->SetSizeHints(this);
+	Fit();
+}
+
+wx_settings_editor::~wx_settings_editor()
+{
+	for(auto i : esettings)
+		delete i;
+}
+
+bool wx_settings_editor::ShouldPreventAppExit() const
+{
+	return false;
+}
+
+void wx_settings_editor::on_close(wxCommandEvent& e)
+{
+	EndModal(wxID_OK);
+}
+
+void wx_settings_editor::change_setting(const std::string& _setting, const std::string& value)
+{
+	for(auto i : esettings)
+		i->change_setting(_setting, value);
+}
+
+void wx_settings_editor::clear_setting(const std::string& _setting)
+{
+	for(auto i : esettings)
+		i->clear_setting(_setting);
+}
+
+wx_settings_editor_listener::wx_settings_editor_listener(wx_settings_editor* _editor)
+{
+	editor = _editor;
+}
+
+wx_settings_editor_listener::~wx_settings_editor_listener() throw()
+{
+}
+
+void wx_settings_editor_listener::on_setting_change(const std::string& _setting, const std::string& value)
+{
+	editor->change_setting(_setting, value);
+}
+
+void wx_settings_editor_listener::on_setting_clear(const std::string& _setting)
+{
+	editor->clear_setting(_setting);
+}
diff --git a/platform/wxwidgets/src/settingseditor.hpp b/platform/wxwidgets/src/settingseditor.hpp
new file mode 100644
index 00000000..901728b0
--- /dev/null
+++ b/platform/wxwidgets/src/settingseditor.hpp
@@ -0,0 +1,56 @@
+#ifndef _wxwidgets_settingseditor__hpp__included__
+#define _wxwidgets_settingseditor__hpp__included__
+
+#include <wx/wx.h>
+#include <wx/event.h>
+#include <wx/control.h>
+#include <wx/combobox.h>
+#include <vector>
+#include <string>
+#include "window.hpp"
+
+class wx_settings_editor_setting : public wxEvtHandler
+{
+public:
+	wx_settings_editor_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 wx_settings_editor;
+
+class wx_settings_editor_listener : public window_callback
+{
+public:
+	wx_settings_editor_listener(wx_settings_editor* _editor);
+	~wx_settings_editor_listener() throw();
+	void on_setting_change(const std::string& setting, const std::string& value);
+	void on_setting_clear(const std::string& setting);
+private:
+	wx_settings_editor* editor;
+};
+
+class wx_settings_editor : public wxDialog
+{
+public:
+	wx_settings_editor(wxWindow* parent);
+	~wx_settings_editor();
+	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:
+	wx_settings_editor_listener listener;
+	std::vector<wx_settings_editor_setting*> esettings;
+	wxButton* close;
+};
+
+#endif
diff --git a/platform/wxwidgets/src/status_window.cpp b/platform/wxwidgets/src/status_window.cpp
new file mode 100644
index 00000000..271c4206
--- /dev/null
+++ b/platform/wxwidgets/src/status_window.cpp
@@ -0,0 +1,75 @@
+#include "status_window.hpp"
+#include "window.hpp"
+#include "emufn.hpp"
+
+
+#define MAXSTATUS 30
+
+class wx_status_panel : public wxPanel
+{
+public:
+	wx_status_panel(unsigned lines);
+	void on_paint(wxPaintEvent& e);
+	bool dirty;
+};
+
+wx_status_window* wx_status_window::ptr;
+
+wx_status_panel::wx_status_panel(unsigned lines)
+	: wxPanel(wx_status_window::ptr)
+{
+	dirty = false;
+	wxMemoryDC d;
+	wxSize s = d.GetTextExtent(wxT("MMMMMM"));
+	SetMinSize(wxSize(6 * s.x, lines * s.y));
+	this->Connect(wxEVT_PAINT, wxPaintEventHandler(wx_status_panel::on_paint), NULL, this);
+}
+
+
+namespace {
+	wx_status_panel* spanel;
+}
+
+wx_status_window::wx_status_window()
+	: wxFrame(NULL, wxID_ANY, wxT("lsnes: Status"), wxDefaultPosition, wxSize(-1, -1), secondary_window_style)
+{
+	ptr = this;
+	wxFlexGridSizer* top_s = new wxFlexGridSizer(1, 1, 0, 0);
+	top_s->Add(spanel = new wx_status_panel(MAXSTATUS));
+	top_s->SetSizeHints(this);
+	SetSizer(top_s);
+	Fit();
+}
+
+wx_status_window::~wx_status_window()
+{
+	ptr = NULL;
+}
+
+void wx_status_panel::on_paint(wxPaintEvent& e)
+{
+	wxPaintDC dc(this);
+	dc.Clear();
+	int y = 0;
+	auto& status = window::get_emustatus();
+	for(auto i : status) {
+		std::string pstr = i.first + ": " + i.second;
+		wxSize s = dc.GetTextExtent(towxstring(pstr));
+		dc.DrawText(towxstring(pstr), 0, y);
+		y += s.y;
+	}
+	dirty = false;
+}
+
+void wx_status_window::notify_status_change()
+{
+	if(!spanel || spanel->dirty)
+		return;
+	spanel->dirty = true;
+	spanel->Refresh();
+}
+
+bool wx_status_window::ShouldPreventAppExit() const
+{
+	return false;
+}
diff --git a/platform/wxwidgets/src/status_window.hpp b/platform/wxwidgets/src/status_window.hpp
new file mode 100644
index 00000000..b87b1def
--- /dev/null
+++ b/platform/wxwidgets/src/status_window.hpp
@@ -0,0 +1,24 @@
+#ifndef _wxwidgets_status_window__hpp__included__
+#define _wxwidgets_status_window__hpp__included__
+
+#include <wx/wx.h>
+#include <wx/event.h>
+#include <wx/control.h>
+#include <wx/combobox.h>
+#include "common.hpp"
+#include <map>
+#include <string>
+
+class wx_status_window : public wxFrame
+{
+public:
+	wx_status_window();
+	~wx_status_window();
+	bool ShouldPreventAppExit() const;
+	static wx_status_window* ptr;
+	void notify_status_change();
+};
+
+void repaint_status_window();
+
+#endif
-- 
2.11.4.GIT