?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Delay committing fullscreen until seeing window size change
[lsnes.git] / src / platform / wxwidgets / mainwindow.cpp
blob8d31807276135589ccc057f4e2124fbfa53a7f00
1 #include "lsnes.hpp"
2
3 #include <wx/dnd.h>
4 #include "platform/wxwidgets/menu_dump.hpp"
5 #include "platform/wxwidgets/menu_upload.hpp"
6 #include "platform/wxwidgets/platform.hpp"
7 #include "platform/wxwidgets/loadsave.hpp"
8 #include "platform/wxwidgets/window_mainwindow.hpp"
9 #include "platform/wxwidgets/window_messages.hpp"
10 #include "platform/wxwidgets/window_status.hpp"
11 #include "platform/wxwidgets/window-romload.hpp"
12 #include "platform/wxwidgets/settings-common.hpp"
13 #include "platform/wxwidgets/menu_tracelog.hpp"
14 #include "platform/wxwidgets/menu_branches.hpp"
15 #include "platform/wxwidgets/menu_projects.hpp"
16
17 #include "cmdhelp/framebuffer.hpp"
18 #include "cmdhelp/loadsave.hpp"
19 #include "cmdhelp/lua.hpp"
20 #include "cmdhelp/subtitles.hpp"
21 #include "core/audioapi.hpp"
22 #include "core/audioapi-driver.hpp"
23 #include "core/command.hpp"
24 #include "core/controller.hpp"
25 #include "core/controllerframe.hpp"
26 #include "core/dispatch.hpp"
27 #include "core/emustatus.hpp"
28 #include "core/framebuffer.hpp"
29 #include "core/framerate.hpp"
30 #include "core/instance.hpp"
31 #include "core/keymapper.hpp"
32 #include "core/ui-services.hpp"
33 #include "interface/romtype.hpp"
34 #include "core/loadlib.hpp"
35 #include "lua/lua.hpp"
36 #include "core/mainloop.hpp"
37 #include "core/memorywatch.hpp"
38 #include "core/messages.hpp"
39 #include "core/misc.hpp"
40 #include "core/moviedata.hpp"
41 #include "core/project.hpp"
42 #include "core/rom.hpp"
43 #include "core/settings.hpp"
44 #include "core/window.hpp"
45 #include "library/directory.hpp"
46 #include "library/minmax.hpp"
47 #include "library/string.hpp"
48 #include "library/zip.hpp"
49 #if defined(_WIN32) || defined(_WIN64) || defined(TEST_WIN32_CODE)
50 #define FUCKED_SYSTEM
51 #endif
52
53 #include <cmath>
54 #include <vector>
55 #include <string>
56
57
58 extern "C"
59 {
60 #ifndef UINT64_C
61 #define UINT64_C(val) val##ULL
62 #endif
63 #include <libswscale/swscale.h>
64 }
65
66 enum
67 {
68 wxID_PAUSE = wxID_HIGHEST + 1,
69 wxID_FRAMEADVANCE,
70 wxID_SUBFRAMEADVANCE,
71 wxID_NEXTPOLL,
72 wxID_AUDIO_ENABLED,
73 wxID_SAVE_STATE,
74 wxID_SAVE_MOVIE,
75 wxID_SAVE_SUBTITLES,
76 wxID_LOAD_STATE,
77 wxID_LOAD_MOVIE,
78 wxID_RUN_SCRIPT,
79 wxID_RUN_LUA,
80 wxID_RESET_LUA,
81 wxID_EVAL_LUA,
82 wxID_SAVE_SCREENSHOT,
83 wxID_READONLY_MODE,
84 wxID_EDIT_AUTHORS,
85 wxID_AUTOHOLD,
86 wxID_EDIT_MEMORYWATCH,
87 wxID_SAVE_MEMORYWATCH,
88 wxID_LOAD_MEMORYWATCH,
89 wxID_EDIT_SUBTITLES,
90 wxID_EDIT_VSUBTITLES,
91 wxID_DUMP_FIRST,
92 wxID_DUMP_LAST = wxID_DUMP_FIRST + 1023,
93 wxID_REWIND_MOVIE,
94 wxID_MEMORY_SEARCH,
95 wxID_CANCEL_SAVES,
96 wxID_SHOW_STATUS,
97 wxID_SET_SPEED,
98 wxID_SPEED_5,
99 wxID_SPEED_10,
100 wxID_SPEED_17,
101 wxID_SPEED_20,
102 wxID_SPEED_25,
103 wxID_SPEED_33,
104 wxID_SPEED_50,
105 wxID_SPEED_100,
106 wxID_SPEED_150,
107 wxID_SPEED_200,
108 wxID_SPEED_300,
109 wxID_SPEED_500,
110 wxID_SPEED_1000,
111 wxID_SPEED_TURBO,
112 wxID_LOAD_LIBRARY,
113 wxID_RELOAD_ROM_IMAGE,
114 wxID_LOAD_ROM_IMAGE_FIRST,
115 wxID_LOAD_ROM_IMAGE_LAST = wxID_LOAD_ROM_IMAGE_FIRST + 1023,
116 wxID_NEW_MOVIE,
117 wxID_SHOW_MESSAGES,
118 wxID_DEDICATED_MEMORY_WATCH,
119 wxID_RMOVIE_FIRST,
120 wxID_RMOVIE_LAST = wxID_RMOVIE_FIRST + 16,
121 wxID_RROM_FIRST,
122 wxID_RROM_LAST = wxID_RROM_FIRST + 16,
123 wxID_CONFLICTRESOLUTION,
124 wxID_VUDISPLAY,
125 wxID_MOVIE_EDIT,
126 wxID_TASINPUT,
127 wxID_NEW_PROJECT,
128 wxID_CLOSE_PROJECT,
129 wxID_CLOSE_ROM,
130 wxID_EDIT_MACROS,
131 wxID_ENTER_FULLSCREEN,
132 wxID_ACTIONS_FIRST,
133 wxID_ACTIONS_LAST = wxID_ACTIONS_FIRST + 256,
134 wxID_SETTINGS_FIRST,
135 wxID_SETTINGS_LAST = wxID_SETTINGS_FIRST + 256,
136 wxID_HEXEDITOR,
137 wxID_MULTITRACK,
138 wxID_CHDIR,
139 wxID_RLUA_FIRST,
140 wxID_RLUA_LAST = wxID_RLUA_FIRST + 16,
141 wxID_UPLOAD_FIRST,
142 wxID_UPLOAD_LAST = wxID_UPLOAD_FIRST + 256,
143 wxID_DOWNLOAD,
144 wxID_TRACELOG_FIRST,
145 wxID_TRACELOG_LAST = wxID_TRACELOG_FIRST + 256,
146 wxID_PLUGIN_MANAGER,
147 wxID_BRANCH_FIRST,
148 wxID_BRANCH_LAST = wxID_BRANCH_FIRST + 10240,
149 wxID_PROJECT_FIRST,
150 wxID_PROJECT_LAST = wxID_PROJECT_FIRST + 17,
151 wxID_DISASSEMBLER,
152 };
153
154
155 double video_scale_factor = 1.0;
156 int scaling_flags = SWS_POINT;
157 bool arcorrect_enabled = false;
158 bool hflip_enabled = false;
159 bool vflip_enabled = false;
160 bool rotate_enabled = false;
161
162 namespace
163 {
164 std::string last_volume = "0dB";
165 std::string last_volume_record = "0dB";
166 std::string last_volume_voice = "0dB";
167 unsigned char* screen_buffer;
168 struct SwsContext* sws_ctx;
169 uint32_t* rotate_buffer;
170 uint32_t old_width;
171 uint32_t old_height;
172 int old_flags = SWS_POINT;
173 bool old_hflip = false;
174 bool old_vflip = false;
175 bool old_rotate = false;
176 bool main_window_dirty;
177 bool is_fs = false;
178 bool hashing_in_progress = false;
179 uint64_t hashing_left = 0;
180 uint64_t hashing_total = 0;
181 int64_t last_update = 0;
182 threads::thread* emulation_thread;
183 bool status_updated = false;
184 bool becoming_fullscreen = false;
185 wxSize current_resolution;
186
187 settingvar::variable<settingvar::model_bool<settingvar::yes_no>> background_audio(*lsnes_instance.settings,
188 "background-audio", "GUIā€£Enable background audio", true);
189
190 class _status_timer : public wxTimer
191 {
192 public:
193 _status_timer()
194 {
195 Start(50);
196 }
197 void Notify()
198 {
199 if(status_updated) {
200 status_updated = false;
201 if(main_window) main_window->update_statusbar();
202 }
203 }
204 };
205
206 void cleanup_dead_download_timers();
207 class _focus_timer : public wxTimer
208 {
209 public:
210 _focus_timer()
211 {
212 was_focused = (wxWindow::FindFocus() != NULL);
213 was_enabled = platform::is_sound_enabled();
214 Start(500);
215 }
216 void Notify()
217 {
218 CHECK_UI_THREAD;
219 bool is_focused = (wxWindow::FindFocus() != NULL);
220 if(is_focused && !was_focused) {
221 //Gained focus.
222 if(!background_audio)
223 platform::sound_enable(was_enabled);
224 } else if(!is_focused && was_focused) {
225 //Lost focus.
226 was_enabled = platform::is_sound_enabled();
227 if(!background_audio)
228 platform::sound_enable(false);
229 }
230 was_focused = is_focused;
231 cleanup_dead_download_timers();
232 }
233 private:
234 bool was_focused;
235 bool was_enabled;
236 };
237
238 class download_timer;
239 std::list<download_timer*> download_timer_gc_queue;
240
241 class download_timer : public wxTimer
242 {
243 public:
244 download_timer(wxwin_mainwindow* main, emulator_instance& _inst)
245 : inst(_inst)
246 {
247 w = main;
248 Start(50);
249 }
250 void Notify()
251 {
252 CHECK_UI_THREAD;
253 if(!w->download_in_progress) {
254 //Received a call with download finish already done. Ignore.
255 return;
256 }
257 if(w->download_in_progress->finished) {
258 w->update_statusbar();
259 auto old = w->download_in_progress;
260 w->download_in_progress = NULL;
261 if(old->errormsg != "") {
262 show_message_ok(w, "Error downloading movie", old->errormsg,
263 wxICON_EXCLAMATION);
264 } else {
265 inst.iqueue->queue(CLOADSAVE::ldm.name, "$MEMORY:wxwidgets_download_tmp");
266 }
267 delete old;
268 try { download_timer_gc_queue.push_back(this); } catch(...) { Stop(); }
269 } else {
270 w->update_statusbar();
271 }
272 }
273 private:
274 emulator_instance& inst;
275 wxwin_mainwindow* w;
276 };
277
278 void cleanup_dead_download_timers()
279 {
280 for(auto i : download_timer_gc_queue) {
281 i->Stop();
282 delete i;
283 }
284 download_timer_gc_queue.clear();
285 }
286
287 void hash_callback(uint64_t left, uint64_t total)
288 {
289 wxwin_mainwindow* mwin = main_window;
290 if(left == 0xFFFFFFFFFFFFFFFFULL) {
291 hashing_in_progress = false;
292 runuifun([mwin]() { if(mwin) mwin->notify_update_status(); });
293 last_update = framerate_regulator::get_utime() - 2000000;
294 return;
295 }
296 hashing_in_progress = true;
297 hashing_left = left;
298 hashing_total = total;
299 int64_t this_update = framerate_regulator::get_utime();
300 if(this_update < last_update - 1000000 || this_update > last_update + 1000000) {
301 runuifun([mwin]() { if(mwin) mwin->notify_update_status(); });
302 last_update = this_update;
303 }
304 }
305
306 std::pair<std::string, std::string> lsplit(std::string l)
307 {
308 for(unsigned i = 0; i < l.length() - 3; i++)
309 if((uint8_t)l[i] == 0xE2 && (uint8_t)l[i + 1] == 0x80 && (uint8_t)l[i + 2] == 0xA3)
310 return std::make_pair(l.substr(0, i), l.substr(i + 3));
311 return std::make_pair("", l);
312 }
313
314 recentfiles::multirom loadreq_to_multirom(const romload_request& req)
315 {
316 recentfiles::multirom r;
317 r.packfile = req.packfile;
318 r.singlefile = req.singlefile;
319 r.core = req.core;
320 r.system = req.system;
321 r.region = req.region;
322 for(unsigned i = 0; i < ROM_SLOT_COUNT; i++)
323 if(req.files[i] != "") {
324 r.files.resize(i + 1);
325 r.files[i] = req.files[i];
326 }
327 return r;
328 }
329
330 class system_menu : public wxMenu
331 {
332 public:
333 system_menu(wxWindow* win, emulator_instance& _inst);
334 ~system_menu();
335 void on_select(wxCommandEvent& e);
336 void update(bool light);
337 private:
338 emulator_instance& inst;
339 wxWindow* pwin;
340 void insert_pass(int id, const std::string& label);
341 void insert_act(unsigned id, const std::string& label, bool dots, bool check);
342 wxMenu* lookup_menu(const std::string& key);
343 wxMenuItem* sep;
344 std::map<int, unsigned> action_by_id;
345 std::map<unsigned, wxMenuItem*> item_by_action;
346 std::map<wxMenuItem*, wxMenu*> menu_by_item;
347 std::map<std::string, wxMenu*> submenu_by_name;
348 std::map<std::string, wxMenuItem*> submenui_by_name;
349 std::set<unsigned> toggles;
350 int next_id;
351 };
352
353 wxMenu* system_menu::lookup_menu(const std::string& key)
354 {
355 CHECK_UI_THREAD;
356 if(key == "")
357 return this;
358 if(submenu_by_name.count(key))
359 return submenu_by_name[key];
360 //Not found, create.
361 if(!sep)
362 sep = AppendSeparator();
363 auto p = lsplit(key);
364 wxMenu* into = lookup_menu(p.first);
365 submenu_by_name[key] = new wxMenu();
366 submenui_by_name[key] = into->AppendSubMenu(submenu_by_name[key], towxstring(p.second));
367 menu_by_item[submenui_by_name[key]] = into;
368 return submenu_by_name[key];
369 }
370
371 void system_menu::insert_act(unsigned id, const std::string& label, bool dots, bool check)
372 {
373 CHECK_UI_THREAD;
374 if(!sep)
375 sep = AppendSeparator();
376
377 auto p = lsplit(label);
378 wxMenu* into = lookup_menu(p.first);
379
380 action_by_id[next_id] = id;
381 std::string use_label = p.second + (dots ? "..." : "");
382 if(check) {
383 item_by_action[id] = into->AppendCheckItem(next_id, towxstring(use_label));
384 toggles.insert(id);
385 } else
386 item_by_action[id] = into->Append(next_id, towxstring(use_label));
387 menu_by_item[item_by_action[id]] = into;
388 pwin->Connect(next_id++, wxEVT_COMMAND_MENU_SELECTED,
389 wxCommandEventHandler(system_menu::on_select), NULL, this);
390 }
391
392 void system_menu::insert_pass(int id, const std::string& label)
393 {
394 CHECK_UI_THREAD;
395 pwin->Connect(id, wxEVT_COMMAND_MENU_SELECTED,
396 wxCommandEventHandler(wxwin_mainwindow::handle_menu_click), NULL, pwin);
397 Append(id, towxstring(label));
398 }
399
400 system_menu::system_menu(wxWindow* win, emulator_instance& _inst)
401 : inst(_inst)
402 {
403 CHECK_UI_THREAD;
404 pwin = win;
405 insert_pass(wxID_PAUSE, "Pause/Unpause");
406 insert_pass(wxID_FRAMEADVANCE, "Step frame");
407 insert_pass(wxID_SUBFRAMEADVANCE, "Step subframe");
408 insert_pass(wxID_NEXTPOLL, "Step poll");
409 sep = NULL;
410 }
411
412 system_menu::~system_menu()
413 {
414 }
415
416 void system_menu::on_select(wxCommandEvent& e)
417 {
418 CHECK_UI_THREAD;
419 if(!action_by_id.count(e.GetId()))
420 return;
421 unsigned act_id = action_by_id[e.GetId()];
422 const interface_action* act = NULL;
423 for(auto i : inst.rom->get_actions())
424 if(i->id == act_id) {
425 act = i;
426 break;
427 }
428 if(!act)
429 return;
430 try {
431 auto p = prompt_action_params(pwin, act->get_title(), act->params);
432 inst.iqueue->run([this, act_id,p]() { this->inst.rom->execute_action(act_id, p); });
433 } catch(canceled_exception& e) {
434 } catch(std::bad_alloc& e) {
435 OOM_panic();
436 }
437 }
438
439 void system_menu::update(bool light)
440 {
441 CHECK_UI_THREAD;
442 if(!light) {
443 next_id = wxID_ACTIONS_FIRST;
444 if(sep) {
445 Destroy(sep);
446 sep = NULL;
447 }
448 for(auto i = item_by_action.begin(); i != item_by_action.end(); i++)
449 menu_by_item[i->second]->Destroy(i->second);
450 for(auto i = submenui_by_name.rbegin(); i != submenui_by_name.rend(); i++)
451 menu_by_item[i->second]->Destroy(i->second);
452 action_by_id.clear();
453 item_by_action.clear();
454 menu_by_item.clear();
455 submenu_by_name.clear();
456 submenui_by_name.clear();
457 toggles.clear();
458
459 for(auto i : inst.rom->get_actions())
460 insert_act(i->id, i->get_title(), !i->params.empty(), i->is_toggle());
461 }
462 for(auto i : item_by_action)
463 i.second->Enable(inst.rom->action_flags(i.first) & 1);
464 for(auto i : toggles)
465 item_by_action[i]->Check(inst.rom->action_flags(i) & 2);
466 }
467
468 std::string munge_name(const std::string& orig)
469 {
470 std::string newname;
471 regex_results r;
472 if(r = regex("(.*)\\(([0-9]+)\\)", newname)) {
473 uint64_t sequence;
474 try {
475 sequence = parse_value<uint64_t>(r[2]);
476 newname = (stringfmt() << r[1] << "(" << sequence + 1 << ")").str();
477 } catch(...) {
478 newname = newname + "(2)";
479 }
480 } else {
481 newname = newname + "(2)";
482 }
483 return newname;
484 }
485
486 void handle_watch_load(emulator_instance& inst, std::map<std::string, std::string>& new_watches,
487 std::set<std::string>& old_watches)
488 {
489 auto proj = inst.project->get();
490 if(proj) {
491 for(auto i : new_watches) {
492 std::string name = i.first;
493 while(true) {
494 if(!old_watches.count(name)) {
495 try {
496 if(name != "" && i.second != "")
497 inst.mwatch->set(name, i.second);
498 } catch(std::exception& e) {
499 messages << "Can't set memory watch '" << name << "': "
500 << e.what() << std::endl;
501 }
502 break;
503 } else if(inst.mwatch->get_string(name) == i.second)
504 break;
505 else
506 name = munge_name(name);
507 }
508 }
509 } else {
510 for(auto i : new_watches)
511 try {
512 if(i.first != "" && i.second != "")
513 inst.mwatch->set(i.first, i.second);
514 } catch(std::exception& e) {
515 messages << "Can't set memory watch '" << i.first << "': "
516 << e.what() << std::endl;
517 }
518 for(auto i : old_watches)
519 if(!new_watches.count(i))
520 try {
521 inst.mwatch->clear(i);
522 } catch(std::exception& e) {
523 messages << "Can't clear memory watch '" << i << "': "
524 << e.what() << std::endl;
525 }
526 }
527 }
528
529 std::string get_default_screenshot_name(emulator_instance& inst)
530 {
531 auto p = inst.project->get();
532 if(!p)
533 return "";
534 else {
535 auto files = directory::enumerate(p->directory, ".*-[0-9]+\\.png");
536 std::set<std::string> numbers;
537 for(auto i : files) {
538 size_t split;
539 #ifdef FUCKED_SYSTEM
540 split = i.find_last_of("\\/");
541 #else
542 split = i.find_last_of("/");
543 #endif
544 std::string name = i;
545 if(split < name.length())
546 name = name.substr(split + 1);
547 regex_results r = regex("(.*)-([0-9]+)\\.png", name);
548 if(r[1] != p->prefix)
549 continue;
550 numbers.insert(r[2]);
551 }
552 for(uint64_t i = 1;; i++) {
553 std::string candidate = (stringfmt() << i).str();
554 if(!numbers.count(candidate))
555 return p->prefix + "-" + candidate + ".png";
556 }
557 }
558 }
559
560 std::string project_prefixname(emulator_instance& inst, const std::string ext)
561 {
562 auto p = inst.project->get();
563 if(!p)
564 return "";
565 else
566 return p->prefix + "." + ext;
567
568 }
569
570 void recent_rom_selected(emulator_instance& inst, const recentfiles::multirom& file)
571 {
572 romload_request req;
573 req.packfile = file.packfile;
574 req.singlefile = file.singlefile;
575 req.core = file.core;
576 req.system = file.system;
577 req.region = file.region;
578 for(unsigned i = 0; i < file.files.size() && i < ROM_SLOT_COUNT; i++)
579 req.files[i] = file.files[i];
580 inst.iqueue->run_async([req]() {
581 CORE().command->invoke("unpause-emulator");
582 load_new_rom(req);
583 }, [](std::exception& e) {});
584 }
585
586 void recent_movie_selected(emulator_instance& inst, const recentfiles::path& file)
587 {
588 inst.iqueue->queue(CLOADSAVE::ldsm.name, file.get_path());
589 }
590
591 void recent_script_selected(emulator_instance& inst, const recentfiles::path& file)
592 {
593 inst.iqueue->queue(CLUA::run.name, file.get_path());
594 }
595
596 wxString getname(emulator_instance& inst)
597 {
598 std::string windowname = "lsnes rr" + lsnes_version + " [";
599 auto p = inst.project->get();
600 if(p)
601 windowname = windowname + p->name;
602 else
603 windowname = windowname + inst.rom->get_core_identifier();
604 windowname = windowname + "]";
605 return towxstring(windowname);
606 }
607
608 struct emu_args
609 {
610 emulator_instance* inst;
611 struct loaded_rom rom;
612 struct moviefile* initial;
613 bool load_has_to_succeed;
614 };
615
616 void* emulator_main(void* _args)
617 {
618 struct emu_args* args = reinterpret_cast<struct emu_args*>(_args);
619 auto& inst = *args->inst;
620 try {
621 *inst.rom = args->rom;
622 messages << "Using core: " << inst.rom->get_core_identifier() << std::endl;
623 struct moviefile* movie = args->initial;
624 bool has_to_succeed = args->load_has_to_succeed;
625 platform::flush_command_queue();
626 main_loop(*inst.rom, *movie, has_to_succeed);
627 signal_program_exit();
628 } catch(std::bad_alloc& e) {
629 OOM_panic();
630 } catch(std::exception& e) {
631 messages << "FATAL: " << e.what() << std::endl;
632 platform::fatal_error();
633 }
634 delete args;
635 return NULL;
636 }
637
638 void join_emulator_thread()
639 {
640 emulation_thread->join();
641 }
642
643 bool is_readonly_mode(emulator_instance& inst)
644 {
645 bool ret;
646 inst.iqueue->run([&ret]() {
647 ret = *CORE().mlogic ? CORE().mlogic->get_movie().readonly_mode() : false;
648 });
649 return ret;
650 }
651
652 void set_speed(emulator_instance& inst, double target)
653 {
654 if(target < 0)
655 inst.framerate->set_speed_multiplier(std::numeric_limits<double>::infinity());
656 else
657 inst.framerate->set_speed_multiplier(target / 100);
658 }
659
660 void update_preferences()
661 {
662 preferred_core.clear();
663 for(auto i : core_type::get_core_types()) {
664 std::string val = i->get_hname() + " / " + i->get_core_identifier();
665 for(auto j : i->get_extensions()) {
666 std::string key = "ext:" + j;
667 if(core_selections.count(key) && core_selections[key] == val)
668 preferred_core[key] = i;
669 }
670 std::string key2 = "type:" + i->get_iname();
671 if(core_selections.count(key2) && core_selections[key2] == val)
672 preferred_core[key2] = i;
673 }
674 }
675
676 bool is_lsnes_movie(const std::string& filename)
677 {
678 std::istream* s = NULL;
679 try {
680 bool ans = false;
681 s = &zip::openrel(filename, "");
682 char buf[6] = {0};
683 s->read(buf, 5);
684 if(*s && !strcmp(buf, "lsmv\x1A"))
685 ans = true;
686 delete s;
687 if(ans) return true;
688 } catch(...) {
689 delete s;
690 }
691 try {
692 zip::reader r(filename);
693 std::istream& s = r["systemid"];
694 std::string s2;
695 std::getline(s, s2);
696 delete &s;
697 istrip_CR(s2);
698 return (s2 == "lsnes-rr1");
699 } catch(...) {
700 return false;
701 }
702 }
703
704 class loadfile : public wxFileDropTarget
705 {
706 public:
707 loadfile(wxwin_mainwindow* win, emulator_instance& _inst) : inst(_inst), pwin(win) {};
708 bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames)
709 {
710 CHECK_UI_THREAD;
711 bool ret = false;
712 if(filenames.Count() == 2) {
713 std::string a = tostdstring(filenames[0]);
714 std::string b = tostdstring(filenames[1]);
715 bool amov = is_lsnes_movie(a);
716 bool bmov = is_lsnes_movie(b);
717 if(amov == bmov)
718 return false;
719 if(amov) std::swap(a, b);
720 inst.iqueue->run_async([a, b]() {
721 CORE().command->invoke("unpause-emulator");
722 romload_request req;
723 req.packfile = a;
724 load_new_rom(req);
725 CORE().command->invoke(CLOADSAVE::ldsm.name, b);
726 }, [](std::exception& e) {});
727 ret = true;
728 }
729 if(filenames.Count() == 1) {
730 std::string a = tostdstring(filenames[0]);
731 bool amov = is_lsnes_movie(a);
732 if(amov) {
733 inst.iqueue->queue(CLOADSAVE::ldsm.name, a);
734 pwin->recent_movies->add(a);
735 ret = true;
736 } else {
737 romload_request req;
738 req.packfile = a;
739 inst.iqueue->run_async([req]() {
740 CORE().command->invoke("unpause-emulator");
741 load_new_rom(req);
742 }, [](std::exception& e) {});
743 pwin->recent_roms->add(loadreq_to_multirom(req));
744 ret = true;
745 }
746 }
747 return ret;
748 }
749 emulator_instance& inst;
750 wxwin_mainwindow* pwin;
751 };
752 }
753
754 void boot_emulator(emulator_instance& inst, loaded_rom& rom, moviefile& movie, bool fscreen)
755 {
756 CHECK_UI_THREAD;
757 update_preferences();
758 try {
759 struct emu_args* a = new emu_args;
760 a->rom = rom;
761 a->initial = &movie;
762 a->load_has_to_succeed = false;
763 a->inst = &inst;
764 modal_pause_holder hld;
765 emulation_thread = new threads::thread(emulator_main, a);
766 main_window = new wxwin_mainwindow(inst, fscreen);
767 main_window->Show();
768 } catch(std::bad_alloc& e) {
769 OOM_panic();
770 }
771 }
772
773 wxwin_mainwindow::panel::panel(wxWindow* win, emulator_instance& _inst)
774 : wxPanel(win, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxWANTS_CHARS), inst(_inst)
775 {
776 CHECK_UI_THREAD;
777 this->Connect(wxEVT_PAINT, wxPaintEventHandler(panel::on_paint), NULL, this);
778 this->Connect(wxEVT_ERASE_BACKGROUND, wxEraseEventHandler(panel::on_erase), NULL, this);
779 this->Connect(wxEVT_KEY_DOWN, wxKeyEventHandler(panel::on_keyboard_down), NULL, this);
780 this->Connect(wxEVT_KEY_UP, wxKeyEventHandler(panel::on_keyboard_up), NULL, this);
781 this->Connect(wxEVT_LEFT_DOWN, wxMouseEventHandler(panel::on_mouse), NULL, this);
782 this->Connect(wxEVT_LEFT_UP, wxMouseEventHandler(panel::on_mouse), NULL, this);
783 this->Connect(wxEVT_MIDDLE_DOWN, wxMouseEventHandler(panel::on_mouse), NULL, this);
784 this->Connect(wxEVT_MIDDLE_UP, wxMouseEventHandler(panel::on_mouse), NULL, this);
785 this->Connect(wxEVT_RIGHT_DOWN, wxMouseEventHandler(panel::on_mouse), NULL, this);
786 this->Connect(wxEVT_RIGHT_UP, wxMouseEventHandler(panel::on_mouse), NULL, this);
787 this->Connect(wxEVT_MOTION, wxMouseEventHandler(panel::on_mouse), NULL, this);
788 this->Connect(wxEVT_ENTER_WINDOW, wxMouseEventHandler(panel::on_mouse), NULL, this);
789 this->Connect(wxEVT_LEAVE_WINDOW, wxMouseEventHandler(panel::on_mouse), NULL, this);
790 SetMinSize(wxSize(512, 448));
791 }
792
793 void wxwin_mainwindow::menu_start(wxString name)
794 {
795 CHECK_UI_THREAD;
796 while(!upper.empty())
797 upper.pop();
798 current_menu = new wxMenu();
799 menubar->Append(current_menu, name);
800 }
801
802 void wxwin_mainwindow::menu_special(wxString name, wxMenu* menu)
803 {
804 CHECK_UI_THREAD;
805 while(!upper.empty())
806 upper.pop();
807 menubar->Append(menu, name);
808 current_menu = NULL;
809 }
810
811 wxMenuItem* wxwin_mainwindow::menu_special_sub(wxString name, wxMenu* menu)
812 {
813 CHECK_UI_THREAD;
814 return current_menu->AppendSubMenu(menu, name);
815 }
816
817 void wxwin_mainwindow::menu_entry(int id, wxString name)
818 {
819 CHECK_UI_THREAD;
820 current_menu->Append(id, name);
821 Connect(id, wxEVT_COMMAND_MENU_SELECTED,
822 wxCommandEventHandler(wxwin_mainwindow::wxwin_mainwindow::handle_menu_click), NULL, this);
823 }
824
825 void wxwin_mainwindow::menu_entry_check(int id, wxString name)
826 {
827 CHECK_UI_THREAD;
828 checkitems[id] = current_menu->AppendCheckItem(id, name);
829 Connect(id, wxEVT_COMMAND_MENU_SELECTED,
830 wxCommandEventHandler(wxwin_mainwindow::wxwin_mainwindow::handle_menu_click), NULL, this);
831 }
832
833 void wxwin_mainwindow::menu_start_sub(wxString name)
834 {
835 CHECK_UI_THREAD;
836 wxMenu* old = current_menu;
837 upper.push(current_menu);
838 current_menu = new wxMenu();
839 old->AppendSubMenu(current_menu, name);
840 }
841
842 void wxwin_mainwindow::menu_end_sub()
843 {
844 current_menu = upper.top();
845 upper.pop();
846 }
847
848 bool wxwin_mainwindow::menu_ischecked(int id)
849 {
850 CHECK_UI_THREAD;
851 if(checkitems.count(id))
852 return checkitems[id]->IsChecked();
853 else
854 return false;
855 }
856
857 void wxwin_mainwindow::menu_check(int id, bool newstate)
858 {
859 CHECK_UI_THREAD;
860 if(checkitems.count(id))
861 return checkitems[id]->Check(newstate);
862 else
863 return;
864 }
865
866 void wxwin_mainwindow::menu_enable(int id, bool newstate)
867 {
868 CHECK_UI_THREAD;
869 auto item = menubar->FindItem(id);
870 if(!item)
871 return;
872 item->Enable(newstate);
873 }
874
875 void wxwin_mainwindow::menu_separator()
876 {
877 CHECK_UI_THREAD;
878 current_menu->AppendSeparator();
879 }
880
881 void wxwin_mainwindow::panel::request_paint()
882 {
883 CHECK_UI_THREAD;
884 Refresh();
885 }
886
887 std::pair<double, double> calc_scale_factors(double factor, bool ar, double par)
888 {
889 if(!ar)
890 return std::make_pair(factor, factor);
891 else if(par < 1) {
892 //Too wide, make taller.
893 return std::make_pair(factor, factor / par);
894 } else {
895 //Too narrow, make wider.
896 return std::make_pair(factor * par, factor);
897 }
898 }
899
900 void wxwin_mainwindow::panel::on_paint(wxPaintEvent& e)
901 {
902 CHECK_UI_THREAD;
903 if(wx_escape_count >= 3 && is_fs) {
904 //Leave fullscreen mode.
905 main_window->enter_or_leave_fullscreen(false);
906 }
907 inst.fbuf->render_framebuffer();
908 uint8_t* srcp[1];
909 int srcs[1];
910 uint8_t* dstp[1];
911 int dsts[1];
912 wxPaintDC dc(this);
913 uint32_t tw, th;
914 bool aux = hflip_enabled || vflip_enabled || rotate_enabled;
915 auto sfactors = calc_scale_factors(video_scale_factor, arcorrect_enabled, inst.rom->get_PAR());
916 if(rotate_enabled) {
917 tw = inst.fbuf->main_screen.get_height() * sfactors.second + 0.5;
918 th = inst.fbuf->main_screen.get_width() * sfactors.first + 0.5;
919 } else {
920 tw = inst.fbuf->main_screen.get_width() * sfactors.first + 0.5;
921 th = inst.fbuf->main_screen.get_height() * sfactors.second + 0.5;
922 }
923 if(!tw || !th) {
924 main_window_dirty = false;
925 return;
926 }
927 //Scale this to fullscreen.
928 unsigned dx = 0, dy = 0;
929 if(is_fs) {
930 wxSize screen = main_window->GetSize();
931 double fss = min(1.0 * screen.GetWidth() / tw, 1.0 * screen.GetHeight() / th);
932 tw *= fss;
933 th *= fss;
934 if((signed)tw < screen.GetWidth())
935 dx = (screen.GetWidth() - tw) / 2;
936 if((signed)th < screen.GetHeight())
937 dy = (screen.GetHeight() - th) / 2;
938 if(becoming_fullscreen && current_resolution != screen) {
939 //Force panel to fullscreen.
940 SetSize(screen);
941 Move(0, 0);
942 becoming_fullscreen = false;
943 }
944 //Erase borders.
945 signed dx2 = dx + tw;
946 signed dy2 = dy + th;
947 dc.SetBrush(*wxBLACK_BRUSH);
948 dc.SetPen(*wxBLACK_PEN);
949 //Erase the borders we don't draw.
950 if(dx > 0) dc.DrawRectangle(0, 0, dx, screen.GetHeight());
951 if(dy > 0) dc.DrawRectangle(0, 0, screen.GetWidth(), dy);
952 if(dx2 < screen.GetWidth()) dc.DrawRectangle(dx2, 0, screen.GetWidth() - dx2, screen.GetHeight());
953 if(dy2 < screen.GetHeight()) dc.DrawRectangle(0, dy2, screen.GetWidth(), screen.GetHeight() - dy2);
954 }
955
956 if(!screen_buffer || tw != old_width || th != old_height || scaling_flags != old_flags ||
957 hflip_enabled != old_hflip || vflip_enabled != old_vflip || rotate_enabled != old_rotate) {
958 if(screen_buffer) {
959 delete[] screen_buffer;
960 screen_buffer = NULL;
961 }
962 if(rotate_buffer) {
963 delete[] rotate_buffer;
964 rotate_buffer = NULL;
965 }
966 old_height = th;
967 old_width = tw;
968 old_flags = scaling_flags;
969 old_hflip = hflip_enabled;
970 old_vflip = vflip_enabled;
971 old_rotate = rotate_enabled;
972 uint32_t w = inst.fbuf->main_screen.get_width();
973 uint32_t h = inst.fbuf->main_screen.get_height();
974 if(w && h)
975 sws_ctx = sws_getCachedContext(sws_ctx, rotate_enabled ? h : w, rotate_enabled ? w : h,
976 AV_PIX_FMT_RGBA, tw, th, AV_PIX_FMT_BGR24, scaling_flags, NULL, NULL, NULL);
977 tw = max(tw, static_cast<uint32_t>(128));
978 th = max(th, static_cast<uint32_t>(112));
979 screen_buffer = new unsigned char[tw * th * 3 + 64];
980 if(aux)
981 rotate_buffer = new uint32_t[inst.fbuf->main_screen.get_width() *
982 inst.fbuf->main_screen.get_height()];
983 if(!is_fs) {
984 //This is not preformed in fullscreen mode.
985 SetMinSize(wxSize(tw, th));
986 signal_resize_needed();
987 }
988 }
989 if(aux) {
990 //Hflip, Vflip or rotate active.
991 size_t width = inst.fbuf->main_screen.get_width();
992 size_t height = inst.fbuf->main_screen.get_height();
993 size_t width1 = width - 1;
994 size_t height1 = height - 1;
995 size_t stride = inst.fbuf->main_screen.rowptr(1) - inst.fbuf->main_screen.rowptr(0);
996 uint32_t* pixels = inst.fbuf->main_screen.rowptr(0);
997 if(rotate_enabled) {
998 for(unsigned y = 0; y < height; y++) {
999 uint32_t* pixels2 = pixels + (vflip_enabled ? (height1 - y) : y) * stride;
1000 uint32_t* dpixels = rotate_buffer + (height1 - y);
1001 if(hflip_enabled)
1002 for(unsigned x = 0; x < width; x++)
1003 dpixels[x * height] = pixels2[width1 - x];
1004 else
1005 for(unsigned x = 0; x < width; x++)
1006 dpixels[x * height] = pixels2[x];
1007 }
1008 } else {
1009 for(unsigned y = 0; y < height; y++) {
1010 uint32_t* pixels2 = pixels + (vflip_enabled ? (height1 - y) : y) * stride;
1011 uint32_t* dpixels = rotate_buffer + y * width;
1012 if(hflip_enabled)
1013 for(unsigned x = 0; x < width; x++)
1014 dpixels[x] = pixels2[width1 - x];
1015 else
1016 for(unsigned x = 0; x < width; x++)
1017 dpixels[x] = pixels2[x];
1018 }
1019 }
1020 }
1021 if(aux)
1022 srcs[0] = 4 * (rotate_enabled ? inst.fbuf->main_screen.get_height() :
1023 inst.fbuf->main_screen.get_width());
1024 else
1025 srcs[0] = 4 * inst.fbuf->main_screen.get_stride();
1026 dsts[0] = 3 * tw;
1027 srcp[0] = reinterpret_cast<unsigned char*>(aux ? rotate_buffer : inst.fbuf->main_screen.rowptr(0));
1028 dstp[0] = screen_buffer;
1029 memset(screen_buffer, 0, tw * th * 3);
1030 if(inst.fbuf->main_screen.get_width() && inst.fbuf->main_screen.get_height())
1031 sws_scale(sws_ctx, srcp, srcs, 0, rotate_enabled ? inst.fbuf->main_screen.get_width() :
1032 inst.fbuf->main_screen.get_height(),
1033 dstp, dsts);
1034 wxBitmap bmp(wxImage(tw, th, screen_buffer, true));
1035 dc.DrawBitmap(bmp, dx, dy, false);
1036 main_window_dirty = false;
1037 main_window->update_statusbar();
1038 }
1039
1040 void wxwin_mainwindow::panel::on_erase(wxEraseEvent& e)
1041 {
1042 //Blank.
1043 }
1044
1045 void wxwin_mainwindow::panel::on_keyboard_down(wxKeyEvent& e)
1046 {
1047 CHECK_UI_THREAD;
1048 handle_wx_keyboard(inst, e, true);
1049 }
1050
1051 void wxwin_mainwindow::panel::on_keyboard_up(wxKeyEvent& e)
1052 {
1053 CHECK_UI_THREAD;
1054 handle_wx_keyboard(inst, e, false);
1055 if(wx_escape_count >= 3 && is_fs) {
1056 //Force leave fullscreen mode.
1057 main_window->enter_or_leave_fullscreen(false);
1058 }
1059 }
1060
1061 void wxwin_mainwindow::panel::on_mouse(wxMouseEvent& e)
1062 {
1063 CHECK_UI_THREAD;
1064 handle_wx_mouse(inst, e);
1065 }
1066
1067 wxwin_mainwindow::wxwin_mainwindow(emulator_instance& _inst, bool fscreen)
1068 : wxFrame(NULL, wxID_ANY, getname(_inst), wxDefaultPosition, wxSize(-1, -1),
1069 wxMINIMIZE_BOX | wxSYSTEM_MENU | wxCAPTION | wxCLIP_CHILDREN | wxCLOSE_BOX), inst(_inst)
1070 {
1071 CHECK_UI_THREAD;
1072 download_in_progress = NULL;
1073 Centre();
1074 mwindow = NULL;
1075 toplevel = new wxFlexGridSizer(1, 2, 0, 0);
1076 toplevel->Add(gpanel = new panel(this, inst), 1, wxGROW);
1077 toplevel->Add(spanel = new wxwin_status::panel(this, inst, gpanel, 20), 1, wxGROW);
1078 spanel_shown = true;
1079 toplevel->SetSizeHints(this);
1080 SetSizer(toplevel);
1081 Fit();
1082 gpanel->SetFocus();
1083 Connect(wxEVT_CLOSE_WINDOW, wxCloseEventHandler(wxwin_mainwindow::on_close));
1084 SetMenuBar(menubar = new wxMenuBar);
1085 SetStatusBar(statusbar = new wxStatusBar(this));
1086
1087 menu_start(wxT("File"));
1088 menu_start_sub(wxT("New"));
1089 menu_entry(wxID_NEW_MOVIE, wxT("Movie..."));
1090 menu_entry(wxID_NEW_PROJECT, wxT("Project..."));
1091 menu_end_sub();
1092 menu_start_sub(wxT("Load"));
1093 menu_entry(wxID_LOAD_STATE, wxT("State..."));
1094 menu_entry(wxID_LOAD_MOVIE, wxT("Movie..."));
1095 menu_entry(wxID_DOWNLOAD, wxT("Download movie..."));
1096 if(loadlib::library::name() != "") {
1097 menu_separator();
1098 menu_entry(wxID_LOAD_LIBRARY, towxstring(std::string("Load ") + loadlib::library::name()));
1099 menu_entry(wxID_PLUGIN_MANAGER, towxstring("Plugin manager"));
1100 }
1101 menu_separator();
1102 menu_entry(wxID_RELOAD_ROM_IMAGE, wxT("Reload ROM"));
1103 menu_entry(wxID_LOAD_ROM_IMAGE_FIRST, wxT("ROM..."));
1104 menu_special_sub(wxT("Multifile ROM"), loadroms = new loadrom_menu(this, wxID_LOAD_ROM_IMAGE_FIRST + 1,
1105 wxID_LOAD_ROM_IMAGE_LAST, [this](core_type* t) { this->do_load_rom_image(t); }));
1106 menu_special_sub(wxT("Project"), projects = new projects_menu(this, inst, wxID_PROJECT_FIRST,
1107 wxID_PROJECT_LAST, get_config_path() + "/recent-projects.txt", [this](const std::string& id) {
1108 this->project_selected(id); }));
1109 menu_separator();
1110 menu_special_sub(wxT("Recent ROMs"), recent_roms = new recent_menu<recentfiles::multirom>(this, inst,
1111 wxID_RROM_FIRST, wxID_RROM_LAST, get_config_path() + "/recent-roms.txt", recent_rom_selected));
1112 menu_special_sub(wxT("Recent Movies"), recent_movies = new recent_menu<recentfiles::path>(this, inst,
1113 wxID_RMOVIE_FIRST, wxID_RMOVIE_LAST, get_config_path() + "/recent-movies.txt",
1114 recent_movie_selected));
1115 menu_special_sub(wxT("Recent Lua scripts"), recent_scripts = new recent_menu<recentfiles::path>(this, inst,
1116 wxID_RLUA_FIRST, wxID_RLUA_LAST, get_config_path() + "/recent-scripts.txt",
1117 recent_script_selected));
1118 menu_separator();
1119 menu_entry(wxID_CONFLICTRESOLUTION, wxT("Conflict resolution"));
1120 menu_separator();
1121 branches_menu* brlist;
1122 auto brlist_item = menu_special_sub(wxT("Branches"), brlist = new branches_menu(this, inst,
1123 wxID_BRANCH_FIRST, wxID_BRANCH_LAST));
1124 brlist->set_disabler([brlist_item](bool enabled) { brlist_item->Enable(enabled); });
1125 brlist->update();
1126 menu_end_sub();
1127 menu_start_sub(wxT("Save"));
1128 menu_entry(wxID_SAVE_STATE, wxT("State..."));
1129 menu_entry(wxID_SAVE_MOVIE, wxT("Movie..."));
1130 menu_entry(wxID_SAVE_SCREENSHOT, wxT("Screenshot..."));
1131 menu_entry(wxID_SAVE_SUBTITLES, wxT("Subtitles..."));
1132 menu_entry(wxID_CANCEL_SAVES, wxT("Cancel pending saves"));
1133 menu_separator();
1134 menu_entry(wxID_CHDIR, wxT("Change working directory..."));
1135 menu_separator();
1136 menu_special_sub(wxT("Upload"), new upload_menu(this, inst, wxID_UPLOAD_FIRST, wxID_UPLOAD_LAST));
1137 menu_end_sub();
1138 menu_start_sub(wxT("Close"));
1139 menu_entry(wxID_CLOSE_PROJECT, wxT("Project"));
1140 menu_entry(wxID_CLOSE_ROM, wxT("ROM"));
1141 menu_enable(wxID_CLOSE_PROJECT, inst.project->get() != NULL);
1142 menu_enable(wxID_CLOSE_ROM, inst.project->get() == NULL);
1143 menu_end_sub();
1144 menu_separator();
1145 menu_entry(wxID_EXIT, wxT("Quit"));
1146
1147 menu_special(wxT("System"), reinterpret_cast<wxMenu*>(sysmenu = new system_menu(this, inst)));
1148
1149 menu_start(wxT("Movie"));
1150 menu_entry_check(wxID_READONLY_MODE, wxT("Readonly mode"));
1151 menu_check(wxID_READONLY_MODE, is_readonly_mode(inst));
1152 menu_entry(wxID_EDIT_AUTHORS, wxT("Edit game name && authors..."));
1153 menu_entry(wxID_EDIT_SUBTITLES, wxT("Edit subtitles..."));
1154 menu_entry(wxID_EDIT_VSUBTITLES, wxT("Edit commantary track..."));
1155 menu_separator();
1156 menu_entry(wxID_REWIND_MOVIE, wxT("Rewind to start"));
1157
1158 menu_start(wxT("Speed"));
1159 menu_entry(wxID_SPEED_5, wxT("1/20x"));
1160 menu_entry(wxID_SPEED_10, wxT("1/10x"));
1161 menu_entry(wxID_SPEED_17, wxT("1/6x"));
1162 menu_entry(wxID_SPEED_20, wxT("1/5x"));
1163 menu_entry(wxID_SPEED_25, wxT("1/4x"));
1164 menu_entry(wxID_SPEED_33, wxT("1/3x"));
1165 menu_entry(wxID_SPEED_50, wxT("1/2x"));
1166 menu_entry(wxID_SPEED_100, wxT("1x"));
1167 menu_entry(wxID_SPEED_150, wxT("1.5x"));
1168 menu_entry(wxID_SPEED_200, wxT("2x"));
1169 menu_entry(wxID_SPEED_300, wxT("3x"));
1170 menu_entry(wxID_SPEED_500, wxT("5x"));
1171 menu_entry(wxID_SPEED_1000, wxT("10x"));
1172 menu_entry(wxID_SPEED_TURBO, wxT("Turbo"));
1173 menu_entry(wxID_SET_SPEED, wxT("Set..."));
1174
1175 menu_start(wxT("Tools"));
1176 menu_entry(wxID_RUN_SCRIPT, wxT("Run batch file..."));
1177 menu_separator();
1178 menu_entry(wxID_EVAL_LUA, wxT("Evaluate Lua statement..."));
1179 menu_entry(wxID_RUN_LUA, wxT("Run Lua script..."));
1180 menu_separator();
1181 menu_entry(wxID_RESET_LUA, wxT("Reset Lua VM"));
1182 menu_separator();
1183 menu_entry(wxID_AUTOHOLD, wxT("Autohold/Autofire..."));
1184 menu_entry(wxID_TASINPUT, wxT("TAS input plugin..."));
1185 menu_entry(wxID_MULTITRACK, wxT("Multitrack..."));
1186 menu_entry(wxID_EDIT_MACROS, wxT("Edit macros..."));
1187 menu_separator();
1188 menu_entry(wxID_EDIT_MEMORYWATCH, wxT("Edit memory watch..."));
1189 menu_separator();
1190 menu_entry(wxID_LOAD_MEMORYWATCH, wxT("Load memory watch..."));
1191 menu_entry(wxID_SAVE_MEMORYWATCH, wxT("Save memory watch..."));
1192 menu_separator();
1193 menu_entry(wxID_MEMORY_SEARCH, wxT("Memory Search..."));
1194 menu_entry(wxID_HEXEDITOR, wxT("Memory editor..."));
1195 tracelog_menu* trlog;
1196 auto trlog_item = menu_special_sub(wxT("Trace log"), trlog = new tracelog_menu(this, inst,
1197 wxID_TRACELOG_FIRST, wxID_TRACELOG_LAST));
1198 trlog->set_disabler([trlog_item](bool enabled) { trlog_item->Enable(enabled); });
1199 trlog->update();
1200 menu_entry(wxID_DISASSEMBLER, wxT("Disassembler..."));
1201 menu_separator();
1202 menu_entry(wxID_MOVIE_EDIT, wxT("Edit movie..."));
1203 menu_separator();
1204 menu_special_sub(wxT("Video Capture"), reinterpret_cast<dumper_menu*>(dmenu = new dumper_menu(this,
1205 inst, wxID_DUMP_FIRST, wxID_DUMP_LAST)));
1206
1207 menu_start(wxT("Configure"));
1208 menu_entry_check(wxID_SHOW_STATUS, wxT("Show status panel"));
1209 menu_check(wxID_SHOW_STATUS, true);
1210 menu_entry_check(wxID_DEDICATED_MEMORY_WATCH, wxT("Dedicated memory watch"));
1211 menu_entry(wxID_SHOW_MESSAGES, wxT("Show messages"));
1212 menu_special_sub(wxT("Settings"), new settings_menu(this, inst, wxID_SETTINGS_FIRST));
1213 if(audioapi_driver_initialized()) {
1214 menu_separator();
1215 menu_entry_check(wxID_AUDIO_ENABLED, wxT("Sounds enabled"));
1216 menu_entry(wxID_VUDISPLAY, wxT("VU display / sound controls"));
1217 menu_check(wxID_AUDIO_ENABLED, platform::is_sound_enabled());
1218 }
1219 menu_separator();
1220 menu_entry(wxID_ENTER_FULLSCREEN, wxT("Enter fullscreen mode"));
1221
1222 menu_start(wxT("Help"));
1223 menu_entry(wxID_ABOUT, wxT("About..."));
1224
1225 corechange.set(inst.dispatch->core_change, []() { signal_core_change(); });
1226 titlechange.set(inst.dispatch->title_change, []() { signal_core_change(); });
1227 newcore.set(notify_new_core, []() { update_preferences(); });
1228 unmuted.set(inst.dispatch->sound_unmute, [this](bool unmute) {
1229 runuifun([this, unmute]() { this->menu_check(wxID_AUDIO_ENABLED, unmute); });
1230 });
1231 modechange.set(inst.dispatch->mode_change, [this](bool readonly) {
1232 runuifun([this, readonly]() { this->menu_check(wxID_READONLY_MODE, readonly); });
1233 });
1234 gpanel->SetDropTarget(new loadfile(this, inst));
1235 spanel->SetDropTarget(new loadfile(this, inst));
1236 set_hasher_callback(hash_callback);
1237 reinterpret_cast<system_menu*>(sysmenu)->update(false);
1238 menubar->SetMenuLabel(1, towxstring(inst.rom->get_systemmenu_name()));
1239 focus_timer = new _focus_timer;
1240 status_timer = new _status_timer;
1241 if(fscreen) {
1242 wx_escape_count = 0;
1243 enter_or_leave_fullscreen(true);
1244 }
1245 }
1246
1247 wxwin_mainwindow::~wxwin_mainwindow()
1248 {
1249 CHECK_UI_THREAD;
1250 if(sws_ctx) sws_freeContext(sws_ctx);
1251 if(screen_buffer) delete[] screen_buffer;
1252 if(rotate_buffer) delete[] rotate_buffer;
1253 focus_timer->Stop();
1254 delete focus_timer;
1255 status_timer->Stop();
1256 delete status_timer;
1257 }
1258
1259 void wxwin_mainwindow::request_paint()
1260 {
1261 CHECK_UI_THREAD;
1262 gpanel->Refresh();
1263 }
1264
1265 void wxwin_mainwindow::on_close(wxCloseEvent& e)
1266 {
1267 CHECK_UI_THREAD;
1268 //Veto it for now, latter things will delete it.
1269 e.Veto();
1270 inst.iqueue->queue("quit-emulator");
1271 }
1272
1273 void wxwin_mainwindow::notify_update() throw()
1274 {
1275 CHECK_UI_THREAD;
1276 if(!main_window_dirty) {
1277 main_window_dirty = true;
1278 gpanel->Refresh();
1279 }
1280 }
1281
1282 void wxwin_mainwindow::notify_resized() throw()
1283 {
1284 CHECK_UI_THREAD;
1285 toplevel->Layout();
1286 toplevel->SetSizeHints(this);
1287 Fit();
1288 }
1289
1290 void wxwin_mainwindow::notify_update_status() throw()
1291 {
1292 CHECK_UI_THREAD;
1293 spanel->request_paint();
1294 if(mwindow)
1295 mwindow->notify_update();
1296 status_updated = true;
1297 }
1298
1299 void wxwin_mainwindow::notify_exit() throw()
1300 {
1301 CHECK_UI_THREAD;
1302 wxwidgets_exiting = true;
1303 join_emulator_thread();
1304 Destroy();
1305 }
1306
1307 std::string read_variable_map(const std::map<std::string, std::u32string>& vars, const std::string& key)
1308 {
1309 if(!vars.count(key))
1310 return "";
1311 return utf8::to8(vars.find(key)->second);
1312 }
1313
1314 void wxwin_mainwindow::update_statusbar()
1315 {
1316 CHECK_UI_THREAD;
1317 if(download_in_progress) {
1318 statusbar->SetStatusText(towxstring(download_in_progress->statusmsg()));
1319 return;
1320 }
1321 if(hashing_in_progress) {
1322 //TODO: Display this as a dialog.
1323 std::ostringstream s;
1324 s << "Hashing ROMs, approximately " << ((hashing_left + 524288) >> 20) << " of "
1325 << ((hashing_total + 524288) >> 20) << "MB left...";
1326 statusbar->SetStatusText(towxstring(s.str()));
1327 return;
1328 }
1329 auto& vars = inst.status->get_read();
1330 if(!vars.valid) {
1331 inst.status->put_read();
1332 return;
1333 }
1334 try {
1335 std::ostringstream s;
1336 bool recording = (vars.mode == 'R');
1337 if(vars.movie_valid) {
1338 if(recording)
1339 s << "Frame: " << vars.curframe;
1340 else
1341 s << "Frame: " << vars.curframe << "/" << vars.length;
1342 s << " Lag: " << vars.lag;
1343 if(vars.subframe == _lsnes_status::subframe_savepoint)
1344 s << " Subframe: S";
1345 else if(vars.subframe == _lsnes_status::subframe_video)
1346 s << " Subframe: V";
1347 else
1348 s << " Subframe: " << vars.subframe;
1349 } else {
1350 s << "Frame: N/A Lag: N/A Subframe: N/A";
1351 }
1352 if(vars.saveslot_valid) {
1353 s << " Slot: ";
1354 if(vars.branch_valid) s << utf8::to8(vars.branch) << "ā†’";
1355 s << vars.saveslot;
1356 s << " [" << utf8::to8(vars.slotinfo) << "]";
1357 }
1358 s << " Speed: " << vars.speed << "% ";
1359 if(vars.pause == _lsnes_status::pause_break)
1360 s << " Breakpoint";
1361 else if(vars.pause == _lsnes_status::pause_normal)
1362 s << " Paused";
1363 if(vars.dumping)
1364 s << " Dumping";
1365 if(vars.mode == 'C')
1366 s << " Corrupt";
1367 else if(vars.mode == 'R')
1368 s << " Recording";
1369 else if(vars.mode == 'P')
1370 s << " Playback";
1371 else if(vars.mode == 'F')
1372 s << " Finished";
1373 else
1374 s << " Unknown";
1375 if(vars.mbranch_valid)
1376 s << " Branch: " << utf8::to8(vars.mbranch);
1377 std::string macros = utf8::to8(vars.macros);
1378 if(macros.length())
1379 s << " Macros: " << macros;
1380
1381 statusbar->SetStatusText(towxstring(s.str()));
1382 } catch(std::exception& e) {
1383 }
1384 inst.status->put_read();
1385 }
1386
1387 #define NEW_KEYBINDING "A new binding..."
1388 #define NEW_ALIAS "A new alias..."
1389 #define NEW_WATCH "A new watch..."
1390
1391 void wxwin_mainwindow::handle_menu_click(wxCommandEvent& e)
1392 {
1393 CHECK_UI_THREAD;
1394 try {
1395 handle_menu_click_cancelable(e);
1396 } catch(canceled_exception& e) {
1397 //Ignore.
1398 } catch(std::bad_alloc& e) {
1399 OOM_panic();
1400 } catch(std::exception& e) {
1401 show_message_ok(this, "Error in menu handler", e.what(), wxICON_EXCLAMATION);
1402 }
1403 }
1404
1405 void wxwin_mainwindow::refresh_title() throw()
1406 {
1407 CHECK_UI_THREAD;
1408 SetTitle(getname(inst));
1409 auto p = inst.project->get();
1410 menu_enable(wxID_RELOAD_ROM_IMAGE, !p);
1411 for(int i = wxID_LOAD_ROM_IMAGE_FIRST; i <= wxID_LOAD_ROM_IMAGE_LAST; i++)
1412 menu_enable(i, !p);
1413 menu_enable(wxID_CLOSE_PROJECT, p != NULL);
1414 menu_enable(wxID_CLOSE_ROM, p == NULL);
1415 reinterpret_cast<system_menu*>(sysmenu)->update(false);
1416 menubar->SetMenuLabel(1, towxstring(inst.rom->get_systemmenu_name()));
1417 }
1418
1419 namespace
1420 {
1421 struct movie_or_savestate
1422 {
1423 public:
1424 typedef std::pair<std::string,std::string> returntype;
1425 movie_or_savestate(emulator_instance& _inst, bool is_state)
1426 : inst(_inst)
1427 {
1428 state = is_state;
1429 }
1430 filedialog_input_params input(bool save) const
1431 {
1432 filedialog_input_params p;
1433 std::string ext = state ? inst.project->savestate_ext() : "lsmv";
1434 std::string name = state ? "Savestates" : "Movies";
1435 if(save) {
1436 p.types.push_back(filedialog_type_entry(name, "*." + ext, ext));
1437 p.types.push_back(filedialog_type_entry(name + " (binary)", "*." + ext, ext));
1438 } else
1439 p.types.push_back(filedialog_type_entry(name, "*." + ext + ";*." + ext + ".backup",
1440 ext));
1441 if(!save && state) {
1442 p.types.push_back(filedialog_type_entry("Savestates [playback]", "*." + ext +
1443 ";*." + ext + ".backup", ext));
1444 p.types.push_back(filedialog_type_entry("Savestates [recording]", "*." + ext +
1445 ";*." + ext + ".backup", ext));
1446 p.types.push_back(filedialog_type_entry("Savestates [preserve]", "*." + ext +
1447 ";*." + ext + ".backup", ext));
1448 p.types.push_back(filedialog_type_entry("Savestates [all branches]", "*." + ext +
1449 ";*." + ext + ".backup", ext));
1450 }
1451 p.default_type = save ? (state ? save_dflt_binary(*inst.settings) :
1452 movie_dflt_binary(*inst.settings)) : 0;
1453 return p;
1454 }
1455 std::pair<std::string, std::string> output(const filedialog_output_params& p, bool save) const
1456 {
1457 std::string cmdmod;
1458 if(save)
1459 cmdmod = p.typechoice ? "-binary" : "-zip";
1460 else if(state)
1461 switch(p.typechoice) {
1462 case 0: cmdmod = ""; break;
1463 case 1: cmdmod = "-readonly"; break;
1464 case 2: cmdmod = "-state"; break;
1465 case 3: cmdmod = "-preserve"; break;
1466 case 4: cmdmod = "-allbranches"; break;
1467 }
1468 return std::make_pair(cmdmod, p.path);
1469 }
1470 private:
1471 emulator_instance& inst;
1472 bool state;
1473 };
1474 struct movie_or_savestate filetype_movie(lsnes_instance, false);
1475 struct movie_or_savestate filetype_savestate(lsnes_instance, true);
1476 }
1477
1478 void wxwin_mainwindow::project_selected(const std::string& id)
1479 {
1480 std::string filename, displayname;
1481 bool load_ok = false;
1482 inst.iqueue->run([id, &filename, &displayname, &load_ok]() -> void {
1483 try {
1484 auto& p = CORE().project->load(id); //Check.
1485 filename = p.filename;
1486 displayname = p.name;
1487 load_ok = true;
1488 delete &p;
1489 switch_projects(id);
1490 } catch(std::exception& e) {
1491 messages << "Failed to change project: " << e.what() << std::endl;
1492 }
1493 });
1494 if(load_ok) {
1495 recentfiles::namedobj obj;
1496 obj._id = id;
1497 obj._filename = filename;
1498 obj._display = displayname;
1499 projects->add(obj);
1500 }
1501 }
1502
1503 void wxwin_mainwindow::handle_menu_click_cancelable(wxCommandEvent& e)
1504 {
1505 CHECK_UI_THREAD;
1506 std::string filename;
1507 std::pair<std::string, std::string> filename2;
1508 bool s;
1509 switch(e.GetId()) {
1510 case wxID_FRAMEADVANCE:
1511 inst.iqueue->queue("+advance-frame");
1512 inst.iqueue->queue("-advance-frame");
1513 return;
1514 case wxID_SUBFRAMEADVANCE:
1515 inst.iqueue->queue("+advance-poll");
1516 inst.iqueue->queue("-advance-poll");
1517 return;
1518 case wxID_NEXTPOLL:
1519 inst.iqueue->queue("advance-skiplag");
1520 return;
1521 case wxID_PAUSE:
1522 inst.iqueue->queue("pause-emulator");
1523 return;
1524 case wxID_EXIT:
1525 inst.iqueue->queue("quit-emulator");
1526 return;
1527 case wxID_AUDIO_ENABLED:
1528 platform::sound_enable(menu_ischecked(wxID_AUDIO_ENABLED));
1529 return;
1530 case wxID_CANCEL_SAVES:
1531 inst.iqueue->queue("cancel-saves");
1532 return;
1533 case wxID_LOAD_MOVIE:
1534 filename = choose_file_load(this, "Load Movie", UI_get_project_moviepath(inst),
1535 filetype_movie).second;
1536 recent_movies->add(filename);
1537 inst.iqueue->queue(CLOADSAVE::ldm.name, filename);
1538 return;
1539 case wxID_LOAD_STATE:
1540 filename2 = choose_file_load(this, "Load State", UI_get_project_moviepath(inst),
1541 filetype_savestate);
1542 recent_movies->add(filename2.second);
1543 inst.iqueue->queue("load" + filename2.first + " " + filename2.second);
1544 return;
1545 case wxID_REWIND_MOVIE:
1546 inst.iqueue->queue("rewind-movie");
1547 return;
1548 case wxID_SAVE_MOVIE:
1549 filename2 = choose_file_save(this, "Save Movie", UI_get_project_moviepath(inst), filetype_movie,
1550 project_prefixname(inst, "lsmv"));
1551 recent_movies->add(filename2.second);
1552 inst.iqueue->queue("save-movie" + filename2.first + " " + filename2.second);
1553 return;
1554 case wxID_SAVE_SUBTITLES:
1555 inst.iqueue->queue(CSUBTITLE::save.name, choose_file_save(this, "Save subtitles",
1556 UI_get_project_moviepath(inst), filetype_sub, project_prefixname(inst, "sub")));
1557 return;
1558 case wxID_SAVE_STATE:
1559 filename2 = choose_file_save(this, "Save State", UI_get_project_moviepath(inst),
1560 filetype_savestate);
1561 recent_movies->add(filename2.second);
1562 inst.iqueue->queue("save-state" + filename2.first + " " + filename2.second);
1563 return;
1564 case wxID_SAVE_SCREENSHOT:
1565 inst.iqueue->queue(CFRAMEBUF::ss.name, choose_file_save(this, "Save Screenshot",
1566 UI_get_project_moviepath(inst), filetype_png, get_default_screenshot_name(inst)));
1567 return;
1568 case wxID_RUN_SCRIPT:
1569 inst.iqueue->queue(CLUA::run.name, pick_file_member(this, "Select Script",
1570 UI_get_project_otherpath(inst)));
1571 return;
1572 case wxID_RUN_LUA: {
1573 std::string f = choose_file_load(this, "Select Lua Script", UI_get_project_otherpath(inst),
1574 filetype_lua_script);
1575 inst.iqueue->queue(CLUA::run.name, f);
1576 recent_scripts->add(f);
1577 return;
1578 }
1579 case wxID_RESET_LUA:
1580 inst.iqueue->queue(CLUA::reset.name);
1581 return;
1582 case wxID_EVAL_LUA:
1583 inst.iqueue->queue(CLUA::eval.name, pick_text(this, "Evaluate Lua", "Enter Lua Statement:"));
1584 return;
1585 case wxID_READONLY_MODE:
1586 s = menu_ischecked(wxID_READONLY_MODE);
1587 inst.iqueue->run([s]() {
1588 auto& core = CORE();
1589 if(!s)
1590 core.lua2->callback_movie_lost("readwrite");
1591 if(*core.mlogic) core.mlogic->get_movie().readonly_mode(s);
1592 core.dispatch->mode_change(s);
1593 if(!s)
1594 core.lua2->callback_do_readwrite();
1595 core.supdater->update();
1596 core.dispatch->status_update();
1597 });
1598 return;
1599 case wxID_AUTOHOLD:
1600 wxeditor_autohold_display(this, inst);
1601 return;
1602 case wxID_EDIT_AUTHORS:
1603 wxeditor_authors_display(this, inst);
1604 return;
1605 case wxID_EDIT_MACROS:
1606 wxeditor_macro_display(this, inst);
1607 return;
1608 case wxID_EDIT_SUBTITLES:
1609 wxeditor_subtitles_display(this, inst);
1610 return;
1611 case wxID_EDIT_VSUBTITLES:
1612 show_wxeditor_voicesub(this, inst);
1613 return;
1614 case wxID_EDIT_MEMORYWATCH:
1615 wxeditor_memorywatches_display(this, inst);
1616 return;
1617 case wxID_SAVE_MEMORYWATCH: {
1618 modal_pause_holder hld;
1619 std::set<std::string> old_watches;
1620 inst.iqueue->run([&old_watches]() { old_watches = CORE().mwatch->enumerate(); });
1621 std::string filename = choose_file_save(this, "Save watches to file",
1622 UI_get_project_otherpath(inst), filetype_watch);
1623 std::ofstream out(filename.c_str());
1624 for(auto i : old_watches) {
1625 std::string val;
1626 inst.iqueue->run([i, &val]() {
1627 try {
1628 val = CORE().mwatch->get_string(i);
1629 } catch(std::exception& e) {
1630 messages << "Can't get value of watch '" << i << "': " << e.what()
1631 << std::endl;
1632 }
1633 });
1634 out << i << std::endl << val << std::endl;
1635 }
1636 out.close();
1637 return;
1638 }
1639 case wxID_LOAD_MEMORYWATCH: {
1640 modal_pause_holder hld;
1641 std::set<std::string> old_watches;
1642 inst.iqueue->run([&old_watches]() { old_watches = CORE().mwatch->enumerate(); });
1643 std::map<std::string, std::string> new_watches;
1644 std::string filename = choose_file_load(this, "Choose memory watch file",
1645 UI_get_project_otherpath(inst), filetype_watch);
1646 try {
1647 std::istream& in = zip::openrel(filename, "");
1648 while(in) {
1649 std::string wname;
1650 std::string wexpr;
1651 std::getline(in, wname);
1652 std::getline(in, wexpr);
1653 new_watches[strip_CR(wname)] = strip_CR(wexpr);
1654 }
1655 delete &in;
1656 } catch(std::exception& e) {
1657 show_message_ok(this, "Error", std::string("Can't load memory watch: ") + e.what(),
1658 wxICON_EXCLAMATION);
1659 return;
1660 }
1661
1662 inst.iqueue->run([this, &new_watches, &old_watches]() {
1663 handle_watch_load(this->inst, new_watches, old_watches);
1664 });
1665 return;
1666 }
1667 case wxID_MEMORY_SEARCH:
1668 wxwindow_memorysearch_display(inst);
1669 return;
1670 case wxID_TASINPUT:
1671 wxeditor_tasinput_display(this, inst);
1672 return;
1673 case wxID_ABOUT: {
1674 std::ostringstream str;
1675 str << "Version: lsnes rr" << lsnes_version << std::endl;
1676 str << "Revision: " << lsnes_git_revision << std::endl;
1677 for(auto i : core_core::all_cores())
1678 if(!i->is_hidden())
1679 str << "Core: " << i->get_core_identifier() << std::endl;
1680 wxMessageBox(towxstring(str.str()), _T("About"), wxICON_INFORMATION | wxOK, this);
1681 return;
1682 }
1683 case wxID_SHOW_STATUS: {
1684 bool newstate = menu_ischecked(wxID_SHOW_STATUS);
1685 if(newstate)
1686 spanel->Show();
1687 if(newstate && !spanel_shown)
1688 toplevel->Add(spanel, 1, wxGROW);
1689 else if(!newstate && spanel_shown)
1690 toplevel->Detach(spanel);
1691 if(!newstate)
1692 spanel->Hide();
1693 spanel_shown = newstate;
1694 toplevel->Layout();
1695 toplevel->SetSizeHints(this);
1696 Fit();
1697 return;
1698 }
1699 case wxID_DEDICATED_MEMORY_WATCH: {
1700 bool newstate = menu_ischecked(wxID_DEDICATED_MEMORY_WATCH);
1701 if(newstate && !mwindow) {
1702 mwindow = new wxwin_status(-1, inst, "Memory Watch");
1703 spanel->set_watch_flag(1);
1704 mwindow->Show();
1705 } else if(!newstate && mwindow) {
1706 mwindow->Destroy();
1707 mwindow = NULL;
1708 spanel->set_watch_flag(0);
1709 }
1710 return;
1711 }
1712 case wxID_SET_SPEED: {
1713 std::string value = "infinite";
1714 double val = inst.framerate->get_speed_multiplier();
1715 if(!(val == std::numeric_limits<double>::infinity()))
1716 value = (stringfmt() << (100 * val)).str();
1717 value = pick_text(this, "Set speed", "Enter percentage speed (or \"infinite\"):", value);
1718 try {
1719 if(value == "infinite")
1720 inst.framerate->set_speed_multiplier(
1721 std::numeric_limits<double>::infinity());
1722 else {
1723 double v = parse_value<double>(value) / 100;
1724 if(v <= 0.0001)
1725 throw 42;
1726 inst.framerate->set_speed_multiplier(v);
1727 }
1728 } catch(...) {
1729 wxMessageBox(wxT("Invalid speed"), _T("Error"), wxICON_EXCLAMATION | wxOK, this);
1730 }
1731 return;
1732 }
1733 case wxID_SPEED_5:
1734 set_speed(inst, 5);
1735 break;
1736 case wxID_SPEED_10:
1737 set_speed(inst, 10);
1738 break;
1739 case wxID_SPEED_17:
1740 set_speed(inst, 16.66666666666);
1741 break;
1742 case wxID_SPEED_20:
1743 set_speed(inst, 20);
1744 break;
1745 case wxID_SPEED_25:
1746 set_speed(inst, 25);
1747 break;
1748 case wxID_SPEED_33:
1749 set_speed(inst, 33.3333333333333);
1750 break;
1751 case wxID_SPEED_50:
1752 set_speed(inst, 50);
1753 break;
1754 case wxID_SPEED_100:
1755 set_speed(inst, 100);
1756 break;
1757 case wxID_SPEED_150:
1758 set_speed(inst, 150);
1759 break;
1760 case wxID_SPEED_200:
1761 set_speed(inst, 200);
1762 break;
1763 case wxID_SPEED_300:
1764 set_speed(inst, 300);
1765 break;
1766 case wxID_SPEED_500:
1767 set_speed(inst, 500);
1768 break;
1769 case wxID_SPEED_1000:
1770 set_speed(inst, 1000);
1771 break;
1772 case wxID_SPEED_TURBO:
1773 set_speed(inst, -1);
1774 break;
1775 case wxID_LOAD_LIBRARY: {
1776 std::string name = std::string("load ") + loadlib::library::name();
1777 with_loaded_library(*new loadlib::module(loadlib::library(choose_file_load(this, name,
1778 UI_get_project_otherpath(inst), single_type(loadlib::library::extension(),
1779 loadlib::library::name())))));
1780 handle_post_loadlibrary();
1781 break;
1782 }
1783 case wxID_PLUGIN_MANAGER:
1784 wxeditor_plugin_manager_display(this);
1785 return;
1786 case wxID_RELOAD_ROM_IMAGE:
1787 inst.iqueue->run([]() {
1788 CORE().command->invoke("unpause-emulator");
1789 reload_current_rom();
1790 });
1791 return;
1792 case wxID_NEW_MOVIE:
1793 show_projectwindow(this, inst);
1794 return;
1795 case wxID_SHOW_MESSAGES:
1796 msg_window->reshow();
1797 return;
1798 case wxID_CONFLICTRESOLUTION:
1799 show_conflictwindow(this);
1800 return;
1801 case wxID_VUDISPLAY:
1802 open_vumeter_window(this, inst);
1803 return;
1804 case wxID_DISASSEMBLER:
1805 wxeditor_disassembler_display(this, inst);
1806 return;
1807 case wxID_MOVIE_EDIT:
1808 wxeditor_movie_display(this, inst);
1809 return;
1810 case wxID_NEW_PROJECT:
1811 open_new_project_window(this, inst);
1812 return;
1813 case wxID_CLOSE_PROJECT:
1814 inst.iqueue->run([this]() -> void { this->inst.project->set(NULL); });
1815 return;
1816 case wxID_CLOSE_ROM:
1817 inst.iqueue->run([]() -> void { close_rom(); });
1818 return;
1819 case wxID_ENTER_FULLSCREEN:
1820 wx_escape_count = 0;
1821 enter_or_leave_fullscreen(true);
1822 return;
1823 case wxID_LOAD_ROM_IMAGE_FIRST:
1824 do_load_rom_image(NULL);
1825 return;
1826 case wxID_HEXEDITOR:
1827 wxeditor_hexedit_display(this, inst);
1828 return;
1829 case wxID_MULTITRACK:
1830 wxeditor_multitrack_display(this, inst);
1831 return;
1832 case wxID_CHDIR: {
1833 wxDirDialog* d = new wxDirDialog(this, wxT("Change working directory"), wxT("."),
1834 wxDD_DIR_MUST_EXIST);
1835 if(d->ShowModal() == wxID_CANCEL) {
1836 d->Destroy();
1837 return;
1838 }
1839 std::string path = tostdstring(d->GetPath());
1840 d->Destroy();
1841 chdir(path.c_str());
1842 messages << "Changed working directory to '" << path << "'" << std::endl;
1843 return;
1844 }
1845 case wxID_DOWNLOAD: {
1846 if(download_in_progress) return;
1847 filename = pick_text(this, "Download movie", "Enter URL to download");
1848 download_in_progress = new file_download();
1849 download_in_progress->url = lsnes_uri_rewrite(filename);
1850 download_in_progress->target_slot = "wxwidgets_download_tmp";
1851 download_in_progress->do_async(*inst.rom);
1852 new download_timer(this, inst);
1853 return;
1854 }
1855 };
1856 }
1857
1858 void wxwin_mainwindow::action_updated()
1859 {
1860 runuifun([this]() { reinterpret_cast<system_menu*>(sysmenu)->update(true); });
1861 }
1862
1863 void wxwin_mainwindow::enter_or_leave_fullscreen(bool fs)
1864 {
1865 CHECK_UI_THREAD;
1866 if(fs && !is_fs) {
1867 //Save current resolution, so we can see the change.
1868 current_resolution = main_window->GetSize();
1869 if(spanel_shown)
1870 toplevel->Detach(spanel);
1871 spanel->Hide();
1872 is_fs = fs;
1873 ShowFullScreen(true);
1874 becoming_fullscreen = true;
1875 request_paint(); //Finish the resizing by running paint handler.
1876 } else if(!fs && is_fs) {
1877 becoming_fullscreen = false;
1878 ShowFullScreen(false);
1879 gpanel->Show();
1880 if(spanel_shown) {
1881 spanel->Show();
1882 toplevel->Add(spanel, 1, wxGROW);
1883 }
1884 Fit();
1885 gpanel->SetFocus();
1886 is_fs = fs;
1887 wx_escape_count = 0;
1888 request_paint(); //Don't leave graphical corruption.
1889 }
1890 }
1891
1892 namespace
1893 {
1894 struct command::stub _exit_fullscreen = {"exit-fullscreen", "Exit fullscreen",
1895 "Syntax: exit_fullscreen\nExit fullscreen"};
1896 command::fnptr<> exit_fullscreen(lsnes_cmds, _exit_fullscreen,
1897 []() throw(std::bad_alloc, std::runtime_error) {
1898 runuifun([]() {
1899 if(is_fs)
1900 main_window->enter_or_leave_fullscreen(false);
1901 });
1902 });
1903 }
Rerecording SNES/GB(C) emulator based on bsnes / gambatte core