From aaa432d0f406a846aa6a43aab076561584f4b0c6 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 2 May 2020 14:31:19 -0400 Subject: [PATCH 001/156] Build fixes for RHEL8 systems. CheckLibWithHeader of minizip installation is failing so I resorted to a simpler pkg-config check. Fixed lua library check, include path and linker flag references. --- SConstruct | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/SConstruct b/SConstruct index a400ebb7..c2e6b021 100644 --- a/SConstruct +++ b/SConstruct @@ -97,7 +97,7 @@ else: if conf.CheckFunc('asprintf'): conf.env.Append(CCFLAGS = "-DHAVE_ASPRINTF") if env['SYSTEM_MINIZIP']: - assert conf.CheckLibWithHeader('minizip', 'minizip/unzip.h', 'C', 'unzOpen;', 1), "please install: libminizip" + assert env.ParseConfig('pkg-config minizip --cflags --libs'), "please install: libminizip" assert conf.CheckLibWithHeader('z', 'zlib.h', 'c', 'inflate;', 1), "please install: zlib" env.Append(CPPDEFINES=["_SYSTEM_MINIZIP"]) else: @@ -153,6 +153,9 @@ else: elif conf.CheckLib('lua5.1'): lua_link_flags = "-llua5.1" lua_include_dir = "/usr/include/lua5.1" + elif conf.CheckLib('lua-5.1'): + lua_link_flags = "-llua-5.1" + lua_include_dir = "/usr/include/lua-5.1" elif conf.CheckLib('lua'): lua_link_flags = "-llua" lua_include_dir = "/usr/include/lua" From 9844caf69dcbdcf1d4ad4d24636c61071445712e Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 2 May 2020 19:57:11 -0400 Subject: [PATCH 002/156] Bug fix for command line game genie enable logic with linux based gtk GUI. GUI was forcing game genie to disabled at startup which was overriding command line selection. The GUI logic has been fixed to sync the state of menu game genie toggle box to the desired startup configuration of game genie. --- src/drivers/sdl/gui.cpp | 18 +++++++++++++++--- 1 file changed, 15 insertions(+), 3 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 837eb6d1..0a769fd3 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -2350,7 +2350,21 @@ static GtkWidget* CreateMenubar( GtkWidget* window) /* Set the autoResume checkbox */ GtkCheckMenuItem* auto_resume_chk = (GtkCheckMenuItem*) gtk_ui_manager_get_widget ( ui_manager, "/Menubar/OptionsMenuAction/AutoResumeAction"); gtk_check_menu_item_set_active (auto_resume_chk, (bool)AutoResumePlay); - + + // Sync State of GameGenie Toggle Action to Startup Configuration + int gameGenieEnabled=0; + g_config->getOption("SDL.GameGenie", &gameGenieEnabled); + + if ( gameGenieEnabled ) + { + state = gtk_action_group_get_action (action_group, "GameGenieToggleAction"); + + if ( state ){ + gtk_action_activate( state ); + } + } + enableGameGenie(gameGenieEnabled); + /* Finally, return the actual menu bar created by the UIManager. */ return gtk_ui_manager_get_widget (ui_manager, "/Menubar"); } @@ -2499,8 +2513,6 @@ int InitGTKSubsystem(int argc, char** argv) gtk_container_add(GTK_CONTAINER(MainWindow), vbox); Menubar = CreateMenubar(MainWindow); - // turn of game genie by default, since its off by default in the menu - enableGameGenie(0); gtk_box_pack_start (GTK_BOX(vbox), Menubar, FALSE, TRUE, 0); From 7416ad2fdbb4980e16bd41c51b2a9a7694d9109e Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sun, 3 May 2020 16:29:28 -0400 Subject: [PATCH 003/156] Added initial layout for gui cheat window. --- src/drivers/sdl/gui.cpp | 234 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 234 insertions(+) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 0a769fd3..93283351 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -1383,6 +1383,234 @@ void toggleAutoResume (GtkToggleAction *action) AutoResumePlay = autoResume; } +// creates and opens cheats window +static void openCheatsWindow(void) +{ + GtkWidget* win; + GtkWidget* main_hbox; + GtkWidget* hbox; + GtkWidget* vbox, *prev_cmp_vbox; + GtkWidget* frame; + GtkWidget* label, *txt_entry; + GtkWidget* button; + GtkWidget *tree; + GtkWidget *scroll; + + win = gtk_dialog_new_with_buttons("Cheats", + GTK_WINDOW(MainWindow), (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT), + GTK_STOCK_CLOSE, + GTK_RESPONSE_OK, + NULL); + gtk_window_set_default_size(GTK_WINDOW(win), 600, 600); + + main_hbox = gtk_hbox_new(FALSE, 2); + vbox = gtk_vbox_new(FALSE, 5); + frame = gtk_frame_new("Active Cheats"); + + GtkTreeStore *actv_cheats_store = gtk_tree_store_new( 1, G_TYPE_STRING); + + GtkTreeIter iter; + + gtk_tree_store_append(actv_cheats_store, &iter, NULL); // aquire iter + + for(int i=0; i<15; i++) + { + std::string cheatName = "Test"; + + gtk_tree_store_set(actv_cheats_store, &iter, + 0, cheatName.c_str(), + -1); + + gtk_tree_store_append(actv_cheats_store, &iter, NULL); // acquire child iterator + } + + tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(actv_cheats_store)); + + GtkCellRenderer *renderer; + GtkTreeViewColumn* column; + + renderer = gtk_cell_renderer_text_new(); + column = gtk_tree_view_column_new_with_attributes("Active Cheats", renderer, "text", 0, NULL); + gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); + + scroll = gtk_scrolled_window_new(NULL, NULL); + gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, + GTK_POLICY_AUTOMATIC); + gtk_container_add(GTK_CONTAINER(scroll), tree); + gtk_box_pack_start(GTK_BOX(vbox), scroll, TRUE, TRUE, 1); + + hbox = gtk_hbox_new(FALSE, 2); + label = gtk_label_new("Name:"); + txt_entry = gtk_entry_new(); + + gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 1); + gtk_box_pack_start(GTK_BOX(hbox), txt_entry, TRUE, TRUE, 1); + + gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 1); + + hbox = gtk_hbox_new(FALSE, 6); + label = gtk_label_new("Addr:"); + txt_entry = gtk_entry_new(); + gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 8 ); + gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 8 ); + + gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 1); + gtk_box_pack_start(GTK_BOX(hbox), txt_entry, TRUE, TRUE, 1); + + label = gtk_label_new("Val:"); + txt_entry = gtk_entry_new(); + gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 4 ); + gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 4 ); + + gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 1); + gtk_box_pack_start(GTK_BOX(hbox), txt_entry, TRUE, TRUE, 1); + + label = gtk_label_new("Cmp:"); + txt_entry = gtk_entry_new(); + gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 4 ); + gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 4 ); + + gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 1); + gtk_box_pack_start(GTK_BOX(hbox), txt_entry, TRUE, TRUE, 1); + + gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 1); + + hbox = gtk_hbox_new(FALSE, 3); + button = gtk_button_new_with_label("Add"); + gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, FALSE, 1); + button = gtk_button_new_with_label("Delete"); + gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, FALSE, 1); + button = gtk_button_new_with_label("Update"); + gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, FALSE, 1); + + gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 1); + + hbox = gtk_hbox_new(FALSE, 1); + button = gtk_button_new_with_label("Add from CHT file..."); + gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, FALSE, 1); + + gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 1); + + gtk_container_add(GTK_CONTAINER(frame), vbox); + // + gtk_box_pack_start(GTK_BOX(main_hbox), frame, TRUE, TRUE, 1); + + vbox = gtk_vbox_new(FALSE, 5); + hbox = gtk_hbox_new(FALSE, 1); + button = gtk_button_new_with_label("Reset"); + gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 5); + + gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5); + + hbox = gtk_hbox_new(FALSE, 3); + button = gtk_button_new_with_label("Known Value:"); + gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 5); + label = gtk_label_new("0x"); + txt_entry = gtk_entry_new(); + gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5); + gtk_box_pack_start(GTK_BOX(hbox), txt_entry, FALSE, FALSE, 5); + + gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5); + + frame = gtk_frame_new("Previous Compare"); + gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5); + button = gtk_check_button_new_with_label("Pause emulation when this window is active"); + gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 5); + + prev_cmp_vbox = gtk_vbox_new(FALSE, 4); + gtk_container_add(GTK_CONTAINER(frame), prev_cmp_vbox); + + hbox = gtk_hbox_new(FALSE, 1); + button = gtk_button_new_with_label("Equal"); + gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 5); + gtk_box_pack_start(GTK_BOX(prev_cmp_vbox), hbox, FALSE, FALSE, 5); + + hbox = gtk_hbox_new(FALSE, 4); + button = gtk_button_new_with_label("Not Equal"); + gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 5); + button = gtk_check_button_new(); + gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 5); + label = gtk_label_new("By:"); + gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5); + txt_entry = gtk_entry_new(); + gtk_box_pack_start(GTK_BOX(hbox), txt_entry, FALSE, FALSE, 5); + + gtk_box_pack_start(GTK_BOX(prev_cmp_vbox), hbox, FALSE, FALSE, 5); + + hbox = gtk_hbox_new(FALSE, 4); + button = gtk_button_new_with_label("Greater Than"); + gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 5); + button = gtk_check_button_new(); + gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 5); + label = gtk_label_new("By:"); + gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5); + txt_entry = gtk_entry_new(); + gtk_box_pack_start(GTK_BOX(hbox), txt_entry, FALSE, FALSE, 5); + + gtk_box_pack_start(GTK_BOX(prev_cmp_vbox), hbox, FALSE, FALSE, 5); + + hbox = gtk_hbox_new(FALSE, 4); + button = gtk_button_new_with_label("Less Than"); + gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 5); + button = gtk_check_button_new(); + gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 5); + label = gtk_label_new("By:"); + gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5); + txt_entry = gtk_entry_new(); + gtk_box_pack_start(GTK_BOX(hbox), txt_entry, FALSE, FALSE, 1); + + gtk_box_pack_start(GTK_BOX(prev_cmp_vbox), hbox, FALSE, FALSE, 1); + + hbox = gtk_hbox_new(FALSE, 2); + gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 1); + + frame = gtk_frame_new("Cheat Search"); + gtk_container_add(GTK_CONTAINER(frame), hbox); + gtk_box_pack_start(GTK_BOX(main_hbox), frame, TRUE, TRUE, 5); + + vbox = gtk_vbox_new(FALSE, 5); + //hbox = gtk_hbox_new(FALSE, 1); + + GtkTreeStore *ram_match_store = gtk_tree_store_new( 1, G_TYPE_STRING); + + gtk_tree_store_append( ram_match_store, &iter, NULL); // aquire iter + + for(int i=0; i<15; i++) + { + std::string ramText = "Test"; + + gtk_tree_store_set(ram_match_store, &iter, + 0, ramText.c_str(), + -1); + + gtk_tree_store_append(ram_match_store, &iter, NULL); // acquire child iterator + } + + tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(ram_match_store)); + + renderer = gtk_cell_renderer_text_new(); + column = gtk_tree_view_column_new_with_attributes("0 Possibilities", renderer, "text", 0, NULL); + gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); + + scroll = gtk_scrolled_window_new(NULL, NULL); + gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, + GTK_POLICY_AUTOMATIC); + gtk_container_add(GTK_CONTAINER(scroll), tree); + gtk_box_pack_start(GTK_BOX(vbox), scroll, TRUE, TRUE, 5); + + frame = gtk_frame_new(""); + gtk_container_add(GTK_CONTAINER(frame), vbox); + + gtk_box_pack_start(GTK_BOX(hbox), frame, TRUE, TRUE, 5); + + gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(win))), main_hbox, TRUE, TRUE, 0); + + g_signal_connect(win, "delete-event", G_CALLBACK(closeDialog), NULL); + g_signal_connect(win, "response", G_CALLBACK(closeDialog), NULL); + + gtk_widget_show_all(win); +} + void recordMovie() { if(isloaded) @@ -2229,6 +2457,9 @@ static char* menuXml = " " " " " " + " " + " " + " " " " " " " " @@ -2281,6 +2512,9 @@ static GtkActionEntry normal_entries[] = { {"LoadGameGenieAction", GTK_STOCK_OPEN, "_Load Game Genie ROM", "", NULL, G_CALLBACK(loadGameGenie)}, {"InsertCoinAction", NULL, "_Insert Coin", NULL, NULL, G_CALLBACK(FCEUI_VSUniCoin)}, + {"ToolsMenuAction", NULL, "_Tools"}, + {"CheatsAction", "cheats-win", "_Cheats...", NULL, NULL, G_CALLBACK(openCheatsWindow)}, + {"MovieMenuAction", NULL, "_Movie"}, {"OpenMovieAction", GTK_STOCK_OPEN, "_Open", "F7", NULL, G_CALLBACK(loadMovie)}, {"StopMovieAction", GTK_STOCK_MEDIA_STOP, "S_top", NULL, NULL, G_CALLBACK(FCEUI_StopMovie)}, From 52cc2629ebb494515683ca9a0e537bc1ca27f67a Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Mon, 4 May 2020 21:42:56 -0400 Subject: [PATCH 004/156] Successful initial test of cheat search functionality. --- src/drivers/sdl/gui.cpp | 258 +++++++++++++++++++++++++++++++++++----- 1 file changed, 231 insertions(+), 27 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 93283351..a0934381 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -1,5 +1,6 @@ #include "../../types.h" #include "../../fceu.h" +#include "../../cheat.h" #include "../../driver.h" #include "../../version.h" #include "../../movie.h" @@ -55,6 +56,16 @@ GtkRadioAction* stateSlot = NULL; bool gtkIsStarted = false; bool menuTogglingEnabled; +//----------------------------------------- +// Cheat static variables +static GtkTreeStore *actv_cheats_store = NULL; +static GtkTreeStore *ram_match_store = NULL; +static GtkTreeIter ram_match_iter; +static int cheat_search_known_value = 0; +static int cheat_search_neq_value = 0; +static int cheat_search_gt_value = 0; +static int cheat_search_lt_value = 0; + // check to see if a particular GTK version is available // 2.24 is required for most of the dialogs -- ie: checkGTKVersion(2,24); bool checkGTKVersion(int major_required, int minor_required) @@ -1383,6 +1394,149 @@ void toggleAutoResume (GtkToggleAction *action) AutoResumePlay = autoResume; } +static int ShowCheatSearchResultsCallB(uint32 a, uint8 last, uint8 current) +{ + char addrStr[32], lastStr[32], curStr[32]; + + sprintf( addrStr, "0x%04x", a ); + sprintf( lastStr, "0x%02x", last ); + sprintf( curStr, "| 0x%02x", current ); + + gtk_tree_store_set(ram_match_store, &ram_match_iter, + 0, addrStr, 1, lastStr, 2, curStr, + -1); + + gtk_tree_store_append( ram_match_store, &ram_match_iter, NULL); // aquire iter + + return 1; +} + +static void showCheatSearchResults(void) +{ + int total_matches = 0; + + gtk_tree_store_clear(ram_match_store); + + gtk_tree_store_append( ram_match_store, &ram_match_iter, NULL); // aquire iter + + total_matches = FCEUI_CheatSearchGetCount(); + + printf("Cheat Search Matches: %i \n", total_matches ); + + FCEUI_CheatSearchGetRange( 0, total_matches, ShowCheatSearchResultsCallB ); +} + +static void cheatSearchReset( GtkButton *button, + gpointer user_data) +{ + printf("Cheat Search Reset!\n"); + + cheat_search_known_value = 0; + cheat_search_neq_value = 0; + cheat_search_gt_value = 0; + cheat_search_lt_value = 0; + + FCEUI_CheatSearchBegin(); + showCheatSearchResults(); + // Enable Cheat Search Buttons - Change Sensitivity +} + +static void cheatSearchKnown( GtkButton *button, + gpointer user_data) +{ + //printf("Cheat Search Known!\n"); + + FCEUI_CheatSearchEnd(FCEU_SEARCH_NEWVAL_KNOWN, cheat_search_known_value, 0); + showCheatSearchResults(); +} + +static void cheatSearchEqual( GtkButton *button, + gpointer user_data) +{ + //printf("Cheat Search Equal !\n"); + + FCEUI_CheatSearchEnd(FCEU_SEARCH_PUERLY_RELATIVE_CHANGE, 0, cheat_search_neq_value); + showCheatSearchResults(); +} + +static void cheatSearchNotEqual( GtkButton *button, + GtkToggleButton *chkbox ) +{ + int checked = gtk_toggle_button_get_active(chkbox); + + //printf("Cheat Search NotEqual %i!\n", checked); + + if ( checked ){ + FCEUI_CheatSearchEnd(FCEU_SEARCH_PUERLY_RELATIVE_CHANGE, 0, cheat_search_neq_value); + } else { + FCEUI_CheatSearchEnd(FCEU_SEARCH_ANY_CHANGE, 0, 0); + } + showCheatSearchResults(); +} + +static void cheatSearchGreaterThan( GtkButton *button, + GtkToggleButton *chkbox ) +{ + int checked = gtk_toggle_button_get_active(chkbox); + + //printf("Cheat Search GreaterThan %i!\n", checked); + + if ( checked ){ + FCEUI_CheatSearchEnd(FCEU_SEARCH_NEWVAL_GT_KNOWN, 0, cheat_search_gt_value); + } else { + FCEUI_CheatSearchEnd(FCEU_SEARCH_NEWVAL_GT, 0, 0); + } + showCheatSearchResults(); +} + +static void cheatSearchLessThan( GtkButton *button, + GtkToggleButton *chkbox ) +{ + int checked = gtk_toggle_button_get_active(chkbox); + + //printf("Cheat Search LessThan %i!\n", checked); + + if ( checked ){ + FCEUI_CheatSearchEnd(FCEU_SEARCH_NEWVAL_LT_KNOWN, 0, cheat_search_gt_value); + } else { + FCEUI_CheatSearchEnd(FCEU_SEARCH_NEWVAL_LT, 0, 0); + } + showCheatSearchResults(); +} + +static void cheatSearchValueEntryCB( GtkWidget *widget, + void *userData ) +{ + long value; + const gchar *entry_text; + entry_text = gtk_entry_get_text (GTK_ENTRY (widget)); + + value = strtol( entry_text, NULL, 16 ); + + switch ( (long)userData ) + { + default: + case 0: + + break; + case 1: + cheat_search_known_value = value; + break; + case 2: + cheat_search_neq_value = value; + break; + case 3: + cheat_search_gt_value = value; + break; + case 4: + cheat_search_lt_value = value; + break; + } + + //printf("Cheat Value Entry contents: '%s' Value: 0x%02lx\n", entry_text, value); +} + + // creates and opens cheats window static void openCheatsWindow(void) { @@ -1392,9 +1546,10 @@ static void openCheatsWindow(void) GtkWidget* vbox, *prev_cmp_vbox; GtkWidget* frame; GtkWidget* label, *txt_entry; - GtkWidget* button; + GtkWidget* button, *chkbutton; GtkWidget *tree; GtkWidget *scroll; + GtkWidget *align; win = gtk_dialog_new_with_buttons("Cheats", GTK_WINDOW(MainWindow), (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT), @@ -1407,7 +1562,7 @@ static void openCheatsWindow(void) vbox = gtk_vbox_new(FALSE, 5); frame = gtk_frame_new("Active Cheats"); - GtkTreeStore *actv_cheats_store = gtk_tree_store_new( 1, G_TYPE_STRING); + actv_cheats_store = gtk_tree_store_new( 1, G_TYPE_STRING); GtkTreeIter iter; @@ -1498,15 +1653,26 @@ static void openCheatsWindow(void) vbox = gtk_vbox_new(FALSE, 5); hbox = gtk_hbox_new(FALSE, 1); button = gtk_button_new_with_label("Reset"); + g_signal_connect( button, "clicked", + G_CALLBACK (cheatSearchReset), (gpointer) NULL ); gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5); hbox = gtk_hbox_new(FALSE, 3); button = gtk_button_new_with_label("Known Value:"); + g_signal_connect( button, "clicked", + G_CALLBACK (cheatSearchKnown), (gpointer) NULL ); gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 5); label = gtk_label_new("0x"); txt_entry = gtk_entry_new(); + gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 2 ); + gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 2 ); + + g_signal_connect( txt_entry, "activate", + G_CALLBACK(cheatSearchValueEntryCB), (void*)1L ); + g_signal_connect( txt_entry, "changed", + G_CALLBACK(cheatSearchValueEntryCB), (void*)1L ); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(hbox), txt_entry, FALSE, FALSE, 5); @@ -1521,43 +1687,77 @@ static void openCheatsWindow(void) gtk_container_add(GTK_CONTAINER(frame), prev_cmp_vbox); hbox = gtk_hbox_new(FALSE, 1); + align = gtk_alignment_new( 0, 0, 0.5, 0 ); button = gtk_button_new_with_label("Equal"); - gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 5); + gtk_container_add( GTK_CONTAINER(align), button ); + gtk_box_pack_start(GTK_BOX(hbox), align, TRUE, TRUE, 5); gtk_box_pack_start(GTK_BOX(prev_cmp_vbox), hbox, FALSE, FALSE, 5); + g_signal_connect( button, "clicked", + G_CALLBACK (cheatSearchEqual), (gpointer) NULL ); hbox = gtk_hbox_new(FALSE, 4); + align = gtk_alignment_new( 0, 0, 1, 0 ); button = gtk_button_new_with_label("Not Equal"); - gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 5); - button = gtk_check_button_new(); - gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 5); - label = gtk_label_new("By:"); + gtk_container_add( GTK_CONTAINER(align), button ); + gtk_box_pack_start(GTK_BOX(hbox), align, TRUE, TRUE, 5); + chkbutton = gtk_check_button_new(); + gtk_box_pack_start(GTK_BOX(hbox), chkbutton, FALSE, FALSE, 5); + g_signal_connect( button, "clicked", + G_CALLBACK (cheatSearchNotEqual), (gpointer) chkbutton ); + label = gtk_label_new("By: 0x"); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5); txt_entry = gtk_entry_new(); + gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 2 ); + gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 2 ); + g_signal_connect( txt_entry, "activate", + G_CALLBACK(cheatSearchValueEntryCB), (void*)2L ); + g_signal_connect( txt_entry, "changed", + G_CALLBACK(cheatSearchValueEntryCB), (void*)2L ); gtk_box_pack_start(GTK_BOX(hbox), txt_entry, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(prev_cmp_vbox), hbox, FALSE, FALSE, 5); hbox = gtk_hbox_new(FALSE, 4); + align = gtk_alignment_new( 0, 0, 1, 0 ); button = gtk_button_new_with_label("Greater Than"); - gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 5); - button = gtk_check_button_new(); - gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 5); - label = gtk_label_new("By:"); + gtk_container_add( GTK_CONTAINER(align), button ); + gtk_box_pack_start(GTK_BOX(hbox), align, TRUE, TRUE, 5); + chkbutton = gtk_check_button_new(); + g_signal_connect( button, "clicked", + G_CALLBACK (cheatSearchGreaterThan), (gpointer) chkbutton ); + gtk_box_pack_start(GTK_BOX(hbox), chkbutton, FALSE, FALSE, 5); + label = gtk_label_new("By: 0x"); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5); txt_entry = gtk_entry_new(); + gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 2 ); + gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 2 ); + g_signal_connect( txt_entry, "activate", + G_CALLBACK(cheatSearchValueEntryCB), (void*)3L ); + g_signal_connect( txt_entry, "changed", + G_CALLBACK(cheatSearchValueEntryCB), (void*)3L ); gtk_box_pack_start(GTK_BOX(hbox), txt_entry, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(prev_cmp_vbox), hbox, FALSE, FALSE, 5); hbox = gtk_hbox_new(FALSE, 4); + align = gtk_alignment_new( 0, 0, 1, 0 ); button = gtk_button_new_with_label("Less Than"); - gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 5); - button = gtk_check_button_new(); - gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 5); - label = gtk_label_new("By:"); + gtk_container_add( GTK_CONTAINER(align), button ); + gtk_box_pack_start(GTK_BOX(hbox), align, TRUE, TRUE, 5); + chkbutton = gtk_check_button_new(); + g_signal_connect( button, "clicked", + G_CALLBACK (cheatSearchLessThan), (gpointer) chkbutton ); + gtk_box_pack_start(GTK_BOX(hbox), chkbutton, FALSE, FALSE, 5); + label = gtk_label_new("By: 0x"); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5); txt_entry = gtk_entry_new(); - gtk_box_pack_start(GTK_BOX(hbox), txt_entry, FALSE, FALSE, 1); + gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 2 ); + gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 2 ); + g_signal_connect( txt_entry, "activate", + G_CALLBACK(cheatSearchValueEntryCB), (void*)4L ); + g_signal_connect( txt_entry, "changed", + G_CALLBACK(cheatSearchValueEntryCB), (void*)4L ); + gtk_box_pack_start(GTK_BOX(hbox), txt_entry, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(prev_cmp_vbox), hbox, FALSE, FALSE, 1); @@ -1571,25 +1771,29 @@ static void openCheatsWindow(void) vbox = gtk_vbox_new(FALSE, 5); //hbox = gtk_hbox_new(FALSE, 1); - GtkTreeStore *ram_match_store = gtk_tree_store_new( 1, G_TYPE_STRING); + ram_match_store = gtk_tree_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); - gtk_tree_store_append( ram_match_store, &iter, NULL); // aquire iter + gtk_tree_store_append( ram_match_store, &ram_match_iter, NULL); // aquire iter - for(int i=0; i<15; i++) - { - std::string ramText = "Test"; + //for(int i=0; i<15; i++) + //{ + // std::string ramText = "Test"; - gtk_tree_store_set(ram_match_store, &iter, - 0, ramText.c_str(), - -1); + // gtk_tree_store_set(ram_match_store, &ram_match_iter, + // 0, ramText.c_str(), + // -1); - gtk_tree_store_append(ram_match_store, &iter, NULL); // acquire child iterator - } + // gtk_tree_store_append(ram_match_store, &ram_match_iter, NULL); // acquire child iterator + //} tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(ram_match_store)); renderer = gtk_cell_renderer_text_new(); - column = gtk_tree_view_column_new_with_attributes("0 Possibilities", renderer, "text", 0, NULL); + column = gtk_tree_view_column_new_with_attributes("Addr", renderer, "text", 0, NULL); + gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); + column = gtk_tree_view_column_new_with_attributes("Last", renderer, "text", 1, NULL); + gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); + column = gtk_tree_view_column_new_with_attributes("Curr", renderer, "text", 2, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); scroll = gtk_scrolled_window_new(NULL, NULL); From 37bb1106011f8252345eb366a8e248acb275d87e Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Mon, 4 May 2020 22:01:15 -0400 Subject: [PATCH 005/156] Added file chooser function for loading cheats from file. --- src/drivers/sdl/gui.cpp | 47 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index a0934381..66c4003b 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -1536,6 +1536,51 @@ static void cheatSearchValueEntryCB( GtkWidget *widget, //printf("Cheat Value Entry contents: '%s' Value: 0x%02lx\n", entry_text, value); } +static void openCheatFile( GtkWidget *widget, + void *userData ) +{ + GtkWidget* fileChooser; + GtkFileFilter* filterCht; + GtkFileFilter* filterAll; + + filterCht = gtk_file_filter_new(); + filterAll = gtk_file_filter_new(); + + gtk_file_filter_add_pattern(filterCht, "*.cht"); + gtk_file_filter_add_pattern(filterAll, "*"); + + gtk_file_filter_set_name(filterCht, "*.cht"); + gtk_file_filter_set_name(filterAll, "All Files"); + + fileChooser = gtk_file_chooser_dialog_new ("Open Cheat", GTK_WINDOW(MainWindow), + GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, + GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); + const char* last_dir; + g_config->getOption("SDL.LastOpenFile", &last_dir); + gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(fileChooser), last_dir); + + gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterCht); + gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterAll); + + if (gtk_dialog_run (GTK_DIALOG (fileChooser)) ==GTK_RESPONSE_ACCEPT) + { + char* filename; + + filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fileChooser)); + gtk_widget_destroy (fileChooser); + //g_config->setOption("SDL.LastOpenFile", filename); + // Error dialog no longer required with GTK implementation of FCEUD_PrintError() + + resizeGtkWindow(); + g_free( filename); + } + else + { + gtk_widget_destroy (fileChooser); + } + +} + // creates and opens cheats window static void openCheatsWindow(void) @@ -1643,6 +1688,8 @@ static void openCheatsWindow(void) hbox = gtk_hbox_new(FALSE, 1); button = gtk_button_new_with_label("Add from CHT file..."); gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, FALSE, 1); + g_signal_connect( button, "clicked", + G_CALLBACK (openCheatFile), (gpointer) NULL ); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 1); From add91354ded5313b2ca66959acd36858f58205a9 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Mon, 4 May 2020 23:50:33 -0400 Subject: [PATCH 006/156] Successful test of Add, remove, and update functions to the active cheat list. --- src/drivers/sdl/gui.cpp | 187 ++++++++++++++++++++++++++++++++++++---- 1 file changed, 171 insertions(+), 16 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 66c4003b..777f47da 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -60,11 +60,16 @@ bool menuTogglingEnabled; // Cheat static variables static GtkTreeStore *actv_cheats_store = NULL; static GtkTreeStore *ram_match_store = NULL; +static GtkTreeIter actv_cheats_iter; static GtkTreeIter ram_match_iter; static int cheat_search_known_value = 0; static int cheat_search_neq_value = 0; static int cheat_search_gt_value = 0; static int cheat_search_lt_value = 0; +static int new_cheat_addr = 0; +static int new_cheat_val = 0; +static int new_cheat_cmp = 0; +static std::string new_cheat_name; // check to see if a particular GTK version is available // 2.24 is required for most of the dialogs -- ie: checkGTKVersion(2,24); @@ -1536,6 +1541,33 @@ static void cheatSearchValueEntryCB( GtkWidget *widget, //printf("Cheat Value Entry contents: '%s' Value: 0x%02lx\n", entry_text, value); } +static int activeCheatListCB(char *name, uint32 a, uint8 v, int c, int s, int type, void* data) +{ + char addrStr[32], valStr[16], cmpStr[16]; + printf("Cheat Name:'%s' Addr:0x%04x Val:0x%02x \n", name, a, v ); + + sprintf( addrStr, "0x%04x", a ); + sprintf( valStr, "0x%02x", v ); + sprintf( cmpStr, "0x%02x", c ); + + gtk_tree_store_set(actv_cheats_store, &actv_cheats_iter, + 0, addrStr, 1, valStr, 2, cmpStr, 3, name, + -1); + + gtk_tree_store_append( actv_cheats_store, &actv_cheats_iter, NULL); // aquire iter + + return 1; +} + +static void showActiveCheatList(void) +{ + gtk_tree_store_clear(actv_cheats_store); + + gtk_tree_store_append( actv_cheats_store, &actv_cheats_iter, NULL); // aquire iter + + FCEUI_ListCheats( activeCheatListCB, 0 ); +} + static void openCheatFile( GtkWidget *widget, void *userData ) { @@ -1579,8 +1611,94 @@ static void openCheatFile( GtkWidget *widget, gtk_widget_destroy (fileChooser); } + showActiveCheatList(); } +static void newCheatEntryCB( GtkWidget *widget, + void *userData ) +{ + const gchar *entry_text; + entry_text = gtk_entry_get_text (GTK_ENTRY (widget)); + + switch ( (long)userData ) + { + default: + case 0: + new_cheat_addr = strtol( entry_text, NULL, 16 ); + break; + case 1: + new_cheat_val = strtol( entry_text, NULL, 16 ); + break; + case 2: + new_cheat_cmp = strtol( entry_text, NULL, 16 ); + break; + case 3: + new_cheat_name.assign( entry_text ); + break; + } + + //printf("Cheat Value Entry contents: '%s' Value: 0x%02lx\n", entry_text, value); +} + +static void addCheat2Active( GtkWidget *widget, + void *userData ) +{ + + if ( FCEUI_AddCheat( new_cheat_name.c_str(), new_cheat_addr, new_cheat_val, new_cheat_cmp, 1) ) + { + showActiveCheatList(); + } +} + +static void removeCheatFromActive( GtkWidget *widget, + GtkTreeView *tree ) +{ + int numListRows; + GList *selListRows, *tmpList; + GtkTreeModel *model = NULL; + GtkTreeSelection *treeSel = gtk_tree_view_get_selection(tree); + + numListRows = gtk_tree_selection_count_selected_rows( treeSel ); + + //printf("Number of Rows Selected: %i\n", numListRows ); + + selListRows = gtk_tree_selection_get_selected_rows( treeSel, &model ); + + tmpList = selListRows; + + while ( tmpList ) + { + int depth; + int *indexArray; + GtkTreePath *path = (GtkTreePath*)tmpList->data; + + depth = gtk_tree_path_get_depth(path); + indexArray = gtk_tree_path_get_indices(path); + + if ( depth > 0 ) + { + FCEUI_DelCheat( indexArray[0] ); + } + //printf("Depth: %i \n", depth ); + + //for (int i=0; inext; + } + + g_list_free_full(selListRows, (GDestroyNotify) gtk_tree_path_free); + + showActiveCheatList(); +} + +static void updateCheatList( GtkWidget *widget, + void *userData ) +{ + + showActiveCheatList(); +} // creates and opens cheats window static void openCheatsWindow(void) @@ -1607,22 +1725,22 @@ static void openCheatsWindow(void) vbox = gtk_vbox_new(FALSE, 5); frame = gtk_frame_new("Active Cheats"); - actv_cheats_store = gtk_tree_store_new( 1, G_TYPE_STRING); + actv_cheats_store = gtk_tree_store_new( 4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING ); GtkTreeIter iter; gtk_tree_store_append(actv_cheats_store, &iter, NULL); // aquire iter - for(int i=0; i<15; i++) - { - std::string cheatName = "Test"; + //for(int i=0; i<15; i++) + //{ + // std::string cheatName = "Test"; - gtk_tree_store_set(actv_cheats_store, &iter, - 0, cheatName.c_str(), - -1); + // gtk_tree_store_set(actv_cheats_store, &iter, + // 0, cheatName.c_str(), + // -1); - gtk_tree_store_append(actv_cheats_store, &iter, NULL); // acquire child iterator - } + // gtk_tree_store_append(actv_cheats_store, &iter, NULL); // acquire child iterator + //} tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(actv_cheats_store)); @@ -1630,7 +1748,13 @@ static void openCheatsWindow(void) GtkTreeViewColumn* column; renderer = gtk_cell_renderer_text_new(); - column = gtk_tree_view_column_new_with_attributes("Active Cheats", renderer, "text", 0, NULL); + column = gtk_tree_view_column_new_with_attributes("Addr", renderer, "text", 0, NULL); + gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); + column = gtk_tree_view_column_new_with_attributes("Val", renderer, "text", 1, NULL); + gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); + column = gtk_tree_view_column_new_with_attributes("Cmp", renderer, "text", 2, NULL); + gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); + column = gtk_tree_view_column_new_with_attributes("Desc", renderer, "text", 3, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); scroll = gtk_scrolled_window_new(NULL, NULL); @@ -1643,6 +1767,11 @@ static void openCheatsWindow(void) label = gtk_label_new("Name:"); txt_entry = gtk_entry_new(); + g_signal_connect( txt_entry, "activate", + G_CALLBACK(newCheatEntryCB), (void*)3L ); + g_signal_connect( txt_entry, "changed", + G_CALLBACK(newCheatEntryCB), (void*)3L ); + gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 1); gtk_box_pack_start(GTK_BOX(hbox), txt_entry, TRUE, TRUE, 1); @@ -1651,24 +1780,39 @@ static void openCheatsWindow(void) hbox = gtk_hbox_new(FALSE, 6); label = gtk_label_new("Addr:"); txt_entry = gtk_entry_new(); - gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 8 ); - gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 8 ); + gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 4 ); + gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 4 ); + + g_signal_connect( txt_entry, "activate", + G_CALLBACK(newCheatEntryCB), (void*)0L ); + g_signal_connect( txt_entry, "changed", + G_CALLBACK(newCheatEntryCB), (void*)0L ); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 1); gtk_box_pack_start(GTK_BOX(hbox), txt_entry, TRUE, TRUE, 1); label = gtk_label_new("Val:"); txt_entry = gtk_entry_new(); - gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 4 ); - gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 4 ); + gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 2 ); + gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 2 ); + + g_signal_connect( txt_entry, "activate", + G_CALLBACK(newCheatEntryCB), (void*)1L ); + g_signal_connect( txt_entry, "changed", + G_CALLBACK(newCheatEntryCB), (void*)1L ); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 1); gtk_box_pack_start(GTK_BOX(hbox), txt_entry, TRUE, TRUE, 1); label = gtk_label_new("Cmp:"); txt_entry = gtk_entry_new(); - gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 4 ); - gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 4 ); + gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 2 ); + gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 2 ); + + g_signal_connect( txt_entry, "activate", + G_CALLBACK(newCheatEntryCB), (void*)2L ); + g_signal_connect( txt_entry, "changed", + G_CALLBACK(newCheatEntryCB), (void*)2L ); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 1); gtk_box_pack_start(GTK_BOX(hbox), txt_entry, TRUE, TRUE, 1); @@ -1678,11 +1822,22 @@ static void openCheatsWindow(void) hbox = gtk_hbox_new(FALSE, 3); button = gtk_button_new_with_label("Add"); gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, FALSE, 1); + + g_signal_connect( button, "clicked", + G_CALLBACK (addCheat2Active), (gpointer) NULL ); + button = gtk_button_new_with_label("Delete"); gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, FALSE, 1); + + g_signal_connect( button, "clicked", + G_CALLBACK (removeCheatFromActive), (gpointer) tree ); + button = gtk_button_new_with_label("Update"); gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, FALSE, 1); + g_signal_connect( button, "clicked", + G_CALLBACK (updateCheatList), (gpointer) NULL ); + gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 1); hbox = gtk_hbox_new(FALSE, 1); From d081c68db360c812bbd1131bf8142f224c829e69 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Tue, 5 May 2020 00:18:15 -0400 Subject: [PATCH 007/156] Successful loading of cheat codes from file via cheat window. --- src/drivers/sdl/gui.cpp | 35 +++++++++++++++++++++++++++++------ 1 file changed, 29 insertions(+), 6 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 777f47da..ba6cbcba 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -66,9 +66,9 @@ static int cheat_search_known_value = 0; static int cheat_search_neq_value = 0; static int cheat_search_gt_value = 0; static int cheat_search_lt_value = 0; -static int new_cheat_addr = 0; -static int new_cheat_val = 0; -static int new_cheat_cmp = 0; +static int new_cheat_addr = 0; +static int new_cheat_val = 0; +static int new_cheat_cmp = -1; static std::string new_cheat_name; // check to see if a particular GTK version is available @@ -1544,11 +1544,16 @@ static void cheatSearchValueEntryCB( GtkWidget *widget, static int activeCheatListCB(char *name, uint32 a, uint8 v, int c, int s, int type, void* data) { char addrStr[32], valStr[16], cmpStr[16]; - printf("Cheat Name:'%s' Addr:0x%04x Val:0x%02x \n", name, a, v ); + //printf("Cheat Name:'%s' Addr:0x%04x Val:0x%02x \n", name, a, v ); sprintf( addrStr, "0x%04x", a ); sprintf( valStr, "0x%02x", v ); - sprintf( cmpStr, "0x%02x", c ); + + if ( c >= 0 ){ + sprintf( cmpStr, "0x%02x", c ); + } else { + strcpy( cmpStr, "0xff"); + } gtk_tree_store_set(actv_cheats_store, &actv_cheats_iter, 0, addrStr, 1, valStr, 2, cmpStr, 3, name, @@ -1596,10 +1601,19 @@ static void openCheatFile( GtkWidget *widget, if (gtk_dialog_run (GTK_DIALOG (fileChooser)) ==GTK_RESPONSE_ACCEPT) { + FILE *fp; char* filename; filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fileChooser)); gtk_widget_destroy (fileChooser); + + fp = fopen( filename, "r"); + + if ( fp != NULL ) + { + FCEU_LoadGameCheats( fp, 0 ); + fclose(fp); + } //g_config->setOption("SDL.LastOpenFile", filename); // Error dialog no longer required with GTK implementation of FCEUD_PrintError() @@ -1630,7 +1644,16 @@ static void newCheatEntryCB( GtkWidget *widget, new_cheat_val = strtol( entry_text, NULL, 16 ); break; case 2: - new_cheat_cmp = strtol( entry_text, NULL, 16 ); + { + if ( entry_text[0] == 0 ) + { + new_cheat_cmp = -1; + } + else + { + new_cheat_cmp = strtol( entry_text, NULL, 16 ); + } + } break; case 3: new_cheat_name.assign( entry_text ); From 7bc778fd0e45ee3c2c76dbf6fea200be259193bd Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Tue, 5 May 2020 08:06:08 -0400 Subject: [PATCH 008/156] Added active toggle functionality to cheat list window. --- src/drivers/sdl/gui.cpp | 77 ++++++++++++++++++++++++++++------------- 1 file changed, 52 insertions(+), 25 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index ba6cbcba..b33f1a9a 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -1546,6 +1546,8 @@ static int activeCheatListCB(char *name, uint32 a, uint8 v, int c, int s, int ty char addrStr[32], valStr[16], cmpStr[16]; //printf("Cheat Name:'%s' Addr:0x%04x Val:0x%02x \n", name, a, v ); + gtk_tree_store_append( actv_cheats_store, &actv_cheats_iter, NULL); // aquire iter + sprintf( addrStr, "0x%04x", a ); sprintf( valStr, "0x%02x", v ); @@ -1556,11 +1558,9 @@ static int activeCheatListCB(char *name, uint32 a, uint8 v, int c, int s, int ty } gtk_tree_store_set(actv_cheats_store, &actv_cheats_iter, - 0, addrStr, 1, valStr, 2, cmpStr, 3, name, + 0, s, 1, addrStr, 2, valStr, 3, cmpStr, 4, name, -1); - gtk_tree_store_append( actv_cheats_store, &actv_cheats_iter, NULL); // aquire iter - return 1; } @@ -1568,11 +1568,42 @@ static void showActiveCheatList(void) { gtk_tree_store_clear(actv_cheats_store); - gtk_tree_store_append( actv_cheats_store, &actv_cheats_iter, NULL); // aquire iter - FCEUI_ListCheats( activeCheatListCB, 0 ); } +static void cheatListEnableToggle( GtkCellRendererToggle *renderer, + gchar *pathStr, + GtkTreeView *tree ) +{ + GtkTreeModel *model=NULL; + GtkTreePath *path; + int depth; + int *indexArray; + + model = gtk_tree_view_get_model( tree ); + + path = gtk_tree_path_new_from_string( pathStr ); + + if ( path == NULL ){ + printf("Error: gtk_tree_path_new_from_string failed\n"); + return; + } + + depth = gtk_tree_path_get_depth(path); + indexArray = gtk_tree_path_get_indices(path); + + if ( depth > 0 ) + { + //printf("Toggle: %i\n", indexArray[0] ); + FCEUI_ToggleCheat( indexArray[0] ); + } + + gtk_tree_path_free( path ); + + showActiveCheatList(); + +} + static void openCheatFile( GtkWidget *widget, void *userData ) { @@ -1748,38 +1779,34 @@ static void openCheatsWindow(void) vbox = gtk_vbox_new(FALSE, 5); frame = gtk_frame_new("Active Cheats"); - actv_cheats_store = gtk_tree_store_new( 4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING ); - - GtkTreeIter iter; - - gtk_tree_store_append(actv_cheats_store, &iter, NULL); // aquire iter - - //for(int i=0; i<15; i++) - //{ - // std::string cheatName = "Test"; - - // gtk_tree_store_set(actv_cheats_store, &iter, - // 0, cheatName.c_str(), - // -1); - - // gtk_tree_store_append(actv_cheats_store, &iter, NULL); // acquire child iterator - //} + actv_cheats_store = gtk_tree_store_new( 5, G_TYPE_BOOLEAN, + G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING ); tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(actv_cheats_store)); GtkCellRenderer *renderer; + GtkCellRenderer *chkbox_renderer; GtkTreeViewColumn* column; renderer = gtk_cell_renderer_text_new(); - column = gtk_tree_view_column_new_with_attributes("Addr", renderer, "text", 0, NULL); + chkbox_renderer = gtk_cell_renderer_toggle_new(); + gtk_cell_renderer_toggle_set_activatable( (GtkCellRendererToggle*)chkbox_renderer, TRUE ); + column = gtk_tree_view_column_new_with_attributes("Ena", chkbox_renderer, "active", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); - column = gtk_tree_view_column_new_with_attributes("Val", renderer, "text", 1, NULL); + column = gtk_tree_view_column_new_with_attributes("Addr", renderer, "text", 1, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); - column = gtk_tree_view_column_new_with_attributes("Cmp", renderer, "text", 2, NULL); + column = gtk_tree_view_column_new_with_attributes("Val", renderer, "text", 2, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); - column = gtk_tree_view_column_new_with_attributes("Desc", renderer, "text", 3, NULL); + column = gtk_tree_view_column_new_with_attributes("Cmp", renderer, "text", 3, NULL); + gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); + column = gtk_tree_view_column_new_with_attributes("Desc", renderer, "text", 4, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); + g_signal_connect( chkbox_renderer, "toggled", + G_CALLBACK(cheatListEnableToggle), (void*)tree ); + + showActiveCheatList(); + scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); From 30aec1e53406e01cec3ca02075b36b20b371a80f Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Tue, 5 May 2020 08:18:41 -0400 Subject: [PATCH 009/156] Added cheat modification via update button logic. --- src/drivers/sdl/gui.cpp | 45 +++++++++++++++++++++++++++++++++++++++-- 1 file changed, 43 insertions(+), 2 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index b33f1a9a..1ca9382c 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -1748,8 +1748,49 @@ static void removeCheatFromActive( GtkWidget *widget, } static void updateCheatList( GtkWidget *widget, - void *userData ) + GtkTreeView *tree ) { + int numListRows; + GList *selListRows, *tmpList; + GtkTreeModel *model = NULL; + GtkTreeSelection *treeSel = gtk_tree_view_get_selection(tree); + + numListRows = gtk_tree_selection_count_selected_rows( treeSel ); + + //printf("Number of Rows Selected: %i\n", numListRows ); + + selListRows = gtk_tree_selection_get_selected_rows( treeSel, &model ); + + tmpList = selListRows; + + while ( tmpList ) + { + int depth; + int *indexArray; + GtkTreePath *path = (GtkTreePath*)tmpList->data; + + depth = gtk_tree_path_get_depth(path); + indexArray = gtk_tree_path_get_indices(path); + + if ( depth > 0 ) + { + uint32 a; uint8 v; + int c, s, type; + if ( FCEUI_GetCheat( indexArray[0], NULL, &a, &v, &c, &s, &type) ) + { + FCEUI_SetCheat( indexArray[0], new_cheat_name.c_str(), new_cheat_addr, new_cheat_val, new_cheat_cmp, s, type ); + } + } + //printf("Depth: %i \n", depth ); + + //for (int i=0; inext; + } + + g_list_free_full(selListRows, (GDestroyNotify) gtk_tree_path_free); showActiveCheatList(); } @@ -1886,7 +1927,7 @@ static void openCheatsWindow(void) gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, FALSE, 1); g_signal_connect( button, "clicked", - G_CALLBACK (updateCheatList), (gpointer) NULL ); + G_CALLBACK (updateCheatList), (gpointer) tree ); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 1); From 45d88df6b0d2380167a3d10d069b65dfa82a51b7 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Tue, 5 May 2020 19:56:38 -0400 Subject: [PATCH 010/156] Hooked up cheats pause while window active function. --- src/drivers/sdl/gui.cpp | 58 ++++++++++++++++++++++++++++++++++++----- 1 file changed, 52 insertions(+), 6 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 1ca9382c..096ee579 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -70,6 +70,8 @@ static int new_cheat_addr = 0; static int new_cheat_val = 0; static int new_cheat_cmp = -1; static std::string new_cheat_name; +static bool wasPausedByCheats = false; +static bool pauseWhileCheatsActv = false; // check to see if a particular GTK version is available // 2.24 is required for most of the dialogs -- ie: checkGTKVersion(2,24); @@ -135,6 +137,7 @@ int configHotkey(char* hotkeyString) return 0;*/ #endif + return 0; } // This function configures a single button on a gamepad int configGamepadButton(GtkButton* button, gpointer p) @@ -1247,7 +1250,7 @@ void openSoundConfig() // mixer mixerFrame = gtk_frame_new("Mixer:"); mixerHbox = gtk_hbox_new(TRUE, 5); - for(int i=0; i<6; i++) + for(long int i=0; i<6; i++) { mixers[i] = gtk_vscale_new_with_range(0, 256, 1); gtk_range_set_inverted(GTK_RANGE(mixers[i]), TRUE); @@ -1509,6 +1512,30 @@ static void cheatSearchLessThan( GtkButton *button, showCheatSearchResults(); } +static void pauseDuringCheatWinActvCB( GtkToggleButton *button, + void *userData ) +{ + pauseWhileCheatsActv = gtk_toggle_button_get_active(button); + + if ( pauseWhileCheatsActv ) + { + if ( EmulationPaused == 0 ) + { + EmulationPaused = 1; + wasPausedByCheats = true; + } + } + else + { + if ( EmulationPaused && wasPausedByCheats ) + { + EmulationPaused = 0; + } + wasPausedByCheats = false; + } + FCEU_printf("Emulation paused: %d\n", EmulationPaused); +} + static void cheatSearchValueEntryCB( GtkWidget *widget, void *userData ) { @@ -1575,13 +1602,10 @@ static void cheatListEnableToggle( GtkCellRendererToggle *renderer, gchar *pathStr, GtkTreeView *tree ) { - GtkTreeModel *model=NULL; GtkTreePath *path; int depth; int *indexArray; - model = gtk_tree_view_get_model( tree ); - path = gtk_tree_path_new_from_string( pathStr ); if ( path == NULL ){ @@ -1714,6 +1738,10 @@ static void removeCheatFromActive( GtkWidget *widget, numListRows = gtk_tree_selection_count_selected_rows( treeSel ); + if ( numListRows == 0 ) + { + return; + } //printf("Number of Rows Selected: %i\n", numListRows ); selListRows = gtk_tree_selection_get_selected_rows( treeSel, &model ); @@ -1757,6 +1785,10 @@ static void updateCheatList( GtkWidget *widget, numListRows = gtk_tree_selection_count_selected_rows( treeSel ); + if ( numListRows == 0 ) + { + return; + } //printf("Number of Rows Selected: %i\n", numListRows ); selListRows = gtk_tree_selection_get_selected_rows( treeSel, &model ); @@ -1795,6 +1827,18 @@ static void updateCheatList( GtkWidget *widget, showActiveCheatList(); } +void closeCheatDialog(GtkWidget* w, GdkEvent* e, gpointer p) +{ + if ( EmulationPaused && wasPausedByCheats ) + { + EmulationPaused = 0; + } + wasPausedByCheats = false; + pauseWhileCheatsActv = false; + + gtk_widget_destroy(w); +} + // creates and opens cheats window static void openCheatsWindow(void) { @@ -1975,6 +2019,8 @@ static void openCheatsWindow(void) gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5); button = gtk_check_button_new_with_label("Pause emulation when this window is active"); gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 5); + g_signal_connect( button, "clicked", + G_CALLBACK (pauseDuringCheatWinActvCB), (gpointer) NULL ); prev_cmp_vbox = gtk_vbox_new(FALSE, 4); gtk_container_add(GTK_CONTAINER(frame), prev_cmp_vbox); @@ -2102,8 +2148,8 @@ static void openCheatsWindow(void) gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(win))), main_hbox, TRUE, TRUE, 0); - g_signal_connect(win, "delete-event", G_CALLBACK(closeDialog), NULL); - g_signal_connect(win, "response", G_CALLBACK(closeDialog), NULL); + g_signal_connect(win, "delete-event", G_CALLBACK(closeCheatDialog), NULL); + g_signal_connect(win, "response", G_CALLBACK(closeCheatDialog), NULL); gtk_widget_show_all(win); } From d1fd5a8e2d94be518117f9de4584372ca1d19e78 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Tue, 5 May 2020 20:42:25 -0400 Subject: [PATCH 011/156] A few bug fixes while testing the cheat window. --- src/drivers/sdl/gui.cpp | 90 ++++++++++++++++++++++++++++------------- 1 file changed, 61 insertions(+), 29 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 096ee579..8112bec0 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -66,12 +66,13 @@ static int cheat_search_known_value = 0; static int cheat_search_neq_value = 0; static int cheat_search_gt_value = 0; static int cheat_search_lt_value = 0; -static int new_cheat_addr = 0; -static int new_cheat_val = 0; +static int new_cheat_addr = -1; +static int new_cheat_val = -1; static int new_cheat_cmp = -1; static std::string new_cheat_name; static bool wasPausedByCheats = false; static bool pauseWhileCheatsActv = false; +static bool cheatWindowOpen = false; // check to see if a particular GTK version is available // 2.24 is required for most of the dialogs -- ie: checkGTKVersion(2,24); @@ -1425,8 +1426,6 @@ static void showCheatSearchResults(void) gtk_tree_store_clear(ram_match_store); - gtk_tree_store_append( ram_match_store, &ram_match_iter, NULL); // aquire iter - total_matches = FCEUI_CheatSearchGetCount(); printf("Cheat Search Matches: %i \n", total_matches ); @@ -1439,10 +1438,10 @@ static void cheatSearchReset( GtkButton *button, { printf("Cheat Search Reset!\n"); - cheat_search_known_value = 0; - cheat_search_neq_value = 0; - cheat_search_gt_value = 0; - cheat_search_lt_value = 0; + //cheat_search_known_value = 0; + //cheat_search_neq_value = 0; + //cheat_search_gt_value = 0; + //cheat_search_lt_value = 0; FCEUI_CheatSearchBegin(); showCheatSearchResults(); @@ -1463,7 +1462,7 @@ static void cheatSearchEqual( GtkButton *button, { //printf("Cheat Search Equal !\n"); - FCEUI_CheatSearchEnd(FCEU_SEARCH_PUERLY_RELATIVE_CHANGE, 0, cheat_search_neq_value); + FCEUI_CheatSearchEnd(FCEU_SEARCH_PUERLY_RELATIVE_CHANGE, 0, 0); showCheatSearchResults(); } @@ -1505,7 +1504,7 @@ static void cheatSearchLessThan( GtkButton *button, //printf("Cheat Search LessThan %i!\n", checked); if ( checked ){ - FCEUI_CheatSearchEnd(FCEU_SEARCH_NEWVAL_LT_KNOWN, 0, cheat_search_gt_value); + FCEUI_CheatSearchEnd(FCEU_SEARCH_NEWVAL_LT_KNOWN, 0, cheat_search_lt_value); } else { FCEUI_CheatSearchEnd(FCEU_SEARCH_NEWVAL_LT, 0, 0); } @@ -1693,10 +1692,24 @@ static void newCheatEntryCB( GtkWidget *widget, { default: case 0: - new_cheat_addr = strtol( entry_text, NULL, 16 ); + if ( entry_text[0] == 0 ) + { + new_cheat_addr = -1; + } + else + { + new_cheat_addr = strtol( entry_text, NULL, 16 ); + } break; case 1: - new_cheat_val = strtol( entry_text, NULL, 16 ); + if ( entry_text[0] == 0 ) + { + new_cheat_val = -1; + } + else + { + new_cheat_val = strtol( entry_text, NULL, 16 ); + } break; case 2: { @@ -1722,9 +1735,12 @@ static void addCheat2Active( GtkWidget *widget, void *userData ) { - if ( FCEUI_AddCheat( new_cheat_name.c_str(), new_cheat_addr, new_cheat_val, new_cheat_cmp, 1) ) - { - showActiveCheatList(); + if ( (new_cheat_addr >= 0) && (new_cheat_val >= 0) ) + { + if ( FCEUI_AddCheat( new_cheat_name.c_str(), new_cheat_addr, new_cheat_val, new_cheat_cmp, 1) ) + { + showActiveCheatList(); + } } } @@ -1808,9 +1824,23 @@ static void updateCheatList( GtkWidget *widget, { uint32 a; uint8 v; int c, s, type; + const char *name = NULL; if ( FCEUI_GetCheat( indexArray[0], NULL, &a, &v, &c, &s, &type) ) { - FCEUI_SetCheat( indexArray[0], new_cheat_name.c_str(), new_cheat_addr, new_cheat_val, new_cheat_cmp, s, type ); + if ( new_cheat_addr >= 0 ){ + a = new_cheat_addr; + } + if ( new_cheat_val >= 0 ){ + v = new_cheat_val; + } + if ( new_cheat_cmp >= 0 ){ + c = new_cheat_cmp; + } + if ( new_cheat_name.size() ) + { + name = new_cheat_name.c_str(); + } + FCEUI_SetCheat( indexArray[0], name, a, v, c, s, type ); } } //printf("Depth: %i \n", depth ); @@ -1835,6 +1865,15 @@ void closeCheatDialog(GtkWidget* w, GdkEvent* e, gpointer p) } wasPausedByCheats = false; pauseWhileCheatsActv = false; + cheatWindowOpen = false; + + cheat_search_known_value = 0; + cheat_search_neq_value = 0; + cheat_search_gt_value = 0; + cheat_search_lt_value = 0; + new_cheat_addr = -1; + new_cheat_val = -1; + new_cheat_cmp = -1; gtk_widget_destroy(w); } @@ -1853,6 +1892,10 @@ static void openCheatsWindow(void) GtkWidget *scroll; GtkWidget *align; + if ( cheatWindowOpen ){ + return; // Only allow one cheat window to be open per gui. + } + win = gtk_dialog_new_with_buttons("Cheats", GTK_WINDOW(MainWindow), (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT), GTK_STOCK_CLOSE, @@ -2112,19 +2155,6 @@ static void openCheatsWindow(void) ram_match_store = gtk_tree_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); - gtk_tree_store_append( ram_match_store, &ram_match_iter, NULL); // aquire iter - - //for(int i=0; i<15; i++) - //{ - // std::string ramText = "Test"; - - // gtk_tree_store_set(ram_match_store, &ram_match_iter, - // 0, ramText.c_str(), - // -1); - - // gtk_tree_store_append(ram_match_store, &ram_match_iter, NULL); // acquire child iterator - //} - tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(ram_match_store)); renderer = gtk_cell_renderer_text_new(); @@ -2152,6 +2182,8 @@ static void openCheatsWindow(void) g_signal_connect(win, "response", G_CALLBACK(closeCheatDialog), NULL); gtk_widget_show_all(win); + + cheatWindowOpen = true; } void recordMovie() From 19deda13146776cd3940c9f89a5d99ad5a6e2b43 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Tue, 5 May 2020 23:08:50 -0400 Subject: [PATCH 012/156] Added initial framework for RAM watch window. --- src/drivers/sdl/gui.cpp | 289 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 289 insertions(+) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 8112bec0..eaa97d2a 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -74,6 +74,10 @@ static bool wasPausedByCheats = false; static bool pauseWhileCheatsActv = false; static bool cheatWindowOpen = false; +//----------------------------------------- +// Ram Watch static variables +static GtkTreeStore *ram_watch_store = NULL; + // check to see if a particular GTK version is available // 2.24 is required for most of the dialogs -- ie: checkGTKVersion(2,24); bool checkGTKVersion(int major_required, int minor_required) @@ -2186,6 +2190,289 @@ static void openCheatsWindow(void) cheatWindowOpen = true; } +//******************************************************************************************************* +// Ram Watch Window +//******************************************************************************************************* + +static void openWatchFile() +{ + GtkWidget* fileChooser; + GtkFileFilter* filterWch; + GtkFileFilter* filterAll; + + filterWch = gtk_file_filter_new(); + gtk_file_filter_add_pattern(filterWch, "*.wch"); + gtk_file_filter_add_pattern(filterWch, "*.WCH"); + gtk_file_filter_set_name(filterWch, "Watch files"); + + filterAll = gtk_file_filter_new(); + gtk_file_filter_add_pattern(filterAll, "*"); + gtk_file_filter_set_name(filterAll, "All Files"); + + const char* last_dir; + g_config->getOption("SDL.LastSaveStateAs", &last_dir); + + fileChooser = gtk_file_chooser_dialog_new ("Open Watch File", GTK_WINDOW(MainWindow), + GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, + GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); + + gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fileChooser), last_dir); + + gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER(fileChooser), ".wch"); + gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterWch); + gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterAll); + + if (gtk_dialog_run (GTK_DIALOG (fileChooser)) ==GTK_RESPONSE_ACCEPT) + { + char* filename; + + filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fileChooser)); + //FCEUI_SaveState(filename); + //g_config->setOption("SDL.LastSaveStateAs", filename); + g_free(filename); + } + gtk_widget_destroy (fileChooser); + + +} + +// Our menu, in the XML markup format used by GtkUIManager +static char* menuRamWatchXml = + "" + " " + " " + " " + " " + " " + " " + ""; + +static GtkActionEntry ramWatch_entries[] = { + {"FileMenuAction", NULL, "_File"}, + {"OpenWatchFile", GTK_STOCK_OPEN, "_Open Watch", NULL, NULL, G_CALLBACK(openWatchFile)}, + {"SaveWatchFile", GTK_STOCK_SAVE_AS, "_Save Watch", NULL, NULL, G_CALLBACK(openWatchFile)}, +}; + + +static GtkWidget* CreateRamWatchMenubar( GtkWidget* window) +{ + GtkUIManager *ui_manager; + GtkActionGroup *action_group; + GtkAccelGroup* accel_group; + GError *error = NULL; + //GtkAction* state; + + /* Make an UIManager (which makes a menubar). */ + ui_manager = gtk_ui_manager_new (); + + /* Add the menu items to the UIManager as a GtkActionGroup. */ + action_group = gtk_action_group_new ("MenubarActions"); + gtk_action_group_add_actions (action_group, ramWatch_entries, G_N_ELEMENTS (ramWatch_entries), NULL); + //gtk_action_group_add_toggle_actions (action_group, toggle_entries, G_N_ELEMENTS (toggle_entries), NULL); + //gtk_action_group_add_radio_actions (action_group, radio_entries, G_N_ELEMENTS (radio_entries), 0, G_CALLBACK(changeState), NULL); + gtk_ui_manager_insert_action_group (ui_manager, action_group, 0); + + /* Read the menu layout from the XML markup. */ + gtk_ui_manager_add_ui_from_string (ui_manager, menuRamWatchXml, -1, &error); + if (error) + { + fprintf (stderr, "Unable to create menu bar: %s\n", error->message); + g_error_free (error); + } + + /* Attach the new accelerator group to the window. */ + accel_group = gtk_ui_manager_get_accel_group (ui_manager); + gtk_window_add_accel_group (GTK_WINDOW (window), accel_group); + + /* Get an action that can be used to change the active state slot selection. */ + //state = gtk_action_group_get_action (action_group, "State0Action"); + //if (state && GTK_IS_RADIO_ACTION (state)) + // stateSlot = GTK_RADIO_ACTION (state); + + /* Finally, return the actual menu bar created by the UIManager. */ + return gtk_ui_manager_get_widget (ui_manager, "/Menubar"); +} + +static int openRamWatchEntryDialog( char *name, int *addr, int *type ) +{ + int retval; + GtkWidget* win; + GtkWidget* vbox; + GtkWidget* hbox; + GtkWidget* label; + GtkWidget* chkbox; + GtkWidget* txt_entry_name; + GtkWidget* txt_entry_addr; + char stmp[32]; + + win = gtk_dialog_new_with_buttons("RAM Watch Entry", + GTK_WINDOW(MainWindow), (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT), + GTK_STOCK_CLOSE, + GTK_RESPONSE_OK, + NULL); + gtk_window_set_default_size(GTK_WINDOW(win), 400, 200); + + vbox = gtk_vbox_new(FALSE, 4); + + label = gtk_label_new("Name:"); + txt_entry_name = gtk_entry_new(); + + if ( name[0] != 0 ){ + gtk_entry_set_text( GTK_ENTRY(txt_entry_name), name ); + } + + gtk_box_pack_start (GTK_BOX(vbox), label, FALSE, FALSE, 0); + gtk_box_pack_start (GTK_BOX(vbox), txt_entry_name, FALSE, TRUE, 0); + + hbox = gtk_hbox_new(FALSE, 2); + label = gtk_label_new("Hex Address:"); + txt_entry_addr = gtk_entry_new(); + + gtk_box_pack_start (GTK_BOX(vbox), label, FALSE, FALSE, 0); + + label = gtk_label_new("0x"); + sprintf( stmp, "%04x", *addr ); + gtk_entry_set_max_length( GTK_ENTRY(txt_entry_addr), 4 ); + gtk_entry_set_width_chars( GTK_ENTRY(txt_entry_addr), 4 ); + gtk_entry_set_text( GTK_ENTRY(txt_entry_addr), stmp ); + + gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0); + gtk_box_pack_start (GTK_BOX(hbox), txt_entry_addr, TRUE, TRUE, 0); + gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, TRUE, 0); + + chkbox = gtk_check_button_new_with_label("Value is Unsigned"); + gtk_box_pack_start (GTK_BOX(vbox), chkbox, FALSE, FALSE, 0); + + gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(win))), vbox, TRUE, TRUE, 0); + + gtk_widget_show_all(win); + + retval = gtk_dialog_run(GTK_DIALOG(win)); + + if ( retval ) + { + // FIXME - what error checking should be done here + } + + strcpy( name, gtk_entry_get_text ( GTK_ENTRY(txt_entry_name) ) ); + + *addr = strtol( gtk_entry_get_text ( GTK_ENTRY(txt_entry_addr) ), NULL, 16 ); + + *type = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(chkbox) ); + + //printf("retval %i\n", retval ); + + gtk_widget_destroy(win); + + return 0; +} + +static void editRamWatch( GtkButton *button, + void *userData ) +{ + char name[256]; + int addr = 0, type = 0; + name[0] = 0; + openRamWatchEntryDialog( name, &addr, &type ); + printf("Edit RamWatch '%s' 0x%04x %i\n", name, addr, type); +} + +static void removeRamWatch( GtkButton *button, + void *userData ) +{ + printf("Remove RamWatch\n"); +} + +static void newRamWatch( GtkButton *button, + void *userData ) +{ + char name[256]; + int addr = 0, type = 0; + name[0] = 0; + openRamWatchEntryDialog( name, &addr, &type ); + printf("New RamWatch '%s' 0x%04x %i\n", name, addr, type); +} + +// creates and opens cheats window +static void openMemoryWatchWindow(void) +{ + GtkWidget* win; + GtkWidget* main_vbox; + GtkWidget* hbox; + GtkWidget* vbox; + GtkWidget* button; + GtkWidget *tree; + GtkWidget *scroll; + GtkWidget* menubar; + + win = gtk_dialog_new_with_buttons("RAM Watch", + GTK_WINDOW(MainWindow), (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT), + GTK_STOCK_CLOSE, + GTK_RESPONSE_OK, + NULL); + gtk_window_set_default_size(GTK_WINDOW(win), 600, 600); + + main_vbox = gtk_vbox_new(FALSE, 1); + + menubar = CreateRamWatchMenubar(win); + + gtk_box_pack_start (GTK_BOX(main_vbox), menubar, FALSE, TRUE, 0); + + hbox = gtk_hbox_new(FALSE,2); + + ram_watch_store = gtk_tree_store_new( 4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); + + tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(ram_watch_store)); + + GtkCellRenderer *renderer; + GtkTreeViewColumn* column; + + renderer = gtk_cell_renderer_text_new(); + column = gtk_tree_view_column_new_with_attributes("Addr", renderer, "text", 0, NULL); + gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); + column = gtk_tree_view_column_new_with_attributes("Value Dec", renderer, "text", 1, NULL); + gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); + column = gtk_tree_view_column_new_with_attributes("Value Hex", renderer, "text", 2, NULL); + gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); + column = gtk_tree_view_column_new_with_attributes("Notes", renderer, "text", 3, NULL); + gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); + + scroll = gtk_scrolled_window_new(NULL, NULL); + gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, + GTK_POLICY_AUTOMATIC); + gtk_container_add(GTK_CONTAINER(scroll), tree); + gtk_box_pack_start(GTK_BOX(hbox), scroll, TRUE, TRUE, 5); + + gtk_box_pack_start(GTK_BOX(main_vbox), hbox, TRUE, TRUE, 5); + + vbox = gtk_vbox_new(FALSE, 3); + + button = gtk_button_new_with_label("Edit"); + gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 5); + g_signal_connect( button, "clicked", + G_CALLBACK (editRamWatch), (gpointer) NULL ); + + button = gtk_button_new_with_label("Remove"); + gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 5); + g_signal_connect( button, "clicked", + G_CALLBACK (removeRamWatch), (gpointer) NULL ); + + button = gtk_button_new_with_label("New"); + gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 5); + g_signal_connect( button, "clicked", + G_CALLBACK (newRamWatch), (gpointer) NULL ); + + gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 5); + + gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(win))), main_vbox, TRUE, TRUE, 0); + + g_signal_connect(win, "delete-event", G_CALLBACK(closeDialog), NULL); + g_signal_connect(win, "response", G_CALLBACK(closeDialog), NULL); + + gtk_widget_show_all(win); +} + + void recordMovie() { if(isloaded) @@ -3034,6 +3321,7 @@ static char* menuXml = " " " " " " + " " " " " " " " @@ -3089,6 +3377,7 @@ static GtkActionEntry normal_entries[] = { {"ToolsMenuAction", NULL, "_Tools"}, {"CheatsAction", "cheats-win", "_Cheats...", NULL, NULL, G_CALLBACK(openCheatsWindow)}, + {"RamWatchAction", "ram-watch", "_RAM Watch...", NULL, NULL, G_CALLBACK(openMemoryWatchWindow)}, {"MovieMenuAction", NULL, "_Movie"}, {"OpenMovieAction", GTK_STOCK_OPEN, "_Open", "F7", NULL, G_CALLBACK(loadMovie)}, From ab5d3f5f14c7f6e30ac082012558fe206741ac29 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Wed, 6 May 2020 00:17:59 -0400 Subject: [PATCH 013/156] Successful view of memory in ram watch window. Still TODO, added rest of button functionality. --- src/drivers/sdl/gui.cpp | 118 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 118 insertions(+) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index eaa97d2a..34e97766 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -1,6 +1,7 @@ #include "../../types.h" #include "../../fceu.h" #include "../../cheat.h" +#include "../../debug.h" #include "../../driver.h" #include "../../version.h" #include "../../movie.h" @@ -32,6 +33,7 @@ #include #include #include +#include // Fix compliation errors for older version of GTK (Ubuntu 10.04 LTS) #if GTK_MINOR_VERSION < 24 && GTK_MAJOR_VERSION == 2 @@ -77,6 +79,72 @@ static bool cheatWindowOpen = false; //----------------------------------------- // Ram Watch static variables static GtkTreeStore *ram_watch_store = NULL; +static gint ramWatchEvntSrcID = 0; + +struct ramWatch_t +{ + std::string name; + int addr; + int type; + + union { + int8_t i; + uint8_t u; + } val; + + ramWatch_t(void) + { + addr = 0; type = 0; val.u = 0; + }; +}; + +struct ramWatchList_t +{ + + std::list ls; + + ramWatchList_t(void) + { + + } + + ~ramWatchList_t(void) + { + ramWatch_t *rw; + + while ( !ls.empty() ) + { + rw = ls.front(); + + delete rw; + + ls.pop_front(); + } + } + + size_t size(void){ return ls.size(); }; + + void add_entry( const char *name, int addr, int type ) + { + ramWatch_t *rw = new ramWatch_t; + + rw->name.assign(name); + rw->addr = addr; + rw->type = type; + ls.push_back(rw); + } + + void updateMemoryValues(void) + { + std::list ::iterator it; + + for (it=ls.begin(); it!=ls.end(); it++) + { + (*it)->val.u = GetMem( (*it)->addr ); + } + } +}; +static ramWatchList_t ramWatchList; // check to see if a particular GTK version is available // 2.24 is required for most of the dialogs -- ie: checkGTKVersion(2,24); @@ -2193,6 +2261,39 @@ static void openCheatsWindow(void) //******************************************************************************************************* // Ram Watch Window //******************************************************************************************************* +// +static void showRamWatchResults(void) +{ + std::list ::iterator it; + GtkTreeIter iter; + char addrStr[32], valStr1[16], valStr2[16]; + ramWatch_t *rw; + + gtk_tree_store_clear(ram_watch_store); + + gtk_tree_store_append( ram_watch_store, &iter, NULL); // aquire iter + + for (it=ramWatchList.ls.begin(); it!=ramWatchList.ls.end(); it++) + { + rw = *it; + sprintf( addrStr, "0x%04x", rw->addr ); + + rw->val.u = GetMem(rw->addr); + + if ( rw->type ){ + sprintf( valStr1, "%4u", rw->val.u); + } else { + sprintf( valStr1, "%4i", rw->val.i); + } + sprintf( valStr2, "0x%02x", rw->val.u); + + gtk_tree_store_set(ram_watch_store, &iter, + 0, addrStr, 1, valStr1, 2, valStr2, 3, rw->name.c_str(), + -1); + + gtk_tree_store_append( ram_watch_store, &iter, NULL); // aquire iter + } +} static void openWatchFile() { @@ -2391,6 +2492,18 @@ static void newRamWatch( GtkButton *button, name[0] = 0; openRamWatchEntryDialog( name, &addr, &type ); printf("New RamWatch '%s' 0x%04x %i\n", name, addr, type); + + ramWatchList.add_entry( name, addr, type ); + + showRamWatchResults(); +} + +static gint updateRamWatchTree( void *userData ) +{ + static uint32_t c = 0; + //printf("RamWatch: %u\n", c++ ); + showRamWatchResults(); + return 1; } // creates and opens cheats window @@ -2445,6 +2558,11 @@ static void openMemoryWatchWindow(void) gtk_box_pack_start(GTK_BOX(main_vbox), hbox, TRUE, TRUE, 5); + if ( ramWatchEvntSrcID == 0 ) + { + ramWatchEvntSrcID = g_timeout_add( 100, updateRamWatchTree, NULL ); + } + vbox = gtk_vbox_new(FALSE, 3); button = gtk_button_new_with_label("Edit"); From 4490f650f11ef91923cc02716aaf46cbb4913bb6 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Wed, 6 May 2020 08:36:08 -0400 Subject: [PATCH 014/156] RAM watch entry window bug fixes. --- src/drivers/sdl/gui.cpp | 119 ++++++++++++++++++++++++++++++++-------- 1 file changed, 97 insertions(+), 22 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 34e97766..f0c15f2c 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -86,16 +86,35 @@ struct ramWatch_t std::string name; int addr; int type; + int size; union { - int8_t i; - uint8_t u; + int8_t i8; + uint8_t u8; + int16_t i16; + uint16_t u16; } val; ramWatch_t(void) { - addr = 0; type = 0; val.u = 0; + addr = 0; type = 0; size = 0; val.u16 = 0; }; + + void updateMem(void) + { + if ( size == 1) + { + val.u8 = GetMem( addr ); + } + else if ( size == 2) + { + val.u16 = GetMem( addr ) | (GetMem( addr+1 ) << 8); + } + else + { + val.u8 = GetMem( addr ); + } + } }; struct ramWatchList_t @@ -124,23 +143,27 @@ struct ramWatchList_t size_t size(void){ return ls.size(); }; - void add_entry( const char *name, int addr, int type ) + void add_entry( const char *name, int addr, int type, int size ) { ramWatch_t *rw = new ramWatch_t; rw->name.assign(name); rw->addr = addr; rw->type = type; + rw->size = size; ls.push_back(rw); } void updateMemoryValues(void) { + ramWatch_t *rw; std::list ::iterator it; for (it=ls.begin(); it!=ls.end(); it++) { - (*it)->val.u = GetMem( (*it)->addr ); + rw = *it; + + rw->updateMem(); } } }; @@ -1474,6 +1497,9 @@ void toggleAutoResume (GtkToggleAction *action) g_config->setOption("SDL.AutoResume", (int)autoResume); AutoResumePlay = autoResume; } +//******************************************************************************************************* +// Cheat Window +//******************************************************************************************************* static int ShowCheatSearchResultsCallB(uint32 a, uint8 last, uint8 current) { @@ -2278,14 +2304,26 @@ static void showRamWatchResults(void) rw = *it; sprintf( addrStr, "0x%04x", rw->addr ); - rw->val.u = GetMem(rw->addr); + rw->updateMem(); - if ( rw->type ){ - sprintf( valStr1, "%4u", rw->val.u); - } else { - sprintf( valStr1, "%4i", rw->val.i); + if ( rw->size == 2 ) + { + if ( rw->type ){ + sprintf( valStr1, "%6u", rw->val.u16); + } else { + sprintf( valStr1, "%6i", rw->val.i16); + } + sprintf( valStr2, "0x%04x", rw->val.u16); + } + else + { + if ( rw->type ){ + sprintf( valStr1, "%6u", rw->val.u8); + } else { + sprintf( valStr1, "%6i", rw->val.i8); + } + sprintf( valStr2, "0x%02x", rw->val.u8); } - sprintf( valStr2, "0x%02x", rw->val.u); gtk_tree_store_set(ram_watch_store, &iter, 0, addrStr, 1, valStr1, 2, valStr2, 3, rw->name.c_str(), @@ -2394,7 +2432,7 @@ static GtkWidget* CreateRamWatchMenubar( GtkWidget* window) return gtk_ui_manager_get_widget (ui_manager, "/Menubar"); } -static int openRamWatchEntryDialog( char *name, int *addr, int *type ) +static int openRamWatchEntryDialog( char *name, int *addr, int *type, int *size ) { int retval; GtkWidget* win; @@ -2402,6 +2440,7 @@ static int openRamWatchEntryDialog( char *name, int *addr, int *type ) GtkWidget* hbox; GtkWidget* label; GtkWidget* chkbox; + GtkWidget* button1, *button2, *button4; GtkWidget* txt_entry_name; GtkWidget* txt_entry_addr; char stmp[32]; @@ -2413,7 +2452,7 @@ static int openRamWatchEntryDialog( char *name, int *addr, int *type ) NULL); gtk_window_set_default_size(GTK_WINDOW(win), 400, 200); - vbox = gtk_vbox_new(FALSE, 4); + vbox = gtk_vbox_new(FALSE, 6); label = gtk_label_new("Name:"); txt_entry_name = gtk_entry_new(); @@ -2444,7 +2483,27 @@ static int openRamWatchEntryDialog( char *name, int *addr, int *type ) chkbox = gtk_check_button_new_with_label("Value is Unsigned"); gtk_box_pack_start (GTK_BOX(vbox), chkbox, FALSE, FALSE, 0); - gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(win))), vbox, TRUE, TRUE, 0); + hbox = gtk_hbox_new(FALSE, 4); + label = gtk_label_new("Size in Bytes:"); + button1 = gtk_radio_button_new_with_label (NULL, "1"); + //gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); + + gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 1); + gtk_box_pack_start (GTK_BOX(hbox), button1, TRUE, FALSE, 1); + + button2 = gtk_radio_button_new_with_label_from_widget ( GTK_RADIO_BUTTON (button1), "2"); + gtk_box_pack_start (GTK_BOX(hbox), button2, TRUE, FALSE, 1); + + button4 = gtk_radio_button_new_with_label_from_widget ( GTK_RADIO_BUTTON (button1), "4"); + gtk_box_pack_start (GTK_BOX(hbox), button4, TRUE, FALSE, 1); + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button1), TRUE); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button2), FALSE); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button4), FALSE); + + gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, TRUE, 1); + + gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(win))), vbox, TRUE, TRUE, 1); gtk_widget_show_all(win); @@ -2461,8 +2520,24 @@ static int openRamWatchEntryDialog( char *name, int *addr, int *type ) *type = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(chkbox) ); + if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(button4) ) ) + { + *size = 4; + } + else if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(button2) ) ) + { + *size = 2; + } + else + { + *size = 1; + } + //printf("retval %i\n", retval ); + g_signal_connect(win, "delete-event", G_CALLBACK(closeDialog), NULL); + g_signal_connect(win, "response", G_CALLBACK(closeDialog), NULL); + gtk_widget_destroy(win); return 0; @@ -2472,10 +2547,10 @@ static void editRamWatch( GtkButton *button, void *userData ) { char name[256]; - int addr = 0, type = 0; + int addr = 0, type = 0, size = 0; name[0] = 0; - openRamWatchEntryDialog( name, &addr, &type ); - printf("Edit RamWatch '%s' 0x%04x %i\n", name, addr, type); + openRamWatchEntryDialog( name, &addr, &type, &size ); + printf("Edit RamWatch '%s' 0x%04x %i %i\n", name, addr, type, size); } static void removeRamWatch( GtkButton *button, @@ -2488,19 +2563,19 @@ static void newRamWatch( GtkButton *button, void *userData ) { char name[256]; - int addr = 0, type = 0; + int addr = 0, type = 0, size = 0; name[0] = 0; - openRamWatchEntryDialog( name, &addr, &type ); - printf("New RamWatch '%s' 0x%04x %i\n", name, addr, type); + openRamWatchEntryDialog( name, &addr, &type, &size ); + printf("New RamWatch '%s' 0x%04x %i %i\n", name, addr, type, size); - ramWatchList.add_entry( name, addr, type ); + ramWatchList.add_entry( name, addr, type, size ); showRamWatchResults(); } static gint updateRamWatchTree( void *userData ) { - static uint32_t c = 0; + //static uint32_t c = 0; //printf("RamWatch: %u\n", c++ ); showRamWatchResults(); return 1; From b4f4f816d7c0c671d9aa40764b06000881681897 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Wed, 6 May 2020 09:00:53 -0400 Subject: [PATCH 015/156] Added logic to allow for RAM watch display updates to be non-destructive. --- src/drivers/sdl/gui.cpp | 28 ++++++++++++++++++++++------ 1 file changed, 22 insertions(+), 6 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index f0c15f2c..bc4ee20f 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -2288,16 +2288,25 @@ static void openCheatsWindow(void) // Ram Watch Window //******************************************************************************************************* // -static void showRamWatchResults(void) +static void showRamWatchResults(int reset) { std::list ::iterator it; GtkTreeIter iter; char addrStr[32], valStr1[16], valStr2[16]; ramWatch_t *rw; - gtk_tree_store_clear(ram_watch_store); - gtk_tree_store_append( ram_watch_store, &iter, NULL); // aquire iter + + if ( reset ) + { + gtk_tree_store_clear(ram_watch_store); + + gtk_tree_store_append( ram_watch_store, &iter, NULL); // aquire iter + } + else + { + gtk_tree_model_get_iter_first( GTK_TREE_MODEL(ram_watch_store), &iter ); + } for (it=ramWatchList.ls.begin(); it!=ramWatchList.ls.end(); it++) { @@ -2329,7 +2338,14 @@ static void showRamWatchResults(void) 0, addrStr, 1, valStr1, 2, valStr2, 3, rw->name.c_str(), -1); - gtk_tree_store_append( ram_watch_store, &iter, NULL); // aquire iter + if ( reset ) + { + gtk_tree_store_append( ram_watch_store, &iter, NULL); // aquire iter + } + else + { + gtk_tree_model_iter_next( GTK_TREE_MODEL(ram_watch_store), &iter ); + } } } @@ -2570,14 +2586,14 @@ static void newRamWatch( GtkButton *button, ramWatchList.add_entry( name, addr, type, size ); - showRamWatchResults(); + showRamWatchResults(1); } static gint updateRamWatchTree( void *userData ) { //static uint32_t c = 0; //printf("RamWatch: %u\n", c++ ); - showRamWatchResults(); + showRamWatchResults(0); return 1; } From c901c7273dff389c1dd5dfef2f639475fef1d63a Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Thu, 7 May 2020 09:49:03 -0400 Subject: [PATCH 016/156] Added directly cheat list cell editing functionality to gtk GUI. --- src/drivers/sdl/gui.cpp | 176 ++++++++++++++++++++++++++++++++++------ 1 file changed, 150 insertions(+), 26 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index bc4ee20f..234b4c92 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -80,6 +80,7 @@ static bool cheatWindowOpen = false; // Ram Watch static variables static GtkTreeStore *ram_watch_store = NULL; static gint ramWatchEvntSrcID = 0; +static bool ramWatchWinOpen = false; struct ramWatch_t { @@ -1667,10 +1668,16 @@ static void cheatSearchValueEntryCB( GtkWidget *widget, static int activeCheatListCB(char *name, uint32 a, uint8 v, int c, int s, int type, void* data) { + long int reset; char addrStr[32], valStr[16], cmpStr[16]; //printf("Cheat Name:'%s' Addr:0x%04x Val:0x%02x \n", name, a, v ); + // + reset = (long)data; - gtk_tree_store_append( actv_cheats_store, &actv_cheats_iter, NULL); // aquire iter + if ( reset ) + { + gtk_tree_store_append( actv_cheats_store, &actv_cheats_iter, NULL); // aquire iter + } sprintf( addrStr, "0x%04x", a ); sprintf( valStr, "0x%02x", v ); @@ -1685,14 +1692,33 @@ static int activeCheatListCB(char *name, uint32 a, uint8 v, int c, int s, int ty 0, s, 1, addrStr, 2, valStr, 3, cmpStr, 4, name, -1); + if ( !reset ) + { + if ( !gtk_tree_model_iter_next( GTK_TREE_MODEL(actv_cheats_store), &actv_cheats_iter ) ) + { + gtk_tree_store_append( actv_cheats_store, &actv_cheats_iter, NULL); // aquire iter + } + } + return 1; } -static void showActiveCheatList(void) +static void showActiveCheatList( long int reset ) { - gtk_tree_store_clear(actv_cheats_store); + if ( reset ) + { + gtk_tree_store_clear(actv_cheats_store); + } + else + { + if ( !gtk_tree_model_get_iter_first( GTK_TREE_MODEL(actv_cheats_store), &actv_cheats_iter ) ) + { + printf("No Tree Entries Loaded.\n"); + reset = 1; + } + } - FCEUI_ListCheats( activeCheatListCB, 0 ); + FCEUI_ListCheats( activeCheatListCB, (void*)reset ); } static void cheatListEnableToggle( GtkCellRendererToggle *renderer, @@ -1721,7 +1747,7 @@ static void cheatListEnableToggle( GtkCellRendererToggle *renderer, gtk_tree_path_free( path ); - showActiveCheatList(); + showActiveCheatList(0); } @@ -1777,7 +1803,7 @@ static void openCheatFile( GtkWidget *widget, gtk_widget_destroy (fileChooser); } - showActiveCheatList(); + showActiveCheatList(1); } static void newCheatEntryCB( GtkWidget *widget, @@ -1826,7 +1852,6 @@ static void newCheatEntryCB( GtkWidget *widget, break; } - //printf("Cheat Value Entry contents: '%s' Value: 0x%02lx\n", entry_text, value); } static void addCheat2Active( GtkWidget *widget, @@ -1837,7 +1862,7 @@ static void addCheat2Active( GtkWidget *widget, { if ( FCEUI_AddCheat( new_cheat_name.c_str(), new_cheat_addr, new_cheat_val, new_cheat_cmp, 1) ) { - showActiveCheatList(); + showActiveCheatList(1); } } } @@ -1873,20 +1898,21 @@ static void removeCheatFromActive( GtkWidget *widget, if ( depth > 0 ) { + //GtkTreeIter iter; FCEUI_DelCheat( indexArray[0] ); - } - //printf("Depth: %i \n", depth ); - //for (int i=0; inext; } g_list_free_full(selListRows, (GDestroyNotify) gtk_tree_path_free); - showActiveCheatList(); + showActiveCheatList(1); } static void updateCheatList( GtkWidget *widget, @@ -1952,9 +1978,60 @@ static void updateCheatList( GtkWidget *widget, g_list_free_full(selListRows, (GDestroyNotify) gtk_tree_path_free); - showActiveCheatList(); + showActiveCheatList(0); } +static void cheat_cell_edited_cb (GtkCellRendererText *cell, + gchar *path_string, + gchar *new_text, + gpointer user_data) +{ + long int row_idx = -1, column_idx; + + //printf("'%s'\n", path_string ); + //printf("'%s'\n", new_text ); + //printf("%p\n", user_data ); + + column_idx = (long)user_data; + + if ( isdigit(path_string[0]) ) + { + row_idx = atoi(path_string); + } + + if ( row_idx >= 0 ) + { + uint32 a; uint8 v; + int c, s, type; + const char *name = NULL; + if ( FCEUI_GetCheat( row_idx, NULL, &a, &v, &c, &s, &type) ) + { + switch ( column_idx ) + { + default: + case 0: + + break; + case 1: + a = strtol( new_text, NULL, 0 ); + break; + case 2: + v = strtol( new_text, NULL, 0 ); + break; + case 3: + c = strtol( new_text, NULL, 0 ); + break; + case 4: + name = new_text; + break; + } + FCEUI_SetCheat( row_idx, name, a, v, c, s, type ); + showActiveCheatList(0); + } + } +} + + void closeCheatDialog(GtkWidget* w, GdkEvent* e, gpointer p) { if ( EmulationPaused && wasPausedByCheats ) @@ -2015,23 +2092,42 @@ static void openCheatsWindow(void) GtkTreeViewColumn* column; renderer = gtk_cell_renderer_text_new(); + g_object_set(renderer, "editable", TRUE, NULL); + g_signal_connect(renderer, "edited", (GCallback) cheat_cell_edited_cb, NULL); + chkbox_renderer = gtk_cell_renderer_toggle_new(); gtk_cell_renderer_toggle_set_activatable( (GtkCellRendererToggle*)chkbox_renderer, TRUE ); column = gtk_tree_view_column_new_with_attributes("Ena", chkbox_renderer, "active", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); + + renderer = gtk_cell_renderer_text_new(); + g_object_set(renderer, "editable", TRUE, NULL); + g_signal_connect(renderer, "edited", (GCallback) cheat_cell_edited_cb, (gpointer)1); column = gtk_tree_view_column_new_with_attributes("Addr", renderer, "text", 1, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); + + renderer = gtk_cell_renderer_text_new(); + g_object_set(renderer, "editable", TRUE, NULL); + g_signal_connect(renderer, "edited", (GCallback) cheat_cell_edited_cb, (gpointer)2); column = gtk_tree_view_column_new_with_attributes("Val", renderer, "text", 2, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); + + renderer = gtk_cell_renderer_text_new(); + g_object_set(renderer, "editable", TRUE, NULL); + g_signal_connect(renderer, "edited", (GCallback) cheat_cell_edited_cb, (gpointer)3); column = gtk_tree_view_column_new_with_attributes("Cmp", renderer, "text", 3, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); + + renderer = gtk_cell_renderer_text_new(); + g_object_set(renderer, "editable", TRUE, NULL); + g_signal_connect(renderer, "edited", (GCallback) cheat_cell_edited_cb, (gpointer)4); column = gtk_tree_view_column_new_with_attributes("Desc", renderer, "text", 4, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); g_signal_connect( chkbox_renderer, "toggled", G_CALLBACK(cheatListEnableToggle), (void*)tree ); - showActiveCheatList(); + showActiveCheatList(1); scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, @@ -2295,13 +2391,24 @@ static void showRamWatchResults(int reset) char addrStr[32], valStr1[16], valStr2[16]; ramWatch_t *rw; + if ( gtk_tree_model_get_iter_first( GTK_TREE_MODEL(ram_watch_store), &iter ) ) + { + size_t treeSize = 1; + while ( gtk_tree_model_iter_next( GTK_TREE_MODEL(ram_watch_store), &iter ) ) + { + treeSize++; + } + if ( treeSize != ramWatchList.size() ) + { + reset = 1; + } + //printf(" TreeSize: %zi RamWatchList.size: %zi \n", treeSize, ramWatchList.size() ); + } if ( reset ) { gtk_tree_store_clear(ram_watch_store); - - gtk_tree_store_append( ram_watch_store, &iter, NULL); // aquire iter } else { @@ -2313,6 +2420,10 @@ static void showRamWatchResults(int reset) rw = *it; sprintf( addrStr, "0x%04x", rw->addr ); + if ( reset ){ + gtk_tree_store_append( ram_watch_store, &iter, NULL); // aquire iter + } + rw->updateMem(); if ( rw->size == 2 ) @@ -2338,11 +2449,7 @@ static void showRamWatchResults(int reset) 0, addrStr, 1, valStr1, 2, valStr2, 3, rw->name.c_str(), -1); - if ( reset ) - { - gtk_tree_store_append( ram_watch_store, &iter, NULL); // aquire iter - } - else + if ( !reset ) { gtk_tree_model_iter_next( GTK_TREE_MODEL(ram_watch_store), &iter ); } @@ -2597,6 +2704,13 @@ static gint updateRamWatchTree( void *userData ) return 1; } +void closeMemoryWatchWindow(GtkWidget* w, GdkEvent* e, gpointer p) +{ + ramWatchWinOpen = false; + + gtk_widget_destroy(w); +} + // creates and opens cheats window static void openMemoryWatchWindow(void) { @@ -2609,6 +2723,11 @@ static void openMemoryWatchWindow(void) GtkWidget *scroll; GtkWidget* menubar; + if ( ramWatchWinOpen ) + { + return; // Only allow 1 RAM watch window to be open. + } + win = gtk_dialog_new_with_buttons("RAM Watch", GTK_WINDOW(MainWindow), (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT), GTK_STOCK_CLOSE, @@ -2632,6 +2751,7 @@ static void openMemoryWatchWindow(void) GtkTreeViewColumn* column; renderer = gtk_cell_renderer_text_new(); + g_object_set(renderer, "editable", TRUE, NULL); column = gtk_tree_view_column_new_with_attributes("Addr", renderer, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); column = gtk_tree_view_column_new_with_attributes("Value Dec", renderer, "text", 1, NULL); @@ -2649,6 +2769,8 @@ static void openMemoryWatchWindow(void) gtk_box_pack_start(GTK_BOX(main_vbox), hbox, TRUE, TRUE, 5); + showRamWatchResults(1); + if ( ramWatchEvntSrcID == 0 ) { ramWatchEvntSrcID = g_timeout_add( 100, updateRamWatchTree, NULL ); @@ -2675,10 +2797,12 @@ static void openMemoryWatchWindow(void) gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(win))), main_vbox, TRUE, TRUE, 0); - g_signal_connect(win, "delete-event", G_CALLBACK(closeDialog), NULL); - g_signal_connect(win, "response", G_CALLBACK(closeDialog), NULL); + g_signal_connect(win, "delete-event", G_CALLBACK(closeMemoryWatchWindow), NULL); + g_signal_connect(win, "response", G_CALLBACK(closeMemoryWatchWindow), NULL); gtk_widget_show_all(win); + + ramWatchWinOpen = true; } From 27cbbdf5344cde67e9238e9a4fd7aa67f0dfd210 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Thu, 7 May 2020 21:31:55 -0400 Subject: [PATCH 017/156] Added logic to load/save RAM watch files. --- src/drivers/sdl/gui.cpp | 269 +++++++++++++++++++++++++++++++++++----- 1 file changed, 241 insertions(+), 28 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 234b4c92..768a4147 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -1510,11 +1510,12 @@ static int ShowCheatSearchResultsCallB(uint32 a, uint8 last, uint8 current) sprintf( lastStr, "0x%02x", last ); sprintf( curStr, "| 0x%02x", current ); - gtk_tree_store_set(ram_match_store, &ram_match_iter, + gtk_tree_store_append( ram_match_store, &ram_match_iter, NULL); // aquire iter + + gtk_tree_store_set(ram_match_store, &ram_match_iter, 0, addrStr, 1, lastStr, 2, curStr, -1); - gtk_tree_store_append( ram_match_store, &ram_match_iter, NULL); // aquire iter return 1; } @@ -2391,19 +2392,22 @@ static void showRamWatchResults(int reset) char addrStr[32], valStr1[16], valStr2[16]; ramWatch_t *rw; - if ( gtk_tree_model_get_iter_first( GTK_TREE_MODEL(ram_watch_store), &iter ) ) + if ( !reset ) { - size_t treeSize = 1; + if ( gtk_tree_model_get_iter_first( GTK_TREE_MODEL(ram_watch_store), &iter ) ) + { + size_t treeSize = 1; - while ( gtk_tree_model_iter_next( GTK_TREE_MODEL(ram_watch_store), &iter ) ) - { - treeSize++; - } - if ( treeSize != ramWatchList.size() ) - { - reset = 1; - } - //printf(" TreeSize: %zi RamWatchList.size: %zi \n", treeSize, ramWatchList.size() ); + while ( gtk_tree_model_iter_next( GTK_TREE_MODEL(ram_watch_store), &iter ) ) + { + treeSize++; + } + if ( treeSize != ramWatchList.size() ) + { + reset = 1; + } + //printf(" TreeSize: %zi RamWatchList.size: %zi \n", treeSize, ramWatchList.size() ); + } } if ( reset ) @@ -2451,12 +2455,193 @@ static void showRamWatchResults(int reset) if ( !reset ) { - gtk_tree_model_iter_next( GTK_TREE_MODEL(ram_watch_store), &iter ); + if ( !gtk_tree_model_iter_next( GTK_TREE_MODEL(ram_watch_store), &iter ) ) + { + gtk_tree_store_append( ram_watch_store, &iter, NULL); // aquire iter + } } } } -static void openWatchFile() +static void saveWatchFile( const char *filename ) +{ + int i; + FILE *fp; + const char *c; + std::list ::iterator it; + ramWatch_t *rw; + + fp = fopen( filename, "w"); + + if ( fp == NULL ) + { + printf("Error: Failed to open file: %s\n", filename); + return; + } + + for (it=ramWatchList.ls.begin(); it!=ramWatchList.ls.end(); it++) + { + rw = *it; + + c = rw->name.c_str(); + + fprintf( fp, "0x%04x %c%i ", rw->addr, rw->type ? 'U' : 'S', rw->size); + + i=0; + fprintf( fp, "\""); + while ( c[i] ) + { + if ( c[i] == '"') + { + fprintf( fp, "\\%c", c[i]); + } + else + { + fprintf( fp, "%c", c[i]); + } + i++; + } + fprintf( fp, "\"\n"); + } + fclose(fp); + +} + +static void loadWatchFile( const char *filename ) +{ + FILE *fp; + int i, j, a, t, s, literal; + char line[512], stmp[512]; + ramWatch_t *rw; + + fp = fopen( filename, "r"); + + if ( fp == NULL ) + { + printf("Error: Failed to open file: %s\n", filename); + return; + } + + while ( fgets( line, sizeof(line)-1, fp ) > 0) + { + a = -1; t = -1; s = -1; + // Check for Comments + i=0; + while ( line[i] != 0 ) + { + if ( literal ) + { + literal = 0; + } + else + { + if ( line[i] == '#') + { + line[i] = 0; break; + } + else if ( line[i] == '\\' ) + { + literal = 1; + } + } + i++; + } + + i=0; j=0; + while ( isspace(line[i]) ) i++; + + if ( (line[i] == '0') && ( tolower(line[i+1]) == 'x') ) + { + stmp[j] = '0'; j++; i++; + stmp[j] = 'x'; j++; i++; + + while ( isxdigit(line[i]) ) + { + stmp[j] = line[i]; i++; j++; + } + } + else + { + while ( isxdigit(line[i]) ) + { + stmp[j] = line[i]; i++; j++; + } + } + stmp[j] = 0; + + if ( j == 0 ) continue; + + a = strtol( stmp, NULL, 0); + + while ( isspace(line[i]) ) i++; + + t = line[i]; i++; + s = line[i]; i++; + + if ( (t != 'U') && (t != 'S') ) + { + printf("Error: Invalid RAM Watch Byte Type: %c", t); + continue; + } + if ( !isdigit(s) ) + { + printf("Error: Invalid RAM Watch Byte Size: %c", s); + continue; + } + s = s - '0'; + + if ( (s != 1) && (s != 2) && (s != 4) ) + { + printf("Error: Invalid RAM Watch Byte Size: %i", s); + continue; + } + + while ( isspace(line[i]) ) i++; + + if ( line[i] == '"') + { + i++; j=0; + literal = 0; + while ( (line[i] != 0) ) + { + if ( literal ) + { + literal = 0; + } + else + { + if ( line[i] == '"') + { + break; + } + else if ( line[i] == '\\' ) + { + literal = 1; + } + } + if ( !literal ){ + stmp[j] = line[i]; j++; + } + i++; + } + stmp[j] = 0; + } + rw = new ramWatch_t; + + rw->addr = a; + rw->type = (t == 'U') ? 1 : 0; + rw->size = s; + rw->name.assign( stmp ); + + ramWatchList.ls.push_back(rw); + } + + fclose(fp); + + showRamWatchResults(1); +} + +static void openWatchFile( int mode ) { GtkWidget* fileChooser; GtkFileFilter* filterWch; @@ -2471,16 +2656,26 @@ static void openWatchFile() gtk_file_filter_add_pattern(filterAll, "*"); gtk_file_filter_set_name(filterAll, "All Files"); - const char* last_dir; - g_config->getOption("SDL.LastSaveStateAs", &last_dir); - - fileChooser = gtk_file_chooser_dialog_new ("Open Watch File", GTK_WINDOW(MainWindow), - GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, - GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); + //const char* last_dir; + //g_config->getOption("SDL.LastSaveStateAs", &last_dir); + + + if ( mode ) + { + fileChooser = gtk_file_chooser_dialog_new ("Save Watch File", GTK_WINDOW(MainWindow), + GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, + GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); + } + else + { + fileChooser = gtk_file_chooser_dialog_new ("Load Watch File", GTK_WINDOW(MainWindow), + GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, + GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); + } - gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fileChooser), last_dir); + //gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fileChooser), last_dir); - gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER(fileChooser), ".wch"); + //gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER(fileChooser), ".wch"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterWch); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterAll); @@ -2491,11 +2686,29 @@ static void openWatchFile() filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fileChooser)); //FCEUI_SaveState(filename); //g_config->setOption("SDL.LastSaveStateAs", filename); - g_free(filename); + if ( filename ) + { + if ( mode ) + { + saveWatchFile( filename ); + } + else + { + loadWatchFile( filename ); + } + g_free(filename); + } } gtk_widget_destroy (fileChooser); - - +} + +static void loadRamWatchCB(void) +{ + openWatchFile(0); +} +static void saveRamWatchCB(void) +{ + openWatchFile(1); } // Our menu, in the XML markup format used by GtkUIManager @@ -2511,8 +2724,8 @@ static char* menuRamWatchXml = static GtkActionEntry ramWatch_entries[] = { {"FileMenuAction", NULL, "_File"}, - {"OpenWatchFile", GTK_STOCK_OPEN, "_Open Watch", NULL, NULL, G_CALLBACK(openWatchFile)}, - {"SaveWatchFile", GTK_STOCK_SAVE_AS, "_Save Watch", NULL, NULL, G_CALLBACK(openWatchFile)}, + {"OpenWatchFile", GTK_STOCK_OPEN, "_Load Watch", NULL, NULL, G_CALLBACK(loadRamWatchCB)}, + {"SaveWatchFile", GTK_STOCK_SAVE_AS, "_Save Watch", NULL, NULL, G_CALLBACK(saveRamWatchCB)}, }; From 305e8b58e8f9611942cdfa731b64dffe84ca85a7 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Thu, 7 May 2020 23:25:33 -0400 Subject: [PATCH 018/156] Added memory write functionality to RAM watch window. --- src/drivers/sdl/gui.cpp | 205 ++++++++++++++++++++++++++++++++++++---- 1 file changed, 185 insertions(+), 20 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 768a4147..6c6813c6 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -81,6 +81,8 @@ static bool cheatWindowOpen = false; static GtkTreeStore *ram_watch_store = NULL; static gint ramWatchEvntSrcID = 0; static bool ramWatchWinOpen = false; +static int ramWatchEditRowIdx = -1; +static int ramWatchEditColIdx = -1; struct ramWatch_t { @@ -167,6 +169,22 @@ struct ramWatchList_t rw->updateMem(); } } + + ramWatch_t *getIndex(size_t idx) + { + size_t i=0; + std::list ::iterator it; + + for (it=ls.begin(); it!=ls.end(); it++) + { + if ( i == idx ) + { + return *it; + } + i++; + } + return NULL; + } }; static ramWatchList_t ramWatchList; @@ -2387,28 +2405,29 @@ static void openCheatsWindow(void) // static void showRamWatchResults(int reset) { + int row=0; std::list ::iterator it; GtkTreeIter iter; char addrStr[32], valStr1[16], valStr2[16]; ramWatch_t *rw; - if ( !reset ) - { - if ( gtk_tree_model_get_iter_first( GTK_TREE_MODEL(ram_watch_store), &iter ) ) - { - size_t treeSize = 1; + //if ( !reset ) + //{ + // if ( gtk_tree_model_get_iter_first( GTK_TREE_MODEL(ram_watch_store), &iter ) ) + // { + // size_t treeSize = 1; - while ( gtk_tree_model_iter_next( GTK_TREE_MODEL(ram_watch_store), &iter ) ) - { - treeSize++; - } - if ( treeSize != ramWatchList.size() ) - { - reset = 1; - } - //printf(" TreeSize: %zi RamWatchList.size: %zi \n", treeSize, ramWatchList.size() ); - } - } + // while ( gtk_tree_model_iter_next( GTK_TREE_MODEL(ram_watch_store), &iter ) ) + // { + // treeSize++; + // } + // if ( treeSize != ramWatchList.size() ) + // { + // reset = 1; + // } + // //printf(" TreeSize: %zi RamWatchList.size: %zi \n", treeSize, ramWatchList.size() ); + // } + //} if ( reset ) { @@ -2416,7 +2435,10 @@ static void showRamWatchResults(int reset) } else { - gtk_tree_model_get_iter_first( GTK_TREE_MODEL(ram_watch_store), &iter ); + if ( !gtk_tree_model_get_iter_first( GTK_TREE_MODEL(ram_watch_store), &iter ) ) + { + gtk_tree_store_append( ram_watch_store, &iter, NULL); // aquire iter + } } for (it=ramWatchList.ls.begin(); it!=ramWatchList.ls.end(); it++) @@ -2449,9 +2471,34 @@ static void showRamWatchResults(int reset) sprintf( valStr2, "0x%02x", rw->val.u8); } - gtk_tree_store_set(ram_watch_store, &iter, - 0, addrStr, 1, valStr1, 2, valStr2, 3, rw->name.c_str(), - -1); + if ( row != ramWatchEditRowIdx ) + { + gtk_tree_store_set(ram_watch_store, &iter, + 0, addrStr, 1, valStr1, 2, valStr2, 3, rw->name.c_str(), + -1); + } + else + { + //if ( ramWatchEditColIdx != 0 ) + //{ + // gtk_tree_store_set(ram_watch_store, &iter, 0, addrStr, -1 ); + //} + + //if ( ramWatchEditColIdx != 1 ) + //{ + // gtk_tree_store_set(ram_watch_store, &iter, 1, valStr1, -1 ); + //} + + //if ( ramWatchEditColIdx != 2 ) + //{ + // gtk_tree_store_set(ram_watch_store, &iter, 2, valStr2, -1 ); + //} + + //if ( ramWatchEditColIdx != 3 ) + //{ + // gtk_tree_store_set(ram_watch_store, &iter, 3, rw->name.c_str(), -1 ); + //} + } if ( !reset ) { @@ -2460,6 +2507,7 @@ static void showRamWatchResults(int reset) gtk_tree_store_append( ram_watch_store, &iter, NULL); // aquire iter } } + row++; } } @@ -2917,6 +2965,102 @@ static gint updateRamWatchTree( void *userData ) return 1; } +static void ramWatch_cell_edited_cb ( + GtkCellRendererText *cell, + gchar *path_string, + gchar *new_text, + gpointer user_data) +{ + ramWatch_t *rw; + //printf("Ram Watch Edited: %i:%i\n", ramWatchEditRowIdx, ramWatchEditColIdx); + + rw = ramWatchList.getIndex( ramWatchEditRowIdx ); + + switch ( (long)user_data ) + { + case 0: + rw->addr = strtol( new_text, NULL, 0 ); + break; + case 1: + case 2: + { + writefunc wfunc; + + if ( rw->size == 2 ) + { + if ( rw->type ) + { + rw->val.u16 = strtol( new_text, NULL, 0 ); + } + else + { + rw->val.i16 = strtol( new_text, NULL, 0 ); + } + wfunc = GetWriteHandler( rw->addr ); + + if ( wfunc ) + { + wfunc( (uint32)rw->addr, (uint8)(rw->val.u16 & 0x00ff) ); + } + + wfunc = GetWriteHandler( rw->addr+1 ); + + if ( wfunc ) + { + wfunc( (uint32)rw->addr+1, (uint8)( (rw->val.u16 & 0xff00) >> 8) ); + } + } + else + { + if ( rw->type ) + { + rw->val.u8 = strtol( new_text, NULL, 0 ); + } + else + { + rw->val.i8 = strtol( new_text, NULL, 0 ); + } + wfunc = GetWriteHandler( rw->addr ); + + if ( wfunc ) + { + wfunc( (uint32)rw->addr, (uint8)rw->val.u8 ); + } + } + } + break; + case 3: + rw->name.assign( new_text ); + break; + default: + + break; + } + + ramWatchEditRowIdx = -1; + ramWatchEditColIdx = -1; +} + +static void ramWatch_cell_edited_start_cb( + GtkCellRenderer *renderer, + GtkCellEditable *editable, + gchar *path, + gpointer user_data) +{ + //printf("Ram Watch Edit Start: '%s':%li\n", path, (long)user_data); + ramWatchEditRowIdx = atoi( path ); + ramWatchEditColIdx = (long)user_data; +} + +static void ramWatch_cell_edited_cancel_cb( + GtkCellRenderer *renderer, + gpointer user_data) +{ + //printf("Ram Watch Edit Cancel:%li\n", (long)user_data); + ramWatchEditRowIdx = -1; + ramWatchEditColIdx = -1; +} + void closeMemoryWatchWindow(GtkWidget* w, GdkEvent* e, gpointer p) { ramWatchWinOpen = false; @@ -2965,12 +3109,33 @@ static void openMemoryWatchWindow(void) renderer = gtk_cell_renderer_text_new(); g_object_set(renderer, "editable", TRUE, NULL); + g_signal_connect(renderer, "edited", (GCallback) ramWatch_cell_edited_cb, (gpointer)0); + g_signal_connect(renderer, "editing-started", (GCallback) ramWatch_cell_edited_start_cb, (gpointer)0); + g_signal_connect(renderer, "editing-canceled", (GCallback) ramWatch_cell_edited_cancel_cb, (gpointer)0); column = gtk_tree_view_column_new_with_attributes("Addr", renderer, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); + + renderer = gtk_cell_renderer_text_new(); + g_object_set(renderer, "editable", TRUE, NULL); + g_signal_connect(renderer, "edited", (GCallback) ramWatch_cell_edited_cb, (gpointer)1); + g_signal_connect(renderer, "editing-started", (GCallback) ramWatch_cell_edited_start_cb, (gpointer)1); + g_signal_connect(renderer, "editing-canceled", (GCallback) ramWatch_cell_edited_cancel_cb, (gpointer)1); column = gtk_tree_view_column_new_with_attributes("Value Dec", renderer, "text", 1, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); + + renderer = gtk_cell_renderer_text_new(); + g_object_set(renderer, "editable", TRUE, NULL); + g_signal_connect(renderer, "edited", (GCallback) ramWatch_cell_edited_cb, (gpointer)2); + g_signal_connect(renderer, "editing-started", (GCallback) ramWatch_cell_edited_start_cb, (gpointer)2); + g_signal_connect(renderer, "editing-canceled", (GCallback) ramWatch_cell_edited_cancel_cb, (gpointer)2); column = gtk_tree_view_column_new_with_attributes("Value Hex", renderer, "text", 2, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); + + renderer = gtk_cell_renderer_text_new(); + g_object_set(renderer, "editable", TRUE, NULL); + g_signal_connect(renderer, "edited", (GCallback) ramWatch_cell_edited_cb, (gpointer)3); + g_signal_connect(renderer, "editing-started", (GCallback) ramWatch_cell_edited_start_cb, (gpointer)3); + g_signal_connect(renderer, "editing-canceled", (GCallback) ramWatch_cell_edited_cancel_cb, (gpointer)3); column = gtk_tree_view_column_new_with_attributes("Notes", renderer, "text", 3, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); From e39c8ab6df40cf68c59d607dbb14407cbba5e2b3 Mon Sep 17 00:00:00 2001 From: mjbudd77 <44712797+mjbudd77@users.noreply.github.com> Date: Fri, 8 May 2020 07:53:39 -0400 Subject: [PATCH 019/156] Set up CI with Azure Pipelines [skip ci] --- azure-pipelines.yml | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 azure-pipelines.yml diff --git a/azure-pipelines.yml b/azure-pipelines.yml new file mode 100644 index 00000000..38d9a371 --- /dev/null +++ b/azure-pipelines.yml @@ -0,0 +1,15 @@ +# C/C++ with GCC +# Build your C/C++ project with GCC using make. +# Add steps that publish test results, save build artifacts, deploy, and more: +# https://docs.microsoft.com/azure/devops/pipelines/apps/c-cpp/gcc + +trigger: +- master + +pool: + vmImage: 'ubuntu-latest' + +steps: +- script: | + make + displayName: 'make' From 2bf8a4d943d5e78c4bf91940106bb76e0c40ac4e Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Fri, 8 May 2020 07:58:35 -0400 Subject: [PATCH 020/156] Pipeline update. --- azure-pipelines.yml | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/azure-pipelines.yml b/azure-pipelines.yml index 38d9a371..fe2ace3f 100644 --- a/azure-pipelines.yml +++ b/azure-pipelines.yml @@ -5,11 +5,12 @@ trigger: - master +- linux-cheats pool: vmImage: 'ubuntu-latest' steps: - script: | - make - displayName: 'make' + which scons-3 + displayName: 'Build' From 94973b0078cffc50084633959e90378946d7495d Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Fri, 8 May 2020 08:14:39 -0400 Subject: [PATCH 021/156] Removed azure-pipeline comfig file that does not work. --- azure-pipelines.yml | 15 --------------- 1 file changed, 15 deletions(-) delete mode 100644 azure-pipelines.yml diff --git a/azure-pipelines.yml b/azure-pipelines.yml deleted file mode 100644 index 38d9a371..00000000 --- a/azure-pipelines.yml +++ /dev/null @@ -1,15 +0,0 @@ -# C/C++ with GCC -# Build your C/C++ project with GCC using make. -# Add steps that publish test results, save build artifacts, deploy, and more: -# https://docs.microsoft.com/azure/devops/pipelines/apps/c-cpp/gcc - -trigger: -- master - -pool: - vmImage: 'ubuntu-latest' - -steps: -- script: | - make - displayName: 'make' From 292a1de39bc35e148c9cb3dd31ce44cb16bd7982 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Fri, 8 May 2020 22:07:19 -0400 Subject: [PATCH 022/156] Added azure pipeline configuration file. Runs a build in an Ubuntu Linux 18.04LTS --- azure-pipelines.yml | 16 ++++++++++++++++ azure/linux_build.sh | 23 +++++++++++++++++++++++ 2 files changed, 39 insertions(+) create mode 100644 azure-pipelines.yml create mode 100755 azure/linux_build.sh diff --git a/azure-pipelines.yml b/azure-pipelines.yml new file mode 100644 index 00000000..e0acee95 --- /dev/null +++ b/azure-pipelines.yml @@ -0,0 +1,16 @@ +# C/C++ with GCC +# Build your C/C++ project with GCC using make. +# Add steps that publish test results, save build artifacts, deploy, and more: +# https://docs.microsoft.com/azure/devops/pipelines/apps/c-cpp/gcc + +trigger: +- master +- development + +pool: + vmImage: 'ubuntu-latest' + +steps: +- script: | + ./azure/linux_build.sh + displayName: 'make' diff --git a/azure/linux_build.sh b/azure/linux_build.sh new file mode 100755 index 00000000..3b6bba04 --- /dev/null +++ b/azure/linux_build.sh @@ -0,0 +1,23 @@ +#!/bin/bash + +id +pwd +cat /etc/os-release + +gcc --version +python2 --version +python3 --version + +sudo apt-get install lua5.1-dev +sudo apt-get install libsdl1.2-dev +sudo apt-get install libsdl2-dev +sudo apt-get install libminizip-dev +#sudo apt-get install libxml2-dev +#sudo apt-get install libgtk2.0-dev +sudo apt-get install libgtk-3-dev +sudo apt-get install libgtksourceview-3.0-dev +sudo apt-get install scons + +scons GTK3=1 SYSTEM_LUA=1 SYSTEM_MINIZIP=1 CREATE_AVI=1 + +ls -ltr ./bin/* From 10d57762b018b069686339020248f43ff3357bfb Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Fri, 8 May 2020 22:11:55 -0400 Subject: [PATCH 023/156] Force GTK3 usage as default over GTK2... its time to move on. --- SConstruct | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/SConstruct b/SConstruct index c2e6b021..1c6a3246 100644 --- a/SConstruct +++ b/SConstruct @@ -19,8 +19,8 @@ opts.AddVariables( BoolVariable('FRAMESKIP', 'Enable frameskipping', 1), BoolVariable('OPENGL', 'Enable OpenGL support', 1), BoolVariable('LUA', 'Enable Lua support', 1), - BoolVariable('GTK', 'Enable GTK2 GUI (SDL only)', 1), - BoolVariable('GTK3', 'Enable GTK3 GUI (SDL only)', 0), + BoolVariable('GTK', 'Enable GTK2 GUI (SDL only)', 0), + BoolVariable('GTK3', 'Enable GTK3 GUI (SDL only)', 1), BoolVariable('NEWPPU', 'Enable new PPU core', 1), BoolVariable('CREATE_AVI', 'Enable avi creation support (SDL only)', 1), BoolVariable('LOGO', 'Enable a logoscreen when creating avis (SDL only)', 1), From 70a804e90f24b043d8ce8eafd792e9bc61a21f10 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Fri, 8 May 2020 23:30:31 -0400 Subject: [PATCH 024/156] Fixed a few code errors identified by cppcheck static code analyzer. Fixed incorrect error handling of realloc function to prevent memory leak. Fixed a few uninitialized local stack variables. Changed (1 << 31) to (1u << 31) to fix error stating that a signed 32 bit integer shifted by 31 bits can result in undefined behavior. --- src/emufile.cpp | 6 +++--- src/file.cpp | 14 +++++++++----- src/utils/endian.cpp | 6 +++--- src/utils/general.cpp | 6 +++--- 4 files changed, 18 insertions(+), 14 deletions(-) diff --git a/src/emufile.cpp b/src/emufile.cpp index 162e8df0..e0e83115 100644 --- a/src/emufile.cpp +++ b/src/emufile.cpp @@ -133,7 +133,7 @@ void EMUFILE::write64le(u64 val) size_t EMUFILE::read64le(u64 *Bufo) { - u64 buf; + u64 buf=0; if(fread((char*)&buf,8) != 8) return 0; #ifndef LOCAL_BE @@ -174,7 +174,7 @@ size_t EMUFILE::read32le(s32* Bufo) { return read32le((u32*)Bufo); } size_t EMUFILE::read32le(u32* Bufo) { - u32 buf; + u32 buf=0; if(fread(&buf,4)<4) return 0; #ifndef LOCAL_BE @@ -213,7 +213,7 @@ size_t EMUFILE::read16le(s16* Bufo) { return read16le((u16*)Bufo); } size_t EMUFILE::read16le(u16* Bufo) { - u32 buf; + u32 buf=0; if(fread(&buf,2)<2) return 0; #ifndef LOCAL_BE diff --git a/src/file.cpp b/src/file.cpp index 9860d87e..dfbba02e 100644 --- a/src/file.cpp +++ b/src/file.cpp @@ -104,12 +104,14 @@ void ApplyIPS(FILE *ips, FCEUFILE* fp) if((offset+size)>(uint32)fp->size) { // Probably a little slow. - buf=(char *)realloc(buf,offset+size); - if(!buf) + char *newbuf=(char *)realloc(buf,offset+size); + if(!newbuf) { + free(buf); buf=NULL; FCEU_printf(" Oops. IPS patch %d(type RLE) goes beyond end of file. Could not allocate memory.\n",count); goto end; } + buf=newbuf; memset(buf+fp->size,0,offset+size-fp->size); fp->size=offset+size; } @@ -127,12 +129,14 @@ void ApplyIPS(FILE *ips, FCEUFILE* fp) if((offset+size)>(uint32)fp->size) { // Probably a little slow. - buf=(char *)realloc(buf,offset+size); - if(!buf) + char *newbuf=(char *)realloc(buf,offset+size); + if(!newbuf) { + free(buf); buf=NULL; FCEU_printf(" Oops. IPS patch %d(type normal) goes beyond end of file. Could not allocate memory.\n",count); goto end; } + buf=newbuf; memset(buf+fp->size,0,offset+size-fp->size); } fread(buf+offset,1,size,ips); @@ -475,9 +479,9 @@ void FCEUI_SetDirOverride(int which, char *n) va_list ap; int ret; - va_start(ap,fmt); if(!(*strp=(char*)FCEU_dmalloc(2048))) //mbg merge 7/17/06 cast to char* return(0); + va_start(ap,fmt); ret=vsnprintf(*strp,2048,fmt,ap); va_end(ap); return(ret); diff --git a/src/utils/endian.cpp b/src/utils/endian.cpp index 71732ff1..56704d41 100644 --- a/src/utils/endian.cpp +++ b/src/utils/endian.cpp @@ -275,7 +275,7 @@ int write64le(uint64 b, EMUFILE* os) int read32le(uint32 *Bufo, EMUFILE *fp) { - uint32 buf; + uint32 buf=0; if(fp->_fread(&buf,4)<4) return 0; #ifdef LOCAL_LE @@ -288,7 +288,7 @@ int read32le(uint32 *Bufo, EMUFILE *fp) int read16le(u16 *Bufo, EMUFILE *is) { - u16 buf; + u16 buf=0; if(is->_fread((char*)&buf,2) != 2) return 0; #ifdef LOCAL_LE @@ -301,7 +301,7 @@ int read16le(u16 *Bufo, EMUFILE *is) int read64le(uint64 *Bufo, EMUFILE *is) { - uint64 buf; + uint64 buf=0; if(is->_fread((char*)&buf,8) != 8) return 0; #ifdef LOCAL_LE diff --git a/src/utils/general.cpp b/src/utils/general.cpp index c84d9e70..9f49a19b 100644 --- a/src/utils/general.cpp +++ b/src/utils/general.cpp @@ -28,10 +28,10 @@ uint32 uppow2(uint32 n) int x; for(x=31;x>=0;x--) - if(n&(1< Date: Sat, 9 May 2020 10:36:55 -0400 Subject: [PATCH 025/156] Changed memory tree views to use monospace and have vertical dividers for columns. --- src/drivers/sdl/gui.cpp | 33 +++++++++++++++++++++++---------- 1 file changed, 23 insertions(+), 10 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 6c6813c6..20507f49 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -1524,9 +1524,9 @@ static int ShowCheatSearchResultsCallB(uint32 a, uint8 last, uint8 current) { char addrStr[32], lastStr[32], curStr[32]; - sprintf( addrStr, "0x%04x", a ); - sprintf( lastStr, "0x%02x", last ); - sprintf( curStr, "| 0x%02x", current ); + sprintf( addrStr, "0x%04X ", a ); + sprintf( lastStr, " 0x%02X ", last ); + sprintf( curStr, " 0x%02X ", current ); gtk_tree_store_append( ram_match_store, &ram_match_iter, NULL); // aquire iter @@ -1698,13 +1698,13 @@ static int activeCheatListCB(char *name, uint32 a, uint8 v, int c, int s, int ty gtk_tree_store_append( actv_cheats_store, &actv_cheats_iter, NULL); // aquire iter } - sprintf( addrStr, "0x%04x", a ); - sprintf( valStr, "0x%02x", v ); + sprintf( addrStr, "0x%04X ", a ); + sprintf( valStr, " 0x%02X ", v ); if ( c >= 0 ){ - sprintf( cmpStr, "0x%02x", c ); + sprintf( cmpStr, " 0x%02X ", c ); } else { - strcpy( cmpStr, "0xff"); + strcpy( cmpStr, " 0xFF "); } gtk_tree_store_set(actv_cheats_store, &actv_cheats_iter, @@ -2110,6 +2110,8 @@ static void openCheatsWindow(void) GtkCellRenderer *chkbox_renderer; GtkTreeViewColumn* column; + gtk_tree_view_set_grid_lines( GTK_TREE_VIEW(tree), GTK_TREE_VIEW_GRID_LINES_VERTICAL ); + renderer = gtk_cell_renderer_text_new(); g_object_set(renderer, "editable", TRUE, NULL); g_signal_connect(renderer, "edited", (GCallback) cheat_cell_edited_cb, NULL); @@ -2120,18 +2122,21 @@ static void openCheatsWindow(void) gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); renderer = gtk_cell_renderer_text_new(); + g_object_set(renderer, "family", "MonoSpace", NULL); g_object_set(renderer, "editable", TRUE, NULL); g_signal_connect(renderer, "edited", (GCallback) cheat_cell_edited_cb, (gpointer)1); column = gtk_tree_view_column_new_with_attributes("Addr", renderer, "text", 1, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); renderer = gtk_cell_renderer_text_new(); + g_object_set(renderer, "family", "MonoSpace", NULL); g_object_set(renderer, "editable", TRUE, NULL); g_signal_connect(renderer, "edited", (GCallback) cheat_cell_edited_cb, (gpointer)2); column = gtk_tree_view_column_new_with_attributes("Val", renderer, "text", 2, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); renderer = gtk_cell_renderer_text_new(); + g_object_set(renderer, "family", "MonoSpace", NULL); g_object_set(renderer, "editable", TRUE, NULL); g_signal_connect(renderer, "edited", (GCallback) cheat_cell_edited_cb, (gpointer)3); column = gtk_tree_view_column_new_with_attributes("Cmp", renderer, "text", 3, NULL); @@ -2370,7 +2375,10 @@ static void openCheatsWindow(void) tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(ram_match_store)); + gtk_tree_view_set_grid_lines( GTK_TREE_VIEW(tree), GTK_TREE_VIEW_GRID_LINES_VERTICAL ); + renderer = gtk_cell_renderer_text_new(); + g_object_set(renderer, "family", "MonoSpace", NULL); column = gtk_tree_view_column_new_with_attributes("Addr", renderer, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); column = gtk_tree_view_column_new_with_attributes("Last", renderer, "text", 1, NULL); @@ -2444,7 +2452,7 @@ static void showRamWatchResults(int reset) for (it=ramWatchList.ls.begin(); it!=ramWatchList.ls.end(); it++) { rw = *it; - sprintf( addrStr, "0x%04x", rw->addr ); + sprintf( addrStr, "0x%04X", rw->addr ); if ( reset ){ gtk_tree_store_append( ram_watch_store, &iter, NULL); // aquire iter @@ -2459,7 +2467,7 @@ static void showRamWatchResults(int reset) } else { sprintf( valStr1, "%6i", rw->val.i16); } - sprintf( valStr2, "0x%04x", rw->val.u16); + sprintf( valStr2, "0x%04X", rw->val.u16); } else { @@ -2468,7 +2476,7 @@ static void showRamWatchResults(int reset) } else { sprintf( valStr1, "%6i", rw->val.i8); } - sprintf( valStr2, "0x%02x", rw->val.u8); + sprintf( valStr2, "0x%02X", rw->val.u8); } if ( row != ramWatchEditRowIdx ) @@ -3104,10 +3112,13 @@ static void openMemoryWatchWindow(void) tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(ram_watch_store)); + gtk_tree_view_set_grid_lines( GTK_TREE_VIEW(tree), GTK_TREE_VIEW_GRID_LINES_VERTICAL ); + GtkCellRenderer *renderer; GtkTreeViewColumn* column; renderer = gtk_cell_renderer_text_new(); + g_object_set(renderer, "family", "MonoSpace", NULL); g_object_set(renderer, "editable", TRUE, NULL); g_signal_connect(renderer, "edited", (GCallback) ramWatch_cell_edited_cb, (gpointer)0); g_signal_connect(renderer, "editing-started", (GCallback) ramWatch_cell_edited_start_cb, (gpointer)0); @@ -3116,6 +3127,7 @@ static void openMemoryWatchWindow(void) gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); renderer = gtk_cell_renderer_text_new(); + g_object_set(renderer, "family", "MonoSpace", NULL); g_object_set(renderer, "editable", TRUE, NULL); g_signal_connect(renderer, "edited", (GCallback) ramWatch_cell_edited_cb, (gpointer)1); g_signal_connect(renderer, "editing-started", (GCallback) ramWatch_cell_edited_start_cb, (gpointer)1); @@ -3124,6 +3136,7 @@ static void openMemoryWatchWindow(void) gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); renderer = gtk_cell_renderer_text_new(); + g_object_set(renderer, "family", "MonoSpace", NULL); g_object_set(renderer, "editable", TRUE, NULL); g_signal_connect(renderer, "edited", (GCallback) ramWatch_cell_edited_cb, (gpointer)2); g_signal_connect(renderer, "editing-started", (GCallback) ramWatch_cell_edited_start_cb, (gpointer)2); From 3231589d25efda7c73b5c2cac70b3016296261ef Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 9 May 2020 16:42:34 -0400 Subject: [PATCH 026/156] Changed out depricated gtk_hbox_new and gtk_vbox_new in favor of gtk_box_new --- src/drivers/sdl/gui.cpp | 82 ++++++++++++++++++++--------------------- 1 file changed, 41 insertions(+), 41 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 20507f49..f3c91c53 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -441,7 +441,7 @@ void openPaletteConfig() vbox = gtk_dialog_get_content_area(GTK_DIALOG(win)); paletteFrame = gtk_frame_new("Custom palette: "); - paletteHbox = gtk_hbox_new(FALSE, 5); + paletteHbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); gtk_container_set_border_width(GTK_CONTAINER(paletteHbox), 5); gtk_container_add(GTK_CONTAINER(paletteFrame), paletteHbox); paletteButton = gtk_button_new_from_stock(GTK_STOCK_OPEN); @@ -471,7 +471,7 @@ void openPaletteConfig() // color / tint / hue sliders slidersFrame = gtk_frame_new("NTSC palette controls"); - slidersVbox = gtk_vbox_new(FALSE, 2); + slidersVbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 2); tintFrame = gtk_frame_new("Tint"); tintHscale = gtk_hscale_new_with_range(0, 128, 1); gtk_container_add(GTK_CONTAINER(tintFrame), tintHscale); @@ -563,7 +563,7 @@ void openNetworkConfig() gtk_window_set_icon_name(GTK_WINDOW(win), GTK_STOCK_NETWORK); box = gtk_dialog_get_content_area(GTK_DIALOG(win)); - userBox = gtk_hbox_new(FALSE, 3); + userBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); userLbl = gtk_label_new("Username:"); userEntry = gtk_entry_new(); std::string s; @@ -573,15 +573,15 @@ void openNetworkConfig() g_signal_connect(userEntry, "changed", G_CALLBACK(setUsername), NULL); frame = gtk_frame_new("Network options"); - vbox = gtk_vbox_new(FALSE, 5); - ipBox = gtk_hbox_new(FALSE, 5); + vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); + ipBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); ipLbl = gtk_label_new("Server IP:"); ipEntry = gtk_entry_new(); - portBox = gtk_hbox_new(FALSE, 5); + portBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); portLbl = gtk_label_new("Server port:"); portSpin = gtk_spin_button_new_with_range(0, 999999, 1); //localPlayersCbo = gtk_combo_box_new_text(); - pwBox = gtk_hbox_new(FALSE, 3); + pwBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); pwLbl = gtk_label_new("Server password:"); pwEntry = gtk_entry_new(); @@ -806,7 +806,7 @@ void openGamepadConfig() vbox = gtk_dialog_get_content_area(GTK_DIALOG(win)); gtk_box_set_homogeneous(GTK_BOX(vbox), FALSE); - hboxPadNo = gtk_hbox_new(FALSE, 0); + hboxPadNo = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); padNoLabel = gtk_label_new("Port:"); //configNoLabel = gtk_label_new("Config Number:"); fourScoreChk = gtk_check_button_new_with_label("Enable Four Score"); @@ -1090,7 +1090,7 @@ void openVideoConfig() lbl = gtk_label_new("Video options will not take\neffect until the emulator is restarted."); // scalar widgets - hbox1 = gtk_hbox_new(FALSE, 3); + hbox1 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); scalerLbl = gtk_label_new("Special Scaler: "); scalerCombo = gtk_combo_box_text_new(); // -Video Modes Tag- @@ -1131,7 +1131,7 @@ void openVideoConfig() #endif // Region (NTSC/PAL/Dendy) - palHbox = gtk_hbox_new(FALSE, 3); + palHbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); palLbl = gtk_label_new("Region: "); palCombo = gtk_combo_box_text_new(); // -Video Modes Tag- @@ -1168,10 +1168,10 @@ void openVideoConfig() setCheckbox(clipSidesChk, "SDL.ClipSides"); // xscale / yscale - xscaleHbox = gtk_hbox_new(FALSE, 5); + xscaleHbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); xscaleLbl = gtk_label_new("X scaling factor"); xscaleSpin = gtk_spin_button_new_with_range(1.0, 40.0, .1); - yscaleHbox = gtk_hbox_new(FALSE, 5); + yscaleHbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); yscaleLbl = gtk_label_new("Y scaling factor"); yscaleSpin = gtk_spin_button_new_with_range(1.0, 40.0, .1); @@ -1289,8 +1289,8 @@ void openSoundConfig() GTK_RESPONSE_OK, NULL); gtk_window_set_icon_name(GTK_WINDOW(win), "audio-x-generic"); - main_hbox = gtk_hbox_new(FALSE, 15); - vbox = gtk_vbox_new(FALSE, 5); + main_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 15); + vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); // sound enable check soundChk = gtk_check_button_new_with_label("Enable sound"); @@ -1303,7 +1303,7 @@ void openSoundConfig() setCheckbox(lowpassChk, "SDL.Sound.LowPass"); // sound quality combo box - hbox1 = gtk_hbox_new(FALSE, 3); + hbox1 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); qualityCombo = gtk_combo_box_text_new(); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(qualityCombo), "Low"); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(qualityCombo), "High"); @@ -1322,7 +1322,7 @@ void openSoundConfig() gtk_box_pack_start(GTK_BOX(hbox1), qualityCombo, FALSE, FALSE, 5); // sound rate widgets - hbox2 = gtk_hbox_new(FALSE, 3); + hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); rateCombo = gtk_combo_box_text_new(); const int rates[5] = {11025, 22050, 44100, 48000, 96000}; @@ -1364,7 +1364,7 @@ void openSoundConfig() // mixer mixerFrame = gtk_frame_new("Mixer:"); - mixerHbox = gtk_hbox_new(TRUE, 5); + mixerHbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); for(long int i=0; i<6; i++) { mixers[i] = gtk_vscale_new_with_range(0, 256, 1); @@ -2097,8 +2097,8 @@ static void openCheatsWindow(void) NULL); gtk_window_set_default_size(GTK_WINDOW(win), 600, 600); - main_hbox = gtk_hbox_new(FALSE, 2); - vbox = gtk_vbox_new(FALSE, 5); + main_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); + vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); frame = gtk_frame_new("Active Cheats"); actv_cheats_store = gtk_tree_store_new( 5, G_TYPE_BOOLEAN, @@ -2159,7 +2159,7 @@ static void openCheatsWindow(void) gtk_container_add(GTK_CONTAINER(scroll), tree); gtk_box_pack_start(GTK_BOX(vbox), scroll, TRUE, TRUE, 1); - hbox = gtk_hbox_new(FALSE, 2); + hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); label = gtk_label_new("Name:"); txt_entry = gtk_entry_new(); @@ -2173,7 +2173,7 @@ static void openCheatsWindow(void) gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 1); - hbox = gtk_hbox_new(FALSE, 6); + hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new("Addr:"); txt_entry = gtk_entry_new(); gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 4 ); @@ -2215,7 +2215,7 @@ static void openCheatsWindow(void) gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 1); - hbox = gtk_hbox_new(FALSE, 3); + hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); button = gtk_button_new_with_label("Add"); gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, FALSE, 1); @@ -2236,7 +2236,7 @@ static void openCheatsWindow(void) gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 1); - hbox = gtk_hbox_new(FALSE, 1); + hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1); button = gtk_button_new_with_label("Add from CHT file..."); gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, FALSE, 1); g_signal_connect( button, "clicked", @@ -2248,8 +2248,8 @@ static void openCheatsWindow(void) // gtk_box_pack_start(GTK_BOX(main_hbox), frame, TRUE, TRUE, 1); - vbox = gtk_vbox_new(FALSE, 5); - hbox = gtk_hbox_new(FALSE, 1); + vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); + hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1); button = gtk_button_new_with_label("Reset"); g_signal_connect( button, "clicked", G_CALLBACK (cheatSearchReset), (gpointer) NULL ); @@ -2257,7 +2257,7 @@ static void openCheatsWindow(void) gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5); - hbox = gtk_hbox_new(FALSE, 3); + hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); button = gtk_button_new_with_label("Known Value:"); g_signal_connect( button, "clicked", G_CALLBACK (cheatSearchKnown), (gpointer) NULL ); @@ -2283,10 +2283,10 @@ static void openCheatsWindow(void) g_signal_connect( button, "clicked", G_CALLBACK (pauseDuringCheatWinActvCB), (gpointer) NULL ); - prev_cmp_vbox = gtk_vbox_new(FALSE, 4); + prev_cmp_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4); gtk_container_add(GTK_CONTAINER(frame), prev_cmp_vbox); - hbox = gtk_hbox_new(FALSE, 1); + hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1); align = gtk_alignment_new( 0, 0, 0.5, 0 ); button = gtk_button_new_with_label("Equal"); gtk_container_add( GTK_CONTAINER(align), button ); @@ -2295,7 +2295,7 @@ static void openCheatsWindow(void) g_signal_connect( button, "clicked", G_CALLBACK (cheatSearchEqual), (gpointer) NULL ); - hbox = gtk_hbox_new(FALSE, 4); + hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); align = gtk_alignment_new( 0, 0, 1, 0 ); button = gtk_button_new_with_label("Not Equal"); gtk_container_add( GTK_CONTAINER(align), button ); @@ -2317,7 +2317,7 @@ static void openCheatsWindow(void) gtk_box_pack_start(GTK_BOX(prev_cmp_vbox), hbox, FALSE, FALSE, 5); - hbox = gtk_hbox_new(FALSE, 4); + hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); align = gtk_alignment_new( 0, 0, 1, 0 ); button = gtk_button_new_with_label("Greater Than"); gtk_container_add( GTK_CONTAINER(align), button ); @@ -2339,7 +2339,7 @@ static void openCheatsWindow(void) gtk_box_pack_start(GTK_BOX(prev_cmp_vbox), hbox, FALSE, FALSE, 5); - hbox = gtk_hbox_new(FALSE, 4); + hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); align = gtk_alignment_new( 0, 0, 1, 0 ); button = gtk_button_new_with_label("Less Than"); gtk_container_add( GTK_CONTAINER(align), button ); @@ -2361,15 +2361,15 @@ static void openCheatsWindow(void) gtk_box_pack_start(GTK_BOX(prev_cmp_vbox), hbox, FALSE, FALSE, 1); - hbox = gtk_hbox_new(FALSE, 2); + hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 1); frame = gtk_frame_new("Cheat Search"); gtk_container_add(GTK_CONTAINER(frame), hbox); gtk_box_pack_start(GTK_BOX(main_hbox), frame, TRUE, TRUE, 5); - vbox = gtk_vbox_new(FALSE, 5); - //hbox = gtk_hbox_new(FALSE, 1); + vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); + //hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1); ram_match_store = gtk_tree_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); @@ -2844,7 +2844,7 @@ static int openRamWatchEntryDialog( char *name, int *addr, int *type, int *size NULL); gtk_window_set_default_size(GTK_WINDOW(win), 400, 200); - vbox = gtk_vbox_new(FALSE, 6); + vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 6); label = gtk_label_new("Name:"); txt_entry_name = gtk_entry_new(); @@ -2856,7 +2856,7 @@ static int openRamWatchEntryDialog( char *name, int *addr, int *type, int *size gtk_box_pack_start (GTK_BOX(vbox), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(vbox), txt_entry_name, FALSE, TRUE, 0); - hbox = gtk_hbox_new(FALSE, 2); + hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); label = gtk_label_new("Hex Address:"); txt_entry_addr = gtk_entry_new(); @@ -2875,7 +2875,7 @@ static int openRamWatchEntryDialog( char *name, int *addr, int *type, int *size chkbox = gtk_check_button_new_with_label("Value is Unsigned"); gtk_box_pack_start (GTK_BOX(vbox), chkbox, FALSE, FALSE, 0); - hbox = gtk_hbox_new(FALSE, 4); + hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); label = gtk_label_new("Size in Bytes:"); button1 = gtk_radio_button_new_with_label (NULL, "1"); //gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); @@ -3100,13 +3100,13 @@ static void openMemoryWatchWindow(void) NULL); gtk_window_set_default_size(GTK_WINDOW(win), 600, 600); - main_vbox = gtk_vbox_new(FALSE, 1); + main_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 1); menubar = CreateRamWatchMenubar(win); gtk_box_pack_start (GTK_BOX(main_vbox), menubar, FALSE, TRUE, 0); - hbox = gtk_hbox_new(FALSE,2); + hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL,2); ram_watch_store = gtk_tree_store_new( 4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); @@ -3167,7 +3167,7 @@ static void openMemoryWatchWindow(void) ramWatchEvntSrcID = g_timeout_add( 100, updateRamWatchTree, NULL ); } - vbox = gtk_vbox_new(FALSE, 3); + vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 3); button = gtk_button_new_with_label("Edit"); gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 5); @@ -4331,7 +4331,7 @@ int InitGTKSubsystem(int argc, char** argv) gtk_window_set_default_icon(icon); gtk_window_set_icon(GTK_WINDOW(MainWindow), icon); - vbox = gtk_vbox_new(FALSE, 0); + vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_container_add(GTK_CONTAINER(MainWindow), vbox); Menubar = CreateMenubar(MainWindow); From 7610dea7fb67cc0eb7bdbe03a1b7edb9145c5695 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 9 May 2020 20:35:15 -0400 Subject: [PATCH 027/156] Removed deprecated UI manager from the ram watch menu. Ram watch menu is now created by raw gtk functions. --- src/drivers/sdl/gui.cpp | 81 ++++++++++++++--------------------------- 1 file changed, 28 insertions(+), 53 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index f3c91c53..631b980b 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -2758,70 +2758,45 @@ static void openWatchFile( int mode ) gtk_widget_destroy (fileChooser); } -static void loadRamWatchCB(void) +static void loadRamWatchCB( GtkMenuItem *menuitem, + gpointer user_data) { openWatchFile(0); } -static void saveRamWatchCB(void) +static void saveRamWatchCB( GtkMenuItem *menuitem, + gpointer user_data) { openWatchFile(1); } -// Our menu, in the XML markup format used by GtkUIManager -static char* menuRamWatchXml = - "" - " " - " " - " " - " " - " " - " " - ""; - -static GtkActionEntry ramWatch_entries[] = { - {"FileMenuAction", NULL, "_File"}, - {"OpenWatchFile", GTK_STOCK_OPEN, "_Load Watch", NULL, NULL, G_CALLBACK(loadRamWatchCB)}, - {"SaveWatchFile", GTK_STOCK_SAVE_AS, "_Save Watch", NULL, NULL, G_CALLBACK(saveRamWatchCB)}, -}; - - static GtkWidget* CreateRamWatchMenubar( GtkWidget* window) { - GtkUIManager *ui_manager; - GtkActionGroup *action_group; - GtkAccelGroup* accel_group; - GError *error = NULL; - //GtkAction* state; + GtkWidget *menubar, *menu, *item; - /* Make an UIManager (which makes a menubar). */ - ui_manager = gtk_ui_manager_new (); - - /* Add the menu items to the UIManager as a GtkActionGroup. */ - action_group = gtk_action_group_new ("MenubarActions"); - gtk_action_group_add_actions (action_group, ramWatch_entries, G_N_ELEMENTS (ramWatch_entries), NULL); - //gtk_action_group_add_toggle_actions (action_group, toggle_entries, G_N_ELEMENTS (toggle_entries), NULL); - //gtk_action_group_add_radio_actions (action_group, radio_entries, G_N_ELEMENTS (radio_entries), 0, G_CALLBACK(changeState), NULL); - gtk_ui_manager_insert_action_group (ui_manager, action_group, 0); - - /* Read the menu layout from the XML markup. */ - gtk_ui_manager_add_ui_from_string (ui_manager, menuRamWatchXml, -1, &error); - if (error) - { - fprintf (stderr, "Unable to create menu bar: %s\n", error->message); - g_error_free (error); - } - - /* Attach the new accelerator group to the window. */ - accel_group = gtk_ui_manager_get_accel_group (ui_manager); - gtk_window_add_accel_group (GTK_WINDOW (window), accel_group); - - /* Get an action that can be used to change the active state slot selection. */ - //state = gtk_action_group_get_action (action_group, "State0Action"); - //if (state && GTK_IS_RADIO_ACTION (state)) - // stateSlot = GTK_RADIO_ACTION (state); + menubar = gtk_menu_bar_new(); - /* Finally, return the actual menu bar created by the UIManager. */ - return gtk_ui_manager_get_widget (ui_manager, "/Menubar"); + item = gtk_menu_item_new_with_label("File"); + + gtk_menu_shell_append( GTK_MENU_SHELL(menubar), item ); + + menu = gtk_menu_new(); + + gtk_menu_item_set_submenu( GTK_MENU_ITEM(item), menu ); + + item = gtk_menu_item_new_with_label("Load Watch"); + + g_signal_connect( item, "activate", G_CALLBACK(loadRamWatchCB), NULL); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + item = gtk_menu_item_new_with_label("Save Watch"); + + g_signal_connect( item, "activate", G_CALLBACK(saveRamWatchCB), NULL); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + // Finally, return the actual menu bar created + return menubar; } static int openRamWatchEntryDialog( char *name, int *addr, int *type, int *size ) From 6ab46618fc3173fd0e3110f55d33e7069a449cd3 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 9 May 2020 20:47:47 -0400 Subject: [PATCH 028/156] Replaced a few more deprecated gtk function calls for their newer variants. --- src/drivers/sdl/gui.cpp | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 631b980b..467e8de6 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -473,10 +473,10 @@ void openPaletteConfig() slidersFrame = gtk_frame_new("NTSC palette controls"); slidersVbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 2); tintFrame = gtk_frame_new("Tint"); - tintHscale = gtk_hscale_new_with_range(0, 128, 1); + tintHscale = gtk_scale_new_with_range( GTK_ORIENTATION_HORIZONTAL, 0, 128, 1); gtk_container_add(GTK_CONTAINER(tintFrame), tintHscale); hueFrame = gtk_frame_new("Hue"); - hueHscale = gtk_hscale_new_with_range(0, 128, 1); + hueHscale = gtk_scale_new_with_range( GTK_ORIENTATION_HORIZONTAL, 0, 128, 1); gtk_container_add(GTK_CONTAINER(hueFrame), hueHscale); g_signal_connect(tintHscale, "button-release-event", G_CALLBACK(setTint), NULL); @@ -950,7 +950,7 @@ void resizeGtkWindow() g_config->getOption("SDL.YScale", &yscale); gtk_widget_set_size_request(evbox, 256*xscale, 224*yscale); GtkRequisition req; - gtk_widget_size_request(GTK_WIDGET(MainWindow), &req); + gtk_widget_get_preferred_size(GTK_WIDGET(MainWindow), NULL, &req); gtk_window_resize(GTK_WINDOW(MainWindow), req.width, req.height); } return; @@ -1348,7 +1348,7 @@ void openSoundConfig() gtk_box_pack_start(GTK_BOX(hbox2), rateLbl, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(hbox2), rateCombo, FALSE, FALSE, 5); - bufferHscale = gtk_hscale_new_with_range(15, 200, 2); + bufferHscale = gtk_scale_new_with_range( GTK_ORIENTATION_HORIZONTAL, 15, 200, 2); bufferLbl = gtk_label_new("Buffer size (in ms)"); // sync widget with cfg @@ -1367,7 +1367,7 @@ void openSoundConfig() mixerHbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); for(long int i=0; i<6; i++) { - mixers[i] = gtk_vscale_new_with_range(0, 256, 1); + mixers[i] = gtk_scale_new_with_range( GTK_ORIENTATION_VERTICAL, 0, 256, 1); gtk_range_set_inverted(GTK_RANGE(mixers[i]), TRUE); mixerFrames[i] = gtk_frame_new(mixerStrings[i]); gtk_container_add(GTK_CONTAINER(mixerFrames[i]), mixers[i]); @@ -4357,7 +4357,7 @@ int InitGTKSubsystem(int argc, char** argv) gtk_widget_show_all(MainWindow); GtkRequisition req; - gtk_widget_size_request(GTK_WIDGET(MainWindow), &req); + gtk_widget_get_preferred_size(GTK_WIDGET(MainWindow), NULL, &req); gtk_window_resize(GTK_WINDOW(MainWindow), req.width, req.height); gtkIsStarted = true; From b68aff598e8cdc10a2014b32169e089f95faae15 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 9 May 2020 21:00:51 -0400 Subject: [PATCH 029/156] Fixed a few more deprecated gtk function usages. --- src/drivers/sdl/gui.cpp | 5 ++--- src/drivers/sdl/sdl-video.cpp | 2 +- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 467e8de6..b877061c 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -444,12 +444,11 @@ void openPaletteConfig() paletteHbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); gtk_container_set_border_width(GTK_CONTAINER(paletteHbox), 5); gtk_container_add(GTK_CONTAINER(paletteFrame), paletteHbox); - paletteButton = gtk_button_new_from_stock(GTK_STOCK_OPEN); - gtk_button_set_label(GTK_BUTTON(paletteButton), "Open palette"); + paletteButton = gtk_button_new_with_label("Open palette"); paletteEntry = gtk_entry_new(); gtk_editable_set_editable(GTK_EDITABLE(paletteEntry), FALSE); - clearButton = gtk_button_new_from_stock(GTK_STOCK_CLEAR); + clearButton = gtk_button_new_with_label("Clear"); gtk_box_pack_start(GTK_BOX(paletteHbox), paletteButton, FALSE, FALSE, 2); gtk_box_pack_start(GTK_BOX(paletteHbox), paletteEntry, TRUE, TRUE, 5); diff --git a/src/drivers/sdl/sdl-video.cpp b/src/drivers/sdl/sdl-video.cpp index ea69ebfa..ef8d4df2 100644 --- a/src/drivers/sdl/sdl-video.cpp +++ b/src/drivers/sdl/sdl-video.cpp @@ -433,7 +433,7 @@ InitVideo(FCEUGI *gi) if(noGui == 0) { GtkRequisition req; - gtk_widget_size_request(GTK_WIDGET(MainWindow), &req); + gtk_widget_get_preferred_size(GTK_WIDGET(MainWindow), NULL, &req); gtk_window_resize(GTK_WINDOW(MainWindow), req.width, req.height); } #endif From 260b45273e33757d92c8143f64ff7962976d46b4 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sun, 10 May 2020 09:54:25 -0400 Subject: [PATCH 030/156] Swapped out deprecated gtk table in favor of gtk grid on game pad configure window. --- src/drivers/sdl/gui.cpp | 36 ++++++++++++++++++++++++++---------- 1 file changed, 26 insertions(+), 10 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index b877061c..bc8921f8 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -861,30 +861,46 @@ void openGamepadConfig() // create gamepad buttons buttonFrame = gtk_frame_new("Buttons"); gtk_label_set_use_markup(GTK_LABEL(gtk_frame_get_label_widget(GTK_FRAME(buttonFrame))), TRUE); - buttonTable = gtk_table_new(10, 3, FALSE); - gtk_table_set_col_spacings(GTK_TABLE(buttonTable), 5); + //buttonTable = gtk_table_new(10, 3, FALSE); + buttonTable = gtk_grid_new(); + //gtk_table_set_col_spacings(GTK_TABLE(buttonTable), 5); gtk_container_add(GTK_CONTAINER(buttonFrame), buttonTable); + + for (int i=0; i<3; i++) + { + gtk_grid_insert_column( GTK_GRID(buttonTable), i ); + } + gtk_grid_set_column_spacing( GTK_GRID(buttonTable), 5 ); + gtk_grid_set_column_homogeneous( GTK_GRID(buttonTable), TRUE ); + gtk_grid_set_row_spacing( GTK_GRID(buttonTable), 3 ); + for(int i=0; i<10; i++) { GtkWidget* buttonName = gtk_label_new(GamePadNames[i]); GtkWidget* mappedKey = gtk_label_new(NULL); GtkWidget* changeButton = gtk_toggle_button_new(); char strBuf[128]; - + + gtk_grid_insert_row( GTK_GRID(buttonTable), i ); + sprintf(strBuf, "%s:", GamePadNames[i]); gtk_label_set_text(GTK_LABEL(buttonName), strBuf); - gtk_misc_set_alignment(GTK_MISC(buttonName), 1.0, 0.5); + //gtk_misc_set_alignment(GTK_MISC(buttonName), 1.0, 0.5); - gtk_misc_set_alignment(GTK_MISC(mappedKey), 0.0, 0.5); + //gtk_misc_set_alignment(GTK_MISC(mappedKey), 0.0, 0.5); gtk_button_set_label(GTK_BUTTON(changeButton), "Change"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(changeButton), FALSE); - gtk_table_attach(GTK_TABLE(buttonTable), buttonName, 0, 1, i, i+1, GTK_FILL, GTK_FILL, 0, 0); - gtk_table_attach(GTK_TABLE(buttonTable), mappedKey, 1, 2, i, i+1, - (GtkAttachOptions)(GTK_EXPAND|GTK_FILL), (GtkAttachOptions)(GTK_EXPAND|GTK_FILL), 0, 0); - gtk_table_attach(GTK_TABLE(buttonTable), changeButton, 2, 3, i, i+1, - (GtkAttachOptions)0, (GtkAttachOptions)0, 0, 0); + gtk_grid_attach(GTK_GRID(buttonTable), buttonName, 0, i, 1, 1); + gtk_grid_attach(GTK_GRID(buttonTable), mappedKey, 1, i, 1, 1); + gtk_grid_attach(GTK_GRID(buttonTable), changeButton, 2, i, 1, 1); + + //gtk_table_attach(GTK_TABLE(buttonTable), buttonName, 0, 1, i, i+1, GTK_FILL, GTK_FILL, 0, 0); + //gtk_table_attach(GTK_TABLE(buttonTable), mappedKey, 1, 2, i, i+1, + // (GtkAttachOptions)(GTK_EXPAND|GTK_FILL), (GtkAttachOptions)(GTK_EXPAND|GTK_FILL), 0, 0); + //gtk_table_attach(GTK_TABLE(buttonTable), changeButton, 2, 3, i, i+1, + // (GtkAttachOptions)0, (GtkAttachOptions)0, 0, 0); g_signal_connect(changeButton, "clicked", G_CALLBACK(configGamepadButton), GINT_TO_POINTER(i)); buttonMappings[i] = mappedKey; From 5a74646bb5c3ca4a22f29f98ea98f07d7ade96f1 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sun, 10 May 2020 10:18:57 -0400 Subject: [PATCH 031/156] Removed use of deprecated gtk_alignment widgets --- src/drivers/sdl/gui.cpp | 33 +++++++++------------------------ 1 file changed, 9 insertions(+), 24 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index bc8921f8..743161f9 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -861,9 +861,7 @@ void openGamepadConfig() // create gamepad buttons buttonFrame = gtk_frame_new("Buttons"); gtk_label_set_use_markup(GTK_LABEL(gtk_frame_get_label_widget(GTK_FRAME(buttonFrame))), TRUE); - //buttonTable = gtk_table_new(10, 3, FALSE); buttonTable = gtk_grid_new(); - //gtk_table_set_col_spacings(GTK_TABLE(buttonTable), 5); gtk_container_add(GTK_CONTAINER(buttonFrame), buttonTable); for (int i=0; i<3; i++) @@ -885,9 +883,6 @@ void openGamepadConfig() sprintf(strBuf, "%s:", GamePadNames[i]); gtk_label_set_text(GTK_LABEL(buttonName), strBuf); - //gtk_misc_set_alignment(GTK_MISC(buttonName), 1.0, 0.5); - - //gtk_misc_set_alignment(GTK_MISC(mappedKey), 0.0, 0.5); gtk_button_set_label(GTK_BUTTON(changeButton), "Change"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(changeButton), FALSE); @@ -896,12 +891,6 @@ void openGamepadConfig() gtk_grid_attach(GTK_GRID(buttonTable), mappedKey, 1, i, 1, 1); gtk_grid_attach(GTK_GRID(buttonTable), changeButton, 2, i, 1, 1); - //gtk_table_attach(GTK_TABLE(buttonTable), buttonName, 0, 1, i, i+1, GTK_FILL, GTK_FILL, 0, 0); - //gtk_table_attach(GTK_TABLE(buttonTable), mappedKey, 1, 2, i, i+1, - // (GtkAttachOptions)(GTK_EXPAND|GTK_FILL), (GtkAttachOptions)(GTK_EXPAND|GTK_FILL), 0, 0); - //gtk_table_attach(GTK_TABLE(buttonTable), changeButton, 2, 3, i, i+1, - // (GtkAttachOptions)0, (GtkAttachOptions)0, 0, 0); - g_signal_connect(changeButton, "clicked", G_CALLBACK(configGamepadButton), GINT_TO_POINTER(i)); buttonMappings[i] = mappedKey; } @@ -2099,7 +2088,6 @@ static void openCheatsWindow(void) GtkWidget* button, *chkbutton; GtkWidget *tree; GtkWidget *scroll; - GtkWidget *align; if ( cheatWindowOpen ){ return; // Only allow one cheat window to be open per gui. @@ -2302,19 +2290,18 @@ static void openCheatsWindow(void) gtk_container_add(GTK_CONTAINER(frame), prev_cmp_vbox); hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1); - align = gtk_alignment_new( 0, 0, 0.5, 0 ); button = gtk_button_new_with_label("Equal"); - gtk_container_add( GTK_CONTAINER(align), button ); - gtk_box_pack_start(GTK_BOX(hbox), align, TRUE, TRUE, 5); + //gtk_widget_set_halign( button, GTK_ALIGN_BASELINE); + + gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 5); gtk_box_pack_start(GTK_BOX(prev_cmp_vbox), hbox, FALSE, FALSE, 5); g_signal_connect( button, "clicked", G_CALLBACK (cheatSearchEqual), (gpointer) NULL ); hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); - align = gtk_alignment_new( 0, 0, 1, 0 ); button = gtk_button_new_with_label("Not Equal"); - gtk_container_add( GTK_CONTAINER(align), button ); - gtk_box_pack_start(GTK_BOX(hbox), align, TRUE, TRUE, 5); + //gtk_widget_set_halign( button, GTK_ALIGN_BASELINE); + gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 5); chkbutton = gtk_check_button_new(); gtk_box_pack_start(GTK_BOX(hbox), chkbutton, FALSE, FALSE, 5); g_signal_connect( button, "clicked", @@ -2333,10 +2320,9 @@ static void openCheatsWindow(void) gtk_box_pack_start(GTK_BOX(prev_cmp_vbox), hbox, FALSE, FALSE, 5); hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); - align = gtk_alignment_new( 0, 0, 1, 0 ); button = gtk_button_new_with_label("Greater Than"); - gtk_container_add( GTK_CONTAINER(align), button ); - gtk_box_pack_start(GTK_BOX(hbox), align, TRUE, TRUE, 5); + //gtk_widget_set_halign( button, GTK_ALIGN_BASELINE); + gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 5); chkbutton = gtk_check_button_new(); g_signal_connect( button, "clicked", G_CALLBACK (cheatSearchGreaterThan), (gpointer) chkbutton ); @@ -2355,10 +2341,9 @@ static void openCheatsWindow(void) gtk_box_pack_start(GTK_BOX(prev_cmp_vbox), hbox, FALSE, FALSE, 5); hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); - align = gtk_alignment_new( 0, 0, 1, 0 ); button = gtk_button_new_with_label("Less Than"); - gtk_container_add( GTK_CONTAINER(align), button ); - gtk_box_pack_start(GTK_BOX(hbox), align, TRUE, TRUE, 5); + //gtk_widget_set_halign( button, GTK_ALIGN_BASELINE); + gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 5); chkbutton = gtk_check_button_new(); g_signal_connect( button, "clicked", G_CALLBACK (cheatSearchLessThan), (gpointer) chkbutton ); From af36752585a00c0064f0b4e6e6a0e6864682821b Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sun, 10 May 2020 11:17:59 -0400 Subject: [PATCH 032/156] Working on removing deprecated main menu and replacing with non-deprecated functions. --- src/drivers/sdl/gui.cpp | 158 ++++++++++++++++++++++++++++++++++++---- 1 file changed, 145 insertions(+), 13 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 743161f9..f1ac48ec 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -44,8 +44,8 @@ #endif void toggleSound(GtkWidget* check, gpointer data); -void loadGame (); -void closeGame(); +void loadGame (void); +void closeGame(void); extern Config *g_config; GtkWidget* MainWindow = NULL; @@ -3281,7 +3281,7 @@ void loadMovie () } #ifdef _S9XLUA_H -void loadLua () +void loadLua (void) { GtkWidget* fileChooser; GtkFileFilter* filterLua; @@ -3480,7 +3480,7 @@ void loadGameGenie () } -void loadNSF () +void loadNSF (void) { GtkWidget* fileChooser; GtkFileFilter* filterNSF; @@ -3536,14 +3536,14 @@ void loadNSF () gtk_widget_destroy (fileChooser); } -void closeGame() +void closeGame(void) { GdkColor bg = {0, 0, 0, 0}; gtk_widget_modify_bg(evbox, GTK_STATE_NORMAL, &bg); CloseGame(); } -void loadGame () +void loadGame (void) { GtkWidget* fileChooser; GtkFileFilter* filterFCEU; @@ -3629,7 +3629,7 @@ void loadGame () gtk_widget_destroy (fileChooser); } -void saveStateAs() +void saveStateAs(void) { GtkWidget* fileChooser; GtkFileFilter* filterSav; @@ -3671,7 +3671,7 @@ void saveStateAs() } -void loadStateFrom() +void loadStateFrom(void) { GtkWidget* fileChooser; GtkFileFilter* filterFcs; @@ -3716,19 +3716,22 @@ void loadStateFrom() gtk_widget_destroy (fileChooser); } -void quickLoad() +void quickLoad(void) { FCEUI_LoadState(NULL); } -void quickSave() +void quickSave(void) { FCEUI_SaveState(NULL); } -void changeState(GtkAction *action, GtkRadioAction *current, gpointer data) +//void changeState(GtkAction *action, GtkRadioAction *current, gpointer data) +void changeState(GtkRadioMenuItem *radiomenuitem, + gpointer user_data) { - FCEUI_SelectState(gtk_radio_action_get_current_value(current), 0); + printf("Changing State: %li\n", (long)user_data); + FCEUI_SelectState( (long)user_data, 0); } #if SDL_VERSION_ATLEAST(2, 0, 0) // SDL 1.2/2.0 compatibility macros @@ -4167,6 +4170,134 @@ static GtkWidget* CreateMenubar( GtkWidget* window) } +static GtkWidget* CreateMenubar2( GtkWidget* window) +{ + GtkWidget *menubar, *menu, *submenu, *item; + GSList *radioGroup; + + // Create Menu Bar + menubar = gtk_menu_bar_new(); + + // Create File Menu + item = gtk_menu_item_new_with_label("File"); + + gtk_menu_shell_append( GTK_MENU_SHELL(menubar), item ); + + menu = gtk_menu_new(); + + gtk_menu_item_set_submenu( GTK_MENU_ITEM(item), menu ); + + // Load File Menu Items + //-File --> Open ROM --------------------- + item = gtk_menu_item_new_with_label("Open ROM"); + + g_signal_connect( item, "activate", G_CALLBACK(loadGame), NULL); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + //-File --> Close ROM ------------------ + item = gtk_menu_item_new_with_label("Close ROM"); + + g_signal_connect( item, "activate", G_CALLBACK(closeGame), NULL); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + // Add Separator + item = gtk_separator_menu_item_new(); + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + //-File --> Play NSF ------------------ + item = gtk_menu_item_new_with_label("Play NSF"); + + g_signal_connect( item, "activate", G_CALLBACK(loadNSF), NULL); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + // Add Separator + item = gtk_separator_menu_item_new(); + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + //-File --> Load State From ------------------ + item = gtk_menu_item_new_with_label("Load State From"); + + g_signal_connect( item, "activate", G_CALLBACK(loadStateFrom), NULL); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + //-File --> Save State As ------------------ + item = gtk_menu_item_new_with_label("Save State As"); + + g_signal_connect( item, "activate", G_CALLBACK(saveStateAs), NULL); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + //-File --> Quick Load ------------------ + item = gtk_menu_item_new_with_label("Quick Load"); + + g_signal_connect( item, "activate", G_CALLBACK(quickLoad), NULL); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + //-File --> Quick Save ------------------ + item = gtk_menu_item_new_with_label("Quick Save"); + + g_signal_connect( item, "activate", G_CALLBACK(quickSave), NULL); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + //-File --> Change State ------------------ + item = gtk_menu_item_new_with_label("Change State"); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + submenu = gtk_menu_new(); + + gtk_menu_item_set_submenu( GTK_MENU_ITEM(item), submenu ); + + //-File --> Change State --> State 0:9 ------------------ + radioGroup = NULL; + + for (int i=0; i<10; i++) + { + char stmp[32]; + + sprintf( stmp, "%i", i ); + + item = gtk_radio_menu_item_new_with_label( radioGroup, stmp); + + radioGroup = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(item) ); + + gtk_menu_shell_append( GTK_MENU_SHELL(submenu), item ); + + g_signal_connect( item, "activate", G_CALLBACK(changeState), (gpointer)i); + } + + // Add Separator + item = gtk_separator_menu_item_new(); + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + //-File --> Load Lua Script ------------------ + item = gtk_menu_item_new_with_label("Load Lua Script"); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + g_signal_connect( item, "activate", G_CALLBACK(loadLua), NULL); + + // Add Separator + item = gtk_separator_menu_item_new(); + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + //-File --> ScreenShot ------------------ + item = gtk_menu_item_new_with_label("Screenshot"); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + g_signal_connect( item, "activate", G_CALLBACK(FCEUI_SaveSnapshot), NULL); + + // Finally, return the actual menu bar created + return menubar; +} + void pushOutputToGTK(const char* str) { // we don't really do anything with the output right now @@ -4309,7 +4440,8 @@ int InitGTKSubsystem(int argc, char** argv) vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_container_add(GTK_CONTAINER(MainWindow), vbox); - Menubar = CreateMenubar(MainWindow); + //Menubar = CreateMenubar(MainWindow); + Menubar = CreateMenubar2(MainWindow); gtk_box_pack_start (GTK_BOX(vbox), Menubar, FALSE, TRUE, 0); From 89895fdd182b8fb8d3455c0538dc8df96dfd125f Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sun, 10 May 2020 14:59:49 -0400 Subject: [PATCH 033/156] Finished File menu of main menu bar. --- src/drivers/sdl/gui.cpp | 33 ++++++++++++++++++++++++++++++++- 1 file changed, 32 insertions(+), 1 deletion(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index f1ac48ec..1b8076f0 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -3730,7 +3730,7 @@ void quickSave(void) void changeState(GtkRadioMenuItem *radiomenuitem, gpointer user_data) { - printf("Changing State: %li\n", (long)user_data); + //printf("Changing State: %li\n", (long)user_data); FCEUI_SelectState( (long)user_data, 0); } #if SDL_VERSION_ATLEAST(2, 0, 0) @@ -4174,10 +4174,16 @@ static GtkWidget* CreateMenubar2( GtkWidget* window) { GtkWidget *menubar, *menu, *submenu, *item; GSList *radioGroup; + GtkAccelGroup *accel_group; // Create Menu Bar menubar = gtk_menu_bar_new(); + // Create a GtkAccelGroup and add it to the window. + accel_group = gtk_accel_group_new (); + + gtk_window_add_accel_group (GTK_WINDOW (window), accel_group); + // Create File Menu item = gtk_menu_item_new_with_label("File"); @@ -4193,6 +4199,9 @@ static GtkWidget* CreateMenubar2( GtkWidget* window) g_signal_connect( item, "activate", G_CALLBACK(loadGame), NULL); + gtk_widget_add_accelerator( item, "activate", accel_group, + GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); //-File --> Close ROM ------------------ @@ -4200,6 +4209,9 @@ static GtkWidget* CreateMenubar2( GtkWidget* window) g_signal_connect( item, "activate", G_CALLBACK(closeGame), NULL); + gtk_widget_add_accelerator( item, "activate", accel_group, + GDK_KEY_c, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); // Add Separator @@ -4211,6 +4223,9 @@ static GtkWidget* CreateMenubar2( GtkWidget* window) g_signal_connect( item, "activate", G_CALLBACK(loadNSF), NULL); + gtk_widget_add_accelerator( item, "activate", accel_group, + GDK_KEY_n, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); // Add Separator @@ -4236,6 +4251,9 @@ static GtkWidget* CreateMenubar2( GtkWidget* window) g_signal_connect( item, "activate", G_CALLBACK(quickLoad), NULL); + gtk_widget_add_accelerator( item, "activate", accel_group, + GDK_KEY_F7, (GdkModifierType)0, GTK_ACCEL_VISIBLE); + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); //-File --> Quick Save ------------------ @@ -4243,6 +4261,9 @@ static GtkWidget* CreateMenubar2( GtkWidget* window) g_signal_connect( item, "activate", G_CALLBACK(quickSave), NULL); + gtk_widget_add_accelerator( item, "activate", accel_group, + GDK_KEY_F5, (GdkModifierType)0, GTK_ACCEL_VISIBLE); + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); //-File --> Change State ------------------ @@ -4294,6 +4315,16 @@ static GtkWidget* CreateMenubar2( GtkWidget* window) g_signal_connect( item, "activate", G_CALLBACK(FCEUI_SaveSnapshot), NULL); + //-File --> Quit ------------------ + item = gtk_menu_item_new_with_label("Quit"); + + g_signal_connect( item, "activate", G_CALLBACK(quit), NULL); + + gtk_widget_add_accelerator( item, "activate", accel_group, + GDK_KEY_q, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + // Finally, return the actual menu bar created return menubar; } From ee35a5bab4f0a7cfbfc73a335f28087310a27879 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sun, 10 May 2020 15:32:32 -0400 Subject: [PATCH 034/156] Updated options sub menu. --- src/drivers/sdl/gui.cpp | 128 ++++++++++++++++++++++++++++++++++++---- 1 file changed, 117 insertions(+), 11 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 1b8076f0..32c8c754 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -56,7 +56,7 @@ GtkWidget* buttonMappings[10]; GtkWidget* Menubar; GtkRadioAction* stateSlot = NULL; bool gtkIsStarted = false; -bool menuTogglingEnabled; +bool menuTogglingEnabled = false; //----------------------------------------- // Cheat static variables @@ -414,7 +414,7 @@ void clearPalette(GtkWidget* w, gpointer p) gtk_entry_set_text(GTK_ENTRY(p), ""); } -void openPaletteConfig() +void openPaletteConfig(void) { GtkWidget* win; GtkWidget* vbox; @@ -539,7 +539,7 @@ void netResponse(GtkWidget* w, gint response_id, gpointer p) gtk_widget_destroy(w); } -void openNetworkConfig() +void openNetworkConfig(void) { GtkWidget* win; GtkWidget* box; @@ -772,7 +772,7 @@ void updateGamepadConfig(GtkWidget* w, gpointer p) } // creates and opens the gamepad config window (requires GTK 2.24) -void openGamepadConfig() +void openGamepadConfig(void) { // GTK 2.24 required for this dialog if (checkGTKVersion(2, 24) == false) @@ -1055,7 +1055,7 @@ void setDoubleBuffering(GtkWidget* w, gpointer p) } #endif -void openVideoConfig() +void openVideoConfig(void) { GtkWidget* win; GtkWidget* vbox; @@ -1265,7 +1265,7 @@ int mixerChanged(GtkWidget* w, gpointer p) return 0; } -void openSoundConfig() +void openSoundConfig(void) { GtkWidget* win; GtkWidget* main_hbox; @@ -1499,24 +1499,26 @@ void hardReset () } } -void enableFullscreen () +void enableFullscreen (void) { if(isloaded) ToggleFS(); } -void toggleMenuToggling (GtkToggleAction *action) +void toggleMenuToggling(GtkCheckMenuItem *item, gpointer user_data) { - bool toggleMenu = gtk_toggle_action_get_active(action); + bool toggleMenu = gtk_check_menu_item_get_active(item); + //printf("ToggleMenu: %i\n", (int)toggleMenu); g_config->setOption("SDL.ToggleMenu", (int)toggleMenu); menuTogglingEnabled = toggleMenu; } -void toggleAutoResume (GtkToggleAction *action) +void toggleAutoResume(GtkCheckMenuItem *item, gpointer user_data) { - bool autoResume = gtk_toggle_action_get_active(action); + bool autoResume = gtk_check_menu_item_get_active(item); + //printf("AutoResume: %i\n", (int)autoResume); g_config->setOption("SDL.AutoResume", (int)autoResume); AutoResumePlay = autoResume; } @@ -4184,6 +4186,7 @@ static GtkWidget* CreateMenubar2( GtkWidget* window) gtk_window_add_accel_group (GTK_WINDOW (window), accel_group); + //--------------------------------------- // Create File Menu item = gtk_menu_item_new_with_label("File"); @@ -4315,6 +4318,9 @@ static GtkWidget* CreateMenubar2( GtkWidget* window) g_signal_connect( item, "activate", G_CALLBACK(FCEUI_SaveSnapshot), NULL); + gtk_widget_add_accelerator( item, "activate", accel_group, + GDK_KEY_F12, (GdkModifierType)0, GTK_ACCEL_VISIBLE); + //-File --> Quit ------------------ item = gtk_menu_item_new_with_label("Quit"); @@ -4323,6 +4329,106 @@ static GtkWidget* CreateMenubar2( GtkWidget* window) gtk_widget_add_accelerator( item, "activate", accel_group, GDK_KEY_q, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + //--------------------------------------- + // Create Options Menu + item = gtk_menu_item_new_with_label("Options"); + + gtk_menu_shell_append( GTK_MENU_SHELL(menubar), item ); + + menu = gtk_menu_new(); + + gtk_menu_item_set_submenu( GTK_MENU_ITEM(item), menu ); + + // Load Options Menu Items + //-Options --> Gamepad Config --------------------- + item = gtk_menu_item_new_with_label("Gamepad Config"); + + g_signal_connect( item, "activate", G_CALLBACK(openGamepadConfig), NULL); + + //gtk_widget_add_accelerator( item, "activate", accel_group, + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + //-Options --> Hotkey Config --------------------- + item = gtk_menu_item_new_with_label("Hotkey Config"); + + g_signal_connect( item, "activate", G_CALLBACK(openHotkeyConfig), NULL); + + //gtk_widget_add_accelerator( item, "activate", accel_group, + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + //-Options --> Sound Config --------------------- + item = gtk_menu_item_new_with_label("Sound Config"); + + g_signal_connect( item, "activate", G_CALLBACK(openSoundConfig), NULL); + + //gtk_widget_add_accelerator( item, "activate", accel_group, + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + //-Options --> Video Config --------------------- + item = gtk_menu_item_new_with_label("Video Config"); + + g_signal_connect( item, "activate", G_CALLBACK(openVideoConfig), NULL); + + //gtk_widget_add_accelerator( item, "activate", accel_group, + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + //-Options --> Palette Config --------------------- + item = gtk_menu_item_new_with_label("Palette Config"); + + g_signal_connect( item, "activate", G_CALLBACK(openPaletteConfig), NULL); + + //gtk_widget_add_accelerator( item, "activate", accel_group, + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + //-Options --> Network Config --------------------- + item = gtk_menu_item_new_with_label("Network Config"); + + g_signal_connect( item, "activate", G_CALLBACK(openNetworkConfig), NULL); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + //-Options --> Auto-Resume Play --------------------- + item = gtk_check_menu_item_new_with_label("Auto-Resume Play"); + + gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(item), AutoResumePlay); + + g_signal_connect( item, "toggled", G_CALLBACK(toggleAutoResume), NULL); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + //-Options --> Toggle Menubar --------------------- + item = gtk_check_menu_item_new_with_label("Toggle Menubar (alt)"); + + //gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(item), FALSE); + + g_signal_connect( item, "toggled", G_CALLBACK(toggleMenuToggling), NULL); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + // Add Separator + item = gtk_separator_menu_item_new(); + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + //-Options --> Fullscreen --------------------- + item = gtk_menu_item_new_with_label("Fullscreen"); + + g_signal_connect( item, "activate", G_CALLBACK(enableFullscreen), NULL); + + gtk_widget_add_accelerator( item, "activate", accel_group, + GDK_KEY_Return, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); // Finally, return the actual menu bar created From 81b9555ad00d2e1c5a2927618b045c6fb5c18850 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sun, 10 May 2020 16:24:44 -0400 Subject: [PATCH 035/156] Finished updating emulation menu to new non-deprecated widgets. --- src/drivers/sdl/gui.cpp | 557 +++++++++++++++++++++++++--------------- 1 file changed, 346 insertions(+), 211 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 32c8c754..b8f0c27e 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -3335,7 +3335,7 @@ void loadLua (void) #endif -void loadFdsBios () +void loadFdsBios (void) { GtkWidget* fileChooser; GtkFileFilter* filterDiskSys; @@ -3397,12 +3397,12 @@ void enableGameGenie(int enabled) FCEUI_SetGameGenie(enabled); } -void toggleGameGenie(GtkToggleAction *action) +void toggleGameGenie(GtkCheckMenuItem *item, gpointer userData) { - enableGameGenie(gtk_toggle_action_get_active(action)); + enableGameGenie( gtk_check_menu_item_get_active(item) ); } -void togglePause(GtkAction *action) +void togglePause(GtkMenuItem *item, gpointer userData ) { SDL_Event sdlev; int paused; @@ -3418,8 +3418,8 @@ void togglePause(GtkAction *action) FCEU_printf("Failed to push SDL event to %s game.\n", paused ? "resume" : "pause"); return; } - gtk_action_set_label(action, paused ? "Pause" : "Resume"); - gtk_action_set_stock_id(action, paused ? GTK_STOCK_MEDIA_PAUSE : GTK_STOCK_MEDIA_PLAY); + gtk_menu_item_set_label( item, paused ? "Pause" : "Resume"); + //gtk_action_set_stock_id(action, paused ? GTK_STOCK_MEDIA_PAUSE : GTK_STOCK_MEDIA_PLAY); } } @@ -3960,216 +3960,216 @@ gint convertKeypress(GtkWidget *grab, GdkEventKey *event, gpointer user_data) } // Our menu, in the XML markup format used by GtkUIManager -static char* menuXml = - "" - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " -#ifdef _S9XLUA_H - " " -#endif - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - " " - ""; +//static char* menuXml = +// "" +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +//#ifdef _S9XLUA_H +// " " +//#endif +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// " " +// ""; // Menu items, as an array of GtkActionEntry structures that define each item -static GtkActionEntry normal_entries[] = { - {"FileMenuAction", NULL, "_File"}, - {"OpenRomAction", GTK_STOCK_OPEN, "_Open ROM", "O", NULL, G_CALLBACK(loadGame)}, - {"CloseRomAction", GTK_STOCK_CLOSE, "_Close ROM", "C", NULL, G_CALLBACK(closeGame)}, - {"PlayNsfAction", GTK_STOCK_OPEN, "_Play NSF", "N", NULL, G_CALLBACK(loadNSF)}, - {"LoadStateFromAction", GTK_STOCK_OPEN, "Load State _From", "", NULL, G_CALLBACK(loadStateFrom)}, - {"SaveStateAsAction", GTK_STOCK_SAVE_AS, "Save State _As", NULL, NULL, G_CALLBACK(saveStateAs)}, - {"QuickLoadAction", "go-jump", "Quick _Load", "F7", NULL, G_CALLBACK(quickLoad)}, - {"QuickSaveAction", GTK_STOCK_SAVE, "Qu_ick Save", "F5", NULL, G_CALLBACK(quickSave)}, - {"ChangeStateMenuAction", NULL, "C_hange State"}, -#ifdef _S9XLUA_H - {"LoadLuaScriptAction", GTK_STOCK_OPEN, "Load L_ua Script", "", NULL, G_CALLBACK(loadLua)}, -#endif - {"ScreenshotAction", NULL, "_Screenshot", "F12", NULL, G_CALLBACK(FCEUI_SaveSnapshot)}, - {"QuitAction", GTK_STOCK_QUIT, "_Quit", "Q", NULL, G_CALLBACK(quit)}, - - {"OptionsMenuAction", NULL, "_Options"}, -#if GTK_MAJOR_VERSION == 3 || (GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION >= 24) - {"GamepadConfigAction", "input-gaming", "_Gamepad Config", NULL, NULL, G_CALLBACK(openGamepadConfig)}, -#endif - {"HotkeyConfigAction", "input", "_Hotkey Config", NULL, NULL, G_CALLBACK(openHotkeyConfig)}, - {"SoundConfigAction", "audio-x-generic", "_Sound Config", NULL, NULL, G_CALLBACK(openSoundConfig)}, - {"VideoConfigAction", "video-display", "_Video Config", NULL, NULL, G_CALLBACK(openVideoConfig)}, - {"PaletteConfigAction", GTK_STOCK_SELECT_COLOR, "_Palette Config", NULL, NULL, G_CALLBACK(openPaletteConfig)}, - {"NetworkConfigAction", GTK_STOCK_NETWORK, "_Network Config", NULL, NULL, G_CALLBACK(openNetworkConfig)}, - {"FullscreenAction", GTK_STOCK_FULLSCREEN, "_Fullscreen", "Return", NULL, G_CALLBACK(enableFullscreen)}, - {"EmulationMenuAction", NULL, "_Emulation"}, - {"PowerAction", NULL, "P_ower", NULL, NULL, G_CALLBACK(FCEUI_PowerNES)}, - {"SoftResetAction", GTK_STOCK_REFRESH, "_Soft Reset", NULL, NULL, G_CALLBACK(emuReset)}, - {"ResetAction", GTK_STOCK_REFRESH, "_Reset", NULL, NULL, G_CALLBACK(hardReset)}, - {"PauseToggleAction", GTK_STOCK_MEDIA_PAUSE, "_Pause", "Pause", NULL, G_CALLBACK(togglePause)}, - {"FdsMenuAction", GTK_STOCK_FLOPPY, "_FDS"}, - {"SwitchDiskAction", "go-jump", "_Switch Disk", NULL, NULL, G_CALLBACK(FCEU_FDSSelect)}, - {"EjectDiskAction", "media-eject", "_Eject Disk", NULL, NULL, G_CALLBACK(FCEU_FDSInsert)}, - {"LoadBiosAction", GTK_STOCK_OPEN, "Load _BIOS File", "", NULL, G_CALLBACK(loadFdsBios)}, - {"LoadGameGenieAction", GTK_STOCK_OPEN, "_Load Game Genie ROM", "", NULL, G_CALLBACK(loadGameGenie)}, - {"InsertCoinAction", NULL, "_Insert Coin", NULL, NULL, G_CALLBACK(FCEUI_VSUniCoin)}, - - {"ToolsMenuAction", NULL, "_Tools"}, - {"CheatsAction", "cheats-win", "_Cheats...", NULL, NULL, G_CALLBACK(openCheatsWindow)}, - {"RamWatchAction", "ram-watch", "_RAM Watch...", NULL, NULL, G_CALLBACK(openMemoryWatchWindow)}, - - {"MovieMenuAction", NULL, "_Movie"}, - {"OpenMovieAction", GTK_STOCK_OPEN, "_Open", "F7", NULL, G_CALLBACK(loadMovie)}, - {"StopMovieAction", GTK_STOCK_MEDIA_STOP, "S_top", NULL, NULL, G_CALLBACK(FCEUI_StopMovie)}, - {"RecordMovieAction", GTK_STOCK_MEDIA_RECORD, "_Record", "F5", NULL, G_CALLBACK(recordMovie)}, - {"RecordMovieAsAction", NULL, "Record _As", NULL, NULL, G_CALLBACK(recordMovieAs)}, - - {"HelpMenuAction", NULL, "_Help"}, - {"AboutAction", GTK_STOCK_ABOUT, "_About", NULL, NULL, G_CALLBACK(openAbout)}, -}; +//static GtkActionEntry normal_entries[] = { +// {"FileMenuAction", NULL, "_File"}, +// {"OpenRomAction", GTK_STOCK_OPEN, "_Open ROM", "O", NULL, G_CALLBACK(loadGame)}, +// {"CloseRomAction", GTK_STOCK_CLOSE, "_Close ROM", "C", NULL, G_CALLBACK(closeGame)}, +// {"PlayNsfAction", GTK_STOCK_OPEN, "_Play NSF", "N", NULL, G_CALLBACK(loadNSF)}, +// {"LoadStateFromAction", GTK_STOCK_OPEN, "Load State _From", "", NULL, G_CALLBACK(loadStateFrom)}, +// {"SaveStateAsAction", GTK_STOCK_SAVE_AS, "Save State _As", NULL, NULL, G_CALLBACK(saveStateAs)}, +// {"QuickLoadAction", "go-jump", "Quick _Load", "F7", NULL, G_CALLBACK(quickLoad)}, +// {"QuickSaveAction", GTK_STOCK_SAVE, "Qu_ick Save", "F5", NULL, G_CALLBACK(quickSave)}, +// {"ChangeStateMenuAction", NULL, "C_hange State"}, +//#ifdef _S9XLUA_H +// {"LoadLuaScriptAction", GTK_STOCK_OPEN, "Load L_ua Script", "", NULL, G_CALLBACK(loadLua)}, +//#endif +// {"ScreenshotAction", NULL, "_Screenshot", "F12", NULL, G_CALLBACK(FCEUI_SaveSnapshot)}, +// {"QuitAction", GTK_STOCK_QUIT, "_Quit", "Q", NULL, G_CALLBACK(quit)}, +// +// {"OptionsMenuAction", NULL, "_Options"}, +//#if GTK_MAJOR_VERSION == 3 || (GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION >= 24) +// {"GamepadConfigAction", "input-gaming", "_Gamepad Config", NULL, NULL, G_CALLBACK(openGamepadConfig)}, +//#endif +// {"HotkeyConfigAction", "input", "_Hotkey Config", NULL, NULL, G_CALLBACK(openHotkeyConfig)}, +// {"SoundConfigAction", "audio-x-generic", "_Sound Config", NULL, NULL, G_CALLBACK(openSoundConfig)}, +// {"VideoConfigAction", "video-display", "_Video Config", NULL, NULL, G_CALLBACK(openVideoConfig)}, +// {"PaletteConfigAction", GTK_STOCK_SELECT_COLOR, "_Palette Config", NULL, NULL, G_CALLBACK(openPaletteConfig)}, +// {"NetworkConfigAction", GTK_STOCK_NETWORK, "_Network Config", NULL, NULL, G_CALLBACK(openNetworkConfig)}, +// {"FullscreenAction", GTK_STOCK_FULLSCREEN, "_Fullscreen", "Return", NULL, G_CALLBACK(enableFullscreen)}, +// {"EmulationMenuAction", NULL, "_Emulation"}, +// {"PowerAction", NULL, "P_ower", NULL, NULL, G_CALLBACK(FCEUI_PowerNES)}, +// {"SoftResetAction", GTK_STOCK_REFRESH, "_Soft Reset", NULL, NULL, G_CALLBACK(emuReset)}, +// {"ResetAction", GTK_STOCK_REFRESH, "_Reset", NULL, NULL, G_CALLBACK(hardReset)}, +// {"PauseToggleAction", GTK_STOCK_MEDIA_PAUSE, "_Pause", "Pause", NULL, G_CALLBACK(togglePause)}, +// {"FdsMenuAction", GTK_STOCK_FLOPPY, "_FDS"}, +// {"SwitchDiskAction", "go-jump", "_Switch Disk", NULL, NULL, G_CALLBACK(FCEU_FDSSelect)}, +// {"EjectDiskAction", "media-eject", "_Eject Disk", NULL, NULL, G_CALLBACK(FCEU_FDSInsert)}, +// {"LoadBiosAction", GTK_STOCK_OPEN, "Load _BIOS File", "", NULL, G_CALLBACK(loadFdsBios)}, +// {"LoadGameGenieAction", GTK_STOCK_OPEN, "_Load Game Genie ROM", "", NULL, G_CALLBACK(loadGameGenie)}, +// {"InsertCoinAction", NULL, "_Insert Coin", NULL, NULL, G_CALLBACK(FCEUI_VSUniCoin)}, +// +// {"ToolsMenuAction", NULL, "_Tools"}, +// {"CheatsAction", "cheats-win", "_Cheats...", NULL, NULL, G_CALLBACK(openCheatsWindow)}, +// {"RamWatchAction", "ram-watch", "_RAM Watch...", NULL, NULL, G_CALLBACK(openMemoryWatchWindow)}, +// +// {"MovieMenuAction", NULL, "_Movie"}, +// {"OpenMovieAction", GTK_STOCK_OPEN, "_Open", "F7", NULL, G_CALLBACK(loadMovie)}, +// {"StopMovieAction", GTK_STOCK_MEDIA_STOP, "S_top", NULL, NULL, G_CALLBACK(FCEUI_StopMovie)}, +// {"RecordMovieAction", GTK_STOCK_MEDIA_RECORD, "_Record", "F5", NULL, G_CALLBACK(recordMovie)}, +// {"RecordMovieAsAction", NULL, "Record _As", NULL, NULL, G_CALLBACK(recordMovieAs)}, +// +// {"HelpMenuAction", NULL, "_Help"}, +// {"AboutAction", GTK_STOCK_ABOUT, "_About", NULL, NULL, G_CALLBACK(openAbout)}, +//}; // Menu items with a check box that can be toggled on or off -static GtkToggleActionEntry toggle_entries[] = { - {"GameGenieToggleAction", NULL, "Enable Game _Genie", NULL, NULL, G_CALLBACK(toggleGameGenie), FALSE}, - {"AutoResumeAction", NULL, "Auto-Resume Play", NULL, NULL, G_CALLBACK(toggleAutoResume), FALSE}, - {"ToggleMenuAction", NULL, "Toggle Menubar (alt)", NULL, NULL, G_CALLBACK(toggleMenuToggling), FALSE}, -}; +//static GtkToggleActionEntry toggle_entries[] = { +// {"GameGenieToggleAction", NULL, "Enable Game _Genie", NULL, NULL, G_CALLBACK(toggleGameGenie), FALSE}, +// {"AutoResumeAction", NULL, "Auto-Resume Play", NULL, NULL, G_CALLBACK(toggleAutoResume), FALSE}, +// {"ToggleMenuAction", NULL, "Toggle Menubar (alt)", NULL, NULL, G_CALLBACK(toggleMenuToggling), FALSE}, +//}; // Menu items for selecting a save state slot using radio buttons -static GtkRadioActionEntry radio_entries[] = { - {"State0Action", NULL, "0", NULL, NULL, 0}, - {"State1Action", NULL, "1", NULL, NULL, 1}, - {"State2Action", NULL, "2", NULL, NULL, 2}, - {"State3Action", NULL, "3", NULL, NULL, 3}, - {"State4Action", NULL, "4", NULL, NULL, 4}, - {"State5Action", NULL, "5", NULL, NULL, 5}, - {"State6Action", NULL, "6", NULL, NULL, 6}, - {"State7Action", NULL, "7", NULL, NULL, 7}, - {"State8Action", NULL, "8", NULL, NULL, 8}, - {"State9Action", NULL, "9", NULL, NULL, 9}, -}; +//static GtkRadioActionEntry radio_entries[] = { +// {"State0Action", NULL, "0", NULL, NULL, 0}, +// {"State1Action", NULL, "1", NULL, NULL, 1}, +// {"State2Action", NULL, "2", NULL, NULL, 2}, +// {"State3Action", NULL, "3", NULL, NULL, 3}, +// {"State4Action", NULL, "4", NULL, NULL, 4}, +// {"State5Action", NULL, "5", NULL, NULL, 5}, +// {"State6Action", NULL, "6", NULL, NULL, 6}, +// {"State7Action", NULL, "7", NULL, NULL, 7}, +// {"State8Action", NULL, "8", NULL, NULL, 8}, +// {"State9Action", NULL, "9", NULL, NULL, 9}, +//}; -static GtkWidget* CreateMenubar( GtkWidget* window) -{ - GtkUIManager *ui_manager; - GtkActionGroup *action_group; - GtkAccelGroup* accel_group; - GError *error = NULL; - GtkAction* state; - - /* Make an UIManager (which makes a menubar). */ - ui_manager = gtk_ui_manager_new (); - - /* Add the menu items to the UIManager as a GtkActionGroup. */ - action_group = gtk_action_group_new ("MenubarActions"); - gtk_action_group_add_actions (action_group, normal_entries, G_N_ELEMENTS (normal_entries), NULL); - gtk_action_group_add_toggle_actions (action_group, toggle_entries, G_N_ELEMENTS (toggle_entries), NULL); - gtk_action_group_add_radio_actions (action_group, radio_entries, G_N_ELEMENTS (radio_entries), 0, G_CALLBACK(changeState), NULL); - gtk_ui_manager_insert_action_group (ui_manager, action_group, 0); - - /* Read the menu layout from the XML markup. */ - gtk_ui_manager_add_ui_from_string (ui_manager, menuXml, -1, &error); - if (error) - { - fprintf (stderr, "Unable to create menu bar: %s\n", error->message); - g_error_free (error); - } - - /* Attach the new accelerator group to the window. */ - accel_group = gtk_ui_manager_get_accel_group (ui_manager); - gtk_window_add_accel_group (GTK_WINDOW (window), accel_group); - - /* Get an action that can be used to change the active state slot selection. */ - state = gtk_action_group_get_action (action_group, "State0Action"); - if (state && GTK_IS_RADIO_ACTION (state)) - stateSlot = GTK_RADIO_ACTION (state); - - /* Set the autoResume checkbox */ - GtkCheckMenuItem* auto_resume_chk = (GtkCheckMenuItem*) gtk_ui_manager_get_widget ( ui_manager, "/Menubar/OptionsMenuAction/AutoResumeAction"); - gtk_check_menu_item_set_active (auto_resume_chk, (bool)AutoResumePlay); - - // Sync State of GameGenie Toggle Action to Startup Configuration - int gameGenieEnabled=0; - g_config->getOption("SDL.GameGenie", &gameGenieEnabled); - - if ( gameGenieEnabled ) - { - state = gtk_action_group_get_action (action_group, "GameGenieToggleAction"); - - if ( state ){ - gtk_action_activate( state ); - } - } - enableGameGenie(gameGenieEnabled); - - /* Finally, return the actual menu bar created by the UIManager. */ - return gtk_ui_manager_get_widget (ui_manager, "/Menubar"); -} +//static GtkWidget* CreateMenubar( GtkWidget* window) +//{ +// GtkUIManager *ui_manager; +// GtkActionGroup *action_group; +// GtkAccelGroup* accel_group; +// GError *error = NULL; +// GtkAction* state; +// +// /* Make an UIManager (which makes a menubar). */ +// ui_manager = gtk_ui_manager_new (); +// +// /* Add the menu items to the UIManager as a GtkActionGroup. */ +// action_group = gtk_action_group_new ("MenubarActions"); +// gtk_action_group_add_actions (action_group, normal_entries, G_N_ELEMENTS (normal_entries), NULL); +// gtk_action_group_add_toggle_actions (action_group, toggle_entries, G_N_ELEMENTS (toggle_entries), NULL); +// gtk_action_group_add_radio_actions (action_group, radio_entries, G_N_ELEMENTS (radio_entries), 0, G_CALLBACK(changeState), NULL); +// gtk_ui_manager_insert_action_group (ui_manager, action_group, 0); +// +// /* Read the menu layout from the XML markup. */ +// gtk_ui_manager_add_ui_from_string (ui_manager, menuXml, -1, &error); +// if (error) +// { +// fprintf (stderr, "Unable to create menu bar: %s\n", error->message); +// g_error_free (error); +// } +// +// /* Attach the new accelerator group to the window. */ +// accel_group = gtk_ui_manager_get_accel_group (ui_manager); +// gtk_window_add_accel_group (GTK_WINDOW (window), accel_group); +// +// /* Get an action that can be used to change the active state slot selection. */ +// state = gtk_action_group_get_action (action_group, "State0Action"); +// if (state && GTK_IS_RADIO_ACTION (state)) +// stateSlot = GTK_RADIO_ACTION (state); +// +// /* Set the autoResume checkbox */ +// GtkCheckMenuItem* auto_resume_chk = (GtkCheckMenuItem*) gtk_ui_manager_get_widget ( ui_manager, "/Menubar/OptionsMenuAction/AutoResumeAction"); +// gtk_check_menu_item_set_active (auto_resume_chk, (bool)AutoResumePlay); +// +// // Sync State of GameGenie Toggle Action to Startup Configuration +// int gameGenieEnabled=0; +// g_config->getOption("SDL.GameGenie", &gameGenieEnabled); +// +// if ( gameGenieEnabled ) +// { +// state = gtk_action_group_get_action (action_group, "GameGenieToggleAction"); +// +// if ( state ){ +// gtk_action_activate( state ); +// } +// } +// enableGameGenie(gameGenieEnabled); +// +// /* Finally, return the actual menu bar created by the UIManager. */ +// return gtk_ui_manager_get_widget (ui_manager, "/Menubar"); +//} static GtkWidget* CreateMenubar2( GtkWidget* window) @@ -4281,11 +4281,11 @@ static GtkWidget* CreateMenubar2( GtkWidget* window) //-File --> Change State --> State 0:9 ------------------ radioGroup = NULL; - for (int i=0; i<10; i++) + for (long int i=0; i<10; i++) { char stmp[32]; - sprintf( stmp, "%i", i ); + sprintf( stmp, "%li", i ); item = gtk_radio_menu_item_new_with_label( radioGroup, stmp); @@ -4296,6 +4296,7 @@ static GtkWidget* CreateMenubar2( GtkWidget* window) g_signal_connect( item, "activate", G_CALLBACK(changeState), (gpointer)i); } +#ifdef _S9XLUA_H // Add Separator item = gtk_separator_menu_item_new(); gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); @@ -4306,6 +4307,7 @@ static GtkWidget* CreateMenubar2( GtkWidget* window) gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); g_signal_connect( item, "activate", G_CALLBACK(loadLua), NULL); +#endif // Add Separator item = gtk_separator_menu_item_new(); @@ -4431,6 +4433,139 @@ static GtkWidget* CreateMenubar2( GtkWidget* window) gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + //--------------------------------------- + // Create Emulation Menu + item = gtk_menu_item_new_with_label("Emulation"); + + gtk_menu_shell_append( GTK_MENU_SHELL(menubar), item ); + + menu = gtk_menu_new(); + + gtk_menu_item_set_submenu( GTK_MENU_ITEM(item), menu ); + + // Load Emulation Menu Items + //-Emulation --> Power --------------------- + item = gtk_menu_item_new_with_label("Power"); + + g_signal_connect( item, "activate", G_CALLBACK(FCEUI_PowerNES), NULL); + + //gtk_widget_add_accelerator( item, "activate", accel_group, + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + //-Emulation --> Reset --------------------- + item = gtk_menu_item_new_with_label("Reset"); + + g_signal_connect( item, "activate", G_CALLBACK(hardReset), NULL); + + //gtk_widget_add_accelerator( item, "activate", accel_group, + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + //-Emulation --> Soft Reset --------------------- + item = gtk_menu_item_new_with_label("Soft Reset"); + + g_signal_connect( item, "activate", G_CALLBACK(emuReset), NULL); + + //gtk_widget_add_accelerator( item, "activate", accel_group, + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + //-Emulation --> Pause --------------------- + item = gtk_menu_item_new_with_label("Pause"); + + g_signal_connect( item, "activate", G_CALLBACK(togglePause), NULL); + + gtk_widget_add_accelerator( item, "activate", accel_group, + GDK_KEY_Pause, (GdkModifierType)0, GTK_ACCEL_VISIBLE); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + // Add Separator + item = gtk_separator_menu_item_new(); + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + //-Emulator --> Enable Game Genie --------------------- + item = gtk_check_menu_item_new_with_label("Enable Game Genie"); + + int gameGenieEnabled=0; + g_config->getOption("SDL.GameGenie", &gameGenieEnabled); + gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(item), gameGenieEnabled); + + g_signal_connect( item, "toggled", G_CALLBACK(toggleGameGenie), NULL); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + //-Emulation --> Load Game Genie ROM --------------------- + item = gtk_menu_item_new_with_label("Load Game Genie ROM"); + + g_signal_connect( item, "activate", G_CALLBACK(loadGameGenie), NULL); + + //gtk_widget_add_accelerator( item, "activate", accel_group, + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + // Add Separator + item = gtk_separator_menu_item_new(); + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + //-Emulation --> Insert Coin --------------------- + item = gtk_menu_item_new_with_label("Insert Coin"); + + g_signal_connect( item, "activate", G_CALLBACK(FCEUI_VSUniCoin), NULL); + + //gtk_widget_add_accelerator( item, "activate", accel_group, + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + // Add Separator + item = gtk_separator_menu_item_new(); + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + //-Emulation --> FDS ------------------ + item = gtk_menu_item_new_with_label("FDS"); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + submenu = gtk_menu_new(); + + gtk_menu_item_set_submenu( GTK_MENU_ITEM(item), submenu ); + + //-Emulation --> FDS --> Switch Disk --------------------- + item = gtk_menu_item_new_with_label("Switch Disk"); + + g_signal_connect( item, "activate", G_CALLBACK(FCEU_FDSSelect), NULL); + + //gtk_widget_add_accelerator( item, "activate", accel_group, + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + + gtk_menu_shell_append( GTK_MENU_SHELL(submenu), item ); + + //-Emulation --> FDS --> Eject Disk --------------------- + item = gtk_menu_item_new_with_label("Eject Disk"); + + g_signal_connect( item, "activate", G_CALLBACK(FCEU_FDSInsert), NULL); + + //gtk_widget_add_accelerator( item, "activate", accel_group, + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + + gtk_menu_shell_append( GTK_MENU_SHELL(submenu), item ); + + //-Emulation --> FDS --> Load BIOS File --------------------- + item = gtk_menu_item_new_with_label("Load BIOS File"); + + g_signal_connect( item, "activate", G_CALLBACK(loadFdsBios), NULL); + + //gtk_widget_add_accelerator( item, "activate", accel_group, + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + + gtk_menu_shell_append( GTK_MENU_SHELL(submenu), item ); + // Finally, return the actual menu bar created return menubar; } From 73a4efcad99524d13c51df5e71bddb7449184a09 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sun, 10 May 2020 16:40:28 -0400 Subject: [PATCH 036/156] Finished reworking main menu. --- src/drivers/sdl/gui.cpp | 111 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 109 insertions(+), 2 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index b8f0c27e..09d6c1f1 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -1449,7 +1449,7 @@ const char* Authors[]= { " Mitsutaka Okazaki - YM2413 emulator", " Andrea Mazzoleni - Scale2x/Scale3x scalers", " Gilles Vollant - unzip.c PKZIP fileio", NULL}; -void openAbout () +void openAbout (void) { GdkPixbuf* logo = gdk_pixbuf_new_from_xpm_data(icon_xpm); @@ -3229,7 +3229,7 @@ void recordMovieAs () gtk_widget_destroy (fileChooser); } -void loadMovie () +void loadMovie (void) { GtkWidget* fileChooser; @@ -4566,6 +4566,113 @@ static GtkWidget* CreateMenubar2( GtkWidget* window) gtk_menu_shell_append( GTK_MENU_SHELL(submenu), item ); + //--------------------------------------- + // Create Tools Menu + item = gtk_menu_item_new_with_label("Tools"); + + gtk_menu_shell_append( GTK_MENU_SHELL(menubar), item ); + + menu = gtk_menu_new(); + + gtk_menu_item_set_submenu( GTK_MENU_ITEM(item), menu ); + + // Load Tools Menu Items + //-Tools --> Cheats --------------------- + item = gtk_menu_item_new_with_label("Cheats..."); + + g_signal_connect( item, "activate", G_CALLBACK(openCheatsWindow), NULL); + + //gtk_widget_add_accelerator( item, "activate", accel_group, + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + //-Tools --> Ram Watch --------------------- + item = gtk_menu_item_new_with_label("Ram Watch..."); + + g_signal_connect( item, "activate", G_CALLBACK(openMemoryWatchWindow), NULL); + + //gtk_widget_add_accelerator( item, "activate", accel_group, + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + //--------------------------------------- + // Create Movie Menu + item = gtk_menu_item_new_with_label("Movie"); + + gtk_menu_shell_append( GTK_MENU_SHELL(menubar), item ); + + menu = gtk_menu_new(); + + gtk_menu_item_set_submenu( GTK_MENU_ITEM(item), menu ); + + // Load Movie Menu Items + //-Movie --> Open --------------------- + item = gtk_menu_item_new_with_label("Open"); + + g_signal_connect( item, "activate", G_CALLBACK(loadMovie), NULL); + + gtk_widget_add_accelerator( item, "activate", accel_group, + GDK_KEY_F7, GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + //-Movie --> Stop --------------------- + item = gtk_menu_item_new_with_label("Stop"); + + g_signal_connect( item, "activate", G_CALLBACK(FCEUI_StopMovie), NULL); + + //gtk_widget_add_accelerator( item, "activate", accel_group, + // GDK_KEY_F7, GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + // Add Separator + item = gtk_separator_menu_item_new(); + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + //-Movie --> Record --------------------- + item = gtk_menu_item_new_with_label("Record"); + + g_signal_connect( item, "activate", G_CALLBACK(recordMovie), NULL); + + gtk_widget_add_accelerator( item, "activate", accel_group, + GDK_KEY_F5, GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + //-Movie --> Record As --------------------- + item = gtk_menu_item_new_with_label("Record As"); + + g_signal_connect( item, "activate", G_CALLBACK(recordMovieAs), NULL); + + //gtk_widget_add_accelerator( item, "activate", accel_group, + // GDK_KEY_F5, GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + //--------------------------------------- + // Create Help Menu + item = gtk_menu_item_new_with_label("Help"); + + gtk_menu_shell_append( GTK_MENU_SHELL(menubar), item ); + + menu = gtk_menu_new(); + + gtk_menu_item_set_submenu( GTK_MENU_ITEM(item), menu ); + + // Load Help Menu Items + //-Help --> About --------------------- + item = gtk_menu_item_new_with_label("About"); + + g_signal_connect( item, "activate", G_CALLBACK(openAbout), NULL); + + //gtk_widget_add_accelerator( item, "activate", accel_group, + // GDK_KEY_F7, GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + // Finally, return the actual menu bar created return menubar; } From d87d5b227105f6fff46925246a34d6cf325a45fe Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sun, 10 May 2020 16:42:45 -0400 Subject: [PATCH 037/156] Fixed & character usage in authors string text in about window. --- src/drivers/sdl/gui.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 09d6c1f1..9d38663b 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -1443,8 +1443,8 @@ const char* Authors[]= { " Luke Gustafson", " _mz", " UncombedCoconut", " DwEdit", " AnS", "rainwarrior", "feos", "Pre 2.0 Guys:", " Bero", " Xodnizel", " Aaron Oneal", " Joe Nahmias", - " Paul Kuliniewicz", " Quietust", " Ben Parnell", " Parasyte & bbitmaster", - " blip & nitsuja", + " Paul Kuliniewicz", " Quietust", " Ben Parnell", " Parasyte & bbitmaster", + " blip & nitsuja", "Included components:", " Mitsutaka Okazaki - YM2413 emulator", " Andrea Mazzoleni - Scale2x/Scale3x scalers", " Gilles Vollant - unzip.c PKZIP fileio", NULL}; From bfaf4296642959dec2befa5fa5d68fb82dedf140 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sun, 10 May 2020 17:11:15 -0400 Subject: [PATCH 038/156] Removed deprecated GTK_STOCK usages. --- src/drivers/sdl/gui.cpp | 76 ++++++++++++++++++++--------------------- 1 file changed, 38 insertions(+), 38 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 9d38663b..5e8075ac 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -389,8 +389,8 @@ void loadPalette (GtkWidget* w, gpointer p) GtkWidget* fileChooser; fileChooser = gtk_file_chooser_dialog_new ("Open NES Palette", GTK_WINDOW(MainWindow), - GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, - GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); + GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel", GTK_RESPONSE_CANCEL, + "_Open", GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fileChooser), "/usr/share/fceux/palettes"); if (gtk_dialog_run (GTK_DIALOG (fileChooser)) ==GTK_RESPONSE_ACCEPT) @@ -434,10 +434,10 @@ void openPaletteConfig(void) win = gtk_dialog_new_with_buttons("Palette Options", GTK_WINDOW(MainWindow), (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT), - GTK_STOCK_CLOSE, + "_Close", GTK_RESPONSE_OK, NULL); - gtk_window_set_icon_name(GTK_WINDOW(win), GTK_STOCK_SELECT_COLOR); + gtk_window_set_icon_name(GTK_WINDOW(win), "Color"); vbox = gtk_dialog_get_content_area(GTK_DIALOG(win)); paletteFrame = gtk_frame_new("Custom palette: "); @@ -558,8 +558,8 @@ void openNetworkConfig(void) GtkWidget* pwBox; GtkWidget* pwLbl; - win = gtk_dialog_new_with_buttons("Network Options",GTK_WINDOW(MainWindow), (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT),GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, GTK_STOCK_CONNECT, GTK_RESPONSE_OK, NULL); - gtk_window_set_icon_name(GTK_WINDOW(win), GTK_STOCK_NETWORK); + win = gtk_dialog_new_with_buttons("Network Options",GTK_WINDOW(MainWindow), (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT),"_Close", GTK_RESPONSE_CLOSE, "_Connect", GTK_RESPONSE_OK, NULL); + gtk_window_set_icon_name(GTK_WINDOW(win), "network-workgroup"); box = gtk_dialog_get_content_area(GTK_DIALOG(win)); userBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); @@ -638,7 +638,7 @@ void openHotkeyConfig() }; GtkWidget* win = gtk_dialog_new_with_buttons("Hotkey Configuration", GTK_WINDOW(MainWindow), (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT), - GTK_STOCK_CLOSE, + "_Close", GTK_RESPONSE_OK, NULL); gtk_window_set_default_size(GTK_WINDOW(win), 400, 800); @@ -795,7 +795,7 @@ void openGamepadConfig(void) win = gtk_dialog_new_with_buttons("Controller Configuration", GTK_WINDOW(MainWindow), (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT), - GTK_STOCK_CLOSE, + "_Close", GTK_RESPONSE_OK, NULL); gtk_window_set_title(GTK_WINDOW(win), "Controller Configuration"); @@ -1084,8 +1084,8 @@ void openVideoConfig(void) win = gtk_dialog_new_with_buttons("Video Preferences", GTK_WINDOW(MainWindow), (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT), - GTK_STOCK_APPLY, GTK_RESPONSE_APPLY, - GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); + "_Apply", GTK_RESPONSE_APPLY, + "_Close", GTK_RESPONSE_CLOSE, NULL); gtk_window_set_icon_name(GTK_WINDOW(win), "video-display"); //gtk_widget_set_size_request(win, 250, 250); @@ -1289,7 +1289,7 @@ void openSoundConfig(void) win = gtk_dialog_new_with_buttons("Sound Preferences", GTK_WINDOW(MainWindow), (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT), - GTK_STOCK_CLOSE, + "_Close", GTK_RESPONSE_OK, NULL); gtk_window_set_icon_name(GTK_WINDOW(win), "audio-x-generic"); @@ -1793,8 +1793,8 @@ static void openCheatFile( GtkWidget *widget, gtk_file_filter_set_name(filterAll, "All Files"); fileChooser = gtk_file_chooser_dialog_new ("Open Cheat", GTK_WINDOW(MainWindow), - GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, - GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); + GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel", GTK_RESPONSE_CANCEL, + "_Open", GTK_RESPONSE_ACCEPT, NULL); const char* last_dir; g_config->getOption("SDL.LastOpenFile", &last_dir); gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(fileChooser), last_dir); @@ -2097,7 +2097,7 @@ static void openCheatsWindow(void) win = gtk_dialog_new_with_buttons("Cheats", GTK_WINDOW(MainWindow), (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT), - GTK_STOCK_CLOSE, + "_Close", GTK_RESPONSE_OK, NULL); gtk_window_set_default_size(GTK_WINDOW(win), 600, 600); @@ -2721,14 +2721,14 @@ static void openWatchFile( int mode ) if ( mode ) { fileChooser = gtk_file_chooser_dialog_new ("Save Watch File", GTK_WINDOW(MainWindow), - GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, - GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); + GTK_FILE_CHOOSER_ACTION_SAVE, "_Cancel", GTK_RESPONSE_CANCEL, + "_Save", GTK_RESPONSE_ACCEPT, NULL); } else { fileChooser = gtk_file_chooser_dialog_new ("Load Watch File", GTK_WINDOW(MainWindow), - GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, - GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); + GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel", GTK_RESPONSE_CANCEL, + "_Open", GTK_RESPONSE_ACCEPT, NULL); } //gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fileChooser), last_dir); @@ -2816,7 +2816,7 @@ static int openRamWatchEntryDialog( char *name, int *addr, int *type, int *size win = gtk_dialog_new_with_buttons("RAM Watch Entry", GTK_WINDOW(MainWindow), (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT), - GTK_STOCK_CLOSE, + "_Close", GTK_RESPONSE_OK, NULL); gtk_window_set_default_size(GTK_WINDOW(win), 400, 200); @@ -3072,7 +3072,7 @@ static void openMemoryWatchWindow(void) win = gtk_dialog_new_with_buttons("RAM Watch", GTK_WINDOW(MainWindow), (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT), - GTK_STOCK_CLOSE, + "_Close", GTK_RESPONSE_OK, NULL); gtk_window_set_default_size(GTK_WINDOW(win), 600, 600); @@ -3205,8 +3205,8 @@ void recordMovieAs () gtk_file_filter_set_name(filterAll, "All Files"); fileChooser = gtk_file_chooser_dialog_new ("Save FM2 movie for recording", GTK_WINDOW(MainWindow), - GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, - GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); + GTK_FILE_CHOOSER_ACTION_SAVE, "_Cancel", GTK_RESPONSE_CANCEL, + "_Save", GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER(fileChooser), ".fm2"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterFm2); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterAll); @@ -3253,8 +3253,8 @@ void loadMovie (void) gtk_file_filter_set_name(filterAll, "All Files"); fileChooser = gtk_file_chooser_dialog_new ("Open FM2 Movie", GTK_WINDOW(MainWindow), - GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, - GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); + GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel", GTK_RESPONSE_CANCEL, + "_Open", GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterMovies); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterFm2); @@ -3299,8 +3299,8 @@ void loadLua (void) gtk_file_filter_set_name(filterAll, "All Files"); fileChooser = gtk_file_chooser_dialog_new ("Open LUA Script", GTK_WINDOW(MainWindow), - GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, - GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); + GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel", GTK_RESPONSE_CANCEL, + "_Open", GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterLua); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterAll); @@ -3357,8 +3357,8 @@ void loadFdsBios (void) fileChooser = gtk_file_chooser_dialog_new ("Load FDS BIOS (disksys.rom)", GTK_WINDOW(MainWindow), - GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, - GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); + GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel", GTK_RESPONSE_CANCEL, + "_Open", GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterDiskSys); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterRom); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterAll); @@ -3450,8 +3450,8 @@ void loadGameGenie () fileChooser = gtk_file_chooser_dialog_new ("Load Game Genie ROM", GTK_WINDOW(MainWindow), - GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, - GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); + GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel", GTK_RESPONSE_CANCEL, + "_Open", GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterGG); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterRom); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterNes); @@ -3503,8 +3503,8 @@ void loadNSF (void) gtk_file_filter_set_name(filterAll, "All Files"); fileChooser = gtk_file_chooser_dialog_new ("Open NSF File", GTK_WINDOW(MainWindow), - GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, - GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); + GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel", GTK_RESPONSE_CANCEL, + "_Open", GTK_RESPONSE_ACCEPT, NULL); const char* last_dir; g_config->getOption("SDL.LastOpenNSF", &last_dir); @@ -3592,8 +3592,8 @@ void loadGame (void) fileChooser = gtk_file_chooser_dialog_new ("Open ROM", GTK_WINDOW(MainWindow), - GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, - GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); + GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel", GTK_RESPONSE_CANCEL, + "_Open", GTK_RESPONSE_ACCEPT, NULL); const char* last_dir; g_config->getOption("SDL.LastOpenFile", &last_dir); gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(fileChooser), last_dir); @@ -3650,8 +3650,8 @@ void saveStateAs(void) g_config->getOption("SDL.LastSaveStateAs", &last_dir); fileChooser = gtk_file_chooser_dialog_new ("Save State As", GTK_WINDOW(MainWindow), - GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, - GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); + GTK_FILE_CHOOSER_ACTION_SAVE, "_Cancel", GTK_RESPONSE_CANCEL, + "_Save", GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fileChooser), last_dir); @@ -3695,8 +3695,8 @@ void loadStateFrom(void) gtk_file_filter_set_name(filterAll, "All Files"); fileChooser = gtk_file_chooser_dialog_new ("Load State From", GTK_WINDOW(MainWindow), - GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, - GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); + GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel", GTK_RESPONSE_CANCEL, + "_Open", GTK_RESPONSE_ACCEPT, NULL); const char* last_dir; g_config->getOption("SDL.LastLoadStateFrom", &last_dir); From d6a798962c4955a4bc8e38bca5245f13753dd443 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sun, 10 May 2020 17:29:14 -0400 Subject: [PATCH 039/156] Removed deprecated gtk_widget_modify_bg. --- src/drivers/sdl/gui.cpp | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 5e8075ac..729850f9 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -3540,8 +3540,8 @@ void loadNSF (void) void closeGame(void) { - GdkColor bg = {0, 0, 0, 0}; - gtk_widget_modify_bg(evbox, GTK_STATE_NORMAL, &bg); + //GdkColor bg = {0, 0, 0, 0}; + //gtk_widget_modify_bg(evbox, GTK_STATE_NORMAL, &bg); CloseGame(); } @@ -4836,6 +4836,7 @@ int InitGTKSubsystem(int argc, char** argv) // prg - Bryan Cain, you are the man! evbox = gtk_event_box_new(); + //evbox = gtk_drawing_area_new(); gtk_box_pack_start (GTK_BOX(vbox), evbox, TRUE, TRUE, 0); double xscale, yscale; @@ -4847,8 +4848,8 @@ int InitGTKSubsystem(int argc, char** argv) gtk_widget_show(evbox); gtk_widget_show_all(vbox); - GdkColor bg = {0, 0, 0, 0}; - gtk_widget_modify_bg(evbox, GTK_STATE_NORMAL, &bg); + //GdkColor bg = {0, 0, 0, 0}; + //gtk_widget_modify_bg(evbox, GTK_STATE_NORMAL, &bg); // set up keypress "snooper" to convert GDK keypress events into SDL keypresses gtk_key_snooper_install(convertKeypress, NULL); From dfd236c9d1a90dcc35081c53f6c17ee8bc514acb Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sun, 10 May 2020 23:38:36 -0400 Subject: [PATCH 040/156] Fixed gtk window gui resizing logic. Can now resize by dragging the corners of the window with the mouse as well as through the vidio menu. --- SConstruct | 2 +- src/cart.h | 2 +- src/drivers/sdl/gui.cpp | 38 +++++++++++++++++++++-------------- src/drivers/sdl/sdl-video.cpp | 17 ++++++++-------- 4 files changed, 34 insertions(+), 25 deletions(-) diff --git a/SConstruct b/SConstruct index 1c6a3246..86133ba5 100644 --- a/SConstruct +++ b/SConstruct @@ -44,7 +44,7 @@ if platform.system == "ppc": env['LSB_FIRST'] = 0 # Default compiler flags: -env.Append(CCFLAGS = ['-Wall', '-Wno-write-strings', '-Wno-sign-compare']) +env.Append(CCFLAGS = ['-Wall', '-Wno-write-strings', '-Wno-sign-compare', '-Wno-parentheses', '-Wno-unused-local-typedefs']) env.Append(CXXFLAGS = ['-std=c++0x']) if 'PLATFORM' in os.environ: diff --git a/src/cart.h b/src/cart.h index e94ee17b..e78c87ea 100644 --- a/src/cart.h +++ b/src/cart.h @@ -104,4 +104,4 @@ bool FCEU_OpenGenie(void); void FCEU_CloseGenie(void); void FCEU_KillGenie(void); -#endif#endif \ No newline at end of file +#endif diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 729850f9..4d1c5973 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -43,6 +43,10 @@ #define gtk_combo_box_text_append_text gtk_combo_box_append_text #endif +// NES resolution = 256x240 +const int NES_WIDTH=256; +const int NES_HEIGHT=240; + void toggleSound(GtkWidget* check, gpointer data); void loadGame (void); void closeGame(void); @@ -297,8 +301,9 @@ int configGamepadButton(GtkButton* button, gpointer p) return 0; } -void resetVideo() +void resetVideo(void) { + resizeGtkWindow(); KillVideo(); InitVideo(GameInfo); } @@ -945,18 +950,20 @@ void setQuality(GtkWidget* w, gpointer p) return; } -void resizeGtkWindow() +void resizeGtkWindow(void) { - if(GameInfo == 0) - { + //if(GameInfo == 0) + //{ double xscale, yscale; g_config->getOption("SDL.XScale", &xscale); g_config->getOption("SDL.YScale", &yscale); - gtk_widget_set_size_request(evbox, 256*xscale, 224*yscale); + gtk_widget_set_size_request(evbox, NES_WIDTH*xscale, NES_HEIGHT*yscale); GtkRequisition req; gtk_widget_get_preferred_size(GTK_WIDGET(MainWindow), NULL, &req); + //printf("GTK Resizing: w:%i h:%i \n", req.width, req.height ); gtk_window_resize(GTK_WINDOW(MainWindow), req.width, req.height); - } + gtk_widget_set_size_request(evbox, NES_WIDTH, NES_HEIGHT); + //} return; } @@ -4749,11 +4756,8 @@ gint handleMouseClick(GtkWidget* widget, GdkEvent *event, gpointer callback_data return 0; } -// NES resolution = 256x240 -const int NES_WIDTH=256; -const int NES_HEIGHT=240; -void handle_resize(GtkWindow* win, GdkEvent* event, gpointer data) +gboolean handle_resize(GtkWindow* win, GdkEvent* event, gpointer data) { // TODO this is a stub atm // this should handle resizing so the emulation takes up as much @@ -4764,7 +4768,7 @@ void handle_resize(GtkWindow* win, GdkEvent* event, gpointer data) int width, height; width = event->configure.width; height = event->configure.height; - printf("DEBUG: new window size: %dx%d\n", width, height); + printf("DEBUG: Configure new window size: %dx%d\n", width, height); // get width/height multipliers double xscale = width / (double)NES_WIDTH; @@ -4787,7 +4791,7 @@ void handle_resize(GtkWindow* win, GdkEvent* event, gpointer data) KillVideo(); InitVideo(GameInfo); } - gtk_widget_set_size_request(evbox, (int)(NES_WIDTH*xscale), (int)(NES_HEIGHT*yscale)); + //gtk_widget_set_size_request(evbox, (int)(NES_WIDTH*xscale), (int)(NES_HEIGHT*yscale)); // Currently unused; unsure why /* GdkColor black; @@ -4798,7 +4802,7 @@ void handle_resize(GtkWindow* win, GdkEvent* event, gpointer data) printf("DEBUG: new xscale: %f yscale: %f\n", xscale, yscale); - return; + return FALSE; } int InitGTKSubsystem(int argc, char** argv) @@ -4864,13 +4868,17 @@ int InitGTKSubsystem(int argc, char** argv) g_signal_connect(MainWindow, "delete-event", quit, NULL); g_signal_connect(MainWindow, "destroy-event", quit, NULL); // resize handler -// g_signal_connect(MainWindow, "configure-event", G_CALLBACK(handle_resize), NULL); + g_signal_connect(MainWindow, "configure-event", G_CALLBACK(handle_resize), NULL); gtk_widget_show_all(MainWindow); GtkRequisition req; gtk_widget_get_preferred_size(GTK_WIDGET(MainWindow), NULL, &req); - gtk_window_resize(GTK_WINDOW(MainWindow), req.width, req.height); + //printf("Init Resize: w:%i h:%i \n", req.width, req.height ); + gtk_window_resize(GTK_WINDOW(MainWindow), req.width, req.height ); + + // Once the window has been resized, return draw area size request to minimum values + gtk_widget_set_size_request(evbox, NES_WIDTH, NES_HEIGHT); gtkIsStarted = true; return 0; diff --git a/src/drivers/sdl/sdl-video.cpp b/src/drivers/sdl/sdl-video.cpp index ef8d4df2..d26b6df9 100644 --- a/src/drivers/sdl/sdl-video.cpp +++ b/src/drivers/sdl/sdl-video.cpp @@ -429,14 +429,15 @@ InitVideo(FCEUGI *gi) return -1; } -#ifdef _GTK - if(noGui == 0) - { - GtkRequisition req; - gtk_widget_get_preferred_size(GTK_WIDGET(MainWindow), NULL, &req); - gtk_window_resize(GTK_WINDOW(MainWindow), req.width, req.height); - } -#endif + // This code is not needed, gui.cpp handles all window sizing. +//#ifdef _GTK +// if(noGui == 0) +// { +// GtkRequisition req; +// gtk_widget_get_preferred_size(GTK_WIDGET(MainWindow), NULL, &req); +// gtk_window_resize(GTK_WINDOW(MainWindow), req.width, req.height); +// } +//#endif } s_curbpp = s_screen->format->BitsPerPixel; if(!s_screen) { From 754e621735be059abe00133373842a0ef89ce139 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Mon, 11 May 2020 00:47:31 -0400 Subject: [PATCH 041/156] Bug fixes for gtk hot key config window. --- src/drivers/sdl/gui.cpp | 200 +++++++++++++++++++------------------- src/drivers/sdl/input.cpp | 2 +- 2 files changed, 100 insertions(+), 102 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 4d1c5973..7674369f 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -62,6 +62,7 @@ GtkRadioAction* stateSlot = NULL; bool gtkIsStarted = false; bool menuTogglingEnabled = false; +static GtkTreeStore *hotkey_store = NULL; //----------------------------------------- // Cheat static variables static GtkTreeStore *actv_cheats_store = NULL; @@ -225,39 +226,6 @@ void setCheckbox(GtkWidget* w, const char* configName) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), buf); } -// This function configures a single hotkey -int configHotkey(char* hotkeyString) -{ - // This is broken right now - //SDL_Surface *screen; -// SDL_Event event; -// KillVideo(); -#if SDL_VERSION_ATLEAST(2, 0, 0) - return 0; // TODO - SDL 2.0 -#else - //screen = SDL_SetVideoMode(420, 200, 8, 0); - //SDL_WM_SetCaption("Press a key to bind...", 0); -/* - int newkey = 0; - while(1) - { - SDL_WaitEvent(&event); - - switch (event.type) - { - case SDL_KEYDOWN: - newkey = event.key.keysym.sym; - g_config->setOption(hotkeyString, newkey); - extern FCEUGI *GameInfo; - InitVideo(GameInfo); - return 0; - } - } - - return 0;*/ -#endif - return 0; -} // This function configures a single button on a gamepad int configGamepadButton(GtkButton* button, gpointer p) { @@ -620,9 +588,8 @@ void openNetworkConfig(void) } // handler prototype -static void tree_selection_changed_cb (GtkTreeSelection *selection, gpointer data); -void flushGtkEvents() +void flushGtkEvents(void) { while (gtk_events_pending ()) gtk_main_iteration_do (FALSE); @@ -632,15 +599,99 @@ void flushGtkEvents() GtkWidget* HotkeyWin; -// creates and opens hotkey config window -void openHotkeyConfig() +static void hotKeyWindowRefresh(void) { - enum + GtkTreeIter iter; + std::string prefix = "SDL.Hotkeys."; + + if ( hotkey_store == NULL ) return; + + gtk_tree_store_clear(hotkey_store); + + gtk_tree_store_append(hotkey_store, &iter, NULL); // aquire iter + + int keycode; + for(int i=0; igetOption(optionName.c_str(), &keycode); + gtk_tree_store_set(hotkey_store, &iter, + 0, optionName.c_str(), + 1, +#if SDL_VERSION_ATLEAST(2, 0, 0) + SDL_GetKeyName(keycode), +#else + SDL_GetKeyName((SDLKey)keycode), +#endif + -1); + gtk_tree_store_append(hotkey_store, &iter, NULL); // acquire child iterator + } + +} + +static gint hotKeyPressCB(GtkTreeView* tree, GdkEventKey* event, gpointer cb_data) +{ + int numListRows; + GList *selListRows, *tmpList; + GtkTreeModel *model = NULL; + GtkTreeSelection *treeSel = gtk_tree_view_get_selection(tree); + + printf("Hot Key Press: %i \n", event->keyval ); + + numListRows = gtk_tree_selection_count_selected_rows( treeSel ); + + if ( numListRows == 0 ) + { + return FALSE; + } + //printf("Number of Rows Selected: %i\n", numListRows ); + + selListRows = gtk_tree_selection_get_selected_rows( treeSel, &model ); + + tmpList = selListRows; + + while ( tmpList ) { - COMMAND_COLUMN, - KEY_COLUMN, - N_COLUMNS - }; + int depth; + int *indexArray; + GtkTreePath *path = (GtkTreePath*)tmpList->data; + + depth = gtk_tree_path_get_depth(path); + indexArray = gtk_tree_path_get_indices(path); + + if ( depth > 0 ) + { + int sdlkey = 0; + std::string hotKeyName = "SDL.Hotkeys."; + hotKeyName.append( HotkeyStrings[indexArray[0]] ); + + // Convert this keypress from GDK to SDL. + #if SDL_VERSION_ATLEAST(2, 0, 0) + sdlkey = GDKToSDLKeyval(event->keyval); + #else + sdlkey = (SDLKey)GDKToSDLKeyval(event->keyval); + #endif + printf("HotKey Index: %i '%s' %i %i \n", + indexArray[0], hotKeyName.c_str(), event->keyval, sdlkey ); + + g_config->setOption( hotKeyName, sdlkey ); + + setHotKeys(); // Update Hot Keys in Input Model + + hotKeyWindowRefresh(); + } + + tmpList = tmpList->next; + } + + g_list_free_full(selListRows, (GDestroyNotify) gtk_tree_path_free); + + return TRUE; +} + +// creates and opens hotkey config window +void openHotkeyConfig(void) +{ GtkWidget* win = gtk_dialog_new_with_buttons("Hotkey Configuration", GTK_WINDOW(MainWindow), (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT), "_Close", @@ -652,43 +703,22 @@ void openHotkeyConfig() GtkWidget *vbox; GtkWidget *scroll; - - vbox = gtk_dialog_get_content_area(GTK_DIALOG(win)); - GtkTreeStore *hotkey_store = gtk_tree_store_new(N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING); + hotkey_store = gtk_tree_store_new(2, G_TYPE_STRING, G_TYPE_STRING); - std::string prefix = "SDL.Hotkeys."; - GtkTreeIter iter; - - gtk_tree_store_append(hotkey_store, &iter, NULL); // aquire iter - - int keycode; - for(int i=0; igetOption(optionName.c_str(), &keycode); - gtk_tree_store_set(hotkey_store, &iter, - COMMAND_COLUMN, optionName.c_str(), - KEY_COLUMN, -#if SDL_VERSION_ATLEAST(2, 0, 0) - SDL_GetKeyName(keycode), -#else - SDL_GetKeyName((SDLKey)keycode), -#endif - -1); - gtk_tree_store_append(hotkey_store, &iter, NULL); // acquire child iterator - } + hotKeyWindowRefresh(); tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(hotkey_store)); GtkCellRenderer *renderer; GtkTreeViewColumn* column; + g_signal_connect(G_OBJECT(tree), "key-press-event", G_CALLBACK(hotKeyPressCB), NULL); renderer = gtk_cell_renderer_text_new(); - column = gtk_tree_view_column_new_with_attributes("Command", renderer, "text", COMMAND_COLUMN, NULL); + column = gtk_tree_view_column_new_with_attributes("Command", renderer, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); - column = gtk_tree_view_column_new_with_attributes("Key", renderer, "text", KEY_COLUMN, NULL); + column = gtk_tree_view_column_new_with_attributes("Key", renderer, "text", 1, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, @@ -698,40 +728,8 @@ void openHotkeyConfig() gtk_widget_show_all(win); g_signal_connect(win, "delete-event", G_CALLBACK(closeDialog), NULL); - g_signal_connect(win, "response", G_CALLBACK(closeDialog), NULL); + g_signal_connect(win, "response", G_CALLBACK(closeDialog), NULL); - GtkTreeSelection *select; - - select = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree)); - gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE); - g_signal_connect ( G_OBJECT (select), "changed", G_CALLBACK (tree_selection_changed_cb), - NULL); - gtk_tree_selection_unselect_all (select); -} - -static void tree_selection_changed_cb (GtkTreeSelection *selection, gpointer data) -{ - GtkTreeIter iter; - GtkTreeModel *model; - char* hotkey; - - if (gtk_tree_selection_get_selected (selection, &model, &iter)) - { - gtk_tree_model_get (model, &iter, 0, &hotkey, -1); - - gtk_widget_hide(HotkeyWin); - - flushGtkEvents(); - - configHotkey(hotkey); - - g_signal_emit_by_name(HotkeyWin, "destroy-event"); - - openHotkeyConfig(); - - g_free (hotkey); - - } } GtkWidget* typeCombo; diff --git a/src/drivers/sdl/input.cpp b/src/drivers/sdl/input.cpp index 3cf13b3c..1fdb891b 100644 --- a/src/drivers/sdl/input.cpp +++ b/src/drivers/sdl/input.cpp @@ -177,7 +177,7 @@ int Hotkeys[HK_MAX] = { 0 }; // on every cycle of keyboardinput() void -setHotKeys () +setHotKeys (void) { std::string prefix = "SDL.Hotkeys."; for (int i = 0; i < HK_MAX; i++) From 309cb00f939553d6477b2d267d1b0899339016db Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Tue, 12 May 2020 20:14:11 -0400 Subject: [PATCH 042/156] Moved cheat window code to its own file. Created a cheat window class object to better manage multiple instances of the cheat window. --- src/drivers/sdl/SConscript | 1 + src/drivers/sdl/cheat.cpp | 1097 ++++++++++++++++++++++++++++++++++++ src/drivers/sdl/cheat.h | 3 + src/drivers/sdl/gui.cpp | 904 +---------------------------- 4 files changed, 1102 insertions(+), 903 deletions(-) create mode 100644 src/drivers/sdl/cheat.cpp create mode 100644 src/drivers/sdl/cheat.h diff --git a/src/drivers/sdl/SConscript b/src/drivers/sdl/SConscript index 23e11b95..d9f86ceb 100644 --- a/src/drivers/sdl/SConscript +++ b/src/drivers/sdl/SConscript @@ -8,6 +8,7 @@ Export('env') source_list = Split( """ input.cpp + cheat.cpp config.cpp sdl.cpp sdl-joystick.cpp diff --git a/src/drivers/sdl/cheat.cpp b/src/drivers/sdl/cheat.cpp new file mode 100644 index 00000000..e15d1427 --- /dev/null +++ b/src/drivers/sdl/cheat.cpp @@ -0,0 +1,1097 @@ +#include +#include +#include +#include +#include + +#include +#include +#ifdef GDK_WINDOWING_X11 +#include +#endif + +#ifdef _GTK3 +#include +#endif + +#include "../../types.h" +#include "../../fceu.h" +#include "../../cheat.h" +#include "../../debug.h" +#include "../../driver.h" +#include "../../version.h" +#include "../../movie.h" +#include "../../palette.h" +#include "../../fds.h" +#include "../common/configSys.h" + +#include "sdl.h" +#include "gui.h" +#include "dface.h" +#include "input.h" +#include "config.h" + +extern Config *g_config; + +static void updateAllActvCheatLists( bool redraw ); + +//----------------------------------------- +class cheat_win_t +{ + public: + + GtkTreeStore *actv_cheats_store; + GtkTreeStore *ram_match_store; + GtkTreeIter actv_cheats_iter; + GtkTreeIter ram_match_iter; + int cheat_search_known_value; + int cheat_search_neq_value; + int cheat_search_gt_value; + int cheat_search_lt_value; + int new_cheat_addr; + int new_cheat_val ; + int new_cheat_cmp ; + std::string new_cheat_name; + bool wasPausedByCheats; + bool pauseWhileCheatsActv; + bool actv_cheat_redraw; + + GtkWidget *actv_cheat_tree; + GtkWidget *search_cheat_tree; + GtkWidget *neq_chkbox; + GtkWidget *lt_chkbox; + GtkWidget *gt_chkbox; + + cheat_win_t(void) + { + actv_cheats_store = NULL; + ram_match_store = NULL; + cheat_search_known_value = 0; + cheat_search_neq_value = 0; + cheat_search_gt_value = 0; + cheat_search_lt_value = 0; + new_cheat_addr = -1; + new_cheat_val = -1; + new_cheat_cmp = -1; + wasPausedByCheats = false; + pauseWhileCheatsActv = false; + actv_cheat_redraw = true; + actv_cheat_tree = NULL; + search_cheat_tree = NULL; + neq_chkbox = NULL; + lt_chkbox = NULL; + gt_chkbox = NULL; + } + + void showActiveCheatList( bool reset ); + void showCheatSearchResults(void); +}; +static cheat_win_t *curr_cw = NULL; +static std::list cheatWinList; + +//******************************************************************************************************* +// Cheat Window +//******************************************************************************************************* + +static int ShowCheatSearchResultsCallB(uint32 a, uint8 last, uint8 current) +{ + char addrStr[32], lastStr[32], curStr[32]; + + sprintf( addrStr, "0x%04X ", a ); + sprintf( lastStr, " 0x%02X ", last ); + sprintf( curStr, " 0x%02X ", current ); + + gtk_tree_store_append( curr_cw->ram_match_store, &curr_cw->ram_match_iter, NULL); // aquire iter + + gtk_tree_store_set(curr_cw->ram_match_store, &curr_cw->ram_match_iter, + 0, addrStr, 1, lastStr, 2, curStr, + -1); + + return 1; +} + +void cheat_win_t::showCheatSearchResults(void) +{ + int total_matches = 0; + + curr_cw = this; + + gtk_tree_store_clear(ram_match_store); + + total_matches = FCEUI_CheatSearchGetCount(); + + //printf("Cheat Search Matches: %i \n", total_matches ); + + FCEUI_CheatSearchGetRange( 0, total_matches, ShowCheatSearchResultsCallB ); +} + +static void cheatSearchReset( GtkButton *button, + cheat_win_t *cw) +{ + //printf("Cheat Search Reset!\n"); + + //cheat_search_known_value = 0; + //cheat_search_neq_value = 0; + //cheat_search_gt_value = 0; + //cheat_search_lt_value = 0; + + FCEUI_CheatSearchBegin(); + cw->showCheatSearchResults(); + // Enable Cheat Search Buttons - Change Sensitivity +} + +static void cheatSearchKnown( GtkButton *button, + cheat_win_t *cw) +{ + //printf("Cheat Search Known!\n"); + + FCEUI_CheatSearchEnd(FCEU_SEARCH_NEWVAL_KNOWN, cw->cheat_search_known_value, 0); + cw->showCheatSearchResults(); +} + +static void cheatSearchEqual( GtkButton *button, + cheat_win_t *cw) +{ + + //printf("Cheat Search Equal !\n"); + + FCEUI_CheatSearchEnd(FCEU_SEARCH_PUERLY_RELATIVE_CHANGE, 0, 0); + cw->showCheatSearchResults(); +} + +static void cheatSearchNotEqual( GtkButton *button, + cheat_win_t *cw ) +{ + int checked = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(cw->neq_chkbox) ); + + //printf("Cheat Search NotEqual %i!\n", checked); + + if ( checked ){ + FCEUI_CheatSearchEnd(FCEU_SEARCH_PUERLY_RELATIVE_CHANGE, 0, cw->cheat_search_neq_value); + } else { + FCEUI_CheatSearchEnd(FCEU_SEARCH_ANY_CHANGE, 0, 0); + } + cw->showCheatSearchResults(); +} + +static void cheatSearchGreaterThan( GtkButton *button, + cheat_win_t *cw ) +{ + int checked = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(cw->gt_chkbox) ); + + //printf("Cheat Search GreaterThan %i!\n", checked); + + if ( checked ){ + FCEUI_CheatSearchEnd(FCEU_SEARCH_NEWVAL_GT_KNOWN, 0, cw->cheat_search_gt_value); + } else { + FCEUI_CheatSearchEnd(FCEU_SEARCH_NEWVAL_GT, 0, 0); + } + cw->showCheatSearchResults(); +} + +static void cheatSearchLessThan( GtkButton *button, + cheat_win_t *cw ) +{ + int checked = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(cw->lt_chkbox) ); + + //printf("Cheat Search LessThan %i!\n", checked); + + if ( checked ){ + FCEUI_CheatSearchEnd(FCEU_SEARCH_NEWVAL_LT_KNOWN, 0, cw->cheat_search_lt_value); + } else { + FCEUI_CheatSearchEnd(FCEU_SEARCH_NEWVAL_LT, 0, 0); + } + cw->showCheatSearchResults(); +} + +static void pauseDuringCheatWinActvCB( GtkToggleButton *button, + cheat_win_t *cw ) +{ + cw->pauseWhileCheatsActv = gtk_toggle_button_get_active(button); + + if ( cw->pauseWhileCheatsActv ) + { + if ( EmulationPaused == 0 ) + { + EmulationPaused = 1; + cw->wasPausedByCheats = true; + } + } + else + { + if ( EmulationPaused && cw->wasPausedByCheats ) + { + EmulationPaused = 0; + } + cw->wasPausedByCheats = false; + } + FCEU_printf("Emulation paused: %d\n", EmulationPaused); +} + +static void cheatSearchValueEntryCB1( GtkWidget *widget, + cheat_win_t *cw ) +{ + long value; + const gchar *entry_text; + entry_text = gtk_entry_get_text (GTK_ENTRY (widget)); + + value = strtol( entry_text, NULL, 16 ); + + cw->cheat_search_known_value = value; + + //printf("Cheat Value Entry contents: '%s' Value: 0x%02lx\n", entry_text, value); +} + +static void cheatSearchValueEntryCB2( GtkWidget *widget, + cheat_win_t *cw ) +{ + long value; + const gchar *entry_text; + entry_text = gtk_entry_get_text (GTK_ENTRY (widget)); + + value = strtol( entry_text, NULL, 16 ); + + cw->cheat_search_neq_value = value; + + //printf("Cheat Value Entry contents: '%s' Value: 0x%02lx\n", entry_text, value); +} + +static void cheatSearchValueEntryCB3( GtkWidget *widget, + cheat_win_t *cw ) +{ + long value; + const gchar *entry_text; + entry_text = gtk_entry_get_text (GTK_ENTRY (widget)); + + value = strtol( entry_text, NULL, 16 ); + + cw->cheat_search_gt_value = value; + + //printf("Cheat Value Entry contents: '%s' Value: 0x%02lx\n", entry_text, value); +} + +static void cheatSearchValueEntryCB4( GtkWidget *widget, + cheat_win_t *cw ) +{ + long value; + const gchar *entry_text; + entry_text = gtk_entry_get_text (GTK_ENTRY (widget)); + + value = strtol( entry_text, NULL, 16 ); + + cw->cheat_search_lt_value = value; + + //printf("Cheat Value Entry contents: '%s' Value: 0x%02lx\n", entry_text, value); +} + +static int activeCheatListCB(char *name, uint32 a, uint8 v, int c, int s, int type, void* data) +{ + char addrStr[32], valStr[16], cmpStr[16]; + //printf("Cheat Name:'%s' Addr:0x%04x Val:0x%02x \n", name, a, v ); + // + cheat_win_t *cw = (cheat_win_t *)data; + + if ( cw->actv_cheat_redraw ) + { + gtk_tree_store_append( cw->actv_cheats_store, &cw->actv_cheats_iter, NULL); // aquire iter + } + + sprintf( addrStr, "0x%04X ", a ); + sprintf( valStr, " 0x%02X ", v ); + + if ( c >= 0 ){ + sprintf( cmpStr, " 0x%02X ", c ); + } else { + strcpy( cmpStr, " 0xFF "); + } + + gtk_tree_store_set(cw->actv_cheats_store, &cw->actv_cheats_iter, + 0, s, 1, addrStr, 2, valStr, 3, cmpStr, 4, name, + -1); + + if ( !cw->actv_cheat_redraw ) + { + if ( !gtk_tree_model_iter_next( GTK_TREE_MODEL(cw->actv_cheats_store), &cw->actv_cheats_iter ) ) + { + gtk_tree_store_append( cw->actv_cheats_store, &cw->actv_cheats_iter, NULL); // aquire iter + } + } + + return 1; +} + +void cheat_win_t::showActiveCheatList( bool reset ) +{ + actv_cheat_redraw = reset; + + if ( actv_cheat_redraw ) + { + gtk_tree_store_clear(actv_cheats_store); + } + else + { + if ( !gtk_tree_model_get_iter_first( GTK_TREE_MODEL(actv_cheats_store), &actv_cheats_iter ) ) + { + //printf("No Tree Entries Loaded.\n"); + actv_cheat_redraw = 1; + } + } + + FCEUI_ListCheats( activeCheatListCB, (void*)this ); + + actv_cheat_redraw = false; +} + +static void cheatListEnableToggle( GtkCellRendererToggle *renderer, + gchar *pathStr, + cheat_win_t *cw ) +{ + GtkTreePath *path; + int depth; + int *indexArray; + + path = gtk_tree_path_new_from_string( pathStr ); + + if ( path == NULL ){ + printf("Error: gtk_tree_path_new_from_string failed\n"); + return; + } + + depth = gtk_tree_path_get_depth(path); + indexArray = gtk_tree_path_get_indices(path); + + if ( depth > 0 ) + { + //printf("Toggle: %i\n", indexArray[0] ); + FCEUI_ToggleCheat( indexArray[0] ); + } + + gtk_tree_path_free( path ); + + updateAllActvCheatLists(0); + +} + +static void openCheatFile( GtkWidget *widget, + cheat_win_t *cw ) +{ + GtkWidget* fileChooser; + GtkFileFilter* filterCht; + GtkFileFilter* filterAll; + + filterCht = gtk_file_filter_new(); + filterAll = gtk_file_filter_new(); + + gtk_file_filter_add_pattern(filterCht, "*.cht"); + gtk_file_filter_add_pattern(filterAll, "*"); + + gtk_file_filter_set_name(filterCht, "*.cht"); + gtk_file_filter_set_name(filterAll, "All Files"); + + fileChooser = gtk_file_chooser_dialog_new ("Open Cheat", GTK_WINDOW(MainWindow), + GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel", GTK_RESPONSE_CANCEL, + "_Open", GTK_RESPONSE_ACCEPT, NULL); + const char* last_dir; + g_config->getOption("SDL.LastOpenFile", &last_dir); + gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(fileChooser), last_dir); + + gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterCht); + gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterAll); + + if (gtk_dialog_run (GTK_DIALOG (fileChooser)) ==GTK_RESPONSE_ACCEPT) + { + FILE *fp; + char* filename; + + filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fileChooser)); + gtk_widget_destroy (fileChooser); + + fp = fopen( filename, "r"); + + if ( fp != NULL ) + { + FCEU_LoadGameCheats( fp, 0 ); + fclose(fp); + } + //g_config->setOption("SDL.LastOpenFile", filename); + // Error dialog no longer required with GTK implementation of FCEUD_PrintError() + + resizeGtkWindow(); + g_free( filename); + } + else + { + gtk_widget_destroy (fileChooser); + } + + updateAllActvCheatLists(1); +} + +static void newCheatEntryCB1( GtkWidget *widget, + cheat_win_t *cw ) +{ + const gchar *entry_text; + entry_text = gtk_entry_get_text (GTK_ENTRY (widget)); + + if ( entry_text[0] == 0 ) + { + cw->new_cheat_addr = -1; + } + else + { + cw->new_cheat_addr = strtol( entry_text, NULL, 16 ); + } +} + +static void newCheatEntryCB2( GtkWidget *widget, + cheat_win_t *cw ) +{ + const gchar *entry_text; + entry_text = gtk_entry_get_text (GTK_ENTRY (widget)); + + if ( entry_text[0] == 0 ) + { + cw->new_cheat_val = -1; + } + else + { + cw->new_cheat_val = strtol( entry_text, NULL, 16 ); + } +} + +static void newCheatEntryCB3( GtkWidget *widget, + cheat_win_t *cw ) +{ + const gchar *entry_text; + entry_text = gtk_entry_get_text (GTK_ENTRY (widget)); + + if ( entry_text[0] == 0 ) + { + cw->new_cheat_cmp = -1; + } + else + { + cw->new_cheat_cmp = strtol( entry_text, NULL, 16 ); + } +} + +static void newCheatEntryCB4( GtkWidget *widget, + cheat_win_t *cw ) +{ + const gchar *entry_text; + entry_text = gtk_entry_get_text (GTK_ENTRY (widget)); + + cw->new_cheat_name.assign( entry_text ); +} + +static void addCheat2Active( GtkWidget *widget, + cheat_win_t *cw ) +{ + + if ( (cw->new_cheat_addr >= 0) && (cw->new_cheat_val >= 0) ) + { + if ( FCEUI_AddCheat( cw->new_cheat_name.c_str(), cw->new_cheat_addr, cw->new_cheat_val, cw->new_cheat_cmp, 1) ) + { + updateAllActvCheatLists(1); + } + } +} + +static void removeCheatFromActive( GtkWidget *widget, + cheat_win_t *cw ) +{ + int numListRows; + GList *selListRows, *tmpList; + GtkTreeModel *model = NULL; + GtkTreeSelection *treeSel; + + treeSel = gtk_tree_view_get_selection( GTK_TREE_VIEW(cw->actv_cheat_tree) ); + + numListRows = gtk_tree_selection_count_selected_rows( treeSel ); + + if ( numListRows == 0 ) + { + return; + } + //printf("Number of Rows Selected: %i\n", numListRows ); + + selListRows = gtk_tree_selection_get_selected_rows( treeSel, &model ); + + tmpList = selListRows; + + while ( tmpList ) + { + int depth; + int *indexArray; + GtkTreePath *path = (GtkTreePath*)tmpList->data; + + depth = gtk_tree_path_get_depth(path); + indexArray = gtk_tree_path_get_indices(path); + + if ( depth > 0 ) + { + //GtkTreeIter iter; + FCEUI_DelCheat( indexArray[0] ); + + //if ( gtk_tree_model_get_iter ( model, &iter, path ) ) + //{ + // gtk_tree_store_remove( actv_cheats_store, &iter ); + //} + } + + tmpList = tmpList->next; + } + + g_list_free_full(selListRows, (GDestroyNotify) gtk_tree_path_free); + + updateAllActvCheatLists(1); +} + +static void updateCheatList( GtkWidget *widget, + cheat_win_t *cw ) +{ + int numListRows; + GList *selListRows, *tmpList; + GtkTreeModel *model = NULL; + GtkTreeSelection *treeSel; + + treeSel = gtk_tree_view_get_selection( GTK_TREE_VIEW(cw->actv_cheat_tree) ); + + numListRows = gtk_tree_selection_count_selected_rows( treeSel ); + + if ( numListRows == 0 ) + { + return; + } + //printf("Number of Rows Selected: %i\n", numListRows ); + + selListRows = gtk_tree_selection_get_selected_rows( treeSel, &model ); + + tmpList = selListRows; + + while ( tmpList ) + { + int depth; + int *indexArray; + GtkTreePath *path = (GtkTreePath*)tmpList->data; + + depth = gtk_tree_path_get_depth(path); + indexArray = gtk_tree_path_get_indices(path); + + if ( depth > 0 ) + { + uint32 a; uint8 v; + int c, s, type; + const char *name = NULL; + if ( FCEUI_GetCheat( indexArray[0], NULL, &a, &v, &c, &s, &type) ) + { + if ( cw->new_cheat_addr >= 0 ){ + a = cw->new_cheat_addr; + } + if ( cw->new_cheat_val >= 0 ){ + v = cw->new_cheat_val; + } + if ( cw->new_cheat_cmp >= 0 ){ + c = cw->new_cheat_cmp; + } + if ( cw->new_cheat_name.size() ) + { + name = cw->new_cheat_name.c_str(); + } + FCEUI_SetCheat( indexArray[0], name, a, v, c, s, type ); + } + } + //printf("Depth: %i \n", depth ); + + //for (int i=0; inext; + } + + g_list_free_full(selListRows, (GDestroyNotify) gtk_tree_path_free); + + updateAllActvCheatLists(0); +} + +static void cheat_cell_edited_cb1 (GtkCellRendererText *cell, + gchar *path_string, + gchar *new_text, + cheat_win_t *cw ) +{ + long int row_idx = -1; + + //printf("'%s'\n", path_string ); + //printf("'%s'\n", new_text ); + //printf("%p\n", user_data ); + + if ( isdigit(path_string[0]) ) + { + row_idx = atoi(path_string); + } + + if ( row_idx >= 0 ) + { + uint32 a; uint8 v; + int c, s, type; + const char *name = NULL; + if ( FCEUI_GetCheat( row_idx, NULL, &a, &v, &c, &s, &type) ) + { + a = strtol( new_text, NULL, 0 ); + FCEUI_SetCheat( row_idx, name, a, v, c, s, type ); + updateAllActvCheatLists(0); + } + } +} + +static void cheat_cell_edited_cb2 (GtkCellRendererText *cell, + gchar *path_string, + gchar *new_text, + cheat_win_t *cw ) +{ + long int row_idx = -1; + + //printf("'%s'\n", path_string ); + //printf("'%s'\n", new_text ); + //printf("%p\n", user_data ); + + if ( isdigit(path_string[0]) ) + { + row_idx = atoi(path_string); + } + + if ( row_idx >= 0 ) + { + uint32 a; uint8 v; + int c, s, type; + const char *name = NULL; + if ( FCEUI_GetCheat( row_idx, NULL, &a, &v, &c, &s, &type) ) + { + v = strtol( new_text, NULL, 0 ); + FCEUI_SetCheat( row_idx, name, a, v, c, s, type ); + updateAllActvCheatLists(0); + } + } +} + +static void cheat_cell_edited_cb3 (GtkCellRendererText *cell, + gchar *path_string, + gchar *new_text, + cheat_win_t *cw ) +{ + long int row_idx = -1; + + //printf("'%s'\n", path_string ); + //printf("'%s'\n", new_text ); + //printf("%p\n", user_data ); + + if ( isdigit(path_string[0]) ) + { + row_idx = atoi(path_string); + } + + if ( row_idx >= 0 ) + { + uint32 a; uint8 v; + int c, s, type; + const char *name = NULL; + if ( FCEUI_GetCheat( row_idx, NULL, &a, &v, &c, &s, &type) ) + { + c = strtol( new_text, NULL, 0 ); + FCEUI_SetCheat( row_idx, name, a, v, c, s, type ); + updateAllActvCheatLists(0); + } + } +} + +static void cheat_cell_edited_cb4 (GtkCellRendererText *cell, + gchar *path_string, + gchar *new_text, + cheat_win_t *cw ) +{ + long int row_idx = -1; + + //printf("'%s'\n", path_string ); + //printf("'%s'\n", new_text ); + //printf("%p\n", user_data ); + + if ( isdigit(path_string[0]) ) + { + row_idx = atoi(path_string); + } + + if ( row_idx >= 0 ) + { + uint32 a; uint8 v; + int c, s, type; + const char *name = NULL; + if ( FCEUI_GetCheat( row_idx, NULL, &a, &v, &c, &s, &type) ) + { + name = new_text; + FCEUI_SetCheat( row_idx, name, a, v, c, s, type ); + updateAllActvCheatLists(0); + } + } +} + +static void updateAllActvCheatLists( bool redraw ) +{ + std::list ::iterator it; + + for (it=cheatWinList.begin(); it != cheatWinList.end(); it++) + { + (*it)->showActiveCheatList( redraw ); + } +} + +static void closeCheatDialog(GtkWidget* w, GdkEvent* e, gpointer p) +{ + std::list ::iterator it; + cheat_win_t *cw = (cheat_win_t*)p; + + if ( EmulationPaused && cw->wasPausedByCheats ) + { + EmulationPaused = 0; + } + + for (it=cheatWinList.begin(); it != cheatWinList.end(); it++) + { + if ( cw == *it ) + { + //printf("Removing Cheat Window %p from List\n", cw); + cheatWinList.erase(it); break; + } + } + //printf("Number of Cheat Windows Still Open: %zi\n", cheatWinList.size() ); + + delete cw; + + gtk_widget_destroy(w); +} + +// creates and opens cheats window +void openCheatsWindow(void) +{ + GtkWidget* win; + GtkWidget* main_hbox; + GtkWidget* hbox; + GtkWidget* vbox, *prev_cmp_vbox; + GtkWidget* frame; + GtkWidget* label, *txt_entry; + GtkWidget* button; + GtkWidget *scroll; + + cheat_win_t *cw = new cheat_win_t; + + cheatWinList.push_back(cw); + + win = gtk_dialog_new_with_buttons("Cheats", + GTK_WINDOW(MainWindow), (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT), + "_Close", + GTK_RESPONSE_OK, + NULL); + gtk_window_set_default_size(GTK_WINDOW(win), 600, 600); + + main_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); + vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); + frame = gtk_frame_new("Active Cheats"); + + cw->actv_cheats_store = gtk_tree_store_new( 5, G_TYPE_BOOLEAN, + G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING ); + + cw->actv_cheat_tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(cw->actv_cheats_store)); + + GtkCellRenderer *renderer; + GtkCellRenderer *chkbox_renderer; + GtkTreeViewColumn* column; + + gtk_tree_view_set_grid_lines( GTK_TREE_VIEW(cw->actv_cheat_tree), GTK_TREE_VIEW_GRID_LINES_VERTICAL ); + + chkbox_renderer = gtk_cell_renderer_toggle_new(); + gtk_cell_renderer_toggle_set_activatable( (GtkCellRendererToggle*)chkbox_renderer, TRUE ); + column = gtk_tree_view_column_new_with_attributes("Ena", chkbox_renderer, "active", 0, NULL); + gtk_tree_view_append_column(GTK_TREE_VIEW(cw->actv_cheat_tree), column); + + renderer = gtk_cell_renderer_text_new(); + g_object_set(renderer, "family", "MonoSpace", NULL); + g_object_set(renderer, "editable", TRUE, NULL); + g_signal_connect(renderer, "edited", (GCallback) cheat_cell_edited_cb1, (gpointer)cw); + column = gtk_tree_view_column_new_with_attributes("Addr", renderer, "text", 1, NULL); + gtk_tree_view_append_column(GTK_TREE_VIEW(cw->actv_cheat_tree), column); + + renderer = gtk_cell_renderer_text_new(); + g_object_set(renderer, "family", "MonoSpace", NULL); + g_object_set(renderer, "editable", TRUE, NULL); + g_signal_connect(renderer, "edited", (GCallback) cheat_cell_edited_cb2, (gpointer)cw); + column = gtk_tree_view_column_new_with_attributes("Val", renderer, "text", 2, NULL); + gtk_tree_view_append_column(GTK_TREE_VIEW(cw->actv_cheat_tree), column); + + renderer = gtk_cell_renderer_text_new(); + g_object_set(renderer, "family", "MonoSpace", NULL); + g_object_set(renderer, "editable", TRUE, NULL); + g_signal_connect(renderer, "edited", (GCallback) cheat_cell_edited_cb3, (gpointer)cw); + column = gtk_tree_view_column_new_with_attributes("Cmp", renderer, "text", 3, NULL); + gtk_tree_view_append_column(GTK_TREE_VIEW(cw->actv_cheat_tree), column); + + renderer = gtk_cell_renderer_text_new(); + g_object_set(renderer, "editable", TRUE, NULL); + g_signal_connect(renderer, "edited", (GCallback) cheat_cell_edited_cb4, (gpointer)cw); + column = gtk_tree_view_column_new_with_attributes("Desc", renderer, "text", 4, NULL); + gtk_tree_view_append_column(GTK_TREE_VIEW(cw->actv_cheat_tree), column); + + g_signal_connect( chkbox_renderer, "toggled", + G_CALLBACK(cheatListEnableToggle), (void*)cw ); + + updateAllActvCheatLists(1); + + scroll = gtk_scrolled_window_new(NULL, NULL); + gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, + GTK_POLICY_AUTOMATIC); + gtk_container_add(GTK_CONTAINER(scroll), cw->actv_cheat_tree); + gtk_box_pack_start(GTK_BOX(vbox), scroll, TRUE, TRUE, 1); + + hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); + label = gtk_label_new("Name:"); + txt_entry = gtk_entry_new(); + + g_signal_connect( txt_entry, "activate", + G_CALLBACK(newCheatEntryCB4), (void*)cw ); + g_signal_connect( txt_entry, "changed", + G_CALLBACK(newCheatEntryCB4), (void*)cw ); + + gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 1); + gtk_box_pack_start(GTK_BOX(hbox), txt_entry, TRUE, TRUE, 1); + + gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 1); + + hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6); + label = gtk_label_new("Addr:"); + txt_entry = gtk_entry_new(); + gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 4 ); + gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 4 ); + + g_signal_connect( txt_entry, "activate", + G_CALLBACK(newCheatEntryCB1), (void*)cw ); + g_signal_connect( txt_entry, "changed", + G_CALLBACK(newCheatEntryCB1), (void*)cw ); + + gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 1); + gtk_box_pack_start(GTK_BOX(hbox), txt_entry, TRUE, TRUE, 1); + + label = gtk_label_new("Val:"); + txt_entry = gtk_entry_new(); + gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 2 ); + gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 2 ); + + g_signal_connect( txt_entry, "activate", + G_CALLBACK(newCheatEntryCB2), (void*)cw ); + g_signal_connect( txt_entry, "changed", + G_CALLBACK(newCheatEntryCB2), (void*)cw ); + + gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 1); + gtk_box_pack_start(GTK_BOX(hbox), txt_entry, TRUE, TRUE, 1); + + label = gtk_label_new("Cmp:"); + txt_entry = gtk_entry_new(); + gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 2 ); + gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 2 ); + + g_signal_connect( txt_entry, "activate", + G_CALLBACK(newCheatEntryCB3), (void*)cw ); + g_signal_connect( txt_entry, "changed", + G_CALLBACK(newCheatEntryCB3), (void*)cw ); + + gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 1); + gtk_box_pack_start(GTK_BOX(hbox), txt_entry, TRUE, TRUE, 1); + + gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 1); + + hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); + button = gtk_button_new_with_label("Add"); + gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, FALSE, 1); + + g_signal_connect( button, "clicked", + G_CALLBACK (addCheat2Active), (gpointer) cw ); + + button = gtk_button_new_with_label("Delete"); + gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, FALSE, 1); + + g_signal_connect( button, "clicked", + G_CALLBACK (removeCheatFromActive), (gpointer) cw ); + + button = gtk_button_new_with_label("Update"); + gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, FALSE, 1); + + g_signal_connect( button, "clicked", + G_CALLBACK (updateCheatList), (gpointer) cw ); + + gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 1); + + hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1); + button = gtk_button_new_with_label("Add from CHT file..."); + gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, FALSE, 1); + g_signal_connect( button, "clicked", + G_CALLBACK (openCheatFile), (gpointer) cw ); + + gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 1); + + gtk_container_add(GTK_CONTAINER(frame), vbox); + // + gtk_box_pack_start(GTK_BOX(main_hbox), frame, TRUE, TRUE, 1); + + vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); + hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1); + button = gtk_button_new_with_label("Reset"); + g_signal_connect( button, "clicked", + G_CALLBACK (cheatSearchReset), (gpointer) cw ); + gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 5); + + gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5); + + hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); + button = gtk_button_new_with_label("Known Value:"); + g_signal_connect( button, "clicked", + G_CALLBACK (cheatSearchKnown), (gpointer) cw ); + gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 5); + label = gtk_label_new("0x"); + txt_entry = gtk_entry_new(); + gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 2 ); + gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 2 ); + + g_signal_connect( txt_entry, "activate", + G_CALLBACK(cheatSearchValueEntryCB1), (void*)cw ); + g_signal_connect( txt_entry, "changed", + G_CALLBACK(cheatSearchValueEntryCB1), (void*)cw ); + gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5); + gtk_box_pack_start(GTK_BOX(hbox), txt_entry, FALSE, FALSE, 5); + + gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5); + + frame = gtk_frame_new("Previous Compare"); + gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5); + button = gtk_check_button_new_with_label("Pause emulation when this window is active"); + gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 5); + g_signal_connect( button, "clicked", + G_CALLBACK (pauseDuringCheatWinActvCB), (gpointer) cw ); + + prev_cmp_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4); + gtk_container_add(GTK_CONTAINER(frame), prev_cmp_vbox); + + hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1); + button = gtk_button_new_with_label("Equal"); + //gtk_widget_set_halign( button, GTK_ALIGN_BASELINE); + + gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 5); + gtk_box_pack_start(GTK_BOX(prev_cmp_vbox), hbox, FALSE, FALSE, 5); + g_signal_connect( button, "clicked", + G_CALLBACK (cheatSearchEqual), (gpointer) cw ); + + hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); + button = gtk_button_new_with_label("Not Equal"); + //gtk_widget_set_halign( button, GTK_ALIGN_BASELINE); + gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 5); + cw->neq_chkbox = gtk_check_button_new(); + gtk_box_pack_start(GTK_BOX(hbox), cw->neq_chkbox, FALSE, FALSE, 5); + g_signal_connect( button, "clicked", + G_CALLBACK (cheatSearchNotEqual), (gpointer) cw ); + label = gtk_label_new("By: 0x"); + gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5); + txt_entry = gtk_entry_new(); + gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 2 ); + gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 2 ); + g_signal_connect( txt_entry, "activate", + G_CALLBACK(cheatSearchValueEntryCB2), (void*)cw ); + g_signal_connect( txt_entry, "changed", + G_CALLBACK(cheatSearchValueEntryCB2), (void*)cw ); + gtk_box_pack_start(GTK_BOX(hbox), txt_entry, FALSE, FALSE, 5); + + gtk_box_pack_start(GTK_BOX(prev_cmp_vbox), hbox, FALSE, FALSE, 5); + + hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); + button = gtk_button_new_with_label("Greater Than"); + //gtk_widget_set_halign( button, GTK_ALIGN_BASELINE); + gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 5); + cw->gt_chkbox = gtk_check_button_new(); + g_signal_connect( button, "clicked", + G_CALLBACK (cheatSearchGreaterThan), (gpointer) cw ); + gtk_box_pack_start(GTK_BOX(hbox), cw->gt_chkbox, FALSE, FALSE, 5); + label = gtk_label_new("By: 0x"); + gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5); + txt_entry = gtk_entry_new(); + gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 2 ); + gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 2 ); + g_signal_connect( txt_entry, "activate", + G_CALLBACK(cheatSearchValueEntryCB3), (void*)cw ); + g_signal_connect( txt_entry, "changed", + G_CALLBACK(cheatSearchValueEntryCB3), (void*)cw ); + gtk_box_pack_start(GTK_BOX(hbox), txt_entry, FALSE, FALSE, 5); + + gtk_box_pack_start(GTK_BOX(prev_cmp_vbox), hbox, FALSE, FALSE, 5); + + hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); + button = gtk_button_new_with_label("Less Than"); + //gtk_widget_set_halign( button, GTK_ALIGN_BASELINE); + gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 5); + cw->lt_chkbox = gtk_check_button_new(); + g_signal_connect( button, "clicked", + G_CALLBACK (cheatSearchLessThan), (gpointer) cw ); + gtk_box_pack_start(GTK_BOX(hbox), cw->lt_chkbox, FALSE, FALSE, 5); + label = gtk_label_new("By: 0x"); + gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5); + txt_entry = gtk_entry_new(); + gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 2 ); + gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 2 ); + g_signal_connect( txt_entry, "activate", + G_CALLBACK(cheatSearchValueEntryCB4), (void*)cw ); + g_signal_connect( txt_entry, "changed", + G_CALLBACK(cheatSearchValueEntryCB4), (void*)cw ); + gtk_box_pack_start(GTK_BOX(hbox), txt_entry, FALSE, FALSE, 5); + + gtk_box_pack_start(GTK_BOX(prev_cmp_vbox), hbox, FALSE, FALSE, 1); + + hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); + gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 1); + + frame = gtk_frame_new("Cheat Search"); + gtk_container_add(GTK_CONTAINER(frame), hbox); + gtk_box_pack_start(GTK_BOX(main_hbox), frame, TRUE, TRUE, 5); + + vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); + //hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1); + + cw->ram_match_store = gtk_tree_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); + + cw->search_cheat_tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(cw->ram_match_store)); + + gtk_tree_view_set_grid_lines( GTK_TREE_VIEW(cw->search_cheat_tree), GTK_TREE_VIEW_GRID_LINES_VERTICAL ); + + renderer = gtk_cell_renderer_text_new(); + g_object_set(renderer, "family", "MonoSpace", NULL); + column = gtk_tree_view_column_new_with_attributes("Addr", renderer, "text", 0, NULL); + gtk_tree_view_append_column(GTK_TREE_VIEW(cw->search_cheat_tree), column); + column = gtk_tree_view_column_new_with_attributes("Last", renderer, "text", 1, NULL); + gtk_tree_view_append_column(GTK_TREE_VIEW(cw->search_cheat_tree), column); + column = gtk_tree_view_column_new_with_attributes("Curr", renderer, "text", 2, NULL); + gtk_tree_view_append_column(GTK_TREE_VIEW(cw->search_cheat_tree), column); + + scroll = gtk_scrolled_window_new(NULL, NULL); + gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, + GTK_POLICY_AUTOMATIC); + gtk_container_add(GTK_CONTAINER(scroll), cw->search_cheat_tree); + gtk_box_pack_start(GTK_BOX(vbox), scroll, TRUE, TRUE, 5); + + frame = gtk_frame_new(""); + gtk_container_add(GTK_CONTAINER(frame), vbox); + + gtk_box_pack_start(GTK_BOX(hbox), frame, TRUE, TRUE, 5); + + gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(win))), main_hbox, TRUE, TRUE, 0); + + g_signal_connect(win, "delete-event", G_CALLBACK(closeCheatDialog), cw); + g_signal_connect(win, "response", G_CALLBACK(closeCheatDialog), cw); + + gtk_widget_show_all(win); + + //printf("Added Cheat Window %p. Number of Cheat Windows Open: %zi\n", cw, cheatWinList.size() ); +} diff --git a/src/drivers/sdl/cheat.h b/src/drivers/sdl/cheat.h new file mode 100644 index 00000000..bd3837ba --- /dev/null +++ b/src/drivers/sdl/cheat.h @@ -0,0 +1,3 @@ +// cheat.h + +void openCheatsWindow(void); diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 7674369f..81462515 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -14,6 +14,7 @@ #include "dface.h" #include "input.h" #include "config.h" +#include "cheat.h" #include "icon.xpm" #ifdef _S9XLUA_H @@ -63,23 +64,6 @@ bool gtkIsStarted = false; bool menuTogglingEnabled = false; static GtkTreeStore *hotkey_store = NULL; -//----------------------------------------- -// Cheat static variables -static GtkTreeStore *actv_cheats_store = NULL; -static GtkTreeStore *ram_match_store = NULL; -static GtkTreeIter actv_cheats_iter; -static GtkTreeIter ram_match_iter; -static int cheat_search_known_value = 0; -static int cheat_search_neq_value = 0; -static int cheat_search_gt_value = 0; -static int cheat_search_lt_value = 0; -static int new_cheat_addr = -1; -static int new_cheat_val = -1; -static int new_cheat_cmp = -1; -static std::string new_cheat_name; -static bool wasPausedByCheats = false; -static bool pauseWhileCheatsActv = false; -static bool cheatWindowOpen = false; //----------------------------------------- // Ram Watch static variables @@ -1527,892 +1511,6 @@ void toggleAutoResume(GtkCheckMenuItem *item, gpointer user_data) g_config->setOption("SDL.AutoResume", (int)autoResume); AutoResumePlay = autoResume; } -//******************************************************************************************************* -// Cheat Window -//******************************************************************************************************* - -static int ShowCheatSearchResultsCallB(uint32 a, uint8 last, uint8 current) -{ - char addrStr[32], lastStr[32], curStr[32]; - - sprintf( addrStr, "0x%04X ", a ); - sprintf( lastStr, " 0x%02X ", last ); - sprintf( curStr, " 0x%02X ", current ); - - gtk_tree_store_append( ram_match_store, &ram_match_iter, NULL); // aquire iter - - gtk_tree_store_set(ram_match_store, &ram_match_iter, - 0, addrStr, 1, lastStr, 2, curStr, - -1); - - - return 1; -} - -static void showCheatSearchResults(void) -{ - int total_matches = 0; - - gtk_tree_store_clear(ram_match_store); - - total_matches = FCEUI_CheatSearchGetCount(); - - printf("Cheat Search Matches: %i \n", total_matches ); - - FCEUI_CheatSearchGetRange( 0, total_matches, ShowCheatSearchResultsCallB ); -} - -static void cheatSearchReset( GtkButton *button, - gpointer user_data) -{ - printf("Cheat Search Reset!\n"); - - //cheat_search_known_value = 0; - //cheat_search_neq_value = 0; - //cheat_search_gt_value = 0; - //cheat_search_lt_value = 0; - - FCEUI_CheatSearchBegin(); - showCheatSearchResults(); - // Enable Cheat Search Buttons - Change Sensitivity -} - -static void cheatSearchKnown( GtkButton *button, - gpointer user_data) -{ - //printf("Cheat Search Known!\n"); - - FCEUI_CheatSearchEnd(FCEU_SEARCH_NEWVAL_KNOWN, cheat_search_known_value, 0); - showCheatSearchResults(); -} - -static void cheatSearchEqual( GtkButton *button, - gpointer user_data) -{ - //printf("Cheat Search Equal !\n"); - - FCEUI_CheatSearchEnd(FCEU_SEARCH_PUERLY_RELATIVE_CHANGE, 0, 0); - showCheatSearchResults(); -} - -static void cheatSearchNotEqual( GtkButton *button, - GtkToggleButton *chkbox ) -{ - int checked = gtk_toggle_button_get_active(chkbox); - - //printf("Cheat Search NotEqual %i!\n", checked); - - if ( checked ){ - FCEUI_CheatSearchEnd(FCEU_SEARCH_PUERLY_RELATIVE_CHANGE, 0, cheat_search_neq_value); - } else { - FCEUI_CheatSearchEnd(FCEU_SEARCH_ANY_CHANGE, 0, 0); - } - showCheatSearchResults(); -} - -static void cheatSearchGreaterThan( GtkButton *button, - GtkToggleButton *chkbox ) -{ - int checked = gtk_toggle_button_get_active(chkbox); - - //printf("Cheat Search GreaterThan %i!\n", checked); - - if ( checked ){ - FCEUI_CheatSearchEnd(FCEU_SEARCH_NEWVAL_GT_KNOWN, 0, cheat_search_gt_value); - } else { - FCEUI_CheatSearchEnd(FCEU_SEARCH_NEWVAL_GT, 0, 0); - } - showCheatSearchResults(); -} - -static void cheatSearchLessThan( GtkButton *button, - GtkToggleButton *chkbox ) -{ - int checked = gtk_toggle_button_get_active(chkbox); - - //printf("Cheat Search LessThan %i!\n", checked); - - if ( checked ){ - FCEUI_CheatSearchEnd(FCEU_SEARCH_NEWVAL_LT_KNOWN, 0, cheat_search_lt_value); - } else { - FCEUI_CheatSearchEnd(FCEU_SEARCH_NEWVAL_LT, 0, 0); - } - showCheatSearchResults(); -} - -static void pauseDuringCheatWinActvCB( GtkToggleButton *button, - void *userData ) -{ - pauseWhileCheatsActv = gtk_toggle_button_get_active(button); - - if ( pauseWhileCheatsActv ) - { - if ( EmulationPaused == 0 ) - { - EmulationPaused = 1; - wasPausedByCheats = true; - } - } - else - { - if ( EmulationPaused && wasPausedByCheats ) - { - EmulationPaused = 0; - } - wasPausedByCheats = false; - } - FCEU_printf("Emulation paused: %d\n", EmulationPaused); -} - -static void cheatSearchValueEntryCB( GtkWidget *widget, - void *userData ) -{ - long value; - const gchar *entry_text; - entry_text = gtk_entry_get_text (GTK_ENTRY (widget)); - - value = strtol( entry_text, NULL, 16 ); - - switch ( (long)userData ) - { - default: - case 0: - - break; - case 1: - cheat_search_known_value = value; - break; - case 2: - cheat_search_neq_value = value; - break; - case 3: - cheat_search_gt_value = value; - break; - case 4: - cheat_search_lt_value = value; - break; - } - - //printf("Cheat Value Entry contents: '%s' Value: 0x%02lx\n", entry_text, value); -} - -static int activeCheatListCB(char *name, uint32 a, uint8 v, int c, int s, int type, void* data) -{ - long int reset; - char addrStr[32], valStr[16], cmpStr[16]; - //printf("Cheat Name:'%s' Addr:0x%04x Val:0x%02x \n", name, a, v ); - // - reset = (long)data; - - if ( reset ) - { - gtk_tree_store_append( actv_cheats_store, &actv_cheats_iter, NULL); // aquire iter - } - - sprintf( addrStr, "0x%04X ", a ); - sprintf( valStr, " 0x%02X ", v ); - - if ( c >= 0 ){ - sprintf( cmpStr, " 0x%02X ", c ); - } else { - strcpy( cmpStr, " 0xFF "); - } - - gtk_tree_store_set(actv_cheats_store, &actv_cheats_iter, - 0, s, 1, addrStr, 2, valStr, 3, cmpStr, 4, name, - -1); - - if ( !reset ) - { - if ( !gtk_tree_model_iter_next( GTK_TREE_MODEL(actv_cheats_store), &actv_cheats_iter ) ) - { - gtk_tree_store_append( actv_cheats_store, &actv_cheats_iter, NULL); // aquire iter - } - } - - return 1; -} - -static void showActiveCheatList( long int reset ) -{ - if ( reset ) - { - gtk_tree_store_clear(actv_cheats_store); - } - else - { - if ( !gtk_tree_model_get_iter_first( GTK_TREE_MODEL(actv_cheats_store), &actv_cheats_iter ) ) - { - printf("No Tree Entries Loaded.\n"); - reset = 1; - } - } - - FCEUI_ListCheats( activeCheatListCB, (void*)reset ); -} - -static void cheatListEnableToggle( GtkCellRendererToggle *renderer, - gchar *pathStr, - GtkTreeView *tree ) -{ - GtkTreePath *path; - int depth; - int *indexArray; - - path = gtk_tree_path_new_from_string( pathStr ); - - if ( path == NULL ){ - printf("Error: gtk_tree_path_new_from_string failed\n"); - return; - } - - depth = gtk_tree_path_get_depth(path); - indexArray = gtk_tree_path_get_indices(path); - - if ( depth > 0 ) - { - //printf("Toggle: %i\n", indexArray[0] ); - FCEUI_ToggleCheat( indexArray[0] ); - } - - gtk_tree_path_free( path ); - - showActiveCheatList(0); - -} - -static void openCheatFile( GtkWidget *widget, - void *userData ) -{ - GtkWidget* fileChooser; - GtkFileFilter* filterCht; - GtkFileFilter* filterAll; - - filterCht = gtk_file_filter_new(); - filterAll = gtk_file_filter_new(); - - gtk_file_filter_add_pattern(filterCht, "*.cht"); - gtk_file_filter_add_pattern(filterAll, "*"); - - gtk_file_filter_set_name(filterCht, "*.cht"); - gtk_file_filter_set_name(filterAll, "All Files"); - - fileChooser = gtk_file_chooser_dialog_new ("Open Cheat", GTK_WINDOW(MainWindow), - GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel", GTK_RESPONSE_CANCEL, - "_Open", GTK_RESPONSE_ACCEPT, NULL); - const char* last_dir; - g_config->getOption("SDL.LastOpenFile", &last_dir); - gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(fileChooser), last_dir); - - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterCht); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterAll); - - if (gtk_dialog_run (GTK_DIALOG (fileChooser)) ==GTK_RESPONSE_ACCEPT) - { - FILE *fp; - char* filename; - - filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fileChooser)); - gtk_widget_destroy (fileChooser); - - fp = fopen( filename, "r"); - - if ( fp != NULL ) - { - FCEU_LoadGameCheats( fp, 0 ); - fclose(fp); - } - //g_config->setOption("SDL.LastOpenFile", filename); - // Error dialog no longer required with GTK implementation of FCEUD_PrintError() - - resizeGtkWindow(); - g_free( filename); - } - else - { - gtk_widget_destroy (fileChooser); - } - - showActiveCheatList(1); -} - -static void newCheatEntryCB( GtkWidget *widget, - void *userData ) -{ - const gchar *entry_text; - entry_text = gtk_entry_get_text (GTK_ENTRY (widget)); - - switch ( (long)userData ) - { - default: - case 0: - if ( entry_text[0] == 0 ) - { - new_cheat_addr = -1; - } - else - { - new_cheat_addr = strtol( entry_text, NULL, 16 ); - } - break; - case 1: - if ( entry_text[0] == 0 ) - { - new_cheat_val = -1; - } - else - { - new_cheat_val = strtol( entry_text, NULL, 16 ); - } - break; - case 2: - { - if ( entry_text[0] == 0 ) - { - new_cheat_cmp = -1; - } - else - { - new_cheat_cmp = strtol( entry_text, NULL, 16 ); - } - } - break; - case 3: - new_cheat_name.assign( entry_text ); - break; - } - -} - -static void addCheat2Active( GtkWidget *widget, - void *userData ) -{ - - if ( (new_cheat_addr >= 0) && (new_cheat_val >= 0) ) - { - if ( FCEUI_AddCheat( new_cheat_name.c_str(), new_cheat_addr, new_cheat_val, new_cheat_cmp, 1) ) - { - showActiveCheatList(1); - } - } -} - -static void removeCheatFromActive( GtkWidget *widget, - GtkTreeView *tree ) -{ - int numListRows; - GList *selListRows, *tmpList; - GtkTreeModel *model = NULL; - GtkTreeSelection *treeSel = gtk_tree_view_get_selection(tree); - - numListRows = gtk_tree_selection_count_selected_rows( treeSel ); - - if ( numListRows == 0 ) - { - return; - } - //printf("Number of Rows Selected: %i\n", numListRows ); - - selListRows = gtk_tree_selection_get_selected_rows( treeSel, &model ); - - tmpList = selListRows; - - while ( tmpList ) - { - int depth; - int *indexArray; - GtkTreePath *path = (GtkTreePath*)tmpList->data; - - depth = gtk_tree_path_get_depth(path); - indexArray = gtk_tree_path_get_indices(path); - - if ( depth > 0 ) - { - //GtkTreeIter iter; - FCEUI_DelCheat( indexArray[0] ); - - //if ( gtk_tree_model_get_iter ( model, &iter, path ) ) - //{ - // gtk_tree_store_remove( actv_cheats_store, &iter ); - //} - } - - tmpList = tmpList->next; - } - - g_list_free_full(selListRows, (GDestroyNotify) gtk_tree_path_free); - - showActiveCheatList(1); -} - -static void updateCheatList( GtkWidget *widget, - GtkTreeView *tree ) -{ - int numListRows; - GList *selListRows, *tmpList; - GtkTreeModel *model = NULL; - GtkTreeSelection *treeSel = gtk_tree_view_get_selection(tree); - - numListRows = gtk_tree_selection_count_selected_rows( treeSel ); - - if ( numListRows == 0 ) - { - return; - } - //printf("Number of Rows Selected: %i\n", numListRows ); - - selListRows = gtk_tree_selection_get_selected_rows( treeSel, &model ); - - tmpList = selListRows; - - while ( tmpList ) - { - int depth; - int *indexArray; - GtkTreePath *path = (GtkTreePath*)tmpList->data; - - depth = gtk_tree_path_get_depth(path); - indexArray = gtk_tree_path_get_indices(path); - - if ( depth > 0 ) - { - uint32 a; uint8 v; - int c, s, type; - const char *name = NULL; - if ( FCEUI_GetCheat( indexArray[0], NULL, &a, &v, &c, &s, &type) ) - { - if ( new_cheat_addr >= 0 ){ - a = new_cheat_addr; - } - if ( new_cheat_val >= 0 ){ - v = new_cheat_val; - } - if ( new_cheat_cmp >= 0 ){ - c = new_cheat_cmp; - } - if ( new_cheat_name.size() ) - { - name = new_cheat_name.c_str(); - } - FCEUI_SetCheat( indexArray[0], name, a, v, c, s, type ); - } - } - //printf("Depth: %i \n", depth ); - - //for (int i=0; inext; - } - - g_list_free_full(selListRows, (GDestroyNotify) gtk_tree_path_free); - - showActiveCheatList(0); -} - -static void cheat_cell_edited_cb (GtkCellRendererText *cell, - gchar *path_string, - gchar *new_text, - gpointer user_data) -{ - long int row_idx = -1, column_idx; - - //printf("'%s'\n", path_string ); - //printf("'%s'\n", new_text ); - //printf("%p\n", user_data ); - - column_idx = (long)user_data; - - if ( isdigit(path_string[0]) ) - { - row_idx = atoi(path_string); - } - - if ( row_idx >= 0 ) - { - uint32 a; uint8 v; - int c, s, type; - const char *name = NULL; - if ( FCEUI_GetCheat( row_idx, NULL, &a, &v, &c, &s, &type) ) - { - switch ( column_idx ) - { - default: - case 0: - - break; - case 1: - a = strtol( new_text, NULL, 0 ); - break; - case 2: - v = strtol( new_text, NULL, 0 ); - break; - case 3: - c = strtol( new_text, NULL, 0 ); - break; - case 4: - name = new_text; - break; - } - FCEUI_SetCheat( row_idx, name, a, v, c, s, type ); - showActiveCheatList(0); - } - } -} - - -void closeCheatDialog(GtkWidget* w, GdkEvent* e, gpointer p) -{ - if ( EmulationPaused && wasPausedByCheats ) - { - EmulationPaused = 0; - } - wasPausedByCheats = false; - pauseWhileCheatsActv = false; - cheatWindowOpen = false; - - cheat_search_known_value = 0; - cheat_search_neq_value = 0; - cheat_search_gt_value = 0; - cheat_search_lt_value = 0; - new_cheat_addr = -1; - new_cheat_val = -1; - new_cheat_cmp = -1; - - gtk_widget_destroy(w); -} - -// creates and opens cheats window -static void openCheatsWindow(void) -{ - GtkWidget* win; - GtkWidget* main_hbox; - GtkWidget* hbox; - GtkWidget* vbox, *prev_cmp_vbox; - GtkWidget* frame; - GtkWidget* label, *txt_entry; - GtkWidget* button, *chkbutton; - GtkWidget *tree; - GtkWidget *scroll; - - if ( cheatWindowOpen ){ - return; // Only allow one cheat window to be open per gui. - } - - win = gtk_dialog_new_with_buttons("Cheats", - GTK_WINDOW(MainWindow), (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT), - "_Close", - GTK_RESPONSE_OK, - NULL); - gtk_window_set_default_size(GTK_WINDOW(win), 600, 600); - - main_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); - vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); - frame = gtk_frame_new("Active Cheats"); - - actv_cheats_store = gtk_tree_store_new( 5, G_TYPE_BOOLEAN, - G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING ); - - tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(actv_cheats_store)); - - GtkCellRenderer *renderer; - GtkCellRenderer *chkbox_renderer; - GtkTreeViewColumn* column; - - gtk_tree_view_set_grid_lines( GTK_TREE_VIEW(tree), GTK_TREE_VIEW_GRID_LINES_VERTICAL ); - - renderer = gtk_cell_renderer_text_new(); - g_object_set(renderer, "editable", TRUE, NULL); - g_signal_connect(renderer, "edited", (GCallback) cheat_cell_edited_cb, NULL); - - chkbox_renderer = gtk_cell_renderer_toggle_new(); - gtk_cell_renderer_toggle_set_activatable( (GtkCellRendererToggle*)chkbox_renderer, TRUE ); - column = gtk_tree_view_column_new_with_attributes("Ena", chkbox_renderer, "active", 0, NULL); - gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); - - renderer = gtk_cell_renderer_text_new(); - g_object_set(renderer, "family", "MonoSpace", NULL); - g_object_set(renderer, "editable", TRUE, NULL); - g_signal_connect(renderer, "edited", (GCallback) cheat_cell_edited_cb, (gpointer)1); - column = gtk_tree_view_column_new_with_attributes("Addr", renderer, "text", 1, NULL); - gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); - - renderer = gtk_cell_renderer_text_new(); - g_object_set(renderer, "family", "MonoSpace", NULL); - g_object_set(renderer, "editable", TRUE, NULL); - g_signal_connect(renderer, "edited", (GCallback) cheat_cell_edited_cb, (gpointer)2); - column = gtk_tree_view_column_new_with_attributes("Val", renderer, "text", 2, NULL); - gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); - - renderer = gtk_cell_renderer_text_new(); - g_object_set(renderer, "family", "MonoSpace", NULL); - g_object_set(renderer, "editable", TRUE, NULL); - g_signal_connect(renderer, "edited", (GCallback) cheat_cell_edited_cb, (gpointer)3); - column = gtk_tree_view_column_new_with_attributes("Cmp", renderer, "text", 3, NULL); - gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); - - renderer = gtk_cell_renderer_text_new(); - g_object_set(renderer, "editable", TRUE, NULL); - g_signal_connect(renderer, "edited", (GCallback) cheat_cell_edited_cb, (gpointer)4); - column = gtk_tree_view_column_new_with_attributes("Desc", renderer, "text", 4, NULL); - gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); - - g_signal_connect( chkbox_renderer, "toggled", - G_CALLBACK(cheatListEnableToggle), (void*)tree ); - - showActiveCheatList(1); - - scroll = gtk_scrolled_window_new(NULL, NULL); - gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, - GTK_POLICY_AUTOMATIC); - gtk_container_add(GTK_CONTAINER(scroll), tree); - gtk_box_pack_start(GTK_BOX(vbox), scroll, TRUE, TRUE, 1); - - hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); - label = gtk_label_new("Name:"); - txt_entry = gtk_entry_new(); - - g_signal_connect( txt_entry, "activate", - G_CALLBACK(newCheatEntryCB), (void*)3L ); - g_signal_connect( txt_entry, "changed", - G_CALLBACK(newCheatEntryCB), (void*)3L ); - - gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 1); - gtk_box_pack_start(GTK_BOX(hbox), txt_entry, TRUE, TRUE, 1); - - gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 1); - - hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6); - label = gtk_label_new("Addr:"); - txt_entry = gtk_entry_new(); - gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 4 ); - gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 4 ); - - g_signal_connect( txt_entry, "activate", - G_CALLBACK(newCheatEntryCB), (void*)0L ); - g_signal_connect( txt_entry, "changed", - G_CALLBACK(newCheatEntryCB), (void*)0L ); - - gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 1); - gtk_box_pack_start(GTK_BOX(hbox), txt_entry, TRUE, TRUE, 1); - - label = gtk_label_new("Val:"); - txt_entry = gtk_entry_new(); - gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 2 ); - gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 2 ); - - g_signal_connect( txt_entry, "activate", - G_CALLBACK(newCheatEntryCB), (void*)1L ); - g_signal_connect( txt_entry, "changed", - G_CALLBACK(newCheatEntryCB), (void*)1L ); - - gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 1); - gtk_box_pack_start(GTK_BOX(hbox), txt_entry, TRUE, TRUE, 1); - - label = gtk_label_new("Cmp:"); - txt_entry = gtk_entry_new(); - gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 2 ); - gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 2 ); - - g_signal_connect( txt_entry, "activate", - G_CALLBACK(newCheatEntryCB), (void*)2L ); - g_signal_connect( txt_entry, "changed", - G_CALLBACK(newCheatEntryCB), (void*)2L ); - - gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 1); - gtk_box_pack_start(GTK_BOX(hbox), txt_entry, TRUE, TRUE, 1); - - gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 1); - - hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); - button = gtk_button_new_with_label("Add"); - gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, FALSE, 1); - - g_signal_connect( button, "clicked", - G_CALLBACK (addCheat2Active), (gpointer) NULL ); - - button = gtk_button_new_with_label("Delete"); - gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, FALSE, 1); - - g_signal_connect( button, "clicked", - G_CALLBACK (removeCheatFromActive), (gpointer) tree ); - - button = gtk_button_new_with_label("Update"); - gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, FALSE, 1); - - g_signal_connect( button, "clicked", - G_CALLBACK (updateCheatList), (gpointer) tree ); - - gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 1); - - hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1); - button = gtk_button_new_with_label("Add from CHT file..."); - gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, FALSE, 1); - g_signal_connect( button, "clicked", - G_CALLBACK (openCheatFile), (gpointer) NULL ); - - gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 1); - - gtk_container_add(GTK_CONTAINER(frame), vbox); - // - gtk_box_pack_start(GTK_BOX(main_hbox), frame, TRUE, TRUE, 1); - - vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); - hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1); - button = gtk_button_new_with_label("Reset"); - g_signal_connect( button, "clicked", - G_CALLBACK (cheatSearchReset), (gpointer) NULL ); - gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 5); - - gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5); - - hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); - button = gtk_button_new_with_label("Known Value:"); - g_signal_connect( button, "clicked", - G_CALLBACK (cheatSearchKnown), (gpointer) NULL ); - gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 5); - label = gtk_label_new("0x"); - txt_entry = gtk_entry_new(); - gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 2 ); - gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 2 ); - - g_signal_connect( txt_entry, "activate", - G_CALLBACK(cheatSearchValueEntryCB), (void*)1L ); - g_signal_connect( txt_entry, "changed", - G_CALLBACK(cheatSearchValueEntryCB), (void*)1L ); - gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5); - gtk_box_pack_start(GTK_BOX(hbox), txt_entry, FALSE, FALSE, 5); - - gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5); - - frame = gtk_frame_new("Previous Compare"); - gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5); - button = gtk_check_button_new_with_label("Pause emulation when this window is active"); - gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 5); - g_signal_connect( button, "clicked", - G_CALLBACK (pauseDuringCheatWinActvCB), (gpointer) NULL ); - - prev_cmp_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4); - gtk_container_add(GTK_CONTAINER(frame), prev_cmp_vbox); - - hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1); - button = gtk_button_new_with_label("Equal"); - //gtk_widget_set_halign( button, GTK_ALIGN_BASELINE); - - gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 5); - gtk_box_pack_start(GTK_BOX(prev_cmp_vbox), hbox, FALSE, FALSE, 5); - g_signal_connect( button, "clicked", - G_CALLBACK (cheatSearchEqual), (gpointer) NULL ); - - hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); - button = gtk_button_new_with_label("Not Equal"); - //gtk_widget_set_halign( button, GTK_ALIGN_BASELINE); - gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 5); - chkbutton = gtk_check_button_new(); - gtk_box_pack_start(GTK_BOX(hbox), chkbutton, FALSE, FALSE, 5); - g_signal_connect( button, "clicked", - G_CALLBACK (cheatSearchNotEqual), (gpointer) chkbutton ); - label = gtk_label_new("By: 0x"); - gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5); - txt_entry = gtk_entry_new(); - gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 2 ); - gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 2 ); - g_signal_connect( txt_entry, "activate", - G_CALLBACK(cheatSearchValueEntryCB), (void*)2L ); - g_signal_connect( txt_entry, "changed", - G_CALLBACK(cheatSearchValueEntryCB), (void*)2L ); - gtk_box_pack_start(GTK_BOX(hbox), txt_entry, FALSE, FALSE, 5); - - gtk_box_pack_start(GTK_BOX(prev_cmp_vbox), hbox, FALSE, FALSE, 5); - - hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); - button = gtk_button_new_with_label("Greater Than"); - //gtk_widget_set_halign( button, GTK_ALIGN_BASELINE); - gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 5); - chkbutton = gtk_check_button_new(); - g_signal_connect( button, "clicked", - G_CALLBACK (cheatSearchGreaterThan), (gpointer) chkbutton ); - gtk_box_pack_start(GTK_BOX(hbox), chkbutton, FALSE, FALSE, 5); - label = gtk_label_new("By: 0x"); - gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5); - txt_entry = gtk_entry_new(); - gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 2 ); - gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 2 ); - g_signal_connect( txt_entry, "activate", - G_CALLBACK(cheatSearchValueEntryCB), (void*)3L ); - g_signal_connect( txt_entry, "changed", - G_CALLBACK(cheatSearchValueEntryCB), (void*)3L ); - gtk_box_pack_start(GTK_BOX(hbox), txt_entry, FALSE, FALSE, 5); - - gtk_box_pack_start(GTK_BOX(prev_cmp_vbox), hbox, FALSE, FALSE, 5); - - hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); - button = gtk_button_new_with_label("Less Than"); - //gtk_widget_set_halign( button, GTK_ALIGN_BASELINE); - gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 5); - chkbutton = gtk_check_button_new(); - g_signal_connect( button, "clicked", - G_CALLBACK (cheatSearchLessThan), (gpointer) chkbutton ); - gtk_box_pack_start(GTK_BOX(hbox), chkbutton, FALSE, FALSE, 5); - label = gtk_label_new("By: 0x"); - gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5); - txt_entry = gtk_entry_new(); - gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 2 ); - gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 2 ); - g_signal_connect( txt_entry, "activate", - G_CALLBACK(cheatSearchValueEntryCB), (void*)4L ); - g_signal_connect( txt_entry, "changed", - G_CALLBACK(cheatSearchValueEntryCB), (void*)4L ); - gtk_box_pack_start(GTK_BOX(hbox), txt_entry, FALSE, FALSE, 5); - - gtk_box_pack_start(GTK_BOX(prev_cmp_vbox), hbox, FALSE, FALSE, 1); - - hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); - gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 1); - - frame = gtk_frame_new("Cheat Search"); - gtk_container_add(GTK_CONTAINER(frame), hbox); - gtk_box_pack_start(GTK_BOX(main_hbox), frame, TRUE, TRUE, 5); - - vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); - //hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1); - - ram_match_store = gtk_tree_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); - - tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(ram_match_store)); - - gtk_tree_view_set_grid_lines( GTK_TREE_VIEW(tree), GTK_TREE_VIEW_GRID_LINES_VERTICAL ); - - renderer = gtk_cell_renderer_text_new(); - g_object_set(renderer, "family", "MonoSpace", NULL); - column = gtk_tree_view_column_new_with_attributes("Addr", renderer, "text", 0, NULL); - gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); - column = gtk_tree_view_column_new_with_attributes("Last", renderer, "text", 1, NULL); - gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); - column = gtk_tree_view_column_new_with_attributes("Curr", renderer, "text", 2, NULL); - gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); - - scroll = gtk_scrolled_window_new(NULL, NULL); - gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, - GTK_POLICY_AUTOMATIC); - gtk_container_add(GTK_CONTAINER(scroll), tree); - gtk_box_pack_start(GTK_BOX(vbox), scroll, TRUE, TRUE, 5); - - frame = gtk_frame_new(""); - gtk_container_add(GTK_CONTAINER(frame), vbox); - - gtk_box_pack_start(GTK_BOX(hbox), frame, TRUE, TRUE, 5); - - gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(win))), main_hbox, TRUE, TRUE, 0); - - g_signal_connect(win, "delete-event", G_CALLBACK(closeCheatDialog), NULL); - g_signal_connect(win, "response", G_CALLBACK(closeCheatDialog), NULL); - - gtk_widget_show_all(win); - - cheatWindowOpen = true; -} //******************************************************************************************************* // Ram Watch Window From 57561ad5632943af13322cc36a425571e73aaf45 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Tue, 12 May 2020 22:13:22 -0400 Subject: [PATCH 043/156] Moved RAM watch window logic to its own separate file. --- src/drivers/sdl/SConscript | 1 + src/drivers/sdl/gui.cpp | 878 +------------------------- src/drivers/sdl/ramwatch.cpp | 1126 ++++++++++++++++++++++++++++++++++ src/drivers/sdl/ramwatch.h | 3 + 4 files changed, 1131 insertions(+), 877 deletions(-) create mode 100644 src/drivers/sdl/ramwatch.cpp create mode 100644 src/drivers/sdl/ramwatch.h diff --git a/src/drivers/sdl/SConscript b/src/drivers/sdl/SConscript index d9f86ceb..f8b8c0fb 100644 --- a/src/drivers/sdl/SConscript +++ b/src/drivers/sdl/SConscript @@ -10,6 +10,7 @@ source_list = Split( input.cpp cheat.cpp config.cpp + ramwatch.cpp sdl.cpp sdl-joystick.cpp sdl-sound.cpp diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 81462515..88752b33 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -16,6 +16,7 @@ #include "config.h" #include "cheat.h" #include "icon.xpm" +#include "ramwatch.h" #ifdef _S9XLUA_H #include "../../fceulua.h" @@ -65,118 +66,6 @@ bool menuTogglingEnabled = false; static GtkTreeStore *hotkey_store = NULL; -//----------------------------------------- -// Ram Watch static variables -static GtkTreeStore *ram_watch_store = NULL; -static gint ramWatchEvntSrcID = 0; -static bool ramWatchWinOpen = false; -static int ramWatchEditRowIdx = -1; -static int ramWatchEditColIdx = -1; - -struct ramWatch_t -{ - std::string name; - int addr; - int type; - int size; - - union { - int8_t i8; - uint8_t u8; - int16_t i16; - uint16_t u16; - } val; - - ramWatch_t(void) - { - addr = 0; type = 0; size = 0; val.u16 = 0; - }; - - void updateMem(void) - { - if ( size == 1) - { - val.u8 = GetMem( addr ); - } - else if ( size == 2) - { - val.u16 = GetMem( addr ) | (GetMem( addr+1 ) << 8); - } - else - { - val.u8 = GetMem( addr ); - } - } -}; - -struct ramWatchList_t -{ - - std::list ls; - - ramWatchList_t(void) - { - - } - - ~ramWatchList_t(void) - { - ramWatch_t *rw; - - while ( !ls.empty() ) - { - rw = ls.front(); - - delete rw; - - ls.pop_front(); - } - } - - size_t size(void){ return ls.size(); }; - - void add_entry( const char *name, int addr, int type, int size ) - { - ramWatch_t *rw = new ramWatch_t; - - rw->name.assign(name); - rw->addr = addr; - rw->type = type; - rw->size = size; - ls.push_back(rw); - } - - void updateMemoryValues(void) - { - ramWatch_t *rw; - std::list ::iterator it; - - for (it=ls.begin(); it!=ls.end(); it++) - { - rw = *it; - - rw->updateMem(); - } - } - - ramWatch_t *getIndex(size_t idx) - { - size_t i=0; - std::list ::iterator it; - - for (it=ls.begin(); it!=ls.end(); it++) - { - if ( i == idx ) - { - return *it; - } - i++; - } - return NULL; - } -}; -static ramWatchList_t ramWatchList; - // check to see if a particular GTK version is available // 2.24 is required for most of the dialogs -- ie: checkGTKVersion(2,24); bool checkGTKVersion(int major_required, int minor_required) @@ -1512,771 +1401,6 @@ void toggleAutoResume(GtkCheckMenuItem *item, gpointer user_data) AutoResumePlay = autoResume; } -//******************************************************************************************************* -// Ram Watch Window -//******************************************************************************************************* -// -static void showRamWatchResults(int reset) -{ - int row=0; - std::list ::iterator it; - GtkTreeIter iter; - char addrStr[32], valStr1[16], valStr2[16]; - ramWatch_t *rw; - - //if ( !reset ) - //{ - // if ( gtk_tree_model_get_iter_first( GTK_TREE_MODEL(ram_watch_store), &iter ) ) - // { - // size_t treeSize = 1; - - // while ( gtk_tree_model_iter_next( GTK_TREE_MODEL(ram_watch_store), &iter ) ) - // { - // treeSize++; - // } - // if ( treeSize != ramWatchList.size() ) - // { - // reset = 1; - // } - // //printf(" TreeSize: %zi RamWatchList.size: %zi \n", treeSize, ramWatchList.size() ); - // } - //} - - if ( reset ) - { - gtk_tree_store_clear(ram_watch_store); - } - else - { - if ( !gtk_tree_model_get_iter_first( GTK_TREE_MODEL(ram_watch_store), &iter ) ) - { - gtk_tree_store_append( ram_watch_store, &iter, NULL); // aquire iter - } - } - - for (it=ramWatchList.ls.begin(); it!=ramWatchList.ls.end(); it++) - { - rw = *it; - sprintf( addrStr, "0x%04X", rw->addr ); - - if ( reset ){ - gtk_tree_store_append( ram_watch_store, &iter, NULL); // aquire iter - } - - rw->updateMem(); - - if ( rw->size == 2 ) - { - if ( rw->type ){ - sprintf( valStr1, "%6u", rw->val.u16); - } else { - sprintf( valStr1, "%6i", rw->val.i16); - } - sprintf( valStr2, "0x%04X", rw->val.u16); - } - else - { - if ( rw->type ){ - sprintf( valStr1, "%6u", rw->val.u8); - } else { - sprintf( valStr1, "%6i", rw->val.i8); - } - sprintf( valStr2, "0x%02X", rw->val.u8); - } - - if ( row != ramWatchEditRowIdx ) - { - gtk_tree_store_set(ram_watch_store, &iter, - 0, addrStr, 1, valStr1, 2, valStr2, 3, rw->name.c_str(), - -1); - } - else - { - //if ( ramWatchEditColIdx != 0 ) - //{ - // gtk_tree_store_set(ram_watch_store, &iter, 0, addrStr, -1 ); - //} - - //if ( ramWatchEditColIdx != 1 ) - //{ - // gtk_tree_store_set(ram_watch_store, &iter, 1, valStr1, -1 ); - //} - - //if ( ramWatchEditColIdx != 2 ) - //{ - // gtk_tree_store_set(ram_watch_store, &iter, 2, valStr2, -1 ); - //} - - //if ( ramWatchEditColIdx != 3 ) - //{ - // gtk_tree_store_set(ram_watch_store, &iter, 3, rw->name.c_str(), -1 ); - //} - } - - if ( !reset ) - { - if ( !gtk_tree_model_iter_next( GTK_TREE_MODEL(ram_watch_store), &iter ) ) - { - gtk_tree_store_append( ram_watch_store, &iter, NULL); // aquire iter - } - } - row++; - } -} - -static void saveWatchFile( const char *filename ) -{ - int i; - FILE *fp; - const char *c; - std::list ::iterator it; - ramWatch_t *rw; - - fp = fopen( filename, "w"); - - if ( fp == NULL ) - { - printf("Error: Failed to open file: %s\n", filename); - return; - } - - for (it=ramWatchList.ls.begin(); it!=ramWatchList.ls.end(); it++) - { - rw = *it; - - c = rw->name.c_str(); - - fprintf( fp, "0x%04x %c%i ", rw->addr, rw->type ? 'U' : 'S', rw->size); - - i=0; - fprintf( fp, "\""); - while ( c[i] ) - { - if ( c[i] == '"') - { - fprintf( fp, "\\%c", c[i]); - } - else - { - fprintf( fp, "%c", c[i]); - } - i++; - } - fprintf( fp, "\"\n"); - } - fclose(fp); - -} - -static void loadWatchFile( const char *filename ) -{ - FILE *fp; - int i, j, a, t, s, literal; - char line[512], stmp[512]; - ramWatch_t *rw; - - fp = fopen( filename, "r"); - - if ( fp == NULL ) - { - printf("Error: Failed to open file: %s\n", filename); - return; - } - - while ( fgets( line, sizeof(line)-1, fp ) > 0) - { - a = -1; t = -1; s = -1; - // Check for Comments - i=0; - while ( line[i] != 0 ) - { - if ( literal ) - { - literal = 0; - } - else - { - if ( line[i] == '#') - { - line[i] = 0; break; - } - else if ( line[i] == '\\' ) - { - literal = 1; - } - } - i++; - } - - i=0; j=0; - while ( isspace(line[i]) ) i++; - - if ( (line[i] == '0') && ( tolower(line[i+1]) == 'x') ) - { - stmp[j] = '0'; j++; i++; - stmp[j] = 'x'; j++; i++; - - while ( isxdigit(line[i]) ) - { - stmp[j] = line[i]; i++; j++; - } - } - else - { - while ( isxdigit(line[i]) ) - { - stmp[j] = line[i]; i++; j++; - } - } - stmp[j] = 0; - - if ( j == 0 ) continue; - - a = strtol( stmp, NULL, 0); - - while ( isspace(line[i]) ) i++; - - t = line[i]; i++; - s = line[i]; i++; - - if ( (t != 'U') && (t != 'S') ) - { - printf("Error: Invalid RAM Watch Byte Type: %c", t); - continue; - } - if ( !isdigit(s) ) - { - printf("Error: Invalid RAM Watch Byte Size: %c", s); - continue; - } - s = s - '0'; - - if ( (s != 1) && (s != 2) && (s != 4) ) - { - printf("Error: Invalid RAM Watch Byte Size: %i", s); - continue; - } - - while ( isspace(line[i]) ) i++; - - if ( line[i] == '"') - { - i++; j=0; - literal = 0; - while ( (line[i] != 0) ) - { - if ( literal ) - { - literal = 0; - } - else - { - if ( line[i] == '"') - { - break; - } - else if ( line[i] == '\\' ) - { - literal = 1; - } - } - if ( !literal ){ - stmp[j] = line[i]; j++; - } - i++; - } - stmp[j] = 0; - } - rw = new ramWatch_t; - - rw->addr = a; - rw->type = (t == 'U') ? 1 : 0; - rw->size = s; - rw->name.assign( stmp ); - - ramWatchList.ls.push_back(rw); - } - - fclose(fp); - - showRamWatchResults(1); -} - -static void openWatchFile( int mode ) -{ - GtkWidget* fileChooser; - GtkFileFilter* filterWch; - GtkFileFilter* filterAll; - - filterWch = gtk_file_filter_new(); - gtk_file_filter_add_pattern(filterWch, "*.wch"); - gtk_file_filter_add_pattern(filterWch, "*.WCH"); - gtk_file_filter_set_name(filterWch, "Watch files"); - - filterAll = gtk_file_filter_new(); - gtk_file_filter_add_pattern(filterAll, "*"); - gtk_file_filter_set_name(filterAll, "All Files"); - - //const char* last_dir; - //g_config->getOption("SDL.LastSaveStateAs", &last_dir); - - - if ( mode ) - { - fileChooser = gtk_file_chooser_dialog_new ("Save Watch File", GTK_WINDOW(MainWindow), - GTK_FILE_CHOOSER_ACTION_SAVE, "_Cancel", GTK_RESPONSE_CANCEL, - "_Save", GTK_RESPONSE_ACCEPT, NULL); - } - else - { - fileChooser = gtk_file_chooser_dialog_new ("Load Watch File", GTK_WINDOW(MainWindow), - GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel", GTK_RESPONSE_CANCEL, - "_Open", GTK_RESPONSE_ACCEPT, NULL); - } - - //gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fileChooser), last_dir); - - //gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER(fileChooser), ".wch"); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterWch); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterAll); - - if (gtk_dialog_run (GTK_DIALOG (fileChooser)) ==GTK_RESPONSE_ACCEPT) - { - char* filename; - - filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fileChooser)); - //FCEUI_SaveState(filename); - //g_config->setOption("SDL.LastSaveStateAs", filename); - if ( filename ) - { - if ( mode ) - { - saveWatchFile( filename ); - } - else - { - loadWatchFile( filename ); - } - g_free(filename); - } - } - gtk_widget_destroy (fileChooser); -} - -static void loadRamWatchCB( GtkMenuItem *menuitem, - gpointer user_data) -{ - openWatchFile(0); -} -static void saveRamWatchCB( GtkMenuItem *menuitem, - gpointer user_data) -{ - openWatchFile(1); -} - -static GtkWidget* CreateRamWatchMenubar( GtkWidget* window) -{ - GtkWidget *menubar, *menu, *item; - - menubar = gtk_menu_bar_new(); - - item = gtk_menu_item_new_with_label("File"); - - gtk_menu_shell_append( GTK_MENU_SHELL(menubar), item ); - - menu = gtk_menu_new(); - - gtk_menu_item_set_submenu( GTK_MENU_ITEM(item), menu ); - - item = gtk_menu_item_new_with_label("Load Watch"); - - g_signal_connect( item, "activate", G_CALLBACK(loadRamWatchCB), NULL); - - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); - - item = gtk_menu_item_new_with_label("Save Watch"); - - g_signal_connect( item, "activate", G_CALLBACK(saveRamWatchCB), NULL); - - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); - - // Finally, return the actual menu bar created - return menubar; -} - -static int openRamWatchEntryDialog( char *name, int *addr, int *type, int *size ) -{ - int retval; - GtkWidget* win; - GtkWidget* vbox; - GtkWidget* hbox; - GtkWidget* label; - GtkWidget* chkbox; - GtkWidget* button1, *button2, *button4; - GtkWidget* txt_entry_name; - GtkWidget* txt_entry_addr; - char stmp[32]; - - win = gtk_dialog_new_with_buttons("RAM Watch Entry", - GTK_WINDOW(MainWindow), (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT), - "_Close", - GTK_RESPONSE_OK, - NULL); - gtk_window_set_default_size(GTK_WINDOW(win), 400, 200); - - vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 6); - - label = gtk_label_new("Name:"); - txt_entry_name = gtk_entry_new(); - - if ( name[0] != 0 ){ - gtk_entry_set_text( GTK_ENTRY(txt_entry_name), name ); - } - - gtk_box_pack_start (GTK_BOX(vbox), label, FALSE, FALSE, 0); - gtk_box_pack_start (GTK_BOX(vbox), txt_entry_name, FALSE, TRUE, 0); - - hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); - label = gtk_label_new("Hex Address:"); - txt_entry_addr = gtk_entry_new(); - - gtk_box_pack_start (GTK_BOX(vbox), label, FALSE, FALSE, 0); - - label = gtk_label_new("0x"); - sprintf( stmp, "%04x", *addr ); - gtk_entry_set_max_length( GTK_ENTRY(txt_entry_addr), 4 ); - gtk_entry_set_width_chars( GTK_ENTRY(txt_entry_addr), 4 ); - gtk_entry_set_text( GTK_ENTRY(txt_entry_addr), stmp ); - - gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0); - gtk_box_pack_start (GTK_BOX(hbox), txt_entry_addr, TRUE, TRUE, 0); - gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, TRUE, 0); - - chkbox = gtk_check_button_new_with_label("Value is Unsigned"); - gtk_box_pack_start (GTK_BOX(vbox), chkbox, FALSE, FALSE, 0); - - hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); - label = gtk_label_new("Size in Bytes:"); - button1 = gtk_radio_button_new_with_label (NULL, "1"); - //gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); - - gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 1); - gtk_box_pack_start (GTK_BOX(hbox), button1, TRUE, FALSE, 1); - - button2 = gtk_radio_button_new_with_label_from_widget ( GTK_RADIO_BUTTON (button1), "2"); - gtk_box_pack_start (GTK_BOX(hbox), button2, TRUE, FALSE, 1); - - button4 = gtk_radio_button_new_with_label_from_widget ( GTK_RADIO_BUTTON (button1), "4"); - gtk_box_pack_start (GTK_BOX(hbox), button4, TRUE, FALSE, 1); - - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button1), TRUE); - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button2), FALSE); - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button4), FALSE); - - gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, TRUE, 1); - - gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(win))), vbox, TRUE, TRUE, 1); - - gtk_widget_show_all(win); - - retval = gtk_dialog_run(GTK_DIALOG(win)); - - if ( retval ) - { - // FIXME - what error checking should be done here - } - - strcpy( name, gtk_entry_get_text ( GTK_ENTRY(txt_entry_name) ) ); - - *addr = strtol( gtk_entry_get_text ( GTK_ENTRY(txt_entry_addr) ), NULL, 16 ); - - *type = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(chkbox) ); - - if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(button4) ) ) - { - *size = 4; - } - else if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(button2) ) ) - { - *size = 2; - } - else - { - *size = 1; - } - - //printf("retval %i\n", retval ); - - g_signal_connect(win, "delete-event", G_CALLBACK(closeDialog), NULL); - g_signal_connect(win, "response", G_CALLBACK(closeDialog), NULL); - - gtk_widget_destroy(win); - - return 0; -} - -static void editRamWatch( GtkButton *button, - void *userData ) -{ - char name[256]; - int addr = 0, type = 0, size = 0; - name[0] = 0; - openRamWatchEntryDialog( name, &addr, &type, &size ); - printf("Edit RamWatch '%s' 0x%04x %i %i\n", name, addr, type, size); -} - -static void removeRamWatch( GtkButton *button, - void *userData ) -{ - printf("Remove RamWatch\n"); -} - -static void newRamWatch( GtkButton *button, - void *userData ) -{ - char name[256]; - int addr = 0, type = 0, size = 0; - name[0] = 0; - openRamWatchEntryDialog( name, &addr, &type, &size ); - printf("New RamWatch '%s' 0x%04x %i %i\n", name, addr, type, size); - - ramWatchList.add_entry( name, addr, type, size ); - - showRamWatchResults(1); -} - -static gint updateRamWatchTree( void *userData ) -{ - //static uint32_t c = 0; - //printf("RamWatch: %u\n", c++ ); - showRamWatchResults(0); - return 1; -} - -static void ramWatch_cell_edited_cb ( - GtkCellRendererText *cell, - gchar *path_string, - gchar *new_text, - gpointer user_data) -{ - ramWatch_t *rw; - //printf("Ram Watch Edited: %i:%i\n", ramWatchEditRowIdx, ramWatchEditColIdx); - - rw = ramWatchList.getIndex( ramWatchEditRowIdx ); - - switch ( (long)user_data ) - { - case 0: - rw->addr = strtol( new_text, NULL, 0 ); - break; - case 1: - case 2: - { - writefunc wfunc; - - if ( rw->size == 2 ) - { - if ( rw->type ) - { - rw->val.u16 = strtol( new_text, NULL, 0 ); - } - else - { - rw->val.i16 = strtol( new_text, NULL, 0 ); - } - wfunc = GetWriteHandler( rw->addr ); - - if ( wfunc ) - { - wfunc( (uint32)rw->addr, (uint8)(rw->val.u16 & 0x00ff) ); - } - - wfunc = GetWriteHandler( rw->addr+1 ); - - if ( wfunc ) - { - wfunc( (uint32)rw->addr+1, (uint8)( (rw->val.u16 & 0xff00) >> 8) ); - } - } - else - { - if ( rw->type ) - { - rw->val.u8 = strtol( new_text, NULL, 0 ); - } - else - { - rw->val.i8 = strtol( new_text, NULL, 0 ); - } - wfunc = GetWriteHandler( rw->addr ); - - if ( wfunc ) - { - wfunc( (uint32)rw->addr, (uint8)rw->val.u8 ); - } - } - } - break; - case 3: - rw->name.assign( new_text ); - break; - default: - - break; - } - - ramWatchEditRowIdx = -1; - ramWatchEditColIdx = -1; -} - -static void ramWatch_cell_edited_start_cb( - GtkCellRenderer *renderer, - GtkCellEditable *editable, - gchar *path, - gpointer user_data) -{ - //printf("Ram Watch Edit Start: '%s':%li\n", path, (long)user_data); - ramWatchEditRowIdx = atoi( path ); - ramWatchEditColIdx = (long)user_data; -} - -static void ramWatch_cell_edited_cancel_cb( - GtkCellRenderer *renderer, - gpointer user_data) -{ - //printf("Ram Watch Edit Cancel:%li\n", (long)user_data); - ramWatchEditRowIdx = -1; - ramWatchEditColIdx = -1; -} - -void closeMemoryWatchWindow(GtkWidget* w, GdkEvent* e, gpointer p) -{ - ramWatchWinOpen = false; - - gtk_widget_destroy(w); -} - -// creates and opens cheats window -static void openMemoryWatchWindow(void) -{ - GtkWidget* win; - GtkWidget* main_vbox; - GtkWidget* hbox; - GtkWidget* vbox; - GtkWidget* button; - GtkWidget *tree; - GtkWidget *scroll; - GtkWidget* menubar; - - if ( ramWatchWinOpen ) - { - return; // Only allow 1 RAM watch window to be open. - } - - win = gtk_dialog_new_with_buttons("RAM Watch", - GTK_WINDOW(MainWindow), (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT), - "_Close", - GTK_RESPONSE_OK, - NULL); - gtk_window_set_default_size(GTK_WINDOW(win), 600, 600); - - main_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 1); - - menubar = CreateRamWatchMenubar(win); - - gtk_box_pack_start (GTK_BOX(main_vbox), menubar, FALSE, TRUE, 0); - - hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL,2); - - ram_watch_store = gtk_tree_store_new( 4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); - - tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(ram_watch_store)); - - gtk_tree_view_set_grid_lines( GTK_TREE_VIEW(tree), GTK_TREE_VIEW_GRID_LINES_VERTICAL ); - - GtkCellRenderer *renderer; - GtkTreeViewColumn* column; - - renderer = gtk_cell_renderer_text_new(); - g_object_set(renderer, "family", "MonoSpace", NULL); - g_object_set(renderer, "editable", TRUE, NULL); - g_signal_connect(renderer, "edited", (GCallback) ramWatch_cell_edited_cb, (gpointer)0); - g_signal_connect(renderer, "editing-started", (GCallback) ramWatch_cell_edited_start_cb, (gpointer)0); - g_signal_connect(renderer, "editing-canceled", (GCallback) ramWatch_cell_edited_cancel_cb, (gpointer)0); - column = gtk_tree_view_column_new_with_attributes("Addr", renderer, "text", 0, NULL); - gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); - - renderer = gtk_cell_renderer_text_new(); - g_object_set(renderer, "family", "MonoSpace", NULL); - g_object_set(renderer, "editable", TRUE, NULL); - g_signal_connect(renderer, "edited", (GCallback) ramWatch_cell_edited_cb, (gpointer)1); - g_signal_connect(renderer, "editing-started", (GCallback) ramWatch_cell_edited_start_cb, (gpointer)1); - g_signal_connect(renderer, "editing-canceled", (GCallback) ramWatch_cell_edited_cancel_cb, (gpointer)1); - column = gtk_tree_view_column_new_with_attributes("Value Dec", renderer, "text", 1, NULL); - gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); - - renderer = gtk_cell_renderer_text_new(); - g_object_set(renderer, "family", "MonoSpace", NULL); - g_object_set(renderer, "editable", TRUE, NULL); - g_signal_connect(renderer, "edited", (GCallback) ramWatch_cell_edited_cb, (gpointer)2); - g_signal_connect(renderer, "editing-started", (GCallback) ramWatch_cell_edited_start_cb, (gpointer)2); - g_signal_connect(renderer, "editing-canceled", (GCallback) ramWatch_cell_edited_cancel_cb, (gpointer)2); - column = gtk_tree_view_column_new_with_attributes("Value Hex", renderer, "text", 2, NULL); - gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); - - renderer = gtk_cell_renderer_text_new(); - g_object_set(renderer, "editable", TRUE, NULL); - g_signal_connect(renderer, "edited", (GCallback) ramWatch_cell_edited_cb, (gpointer)3); - g_signal_connect(renderer, "editing-started", (GCallback) ramWatch_cell_edited_start_cb, (gpointer)3); - g_signal_connect(renderer, "editing-canceled", (GCallback) ramWatch_cell_edited_cancel_cb, (gpointer)3); - column = gtk_tree_view_column_new_with_attributes("Notes", renderer, "text", 3, NULL); - gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); - - scroll = gtk_scrolled_window_new(NULL, NULL); - gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, - GTK_POLICY_AUTOMATIC); - gtk_container_add(GTK_CONTAINER(scroll), tree); - gtk_box_pack_start(GTK_BOX(hbox), scroll, TRUE, TRUE, 5); - - gtk_box_pack_start(GTK_BOX(main_vbox), hbox, TRUE, TRUE, 5); - - showRamWatchResults(1); - - if ( ramWatchEvntSrcID == 0 ) - { - ramWatchEvntSrcID = g_timeout_add( 100, updateRamWatchTree, NULL ); - } - - vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 3); - - button = gtk_button_new_with_label("Edit"); - gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 5); - g_signal_connect( button, "clicked", - G_CALLBACK (editRamWatch), (gpointer) NULL ); - - button = gtk_button_new_with_label("Remove"); - gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 5); - g_signal_connect( button, "clicked", - G_CALLBACK (removeRamWatch), (gpointer) NULL ); - - button = gtk_button_new_with_label("New"); - gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 5); - g_signal_connect( button, "clicked", - G_CALLBACK (newRamWatch), (gpointer) NULL ); - - gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 5); - - gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(win))), main_vbox, TRUE, TRUE, 0); - - g_signal_connect(win, "delete-event", G_CALLBACK(closeMemoryWatchWindow), NULL); - g_signal_connect(win, "response", G_CALLBACK(closeMemoryWatchWindow), NULL); - - gtk_widget_show_all(win); - - ramWatchWinOpen = true; -} - - void recordMovie() { if(isloaded) diff --git a/src/drivers/sdl/ramwatch.cpp b/src/drivers/sdl/ramwatch.cpp new file mode 100644 index 00000000..2de4e69b --- /dev/null +++ b/src/drivers/sdl/ramwatch.cpp @@ -0,0 +1,1126 @@ +#include +#include +#include +#include +#include + +#include +#include +#ifdef GDK_WINDOWING_X11 +#include +#endif + +#ifdef _GTK3 +#include +#endif + +#include "../../types.h" +#include "../../fceu.h" +#include "../../cheat.h" +#include "../../debug.h" +#include "../../driver.h" +#include "../../version.h" +#include "../../movie.h" +#include "../../palette.h" +#include "../../fds.h" +#include "../common/configSys.h" + +#include "sdl.h" +#include "gui.h" +#include "dface.h" +#include "input.h" +#include "config.h" + +extern Config *g_config; + +//******************************************************************************************************* +// Ram Watch Window +//******************************************************************************************************* +// +struct ramWatch_t +{ + std::string name; + int addr; + int type; + int size; + + union { + int8_t i8; + uint8_t u8; + int16_t i16; + uint16_t u16; + } val; + + ramWatch_t(void) + { + addr = 0; type = 0; size = 0; val.u16 = 0; + }; + + void updateMem(void) + { + if ( size == 1) + { + val.u8 = GetMem( addr ); + } + else if ( size == 2) + { + val.u16 = GetMem( addr ) | (GetMem( addr+1 ) << 8); + } + else + { + val.u8 = GetMem( addr ); + } + } +}; + +struct ramWatchList_t +{ + + std::list ls; + + ramWatchList_t(void) + { + + } + + ~ramWatchList_t(void) + { + ramWatch_t *rw; + + while ( !ls.empty() ) + { + rw = ls.front(); + + delete rw; + + ls.pop_front(); + } + } + + size_t size(void){ return ls.size(); }; + + void add_entry( const char *name, int addr, int type, int size ) + { + ramWatch_t *rw = new ramWatch_t; + + rw->name.assign(name); + rw->addr = addr; + rw->type = type; + rw->size = size; + ls.push_back(rw); + } + + void updateMemoryValues(void) + { + ramWatch_t *rw; + std::list ::iterator it; + + for (it=ls.begin(); it!=ls.end(); it++) + { + rw = *it; + + rw->updateMem(); + } + } + + ramWatch_t *getIndex(size_t idx) + { + size_t i=0; + std::list ::iterator it; + + for (it=ls.begin(); it!=ls.end(); it++) + { + if ( i == idx ) + { + return *it; + } + i++; + } + return NULL; + } + + int deleteIndex(size_t idx) + { + size_t i=0; + std::list ::iterator it; + + for (it=ls.begin(); it!=ls.end(); it++) + { + if ( i == idx ) + { + delete *it; + ls.erase(it); + return 0; + } + i++; + } + return -1; + } +}; +static ramWatchList_t ramWatchList; + +struct ramWatchWin_t; + +struct ramWatchEntryWin_t +{ + GtkWidget* win; + GtkWidget* chkbox; + GtkWidget* button1, *button2, *button4; + GtkWidget *txt_entry_name; + GtkWidget *txt_entry_addr; + ramWatchWin_t *rww; + int idx; + + ramWatchEntryWin_t(void) + { + win = NULL; + chkbox = NULL; + button1 = NULL; + button2 = NULL; + button4 = NULL; + txt_entry_name = NULL; + txt_entry_addr = NULL; + rww = NULL; + idx = -1; + } +}; + +struct ramWatchWin_t +{ + + GtkWidget *win; + GtkWidget *tree; + GtkTreeStore *ram_watch_store; + bool ramWatchWinOpen; + int ramWatchEditRowIdx; + int ramWatchEditColIdx; + + ramWatchWin_t(void) + { + win = NULL; + tree = NULL; + ram_watch_store = NULL; + ramWatchWinOpen = false; + ramWatchEditRowIdx = -1; + ramWatchEditColIdx = -1; + } + + void showRamWatchResults(int reset); +}; + +static gint ramWatchEvntSrcID = 0; + +void ramWatchWin_t::showRamWatchResults(int reset) +{ + int row=0; + std::list ::iterator it; + GtkTreeIter iter; + char addrStr[32], valStr1[16], valStr2[16]; + ramWatch_t *rw; + + //if ( !reset ) + //{ + // if ( gtk_tree_model_get_iter_first( GTK_TREE_MODEL(ram_watch_store), &iter ) ) + // { + // size_t treeSize = 1; + + // while ( gtk_tree_model_iter_next( GTK_TREE_MODEL(ram_watch_store), &iter ) ) + // { + // treeSize++; + // } + // if ( treeSize != ramWatchList.size() ) + // { + // reset = 1; + // } + // //printf(" TreeSize: %zi RamWatchList.size: %zi \n", treeSize, ramWatchList.size() ); + // } + //} + + if ( reset ) + { + gtk_tree_store_clear(ram_watch_store); + } + else + { + if ( !gtk_tree_model_get_iter_first( GTK_TREE_MODEL(ram_watch_store), &iter ) ) + { + gtk_tree_store_append( ram_watch_store, &iter, NULL); // aquire iter + } + } + + for (it=ramWatchList.ls.begin(); it!=ramWatchList.ls.end(); it++) + { + rw = *it; + sprintf( addrStr, "0x%04X", rw->addr ); + + if ( reset ){ + gtk_tree_store_append( ram_watch_store, &iter, NULL); // aquire iter + } + + rw->updateMem(); + + if ( rw->size == 2 ) + { + if ( rw->type ){ + sprintf( valStr1, "%6u", rw->val.u16); + } else { + sprintf( valStr1, "%6i", rw->val.i16); + } + sprintf( valStr2, "0x%04X", rw->val.u16); + } + else + { + if ( rw->type ){ + sprintf( valStr1, "%6u", rw->val.u8); + } else { + sprintf( valStr1, "%6i", rw->val.i8); + } + sprintf( valStr2, "0x%02X", rw->val.u8); + } + + if ( row != ramWatchEditRowIdx ) + { + gtk_tree_store_set(ram_watch_store, &iter, + 0, addrStr, 1, valStr1, 2, valStr2, 3, rw->name.c_str(), + -1); + } + else + { + //if ( ramWatchEditColIdx != 0 ) + //{ + // gtk_tree_store_set(ram_watch_store, &iter, 0, addrStr, -1 ); + //} + + //if ( ramWatchEditColIdx != 1 ) + //{ + // gtk_tree_store_set(ram_watch_store, &iter, 1, valStr1, -1 ); + //} + + //if ( ramWatchEditColIdx != 2 ) + //{ + // gtk_tree_store_set(ram_watch_store, &iter, 2, valStr2, -1 ); + //} + + //if ( ramWatchEditColIdx != 3 ) + //{ + // gtk_tree_store_set(ram_watch_store, &iter, 3, rw->name.c_str(), -1 ); + //} + } + + if ( !reset ) + { + if ( !gtk_tree_model_iter_next( GTK_TREE_MODEL(ram_watch_store), &iter ) ) + { + gtk_tree_store_append( ram_watch_store, &iter, NULL); // aquire iter + } + } + row++; + } +} + +static std::list ramWatchWinList; + +void showAllRamWatchResults(int reset) +{ + std::list ::iterator it; + + for (it=ramWatchWinList.begin(); it != ramWatchWinList.end(); it++) + { + (*it)->showRamWatchResults(reset); + } +} + +static void saveWatchFile( const char *filename ) +{ + int i; + FILE *fp; + const char *c; + std::list ::iterator it; + ramWatch_t *rw; + + fp = fopen( filename, "w"); + + if ( fp == NULL ) + { + printf("Error: Failed to open file: %s\n", filename); + return; + } + + for (it=ramWatchList.ls.begin(); it!=ramWatchList.ls.end(); it++) + { + rw = *it; + + c = rw->name.c_str(); + + fprintf( fp, "0x%04x %c%i ", rw->addr, rw->type ? 'U' : 'S', rw->size); + + i=0; + fprintf( fp, "\""); + while ( c[i] ) + { + if ( c[i] == '"') + { + fprintf( fp, "\\%c", c[i]); + } + else + { + fprintf( fp, "%c", c[i]); + } + i++; + } + fprintf( fp, "\"\n"); + } + fclose(fp); + +} + +static void loadWatchFile( const char *filename ) +{ + FILE *fp; + int i, j, a, t, s, literal; + char line[512], stmp[512]; + ramWatch_t *rw; + + fp = fopen( filename, "r"); + + if ( fp == NULL ) + { + printf("Error: Failed to open file: %s\n", filename); + return; + } + + while ( fgets( line, sizeof(line)-1, fp ) > 0) + { + a = -1; t = -1; s = -1; + // Check for Comments + i=0; + while ( line[i] != 0 ) + { + if ( literal ) + { + literal = 0; + } + else + { + if ( line[i] == '#') + { + line[i] = 0; break; + } + else if ( line[i] == '\\' ) + { + literal = 1; + } + } + i++; + } + + i=0; j=0; + while ( isspace(line[i]) ) i++; + + if ( (line[i] == '0') && ( tolower(line[i+1]) == 'x') ) + { + stmp[j] = '0'; j++; i++; + stmp[j] = 'x'; j++; i++; + + while ( isxdigit(line[i]) ) + { + stmp[j] = line[i]; i++; j++; + } + } + else + { + while ( isxdigit(line[i]) ) + { + stmp[j] = line[i]; i++; j++; + } + } + stmp[j] = 0; + + if ( j == 0 ) continue; + + a = strtol( stmp, NULL, 0); + + while ( isspace(line[i]) ) i++; + + t = line[i]; i++; + s = line[i]; i++; + + if ( (t != 'U') && (t != 'S') ) + { + printf("Error: Invalid RAM Watch Byte Type: %c", t); + continue; + } + if ( !isdigit(s) ) + { + printf("Error: Invalid RAM Watch Byte Size: %c", s); + continue; + } + s = s - '0'; + + if ( (s != 1) && (s != 2) && (s != 4) ) + { + printf("Error: Invalid RAM Watch Byte Size: %i", s); + continue; + } + + while ( isspace(line[i]) ) i++; + + if ( line[i] == '"') + { + i++; j=0; + literal = 0; + while ( (line[i] != 0) ) + { + if ( literal ) + { + literal = 0; + } + else + { + if ( line[i] == '"') + { + break; + } + else if ( line[i] == '\\' ) + { + literal = 1; + } + } + if ( !literal ){ + stmp[j] = line[i]; j++; + } + i++; + } + stmp[j] = 0; + } + rw = new ramWatch_t; + + rw->addr = a; + rw->type = (t == 'U') ? 1 : 0; + rw->size = s; + rw->name.assign( stmp ); + + ramWatchList.ls.push_back(rw); + } + + fclose(fp); + + showAllRamWatchResults(1); +} + +static void openWatchFile( int mode ) +{ + GtkWidget* fileChooser; + GtkFileFilter* filterWch; + GtkFileFilter* filterAll; + + filterWch = gtk_file_filter_new(); + gtk_file_filter_add_pattern(filterWch, "*.wch"); + gtk_file_filter_add_pattern(filterWch, "*.WCH"); + gtk_file_filter_set_name(filterWch, "Watch files"); + + filterAll = gtk_file_filter_new(); + gtk_file_filter_add_pattern(filterAll, "*"); + gtk_file_filter_set_name(filterAll, "All Files"); + + //const char* last_dir; + //g_config->getOption("SDL.LastSaveStateAs", &last_dir); + + + if ( mode ) + { + fileChooser = gtk_file_chooser_dialog_new ("Save Watch File", GTK_WINDOW(MainWindow), + GTK_FILE_CHOOSER_ACTION_SAVE, "_Cancel", GTK_RESPONSE_CANCEL, + "_Save", GTK_RESPONSE_ACCEPT, NULL); + } + else + { + fileChooser = gtk_file_chooser_dialog_new ("Load Watch File", GTK_WINDOW(MainWindow), + GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel", GTK_RESPONSE_CANCEL, + "_Open", GTK_RESPONSE_ACCEPT, NULL); + } + + //gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fileChooser), last_dir); + + //gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER(fileChooser), ".wch"); + gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterWch); + gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterAll); + + if (gtk_dialog_run (GTK_DIALOG (fileChooser)) ==GTK_RESPONSE_ACCEPT) + { + char* filename; + + filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fileChooser)); + //FCEUI_SaveState(filename); + //g_config->setOption("SDL.LastSaveStateAs", filename); + if ( filename ) + { + if ( mode ) + { + saveWatchFile( filename ); + } + else + { + loadWatchFile( filename ); + } + g_free(filename); + } + } + gtk_widget_destroy (fileChooser); +} + +static void loadRamWatchCB( GtkMenuItem *menuitem, + gpointer user_data) +{ + openWatchFile(0); +} +static void saveRamWatchCB( GtkMenuItem *menuitem, + gpointer user_data) +{ + openWatchFile(1); +} + +static GtkWidget* CreateRamWatchMenubar( GtkWidget* window) +{ + GtkWidget *menubar, *menu, *item; + + menubar = gtk_menu_bar_new(); + + item = gtk_menu_item_new_with_label("File"); + + gtk_menu_shell_append( GTK_MENU_SHELL(menubar), item ); + + menu = gtk_menu_new(); + + gtk_menu_item_set_submenu( GTK_MENU_ITEM(item), menu ); + + item = gtk_menu_item_new_with_label("Load Watch"); + + g_signal_connect( item, "activate", G_CALLBACK(loadRamWatchCB), NULL); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + item = gtk_menu_item_new_with_label("Save Watch"); + + g_signal_connect( item, "activate", G_CALLBACK(saveRamWatchCB), NULL); + + gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + + // Finally, return the actual menu bar created + return menubar; +} + +void closeMemoryWatchEntryWindow(GtkWidget* w, GdkEvent* e, ramWatchEntryWin_t *ew) +{ + +// strcpy( name, gtk_entry_get_text ( GTK_ENTRY(ew->txt_entry_name) ) ); + +//*addr = strtol( gtk_entry_get_text ( GTK_ENTRY(ew->txt_entry_addr) ), NULL, 16 ); + +//*type = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(ew->chkbox) ); + +// if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(ew->button4) ) ) +// { +// *size = 4; +// } +// else if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(ew->button2) ) ) +// { +// *size = 2; +// } +// else +// { +// *size = 1; +// } + + delete ew; + + gtk_widget_destroy(w); +} + +static int openRamWatchEntryDialog( ramWatchWin_t *rww, std::string *name, int *addr, int *type, int *size, int idx ) +{ + int retval; + GtkWidget* vbox; + GtkWidget* hbox; + GtkWidget* label; + ramWatchEntryWin_t *ew; + char stmp[32]; + + ew = new ramWatchEntryWin_t; + + //printf("RAM Entry At Index %i \n", idx ); + + ew->rww = rww; + ew->idx = idx; + + ew->win = gtk_dialog_new_with_buttons("RAM Watch Entry", + GTK_WINDOW(rww->win), (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT), + "_Close", + GTK_RESPONSE_OK, + NULL); + gtk_window_set_default_size(GTK_WINDOW(ew->win), 400, 200); + + vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 6); + + label = gtk_label_new("Name:"); + ew->txt_entry_name = gtk_entry_new(); + + if ( name->size() > 0 ){ + gtk_entry_set_text( GTK_ENTRY(ew->txt_entry_name), name->c_str() ); + } + + gtk_box_pack_start (GTK_BOX(vbox), label, FALSE, FALSE, 0); + gtk_box_pack_start (GTK_BOX(vbox), ew->txt_entry_name, FALSE, TRUE, 0); + + hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); + label = gtk_label_new("Hex Address:"); + ew->txt_entry_addr = gtk_entry_new(); + + gtk_box_pack_start (GTK_BOX(vbox), label, FALSE, FALSE, 0); + + label = gtk_label_new("0x"); + sprintf( stmp, "%04x", *addr ); + gtk_entry_set_max_length( GTK_ENTRY(ew->txt_entry_addr), 4 ); + gtk_entry_set_width_chars( GTK_ENTRY(ew->txt_entry_addr), 4 ); + gtk_entry_set_text( GTK_ENTRY(ew->txt_entry_addr), stmp ); + + gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0); + gtk_box_pack_start (GTK_BOX(hbox), ew->txt_entry_addr, TRUE, TRUE, 0); + gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, TRUE, 0); + + ew->chkbox = gtk_check_button_new_with_label("Value is Unsigned"); + gtk_box_pack_start (GTK_BOX(vbox), ew->chkbox, FALSE, FALSE, 0); + + hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); + label = gtk_label_new("Size in Bytes:"); + ew->button1 = gtk_radio_button_new_with_label (NULL, "1"); + //gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); + + gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 1); + gtk_box_pack_start (GTK_BOX(hbox), ew->button1, TRUE, FALSE, 1); + + ew->button2 = gtk_radio_button_new_with_label_from_widget ( GTK_RADIO_BUTTON (ew->button1), "2"); + gtk_box_pack_start (GTK_BOX(hbox), ew->button2, TRUE, FALSE, 1); + + ew->button4 = gtk_radio_button_new_with_label_from_widget ( GTK_RADIO_BUTTON (ew->button1), "4"); + gtk_box_pack_start (GTK_BOX(hbox), ew->button4, TRUE, FALSE, 1); + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ew->button1), TRUE); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ew->button2), FALSE); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ew->button4), FALSE); + + gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, TRUE, 1); + + gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(ew->win))), vbox, TRUE, TRUE, 1); + + gtk_widget_show_all(ew->win); + + retval = gtk_dialog_run(GTK_DIALOG(ew->win)); + + if ( retval ) + { + // FIXME - what error checking should be done here + } + + name->assign( gtk_entry_get_text ( GTK_ENTRY(ew->txt_entry_name) ) ); + + *addr = strtol( gtk_entry_get_text ( GTK_ENTRY(ew->txt_entry_addr) ), NULL, 16 ); + + *type = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(ew->chkbox) ); + + if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(ew->button4) ) ) + { + *size = 4; + } + else if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(ew->button2) ) ) + { + *size = 2; + } + else + { + *size = 1; + } + + //printf("retval %i\n", retval ); + + g_signal_connect(ew->win, "delete-event", G_CALLBACK(closeMemoryWatchEntryWindow), ew); + g_signal_connect(ew->win, "response", G_CALLBACK(closeMemoryWatchEntryWindow), ew); + + //gtk_widget_destroy(win); + + return 0; +} + +static void editRamWatch( GtkButton *button, + ramWatchWin_t *rww ) +{ + GtkTreeModel *model = NULL; + GtkTreeSelection *treeSel; + int numListRows; + GList *selListRows, *tmpList; + + treeSel = gtk_tree_view_get_selection( GTK_TREE_VIEW(rww->tree) ); + + numListRows = gtk_tree_selection_count_selected_rows( treeSel ); + + if ( numListRows == 0 ) + { + return; + } + + selListRows = gtk_tree_selection_get_selected_rows( treeSel, &model ); + + tmpList = selListRows; + + while ( tmpList ) + { + int depth; + int *indexArray; + GtkTreePath *path = (GtkTreePath*)tmpList->data; + + depth = gtk_tree_path_get_depth(path); + indexArray = gtk_tree_path_get_indices(path); + + if ( depth > 0 ) + { + ramWatch_t *rw = ramWatchList.getIndex(indexArray[0]); + + if ( rw != NULL ) + { + openRamWatchEntryDialog( rww, &rw->name, &rw->addr, &rw->type, &rw->size, indexArray[0] ); + showAllRamWatchResults(1); + } + } + tmpList = tmpList->next; + } + + g_list_free_full(selListRows, (GDestroyNotify) gtk_tree_path_free); + +} + +static void removeRamWatch( GtkButton *button, + ramWatchWin_t *rww ) +{ + GtkTreeModel *model = NULL; + GtkTreeSelection *treeSel; + int numListRows; + GList *selListRows, *tmpList; + + treeSel = gtk_tree_view_get_selection( GTK_TREE_VIEW(rww->tree) ); + + numListRows = gtk_tree_selection_count_selected_rows( treeSel ); + + if ( numListRows == 0 ) + { + return; + } + + selListRows = gtk_tree_selection_get_selected_rows( treeSel, &model ); + + tmpList = selListRows; + + while ( tmpList ) + { + int depth; + int *indexArray; + GtkTreePath *path = (GtkTreePath*)tmpList->data; + + depth = gtk_tree_path_get_depth(path); + indexArray = gtk_tree_path_get_indices(path); + + if ( depth > 0 ) + { + ramWatchList.deleteIndex(indexArray[0]); + showAllRamWatchResults(1); + } + tmpList = tmpList->next; + } + + g_list_free_full(selListRows, (GDestroyNotify) gtk_tree_path_free); +} + +static void newRamWatch( GtkButton *button, + ramWatchWin_t *rww ) +{ + std::string name; + int addr = 0, type = 0, size = 0; + + openRamWatchEntryDialog( rww, &name, &addr, &type, &size, -1 ); + + ramWatchList.add_entry( name.c_str(), addr, type, size ); + + showAllRamWatchResults(1); +} + +static gint updateRamWatchTree( void *userData ) +{ + //static uint32_t c = 0; + //printf("RamWatch: %u\n", c++ ); + showAllRamWatchResults(0); + return 1; +} + +static void ramWatch_cell_edited_cb ( + GtkCellRendererText *cell, + gchar *path_string, + gchar *new_text, + ramWatchWin_t *rww ) +{ + ramWatch_t *rw; + //printf("Ram Watch Edited: %i:%i\n", ramWatchEditRowIdx, ramWatchEditColIdx); + + rw = ramWatchList.getIndex( rww->ramWatchEditRowIdx ); + + switch ( rww->ramWatchEditColIdx ) + { + case 0: + rw->addr = strtol( new_text, NULL, 0 ); + break; + case 1: + case 2: + { + writefunc wfunc; + + if ( rw->size == 2 ) + { + if ( rw->type ) + { + rw->val.u16 = strtol( new_text, NULL, 0 ); + } + else + { + rw->val.i16 = strtol( new_text, NULL, 0 ); + } + wfunc = GetWriteHandler( rw->addr ); + + if ( wfunc ) + { + wfunc( (uint32)rw->addr, (uint8)(rw->val.u16 & 0x00ff) ); + } + + wfunc = GetWriteHandler( rw->addr+1 ); + + if ( wfunc ) + { + wfunc( (uint32)rw->addr+1, (uint8)( (rw->val.u16 & 0xff00) >> 8) ); + } + } + else + { + if ( rw->type ) + { + rw->val.u8 = strtol( new_text, NULL, 0 ); + } + else + { + rw->val.i8 = strtol( new_text, NULL, 0 ); + } + wfunc = GetWriteHandler( rw->addr ); + + if ( wfunc ) + { + wfunc( (uint32)rw->addr, (uint8)rw->val.u8 ); + } + } + } + break; + case 3: + rw->name.assign( new_text ); + break; + default: + + break; + } + + rww->ramWatchEditRowIdx = -1; + rww->ramWatchEditColIdx = -1; +} + +static void ramWatch_cell_edited_start_cb0( + GtkCellRenderer *renderer, + GtkCellEditable *editable, + gchar *path, + ramWatchWin_t *rww ) +{ + //printf("Ram Watch Edit Start: '%s':%li\n", path, (long)user_data); + rww->ramWatchEditRowIdx = atoi( path ); + rww->ramWatchEditColIdx = 0; +} + +static void ramWatch_cell_edited_start_cb1( + GtkCellRenderer *renderer, + GtkCellEditable *editable, + gchar *path, + ramWatchWin_t *rww ) +{ + //printf("Ram Watch Edit Start: '%s':%li\n", path, (long)user_data); + rww->ramWatchEditRowIdx = atoi( path ); + rww->ramWatchEditColIdx = 1; +} + +static void ramWatch_cell_edited_start_cb2( + GtkCellRenderer *renderer, + GtkCellEditable *editable, + gchar *path, + ramWatchWin_t *rww ) +{ + //printf("Ram Watch Edit Start: '%s':%li\n", path, (long)user_data); + rww->ramWatchEditRowIdx = atoi( path ); + rww->ramWatchEditColIdx = 2; +} + +static void ramWatch_cell_edited_start_cb3( + GtkCellRenderer *renderer, + GtkCellEditable *editable, + gchar *path, + ramWatchWin_t *rww ) +{ + //printf("Ram Watch Edit Start: '%s':%li\n", path, (long)user_data); + rww->ramWatchEditRowIdx = atoi( path ); + rww->ramWatchEditColIdx = 3; +} + +static void ramWatch_cell_edited_cancel_cb( + GtkCellRenderer *renderer, + ramWatchWin_t *rww ) +{ + //printf("Ram Watch Edit Cancel:%li\n", (long)user_data); + rww->ramWatchEditRowIdx = -1; + rww->ramWatchEditColIdx = -1; +} + +void closeMemoryWatchWindow(GtkWidget* w, GdkEvent* e, ramWatchWin_t *rww) +{ + std::list ::iterator it; + + for (it=ramWatchWinList.begin(); it != ramWatchWinList.end(); it++) + { + if ( rww == *it ) + { + //printf("Removing RamWatch Window %p from List\n", cw); + ramWatchWinList.erase(it); break; + } + } + + delete rww; + + gtk_widget_destroy(w); +} + +// creates and opens cheats window +void openMemoryWatchWindow(void) +{ + GtkWidget* main_vbox; + GtkWidget* hbox; + GtkWidget* vbox; + GtkWidget* button; + GtkWidget *scroll; + GtkWidget* menubar; + ramWatchWin_t *rww; + + rww = new ramWatchWin_t; + + ramWatchWinList.push_back( rww ); + + rww->win = gtk_dialog_new_with_buttons("RAM Watch", + GTK_WINDOW(MainWindow), (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT), + "_Close", + GTK_RESPONSE_OK, + NULL); + + gtk_window_set_default_size(GTK_WINDOW(rww->win), 600, 600); + + main_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 1); + + menubar = CreateRamWatchMenubar(rww->win); + + gtk_box_pack_start (GTK_BOX(main_vbox), menubar, FALSE, TRUE, 0); + + hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL,2); + + rww->ram_watch_store = gtk_tree_store_new( 4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); + + rww->tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(rww->ram_watch_store)); + + gtk_tree_view_set_grid_lines( GTK_TREE_VIEW(rww->tree), GTK_TREE_VIEW_GRID_LINES_VERTICAL ); + + GtkCellRenderer *renderer; + GtkTreeViewColumn* column; + + renderer = gtk_cell_renderer_text_new(); + g_object_set(renderer, "family", "MonoSpace", NULL); + g_object_set(renderer, "editable", TRUE, NULL); + g_signal_connect(renderer, "edited", (GCallback) ramWatch_cell_edited_cb, (gpointer)rww); + g_signal_connect(renderer, "editing-started", (GCallback) ramWatch_cell_edited_start_cb0, (gpointer)rww); + g_signal_connect(renderer, "editing-canceled", (GCallback) ramWatch_cell_edited_cancel_cb, (gpointer)rww); + column = gtk_tree_view_column_new_with_attributes("Addr", renderer, "text", 0, NULL); + gtk_tree_view_append_column(GTK_TREE_VIEW(rww->tree), column); + + renderer = gtk_cell_renderer_text_new(); + g_object_set(renderer, "family", "MonoSpace", NULL); + g_object_set(renderer, "editable", TRUE, NULL); + g_signal_connect(renderer, "edited", (GCallback) ramWatch_cell_edited_cb, (gpointer)rww); + g_signal_connect(renderer, "editing-started", (GCallback) ramWatch_cell_edited_start_cb1, (gpointer)rww); + g_signal_connect(renderer, "editing-canceled", (GCallback) ramWatch_cell_edited_cancel_cb, (gpointer)rww); + column = gtk_tree_view_column_new_with_attributes("Value Dec", renderer, "text", 1, NULL); + gtk_tree_view_append_column(GTK_TREE_VIEW(rww->tree), column); + + renderer = gtk_cell_renderer_text_new(); + g_object_set(renderer, "family", "MonoSpace", NULL); + g_object_set(renderer, "editable", TRUE, NULL); + g_signal_connect(renderer, "edited", (GCallback) ramWatch_cell_edited_cb, (gpointer)rww); + g_signal_connect(renderer, "editing-started", (GCallback) ramWatch_cell_edited_start_cb2, (gpointer)rww); + g_signal_connect(renderer, "editing-canceled", (GCallback) ramWatch_cell_edited_cancel_cb, (gpointer)rww); + column = gtk_tree_view_column_new_with_attributes("Value Hex", renderer, "text", 2, NULL); + gtk_tree_view_append_column(GTK_TREE_VIEW(rww->tree), column); + + renderer = gtk_cell_renderer_text_new(); + g_object_set(renderer, "editable", TRUE, NULL); + g_signal_connect(renderer, "edited", (GCallback) ramWatch_cell_edited_cb, (gpointer)rww); + g_signal_connect(renderer, "editing-started", (GCallback) ramWatch_cell_edited_start_cb3, (gpointer)rww); + g_signal_connect(renderer, "editing-canceled", (GCallback) ramWatch_cell_edited_cancel_cb, (gpointer)rww); + column = gtk_tree_view_column_new_with_attributes("Notes", renderer, "text", 3, NULL); + gtk_tree_view_append_column(GTK_TREE_VIEW(rww->tree), column); + + scroll = gtk_scrolled_window_new(NULL, NULL); + gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, + GTK_POLICY_AUTOMATIC); + gtk_container_add(GTK_CONTAINER(scroll), rww->tree); + gtk_box_pack_start(GTK_BOX(hbox), scroll, TRUE, TRUE, 5); + + gtk_box_pack_start(GTK_BOX(main_vbox), hbox, TRUE, TRUE, 5); + + showAllRamWatchResults(1); + + if ( ramWatchEvntSrcID == 0 ) + { + ramWatchEvntSrcID = g_timeout_add( 100, updateRamWatchTree, NULL ); + } + + vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 3); + + button = gtk_button_new_with_label("Edit"); + gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 5); + g_signal_connect( button, "clicked", + G_CALLBACK (editRamWatch), (gpointer) rww ); + + button = gtk_button_new_with_label("Remove"); + gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 5); + g_signal_connect( button, "clicked", + G_CALLBACK (removeRamWatch), (gpointer) rww ); + + button = gtk_button_new_with_label("New"); + gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 5); + g_signal_connect( button, "clicked", + G_CALLBACK (newRamWatch), (gpointer) rww ); + + gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 5); + + gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(rww->win))), main_vbox, TRUE, TRUE, 0); + + g_signal_connect(rww->win, "delete-event", G_CALLBACK(closeMemoryWatchWindow), rww); + g_signal_connect(rww->win, "response", G_CALLBACK(closeMemoryWatchWindow), rww); + + gtk_widget_show_all(rww->win); + +} diff --git a/src/drivers/sdl/ramwatch.h b/src/drivers/sdl/ramwatch.h new file mode 100644 index 00000000..6776a765 --- /dev/null +++ b/src/drivers/sdl/ramwatch.h @@ -0,0 +1,3 @@ +// ramwatch.h + +void openMemoryWatchWindow(void); From 9583c0fbdd8950044cc3786064b413cf6c387fbe Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Tue, 12 May 2020 22:39:03 -0400 Subject: [PATCH 044/156] A few more bug fixes for the ram watch window. --- src/drivers/sdl/ramwatch.cpp | 113 ++++++++++++++++++----------------- 1 file changed, 58 insertions(+), 55 deletions(-) diff --git a/src/drivers/sdl/ramwatch.cpp b/src/drivers/sdl/ramwatch.cpp index 2de4e69b..3b721998 100644 --- a/src/drivers/sdl/ramwatch.cpp +++ b/src/drivers/sdl/ramwatch.cpp @@ -610,32 +610,32 @@ static GtkWidget* CreateRamWatchMenubar( GtkWidget* window) return menubar; } -void closeMemoryWatchEntryWindow(GtkWidget* w, GdkEvent* e, ramWatchEntryWin_t *ew) -{ - -// strcpy( name, gtk_entry_get_text ( GTK_ENTRY(ew->txt_entry_name) ) ); - -//*addr = strtol( gtk_entry_get_text ( GTK_ENTRY(ew->txt_entry_addr) ), NULL, 16 ); - -//*type = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(ew->chkbox) ); - -// if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(ew->button4) ) ) -// { -// *size = 4; -// } -// else if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(ew->button2) ) ) -// { -// *size = 2; -// } -// else -// { -// *size = 1; -// } - - delete ew; - - gtk_widget_destroy(w); -} +//void closeMemoryWatchEntryWindow(GtkWidget* w, GdkEvent* e, ramWatchEntryWin_t *ew) +//{ +// +//// strcpy( name, gtk_entry_get_text ( GTK_ENTRY(ew->txt_entry_name) ) ); +// +////*addr = strtol( gtk_entry_get_text ( GTK_ENTRY(ew->txt_entry_addr) ), NULL, 16 ); +// +////*type = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(ew->chkbox) ); +// +//// if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(ew->button4) ) ) +//// { +//// *size = 4; +//// } +//// else if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(ew->button2) ) ) +//// { +//// *size = 2; +//// } +//// else +//// { +//// *size = 1; +//// } +// +// delete ew; +// +// gtk_widget_destroy(w); +//} static int openRamWatchEntryDialog( ramWatchWin_t *rww, std::string *name, int *addr, int *type, int *size, int idx ) { @@ -717,38 +717,40 @@ static int openRamWatchEntryDialog( ramWatchWin_t *rww, std::string *name, int * retval = gtk_dialog_run(GTK_DIALOG(ew->win)); - if ( retval ) + printf("retval %i\n", retval ); + // + if ( retval == GTK_RESPONSE_OK ) { // FIXME - what error checking should be done here + + name->assign( gtk_entry_get_text ( GTK_ENTRY(ew->txt_entry_name) ) ); + + *addr = strtol( gtk_entry_get_text ( GTK_ENTRY(ew->txt_entry_addr) ), NULL, 16 ); + + *type = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(ew->chkbox) ); + + if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(ew->button4) ) ) + { + *size = 4; + } + else if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(ew->button2) ) ) + { + *size = 2; + } + else + { + *size = 1; + } } - name->assign( gtk_entry_get_text ( GTK_ENTRY(ew->txt_entry_name) ) ); + //g_signal_connect(ew->win, "delete-event", G_CALLBACK(closeMemoryWatchEntryWindow), ew); + //g_signal_connect(ew->win, "response", G_CALLBACK(closeMemoryWatchEntryWindow), ew); - *addr = strtol( gtk_entry_get_text ( GTK_ENTRY(ew->txt_entry_addr) ), NULL, 16 ); + gtk_widget_destroy(ew->win); - *type = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(ew->chkbox) ); + delete ew; - if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(ew->button4) ) ) - { - *size = 4; - } - else if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(ew->button2) ) ) - { - *size = 2; - } - else - { - *size = 1; - } - - //printf("retval %i\n", retval ); - - g_signal_connect(ew->win, "delete-event", G_CALLBACK(closeMemoryWatchEntryWindow), ew); - g_signal_connect(ew->win, "response", G_CALLBACK(closeMemoryWatchEntryWindow), ew); - - //gtk_widget_destroy(win); - - return 0; + return ( retval == GTK_RESPONSE_OK ); } static void editRamWatch( GtkButton *button, @@ -788,7 +790,7 @@ static void editRamWatch( GtkButton *button, if ( rw != NULL ) { openRamWatchEntryDialog( rww, &rw->name, &rw->addr, &rw->type, &rw->size, indexArray[0] ); - showAllRamWatchResults(1); + showAllRamWatchResults(0); } } tmpList = tmpList->next; @@ -845,9 +847,10 @@ static void newRamWatch( GtkButton *button, std::string name; int addr = 0, type = 0, size = 0; - openRamWatchEntryDialog( rww, &name, &addr, &type, &size, -1 ); - - ramWatchList.add_entry( name.c_str(), addr, type, size ); + if ( openRamWatchEntryDialog( rww, &name, &addr, &type, &size, -1 ) ) + { + ramWatchList.add_entry( name.c_str(), addr, type, size ); + } showAllRamWatchResults(1); } From 61f55f3e282bb16939f4675d619184e48a70a440 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Tue, 12 May 2020 22:45:08 -0400 Subject: [PATCH 045/156] Ensure that pallette variable has been freed before attempting malloc a new heap. --- src/drivers/common/vidblit.cpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/drivers/common/vidblit.cpp b/src/drivers/common/vidblit.cpp index 7a3eb0f9..d93c520a 100644 --- a/src/drivers/common/vidblit.cpp +++ b/src/drivers/common/vidblit.cpp @@ -218,6 +218,11 @@ int InitBlitToHigh(int b, uint32 rmask, uint32 gmask, uint32 bmask, int efx, int return(0); //allocate adequate room for 32bpp palette + if ( palettetranslate ) + { + free(palettetranslate); + palettetranslate=NULL; + } palettetranslate=(uint32*)FCEU_dmalloc(256*4 + 512*4); if(!palettetranslate) From c45c6c00cf5859c167a766cea8c931aa58c2c5e3 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Wed, 13 May 2020 08:33:55 -0400 Subject: [PATCH 046/156] Removed old menu comments from gtk gui. --- src/drivers/sdl/gui.cpp | 218 +--------------------------------------- 1 file changed, 2 insertions(+), 216 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 88752b33..93eb18f7 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -2186,220 +2186,7 @@ gint convertKeypress(GtkWidget *grab, GdkEventKey *event, gpointer user_data) return FALSE; } -// Our menu, in the XML markup format used by GtkUIManager -//static char* menuXml = -// "" -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -//#ifdef _S9XLUA_H -// " " -//#endif -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// " " -// ""; - -// Menu items, as an array of GtkActionEntry structures that define each item -//static GtkActionEntry normal_entries[] = { -// {"FileMenuAction", NULL, "_File"}, -// {"OpenRomAction", GTK_STOCK_OPEN, "_Open ROM", "O", NULL, G_CALLBACK(loadGame)}, -// {"CloseRomAction", GTK_STOCK_CLOSE, "_Close ROM", "C", NULL, G_CALLBACK(closeGame)}, -// {"PlayNsfAction", GTK_STOCK_OPEN, "_Play NSF", "N", NULL, G_CALLBACK(loadNSF)}, -// {"LoadStateFromAction", GTK_STOCK_OPEN, "Load State _From", "", NULL, G_CALLBACK(loadStateFrom)}, -// {"SaveStateAsAction", GTK_STOCK_SAVE_AS, "Save State _As", NULL, NULL, G_CALLBACK(saveStateAs)}, -// {"QuickLoadAction", "go-jump", "Quick _Load", "F7", NULL, G_CALLBACK(quickLoad)}, -// {"QuickSaveAction", GTK_STOCK_SAVE, "Qu_ick Save", "F5", NULL, G_CALLBACK(quickSave)}, -// {"ChangeStateMenuAction", NULL, "C_hange State"}, -//#ifdef _S9XLUA_H -// {"LoadLuaScriptAction", GTK_STOCK_OPEN, "Load L_ua Script", "", NULL, G_CALLBACK(loadLua)}, -//#endif -// {"ScreenshotAction", NULL, "_Screenshot", "F12", NULL, G_CALLBACK(FCEUI_SaveSnapshot)}, -// {"QuitAction", GTK_STOCK_QUIT, "_Quit", "Q", NULL, G_CALLBACK(quit)}, -// -// {"OptionsMenuAction", NULL, "_Options"}, -//#if GTK_MAJOR_VERSION == 3 || (GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION >= 24) -// {"GamepadConfigAction", "input-gaming", "_Gamepad Config", NULL, NULL, G_CALLBACK(openGamepadConfig)}, -//#endif -// {"HotkeyConfigAction", "input", "_Hotkey Config", NULL, NULL, G_CALLBACK(openHotkeyConfig)}, -// {"SoundConfigAction", "audio-x-generic", "_Sound Config", NULL, NULL, G_CALLBACK(openSoundConfig)}, -// {"VideoConfigAction", "video-display", "_Video Config", NULL, NULL, G_CALLBACK(openVideoConfig)}, -// {"PaletteConfigAction", GTK_STOCK_SELECT_COLOR, "_Palette Config", NULL, NULL, G_CALLBACK(openPaletteConfig)}, -// {"NetworkConfigAction", GTK_STOCK_NETWORK, "_Network Config", NULL, NULL, G_CALLBACK(openNetworkConfig)}, -// {"FullscreenAction", GTK_STOCK_FULLSCREEN, "_Fullscreen", "Return", NULL, G_CALLBACK(enableFullscreen)}, -// {"EmulationMenuAction", NULL, "_Emulation"}, -// {"PowerAction", NULL, "P_ower", NULL, NULL, G_CALLBACK(FCEUI_PowerNES)}, -// {"SoftResetAction", GTK_STOCK_REFRESH, "_Soft Reset", NULL, NULL, G_CALLBACK(emuReset)}, -// {"ResetAction", GTK_STOCK_REFRESH, "_Reset", NULL, NULL, G_CALLBACK(hardReset)}, -// {"PauseToggleAction", GTK_STOCK_MEDIA_PAUSE, "_Pause", "Pause", NULL, G_CALLBACK(togglePause)}, -// {"FdsMenuAction", GTK_STOCK_FLOPPY, "_FDS"}, -// {"SwitchDiskAction", "go-jump", "_Switch Disk", NULL, NULL, G_CALLBACK(FCEU_FDSSelect)}, -// {"EjectDiskAction", "media-eject", "_Eject Disk", NULL, NULL, G_CALLBACK(FCEU_FDSInsert)}, -// {"LoadBiosAction", GTK_STOCK_OPEN, "Load _BIOS File", "", NULL, G_CALLBACK(loadFdsBios)}, -// {"LoadGameGenieAction", GTK_STOCK_OPEN, "_Load Game Genie ROM", "", NULL, G_CALLBACK(loadGameGenie)}, -// {"InsertCoinAction", NULL, "_Insert Coin", NULL, NULL, G_CALLBACK(FCEUI_VSUniCoin)}, -// -// {"ToolsMenuAction", NULL, "_Tools"}, -// {"CheatsAction", "cheats-win", "_Cheats...", NULL, NULL, G_CALLBACK(openCheatsWindow)}, -// {"RamWatchAction", "ram-watch", "_RAM Watch...", NULL, NULL, G_CALLBACK(openMemoryWatchWindow)}, -// -// {"MovieMenuAction", NULL, "_Movie"}, -// {"OpenMovieAction", GTK_STOCK_OPEN, "_Open", "F7", NULL, G_CALLBACK(loadMovie)}, -// {"StopMovieAction", GTK_STOCK_MEDIA_STOP, "S_top", NULL, NULL, G_CALLBACK(FCEUI_StopMovie)}, -// {"RecordMovieAction", GTK_STOCK_MEDIA_RECORD, "_Record", "F5", NULL, G_CALLBACK(recordMovie)}, -// {"RecordMovieAsAction", NULL, "Record _As", NULL, NULL, G_CALLBACK(recordMovieAs)}, -// -// {"HelpMenuAction", NULL, "_Help"}, -// {"AboutAction", GTK_STOCK_ABOUT, "_About", NULL, NULL, G_CALLBACK(openAbout)}, -//}; - -// Menu items with a check box that can be toggled on or off -//static GtkToggleActionEntry toggle_entries[] = { -// {"GameGenieToggleAction", NULL, "Enable Game _Genie", NULL, NULL, G_CALLBACK(toggleGameGenie), FALSE}, -// {"AutoResumeAction", NULL, "Auto-Resume Play", NULL, NULL, G_CALLBACK(toggleAutoResume), FALSE}, -// {"ToggleMenuAction", NULL, "Toggle Menubar (alt)", NULL, NULL, G_CALLBACK(toggleMenuToggling), FALSE}, -//}; - -// Menu items for selecting a save state slot using radio buttons -//static GtkRadioActionEntry radio_entries[] = { -// {"State0Action", NULL, "0", NULL, NULL, 0}, -// {"State1Action", NULL, "1", NULL, NULL, 1}, -// {"State2Action", NULL, "2", NULL, NULL, 2}, -// {"State3Action", NULL, "3", NULL, NULL, 3}, -// {"State4Action", NULL, "4", NULL, NULL, 4}, -// {"State5Action", NULL, "5", NULL, NULL, 5}, -// {"State6Action", NULL, "6", NULL, NULL, 6}, -// {"State7Action", NULL, "7", NULL, NULL, 7}, -// {"State8Action", NULL, "8", NULL, NULL, 8}, -// {"State9Action", NULL, "9", NULL, NULL, 9}, -//}; - -//static GtkWidget* CreateMenubar( GtkWidget* window) -//{ -// GtkUIManager *ui_manager; -// GtkActionGroup *action_group; -// GtkAccelGroup* accel_group; -// GError *error = NULL; -// GtkAction* state; -// -// /* Make an UIManager (which makes a menubar). */ -// ui_manager = gtk_ui_manager_new (); -// -// /* Add the menu items to the UIManager as a GtkActionGroup. */ -// action_group = gtk_action_group_new ("MenubarActions"); -// gtk_action_group_add_actions (action_group, normal_entries, G_N_ELEMENTS (normal_entries), NULL); -// gtk_action_group_add_toggle_actions (action_group, toggle_entries, G_N_ELEMENTS (toggle_entries), NULL); -// gtk_action_group_add_radio_actions (action_group, radio_entries, G_N_ELEMENTS (radio_entries), 0, G_CALLBACK(changeState), NULL); -// gtk_ui_manager_insert_action_group (ui_manager, action_group, 0); -// -// /* Read the menu layout from the XML markup. */ -// gtk_ui_manager_add_ui_from_string (ui_manager, menuXml, -1, &error); -// if (error) -// { -// fprintf (stderr, "Unable to create menu bar: %s\n", error->message); -// g_error_free (error); -// } -// -// /* Attach the new accelerator group to the window. */ -// accel_group = gtk_ui_manager_get_accel_group (ui_manager); -// gtk_window_add_accel_group (GTK_WINDOW (window), accel_group); -// -// /* Get an action that can be used to change the active state slot selection. */ -// state = gtk_action_group_get_action (action_group, "State0Action"); -// if (state && GTK_IS_RADIO_ACTION (state)) -// stateSlot = GTK_RADIO_ACTION (state); -// -// /* Set the autoResume checkbox */ -// GtkCheckMenuItem* auto_resume_chk = (GtkCheckMenuItem*) gtk_ui_manager_get_widget ( ui_manager, "/Menubar/OptionsMenuAction/AutoResumeAction"); -// gtk_check_menu_item_set_active (auto_resume_chk, (bool)AutoResumePlay); -// -// // Sync State of GameGenie Toggle Action to Startup Configuration -// int gameGenieEnabled=0; -// g_config->getOption("SDL.GameGenie", &gameGenieEnabled); -// -// if ( gameGenieEnabled ) -// { -// state = gtk_action_group_get_action (action_group, "GameGenieToggleAction"); -// -// if ( state ){ -// gtk_action_activate( state ); -// } -// } -// enableGameGenie(gameGenieEnabled); -// -// /* Finally, return the actual menu bar created by the UIManager. */ -// return gtk_ui_manager_get_widget (ui_manager, "/Menubar"); -//} - - -static GtkWidget* CreateMenubar2( GtkWidget* window) +static GtkWidget* CreateMenubar( GtkWidget* window) { GtkWidget *menubar, *menu, *submenu, *item; GSList *radioGroup; @@ -3043,8 +2830,7 @@ int InitGTKSubsystem(int argc, char** argv) vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_container_add(GTK_CONTAINER(MainWindow), vbox); - //Menubar = CreateMenubar(MainWindow); - Menubar = CreateMenubar2(MainWindow); + Menubar = CreateMenubar(MainWindow); gtk_box_pack_start (GTK_BOX(vbox), Menubar, FALSE, TRUE, 0); From 42233b0425165180188774cb7d02f28cfe2cae2c Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Wed, 13 May 2020 08:36:35 -0400 Subject: [PATCH 047/156] Removed unused global window symbol for hotkey gui window --- src/drivers/sdl/gui.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 93eb18f7..da62b4e2 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -470,7 +470,6 @@ void flushGtkEvents(void) return; } -GtkWidget* HotkeyWin; static void hotKeyWindowRefresh(void) { @@ -571,7 +570,6 @@ void openHotkeyConfig(void) GTK_RESPONSE_OK, NULL); gtk_window_set_default_size(GTK_WINDOW(win), 400, 800); - HotkeyWin = win; GtkWidget *tree; GtkWidget *vbox; GtkWidget *scroll; From 48bbec8fba1eb48f1c50f3ae54acf882d96b739d Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Wed, 13 May 2020 09:00:07 -0400 Subject: [PATCH 048/156] Added logic to clear screen to black during startup and if a screen configure event occurs and no game is loaded. --- src/drivers/sdl/gui.cpp | 67 +++++++++++++++++++++++++++++++++++++---- 1 file changed, 61 insertions(+), 6 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index da62b4e2..e46ca9cd 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -66,6 +66,9 @@ bool menuTogglingEnabled = false; static GtkTreeStore *hotkey_store = NULL; +/* Surface to store black screen */ +static cairo_surface_t *surface = NULL; + // check to see if a particular GTK version is available // 2.24 is required for most of the dialogs -- ie: checkGTKVersion(2,24); bool checkGTKVersion(int major_required, int minor_required) @@ -1294,11 +1297,17 @@ void openSoundConfig(void) return; } -void quit () +void quit (void) { // manually flush GTK event queue while(gtk_events_pending()) gtk_main_iteration_do(FALSE); + + if (surface) + { + cairo_surface_destroy (surface); + surface = NULL; + } // this is not neccesary to be explicitly called // it raises a GTK-Critical when its called //gtk_main_quit(); @@ -2764,8 +2773,8 @@ gint handleMouseClick(GtkWidget* widget, GdkEvent *event, gpointer callback_data gboolean handle_resize(GtkWindow* win, GdkEvent* event, gpointer data) { - // TODO this is a stub atm - // this should handle resizing so the emulation takes up as much + cairo_t *cr = NULL; + // This should handle resizing so the emulation takes up as much // of the GTK window as possible @@ -2795,7 +2804,32 @@ gboolean handle_resize(GtkWindow* win, GdkEvent* event, gpointer data) { KillVideo(); InitVideo(GameInfo); - } + } + + + if (surface) + { + cairo_surface_destroy (surface); + } + surface = gdk_window_create_similar_surface (gtk_widget_get_window (evbox), + CAIRO_CONTENT_COLOR, + gtk_widget_get_allocated_width (evbox), + gtk_widget_get_allocated_height (evbox)); + + + if ( surface != NULL ) + { + cr = cairo_create (surface); + + if ( cr != NULL ) + { + cairo_set_source_rgb (cr, 0, 0, 0); + cairo_paint (cr); + + cairo_destroy (cr); + } + } + //gtk_widget_set_size_request(evbox, (int)(NES_WIDTH*xscale), (int)(NES_HEIGHT*yscale)); // Currently unused; unsure why @@ -2810,6 +2844,26 @@ gboolean handle_resize(GtkWindow* win, GdkEvent* event, gpointer data) return FALSE; } +/* Redraw the screen from the surface. Note that the ::draw + * signal receives a ready-to-be-used cairo_t that is already + * clipped to only draw the exposed areas of the widget + */ +static gboolean +draw_cb (GtkWidget *widget, + cairo_t *cr, + gpointer data) +{ + // Only clear the screen if a game is not loaded + if (GameInfo == 0) + { + cairo_set_source_surface (cr, surface, 0, 0); + cairo_paint (cr); + } + + return FALSE; +} + + int InitGTKSubsystem(int argc, char** argv) { GtkWidget* vbox; @@ -2843,8 +2897,8 @@ int InitGTKSubsystem(int argc, char** argv) // // prg - Bryan Cain, you are the man! - evbox = gtk_event_box_new(); - //evbox = gtk_drawing_area_new(); + //evbox = gtk_event_box_new(); + evbox = gtk_drawing_area_new(); gtk_box_pack_start (GTK_BOX(vbox), evbox, TRUE, TRUE, 0); double xscale, yscale; @@ -2873,6 +2927,7 @@ int InitGTKSubsystem(int argc, char** argv) g_signal_connect(MainWindow, "destroy-event", quit, NULL); // resize handler g_signal_connect(MainWindow, "configure-event", G_CALLBACK(handle_resize), NULL); + g_signal_connect( evbox, "draw", G_CALLBACK(draw_cb), NULL); gtk_widget_show_all(MainWindow); From 7ac726d415a388d5c657a5aa605f150d0445b445 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Wed, 13 May 2020 09:24:31 -0400 Subject: [PATCH 049/156] Replaced deprecated gtk_key_snoop function with standard gtk key press/release event handling functions. --- src/drivers/sdl/gui.cpp | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index e46ca9cd..033b2380 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -2135,7 +2135,7 @@ unsigned short GDKToSDLKeyval(int gdk_key) // Function adapted from Gens/GS (source/gens/input/input_sdl.c) -gint convertKeypress(GtkWidget *grab, GdkEventKey *event, gpointer user_data) +static gint convertKeypress(GtkWidget *grab, GdkEventKey *event, gpointer user_data) { SDL_Event sdlev; int keystate; @@ -2914,13 +2914,15 @@ int InitGTKSubsystem(int argc, char** argv) //gtk_widget_modify_bg(evbox, GTK_STATE_NORMAL, &bg); // set up keypress "snooper" to convert GDK keypress events into SDL keypresses - gtk_key_snooper_install(convertKeypress, NULL); + //gtk_key_snooper_install(convertKeypress, NULL); + g_signal_connect(G_OBJECT(MainWindow), "key-press-event", G_CALLBACK(convertKeypress), NULL); + g_signal_connect(G_OBJECT(MainWindow), "key-release-event", G_CALLBACK(convertKeypress), NULL); // pass along mouse data from GTK to SDL g_signal_connect(G_OBJECT(evbox), "button-press-event", G_CALLBACK(handleMouseClick), NULL); g_signal_connect(G_OBJECT(evbox), "button-release-event", G_CALLBACK(handleMouseClick), NULL); - g_signal_connect(G_OBJECT(MainWindow), "key-release-event", G_CALLBACK(handleKeyRelease), NULL); + //g_signal_connect(G_OBJECT(MainWindow), "key-release-event", G_CALLBACK(handleKeyRelease), NULL); // signal handlers g_signal_connect(MainWindow, "delete-event", quit, NULL); From 699069b7ee41ebcaed11258c4dbfa15edbdb01e8 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Wed, 13 May 2020 21:07:31 -0400 Subject: [PATCH 050/156] Ran indent program to gui.cpp to re-apply hard tabs. --- src/drivers/sdl/gui.cpp | 3810 +++++++++++++++++++++------------------ 1 file changed, 2029 insertions(+), 1781 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 033b2380..1ab6cacc 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -39,28 +39,28 @@ // Fix compliation errors for older version of GTK (Ubuntu 10.04 LTS) #if GTK_MINOR_VERSION < 24 && GTK_MAJOR_VERSION == 2 - #define GTK_COMBO_BOX_TEXT GTK_COMBO_BOX - #define gtk_combo_box_text_new gtk_combo_box_new - #define gtk_combo_box_text_get_active_text gtk_combo_box_get_active_text - #define gtk_combo_box_text_append_text gtk_combo_box_append_text +#define GTK_COMBO_BOX_TEXT GTK_COMBO_BOX +#define gtk_combo_box_text_new gtk_combo_box_new +#define gtk_combo_box_text_get_active_text gtk_combo_box_get_active_text +#define gtk_combo_box_text_append_text gtk_combo_box_append_text #endif // NES resolution = 256x240 -const int NES_WIDTH=256; -const int NES_HEIGHT=240; +const int NES_WIDTH = 256; +const int NES_HEIGHT = 240; -void toggleSound(GtkWidget* check, gpointer data); +void toggleSound (GtkWidget * check, gpointer data); void loadGame (void); -void closeGame(void); +void closeGame (void); extern Config *g_config; -GtkWidget* MainWindow = NULL; -GtkWidget* evbox = NULL; -GtkWidget* padNoCombo = NULL; -GtkWidget* configNoCombo = NULL; -GtkWidget* buttonMappings[10]; -GtkWidget* Menubar; -GtkRadioAction* stateSlot = NULL; +GtkWidget *MainWindow = NULL; +GtkWidget *evbox = NULL; +GtkWidget *padNoCombo = NULL; +GtkWidget *configNoCombo = NULL; +GtkWidget *buttonMappings[10]; +GtkWidget *Menubar; +GtkRadioAction *stateSlot = NULL; bool gtkIsStarted = false; bool menuTogglingEnabled = false; @@ -71,17 +71,18 @@ static cairo_surface_t *surface = NULL; // check to see if a particular GTK version is available // 2.24 is required for most of the dialogs -- ie: checkGTKVersion(2,24); -bool checkGTKVersion(int major_required, int minor_required) +bool checkGTKVersion (int major_required, int minor_required) { int major = GTK_MAJOR_VERSION; int minor = GTK_MINOR_VERSION; - if(major > major_required) + if (major > major_required) { return true; - } else if (major == major_required) + } + else if (major == major_required) { - if(minor >= minor_required) + if (minor >= minor_required) { return true; } @@ -89,383 +90,421 @@ bool checkGTKVersion(int major_required, int minor_required) { return false; } - } else + } + else { return false; } } -void setCheckbox(GtkWidget* w, const char* configName) +void setCheckbox (GtkWidget * w, const char *configName) { int buf; - g_config->getOption(configName, &buf); - gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), buf); + g_config->getOption (configName, &buf); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), buf); } // This function configures a single button on a gamepad -int configGamepadButton(GtkButton* button, gpointer p) +int configGamepadButton (GtkButton * button, gpointer p) { - gint x = ((gint)(glong)(p)); + gint x = ((gint) (glong) (p)); //gint x = GPOINTER_TO_INT(p); - int padNo = atoi(gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(padNoCombo))) - 1; - int configNo = atoi(gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(configNoCombo))) - 1; - + int padNo = + atoi (gtk_combo_box_text_get_active_text + (GTK_COMBO_BOX_TEXT (padNoCombo))) - 1; + int configNo = + atoi (gtk_combo_box_text_get_active_text + (GTK_COMBO_BOX_TEXT (configNoCombo))) - 1; + char buf[256]; std::string prefix; - + // only configure when the "Change" button is pressed in, not when it is unpressed - if(!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button))) + if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button))) return 0; - - ButtonConfigBegin(); - - snprintf(buf, sizeof(buf), "SDL.Input.GamePad.%d", padNo); + + ButtonConfigBegin (); + + snprintf (buf, sizeof (buf), "SDL.Input.GamePad.%d", padNo); prefix = buf; - DWaitButton(NULL, &GamePadConfig[padNo][x], configNo); + DWaitButton (NULL, &GamePadConfig[padNo][x], configNo); - g_config->setOption(prefix + GamePadNames[x], GamePadConfig[padNo][x].ButtonNum[configNo]); + g_config->setOption (prefix + GamePadNames[x], + GamePadConfig[padNo][x].ButtonNum[configNo]); - if(GamePadConfig[padNo][x].ButtType[0] == BUTTC_KEYBOARD) + if (GamePadConfig[padNo][x].ButtType[0] == BUTTC_KEYBOARD) { - g_config->setOption(prefix + "DeviceType", "Keyboard"); - } else if(GamePadConfig[padNo][x].ButtType[0] == BUTTC_JOYSTICK) { - g_config->setOption(prefix + "DeviceType", "Joystick"); - } else { - g_config->setOption(prefix + "DeviceType", "Unknown"); + g_config->setOption (prefix + "DeviceType", "Keyboard"); } - g_config->setOption(prefix + "DeviceNum", GamePadConfig[padNo][x].DeviceNum[configNo]); - - snprintf(buf, sizeof(buf), "%s", ButtonName(&GamePadConfig[padNo][x], configNo)); - gtk_label_set_markup(GTK_LABEL(buttonMappings[x]), buf); - - ButtonConfigEnd(); - - gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), FALSE); - - return 0; -} - -void resetVideo(void) -{ - resizeGtkWindow(); - KillVideo(); - InitVideo(GameInfo); -} - -void closeVideoWin(GtkWidget* w, gint response, gpointer p) -{ - resetVideo(); - if(response != GTK_RESPONSE_APPLY) + else if (GamePadConfig[padNo][x].ButtType[0] == BUTTC_JOYSTICK) { - gtk_widget_destroy(w); - } -} - -void closeDialog(GtkWidget* w, GdkEvent* e, gpointer p) -{ - gtk_widget_destroy(w); -} -void toggleLowPass(GtkWidget* w, gpointer p) -{ - if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w))) - { - g_config->setOption("SDL.Sound.LowPass", 1); - FCEUI_SetLowPass(1); + g_config->setOption (prefix + "DeviceType", "Joystick"); } else { - g_config->setOption("SDL.Sound.LowPass", 0); - FCEUI_SetLowPass(0); + g_config->setOption (prefix + "DeviceType", "Unknown"); } - g_config->save(); + g_config->setOption (prefix + "DeviceNum", + GamePadConfig[padNo][x].DeviceNum[configNo]); + + snprintf (buf, sizeof (buf), "%s", + ButtonName (&GamePadConfig[padNo][x], configNo)); + gtk_label_set_markup (GTK_LABEL (buttonMappings[x]), buf); + + ButtonConfigEnd (); + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE); + + return 0; } -void toggleSwapDuty(GtkWidget* w, gpointer p) +void resetVideo (void) { - if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w))) + resizeGtkWindow (); + KillVideo (); + InitVideo (GameInfo); +} + +void closeVideoWin (GtkWidget * w, gint response, gpointer p) +{ + resetVideo (); + if (response != GTK_RESPONSE_APPLY) { - g_config->setOption("SDL.SwapDuty", 1); + gtk_widget_destroy (w); + } +} + +void closeDialog (GtkWidget * w, GdkEvent * e, gpointer p) +{ + gtk_widget_destroy (w); +} + +void toggleLowPass (GtkWidget * w, gpointer p) +{ + if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w))) + { + g_config->setOption ("SDL.Sound.LowPass", 1); + FCEUI_SetLowPass (1); + } + else + { + g_config->setOption ("SDL.Sound.LowPass", 0); + FCEUI_SetLowPass (0); + } + g_config->save (); +} + +void toggleSwapDuty (GtkWidget * w, gpointer p) +{ + if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w))) + { + g_config->setOption ("SDL.SwapDuty", 1); swapDuty = 1; } else { - g_config->setOption("SDL.SwapDuty", 0); + g_config->setOption ("SDL.SwapDuty", 0); swapDuty = 0; } - g_config->save(); + g_config->save (); } // Wrapper for pushing GTK options into the config file // p : pointer to the string that names the config option // w : toggle widget -void toggleOption(GtkWidget* w, gpointer p) +void toggleOption (GtkWidget * w, gpointer p) { - if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w))) - g_config->setOption((char*)p, 1); + if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w))) + g_config->setOption ((char *) p, 1); else - g_config->setOption((char*)p, 0); - - g_config->save(); - UpdateEMUCore(g_config); + g_config->setOption ((char *) p, 0); + + g_config->save (); + UpdateEMUCore (g_config); } -int setTint(GtkWidget* w, gpointer p) +int setTint (GtkWidget * w, gpointer p) { - int v = gtk_range_get_value(GTK_RANGE(w)); - g_config->setOption("SDL.Tint", v); - g_config->save(); + int v = gtk_range_get_value (GTK_RANGE (w)); + g_config->setOption ("SDL.Tint", v); + g_config->save (); int c, h; - g_config->getOption("SDL.NTSCpalette", &c); - g_config->getOption("SDL.Hue", &h); - FCEUI_SetNTSCTH(c, v, h); - - return 0; -} -int setHue(GtkWidget* w, gpointer p) -{ - int v = gtk_range_get_value(GTK_RANGE(w)); - g_config->setOption("SDL.Hue", v); - g_config->save(); - int c, t; - g_config->getOption("SDL.Tint", &t); - g_config->getOption("SDL.SDL.NTSCpalette", &c); - FCEUI_SetNTSCTH(c, t, v); - - return 0; -} -void loadPalette (GtkWidget* w, gpointer p) -{ - GtkWidget* fileChooser; - - fileChooser = gtk_file_chooser_dialog_new ("Open NES Palette", GTK_WINDOW(MainWindow), - GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel", GTK_RESPONSE_CANCEL, - "_Open", GTK_RESPONSE_ACCEPT, NULL); - gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fileChooser), "/usr/share/fceux/palettes"); + g_config->getOption ("SDL.NTSCpalette", &c); + g_config->getOption ("SDL.Hue", &h); + FCEUI_SetNTSCTH (c, v, h); - if (gtk_dialog_run (GTK_DIALOG (fileChooser)) ==GTK_RESPONSE_ACCEPT) + return 0; +} + +int setHue (GtkWidget * w, gpointer p) +{ + int v = gtk_range_get_value (GTK_RANGE (w)); + g_config->setOption ("SDL.Hue", v); + g_config->save (); + int c, t; + g_config->getOption ("SDL.Tint", &t); + g_config->getOption ("SDL.SDL.NTSCpalette", &c); + FCEUI_SetNTSCTH (c, t, v); + + return 0; +} + +void loadPalette (GtkWidget * w, gpointer p) +{ + GtkWidget *fileChooser; + + fileChooser = + gtk_file_chooser_dialog_new ("Open NES Palette", + GTK_WINDOW (MainWindow), + GTK_FILE_CHOOSER_ACTION_OPEN, + "_Cancel", GTK_RESPONSE_CANCEL, + "_Open", GTK_RESPONSE_ACCEPT, + NULL); + gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (fileChooser), + "/usr/share/fceux/palettes"); + + if (gtk_dialog_run (GTK_DIALOG (fileChooser)) == GTK_RESPONSE_ACCEPT) { - char* filename; - - filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fileChooser)); - g_config->setOption("SDL.Palette", filename); - g_config->setOption("SDL.SDL.NTSCpalette", 0); - LoadCPalette(filename); - - gtk_entry_set_text(GTK_ENTRY(p), filename); - + char *filename; + + filename = + gtk_file_chooser_get_filename (GTK_FILE_CHOOSER + (fileChooser)); + g_config->setOption ("SDL.Palette", filename); + g_config->setOption ("SDL.SDL.NTSCpalette", 0); + LoadCPalette (filename); + + gtk_entry_set_text (GTK_ENTRY (p), filename); + } gtk_widget_destroy (fileChooser); } -void clearPalette(GtkWidget* w, gpointer p) +void clearPalette (GtkWidget * w, gpointer p) { - g_config->setOption("SDL.Palette", 0); - gtk_entry_set_text(GTK_ENTRY(p), ""); + g_config->setOption ("SDL.Palette", 0); + gtk_entry_set_text (GTK_ENTRY (p), ""); } -void openPaletteConfig(void) +void openPaletteConfig (void) { - GtkWidget* win; - GtkWidget* vbox; - GtkWidget* paletteFrame; - GtkWidget* paletteHbox; - GtkWidget* paletteButton; - GtkWidget* paletteEntry; - GtkWidget* clearButton; - GtkWidget* ntscColorChk; - GtkWidget* slidersFrame; - GtkWidget* slidersVbox; - GtkWidget* tintFrame; - GtkWidget* tintHscale; - GtkWidget* hueFrame; - GtkWidget* hueHscale; - - win = gtk_dialog_new_with_buttons("Palette Options", - GTK_WINDOW(MainWindow), - (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT), - "_Close", - GTK_RESPONSE_OK, - NULL); - gtk_window_set_icon_name(GTK_WINDOW(win), "Color"); - vbox = gtk_dialog_get_content_area(GTK_DIALOG(win)); - - paletteFrame = gtk_frame_new("Custom palette: "); - paletteHbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); - gtk_container_set_border_width(GTK_CONTAINER(paletteHbox), 5); - gtk_container_add(GTK_CONTAINER(paletteFrame), paletteHbox); - paletteButton = gtk_button_new_with_label("Open palette"); - paletteEntry = gtk_entry_new(); - gtk_editable_set_editable(GTK_EDITABLE(paletteEntry), FALSE); - - clearButton = gtk_button_new_with_label("Clear"); - - gtk_box_pack_start(GTK_BOX(paletteHbox), paletteButton, FALSE, FALSE, 2); - gtk_box_pack_start(GTK_BOX(paletteHbox), paletteEntry, TRUE, TRUE, 5); - gtk_box_pack_start(GTK_BOX(paletteHbox), clearButton, FALSE, FALSE, 0); - - g_signal_connect(paletteButton, "clicked", G_CALLBACK(loadPalette), paletteEntry); - g_signal_connect(clearButton, "clicked", G_CALLBACK(clearPalette), paletteEntry); - + GtkWidget *win; + GtkWidget *vbox; + GtkWidget *paletteFrame; + GtkWidget *paletteHbox; + GtkWidget *paletteButton; + GtkWidget *paletteEntry; + GtkWidget *clearButton; + GtkWidget *ntscColorChk; + GtkWidget *slidersFrame; + GtkWidget *slidersVbox; + GtkWidget *tintFrame; + GtkWidget *tintHscale; + GtkWidget *hueFrame; + GtkWidget *hueHscale; + + win = gtk_dialog_new_with_buttons ("Palette Options", + GTK_WINDOW (MainWindow), + (GtkDialogFlags) + (GTK_DIALOG_DESTROY_WITH_PARENT), + "_Close", GTK_RESPONSE_OK, NULL); + gtk_window_set_icon_name (GTK_WINDOW (win), "Color"); + vbox = gtk_dialog_get_content_area (GTK_DIALOG (win)); + + paletteFrame = gtk_frame_new ("Custom palette: "); + paletteHbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5); + gtk_container_set_border_width (GTK_CONTAINER (paletteHbox), 5); + gtk_container_add (GTK_CONTAINER (paletteFrame), paletteHbox); + paletteButton = gtk_button_new_with_label ("Open palette"); + paletteEntry = gtk_entry_new (); + gtk_editable_set_editable (GTK_EDITABLE (paletteEntry), FALSE); + + clearButton = gtk_button_new_with_label ("Clear"); + + gtk_box_pack_start (GTK_BOX (paletteHbox), paletteButton, FALSE, FALSE, + 2); + gtk_box_pack_start (GTK_BOX (paletteHbox), paletteEntry, TRUE, TRUE, 5); + gtk_box_pack_start (GTK_BOX (paletteHbox), clearButton, FALSE, FALSE, + 0); + + g_signal_connect (paletteButton, "clicked", G_CALLBACK (loadPalette), + paletteEntry); + g_signal_connect (clearButton, "clicked", G_CALLBACK (clearPalette), + paletteEntry); + // sync with config std::string fn; - g_config->getOption("SDL.Palette", &fn); - gtk_entry_set_text(GTK_ENTRY(paletteEntry), fn.c_str()); - + g_config->getOption ("SDL.Palette", &fn); + gtk_entry_set_text (GTK_ENTRY (paletteEntry), fn.c_str ()); + // ntsc color check - ntscColorChk = gtk_check_button_new_with_label("Use NTSC palette"); - - g_signal_connect(ntscColorChk, "clicked", G_CALLBACK(toggleOption), (gpointer)"SDL.NTSCpalette"); - setCheckbox(ntscColorChk, "SDL.NTSCpalette"); - + ntscColorChk = gtk_check_button_new_with_label ("Use NTSC palette"); + + g_signal_connect (ntscColorChk, "clicked", G_CALLBACK (toggleOption), + (gpointer) "SDL.NTSCpalette"); + setCheckbox (ntscColorChk, "SDL.NTSCpalette"); + // color / tint / hue sliders - slidersFrame = gtk_frame_new("NTSC palette controls"); - slidersVbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 2); - tintFrame = gtk_frame_new("Tint"); - tintHscale = gtk_scale_new_with_range( GTK_ORIENTATION_HORIZONTAL, 0, 128, 1); - gtk_container_add(GTK_CONTAINER(tintFrame), tintHscale); - hueFrame = gtk_frame_new("Hue"); - hueHscale = gtk_scale_new_with_range( GTK_ORIENTATION_HORIZONTAL, 0, 128, 1); - gtk_container_add(GTK_CONTAINER(hueFrame), hueHscale); - - g_signal_connect(tintHscale, "button-release-event", G_CALLBACK(setTint), NULL); - g_signal_connect(hueHscale, "button-release-event", G_CALLBACK(setHue), NULL); - + slidersFrame = gtk_frame_new ("NTSC palette controls"); + slidersVbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); + tintFrame = gtk_frame_new ("Tint"); + tintHscale = + gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 128, + 1); + gtk_container_add (GTK_CONTAINER (tintFrame), tintHscale); + hueFrame = gtk_frame_new ("Hue"); + hueHscale = + gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 128, + 1); + gtk_container_add (GTK_CONTAINER (hueFrame), hueHscale); + + g_signal_connect (tintHscale, "button-release-event", + G_CALLBACK (setTint), NULL); + g_signal_connect (hueHscale, "button-release-event", + G_CALLBACK (setHue), NULL); + // sync with config int h, t; - g_config->getOption("SDL.Hue", &h); - g_config->getOption("SDL.Tint", &t); + g_config->getOption ("SDL.Hue", &h); + g_config->getOption ("SDL.Tint", &t); + + gtk_range_set_value (GTK_RANGE (hueHscale), h); + gtk_range_set_value (GTK_RANGE (tintHscale), t); + + gtk_container_add (GTK_CONTAINER (slidersFrame), slidersVbox); + gtk_box_pack_start (GTK_BOX (slidersVbox), ntscColorChk, FALSE, FALSE, + 5); + gtk_box_pack_start (GTK_BOX (slidersVbox), tintFrame, FALSE, TRUE, 5); + gtk_box_pack_start (GTK_BOX (slidersVbox), hueFrame, FALSE, TRUE, 5); + + gtk_box_pack_start (GTK_BOX (vbox), paletteFrame, FALSE, TRUE, 5); + gtk_box_pack_start (GTK_BOX (vbox), slidersFrame, FALSE, TRUE, 5); + + g_signal_connect (win, "delete-event", G_CALLBACK (closeDialog), NULL); + g_signal_connect (win, "response", G_CALLBACK (closeDialog), NULL); + + gtk_widget_show_all (win); - gtk_range_set_value(GTK_RANGE(hueHscale), h); - gtk_range_set_value(GTK_RANGE(tintHscale), t); - - gtk_container_add(GTK_CONTAINER(slidersFrame), slidersVbox); - gtk_box_pack_start(GTK_BOX(slidersVbox), ntscColorChk, FALSE, FALSE, 5); - gtk_box_pack_start(GTK_BOX(slidersVbox), tintFrame, FALSE, TRUE, 5); - gtk_box_pack_start(GTK_BOX(slidersVbox), hueFrame, FALSE, TRUE, 5); - - gtk_box_pack_start(GTK_BOX(vbox), paletteFrame, FALSE, TRUE, 5); - gtk_box_pack_start(GTK_BOX(vbox), slidersFrame, FALSE, TRUE, 5); - - g_signal_connect(win, "delete-event", G_CALLBACK(closeDialog), NULL); - g_signal_connect(win, "response", G_CALLBACK(closeDialog), NULL); - - gtk_widget_show_all(win); - return; } -GtkWidget* ipEntry; -GtkWidget* portSpin; -GtkWidget* pwEntry; +GtkWidget *ipEntry; +GtkWidget *portSpin; +GtkWidget *pwEntry; -void launchNet(GtkWidget* w, gpointer p) +void launchNet (GtkWidget * w, gpointer p) { - char* ip = (char*)gtk_entry_get_text(GTK_ENTRY(ipEntry)); - char* pw = (char*)gtk_entry_get_text(GTK_ENTRY(pwEntry)); - int port = (int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(portSpin)); - - g_config->setOption("SDL.NetworkIP", ip); - g_config->setOption("SDL.NetworkPassword", pw); - g_config->setOption("SDL.NetworkPort", port); - - gtk_widget_destroy(GTK_WIDGET(w)); - - loadGame(); + char *ip = (char *) gtk_entry_get_text (GTK_ENTRY (ipEntry)); + char *pw = (char *) gtk_entry_get_text (GTK_ENTRY (pwEntry)); + int port = (int) gtk_spin_button_get_value (GTK_SPIN_BUTTON (portSpin)); + + g_config->setOption ("SDL.NetworkIP", ip); + g_config->setOption ("SDL.NetworkPassword", pw); + g_config->setOption ("SDL.NetworkPort", port); + + gtk_widget_destroy (GTK_WIDGET (w)); + + loadGame (); } -void setUsername(GtkWidget* w, gpointer p) +void setUsername (GtkWidget * w, gpointer p) { - char* s = (char*)gtk_entry_get_text(GTK_ENTRY(w)); - g_config->setOption("SDL.NetworkUsername", s); + char *s = (char *) gtk_entry_get_text (GTK_ENTRY (w)); + g_config->setOption ("SDL.NetworkUsername", s); } -void netResponse(GtkWidget* w, gint response_id, gpointer p) +void netResponse (GtkWidget * w, gint response_id, gpointer p) { - if(response_id == GTK_RESPONSE_OK) - launchNet(w, p); + if (response_id == GTK_RESPONSE_OK) + launchNet (w, p); else - gtk_widget_destroy(w); + gtk_widget_destroy (w); } -void openNetworkConfig(void) +void openNetworkConfig (void) { - GtkWidget* win; - GtkWidget* box; - GtkWidget* userBox; - GtkWidget* userEntry; - GtkWidget* userLbl; - GtkWidget* frame; - GtkWidget* vbox; - GtkWidget* ipBox; - GtkWidget* ipLbl; - - GtkWidget* portBox; - GtkWidget* portLbl; - - //GtkWidget* localPlayersCbo; - GtkWidget* pwBox; - GtkWidget* pwLbl; - - win = gtk_dialog_new_with_buttons("Network Options",GTK_WINDOW(MainWindow), (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT),"_Close", GTK_RESPONSE_CLOSE, "_Connect", GTK_RESPONSE_OK, NULL); - gtk_window_set_icon_name(GTK_WINDOW(win), "network-workgroup"); - box = gtk_dialog_get_content_area(GTK_DIALOG(win)); - - userBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); - userLbl = gtk_label_new("Username:"); - userEntry = gtk_entry_new(); - std::string s; - g_config->getOption("SDL.NetworkUsername", &s); - gtk_entry_set_text(GTK_ENTRY(userEntry), s.c_str()); - - g_signal_connect(userEntry, "changed", G_CALLBACK(setUsername), NULL); + GtkWidget *win; + GtkWidget *box; + GtkWidget *userBox; + GtkWidget *userEntry; + GtkWidget *userLbl; + GtkWidget *frame; + GtkWidget *vbox; + GtkWidget *ipBox; + GtkWidget *ipLbl; - frame = gtk_frame_new("Network options"); - vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); - ipBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); - ipLbl = gtk_label_new("Server IP:"); - ipEntry = gtk_entry_new(); - portBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); - portLbl = gtk_label_new("Server port:"); - portSpin = gtk_spin_button_new_with_range(0, 999999, 1); + GtkWidget *portBox; + GtkWidget *portLbl; + + //GtkWidget* localPlayersCbo; + GtkWidget *pwBox; + GtkWidget *pwLbl; + + win = gtk_dialog_new_with_buttons ("Network Options", + GTK_WINDOW (MainWindow), + (GtkDialogFlags) + (GTK_DIALOG_DESTROY_WITH_PARENT), + "_Close", GTK_RESPONSE_CLOSE, + "_Connect", GTK_RESPONSE_OK, NULL); + gtk_window_set_icon_name (GTK_WINDOW (win), "network-workgroup"); + box = gtk_dialog_get_content_area (GTK_DIALOG (win)); + + userBox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3); + userLbl = gtk_label_new ("Username:"); + userEntry = gtk_entry_new (); + std::string s; + g_config->getOption ("SDL.NetworkUsername", &s); + gtk_entry_set_text (GTK_ENTRY (userEntry), s.c_str ()); + + g_signal_connect (userEntry, "changed", G_CALLBACK (setUsername), NULL); + + frame = gtk_frame_new ("Network options"); + vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5); + ipBox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5); + ipLbl = gtk_label_new ("Server IP:"); + ipEntry = gtk_entry_new (); + portBox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5); + portLbl = gtk_label_new ("Server port:"); + portSpin = gtk_spin_button_new_with_range (0, 999999, 1); //localPlayersCbo = gtk_combo_box_new_text(); - pwBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); - pwLbl = gtk_label_new("Server password:"); - pwEntry = gtk_entry_new(); - - gtk_spin_button_set_value(GTK_SPIN_BUTTON(portSpin), 4046); - - gtk_box_pack_start(GTK_BOX(userBox), userLbl, FALSE, FALSE, 3); - gtk_box_pack_start(GTK_BOX(userBox), userEntry, TRUE , TRUE, 3); - - gtk_box_pack_start(GTK_BOX(portBox), portLbl, FALSE, FALSE, 3); - gtk_box_pack_start(GTK_BOX(portBox), portSpin, FALSE , FALSE, 3); - - gtk_box_pack_start(GTK_BOX(ipBox), ipLbl, FALSE, FALSE, 3); - gtk_box_pack_start(GTK_BOX(ipBox), ipEntry, TRUE , TRUE, 3); - - gtk_box_pack_start(GTK_BOX(pwBox), pwLbl, FALSE, FALSE, 3); - gtk_box_pack_start(GTK_BOX(pwBox), pwEntry, TRUE , TRUE, 3); - - gtk_box_pack_start(GTK_BOX(vbox), ipBox, FALSE, FALSE, 3); - gtk_box_pack_start(GTK_BOX(vbox), portBox, FALSE, FALSE, 3); + pwBox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3); + pwLbl = gtk_label_new ("Server password:"); + pwEntry = gtk_entry_new (); + + gtk_spin_button_set_value (GTK_SPIN_BUTTON (portSpin), 4046); + + gtk_box_pack_start (GTK_BOX (userBox), userLbl, FALSE, FALSE, 3); + gtk_box_pack_start (GTK_BOX (userBox), userEntry, TRUE, TRUE, 3); + + gtk_box_pack_start (GTK_BOX (portBox), portLbl, FALSE, FALSE, 3); + gtk_box_pack_start (GTK_BOX (portBox), portSpin, FALSE, FALSE, 3); + + gtk_box_pack_start (GTK_BOX (ipBox), ipLbl, FALSE, FALSE, 3); + gtk_box_pack_start (GTK_BOX (ipBox), ipEntry, TRUE, TRUE, 3); + + gtk_box_pack_start (GTK_BOX (pwBox), pwLbl, FALSE, FALSE, 3); + gtk_box_pack_start (GTK_BOX (pwBox), pwEntry, TRUE, TRUE, 3); + + gtk_box_pack_start (GTK_BOX (vbox), ipBox, FALSE, FALSE, 3); + gtk_box_pack_start (GTK_BOX (vbox), portBox, FALSE, FALSE, 3); //gtk_box_pack_start_defaults(GTK_BOX(vbox), localPlayersCbo); - gtk_box_pack_start(GTK_BOX(vbox), pwBox, FALSE, FALSE, 3); - - gtk_container_add(GTK_CONTAINER(frame), vbox); - - gtk_box_pack_start(GTK_BOX(box), userBox, TRUE, TRUE, 0); - gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 0); - - gtk_widget_show_all(win); - - g_signal_connect(win, "delete-event", G_CALLBACK(closeDialog), NULL); - g_signal_connect(win, "response", G_CALLBACK(netResponse), NULL); + gtk_box_pack_start (GTK_BOX (vbox), pwBox, FALSE, FALSE, 3); + + gtk_container_add (GTK_CONTAINER (frame), vbox); + + gtk_box_pack_start (GTK_BOX (box), userBox, TRUE, TRUE, 0); + gtk_box_pack_start (GTK_BOX (box), frame, TRUE, TRUE, 0); + + gtk_widget_show_all (win); + + g_signal_connect (win, "delete-event", G_CALLBACK (closeDialog), NULL); + g_signal_connect (win, "response", G_CALLBACK (netResponse), NULL); } // handler prototype -void flushGtkEvents(void) +void flushGtkEvents (void) { while (gtk_events_pending ()) gtk_main_iteration_do (FALSE); @@ -474,1043 +513,1146 @@ void flushGtkEvents(void) } -static void hotKeyWindowRefresh(void) +static void hotKeyWindowRefresh (void) { - GtkTreeIter iter; - std::string prefix = "SDL.Hotkeys."; + GtkTreeIter iter; + std::string prefix = "SDL.Hotkeys."; - if ( hotkey_store == NULL ) return; + if (hotkey_store == NULL) return; - gtk_tree_store_clear(hotkey_store); - - gtk_tree_store_append(hotkey_store, &iter, NULL); // aquire iter - - int keycode; - for(int i=0; igetOption(optionName.c_str(), &keycode); - gtk_tree_store_set(hotkey_store, &iter, - 0, optionName.c_str(), - 1, -#if SDL_VERSION_ATLEAST(2, 0, 0) - SDL_GetKeyName(keycode), + gtk_tree_store_clear (hotkey_store); + + gtk_tree_store_append (hotkey_store, &iter, NULL); // aquire iter + + int keycode; + for (int i = 0; i < HK_MAX; i++) + { + std::string optionName = prefix + HotkeyStrings[i]; + g_config->getOption (optionName.c_str (), &keycode); + gtk_tree_store_set (hotkey_store, &iter, + 0, optionName.c_str (), 1, +#if SDL_VERSION_ATLEAST(2, 0, 0) + SDL_GetKeyName (keycode), #else - SDL_GetKeyName((SDLKey)keycode), + SDL_GetKeyName ((SDLKey) keycode), #endif - -1); - gtk_tree_store_append(hotkey_store, &iter, NULL); // acquire child iterator - } + -1); + gtk_tree_store_append (hotkey_store, &iter, NULL); // acquire child iterator + } } -static gint hotKeyPressCB(GtkTreeView* tree, GdkEventKey* event, gpointer cb_data) +static gint hotKeyPressCB (GtkTreeView * tree, GdkEventKey * event, + gpointer cb_data) { int numListRows; GList *selListRows, *tmpList; GtkTreeModel *model = NULL; - GtkTreeSelection *treeSel = gtk_tree_view_get_selection(tree); + GtkTreeSelection *treeSel = gtk_tree_view_get_selection (tree); - printf("Hot Key Press: %i \n", event->keyval ); + printf ("Hot Key Press: %i \n", event->keyval); - numListRows = gtk_tree_selection_count_selected_rows( treeSel ); + numListRows = gtk_tree_selection_count_selected_rows (treeSel); - if ( numListRows == 0 ) - { - return FALSE; - } + if (numListRows == 0) + { + return FALSE; + } //printf("Number of Rows Selected: %i\n", numListRows ); - selListRows = gtk_tree_selection_get_selected_rows( treeSel, &model ); + selListRows = gtk_tree_selection_get_selected_rows (treeSel, &model); tmpList = selListRows; - while ( tmpList ) + while (tmpList) { int depth; int *indexArray; - GtkTreePath *path = (GtkTreePath*)tmpList->data; + GtkTreePath *path = (GtkTreePath *) tmpList->data; - depth = gtk_tree_path_get_depth(path); - indexArray = gtk_tree_path_get_indices(path); + depth = gtk_tree_path_get_depth (path); + indexArray = gtk_tree_path_get_indices (path); - if ( depth > 0 ) + if (depth > 0) { - int sdlkey = 0; - std::string hotKeyName = "SDL.Hotkeys."; - hotKeyName.append( HotkeyStrings[indexArray[0]] ); + int sdlkey = 0; + std::string hotKeyName = "SDL.Hotkeys."; + hotKeyName.append (HotkeyStrings[indexArray[0]]); - // Convert this keypress from GDK to SDL. - #if SDL_VERSION_ATLEAST(2, 0, 0) - sdlkey = GDKToSDLKeyval(event->keyval); - #else - sdlkey = (SDLKey)GDKToSDLKeyval(event->keyval); - #endif - printf("HotKey Index: %i '%s' %i %i \n", - indexArray[0], hotKeyName.c_str(), event->keyval, sdlkey ); + // Convert this keypress from GDK to SDL. +#if SDL_VERSION_ATLEAST(2, 0, 0) + sdlkey = GDKToSDLKeyval (event->keyval); +#else + sdlkey = (SDLKey) GDKToSDLKeyval (event->keyval); +#endif + printf ("HotKey Index: %i '%s' %i %i \n", + indexArray[0], hotKeyName.c_str (), + event->keyval, sdlkey); - g_config->setOption( hotKeyName, sdlkey ); + g_config->setOption (hotKeyName, sdlkey); - setHotKeys(); // Update Hot Keys in Input Model + setHotKeys (); // Update Hot Keys in Input Model - hotKeyWindowRefresh(); + hotKeyWindowRefresh (); } - tmpList = tmpList->next; + tmpList = tmpList->next; } - g_list_free_full(selListRows, (GDestroyNotify) gtk_tree_path_free); + g_list_free_full (selListRows, (GDestroyNotify) gtk_tree_path_free); - return TRUE; + return TRUE; } // creates and opens hotkey config window -void openHotkeyConfig(void) +void openHotkeyConfig (void) { - GtkWidget* win = gtk_dialog_new_with_buttons("Hotkey Configuration", - GTK_WINDOW(MainWindow), (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT), - "_Close", - GTK_RESPONSE_OK, - NULL); - gtk_window_set_default_size(GTK_WINDOW(win), 400, 800); + GtkWidget *win = gtk_dialog_new_with_buttons ("Hotkey Configuration", + GTK_WINDOW (MainWindow), + (GtkDialogFlags) + (GTK_DIALOG_DESTROY_WITH_PARENT), + "_Close", + GTK_RESPONSE_OK, + NULL); + gtk_window_set_default_size (GTK_WINDOW (win), 400, 800); GtkWidget *tree; GtkWidget *vbox; GtkWidget *scroll; - vbox = gtk_dialog_get_content_area(GTK_DIALOG(win)); - - hotkey_store = gtk_tree_store_new(2, G_TYPE_STRING, G_TYPE_STRING); + vbox = gtk_dialog_get_content_area (GTK_DIALOG (win)); - hotKeyWindowRefresh(); + hotkey_store = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_STRING); - tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(hotkey_store)); + hotKeyWindowRefresh (); + + tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (hotkey_store)); GtkCellRenderer *renderer; - GtkTreeViewColumn* column; + GtkTreeViewColumn *column; - g_signal_connect(G_OBJECT(tree), "key-press-event", G_CALLBACK(hotKeyPressCB), NULL); - - renderer = gtk_cell_renderer_text_new(); - column = gtk_tree_view_column_new_with_attributes("Command", renderer, "text", 0, NULL); - gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); - column = gtk_tree_view_column_new_with_attributes("Key", renderer, "text", 1, NULL); - gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); - scroll = gtk_scrolled_window_new(NULL, NULL); - gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, - GTK_POLICY_AUTOMATIC); - gtk_container_add(GTK_CONTAINER(scroll), tree); - gtk_box_pack_start(GTK_BOX(vbox), scroll, TRUE, TRUE, 5); - gtk_widget_show_all(win); + g_signal_connect (G_OBJECT (tree), "key-press-event", + G_CALLBACK (hotKeyPressCB), NULL); - g_signal_connect(win, "delete-event", G_CALLBACK(closeDialog), NULL); - g_signal_connect(win, "response", G_CALLBACK(closeDialog), NULL); + renderer = gtk_cell_renderer_text_new (); + column = gtk_tree_view_column_new_with_attributes ("Command", renderer, + "text", 0, NULL); + gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column); + column = gtk_tree_view_column_new_with_attributes ("Key", renderer, + "text", 1, NULL); + gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column); + scroll = gtk_scrolled_window_new (NULL, NULL); + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), + GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); + gtk_container_add (GTK_CONTAINER (scroll), tree); + gtk_box_pack_start (GTK_BOX (vbox), scroll, TRUE, TRUE, 5); + gtk_widget_show_all (win); + + g_signal_connect (win, "delete-event", G_CALLBACK (closeDialog), NULL); + g_signal_connect (win, "response", G_CALLBACK (closeDialog), NULL); } -GtkWidget* typeCombo; +GtkWidget *typeCombo; // TODO: finish this -int setInputDevice(GtkWidget* w, gpointer p) +int setInputDevice (GtkWidget * w, gpointer p) { std::string s = "SDL.Input."; - s = s + (char*)p; - printf("%s", s.c_str()); - g_config->setOption(s, gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(typeCombo))); - g_config->save(); - + s = s + (char *) p; + printf ("%s", s.c_str ()); + g_config->setOption (s, + gtk_combo_box_text_get_active_text + (GTK_COMBO_BOX_TEXT (typeCombo))); + g_config->save (); + return 1; } -void updateGamepadConfig(GtkWidget* w, gpointer p) +void updateGamepadConfig (GtkWidget * w, gpointer p) { int i; char strBuf[128]; - int padNo = atoi(gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(padNoCombo))) - 1; - int configNo = atoi(gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(configNoCombo))) - 1; - - for(i=0; i<10; i++) + int padNo = + atoi (gtk_combo_box_text_get_active_text + (GTK_COMBO_BOX_TEXT (padNoCombo))) - 1; + int configNo = + atoi (gtk_combo_box_text_get_active_text + (GTK_COMBO_BOX_TEXT (configNoCombo))) - 1; + + for (i = 0; i < 10; i++) { - GtkWidget* mappedKey = buttonMappings[i]; - if(GamePadConfig[padNo][i].ButtType[configNo] == BUTTC_KEYBOARD) + GtkWidget *mappedKey = buttonMappings[i]; + if (GamePadConfig[padNo][i].ButtType[configNo] == + BUTTC_KEYBOARD) { -#if SDL_VERSION_ATLEAST(2, 0, 0) - snprintf(strBuf, sizeof(strBuf), "%s", - SDL_GetKeyName(GamePadConfig[padNo][i].ButtonNum[configNo])); +#if SDL_VERSION_ATLEAST(2, 0, 0) + snprintf (strBuf, sizeof (strBuf), "%s", + SDL_GetKeyName (GamePadConfig[padNo][i]. + ButtonNum[configNo])); #else - snprintf(strBuf, sizeof(strBuf), "%s", - SDL_GetKeyName((SDLKey)GamePadConfig[padNo][i].ButtonNum[configNo])); + snprintf (strBuf, sizeof (strBuf), "%s", + SDL_GetKeyName ((SDLKey) + GamePadConfig[padNo][i]. + ButtonNum[configNo])); #endif } - else // FIXME: display joystick button/hat/axis names properly - strncpy(strBuf, "Joystick", sizeof(strBuf)); - - gtk_label_set_text(GTK_LABEL(mappedKey), strBuf); - gtk_label_set_use_markup(GTK_LABEL(mappedKey), TRUE); + else // FIXME: display joystick button/hat/axis names properly + strncpy (strBuf, "Joystick", sizeof (strBuf)); + + gtk_label_set_text (GTK_LABEL (mappedKey), strBuf); + gtk_label_set_use_markup (GTK_LABEL (mappedKey), TRUE); } } // creates and opens the gamepad config window (requires GTK 2.24) -void openGamepadConfig(void) +void openGamepadConfig (void) { // GTK 2.24 required for this dialog - if (checkGTKVersion(2, 24) == false) + if (checkGTKVersion (2, 24) == false) { // TODO: present this in a GTK MessageBox? - printf(" Warning: GTK >= 2.24 required for this dialog.\nTo configure the gamepads, use \"--inputcfg\" from the command line (ie: \"fceux --inputcfg gamepad1\").\n"); + printf (" Warning: GTK >= 2.24 required for this dialog.\nTo configure the gamepads, use \"--inputcfg\" from the command line (ie: \"fceux --inputcfg gamepad1\").\n"); return; } - GtkWidget* win; - GtkWidget* vbox; - GtkWidget* hboxPadNo; - GtkWidget* padNoLabel; + GtkWidget *win; + GtkWidget *vbox; + GtkWidget *hboxPadNo; + GtkWidget *padNoLabel; //GtkWidget* configNoLabel; - GtkWidget* fourScoreChk; - GtkWidget* oppositeDirChk; - GtkWidget* buttonFrame; - GtkWidget* buttonTable; - - win = gtk_dialog_new_with_buttons("Controller Configuration", - GTK_WINDOW(MainWindow), - (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT), - "_Close", - GTK_RESPONSE_OK, - NULL); - gtk_window_set_title(GTK_WINDOW(win), "Controller Configuration"); - gtk_window_set_icon_name(GTK_WINDOW(win), "input-gaming"); - gtk_widget_set_size_request(win, 350, 500); - - vbox = gtk_dialog_get_content_area(GTK_DIALOG(win)); - gtk_box_set_homogeneous(GTK_BOX(vbox), FALSE); - - hboxPadNo = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); - padNoLabel = gtk_label_new("Port:"); + GtkWidget *fourScoreChk; + GtkWidget *oppositeDirChk; + GtkWidget *buttonFrame; + GtkWidget *buttonTable; + + win = gtk_dialog_new_with_buttons ("Controller Configuration", + GTK_WINDOW (MainWindow), + (GtkDialogFlags) + (GTK_DIALOG_DESTROY_WITH_PARENT), + "_Close", GTK_RESPONSE_OK, NULL); + gtk_window_set_title (GTK_WINDOW (win), "Controller Configuration"); + gtk_window_set_icon_name (GTK_WINDOW (win), "input-gaming"); + gtk_widget_set_size_request (win, 350, 500); + + vbox = gtk_dialog_get_content_area (GTK_DIALOG (win)); + gtk_box_set_homogeneous (GTK_BOX (vbox), FALSE); + + hboxPadNo = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); + padNoLabel = gtk_label_new ("Port:"); //configNoLabel = gtk_label_new("Config Number:"); - fourScoreChk = gtk_check_button_new_with_label("Enable Four Score"); - oppositeDirChk = gtk_check_button_new_with_label("Allow Up+Down / Left+Right"); - - typeCombo = gtk_combo_box_text_new(); - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(typeCombo), "gamepad"); - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(typeCombo), "zapper"); - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(typeCombo), "powerpad.0"); - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(typeCombo), "powerpad.1"); - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(typeCombo), "arkanoid"); - - gtk_combo_box_set_active(GTK_COMBO_BOX(typeCombo), 0); - - - padNoCombo = gtk_combo_box_text_new(); - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(padNoCombo), "1"); - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(padNoCombo), "2"); - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(padNoCombo), "3"); - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(padNoCombo), "4"); - gtk_combo_box_set_active(GTK_COMBO_BOX(padNoCombo), 0); - g_signal_connect(padNoCombo, "changed", G_CALLBACK(updateGamepadConfig), NULL); - - configNoCombo = gtk_combo_box_text_new(); - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(configNoCombo), "1"); - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(configNoCombo), "2"); - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(configNoCombo), "3"); - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(configNoCombo), "4"); - gtk_combo_box_set_active(GTK_COMBO_BOX(configNoCombo), 0); - g_signal_connect(padNoCombo, "changed", G_CALLBACK(updateGamepadConfig), NULL); - - - g_signal_connect(typeCombo, "changed", G_CALLBACK(setInputDevice), - gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(typeCombo))); - - setCheckbox(fourScoreChk, "SDL.FourScore"); - g_signal_connect(fourScoreChk, "clicked", G_CALLBACK(toggleOption), (gpointer)"SDL.FourScore"); - setCheckbox(oppositeDirChk, "SDL.Input.EnableOppositeDirectionals"); - g_signal_connect(oppositeDirChk, "clicked", G_CALLBACK(toggleOption), (gpointer)"SDL.Input.EnableOppositeDirectionals"); - - - gtk_box_pack_start(GTK_BOX(hboxPadNo), padNoLabel, TRUE, TRUE, 5); - gtk_box_pack_start(GTK_BOX(hboxPadNo), padNoCombo, TRUE, TRUE, 5); + fourScoreChk = gtk_check_button_new_with_label ("Enable Four Score"); + oppositeDirChk = + gtk_check_button_new_with_label ("Allow Up+Down / Left+Right"); + + typeCombo = gtk_combo_box_text_new (); + gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (typeCombo), + "gamepad"); + gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (typeCombo), + "zapper"); + gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (typeCombo), + "powerpad.0"); + gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (typeCombo), + "powerpad.1"); + gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (typeCombo), + "arkanoid"); + + gtk_combo_box_set_active (GTK_COMBO_BOX (typeCombo), 0); + + + padNoCombo = gtk_combo_box_text_new (); + gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (padNoCombo), "1"); + gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (padNoCombo), "2"); + gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (padNoCombo), "3"); + gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (padNoCombo), "4"); + gtk_combo_box_set_active (GTK_COMBO_BOX (padNoCombo), 0); + g_signal_connect (padNoCombo, "changed", + G_CALLBACK (updateGamepadConfig), NULL); + + configNoCombo = gtk_combo_box_text_new (); + gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (configNoCombo), + "1"); + gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (configNoCombo), + "2"); + gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (configNoCombo), + "3"); + gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (configNoCombo), + "4"); + gtk_combo_box_set_active (GTK_COMBO_BOX (configNoCombo), 0); + g_signal_connect (padNoCombo, "changed", + G_CALLBACK (updateGamepadConfig), NULL); + + + g_signal_connect (typeCombo, "changed", G_CALLBACK (setInputDevice), + gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT + (typeCombo))); + + setCheckbox (fourScoreChk, "SDL.FourScore"); + g_signal_connect (fourScoreChk, "clicked", G_CALLBACK (toggleOption), + (gpointer) "SDL.FourScore"); + setCheckbox (oppositeDirChk, "SDL.Input.EnableOppositeDirectionals"); + g_signal_connect (oppositeDirChk, "clicked", G_CALLBACK (toggleOption), + (gpointer) "SDL.Input.EnableOppositeDirectionals"); + + + gtk_box_pack_start (GTK_BOX (hboxPadNo), padNoLabel, TRUE, TRUE, 5); + gtk_box_pack_start (GTK_BOX (hboxPadNo), padNoCombo, TRUE, TRUE, 5); //gtk_box_pack_start(GTK_BOX(hboxPadNo), configNoLabel, TRUE, TRUE, 5); //gtk_box_pack_start(GTK_BOX(hboxPadNo), configNoCombo, TRUE, TRUE, 5); - gtk_box_pack_start(GTK_BOX(vbox), hboxPadNo, FALSE, TRUE, 5); + gtk_box_pack_start (GTK_BOX (vbox), hboxPadNo, FALSE, TRUE, 5); //gtk_box_pack_start_defaults(GTK_BOX(vbox), typeCombo); - - gtk_box_pack_start(GTK_BOX(vbox), fourScoreChk, FALSE, TRUE, 5); - gtk_box_pack_start(GTK_BOX(vbox), oppositeDirChk, FALSE, TRUE, 5); - - + + gtk_box_pack_start (GTK_BOX (vbox), fourScoreChk, FALSE, TRUE, 5); + gtk_box_pack_start (GTK_BOX (vbox), oppositeDirChk, FALSE, TRUE, 5); + + // create gamepad buttons - buttonFrame = gtk_frame_new("Buttons"); - gtk_label_set_use_markup(GTK_LABEL(gtk_frame_get_label_widget(GTK_FRAME(buttonFrame))), TRUE); - buttonTable = gtk_grid_new(); - gtk_container_add(GTK_CONTAINER(buttonFrame), buttonTable); + buttonFrame = gtk_frame_new ("Buttons"); + gtk_label_set_use_markup (GTK_LABEL + (gtk_frame_get_label_widget + (GTK_FRAME (buttonFrame))), TRUE); + buttonTable = gtk_grid_new (); + gtk_container_add (GTK_CONTAINER (buttonFrame), buttonTable); - for (int i=0; i<3; i++) + for (int i = 0; i < 3; i++) { - gtk_grid_insert_column( GTK_GRID(buttonTable), i ); + gtk_grid_insert_column (GTK_GRID (buttonTable), i); } - gtk_grid_set_column_spacing( GTK_GRID(buttonTable), 5 ); - gtk_grid_set_column_homogeneous( GTK_GRID(buttonTable), TRUE ); - gtk_grid_set_row_spacing( GTK_GRID(buttonTable), 3 ); + gtk_grid_set_column_spacing (GTK_GRID (buttonTable), 5); + gtk_grid_set_column_homogeneous (GTK_GRID (buttonTable), TRUE); + gtk_grid_set_row_spacing (GTK_GRID (buttonTable), 3); - for(int i=0; i<10; i++) + for (int i = 0; i < 10; i++) { - GtkWidget* buttonName = gtk_label_new(GamePadNames[i]); - GtkWidget* mappedKey = gtk_label_new(NULL); - GtkWidget* changeButton = gtk_toggle_button_new(); + GtkWidget *buttonName = gtk_label_new (GamePadNames[i]); + GtkWidget *mappedKey = gtk_label_new (NULL); + GtkWidget *changeButton = gtk_toggle_button_new (); char strBuf[128]; - gtk_grid_insert_row( GTK_GRID(buttonTable), i ); + gtk_grid_insert_row (GTK_GRID (buttonTable), i); - sprintf(strBuf, "%s:", GamePadNames[i]); - gtk_label_set_text(GTK_LABEL(buttonName), strBuf); - - gtk_button_set_label(GTK_BUTTON(changeButton), "Change"); - gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(changeButton), FALSE); - - gtk_grid_attach(GTK_GRID(buttonTable), buttonName, 0, i, 1, 1); - gtk_grid_attach(GTK_GRID(buttonTable), mappedKey, 1, i, 1, 1); - gtk_grid_attach(GTK_GRID(buttonTable), changeButton, 2, i, 1, 1); + sprintf (strBuf, "%s:", GamePadNames[i]); + gtk_label_set_text (GTK_LABEL (buttonName), strBuf); - g_signal_connect(changeButton, "clicked", G_CALLBACK(configGamepadButton), GINT_TO_POINTER(i)); + gtk_button_set_label (GTK_BUTTON (changeButton), "Change"); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (changeButton), + FALSE); + + gtk_grid_attach (GTK_GRID (buttonTable), buttonName, 0, i, 1, + 1); + gtk_grid_attach (GTK_GRID (buttonTable), mappedKey, 1, i, 1, 1); + gtk_grid_attach (GTK_GRID (buttonTable), changeButton, 2, i, 1, + 1); + + g_signal_connect (changeButton, "clicked", + G_CALLBACK (configGamepadButton), + GINT_TO_POINTER (i)); buttonMappings[i] = mappedKey; } - + // display the button mappings for the currently selected configuration - updateGamepadConfig(NULL, NULL); - - gtk_box_pack_start(GTK_BOX(vbox), buttonFrame, TRUE, TRUE, 5); - - g_signal_connect(win, "delete-event", G_CALLBACK(closeDialog), NULL); - g_signal_connect(win, "response", G_CALLBACK(closeDialog), NULL); - - gtk_widget_show_all(win); - + updateGamepadConfig (NULL, NULL); + + gtk_box_pack_start (GTK_BOX (vbox), buttonFrame, TRUE, TRUE, 5); + + g_signal_connect (win, "delete-event", G_CALLBACK (closeDialog), NULL); + g_signal_connect (win, "response", G_CALLBACK (closeDialog), NULL); + + gtk_widget_show_all (win); + return; } -int setBufSize(GtkWidget* w, gpointer p) +int setBufSize (GtkWidget * w, gpointer p) { - int x = gtk_range_get_value(GTK_RANGE(w)); - g_config->setOption("SDL.Sound.BufSize", x); + int x = gtk_range_get_value (GTK_RANGE (w)); + g_config->setOption ("SDL.Sound.BufSize", x); // reset sound subsystem for changes to take effect - KillSound(); - InitSound(); + KillSound (); + InitSound (); return false; } -void setRate(GtkWidget* w, gpointer p) +void setRate (GtkWidget * w, gpointer p) { - char* str = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(w)); - g_config->setOption("SDL.Sound.Rate", atoi(str)); + char *str = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT (w)); + g_config->setOption ("SDL.Sound.Rate", atoi (str)); // reset sound subsystem for changes to take effect - KillSound(); - InitSound(); - g_config->save(); + KillSound (); + InitSound (); + g_config->save (); return; } -void setQuality(GtkWidget* w, gpointer p) +void setQuality (GtkWidget * w, gpointer p) { - char* str = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(w)); - if(!strcmp(str, "Very High")) - g_config->setOption("SDL.Sound.Quality", 2); - if(!strcmp(str, "High")) - g_config->setOption("SDL.Sound.Quality", 1); - if(!strcmp(str, "Low")) - g_config->setOption("SDL.Sound.Quality", 0); + char *str = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT (w)); + if (!strcmp (str, "Very High")) + g_config->setOption ("SDL.Sound.Quality", 2); + if (!strcmp (str, "High")) + g_config->setOption ("SDL.Sound.Quality", 1); + if (!strcmp (str, "Low")) + g_config->setOption ("SDL.Sound.Quality", 0); // reset sound subsystem for changes to take effect - KillSound(); - InitSound(); - g_config->save(); + KillSound (); + InitSound (); + g_config->save (); return; } -void resizeGtkWindow(void) +void resizeGtkWindow (void) { //if(GameInfo == 0) //{ - double xscale, yscale; - g_config->getOption("SDL.XScale", &xscale); - g_config->getOption("SDL.YScale", &yscale); - gtk_widget_set_size_request(evbox, NES_WIDTH*xscale, NES_HEIGHT*yscale); - GtkRequisition req; - gtk_widget_get_preferred_size(GTK_WIDGET(MainWindow), NULL, &req); - //printf("GTK Resizing: w:%i h:%i \n", req.width, req.height ); - gtk_window_resize(GTK_WINDOW(MainWindow), req.width, req.height); - gtk_widget_set_size_request(evbox, NES_WIDTH, NES_HEIGHT); + double xscale, yscale; + g_config->getOption ("SDL.XScale", &xscale); + g_config->getOption ("SDL.YScale", &yscale); + gtk_widget_set_size_request (evbox, NES_WIDTH * xscale, + NES_HEIGHT * yscale); + GtkRequisition req; + gtk_widget_get_preferred_size (GTK_WIDGET (MainWindow), NULL, &req); + //printf("GTK Resizing: w:%i h:%i \n", req.width, req.height ); + gtk_window_resize (GTK_WINDOW (MainWindow), req.width, req.height); + gtk_widget_set_size_request (evbox, NES_WIDTH, NES_HEIGHT); //} return; } -void setScaler(GtkWidget* w, gpointer p) +void setScaler (GtkWidget * w, gpointer p) { - int scaler = gtk_combo_box_get_active(GTK_COMBO_BOX(w)); + int scaler = gtk_combo_box_get_active (GTK_COMBO_BOX (w)); int opengl; - g_config->getOption("SDL.OpenGL", &opengl); - if(opengl && scaler) + g_config->getOption ("SDL.OpenGL", &opengl); + if (opengl && scaler) { - FCEUD_PrintError("Scalers not supported in OpenGL mode."); - gtk_combo_box_set_active(GTK_COMBO_BOX(w), 0); + FCEUD_PrintError ("Scalers not supported in OpenGL mode."); + gtk_combo_box_set_active (GTK_COMBO_BOX (w), 0); return; } - g_config->setOption("SDL.SpecialFilter", scaler); - + g_config->setOption ("SDL.SpecialFilter", scaler); + // 1=hq2x 2=Scale2x 3=NTSC2x 4=hq3x 5=Scale3x 6=Prescale2x 7=Prescale3x 8=Prescale4x 9=pal - switch(scaler) + switch (scaler) { case 4: // hq3x case 5: // scale3x case 7: // prescale3x - g_config->setOption("SDL.XScale", 3.0); - g_config->setOption("SDL.YScale", 3.0); - resizeGtkWindow(); + g_config->setOption ("SDL.XScale", 3.0); + g_config->setOption ("SDL.YScale", 3.0); + resizeGtkWindow (); break; - case 8: // prescale4x - g_config->setOption("SDL.XScale", 4.0); - g_config->setOption("SDL.YScale", 4.0); + case 8: // prescale4x + g_config->setOption ("SDL.XScale", 4.0); + g_config->setOption ("SDL.YScale", 4.0); break; default: - g_config->setOption("SDL.XScale", 2.0); - g_config->setOption("SDL.YScale", 2.0); - resizeGtkWindow(); + g_config->setOption ("SDL.XScale", 2.0); + g_config->setOption ("SDL.YScale", 2.0); + resizeGtkWindow (); break; } - g_config->save(); + g_config->save (); } -void setRegion(GtkWidget* w, gpointer p) +void setRegion (GtkWidget * w, gpointer p) { - int region = gtk_combo_box_get_active(GTK_COMBO_BOX(w)); - g_config->setOption("SDL.PAL", region); - FCEUI_SetRegion(region); - - g_config->save(); - + int region = gtk_combo_box_get_active (GTK_COMBO_BOX (w)); + g_config->setOption ("SDL.PAL", region); + FCEUI_SetRegion (region); + + g_config->save (); + } -int setXscale(GtkWidget* w, gpointer p) +int setXscale (GtkWidget * w, gpointer p) { - double v = gtk_spin_button_get_value(GTK_SPIN_BUTTON(w)); - g_config->setOption("SDL.XScale", v); - g_config->save(); - resizeGtkWindow(); + double v = gtk_spin_button_get_value (GTK_SPIN_BUTTON (w)); + g_config->setOption ("SDL.XScale", v); + g_config->save (); + resizeGtkWindow (); return 0; } -int setYscale(GtkWidget* w, gpointer p) +int setYscale (GtkWidget * w, gpointer p) { - double v = gtk_spin_button_get_value(GTK_SPIN_BUTTON(w)); - g_config->setOption("SDL.YScale", v); - g_config->save(); - resizeGtkWindow(); + double v = gtk_spin_button_get_value (GTK_SPIN_BUTTON (w)); + g_config->setOption ("SDL.YScale", v); + g_config->save (); + resizeGtkWindow (); return 0; } #ifdef OPENGL -void setGl(GtkWidget* w, gpointer p) +void setGl (GtkWidget * w, gpointer p) { int scaler; - int opengl = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w)); - g_config->getOption("SDL.SpecialFilter", &scaler); - if(scaler && opengl) + int opengl = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)); + g_config->getOption ("SDL.SpecialFilter", &scaler); + if (scaler && opengl) { - FCEUD_PrintError("Scalers not supported in OpenGL mode."); - gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), 0); + FCEUD_PrintError ("Scalers not supported in OpenGL mode."); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), 0); return; } - if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w))) - g_config->setOption("SDL.OpenGL", 1); + if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w))) + g_config->setOption ("SDL.OpenGL", 1); else - g_config->setOption("SDL.OpenGL", 0); - g_config->save(); + g_config->setOption ("SDL.OpenGL", 0); + g_config->save (); } -void setDoubleBuffering(GtkWidget* w, gpointer p) +void setDoubleBuffering (GtkWidget * w, gpointer p) { - if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w))) - g_config->setOption("SDL.DoubleBuffering", 1); + if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w))) + g_config->setOption ("SDL.DoubleBuffering", 1); else - g_config->setOption("SDL.DoubleBuffering", 0); - g_config->save(); + g_config->setOption ("SDL.DoubleBuffering", 0); + g_config->save (); } #endif -void openVideoConfig(void) +void openVideoConfig (void) { - GtkWidget* win; - GtkWidget* vbox; - GtkWidget* lbl; - GtkWidget* hbox1; - GtkWidget* scalerLbl; - GtkWidget* scalerCombo; - GtkWidget* glChk; - GtkWidget* linearChk; - GtkWidget* dbChk; - GtkWidget* palHbox; - GtkWidget* palLbl; - GtkWidget* palCombo; - GtkWidget* ppuChk; - GtkWidget* spriteLimitChk; - GtkWidget* frameskipChk; - GtkWidget* clipSidesChk; - GtkWidget* xscaleSpin; - GtkWidget* yscaleSpin; - GtkWidget* xscaleLbl; - GtkWidget* yscaleLbl; - GtkWidget* xscaleHbox; - GtkWidget* yscaleHbox; - GtkWidget* showFpsChk; - - win = gtk_dialog_new_with_buttons("Video Preferences", - GTK_WINDOW(MainWindow), - (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT), - "_Apply", GTK_RESPONSE_APPLY, - "_Close", GTK_RESPONSE_CLOSE, NULL); - gtk_window_set_icon_name(GTK_WINDOW(win), "video-display"); + GtkWidget *win; + GtkWidget *vbox; + GtkWidget *lbl; + GtkWidget *hbox1; + GtkWidget *scalerLbl; + GtkWidget *scalerCombo; + GtkWidget *glChk; + GtkWidget *linearChk; + GtkWidget *dbChk; + GtkWidget *palHbox; + GtkWidget *palLbl; + GtkWidget *palCombo; + GtkWidget *ppuChk; + GtkWidget *spriteLimitChk; + GtkWidget *frameskipChk; + GtkWidget *clipSidesChk; + GtkWidget *xscaleSpin; + GtkWidget *yscaleSpin; + GtkWidget *xscaleLbl; + GtkWidget *yscaleLbl; + GtkWidget *xscaleHbox; + GtkWidget *yscaleHbox; + GtkWidget *showFpsChk; + + win = gtk_dialog_new_with_buttons ("Video Preferences", + GTK_WINDOW (MainWindow), + (GtkDialogFlags) + (GTK_DIALOG_DESTROY_WITH_PARENT), + "_Apply", GTK_RESPONSE_APPLY, + "_Close", GTK_RESPONSE_CLOSE, NULL); + gtk_window_set_icon_name (GTK_WINDOW (win), "video-display"); //gtk_widget_set_size_request(win, 250, 250); - - vbox = gtk_dialog_get_content_area(GTK_DIALOG(win)); - - lbl = gtk_label_new("Video options will not take\neffect until the emulator is restarted."); - + + vbox = gtk_dialog_get_content_area (GTK_DIALOG (win)); + + lbl = gtk_label_new + ("Video options will not take\neffect until the emulator is restarted."); + // scalar widgets - hbox1 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); - scalerLbl = gtk_label_new("Special Scaler: "); - scalerCombo = gtk_combo_box_text_new(); + hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3); + scalerLbl = gtk_label_new ("Special Scaler: "); + scalerCombo = gtk_combo_box_text_new (); // -Video Modes Tag- - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(scalerCombo), "none"); - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(scalerCombo), "hq2x"); - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(scalerCombo), "scale2x"); - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(scalerCombo), "NTSC 2x"); - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(scalerCombo), "hq3x"); - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(scalerCombo), "scale3x"); - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(scalerCombo), "prescale2x"); - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(scalerCombo), "prescale3x"); - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(scalerCombo), "prescale4x"); + gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (scalerCombo), + "none"); + gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (scalerCombo), + "hq2x"); + gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (scalerCombo), + "scale2x"); + gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (scalerCombo), + "NTSC 2x"); + gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (scalerCombo), + "hq3x"); + gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (scalerCombo), + "scale3x"); + gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (scalerCombo), + "prescale2x"); + gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (scalerCombo), + "prescale3x"); + gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (scalerCombo), + "prescale4x"); //gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(scalerCombo), "pal"); - + // sync with cfg int buf; - g_config->getOption("SDL.SpecialFilter", &buf); - gtk_combo_box_set_active(GTK_COMBO_BOX(scalerCombo), buf); - - g_signal_connect(scalerCombo, "changed", G_CALLBACK(setScaler), NULL); - gtk_box_pack_start(GTK_BOX(hbox1), scalerLbl, FALSE, FALSE, 5); - gtk_box_pack_start(GTK_BOX(hbox1), scalerCombo, FALSE, FALSE, 5); -#ifdef OPENGL + g_config->getOption ("SDL.SpecialFilter", &buf); + gtk_combo_box_set_active (GTK_COMBO_BOX (scalerCombo), buf); + + g_signal_connect (scalerCombo, "changed", G_CALLBACK (setScaler), NULL); + gtk_box_pack_start (GTK_BOX (hbox1), scalerLbl, FALSE, FALSE, 5); + gtk_box_pack_start (GTK_BOX (hbox1), scalerCombo, FALSE, FALSE, 5); +#ifdef OPENGL // openGL check - glChk = gtk_check_button_new_with_label("Enable OpenGL"); - g_signal_connect(glChk, "clicked", G_CALLBACK(setGl), NULL); - setCheckbox(glChk, "SDL.OpenGL"); - + glChk = gtk_check_button_new_with_label ("Enable OpenGL"); + g_signal_connect (glChk, "clicked", G_CALLBACK (setGl), NULL); + setCheckbox (glChk, "SDL.OpenGL"); + // openGL linear filter check - linearChk = gtk_check_button_new_with_label("Enable OpenGL linear filter"); - g_signal_connect(linearChk, "clicked", G_CALLBACK(toggleOption), (gpointer)"SDL.OpenGLip"); - setCheckbox(linearChk, "SDL.OpenGLip"); - + linearChk = + gtk_check_button_new_with_label ("Enable OpenGL linear filter"); + g_signal_connect (linearChk, "clicked", G_CALLBACK (toggleOption), + (gpointer) "SDL.OpenGLip"); + setCheckbox (linearChk, "SDL.OpenGLip"); + // DoubleBuffering check - dbChk = gtk_check_button_new_with_label("Enable double buffering"); - g_signal_connect(dbChk, "clicked", G_CALLBACK(setDoubleBuffering), NULL); - setCheckbox(dbChk, "SDL.DoubleBuffering"); + dbChk = gtk_check_button_new_with_label ("Enable double buffering"); + g_signal_connect (dbChk, "clicked", G_CALLBACK (setDoubleBuffering), + NULL); + setCheckbox (dbChk, "SDL.DoubleBuffering"); #endif - + // Region (NTSC/PAL/Dendy) - palHbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); - palLbl = gtk_label_new("Region: "); - palCombo = gtk_combo_box_text_new(); + palHbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3); + palLbl = gtk_label_new ("Region: "); + palCombo = gtk_combo_box_text_new (); // -Video Modes Tag- - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(palCombo), "NTSC"); - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(palCombo), "PAL"); - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(palCombo), "Dendy"); + gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (palCombo), "NTSC"); + gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (palCombo), "PAL"); + gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (palCombo), "Dendy"); // sync with cfg - g_config->getOption("SDL.PAL", &buf); - gtk_combo_box_set_active(GTK_COMBO_BOX(palCombo), buf); - - g_signal_connect(palCombo, "changed", G_CALLBACK(setRegion), NULL); - gtk_box_pack_start(GTK_BOX(palHbox), palLbl, FALSE, FALSE, 5); - gtk_box_pack_start(GTK_BOX(palHbox), palCombo, FALSE, FALSE, 5); + g_config->getOption ("SDL.PAL", &buf); + gtk_combo_box_set_active (GTK_COMBO_BOX (palCombo), buf); + + g_signal_connect (palCombo, "changed", G_CALLBACK (setRegion), NULL); + gtk_box_pack_start (GTK_BOX (palHbox), palLbl, FALSE, FALSE, 5); + gtk_box_pack_start (GTK_BOX (palHbox), palCombo, FALSE, FALSE, 5); // New PPU check - ppuChk = gtk_check_button_new_with_label("Enable new PPU"); - g_signal_connect(ppuChk, "clicked", G_CALLBACK(toggleOption), (gpointer)"SDL.NewPPU"); - setCheckbox(ppuChk, "SDL.NewPPU"); + ppuChk = gtk_check_button_new_with_label ("Enable new PPU"); + g_signal_connect (ppuChk, "clicked", G_CALLBACK (toggleOption), + (gpointer) "SDL.NewPPU"); + setCheckbox (ppuChk, "SDL.NewPPU"); // "disable 8 sprite limit" check - spriteLimitChk = gtk_check_button_new_with_label("Disable sprite limit"); - g_signal_connect(spriteLimitChk, "clicked", G_CALLBACK(toggleOption), (gpointer)"SDL.DisableSpriteLimit"); - setCheckbox(spriteLimitChk, "SDL.DisableSpriteLimit"); - + spriteLimitChk = + gtk_check_button_new_with_label ("Disable sprite limit"); + g_signal_connect (spriteLimitChk, "clicked", G_CALLBACK (toggleOption), + (gpointer) "SDL.DisableSpriteLimit"); + setCheckbox (spriteLimitChk, "SDL.DisableSpriteLimit"); + // frameskip check - frameskipChk = gtk_check_button_new_with_label("Enable frameskip"); - g_signal_connect(frameskipChk, "clicked", G_CALLBACK(toggleOption), (gpointer)"SDL.Frameskip"); - setCheckbox(frameskipChk, "SDL.Frameskip"); + frameskipChk = gtk_check_button_new_with_label ("Enable frameskip"); + g_signal_connect (frameskipChk, "clicked", G_CALLBACK (toggleOption), + (gpointer) "SDL.Frameskip"); + setCheckbox (frameskipChk, "SDL.Frameskip"); // clip sides check - clipSidesChk = gtk_check_button_new_with_label("Clip sides"); - g_signal_connect(clipSidesChk, "clicked", G_CALLBACK(toggleOption), (gpointer)"SDL.ClipSides"); - setCheckbox(clipSidesChk, "SDL.ClipSides"); - + clipSidesChk = gtk_check_button_new_with_label ("Clip sides"); + g_signal_connect (clipSidesChk, "clicked", G_CALLBACK (toggleOption), + (gpointer) "SDL.ClipSides"); + setCheckbox (clipSidesChk, "SDL.ClipSides"); + // xscale / yscale - xscaleHbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); - xscaleLbl = gtk_label_new("X scaling factor"); - xscaleSpin = gtk_spin_button_new_with_range(1.0, 40.0, .1); - yscaleHbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); - yscaleLbl = gtk_label_new("Y scaling factor"); - yscaleSpin = gtk_spin_button_new_with_range(1.0, 40.0, .1); - - gtk_box_pack_start(GTK_BOX(xscaleHbox), xscaleLbl, FALSE, FALSE, 2); - gtk_box_pack_start(GTK_BOX(xscaleHbox), xscaleSpin, FALSE, FALSE, 2); - gtk_box_pack_start(GTK_BOX(yscaleHbox), yscaleLbl, FALSE, FALSE, 2); - gtk_box_pack_start(GTK_BOX(yscaleHbox), yscaleSpin, FALSE, FALSE, 2); - - g_signal_connect(xscaleSpin, "value-changed", G_CALLBACK(setXscale), NULL); - g_signal_connect(yscaleSpin, "value-changed", G_CALLBACK(setYscale), NULL); - + xscaleHbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5); + xscaleLbl = gtk_label_new ("X scaling factor"); + xscaleSpin = gtk_spin_button_new_with_range (1.0, 40.0, .1); + yscaleHbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5); + yscaleLbl = gtk_label_new ("Y scaling factor"); + yscaleSpin = gtk_spin_button_new_with_range (1.0, 40.0, .1); + + gtk_box_pack_start (GTK_BOX (xscaleHbox), xscaleLbl, FALSE, FALSE, 2); + gtk_box_pack_start (GTK_BOX (xscaleHbox), xscaleSpin, FALSE, FALSE, 2); + gtk_box_pack_start (GTK_BOX (yscaleHbox), yscaleLbl, FALSE, FALSE, 2); + gtk_box_pack_start (GTK_BOX (yscaleHbox), yscaleSpin, FALSE, FALSE, 2); + + g_signal_connect (xscaleSpin, "value-changed", G_CALLBACK (setXscale), + NULL); + g_signal_connect (yscaleSpin, "value-changed", G_CALLBACK (setYscale), + NULL); + double f; // sync with config - g_config->getOption("SDL.XScale", &f); - gtk_spin_button_set_value(GTK_SPIN_BUTTON(xscaleSpin), f); - g_config->getOption("SDL.YScale", &f); - gtk_spin_button_set_value(GTK_SPIN_BUTTON(yscaleSpin), f); + g_config->getOption ("SDL.XScale", &f); + gtk_spin_button_set_value (GTK_SPIN_BUTTON (xscaleSpin), f); + g_config->getOption ("SDL.YScale", &f); + gtk_spin_button_set_value (GTK_SPIN_BUTTON (yscaleSpin), f); // show FPS check - showFpsChk = gtk_check_button_new_with_label("Show FPS"); - g_signal_connect(showFpsChk, "clicked", G_CALLBACK(toggleOption), (gpointer)"SDL.ShowFPS"); - setCheckbox(showFpsChk, "SDL.ShowFPS"); + showFpsChk = gtk_check_button_new_with_label ("Show FPS"); + g_signal_connect (showFpsChk, "clicked", G_CALLBACK (toggleOption), + (gpointer) "SDL.ShowFPS"); + setCheckbox (showFpsChk, "SDL.ShowFPS"); - gtk_box_pack_start(GTK_BOX(vbox), lbl, FALSE, FALSE, 5); - gtk_box_pack_start(GTK_BOX(vbox), hbox1, FALSE, FALSE, 5); + gtk_box_pack_start (GTK_BOX (vbox), lbl, FALSE, FALSE, 5); + gtk_box_pack_start (GTK_BOX (vbox), hbox1, FALSE, FALSE, 5); #ifdef OPENGL - gtk_box_pack_start(GTK_BOX(vbox), glChk, FALSE, FALSE, 5); - gtk_box_pack_start(GTK_BOX(vbox), linearChk, FALSE, FALSE, 5); - gtk_box_pack_start(GTK_BOX(vbox), dbChk, FALSE, FALSE, 5); + gtk_box_pack_start (GTK_BOX (vbox), glChk, FALSE, FALSE, 5); + gtk_box_pack_start (GTK_BOX (vbox), linearChk, FALSE, FALSE, 5); + gtk_box_pack_start (GTK_BOX (vbox), dbChk, FALSE, FALSE, 5); #endif - gtk_box_pack_start(GTK_BOX(vbox), palHbox, FALSE, FALSE,5); - gtk_box_pack_start(GTK_BOX(vbox), ppuChk, FALSE, FALSE, 5); + gtk_box_pack_start (GTK_BOX (vbox), palHbox, FALSE, FALSE, 5); + gtk_box_pack_start (GTK_BOX (vbox), ppuChk, FALSE, FALSE, 5); #ifdef FRAMESKIP - gtk_box_pack_start(GTK_BOX(vbox), frameskipChk, FALSE, FALSE, 5); -#endif - gtk_box_pack_start(GTK_BOX(vbox), spriteLimitChk, FALSE, FALSE, 5); - gtk_box_pack_start(GTK_BOX(vbox), clipSidesChk, FALSE, FALSE, 5); - gtk_box_pack_start(GTK_BOX(vbox), xscaleHbox, FALSE, FALSE, 5); - gtk_box_pack_start(GTK_BOX(vbox), yscaleHbox, FALSE, FALSE, 5); - gtk_box_pack_start(GTK_BOX(vbox), showFpsChk, FALSE, FALSE, 5); - - g_signal_connect(win, "delete-event", G_CALLBACK(closeVideoWin), NULL); - g_signal_connect(win, "response", G_CALLBACK(closeVideoWin), NULL); - - gtk_widget_show_all(win); - + gtk_box_pack_start (GTK_BOX (vbox), frameskipChk, FALSE, FALSE, 5); +#endif + gtk_box_pack_start (GTK_BOX (vbox), spriteLimitChk, FALSE, FALSE, 5); + gtk_box_pack_start (GTK_BOX (vbox), clipSidesChk, FALSE, FALSE, 5); + gtk_box_pack_start (GTK_BOX (vbox), xscaleHbox, FALSE, FALSE, 5); + gtk_box_pack_start (GTK_BOX (vbox), yscaleHbox, FALSE, FALSE, 5); + gtk_box_pack_start (GTK_BOX (vbox), showFpsChk, FALSE, FALSE, 5); + + g_signal_connect (win, "delete-event", G_CALLBACK (closeVideoWin), + NULL); + g_signal_connect (win, "response", G_CALLBACK (closeVideoWin), NULL); + + gtk_widget_show_all (win); + return; } -const char* mixerStrings[6] = {"Volume", "Triangle", "Square1", "Square2", "Noise", "PCM"}; +const char *mixerStrings[6] = + { "Volume", "Triangle", "Square1", "Square2", "Noise", "PCM" }; -int mixerChanged(GtkWidget* w, gpointer p) +int mixerChanged (GtkWidget * w, gpointer p) { - int v = gtk_range_get_value(GTK_RANGE(w)); - GtkWidget* parent = gtk_widget_get_parent(w); - char* lbl = (char*)gtk_frame_get_label(GTK_FRAME(parent)); - if(strcmp(lbl, "Volume") == 0) + int v = gtk_range_get_value (GTK_RANGE (w)); + GtkWidget *parent = gtk_widget_get_parent (w); + char *lbl = (char *) gtk_frame_get_label (GTK_FRAME (parent)); + if (strcmp (lbl, "Volume") == 0) { - g_config->setOption("SDL.Sound.Volume", v); - FCEUI_SetSoundVolume(v); + g_config->setOption ("SDL.Sound.Volume", v); + FCEUI_SetSoundVolume (v); } - if(strcmp(lbl, "Triangle") == 0) + if (strcmp (lbl, "Triangle") == 0) { - g_config->setOption("SDL.Sound.TriangleVolume", v); - FCEUI_SetTriangleVolume(v); + g_config->setOption ("SDL.Sound.TriangleVolume", v); + FCEUI_SetTriangleVolume (v); } - if(strcmp(lbl, "Square1") == 0) + if (strcmp (lbl, "Square1") == 0) { - g_config->setOption("SDL.Sound.Square1Volume", v); - FCEUI_SetSquare1Volume(v); + g_config->setOption ("SDL.Sound.Square1Volume", v); + FCEUI_SetSquare1Volume (v); } - if(strcmp(lbl, "Square2") == 0) + if (strcmp (lbl, "Square2") == 0) { - g_config->setOption("SDL.Sound.Square2Volume", v); - FCEUI_SetSquare2Volume(v); + g_config->setOption ("SDL.Sound.Square2Volume", v); + FCEUI_SetSquare2Volume (v); } - if(strcmp(lbl, "Noise") == 0) + if (strcmp (lbl, "Noise") == 0) { - g_config->setOption("SDL.Sound.NoiseVolume", v); - FCEUI_SetNoiseVolume(v); + g_config->setOption ("SDL.Sound.NoiseVolume", v); + FCEUI_SetNoiseVolume (v); } - if(strcmp(lbl, "PCM") == 0) + if (strcmp (lbl, "PCM") == 0) { - g_config->setOption("SDL.Sound.PCMVolume", v); - FCEUI_SetPCMVolume(v); + g_config->setOption ("SDL.Sound.PCMVolume", v); + FCEUI_SetPCMVolume (v); } - + return 0; } -void openSoundConfig(void) +void openSoundConfig (void) { - GtkWidget* win; - GtkWidget* main_hbox; - GtkWidget* vbox; - GtkWidget* soundChk; - GtkWidget* lowpassChk; - GtkWidget* hbox1; - GtkWidget* qualityCombo; - GtkWidget* qualityLbl; - GtkWidget* hbox2; - GtkWidget* rateCombo; - GtkWidget* rateLbl; - GtkWidget* bufferLbl; - GtkWidget* bufferHscale; - GtkWidget* swapDutyChk; - GtkWidget* mixerFrame; - GtkWidget* mixerHbox; - GtkWidget* mixers[6]; - GtkWidget* mixerFrames[6]; + GtkWidget *win; + GtkWidget *main_hbox; + GtkWidget *vbox; + GtkWidget *soundChk; + GtkWidget *lowpassChk; + GtkWidget *hbox1; + GtkWidget *qualityCombo; + GtkWidget *qualityLbl; + GtkWidget *hbox2; + GtkWidget *rateCombo; + GtkWidget *rateLbl; + GtkWidget *bufferLbl; + GtkWidget *bufferHscale; + GtkWidget *swapDutyChk; + GtkWidget *mixerFrame; + GtkWidget *mixerHbox; + GtkWidget *mixers[6]; + GtkWidget *mixerFrames[6]; - win = gtk_dialog_new_with_buttons("Sound Preferences", - GTK_WINDOW(MainWindow), - (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT), - "_Close", - GTK_RESPONSE_OK, - NULL); - gtk_window_set_icon_name(GTK_WINDOW(win), "audio-x-generic"); - main_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 15); - vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); + win = gtk_dialog_new_with_buttons ("Sound Preferences", + GTK_WINDOW (MainWindow), + (GtkDialogFlags) + (GTK_DIALOG_DESTROY_WITH_PARENT), + "_Close", GTK_RESPONSE_OK, NULL); + gtk_window_set_icon_name (GTK_WINDOW (win), "audio-x-generic"); + main_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 15); + vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5); // sound enable check - soundChk = gtk_check_button_new_with_label("Enable sound"); - g_signal_connect(soundChk, "clicked", G_CALLBACK(toggleSound), NULL); - setCheckbox(soundChk,"SDL.Sound"); + soundChk = gtk_check_button_new_with_label ("Enable sound"); + g_signal_connect (soundChk, "clicked", G_CALLBACK (toggleSound), NULL); + setCheckbox (soundChk, "SDL.Sound"); // low pass filter check - lowpassChk = gtk_check_button_new_with_label("Enable low pass filter"); - g_signal_connect(lowpassChk, "clicked", G_CALLBACK(toggleLowPass), NULL); - setCheckbox(lowpassChk, "SDL.Sound.LowPass"); - + lowpassChk = gtk_check_button_new_with_label ("Enable low pass filter"); + g_signal_connect (lowpassChk, "clicked", G_CALLBACK (toggleLowPass), + NULL); + setCheckbox (lowpassChk, "SDL.Sound.LowPass"); + // sound quality combo box - hbox1 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); - qualityCombo = gtk_combo_box_text_new(); - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(qualityCombo), "Low"); - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(qualityCombo), "High"); - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(qualityCombo), "Very High"); + hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3); + qualityCombo = gtk_combo_box_text_new (); + gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (qualityCombo), + "Low"); + gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (qualityCombo), + "High"); + gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (qualityCombo), + "Very High"); // sync widget with cfg int buf; - g_config->getOption("SDL.Sound.Quality", &buf); - gtk_combo_box_set_active(GTK_COMBO_BOX(qualityCombo), buf); - - g_signal_connect(qualityCombo, "changed", G_CALLBACK(setQuality), NULL); - - qualityLbl = gtk_label_new("Quality: "); - - gtk_box_pack_start(GTK_BOX(hbox1), qualityLbl, FALSE, FALSE, 5); - gtk_box_pack_start(GTK_BOX(hbox1), qualityCombo, FALSE, FALSE, 5); - + g_config->getOption ("SDL.Sound.Quality", &buf); + gtk_combo_box_set_active (GTK_COMBO_BOX (qualityCombo), buf); + + g_signal_connect (qualityCombo, "changed", G_CALLBACK (setQuality), + NULL); + + qualityLbl = gtk_label_new ("Quality: "); + + gtk_box_pack_start (GTK_BOX (hbox1), qualityLbl, FALSE, FALSE, 5); + gtk_box_pack_start (GTK_BOX (hbox1), qualityCombo, FALSE, FALSE, 5); + // sound rate widgets - hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); - rateCombo = gtk_combo_box_text_new(); - - const int rates[5] = {11025, 22050, 44100, 48000, 96000}; - + hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3); + rateCombo = gtk_combo_box_text_new (); + + const int rates[5] = { 11025, 22050, 44100, 48000, 96000 }; + char choices[8]; - for(int i=0; i<5;i++) + for (int i = 0; i < 5; i++) { - sprintf(choices, "%d", rates[i]); - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(rateCombo), choices); + sprintf (choices, "%d", rates[i]); + gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (rateCombo), + choices); } - - // sync widget with cfg - g_config->getOption("SDL.Sound.Rate", &buf); - for(int i=0; i<5; i++) - if(buf == rates[i]) - gtk_combo_box_set_active(GTK_COMBO_BOX(rateCombo), i); - - g_signal_connect(rateCombo, "changed", G_CALLBACK(setRate), NULL); - - // sound rate widgets - rateLbl = gtk_label_new("Rate (Hz): "); - - gtk_box_pack_start(GTK_BOX(hbox2), rateLbl, FALSE, FALSE, 5); - gtk_box_pack_start(GTK_BOX(hbox2), rateCombo, FALSE, FALSE, 5); - - bufferHscale = gtk_scale_new_with_range( GTK_ORIENTATION_HORIZONTAL, 15, 200, 2); - bufferLbl = gtk_label_new("Buffer size (in ms)"); // sync widget with cfg - g_config->getOption("SDL.Sound.BufSize", &buf); - gtk_range_set_value(GTK_RANGE(bufferHscale), buf); - - g_signal_connect(bufferHscale, "button-release-event", G_CALLBACK(setBufSize), NULL); + g_config->getOption ("SDL.Sound.Rate", &buf); + for (int i = 0; i < 5; i++) + if (buf == rates[i]) + gtk_combo_box_set_active (GTK_COMBO_BOX (rateCombo), i); + + g_signal_connect (rateCombo, "changed", G_CALLBACK (setRate), NULL); + + // sound rate widgets + rateLbl = gtk_label_new ("Rate (Hz): "); + + gtk_box_pack_start (GTK_BOX (hbox2), rateLbl, FALSE, FALSE, 5); + gtk_box_pack_start (GTK_BOX (hbox2), rateCombo, FALSE, FALSE, 5); + + bufferHscale = + gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 15, 200, + 2); + bufferLbl = gtk_label_new ("Buffer size (in ms)"); + + // sync widget with cfg + g_config->getOption ("SDL.Sound.BufSize", &buf); + gtk_range_set_value (GTK_RANGE (bufferHscale), buf); + + g_signal_connect (bufferHscale, "button-release-event", + G_CALLBACK (setBufSize), NULL); // Swap duty cycles - swapDutyChk = gtk_check_button_new_with_label("Swap Duty Cycles"); - g_signal_connect(swapDutyChk, "clicked", G_CALLBACK(toggleSwapDuty), NULL); - setCheckbox(swapDutyChk, "SDL.SwapDuty"); + swapDutyChk = gtk_check_button_new_with_label ("Swap Duty Cycles"); + g_signal_connect (swapDutyChk, "clicked", G_CALLBACK (toggleSwapDuty), + NULL); + setCheckbox (swapDutyChk, "SDL.SwapDuty"); // mixer - mixerFrame = gtk_frame_new("Mixer:"); - mixerHbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); - for(long int i=0; i<6; i++) + mixerFrame = gtk_frame_new ("Mixer:"); + mixerHbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5); + for (long int i = 0; i < 6; i++) { - mixers[i] = gtk_scale_new_with_range( GTK_ORIENTATION_VERTICAL, 0, 256, 1); - gtk_range_set_inverted(GTK_RANGE(mixers[i]), TRUE); - mixerFrames[i] = gtk_frame_new(mixerStrings[i]); - gtk_container_add(GTK_CONTAINER(mixerFrames[i]), mixers[i]); - gtk_box_pack_start(GTK_BOX(mixerHbox), mixerFrames[i], FALSE, TRUE, 5); - g_signal_connect(mixers[i], "button-release-event", G_CALLBACK(mixerChanged), (gpointer)i); + mixers[i] = + gtk_scale_new_with_range (GTK_ORIENTATION_VERTICAL, 0, + 256, 1); + gtk_range_set_inverted (GTK_RANGE (mixers[i]), TRUE); + mixerFrames[i] = gtk_frame_new (mixerStrings[i]); + gtk_container_add (GTK_CONTAINER (mixerFrames[i]), mixers[i]); + gtk_box_pack_start (GTK_BOX (mixerHbox), mixerFrames[i], FALSE, + TRUE, 5); + g_signal_connect (mixers[i], "button-release-event", + G_CALLBACK (mixerChanged), (gpointer) i); } - + // sync with cfg int v; - g_config->getOption("SDL.Sound.Volume", &v); - gtk_range_set_value(GTK_RANGE(mixers[0]), v); - g_config->getOption("SDL.Sound.TriangleVolume", &v); - gtk_range_set_value(GTK_RANGE(mixers[1]), v); - g_config->getOption("SDL.Sound.Square1Volume", &v); - gtk_range_set_value(GTK_RANGE(mixers[2]), v); - g_config->getOption("SDL.Sound.Square2Volume", &v); - gtk_range_set_value(GTK_RANGE(mixers[3]), v); - g_config->getOption("SDL.Sound.NoiseVolume", &v); - gtk_range_set_value(GTK_RANGE(mixers[4]), v); - g_config->getOption("SDL.Sound.PCMVolume", &v); - gtk_range_set_value(GTK_RANGE(mixers[5]), v); + g_config->getOption ("SDL.Sound.Volume", &v); + gtk_range_set_value (GTK_RANGE (mixers[0]), v); + g_config->getOption ("SDL.Sound.TriangleVolume", &v); + gtk_range_set_value (GTK_RANGE (mixers[1]), v); + g_config->getOption ("SDL.Sound.Square1Volume", &v); + gtk_range_set_value (GTK_RANGE (mixers[2]), v); + g_config->getOption ("SDL.Sound.Square2Volume", &v); + gtk_range_set_value (GTK_RANGE (mixers[3]), v); + g_config->getOption ("SDL.Sound.NoiseVolume", &v); + gtk_range_set_value (GTK_RANGE (mixers[4]), v); + g_config->getOption ("SDL.Sound.PCMVolume", &v); + gtk_range_set_value (GTK_RANGE (mixers[5]), v); + - // packing some boxes - - gtk_box_pack_start(GTK_BOX(main_hbox), vbox, FALSE, TRUE, 5); - gtk_box_pack_start(GTK_BOX(vbox), soundChk, FALSE, FALSE, 5); - gtk_box_pack_start(GTK_BOX(vbox), lowpassChk, FALSE, FALSE, 5); - gtk_box_pack_start(GTK_BOX(vbox), hbox1, FALSE, FALSE, 5); - gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, 5); - gtk_box_pack_start(GTK_BOX(vbox), bufferLbl, FALSE, FALSE, 5); - gtk_box_pack_start(GTK_BOX(vbox), bufferHscale, FALSE, TRUE, 5); - gtk_box_pack_start(GTK_BOX(vbox), swapDutyChk, FALSE, TRUE, 5); - gtk_box_pack_start(GTK_BOX(main_hbox), mixerFrame, TRUE, TRUE, 5); - gtk_container_add(GTK_CONTAINER(mixerFrame), mixerHbox); - - gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(win))), main_hbox, TRUE, TRUE, 0); - - g_signal_connect(win, "delete-event", G_CALLBACK(closeDialog), NULL); - g_signal_connect(win, "response", G_CALLBACK(closeDialog), NULL); - - gtk_widget_show_all(win); - + + gtk_box_pack_start (GTK_BOX (main_hbox), vbox, FALSE, TRUE, 5); + gtk_box_pack_start (GTK_BOX (vbox), soundChk, FALSE, FALSE, 5); + gtk_box_pack_start (GTK_BOX (vbox), lowpassChk, FALSE, FALSE, 5); + gtk_box_pack_start (GTK_BOX (vbox), hbox1, FALSE, FALSE, 5); + gtk_box_pack_start (GTK_BOX (vbox), hbox2, FALSE, FALSE, 5); + gtk_box_pack_start (GTK_BOX (vbox), bufferLbl, FALSE, FALSE, 5); + gtk_box_pack_start (GTK_BOX (vbox), bufferHscale, FALSE, TRUE, 5); + gtk_box_pack_start (GTK_BOX (vbox), swapDutyChk, FALSE, TRUE, 5); + gtk_box_pack_start (GTK_BOX (main_hbox), mixerFrame, TRUE, TRUE, 5); + gtk_container_add (GTK_CONTAINER (mixerFrame), mixerHbox); + + gtk_box_pack_start (GTK_BOX + (gtk_dialog_get_content_area (GTK_DIALOG (win))), + main_hbox, TRUE, TRUE, 0); + + g_signal_connect (win, "delete-event", G_CALLBACK (closeDialog), NULL); + g_signal_connect (win, "response", G_CALLBACK (closeDialog), NULL); + + gtk_widget_show_all (win); + return; } void quit (void) { // manually flush GTK event queue - while(gtk_events_pending()) - gtk_main_iteration_do(FALSE); + while (gtk_events_pending ()) + gtk_main_iteration_do (FALSE); - if (surface) - { - cairo_surface_destroy (surface); - surface = NULL; - } + if (surface) + { + cairo_surface_destroy (surface); + surface = NULL; + } // this is not neccesary to be explicitly called // it raises a GTK-Critical when its called //gtk_main_quit(); - FCEUI_CloseGame(); - FCEUI_Kill(); + FCEUI_CloseGame (); + FCEUI_Kill (); // LoadGame() checks for an IP and if it finds one begins a network session // clear the NetworkIP field so this doesn't happen unintentionally - g_config->setOption("SDL.NetworkIP", ""); - g_config->save(); - SDL_Quit(); - exit(0); + g_config->setOption ("SDL.NetworkIP", ""); + g_config->save (); + SDL_Quit (); + exit (0); } -const char* Authors[]= { + +const char *Authors[] = { "Linux/SDL Developers:", - " Lukas Sabota //punkrockguy318", " Soules", " Bryan Cain", " radsaq", " Shinydoofy", + " Lukas Sabota //punkrockguy318", " Soules", " Bryan Cain", " radsaq", + " Shinydoofy", "FceuX 2.0 Developers:", " SP", " zeromus", " adelikat", " caH4e3", " qfox", - " Luke Gustafson", " _mz", " UncombedCoconut", " DwEdit", " AnS", "rainwarrior", "feos", + " Luke Gustafson", " _mz", " UncombedCoconut", " DwEdit", " AnS", + "rainwarrior", "feos", "Pre 2.0 Guys:", " Bero", " Xodnizel", " Aaron Oneal", " Joe Nahmias", - " Paul Kuliniewicz", " Quietust", " Ben Parnell", " Parasyte & bbitmaster", + " Paul Kuliniewicz", " Quietust", " Ben Parnell", + " Parasyte & bbitmaster", " blip & nitsuja", "Included components:", - " Mitsutaka Okazaki - YM2413 emulator", " Andrea Mazzoleni - Scale2x/Scale3x scalers", " Gilles Vollant - unzip.c PKZIP fileio", - NULL}; + " Mitsutaka Okazaki - YM2413 emulator", + " Andrea Mazzoleni - Scale2x/Scale3x scalers", + " Gilles Vollant - unzip.c PKZIP fileio", + NULL +}; void openAbout (void) { - GdkPixbuf* logo = gdk_pixbuf_new_from_xpm_data(icon_xpm); - - gtk_show_about_dialog(GTK_WINDOW(MainWindow), - "program-name", "fceuX", - "version", FCEU_VERSION_STRING, - "copyright", "© 2016 FceuX development team", - "license", "GPL-2; See COPYING", - //"license-type", GTK_LICENSE_GPL_2_0, - "website", "http://fceux.com", - "authors", Authors, - "logo", logo, NULL); + GdkPixbuf *logo = gdk_pixbuf_new_from_xpm_data (icon_xpm); + + gtk_show_about_dialog (GTK_WINDOW (MainWindow), + "program-name", "fceuX", + "version", FCEU_VERSION_STRING, + "copyright", "© 2016 FceuX development team", + "license", "GPL-2; See COPYING", + //"license-type", GTK_LICENSE_GPL_2_0, + "website", "http://fceux.com", + "authors", Authors, "logo", logo, NULL); } -void toggleSound(GtkWidget* check, gpointer data) +void toggleSound (GtkWidget * check, gpointer data) { - if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check))) + if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (check))) { int last_soundopt; - g_config->getOption("SDL.Sound", &last_soundopt); - g_config->setOption("SDL.Sound", 1); - if(GameInfo && !last_soundopt) - InitSound(); + g_config->getOption ("SDL.Sound", &last_soundopt); + g_config->setOption ("SDL.Sound", 1); + if (GameInfo && !last_soundopt) + InitSound (); } else { - g_config->setOption("SDL.Sound", 0); - KillSound(); + g_config->setOption ("SDL.Sound", 0); + KillSound (); } } void emuReset () { - if(isloaded) - ResetNES(); + if (isloaded) + ResetNES (); } void hardReset () { - if(isloaded) + if (isloaded) { - closeGame(); - const char* lastFile; - g_config->getOption("SDL.LastOpenFile", &lastFile); - LoadGame(lastFile); - resizeGtkWindow(); + closeGame (); + const char *lastFile; + g_config->getOption ("SDL.LastOpenFile", &lastFile); + LoadGame (lastFile); + resizeGtkWindow (); } } void enableFullscreen (void) { - if(isloaded) - ToggleFS(); + if (isloaded) + ToggleFS (); } -void toggleMenuToggling(GtkCheckMenuItem *item, gpointer user_data) +void toggleMenuToggling (GtkCheckMenuItem * item, gpointer user_data) { - bool toggleMenu = gtk_check_menu_item_get_active(item); + bool toggleMenu = gtk_check_menu_item_get_active (item); //printf("ToggleMenu: %i\n", (int)toggleMenu); - g_config->setOption("SDL.ToggleMenu", (int)toggleMenu); + g_config->setOption ("SDL.ToggleMenu", (int) toggleMenu); menuTogglingEnabled = toggleMenu; } -void toggleAutoResume(GtkCheckMenuItem *item, gpointer user_data) +void toggleAutoResume (GtkCheckMenuItem * item, gpointer user_data) { - bool autoResume = gtk_check_menu_item_get_active(item); + bool autoResume = gtk_check_menu_item_get_active (item); //printf("AutoResume: %i\n", (int)autoResume); - g_config->setOption("SDL.AutoResume", (int)autoResume); + g_config->setOption ("SDL.AutoResume", (int) autoResume); AutoResumePlay = autoResume; } -void recordMovie() +void recordMovie () { - if(isloaded) + if (isloaded) { - std::string name = FCEU_MakeFName(FCEUMKF_MOVIE, 0, 0); - FCEUI_printf("Recording movie to %s\n", name.c_str()); - FCEUI_SaveMovie(name.c_str(), MOVIE_FLAG_NONE, L""); + std::string name = FCEU_MakeFName (FCEUMKF_MOVIE, 0, 0); + FCEUI_printf ("Recording movie to %s\n", name.c_str ()); + FCEUI_SaveMovie (name.c_str (), MOVIE_FLAG_NONE, L""); } - + return; } + void recordMovieAs () { - if(!isloaded) + if (!isloaded) { return; } - GtkWidget* fileChooser; - - GtkFileFilter* filterFm2; - GtkFileFilter* filterAll; - - filterFm2 = gtk_file_filter_new(); - gtk_file_filter_add_pattern(filterFm2, "*.fm2"); - gtk_file_filter_set_name(filterFm2, "FM2 Movies"); - - filterAll = gtk_file_filter_new(); - gtk_file_filter_add_pattern(filterAll, "*"); - gtk_file_filter_set_name(filterAll, "All Files"); - - fileChooser = gtk_file_chooser_dialog_new ("Save FM2 movie for recording", GTK_WINDOW(MainWindow), - GTK_FILE_CHOOSER_ACTION_SAVE, "_Cancel", GTK_RESPONSE_CANCEL, - "_Save", GTK_RESPONSE_ACCEPT, NULL); - gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER(fileChooser), ".fm2"); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterFm2); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterAll); - gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fileChooser), getcwd(NULL, 0)); - - if (gtk_dialog_run (GTK_DIALOG (fileChooser)) ==GTK_RESPONSE_ACCEPT) + GtkWidget *fileChooser; + + GtkFileFilter *filterFm2; + GtkFileFilter *filterAll; + + filterFm2 = gtk_file_filter_new (); + gtk_file_filter_add_pattern (filterFm2, "*.fm2"); + gtk_file_filter_set_name (filterFm2, "FM2 Movies"); + + filterAll = gtk_file_filter_new (); + gtk_file_filter_add_pattern (filterAll, "*"); + gtk_file_filter_set_name (filterAll, "All Files"); + + fileChooser = + gtk_file_chooser_dialog_new ("Save FM2 movie for recording", + GTK_WINDOW (MainWindow), + GTK_FILE_CHOOSER_ACTION_SAVE, + "_Cancel", GTK_RESPONSE_CANCEL, + "_Save", GTK_RESPONSE_ACCEPT, + NULL); + gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (fileChooser), + ".fm2"); + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fileChooser), filterFm2); + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fileChooser), filterAll); + gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (fileChooser), + getcwd (NULL, 0)); + + if (gtk_dialog_run (GTK_DIALOG (fileChooser)) == GTK_RESPONSE_ACCEPT) { std::string fname; - - fname = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fileChooser)); - if (!fname.size()) - return; // no filename selected, quit the whole thing - - std::string s = GetUserText("Author name"); - std::wstring author(s.begin(), s.end()); - - FCEUI_SaveMovie(fname.c_str(), MOVIE_FLAG_NONE, author); + fname = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER + (fileChooser)); + if (!fname.size ()) + return; // no filename selected, quit the whole thing + + std::string s = GetUserText ("Author name"); + std::wstring author (s.begin (), s.end ()); + + + FCEUI_SaveMovie (fname.c_str (), MOVIE_FLAG_NONE, author); } gtk_widget_destroy (fileChooser); } void loadMovie (void) { - GtkWidget* fileChooser; - - GtkFileFilter* filterMovies; - GtkFileFilter* filterFm2; - GtkFileFilter* filterAll; + GtkWidget *fileChooser; - filterMovies = gtk_file_filter_new(); - gtk_file_filter_add_pattern(filterMovies, "*.fm2"); - gtk_file_filter_add_pattern(filterMovies, "*.FM2f"); - gtk_file_filter_add_pattern(filterMovies, "*.fm3"); - gtk_file_filter_set_name(filterMovies, "FM2 Movies, TAS Editor Projects"); + GtkFileFilter *filterMovies; + GtkFileFilter *filterFm2; + GtkFileFilter *filterAll; - filterFm2 = gtk_file_filter_new(); - gtk_file_filter_add_pattern(filterFm2, "*.fm2"); - gtk_file_filter_add_pattern(filterFm2, "*.FM2f"); - gtk_file_filter_set_name(filterFm2, "FM2 Movies"); - - filterAll = gtk_file_filter_new(); - gtk_file_filter_add_pattern(filterAll, "*"); - gtk_file_filter_set_name(filterAll, "All Files"); - - fileChooser = gtk_file_chooser_dialog_new ("Open FM2 Movie", GTK_WINDOW(MainWindow), - GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel", GTK_RESPONSE_CANCEL, - "_Open", GTK_RESPONSE_ACCEPT, NULL); - - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterMovies); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterFm2); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterAll); - gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fileChooser), getcwd(NULL, 0)); - - if (gtk_dialog_run (GTK_DIALOG (fileChooser)) ==GTK_RESPONSE_ACCEPT) + filterMovies = gtk_file_filter_new (); + gtk_file_filter_add_pattern (filterMovies, "*.fm2"); + gtk_file_filter_add_pattern (filterMovies, "*.FM2f"); + gtk_file_filter_add_pattern (filterMovies, "*.fm3"); + gtk_file_filter_set_name (filterMovies, + "FM2 Movies, TAS Editor Projects"); + + filterFm2 = gtk_file_filter_new (); + gtk_file_filter_add_pattern (filterFm2, "*.fm2"); + gtk_file_filter_add_pattern (filterFm2, "*.FM2f"); + gtk_file_filter_set_name (filterFm2, "FM2 Movies"); + + filterAll = gtk_file_filter_new (); + gtk_file_filter_add_pattern (filterAll, "*"); + gtk_file_filter_set_name (filterAll, "All Files"); + + fileChooser = + gtk_file_chooser_dialog_new ("Open FM2 Movie", + GTK_WINDOW (MainWindow), + GTK_FILE_CHOOSER_ACTION_OPEN, + "_Cancel", GTK_RESPONSE_CANCEL, + "_Open", GTK_RESPONSE_ACCEPT, + NULL); + + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fileChooser), + filterMovies); + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fileChooser), filterFm2); + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fileChooser), filterAll); + gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (fileChooser), + getcwd (NULL, 0)); + + if (gtk_dialog_run (GTK_DIALOG (fileChooser)) == GTK_RESPONSE_ACCEPT) { - char* fname; - - fname = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fileChooser)); + char *fname; + + fname = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER + (fileChooser)); static int pauseframe; - g_config->getOption("SDL.PauseFrame", &pauseframe); - g_config->setOption("SDL.PauseFrame", 0); - FCEUI_printf("Playing back movie located at %s\n", fname); - if(FCEUI_LoadMovie(fname, false, pauseframe ? pauseframe : false) == FALSE) + g_config->getOption ("SDL.PauseFrame", &pauseframe); + g_config->setOption ("SDL.PauseFrame", 0); + FCEUI_printf ("Playing back movie located at %s\n", fname); + if (FCEUI_LoadMovie + (fname, false, pauseframe ? pauseframe : false) == FALSE) { - GtkWidget* d; - d = gtk_message_dialog_new(GTK_WINDOW(MainWindow), GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, - "Could not open the movie file."); - gtk_dialog_run(GTK_DIALOG(d)); - gtk_widget_destroy(d); + GtkWidget *d; + d = gtk_message_dialog_new (GTK_WINDOW (MainWindow), + GTK_DIALOG_MODAL, + GTK_MESSAGE_ERROR, + GTK_BUTTONS_OK, + "Could not open the movie file."); + gtk_dialog_run (GTK_DIALOG (d)); + gtk_widget_destroy (d); } } gtk_widget_destroy (fileChooser); @@ -1519,49 +1661,61 @@ void loadMovie (void) #ifdef _S9XLUA_H void loadLua (void) { - GtkWidget* fileChooser; - GtkFileFilter* filterLua; - GtkFileFilter* filterAll; - - filterLua = gtk_file_filter_new(); - gtk_file_filter_add_pattern(filterLua, "*.lua"); - gtk_file_filter_add_pattern(filterLua, "*.LUA"); - gtk_file_filter_set_name(filterLua, "Lua scripts"); - - filterAll = gtk_file_filter_new(); - gtk_file_filter_add_pattern(filterAll, "*"); - gtk_file_filter_set_name(filterAll, "All Files"); - - fileChooser = gtk_file_chooser_dialog_new ("Open LUA Script", GTK_WINDOW(MainWindow), - GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel", GTK_RESPONSE_CANCEL, - "_Open", GTK_RESPONSE_ACCEPT, NULL); - - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterLua); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterAll); - const char* last_file; - g_config->getOption("SDL.LastLoadLua", &last_file); - gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(fileChooser), last_file); - - if(strcmp(last_file, "") == 0) - gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fileChooser), "/usr/share/fceux/luaScripts"); - - if (gtk_dialog_run (GTK_DIALOG (fileChooser)) ==GTK_RESPONSE_ACCEPT) + GtkWidget *fileChooser; + GtkFileFilter *filterLua; + GtkFileFilter *filterAll; + + filterLua = gtk_file_filter_new (); + gtk_file_filter_add_pattern (filterLua, "*.lua"); + gtk_file_filter_add_pattern (filterLua, "*.LUA"); + gtk_file_filter_set_name (filterLua, "Lua scripts"); + + filterAll = gtk_file_filter_new (); + gtk_file_filter_add_pattern (filterAll, "*"); + gtk_file_filter_set_name (filterAll, "All Files"); + + fileChooser = + gtk_file_chooser_dialog_new ("Open LUA Script", + GTK_WINDOW (MainWindow), + GTK_FILE_CHOOSER_ACTION_OPEN, + "_Cancel", GTK_RESPONSE_CANCEL, + "_Open", GTK_RESPONSE_ACCEPT, + NULL); + + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fileChooser), filterLua); + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fileChooser), filterAll); + const char *last_file; + g_config->getOption ("SDL.LastLoadLua", &last_file); + gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (fileChooser), + last_file); + + if (strcmp (last_file, "") == 0) + gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER + (fileChooser), + "/usr/share/fceux/luaScripts"); + + if (gtk_dialog_run (GTK_DIALOG (fileChooser)) == GTK_RESPONSE_ACCEPT) { - char* filename; - - filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fileChooser)); - g_config->setOption("SDL.LastLoadLua", filename); - gtk_widget_destroy(fileChooser); - if(FCEU_LoadLuaCode(filename) == 0) + char *filename; + + filename = + gtk_file_chooser_get_filename (GTK_FILE_CHOOSER + (fileChooser)); + g_config->setOption ("SDL.LastLoadLua", filename); + gtk_widget_destroy (fileChooser); + if (FCEU_LoadLuaCode (filename) == 0) { // This is necessary because lua scripts do not use FCEUD_PrintError to print errors. - GtkWidget* d; - d = gtk_message_dialog_new(GTK_WINDOW(MainWindow), GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, - "Could not open the selected lua script."); - gtk_dialog_run(GTK_DIALOG(d)); - gtk_widget_destroy(d); + GtkWidget *d; + d = gtk_message_dialog_new (GTK_WINDOW (MainWindow), + GTK_DIALOG_MODAL, + GTK_MESSAGE_ERROR, + GTK_BUTTONS_OK, + "Could not open the selected lua script."); + gtk_dialog_run (GTK_DIALOG (d)); + gtk_widget_destroy (d); } - g_free(filename); + g_free (filename); } else gtk_widget_destroy (fileChooser); @@ -1571,145 +1725,171 @@ void loadLua (void) void loadFdsBios (void) { - GtkWidget* fileChooser; - GtkFileFilter* filterDiskSys; - GtkFileFilter* filterRom; - GtkFileFilter* filterAll; - - - filterDiskSys = gtk_file_filter_new(); - gtk_file_filter_add_pattern(filterDiskSys, "disksys.rom"); - gtk_file_filter_set_name(filterDiskSys, "disksys.rom"); - - filterRom = gtk_file_filter_new(); - gtk_file_filter_add_pattern(filterRom, "*.rom"); - gtk_file_filter_set_name(filterRom, "*.rom"); - - filterAll = gtk_file_filter_new(); - gtk_file_filter_add_pattern(filterAll, "*"); - gtk_file_filter_set_name(filterAll, "All Files"); - - - fileChooser = gtk_file_chooser_dialog_new ("Load FDS BIOS (disksys.rom)", GTK_WINDOW(MainWindow), - GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel", GTK_RESPONSE_CANCEL, - "_Open", GTK_RESPONSE_ACCEPT, NULL); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterDiskSys); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterRom); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterAll); - gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fileChooser), getcwd(NULL, 0)); - - if (gtk_dialog_run (GTK_DIALOG (fileChooser)) ==GTK_RESPONSE_ACCEPT) + GtkWidget *fileChooser; + GtkFileFilter *filterDiskSys; + GtkFileFilter *filterRom; + GtkFileFilter *filterAll; + + + filterDiskSys = gtk_file_filter_new (); + gtk_file_filter_add_pattern (filterDiskSys, "disksys.rom"); + gtk_file_filter_set_name (filterDiskSys, "disksys.rom"); + + filterRom = gtk_file_filter_new (); + gtk_file_filter_add_pattern (filterRom, "*.rom"); + gtk_file_filter_set_name (filterRom, "*.rom"); + + filterAll = gtk_file_filter_new (); + gtk_file_filter_add_pattern (filterAll, "*"); + gtk_file_filter_set_name (filterAll, "All Files"); + + + fileChooser = + gtk_file_chooser_dialog_new ("Load FDS BIOS (disksys.rom)", + GTK_WINDOW (MainWindow), + GTK_FILE_CHOOSER_ACTION_OPEN, + "_Cancel", GTK_RESPONSE_CANCEL, + "_Open", GTK_RESPONSE_ACCEPT, + NULL); + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fileChooser), + filterDiskSys); + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fileChooser), filterRom); + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fileChooser), filterAll); + gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (fileChooser), + getcwd (NULL, 0)); + + if (gtk_dialog_run (GTK_DIALOG (fileChooser)) == GTK_RESPONSE_ACCEPT) { - char* filename; - filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fileChooser)); + char *filename; + filename = + gtk_file_chooser_get_filename (GTK_FILE_CHOOSER + (fileChooser)); // copy BIOS file to proper place (~/.fceux/disksys.rom) - std::ifstream fdsBios (filename,std::fstream::binary); - std::string output_filename = FCEU_MakeFName(FCEUMKF_FDSROM, 0, ""); - std::ofstream outFile (output_filename.c_str(),std::fstream::trunc|std::fstream::binary); - outFile<setOption("SDL.GameGenie", enabled); - g_config->save(); - FCEUI_SetGameGenie(enabled); + g_config->setOption ("SDL.GameGenie", enabled); + g_config->save (); + FCEUI_SetGameGenie (enabled); } -void toggleGameGenie(GtkCheckMenuItem *item, gpointer userData) +void toggleGameGenie (GtkCheckMenuItem * item, gpointer userData) { - enableGameGenie( gtk_check_menu_item_get_active(item) ); + enableGameGenie (gtk_check_menu_item_get_active (item)); } -void togglePause(GtkMenuItem *item, gpointer userData ) +void togglePause (GtkMenuItem * item, gpointer userData) { SDL_Event sdlev; int paused; - - if(isloaded) + + if (isloaded) { - paused = FCEUI_EmulationPaused(); - + paused = FCEUI_EmulationPaused (); + sdlev.type = SDL_FCEU_HOTKEY_EVENT; sdlev.user.code = HK_PAUSE; - if(SDL_PushEvent(&sdlev) < 0) + if (SDL_PushEvent (&sdlev) < 0) { - FCEU_printf("Failed to push SDL event to %s game.\n", paused ? "resume" : "pause"); + FCEU_printf ("Failed to push SDL event to %s game.\n", + paused ? "resume" : "pause"); return; } - gtk_menu_item_set_label( item, paused ? "Pause" : "Resume"); + gtk_menu_item_set_label (item, paused ? "Pause" : "Resume"); //gtk_action_set_stock_id(action, paused ? GTK_STOCK_MEDIA_PAUSE : GTK_STOCK_MEDIA_PLAY); } } void loadGameGenie () { - GtkWidget* fileChooser; - GtkFileFilter* filterGG; - GtkFileFilter* filterRom; - GtkFileFilter* filterNes; - GtkFileFilter* filterAll; - - - filterGG = gtk_file_filter_new(); - gtk_file_filter_add_pattern(filterGG, "gg.rom"); - gtk_file_filter_set_name(filterGG, "gg.rom"); - - filterRom = gtk_file_filter_new(); - gtk_file_filter_add_pattern(filterRom, "*.rom"); - gtk_file_filter_set_name(filterRom, "*.rom"); - - filterNes = gtk_file_filter_new(); - gtk_file_filter_add_pattern(filterNes, "*.nes"); - gtk_file_filter_set_name(filterNes, "*.nes"); - - filterAll = gtk_file_filter_new(); - gtk_file_filter_add_pattern(filterAll, "*"); - gtk_file_filter_set_name(filterAll, "All Files"); - - - fileChooser = gtk_file_chooser_dialog_new ("Load Game Genie ROM", GTK_WINDOW(MainWindow), - GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel", GTK_RESPONSE_CANCEL, - "_Open", GTK_RESPONSE_ACCEPT, NULL); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterGG); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterRom); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterNes); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterAll); - gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fileChooser), getcwd(NULL, 0)); - - if (gtk_dialog_run (GTK_DIALOG (fileChooser)) ==GTK_RESPONSE_ACCEPT) - { - char* filename; - filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fileChooser)); - // copy file to proper place (~/.fceux/gg.rom) - std::ifstream f1 (filename,std::fstream::binary); - std::string fn_out = FCEU_MakeFName(FCEUMKF_GGROM, 0, ""); - std::ofstream f2 (fn_out.c_str(),std::fstream::trunc|std::fstream::binary); - gtk_widget_destroy (fileChooser); - GtkWidget* d; - enableGameGenie(TRUE); - d = gtk_message_dialog_new(GTK_WINDOW(MainWindow), GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, - "Game Genie ROM copied to: '%s'.", fn_out.c_str()); - gtk_dialog_run(GTK_DIALOG(d)); - gtk_widget_destroy(d); + GtkWidget *fileChooser; + GtkFileFilter *filterGG; + GtkFileFilter *filterRom; + GtkFileFilter *filterNes; + GtkFileFilter *filterAll; - f2<getOption("SDL.LastOpenNSF", &last_dir); - gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(fileChooser), last_dir); - - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterNSF); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterZip); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterAll); - - if (gtk_dialog_run (GTK_DIALOG (fileChooser)) ==GTK_RESPONSE_ACCEPT) + GtkWidget *fileChooser; + GtkFileFilter *filterNSF; + GtkFileFilter *filterZip; + GtkFileFilter *filterAll; + + filterNSF = gtk_file_filter_new (); + filterZip = gtk_file_filter_new (); + gtk_file_filter_add_pattern (filterNSF, "*.nsf"); + gtk_file_filter_add_pattern (filterNSF, "*.NSF"); + gtk_file_filter_add_pattern (filterZip, "*.zip"); + gtk_file_filter_add_pattern (filterZip, "*.ZIP"); + gtk_file_filter_set_name (filterNSF, "NSF sound files"); + gtk_file_filter_set_name (filterZip, "Zip archives"); + + filterAll = gtk_file_filter_new (); + gtk_file_filter_add_pattern (filterAll, "*"); + gtk_file_filter_set_name (filterAll, "All Files"); + + fileChooser = + gtk_file_chooser_dialog_new ("Open NSF File", + GTK_WINDOW (MainWindow), + GTK_FILE_CHOOSER_ACTION_OPEN, + "_Cancel", GTK_RESPONSE_CANCEL, + "_Open", GTK_RESPONSE_ACCEPT, + NULL); + + const char *last_dir; + g_config->getOption ("SDL.LastOpenNSF", &last_dir); + gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (fileChooser), + last_dir); + + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fileChooser), filterNSF); + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fileChooser), filterZip); + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fileChooser), filterAll); + + if (gtk_dialog_run (GTK_DIALOG (fileChooser)) == GTK_RESPONSE_ACCEPT) { - char* filename; - - filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fileChooser)); + char *filename; + + filename = + gtk_file_chooser_get_filename (GTK_FILE_CHOOSER + (fileChooser)); gtk_widget_destroy (fileChooser); - LoadGame(filename); + LoadGame (filename); // no longer required with GTK FCEUD_PrintError implementation /*if(LoadGame(filename) == 0) - { - - GtkWidget* d; - d = gtk_message_dialog_new(GTK_WINDOW(MainWindow), GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, - "Could not open the selected NSF file."); - gtk_dialog_run(GTK_DIALOG(d)); - gtk_widget_destroy(d); - }*/ - g_config->setOption("SDL.LastOpenNSF", filename); - g_free(filename); + { + + GtkWidget* d; + d = gtk_message_dialog_new(GTK_WINDOW(MainWindow), GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, + "Could not open the selected NSF file."); + gtk_dialog_run(GTK_DIALOG(d)); + gtk_widget_destroy(d); + } */ + g_config->setOption ("SDL.LastOpenNSF", filename); + g_free (filename); } else gtk_widget_destroy (fileChooser); } -void closeGame(void) +void closeGame (void) { //GdkColor bg = {0, 0, 0, 0}; //gtk_widget_modify_bg(evbox, GTK_STATE_NORMAL, &bg); - CloseGame(); + CloseGame (); } void loadGame (void) { - GtkWidget* fileChooser; - GtkFileFilter* filterFCEU; - GtkFileFilter* filterNes; - GtkFileFilter* filterFds; - GtkFileFilter* filterNSF; - GtkFileFilter* filterZip; - GtkFileFilter* filterAll; - - filterFCEU = gtk_file_filter_new(); - filterNes = gtk_file_filter_new(); - filterFds = gtk_file_filter_new(); - filterNSF = gtk_file_filter_new(); - filterZip = gtk_file_filter_new(); - gtk_file_filter_add_pattern(filterFCEU, "*.nes"); - gtk_file_filter_add_pattern(filterFCEU, "*.NES"); - gtk_file_filter_add_pattern(filterFCEU, "*.fds"); - gtk_file_filter_add_pattern(filterFCEU, "*.FDS"); - gtk_file_filter_add_pattern(filterFCEU, "*.zip"); - gtk_file_filter_add_pattern(filterFCEU, "*.ZIP"); - gtk_file_filter_add_pattern(filterFCEU, "*.Nes"); - gtk_file_filter_add_pattern(filterFCEU, "*.Fds"); - gtk_file_filter_add_pattern(filterFCEU, "*.Zip"); - gtk_file_filter_add_pattern(filterFCEU, "*.nsf"); - gtk_file_filter_add_pattern(filterFCEU, "*.NSF"); - gtk_file_filter_add_pattern(filterNes, "*.nes"); - gtk_file_filter_add_pattern(filterNes, "*.NES"); - gtk_file_filter_add_pattern(filterFds, "*.fds"); - gtk_file_filter_add_pattern(filterFds, "*.FDS"); - gtk_file_filter_add_pattern(filterNSF, "*.nsf"); - gtk_file_filter_add_pattern(filterNSF, "*.NSF"); - gtk_file_filter_add_pattern(filterZip, "*.zip"); - gtk_file_filter_add_pattern(filterZip, "*.zip"); - gtk_file_filter_set_name(filterFCEU, "*.nes;*.fds;*.nsf;*.zip"); - gtk_file_filter_set_name(filterNes, "NES ROM files"); - gtk_file_filter_set_name(filterFds, "FDS ROM files"); - gtk_file_filter_set_name(filterNSF, "NSF sound files"); - gtk_file_filter_set_name(filterZip, "Zip archives"); - - filterAll = gtk_file_filter_new(); - gtk_file_filter_add_pattern(filterAll, "*"); - gtk_file_filter_set_name(filterAll, "All Files"); - - - - fileChooser = gtk_file_chooser_dialog_new ("Open ROM", GTK_WINDOW(MainWindow), - GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel", GTK_RESPONSE_CANCEL, - "_Open", GTK_RESPONSE_ACCEPT, NULL); - const char* last_dir; - g_config->getOption("SDL.LastOpenFile", &last_dir); - gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(fileChooser), last_dir); - - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterFCEU); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterNes); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterFds); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterNSF); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterZip); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterAll); - - if (gtk_dialog_run (GTK_DIALOG (fileChooser)) ==GTK_RESPONSE_ACCEPT) + GtkWidget *fileChooser; + GtkFileFilter *filterFCEU; + GtkFileFilter *filterNes; + GtkFileFilter *filterFds; + GtkFileFilter *filterNSF; + GtkFileFilter *filterZip; + GtkFileFilter *filterAll; + + filterFCEU = gtk_file_filter_new (); + filterNes = gtk_file_filter_new (); + filterFds = gtk_file_filter_new (); + filterNSF = gtk_file_filter_new (); + filterZip = gtk_file_filter_new (); + gtk_file_filter_add_pattern (filterFCEU, "*.nes"); + gtk_file_filter_add_pattern (filterFCEU, "*.NES"); + gtk_file_filter_add_pattern (filterFCEU, "*.fds"); + gtk_file_filter_add_pattern (filterFCEU, "*.FDS"); + gtk_file_filter_add_pattern (filterFCEU, "*.zip"); + gtk_file_filter_add_pattern (filterFCEU, "*.ZIP"); + gtk_file_filter_add_pattern (filterFCEU, "*.Nes"); + gtk_file_filter_add_pattern (filterFCEU, "*.Fds"); + gtk_file_filter_add_pattern (filterFCEU, "*.Zip"); + gtk_file_filter_add_pattern (filterFCEU, "*.nsf"); + gtk_file_filter_add_pattern (filterFCEU, "*.NSF"); + gtk_file_filter_add_pattern (filterNes, "*.nes"); + gtk_file_filter_add_pattern (filterNes, "*.NES"); + gtk_file_filter_add_pattern (filterFds, "*.fds"); + gtk_file_filter_add_pattern (filterFds, "*.FDS"); + gtk_file_filter_add_pattern (filterNSF, "*.nsf"); + gtk_file_filter_add_pattern (filterNSF, "*.NSF"); + gtk_file_filter_add_pattern (filterZip, "*.zip"); + gtk_file_filter_add_pattern (filterZip, "*.zip"); + gtk_file_filter_set_name (filterFCEU, "*.nes;*.fds;*.nsf;*.zip"); + gtk_file_filter_set_name (filterNes, "NES ROM files"); + gtk_file_filter_set_name (filterFds, "FDS ROM files"); + gtk_file_filter_set_name (filterNSF, "NSF sound files"); + gtk_file_filter_set_name (filterZip, "Zip archives"); + + filterAll = gtk_file_filter_new (); + gtk_file_filter_add_pattern (filterAll, "*"); + gtk_file_filter_set_name (filterAll, "All Files"); + + + + fileChooser = + gtk_file_chooser_dialog_new ("Open ROM", + GTK_WINDOW (MainWindow), + GTK_FILE_CHOOSER_ACTION_OPEN, + "_Cancel", GTK_RESPONSE_CANCEL, + "_Open", GTK_RESPONSE_ACCEPT, + NULL); + const char *last_dir; + g_config->getOption ("SDL.LastOpenFile", &last_dir); + gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (fileChooser), + last_dir); + + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fileChooser), + filterFCEU); + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fileChooser), filterNes); + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fileChooser), filterFds); + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fileChooser), filterNSF); + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fileChooser), filterZip); + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fileChooser), filterAll); + + if (gtk_dialog_run (GTK_DIALOG (fileChooser)) == GTK_RESPONSE_ACCEPT) { - char* filename; - - filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fileChooser)); + char *filename; + + filename = + gtk_file_chooser_get_filename (GTK_FILE_CHOOSER + (fileChooser)); gtk_widget_destroy (fileChooser); - g_config->setOption("SDL.LastOpenFile", filename); - closeGame(); - LoadGame(filename); + g_config->setOption ("SDL.LastOpenFile", filename); + closeGame (); + LoadGame (filename); // Error dialog no longer required with GTK implementation of FCEUD_PrintError() /*if(LoadGame(filename) == 0) - { - - GtkWidget* d; - d = gtk_message_dialog_new(GTK_WINDOW(MainWindow), GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, - "Could not open the selected ROM file."); - gtk_dialog_run(GTK_DIALOG(d)); - gtk_widget_destroy(d); - }*/ - resizeGtkWindow(); - g_free(filename); + { + + GtkWidget* d; + d = gtk_message_dialog_new(GTK_WINDOW(MainWindow), GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, + "Could not open the selected ROM file."); + gtk_dialog_run(GTK_DIALOG(d)); + gtk_widget_destroy(d); + } */ + resizeGtkWindow (); + g_free (filename); } else gtk_widget_destroy (fileChooser); } -void saveStateAs(void) +void saveStateAs (void) { - GtkWidget* fileChooser; - GtkFileFilter* filterSav; - GtkFileFilter* filterAll; - - filterSav = gtk_file_filter_new(); - gtk_file_filter_add_pattern(filterSav, "*.sav"); - gtk_file_filter_add_pattern(filterSav, "*.SAV"); - gtk_file_filter_set_name(filterSav, "SAV files"); - - filterAll = gtk_file_filter_new(); - gtk_file_filter_add_pattern(filterAll, "*"); - gtk_file_filter_set_name(filterAll, "All Files"); - - const char* last_dir; - g_config->getOption("SDL.LastSaveStateAs", &last_dir); - - fileChooser = gtk_file_chooser_dialog_new ("Save State As", GTK_WINDOW(MainWindow), - GTK_FILE_CHOOSER_ACTION_SAVE, "_Cancel", GTK_RESPONSE_CANCEL, - "_Save", GTK_RESPONSE_ACCEPT, NULL); - - gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fileChooser), last_dir); - - gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER(fileChooser), ".sav"); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterSav); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterAll); - - if (gtk_dialog_run (GTK_DIALOG (fileChooser)) ==GTK_RESPONSE_ACCEPT) + GtkWidget *fileChooser; + GtkFileFilter *filterSav; + GtkFileFilter *filterAll; + + filterSav = gtk_file_filter_new (); + gtk_file_filter_add_pattern (filterSav, "*.sav"); + gtk_file_filter_add_pattern (filterSav, "*.SAV"); + gtk_file_filter_set_name (filterSav, "SAV files"); + + filterAll = gtk_file_filter_new (); + gtk_file_filter_add_pattern (filterAll, "*"); + gtk_file_filter_set_name (filterAll, "All Files"); + + const char *last_dir; + g_config->getOption ("SDL.LastSaveStateAs", &last_dir); + + fileChooser = + gtk_file_chooser_dialog_new ("Save State As", + GTK_WINDOW (MainWindow), + GTK_FILE_CHOOSER_ACTION_SAVE, + "_Cancel", GTK_RESPONSE_CANCEL, + "_Save", GTK_RESPONSE_ACCEPT, + NULL); + + gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (fileChooser), + last_dir); + + gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (fileChooser), + ".sav"); + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fileChooser), filterSav); + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fileChooser), filterAll); + + if (gtk_dialog_run (GTK_DIALOG (fileChooser)) == GTK_RESPONSE_ACCEPT) { - char* filename; - - filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fileChooser)); - FCEUI_SaveState(filename); - g_config->setOption("SDL.LastSaveStateAs", filename); - g_free(filename); + char *filename; + + filename = + gtk_file_chooser_get_filename (GTK_FILE_CHOOSER + (fileChooser)); + FCEUI_SaveState (filename); + g_config->setOption ("SDL.LastSaveStateAs", filename); + g_free (filename); } gtk_widget_destroy (fileChooser); - - + + } -void loadStateFrom(void) +void loadStateFrom (void) { - GtkWidget* fileChooser; - GtkFileFilter* filterFcs; - GtkFileFilter* filterSav; - GtkFileFilter* filterAll; - - filterSav = gtk_file_filter_new(); - gtk_file_filter_add_pattern(filterSav, "*.sav"); - gtk_file_filter_add_pattern(filterSav, "*.SAV"); - gtk_file_filter_set_name(filterSav, "SAV files"); - - filterFcs = gtk_file_filter_new(); - gtk_file_filter_add_pattern(filterFcs, "*.fc?"); - gtk_file_filter_add_pattern(filterFcs, "*.FC?"); - gtk_file_filter_set_name(filterFcs, "FCS files"); - - filterAll = gtk_file_filter_new(); - gtk_file_filter_add_pattern(filterAll, "*"); - gtk_file_filter_set_name(filterAll, "All Files"); - - fileChooser = gtk_file_chooser_dialog_new ("Load State From", GTK_WINDOW(MainWindow), - GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel", GTK_RESPONSE_CANCEL, - "_Open", GTK_RESPONSE_ACCEPT, NULL); - - const char* last_dir; - g_config->getOption("SDL.LastLoadStateFrom", &last_dir); - gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(fileChooser), last_dir); + GtkWidget *fileChooser; + GtkFileFilter *filterFcs; + GtkFileFilter *filterSav; + GtkFileFilter *filterAll; - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterFcs); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterSav); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterAll); - - if (gtk_dialog_run (GTK_DIALOG (fileChooser)) ==GTK_RESPONSE_ACCEPT) + filterSav = gtk_file_filter_new (); + gtk_file_filter_add_pattern (filterSav, "*.sav"); + gtk_file_filter_add_pattern (filterSav, "*.SAV"); + gtk_file_filter_set_name (filterSav, "SAV files"); + + filterFcs = gtk_file_filter_new (); + gtk_file_filter_add_pattern (filterFcs, "*.fc?"); + gtk_file_filter_add_pattern (filterFcs, "*.FC?"); + gtk_file_filter_set_name (filterFcs, "FCS files"); + + filterAll = gtk_file_filter_new (); + gtk_file_filter_add_pattern (filterAll, "*"); + gtk_file_filter_set_name (filterAll, "All Files"); + + fileChooser = + gtk_file_chooser_dialog_new ("Load State From", + GTK_WINDOW (MainWindow), + GTK_FILE_CHOOSER_ACTION_OPEN, + "_Cancel", GTK_RESPONSE_CANCEL, + "_Open", GTK_RESPONSE_ACCEPT, + NULL); + + const char *last_dir; + g_config->getOption ("SDL.LastLoadStateFrom", &last_dir); + gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (fileChooser), + last_dir); + + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fileChooser), filterFcs); + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fileChooser), filterSav); + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fileChooser), filterAll); + + if (gtk_dialog_run (GTK_DIALOG (fileChooser)) == GTK_RESPONSE_ACCEPT) { - char* filename; - - filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fileChooser)); - FCEUI_LoadState(filename); - g_config->setOption("SDL.LastLoadStateFrom", filename); - g_free(filename); + char *filename; + + filename = + gtk_file_chooser_get_filename (GTK_FILE_CHOOSER + (fileChooser)); + FCEUI_LoadState (filename); + g_config->setOption ("SDL.LastLoadStateFrom", filename); + g_free (filename); } gtk_widget_destroy (fileChooser); } -void quickLoad(void) +void quickLoad (void) { - FCEUI_LoadState(NULL); + FCEUI_LoadState (NULL); } -void quickSave(void) +void quickSave (void) { - FCEUI_SaveState(NULL); + FCEUI_SaveState (NULL); } //void changeState(GtkAction *action, GtkRadioAction *current, gpointer data) -void changeState(GtkRadioMenuItem *radiomenuitem, - gpointer user_data) +void changeState (GtkRadioMenuItem * radiomenuitem, gpointer user_data) { //printf("Changing State: %li\n", (long)user_data); - FCEUI_SelectState( (long)user_data, 0); + FCEUI_SelectState ((long) user_data, 0); } -#if SDL_VERSION_ATLEAST(2, 0, 0) + +#if SDL_VERSION_ATLEAST(2, 0, 0) // SDL 1.2/2.0 compatibility macros #define SDLK_SCROLLOCK SDLK_SCROLLLOCK #define SDLK_PRINT SDLK_PRINTSCREEN @@ -1992,158 +2202,161 @@ void changeState(GtkRadioMenuItem *radiomenuitem, #define SDLK_RMETA 0 #endif // Adapted from Gens/GS. Converts a GDK key value into an SDL key value. -unsigned short GDKToSDLKeyval(int gdk_key) +unsigned short GDKToSDLKeyval (int gdk_key) { if (!(gdk_key & 0xFF00)) { // ASCII symbol. // SDL and GDK use the same values for these keys. - + // Make sure the key value is lowercase. - gdk_key = tolower(gdk_key); - + gdk_key = tolower (gdk_key); + // Return the key value. return gdk_key; } - + if (gdk_key & 0xFFFF0000) { // Extended X11 key. Not supported by SDL. #ifdef GDK_WINDOWING_X11 - fprintf(stderr, "Unhandled extended X11 key: 0x%08X (%s)", gdk_key, XKeysymToString(gdk_key)); + fprintf (stderr, "Unhandled extended X11 key: 0x%08X (%s)", + gdk_key, XKeysymToString (gdk_key)); #else - fprintf(stderr, "Unhandled extended key: 0x%08X\n", gdk_key); + fprintf (stderr, "Unhandled extended key: 0x%08X\n", gdk_key); #endif return 0; } - + // Non-ASCII symbol. - static const uint16_t gdk_to_sdl_table[0x100] = - { + static const uint16_t gdk_to_sdl_table[0x100] = { // 0x00 - 0x0F 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, SDLK_BACKSPACE, SDLK_TAB, SDLK_RETURN, SDLK_CLEAR, 0x0000, SDLK_RETURN, 0x0000, 0x0000, - + // 0x10 - 0x1F 0x0000, 0x0000, 0x0000, SDLK_PAUSE, SDLK_SCROLLOCK, SDLK_SYSREQ, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, SDLK_ESCAPE, 0x0000, 0x0000, 0x0000, 0x0000, - + // 0x20 - 0x2F SDLK_COMPOSE, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, - + // 0x30 - 0x3F [Japanese keys] 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, - + // 0x40 - 0x4F [unused] 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, - + // 0x50 - 0x5F SDLK_HOME, SDLK_LEFT, SDLK_UP, SDLK_RIGHT, SDLK_DOWN, SDLK_PAGEUP, SDLK_PAGEDOWN, SDLK_END, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, - + // 0x60 - 0x6F 0x0000, SDLK_PRINT, 0x0000, SDLK_INSERT, SDLK_UNDO, 0x0000, 0x0000, SDLK_MENU, 0x0000, SDLK_HELP, SDLK_BREAK, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, - + // 0x70 - 0x7F [mostly unused, except for Alt Gr and Num Lock] 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, SDLK_MODE, SDLK_NUMLOCK, - + // 0x80 - 0x8F [mostly unused, except for some numeric keypad keys] SDLK_KP5, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, SDLK_KP_ENTER, 0x0000, 0x0000, - + // 0x90 - 0x9F 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, SDLK_KP7, SDLK_KP4, SDLK_KP8, SDLK_KP6, SDLK_KP2, SDLK_KP9, SDLK_KP3, SDLK_KP1, SDLK_KP5, SDLK_KP0, SDLK_KP_PERIOD, - + // 0xA0 - 0xAF 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, SDLK_KP_MULTIPLY, SDLK_KP_PLUS, 0x0000, SDLK_KP_MINUS, SDLK_KP_PERIOD, SDLK_KP_DIVIDE, - + // 0xB0 - 0xBF SDLK_KP0, SDLK_KP1, SDLK_KP2, SDLK_KP3, SDLK_KP4, SDLK_KP5, SDLK_KP6, SDLK_KP7, SDLK_KP8, SDLK_KP9, 0x0000, 0x0000, 0x0000, SDLK_KP_EQUALS, SDLK_F1, SDLK_F2, - + // 0xC0 - 0xCF SDLK_F3, SDLK_F4, SDLK_F5, SDLK_F6, SDLK_F7, SDLK_F8, SDLK_F9, SDLK_F10, SDLK_F11, SDLK_F12, SDLK_F13, SDLK_F14, SDLK_F15, 0x0000, 0x0000, 0x0000, - + // 0xD0 - 0xDF [L* and R* function keys] 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, - + // 0xE0 - 0xEF 0x0000, SDLK_LSHIFT, SDLK_RSHIFT, SDLK_LCTRL, SDLK_RCTRL, SDLK_CAPSLOCK, 0x0000, SDLK_LMETA, SDLK_RMETA, SDLK_LALT, SDLK_RALT, SDLK_LSUPER, SDLK_RSUPER, 0x0000, 0x0000, 0x0000, - + // 0xF0 - 0xFF [mostly unused, except for Delete] 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, - 0x0000, 0x0000, 0x0000, SDLK_DELETE, + 0x0000, 0x0000, 0x0000, SDLK_DELETE, }; - + unsigned short sdl_key = gdk_to_sdl_table[gdk_key & 0xFF]; if (sdl_key == 0) { // Unhandled GDK key. - fprintf(stderr, "Unhandled GDK key: 0x%04X (%s)", gdk_key, gdk_keyval_name(gdk_key)); + fprintf (stderr, "Unhandled GDK key: 0x%04X (%s)", gdk_key, + gdk_keyval_name (gdk_key)); return 0; } - + // ignore pause and screenshot hotkeys since they is handled by GTK+ as accelerators - if (sdl_key == Hotkeys[HK_PAUSE] || sdl_key == Hotkeys[HK_SCREENSHOT] || - sdl_key == Hotkeys[HK_SAVE_STATE] || sdl_key == Hotkeys[HK_LOAD_STATE]) + if (sdl_key == Hotkeys[HK_PAUSE] || sdl_key == Hotkeys[HK_SCREENSHOT] || + sdl_key == Hotkeys[HK_SAVE_STATE] + || sdl_key == Hotkeys[HK_LOAD_STATE]) return 0; - + return sdl_key; } // Function adapted from Gens/GS (source/gens/input/input_sdl.c) -static gint convertKeypress(GtkWidget *grab, GdkEventKey *event, gpointer user_data) +static gint convertKeypress (GtkWidget * grab, GdkEventKey * event, + gpointer user_data) { SDL_Event sdlev; int keystate; -#if SDL_VERSION_ATLEAST(2, 0, 0) +#if SDL_VERSION_ATLEAST(2, 0, 0) SDL_Keycode sdlkey; #else SDLKey sdlkey; -#endif +#endif switch (event->type) { case GDK_KEY_PRESS: @@ -2151,582 +2364,610 @@ static gint convertKeypress(GtkWidget *grab, GdkEventKey *event, gpointer user_d sdlev.key.state = SDL_PRESSED; keystate = 1; break; - + case GDK_KEY_RELEASE: sdlev.type = SDL_KEYUP; sdlev.key.state = SDL_RELEASED; keystate = 0; break; - + default: - fprintf(stderr, "Unhandled GDK event type: %d", event->type); + fprintf (stderr, "Unhandled GDK event type: %d", + event->type); return FALSE; } - + // Convert this keypress from GDK to SDL. #if SDL_VERSION_ATLEAST(2, 0, 0) - sdlkey = GDKToSDLKeyval(event->keyval); + sdlkey = GDKToSDLKeyval (event->keyval); #else - sdlkey = (SDLKey)GDKToSDLKeyval(event->keyval); + sdlkey = (SDLKey) GDKToSDLKeyval (event->keyval); #endif - + // Create an SDL event from the keypress. sdlev.key.keysym.sym = sdlkey; if (sdlkey != 0) { - SDL_PushEvent(&sdlev); - + SDL_PushEvent (&sdlev); + // Only let the emulator handle the key event if this window has the input focus. - if(keystate == 0 || gtk_window_is_active(GTK_WINDOW(MainWindow))) + if (keystate == 0 + || gtk_window_is_active (GTK_WINDOW (MainWindow))) { - #if SDL_VERSION_ATLEAST(2, 0, 0) +#if SDL_VERSION_ATLEAST(2, 0, 0) // Not sure how to do this yet with SDL 2.0 // TODO - SDL 2.0 //SDL_GetKeyboardState(NULL)[SDL_GetScancodeFromKey(sdlkey)] = keystate; - #else - SDL_GetKeyState(NULL)[sdlkey] = keystate; - #endif +#else + SDL_GetKeyState (NULL)[sdlkey] = keystate; +#endif } } - + // Allow GTK+ to process this key. return FALSE; } -static GtkWidget* CreateMenubar( GtkWidget* window) +static GtkWidget *CreateMenubar (GtkWidget * window) { - GtkWidget *menubar, *menu, *submenu, *item; + GtkWidget *menubar, *menu, *submenu, *item; GSList *radioGroup; GtkAccelGroup *accel_group; // Create Menu Bar - menubar = gtk_menu_bar_new(); + menubar = gtk_menu_bar_new (); // Create a GtkAccelGroup and add it to the window. - accel_group = gtk_accel_group_new (); + accel_group = gtk_accel_group_new (); - gtk_window_add_accel_group (GTK_WINDOW (window), accel_group); + gtk_window_add_accel_group (GTK_WINDOW (window), accel_group); //--------------------------------------- // Create File Menu - item = gtk_menu_item_new_with_label("File"); + item = gtk_menu_item_new_with_label ("File"); - gtk_menu_shell_append( GTK_MENU_SHELL(menubar), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menubar), item); - menu = gtk_menu_new(); + menu = gtk_menu_new (); - gtk_menu_item_set_submenu( GTK_MENU_ITEM(item), menu ); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), menu); // Load File Menu Items //-File --> Open ROM --------------------- - item = gtk_menu_item_new_with_label("Open ROM"); + item = gtk_menu_item_new_with_label ("Open ROM"); - g_signal_connect( item, "activate", G_CALLBACK(loadGame), NULL); + g_signal_connect (item, "activate", G_CALLBACK (loadGame), NULL); - gtk_widget_add_accelerator( item, "activate", accel_group, - GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + gtk_widget_add_accelerator (item, "activate", accel_group, + GDK_KEY_o, GDK_CONTROL_MASK, + GTK_ACCEL_VISIBLE); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //-File --> Close ROM ------------------ - item = gtk_menu_item_new_with_label("Close ROM"); + item = gtk_menu_item_new_with_label ("Close ROM"); - g_signal_connect( item, "activate", G_CALLBACK(closeGame), NULL); + g_signal_connect (item, "activate", G_CALLBACK (closeGame), NULL); - gtk_widget_add_accelerator( item, "activate", accel_group, - GDK_KEY_c, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + gtk_widget_add_accelerator (item, "activate", accel_group, + GDK_KEY_c, GDK_CONTROL_MASK, + GTK_ACCEL_VISIBLE); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); // Add Separator - item = gtk_separator_menu_item_new(); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + item = gtk_separator_menu_item_new (); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //-File --> Play NSF ------------------ - item = gtk_menu_item_new_with_label("Play NSF"); + item = gtk_menu_item_new_with_label ("Play NSF"); - g_signal_connect( item, "activate", G_CALLBACK(loadNSF), NULL); + g_signal_connect (item, "activate", G_CALLBACK (loadNSF), NULL); - gtk_widget_add_accelerator( item, "activate", accel_group, - GDK_KEY_n, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + gtk_widget_add_accelerator (item, "activate", accel_group, + GDK_KEY_n, GDK_CONTROL_MASK, + GTK_ACCEL_VISIBLE); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); // Add Separator - item = gtk_separator_menu_item_new(); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + item = gtk_separator_menu_item_new (); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //-File --> Load State From ------------------ - item = gtk_menu_item_new_with_label("Load State From"); + item = gtk_menu_item_new_with_label ("Load State From"); - g_signal_connect( item, "activate", G_CALLBACK(loadStateFrom), NULL); + g_signal_connect (item, "activate", G_CALLBACK (loadStateFrom), NULL); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //-File --> Save State As ------------------ - item = gtk_menu_item_new_with_label("Save State As"); + item = gtk_menu_item_new_with_label ("Save State As"); - g_signal_connect( item, "activate", G_CALLBACK(saveStateAs), NULL); + g_signal_connect (item, "activate", G_CALLBACK (saveStateAs), NULL); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //-File --> Quick Load ------------------ - item = gtk_menu_item_new_with_label("Quick Load"); + item = gtk_menu_item_new_with_label ("Quick Load"); - g_signal_connect( item, "activate", G_CALLBACK(quickLoad), NULL); + g_signal_connect (item, "activate", G_CALLBACK (quickLoad), NULL); - gtk_widget_add_accelerator( item, "activate", accel_group, - GDK_KEY_F7, (GdkModifierType)0, GTK_ACCEL_VISIBLE); + gtk_widget_add_accelerator (item, "activate", accel_group, + GDK_KEY_F7, (GdkModifierType) 0, + GTK_ACCEL_VISIBLE); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //-File --> Quick Save ------------------ - item = gtk_menu_item_new_with_label("Quick Save"); + item = gtk_menu_item_new_with_label ("Quick Save"); - g_signal_connect( item, "activate", G_CALLBACK(quickSave), NULL); + g_signal_connect (item, "activate", G_CALLBACK (quickSave), NULL); - gtk_widget_add_accelerator( item, "activate", accel_group, - GDK_KEY_F5, (GdkModifierType)0, GTK_ACCEL_VISIBLE); + gtk_widget_add_accelerator (item, "activate", accel_group, + GDK_KEY_F5, (GdkModifierType) 0, + GTK_ACCEL_VISIBLE); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //-File --> Change State ------------------ - item = gtk_menu_item_new_with_label("Change State"); + item = gtk_menu_item_new_with_label ("Change State"); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); - - submenu = gtk_menu_new(); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); - gtk_menu_item_set_submenu( GTK_MENU_ITEM(item), submenu ); + submenu = gtk_menu_new (); + + gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu); //-File --> Change State --> State 0:9 ------------------ radioGroup = NULL; - for (long int i=0; i<10; i++) + for (long int i = 0; i < 10; i++) { char stmp[32]; - sprintf( stmp, "%li", i ); + sprintf (stmp, "%li", i); - item = gtk_radio_menu_item_new_with_label( radioGroup, stmp); - - radioGroup = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(item) ); - - gtk_menu_shell_append( GTK_MENU_SHELL(submenu), item ); + item = gtk_radio_menu_item_new_with_label (radioGroup, stmp); - g_signal_connect( item, "activate", G_CALLBACK(changeState), (gpointer)i); + radioGroup = + gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM + (item)); + + gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item); + + g_signal_connect (item, "activate", G_CALLBACK (changeState), + (gpointer) i); } #ifdef _S9XLUA_H // Add Separator - item = gtk_separator_menu_item_new(); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + item = gtk_separator_menu_item_new (); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //-File --> Load Lua Script ------------------ - item = gtk_menu_item_new_with_label("Load Lua Script"); + item = gtk_menu_item_new_with_label ("Load Lua Script"); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); - - g_signal_connect( item, "activate", G_CALLBACK(loadLua), NULL); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + + g_signal_connect (item, "activate", G_CALLBACK (loadLua), NULL); #endif // Add Separator - item = gtk_separator_menu_item_new(); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + item = gtk_separator_menu_item_new (); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //-File --> ScreenShot ------------------ - item = gtk_menu_item_new_with_label("Screenshot"); + item = gtk_menu_item_new_with_label ("Screenshot"); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); - - g_signal_connect( item, "activate", G_CALLBACK(FCEUI_SaveSnapshot), NULL); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); - gtk_widget_add_accelerator( item, "activate", accel_group, - GDK_KEY_F12, (GdkModifierType)0, GTK_ACCEL_VISIBLE); + g_signal_connect (item, "activate", G_CALLBACK (FCEUI_SaveSnapshot), + NULL); + + gtk_widget_add_accelerator (item, "activate", accel_group, + GDK_KEY_F12, (GdkModifierType) 0, + GTK_ACCEL_VISIBLE); //-File --> Quit ------------------ - item = gtk_menu_item_new_with_label("Quit"); + item = gtk_menu_item_new_with_label ("Quit"); - g_signal_connect( item, "activate", G_CALLBACK(quit), NULL); + g_signal_connect (item, "activate", G_CALLBACK (quit), NULL); - gtk_widget_add_accelerator( item, "activate", accel_group, - GDK_KEY_q, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + gtk_widget_add_accelerator (item, "activate", accel_group, + GDK_KEY_q, GDK_CONTROL_MASK, + GTK_ACCEL_VISIBLE); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //--------------------------------------- // Create Options Menu - item = gtk_menu_item_new_with_label("Options"); + item = gtk_menu_item_new_with_label ("Options"); - gtk_menu_shell_append( GTK_MENU_SHELL(menubar), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menubar), item); - menu = gtk_menu_new(); + menu = gtk_menu_new (); - gtk_menu_item_set_submenu( GTK_MENU_ITEM(item), menu ); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), menu); // Load Options Menu Items //-Options --> Gamepad Config --------------------- - item = gtk_menu_item_new_with_label("Gamepad Config"); + item = gtk_menu_item_new_with_label ("Gamepad Config"); - g_signal_connect( item, "activate", G_CALLBACK(openGamepadConfig), NULL); + g_signal_connect (item, "activate", G_CALLBACK (openGamepadConfig), + NULL); //gtk_widget_add_accelerator( item, "activate", accel_group, - // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //-Options --> Hotkey Config --------------------- - item = gtk_menu_item_new_with_label("Hotkey Config"); + item = gtk_menu_item_new_with_label ("Hotkey Config"); - g_signal_connect( item, "activate", G_CALLBACK(openHotkeyConfig), NULL); + g_signal_connect (item, "activate", G_CALLBACK (openHotkeyConfig), + NULL); //gtk_widget_add_accelerator( item, "activate", accel_group, - // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //-Options --> Sound Config --------------------- - item = gtk_menu_item_new_with_label("Sound Config"); + item = gtk_menu_item_new_with_label ("Sound Config"); - g_signal_connect( item, "activate", G_CALLBACK(openSoundConfig), NULL); + g_signal_connect (item, "activate", G_CALLBACK (openSoundConfig), NULL); //gtk_widget_add_accelerator( item, "activate", accel_group, - // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //-Options --> Video Config --------------------- - item = gtk_menu_item_new_with_label("Video Config"); + item = gtk_menu_item_new_with_label ("Video Config"); - g_signal_connect( item, "activate", G_CALLBACK(openVideoConfig), NULL); + g_signal_connect (item, "activate", G_CALLBACK (openVideoConfig), NULL); //gtk_widget_add_accelerator( item, "activate", accel_group, - // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //-Options --> Palette Config --------------------- - item = gtk_menu_item_new_with_label("Palette Config"); + item = gtk_menu_item_new_with_label ("Palette Config"); - g_signal_connect( item, "activate", G_CALLBACK(openPaletteConfig), NULL); + g_signal_connect (item, "activate", G_CALLBACK (openPaletteConfig), + NULL); //gtk_widget_add_accelerator( item, "activate", accel_group, - // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //-Options --> Network Config --------------------- - item = gtk_menu_item_new_with_label("Network Config"); + item = gtk_menu_item_new_with_label ("Network Config"); - g_signal_connect( item, "activate", G_CALLBACK(openNetworkConfig), NULL); + g_signal_connect (item, "activate", G_CALLBACK (openNetworkConfig), + NULL); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //-Options --> Auto-Resume Play --------------------- - item = gtk_check_menu_item_new_with_label("Auto-Resume Play"); + item = gtk_check_menu_item_new_with_label ("Auto-Resume Play"); - gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(item), AutoResumePlay); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), + AutoResumePlay); - g_signal_connect( item, "toggled", G_CALLBACK(toggleAutoResume), NULL); + g_signal_connect (item, "toggled", G_CALLBACK (toggleAutoResume), NULL); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //-Options --> Toggle Menubar --------------------- - item = gtk_check_menu_item_new_with_label("Toggle Menubar (alt)"); + item = gtk_check_menu_item_new_with_label ("Toggle Menubar (alt)"); //gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(item), FALSE); - g_signal_connect( item, "toggled", G_CALLBACK(toggleMenuToggling), NULL); + g_signal_connect (item, "toggled", G_CALLBACK (toggleMenuToggling), + NULL); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); // Add Separator - item = gtk_separator_menu_item_new(); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + item = gtk_separator_menu_item_new (); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //-Options --> Fullscreen --------------------- - item = gtk_menu_item_new_with_label("Fullscreen"); + item = gtk_menu_item_new_with_label ("Fullscreen"); - g_signal_connect( item, "activate", G_CALLBACK(enableFullscreen), NULL); + g_signal_connect (item, "activate", G_CALLBACK (enableFullscreen), + NULL); - gtk_widget_add_accelerator( item, "activate", accel_group, - GDK_KEY_Return, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); + gtk_widget_add_accelerator (item, "activate", accel_group, + GDK_KEY_Return, GDK_MOD1_MASK, + GTK_ACCEL_VISIBLE); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //--------------------------------------- // Create Emulation Menu - item = gtk_menu_item_new_with_label("Emulation"); + item = gtk_menu_item_new_with_label ("Emulation"); - gtk_menu_shell_append( GTK_MENU_SHELL(menubar), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menubar), item); - menu = gtk_menu_new(); + menu = gtk_menu_new (); - gtk_menu_item_set_submenu( GTK_MENU_ITEM(item), menu ); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), menu); // Load Emulation Menu Items //-Emulation --> Power --------------------- - item = gtk_menu_item_new_with_label("Power"); + item = gtk_menu_item_new_with_label ("Power"); - g_signal_connect( item, "activate", G_CALLBACK(FCEUI_PowerNES), NULL); + g_signal_connect (item, "activate", G_CALLBACK (FCEUI_PowerNES), NULL); //gtk_widget_add_accelerator( item, "activate", accel_group, - // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //-Emulation --> Reset --------------------- - item = gtk_menu_item_new_with_label("Reset"); + item = gtk_menu_item_new_with_label ("Reset"); - g_signal_connect( item, "activate", G_CALLBACK(hardReset), NULL); + g_signal_connect (item, "activate", G_CALLBACK (hardReset), NULL); //gtk_widget_add_accelerator( item, "activate", accel_group, - // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //-Emulation --> Soft Reset --------------------- - item = gtk_menu_item_new_with_label("Soft Reset"); + item = gtk_menu_item_new_with_label ("Soft Reset"); - g_signal_connect( item, "activate", G_CALLBACK(emuReset), NULL); + g_signal_connect (item, "activate", G_CALLBACK (emuReset), NULL); //gtk_widget_add_accelerator( item, "activate", accel_group, - // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //-Emulation --> Pause --------------------- - item = gtk_menu_item_new_with_label("Pause"); + item = gtk_menu_item_new_with_label ("Pause"); - g_signal_connect( item, "activate", G_CALLBACK(togglePause), NULL); + g_signal_connect (item, "activate", G_CALLBACK (togglePause), NULL); - gtk_widget_add_accelerator( item, "activate", accel_group, - GDK_KEY_Pause, (GdkModifierType)0, GTK_ACCEL_VISIBLE); + gtk_widget_add_accelerator (item, "activate", accel_group, + GDK_KEY_Pause, (GdkModifierType) 0, + GTK_ACCEL_VISIBLE); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); // Add Separator - item = gtk_separator_menu_item_new(); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + item = gtk_separator_menu_item_new (); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //-Emulator --> Enable Game Genie --------------------- - item = gtk_check_menu_item_new_with_label("Enable Game Genie"); + item = gtk_check_menu_item_new_with_label ("Enable Game Genie"); - int gameGenieEnabled=0; - g_config->getOption("SDL.GameGenie", &gameGenieEnabled); - gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(item), gameGenieEnabled); + int gameGenieEnabled = 0; + g_config->getOption ("SDL.GameGenie", &gameGenieEnabled); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), + gameGenieEnabled); - g_signal_connect( item, "toggled", G_CALLBACK(toggleGameGenie), NULL); + g_signal_connect (item, "toggled", G_CALLBACK (toggleGameGenie), NULL); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //-Emulation --> Load Game Genie ROM --------------------- - item = gtk_menu_item_new_with_label("Load Game Genie ROM"); + item = gtk_menu_item_new_with_label ("Load Game Genie ROM"); - g_signal_connect( item, "activate", G_CALLBACK(loadGameGenie), NULL); + g_signal_connect (item, "activate", G_CALLBACK (loadGameGenie), NULL); //gtk_widget_add_accelerator( item, "activate", accel_group, - // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); // Add Separator - item = gtk_separator_menu_item_new(); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + item = gtk_separator_menu_item_new (); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //-Emulation --> Insert Coin --------------------- - item = gtk_menu_item_new_with_label("Insert Coin"); + item = gtk_menu_item_new_with_label ("Insert Coin"); - g_signal_connect( item, "activate", G_CALLBACK(FCEUI_VSUniCoin), NULL); + g_signal_connect (item, "activate", G_CALLBACK (FCEUI_VSUniCoin), NULL); //gtk_widget_add_accelerator( item, "activate", accel_group, - // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); // Add Separator - item = gtk_separator_menu_item_new(); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + item = gtk_separator_menu_item_new (); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //-Emulation --> FDS ------------------ - item = gtk_menu_item_new_with_label("FDS"); + item = gtk_menu_item_new_with_label ("FDS"); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); - - submenu = gtk_menu_new(); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); - gtk_menu_item_set_submenu( GTK_MENU_ITEM(item), submenu ); + submenu = gtk_menu_new (); + + gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu); //-Emulation --> FDS --> Switch Disk --------------------- - item = gtk_menu_item_new_with_label("Switch Disk"); + item = gtk_menu_item_new_with_label ("Switch Disk"); - g_signal_connect( item, "activate", G_CALLBACK(FCEU_FDSSelect), NULL); + g_signal_connect (item, "activate", G_CALLBACK (FCEU_FDSSelect), NULL); //gtk_widget_add_accelerator( item, "activate", accel_group, - // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); - gtk_menu_shell_append( GTK_MENU_SHELL(submenu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item); //-Emulation --> FDS --> Eject Disk --------------------- - item = gtk_menu_item_new_with_label("Eject Disk"); + item = gtk_menu_item_new_with_label ("Eject Disk"); - g_signal_connect( item, "activate", G_CALLBACK(FCEU_FDSInsert), NULL); + g_signal_connect (item, "activate", G_CALLBACK (FCEU_FDSInsert), NULL); //gtk_widget_add_accelerator( item, "activate", accel_group, - // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); - gtk_menu_shell_append( GTK_MENU_SHELL(submenu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item); //-Emulation --> FDS --> Load BIOS File --------------------- - item = gtk_menu_item_new_with_label("Load BIOS File"); + item = gtk_menu_item_new_with_label ("Load BIOS File"); - g_signal_connect( item, "activate", G_CALLBACK(loadFdsBios), NULL); + g_signal_connect (item, "activate", G_CALLBACK (loadFdsBios), NULL); //gtk_widget_add_accelerator( item, "activate", accel_group, - // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); - gtk_menu_shell_append( GTK_MENU_SHELL(submenu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item); //--------------------------------------- // Create Tools Menu - item = gtk_menu_item_new_with_label("Tools"); + item = gtk_menu_item_new_with_label ("Tools"); - gtk_menu_shell_append( GTK_MENU_SHELL(menubar), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menubar), item); - menu = gtk_menu_new(); + menu = gtk_menu_new (); - gtk_menu_item_set_submenu( GTK_MENU_ITEM(item), menu ); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), menu); // Load Tools Menu Items //-Tools --> Cheats --------------------- - item = gtk_menu_item_new_with_label("Cheats..."); + item = gtk_menu_item_new_with_label ("Cheats..."); - g_signal_connect( item, "activate", G_CALLBACK(openCheatsWindow), NULL); + g_signal_connect (item, "activate", G_CALLBACK (openCheatsWindow), + NULL); //gtk_widget_add_accelerator( item, "activate", accel_group, - // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //-Tools --> Ram Watch --------------------- - item = gtk_menu_item_new_with_label("Ram Watch..."); + item = gtk_menu_item_new_with_label ("Ram Watch..."); - g_signal_connect( item, "activate", G_CALLBACK(openMemoryWatchWindow), NULL); + g_signal_connect (item, "activate", G_CALLBACK (openMemoryWatchWindow), + NULL); //gtk_widget_add_accelerator( item, "activate", accel_group, - // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //--------------------------------------- // Create Movie Menu - item = gtk_menu_item_new_with_label("Movie"); + item = gtk_menu_item_new_with_label ("Movie"); - gtk_menu_shell_append( GTK_MENU_SHELL(menubar), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menubar), item); - menu = gtk_menu_new(); + menu = gtk_menu_new (); - gtk_menu_item_set_submenu( GTK_MENU_ITEM(item), menu ); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), menu); // Load Movie Menu Items //-Movie --> Open --------------------- - item = gtk_menu_item_new_with_label("Open"); + item = gtk_menu_item_new_with_label ("Open"); - g_signal_connect( item, "activate", G_CALLBACK(loadMovie), NULL); + g_signal_connect (item, "activate", G_CALLBACK (loadMovie), NULL); - gtk_widget_add_accelerator( item, "activate", accel_group, - GDK_KEY_F7, GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE); + gtk_widget_add_accelerator (item, "activate", accel_group, + GDK_KEY_F7, GDK_SHIFT_MASK, + GTK_ACCEL_VISIBLE); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //-Movie --> Stop --------------------- - item = gtk_menu_item_new_with_label("Stop"); + item = gtk_menu_item_new_with_label ("Stop"); - g_signal_connect( item, "activate", G_CALLBACK(FCEUI_StopMovie), NULL); + g_signal_connect (item, "activate", G_CALLBACK (FCEUI_StopMovie), NULL); //gtk_widget_add_accelerator( item, "activate", accel_group, - // GDK_KEY_F7, GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE); + // GDK_KEY_F7, GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); // Add Separator - item = gtk_separator_menu_item_new(); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + item = gtk_separator_menu_item_new (); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //-Movie --> Record --------------------- - item = gtk_menu_item_new_with_label("Record"); + item = gtk_menu_item_new_with_label ("Record"); - g_signal_connect( item, "activate", G_CALLBACK(recordMovie), NULL); + g_signal_connect (item, "activate", G_CALLBACK (recordMovie), NULL); - gtk_widget_add_accelerator( item, "activate", accel_group, - GDK_KEY_F5, GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE); + gtk_widget_add_accelerator (item, "activate", accel_group, + GDK_KEY_F5, GDK_SHIFT_MASK, + GTK_ACCEL_VISIBLE); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //-Movie --> Record As --------------------- - item = gtk_menu_item_new_with_label("Record As"); + item = gtk_menu_item_new_with_label ("Record As"); - g_signal_connect( item, "activate", G_CALLBACK(recordMovieAs), NULL); + g_signal_connect (item, "activate", G_CALLBACK (recordMovieAs), NULL); //gtk_widget_add_accelerator( item, "activate", accel_group, - // GDK_KEY_F5, GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE); + // GDK_KEY_F5, GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //--------------------------------------- // Create Help Menu - item = gtk_menu_item_new_with_label("Help"); + item = gtk_menu_item_new_with_label ("Help"); - gtk_menu_shell_append( GTK_MENU_SHELL(menubar), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menubar), item); - menu = gtk_menu_new(); + menu = gtk_menu_new (); - gtk_menu_item_set_submenu( GTK_MENU_ITEM(item), menu ); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), menu); // Load Help Menu Items //-Help --> About --------------------- - item = gtk_menu_item_new_with_label("About"); + item = gtk_menu_item_new_with_label ("About"); - g_signal_connect( item, "activate", G_CALLBACK(openAbout), NULL); + g_signal_connect (item, "activate", G_CALLBACK (openAbout), NULL); //gtk_widget_add_accelerator( item, "activate", accel_group, - // GDK_KEY_F7, GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE); + // GDK_KEY_F7, GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); // Finally, return the actual menu bar created return menubar; } -void pushOutputToGTK(const char* str) +void pushOutputToGTK (const char *str) { // we don't really do anything with the output right now return; } -void showGui(bool b) +void showGui (bool b) { - if(b) - gtk_widget_show_all(MainWindow); + if (b) + gtk_widget_show_all (MainWindow); else - gtk_widget_hide(MainWindow); + gtk_widget_hide (MainWindow); } -gint handleKeyRelease(GtkWidget* w, GdkEvent* event, gpointer cb_data) +gint handleKeyRelease (GtkWidget * w, GdkEvent * event, gpointer cb_data) { - if(menuTogglingEnabled) + if (menuTogglingEnabled) { static bool menuShown = true; - if(((GdkEventKey*)event)->keyval == GDK_KEY_Alt_L || ((GdkEventKey*)event)->keyval == GDK_KEY_Alt_R) + if (((GdkEventKey *) event)->keyval == GDK_KEY_Alt_L + || ((GdkEventKey *) event)->keyval == GDK_KEY_Alt_R) { - if(menuShown) + if (menuShown) { - gtk_widget_hide(Menubar); + gtk_widget_hide (Menubar); menuShown = false; } else { - gtk_widget_show(Menubar); + gtk_widget_show (Menubar); menuShown = true; } } @@ -2734,46 +2975,47 @@ gint handleKeyRelease(GtkWidget* w, GdkEvent* event, gpointer cb_data) return 0; }; -int GtkMouseData[3] = {0,0,0}; +int GtkMouseData[3] = { 0, 0, 0 }; -gint handleMouseClick(GtkWidget* widget, GdkEvent *event, gpointer callback_data) +gint handleMouseClick (GtkWidget * widget, GdkEvent * event, + gpointer callback_data) { - GtkMouseData[0] = ((GdkEventButton*)event)->x; - GtkMouseData[1] = ((GdkEventButton*)event)->y; - int button = ((GdkEventButton*)event)->button; - if(!(((GdkEventButton*)event)->type == GDK_BUTTON_PRESS)) + GtkMouseData[0] = ((GdkEventButton *) event)->x; + GtkMouseData[1] = ((GdkEventButton *) event)->y; + int button = ((GdkEventButton *) event)->button; + if (!(((GdkEventButton *) event)->type == GDK_BUTTON_PRESS)) GtkMouseData[2] = 0; else { - if(button == 1) + if (button == 1) GtkMouseData[2] |= 0x1; - if(button == 3) + if (button == 3) GtkMouseData[2] |= 0x3; } // this doesn't work because we poll the mouse position rather // than use events /* - SDL_Event sdlev; - sdlev.type = SDL_MOUSEBUTTONDOWN; - if(((GdkEventButton*)event)->type == GDK_BUTTON_PRESS) - sdlev.button.type = SDL_MOUSEBUTTONDOWN; - else - sdlev.button.type = SDL_MOUSEBUTTONUP; - sdlev.button.button = ((GdkEventButton*)event)->button; - sdlev.button.state = ((GdkEventButton*)event)->state; - sdlev.button.x = ((GdkEventButton*)event)->x; - sdlev.button.y = ((GdkEventButton*)event)->y; + SDL_Event sdlev; + sdlev.type = SDL_MOUSEBUTTONDOWN; + if(((GdkEventButton*)event)->type == GDK_BUTTON_PRESS) + sdlev.button.type = SDL_MOUSEBUTTONDOWN; + else + sdlev.button.type = SDL_MOUSEBUTTONUP; + sdlev.button.button = ((GdkEventButton*)event)->button; + sdlev.button.state = ((GdkEventButton*)event)->state; + sdlev.button.x = ((GdkEventButton*)event)->x; + sdlev.button.y = ((GdkEventButton*)event)->y; + + SDL_PushEvent(&sdlev); + */ - SDL_PushEvent(&sdlev); - */ - return 0; } -gboolean handle_resize(GtkWindow* win, GdkEvent* event, gpointer data) +gboolean handle_resize (GtkWindow * win, GdkEvent * event, gpointer data) { - cairo_t *cr = NULL; + cairo_t *cr = NULL; // This should handle resizing so the emulation takes up as much // of the GTK window as possible @@ -2782,64 +3024,67 @@ gboolean handle_resize(GtkWindow* win, GdkEvent* event, gpointer data) int width, height; width = event->configure.width; height = event->configure.height; - printf("DEBUG: Configure new window size: %dx%d\n", width, height); + printf ("DEBUG: Configure new window size: %dx%d\n", width, height); // get width/height multipliers - double xscale = width / (double)NES_WIDTH; - double yscale = height / (double)NES_HEIGHT; + double xscale = width / (double) NES_WIDTH; + double yscale = height / (double) NES_HEIGHT; // TODO check KeepRatio (where is this) // do this to keep aspect ratio - if(xscale > yscale) + if (xscale > yscale) xscale = yscale; - if(yscale > xscale) + if (yscale > xscale) yscale = xscale; //TODO if openGL make these integers - g_config->setOption("SDL.XScale", xscale); - g_config->setOption("SDL.YScale", yscale); - //gtk_widget_realize(evbox); - flushGtkEvents(); - if(GameInfo != 0) + g_config->setOption ("SDL.XScale", xscale); + g_config->setOption ("SDL.YScale", yscale); + //gtk_widget_realize(evbox); + flushGtkEvents (); + if (GameInfo != 0) { - KillVideo(); - InitVideo(GameInfo); - } + KillVideo (); + InitVideo (GameInfo); + } - if (surface) - { - cairo_surface_destroy (surface); - } - surface = gdk_window_create_similar_surface (gtk_widget_get_window (evbox), - CAIRO_CONTENT_COLOR, - gtk_widget_get_allocated_width (evbox), - gtk_widget_get_allocated_height (evbox)); + if (surface) + { + cairo_surface_destroy (surface); + } + surface = + gdk_window_create_similar_surface (gtk_widget_get_window + (evbox), CAIRO_CONTENT_COLOR, + gtk_widget_get_allocated_width + (evbox), + gtk_widget_get_allocated_height + (evbox)); - if ( surface != NULL ) - { - cr = cairo_create (surface); - - if ( cr != NULL ) - { - cairo_set_source_rgb (cr, 0, 0, 0); - cairo_paint (cr); - - cairo_destroy (cr); - } - } + if (surface != NULL) + { + cr = cairo_create (surface); + + if (cr != NULL) + { + cairo_set_source_rgb (cr, 0, 0, 0); + cairo_paint (cr); + + cairo_destroy (cr); + } + } //gtk_widget_set_size_request(evbox, (int)(NES_WIDTH*xscale), (int)(NES_HEIGHT*yscale)); // Currently unused; unsure why - /* GdkColor black; - black.red = 0; - black.green = 0; - black.blue = 0; - gtk_widget_modify_bg(GTK_WIDGET(win), GTK_STATE_NORMAL, &black);*/ + /* GdkColor black; + black.red = 0; + black.green = 0; + black.blue = 0; + gtk_widget_modify_bg(GTK_WIDGET(win), GTK_STATE_NORMAL, &black); */ - printf("DEBUG: new xscale: %f yscale: %f\n", xscale, yscale); + printf ("DEBUG: new xscale: %f yscale: %f\n", xscale, yscale); return FALSE; } @@ -2848,46 +3093,44 @@ gboolean handle_resize(GtkWindow* win, GdkEvent* event, gpointer data) * signal receives a ready-to-be-used cairo_t that is already * clipped to only draw the exposed areas of the widget */ -static gboolean -draw_cb (GtkWidget *widget, - cairo_t *cr, - gpointer data) +static gboolean draw_cb (GtkWidget * widget, cairo_t * cr, gpointer data) { - // Only clear the screen if a game is not loaded - if (GameInfo == 0) - { - cairo_set_source_surface (cr, surface, 0, 0); - cairo_paint (cr); - } + // Only clear the screen if a game is not loaded + if (GameInfo == 0) + { + cairo_set_source_surface (cr, surface, 0, 0); + cairo_paint (cr); + } - return FALSE; + return FALSE; } -int InitGTKSubsystem(int argc, char** argv) +int InitGTKSubsystem (int argc, char **argv) { - GtkWidget* vbox; - - MainWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL); - gtk_widget_set_events(GTK_WIDGET(MainWindow), GDK_KEY_RELEASE_MASK); -// gtk_window_set_policy (GTK_WINDOW (MainWindow), FALSE, FALSE, TRUE); - gtk_window_set_resizable(GTK_WINDOW(MainWindow), TRUE); - gtk_window_set_title(GTK_WINDOW(MainWindow), FCEU_NAME_AND_VERSION); - gtk_window_set_default_size(GTK_WINDOW(MainWindow), NES_WIDTH, NES_HEIGHT); - - GdkPixbuf* icon = gdk_pixbuf_new_from_xpm_data(icon_xpm); - gtk_window_set_default_icon(icon); - gtk_window_set_icon(GTK_WINDOW(MainWindow), icon); - - vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); - gtk_container_add(GTK_CONTAINER(MainWindow), vbox); - - Menubar = CreateMenubar(MainWindow); + GtkWidget *vbox; + + MainWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_widget_set_events (GTK_WIDGET (MainWindow), GDK_KEY_RELEASE_MASK); +// gtk_window_set_policy (GTK_WINDOW (MainWindow), FALSE, FALSE, TRUE); + gtk_window_set_resizable (GTK_WINDOW (MainWindow), TRUE); + gtk_window_set_title (GTK_WINDOW (MainWindow), FCEU_NAME_AND_VERSION); + gtk_window_set_default_size (GTK_WINDOW (MainWindow), NES_WIDTH, + NES_HEIGHT); + + GdkPixbuf *icon = gdk_pixbuf_new_from_xpm_data (icon_xpm); + gtk_window_set_default_icon (icon); + gtk_window_set_icon (GTK_WINDOW (MainWindow), icon); + + vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); + gtk_container_add (GTK_CONTAINER (MainWindow), vbox); + + Menubar = CreateMenubar (MainWindow); + + gtk_box_pack_start (GTK_BOX (vbox), Menubar, FALSE, TRUE, 0); - gtk_box_pack_start (GTK_BOX(vbox), Menubar, FALSE, TRUE, 0); - // PRG: this code here is the the windowID "hack" to render SDL - // in a GTK window. however, I can't get it to work right now + // in a GTK window. however, I can't get it to work right now // so i'm commenting it out and haivng a seperate GTK2 window with // controls // 12/21/09 @@ -2896,52 +3139,57 @@ int InitGTKSubsystem(int argc, char** argv) // 1/24/11 // // prg - Bryan Cain, you are the man! - - //evbox = gtk_event_box_new(); - evbox = gtk_drawing_area_new(); - gtk_box_pack_start (GTK_BOX(vbox), evbox, TRUE, TRUE, 0); - - double xscale, yscale; - g_config->getOption("SDL.XScale", &xscale); - g_config->getOption("SDL.YScale", &yscale); - gtk_widget_set_size_request(evbox, NES_WIDTH*xscale, NES_HEIGHT*yscale); - gtk_widget_realize(evbox); - gtk_widget_show(evbox); - gtk_widget_show_all(vbox); - + //evbox = gtk_event_box_new(); + evbox = gtk_drawing_area_new (); + gtk_box_pack_start (GTK_BOX (vbox), evbox, TRUE, TRUE, 0); + + double xscale, yscale; + g_config->getOption ("SDL.XScale", &xscale); + g_config->getOption ("SDL.YScale", &yscale); + + gtk_widget_set_size_request (evbox, NES_WIDTH * xscale, + NES_HEIGHT * yscale); + gtk_widget_realize (evbox); + gtk_widget_show (evbox); + gtk_widget_show_all (vbox); + //GdkColor bg = {0, 0, 0, 0}; //gtk_widget_modify_bg(evbox, GTK_STATE_NORMAL, &bg); - + // set up keypress "snooper" to convert GDK keypress events into SDL keypresses //gtk_key_snooper_install(convertKeypress, NULL); - g_signal_connect(G_OBJECT(MainWindow), "key-press-event", G_CALLBACK(convertKeypress), NULL); - g_signal_connect(G_OBJECT(MainWindow), "key-release-event", G_CALLBACK(convertKeypress), NULL); + g_signal_connect (G_OBJECT (MainWindow), "key-press-event", + G_CALLBACK (convertKeypress), NULL); + g_signal_connect (G_OBJECT (MainWindow), "key-release-event", + G_CALLBACK (convertKeypress), NULL); // pass along mouse data from GTK to SDL - g_signal_connect(G_OBJECT(evbox), "button-press-event", G_CALLBACK(handleMouseClick), NULL); - g_signal_connect(G_OBJECT(evbox), "button-release-event", G_CALLBACK(handleMouseClick), NULL); + g_signal_connect (G_OBJECT (evbox), "button-press-event", + G_CALLBACK (handleMouseClick), NULL); + g_signal_connect (G_OBJECT (evbox), "button-release-event", + G_CALLBACK (handleMouseClick), NULL); //g_signal_connect(G_OBJECT(MainWindow), "key-release-event", G_CALLBACK(handleKeyRelease), NULL); - - // signal handlers - g_signal_connect(MainWindow, "delete-event", quit, NULL); - g_signal_connect(MainWindow, "destroy-event", quit, NULL); - // resize handler - g_signal_connect(MainWindow, "configure-event", G_CALLBACK(handle_resize), NULL); - g_signal_connect( evbox, "draw", G_CALLBACK(draw_cb), NULL); - - gtk_widget_show_all(MainWindow); - - GtkRequisition req; - gtk_widget_get_preferred_size(GTK_WIDGET(MainWindow), NULL, &req); - //printf("Init Resize: w:%i h:%i \n", req.width, req.height ); - gtk_window_resize(GTK_WINDOW(MainWindow), req.width, req.height ); - // Once the window has been resized, return draw area size request to minimum values - gtk_widget_set_size_request(evbox, NES_WIDTH, NES_HEIGHT); + // signal handlers + g_signal_connect (MainWindow, "delete-event", quit, NULL); + g_signal_connect (MainWindow, "destroy-event", quit, NULL); + // resize handler + g_signal_connect (MainWindow, "configure-event", + G_CALLBACK (handle_resize), NULL); + g_signal_connect (evbox, "draw", G_CALLBACK (draw_cb), NULL); + + gtk_widget_show_all (MainWindow); + + GtkRequisition req; + gtk_widget_get_preferred_size (GTK_WIDGET (MainWindow), NULL, &req); + //printf("Init Resize: w:%i h:%i \n", req.width, req.height ); + gtk_window_resize (GTK_WINDOW (MainWindow), req.width, req.height); + + // Once the window has been resized, return draw area size request to minimum values + gtk_widget_set_size_request (evbox, NES_WIDTH, NES_HEIGHT); gtkIsStarted = true; - + return 0; } - From 575e090affb884def1eeeacf8f198cb26accb017 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Wed, 13 May 2020 21:13:22 -0400 Subject: [PATCH 051/156] Ran indent program on new cheat and ramwatch cpp files to apply hard tabs. --- src/drivers/sdl/cheat.cpp | 1479 +++++++++++++++++--------------- src/drivers/sdl/ramwatch.cpp | 1564 ++++++++++++++++++---------------- 2 files changed, 1603 insertions(+), 1440 deletions(-) diff --git a/src/drivers/sdl/cheat.cpp b/src/drivers/sdl/cheat.cpp index e15d1427..763aeeaa 100644 --- a/src/drivers/sdl/cheat.cpp +++ b/src/drivers/sdl/cheat.cpp @@ -33,1065 +33,1132 @@ extern Config *g_config; -static void updateAllActvCheatLists( bool redraw ); +static void updateAllActvCheatLists (bool redraw); //----------------------------------------- class cheat_win_t -{ - public: +{ + public: - GtkTreeStore *actv_cheats_store; - GtkTreeStore *ram_match_store; - GtkTreeIter actv_cheats_iter; - GtkTreeIter ram_match_iter; - int cheat_search_known_value; - int cheat_search_neq_value; - int cheat_search_gt_value; - int cheat_search_lt_value; - int new_cheat_addr; - int new_cheat_val ; - int new_cheat_cmp ; - std::string new_cheat_name; - bool wasPausedByCheats; - bool pauseWhileCheatsActv; - bool actv_cheat_redraw; + GtkTreeStore * actv_cheats_store; + GtkTreeStore *ram_match_store; + GtkTreeIter actv_cheats_iter; + GtkTreeIter ram_match_iter; + int cheat_search_known_value; + int cheat_search_neq_value; + int cheat_search_gt_value; + int cheat_search_lt_value; + int new_cheat_addr; + int new_cheat_val; + int new_cheat_cmp; + std::string new_cheat_name; + bool wasPausedByCheats; + bool pauseWhileCheatsActv; + bool actv_cheat_redraw; GtkWidget *actv_cheat_tree; GtkWidget *search_cheat_tree; - GtkWidget *neq_chkbox; - GtkWidget *lt_chkbox; - GtkWidget *gt_chkbox; + GtkWidget *neq_chkbox; + GtkWidget *lt_chkbox; + GtkWidget *gt_chkbox; - cheat_win_t(void) - { - actv_cheats_store = NULL; - ram_match_store = NULL; - cheat_search_known_value = 0; - cheat_search_neq_value = 0; - cheat_search_gt_value = 0; - cheat_search_lt_value = 0; - new_cheat_addr = -1; - new_cheat_val = -1; - new_cheat_cmp = -1; - wasPausedByCheats = false; - pauseWhileCheatsActv = false; - actv_cheat_redraw = true; - actv_cheat_tree = NULL; - search_cheat_tree = NULL; - neq_chkbox = NULL; - lt_chkbox = NULL; - gt_chkbox = NULL; - } + cheat_win_t (void) + { + actv_cheats_store = NULL; + ram_match_store = NULL; + cheat_search_known_value = 0; + cheat_search_neq_value = 0; + cheat_search_gt_value = 0; + cheat_search_lt_value = 0; + new_cheat_addr = -1; + new_cheat_val = -1; + new_cheat_cmp = -1; + wasPausedByCheats = false; + pauseWhileCheatsActv = false; + actv_cheat_redraw = true; + actv_cheat_tree = NULL; + search_cheat_tree = NULL; + neq_chkbox = NULL; + lt_chkbox = NULL; + gt_chkbox = NULL; + } - void showActiveCheatList( bool reset ); - void showCheatSearchResults(void); + void showActiveCheatList (bool reset); + void showCheatSearchResults (void); }; + static cheat_win_t *curr_cw = NULL; -static std::list cheatWinList; +static std::list < cheat_win_t * >cheatWinList; //******************************************************************************************************* // Cheat Window //******************************************************************************************************* -static int ShowCheatSearchResultsCallB(uint32 a, uint8 last, uint8 current) +static int ShowCheatSearchResultsCallB (uint32 a, uint8 last, uint8 current) { char addrStr[32], lastStr[32], curStr[32]; - sprintf( addrStr, "0x%04X ", a ); - sprintf( lastStr, " 0x%02X ", last ); - sprintf( curStr, " 0x%02X ", current ); + sprintf (addrStr, "0x%04X ", a); + sprintf (lastStr, " 0x%02X ", last); + sprintf (curStr, " 0x%02X ", current); - gtk_tree_store_append( curr_cw->ram_match_store, &curr_cw->ram_match_iter, NULL); // aquire iter + gtk_tree_store_append (curr_cw->ram_match_store, &curr_cw->ram_match_iter, NULL); // aquire iter - gtk_tree_store_set(curr_cw->ram_match_store, &curr_cw->ram_match_iter, - 0, addrStr, 1, lastStr, 2, curStr, - -1); + gtk_tree_store_set (curr_cw->ram_match_store, &curr_cw->ram_match_iter, + 0, addrStr, 1, lastStr, 2, curStr, -1); return 1; } -void cheat_win_t::showCheatSearchResults(void) +void cheat_win_t::showCheatSearchResults (void) { int total_matches = 0; - curr_cw = this; + curr_cw = this; - gtk_tree_store_clear(ram_match_store); + gtk_tree_store_clear (ram_match_store); - total_matches = FCEUI_CheatSearchGetCount(); + total_matches = FCEUI_CheatSearchGetCount (); //printf("Cheat Search Matches: %i \n", total_matches ); - FCEUI_CheatSearchGetRange( 0, total_matches, ShowCheatSearchResultsCallB ); + FCEUI_CheatSearchGetRange (0, total_matches, + ShowCheatSearchResultsCallB); } -static void cheatSearchReset( GtkButton *button, - cheat_win_t *cw) +static void cheatSearchReset (GtkButton * button, cheat_win_t * cw) { //printf("Cheat Search Reset!\n"); - //cheat_search_known_value = 0; - //cheat_search_neq_value = 0; - //cheat_search_gt_value = 0; - //cheat_search_lt_value = 0; + //cheat_search_known_value = 0; + //cheat_search_neq_value = 0; + //cheat_search_gt_value = 0; + //cheat_search_lt_value = 0; - FCEUI_CheatSearchBegin(); - cw->showCheatSearchResults(); + FCEUI_CheatSearchBegin (); + cw->showCheatSearchResults (); // Enable Cheat Search Buttons - Change Sensitivity } -static void cheatSearchKnown( GtkButton *button, - cheat_win_t *cw) +static void cheatSearchKnown (GtkButton * button, cheat_win_t * cw) { //printf("Cheat Search Known!\n"); - FCEUI_CheatSearchEnd(FCEU_SEARCH_NEWVAL_KNOWN, cw->cheat_search_known_value, 0); - cw->showCheatSearchResults(); + FCEUI_CheatSearchEnd (FCEU_SEARCH_NEWVAL_KNOWN, + cw->cheat_search_known_value, 0); + cw->showCheatSearchResults (); } -static void cheatSearchEqual( GtkButton *button, - cheat_win_t *cw) +static void cheatSearchEqual (GtkButton * button, cheat_win_t * cw) { //printf("Cheat Search Equal !\n"); - FCEUI_CheatSearchEnd(FCEU_SEARCH_PUERLY_RELATIVE_CHANGE, 0, 0); - cw->showCheatSearchResults(); + FCEUI_CheatSearchEnd (FCEU_SEARCH_PUERLY_RELATIVE_CHANGE, 0, 0); + cw->showCheatSearchResults (); } -static void cheatSearchNotEqual( GtkButton *button, - cheat_win_t *cw ) +static void cheatSearchNotEqual (GtkButton * button, cheat_win_t * cw) { - int checked = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(cw->neq_chkbox) ); + int checked = + gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON + (cw->neq_chkbox)); //printf("Cheat Search NotEqual %i!\n", checked); - if ( checked ){ - FCEUI_CheatSearchEnd(FCEU_SEARCH_PUERLY_RELATIVE_CHANGE, 0, cw->cheat_search_neq_value); - } else { - FCEUI_CheatSearchEnd(FCEU_SEARCH_ANY_CHANGE, 0, 0); + if (checked) + { + FCEUI_CheatSearchEnd (FCEU_SEARCH_PUERLY_RELATIVE_CHANGE, 0, + cw->cheat_search_neq_value); } - cw->showCheatSearchResults(); + else + { + FCEUI_CheatSearchEnd (FCEU_SEARCH_ANY_CHANGE, 0, 0); + } + cw->showCheatSearchResults (); } -static void cheatSearchGreaterThan( GtkButton *button, - cheat_win_t *cw ) +static void cheatSearchGreaterThan (GtkButton * button, cheat_win_t * cw) { - int checked = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(cw->gt_chkbox) ); + int checked = + gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON + (cw->gt_chkbox)); //printf("Cheat Search GreaterThan %i!\n", checked); - if ( checked ){ - FCEUI_CheatSearchEnd(FCEU_SEARCH_NEWVAL_GT_KNOWN, 0, cw->cheat_search_gt_value); - } else { - FCEUI_CheatSearchEnd(FCEU_SEARCH_NEWVAL_GT, 0, 0); + if (checked) + { + FCEUI_CheatSearchEnd (FCEU_SEARCH_NEWVAL_GT_KNOWN, 0, + cw->cheat_search_gt_value); } - cw->showCheatSearchResults(); + else + { + FCEUI_CheatSearchEnd (FCEU_SEARCH_NEWVAL_GT, 0, 0); + } + cw->showCheatSearchResults (); } -static void cheatSearchLessThan( GtkButton *button, - cheat_win_t *cw ) +static void cheatSearchLessThan (GtkButton * button, cheat_win_t * cw) { - int checked = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(cw->lt_chkbox) ); + int checked = + gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON + (cw->lt_chkbox)); //printf("Cheat Search LessThan %i!\n", checked); - if ( checked ){ - FCEUI_CheatSearchEnd(FCEU_SEARCH_NEWVAL_LT_KNOWN, 0, cw->cheat_search_lt_value); - } else { - FCEUI_CheatSearchEnd(FCEU_SEARCH_NEWVAL_LT, 0, 0); + if (checked) + { + FCEUI_CheatSearchEnd (FCEU_SEARCH_NEWVAL_LT_KNOWN, 0, + cw->cheat_search_lt_value); } - cw->showCheatSearchResults(); + else + { + FCEUI_CheatSearchEnd (FCEU_SEARCH_NEWVAL_LT, 0, 0); + } + cw->showCheatSearchResults (); } -static void pauseDuringCheatWinActvCB( GtkToggleButton *button, - cheat_win_t *cw ) +static void pauseDuringCheatWinActvCB (GtkToggleButton * button, + cheat_win_t * cw) { - cw->pauseWhileCheatsActv = gtk_toggle_button_get_active(button); + cw->pauseWhileCheatsActv = gtk_toggle_button_get_active (button); - if ( cw->pauseWhileCheatsActv ) - { - if ( EmulationPaused == 0 ) - { - EmulationPaused = 1; - cw->wasPausedByCheats = true; - } - } - else - { - if ( EmulationPaused && cw->wasPausedByCheats ) - { - EmulationPaused = 0; - } - cw->wasPausedByCheats = false; - } - FCEU_printf("Emulation paused: %d\n", EmulationPaused); + if (cw->pauseWhileCheatsActv) + { + if (EmulationPaused == 0) + { + EmulationPaused = 1; + cw->wasPausedByCheats = true; + } + } + else + { + if (EmulationPaused && cw->wasPausedByCheats) + { + EmulationPaused = 0; + } + cw->wasPausedByCheats = false; + } + FCEU_printf ("Emulation paused: %d\n", EmulationPaused); } -static void cheatSearchValueEntryCB1( GtkWidget *widget, - cheat_win_t *cw ) +static void cheatSearchValueEntryCB1 (GtkWidget * widget, cheat_win_t * cw) { long value; const gchar *entry_text; - entry_text = gtk_entry_get_text (GTK_ENTRY (widget)); + entry_text = gtk_entry_get_text (GTK_ENTRY (widget)); - value = strtol( entry_text, NULL, 16 ); + value = strtol (entry_text, NULL, 16); - cw->cheat_search_known_value = value; + cw->cheat_search_known_value = value; - //printf("Cheat Value Entry contents: '%s' Value: 0x%02lx\n", entry_text, value); + //printf("Cheat Value Entry contents: '%s' Value: 0x%02lx\n", entry_text, value); } -static void cheatSearchValueEntryCB2( GtkWidget *widget, - cheat_win_t *cw ) +static void cheatSearchValueEntryCB2 (GtkWidget * widget, cheat_win_t * cw) { long value; const gchar *entry_text; - entry_text = gtk_entry_get_text (GTK_ENTRY (widget)); + entry_text = gtk_entry_get_text (GTK_ENTRY (widget)); - value = strtol( entry_text, NULL, 16 ); + value = strtol (entry_text, NULL, 16); - cw->cheat_search_neq_value = value; + cw->cheat_search_neq_value = value; - //printf("Cheat Value Entry contents: '%s' Value: 0x%02lx\n", entry_text, value); + //printf("Cheat Value Entry contents: '%s' Value: 0x%02lx\n", entry_text, value); } -static void cheatSearchValueEntryCB3( GtkWidget *widget, - cheat_win_t *cw ) +static void cheatSearchValueEntryCB3 (GtkWidget * widget, cheat_win_t * cw) { long value; const gchar *entry_text; - entry_text = gtk_entry_get_text (GTK_ENTRY (widget)); + entry_text = gtk_entry_get_text (GTK_ENTRY (widget)); - value = strtol( entry_text, NULL, 16 ); + value = strtol (entry_text, NULL, 16); - cw->cheat_search_gt_value = value; + cw->cheat_search_gt_value = value; - //printf("Cheat Value Entry contents: '%s' Value: 0x%02lx\n", entry_text, value); + //printf("Cheat Value Entry contents: '%s' Value: 0x%02lx\n", entry_text, value); } -static void cheatSearchValueEntryCB4( GtkWidget *widget, - cheat_win_t *cw ) +static void cheatSearchValueEntryCB4 (GtkWidget * widget, cheat_win_t * cw) { long value; const gchar *entry_text; - entry_text = gtk_entry_get_text (GTK_ENTRY (widget)); + entry_text = gtk_entry_get_text (GTK_ENTRY (widget)); - value = strtol( entry_text, NULL, 16 ); + value = strtol (entry_text, NULL, 16); - cw->cheat_search_lt_value = value; + cw->cheat_search_lt_value = value; - //printf("Cheat Value Entry contents: '%s' Value: 0x%02lx\n", entry_text, value); + //printf("Cheat Value Entry contents: '%s' Value: 0x%02lx\n", entry_text, value); } -static int activeCheatListCB(char *name, uint32 a, uint8 v, int c, int s, int type, void* data) +static int activeCheatListCB (char *name, uint32 a, uint8 v, int c, int s, + int type, void *data) { char addrStr[32], valStr[16], cmpStr[16]; //printf("Cheat Name:'%s' Addr:0x%04x Val:0x%02x \n", name, a, v ); - // - cheat_win_t *cw = (cheat_win_t *)data; + // + cheat_win_t *cw = (cheat_win_t *) data; - if ( cw->actv_cheat_redraw ) - { - gtk_tree_store_append( cw->actv_cheats_store, &cw->actv_cheats_iter, NULL); // aquire iter - } - - sprintf( addrStr, "0x%04X ", a ); - sprintf( valStr, " 0x%02X ", v ); - - if ( c >= 0 ){ - sprintf( cmpStr, " 0x%02X ", c ); - } else { - strcpy( cmpStr, " 0xFF "); + if (cw->actv_cheat_redraw) + { + gtk_tree_store_append (cw->actv_cheats_store, &cw->actv_cheats_iter, NULL); // aquire iter } - gtk_tree_store_set(cw->actv_cheats_store, &cw->actv_cheats_iter, - 0, s, 1, addrStr, 2, valStr, 3, cmpStr, 4, name, - -1); + sprintf (addrStr, "0x%04X ", a); + sprintf (valStr, " 0x%02X ", v); - if ( !cw->actv_cheat_redraw ) - { - if ( !gtk_tree_model_iter_next( GTK_TREE_MODEL(cw->actv_cheats_store), &cw->actv_cheats_iter ) ) - { - gtk_tree_store_append( cw->actv_cheats_store, &cw->actv_cheats_iter, NULL); // aquire iter - } - } + if (c >= 0) + { + sprintf (cmpStr, " 0x%02X ", c); + } + else + { + strcpy (cmpStr, " 0xFF "); + } - return 1; + gtk_tree_store_set (cw->actv_cheats_store, &cw->actv_cheats_iter, + 0, s, 1, addrStr, 2, valStr, 3, cmpStr, 4, name, + -1); + + if (!cw->actv_cheat_redraw) + { + if (!gtk_tree_model_iter_next + (GTK_TREE_MODEL (cw->actv_cheats_store), + &cw->actv_cheats_iter)) + { + gtk_tree_store_append (cw->actv_cheats_store, &cw->actv_cheats_iter, NULL); // aquire iter + } + } + + return 1; } -void cheat_win_t::showActiveCheatList( bool reset ) +void cheat_win_t::showActiveCheatList (bool reset) { - actv_cheat_redraw = reset; + actv_cheat_redraw = reset; - if ( actv_cheat_redraw ) - { - gtk_tree_store_clear(actv_cheats_store); - } - else - { - if ( !gtk_tree_model_get_iter_first( GTK_TREE_MODEL(actv_cheats_store), &actv_cheats_iter ) ) - { - //printf("No Tree Entries Loaded.\n"); - actv_cheat_redraw = 1; - } - } + if (actv_cheat_redraw) + { + gtk_tree_store_clear (actv_cheats_store); + } + else + { + if (!gtk_tree_model_get_iter_first + (GTK_TREE_MODEL (actv_cheats_store), &actv_cheats_iter)) + { + //printf("No Tree Entries Loaded.\n"); + actv_cheat_redraw = 1; + } + } - FCEUI_ListCheats( activeCheatListCB, (void*)this ); + FCEUI_ListCheats (activeCheatListCB, (void *) this); - actv_cheat_redraw = false; + actv_cheat_redraw = false; } -static void cheatListEnableToggle( GtkCellRendererToggle *renderer, - gchar *pathStr, - cheat_win_t *cw ) +static void cheatListEnableToggle (GtkCellRendererToggle * renderer, + gchar * pathStr, cheat_win_t * cw) { - GtkTreePath *path; + GtkTreePath *path; int depth; int *indexArray; - path = gtk_tree_path_new_from_string( pathStr ); + path = gtk_tree_path_new_from_string (pathStr); - if ( path == NULL ){ - printf("Error: gtk_tree_path_new_from_string failed\n"); + if (path == NULL) + { + printf ("Error: gtk_tree_path_new_from_string failed\n"); return; } - depth = gtk_tree_path_get_depth(path); - indexArray = gtk_tree_path_get_indices(path); + depth = gtk_tree_path_get_depth (path); + indexArray = gtk_tree_path_get_indices (path); - if ( depth > 0 ) + if (depth > 0) { - //printf("Toggle: %i\n", indexArray[0] ); - FCEUI_ToggleCheat( indexArray[0] ); + //printf("Toggle: %i\n", indexArray[0] ); + FCEUI_ToggleCheat (indexArray[0]); } - gtk_tree_path_free( path ); + gtk_tree_path_free (path); - updateAllActvCheatLists(0); + updateAllActvCheatLists (0); } -static void openCheatFile( GtkWidget *widget, - cheat_win_t *cw ) +static void openCheatFile (GtkWidget * widget, cheat_win_t * cw) { - GtkWidget* fileChooser; - GtkFileFilter* filterCht; - GtkFileFilter* filterAll; + GtkWidget *fileChooser; + GtkFileFilter *filterCht; + GtkFileFilter *filterAll; - filterCht = gtk_file_filter_new(); - filterAll = gtk_file_filter_new(); + filterCht = gtk_file_filter_new (); + filterAll = gtk_file_filter_new (); - gtk_file_filter_add_pattern(filterCht, "*.cht"); - gtk_file_filter_add_pattern(filterAll, "*"); + gtk_file_filter_add_pattern (filterCht, "*.cht"); + gtk_file_filter_add_pattern (filterAll, "*"); - gtk_file_filter_set_name(filterCht, "*.cht"); - gtk_file_filter_set_name(filterAll, "All Files"); + gtk_file_filter_set_name (filterCht, "*.cht"); + gtk_file_filter_set_name (filterAll, "All Files"); - fileChooser = gtk_file_chooser_dialog_new ("Open Cheat", GTK_WINDOW(MainWindow), - GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel", GTK_RESPONSE_CANCEL, - "_Open", GTK_RESPONSE_ACCEPT, NULL); - const char* last_dir; - g_config->getOption("SDL.LastOpenFile", &last_dir); - gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(fileChooser), last_dir); + fileChooser = + gtk_file_chooser_dialog_new ("Open Cheat", + GTK_WINDOW (MainWindow), + GTK_FILE_CHOOSER_ACTION_OPEN, + "_Cancel", GTK_RESPONSE_CANCEL, + "_Open", GTK_RESPONSE_ACCEPT, + NULL); + const char *last_dir; + g_config->getOption ("SDL.LastOpenFile", &last_dir); + gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (fileChooser), + last_dir); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterCht); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterAll); + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fileChooser), filterCht); + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fileChooser), filterAll); - if (gtk_dialog_run (GTK_DIALOG (fileChooser)) ==GTK_RESPONSE_ACCEPT) + if (gtk_dialog_run (GTK_DIALOG (fileChooser)) == GTK_RESPONSE_ACCEPT) { FILE *fp; - char* filename; - - filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fileChooser)); + char *filename; + + filename = + gtk_file_chooser_get_filename (GTK_FILE_CHOOSER + (fileChooser)); gtk_widget_destroy (fileChooser); - fp = fopen( filename, "r"); + fp = fopen (filename, "r"); - if ( fp != NULL ) + if (fp != NULL) { - FCEU_LoadGameCheats( fp, 0 ); - fclose(fp); + FCEU_LoadGameCheats (fp, 0); + fclose (fp); } //g_config->setOption("SDL.LastOpenFile", filename); // Error dialog no longer required with GTK implementation of FCEUD_PrintError() - - resizeGtkWindow(); - g_free( filename); + + resizeGtkWindow (); + g_free (filename); } else { gtk_widget_destroy (fileChooser); } - updateAllActvCheatLists(1); + updateAllActvCheatLists (1); } -static void newCheatEntryCB1( GtkWidget *widget, - cheat_win_t *cw ) +static void newCheatEntryCB1 (GtkWidget * widget, cheat_win_t * cw) { const gchar *entry_text; - entry_text = gtk_entry_get_text (GTK_ENTRY (widget)); + entry_text = gtk_entry_get_text (GTK_ENTRY (widget)); - if ( entry_text[0] == 0 ) - { - cw->new_cheat_addr = -1; - } - else - { - cw->new_cheat_addr = strtol( entry_text, NULL, 16 ); - } -} - -static void newCheatEntryCB2( GtkWidget *widget, - cheat_win_t *cw ) -{ - const gchar *entry_text; - entry_text = gtk_entry_get_text (GTK_ENTRY (widget)); - - if ( entry_text[0] == 0 ) + if (entry_text[0] == 0) { - cw->new_cheat_val = -1; - } - else - { - cw->new_cheat_val = strtol( entry_text, NULL, 16 ); - } -} - -static void newCheatEntryCB3( GtkWidget *widget, - cheat_win_t *cw ) -{ - const gchar *entry_text; - entry_text = gtk_entry_get_text (GTK_ENTRY (widget)); - - if ( entry_text[0] == 0 ) - { - cw->new_cheat_cmp = -1; + cw->new_cheat_addr = -1; } else { - cw->new_cheat_cmp = strtol( entry_text, NULL, 16 ); + cw->new_cheat_addr = strtol (entry_text, NULL, 16); } } -static void newCheatEntryCB4( GtkWidget *widget, - cheat_win_t *cw ) +static void newCheatEntryCB2 (GtkWidget * widget, cheat_win_t * cw) { const gchar *entry_text; - entry_text = gtk_entry_get_text (GTK_ENTRY (widget)); + entry_text = gtk_entry_get_text (GTK_ENTRY (widget)); - cw->new_cheat_name.assign( entry_text ); + if (entry_text[0] == 0) + { + cw->new_cheat_val = -1; + } + else + { + cw->new_cheat_val = strtol (entry_text, NULL, 16); + } } -static void addCheat2Active( GtkWidget *widget, - cheat_win_t *cw ) +static void newCheatEntryCB3 (GtkWidget * widget, cheat_win_t * cw) +{ + const gchar *entry_text; + entry_text = gtk_entry_get_text (GTK_ENTRY (widget)); + + if (entry_text[0] == 0) + { + cw->new_cheat_cmp = -1; + } + else + { + cw->new_cheat_cmp = strtol (entry_text, NULL, 16); + } +} + +static void newCheatEntryCB4 (GtkWidget * widget, cheat_win_t * cw) +{ + const gchar *entry_text; + entry_text = gtk_entry_get_text (GTK_ENTRY (widget)); + + cw->new_cheat_name.assign (entry_text); +} + +static void addCheat2Active (GtkWidget * widget, cheat_win_t * cw) { - if ( (cw->new_cheat_addr >= 0) && (cw->new_cheat_val >= 0) ) - { - if ( FCEUI_AddCheat( cw->new_cheat_name.c_str(), cw->new_cheat_addr, cw->new_cheat_val, cw->new_cheat_cmp, 1) ) + if ((cw->new_cheat_addr >= 0) && (cw->new_cheat_val >= 0)) + { + if (FCEUI_AddCheat + (cw->new_cheat_name.c_str (), cw->new_cheat_addr, + cw->new_cheat_val, cw->new_cheat_cmp, 1)) { - updateAllActvCheatLists(1); + updateAllActvCheatLists (1); } } } -static void removeCheatFromActive( GtkWidget *widget, - cheat_win_t *cw ) +static void removeCheatFromActive (GtkWidget * widget, cheat_win_t * cw) { int numListRows; GList *selListRows, *tmpList; GtkTreeModel *model = NULL; GtkTreeSelection *treeSel; - treeSel = gtk_tree_view_get_selection( GTK_TREE_VIEW(cw->actv_cheat_tree) ); + treeSel = + gtk_tree_view_get_selection (GTK_TREE_VIEW + (cw->actv_cheat_tree)); - numListRows = gtk_tree_selection_count_selected_rows( treeSel ); + numListRows = gtk_tree_selection_count_selected_rows (treeSel); - if ( numListRows == 0 ) - { - return; - } + if (numListRows == 0) + { + return; + } //printf("Number of Rows Selected: %i\n", numListRows ); - selListRows = gtk_tree_selection_get_selected_rows( treeSel, &model ); + selListRows = gtk_tree_selection_get_selected_rows (treeSel, &model); tmpList = selListRows; - while ( tmpList ) + while (tmpList) { int depth; int *indexArray; - GtkTreePath *path = (GtkTreePath*)tmpList->data; + GtkTreePath *path = (GtkTreePath *) tmpList->data; - depth = gtk_tree_path_get_depth(path); - indexArray = gtk_tree_path_get_indices(path); + depth = gtk_tree_path_get_depth (path); + indexArray = gtk_tree_path_get_indices (path); - if ( depth > 0 ) + if (depth > 0) { - //GtkTreeIter iter; - FCEUI_DelCheat( indexArray[0] ); + //GtkTreeIter iter; + FCEUI_DelCheat (indexArray[0]); - //if ( gtk_tree_model_get_iter ( model, &iter, path ) ) - //{ - // gtk_tree_store_remove( actv_cheats_store, &iter ); - //} + //if ( gtk_tree_model_get_iter ( model, &iter, path ) ) + //{ + // gtk_tree_store_remove( actv_cheats_store, &iter ); + //} } - tmpList = tmpList->next; + tmpList = tmpList->next; } - g_list_free_full(selListRows, (GDestroyNotify) gtk_tree_path_free); + g_list_free_full (selListRows, (GDestroyNotify) gtk_tree_path_free); - updateAllActvCheatLists(1); + updateAllActvCheatLists (1); } -static void updateCheatList( GtkWidget *widget, - cheat_win_t *cw ) +static void updateCheatList (GtkWidget * widget, cheat_win_t * cw) { int numListRows; GList *selListRows, *tmpList; GtkTreeModel *model = NULL; GtkTreeSelection *treeSel; - treeSel = gtk_tree_view_get_selection( GTK_TREE_VIEW(cw->actv_cheat_tree) ); + treeSel = + gtk_tree_view_get_selection (GTK_TREE_VIEW + (cw->actv_cheat_tree)); - numListRows = gtk_tree_selection_count_selected_rows( treeSel ); + numListRows = gtk_tree_selection_count_selected_rows (treeSel); - if ( numListRows == 0 ) - { - return; - } + if (numListRows == 0) + { + return; + } //printf("Number of Rows Selected: %i\n", numListRows ); - selListRows = gtk_tree_selection_get_selected_rows( treeSel, &model ); + selListRows = gtk_tree_selection_get_selected_rows (treeSel, &model); tmpList = selListRows; - while ( tmpList ) + while (tmpList) { int depth; int *indexArray; - GtkTreePath *path = (GtkTreePath*)tmpList->data; + GtkTreePath *path = (GtkTreePath *) tmpList->data; - depth = gtk_tree_path_get_depth(path); - indexArray = gtk_tree_path_get_indices(path); + depth = gtk_tree_path_get_depth (path); + indexArray = gtk_tree_path_get_indices (path); - if ( depth > 0 ) + if (depth > 0) { - uint32 a; uint8 v; + uint32 a; + uint8 v; int c, s, type; - const char *name = NULL; - if ( FCEUI_GetCheat( indexArray[0], NULL, &a, &v, &c, &s, &type) ) + const char *name = NULL; + if (FCEUI_GetCheat + (indexArray[0], NULL, &a, &v, &c, &s, &type)) { - if ( cw->new_cheat_addr >= 0 ){ - a = cw->new_cheat_addr; - } - if ( cw->new_cheat_val >= 0 ){ - v = cw->new_cheat_val; - } - if ( cw->new_cheat_cmp >= 0 ){ - c = cw->new_cheat_cmp; - } - if ( cw->new_cheat_name.size() ) - { - name = cw->new_cheat_name.c_str(); - } - FCEUI_SetCheat( indexArray[0], name, a, v, c, s, type ); + if (cw->new_cheat_addr >= 0) + { + a = cw->new_cheat_addr; + } + if (cw->new_cheat_val >= 0) + { + v = cw->new_cheat_val; + } + if (cw->new_cheat_cmp >= 0) + { + c = cw->new_cheat_cmp; + } + if (cw->new_cheat_name.size ()) + { + name = cw->new_cheat_name.c_str (); + } + FCEUI_SetCheat (indexArray[0], name, a, v, c, s, + type); } } //printf("Depth: %i \n", depth ); //for (int i=0; inext; + tmpList = tmpList->next; } - g_list_free_full(selListRows, (GDestroyNotify) gtk_tree_path_free); + g_list_free_full (selListRows, (GDestroyNotify) gtk_tree_path_free); - updateAllActvCheatLists(0); + updateAllActvCheatLists (0); } -static void cheat_cell_edited_cb1 (GtkCellRendererText *cell, - gchar *path_string, - gchar *new_text, - cheat_win_t *cw ) +static void cheat_cell_edited_cb1 (GtkCellRendererText * cell, + gchar * path_string, + gchar * new_text, cheat_win_t * cw) { - long int row_idx = -1; + long int row_idx = -1; - //printf("'%s'\n", path_string ); - //printf("'%s'\n", new_text ); - //printf("%p\n", user_data ); + //printf("'%s'\n", path_string ); + //printf("'%s'\n", new_text ); + //printf("%p\n", user_data ); - if ( isdigit(path_string[0]) ) - { - row_idx = atoi(path_string); - } - - if ( row_idx >= 0 ) + if (isdigit (path_string[0])) { - uint32 a; uint8 v; - int c, s, type; - const char *name = NULL; - if ( FCEUI_GetCheat( row_idx, NULL, &a, &v, &c, &s, &type) ) - { - a = strtol( new_text, NULL, 0 ); - FCEUI_SetCheat( row_idx, name, a, v, c, s, type ); - updateAllActvCheatLists(0); - } - } -} + row_idx = atoi (path_string); + } -static void cheat_cell_edited_cb2 (GtkCellRendererText *cell, - gchar *path_string, - gchar *new_text, - cheat_win_t *cw ) -{ - long int row_idx = -1; - - //printf("'%s'\n", path_string ); - //printf("'%s'\n", new_text ); - //printf("%p\n", user_data ); - - if ( isdigit(path_string[0]) ) - { - row_idx = atoi(path_string); - } - - if ( row_idx >= 0 ) + if (row_idx >= 0) { - uint32 a; uint8 v; + uint32 a; + uint8 v; int c, s, type; - const char *name = NULL; - if ( FCEUI_GetCheat( row_idx, NULL, &a, &v, &c, &s, &type) ) + const char *name = NULL; + if (FCEUI_GetCheat (row_idx, NULL, &a, &v, &c, &s, &type)) { - v = strtol( new_text, NULL, 0 ); - FCEUI_SetCheat( row_idx, name, a, v, c, s, type ); - updateAllActvCheatLists(0); + a = strtol (new_text, NULL, 0); + FCEUI_SetCheat (row_idx, name, a, v, c, s, type); + updateAllActvCheatLists (0); } - } + } } -static void cheat_cell_edited_cb3 (GtkCellRendererText *cell, - gchar *path_string, - gchar *new_text, - cheat_win_t *cw ) +static void cheat_cell_edited_cb2 (GtkCellRendererText * cell, + gchar * path_string, + gchar * new_text, cheat_win_t * cw) { - long int row_idx = -1; + long int row_idx = -1; - //printf("'%s'\n", path_string ); - //printf("'%s'\n", new_text ); - //printf("%p\n", user_data ); + //printf("'%s'\n", path_string ); + //printf("'%s'\n", new_text ); + //printf("%p\n", user_data ); - if ( isdigit(path_string[0]) ) - { - row_idx = atoi(path_string); - } - - if ( row_idx >= 0 ) + if (isdigit (path_string[0])) { - uint32 a; uint8 v; - int c, s, type; - const char *name = NULL; - if ( FCEUI_GetCheat( row_idx, NULL, &a, &v, &c, &s, &type) ) - { - c = strtol( new_text, NULL, 0 ); - FCEUI_SetCheat( row_idx, name, a, v, c, s, type ); - updateAllActvCheatLists(0); - } - } -} + row_idx = atoi (path_string); + } -static void cheat_cell_edited_cb4 (GtkCellRendererText *cell, - gchar *path_string, - gchar *new_text, - cheat_win_t *cw ) -{ - long int row_idx = -1; - - //printf("'%s'\n", path_string ); - //printf("'%s'\n", new_text ); - //printf("%p\n", user_data ); - - if ( isdigit(path_string[0]) ) - { - row_idx = atoi(path_string); - } - - if ( row_idx >= 0 ) + if (row_idx >= 0) { - uint32 a; uint8 v; + uint32 a; + uint8 v; int c, s, type; - const char *name = NULL; - if ( FCEUI_GetCheat( row_idx, NULL, &a, &v, &c, &s, &type) ) + const char *name = NULL; + if (FCEUI_GetCheat (row_idx, NULL, &a, &v, &c, &s, &type)) { - name = new_text; - FCEUI_SetCheat( row_idx, name, a, v, c, s, type ); - updateAllActvCheatLists(0); + v = strtol (new_text, NULL, 0); + FCEUI_SetCheat (row_idx, name, a, v, c, s, type); + updateAllActvCheatLists (0); } - } + } } -static void updateAllActvCheatLists( bool redraw ) +static void cheat_cell_edited_cb3 (GtkCellRendererText * cell, + gchar * path_string, + gchar * new_text, cheat_win_t * cw) { - std::list ::iterator it; + long int row_idx = -1; - for (it=cheatWinList.begin(); it != cheatWinList.end(); it++) - { - (*it)->showActiveCheatList( redraw ); - } + //printf("'%s'\n", path_string ); + //printf("'%s'\n", new_text ); + //printf("%p\n", user_data ); + + if (isdigit (path_string[0])) + { + row_idx = atoi (path_string); + } + + if (row_idx >= 0) + { + uint32 a; + uint8 v; + int c, s, type; + const char *name = NULL; + if (FCEUI_GetCheat (row_idx, NULL, &a, &v, &c, &s, &type)) + { + c = strtol (new_text, NULL, 0); + FCEUI_SetCheat (row_idx, name, a, v, c, s, type); + updateAllActvCheatLists (0); + } + } } -static void closeCheatDialog(GtkWidget* w, GdkEvent* e, gpointer p) +static void cheat_cell_edited_cb4 (GtkCellRendererText * cell, + gchar * path_string, + gchar * new_text, cheat_win_t * cw) { - std::list ::iterator it; - cheat_win_t *cw = (cheat_win_t*)p; + long int row_idx = -1; - if ( EmulationPaused && cw->wasPausedByCheats ) - { - EmulationPaused = 0; - } + //printf("'%s'\n", path_string ); + //printf("'%s'\n", new_text ); + //printf("%p\n", user_data ); - for (it=cheatWinList.begin(); it != cheatWinList.end(); it++) - { - if ( cw == *it ) - { - //printf("Removing Cheat Window %p from List\n", cw); - cheatWinList.erase(it); break; - } - } - //printf("Number of Cheat Windows Still Open: %zi\n", cheatWinList.size() ); + if (isdigit (path_string[0])) + { + row_idx = atoi (path_string); + } - delete cw; + if (row_idx >= 0) + { + uint32 a; + uint8 v; + int c, s, type; + const char *name = NULL; + if (FCEUI_GetCheat (row_idx, NULL, &a, &v, &c, &s, &type)) + { + name = new_text; + FCEUI_SetCheat (row_idx, name, a, v, c, s, type); + updateAllActvCheatLists (0); + } + } +} - gtk_widget_destroy(w); +static void updateAllActvCheatLists (bool redraw) +{ + std::list < cheat_win_t * >::iterator it; + + for (it = cheatWinList.begin (); it != cheatWinList.end (); it++) + { + (*it)->showActiveCheatList (redraw); + } +} + +static void closeCheatDialog (GtkWidget * w, GdkEvent * e, gpointer p) +{ + std::list < cheat_win_t * >::iterator it; + cheat_win_t *cw = (cheat_win_t *) p; + + if (EmulationPaused && cw->wasPausedByCheats) + { + EmulationPaused = 0; + } + + for (it = cheatWinList.begin (); it != cheatWinList.end (); it++) + { + if (cw == *it) + { + //printf("Removing Cheat Window %p from List\n", cw); + cheatWinList.erase (it); + break; + } + } + //printf("Number of Cheat Windows Still Open: %zi\n", cheatWinList.size() ); + + delete cw; + + gtk_widget_destroy (w); } // creates and opens cheats window -void openCheatsWindow(void) +void openCheatsWindow (void) { - GtkWidget* win; - GtkWidget* main_hbox; - GtkWidget* hbox; - GtkWidget* vbox, *prev_cmp_vbox; - GtkWidget* frame; - GtkWidget* label, *txt_entry; - GtkWidget* button; + GtkWidget *win; + GtkWidget *main_hbox; + GtkWidget *hbox; + GtkWidget *vbox, *prev_cmp_vbox; + GtkWidget *frame; + GtkWidget *label, *txt_entry; + GtkWidget *button; GtkWidget *scroll; - cheat_win_t *cw = new cheat_win_t; + cheat_win_t *cw = new cheat_win_t; - cheatWinList.push_back(cw); + cheatWinList.push_back (cw); - win = gtk_dialog_new_with_buttons("Cheats", - GTK_WINDOW(MainWindow), (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT), - "_Close", - GTK_RESPONSE_OK, - NULL); - gtk_window_set_default_size(GTK_WINDOW(win), 600, 600); + win = gtk_dialog_new_with_buttons ("Cheats", + GTK_WINDOW (MainWindow), + (GtkDialogFlags) + (GTK_DIALOG_DESTROY_WITH_PARENT), + "_Close", GTK_RESPONSE_OK, NULL); + gtk_window_set_default_size (GTK_WINDOW (win), 600, 600); - main_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); - vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); - frame = gtk_frame_new("Active Cheats"); - - cw->actv_cheats_store = gtk_tree_store_new( 5, G_TYPE_BOOLEAN, - G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING ); + main_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); + vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5); + frame = gtk_frame_new ("Active Cheats"); - cw->actv_cheat_tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(cw->actv_cheats_store)); + cw->actv_cheats_store = gtk_tree_store_new (5, G_TYPE_BOOLEAN, + G_TYPE_STRING, + G_TYPE_STRING, + G_TYPE_STRING, + G_TYPE_STRING); + + cw->actv_cheat_tree = + gtk_tree_view_new_with_model (GTK_TREE_MODEL + (cw->actv_cheats_store)); GtkCellRenderer *renderer; GtkCellRenderer *chkbox_renderer; - GtkTreeViewColumn* column; - - gtk_tree_view_set_grid_lines( GTK_TREE_VIEW(cw->actv_cheat_tree), GTK_TREE_VIEW_GRID_LINES_VERTICAL ); + GtkTreeViewColumn *column; - chkbox_renderer = gtk_cell_renderer_toggle_new(); - gtk_cell_renderer_toggle_set_activatable( (GtkCellRendererToggle*)chkbox_renderer, TRUE ); - column = gtk_tree_view_column_new_with_attributes("Ena", chkbox_renderer, "active", 0, NULL); - gtk_tree_view_append_column(GTK_TREE_VIEW(cw->actv_cheat_tree), column); + gtk_tree_view_set_grid_lines (GTK_TREE_VIEW (cw->actv_cheat_tree), + GTK_TREE_VIEW_GRID_LINES_VERTICAL); - renderer = gtk_cell_renderer_text_new(); - g_object_set(renderer, "family", "MonoSpace", NULL); - g_object_set(renderer, "editable", TRUE, NULL); - g_signal_connect(renderer, "edited", (GCallback) cheat_cell_edited_cb1, (gpointer)cw); - column = gtk_tree_view_column_new_with_attributes("Addr", renderer, "text", 1, NULL); - gtk_tree_view_append_column(GTK_TREE_VIEW(cw->actv_cheat_tree), column); + chkbox_renderer = gtk_cell_renderer_toggle_new (); + gtk_cell_renderer_toggle_set_activatable ((GtkCellRendererToggle *) + chkbox_renderer, TRUE); + column = gtk_tree_view_column_new_with_attributes ("Ena", + chkbox_renderer, + "active", 0, NULL); + gtk_tree_view_append_column (GTK_TREE_VIEW (cw->actv_cheat_tree), + column); - renderer = gtk_cell_renderer_text_new(); - g_object_set(renderer, "family", "MonoSpace", NULL); - g_object_set(renderer, "editable", TRUE, NULL); - g_signal_connect(renderer, "edited", (GCallback) cheat_cell_edited_cb2, (gpointer)cw); - column = gtk_tree_view_column_new_with_attributes("Val", renderer, "text", 2, NULL); - gtk_tree_view_append_column(GTK_TREE_VIEW(cw->actv_cheat_tree), column); + renderer = gtk_cell_renderer_text_new (); + g_object_set (renderer, "family", "MonoSpace", NULL); + g_object_set (renderer, "editable", TRUE, NULL); + g_signal_connect (renderer, "edited", (GCallback) cheat_cell_edited_cb1, + (gpointer) cw); + column = gtk_tree_view_column_new_with_attributes ("Addr", renderer, + "text", 1, NULL); + gtk_tree_view_append_column (GTK_TREE_VIEW (cw->actv_cheat_tree), + column); - renderer = gtk_cell_renderer_text_new(); - g_object_set(renderer, "family", "MonoSpace", NULL); - g_object_set(renderer, "editable", TRUE, NULL); - g_signal_connect(renderer, "edited", (GCallback) cheat_cell_edited_cb3, (gpointer)cw); - column = gtk_tree_view_column_new_with_attributes("Cmp", renderer, "text", 3, NULL); - gtk_tree_view_append_column(GTK_TREE_VIEW(cw->actv_cheat_tree), column); + renderer = gtk_cell_renderer_text_new (); + g_object_set (renderer, "family", "MonoSpace", NULL); + g_object_set (renderer, "editable", TRUE, NULL); + g_signal_connect (renderer, "edited", (GCallback) cheat_cell_edited_cb2, + (gpointer) cw); + column = gtk_tree_view_column_new_with_attributes ("Val", renderer, + "text", 2, NULL); + gtk_tree_view_append_column (GTK_TREE_VIEW (cw->actv_cheat_tree), + column); - renderer = gtk_cell_renderer_text_new(); - g_object_set(renderer, "editable", TRUE, NULL); - g_signal_connect(renderer, "edited", (GCallback) cheat_cell_edited_cb4, (gpointer)cw); - column = gtk_tree_view_column_new_with_attributes("Desc", renderer, "text", 4, NULL); - gtk_tree_view_append_column(GTK_TREE_VIEW(cw->actv_cheat_tree), column); - - g_signal_connect( chkbox_renderer, "toggled", - G_CALLBACK(cheatListEnableToggle), (void*)cw ); + renderer = gtk_cell_renderer_text_new (); + g_object_set (renderer, "family", "MonoSpace", NULL); + g_object_set (renderer, "editable", TRUE, NULL); + g_signal_connect (renderer, "edited", (GCallback) cheat_cell_edited_cb3, + (gpointer) cw); + column = gtk_tree_view_column_new_with_attributes ("Cmp", renderer, + "text", 3, NULL); + gtk_tree_view_append_column (GTK_TREE_VIEW (cw->actv_cheat_tree), + column); - updateAllActvCheatLists(1); + renderer = gtk_cell_renderer_text_new (); + g_object_set (renderer, "editable", TRUE, NULL); + g_signal_connect (renderer, "edited", (GCallback) cheat_cell_edited_cb4, + (gpointer) cw); + column = gtk_tree_view_column_new_with_attributes ("Desc", renderer, + "text", 4, NULL); + gtk_tree_view_append_column (GTK_TREE_VIEW (cw->actv_cheat_tree), + column); - scroll = gtk_scrolled_window_new(NULL, NULL); - gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, - GTK_POLICY_AUTOMATIC); - gtk_container_add(GTK_CONTAINER(scroll), cw->actv_cheat_tree); - gtk_box_pack_start(GTK_BOX(vbox), scroll, TRUE, TRUE, 1); + g_signal_connect (chkbox_renderer, "toggled", + G_CALLBACK (cheatListEnableToggle), (void *) cw); - hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); - label = gtk_label_new("Name:"); - txt_entry = gtk_entry_new(); + updateAllActvCheatLists (1); - g_signal_connect( txt_entry, "activate", - G_CALLBACK(newCheatEntryCB4), (void*)cw ); - g_signal_connect( txt_entry, "changed", - G_CALLBACK(newCheatEntryCB4), (void*)cw ); + scroll = gtk_scrolled_window_new (NULL, NULL); + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), + GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); + gtk_container_add (GTK_CONTAINER (scroll), cw->actv_cheat_tree); + gtk_box_pack_start (GTK_BOX (vbox), scroll, TRUE, TRUE, 1); - gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 1); - gtk_box_pack_start(GTK_BOX(hbox), txt_entry, TRUE, TRUE, 1); + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); + label = gtk_label_new ("Name:"); + txt_entry = gtk_entry_new (); - gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 1); + g_signal_connect (txt_entry, "activate", + G_CALLBACK (newCheatEntryCB4), (void *) cw); + g_signal_connect (txt_entry, "changed", + G_CALLBACK (newCheatEntryCB4), (void *) cw); - hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6); - label = gtk_label_new("Addr:"); - txt_entry = gtk_entry_new(); - gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 4 ); - gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 4 ); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 1); + gtk_box_pack_start (GTK_BOX (hbox), txt_entry, TRUE, TRUE, 1); - g_signal_connect( txt_entry, "activate", - G_CALLBACK(newCheatEntryCB1), (void*)cw ); - g_signal_connect( txt_entry, "changed", - G_CALLBACK(newCheatEntryCB1), (void*)cw ); + gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 1); - gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 1); - gtk_box_pack_start(GTK_BOX(hbox), txt_entry, TRUE, TRUE, 1); + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); + label = gtk_label_new ("Addr:"); + txt_entry = gtk_entry_new (); + gtk_entry_set_max_length (GTK_ENTRY (txt_entry), 4); + gtk_entry_set_width_chars (GTK_ENTRY (txt_entry), 4); - label = gtk_label_new("Val:"); - txt_entry = gtk_entry_new(); - gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 2 ); - gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 2 ); + g_signal_connect (txt_entry, "activate", + G_CALLBACK (newCheatEntryCB1), (void *) cw); + g_signal_connect (txt_entry, "changed", + G_CALLBACK (newCheatEntryCB1), (void *) cw); - g_signal_connect( txt_entry, "activate", - G_CALLBACK(newCheatEntryCB2), (void*)cw ); - g_signal_connect( txt_entry, "changed", - G_CALLBACK(newCheatEntryCB2), (void*)cw ); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 1); + gtk_box_pack_start (GTK_BOX (hbox), txt_entry, TRUE, TRUE, 1); - gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 1); - gtk_box_pack_start(GTK_BOX(hbox), txt_entry, TRUE, TRUE, 1); + label = gtk_label_new ("Val:"); + txt_entry = gtk_entry_new (); + gtk_entry_set_max_length (GTK_ENTRY (txt_entry), 2); + gtk_entry_set_width_chars (GTK_ENTRY (txt_entry), 2); - label = gtk_label_new("Cmp:"); - txt_entry = gtk_entry_new(); - gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 2 ); - gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 2 ); + g_signal_connect (txt_entry, "activate", + G_CALLBACK (newCheatEntryCB2), (void *) cw); + g_signal_connect (txt_entry, "changed", + G_CALLBACK (newCheatEntryCB2), (void *) cw); - g_signal_connect( txt_entry, "activate", - G_CALLBACK(newCheatEntryCB3), (void*)cw ); - g_signal_connect( txt_entry, "changed", - G_CALLBACK(newCheatEntryCB3), (void*)cw ); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 1); + gtk_box_pack_start (GTK_BOX (hbox), txt_entry, TRUE, TRUE, 1); - gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 1); - gtk_box_pack_start(GTK_BOX(hbox), txt_entry, TRUE, TRUE, 1); + label = gtk_label_new ("Cmp:"); + txt_entry = gtk_entry_new (); + gtk_entry_set_max_length (GTK_ENTRY (txt_entry), 2); + gtk_entry_set_width_chars (GTK_ENTRY (txt_entry), 2); - gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 1); + g_signal_connect (txt_entry, "activate", + G_CALLBACK (newCheatEntryCB3), (void *) cw); + g_signal_connect (txt_entry, "changed", + G_CALLBACK (newCheatEntryCB3), (void *) cw); - hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); - button = gtk_button_new_with_label("Add"); - gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, FALSE, 1); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 1); + gtk_box_pack_start (GTK_BOX (hbox), txt_entry, TRUE, TRUE, 1); - g_signal_connect( button, "clicked", - G_CALLBACK (addCheat2Active), (gpointer) cw ); + gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 1); - button = gtk_button_new_with_label("Delete"); - gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, FALSE, 1); + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3); + button = gtk_button_new_with_label ("Add"); + gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, FALSE, 1); - g_signal_connect( button, "clicked", - G_CALLBACK (removeCheatFromActive), (gpointer) cw ); + g_signal_connect (button, "clicked", + G_CALLBACK (addCheat2Active), (gpointer) cw); - button = gtk_button_new_with_label("Update"); - gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, FALSE, 1); + button = gtk_button_new_with_label ("Delete"); + gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, FALSE, 1); - g_signal_connect( button, "clicked", - G_CALLBACK (updateCheatList), (gpointer) cw ); + g_signal_connect (button, "clicked", + G_CALLBACK (removeCheatFromActive), (gpointer) cw); - gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 1); + button = gtk_button_new_with_label ("Update"); + gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, FALSE, 1); - hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1); - button = gtk_button_new_with_label("Add from CHT file..."); - gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, FALSE, 1); - g_signal_connect( button, "clicked", - G_CALLBACK (openCheatFile), (gpointer) cw ); + g_signal_connect (button, "clicked", + G_CALLBACK (updateCheatList), (gpointer) cw); - gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 1); + gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 1); - gtk_container_add(GTK_CONTAINER(frame), vbox); + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 1); + button = gtk_button_new_with_label ("Add from CHT file..."); + gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, FALSE, 1); + g_signal_connect (button, "clicked", + G_CALLBACK (openCheatFile), (gpointer) cw); + + gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 1); + + gtk_container_add (GTK_CONTAINER (frame), vbox); // - gtk_box_pack_start(GTK_BOX(main_hbox), frame, TRUE, TRUE, 1); + gtk_box_pack_start (GTK_BOX (main_hbox), frame, TRUE, TRUE, 1); - vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); - hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1); - button = gtk_button_new_with_label("Reset"); - g_signal_connect( button, "clicked", - G_CALLBACK (cheatSearchReset), (gpointer) cw ); - gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 5); + vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5); + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 1); + button = gtk_button_new_with_label ("Reset"); + g_signal_connect (button, "clicked", + G_CALLBACK (cheatSearchReset), (gpointer) cw); + gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 5); - gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5); + gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 5); - hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); - button = gtk_button_new_with_label("Known Value:"); - g_signal_connect( button, "clicked", - G_CALLBACK (cheatSearchKnown), (gpointer) cw ); - gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 5); - label = gtk_label_new("0x"); - txt_entry = gtk_entry_new(); - gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 2 ); - gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 2 ); + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3); + button = gtk_button_new_with_label ("Known Value:"); + g_signal_connect (button, "clicked", + G_CALLBACK (cheatSearchKnown), (gpointer) cw); + gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 5); + label = gtk_label_new ("0x"); + txt_entry = gtk_entry_new (); + gtk_entry_set_max_length (GTK_ENTRY (txt_entry), 2); + gtk_entry_set_width_chars (GTK_ENTRY (txt_entry), 2); - g_signal_connect( txt_entry, "activate", - G_CALLBACK(cheatSearchValueEntryCB1), (void*)cw ); - g_signal_connect( txt_entry, "changed", - G_CALLBACK(cheatSearchValueEntryCB1), (void*)cw ); - gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5); - gtk_box_pack_start(GTK_BOX(hbox), txt_entry, FALSE, FALSE, 5); + g_signal_connect (txt_entry, "activate", + G_CALLBACK (cheatSearchValueEntryCB1), (void *) cw); + g_signal_connect (txt_entry, "changed", + G_CALLBACK (cheatSearchValueEntryCB1), (void *) cw); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 5); + gtk_box_pack_start (GTK_BOX (hbox), txt_entry, FALSE, FALSE, 5); - gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5); + gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 5); - frame = gtk_frame_new("Previous Compare"); - gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5); - button = gtk_check_button_new_with_label("Pause emulation when this window is active"); - gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 5); - g_signal_connect( button, "clicked", - G_CALLBACK (pauseDuringCheatWinActvCB), (gpointer) cw ); + frame = gtk_frame_new ("Previous Compare"); + gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 5); + button = gtk_check_button_new_with_label + ("Pause emulation when this window is active"); + gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 5); + g_signal_connect (button, "clicked", + G_CALLBACK (pauseDuringCheatWinActvCB), + (gpointer) cw); - prev_cmp_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4); - gtk_container_add(GTK_CONTAINER(frame), prev_cmp_vbox); + prev_cmp_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4); + gtk_container_add (GTK_CONTAINER (frame), prev_cmp_vbox); - hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1); - button = gtk_button_new_with_label("Equal"); + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 1); + button = gtk_button_new_with_label ("Equal"); //gtk_widget_set_halign( button, GTK_ALIGN_BASELINE); - - gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 5); - gtk_box_pack_start(GTK_BOX(prev_cmp_vbox), hbox, FALSE, FALSE, 5); - g_signal_connect( button, "clicked", - G_CALLBACK (cheatSearchEqual), (gpointer) cw ); - hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); - button = gtk_button_new_with_label("Not Equal"); + gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5); + gtk_box_pack_start (GTK_BOX (prev_cmp_vbox), hbox, FALSE, FALSE, 5); + g_signal_connect (button, "clicked", + G_CALLBACK (cheatSearchEqual), (gpointer) cw); + + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); + button = gtk_button_new_with_label ("Not Equal"); //gtk_widget_set_halign( button, GTK_ALIGN_BASELINE); - gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 5); - cw->neq_chkbox = gtk_check_button_new(); - gtk_box_pack_start(GTK_BOX(hbox), cw->neq_chkbox, FALSE, FALSE, 5); - g_signal_connect( button, "clicked", - G_CALLBACK (cheatSearchNotEqual), (gpointer) cw ); - label = gtk_label_new("By: 0x"); - gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5); - txt_entry = gtk_entry_new(); - gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 2 ); - gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 2 ); - g_signal_connect( txt_entry, "activate", - G_CALLBACK(cheatSearchValueEntryCB2), (void*)cw ); - g_signal_connect( txt_entry, "changed", - G_CALLBACK(cheatSearchValueEntryCB2), (void*)cw ); - gtk_box_pack_start(GTK_BOX(hbox), txt_entry, FALSE, FALSE, 5); + gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5); + cw->neq_chkbox = gtk_check_button_new (); + gtk_box_pack_start (GTK_BOX (hbox), cw->neq_chkbox, FALSE, FALSE, 5); + g_signal_connect (button, "clicked", + G_CALLBACK (cheatSearchNotEqual), (gpointer) cw); + label = gtk_label_new ("By: 0x"); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 5); + txt_entry = gtk_entry_new (); + gtk_entry_set_max_length (GTK_ENTRY (txt_entry), 2); + gtk_entry_set_width_chars (GTK_ENTRY (txt_entry), 2); + g_signal_connect (txt_entry, "activate", + G_CALLBACK (cheatSearchValueEntryCB2), (void *) cw); + g_signal_connect (txt_entry, "changed", + G_CALLBACK (cheatSearchValueEntryCB2), (void *) cw); + gtk_box_pack_start (GTK_BOX (hbox), txt_entry, FALSE, FALSE, 5); - gtk_box_pack_start(GTK_BOX(prev_cmp_vbox), hbox, FALSE, FALSE, 5); + gtk_box_pack_start (GTK_BOX (prev_cmp_vbox), hbox, FALSE, FALSE, 5); - hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); - button = gtk_button_new_with_label("Greater Than"); + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); + button = gtk_button_new_with_label ("Greater Than"); //gtk_widget_set_halign( button, GTK_ALIGN_BASELINE); - gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 5); - cw->gt_chkbox = gtk_check_button_new(); - g_signal_connect( button, "clicked", - G_CALLBACK (cheatSearchGreaterThan), (gpointer) cw ); - gtk_box_pack_start(GTK_BOX(hbox), cw->gt_chkbox, FALSE, FALSE, 5); - label = gtk_label_new("By: 0x"); - gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5); - txt_entry = gtk_entry_new(); - gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 2 ); - gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 2 ); - g_signal_connect( txt_entry, "activate", - G_CALLBACK(cheatSearchValueEntryCB3), (void*)cw ); - g_signal_connect( txt_entry, "changed", - G_CALLBACK(cheatSearchValueEntryCB3), (void*)cw ); - gtk_box_pack_start(GTK_BOX(hbox), txt_entry, FALSE, FALSE, 5); + gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5); + cw->gt_chkbox = gtk_check_button_new (); + g_signal_connect (button, "clicked", + G_CALLBACK (cheatSearchGreaterThan), (gpointer) cw); + gtk_box_pack_start (GTK_BOX (hbox), cw->gt_chkbox, FALSE, FALSE, 5); + label = gtk_label_new ("By: 0x"); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 5); + txt_entry = gtk_entry_new (); + gtk_entry_set_max_length (GTK_ENTRY (txt_entry), 2); + gtk_entry_set_width_chars (GTK_ENTRY (txt_entry), 2); + g_signal_connect (txt_entry, "activate", + G_CALLBACK (cheatSearchValueEntryCB3), (void *) cw); + g_signal_connect (txt_entry, "changed", + G_CALLBACK (cheatSearchValueEntryCB3), (void *) cw); + gtk_box_pack_start (GTK_BOX (hbox), txt_entry, FALSE, FALSE, 5); - gtk_box_pack_start(GTK_BOX(prev_cmp_vbox), hbox, FALSE, FALSE, 5); + gtk_box_pack_start (GTK_BOX (prev_cmp_vbox), hbox, FALSE, FALSE, 5); - hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); - button = gtk_button_new_with_label("Less Than"); + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); + button = gtk_button_new_with_label ("Less Than"); //gtk_widget_set_halign( button, GTK_ALIGN_BASELINE); - gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 5); - cw->lt_chkbox = gtk_check_button_new(); - g_signal_connect( button, "clicked", - G_CALLBACK (cheatSearchLessThan), (gpointer) cw ); - gtk_box_pack_start(GTK_BOX(hbox), cw->lt_chkbox, FALSE, FALSE, 5); - label = gtk_label_new("By: 0x"); - gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5); - txt_entry = gtk_entry_new(); - gtk_entry_set_max_length( GTK_ENTRY(txt_entry), 2 ); - gtk_entry_set_width_chars( GTK_ENTRY(txt_entry), 2 ); - g_signal_connect( txt_entry, "activate", - G_CALLBACK(cheatSearchValueEntryCB4), (void*)cw ); - g_signal_connect( txt_entry, "changed", - G_CALLBACK(cheatSearchValueEntryCB4), (void*)cw ); - gtk_box_pack_start(GTK_BOX(hbox), txt_entry, FALSE, FALSE, 5); + gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5); + cw->lt_chkbox = gtk_check_button_new (); + g_signal_connect (button, "clicked", + G_CALLBACK (cheatSearchLessThan), (gpointer) cw); + gtk_box_pack_start (GTK_BOX (hbox), cw->lt_chkbox, FALSE, FALSE, 5); + label = gtk_label_new ("By: 0x"); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 5); + txt_entry = gtk_entry_new (); + gtk_entry_set_max_length (GTK_ENTRY (txt_entry), 2); + gtk_entry_set_width_chars (GTK_ENTRY (txt_entry), 2); + g_signal_connect (txt_entry, "activate", + G_CALLBACK (cheatSearchValueEntryCB4), (void *) cw); + g_signal_connect (txt_entry, "changed", + G_CALLBACK (cheatSearchValueEntryCB4), (void *) cw); + gtk_box_pack_start (GTK_BOX (hbox), txt_entry, FALSE, FALSE, 5); - gtk_box_pack_start(GTK_BOX(prev_cmp_vbox), hbox, FALSE, FALSE, 1); + gtk_box_pack_start (GTK_BOX (prev_cmp_vbox), hbox, FALSE, FALSE, 1); - hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); - gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 1); + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); + gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 1); - frame = gtk_frame_new("Cheat Search"); - gtk_container_add(GTK_CONTAINER(frame), hbox); - gtk_box_pack_start(GTK_BOX(main_hbox), frame, TRUE, TRUE, 5); + frame = gtk_frame_new ("Cheat Search"); + gtk_container_add (GTK_CONTAINER (frame), hbox); + gtk_box_pack_start (GTK_BOX (main_hbox), frame, TRUE, TRUE, 5); - vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); + vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5); //hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1); - cw->ram_match_store = gtk_tree_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); + cw->ram_match_store = + gtk_tree_store_new (3, G_TYPE_STRING, G_TYPE_STRING, + G_TYPE_STRING); - cw->search_cheat_tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(cw->ram_match_store)); + cw->search_cheat_tree = + gtk_tree_view_new_with_model (GTK_TREE_MODEL + (cw->ram_match_store)); - gtk_tree_view_set_grid_lines( GTK_TREE_VIEW(cw->search_cheat_tree), GTK_TREE_VIEW_GRID_LINES_VERTICAL ); + gtk_tree_view_set_grid_lines (GTK_TREE_VIEW (cw->search_cheat_tree), + GTK_TREE_VIEW_GRID_LINES_VERTICAL); - renderer = gtk_cell_renderer_text_new(); - g_object_set(renderer, "family", "MonoSpace", NULL); - column = gtk_tree_view_column_new_with_attributes("Addr", renderer, "text", 0, NULL); - gtk_tree_view_append_column(GTK_TREE_VIEW(cw->search_cheat_tree), column); - column = gtk_tree_view_column_new_with_attributes("Last", renderer, "text", 1, NULL); - gtk_tree_view_append_column(GTK_TREE_VIEW(cw->search_cheat_tree), column); - column = gtk_tree_view_column_new_with_attributes("Curr", renderer, "text", 2, NULL); - gtk_tree_view_append_column(GTK_TREE_VIEW(cw->search_cheat_tree), column); - - scroll = gtk_scrolled_window_new(NULL, NULL); - gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, - GTK_POLICY_AUTOMATIC); - gtk_container_add(GTK_CONTAINER(scroll), cw->search_cheat_tree); - gtk_box_pack_start(GTK_BOX(vbox), scroll, TRUE, TRUE, 5); + renderer = gtk_cell_renderer_text_new (); + g_object_set (renderer, "family", "MonoSpace", NULL); + column = gtk_tree_view_column_new_with_attributes ("Addr", renderer, + "text", 0, NULL); + gtk_tree_view_append_column (GTK_TREE_VIEW (cw->search_cheat_tree), + column); + column = gtk_tree_view_column_new_with_attributes ("Last", renderer, + "text", 1, NULL); + gtk_tree_view_append_column (GTK_TREE_VIEW (cw->search_cheat_tree), + column); + column = gtk_tree_view_column_new_with_attributes ("Curr", renderer, + "text", 2, NULL); + gtk_tree_view_append_column (GTK_TREE_VIEW (cw->search_cheat_tree), + column); - frame = gtk_frame_new(""); - gtk_container_add(GTK_CONTAINER(frame), vbox); + scroll = gtk_scrolled_window_new (NULL, NULL); + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), + GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); + gtk_container_add (GTK_CONTAINER (scroll), cw->search_cheat_tree); + gtk_box_pack_start (GTK_BOX (vbox), scroll, TRUE, TRUE, 5); - gtk_box_pack_start(GTK_BOX(hbox), frame, TRUE, TRUE, 5); + frame = gtk_frame_new (""); + gtk_container_add (GTK_CONTAINER (frame), vbox); - gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(win))), main_hbox, TRUE, TRUE, 0); + gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 5); - g_signal_connect(win, "delete-event", G_CALLBACK(closeCheatDialog), cw); - g_signal_connect(win, "response", G_CALLBACK(closeCheatDialog), cw); - - gtk_widget_show_all(win); + gtk_box_pack_start (GTK_BOX + (gtk_dialog_get_content_area (GTK_DIALOG (win))), + main_hbox, TRUE, TRUE, 0); - //printf("Added Cheat Window %p. Number of Cheat Windows Open: %zi\n", cw, cheatWinList.size() ); + g_signal_connect (win, "delete-event", G_CALLBACK (closeCheatDialog), + cw); + g_signal_connect (win, "response", G_CALLBACK (closeCheatDialog), cw); + + gtk_widget_show_all (win); + + //printf("Added Cheat Window %p. Number of Cheat Windows Open: %zi\n", cw, cheatWinList.size() ); } diff --git a/src/drivers/sdl/ramwatch.cpp b/src/drivers/sdl/ramwatch.cpp index 3b721998..4fde04c7 100644 --- a/src/drivers/sdl/ramwatch.cpp +++ b/src/drivers/sdl/ramwatch.cpp @@ -39,150 +39,158 @@ extern Config *g_config; // struct ramWatch_t { - std::string name; - int addr; - int type; - int size; + std::string name; + int addr; + int type; + int size; - union { - int8_t i8; - uint8_t u8; - int16_t i16; - uint16_t u16; - } val; + union + { + int8_t i8; + uint8_t u8; + int16_t i16; + uint16_t u16; + } val; - ramWatch_t(void) - { - addr = 0; type = 0; size = 0; val.u16 = 0; - }; + ramWatch_t (void) + { + addr = 0; + type = 0; + size = 0; + val.u16 = 0; + }; - void updateMem(void) - { - if ( size == 1) - { - val.u8 = GetMem( addr ); - } - else if ( size == 2) - { - val.u16 = GetMem( addr ) | (GetMem( addr+1 ) << 8); - } - else - { - val.u8 = GetMem( addr ); - } - } + void updateMem (void) + { + if (size == 1) + { + val.u8 = GetMem (addr); + } + else if (size == 2) + { + val.u16 = GetMem (addr) | (GetMem (addr + 1) << 8); + } + else + { + val.u8 = GetMem (addr); + } + } }; struct ramWatchList_t { - std::list ls; + std::list < ramWatch_t * >ls; - ramWatchList_t(void) - { + ramWatchList_t (void) + { - } + } - ~ramWatchList_t(void) - { - ramWatch_t *rw; + ~ramWatchList_t (void) + { + ramWatch_t *rw; - while ( !ls.empty() ) - { - rw = ls.front(); + while (!ls.empty ()) + { + rw = ls.front (); - delete rw; + delete rw; - ls.pop_front(); - } - } + ls.pop_front (); + } + } - size_t size(void){ return ls.size(); }; + size_t size (void) + { + return ls.size (); + }; - void add_entry( const char *name, int addr, int type, int size ) - { - ramWatch_t *rw = new ramWatch_t; + void add_entry (const char *name, int addr, int type, int size) + { + ramWatch_t *rw = new ramWatch_t; - rw->name.assign(name); - rw->addr = addr; - rw->type = type; - rw->size = size; - ls.push_back(rw); - } + rw->name.assign (name); + rw->addr = addr; + rw->type = type; + rw->size = size; + ls.push_back (rw); + } - void updateMemoryValues(void) - { - ramWatch_t *rw; - std::list ::iterator it; + void updateMemoryValues (void) + { + ramWatch_t *rw; + std::list < ramWatch_t * >::iterator it; - for (it=ls.begin(); it!=ls.end(); it++) - { - rw = *it; + for (it = ls.begin (); it != ls.end (); it++) + { + rw = *it; - rw->updateMem(); - } - } + rw->updateMem (); + } + } - ramWatch_t *getIndex(size_t idx) - { - size_t i=0; - std::list ::iterator it; + ramWatch_t *getIndex (size_t idx) + { + size_t i = 0; + std::list < ramWatch_t * >::iterator it; - for (it=ls.begin(); it!=ls.end(); it++) - { - if ( i == idx ) - { - return *it; - } - i++; - } - return NULL; - } + for (it = ls.begin (); it != ls.end (); it++) + { + if (i == idx) + { + return *it; + } + i++; + } + return NULL; + } - int deleteIndex(size_t idx) - { - size_t i=0; - std::list ::iterator it; + int deleteIndex (size_t idx) + { + size_t i = 0; + std::list < ramWatch_t * >::iterator it; - for (it=ls.begin(); it!=ls.end(); it++) - { - if ( i == idx ) - { - delete *it; - ls.erase(it); - return 0; - } - i++; - } - return -1; - } + for (it = ls.begin (); it != ls.end (); it++) + { + if (i == idx) + { + delete *it; + ls.erase (it); + return 0; + } + i++; + } + return -1; + } }; + static ramWatchList_t ramWatchList; struct ramWatchWin_t; struct ramWatchEntryWin_t { - GtkWidget* win; - GtkWidget* chkbox; - GtkWidget* button1, *button2, *button4; + GtkWidget *win; + GtkWidget *chkbox; + GtkWidget *button1, *button2, *button4; GtkWidget *txt_entry_name; GtkWidget *txt_entry_addr; - ramWatchWin_t *rww; - int idx; + ramWatchWin_t *rww; + int idx; - ramWatchEntryWin_t(void) - { - win = NULL; + ramWatchEntryWin_t (void) + { + win = NULL; chkbox = NULL; button1 = NULL; - button2 = NULL; - button4 = NULL; + button2 = NULL; + button4 = NULL; txt_entry_name = NULL; txt_entry_addr = NULL; - rww = NULL; - idx = -1; - } + rww = NULL; + idx = -1; + } }; struct ramWatchWin_t @@ -190,421 +198,459 @@ struct ramWatchWin_t GtkWidget *win; GtkWidget *tree; - GtkTreeStore *ram_watch_store; - bool ramWatchWinOpen; - int ramWatchEditRowIdx; - int ramWatchEditColIdx; + GtkTreeStore *ram_watch_store; + bool ramWatchWinOpen; + int ramWatchEditRowIdx; + int ramWatchEditColIdx; - ramWatchWin_t(void) - { - win = NULL; - tree = NULL; - ram_watch_store = NULL; - ramWatchWinOpen = false; - ramWatchEditRowIdx = -1; - ramWatchEditColIdx = -1; - } + ramWatchWin_t (void) + { + win = NULL; + tree = NULL; + ram_watch_store = NULL; + ramWatchWinOpen = false; + ramWatchEditRowIdx = -1; + ramWatchEditColIdx = -1; + } - void showRamWatchResults(int reset); + void showRamWatchResults (int reset); }; -static gint ramWatchEvntSrcID = 0; +static gint ramWatchEvntSrcID = 0; -void ramWatchWin_t::showRamWatchResults(int reset) +void ramWatchWin_t::showRamWatchResults (int reset) { - int row=0; - std::list ::iterator it; - GtkTreeIter iter; - char addrStr[32], valStr1[16], valStr2[16]; - ramWatch_t *rw; + int row = 0; + std::list < ramWatch_t * >::iterator it; + GtkTreeIter iter; + char addrStr[32], valStr1[16], valStr2[16]; + ramWatch_t *rw; - //if ( !reset ) - //{ - // if ( gtk_tree_model_get_iter_first( GTK_TREE_MODEL(ram_watch_store), &iter ) ) - // { - // size_t treeSize = 1; + //if ( !reset ) + //{ + // if ( gtk_tree_model_get_iter_first( GTK_TREE_MODEL(ram_watch_store), &iter ) ) + // { + // size_t treeSize = 1; - // while ( gtk_tree_model_iter_next( GTK_TREE_MODEL(ram_watch_store), &iter ) ) - // { - // treeSize++; - // } - // if ( treeSize != ramWatchList.size() ) - // { - // reset = 1; - // } - // //printf(" TreeSize: %zi RamWatchList.size: %zi \n", treeSize, ramWatchList.size() ); - // } - //} + // while ( gtk_tree_model_iter_next( GTK_TREE_MODEL(ram_watch_store), &iter ) ) + // { + // treeSize++; + // } + // if ( treeSize != ramWatchList.size() ) + // { + // reset = 1; + // } + // //printf(" TreeSize: %zi RamWatchList.size: %zi \n", treeSize, ramWatchList.size() ); + // } + //} - if ( reset ) - { - gtk_tree_store_clear(ram_watch_store); - } - else - { - if ( !gtk_tree_model_get_iter_first( GTK_TREE_MODEL(ram_watch_store), &iter ) ) - { - gtk_tree_store_append( ram_watch_store, &iter, NULL); // aquire iter - } - } + if (reset) + { + gtk_tree_store_clear (ram_watch_store); + } + else + { + if (!gtk_tree_model_get_iter_first + (GTK_TREE_MODEL (ram_watch_store), &iter)) + { + gtk_tree_store_append (ram_watch_store, &iter, NULL); // aquire iter + } + } - for (it=ramWatchList.ls.begin(); it!=ramWatchList.ls.end(); it++) - { - rw = *it; - sprintf( addrStr, "0x%04X", rw->addr ); + for (it = ramWatchList.ls.begin (); it != ramWatchList.ls.end (); it++) + { + rw = *it; + sprintf (addrStr, "0x%04X", rw->addr); - if ( reset ){ - gtk_tree_store_append( ram_watch_store, &iter, NULL); // aquire iter - } + if (reset) + { + gtk_tree_store_append (ram_watch_store, &iter, NULL); // aquire iter + } - rw->updateMem(); + rw->updateMem (); - if ( rw->size == 2 ) - { - if ( rw->type ){ - sprintf( valStr1, "%6u", rw->val.u16); - } else { - sprintf( valStr1, "%6i", rw->val.i16); - } - sprintf( valStr2, "0x%04X", rw->val.u16); - } - else - { - if ( rw->type ){ - sprintf( valStr1, "%6u", rw->val.u8); - } else { - sprintf( valStr1, "%6i", rw->val.i8); - } - sprintf( valStr2, "0x%02X", rw->val.u8); - } - - if ( row != ramWatchEditRowIdx ) - { - gtk_tree_store_set(ram_watch_store, &iter, - 0, addrStr, 1, valStr1, 2, valStr2, 3, rw->name.c_str(), - -1); - } - else - { - //if ( ramWatchEditColIdx != 0 ) - //{ - // gtk_tree_store_set(ram_watch_store, &iter, 0, addrStr, -1 ); - //} + if (rw->size == 2) + { + if (rw->type) + { + sprintf (valStr1, "%6u", rw->val.u16); + } + else + { + sprintf (valStr1, "%6i", rw->val.i16); + } + sprintf (valStr2, "0x%04X", rw->val.u16); + } + else + { + if (rw->type) + { + sprintf (valStr1, "%6u", rw->val.u8); + } + else + { + sprintf (valStr1, "%6i", rw->val.i8); + } + sprintf (valStr2, "0x%02X", rw->val.u8); + } - //if ( ramWatchEditColIdx != 1 ) - //{ - // gtk_tree_store_set(ram_watch_store, &iter, 1, valStr1, -1 ); - //} + if (row != ramWatchEditRowIdx) + { + gtk_tree_store_set (ram_watch_store, &iter, + 0, addrStr, 1, valStr1, 2, valStr2, + 3, rw->name.c_str (), -1); + } + else + { + //if ( ramWatchEditColIdx != 0 ) + //{ + // gtk_tree_store_set(ram_watch_store, &iter, 0, addrStr, -1 ); + //} - //if ( ramWatchEditColIdx != 2 ) - //{ - // gtk_tree_store_set(ram_watch_store, &iter, 2, valStr2, -1 ); - //} + //if ( ramWatchEditColIdx != 1 ) + //{ + // gtk_tree_store_set(ram_watch_store, &iter, 1, valStr1, -1 ); + //} - //if ( ramWatchEditColIdx != 3 ) - //{ - // gtk_tree_store_set(ram_watch_store, &iter, 3, rw->name.c_str(), -1 ); - //} - } + //if ( ramWatchEditColIdx != 2 ) + //{ + // gtk_tree_store_set(ram_watch_store, &iter, 2, valStr2, -1 ); + //} - if ( !reset ) - { - if ( !gtk_tree_model_iter_next( GTK_TREE_MODEL(ram_watch_store), &iter ) ) - { - gtk_tree_store_append( ram_watch_store, &iter, NULL); // aquire iter - } - } - row++; - } + //if ( ramWatchEditColIdx != 3 ) + //{ + // gtk_tree_store_set(ram_watch_store, &iter, 3, rw->name.c_str(), -1 ); + //} + } + + if (!reset) + { + if (!gtk_tree_model_iter_next + (GTK_TREE_MODEL (ram_watch_store), &iter)) + { + gtk_tree_store_append (ram_watch_store, &iter, NULL); // aquire iter + } + } + row++; + } } -static std::list ramWatchWinList; +static std::list < ramWatchWin_t * >ramWatchWinList; -void showAllRamWatchResults(int reset) +void showAllRamWatchResults (int reset) { - std::list ::iterator it; - - for (it=ramWatchWinList.begin(); it != ramWatchWinList.end(); it++) - { - (*it)->showRamWatchResults(reset); - } + std::list < ramWatchWin_t * >::iterator it; + + for (it = ramWatchWinList.begin (); it != ramWatchWinList.end (); it++) + { + (*it)->showRamWatchResults (reset); + } } -static void saveWatchFile( const char *filename ) +static void saveWatchFile (const char *filename) { int i; FILE *fp; const char *c; - std::list ::iterator it; + std::list < ramWatch_t * >::iterator it; ramWatch_t *rw; - fp = fopen( filename, "w"); + fp = fopen (filename, "w"); - if ( fp == NULL ) + if (fp == NULL) { - printf("Error: Failed to open file: %s\n", filename); + printf ("Error: Failed to open file: %s\n", filename); return; } - for (it=ramWatchList.ls.begin(); it!=ramWatchList.ls.end(); it++) + for (it = ramWatchList.ls.begin (); it != ramWatchList.ls.end (); it++) { rw = *it; - c = rw->name.c_str(); + c = rw->name.c_str (); - fprintf( fp, "0x%04x %c%i ", rw->addr, rw->type ? 'U' : 'S', rw->size); + fprintf (fp, "0x%04x %c%i ", rw->addr, rw->type ? 'U' : 'S', + rw->size); - i=0; - fprintf( fp, "\""); - while ( c[i] ) + i = 0; + fprintf (fp, "\""); + while (c[i]) { - if ( c[i] == '"') + if (c[i] == '"') { - fprintf( fp, "\\%c", c[i]); + fprintf (fp, "\\%c", c[i]); } else { - fprintf( fp, "%c", c[i]); + fprintf (fp, "%c", c[i]); } i++; } - fprintf( fp, "\"\n"); + fprintf (fp, "\"\n"); } - fclose(fp); + fclose (fp); } -static void loadWatchFile( const char *filename ) +static void loadWatchFile (const char *filename) { FILE *fp; int i, j, a, t, s, literal; char line[512], stmp[512]; ramWatch_t *rw; - fp = fopen( filename, "r"); + fp = fopen (filename, "r"); - if ( fp == NULL ) + if (fp == NULL) { - printf("Error: Failed to open file: %s\n", filename); + printf ("Error: Failed to open file: %s\n", filename); return; } - while ( fgets( line, sizeof(line)-1, fp ) > 0) + while (fgets (line, sizeof (line) - 1, fp) > 0) { - a = -1; t = -1; s = -1; - // Check for Comments - i=0; - while ( line[i] != 0 ) - { - if ( literal ) - { - literal = 0; - } - else - { - if ( line[i] == '#') - { - line[i] = 0; break; - } - else if ( line[i] == '\\' ) - { + a = -1; + t = -1; + s = -1; + // Check for Comments + i = 0; + while (line[i] != 0) + { + if (literal) + { + literal = 0; + } + else + { + if (line[i] == '#') + { + line[i] = 0; + break; + } + else if (line[i] == '\\') + { literal = 1; } - } - i++; - } + } + i++; + } - i=0; j=0; - while ( isspace(line[i]) ) i++; + i = 0; + j = 0; + while (isspace (line[i])) i++; - if ( (line[i] == '0') && ( tolower(line[i+1]) == 'x') ) - { - stmp[j] = '0'; j++; i++; - stmp[j] = 'x'; j++; i++; + if ((line[i] == '0') && (tolower (line[i + 1]) == 'x')) + { + stmp[j] = '0'; + j++; + i++; + stmp[j] = 'x'; + j++; + i++; - while ( isxdigit(line[i]) ) - { - stmp[j] = line[i]; i++; j++; - } - } - else - { - while ( isxdigit(line[i]) ) - { - stmp[j] = line[i]; i++; j++; - } - } - stmp[j] = 0; + while (isxdigit (line[i])) + { + stmp[j] = line[i]; + i++; + j++; + } + } + else + { + while (isxdigit (line[i])) + { + stmp[j] = line[i]; + i++; + j++; + } + } + stmp[j] = 0; - if ( j == 0 ) continue; + if (j == 0) continue; - a = strtol( stmp, NULL, 0); + a = strtol (stmp, NULL, 0); - while ( isspace(line[i]) ) i++; + while (isspace (line[i])) i++; - t = line[i]; i++; - s = line[i]; i++; + t = line[i]; + i++; + s = line[i]; + i++; - if ( (t != 'U') && (t != 'S') ) - { - printf("Error: Invalid RAM Watch Byte Type: %c", t); - continue; - } - if ( !isdigit(s) ) - { - printf("Error: Invalid RAM Watch Byte Size: %c", s); - continue; - } - s = s - '0'; + if ((t != 'U') && (t != 'S')) + { + printf ("Error: Invalid RAM Watch Byte Type: %c", t); + continue; + } + if (!isdigit (s)) + { + printf ("Error: Invalid RAM Watch Byte Size: %c", s); + continue; + } + s = s - '0'; - if ( (s != 1) && (s != 2) && (s != 4) ) - { - printf("Error: Invalid RAM Watch Byte Size: %i", s); - continue; - } + if ((s != 1) && (s != 2) && (s != 4)) + { + printf ("Error: Invalid RAM Watch Byte Size: %i", s); + continue; + } - while ( isspace(line[i]) ) i++; + while (isspace (line[i])) i++; - if ( line[i] == '"') - { - i++; j=0; - literal = 0; - while ( (line[i] != 0) ) - { - if ( literal ) + if (line[i] == '"') + { + i++; + j = 0; + literal = 0; + while ((line[i] != 0)) + { + if (literal) { - literal = 0; + literal = 0; } else { - if ( line[i] == '"') + if (line[i] == '"') { break; } - else if ( line[i] == '\\' ) - { + else if (line[i] == '\\') + { literal = 1; } } - if ( !literal ){ - stmp[j] = line[i]; j++; + if (!literal) + { + stmp[j] = line[i]; + j++; } - i++; - } - stmp[j] = 0; - } - rw = new ramWatch_t; + i++; + } + stmp[j] = 0; + } + rw = new ramWatch_t; - rw->addr = a; - rw->type = (t == 'U') ? 1 : 0; - rw->size = s; - rw->name.assign( stmp ); + rw->addr = a; + rw->type = (t == 'U') ? 1 : 0; + rw->size = s; + rw->name.assign (stmp); - ramWatchList.ls.push_back(rw); + ramWatchList.ls.push_back (rw); } - fclose(fp); + fclose (fp); - showAllRamWatchResults(1); + showAllRamWatchResults (1); } -static void openWatchFile( int mode ) +static void openWatchFile (int mode) { - GtkWidget* fileChooser; - GtkFileFilter* filterWch; - GtkFileFilter* filterAll; - - filterWch = gtk_file_filter_new(); - gtk_file_filter_add_pattern(filterWch, "*.wch"); - gtk_file_filter_add_pattern(filterWch, "*.WCH"); - gtk_file_filter_set_name(filterWch, "Watch files"); - - filterAll = gtk_file_filter_new(); - gtk_file_filter_add_pattern(filterAll, "*"); - gtk_file_filter_set_name(filterAll, "All Files"); - + GtkWidget *fileChooser; + GtkFileFilter *filterWch; + GtkFileFilter *filterAll; + + filterWch = gtk_file_filter_new (); + gtk_file_filter_add_pattern (filterWch, "*.wch"); + gtk_file_filter_add_pattern (filterWch, "*.WCH"); + gtk_file_filter_set_name (filterWch, "Watch files"); + + filterAll = gtk_file_filter_new (); + gtk_file_filter_add_pattern (filterAll, "*"); + gtk_file_filter_set_name (filterAll, "All Files"); + //const char* last_dir; //g_config->getOption("SDL.LastSaveStateAs", &last_dir); - if ( mode ) - { - fileChooser = gtk_file_chooser_dialog_new ("Save Watch File", GTK_WINDOW(MainWindow), - GTK_FILE_CHOOSER_ACTION_SAVE, "_Cancel", GTK_RESPONSE_CANCEL, - "_Save", GTK_RESPONSE_ACCEPT, NULL); - } - else - { - fileChooser = gtk_file_chooser_dialog_new ("Load Watch File", GTK_WINDOW(MainWindow), - GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel", GTK_RESPONSE_CANCEL, - "_Open", GTK_RESPONSE_ACCEPT, NULL); - } - - //gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fileChooser), last_dir); - - //gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER(fileChooser), ".wch"); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterWch); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileChooser), filterAll); - - if (gtk_dialog_run (GTK_DIALOG (fileChooser)) ==GTK_RESPONSE_ACCEPT) + if (mode) { - char* filename; - - filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fileChooser)); + fileChooser = + gtk_file_chooser_dialog_new ("Save Watch File", + GTK_WINDOW (MainWindow), + GTK_FILE_CHOOSER_ACTION_SAVE, + "_Cancel", + GTK_RESPONSE_CANCEL, + "_Save", + GTK_RESPONSE_ACCEPT, NULL); + } + else + { + fileChooser = + gtk_file_chooser_dialog_new ("Load Watch File", + GTK_WINDOW (MainWindow), + GTK_FILE_CHOOSER_ACTION_OPEN, + "_Cancel", + GTK_RESPONSE_CANCEL, + "_Open", + GTK_RESPONSE_ACCEPT, NULL); + } + + //gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fileChooser), last_dir); + + //gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER(fileChooser), ".wch"); + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fileChooser), filterWch); + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fileChooser), filterAll); + + if (gtk_dialog_run (GTK_DIALOG (fileChooser)) == GTK_RESPONSE_ACCEPT) + { + char *filename; + + filename = + gtk_file_chooser_get_filename (GTK_FILE_CHOOSER + (fileChooser)); //FCEUI_SaveState(filename); //g_config->setOption("SDL.LastSaveStateAs", filename); - if ( filename ) + if (filename) { - if ( mode ) + if (mode) { - saveWatchFile( filename ); + saveWatchFile (filename); } else { - loadWatchFile( filename ); + loadWatchFile (filename); } - g_free(filename); + g_free (filename); } } gtk_widget_destroy (fileChooser); } -static void loadRamWatchCB( GtkMenuItem *menuitem, - gpointer user_data) +static void loadRamWatchCB (GtkMenuItem * menuitem, gpointer user_data) { - openWatchFile(0); -} -static void saveRamWatchCB( GtkMenuItem *menuitem, - gpointer user_data) -{ - openWatchFile(1); + openWatchFile (0); } -static GtkWidget* CreateRamWatchMenubar( GtkWidget* window) +static void saveRamWatchCB (GtkMenuItem * menuitem, gpointer user_data) { - GtkWidget *menubar, *menu, *item; + openWatchFile (1); +} - menubar = gtk_menu_bar_new(); +static GtkWidget *CreateRamWatchMenubar (GtkWidget * window) +{ + GtkWidget *menubar, *menu, *item; - item = gtk_menu_item_new_with_label("File"); + menubar = gtk_menu_bar_new (); - gtk_menu_shell_append( GTK_MENU_SHELL(menubar), item ); + item = gtk_menu_item_new_with_label ("File"); - menu = gtk_menu_new(); + gtk_menu_shell_append (GTK_MENU_SHELL (menubar), item); - gtk_menu_item_set_submenu( GTK_MENU_ITEM(item), menu ); + menu = gtk_menu_new (); - item = gtk_menu_item_new_with_label("Load Watch"); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), menu); - g_signal_connect( item, "activate", G_CALLBACK(loadRamWatchCB), NULL); + item = gtk_menu_item_new_with_label ("Load Watch"); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + g_signal_connect (item, "activate", G_CALLBACK (loadRamWatchCB), NULL); - item = gtk_menu_item_new_with_label("Save Watch"); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); - g_signal_connect( item, "activate", G_CALLBACK(saveRamWatchCB), NULL); + item = gtk_menu_item_new_with_label ("Save Watch"); - gtk_menu_shell_append( GTK_MENU_SHELL(menu), item ); + g_signal_connect (item, "activate", G_CALLBACK (saveRamWatchCB), NULL); + + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); // Finally, return the actual menu bar created return menubar; @@ -634,496 +680,546 @@ static GtkWidget* CreateRamWatchMenubar( GtkWidget* window) // // delete ew; // -// gtk_widget_destroy(w); +// gtk_widget_destroy(w); //} -static int openRamWatchEntryDialog( ramWatchWin_t *rww, std::string *name, int *addr, int *type, int *size, int idx ) +static int openRamWatchEntryDialog (ramWatchWin_t * rww, std::string * name, + int *addr, int *type, int *size, int idx) { - int retval; - GtkWidget* vbox; - GtkWidget* hbox; - GtkWidget* label; - ramWatchEntryWin_t *ew; - char stmp[32]; + int retval; + GtkWidget *vbox; + GtkWidget *hbox; + GtkWidget *label; + ramWatchEntryWin_t *ew; + char stmp[32]; - ew = new ramWatchEntryWin_t; + ew = new ramWatchEntryWin_t; - //printf("RAM Entry At Index %i \n", idx ); + //printf("RAM Entry At Index %i \n", idx ); - ew->rww = rww; - ew->idx = idx; + ew->rww = rww; + ew->idx = idx; - ew->win = gtk_dialog_new_with_buttons("RAM Watch Entry", - GTK_WINDOW(rww->win), (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT), - "_Close", - GTK_RESPONSE_OK, - NULL); - gtk_window_set_default_size(GTK_WINDOW(ew->win), 400, 200); + ew->win = gtk_dialog_new_with_buttons ("RAM Watch Entry", + GTK_WINDOW (rww->win), + (GtkDialogFlags) + (GTK_DIALOG_DESTROY_WITH_PARENT), + "_Close", GTK_RESPONSE_OK, NULL); + gtk_window_set_default_size (GTK_WINDOW (ew->win), 400, 200); - vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 6); + vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); - label = gtk_label_new("Name:"); - ew->txt_entry_name = gtk_entry_new(); + label = gtk_label_new ("Name:"); + ew->txt_entry_name = gtk_entry_new (); - if ( name->size() > 0 ){ - gtk_entry_set_text( GTK_ENTRY(ew->txt_entry_name), name->c_str() ); - } + if (name->size () > 0) + { + gtk_entry_set_text (GTK_ENTRY (ew->txt_entry_name), + name->c_str ()); + } - gtk_box_pack_start (GTK_BOX(vbox), label, FALSE, FALSE, 0); - gtk_box_pack_start (GTK_BOX(vbox), ew->txt_entry_name, FALSE, TRUE, 0); + gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); + gtk_box_pack_start (GTK_BOX (vbox), ew->txt_entry_name, FALSE, TRUE, 0); - hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); - label = gtk_label_new("Hex Address:"); - ew->txt_entry_addr = gtk_entry_new(); + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); + label = gtk_label_new ("Hex Address:"); + ew->txt_entry_addr = gtk_entry_new (); - gtk_box_pack_start (GTK_BOX(vbox), label, FALSE, FALSE, 0); + gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); - label = gtk_label_new("0x"); - sprintf( stmp, "%04x", *addr ); - gtk_entry_set_max_length( GTK_ENTRY(ew->txt_entry_addr), 4 ); - gtk_entry_set_width_chars( GTK_ENTRY(ew->txt_entry_addr), 4 ); - gtk_entry_set_text( GTK_ENTRY(ew->txt_entry_addr), stmp ); + label = gtk_label_new ("0x"); + sprintf (stmp, "%04x", *addr); + gtk_entry_set_max_length (GTK_ENTRY (ew->txt_entry_addr), 4); + gtk_entry_set_width_chars (GTK_ENTRY (ew->txt_entry_addr), 4); + gtk_entry_set_text (GTK_ENTRY (ew->txt_entry_addr), stmp); - gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0); - gtk_box_pack_start (GTK_BOX(hbox), ew->txt_entry_addr, TRUE, TRUE, 0); - gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, TRUE, 0); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); + gtk_box_pack_start (GTK_BOX (hbox), ew->txt_entry_addr, TRUE, TRUE, 0); + gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); - ew->chkbox = gtk_check_button_new_with_label("Value is Unsigned"); - gtk_box_pack_start (GTK_BOX(vbox), ew->chkbox, FALSE, FALSE, 0); + ew->chkbox = gtk_check_button_new_with_label ("Value is Unsigned"); + gtk_box_pack_start (GTK_BOX (vbox), ew->chkbox, FALSE, FALSE, 0); - hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); - label = gtk_label_new("Size in Bytes:"); - ew->button1 = gtk_radio_button_new_with_label (NULL, "1"); - //gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); + label = gtk_label_new ("Size in Bytes:"); + ew->button1 = gtk_radio_button_new_with_label (NULL, "1"); + //gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); - gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 1); - gtk_box_pack_start (GTK_BOX(hbox), ew->button1, TRUE, FALSE, 1); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 1); + gtk_box_pack_start (GTK_BOX (hbox), ew->button1, TRUE, FALSE, 1); - ew->button2 = gtk_radio_button_new_with_label_from_widget ( GTK_RADIO_BUTTON (ew->button1), "2"); - gtk_box_pack_start (GTK_BOX(hbox), ew->button2, TRUE, FALSE, 1); + ew->button2 = + gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON + (ew->button1), + "2"); + gtk_box_pack_start (GTK_BOX (hbox), ew->button2, TRUE, FALSE, 1); - ew->button4 = gtk_radio_button_new_with_label_from_widget ( GTK_RADIO_BUTTON (ew->button1), "4"); - gtk_box_pack_start (GTK_BOX(hbox), ew->button4, TRUE, FALSE, 1); + ew->button4 = + gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON + (ew->button1), + "4"); + gtk_box_pack_start (GTK_BOX (hbox), ew->button4, TRUE, FALSE, 1); - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ew->button1), TRUE); - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ew->button2), FALSE); - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ew->button4), FALSE); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ew->button1), TRUE); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ew->button2), FALSE); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ew->button4), FALSE); - gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, TRUE, 1); + gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 1); - gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(ew->win))), vbox, TRUE, TRUE, 1); + gtk_box_pack_start (GTK_BOX + (gtk_dialog_get_content_area + (GTK_DIALOG (ew->win))), vbox, TRUE, TRUE, 1); - gtk_widget_show_all(ew->win); + gtk_widget_show_all (ew->win); - retval = gtk_dialog_run(GTK_DIALOG(ew->win)); + retval = gtk_dialog_run (GTK_DIALOG (ew->win)); - printf("retval %i\n", retval ); - // - if ( retval == GTK_RESPONSE_OK ) - { - // FIXME - what error checking should be done here + printf ("retval %i\n", retval); + // + if (retval == GTK_RESPONSE_OK) + { + // FIXME - what error checking should be done here - name->assign( gtk_entry_get_text ( GTK_ENTRY(ew->txt_entry_name) ) ); - - *addr = strtol( gtk_entry_get_text ( GTK_ENTRY(ew->txt_entry_addr) ), NULL, 16 ); - - *type = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(ew->chkbox) ); - - if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(ew->button4) ) ) - { - *size = 4; - } - else if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(ew->button2) ) ) - { - *size = 2; - } - else - { - *size = 1; - } - } + name->assign (gtk_entry_get_text + (GTK_ENTRY (ew->txt_entry_name))); - //g_signal_connect(ew->win, "delete-event", G_CALLBACK(closeMemoryWatchEntryWindow), ew); + *addr = strtol (gtk_entry_get_text + (GTK_ENTRY (ew->txt_entry_addr)), NULL, 16); + + *type = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON + (ew->chkbox)); + + if (gtk_toggle_button_get_active + (GTK_TOGGLE_BUTTON (ew->button4))) + { + *size = 4; + } + else if (gtk_toggle_button_get_active + (GTK_TOGGLE_BUTTON (ew->button2))) + { + *size = 2; + } + else + { + *size = 1; + } + } + + //g_signal_connect(ew->win, "delete-event", G_CALLBACK(closeMemoryWatchEntryWindow), ew); //g_signal_connect(ew->win, "response", G_CALLBACK(closeMemoryWatchEntryWindow), ew); - gtk_widget_destroy(ew->win); + gtk_widget_destroy (ew->win); - delete ew; + delete ew; - return ( retval == GTK_RESPONSE_OK ); + return (retval == GTK_RESPONSE_OK); } -static void editRamWatch( GtkButton *button, - ramWatchWin_t *rww ) +static void editRamWatch (GtkButton * button, ramWatchWin_t * rww) { - GtkTreeModel *model = NULL; + GtkTreeModel *model = NULL; GtkTreeSelection *treeSel; - int numListRows; + int numListRows; GList *selListRows, *tmpList; - treeSel = gtk_tree_view_get_selection( GTK_TREE_VIEW(rww->tree) ); + treeSel = gtk_tree_view_get_selection (GTK_TREE_VIEW (rww->tree)); - numListRows = gtk_tree_selection_count_selected_rows( treeSel ); + numListRows = gtk_tree_selection_count_selected_rows (treeSel); - if ( numListRows == 0 ) - { - return; - } + if (numListRows == 0) + { + return; + } - selListRows = gtk_tree_selection_get_selected_rows( treeSel, &model ); + selListRows = gtk_tree_selection_get_selected_rows (treeSel, &model); tmpList = selListRows; - while ( tmpList ) + while (tmpList) { int depth; int *indexArray; - GtkTreePath *path = (GtkTreePath*)tmpList->data; + GtkTreePath *path = (GtkTreePath *) tmpList->data; - depth = gtk_tree_path_get_depth(path); - indexArray = gtk_tree_path_get_indices(path); + depth = gtk_tree_path_get_depth (path); + indexArray = gtk_tree_path_get_indices (path); - if ( depth > 0 ) + if (depth > 0) { - ramWatch_t *rw = ramWatchList.getIndex(indexArray[0]); + ramWatch_t *rw = ramWatchList.getIndex (indexArray[0]); - if ( rw != NULL ) - { - openRamWatchEntryDialog( rww, &rw->name, &rw->addr, &rw->type, &rw->size, indexArray[0] ); - showAllRamWatchResults(0); - } + if (rw != NULL) + { + openRamWatchEntryDialog (rww, &rw->name, + &rw->addr, &rw->type, + &rw->size, + indexArray[0]); + showAllRamWatchResults (0); + } } - tmpList = tmpList->next; + tmpList = tmpList->next; } - g_list_free_full(selListRows, (GDestroyNotify) gtk_tree_path_free); + g_list_free_full (selListRows, (GDestroyNotify) gtk_tree_path_free); } -static void removeRamWatch( GtkButton *button, - ramWatchWin_t *rww ) +static void removeRamWatch (GtkButton * button, ramWatchWin_t * rww) { - GtkTreeModel *model = NULL; + GtkTreeModel *model = NULL; GtkTreeSelection *treeSel; - int numListRows; + int numListRows; GList *selListRows, *tmpList; - treeSel = gtk_tree_view_get_selection( GTK_TREE_VIEW(rww->tree) ); + treeSel = gtk_tree_view_get_selection (GTK_TREE_VIEW (rww->tree)); - numListRows = gtk_tree_selection_count_selected_rows( treeSel ); + numListRows = gtk_tree_selection_count_selected_rows (treeSel); - if ( numListRows == 0 ) - { - return; - } + if (numListRows == 0) + { + return; + } - selListRows = gtk_tree_selection_get_selected_rows( treeSel, &model ); + selListRows = gtk_tree_selection_get_selected_rows (treeSel, &model); tmpList = selListRows; - while ( tmpList ) + while (tmpList) { int depth; int *indexArray; - GtkTreePath *path = (GtkTreePath*)tmpList->data; + GtkTreePath *path = (GtkTreePath *) tmpList->data; - depth = gtk_tree_path_get_depth(path); - indexArray = gtk_tree_path_get_indices(path); + depth = gtk_tree_path_get_depth (path); + indexArray = gtk_tree_path_get_indices (path); - if ( depth > 0 ) + if (depth > 0) { - ramWatchList.deleteIndex(indexArray[0]); - showAllRamWatchResults(1); + ramWatchList.deleteIndex (indexArray[0]); + showAllRamWatchResults (1); } - tmpList = tmpList->next; + tmpList = tmpList->next; } - g_list_free_full(selListRows, (GDestroyNotify) gtk_tree_path_free); + g_list_free_full (selListRows, (GDestroyNotify) gtk_tree_path_free); } -static void newRamWatch( GtkButton *button, - ramWatchWin_t *rww ) +static void newRamWatch (GtkButton * button, ramWatchWin_t * rww) { - std::string name; - int addr = 0, type = 0, size = 0; + std::string name; + int addr = 0, type = 0, size = 0; - if ( openRamWatchEntryDialog( rww, &name, &addr, &type, &size, -1 ) ) - { - ramWatchList.add_entry( name.c_str(), addr, type, size ); - } + if (openRamWatchEntryDialog (rww, &name, &addr, &type, &size, -1)) + { + ramWatchList.add_entry (name.c_str (), addr, type, size); + } - showAllRamWatchResults(1); + showAllRamWatchResults (1); } -static gint updateRamWatchTree( void *userData ) +static gint updateRamWatchTree (void *userData) { - //static uint32_t c = 0; - //printf("RamWatch: %u\n", c++ ); - showAllRamWatchResults(0); - return 1; + //static uint32_t c = 0; + //printf("RamWatch: %u\n", c++ ); + showAllRamWatchResults (0); + return 1; } -static void ramWatch_cell_edited_cb ( - GtkCellRendererText *cell, - gchar *path_string, - gchar *new_text, - ramWatchWin_t *rww ) +static void ramWatch_cell_edited_cb (GtkCellRendererText * cell, + gchar * path_string, + gchar * new_text, ramWatchWin_t * rww) { ramWatch_t *rw; - //printf("Ram Watch Edited: %i:%i\n", ramWatchEditRowIdx, ramWatchEditColIdx); + //printf("Ram Watch Edited: %i:%i\n", ramWatchEditRowIdx, ramWatchEditColIdx); - rw = ramWatchList.getIndex( rww->ramWatchEditRowIdx ); + rw = ramWatchList.getIndex (rww->ramWatchEditRowIdx); - switch ( rww->ramWatchEditColIdx ) - { - case 0: - rw->addr = strtol( new_text, NULL, 0 ); - break; - case 1: - case 2: - { - writefunc wfunc; + switch (rww->ramWatchEditColIdx) + { + case 0: + rw->addr = strtol (new_text, NULL, 0); + break; + case 1: + case 2: + { + writefunc wfunc; - if ( rw->size == 2 ) - { - if ( rw->type ) - { - rw->val.u16 = strtol( new_text, NULL, 0 ); - } - else - { - rw->val.i16 = strtol( new_text, NULL, 0 ); - } - wfunc = GetWriteHandler( rw->addr ); + if (rw->size == 2) + { + if (rw->type) + { + rw->val.u16 = + strtol (new_text, NULL, 0); + } + else + { + rw->val.i16 = + strtol (new_text, NULL, 0); + } + wfunc = GetWriteHandler (rw->addr); - if ( wfunc ) - { - wfunc( (uint32)rw->addr, (uint8)(rw->val.u16 & 0x00ff) ); - } + if (wfunc) + { + wfunc ((uint32) rw->addr, + (uint8) (rw->val.u16 & 0x00ff)); + } - wfunc = GetWriteHandler( rw->addr+1 ); + wfunc = GetWriteHandler (rw->addr + 1); - if ( wfunc ) - { - wfunc( (uint32)rw->addr+1, (uint8)( (rw->val.u16 & 0xff00) >> 8) ); - } - } - else - { - if ( rw->type ) - { - rw->val.u8 = strtol( new_text, NULL, 0 ); - } - else - { - rw->val.i8 = strtol( new_text, NULL, 0 ); - } - wfunc = GetWriteHandler( rw->addr ); + if (wfunc) + { + wfunc ((uint32) rw->addr + 1, + (uint8) ((rw->val. + u16 & 0xff00) >> 8)); + } + } + else + { + if (rw->type) + { + rw->val.u8 = strtol (new_text, NULL, 0); + } + else + { + rw->val.i8 = strtol (new_text, NULL, 0); + } + wfunc = GetWriteHandler (rw->addr); - if ( wfunc ) - { - wfunc( (uint32)rw->addr, (uint8)rw->val.u8 ); - } - } - } - break; - case 3: - rw->name.assign( new_text ); - break; - default: + if (wfunc) + { + wfunc ((uint32) rw->addr, + (uint8) rw->val.u8); + } + } + } + break; + case 3: + rw->name.assign (new_text); + break; + default: - break; - } + break; + } - rww->ramWatchEditRowIdx = -1; - rww->ramWatchEditColIdx = -1; + rww->ramWatchEditRowIdx = -1; + rww->ramWatchEditColIdx = -1; } -static void ramWatch_cell_edited_start_cb0( - GtkCellRenderer *renderer, - GtkCellEditable *editable, - gchar *path, - ramWatchWin_t *rww ) +static void ramWatch_cell_edited_start_cb0 (GtkCellRenderer * renderer, + GtkCellEditable * editable, + gchar * path, ramWatchWin_t * rww) { - //printf("Ram Watch Edit Start: '%s':%li\n", path, (long)user_data); - rww->ramWatchEditRowIdx = atoi( path ); - rww->ramWatchEditColIdx = 0; + //printf("Ram Watch Edit Start: '%s':%li\n", path, (long)user_data); + rww->ramWatchEditRowIdx = atoi (path); + rww->ramWatchEditColIdx = 0; } -static void ramWatch_cell_edited_start_cb1( - GtkCellRenderer *renderer, - GtkCellEditable *editable, - gchar *path, - ramWatchWin_t *rww ) +static void ramWatch_cell_edited_start_cb1 (GtkCellRenderer * renderer, + GtkCellEditable * editable, + gchar * path, ramWatchWin_t * rww) { - //printf("Ram Watch Edit Start: '%s':%li\n", path, (long)user_data); - rww->ramWatchEditRowIdx = atoi( path ); - rww->ramWatchEditColIdx = 1; + //printf("Ram Watch Edit Start: '%s':%li\n", path, (long)user_data); + rww->ramWatchEditRowIdx = atoi (path); + rww->ramWatchEditColIdx = 1; } -static void ramWatch_cell_edited_start_cb2( - GtkCellRenderer *renderer, - GtkCellEditable *editable, - gchar *path, - ramWatchWin_t *rww ) +static void ramWatch_cell_edited_start_cb2 (GtkCellRenderer * renderer, + GtkCellEditable * editable, + gchar * path, ramWatchWin_t * rww) { - //printf("Ram Watch Edit Start: '%s':%li\n", path, (long)user_data); - rww->ramWatchEditRowIdx = atoi( path ); - rww->ramWatchEditColIdx = 2; + //printf("Ram Watch Edit Start: '%s':%li\n", path, (long)user_data); + rww->ramWatchEditRowIdx = atoi (path); + rww->ramWatchEditColIdx = 2; } -static void ramWatch_cell_edited_start_cb3( - GtkCellRenderer *renderer, - GtkCellEditable *editable, - gchar *path, - ramWatchWin_t *rww ) +static void ramWatch_cell_edited_start_cb3 (GtkCellRenderer * renderer, + GtkCellEditable * editable, + gchar * path, ramWatchWin_t * rww) { - //printf("Ram Watch Edit Start: '%s':%li\n", path, (long)user_data); - rww->ramWatchEditRowIdx = atoi( path ); - rww->ramWatchEditColIdx = 3; + //printf("Ram Watch Edit Start: '%s':%li\n", path, (long)user_data); + rww->ramWatchEditRowIdx = atoi (path); + rww->ramWatchEditColIdx = 3; } -static void ramWatch_cell_edited_cancel_cb( - GtkCellRenderer *renderer, - ramWatchWin_t *rww ) +static void ramWatch_cell_edited_cancel_cb (GtkCellRenderer * renderer, + ramWatchWin_t * rww) { - //printf("Ram Watch Edit Cancel:%li\n", (long)user_data); - rww->ramWatchEditRowIdx = -1; - rww->ramWatchEditColIdx = -1; + //printf("Ram Watch Edit Cancel:%li\n", (long)user_data); + rww->ramWatchEditRowIdx = -1; + rww->ramWatchEditColIdx = -1; } -void closeMemoryWatchWindow(GtkWidget* w, GdkEvent* e, ramWatchWin_t *rww) +void closeMemoryWatchWindow (GtkWidget * w, GdkEvent * e, ramWatchWin_t * rww) { - std::list ::iterator it; + std::list < ramWatchWin_t * >::iterator it; - for (it=ramWatchWinList.begin(); it != ramWatchWinList.end(); it++) - { - if ( rww == *it ) - { - //printf("Removing RamWatch Window %p from List\n", cw); - ramWatchWinList.erase(it); break; - } - } + for (it = ramWatchWinList.begin (); it != ramWatchWinList.end (); it++) + { + if (rww == *it) + { + //printf("Removing RamWatch Window %p from List\n", cw); + ramWatchWinList.erase (it); + break; + } + } - delete rww; + delete rww; - gtk_widget_destroy(w); + gtk_widget_destroy (w); } // creates and opens cheats window -void openMemoryWatchWindow(void) +void openMemoryWatchWindow (void) { - GtkWidget* main_vbox; - GtkWidget* hbox; - GtkWidget* vbox; - GtkWidget* button; + GtkWidget *main_vbox; + GtkWidget *hbox; + GtkWidget *vbox; + GtkWidget *button; GtkWidget *scroll; - GtkWidget* menubar; - ramWatchWin_t *rww; + GtkWidget *menubar; + ramWatchWin_t *rww; - rww = new ramWatchWin_t; + rww = new ramWatchWin_t; - ramWatchWinList.push_back( rww ); + ramWatchWinList.push_back (rww); - rww->win = gtk_dialog_new_with_buttons("RAM Watch", - GTK_WINDOW(MainWindow), (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT), - "_Close", - GTK_RESPONSE_OK, - NULL); + rww->win = gtk_dialog_new_with_buttons ("RAM Watch", + GTK_WINDOW (MainWindow), + (GtkDialogFlags) + (GTK_DIALOG_DESTROY_WITH_PARENT), + "_Close", GTK_RESPONSE_OK, + NULL); - gtk_window_set_default_size(GTK_WINDOW(rww->win), 600, 600); + gtk_window_set_default_size (GTK_WINDOW (rww->win), 600, 600); - main_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 1); + main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1); - menubar = CreateRamWatchMenubar(rww->win); + menubar = CreateRamWatchMenubar (rww->win); - gtk_box_pack_start (GTK_BOX(main_vbox), menubar, FALSE, TRUE, 0); - - hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL,2); + gtk_box_pack_start (GTK_BOX (main_vbox), menubar, FALSE, TRUE, 0); - rww->ram_watch_store = gtk_tree_store_new( 4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); - rww->tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(rww->ram_watch_store)); + rww->ram_watch_store = + gtk_tree_store_new (4, G_TYPE_STRING, G_TYPE_STRING, + G_TYPE_STRING, G_TYPE_STRING); - gtk_tree_view_set_grid_lines( GTK_TREE_VIEW(rww->tree), GTK_TREE_VIEW_GRID_LINES_VERTICAL ); + rww->tree = + gtk_tree_view_new_with_model (GTK_TREE_MODEL + (rww->ram_watch_store)); + + gtk_tree_view_set_grid_lines (GTK_TREE_VIEW (rww->tree), + GTK_TREE_VIEW_GRID_LINES_VERTICAL); GtkCellRenderer *renderer; - GtkTreeViewColumn* column; + GtkTreeViewColumn *column; - renderer = gtk_cell_renderer_text_new(); - g_object_set(renderer, "family", "MonoSpace", NULL); - g_object_set(renderer, "editable", TRUE, NULL); - g_signal_connect(renderer, "edited", (GCallback) ramWatch_cell_edited_cb, (gpointer)rww); - g_signal_connect(renderer, "editing-started", (GCallback) ramWatch_cell_edited_start_cb0, (gpointer)rww); - g_signal_connect(renderer, "editing-canceled", (GCallback) ramWatch_cell_edited_cancel_cb, (gpointer)rww); - column = gtk_tree_view_column_new_with_attributes("Addr", renderer, "text", 0, NULL); - gtk_tree_view_append_column(GTK_TREE_VIEW(rww->tree), column); + renderer = gtk_cell_renderer_text_new (); + g_object_set (renderer, "family", "MonoSpace", NULL); + g_object_set (renderer, "editable", TRUE, NULL); + g_signal_connect (renderer, "edited", + (GCallback) ramWatch_cell_edited_cb, (gpointer) rww); + g_signal_connect (renderer, "editing-started", + (GCallback) ramWatch_cell_edited_start_cb0, + (gpointer) rww); + g_signal_connect (renderer, "editing-canceled", + (GCallback) ramWatch_cell_edited_cancel_cb, + (gpointer) rww); + column = gtk_tree_view_column_new_with_attributes ("Addr", renderer, + "text", 0, NULL); + gtk_tree_view_append_column (GTK_TREE_VIEW (rww->tree), column); - renderer = gtk_cell_renderer_text_new(); - g_object_set(renderer, "family", "MonoSpace", NULL); - g_object_set(renderer, "editable", TRUE, NULL); - g_signal_connect(renderer, "edited", (GCallback) ramWatch_cell_edited_cb, (gpointer)rww); - g_signal_connect(renderer, "editing-started", (GCallback) ramWatch_cell_edited_start_cb1, (gpointer)rww); - g_signal_connect(renderer, "editing-canceled", (GCallback) ramWatch_cell_edited_cancel_cb, (gpointer)rww); - column = gtk_tree_view_column_new_with_attributes("Value Dec", renderer, "text", 1, NULL); - gtk_tree_view_append_column(GTK_TREE_VIEW(rww->tree), column); + renderer = gtk_cell_renderer_text_new (); + g_object_set (renderer, "family", "MonoSpace", NULL); + g_object_set (renderer, "editable", TRUE, NULL); + g_signal_connect (renderer, "edited", + (GCallback) ramWatch_cell_edited_cb, (gpointer) rww); + g_signal_connect (renderer, "editing-started", + (GCallback) ramWatch_cell_edited_start_cb1, + (gpointer) rww); + g_signal_connect (renderer, "editing-canceled", + (GCallback) ramWatch_cell_edited_cancel_cb, + (gpointer) rww); + column = gtk_tree_view_column_new_with_attributes ("Value Dec", + renderer, "text", 1, + NULL); + gtk_tree_view_append_column (GTK_TREE_VIEW (rww->tree), column); - renderer = gtk_cell_renderer_text_new(); - g_object_set(renderer, "family", "MonoSpace", NULL); - g_object_set(renderer, "editable", TRUE, NULL); - g_signal_connect(renderer, "edited", (GCallback) ramWatch_cell_edited_cb, (gpointer)rww); - g_signal_connect(renderer, "editing-started", (GCallback) ramWatch_cell_edited_start_cb2, (gpointer)rww); - g_signal_connect(renderer, "editing-canceled", (GCallback) ramWatch_cell_edited_cancel_cb, (gpointer)rww); - column = gtk_tree_view_column_new_with_attributes("Value Hex", renderer, "text", 2, NULL); - gtk_tree_view_append_column(GTK_TREE_VIEW(rww->tree), column); + renderer = gtk_cell_renderer_text_new (); + g_object_set (renderer, "family", "MonoSpace", NULL); + g_object_set (renderer, "editable", TRUE, NULL); + g_signal_connect (renderer, "edited", + (GCallback) ramWatch_cell_edited_cb, (gpointer) rww); + g_signal_connect (renderer, "editing-started", + (GCallback) ramWatch_cell_edited_start_cb2, + (gpointer) rww); + g_signal_connect (renderer, "editing-canceled", + (GCallback) ramWatch_cell_edited_cancel_cb, + (gpointer) rww); + column = gtk_tree_view_column_new_with_attributes ("Value Hex", + renderer, "text", 2, + NULL); + gtk_tree_view_append_column (GTK_TREE_VIEW (rww->tree), column); - renderer = gtk_cell_renderer_text_new(); - g_object_set(renderer, "editable", TRUE, NULL); - g_signal_connect(renderer, "edited", (GCallback) ramWatch_cell_edited_cb, (gpointer)rww); - g_signal_connect(renderer, "editing-started", (GCallback) ramWatch_cell_edited_start_cb3, (gpointer)rww); - g_signal_connect(renderer, "editing-canceled", (GCallback) ramWatch_cell_edited_cancel_cb, (gpointer)rww); - column = gtk_tree_view_column_new_with_attributes("Notes", renderer, "text", 3, NULL); - gtk_tree_view_append_column(GTK_TREE_VIEW(rww->tree), column); + renderer = gtk_cell_renderer_text_new (); + g_object_set (renderer, "editable", TRUE, NULL); + g_signal_connect (renderer, "edited", + (GCallback) ramWatch_cell_edited_cb, (gpointer) rww); + g_signal_connect (renderer, "editing-started", + (GCallback) ramWatch_cell_edited_start_cb3, + (gpointer) rww); + g_signal_connect (renderer, "editing-canceled", + (GCallback) ramWatch_cell_edited_cancel_cb, + (gpointer) rww); + column = gtk_tree_view_column_new_with_attributes ("Notes", renderer, + "text", 3, NULL); + gtk_tree_view_append_column (GTK_TREE_VIEW (rww->tree), column); - scroll = gtk_scrolled_window_new(NULL, NULL); - gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, - GTK_POLICY_AUTOMATIC); - gtk_container_add(GTK_CONTAINER(scroll), rww->tree); - gtk_box_pack_start(GTK_BOX(hbox), scroll, TRUE, TRUE, 5); + scroll = gtk_scrolled_window_new (NULL, NULL); + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), + GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); + gtk_container_add (GTK_CONTAINER (scroll), rww->tree); + gtk_box_pack_start (GTK_BOX (hbox), scroll, TRUE, TRUE, 5); - gtk_box_pack_start(GTK_BOX(main_vbox), hbox, TRUE, TRUE, 5); + gtk_box_pack_start (GTK_BOX (main_vbox), hbox, TRUE, TRUE, 5); - showAllRamWatchResults(1); + showAllRamWatchResults (1); - if ( ramWatchEvntSrcID == 0 ) - { - ramWatchEvntSrcID = g_timeout_add( 100, updateRamWatchTree, NULL ); - } + if (ramWatchEvntSrcID == 0) + { + ramWatchEvntSrcID = + g_timeout_add (100, updateRamWatchTree, NULL); + } - vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 3); + vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3); - button = gtk_button_new_with_label("Edit"); - gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 5); - g_signal_connect( button, "clicked", - G_CALLBACK (editRamWatch), (gpointer) rww ); + button = gtk_button_new_with_label ("Edit"); + gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 5); + g_signal_connect (button, "clicked", + G_CALLBACK (editRamWatch), (gpointer) rww); - button = gtk_button_new_with_label("Remove"); - gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 5); - g_signal_connect( button, "clicked", - G_CALLBACK (removeRamWatch), (gpointer) rww ); + button = gtk_button_new_with_label ("Remove"); + gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 5); + g_signal_connect (button, "clicked", + G_CALLBACK (removeRamWatch), (gpointer) rww); - button = gtk_button_new_with_label("New"); - gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 5); - g_signal_connect( button, "clicked", - G_CALLBACK (newRamWatch), (gpointer) rww ); + button = gtk_button_new_with_label ("New"); + gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 5); + g_signal_connect (button, "clicked", + G_CALLBACK (newRamWatch), (gpointer) rww); - gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 5); + gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 5); - gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(rww->win))), main_vbox, TRUE, TRUE, 0); + gtk_box_pack_start (GTK_BOX + (gtk_dialog_get_content_area + (GTK_DIALOG (rww->win))), main_vbox, TRUE, TRUE, + 0); - g_signal_connect(rww->win, "delete-event", G_CALLBACK(closeMemoryWatchWindow), rww); - g_signal_connect(rww->win, "response", G_CALLBACK(closeMemoryWatchWindow), rww); - - gtk_widget_show_all(rww->win); + g_signal_connect (rww->win, "delete-event", + G_CALLBACK (closeMemoryWatchWindow), rww); + g_signal_connect (rww->win, "response", + G_CALLBACK (closeMemoryWatchWindow), rww); + + gtk_widget_show_all (rww->win); } From c702a86b675c9943a99411fc167473233eb5d890 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Wed, 13 May 2020 22:00:00 -0400 Subject: [PATCH 052/156] commented out window configure print statements. --- src/drivers/sdl/gui.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 1ab6cacc..b1120c4b 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -3024,7 +3024,7 @@ gboolean handle_resize (GtkWindow * win, GdkEvent * event, gpointer data) int width, height; width = event->configure.width; height = event->configure.height; - printf ("DEBUG: Configure new window size: %dx%d\n", width, height); + //printf ("DEBUG: Configure new window size: %dx%d\n", width, height); // get width/height multipliers double xscale = width / (double) NES_WIDTH; @@ -3084,7 +3084,7 @@ gboolean handle_resize (GtkWindow * win, GdkEvent * event, gpointer data) black.blue = 0; gtk_widget_modify_bg(GTK_WIDGET(win), GTK_STATE_NORMAL, &black); */ - printf ("DEBUG: new xscale: %f yscale: %f\n", xscale, yscale); + //printf ("DEBUG: new xscale: %f yscale: %f\n", xscale, yscale); return FALSE; } From 9f615d6f8118db06c0d96da165cd683e4ae6d317 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Thu, 14 May 2020 07:55:06 -0400 Subject: [PATCH 053/156] Found a better way to clear the screen to a black background. --- src/drivers/sdl/gui.cpp | 60 +++++++++++------------------------------ 1 file changed, 15 insertions(+), 45 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index b1120c4b..b7ecf013 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -66,9 +66,6 @@ bool menuTogglingEnabled = false; static GtkTreeStore *hotkey_store = NULL; -/* Surface to store black screen */ -static cairo_surface_t *surface = NULL; - // check to see if a particular GTK version is available // 2.24 is required for most of the dialogs -- ie: checkGTKVersion(2,24); bool checkGTKVersion (int major_required, int minor_required) @@ -1419,11 +1416,6 @@ void quit (void) while (gtk_events_pending ()) gtk_main_iteration_do (FALSE); - if (surface) - { - cairo_surface_destroy (surface); - surface = NULL; - } // this is not neccesary to be explicitly called // it raises a GTK-Critical when its called //gtk_main_quit(); @@ -3015,11 +3007,9 @@ gint handleMouseClick (GtkWidget * widget, GdkEvent * event, gboolean handle_resize (GtkWindow * win, GdkEvent * event, gpointer data) { - cairo_t *cr = NULL; // This should handle resizing so the emulation takes up as much // of the GTK window as possible - // get new window width/height int width, height; width = event->configure.width; @@ -3048,42 +3038,8 @@ gboolean handle_resize (GtkWindow * win, GdkEvent * event, gpointer data) InitVideo (GameInfo); } - - if (surface) - { - cairo_surface_destroy (surface); - } - surface = - gdk_window_create_similar_surface (gtk_widget_get_window - (evbox), CAIRO_CONTENT_COLOR, - gtk_widget_get_allocated_width - (evbox), - gtk_widget_get_allocated_height - (evbox)); - - - if (surface != NULL) - { - cr = cairo_create (surface); - - if (cr != NULL) - { - cairo_set_source_rgb (cr, 0, 0, 0); - cairo_paint (cr); - - cairo_destroy (cr); - } - } - //gtk_widget_set_size_request(evbox, (int)(NES_WIDTH*xscale), (int)(NES_HEIGHT*yscale)); - // Currently unused; unsure why - /* GdkColor black; - black.red = 0; - black.green = 0; - black.blue = 0; - gtk_widget_modify_bg(GTK_WIDGET(win), GTK_STATE_NORMAL, &black); */ - //printf ("DEBUG: new xscale: %f yscale: %f\n", xscale, yscale); return FALSE; @@ -3095,10 +3051,24 @@ gboolean handle_resize (GtkWindow * win, GdkEvent * event, gpointer data) */ static gboolean draw_cb (GtkWidget * widget, cairo_t * cr, gpointer data) { + guint width, height; + GdkRGBA color; + GtkStyleContext *context; + // Only clear the screen if a game is not loaded if (GameInfo == 0) { - cairo_set_source_surface (cr, surface, 0, 0); + context = gtk_widget_get_style_context (widget); + + width = gtk_widget_get_allocated_width (widget); + height = gtk_widget_get_allocated_height (widget); + + color.red = 0, color.blue = 0; color.green = 0; color.alpha = 1.0; + + gtk_render_background( context, cr, 0, 0, width, height ); + gdk_cairo_set_source_rgba (cr, &color); + + cairo_fill (cr); cairo_paint (cr); } From f162600f5476cd677f2f546e1b4d4e756206e31d Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Thu, 14 May 2020 07:55:57 -0400 Subject: [PATCH 054/156] Added clean before build in pipeline. --- azure/linux_build.sh | 1 + 1 file changed, 1 insertion(+) diff --git a/azure/linux_build.sh b/azure/linux_build.sh index 3b6bba04..6ab9ee8e 100755 --- a/azure/linux_build.sh +++ b/azure/linux_build.sh @@ -18,6 +18,7 @@ sudo apt-get install libgtk-3-dev sudo apt-get install libgtksourceview-3.0-dev sudo apt-get install scons +scons --clean scons GTK3=1 SYSTEM_LUA=1 SYSTEM_MINIZIP=1 CREATE_AVI=1 ls -ltr ./bin/* From 1ba5929ea26e33d5e1547035f030cf175d64e01f Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Thu, 14 May 2020 09:16:09 -0400 Subject: [PATCH 055/156] Modified screen display logic to always center image in the center of the window. --- src/drivers/sdl/gui.cpp | 22 +++++++++++++--------- src/drivers/sdl/sdl-video.cpp | 26 ++++++++++++++++---------- 2 files changed, 29 insertions(+), 19 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index b7ecf013..43a88ec5 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -64,6 +64,8 @@ GtkRadioAction *stateSlot = NULL; bool gtkIsStarted = false; bool menuTogglingEnabled = false; +unsigned int gtk_draw_area_width = NES_WIDTH; +unsigned int gtk_draw_area_height = NES_HEIGHT; static GtkTreeStore *hotkey_store = NULL; // check to see if a particular GTK version is available @@ -3020,6 +3022,9 @@ gboolean handle_resize (GtkWindow * win, GdkEvent * event, gpointer data) double xscale = width / (double) NES_WIDTH; double yscale = height / (double) NES_HEIGHT; + gtk_draw_area_width = gtk_widget_get_allocated_width (evbox); + gtk_draw_area_height = gtk_widget_get_allocated_height (evbox); + // TODO check KeepRatio (where is this) // do this to keep aspect ratio if (xscale > yscale) @@ -3051,26 +3056,25 @@ gboolean handle_resize (GtkWindow * win, GdkEvent * event, gpointer data) */ static gboolean draw_cb (GtkWidget * widget, cairo_t * cr, gpointer data) { - guint width, height; GdkRGBA color; GtkStyleContext *context; - // Only clear the screen if a game is not loaded - if (GameInfo == 0) - { - context = gtk_widget_get_style_context (widget); + gtk_draw_area_width = gtk_widget_get_allocated_width (widget); + gtk_draw_area_height = gtk_widget_get_allocated_height (widget); - width = gtk_widget_get_allocated_width (widget); - height = gtk_widget_get_allocated_height (widget); + // Clear the screen on a window redraw + //if (GameInfo == 0) + //{ + context = gtk_widget_get_style_context (widget); color.red = 0, color.blue = 0; color.green = 0; color.alpha = 1.0; - gtk_render_background( context, cr, 0, 0, width, height ); + gtk_render_background( context, cr, 0, 0, gtk_draw_area_width, gtk_draw_area_height ); gdk_cairo_set_source_rgba (cr, &color); cairo_fill (cr); cairo_paint (cr); - } + //} return FALSE; } diff --git a/src/drivers/sdl/sdl-video.cpp b/src/drivers/sdl/sdl-video.cpp index d26b6df9..4c24883d 100644 --- a/src/drivers/sdl/sdl-video.cpp +++ b/src/drivers/sdl/sdl-video.cpp @@ -83,6 +83,8 @@ static int s_paletterefresh; extern bool MaxSpeed; +extern unsigned int gtk_draw_area_width; +extern unsigned int gtk_draw_area_height; /** * Attempts to destroy the graphical video display. Returns 0 on * success, -1 on failure. @@ -181,13 +183,16 @@ InitVideo(FCEUGI *gi) g_config->getOption("SDL.SpecialFilter", &s_sponge); g_config->getOption("SDL.XStretch", &xstretch); g_config->getOption("SDL.YStretch", &ystretch); - g_config->getOption("SDL.LastXRes", &xres); - g_config->getOption("SDL.LastYRes", &yres); + //g_config->getOption("SDL.LastXRes", &xres); + //g_config->getOption("SDL.LastYRes", &yres); g_config->getOption("SDL.ClipSides", &s_clipSides); g_config->getOption("SDL.NoFrame", &noframe); g_config->getOption("SDL.ShowFPS", &show_fps); + xres = gtk_draw_area_width; + yres = gtk_draw_area_height; // check the starting, ending, and total scan lines + FCEUI_GetCurrentVidSystem(&s_srendline, &s_erendline); s_tlines = s_erendline - s_srendline + 1; @@ -374,10 +379,10 @@ InitVideo(FCEUGI *gi) } } - int scrw = NWIDTH * s_exs; - if(s_sponge == 3) { - scrw = 301 * s_exs; - } + //int scrw = NWIDTH * s_exs; + //if(s_sponge == 3) { + // scrw = 301 * s_exs; + //} #ifdef OPENGL if(!s_useOpenGL) { @@ -422,7 +427,8 @@ InitVideo(FCEUGI *gi) } #endif - s_screen = SDL_SetVideoMode(scrw, (int)(s_tlines * s_eys), + //s_screen = SDL_SetVideoMode(scrw, (int)(s_tlines * s_eys), + s_screen = SDL_SetVideoMode( xres, yres, desbpp, flags); if(!s_screen) { FCEUD_PrintError(SDL_GetError()); @@ -540,7 +546,7 @@ void ToggleFS() if(noGui == 0) { if(!fullscreen) - showGui(0); + showGui(0); else showGui(1); } @@ -666,14 +672,14 @@ BlitScreen(uint8 *XBuf) dest = (uint8*)TmpScreen->pixels; - if(s_fullscreen) { + //if(s_fullscreen) { // Always do this calculation now. Screen resolution is always provided. xo = (int)(((TmpScreen->w - NWIDTH * s_exs)) / 2); dest += xo * (s_curbpp >> 3); if(TmpScreen->h > (s_tlines * s_eys)) { yo = (int)((TmpScreen->h - s_tlines * s_eys) / 2); dest += yo * TmpScreen->pitch; } - } + //} // XXX soules - again, I'm surprised SDL can't handle this // perform the blit, converting bpp if necessary From 87d3db240623e7b029ef1aa7efda5672d81313e1 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Thu, 14 May 2020 18:16:04 -0400 Subject: [PATCH 056/156] Added screen dimension limits. Added some debug statements to pipeline script. --- azure/linux_build.sh | 6 ++++++ src/drivers/sdl/gui.cpp | 6 ++++++ 2 files changed, 12 insertions(+) diff --git a/azure/linux_build.sh b/azure/linux_build.sh index 6ab9ee8e..30720204 100755 --- a/azure/linux_build.sh +++ b/azure/linux_build.sh @@ -9,13 +9,19 @@ python2 --version python3 --version sudo apt-get install lua5.1-dev +pkg-config --cflags --libs lua5.1 sudo apt-get install libsdl1.2-dev +sdl-config --cflags --libs sudo apt-get install libsdl2-dev +sdl2-config --cflags --libs sudo apt-get install libminizip-dev +pkg-config --cflags --libs minizip #sudo apt-get install libxml2-dev #sudo apt-get install libgtk2.0-dev sudo apt-get install libgtk-3-dev +pkg-config --cflags --libs gtk+-3.0 sudo apt-get install libgtksourceview-3.0-dev +pkg-config --cflags --libs gtksourceview-3.0 sudo apt-get install scons scons --clean diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 43a88ec5..4a3e4676 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -3025,6 +3025,9 @@ gboolean handle_resize (GtkWindow * win, GdkEvent * event, gpointer data) gtk_draw_area_width = gtk_widget_get_allocated_width (evbox); gtk_draw_area_height = gtk_widget_get_allocated_height (evbox); + if ( gtk_draw_area_width < NES_WIDTH ) gtk_draw_area_width = NES_WIDTH; + if ( gtk_draw_area_height < NES_HEIGHT ) gtk_draw_area_height = NES_HEIGHT; + // TODO check KeepRatio (where is this) // do this to keep aspect ratio if (xscale > yscale) @@ -3062,6 +3065,9 @@ static gboolean draw_cb (GtkWidget * widget, cairo_t * cr, gpointer data) gtk_draw_area_width = gtk_widget_get_allocated_width (widget); gtk_draw_area_height = gtk_widget_get_allocated_height (widget); + if ( gtk_draw_area_width < NES_WIDTH ) gtk_draw_area_width = NES_WIDTH; + if ( gtk_draw_area_height < NES_HEIGHT ) gtk_draw_area_height = NES_HEIGHT; + // Clear the screen on a window redraw //if (GameInfo == 0) //{ From 0605427979665347b80b165d14d73cf19cfbd69e Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Thu, 14 May 2020 19:08:14 -0400 Subject: [PATCH 057/156] Added --fix-missing to apt-get sdl1 due to pipeline virtual machine failing to download all dependencies --- azure/linux_build.sh | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/azure/linux_build.sh b/azure/linux_build.sh index 30720204..845cd3b2 100755 --- a/azure/linux_build.sh +++ b/azure/linux_build.sh @@ -10,9 +10,9 @@ python3 --version sudo apt-get install lua5.1-dev pkg-config --cflags --libs lua5.1 -sudo apt-get install libsdl1.2-dev +sudo apt-get install libsdl1.2-dev --fix-missing sdl-config --cflags --libs -sudo apt-get install libsdl2-dev +sudo apt-get install libsdl2-dev --fix-missing sdl2-config --cflags --libs sudo apt-get install libminizip-dev pkg-config --cflags --libs minizip From 7fb5ed52c4795994f1974d6fb3b6dd7923504b4e Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Thu, 14 May 2020 20:04:49 -0400 Subject: [PATCH 058/156] Removed --fix-missing references from pipeline script. The issue with the pipeline lies on the microsoft side with there linux package servers. There is nothing that can be done here. --- azure/linux_build.sh | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/azure/linux_build.sh b/azure/linux_build.sh index 845cd3b2..36e7644f 100755 --- a/azure/linux_build.sh +++ b/azure/linux_build.sh @@ -10,13 +10,12 @@ python3 --version sudo apt-get install lua5.1-dev pkg-config --cflags --libs lua5.1 -sudo apt-get install libsdl1.2-dev --fix-missing +sudo apt-get install libsdl1.2-dev sdl-config --cflags --libs -sudo apt-get install libsdl2-dev --fix-missing +sudo apt-get install libsdl2-dev sdl2-config --cflags --libs sudo apt-get install libminizip-dev pkg-config --cflags --libs minizip -#sudo apt-get install libxml2-dev #sudo apt-get install libgtk2.0-dev sudo apt-get install libgtk-3-dev pkg-config --cflags --libs gtk+-3.0 From bcbac7708480232bf2c39c6f61e73cec05c84b85 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Thu, 14 May 2020 23:47:57 -0400 Subject: [PATCH 059/156] When a lua script is provided on the command line with the --loadlua option. Added code to always resolve any relative file path to an absolute as the lua core changes the current working directory which then invalidates the relative pathing from where the current working directory was at the time the program had initially been started. --- src/drivers/sdl/sdl.cpp | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/drivers/sdl/sdl.cpp b/src/drivers/sdl/sdl.cpp index a4f7c5d8..9273d578 100644 --- a/src/drivers/sdl/sdl.cpp +++ b/src/drivers/sdl/sdl.cpp @@ -915,6 +915,15 @@ int main(int argc, char *argv[]) g_config->setOption("SDL.LuaScript", ""); if (s != "") { +#ifdef __linux + // Resolve absolute path to file + char fullpath[2048]; + if ( realpath( s.c_str(), fullpath ) != NULL ) + { + //printf("Fullpath: '%s'\n", fullpath ); + s.assign( fullpath ); + } +#endif FCEU_LoadLuaCode(s.c_str()); } #endif From 8339508f21a388d0c9746b50c5e5483251efcd38 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Fri, 15 May 2020 16:06:18 -0400 Subject: [PATCH 060/156] Added an appveyor pipeline configure file to allow for a side by side build of both the windows and linux application. --- appveyor.yml | 8 ++++++++ azure-pipelines.yml | 2 +- {azure => pipelines}/linux_build.sh | 0 3 files changed, 9 insertions(+), 1 deletion(-) create mode 100644 appveyor.yml rename {azure => pipelines}/linux_build.sh (100%) diff --git a/appveyor.yml b/appveyor.yml new file mode 100644 index 00000000..ff7c0140 --- /dev/null +++ b/appveyor.yml @@ -0,0 +1,8 @@ +version: 1.0.{build} +image: +- Visual Studio 2019 +- Ubuntu2004 + #- Ubuntu1804 +build_script: +- cmd: msbuild "./vc/vc14_fceux.sln" +- sh: ./pipelines/linux_build.sh diff --git a/azure-pipelines.yml b/azure-pipelines.yml index e0acee95..8365c84a 100644 --- a/azure-pipelines.yml +++ b/azure-pipelines.yml @@ -12,5 +12,5 @@ pool: steps: - script: | - ./azure/linux_build.sh + ./pipelines/linux_build.sh displayName: 'make' diff --git a/azure/linux_build.sh b/pipelines/linux_build.sh similarity index 100% rename from azure/linux_build.sh rename to pipelines/linux_build.sh From 017ee17ee141640c6d482c5c9a37589c48d8454f Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Fri, 15 May 2020 16:14:03 -0400 Subject: [PATCH 061/156] Updated linux ubuntu build script to latest --- pipelines/linux_build.sh | 90 ++++++++++++++++++++++++++++++++++++---- 1 file changed, 81 insertions(+), 9 deletions(-) diff --git a/pipelines/linux_build.sh b/pipelines/linux_build.sh index 36e7644f..15ccefd2 100755 --- a/pipelines/linux_build.sh +++ b/pipelines/linux_build.sh @@ -8,22 +8,94 @@ gcc --version python2 --version python3 --version -sudo apt-get install lua5.1-dev +INSTALL_PREFIX=/tmp/fceux + +echo '****************************************' +echo "APPVEYOR_SSH_KEY=$APPVEYOR_SSH_KEY"; +echo "APPVEYOR_SSH_BLOCK=$APPVEYOR_SSH_BLOCK"; +echo '****************************************' + +echo '****************************************' +echo '****************************************' +echo '*** Installing Package Dependencies ***' +echo '****************************************' +echo '****************************************' +# Install Lua-5.1 development package +echo '****************************************' +echo 'Install Dependency lua5.1-dev' +echo '****************************************' +sudo apt-get --assume-yes install lua5.1-dev pkg-config --cflags --libs lua5.1 -sudo apt-get install libsdl1.2-dev + +# Install libSDL-1.2 and libSDL-2 +echo '****************************************' +echo 'Install Dependency libsdl1.2-dev' +echo '****************************************' +sudo apt-get --assume-yes install libsdl1.2-dev sdl-config --cflags --libs -sudo apt-get install libsdl2-dev +echo '****************************************' +echo 'Install Dependency libsdl2-dev' +echo '****************************************' +sudo apt-get --assume-yes install libsdl2-dev sdl2-config --cflags --libs -sudo apt-get install libminizip-dev + +# Install libminizip-dev +echo '****************************************' +echo 'Install Dependency libminizip-dev' +echo '****************************************' +sudo apt-get --assume-yes install libminizip-dev pkg-config --cflags --libs minizip + +# GTK+-2 is no longer needed #sudo apt-get install libgtk2.0-dev -sudo apt-get install libgtk-3-dev + +# Install GTK+-3 +echo '****************************************' +echo 'Install Dependency libgtk-3-dev' +echo '****************************************' +sudo apt-get --assume-yes install libgtk-3-dev pkg-config --cflags --libs gtk+-3.0 -sudo apt-get install libgtksourceview-3.0-dev + +# Install GTK+-3 Sourceview +sudo apt-get --assume-yes install libgtksourceview-3.0-dev pkg-config --cflags --libs gtksourceview-3.0 -sudo apt-get install scons +# Install scons +echo '****************************************' +echo 'Install Build Dependency scons' +echo '****************************************' +sudo apt-get --assume-yes install scons + +# Install cppcheck +echo '****************************************' +echo 'Install Check Dependency cppcheck' +echo '****************************************' +sudo apt-get --assume-yes install cppcheck + +echo '**************************' +echo '*** Building Project ***' +echo '**************************' +mkdir -p $INSTALL_PREFIX/usr; scons --clean -scons GTK3=1 SYSTEM_LUA=1 SYSTEM_MINIZIP=1 CREATE_AVI=1 +scons GTK3=1 SYSTEM_LUA=1 SYSTEM_MINIZIP=1 CREATE_AVI=1 install --prefix=$INSTALL_PREFIX/usr + +# Debug via ssh if necessary +if [ ! -z $APPVEYOR_SSH_BLOCK ]; then + curl -sflL 'https://raw.githubusercontent.com/appveyor/ci/master/scripts/enable-ssh.sh' | bash -e - +fi + +if [ -e $INSTALL_PREFIX/usr/bin/fceux ]; then + echo '**************************************************************' + echo 'Printing Shared Object Dependencies for ./bin/fceux Executable' + echo '**************************************************************' + ldd $INSTALL_PREFIX/usr/bin/fceux +else + echo "Error: Executable Failed to build: $INSTALL_PREFIX/usr/bin/fceux"; + exit 1; +fi + +echo '**************************************************************' +echo 'Printing Packaged Files ' +echo '**************************************************************' +find $INSTALL_PREFIX -ls -ltr ./bin/* From 5173b85ac1fb69ce24dbf8aa4e410ef3dbbc5b2d Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Fri, 15 May 2020 17:02:33 -0400 Subject: [PATCH 062/156] Added logic to check if the screen size has actually changed in the window configure event callback. Do not reset video is screen size is the same. This prevents annoying screen flickering during transitions to/from full screen mode. --- src/drivers/sdl/gui.cpp | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 4a3e4676..51f6d88f 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -64,6 +64,8 @@ GtkRadioAction *stateSlot = NULL; bool gtkIsStarted = false; bool menuTogglingEnabled = false; +unsigned int gtk_win_width = NES_WIDTH; +unsigned int gtk_win_height = NES_HEIGHT; unsigned int gtk_draw_area_width = NES_WIDTH; unsigned int gtk_draw_area_height = NES_HEIGHT; static GtkTreeStore *hotkey_store = NULL; @@ -3013,11 +3015,16 @@ gboolean handle_resize (GtkWindow * win, GdkEvent * event, gpointer data) // of the GTK window as possible // get new window width/height - int width, height; + int width, height, winsize_changed; width = event->configure.width; height = event->configure.height; //printf ("DEBUG: Configure new window size: %dx%d\n", width, height); + winsize_changed = (width != gtk_win_width) || (height != gtk_win_height); + + gtk_win_width = width; + gtk_win_height = height; + // get width/height multipliers double xscale = width / (double) NES_WIDTH; double yscale = height / (double) NES_HEIGHT; @@ -3039,8 +3046,9 @@ gboolean handle_resize (GtkWindow * win, GdkEvent * event, gpointer data) g_config->setOption ("SDL.XScale", xscale); g_config->setOption ("SDL.YScale", yscale); //gtk_widget_realize(evbox); + flushGtkEvents (); - if (GameInfo != 0) + if ( winsize_changed && (GameInfo != 0) ) { KillVideo (); InitVideo (GameInfo); From 172dffec55916f617c76e8ce0e1ed9932425d244 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Fri, 15 May 2020 17:08:13 -0400 Subject: [PATCH 063/156] Changed window size variables in gui to be static as their is no reason to export them to the linker. --- src/drivers/sdl/gui.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 51f6d88f..46c0b603 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -64,10 +64,10 @@ GtkRadioAction *stateSlot = NULL; bool gtkIsStarted = false; bool menuTogglingEnabled = false; -unsigned int gtk_win_width = NES_WIDTH; -unsigned int gtk_win_height = NES_HEIGHT; unsigned int gtk_draw_area_width = NES_WIDTH; unsigned int gtk_draw_area_height = NES_HEIGHT; +static unsigned int gtk_win_width = NES_WIDTH; +static unsigned int gtk_win_height = NES_HEIGHT; static GtkTreeStore *hotkey_store = NULL; // check to see if a particular GTK version is available From 2f00e3517b2fc2c239a93d6265df09f9af5fc7be Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Fri, 15 May 2020 20:12:21 -0400 Subject: [PATCH 064/156] Added debian package creation script. --- pipelines/debpkg.pl | 93 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 93 insertions(+) create mode 100755 pipelines/debpkg.pl diff --git a/pipelines/debpkg.pl b/pipelines/debpkg.pl new file mode 100755 index 00000000..e798128d --- /dev/null +++ b/pipelines/debpkg.pl @@ -0,0 +1,93 @@ +#!/usr/bin/perl + +use strict; + +my $VERSION="2.2.4"; +my $INSTALL_PREFIX="/tmp/fceux"; +my $CTL_FILENAME="$INSTALL_PREFIX/DEBIAN/control"; + +my $SO_LIST=`objdump -x $INSTALL_PREFIX/usr/bin/fceux`; + +#print "$SO_LIST"; + +my $i; my $j; my $k; my $PKG; +my @fd = split /\n/, $SO_LIST; +my @libls; + +$#libls=0; + +for ($i=0; $i<=$#fd; $i++) +{ + #$fd[$i] =~ s/^\s+//; + #print "$fd[$i]\n"; + + if ( $fd[$i] =~ m/NEEDED\s+(.*)/ ) + { + #print "$1 \n"; + $libls[$#libls] = $1; $#libls++; + } + + #$PKG=`dpkg-query -S $fd[$i] | cut -d ':' -f1`; +} + +my @rpm; +my @rpmfile; +my @rpmfilelist; +my $rpmlist = `rpm -qa`; +@rpm = split /\n/, $rpmlist; + +$#rpmfilelist = 0; + +for ($i=0; $i<=$#rpm; $i++) +{ + #print "$fd[$i]\n"; + #$pkg = `rpm -qf --queryformat '%{NAME}'`; + # + $rpmfilelist[ $#rpmfilelist ] = `rpm -ql $rpm[$i]`; + $#rpmfilelist++; +} + +for ($i=0; $i<$#libls; $i++) +{ + for ($j=0; $j<$#rpmfilelist; $j++) + { + @rpmfile = split /\n/, $rpmfilelist[$j]; + + for ($k=0; $k<=$#rpmfile; $k++) + { + if ( $rpmfile[$k] =~ m/$libls[$i]/ ) + { + print "FOUND: $rpmfile[$k] in $rpm[$j]\n"; + } + } + } +} +#for LIB in $LDD_LIST +#do +# PKG+=`dpkg-query -S $LIB | cut -d ':' -f1`; +#done +# +# +system("mkdir -p $INSTALL_PREFIX/DEBIAN"); + +open CTL, ">$CTL_FILENAME" or die "Error: Could not open file '$CTL_FILENAME'\n"; +# +print CTL "Package: fceux"; +print CTL "Version: $VERSION"; +print CTL "Section: games"; +print CTL "Priority: extra"; +print CTL "Architecture: amd64"; +print CTL "Homepage: http://fceux.com/"; +print CTL "Essential: no"; +print CTL "Installed-Size: 1024"; +print CTL "Maintainer: mjbudd77"; +print CTL "Description: fceux is an emulator of the original (8-bit) Nintendo Entertainment System (NES)"; +print CTL "Depends: liblua5.1-0, libsdl1.2debian, libsdl2-2.0-0, libminizip1, libgtk-3-0 "; + +close CTL; +# +#cd /tmp; +#dpkg-deb --build fceux +#mv fceux.deb fceux-$VERSION.deb +#dpkg-deb -I fceux-$VERSION.deb +# From e70b38cf5f7a86ae42643cd7c0f5a0ed76ee6d94 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Fri, 15 May 2020 21:17:54 -0400 Subject: [PATCH 065/156] Bug fixes for debian package builder script. Added package build to pipeline. --- pipelines/debpkg.pl | 105 +++++++++++++++++++++++---------------- pipelines/linux_build.sh | 15 +++++- 2 files changed, 76 insertions(+), 44 deletions(-) diff --git a/pipelines/debpkg.pl b/pipelines/debpkg.pl index e798128d..d3653be2 100755 --- a/pipelines/debpkg.pl +++ b/pipelines/debpkg.pl @@ -5,12 +5,14 @@ use strict; my $VERSION="2.2.4"; my $INSTALL_PREFIX="/tmp/fceux"; my $CTL_FILENAME="$INSTALL_PREFIX/DEBIAN/control"; +my $ARCH="amd64"; +my $PKG_OUTPUT_FILE="fceux-$VERSION-$ARCH.deb"; my $SO_LIST=`objdump -x $INSTALL_PREFIX/usr/bin/fceux`; #print "$SO_LIST"; -my $i; my $j; my $k; my $PKG; +my $i; my $j; my $k; my $pkg; my @fd = split /\n/, $SO_LIST; my @libls; @@ -27,67 +29,84 @@ for ($i=0; $i<=$#fd; $i++) $libls[$#libls] = $1; $#libls++; } - #$PKG=`dpkg-query -S $fd[$i] | cut -d ':' -f1`; } -my @rpm; -my @rpmfile; -my @rpmfilelist; -my $rpmlist = `rpm -qa`; -@rpm = split /\n/, $rpmlist; +my %pkghash; my $pkgsearch; +my @pkglist; my @pkgdeps; +my $pkg; my $filepath; -$#rpmfilelist = 0; - -for ($i=0; $i<=$#rpm; $i++) -{ - #print "$fd[$i]\n"; - #$pkg = `rpm -qf --queryformat '%{NAME}'`; - # - $rpmfilelist[ $#rpmfilelist ] = `rpm -ql $rpm[$i]`; - $#rpmfilelist++; -} +$#pkgdeps=0; for ($i=0; $i<$#libls; $i++) { - for ($j=0; $j<$#rpmfilelist; $j++) - { - @rpmfile = split /\n/, $rpmfilelist[$j]; + $pkgsearch=`dpkg-query -S $libls[$i]`; - for ($k=0; $k<=$#rpmfile; $k++) + @pkglist = split /\n/, $pkgsearch; + + for ($j=0; $j<=$#pkglist; $j++) + { + #$pkghash{$pkg} = 1; + #print " $libls[$i] '$pkglist[$j]' \n"; + + if ( $pkglist[$j] =~ m/(.*):$ARCH:\s+(.*)/ ) { - if ( $rpmfile[$k] =~ m/$libls[$i]/ ) - { - print "FOUND: $rpmfile[$k] in $rpm[$j]\n"; + $pkg = $1; + $filepath = $2; + + $filepath =~ s/^.*\///; + + if ( $libls[$i] eq $filepath ) + { + #print "PKG: '$pkg' '$libls[$i]' == '$filepath' \n"; + $pkgdeps[ $#pkgdeps ] = $pkg; $#pkgdeps++; } } } } -#for LIB in $LDD_LIST -#do -# PKG+=`dpkg-query -S $LIB | cut -d ':' -f1`; -#done # # system("mkdir -p $INSTALL_PREFIX/DEBIAN"); open CTL, ">$CTL_FILENAME" or die "Error: Could not open file '$CTL_FILENAME'\n"; # -print CTL "Package: fceux"; -print CTL "Version: $VERSION"; -print CTL "Section: games"; -print CTL "Priority: extra"; -print CTL "Architecture: amd64"; -print CTL "Homepage: http://fceux.com/"; -print CTL "Essential: no"; -print CTL "Installed-Size: 1024"; -print CTL "Maintainer: mjbudd77"; -print CTL "Description: fceux is an emulator of the original (8-bit) Nintendo Entertainment System (NES)"; -print CTL "Depends: liblua5.1-0, libsdl1.2debian, libsdl2-2.0-0, libminizip1, libgtk-3-0 "; +print CTL "Package: fceux\n"; +print CTL "Version: $VERSION\n"; +print CTL "Section: games\n"; +print CTL "Priority: extra\n"; +print CTL "Architecture: $ARCH\n"; +print CTL "Homepage: http://fceux.com/\n"; +print CTL "Essential: no\n"; +#print CTL "Installed-Size: 1024\n"; +print CTL "Maintainer: mjbudd77\n"; +print CTL "Description: fceux is an emulator of the original (8-bit) Nintendo Entertainment System (NES)\n"; +print CTL "Depends: $pkgdeps[0]"; + +for ($i=1; $i<$#pkgdeps; $i++) +{ + print CTL ", $pkgdeps[$i]"; +} +print CTL "\n"; close CTL; + +#system("cat $CTL_FILENAME"); # -#cd /tmp; -#dpkg-deb --build fceux -#mv fceux.deb fceux-$VERSION.deb -#dpkg-deb -I fceux-$VERSION.deb +chdir "/tmp"; +system("dpkg-deb --build fceux "); +if ( !(-e "/tmp/fceux.deb") ) +{ + die "Error: Failed to create package $PKG_OUTPUT_FILE\n"; +} +system("mv fceux.deb $PKG_OUTPUT_FILE"); +system("dpkg-deb -I $PKG_OUTPUT_FILE"); # +if ( -e "/tmp/$PKG_OUTPUT_FILE" ) +{ + print "**********************************************\n"; + print "Created deb package: /tmp/$PKG_OUTPUT_FILE\n"; + print "**********************************************\n"; +} +else +{ + die "Error: Failed to create package $PKG_OUTPUT_FILE\n"; +} diff --git a/pipelines/linux_build.sh b/pipelines/linux_build.sh index 15ccefd2..ec4c3481 100755 --- a/pipelines/linux_build.sh +++ b/pipelines/linux_build.sh @@ -4,6 +4,10 @@ id pwd cat /etc/os-release +SCRIPT_DIR=$( cd $(dirname $BASH_SOURCE[0]); pwd ); + +#echo $SCRIPT_DIR; + gcc --version python2 --version python3 --version @@ -95,7 +99,16 @@ else fi echo '**************************************************************' -echo 'Printing Packaged Files ' +echo 'Printing To Be Packaged Files ' echo '**************************************************************' find $INSTALL_PREFIX +echo '**************************************************************' +echo 'Creating Debian Package' +echo '**************************************************************' +$SCRIPT_DIR/debpkg.pl; + +echo '**************************************************************' +echo 'Testing Install of Package' +echo '**************************************************************' +dpkg -i /tmp/fceux*.deb From 09d84283cde374953b0318a2970c456c51340a9b Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Fri, 15 May 2020 21:27:17 -0400 Subject: [PATCH 066/156] bug fix for test install of debian pkg --- pipelines/debpkg.pl | 2 ++ pipelines/linux_build.sh | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/pipelines/debpkg.pl b/pipelines/debpkg.pl index d3653be2..33171e43 100755 --- a/pipelines/debpkg.pl +++ b/pipelines/debpkg.pl @@ -8,6 +8,8 @@ my $CTL_FILENAME="$INSTALL_PREFIX/DEBIAN/control"; my $ARCH="amd64"; my $PKG_OUTPUT_FILE="fceux-$VERSION-$ARCH.deb"; +# Start by auto figuring out dependencies of the executable. +# the rest of the package creation is trival. my $SO_LIST=`objdump -x $INSTALL_PREFIX/usr/bin/fceux`; #print "$SO_LIST"; diff --git a/pipelines/linux_build.sh b/pipelines/linux_build.sh index ec4c3481..5acd73b1 100755 --- a/pipelines/linux_build.sh +++ b/pipelines/linux_build.sh @@ -111,4 +111,4 @@ $SCRIPT_DIR/debpkg.pl; echo '**************************************************************' echo 'Testing Install of Package' echo '**************************************************************' -dpkg -i /tmp/fceux*.deb +sudo dpkg -i /tmp/fceux-*.deb From 3573a596e92c7223eb0a75fae292b8b4e6b34b1d Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 16 May 2020 07:38:20 -0400 Subject: [PATCH 067/156] Added logic to the deb pkg script to not put duplicate entries into the pkg depends list. --- pipelines/debpkg.pl | 25 +++++++++++++++---------- 1 file changed, 15 insertions(+), 10 deletions(-) diff --git a/pipelines/debpkg.pl b/pipelines/debpkg.pl index 33171e43..64c04735 100755 --- a/pipelines/debpkg.pl +++ b/pipelines/debpkg.pl @@ -52,16 +52,21 @@ for ($i=0; $i<$#libls; $i++) if ( $pkglist[$j] =~ m/(.*):$ARCH:\s+(.*)/ ) { - $pkg = $1; - $filepath = $2; - - $filepath =~ s/^.*\///; - - if ( $libls[$i] eq $filepath ) - { - #print "PKG: '$pkg' '$libls[$i]' == '$filepath' \n"; - $pkgdeps[ $#pkgdeps ] = $pkg; $#pkgdeps++; - } + $pkg = $1; + $filepath = $2; + + $filepath =~ s/^.*\///; + + if ( $libls[$i] eq $filepath ) + { + #print "PKG: '$pkg' '$libls[$i]' == '$filepath' \n"; + # Don't put duplicate entries into the pkg depend list. + if ( !defined( $pkghash{$pkg} ) ) + { + $pkgdeps[ $#pkgdeps ] = $pkg; $#pkgdeps++; + $pkghash{$pkg} = 1; + } + } } } } From c3e4db0faa121bec9d81a59e0afa035397f6b597 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 16 May 2020 09:09:36 -0400 Subject: [PATCH 068/156] Hotkey selected state cleanup. Sync gui menu selected state when state changes occur via hotkeys. Removed deprecated gtk widgets from sdl/input.cpp. --- src/drivers/sdl/gui.cpp | 38 +++++++++++++++++++++++++++----------- src/drivers/sdl/gui.h | 3 ++- src/drivers/sdl/input.cpp | 31 ++++++++++++++++++++----------- 3 files changed, 49 insertions(+), 23 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 46c0b603..0463fd10 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -59,15 +59,15 @@ GtkWidget *evbox = NULL; GtkWidget *padNoCombo = NULL; GtkWidget *configNoCombo = NULL; GtkWidget *buttonMappings[10]; -GtkWidget *Menubar; -GtkRadioAction *stateSlot = NULL; +static GtkWidget *Menubar = NULL; +static GtkRadioMenuItem *stateSlot[10] = { NULL }; bool gtkIsStarted = false; bool menuTogglingEnabled = false; unsigned int gtk_draw_area_width = NES_WIDTH; unsigned int gtk_draw_area_height = NES_HEIGHT; -static unsigned int gtk_win_width = NES_WIDTH; -static unsigned int gtk_win_height = NES_HEIGHT; +static unsigned int gtk_win_width = 0; +static unsigned int gtk_win_height = 0; static GtkTreeStore *hotkey_store = NULL; // check to see if a particular GTK version is available @@ -2168,11 +2168,18 @@ void quickSave (void) FCEUI_SaveState (NULL); } -//void changeState(GtkAction *action, GtkRadioAction *current, gpointer data) -void changeState (GtkRadioMenuItem * radiomenuitem, gpointer user_data) +void setStateMenuItem( int i ) { - //printf("Changing State: %li\n", (long)user_data); - FCEUI_SelectState ((long) user_data, 0); + if ( (i >= 0) && (i < 10) ) + { + gtk_menu_item_activate( GTK_MENU_ITEM(stateSlot[i]) ); + } +} + +static void changeState (GtkRadioMenuItem * radiomenuitem, gpointer user_data) +{ + printf("GTK Changing State: %li\n", (long)user_data); + FCEUI_SelectState ((long) user_data, 1); } #if SDL_VERSION_ATLEAST(2, 0, 0) @@ -2526,6 +2533,8 @@ static GtkWidget *CreateMenubar (GtkWidget * window) item = gtk_radio_menu_item_new_with_label (radioGroup, stmp); + stateSlot[i] = GTK_RADIO_MENU_ITEM(item); + radioGroup = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (item)); @@ -3015,7 +3024,7 @@ gboolean handle_resize (GtkWindow * win, GdkEvent * event, gpointer data) // of the GTK window as possible // get new window width/height - int width, height, winsize_changed; + int width, height, draw_width, draw_height, winsize_changed = 0; width = event->configure.width; height = event->configure.height; //printf ("DEBUG: Configure new window size: %dx%d\n", width, height); @@ -3029,8 +3038,15 @@ gboolean handle_resize (GtkWindow * win, GdkEvent * event, gpointer data) double xscale = width / (double) NES_WIDTH; double yscale = height / (double) NES_HEIGHT; - gtk_draw_area_width = gtk_widget_get_allocated_width (evbox); - gtk_draw_area_height = gtk_widget_get_allocated_height (evbox); + draw_width = gtk_widget_get_allocated_width (evbox); + draw_height = gtk_widget_get_allocated_height (evbox); + + if ( (draw_width != gtk_draw_area_width) || (draw_height != gtk_draw_area_height) ) + { + winsize_changed = 1; + } + gtk_draw_area_width = draw_width; + gtk_draw_area_height = draw_height; if ( gtk_draw_area_width < NES_WIDTH ) gtk_draw_area_width = NES_WIDTH; if ( gtk_draw_area_height < NES_HEIGHT ) gtk_draw_area_height = NES_HEIGHT; diff --git a/src/drivers/sdl/gui.h b/src/drivers/sdl/gui.h index 35b5bdbf..3edb5782 100644 --- a/src/drivers/sdl/gui.h +++ b/src/drivers/sdl/gui.h @@ -27,7 +27,6 @@ #endif extern GtkWidget* MainWindow; extern GtkWidget* evbox; -extern GtkRadioAction* stateSlot; extern int GtkMouseData[3]; extern bool gtkIsStarted; @@ -55,6 +54,8 @@ void setGl(GtkWidget* w, gpointer p); void setDoubleBuffering(GtkWidget* w, gpointer p); #endif +void setStateMenuItem( int i ); + void openVideoConfig(); void openSoundConfig(); void quit (); diff --git a/src/drivers/sdl/input.cpp b/src/drivers/sdl/input.cpp index 1fdb891b..e0c459cf 100644 --- a/src/drivers/sdl/input.cpp +++ b/src/drivers/sdl/input.cpp @@ -31,6 +31,7 @@ #include "../../movie.h" #include "../../fceu.h" #include "../../driver.h" +#include "../../state.h" #include "../../utils/xstring.h" #ifdef _S9XLUA_H #include "../../fceulua.h" @@ -281,16 +282,16 @@ std::string GetFilename (const char *title, bool save, const char *filter) if (save) fileChooser = gtk_file_chooser_dialog_new ("Save as", NULL, GTK_FILE_CHOOSER_ACTION_SAVE, - GTK_STOCK_CANCEL, + "_Cancel", GTK_RESPONSE_CANCEL, - GTK_STOCK_SAVE_AS, + "_Save", GTK_RESPONSE_ACCEPT, NULL); else fileChooser = gtk_file_chooser_dialog_new ("Open", NULL, GTK_FILE_CHOOSER_ACTION_OPEN, - GTK_STOCK_CANCEL, + "_Cancel", GTK_RESPONSE_CANCEL, - GTK_STOCK_OPEN, + "_Open", GTK_RESPONSE_ACCEPT, NULL); // TODO: make file filters case insensitive @@ -739,22 +740,30 @@ static void KeyboardCommands () #endif for (int i = 0; i < 10; i++) + { if (_keyonly (Hotkeys[HK_SELECT_STATE_0 + i])) { #ifdef _GTK - gtk_radio_action_set_current_value (stateSlot, i); + setStateMenuItem(i); #endif FCEUI_SelectState (i, 1); } + } if (_keyonly (Hotkeys[HK_SELECT_STATE_NEXT])) { FCEUI_SelectStateNext (1); +#ifdef _GTK + setStateMenuItem( CurrentState ); +#endif } if (_keyonly (Hotkeys[HK_SELECT_STATE_PREV])) { FCEUI_SelectStateNext (-1); +#ifdef _GTK + setStateMenuItem( CurrentState ); +#endif } if (_keyonly (Hotkeys[HK_BIND_STATE])) @@ -1685,13 +1694,13 @@ const char * ButtonName (const ButtConfig * bc, int which) inputValue = bc->ButtonNum[which] & 0xF; if (inputValue & SDL_HAT_UP) - strncat (direction, "Up ", sizeof (direction)); + strncat (direction, "Up ", sizeof (direction)-1); if (inputValue & SDL_HAT_DOWN) - strncat (direction, "Down ", sizeof (direction)); + strncat (direction, "Down ", sizeof (direction)-1); if (inputValue & SDL_HAT_LEFT) - strncat (direction, "Left ", sizeof (direction)); + strncat (direction, "Left ", sizeof (direction)-1); if (inputValue & SDL_HAT_RIGHT) - strncat (direction, "Right ", sizeof (direction)); + strncat (direction, "Right ", sizeof (direction)-1); if (direction[0]) inputDirection = direction; @@ -2127,7 +2136,7 @@ UpdateInput (Config * config) for (unsigned int i = 0; i < GAMEPAD_NUM_DEVICES; i++) { char buf[64]; - snprintf (buf, 20, "SDL.Input.GamePad.%d.", i); + snprintf (buf, 32, "SDL.Input.GamePad.%d.", i); prefix = buf; config->getOption (prefix + "DeviceType", &device); @@ -2160,7 +2169,7 @@ UpdateInput (Config * config) for (unsigned int i = 0; i < POWERPAD_NUM_DEVICES; i++) { char buf[64]; - snprintf (buf, 20, "SDL.Input.PowerPad.%d.", i); + snprintf (buf, 32, "SDL.Input.PowerPad.%d.", i); prefix = buf; config->getOption (prefix + "DeviceType", &device); From b63772b774dd5d02bd6e3217e9f0ad6a8f935acf Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 16 May 2020 09:19:25 -0400 Subject: [PATCH 069/156] Removed debug print statement. --- src/drivers/sdl/gui.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 0463fd10..ce439296 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -2178,7 +2178,7 @@ void setStateMenuItem( int i ) static void changeState (GtkRadioMenuItem * radiomenuitem, gpointer user_data) { - printf("GTK Changing State: %li\n", (long)user_data); + //printf("GTK Changing State: %li\n", (long)user_data); FCEUI_SelectState ((long) user_data, 1); } From e5e02e20f4ad185e85a787ab0898cce2cd3213b5 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 16 May 2020 09:47:13 -0400 Subject: [PATCH 070/156] Bug fix for gamepad key name display when calibrating buttons. --- src/drivers/sdl/input.cpp | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/drivers/sdl/input.cpp b/src/drivers/sdl/input.cpp index e0c459cf..a470372d 100644 --- a/src/drivers/sdl/input.cpp +++ b/src/drivers/sdl/input.cpp @@ -1070,6 +1070,10 @@ int ButtonConfigBegin () // TODO - SDL2 #else screen = SDL_SetVideoMode (420, 200, 8, 0); + if ( screen == NULL ) + { + printf("Error: SDL_SetVideoMode Failed\n"); + } SDL_WM_SetCaption ("Button Config", 0); #endif } @@ -1672,7 +1676,9 @@ const char * ButtonName (const ButtConfig * bc, int which) #else return SDL_GetKeyName ((SDLKey) bc->ButtonNum[which]); #endif + break; case BUTTC_JOYSTICK: + { int joyNum, inputNum; const char *inputType, *inputDirection; @@ -1713,6 +1719,9 @@ const char * ButtonName (const ButtConfig * bc, int which) inputNum = bc->ButtonNum[which]; inputDirection = ""; } + sprintf( name, "js%i:%s%i%s", joyNum, inputType, inputNum, inputDirection ); + } + break; } return name; From 01c60c4dc1c9d18c8700b8789c4b0534c0071323 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 16 May 2020 10:14:37 -0400 Subject: [PATCH 071/156] Bug fix for displaying button names when reloading gamepad config window. --- src/drivers/sdl/gui.cpp | 60 ++++++++++++++++++++--------------------- 1 file changed, 30 insertions(+), 30 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index ce439296..86ba5330 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -652,21 +652,21 @@ void openHotkeyConfig (void) } -GtkWidget *typeCombo; +//GtkWidget *typeCombo; // TODO: finish this -int setInputDevice (GtkWidget * w, gpointer p) -{ - std::string s = "SDL.Input."; - s = s + (char *) p; - printf ("%s", s.c_str ()); - g_config->setOption (s, - gtk_combo_box_text_get_active_text - (GTK_COMBO_BOX_TEXT (typeCombo))); - g_config->save (); - - return 1; -} +//int setInputDevice (GtkWidget * w, gpointer p) +//{ +// std::string s = "SDL.Input."; +// s = s + (char *) p; +// printf ("setInputDevice: %s", s.c_str ()); +// g_config->setOption (s, +// gtk_combo_box_text_get_active_text +// (GTK_COMBO_BOX_TEXT (typeCombo))); +// g_config->save (); +// +// return 1; +//} void updateGamepadConfig (GtkWidget * w, gpointer p) { @@ -696,8 +696,8 @@ void updateGamepadConfig (GtkWidget * w, gpointer p) ButtonNum[configNo])); #endif } - else // FIXME: display joystick button/hat/axis names properly - strncpy (strBuf, "Joystick", sizeof (strBuf)); + else + sprintf (strBuf, "%s", ButtonName( &GamePadConfig[padNo][i], configNo ) ); gtk_label_set_text (GTK_LABEL (mappedKey), strBuf); gtk_label_set_use_markup (GTK_LABEL (mappedKey), TRUE); @@ -744,19 +744,19 @@ void openGamepadConfig (void) oppositeDirChk = gtk_check_button_new_with_label ("Allow Up+Down / Left+Right"); - typeCombo = gtk_combo_box_text_new (); - gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (typeCombo), - "gamepad"); - gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (typeCombo), - "zapper"); - gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (typeCombo), - "powerpad.0"); - gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (typeCombo), - "powerpad.1"); - gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (typeCombo), - "arkanoid"); + //typeCombo = gtk_combo_box_text_new (); + //gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (typeCombo), + // "gamepad"); + //gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (typeCombo), + // "zapper"); + //gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (typeCombo), + // "powerpad.0"); + //gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (typeCombo), + // "powerpad.1"); + //gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (typeCombo), + // "arkanoid"); - gtk_combo_box_set_active (GTK_COMBO_BOX (typeCombo), 0); + //gtk_combo_box_set_active (GTK_COMBO_BOX (typeCombo), 0); padNoCombo = gtk_combo_box_text_new (); @@ -782,9 +782,9 @@ void openGamepadConfig (void) G_CALLBACK (updateGamepadConfig), NULL); - g_signal_connect (typeCombo, "changed", G_CALLBACK (setInputDevice), - gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT - (typeCombo))); + //g_signal_connect (typeCombo, "changed", G_CALLBACK (setInputDevice), + // gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT + // (typeCombo))); setCheckbox (fourScoreChk, "SDL.FourScore"); g_signal_connect (fourScoreChk, "clicked", G_CALLBACK (toggleOption), From 00e316b5214a318268bc444eaaa5284efbdb2a2e Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 16 May 2020 10:40:57 -0400 Subject: [PATCH 072/156] Bug fix for loading gamepad config at startup. --- src/drivers/sdl/input.cpp | 2 +- src/drivers/sdl/sdl.cpp | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/drivers/sdl/input.cpp b/src/drivers/sdl/input.cpp index a470372d..3110d32e 100644 --- a/src/drivers/sdl/input.cpp +++ b/src/drivers/sdl/input.cpp @@ -2145,7 +2145,7 @@ UpdateInput (Config * config) for (unsigned int i = 0; i < GAMEPAD_NUM_DEVICES; i++) { char buf[64]; - snprintf (buf, 32, "SDL.Input.GamePad.%d.", i); + snprintf (buf, 32, "SDL.Input.GamePad.%d", i); prefix = buf; config->getOption (prefix + "DeviceType", &device); diff --git a/src/drivers/sdl/sdl.cpp b/src/drivers/sdl/sdl.cpp index 9273d578..ce69bd54 100644 --- a/src/drivers/sdl/sdl.cpp +++ b/src/drivers/sdl/sdl.cpp @@ -614,8 +614,8 @@ int main(int argc, char *argv[]) g_config->getOption("SDL.InputCfg", &s); if(s.size() != 0) { - InitVideo(GameInfo); - InputCfg(s); + InitVideo(GameInfo); + InputCfg(s); } // set the FAMICOM PAD 2 Mic thing { From 26f36da7e73ea5f6b597f64a6b23c03615efe978 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 16 May 2020 11:13:24 -0400 Subject: [PATCH 073/156] Another bug fix for gamepad config loading at startup, the first fix was in the wrong place. Removed static video variable from header. --- src/drivers/sdl/config.cpp | 7 ++++--- src/drivers/sdl/gui.cpp | 2 +- src/drivers/sdl/input.cpp | 2 +- src/drivers/sdl/sdl-video.cpp | 2 +- src/drivers/sdl/sdl-video.h | 1 - 5 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/drivers/sdl/config.cpp b/src/drivers/sdl/config.cpp index 3c5b04df..a249d74e 100644 --- a/src/drivers/sdl/config.cpp +++ b/src/drivers/sdl/config.cpp @@ -269,9 +269,10 @@ InitConfig() config->addOption("4buttonexit", "SDL.ABStartSelectExit", 0); // GamePad 0 - 3 - for(unsigned int i = 0; i < GAMEPAD_NUM_DEVICES; i++) { + for(unsigned int i = 0; i < GAMEPAD_NUM_DEVICES; i++) + { char buf[64]; - snprintf(buf, 20, "SDL.Input.GamePad.%d.", i); + snprintf(buf, sizeof(buf)-1, "SDL.Input.GamePad.%d.", i); prefix = buf; config->addOption(prefix + "DeviceType", DefaultGamePadDevice[i]); @@ -284,7 +285,7 @@ InitConfig() // PowerPad 0 - 1 for(unsigned int i = 0; i < POWERPAD_NUM_DEVICES; i++) { char buf[64]; - snprintf(buf, 20, "SDL.Input.PowerPad.%d.", i); + snprintf(buf, sizeof(buf)-1, "SDL.Input.PowerPad.%d.", i); prefix = buf; config->addOption(prefix + "DeviceType", DefaultPowerPadDevice[i]); diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 86ba5330..a483d2b8 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -126,7 +126,7 @@ int configGamepadButton (GtkButton * button, gpointer p) ButtonConfigBegin (); - snprintf (buf, sizeof (buf), "SDL.Input.GamePad.%d", padNo); + snprintf (buf, sizeof(buf)-1, "SDL.Input.GamePad.%d.", padNo); prefix = buf; DWaitButton (NULL, &GamePadConfig[padNo][x], configNo); diff --git a/src/drivers/sdl/input.cpp b/src/drivers/sdl/input.cpp index 3110d32e..e6782e34 100644 --- a/src/drivers/sdl/input.cpp +++ b/src/drivers/sdl/input.cpp @@ -2145,7 +2145,7 @@ UpdateInput (Config * config) for (unsigned int i = 0; i < GAMEPAD_NUM_DEVICES; i++) { char buf[64]; - snprintf (buf, 32, "SDL.Input.GamePad.%d", i); + snprintf (buf, sizeof(buf)-1, "SDL.Input.GamePad.%d.", i); prefix = buf; config->getOption (prefix + "DeviceType", &device); diff --git a/src/drivers/sdl/sdl-video.cpp b/src/drivers/sdl/sdl-video.cpp index 4c24883d..a3538cf1 100644 --- a/src/drivers/sdl/sdl-video.cpp +++ b/src/drivers/sdl/sdl-video.cpp @@ -55,7 +55,7 @@ extern Config *g_config; // STATIC GLOBALS -extern SDL_Surface *s_screen; +static SDL_Surface *s_screen = NULL; static SDL_Surface *s_BlitBuf; // Buffer when using hardware-accelerated blits. static SDL_Surface *s_IconSurface = NULL; diff --git a/src/drivers/sdl/sdl-video.h b/src/drivers/sdl/sdl-video.h index ef6c30d5..82ac15f7 100644 --- a/src/drivers/sdl/sdl-video.h +++ b/src/drivers/sdl/sdl-video.h @@ -9,7 +9,6 @@ uint32 PtoV(uint16 x, uint16 y); bool FCEUD_ShouldDrawInputAids(); bool FCEUI_AviDisableMovieMessages(); -static SDL_Surface *s_screen; bool FCEUI_AviEnableHUDrecording(); void FCEUI_SetAviEnableHUDrecording(bool enable); bool FCEUI_AviDisableMovieMessages(); From 74923eaccc45695ba820cc86c77eb766f411d096 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 16 May 2020 13:16:24 -0400 Subject: [PATCH 074/156] Removed static hotkey string array from global header and added an accessor function. --- src/drivers/sdl/config.cpp | 40 ++++++++++++++++++++++++++++++++++++++ src/drivers/sdl/config.h | 31 +---------------------------- src/drivers/sdl/gui.cpp | 4 ++-- src/drivers/sdl/input.cpp | 2 +- 4 files changed, 44 insertions(+), 33 deletions(-) diff --git a/src/drivers/sdl/config.cpp b/src/drivers/sdl/config.cpp index a249d74e..d8bddc62 100644 --- a/src/drivers/sdl/config.cpp +++ b/src/drivers/sdl/config.cpp @@ -26,6 +26,46 @@ #include #include +static const char* HotkeyStrings[HK_MAX] = { + "CheatMenu", + "BindState", + "LoadLua", + "ToggleBG", + "SaveState", + "FDSSelect", + "LoadState", + "FDSEject", + "VSInsertCoin", + "VSToggleDip", + "MovieToggleFrameDisplay", + "SubtitleDisplay", + "Reset", + "Screenshot", + "Pause", + "DecreaseSpeed", + "IncreaseSpeed", + "FrameAdvance", + "Turbo", + "ToggleInputDisplay", + "ToggleMovieRW", + "MuteCapture", + "Quit", + "FrameAdvanceLagSkip", + "LagCounterDisplay", + "SelectState0", "SelectState1", "SelectState2", "SelectState3", + "SelectState4", "SelectState5", "SelectState6", "SelectState7", + "SelectState8", "SelectState9", "SelectStateNext", "SelectStatePrev", + "VolumeDown", "VolumeUp" }; + +const char *getHotkeyString( int i ) +{ + if ( (i>=0) && (igetOption (optionName.c_str (), &keycode); gtk_tree_store_set (hotkey_store, &iter, 0, optionName.c_str (), 1, @@ -578,7 +578,7 @@ static gint hotKeyPressCB (GtkTreeView * tree, GdkEventKey * event, { int sdlkey = 0; std::string hotKeyName = "SDL.Hotkeys."; - hotKeyName.append (HotkeyStrings[indexArray[0]]); + hotKeyName.append ( getHotkeyString(indexArray[0]) ); // Convert this keypress from GDK to SDL. #if SDL_VERSION_ATLEAST(2, 0, 0) diff --git a/src/drivers/sdl/input.cpp b/src/drivers/sdl/input.cpp index e6782e34..38d16fe1 100644 --- a/src/drivers/sdl/input.cpp +++ b/src/drivers/sdl/input.cpp @@ -183,7 +183,7 @@ setHotKeys (void) std::string prefix = "SDL.Hotkeys."; for (int i = 0; i < HK_MAX; i++) { - g_config->getOption (prefix + HotkeyStrings[i], &Hotkeys[i]); + g_config->getOption (prefix + getHotkeyString(i), &Hotkeys[i]); } return; } From c7f9a4257ad5002e038ee135b189dc54be652ebc Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 16 May 2020 15:06:40 -0400 Subject: [PATCH 075/156] Bug fixes for screen sizing at startup with a ROM specified on the command line. --- src/drivers/sdl/gui.cpp | 31 ++++++++++++++++++------------- src/drivers/sdl/sdl.cpp | 8 ++++---- 2 files changed, 22 insertions(+), 17 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index d4dbdc1c..ca34d6d7 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -68,6 +68,7 @@ unsigned int gtk_draw_area_width = NES_WIDTH; unsigned int gtk_draw_area_height = NES_HEIGHT; static unsigned int gtk_win_width = 0; static unsigned int gtk_win_height = 0; +static int gtk_win_menu_ysize = 30; static GtkTreeStore *hotkey_store = NULL; // check to see if a particular GTK version is available @@ -3038,14 +3039,16 @@ gboolean handle_resize (GtkWindow * win, GdkEvent * event, gpointer data) double xscale = width / (double) NES_WIDTH; double yscale = height / (double) NES_HEIGHT; - draw_width = gtk_widget_get_allocated_width (evbox); - draw_height = gtk_widget_get_allocated_height (evbox); + draw_width = gtk_win_width; + draw_height = gtk_win_height - gtk_win_menu_ysize; + + //printf("DRAW: %ix%i MenuY: %i \n", draw_width, draw_height, gtk_win_menu_ysize ); if ( (draw_width != gtk_draw_area_width) || (draw_height != gtk_draw_area_height) ) { winsize_changed = 1; } - gtk_draw_area_width = draw_width; + gtk_draw_area_width = draw_width; gtk_draw_area_height = draw_height; if ( gtk_draw_area_width < NES_WIDTH ) gtk_draw_area_width = NES_WIDTH; @@ -3063,13 +3066,15 @@ gboolean handle_resize (GtkWindow * win, GdkEvent * event, gpointer data) g_config->setOption ("SDL.YScale", yscale); //gtk_widget_realize(evbox); - flushGtkEvents (); + //flushGtkEvents (); if ( winsize_changed && (GameInfo != 0) ) { KillVideo (); InitVideo (GameInfo); } + gtk_widget_queue_draw( evbox ); + //gtk_widget_set_size_request(evbox, (int)(NES_WIDTH*xscale), (int)(NES_HEIGHT*yscale)); //printf ("DEBUG: new xscale: %f yscale: %f\n", xscale, yscale); @@ -3092,6 +3097,8 @@ static gboolean draw_cb (GtkWidget * widget, cairo_t * cr, gpointer data) if ( gtk_draw_area_width < NES_WIDTH ) gtk_draw_area_width = NES_WIDTH; if ( gtk_draw_area_height < NES_HEIGHT ) gtk_draw_area_height = NES_HEIGHT; + gtk_win_menu_ysize = gtk_win_height - gtk_draw_area_height; + // Clear the screen on a window redraw //if (GameInfo == 0) //{ @@ -3152,15 +3159,6 @@ int InitGTKSubsystem (int argc, char **argv) g_config->getOption ("SDL.XScale", &xscale); g_config->getOption ("SDL.YScale", &yscale); - gtk_widget_set_size_request (evbox, NES_WIDTH * xscale, - NES_HEIGHT * yscale); - gtk_widget_realize (evbox); - gtk_widget_show (evbox); - gtk_widget_show_all (vbox); - - //GdkColor bg = {0, 0, 0, 0}; - //gtk_widget_modify_bg(evbox, GTK_STATE_NORMAL, &bg); - // set up keypress "snooper" to convert GDK keypress events into SDL keypresses //gtk_key_snooper_install(convertKeypress, NULL); g_signal_connect (G_OBJECT (MainWindow), "key-press-event", @@ -3184,6 +3182,13 @@ int InitGTKSubsystem (int argc, char **argv) G_CALLBACK (handle_resize), NULL); g_signal_connect (evbox, "draw", G_CALLBACK (draw_cb), NULL); + gtk_widget_set_size_request (evbox, NES_WIDTH * xscale, + NES_HEIGHT * yscale); + + gtk_widget_realize (evbox); + gtk_widget_show (evbox); + gtk_widget_show_all (vbox); + gtk_widget_show_all (MainWindow); GtkRequisition req; diff --git a/src/drivers/sdl/sdl.cpp b/src/drivers/sdl/sdl.cpp index ce69bd54..a245b98b 100644 --- a/src/drivers/sdl/sdl.cpp +++ b/src/drivers/sdl/sdl.cpp @@ -193,9 +193,9 @@ static void ShowUsage(char *prog) */ int LoadGame(const char *path) { - if (isloaded){ - CloseGame(); - } + if (isloaded){ + CloseGame(); + } if(!FCEUI_LoadGame(path, 1)) { return 0; } @@ -864,7 +864,7 @@ int main(int argc, char *argv[]) } #endif - if(romIndex >= 0) + if(romIndex >= 0) { // load the specified game error = LoadGame(argv[romIndex]); From 9dcad0b21139bb5d01b426d9d3372e0b76d75583 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 16 May 2020 18:50:29 -0400 Subject: [PATCH 076/156] Bug fix for gamepad configuration when using keyboard inputs. --- src/drivers/sdl/gui.cpp | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index ca34d6d7..51dc0a2a 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -71,6 +71,8 @@ static unsigned int gtk_win_height = 0; static int gtk_win_menu_ysize = 30; static GtkTreeStore *hotkey_store = NULL; +static gint convertKeypress (GtkWidget * grab, GdkEventKey * event, gpointer user_data); + // check to see if a particular GTK version is available // 2.24 is required for most of the dialogs -- ie: checkGTKVersion(2,24); bool checkGTKVersion (int major_required, int minor_required) @@ -860,6 +862,11 @@ void openGamepadConfig (void) gtk_widget_show_all (win); + g_signal_connect (G_OBJECT (win), "key-press-event", + G_CALLBACK (convertKeypress), NULL); + g_signal_connect (G_OBJECT (win), "key-release-event", + G_CALLBACK (convertKeypress), NULL); + return; } @@ -2395,9 +2402,9 @@ static gint convertKeypress (GtkWidget * grab, GdkEventKey * event, SDL_PushEvent (&sdlev); // Only let the emulator handle the key event if this window has the input focus. - if (keystate == 0 - || gtk_window_is_active (GTK_WINDOW (MainWindow))) - { + //if (keystate == 0 + // || gtk_window_is_active (GTK_WINDOW (MainWindow))) + //{ #if SDL_VERSION_ATLEAST(2, 0, 0) // Not sure how to do this yet with SDL 2.0 // TODO - SDL 2.0 @@ -2405,7 +2412,7 @@ static gint convertKeypress (GtkWidget * grab, GdkEventKey * event, #else SDL_GetKeyState (NULL)[sdlkey] = keystate; #endif - } + //} } // Allow GTK+ to process this key. From 5834dd3661c9dba2a74d0dc6d4891ec71995db5c Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 16 May 2020 22:17:24 -0400 Subject: [PATCH 077/156] Added memory view window framework. Still TODO memory poke functionality. --- src/drivers/sdl/SConscript | 1 + src/drivers/sdl/gui.cpp | 12 ++ src/drivers/sdl/memview.cpp | 354 ++++++++++++++++++++++++++++++++++++ src/drivers/sdl/memview.h | 4 + 4 files changed, 371 insertions(+) create mode 100644 src/drivers/sdl/memview.cpp create mode 100644 src/drivers/sdl/memview.h diff --git a/src/drivers/sdl/SConscript b/src/drivers/sdl/SConscript index f8b8c0fb..ebbad1b3 100644 --- a/src/drivers/sdl/SConscript +++ b/src/drivers/sdl/SConscript @@ -10,6 +10,7 @@ source_list = Split( input.cpp cheat.cpp config.cpp + memview.cpp ramwatch.cpp sdl.cpp sdl-joystick.cpp diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 51dc0a2a..eb49537c 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -16,6 +16,7 @@ #include "config.h" #include "cheat.h" #include "icon.xpm" +#include "memview.h" #include "ramwatch.h" #ifdef _S9XLUA_H @@ -2869,6 +2870,17 @@ static GtkWidget *CreateMenubar (GtkWidget * window) gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + //-Tools --> Memory Viewer --------------------- + item = gtk_menu_item_new_with_label ("Memory Viewer"); + + g_signal_connect (item, "activate", G_CALLBACK (openMemoryViewWindow), + NULL); + + //gtk_widget_add_accelerator( item, "activate", accel_group, + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + //--------------------------------------- // Create Movie Menu item = gtk_menu_item_new_with_label ("Movie"); diff --git a/src/drivers/sdl/memview.cpp b/src/drivers/sdl/memview.cpp new file mode 100644 index 00000000..b7351cfd --- /dev/null +++ b/src/drivers/sdl/memview.cpp @@ -0,0 +1,354 @@ +#include +#include +#include +#include +#include + +#include +#include +#ifdef GDK_WINDOWING_X11 +#include +#endif + +#ifdef _GTK3 +#include +#endif + +#include "../../types.h" +#include "../../fceu.h" +#include "../../cheat.h" +#include "../../debug.h" +#include "../../driver.h" +#include "../../version.h" +#include "../../movie.h" +#include "../../palette.h" +#include "../../fds.h" +#include "../common/configSys.h" + +#include "sdl.h" +#include "gui.h" +#include "dface.h" +#include "input.h" +#include "config.h" +#include "memview.h" + +extern Config *g_config; + +//******************************************************************************************************* +// Memory View (Hex Editor) Window +//******************************************************************************************************* +// +// +struct memViewWin_t +{ + GtkWidget *win; + GtkWidget *tree; + GtkWidget *vbar; + GtkTreeStore *memview_store; + int editRowIdx; + int editColIdx; + int row_vis_start; + int row_vis_end; + GtkCellRenderer *hexByte_renderer[16]; + + memViewWin_t(void) + { + win = NULL; + tree = NULL; + vbar = NULL; + memview_store = NULL; + editRowIdx = -1; + editColIdx = -1; + row_vis_start = 0; + row_vis_end = 0; + + for (int i=0; i<16; i++) + { + hexByte_renderer[i] = NULL; + } + } + + void showMemViewResults (int reset); + +}; + +void memViewWin_t::showMemViewResults (int reset) +{ + int lineAddr = 0, line_addr_start, line_addr_end, i; + unsigned int c; + GtkTreeIter iter; + char addrStr[16], valStr[16][16], ascii[18]; + int *indexArray; + GtkTreePath *start_path = NULL, *end_path = NULL; + + if ( gtk_tree_view_get_visible_range ( GTK_TREE_VIEW(tree), &start_path, &end_path ) ) + { + indexArray = gtk_tree_path_get_indices (start_path); + + row_vis_start = indexArray[0]; + + indexArray = gtk_tree_path_get_indices (end_path); + + row_vis_end = indexArray[0]; + + if ( !gtk_tree_model_get_iter( GTK_TREE_MODEL (memview_store), &iter, start_path ) ) + { + return; + } + gtk_tree_path_free( start_path ); + gtk_tree_path_free( end_path ); + + //printf("Tree View Start: %i End: %i \n", row_vis_start, row_vis_end ); + } + + if (reset) + { + line_addr_start = 0; + line_addr_end = 0x10000; + + gtk_tree_store_clear (memview_store); + } + else + { + line_addr_start = row_vis_start * 16; + line_addr_end = row_vis_end * 16; + } + + for ( lineAddr=line_addr_start; lineAddr < line_addr_end; lineAddr += 16 ) + { + if (reset) + { + gtk_tree_store_append (memview_store, &iter, NULL); // aquire iter + } + + sprintf( addrStr, "$%06X", lineAddr ); + + for (i=0; i<16; i++) + { + c = GetMem(lineAddr+i); + + sprintf( valStr[i], "%02X", c ); + + if ( isprint(c) ) + { + ascii[i] = c; + } + else + { + ascii[i] = '.'; + } + } + ascii[16] = 0; + + gtk_tree_store_set( memview_store, &iter, 0, addrStr, + 1 , valStr[0] , 2, valStr[1] , 3, valStr[2] , 4, valStr[3], + 5 , valStr[4] , 6, valStr[5] , 7, valStr[6] , 8, valStr[7], + 9 , valStr[8] , 10, valStr[9] , 11, valStr[10], 12, valStr[11], + 13, valStr[12], 14, valStr[13], 15, valStr[14], 16, valStr[15], + 17, ascii, + -1 ); + + if (!reset) + { + if (!gtk_tree_model_iter_next + (GTK_TREE_MODEL (memview_store), &iter)) + { + gtk_tree_store_append (memview_store, &iter, NULL); // aquire iter + } + } + } +} + +static int memViewEvntSrcID = 0; +static std::list memViewWinList; + + +static GtkWidget *CreateMemViewMenubar (GtkWidget * window) +{ + GtkWidget *menubar, *menu, *item; + + menubar = gtk_menu_bar_new (); + + item = gtk_menu_item_new_with_label ("File"); + + gtk_menu_shell_append (GTK_MENU_SHELL (menubar), item); + + menu = gtk_menu_new (); + + gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), menu); + + item = gtk_menu_item_new_with_label ("Load Watch"); + + //g_signal_connect (item, "activate", G_CALLBACK (loadRamWatchCB), NULL); + + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + + item = gtk_menu_item_new_with_label ("Save Watch"); + + //g_signal_connect (item, "activate", G_CALLBACK (saveRamWatchCB), NULL); + + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + + // Finally, return the actual menu bar created + return menubar; +} + + +static void closeMemoryViewWindow (GtkWidget * w, GdkEvent * e, memViewWin_t * mv) +{ + std::list < memViewWin_t * >::iterator it; + + for (it = memViewWinList.begin (); it != memViewWinList.end (); it++) + { + if (mv == *it) + { + //printf("Removing MemView Window %p from List\n", cw); + memViewWinList.erase (it); + break; + } + } + + delete mv; + + gtk_widget_destroy (w); +} + +//static void memview_cell_edit_cb( int row, int col + +static void memview_cell_edited_start_cb1 (GtkCellRenderer * renderer, GtkCellEditable * editable, gchar * path, memViewWin_t * mv) +{ + //printf("MemView Edit Start: '%s':%li\n", path, (long)user_data); + mv->editRowIdx = atoi (path); + mv->editColIdx = 1; +} + +static void memview_cell_edited_cancel_cb (GtkCellRenderer * renderer, memViewWin_t * mv) +{ + //printf("MemView Edit Cancel:%li\n", (long)user_data); + mv->editRowIdx = -1; + mv->editColIdx = -1; +} + +static gint updateMemViewTree (void *userData) +{ + std::list ::iterator it; + + for (it=memViewWinList.begin(); it != memViewWinList.end(); it++) + { + (*it)->showMemViewResults(0); + } + return 1; +} + +void openMemoryViewWindow (void) +{ + GtkWidget *main_vbox; + GtkWidget *scroll; + GtkWidget *menubar; + GtkCellRenderer *renderer; + GtkTreeViewColumn *column; + memViewWin_t *mv; + //void (*memview_cell_edited_start_cbs)(GtkCellRenderer * renderer, GtkCellEditable * editable, gchar * path, memViewWin_t * mv)[16]; + + mv = new memViewWin_t; + + memViewWinList.push_back (mv); + + mv->win = gtk_dialog_new_with_buttons ("Memory View", + GTK_WINDOW (MainWindow), + (GtkDialogFlags) + (GTK_DIALOG_DESTROY_WITH_PARENT), + "_Close", GTK_RESPONSE_OK, + NULL); + + gtk_window_set_default_size (GTK_WINDOW (mv->win), 800, 600); + + main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); + + menubar = CreateMemViewMenubar (mv->win); + + gtk_box_pack_start (GTK_BOX (main_vbox), menubar, FALSE, TRUE, 0); + + mv->memview_store = + gtk_tree_store_new ( 18, + G_TYPE_STRING, // Address Field + G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, // Bytes 0 -> 3 + G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, // Bytes 4 -> 7 + G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, // Bytes 8 -> 11 + G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, // Bytes 12 -> 15 + G_TYPE_STRING ); // Ascii Byte Decoding + + mv->tree = + gtk_tree_view_new_with_model (GTK_TREE_MODEL + (mv->memview_store)); + + gtk_tree_view_set_grid_lines (GTK_TREE_VIEW (mv->tree), + GTK_TREE_VIEW_GRID_LINES_VERTICAL); + + renderer = gtk_cell_renderer_text_new (); + g_object_set (renderer, "family", "MonoSpace", NULL); + column = gtk_tree_view_column_new_with_attributes ("Addr", renderer, + "text", 0, NULL); + gtk_tree_view_append_column (GTK_TREE_VIEW (mv->tree), column); + + for (int i=0; i<16; i++) + { + char title[16]; + + sprintf( title, "%02X", i ); + + renderer = gtk_cell_renderer_text_new (); + g_object_set (renderer, "family", "MonoSpace", NULL); + g_object_set (renderer, "editable", TRUE, NULL); + //g_signal_connect (renderer, "edited", + // (GCallback) ramWatch_cell_edited_cb, (gpointer) mv); + g_signal_connect (renderer, "editing-started", + (GCallback) memview_cell_edited_start_cb1, + (gpointer) mv); + g_signal_connect (renderer, "editing-canceled", + (GCallback) memview_cell_edited_cancel_cb, + (gpointer) mv); + column = gtk_tree_view_column_new_with_attributes ( title, + renderer, "text", i+1, + NULL); + gtk_tree_view_append_column (GTK_TREE_VIEW (mv->tree), column); + + mv->hexByte_renderer[i] = renderer; + } + + renderer = gtk_cell_renderer_text_new (); + g_object_set (renderer, "family", "MonoSpace", NULL); + column = gtk_tree_view_column_new_with_attributes ("ASCII", renderer, + "text", 17, NULL); + gtk_tree_view_append_column (GTK_TREE_VIEW (mv->tree), column); + + scroll = gtk_scrolled_window_new (NULL, NULL); + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), + GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); + gtk_container_add (GTK_CONTAINER (scroll), mv->tree); + gtk_box_pack_start (GTK_BOX (main_vbox), scroll, TRUE, TRUE, 5); + + gtk_box_pack_start (GTK_BOX + (gtk_dialog_get_content_area + (GTK_DIALOG (mv->win))), main_vbox, TRUE, TRUE, + 0); + + mv->vbar = gtk_scrolled_window_get_vscrollbar( GTK_SCROLLED_WINDOW(scroll) ); + + if (memViewEvntSrcID == 0) + { + memViewEvntSrcID = + g_timeout_add (100, updateMemViewTree, NULL); + } + + g_signal_connect (mv->win, "delete-event", + G_CALLBACK (closeMemoryViewWindow), mv); + g_signal_connect (mv->win, "response", + G_CALLBACK (closeMemoryViewWindow), mv); + + gtk_widget_show_all (mv->win); + + mv->showMemViewResults(1); + + printf("VBAR: %p \n", mv->vbar ); +} diff --git a/src/drivers/sdl/memview.h b/src/drivers/sdl/memview.h new file mode 100644 index 00000000..aa149af3 --- /dev/null +++ b/src/drivers/sdl/memview.h @@ -0,0 +1,4 @@ +// memview.h +// + +void openMemoryViewWindow (void); From 3c10dcc1fd612e74a6a6f1905fde3e20e13ae01d Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 16 May 2020 23:50:58 -0400 Subject: [PATCH 078/156] Added logic to allow for writing into memory via the mem view hex editor. --- src/drivers/sdl/memview.cpp | 147 ++++++++++++++++++++++++++++-------- 1 file changed, 114 insertions(+), 33 deletions(-) diff --git a/src/drivers/sdl/memview.cpp b/src/drivers/sdl/memview.cpp index b7351cfd..71632be0 100644 --- a/src/drivers/sdl/memview.cpp +++ b/src/drivers/sdl/memview.cpp @@ -44,7 +44,11 @@ struct memViewWin_t GtkWidget *win; GtkWidget *tree; GtkWidget *vbar; + GtkWidget *selCellLabel; GtkTreeStore *memview_store; + int selAddr; + int selRowIdx; + int selColIdx; int editRowIdx; int editColIdx; int row_vis_start; @@ -56,9 +60,13 @@ struct memViewWin_t win = NULL; tree = NULL; vbar = NULL; + selCellLabel = NULL; memview_store = NULL; + selRowIdx = -1; + selColIdx = -1; editRowIdx = -1; editColIdx = -1; + selAddr = -1; row_vis_start = 0; row_vis_end = 0; @@ -74,31 +82,38 @@ struct memViewWin_t void memViewWin_t::showMemViewResults (int reset) { - int lineAddr = 0, line_addr_start, line_addr_end, i; + + int lineAddr = 0, line_addr_start, line_addr_end, i, row; unsigned int c; GtkTreeIter iter; char addrStr[16], valStr[16][16], ascii[18]; int *indexArray; GtkTreePath *start_path = NULL, *end_path = NULL; - if ( gtk_tree_view_get_visible_range ( GTK_TREE_VIEW(tree), &start_path, &end_path ) ) + if ( !reset ) { - indexArray = gtk_tree_path_get_indices (start_path); - - row_vis_start = indexArray[0]; - - indexArray = gtk_tree_path_get_indices (end_path); - - row_vis_end = indexArray[0]; - - if ( !gtk_tree_model_get_iter( GTK_TREE_MODEL (memview_store), &iter, start_path ) ) + if ( gtk_tree_view_get_visible_range ( GTK_TREE_VIEW(tree), &start_path, &end_path ) ) { - return; - } - gtk_tree_path_free( start_path ); - gtk_tree_path_free( end_path ); + int iterValid; + indexArray = gtk_tree_path_get_indices (start_path); - //printf("Tree View Start: %i End: %i \n", row_vis_start, row_vis_end ); + row_vis_start = indexArray[0]; + + indexArray = gtk_tree_path_get_indices (end_path); + + row_vis_end = indexArray[0]; + + iterValid = gtk_tree_model_get_iter( GTK_TREE_MODEL (memview_store), &iter, start_path ); + + gtk_tree_path_free( start_path ); + gtk_tree_path_free( end_path ); + + if ( !iterValid ) + { + return; + } + //printf("Tree View Start: %i End: %i \n", row_vis_start, row_vis_end ); + } } if (reset) @@ -114,6 +129,8 @@ void memViewWin_t::showMemViewResults (int reset) line_addr_end = row_vis_end * 16; } + row = row_vis_start; + for ( lineAddr=line_addr_start; lineAddr < line_addr_end; lineAddr += 16 ) { if (reset) @@ -121,7 +138,7 @@ void memViewWin_t::showMemViewResults (int reset) gtk_tree_store_append (memview_store, &iter, NULL); // aquire iter } - sprintf( addrStr, "$%06X", lineAddr ); + sprintf( addrStr, "%06X", lineAddr ); for (i=0; i<16; i++) { @@ -140,13 +157,16 @@ void memViewWin_t::showMemViewResults (int reset) } ascii[16] = 0; - gtk_tree_store_set( memview_store, &iter, 0, addrStr, - 1 , valStr[0] , 2, valStr[1] , 3, valStr[2] , 4, valStr[3], - 5 , valStr[4] , 6, valStr[5] , 7, valStr[6] , 8, valStr[7], - 9 , valStr[8] , 10, valStr[9] , 11, valStr[10], 12, valStr[11], - 13, valStr[12], 14, valStr[13], 15, valStr[14], 16, valStr[15], - 17, ascii, - -1 ); + if ( editRowIdx != row ) + { + gtk_tree_store_set( memview_store, &iter, 0, addrStr, + 1 , valStr[0] , 2, valStr[1] , 3, valStr[2] , 4, valStr[3], + 5 , valStr[4] , 6, valStr[5] , 7, valStr[6] , 8, valStr[7], + 9 , valStr[8] , 10, valStr[9] , 11, valStr[10], 12, valStr[11], + 13, valStr[12], 14, valStr[13], 15, valStr[14], 16, valStr[15], + 17, ascii, + -1 ); + } if (!reset) { @@ -156,6 +176,7 @@ void memViewWin_t::showMemViewResults (int reset) gtk_tree_store_append (memview_store, &iter, NULL); // aquire iter } } + row++; } } @@ -215,11 +236,58 @@ static void closeMemoryViewWindow (GtkWidget * w, GdkEvent * e, memViewWin_t * m //static void memview_cell_edit_cb( int row, int col -static void memview_cell_edited_start_cb1 (GtkCellRenderer * renderer, GtkCellEditable * editable, gchar * path, memViewWin_t * mv) +static void +treeRowActivated (GtkTreeView *tree_view, + GtkTreePath *path, + GtkTreeViewColumn *column, + memViewWin_t * mv ) +{ + char stmp[128]; + + mv->selRowIdx = strtol( gtk_tree_path_to_string(path), NULL, 0 ); + mv->selColIdx = strtol( gtk_tree_view_column_get_title(column), NULL, 16 ); + + mv->selAddr = (mv->selRowIdx*16) + mv->selColIdx; + + sprintf( stmp, "Selected Cell Address: 0x%04X", mv->selAddr ); + + gtk_label_set_markup ( GTK_LABEL(mv->selCellLabel), stmp ); + + //printf("Row:Col Active: %i:%i Addr: 0x%04X \n", mv->selRowIdx, mv->selColIdx, mv->selAddr ); +} + +static void memview_cell_edited_cb (GtkCellRendererText * cell, + gchar * path_string, + gchar * new_text, memViewWin_t * mv) +{ + int addr, rowIdx; + unsigned int value; + writefunc wfunc; + + //printf("PATH: %s \n", path_string ); + + rowIdx = atoi( path_string ); + + addr = (rowIdx*16) + mv->selColIdx; + + wfunc = GetWriteHandler (addr); + + if (wfunc) + { + value = strtoul (new_text, NULL, 16); + + wfunc ((uint32) addr, + (uint8) (value & 0x000000ff)); + } + + mv->editRowIdx = -1; + mv->editColIdx = -1; +} +static void memview_cell_edited_start_cb (GtkCellRenderer * renderer, GtkCellEditable * editable, gchar * path, memViewWin_t * mv) { //printf("MemView Edit Start: '%s':%li\n", path, (long)user_data); mv->editRowIdx = atoi (path); - mv->editColIdx = 1; + mv->editColIdx = mv->selColIdx; } static void memview_cell_edited_cancel_cb (GtkCellRenderer * renderer, memViewWin_t * mv) @@ -243,6 +311,7 @@ static gint updateMemViewTree (void *userData) void openMemoryViewWindow (void) { GtkWidget *main_vbox; + GtkWidget *hbox; GtkWidget *scroll; GtkWidget *menubar; GtkCellRenderer *renderer; @@ -263,7 +332,7 @@ void openMemoryViewWindow (void) gtk_window_set_default_size (GTK_WINDOW (mv->win), 800, 600); - main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); + main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3); menubar = CreateMemViewMenubar (mv->win); @@ -285,25 +354,31 @@ void openMemoryViewWindow (void) gtk_tree_view_set_grid_lines (GTK_TREE_VIEW (mv->tree), GTK_TREE_VIEW_GRID_LINES_VERTICAL); + g_object_set( mv->tree, "activate-on-single-click", TRUE, NULL ); + + g_signal_connect (mv->tree, "row-activated", + (GCallback) treeRowActivated, + (gpointer) mv); + renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "family", "MonoSpace", NULL); column = gtk_tree_view_column_new_with_attributes ("Addr", renderer, "text", 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (mv->tree), column); - for (int i=0; i<16; i++) + for (long int i=0; i<16; i++) { char title[16]; - sprintf( title, "%02X", i ); + sprintf( title, "%02lX", i ); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "family", "MonoSpace", NULL); g_object_set (renderer, "editable", TRUE, NULL); - //g_signal_connect (renderer, "edited", - // (GCallback) ramWatch_cell_edited_cb, (gpointer) mv); + g_signal_connect (renderer, "edited", + (GCallback) memview_cell_edited_cb, (gpointer) mv); g_signal_connect (renderer, "editing-started", - (GCallback) memview_cell_edited_start_cb1, + (GCallback) memview_cell_edited_start_cb, (gpointer) mv); g_signal_connect (renderer, "editing-canceled", (GCallback) memview_cell_edited_cancel_cb, @@ -328,6 +403,13 @@ void openMemoryViewWindow (void) gtk_container_add (GTK_CONTAINER (scroll), mv->tree); gtk_box_pack_start (GTK_BOX (main_vbox), scroll, TRUE, TRUE, 5); + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 1); + + mv->selCellLabel = gtk_label_new(""); + //g_object_set (mv->selCellLabel, "family", "MonoSpace", NULL); + gtk_box_pack_start (GTK_BOX (hbox), mv->selCellLabel, FALSE, FALSE, 5); + gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 5); + gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (mv->win))), main_vbox, TRUE, TRUE, @@ -350,5 +432,4 @@ void openMemoryViewWindow (void) mv->showMemViewResults(1); - printf("VBAR: %p \n", mv->vbar ); } From 90482feac8436df14a8ba175e7420b63dd0c6f60 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sun, 17 May 2020 11:36:55 -0400 Subject: [PATCH 079/156] Memview successful initial test, but performance is slightly lacking. Going to change tree view logic. --- src/drivers/sdl/memview.cpp | 298 ++++++++++++++++++++++++++++++------ 1 file changed, 253 insertions(+), 45 deletions(-) diff --git a/src/drivers/sdl/memview.cpp b/src/drivers/sdl/memview.cpp index 71632be0..4213bfc6 100644 --- a/src/drivers/sdl/memview.cpp +++ b/src/drivers/sdl/memview.cpp @@ -23,6 +23,8 @@ #include "../../movie.h" #include "../../palette.h" #include "../../fds.h" +#include "../../cart.h" +#include "../../ines.h" #include "../common/configSys.h" #include "sdl.h" @@ -38,6 +40,45 @@ extern Config *g_config; // Memory View (Hex Editor) Window //******************************************************************************************************* // +static int getRAM( unsigned int i ) +{ + return GetMem(i); +} +static int getPPU( unsigned int i ) +{ + i &= 0x3FFF; + if (i < 0x2000)return VPage[(i) >> 10][(i)]; + //NSF PPU Viewer crash here (UGETAB) (Also disabled by 'MaxSize = 0x2000') + if (GameInfo->type == GIT_NSF) + return 0; + else + { + if (i < 0x3F00) + return vnapage[(i >> 10) & 0x3][i & 0x3FF]; + return READPAL_MOTHEROFALL(i & 0x1F); + } + return 0; +} +static int getOAM( unsigned int i ) +{ + return SPRAM[i & 0xFF]; +} +static int getROM( unsigned int offset) +{ + if (offset < 16) + { + return *((unsigned char *)&head+offset); + } + else if (offset < (16+PRGsize[0]) ) + { + return PRGptr[0][offset-16]; + } + else if (offset < (16+PRGsize[0]+CHRsize[0]) ) + { + return CHRptr[0][offset-16-PRGsize[0]]; + } + return -1; +} // struct memViewWin_t { @@ -53,8 +94,19 @@ struct memViewWin_t int editColIdx; int row_vis_start; int row_vis_end; + int mode; + int evntSrcID; + unsigned char *mbuf; + int mbuf_size; GtkCellRenderer *hexByte_renderer[16]; + enum { + MODE_NES_RAM = 0, + MODE_NES_PPU, + MODE_NES_OAM, + MODE_NES_ROM + }; + memViewWin_t(void) { win = NULL; @@ -69,6 +121,9 @@ struct memViewWin_t selAddr = -1; row_vis_start = 0; row_vis_end = 0; + mode = MODE_NES_RAM; + mbuf = NULL; + evntSrcID = 0; for (int i=0; i<16; i++) { @@ -76,19 +131,126 @@ struct memViewWin_t } } + ~memViewWin_t(void) + { + if ( mbuf != NULL ) + { + free(mbuf); mbuf = NULL; + } + } + + void setMode(int new_mode) + { + if ( mode != new_mode ) + { + showMemViewResults(1); + } + mode = new_mode; + } + void showMemViewResults (int reset); }; +static int conv2xchar( int i ) +{ + int c = 0; + + if ( (i >= 0) && (i < 10) ) + { + c = i + '0'; + } + else if ( i < 16 ) + { + c = (i - 10) + 'A'; + } + return c; +} + +static void initMem( unsigned char *c, int size ) +{ + for (int i=0; itype == GIT_NSF ? 0x2000 : 0x4000); + break; + case MODE_NES_OAM: + memAccessFunc = getOAM; + memSize = 0x100; + break; + case MODE_NES_ROM: + memAccessFunc = getROM; + memSize = 16 + CHRsize[0] + PRGsize[0]; + break; + } + + if ( (mbuf == NULL) || (mbuf_size != memSize) ) + { + printf("Mode: %i MemSize:%i 0x%08x\n", mode, memSize, (unsigned int)memSize ); + reset = 1; + + if ( mbuf ) + { + free(mbuf); mbuf = NULL; + } + mbuf = (unsigned char *)malloc( memSize ); + + if ( mbuf ) + { + mbuf_size = memSize; + initMem( mbuf, memSize ); + } + else + { + printf("Error: Failed to allocate memview buffer size\n"); + mbuf_size = 0; + return; + } + } + + if (reset) + { + line_addr_start = 0; + line_addr_end = memSize; + + gtk_tree_store_clear (memview_store); + + for ( lineAddr=line_addr_start; lineAddr < (line_addr_end+1); lineAddr += 16 ) + { + gtk_tree_store_append (memview_store, &iter, NULL); // aquire iter + } + gtk_tree_model_get_iter_first( GTK_TREE_MODEL (memview_store), &iter ); + + line_addr_start = 0; + line_addr_end = memSize; + + row_vis_start = 0; + row_vis_end = 60; + } if ( !reset ) { @@ -97,11 +259,17 @@ void memViewWin_t::showMemViewResults (int reset) int iterValid; indexArray = gtk_tree_path_get_indices (start_path); - row_vis_start = indexArray[0]; + if ( indexArray != NULL ) + { + row_vis_start = indexArray[0]; + } indexArray = gtk_tree_path_get_indices (end_path); - row_vis_end = indexArray[0]; + if ( indexArray != NULL ) + { + row_vis_end = indexArray[0]; + } iterValid = gtk_tree_model_get_iter( GTK_TREE_MODEL (memview_store), &iter, start_path ); @@ -110,41 +278,35 @@ void memViewWin_t::showMemViewResults (int reset) if ( !iterValid ) { + printf("Error: Failed to get start iterator.\n"); return; } //printf("Tree View Start: %i End: %i \n", row_vis_start, row_vis_end ); } } - - if (reset) - { - line_addr_start = 0; - line_addr_end = 0x10000; - - gtk_tree_store_clear (memview_store); - } - else - { - line_addr_start = row_vis_start * 16; - line_addr_end = row_vis_end * 16; - } + line_addr_start = row_vis_start * 16; + line_addr_end = row_vis_end * 16; row = row_vis_start; for ( lineAddr=line_addr_start; lineAddr < line_addr_end; lineAddr += 16 ) { - if (reset) - { - gtk_tree_store_append (memview_store, &iter, NULL); // aquire iter - } + row_changed = reset; - sprintf( addrStr, "%06X", lineAddr ); + sprintf( addrStr, "%08X", lineAddr ); for (i=0; i<16; i++) { - c = GetMem(lineAddr+i); + addr = lineAddr+i; - sprintf( valStr[i], "%02X", c ); + c = memAccessFunc(addr); + + un = ( c & 0x00f0 ) >> 4; + ln = ( c & 0x000f ); + + valStr[i][0] = conv2xchar(un); + valStr[i][1] = conv2xchar(ln); + valStr[i][2] = 0; if ( isprint(c) ) { @@ -154,10 +316,15 @@ void memViewWin_t::showMemViewResults (int reset) { ascii[i] = '.'; } + if ( c != mbuf[addr] ) + { + row_changed = 1; + mbuf[addr] = c; + } } ascii[16] = 0; - if ( editRowIdx != row ) + if ( row_changed && (editRowIdx != row) ) { gtk_tree_store_set( memview_store, &iter, 0, addrStr, 1 , valStr[0] , 2, valStr[1] , 3, valStr[2] , 4, valStr[3], @@ -168,13 +335,10 @@ void memViewWin_t::showMemViewResults (int reset) -1 ); } - if (!reset) + if (!gtk_tree_model_iter_next + (GTK_TREE_MODEL (memview_store), &iter)) { - if (!gtk_tree_model_iter_next - (GTK_TREE_MODEL (memview_store), &iter)) - { - gtk_tree_store_append (memview_store, &iter, NULL); // aquire iter - } + return; } row++; } @@ -183,14 +347,35 @@ void memViewWin_t::showMemViewResults (int reset) static int memViewEvntSrcID = 0; static std::list memViewWinList; +static void changeModeRAM (GtkRadioMenuItem * radiomenuitem, memViewWin_t *mv) +{ + printf("Changing Mode RAM \n"); + mv->setMode( memViewWin_t::MODE_NES_RAM ); +} +static void changeModePPU (GtkRadioMenuItem * radiomenuitem, memViewWin_t *mv) +{ + printf("Changing Mode PPU \n"); + mv->setMode( memViewWin_t::MODE_NES_PPU ); +} +static void changeModeOAM (GtkRadioMenuItem * radiomenuitem, memViewWin_t *mv) +{ + printf("Changing Mode OAM \n"); + mv->setMode( memViewWin_t::MODE_NES_OAM ); +} +static void changeModeROM (GtkRadioMenuItem * radiomenuitem, memViewWin_t *mv) +{ + printf("Changing Mode ROM \n"); + mv->setMode( memViewWin_t::MODE_NES_ROM ); +} -static GtkWidget *CreateMemViewMenubar (GtkWidget * window) +static GtkWidget *CreateMemViewMenubar (memViewWin_t * mv) { GtkWidget *menubar, *menu, *item; + GSList *radioGroup; menubar = gtk_menu_bar_new (); - item = gtk_menu_item_new_with_label ("File"); + item = gtk_menu_item_new_with_label ("View"); gtk_menu_shell_append (GTK_MENU_SHELL (menubar), item); @@ -198,18 +383,43 @@ static GtkWidget *CreateMemViewMenubar (GtkWidget * window) gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), menu); - item = gtk_menu_item_new_with_label ("Load Watch"); + //-View --> RAM ------------------ + radioGroup = NULL; - //g_signal_connect (item, "activate", G_CALLBACK (loadRamWatchCB), NULL); + item = gtk_radio_menu_item_new_with_label (radioGroup, "RAM"); + + radioGroup = + gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM(item)); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); - item = gtk_menu_item_new_with_label ("Save Watch"); + g_signal_connect (item, "activate", G_CALLBACK (changeModeRAM), + (gpointer) mv); - //g_signal_connect (item, "activate", G_CALLBACK (saveRamWatchCB), NULL); + //-View --> PPU ------------------ + item = gtk_radio_menu_item_new_with_label (radioGroup, "PPU"); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + g_signal_connect (item, "activate", G_CALLBACK (changeModePPU), + (gpointer) mv); + + //-View --> OAM ------------------ + item = gtk_radio_menu_item_new_with_label (radioGroup, "OAM"); + + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + + g_signal_connect (item, "activate", G_CALLBACK (changeModeOAM), + (gpointer) mv); + + //-View --> ROM ------------------ + item = gtk_radio_menu_item_new_with_label (radioGroup, "ROM"); + + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + + g_signal_connect (item, "activate", G_CALLBACK (changeModeROM), + (gpointer) mv); + // Finally, return the actual menu bar created return menubar; } @@ -234,8 +444,6 @@ static void closeMemoryViewWindow (GtkWidget * w, GdkEvent * e, memViewWin_t * m gtk_widget_destroy (w); } -//static void memview_cell_edit_cb( int row, int col - static void treeRowActivated (GtkTreeView *tree_view, GtkTreePath *path, @@ -334,7 +542,7 @@ void openMemoryViewWindow (void) main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3); - menubar = CreateMemViewMenubar (mv->win); + menubar = CreateMemViewMenubar(mv); gtk_box_pack_start (GTK_BOX (main_vbox), menubar, FALSE, TRUE, 0); @@ -417,12 +625,6 @@ void openMemoryViewWindow (void) mv->vbar = gtk_scrolled_window_get_vscrollbar( GTK_SCROLLED_WINDOW(scroll) ); - if (memViewEvntSrcID == 0) - { - memViewEvntSrcID = - g_timeout_add (100, updateMemViewTree, NULL); - } - g_signal_connect (mv->win, "delete-event", G_CALLBACK (closeMemoryViewWindow), mv); g_signal_connect (mv->win, "response", @@ -432,4 +634,10 @@ void openMemoryViewWindow (void) mv->showMemViewResults(1); + if (memViewEvntSrcID == 0) + { + memViewEvntSrcID = + g_timeout_add (100, updateMemViewTree, mv); + } + } From 6460a3035ba5fabac1791c30b129d4fbafb33b34 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Mon, 18 May 2020 08:29:05 -0400 Subject: [PATCH 080/156] Tree view inner / outer slider functions but is not ideal. Going to try out text view object instead. --- src/drivers/sdl/memview.cpp | 240 +++++++++++++++++++++++++++++++++--- 1 file changed, 224 insertions(+), 16 deletions(-) diff --git a/src/drivers/sdl/memview.cpp b/src/drivers/sdl/memview.cpp index 4213bfc6..7322c92c 100644 --- a/src/drivers/sdl/memview.cpp +++ b/src/drivers/sdl/memview.cpp @@ -85,8 +85,12 @@ struct memViewWin_t GtkWidget *win; GtkWidget *tree; GtkWidget *vbar; + GtkWidget *ivbar; GtkWidget *selCellLabel; GtkTreeStore *memview_store; + GtkAdjustment *vadj; + int baseAddr; + int maxAddr; int selAddr; int selRowIdx; int selColIdx; @@ -94,11 +98,14 @@ struct memViewWin_t int editColIdx; int row_vis_start; int row_vis_end; + int row_vis_center; int mode; int evntSrcID; + int treeViewLines; unsigned char *mbuf; int mbuf_size; GtkCellRenderer *hexByte_renderer[16]; + bool redraw; enum { MODE_NES_RAM = 0, @@ -112,6 +119,7 @@ struct memViewWin_t win = NULL; tree = NULL; vbar = NULL; + vadj = NULL; selCellLabel = NULL; memview_store = NULL; selRowIdx = -1; @@ -119,11 +127,15 @@ struct memViewWin_t editRowIdx = -1; editColIdx = -1; selAddr = -1; + baseAddr = 0; row_vis_start = 0; - row_vis_end = 0; + row_vis_end = 64; + row_vis_center= 32; mode = MODE_NES_RAM; mbuf = NULL; evntSrcID = 0; + treeViewLines = 64; + redraw = 1; for (int i=0; i<16; i++) { @@ -148,7 +160,69 @@ struct memViewWin_t mode = new_mode; } + void setBaseAddr( double value ) + { + int addr, r, max; + addr = (int)( value + 0.50 ); + + printf("Set BaseAddr Req: %i 0x%08x\n", addr, addr ); + + r = addr % 16; + + addr = addr - r; + + max = mbuf_size - (treeViewLines * 16); + + if ( addr >= max ) + { + addr = max; + } + baseAddr = addr; + redraw = 1; + } + + void incrBaseAddr( int value ) + { + int addr, r, max; + + addr = baseAddr + value; + + printf("Set BaseAddr Req: %i 0x%08x\n", addr, addr ); + + r = addr % 16; + + addr = addr - r; + + max = mbuf_size - (treeViewLines * 16); + + if ( addr >= max ) + { + addr = max; + } + baseAddr = addr; + redraw = 1; + } + + int set_inner_slider( double value ) + { + GtkAdjustment *ivadj; + double l, u; + + ivadj = gtk_range_get_adjustment( GTK_RANGE(ivbar) ); + + l = gtk_adjustment_get_lower( ivadj ); + u = gtk_adjustment_get_upper( ivadj ); + + printf("Inner VBAR Limits: %f %f \n" , + l, u ); + + gtk_range_set_value( GTK_RANGE(ivbar), l + value*(u-l) ); + + return 0; + } + void showMemViewResults (int reset); + int calcVisibleRange( int *start_out, int *end_out, int *center_out ); }; @@ -178,7 +252,7 @@ static void initMem( unsigned char *c, int size ) void memViewWin_t::showMemViewResults (int reset) { - int lineAddr = 0, line_addr_start, line_addr_end, i, row; + int lineAddr = 0, line_addr_start, line_addr_end, i, row=0; int addr, memSize = 0, un, ln; unsigned int c; GtkTreeIter iter; @@ -230,6 +304,14 @@ void memViewWin_t::showMemViewResults (int reset) mbuf_size = 0; return; } + + gtk_adjustment_configure ( vadj, + 0.0, // value, + 0.0, // lower, + mbuf_size, // upper, + 16.0, // step_increment, + 32.0, // page_increment, + 32.0 ); // page_size); } if (reset) @@ -239,17 +321,18 @@ void memViewWin_t::showMemViewResults (int reset) gtk_tree_store_clear (memview_store); - for ( lineAddr=line_addr_start; lineAddr < (line_addr_end+1); lineAddr += 16 ) + for ( i=0; i < treeViewLines; i++) { gtk_tree_store_append (memview_store, &iter, NULL); // aquire iter } gtk_tree_model_get_iter_first( GTK_TREE_MODEL (memview_store), &iter ); line_addr_start = 0; - line_addr_end = memSize; + line_addr_end = treeViewLines * 16; row_vis_start = 0; - row_vis_end = 60; + row_vis_end = treeViewLines; + row_vis_center = treeViewLines/2; } if ( !reset ) @@ -268,7 +351,7 @@ void memViewWin_t::showMemViewResults (int reset) if ( indexArray != NULL ) { - row_vis_end = indexArray[0]; + row_vis_end = indexArray[0] + 1; } iterValid = gtk_tree_model_get_iter( GTK_TREE_MODEL (memview_store), &iter, start_path ); @@ -281,17 +364,22 @@ void memViewWin_t::showMemViewResults (int reset) printf("Error: Failed to get start iterator.\n"); return; } - //printf("Tree View Start: %i End: %i \n", row_vis_start, row_vis_end ); + row_vis_center = row_vis_start + (row_vis_end - row_vis_start + 1) / 2; + //printf("Tree View Start: %i End: %i Center: %i \n", row_vis_start, row_vis_end, row_vis_center ); + + //if ( row_vis_center > 48 ) + //{ + // set_inner_slider( 0.50 ); + //} } } line_addr_start = row_vis_start * 16; line_addr_end = row_vis_end * 16; - row = row_vis_start; - - for ( lineAddr=line_addr_start; lineAddr < line_addr_end; lineAddr += 16 ) + for ( row=row_vis_start; rowselRowIdx = strtol( gtk_tree_path_to_string(path), NULL, 0 ); mv->selColIdx = strtol( gtk_tree_view_column_get_title(column), NULL, 16 ); - mv->selAddr = (mv->selRowIdx*16) + mv->selColIdx; + mv->selAddr = mv->baseAddr + (mv->selRowIdx*16) + mv->selColIdx; sprintf( stmp, "Selected Cell Address: 0x%04X", mv->selAddr ); @@ -464,6 +608,45 @@ treeRowActivated (GtkTreeView *tree_view, //printf("Row:Col Active: %i:%i Addr: 0x%04X \n", mv->selRowIdx, mv->selColIdx, mv->selAddr ); } +static gboolean +vscroll_changed (GtkRange *range, + GtkScrollType scroll, + gdouble value, + memViewWin_t * mv) +{ + mv->setBaseAddr( value ); + + return FALSE; +} + +static void +inner_vbar_changed (GtkRange *range, + memViewWin_t * mv) +{ + GtkAdjustment *ivadj; + double v, l, u, r; + + ivadj = gtk_range_get_adjustment( range ); + + + v = gtk_range_get_value( range ); + l = gtk_adjustment_get_lower( ivadj ); + u = gtk_adjustment_get_upper( ivadj ); + + r = (v - l) / (u - l); + + printf("Inner VBAR: %f %f %f %f \n" , + v, l, u, r ); +} + +static void +outer_vbar_changed (GtkRange *range, + memViewWin_t * mv) +{ + //printf("Outer VBAR: %f \n", gtk_range_get_value( range ) ); + mv->setBaseAddr( gtk_range_get_value( range ) ); +} + static void memview_cell_edited_cb (GtkCellRendererText * cell, gchar * path_string, gchar * new_text, memViewWin_t * mv) @@ -476,7 +659,7 @@ static void memview_cell_edited_cb (GtkCellRendererText * cell, rowIdx = atoi( path_string ); - addr = (rowIdx*16) + mv->selColIdx; + addr = mv->baseAddr + (rowIdx*16) + mv->selColIdx; wfunc = GetWriteHandler (addr); @@ -520,6 +703,7 @@ void openMemoryViewWindow (void) { GtkWidget *main_vbox; GtkWidget *hbox; + GtkWidget *vbox; GtkWidget *scroll; GtkWidget *menubar; GtkCellRenderer *renderer; @@ -609,7 +793,28 @@ void openMemoryViewWindow (void) gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (scroll), mv->tree); - gtk_box_pack_start (GTK_BOX (main_vbox), scroll, TRUE, TRUE, 5); + + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); + vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1); + gtk_box_pack_start (GTK_BOX (vbox), scroll, TRUE, TRUE, 2); + gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 2); + + mv->vadj = gtk_adjustment_new( 0, 0, 100, 1, 20, 20 ); + + mv->vbar = gtk_scrollbar_new( GTK_ORIENTATION_VERTICAL, mv->vadj ); + + g_signal_connect (mv->vbar, "change-value", + G_CALLBACK (vscroll_changed), mv); + g_signal_connect (mv->vbar, "value-changed", + G_CALLBACK (outer_vbar_changed), mv); + + vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1); + + gtk_box_pack_start (GTK_BOX (vbox), mv->vbar, TRUE, TRUE, 2); + + gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 2); + + gtk_box_pack_start (GTK_BOX (main_vbox), hbox, TRUE, TRUE, 5); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 1); @@ -623,7 +828,10 @@ void openMemoryViewWindow (void) (GTK_DIALOG (mv->win))), main_vbox, TRUE, TRUE, 0); - mv->vbar = gtk_scrolled_window_get_vscrollbar( GTK_SCROLLED_WINDOW(scroll) ); + mv->ivbar = gtk_scrolled_window_get_vscrollbar( GTK_SCROLLED_WINDOW(scroll) ); + + g_signal_connect (mv->ivbar, "value-changed", + G_CALLBACK (inner_vbar_changed), mv); g_signal_connect (mv->win, "delete-event", G_CALLBACK (closeMemoryViewWindow), mv); From 267966b0b340cf6320733881c2d83f13feb71218 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Mon, 18 May 2020 22:03:58 -0400 Subject: [PATCH 081/156] Text View hex editor in work. --- src/drivers/sdl/memview.cpp | 514 ++++++++++++++++++++++++++---------- 1 file changed, 373 insertions(+), 141 deletions(-) diff --git a/src/drivers/sdl/memview.cpp b/src/drivers/sdl/memview.cpp index 7322c92c..bff055e5 100644 --- a/src/drivers/sdl/memview.cpp +++ b/src/drivers/sdl/memview.cpp @@ -87,6 +87,8 @@ struct memViewWin_t GtkWidget *vbar; GtkWidget *ivbar; GtkWidget *selCellLabel; + GtkTextView *textview; + GtkTextBuffer *textbuf; GtkTreeStore *memview_store; GtkAdjustment *vadj; int baseAddr; @@ -102,6 +104,8 @@ struct memViewWin_t int mode; int evntSrcID; int treeViewLines; + int numLines; + int numCharsPerLine; unsigned char *mbuf; int mbuf_size; GtkCellRenderer *hexByte_renderer[16]; @@ -120,6 +124,8 @@ struct memViewWin_t tree = NULL; vbar = NULL; vadj = NULL; + textview = NULL; + textbuf = NULL; selCellLabel = NULL; memview_store = NULL; selRowIdx = -1; @@ -133,8 +139,10 @@ struct memViewWin_t row_vis_center= 32; mode = MODE_NES_RAM; mbuf = NULL; + numLines = 0; evntSrcID = 0; treeViewLines = 64; + numCharsPerLine = 64; redraw = 1; for (int i=0; i<16; i++) @@ -222,6 +230,7 @@ struct memViewWin_t } void showMemViewResults (int reset); + //int calcVisibleRange( int *start_out, int *end_out, int *center_out ); int calcVisibleRange( int *start_out, int *end_out, int *center_out ); }; @@ -251,14 +260,15 @@ static void initMem( unsigned char *c, int size ) void memViewWin_t::showMemViewResults (int reset) { - - int lineAddr = 0, line_addr_start, line_addr_end, i, row=0; - int addr, memSize = 0, un, ln; - unsigned int c; - GtkTreeIter iter; - char addrStr[16], valStr[16][8], ascii[18], row_changed; - int *indexArray; - GtkTreePath *start_path = NULL, *end_path = NULL; + int addr, memSize = 0; + int lineAddr = 0, c, un, ln; + int i, row, row_start, row_end, totalChars; + char addrStr[16], valStr[16][8], ascii[18]; + char row_changed; + std::string txt; + std::string line; + GtkTextIter iter, start_iter, end_iter; + GdkRectangle visible_rect; int (*memAccessFunc)( unsigned int offset) = NULL; switch ( mode ) @@ -281,6 +291,7 @@ void memViewWin_t::showMemViewResults (int reset) memSize = 16 + CHRsize[0] + PRGsize[0]; break; } + numLines = memSize / 16; if ( (mbuf == NULL) || (mbuf_size != memSize) ) { @@ -304,84 +315,41 @@ void memViewWin_t::showMemViewResults (int reset) mbuf_size = 0; return; } + } + gtk_text_view_get_visible_rect ( textview, &visible_rect ); - gtk_adjustment_configure ( vadj, - 0.0, // value, - 0.0, // lower, - mbuf_size, // upper, - 16.0, // step_increment, - 32.0, // page_increment, - 32.0 ); // page_size); + //printf("Vis: x:%i y:%i w:%i h:%i \n", visible_rect.x, visible_rect.y, visible_rect.width, visible_rect.height ); + + gtk_text_buffer_get_start_iter( textbuf, &start_iter ); + gtk_text_buffer_get_end_iter( textbuf, &end_iter ); + + if ( reset ) + { + gtk_text_buffer_delete( textbuf, &start_iter, &end_iter ); + + row_start = 0; + row_end = numLines; + } + else + { + calcVisibleRange( &row_start, &row_end, NULL ); } - if (reset) + gtk_text_buffer_get_iter_at_offset( textbuf, &iter, 0 ); + + totalChars = row_start * numCharsPerLine; + + for (row=row_start; row 48 ) - //{ - // set_inner_slider( 0.50 ); - //} - } - } - line_addr_start = row_vis_start * 16; - line_addr_end = row_vis_end * 16; - - for ( row=row_vis_start; rowtype == GIT_NSF ? 0x2000 : 0x4000); +// break; +// case MODE_NES_OAM: +// memAccessFunc = getOAM; +// memSize = 0x100; +// break; +// case MODE_NES_ROM: +// memAccessFunc = getROM; +// memSize = 16 + CHRsize[0] + PRGsize[0]; +// break; +// } +// +// if ( (mbuf == NULL) || (mbuf_size != memSize) ) +// { +// printf("Mode: %i MemSize:%i 0x%08x\n", mode, memSize, (unsigned int)memSize ); +// reset = 1; +// +// if ( mbuf ) +// { +// free(mbuf); mbuf = NULL; +// } +// mbuf = (unsigned char *)malloc( memSize ); +// +// if ( mbuf ) +// { +// mbuf_size = memSize; +// initMem( mbuf, memSize ); +// } +// else +// { +// printf("Error: Failed to allocate memview buffer size\n"); +// mbuf_size = 0; +// return; +// } +// +// gtk_adjustment_configure ( vadj, +// 0.0, // value, +// 0.0, // lower, +// mbuf_size, // upper, +// 16.0, // step_increment, +// 32.0, // page_increment, +// 32.0 ); // page_size); +// } +// +// if (reset) +// { +// line_addr_start = 0; +// line_addr_end = memSize; +// +// gtk_tree_store_clear (memview_store); +// +// for ( i=0; i < treeViewLines; i++) +// { +// gtk_tree_store_append (memview_store, &iter, NULL); // aquire iter +// } +// gtk_tree_model_get_iter_first( GTK_TREE_MODEL (memview_store), &iter ); +// +// line_addr_start = 0; +// line_addr_end = treeViewLines * 16; +// +// row_vis_start = 0; +// row_vis_end = treeViewLines; +// row_vis_center = treeViewLines/2; +// } +// +// if ( !reset ) +// { +// if ( gtk_tree_view_get_visible_range ( GTK_TREE_VIEW(tree), &start_path, &end_path ) ) +// { +// int iterValid; +// indexArray = gtk_tree_path_get_indices (start_path); +// +// if ( indexArray != NULL ) +// { +// row_vis_start = indexArray[0]; +// } +// +// indexArray = gtk_tree_path_get_indices (end_path); +// +// if ( indexArray != NULL ) +// { +// row_vis_end = indexArray[0] + 1; +// } +// +// iterValid = gtk_tree_model_get_iter( GTK_TREE_MODEL (memview_store), &iter, start_path ); +// +// gtk_tree_path_free( start_path ); +// gtk_tree_path_free( end_path ); +// +// if ( !iterValid ) +// { +// printf("Error: Failed to get start iterator.\n"); +// return; +// } +// row_vis_center = row_vis_start + (row_vis_end - row_vis_start + 1) / 2; +// //printf("Tree View Start: %i End: %i Center: %i \n", row_vis_start, row_vis_end, row_vis_center ); +// +// //if ( row_vis_center > 48 ) +// //{ +// // set_inner_slider( 0.50 ); +// //} +// } +// } +// line_addr_start = row_vis_start * 16; +// line_addr_end = row_vis_end * 16; +// +// for ( row=row_vis_start; row> 4; +// ln = ( c & 0x000f ); +// +// valStr[i][0] = conv2xchar(un); +// valStr[i][1] = conv2xchar(ln); +// valStr[i][2] = 0; +// +// if ( isprint(c) ) +// { +// ascii[i] = c; +// } +// else +// { +// ascii[i] = '.'; +// } +// if ( c != mbuf[addr] ) +// { +// row_changed = 1; +// mbuf[addr] = c; +// } +// } +// ascii[16] = 0; +// +// if ( row_changed && (editRowIdx != row) ) +// { +// gtk_tree_store_set( memview_store, &iter, 0, addrStr, +// 1 , valStr[0] , 2, valStr[1] , 3, valStr[2] , 4, valStr[3], +// 5 , valStr[4] , 6, valStr[5] , 7, valStr[6] , 8, valStr[7], +// 9 , valStr[8] , 10, valStr[9] , 11, valStr[10], 12, valStr[11], +// 13, valStr[12], 14, valStr[13], 15, valStr[14], 16, valStr[15], +// 17, ascii, +// -1 ); +// } +// +// if (!gtk_tree_model_iter_next +// (GTK_TREE_MODEL (memview_store), &iter)) +// { +// return; +// } +// } +// redraw = 0; +//} + +//int memViewWin_t::calcVisibleRange( int *start_out, int *end_out, int *center_out ) +//{ +// int retval = 0; +// int *indexArray; +// int start=0, end=64, center=32; +// GtkTreePath *start_path = NULL, *end_path = NULL; +// +// if ( gtk_tree_view_get_visible_range ( GTK_TREE_VIEW(tree), &start_path, &end_path ) ) +// { +// indexArray = gtk_tree_path_get_indices (start_path); +// +// if ( indexArray != NULL ) +// { +// start = indexArray[0]; +// } +// else +// { +// retval = -1; +// } +// +// indexArray = gtk_tree_path_get_indices (end_path); +// +// if ( indexArray != NULL ) +// { +// end = indexArray[0] + 1; +// } +// else +// { +// retval = -1; +// } +// +// gtk_tree_path_free( start_path ); +// gtk_tree_path_free( end_path ); +// +// center = start + (end - start + 1) / 2; +// +// if ( start_out != NULL ) +// { +// *start_out = start; +// } +// if ( end_out != NULL ) +// { +// *end_out = end; +// } +// if ( center_out != NULL ) +// { +// *center_out = center; +// } +// } +// else +// { +// retval = -1; +// } +// return retval; +//} + int memViewWin_t::calcVisibleRange( int *start_out, int *end_out, int *center_out ) { - int retval = 0; - int *indexArray; - int start=0, end=64, center=32; - GtkTreePath *start_path = NULL, *end_path = NULL; + GtkAdjustment *ivadj; + double v, l, u, r; + int start, end, center; - if ( gtk_tree_view_get_visible_range ( GTK_TREE_VIEW(tree), &start_path, &end_path ) ) + ivadj = gtk_range_get_adjustment( GTK_RANGE(ivbar) ); + + + v = gtk_range_get_value( GTK_RANGE(ivbar) ); + l = gtk_adjustment_get_lower( ivadj ); + u = gtk_adjustment_get_upper( ivadj ); + + r = (v - l) / (u - l); + + start = ((int)( r * (double)numLines )) - 16; + + if ( start < 0 ) { - indexArray = gtk_tree_path_get_indices (start_path); - - if ( indexArray != NULL ) - { - start = indexArray[0]; - } - else - { - retval = -1; - } - - indexArray = gtk_tree_path_get_indices (end_path); - - if ( indexArray != NULL ) - { - end = indexArray[0] + 1; - } - else - { - retval = -1; - } - - gtk_tree_path_free( start_path ); - gtk_tree_path_free( end_path ); - - center = start + (end - start + 1) / 2; - - if ( start_out != NULL ) - { - *start_out = start; - } - if ( end_out != NULL ) - { - *end_out = end; - } - if ( center_out != NULL ) - { - *center_out = center; - } + start = 0; } - else + end = start + 64; + + if ( end > numLines ) { - retval = -1; + end = numLines; } - return retval; + + center = start + (end - start)/2; + + printf(" Start:%i End:%i 0x%08x -> 0x%08x \n", start, end, start * 16, end * 16 ); + + if ( start_out ) *start_out = start; + if ( end_out ) *end_out = end; + if ( center_out ) *center_out = center; + + return 0; } static int memViewEvntSrcID = 0; @@ -789,10 +1012,19 @@ void openMemoryViewWindow (void) "text", 17, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (mv->tree), column); + mv->textview = (GtkTextView*) gtk_text_view_new(); + + gtk_text_view_set_monospace( mv->textview, TRUE ); + gtk_text_view_set_overwrite( mv->textview, TRUE ); + gtk_text_view_set_wrap_mode( mv->textview, GTK_WRAP_NONE ); + + mv->textbuf = gtk_text_view_get_buffer( mv->textview ); + scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); - gtk_container_add (GTK_CONTAINER (scroll), mv->tree); + //gtk_container_add (GTK_CONTAINER (scroll), mv->tree); + gtk_container_add (GTK_CONTAINER (scroll), GTK_WIDGET(mv->textview) ); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1); @@ -845,7 +1077,7 @@ void openMemoryViewWindow (void) if (memViewEvntSrcID == 0) { memViewEvntSrcID = - g_timeout_add (100, updateMemViewTree, mv); + g_timeout_add (1000, updateMemViewTree, mv); } } From 41cfd69fe28777ace483ad7c442115568469b157 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Tue, 19 May 2020 00:03:30 -0400 Subject: [PATCH 082/156] Successful display of memview. --- src/drivers/sdl/memview.cpp | 125 ++++++++++++++++++++++-------------- 1 file changed, 76 insertions(+), 49 deletions(-) diff --git a/src/drivers/sdl/memview.cpp b/src/drivers/sdl/memview.cpp index bff055e5..582b39cd 100644 --- a/src/drivers/sdl/memview.cpp +++ b/src/drivers/sdl/memview.cpp @@ -142,7 +142,7 @@ struct memViewWin_t numLines = 0; evntSrcID = 0; treeViewLines = 64; - numCharsPerLine = 64; + numCharsPerLine = 90; redraw = 1; for (int i=0; i<16; i++) @@ -211,23 +211,23 @@ struct memViewWin_t redraw = 1; } - int set_inner_slider( double value ) - { - GtkAdjustment *ivadj; - double l, u; + //int set_inner_slider( double value ) + //{ + // GtkAdjustment *ivadj; + // double l, u; - ivadj = gtk_range_get_adjustment( GTK_RANGE(ivbar) ); + // ivadj = gtk_range_get_adjustment( GTK_RANGE(ivbar) ); - l = gtk_adjustment_get_lower( ivadj ); - u = gtk_adjustment_get_upper( ivadj ); + // l = gtk_adjustment_get_lower( ivadj ); + // u = gtk_adjustment_get_upper( ivadj ); - printf("Inner VBAR Limits: %f %f \n" , - l, u ); + // printf("Inner VBAR Limits: %f %f \n" , + // l, u ); - gtk_range_set_value( GTK_RANGE(ivbar), l + value*(u-l) ); + // gtk_range_set_value( GTK_RANGE(ivbar), l + value*(u-l) ); - return 0; - } + // return 0; + //} void showMemViewResults (int reset); //int calcVisibleRange( int *start_out, int *end_out, int *center_out ); @@ -263,12 +263,11 @@ void memViewWin_t::showMemViewResults (int reset) int addr, memSize = 0; int lineAddr = 0, c, un, ln; int i, row, row_start, row_end, totalChars; + gint cpos; char addrStr[16], valStr[16][8], ascii[18]; char row_changed; - std::string txt; std::string line; GtkTextIter iter, start_iter, end_iter; - GdkRectangle visible_rect; int (*memAccessFunc)( unsigned int offset) = NULL; switch ( mode ) @@ -316,9 +315,10 @@ void memViewWin_t::showMemViewResults (int reset) return; } } - gtk_text_view_get_visible_rect ( textview, &visible_rect ); - //printf("Vis: x:%i y:%i w:%i h:%i \n", visible_rect.x, visible_rect.y, visible_rect.width, visible_rect.height ); + g_object_get( textbuf, "cursor-position", &cpos, NULL ); + + //printf("CPOS: %i \n", cpos ); gtk_text_buffer_get_start_iter( textbuf, &start_iter ); gtk_text_buffer_get_end_iter( textbuf, &end_iter ); @@ -343,7 +343,7 @@ void memViewWin_t::showMemViewResults (int reset) { gtk_text_buffer_get_iter_at_offset( textbuf, &iter, totalChars ); - row_changed = reset; + row_changed = 1; line.clear(); @@ -395,41 +395,30 @@ void memViewWin_t::showMemViewResults (int reset) if ( row_changed ) { - if ( !reset ) - { - //int k=0; - //char *bfp; char l[256]; - - GtkTextIter next_iter; - gtk_text_buffer_get_iter_at_offset( textbuf, &next_iter, totalChars + numCharsPerLine ); - gtk_text_buffer_delete ( textbuf, &iter, &next_iter ); - //bfp = gtk_text_buffer_get_text ( textbuf, &iter, &next_iter, 0 ); - //while ( bfp[k] != 0 ) - //{ - // if ( bfp[k] == '\n') break; - - // l[k] = bfp[k]; k++; - //} - //l[k] = 0; - //printf("%s:%s\n", addrStr, l ); - gtk_text_buffer_insert ( textbuf, &iter, line.c_str(), -1 ); - } if ( reset ) { gtk_text_buffer_get_iter_at_offset( textbuf, &iter, totalChars ); gtk_text_buffer_insert ( textbuf, &iter, line.c_str(), -1 ); } + else + { + GtkTextIter next_iter; + + gtk_text_buffer_get_iter_at_offset( textbuf, &next_iter, totalChars + numCharsPerLine - 1 ); + gtk_text_buffer_delete ( textbuf, &iter, &next_iter ); + + gtk_text_buffer_get_iter_at_offset( textbuf, &iter, totalChars ); + gtk_text_buffer_insert ( textbuf, &iter, line.c_str(), line.size()-1 ); + } } totalChars += numCharsPerLine; - - //txt.append( line ); } - //if ( reset ) - //{ - // gtk_text_buffer_set_text( textbuf, txt.c_str(), -1 ); - //} + // Put cursor back where it was + gtk_text_buffer_get_iter_at_offset( textbuf, &iter, cpos ); + gtk_text_buffer_place_cursor( textbuf, &iter ); + } @@ -702,7 +691,7 @@ int memViewWin_t::calcVisibleRange( int *start_out, int *end_out, int *center_ou center = start + (end - start)/2; - printf(" Start:%i End:%i 0x%08x -> 0x%08x \n", start, end, start * 16, end * 16 ); + //printf(" Start:%i End:%i 0x%08x -> 0x%08x \n", start, end, start * 16, end * 16 ); if ( start_out ) *start_out = start; if ( end_out ) *end_out = end; @@ -811,6 +800,33 @@ static void closeMemoryViewWindow (GtkWidget * w, GdkEvent * e, memViewWin_t * m gtk_widget_destroy (w); } +static void +textview_string_insert (GtkTextView *text_view, + gchar *string, + memViewWin_t * mv ) +{ + printf("String: '%s'\n", string ); + +} + +static void +textbuffer_string_insert (GtkTextBuffer *textbuffer, + GtkTextIter *location, + gchar *text, + gint len, + memViewWin_t * mv ) +{ + if ( len == 1 ) + { + printf("Line: %i Offset: %i \n", + gtk_text_iter_get_line( location ), + gtk_text_iter_get_line_offset( location ) ); + + printf("Text: '%s' \n", text ); + } +} + + static void treeRowActivated (GtkTreeView *tree_view, GtkTreePath *path, @@ -837,7 +853,7 @@ vscroll_changed (GtkRange *range, gdouble value, memViewWin_t * mv) { - mv->setBaseAddr( value ); + //mv->setBaseAddr( value ); return FALSE; } @@ -858,8 +874,8 @@ inner_vbar_changed (GtkRange *range, r = (v - l) / (u - l); - printf("Inner VBAR: %f %f %f %f \n" , - v, l, u, r ); + //printf("Inner VBAR: %f %f %f %f \n" , + // v, l, u, r ); } static void @@ -867,7 +883,7 @@ outer_vbar_changed (GtkRange *range, memViewWin_t * mv) { //printf("Outer VBAR: %f \n", gtk_range_get_value( range ) ); - mv->setBaseAddr( gtk_range_get_value( range ) ); + //mv->setBaseAddr( gtk_range_get_value( range ) ); } static void memview_cell_edited_cb (GtkCellRendererText * cell, @@ -1016,10 +1032,21 @@ void openMemoryViewWindow (void) gtk_text_view_set_monospace( mv->textview, TRUE ); gtk_text_view_set_overwrite( mv->textview, TRUE ); + gtk_text_view_set_editable( mv->textview, TRUE ); gtk_text_view_set_wrap_mode( mv->textview, GTK_WRAP_NONE ); + gtk_text_view_set_cursor_visible( mv->textview, TRUE ); + + g_signal_connect (mv->textview, "insert-at-cursor", + G_CALLBACK (textview_string_insert), mv); + g_signal_connect (mv->textview, "preedit-changed", + G_CALLBACK (textview_string_insert), mv); + mv->textbuf = gtk_text_view_get_buffer( mv->textview ); + g_signal_connect (mv->textbuf, "insert-text", + G_CALLBACK (textbuffer_string_insert), mv); + scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); @@ -1077,7 +1104,7 @@ void openMemoryViewWindow (void) if (memViewEvntSrcID == 0) { memViewEvntSrcID = - g_timeout_add (1000, updateMemViewTree, mv); + g_timeout_add (100, updateMemViewTree, mv); } } From fe4d1f85afaaaf0f7b36960b622715f70b99b2b6 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Tue, 19 May 2020 00:30:24 -0400 Subject: [PATCH 083/156] Successful test of poking into RAM with hex editor in text view. --- src/drivers/sdl/memview.cpp | 81 ++++++++++++++++++++++++++++++++++--- 1 file changed, 76 insertions(+), 5 deletions(-) diff --git a/src/drivers/sdl/memview.cpp b/src/drivers/sdl/memview.cpp index 582b39cd..9cf9c149 100644 --- a/src/drivers/sdl/memview.cpp +++ b/src/drivers/sdl/memview.cpp @@ -79,6 +79,7 @@ static int getROM( unsigned int offset) } return -1; } + // struct memViewWin_t { @@ -110,6 +111,7 @@ struct memViewWin_t int mbuf_size; GtkCellRenderer *hexByte_renderer[16]; bool redraw; + int (*memAccessFunc)( unsigned int offset); enum { MODE_NES_RAM = 0, @@ -144,6 +146,7 @@ struct memViewWin_t treeViewLines = 64; numCharsPerLine = 90; redraw = 1; + memAccessFunc = getRAM; for (int i=0; i<16; i++) { @@ -211,6 +214,33 @@ struct memViewWin_t redraw = 1; } + int writeMem( unsigned int addr, int value ) + { + switch ( mode ) + { + default: + case MODE_NES_RAM: + { + writefunc wfunc; + + wfunc = GetWriteHandler (addr); + + if (wfunc) + { + wfunc ((uint32) addr, + (uint8) (value & 0x000000ff)); + } + } + break; + case MODE_NES_PPU: + break; + case MODE_NES_OAM: + break; + case MODE_NES_ROM: + break; + } + } + //int set_inner_slider( double value ) //{ // GtkAdjustment *ivadj; @@ -268,7 +298,6 @@ void memViewWin_t::showMemViewResults (int reset) char row_changed; std::string line; GtkTextIter iter, start_iter, end_iter; - int (*memAccessFunc)( unsigned int offset) = NULL; switch ( mode ) { @@ -818,11 +847,53 @@ textbuffer_string_insert (GtkTextBuffer *textbuffer, { if ( len == 1 ) { - printf("Line: %i Offset: %i \n", - gtk_text_iter_get_line( location ), - gtk_text_iter_get_line_offset( location ) ); + int addr, line, offs, byte0, byte, bcol, c, d; - printf("Text: '%s' \n", text ); + line = gtk_text_iter_get_line( location ), + offs = gtk_text_iter_get_line_offset( location ); + + byte0 = (offs - 10); + + byte = byte0 / 4; + bcol = byte0 % 4; + + addr = (line*16) + byte; + + //printf("Line: %i Offset: %i Byte:%i Bcol:%i\n", line, offs, byte, bcol ); + //printf("Text: '%s' \n", text ); + + if ( !isxdigit( text[0] ) ) + { + return; + } + d = toupper( text[0] ); + + if ( isdigit(d) ) + { + d = d - '0'; + } + else + { + d = d - 'A'; + } + + c = mv->memAccessFunc( addr ); + + //printf("Changing Addr:0x%08x from:0x%02x ", addr, c ); + + if ( bcol == 0 ) + { + c = c & 0x0f; + c = c | (d << 4); + } + else if ( bcol == 1 ) + { + c = c & 0xf0; + c = c | d; + } + //printf(" to:0x%02x \n", c ); + + mv->writeMem( addr, c ); } } From 284a787104496e1c06e05c054b0f64a055eb4c4a Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Tue, 19 May 2020 00:51:03 -0400 Subject: [PATCH 084/156] bug fix for memory poke logic. --- src/drivers/sdl/memview.cpp | 26 +++++++++++++++++++++++--- 1 file changed, 23 insertions(+), 3 deletions(-) diff --git a/src/drivers/sdl/memview.cpp b/src/drivers/sdl/memview.cpp index 9cf9c149..4366cc3c 100644 --- a/src/drivers/sdl/memview.cpp +++ b/src/drivers/sdl/memview.cpp @@ -299,6 +299,12 @@ void memViewWin_t::showMemViewResults (int reset) std::string line; GtkTextIter iter, start_iter, end_iter; + if ( redraw ) + { + reset = 1; + redraw = 0; + } + switch ( mode ) { default: @@ -866,15 +872,19 @@ textbuffer_string_insert (GtkTextBuffer *textbuffer, { return; } - d = toupper( text[0] ); + d = text[0]; - if ( isdigit(d) ) + if ( (d >= '0') && (d <= '9') ) { d = d - '0'; } + else if ( (d >= 'a') && (d <= 'f') ) + { + d = d - 'a' + 10; + } else { - d = d - 'A'; + d = d - 'A' + 10; } c = mv->memAccessFunc( addr ); @@ -957,6 +967,14 @@ outer_vbar_changed (GtkRange *range, //mv->setBaseAddr( gtk_range_get_value( range ) ); } +static void +textview_backspace_cb (GtkTextView *text_view, + memViewWin_t * mv) +{ + printf("BackSpace:\n"); + mv->redraw = 1; +} + static void memview_cell_edited_cb (GtkCellRendererText * cell, gchar * path_string, gchar * new_text, memViewWin_t * mv) @@ -1111,6 +1129,8 @@ void openMemoryViewWindow (void) G_CALLBACK (textview_string_insert), mv); g_signal_connect (mv->textview, "preedit-changed", G_CALLBACK (textview_string_insert), mv); + g_signal_connect (mv->textview, "backspace", + G_CALLBACK (textview_backspace_cb), mv); mv->textbuf = gtk_text_view_get_buffer( mv->textview ); From 5db17d79133ad2faa2757622ffa69986ee24d269 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Tue, 19 May 2020 01:00:14 -0400 Subject: [PATCH 085/156] Cleaned out treeview logic in favor of text view. Text view is much more efficient. --- src/drivers/sdl/memview.cpp | 484 +----------------------------------- 1 file changed, 2 insertions(+), 482 deletions(-) diff --git a/src/drivers/sdl/memview.cpp b/src/drivers/sdl/memview.cpp index 4366cc3c..c66e4dc4 100644 --- a/src/drivers/sdl/memview.cpp +++ b/src/drivers/sdl/memview.cpp @@ -84,27 +84,16 @@ static int getROM( unsigned int offset) struct memViewWin_t { GtkWidget *win; - GtkWidget *tree; - GtkWidget *vbar; GtkWidget *ivbar; GtkWidget *selCellLabel; GtkTextView *textview; GtkTextBuffer *textbuf; GtkTreeStore *memview_store; - GtkAdjustment *vadj; - int baseAddr; - int maxAddr; - int selAddr; - int selRowIdx; - int selColIdx; - int editRowIdx; - int editColIdx; int row_vis_start; int row_vis_end; int row_vis_center; int mode; int evntSrcID; - int treeViewLines; int numLines; int numCharsPerLine; unsigned char *mbuf; @@ -123,19 +112,10 @@ struct memViewWin_t memViewWin_t(void) { win = NULL; - tree = NULL; - vbar = NULL; - vadj = NULL; textview = NULL; textbuf = NULL; selCellLabel = NULL; memview_store = NULL; - selRowIdx = -1; - selColIdx = -1; - editRowIdx = -1; - editColIdx = -1; - selAddr = -1; - baseAddr = 0; row_vis_start = 0; row_vis_end = 64; row_vis_center= 32; @@ -143,7 +123,6 @@ struct memViewWin_t mbuf = NULL; numLines = 0; evntSrcID = 0; - treeViewLines = 64; numCharsPerLine = 90; redraw = 1; memAccessFunc = getRAM; @@ -171,49 +150,6 @@ struct memViewWin_t mode = new_mode; } - void setBaseAddr( double value ) - { - int addr, r, max; - addr = (int)( value + 0.50 ); - - printf("Set BaseAddr Req: %i 0x%08x\n", addr, addr ); - - r = addr % 16; - - addr = addr - r; - - max = mbuf_size - (treeViewLines * 16); - - if ( addr >= max ) - { - addr = max; - } - baseAddr = addr; - redraw = 1; - } - - void incrBaseAddr( int value ) - { - int addr, r, max; - - addr = baseAddr + value; - - printf("Set BaseAddr Req: %i 0x%08x\n", addr, addr ); - - r = addr % 16; - - addr = addr - r; - - max = mbuf_size - (treeViewLines * 16); - - if ( addr >= max ) - { - addr = max; - } - baseAddr = addr; - redraw = 1; - } - int writeMem( unsigned int addr, int value ) { switch ( mode ) @@ -241,26 +177,7 @@ struct memViewWin_t } } - //int set_inner_slider( double value ) - //{ - // GtkAdjustment *ivadj; - // double l, u; - - // ivadj = gtk_range_get_adjustment( GTK_RANGE(ivbar) ); - - // l = gtk_adjustment_get_lower( ivadj ); - // u = gtk_adjustment_get_upper( ivadj ); - - // printf("Inner VBAR Limits: %f %f \n" , - // l, u ); - - // gtk_range_set_value( GTK_RANGE(ivbar), l + value*(u-l) ); - - // return 0; - //} - void showMemViewResults (int reset); - //int calcVisibleRange( int *start_out, int *end_out, int *center_out ); int calcVisibleRange( int *start_out, int *end_out, int *center_out ); }; @@ -456,246 +373,6 @@ void memViewWin_t::showMemViewResults (int reset) } - -//void memViewWin_t::showMemViewResults (int reset) -//{ -// -// int lineAddr = 0, line_addr_start, line_addr_end, i, row=0; -// int addr, memSize = 0, un, ln; -// unsigned int c; -// GtkTreeIter iter; -// char addrStr[16], valStr[16][8], ascii[18], row_changed; -// int *indexArray; -// GtkTreePath *start_path = NULL, *end_path = NULL; -// int (*memAccessFunc)( unsigned int offset) = NULL; -// -// switch ( mode ) -// { -// default: -// case MODE_NES_RAM: -// memAccessFunc = getRAM; -// memSize = 0x10000; -// break; -// case MODE_NES_PPU: -// memAccessFunc = getPPU; -// memSize = (GameInfo->type == GIT_NSF ? 0x2000 : 0x4000); -// break; -// case MODE_NES_OAM: -// memAccessFunc = getOAM; -// memSize = 0x100; -// break; -// case MODE_NES_ROM: -// memAccessFunc = getROM; -// memSize = 16 + CHRsize[0] + PRGsize[0]; -// break; -// } -// -// if ( (mbuf == NULL) || (mbuf_size != memSize) ) -// { -// printf("Mode: %i MemSize:%i 0x%08x\n", mode, memSize, (unsigned int)memSize ); -// reset = 1; -// -// if ( mbuf ) -// { -// free(mbuf); mbuf = NULL; -// } -// mbuf = (unsigned char *)malloc( memSize ); -// -// if ( mbuf ) -// { -// mbuf_size = memSize; -// initMem( mbuf, memSize ); -// } -// else -// { -// printf("Error: Failed to allocate memview buffer size\n"); -// mbuf_size = 0; -// return; -// } -// -// gtk_adjustment_configure ( vadj, -// 0.0, // value, -// 0.0, // lower, -// mbuf_size, // upper, -// 16.0, // step_increment, -// 32.0, // page_increment, -// 32.0 ); // page_size); -// } -// -// if (reset) -// { -// line_addr_start = 0; -// line_addr_end = memSize; -// -// gtk_tree_store_clear (memview_store); -// -// for ( i=0; i < treeViewLines; i++) -// { -// gtk_tree_store_append (memview_store, &iter, NULL); // aquire iter -// } -// gtk_tree_model_get_iter_first( GTK_TREE_MODEL (memview_store), &iter ); -// -// line_addr_start = 0; -// line_addr_end = treeViewLines * 16; -// -// row_vis_start = 0; -// row_vis_end = treeViewLines; -// row_vis_center = treeViewLines/2; -// } -// -// if ( !reset ) -// { -// if ( gtk_tree_view_get_visible_range ( GTK_TREE_VIEW(tree), &start_path, &end_path ) ) -// { -// int iterValid; -// indexArray = gtk_tree_path_get_indices (start_path); -// -// if ( indexArray != NULL ) -// { -// row_vis_start = indexArray[0]; -// } -// -// indexArray = gtk_tree_path_get_indices (end_path); -// -// if ( indexArray != NULL ) -// { -// row_vis_end = indexArray[0] + 1; -// } -// -// iterValid = gtk_tree_model_get_iter( GTK_TREE_MODEL (memview_store), &iter, start_path ); -// -// gtk_tree_path_free( start_path ); -// gtk_tree_path_free( end_path ); -// -// if ( !iterValid ) -// { -// printf("Error: Failed to get start iterator.\n"); -// return; -// } -// row_vis_center = row_vis_start + (row_vis_end - row_vis_start + 1) / 2; -// //printf("Tree View Start: %i End: %i Center: %i \n", row_vis_start, row_vis_end, row_vis_center ); -// -// //if ( row_vis_center > 48 ) -// //{ -// // set_inner_slider( 0.50 ); -// //} -// } -// } -// line_addr_start = row_vis_start * 16; -// line_addr_end = row_vis_end * 16; -// -// for ( row=row_vis_start; row> 4; -// ln = ( c & 0x000f ); -// -// valStr[i][0] = conv2xchar(un); -// valStr[i][1] = conv2xchar(ln); -// valStr[i][2] = 0; -// -// if ( isprint(c) ) -// { -// ascii[i] = c; -// } -// else -// { -// ascii[i] = '.'; -// } -// if ( c != mbuf[addr] ) -// { -// row_changed = 1; -// mbuf[addr] = c; -// } -// } -// ascii[16] = 0; -// -// if ( row_changed && (editRowIdx != row) ) -// { -// gtk_tree_store_set( memview_store, &iter, 0, addrStr, -// 1 , valStr[0] , 2, valStr[1] , 3, valStr[2] , 4, valStr[3], -// 5 , valStr[4] , 6, valStr[5] , 7, valStr[6] , 8, valStr[7], -// 9 , valStr[8] , 10, valStr[9] , 11, valStr[10], 12, valStr[11], -// 13, valStr[12], 14, valStr[13], 15, valStr[14], 16, valStr[15], -// 17, ascii, -// -1 ); -// } -// -// if (!gtk_tree_model_iter_next -// (GTK_TREE_MODEL (memview_store), &iter)) -// { -// return; -// } -// } -// redraw = 0; -//} - -//int memViewWin_t::calcVisibleRange( int *start_out, int *end_out, int *center_out ) -//{ -// int retval = 0; -// int *indexArray; -// int start=0, end=64, center=32; -// GtkTreePath *start_path = NULL, *end_path = NULL; -// -// if ( gtk_tree_view_get_visible_range ( GTK_TREE_VIEW(tree), &start_path, &end_path ) ) -// { -// indexArray = gtk_tree_path_get_indices (start_path); -// -// if ( indexArray != NULL ) -// { -// start = indexArray[0]; -// } -// else -// { -// retval = -1; -// } -// -// indexArray = gtk_tree_path_get_indices (end_path); -// -// if ( indexArray != NULL ) -// { -// end = indexArray[0] + 1; -// } -// else -// { -// retval = -1; -// } -// -// gtk_tree_path_free( start_path ); -// gtk_tree_path_free( end_path ); -// -// center = start + (end - start + 1) / 2; -// -// if ( start_out != NULL ) -// { -// *start_out = start; -// } -// if ( end_out != NULL ) -// { -// *end_out = end; -// } -// if ( center_out != NULL ) -// { -// *center_out = center; -// } -// } -// else -// { -// retval = -1; -// } -// return retval; -//} - int memViewWin_t::calcVisibleRange( int *start_out, int *end_out, int *center_out ) { GtkAdjustment *ivadj; @@ -907,38 +584,6 @@ textbuffer_string_insert (GtkTextBuffer *textbuffer, } } - -static void -treeRowActivated (GtkTreeView *tree_view, - GtkTreePath *path, - GtkTreeViewColumn *column, - memViewWin_t * mv ) -{ - char stmp[128]; - - mv->selRowIdx = strtol( gtk_tree_path_to_string(path), NULL, 0 ); - mv->selColIdx = strtol( gtk_tree_view_column_get_title(column), NULL, 16 ); - - mv->selAddr = mv->baseAddr + (mv->selRowIdx*16) + mv->selColIdx; - - sprintf( stmp, "Selected Cell Address: 0x%04X", mv->selAddr ); - - gtk_label_set_markup ( GTK_LABEL(mv->selCellLabel), stmp ); - - //printf("Row:Col Active: %i:%i Addr: 0x%04X \n", mv->selRowIdx, mv->selColIdx, mv->selAddr ); -} - -static gboolean -vscroll_changed (GtkRange *range, - GtkScrollType scroll, - gdouble value, - memViewWin_t * mv) -{ - //mv->setBaseAddr( value ); - - return FALSE; -} - static void inner_vbar_changed (GtkRange *range, memViewWin_t * mv) @@ -959,63 +604,14 @@ inner_vbar_changed (GtkRange *range, // v, l, u, r ); } -static void -outer_vbar_changed (GtkRange *range, - memViewWin_t * mv) -{ - //printf("Outer VBAR: %f \n", gtk_range_get_value( range ) ); - //mv->setBaseAddr( gtk_range_get_value( range ) ); -} - static void textview_backspace_cb (GtkTextView *text_view, memViewWin_t * mv) { - printf("BackSpace:\n"); + //printf("BackSpace:\n"); mv->redraw = 1; } -static void memview_cell_edited_cb (GtkCellRendererText * cell, - gchar * path_string, - gchar * new_text, memViewWin_t * mv) -{ - int addr, rowIdx; - unsigned int value; - writefunc wfunc; - - //printf("PATH: %s \n", path_string ); - - rowIdx = atoi( path_string ); - - addr = mv->baseAddr + (rowIdx*16) + mv->selColIdx; - - wfunc = GetWriteHandler (addr); - - if (wfunc) - { - value = strtoul (new_text, NULL, 16); - - wfunc ((uint32) addr, - (uint8) (value & 0x000000ff)); - } - - mv->editRowIdx = -1; - mv->editColIdx = -1; -} -static void memview_cell_edited_start_cb (GtkCellRenderer * renderer, GtkCellEditable * editable, gchar * path, memViewWin_t * mv) -{ - //printf("MemView Edit Start: '%s':%li\n", path, (long)user_data); - mv->editRowIdx = atoi (path); - mv->editColIdx = mv->selColIdx; -} - -static void memview_cell_edited_cancel_cb (GtkCellRenderer * renderer, memViewWin_t * mv) -{ - //printf("MemView Edit Cancel:%li\n", (long)user_data); - mv->editRowIdx = -1; - mv->editColIdx = -1; -} - static gint updateMemViewTree (void *userData) { std::list ::iterator it; @@ -1034,10 +630,7 @@ void openMemoryViewWindow (void) GtkWidget *vbox; GtkWidget *scroll; GtkWidget *menubar; - GtkCellRenderer *renderer; - GtkTreeViewColumn *column; memViewWin_t *mv; - //void (*memview_cell_edited_start_cbs)(GtkCellRenderer * renderer, GtkCellEditable * editable, gchar * path, memViewWin_t * mv)[16]; mv = new memViewWin_t; @@ -1058,65 +651,6 @@ void openMemoryViewWindow (void) gtk_box_pack_start (GTK_BOX (main_vbox), menubar, FALSE, TRUE, 0); - mv->memview_store = - gtk_tree_store_new ( 18, - G_TYPE_STRING, // Address Field - G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, // Bytes 0 -> 3 - G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, // Bytes 4 -> 7 - G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, // Bytes 8 -> 11 - G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, // Bytes 12 -> 15 - G_TYPE_STRING ); // Ascii Byte Decoding - - mv->tree = - gtk_tree_view_new_with_model (GTK_TREE_MODEL - (mv->memview_store)); - - gtk_tree_view_set_grid_lines (GTK_TREE_VIEW (mv->tree), - GTK_TREE_VIEW_GRID_LINES_VERTICAL); - - g_object_set( mv->tree, "activate-on-single-click", TRUE, NULL ); - - g_signal_connect (mv->tree, "row-activated", - (GCallback) treeRowActivated, - (gpointer) mv); - - renderer = gtk_cell_renderer_text_new (); - g_object_set (renderer, "family", "MonoSpace", NULL); - column = gtk_tree_view_column_new_with_attributes ("Addr", renderer, - "text", 0, NULL); - gtk_tree_view_append_column (GTK_TREE_VIEW (mv->tree), column); - - for (long int i=0; i<16; i++) - { - char title[16]; - - sprintf( title, "%02lX", i ); - - renderer = gtk_cell_renderer_text_new (); - g_object_set (renderer, "family", "MonoSpace", NULL); - g_object_set (renderer, "editable", TRUE, NULL); - g_signal_connect (renderer, "edited", - (GCallback) memview_cell_edited_cb, (gpointer) mv); - g_signal_connect (renderer, "editing-started", - (GCallback) memview_cell_edited_start_cb, - (gpointer) mv); - g_signal_connect (renderer, "editing-canceled", - (GCallback) memview_cell_edited_cancel_cb, - (gpointer) mv); - column = gtk_tree_view_column_new_with_attributes ( title, - renderer, "text", i+1, - NULL); - gtk_tree_view_append_column (GTK_TREE_VIEW (mv->tree), column); - - mv->hexByte_renderer[i] = renderer; - } - - renderer = gtk_cell_renderer_text_new (); - g_object_set (renderer, "family", "MonoSpace", NULL); - column = gtk_tree_view_column_new_with_attributes ("ASCII", renderer, - "text", 17, NULL); - gtk_tree_view_append_column (GTK_TREE_VIEW (mv->tree), column); - mv->textview = (GtkTextView*) gtk_text_view_new(); gtk_text_view_set_monospace( mv->textview, TRUE ); @@ -1140,8 +674,7 @@ void openMemoryViewWindow (void) scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), - GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); - //gtk_container_add (GTK_CONTAINER (scroll), mv->tree); + GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS); gtk_container_add (GTK_CONTAINER (scroll), GTK_WIDGET(mv->textview) ); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); @@ -1149,19 +682,6 @@ void openMemoryViewWindow (void) gtk_box_pack_start (GTK_BOX (vbox), scroll, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 2); - mv->vadj = gtk_adjustment_new( 0, 0, 100, 1, 20, 20 ); - - mv->vbar = gtk_scrollbar_new( GTK_ORIENTATION_VERTICAL, mv->vadj ); - - g_signal_connect (mv->vbar, "change-value", - G_CALLBACK (vscroll_changed), mv); - g_signal_connect (mv->vbar, "value-changed", - G_CALLBACK (outer_vbar_changed), mv); - - vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1); - - gtk_box_pack_start (GTK_BOX (vbox), mv->vbar, TRUE, TRUE, 2); - gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (main_vbox), hbox, TRUE, TRUE, 5); From 364ae8c68913826086efe276b438f48523458660 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Wed, 20 May 2020 21:48:39 -0400 Subject: [PATCH 086/156] Added callback for context menu on memview window. --- src/drivers/sdl/memview.cpp | 21 +++++++++++++++++++-- 1 file changed, 19 insertions(+), 2 deletions(-) diff --git a/src/drivers/sdl/memview.cpp b/src/drivers/sdl/memview.cpp index c66e4dc4..796eeb9d 100644 --- a/src/drivers/sdl/memview.cpp +++ b/src/drivers/sdl/memview.cpp @@ -612,6 +612,23 @@ textview_backspace_cb (GtkTextView *text_view, mv->redraw = 1; } +static void +populate_context_menu (GtkTextView *text_view, + GtkWidget *popup, + memViewWin_t * mv ) +{ + //GtkWidget *menu; + GtkWidget *item; + + //menu = gtk_menu_new (); + + item = gtk_menu_item_new_with_label("Go to ROM"); + + gtk_menu_shell_append (GTK_MENU_SHELL (popup), item); + + gtk_widget_show_all (popup); +} + static gint updateMemViewTree (void *userData) { std::list ::iterator it; @@ -665,6 +682,8 @@ void openMemoryViewWindow (void) G_CALLBACK (textview_string_insert), mv); g_signal_connect (mv->textview, "backspace", G_CALLBACK (textview_backspace_cb), mv); + g_signal_connect (mv->textview, "populate-popup", + G_CALLBACK (populate_context_menu), mv); mv->textbuf = gtk_text_view_get_buffer( mv->textview ); @@ -682,8 +701,6 @@ void openMemoryViewWindow (void) gtk_box_pack_start (GTK_BOX (vbox), scroll, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 2); - gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 2); - gtk_box_pack_start (GTK_BOX (main_vbox), hbox, TRUE, TRUE, 5); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 1); From c05c85bcfde0dc444c05a922e00ac929297b6a25 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Thu, 21 May 2020 22:07:10 -0400 Subject: [PATCH 087/156] Added popup context menu framework for memview. --- src/drivers/sdl/memview.cpp | 40 ++++++++++++++++++++++++++++++------- 1 file changed, 33 insertions(+), 7 deletions(-) diff --git a/src/drivers/sdl/memview.cpp b/src/drivers/sdl/memview.cpp index 796eeb9d..67b40203 100644 --- a/src/drivers/sdl/memview.cpp +++ b/src/drivers/sdl/memview.cpp @@ -175,6 +175,7 @@ struct memViewWin_t case MODE_NES_ROM: break; } + return 0; } void showMemViewResults (int reset); @@ -612,21 +613,43 @@ textview_backspace_cb (GtkTextView *text_view, mv->redraw = 1; } -static void -populate_context_menu (GtkTextView *text_view, - GtkWidget *popup, +static gboolean +populate_context_menu (GtkWidget *popup, memViewWin_t * mv ) { - //GtkWidget *menu; + GtkWidget *menu; GtkWidget *item; - //menu = gtk_menu_new (); + //printf("Context Menu\n"); + + menu = gtk_menu_new (); item = gtk_menu_item_new_with_label("Go to ROM"); - gtk_menu_shell_append (GTK_MENU_SHELL (popup), item); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + + gtk_menu_popup_at_pointer (GTK_MENU (menu), NULL ); gtk_widget_show_all (popup); + gtk_widget_show_all (menu); + + return TRUE; +} + +static gboolean +textview_button_press_cb (GtkWidget *widget, + GdkEventButton *event, + memViewWin_t * mv ) +{ + gboolean ret = FALSE; + //printf("Press Button %i %u\n", event->type, event->button ); + + if ( event->button == 3 ) + { + ret = populate_context_menu( widget, mv ); + } + + return ret; } static gint updateMemViewTree (void *userData) @@ -682,8 +705,11 @@ void openMemoryViewWindow (void) G_CALLBACK (textview_string_insert), mv); g_signal_connect (mv->textview, "backspace", G_CALLBACK (textview_backspace_cb), mv); - g_signal_connect (mv->textview, "populate-popup", + g_signal_connect (mv->textview, "popup-menu", G_CALLBACK (populate_context_menu), mv); + g_signal_connect (mv->textview, "button-press-event", + G_CALLBACK (textview_button_press_cb), mv); + mv->textbuf = gtk_text_view_get_buffer( mv->textview ); From 475464cca2f9906316d047851213cac27a1b95cd Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Fri, 22 May 2020 09:00:07 -0400 Subject: [PATCH 088/156] Added logic to display a label showing the address of the cursor selected memory location in hex editor. --- src/drivers/sdl/memview.cpp | 62 +++++++++++++++++++++++++++++++++++-- 1 file changed, 59 insertions(+), 3 deletions(-) diff --git a/src/drivers/sdl/memview.cpp b/src/drivers/sdl/memview.cpp index 67b40203..81b7df96 100644 --- a/src/drivers/sdl/memview.cpp +++ b/src/drivers/sdl/memview.cpp @@ -89,6 +89,7 @@ struct memViewWin_t GtkTextView *textview; GtkTextBuffer *textbuf; GtkTreeStore *memview_store; + int selAddr; int row_vis_start; int row_vis_end; int row_vis_center; @@ -119,6 +120,7 @@ struct memViewWin_t row_vis_start = 0; row_vis_end = 64; row_vis_center= 32; + selAddr = 0; mode = MODE_NES_RAM; mbuf = NULL; numLines = 0; @@ -180,6 +182,7 @@ struct memViewWin_t void showMemViewResults (int reset); int calcVisibleRange( int *start_out, int *end_out, int *center_out ); + int getAddrFromCursor( int CursorTextOffset = -1 ); }; @@ -206,13 +209,56 @@ static void initMem( unsigned char *c, int size ) } } +int memViewWin_t::getAddrFromCursor( int CursorTextOffset ) +{ + int line, offs, byte0, byte, bcol, addr = -1; + + if ( CursorTextOffset < 0 ) + { + gint cpos; + g_object_get( textbuf, "cursor-position", &cpos, NULL ); + CursorTextOffset = cpos; + } + line = CursorTextOffset / numCharsPerLine; + offs = CursorTextOffset % numCharsPerLine; + + if ( offs < 10 ) + { + return addr; + } + else if ( offs < 73 ) + { + byte0 = (offs - 10); + + byte = byte0 / 4; + bcol = byte0 % 4; + + if ( byte < 16 ) + { + if (bcol < 2) + { + addr = (line*16) + byte; + } + } + } + else + { + if ( (offs >= 73) && (offs < 89) ) + { + addr = (line*16) + (offs-73); + } + } + + return addr; +} + void memViewWin_t::showMemViewResults (int reset) { int addr, memSize = 0; int lineAddr = 0, c, un, ln; int i, row, row_start, row_end, totalChars; gint cpos; - char addrStr[16], valStr[16][8], ascii[18]; + char addrStr[128], valStr[16][8], ascii[18]; char row_changed; std::string line; GtkTextIter iter, start_iter, end_iter; @@ -271,6 +317,8 @@ void memViewWin_t::showMemViewResults (int reset) g_object_get( textbuf, "cursor-position", &cpos, NULL ); + selAddr = getAddrFromCursor( cpos ); + //printf("CPOS: %i \n", cpos ); gtk_text_buffer_get_start_iter( textbuf, &start_iter ); @@ -372,6 +420,16 @@ void memViewWin_t::showMemViewResults (int reset) gtk_text_buffer_get_iter_at_offset( textbuf, &iter, cpos ); gtk_text_buffer_place_cursor( textbuf, &iter ); + if ( selAddr >= 0 ) + { + sprintf( addrStr, "Selected Addr: 0x%08X", selAddr ); + } + else + { + addrStr[0] = 0; + } + gtk_label_set_text( GTK_LABEL(selCellLabel), addrStr ); + } int memViewWin_t::calcVisibleRange( int *start_out, int *end_out, int *center_out ) @@ -710,8 +768,6 @@ void openMemoryViewWindow (void) g_signal_connect (mv->textview, "button-press-event", G_CALLBACK (textview_button_press_cb), mv); - - mv->textbuf = gtk_text_view_get_buffer( mv->textview ); g_signal_connect (mv->textbuf, "insert-text", From b731245171e5f812cf223e73c7bf1fb463e3f8ef Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Fri, 22 May 2020 09:19:45 -0400 Subject: [PATCH 089/156] Added a few context menu items. TODO create callback functions for them --- src/drivers/sdl/memview.cpp | 42 +++++++++++++++++++++++++++++++------ 1 file changed, 36 insertions(+), 6 deletions(-) diff --git a/src/drivers/sdl/memview.cpp b/src/drivers/sdl/memview.cpp index 81b7df96..47492253 100644 --- a/src/drivers/sdl/memview.cpp +++ b/src/drivers/sdl/memview.cpp @@ -675,20 +675,50 @@ static gboolean populate_context_menu (GtkWidget *popup, memViewWin_t * mv ) { - GtkWidget *menu; + GtkWidget *menu = NULL; GtkWidget *item; + char stmp[256]; //printf("Context Menu\n"); - + menu = gtk_menu_new (); + + switch ( mv->mode ) + { + case memViewWin_t::MODE_NES_RAM: + { + if ( mv->selAddr >= 0x0000 ) + { + sprintf( stmp, "Poke RAM 0x%04X", mv->selAddr ); - item = gtk_menu_item_new_with_label("Go to ROM"); + item = gtk_menu_item_new_with_label(stmp); - gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + } + if ( mv->selAddr >= 0x8000 ) + { + item = gtk_menu_item_new_with_label("Go to ROM"); + + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + } + } + break; + case memViewWin_t::MODE_NES_ROM: + { + if ( mv->selAddr >= 0x0000 ) + { + sprintf( stmp, "Poke ROM 0x%08X", mv->selAddr ); + + item = gtk_menu_item_new_with_label(stmp); + + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + } + } + break; + } gtk_menu_popup_at_pointer (GTK_MENU (menu), NULL ); - - gtk_widget_show_all (popup); + //gtk_widget_show_all (popup); gtk_widget_show_all (menu); return TRUE; From 9ac2803533ad79af873d6cf13c4177e8692df96e Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Fri, 22 May 2020 09:30:16 -0400 Subject: [PATCH 090/156] Added logic to get NES ROM address from RAM location for context menu. --- src/drivers/sdl/memview.cpp | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/src/drivers/sdl/memview.cpp b/src/drivers/sdl/memview.cpp index 47492253..5dbff8e1 100644 --- a/src/drivers/sdl/memview.cpp +++ b/src/drivers/sdl/memview.cpp @@ -695,11 +695,18 @@ populate_context_menu (GtkWidget *popup, gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); } - if ( mv->selAddr >= 0x8000 ) + if ( mv->selAddr >= 0x6000 ) { - item = gtk_menu_item_new_with_label("Go to ROM"); + int romAddr = GetNesFileAddress(mv->selAddr); - gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + if ( romAddr >= 0 ) + { + sprintf( stmp, "Goto ROM 0x%08X", romAddr ); + + item = gtk_menu_item_new_with_label(stmp); + + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + } } } break; From 04a4b6de7435a0bba6ccd3d664c13fded9dde6e6 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 23 May 2020 14:56:42 -0400 Subject: [PATCH 091/156] Added more functionality to the memview window. Now can view all memory types. New context menu allows for seeking to a new location by address, poking memory locations, and jumping from RAM to ROM. --- src/drivers/sdl/config.cpp | 4 +- src/drivers/sdl/input.cpp | 6 +- src/drivers/sdl/memview.cpp | 379 +++++++++++++++++++++++++++++++----- 3 files changed, 336 insertions(+), 53 deletions(-) diff --git a/src/drivers/sdl/config.cpp b/src/drivers/sdl/config.cpp index d8bddc62..0c91e621 100644 --- a/src/drivers/sdl/config.cpp +++ b/src/drivers/sdl/config.cpp @@ -312,7 +312,7 @@ InitConfig() for(unsigned int i = 0; i < GAMEPAD_NUM_DEVICES; i++) { char buf[64]; - snprintf(buf, sizeof(buf)-1, "SDL.Input.GamePad.%d.", i); + snprintf(buf, sizeof(buf)-1, "SDL.Input.GamePad.%u.", i); prefix = buf; config->addOption(prefix + "DeviceType", DefaultGamePadDevice[i]); @@ -325,7 +325,7 @@ InitConfig() // PowerPad 0 - 1 for(unsigned int i = 0; i < POWERPAD_NUM_DEVICES; i++) { char buf[64]; - snprintf(buf, sizeof(buf)-1, "SDL.Input.PowerPad.%d.", i); + snprintf(buf, sizeof(buf)-1, "SDL.Input.PowerPad.%u.", i); prefix = buf; config->addOption(prefix + "DeviceType", DefaultPowerPadDevice[i]); diff --git a/src/drivers/sdl/input.cpp b/src/drivers/sdl/input.cpp index 38d16fe1..31cd81fe 100644 --- a/src/drivers/sdl/input.cpp +++ b/src/drivers/sdl/input.cpp @@ -2059,7 +2059,7 @@ UpdateInput (Config * config) for (unsigned int i = 0; i < 3; i++) { - snprintf (buf, 64, "SDL.Input.%d", i); + snprintf (buf, 64, "SDL.Input.%u", i); config->getOption (buf, &device); if (device == "None") @@ -2145,7 +2145,7 @@ UpdateInput (Config * config) for (unsigned int i = 0; i < GAMEPAD_NUM_DEVICES; i++) { char buf[64]; - snprintf (buf, sizeof(buf)-1, "SDL.Input.GamePad.%d.", i); + snprintf (buf, sizeof(buf)-1, "SDL.Input.GamePad.%u.", i); prefix = buf; config->getOption (prefix + "DeviceType", &device); @@ -2178,7 +2178,7 @@ UpdateInput (Config * config) for (unsigned int i = 0; i < POWERPAD_NUM_DEVICES; i++) { char buf[64]; - snprintf (buf, 32, "SDL.Input.PowerPad.%d.", i); + snprintf (buf, 32, "SDL.Input.PowerPad.%u.", i); prefix = buf; config->getOption (prefix + "DeviceType", &device); diff --git a/src/drivers/sdl/memview.cpp b/src/drivers/sdl/memview.cpp index 5dbff8e1..f61b9565 100644 --- a/src/drivers/sdl/memview.cpp +++ b/src/drivers/sdl/memview.cpp @@ -80,19 +80,46 @@ static int getROM( unsigned int offset) return -1; } +static void PalettePoke(uint32 addr, uint8 data) +{ + data = data & 0x3F; + addr = addr & 0x1F; + if ((addr & 3) == 0) + { + addr = (addr & 0xC) >> 2; + if (addr == 0) + { + PALRAM[0x00] = PALRAM[0x04] = PALRAM[0x08] = PALRAM[0x0C] = data; + } + else + { + UPALRAM[addr-1] = UPALRAM[0x10|(addr-1)] = data; + } + } + else + { + PALRAM[addr] = data; + } +} + // struct memViewWin_t { GtkWidget *win; GtkWidget *ivbar; GtkWidget *selCellLabel; + GtkWidget *addr_entry; + GtkWidget *memSelRadioItem[4]; GtkTextView *textview; GtkTextBuffer *textbuf; - GtkTreeStore *memview_store; int selAddr; + int selRomAddr; + int jumpAddr; + int jumpDelay; int row_vis_start; int row_vis_end; int row_vis_center; + int dialog_op; int mode; int evntSrcID; int numLines; @@ -115,20 +142,30 @@ struct memViewWin_t win = NULL; textview = NULL; textbuf = NULL; + addr_entry = NULL; selCellLabel = NULL; - memview_store = NULL; + ivbar = NULL; row_vis_start = 0; row_vis_end = 64; row_vis_center= 32; selAddr = 0; + selRomAddr = -1; + jumpAddr = -1; + jumpDelay = 0; + dialog_op = 0; mode = MODE_NES_RAM; mbuf = NULL; + mbuf_size = 0; numLines = 0; evntSrcID = 0; numCharsPerLine = 90; redraw = 1; memAccessFunc = getRAM; + for (int i=0; i<4; i++) + { + memSelRadioItem[i] = NULL; + } for (int i=0; i<16; i++) { hexByte_renderer[i] = NULL; @@ -154,32 +191,75 @@ struct memViewWin_t int writeMem( unsigned int addr, int value ) { + value = value & 0x000000ff; + switch ( mode ) { default: case MODE_NES_RAM: { - writefunc wfunc; - - wfunc = GetWriteHandler (addr); - - if (wfunc) + if ( addr < 0x8000 ) { - wfunc ((uint32) addr, - (uint8) (value & 0x000000ff)); + writefunc wfunc; + + wfunc = GetWriteHandler (addr); + + if (wfunc) + { + wfunc ((uint32) addr, + (uint8) (value & 0x000000ff)); + } + } + else + { + fprintf( stdout, "Error: Writing into RAM addresses >= 0x8000 is unsafe. Operation Denied.\n"); } } break; case MODE_NES_PPU: + { + addr &= 0x3FFF; + if (addr < 0x2000) + { + VPage[addr >> 10][addr] = value; //todo: detect if this is vrom and turn it red if so + } + if ((addr >= 0x2000) && (addr < 0x3F00)) + { + vnapage[(addr >> 10) & 0x3][addr & 0x3FF] = value; //todo: this causes 0x3000-0x3f00 to mirror 0x2000-0x2f00, is this correct? + } + if ((addr >= 0x3F00) && (addr < 0x3FFF)) + { + PalettePoke(addr, value); + } + } break; case MODE_NES_OAM: + { + addr &= 0xFF; + SPRAM[addr] = value; + } break; case MODE_NES_ROM: + { + if (addr < 16) + { + fprintf( stdout, "You can't edit ROM header here, however you can use iNES Header Editor to edit the header if it's an iNES format file."); + } + else if ( (addr >= 16) && (addr < PRGsize[0]+16) ) + { + *(uint8 *)(GetNesPRGPointer(addr-16)) = value; + } + else if ( (addr >= PRGsize[0]+16) && (addr < CHRsize[0]+PRGsize[0]+16) ) + { + *(uint8 *)(GetNesCHRPointer(addr-16-PRGsize[0])) = value; + } + } break; } return 0; } + int gotoLocation( int addr ); void showMemViewResults (int reset); int calcVisibleRange( int *start_out, int *end_out, int *center_out ); int getAddrFromCursor( int CursorTextOffset = -1 ); @@ -420,6 +500,21 @@ void memViewWin_t::showMemViewResults (int reset) gtk_text_buffer_get_iter_at_offset( textbuf, &iter, cpos ); gtk_text_buffer_place_cursor( textbuf, &iter ); + // Check if a Jump Delay is set. + if ( jumpDelay <= 0 ) + { + if ( jumpAddr >= 0 ) + { + gotoLocation( jumpAddr ); + jumpAddr = -1; + } + jumpDelay = 0; + } + else + { + jumpDelay--; + } + if ( selAddr >= 0 ) { sprintf( addrStr, "Selected Addr: 0x%08X", selAddr ); @@ -471,6 +566,26 @@ int memViewWin_t::calcVisibleRange( int *start_out, int *end_out, int *center_ou return 0; } +int memViewWin_t::gotoLocation( int addr ) +{ + int linenum, bytenum, cpos; + GtkTextIter iter; + + linenum = addr / 16; + bytenum = addr % 16; + + cpos = (linenum*numCharsPerLine) + (bytenum*4) + 10; + + //printf("Line:%i Byte:%i CPOS:%i \n", linenum, bytenum, cpos ); + + gtk_text_buffer_get_iter_at_offset( textbuf, &iter, cpos ); + + gtk_text_view_scroll_to_iter ( textview, &iter, 0.0, 1, 0.0, 0.25 ); + gtk_text_buffer_place_cursor( textbuf, &iter ); + + return 0; +} + static int memViewEvntSrcID = 0; static std::list memViewWinList; @@ -513,38 +628,38 @@ static GtkWidget *CreateMemViewMenubar (memViewWin_t * mv) //-View --> RAM ------------------ radioGroup = NULL; - item = gtk_radio_menu_item_new_with_label (radioGroup, "RAM"); + mv->memSelRadioItem[0] = gtk_radio_menu_item_new_with_label (radioGroup, "RAM"); radioGroup = - gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM(item)); + gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM(mv->memSelRadioItem[0])); - gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), mv->memSelRadioItem[0]); - g_signal_connect (item, "activate", G_CALLBACK (changeModeRAM), + g_signal_connect (mv->memSelRadioItem[0], "activate", G_CALLBACK (changeModeRAM), (gpointer) mv); //-View --> PPU ------------------ - item = gtk_radio_menu_item_new_with_label (radioGroup, "PPU"); + mv->memSelRadioItem[1] = gtk_radio_menu_item_new_with_label (radioGroup, "PPU"); - gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), mv->memSelRadioItem[1]); - g_signal_connect (item, "activate", G_CALLBACK (changeModePPU), + g_signal_connect (mv->memSelRadioItem[1], "activate", G_CALLBACK (changeModePPU), (gpointer) mv); //-View --> OAM ------------------ - item = gtk_radio_menu_item_new_with_label (radioGroup, "OAM"); + mv->memSelRadioItem[2] = gtk_radio_menu_item_new_with_label (radioGroup, "OAM"); - gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), mv->memSelRadioItem[2]); - g_signal_connect (item, "activate", G_CALLBACK (changeModeOAM), + g_signal_connect (mv->memSelRadioItem[2], "activate", G_CALLBACK (changeModeOAM), (gpointer) mv); //-View --> ROM ------------------ - item = gtk_radio_menu_item_new_with_label (radioGroup, "ROM"); + mv->memSelRadioItem[3] = gtk_radio_menu_item_new_with_label (radioGroup, "ROM"); - gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), mv->memSelRadioItem[3]); - g_signal_connect (item, "activate", G_CALLBACK (changeModeROM), + g_signal_connect (mv->memSelRadioItem[3], "activate", G_CALLBACK (changeModeROM), (gpointer) mv); // Finally, return the actual menu bar created @@ -643,26 +758,6 @@ textbuffer_string_insert (GtkTextBuffer *textbuffer, } } -static void -inner_vbar_changed (GtkRange *range, - memViewWin_t * mv) -{ - GtkAdjustment *ivadj; - double v, l, u, r; - - ivadj = gtk_range_get_adjustment( range ); - - - v = gtk_range_get_value( range ); - l = gtk_adjustment_get_lower( ivadj ); - u = gtk_adjustment_get_upper( ivadj ); - - r = (v - l) / (u - l); - - //printf("Inner VBAR: %f %f %f %f \n" , - // v, l, u, r ); -} - static void textview_backspace_cb (GtkTextView *text_view, memViewWin_t * mv) @@ -671,6 +766,151 @@ textview_backspace_cb (GtkTextView *text_view, mv->redraw = 1; } +static void handleDialogResponse (GtkWidget * w, gint response_id, memViewWin_t * mv) +{ + //printf("Response %i\n", response_id ); + + if ( response_id == GTK_RESPONSE_OK ) + { + const char *txt; + + //printf("Reponse OK\n"); + + txt = gtk_entry_get_text( GTK_ENTRY( mv->addr_entry ) ); + + if ( txt != NULL ) + { + //printf("Text: '%s'\n", txt ); + switch (mv->dialog_op) + { + case 1: + if ( isxdigit(txt[0]) ) + { // Address is always treated as hex number + mv->gotoLocation( strtol( txt, NULL, 16 ) ); + } + break; + case 2: + if ( isdigit(txt[0]) ) + { // Value is numerical + mv->writeMem( mv->selAddr, strtol( txt, NULL, 0 ) ); + } + else if ( (txt[0] == '\'') && (txt[2] == '\'') ) + { // Byte to be written is expressed as ASCII character + mv->writeMem( mv->selAddr, txt[1] ); + } + break; + } + } + } + //else if ( response_id == GTK_RESPONSE_CANCEL ) + //{ + // printf("Reponse Cancel\n"); + //} + gtk_widget_destroy (w); + + mv->addr_entry = NULL; +} +static void closeDialogWindow (GtkWidget * w, GdkEvent * e, memViewWin_t * mv) +{ + gtk_widget_destroy (w); + + mv->addr_entry = NULL; +} + +static void +gotoLocationCB (GtkMenuItem *menuitem, + memViewWin_t * mv) +{ + GtkWidget *win; + GtkWidget *vbox; + + mv->dialog_op = 1; + + win = gtk_dialog_new_with_buttons ("Goto Address", + GTK_WINDOW (mv->win), + (GtkDialogFlags) + (GTK_DIALOG_DESTROY_WITH_PARENT), + "_Cancel", GTK_RESPONSE_CANCEL, + "_Goto", GTK_RESPONSE_OK, NULL); + + vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1); + + mv->addr_entry = gtk_entry_new (); + + gtk_entry_set_text (GTK_ENTRY (mv->addr_entry), "0x0"); + + gtk_box_pack_start (GTK_BOX (vbox), mv->addr_entry, TRUE, TRUE, 0); + + gtk_box_pack_start (GTK_BOX + (gtk_dialog_get_content_area + (GTK_DIALOG (win))), vbox, TRUE, TRUE, 1); + + gtk_widget_show_all (win); + + g_signal_connect (win, "delete-event", + G_CALLBACK (closeDialogWindow), mv); + g_signal_connect (win, "response", + G_CALLBACK (handleDialogResponse), mv); + + //mv->gotoLocation( mv->selRomAddr ); +} + +static void +setValueCB (GtkMenuItem *menuitem, + memViewWin_t * mv) +{ + GtkWidget *win; + GtkWidget *vbox; + char stmp[256]; + + mv->dialog_op = 2; + + sprintf( stmp, "Poke Address 0x%08x", mv->selAddr ); + + win = gtk_dialog_new_with_buttons ( stmp, + GTK_WINDOW (mv->win), + (GtkDialogFlags) + (GTK_DIALOG_DESTROY_WITH_PARENT), + "_Cancel", GTK_RESPONSE_CANCEL, + "_Write", GTK_RESPONSE_OK, NULL); + + vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1); + + mv->addr_entry = gtk_entry_new (); + + gtk_entry_set_text (GTK_ENTRY (mv->addr_entry), "0x0"); + + gtk_box_pack_start (GTK_BOX (vbox), mv->addr_entry, TRUE, TRUE, 0); + + gtk_box_pack_start (GTK_BOX + (gtk_dialog_get_content_area + (GTK_DIALOG (win))), vbox, TRUE, TRUE, 1); + + gtk_widget_show_all (win); + + g_signal_connect (win, "delete-event", + G_CALLBACK (closeDialogWindow), mv); + g_signal_connect (win, "response", + G_CALLBACK (handleDialogResponse), mv); + + //mv->gotoLocation( mv->selRomAddr ); +} + +static void +gotoRomLocationCB (GtkMenuItem *menuitem, + memViewWin_t * mv) +{ + gtk_menu_item_activate( GTK_MENU_ITEM(mv->memSelRadioItem[3]) ); + + mv->setMode( memViewWin_t::MODE_NES_ROM ); + + mv->showMemViewResults(1); + + mv->jumpAddr = mv->selRomAddr; + mv->jumpDelay = 10; + +} + static gboolean populate_context_menu (GtkWidget *popup, memViewWin_t * mv ) @@ -683,6 +923,13 @@ populate_context_menu (GtkWidget *popup, menu = gtk_menu_new (); + item = gtk_menu_item_new_with_label("Goto Address..."); + + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + + g_signal_connect (item, "activate", + G_CALLBACK (gotoLocationCB), mv); + switch ( mv->mode ) { case memViewWin_t::MODE_NES_RAM: @@ -694,22 +941,58 @@ populate_context_menu (GtkWidget *popup, item = gtk_menu_item_new_with_label(stmp); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + + g_signal_connect (item, "activate", + G_CALLBACK (setValueCB), mv); } if ( mv->selAddr >= 0x6000 ) { - int romAddr = GetNesFileAddress(mv->selAddr); + mv->selRomAddr = GetNesFileAddress(mv->selAddr); - if ( romAddr >= 0 ) + if ( mv->selRomAddr >= 0 ) { - sprintf( stmp, "Goto ROM 0x%08X", romAddr ); + sprintf( stmp, "Goto ROM 0x%08X", mv->selRomAddr ); item = gtk_menu_item_new_with_label(stmp); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + + g_signal_connect (item, "activate", + G_CALLBACK (gotoRomLocationCB), mv); } } } break; + case memViewWin_t::MODE_NES_PPU: + { + if ( mv->selAddr >= 0x0000 ) + { + sprintf( stmp, "Poke PPU 0x%08X", mv->selAddr ); + + item = gtk_menu_item_new_with_label(stmp); + + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + + g_signal_connect (item, "activate", + G_CALLBACK (setValueCB), mv); + } + } + break; + case memViewWin_t::MODE_NES_OAM: + { + if ( mv->selAddr >= 0x0000 ) + { + sprintf( stmp, "Poke OAM 0x%08X", mv->selAddr ); + + item = gtk_menu_item_new_with_label(stmp); + + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + + g_signal_connect (item, "activate", + G_CALLBACK (setValueCB), mv); + } + } + break; case memViewWin_t::MODE_NES_ROM: { if ( mv->selAddr >= 0x0000 ) @@ -719,6 +1002,9 @@ populate_context_menu (GtkWidget *popup, item = gtk_menu_item_new_with_label(stmp); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + + g_signal_connect (item, "activate", + G_CALLBACK (setValueCB), mv); } } break; @@ -836,9 +1122,6 @@ void openMemoryViewWindow (void) mv->ivbar = gtk_scrolled_window_get_vscrollbar( GTK_SCROLLED_WINDOW(scroll) ); - g_signal_connect (mv->ivbar, "value-changed", - G_CALLBACK (inner_vbar_changed), mv); - g_signal_connect (mv->win, "delete-event", G_CALLBACK (closeMemoryViewWindow), mv); g_signal_connect (mv->win, "response", From 6947f2bd0500700b37c085416212c6086bc4aed7 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 23 May 2020 15:08:03 -0400 Subject: [PATCH 092/156] Bug fix for GUI initialization with a specified game on the command line. Sometimes the X-server needs a little more time to initialize the window. Added a short 0.1 sec usleep at startup to give X the time it needs. A few more cppcheck warning fixes made as well. --- src/drivers/sdl/memview.cpp | 6 ------ src/drivers/sdl/sdl-netplay.cpp | 2 +- src/drivers/sdl/sdl-video.cpp | 2 +- src/drivers/sdl/sdl.cpp | 5 +++++ 4 files changed, 7 insertions(+), 8 deletions(-) diff --git a/src/drivers/sdl/memview.cpp b/src/drivers/sdl/memview.cpp index f61b9565..233e7c02 100644 --- a/src/drivers/sdl/memview.cpp +++ b/src/drivers/sdl/memview.cpp @@ -116,9 +116,6 @@ struct memViewWin_t int selRomAddr; int jumpAddr; int jumpDelay; - int row_vis_start; - int row_vis_end; - int row_vis_center; int dialog_op; int mode; int evntSrcID; @@ -145,9 +142,6 @@ struct memViewWin_t addr_entry = NULL; selCellLabel = NULL; ivbar = NULL; - row_vis_start = 0; - row_vis_end = 64; - row_vis_center= 32; selAddr = 0; selRomAddr = -1; jumpAddr = -1; diff --git a/src/drivers/sdl/sdl-netplay.cpp b/src/drivers/sdl/sdl-netplay.cpp index 52a9e25e..093ff7e9 100644 --- a/src/drivers/sdl/sdl-netplay.cpp +++ b/src/drivers/sdl/sdl-netplay.cpp @@ -216,7 +216,7 @@ int FCEUD_GetDataFromServer(uint8 *data) } } - if(SDLNet_SocketReady(UDPSocket) + if(SDLNet_SocketReady(UDPSocket)) { diff --git a/src/drivers/sdl/sdl-video.cpp b/src/drivers/sdl/sdl-video.cpp index a3538cf1..a101bd61 100644 --- a/src/drivers/sdl/sdl-video.cpp +++ b/src/drivers/sdl/sdl-video.cpp @@ -445,12 +445,12 @@ InitVideo(FCEUGI *gi) // } //#endif } - s_curbpp = s_screen->format->BitsPerPixel; if(!s_screen) { FCEUD_PrintError(SDL_GetError()); KillVideo(); return -1; } + s_curbpp = s_screen->format->BitsPerPixel; #if 0 // XXX soules - this would be creating a surface on the video diff --git a/src/drivers/sdl/sdl.cpp b/src/drivers/sdl/sdl.cpp index a245b98b..a2c00cda 100644 --- a/src/drivers/sdl/sdl.cpp +++ b/src/drivers/sdl/sdl.cpp @@ -861,6 +861,11 @@ int main(int argc, char *argv[]) InitGTKSubsystem(argc, argv); while(gtk_events_pending()) gtk_main_iteration_do(FALSE); + // Ensure that the GUI has fully initialized. + // Give the X-server a small amount of time to init. + usleep(100000); + while(gtk_events_pending()) + gtk_main_iteration_do(FALSE); } #endif From 11d02a31c464b78f007219b710cc1cfebd8d643b Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 23 May 2020 16:09:14 -0400 Subject: [PATCH 093/156] Added logic in memview window to make set address and value entry windows exit on an enter key press. --- src/drivers/sdl/memview.cpp | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/src/drivers/sdl/memview.cpp b/src/drivers/sdl/memview.cpp index 233e7c02..67689ffa 100644 --- a/src/drivers/sdl/memview.cpp +++ b/src/drivers/sdl/memview.cpp @@ -804,6 +804,7 @@ static void handleDialogResponse (GtkWidget * w, gint response_id, memViewWin_t mv->addr_entry = NULL; } + static void closeDialogWindow (GtkWidget * w, GdkEvent * e, memViewWin_t * mv) { gtk_widget_destroy (w); @@ -827,10 +828,14 @@ gotoLocationCB (GtkMenuItem *menuitem, "_Cancel", GTK_RESPONSE_CANCEL, "_Goto", GTK_RESPONSE_OK, NULL); + gtk_dialog_set_default_response( GTK_DIALOG(win), GTK_RESPONSE_OK ); + vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1); mv->addr_entry = gtk_entry_new (); + gtk_entry_set_activates_default( GTK_ENTRY (mv->addr_entry), TRUE ); + gtk_entry_set_text (GTK_ENTRY (mv->addr_entry), "0x0"); gtk_box_pack_start (GTK_BOX (vbox), mv->addr_entry, TRUE, TRUE, 0); @@ -846,7 +851,6 @@ gotoLocationCB (GtkMenuItem *menuitem, g_signal_connect (win, "response", G_CALLBACK (handleDialogResponse), mv); - //mv->gotoLocation( mv->selRomAddr ); } static void @@ -868,12 +872,16 @@ setValueCB (GtkMenuItem *menuitem, "_Cancel", GTK_RESPONSE_CANCEL, "_Write", GTK_RESPONSE_OK, NULL); + gtk_dialog_set_default_response( GTK_DIALOG(win), GTK_RESPONSE_OK ); + vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1); mv->addr_entry = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (mv->addr_entry), "0x0"); + gtk_entry_set_activates_default( GTK_ENTRY (mv->addr_entry), TRUE ); + gtk_box_pack_start (GTK_BOX (vbox), mv->addr_entry, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX @@ -887,7 +895,6 @@ setValueCB (GtkMenuItem *menuitem, g_signal_connect (win, "response", G_CALLBACK (handleDialogResponse), mv); - //mv->gotoLocation( mv->selRomAddr ); } static void From 484f299107a95b4bc260c81e56474f21d911d6a7 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 23 May 2020 16:20:40 -0400 Subject: [PATCH 094/156] Added a NULL check to prevent crash in RAM watch window. --- src/drivers/sdl/ramwatch.cpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/drivers/sdl/ramwatch.cpp b/src/drivers/sdl/ramwatch.cpp index 4fde04c7..04797d24 100644 --- a/src/drivers/sdl/ramwatch.cpp +++ b/src/drivers/sdl/ramwatch.cpp @@ -934,6 +934,11 @@ static void ramWatch_cell_edited_cb (GtkCellRendererText * cell, rw = ramWatchList.getIndex (rww->ramWatchEditRowIdx); + if ( rw == NULL ) + { + return; + } + switch (rww->ramWatchEditColIdx) { case 0: From c46d3e2a9d06cb3d582705c9feeb132af1d300f7 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 23 May 2020 16:22:56 -0400 Subject: [PATCH 095/156] Added logic to clear edited row and column indices on null pointer error in RAM watch window. --- src/drivers/sdl/ramwatch.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/drivers/sdl/ramwatch.cpp b/src/drivers/sdl/ramwatch.cpp index 04797d24..e82684fb 100644 --- a/src/drivers/sdl/ramwatch.cpp +++ b/src/drivers/sdl/ramwatch.cpp @@ -936,6 +936,8 @@ static void ramWatch_cell_edited_cb (GtkCellRendererText * cell, if ( rw == NULL ) { + rww->ramWatchEditRowIdx = -1; + rww->ramWatchEditColIdx = -1; return; } From 40379a32dc331980f691c83b302b97591b067e82 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 23 May 2020 16:28:43 -0400 Subject: [PATCH 096/156] Added a memory write boundary protection in the ram watch window to prevent users from writing into ROM memory area. --- src/drivers/sdl/ramwatch.cpp | 85 +++++++++++++++++++----------------- 1 file changed, 44 insertions(+), 41 deletions(-) diff --git a/src/drivers/sdl/ramwatch.cpp b/src/drivers/sdl/ramwatch.cpp index e82684fb..9683ce92 100644 --- a/src/drivers/sdl/ramwatch.cpp +++ b/src/drivers/sdl/ramwatch.cpp @@ -949,53 +949,56 @@ static void ramWatch_cell_edited_cb (GtkCellRendererText * cell, case 1: case 2: { - writefunc wfunc; - - if (rw->size == 2) + if ( (rw->addr >= 0) && (rw->addr < 0x8000) ) { - if (rw->type) + writefunc wfunc; + + if (rw->size == 2) { - rw->val.u16 = - strtol (new_text, NULL, 0); + if (rw->type) + { + rw->val.u16 = + strtol (new_text, NULL, 0); + } + else + { + rw->val.i16 = + strtol (new_text, NULL, 0); + } + wfunc = GetWriteHandler (rw->addr); + + if (wfunc) + { + wfunc ((uint32) rw->addr, + (uint8) (rw->val.u16 & 0x00ff)); + } + + wfunc = GetWriteHandler (rw->addr + 1); + + if (wfunc) + { + wfunc ((uint32) rw->addr + 1, + (uint8) ((rw->val. + u16 & 0xff00) >> 8)); + } } else { - rw->val.i16 = - strtol (new_text, NULL, 0); - } - wfunc = GetWriteHandler (rw->addr); + if (rw->type) + { + rw->val.u8 = strtol (new_text, NULL, 0); + } + else + { + rw->val.i8 = strtol (new_text, NULL, 0); + } + wfunc = GetWriteHandler (rw->addr); - if (wfunc) - { - wfunc ((uint32) rw->addr, - (uint8) (rw->val.u16 & 0x00ff)); - } - - wfunc = GetWriteHandler (rw->addr + 1); - - if (wfunc) - { - wfunc ((uint32) rw->addr + 1, - (uint8) ((rw->val. - u16 & 0xff00) >> 8)); - } - } - else - { - if (rw->type) - { - rw->val.u8 = strtol (new_text, NULL, 0); - } - else - { - rw->val.i8 = strtol (new_text, NULL, 0); - } - wfunc = GetWriteHandler (rw->addr); - - if (wfunc) - { - wfunc ((uint32) rw->addr, - (uint8) rw->val.u8); + if (wfunc) + { + wfunc ((uint32) rw->addr, + (uint8) rw->val.u8); + } } } } From 69790db4986946ea0a12b865b0e173af6f2d6851 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 23 May 2020 22:37:31 -0400 Subject: [PATCH 097/156] Initial framework for debugger window in work. --- src/drivers/sdl/SConscript | 1 + src/drivers/sdl/debugger.cpp | 428 +++++++++++++++++++++++++++++++++++ src/drivers/sdl/debugger.h | 3 + src/drivers/sdl/gui.cpp | 12 + 4 files changed, 444 insertions(+) create mode 100644 src/drivers/sdl/debugger.cpp create mode 100644 src/drivers/sdl/debugger.h diff --git a/src/drivers/sdl/SConscript b/src/drivers/sdl/SConscript index ebbad1b3..a8bde4ac 100644 --- a/src/drivers/sdl/SConscript +++ b/src/drivers/sdl/SConscript @@ -12,6 +12,7 @@ source_list = Split( config.cpp memview.cpp ramwatch.cpp + debugger.cpp sdl.cpp sdl-joystick.cpp sdl-sound.cpp diff --git a/src/drivers/sdl/debugger.cpp b/src/drivers/sdl/debugger.cpp new file mode 100644 index 00000000..916ed90e --- /dev/null +++ b/src/drivers/sdl/debugger.cpp @@ -0,0 +1,428 @@ +#include +#include +#include +#include +#include + +#include +#include +#ifdef GDK_WINDOWING_X11 +#include +#endif + +#ifdef _GTK3 +#include +#endif + +#include "../../types.h" +#include "../../fceu.h" +#include "../../cheat.h" +#include "../../debug.h" +#include "../../driver.h" +#include "../../version.h" +#include "../../movie.h" +#include "../../palette.h" +#include "../../fds.h" +#include "../../cart.h" +#include "../../ines.h" +#include "../common/configSys.h" + +#include "sdl.h" +#include "gui.h" +#include "dface.h" +#include "input.h" +#include "config.h" +#include "debugger.h" + +extern Config *g_config; + +//******************************************************************************************************* +// Debugger Window +//******************************************************************************************************* +// + +struct debuggerWin_t +{ + GtkWidget *win; + GtkTextView *textview; + GtkTextBuffer *textbuf; + GtkTextView *stackview; + GtkTextBuffer *stackTextBuf; + GtkTreeStore *bp_store; + GtkWidget *bp_tree; + GtkWidget *pc_entry; + GtkWidget *A_entry; + GtkWidget *X_entry; + GtkWidget *Y_entry; + + debuggerWin_t(void) + { + win = NULL; + textview = NULL; + textbuf = NULL; + bp_store = NULL; + bp_tree = NULL; + stackview = NULL; + stackTextBuf = NULL; + } + + ~debuggerWin_t(void) + { + + } +}; + +static std::list debuggerWinList; + +static void closeDebuggerWindow (GtkWidget * w, GdkEvent * e, debuggerWin_t * dw) +{ + std::list < debuggerWin_t * >::iterator it; + + for (it = debuggerWinList.begin (); it != debuggerWinList.end (); it++) + { + if (dw == *it) + { + //printf("Removing MemView Window %p from List\n", cw); + debuggerWinList.erase (it); + break; + } + } + + delete dw; + + gtk_widget_destroy (w); +} + +void openDebuggerWindow (void) +{ + GtkWidget *main_hbox; + GtkWidget *vbox1, *vbox2, *vbox3; + GtkWidget *hbox1; + GtkWidget *vbox; + GtkWidget *hbox; + GtkWidget *label; + GtkWidget *button; + GtkWidget *scroll; + GtkWidget *frame; + GtkWidget *entry; + GtkWidget *grid; + GtkCellRenderer *renderer; + GtkTreeViewColumn *column; + debuggerWin_t *dw; + + dw = new debuggerWin_t; + + debuggerWinList.push_back (dw); + + dw->win = gtk_dialog_new_with_buttons ("6502 Debugger", + GTK_WINDOW (MainWindow), + (GtkDialogFlags) + (GTK_DIALOG_DESTROY_WITH_PARENT), + "_Close", GTK_RESPONSE_OK, + NULL); + + gtk_window_set_default_size (GTK_WINDOW (dw->win), 800, 600); + + main_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); + + dw->textview = (GtkTextView*) gtk_text_view_new(); + + gtk_text_view_set_monospace( dw->textview, TRUE ); + gtk_text_view_set_overwrite( dw->textview, TRUE ); + gtk_text_view_set_editable( dw->textview, FALSE ); + gtk_text_view_set_wrap_mode( dw->textview, GTK_WRAP_NONE ); + gtk_text_view_set_cursor_visible( dw->textview, TRUE ); + + dw->textbuf = gtk_text_view_get_buffer( dw->textview ); + + scroll = gtk_scrolled_window_new (NULL, NULL); + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), + GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS); + gtk_container_add (GTK_CONTAINER (scroll), GTK_WIDGET(dw->textview) ); + + vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1); + gtk_box_pack_start (GTK_BOX (vbox), scroll, TRUE, TRUE, 2); + gtk_box_pack_start (GTK_BOX (main_hbox), vbox, TRUE, TRUE, 2); + + vbox1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3); + hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); + + gtk_box_pack_start (GTK_BOX (vbox1), hbox1, TRUE, TRUE, 2); + + /* + * Vertical box 2 contains: + * 1. "Run" and "Step Into" Buttons + * 2. "Step Out" and "Step Over" Buttons + * 3. "Run Line" and "128 Lines" Buttons + * 4. "Seek To:" button and Address Entry Field + * 5. PC Entry Field and "Seek PC" Button + * 6. A, X, Y Register Entry Fields + */ + vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 1); + + gtk_box_pack_start (GTK_BOX (hbox1), vbox2, TRUE, TRUE, 2); + + grid = gtk_grid_new(); + + gtk_grid_set_row_homogeneous( GTK_GRID(grid), TRUE ); + gtk_grid_set_column_homogeneous( GTK_GRID(grid), TRUE ); + gtk_grid_set_row_spacing( GTK_GRID(grid), 5 ); + gtk_grid_set_column_spacing( GTK_GRID(grid), 10 ); + + gtk_grid_insert_column( GTK_GRID(grid), 0 ); + gtk_grid_insert_column( GTK_GRID(grid), 0 ); + + for (int i=0; i<5;i++) + { + gtk_grid_insert_row( GTK_GRID(grid), 0 ); + } + gtk_box_pack_start (GTK_BOX (hbox ), grid, TRUE, TRUE, 2); + gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 2); + + // Row 1 + button = gtk_button_new_with_label ("Run"); + + gtk_grid_attach( GTK_GRID(grid), button, 0, 0, 1, 1 ); + + button = gtk_button_new_with_label ("Step Into"); + + gtk_grid_attach( GTK_GRID(grid), button, 1, 0, 1, 1 ); + + // Row 2 + button = gtk_button_new_with_label ("Step Out"); + + gtk_grid_attach( GTK_GRID(grid), button, 0, 1, 1, 1 ); + + button = gtk_button_new_with_label ("Step Over"); + + gtk_grid_attach( GTK_GRID(grid), button, 1, 1, 1, 1 ); + + // Row 3 + button = gtk_button_new_with_label ("Run Line"); + + gtk_grid_attach( GTK_GRID(grid), button, 0, 2, 1, 1 ); + + button = gtk_button_new_with_label ("128 Lines"); + + gtk_grid_attach( GTK_GRID(grid), button, 1, 2, 1, 1 ); + + // Row 4 + button = gtk_button_new_with_label ("Seek To:"); + + gtk_grid_attach( GTK_GRID(grid), button, 0, 3, 1, 1 ); + + entry = gtk_entry_new (); + gtk_entry_set_max_length (GTK_ENTRY (entry), 4); + gtk_entry_set_width_chars (GTK_ENTRY (entry), 4); + + gtk_grid_attach( GTK_GRID(grid), entry, 1, 3, 1, 1 ); + + // Row 5 + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); + + label = gtk_label_new("PC:"); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2); + + dw->pc_entry = gtk_entry_new (); + gtk_entry_set_max_length (GTK_ENTRY (dw->pc_entry), 4); + gtk_entry_set_width_chars (GTK_ENTRY (dw->pc_entry), 4); + + gtk_box_pack_start (GTK_BOX (hbox), dw->pc_entry, FALSE, FALSE, 2); + + gtk_grid_attach( GTK_GRID(grid), hbox, 0, 4, 1, 1 ); + + button = gtk_button_new_with_label ("Seek PC"); + + gtk_grid_attach( GTK_GRID(grid), button, 1, 4, 1, 1 ); + + // Row 6 + grid = gtk_grid_new(); + + gtk_grid_set_row_homogeneous( GTK_GRID(grid), TRUE ); + gtk_grid_set_column_homogeneous( GTK_GRID(grid), TRUE ); + gtk_grid_set_row_spacing( GTK_GRID(grid), 5 ); + gtk_grid_set_column_spacing( GTK_GRID(grid), 10 ); + + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); + + label = gtk_label_new("A:"); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2); + + dw->A_entry = gtk_entry_new (); + gtk_entry_set_max_length (GTK_ENTRY (dw->A_entry), 2); + gtk_entry_set_width_chars (GTK_ENTRY (dw->A_entry), 2); + + gtk_box_pack_start (GTK_BOX (hbox), dw->A_entry, FALSE, FALSE, 2); + + gtk_grid_attach( GTK_GRID(grid), hbox, 0, 0, 1, 1 ); + + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); + + label = gtk_label_new("X:"); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2); + + dw->X_entry = gtk_entry_new (); + gtk_entry_set_max_length (GTK_ENTRY (dw->X_entry), 2); + gtk_entry_set_width_chars (GTK_ENTRY (dw->X_entry), 2); + + gtk_box_pack_start (GTK_BOX (hbox), dw->X_entry, FALSE, FALSE, 2); + + gtk_grid_attach( GTK_GRID(grid), hbox, 1, 0, 1, 1 ); + + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); + + label = gtk_label_new("Y:"); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2); + + dw->Y_entry = gtk_entry_new (); + gtk_entry_set_max_length (GTK_ENTRY (dw->Y_entry), 2); + gtk_entry_set_width_chars (GTK_ENTRY (dw->Y_entry), 2); + + gtk_box_pack_start (GTK_BOX (hbox), dw->Y_entry, FALSE, FALSE, 2); + + gtk_grid_attach( GTK_GRID(grid), hbox, 2, 0, 1, 1 ); + + gtk_box_pack_start (GTK_BOX (vbox2), grid, FALSE, FALSE, 2); + + // Stack Frame + frame = gtk_frame_new ("Stack"); + + dw->stackview = (GtkTextView*) gtk_text_view_new(); + + gtk_text_view_set_monospace( dw->stackview, TRUE ); + gtk_text_view_set_overwrite( dw->stackview, TRUE ); + gtk_text_view_set_editable( dw->stackview, FALSE ); + gtk_text_view_set_wrap_mode( dw->stackview, GTK_WRAP_NONE ); + gtk_text_view_set_cursor_visible( dw->stackview, TRUE ); + + dw->stackTextBuf = gtk_text_view_get_buffer( dw->stackview ); + + scroll = gtk_scrolled_window_new (NULL, NULL); + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), + GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS); + gtk_container_add (GTK_CONTAINER (scroll), GTK_WIDGET(dw->stackview) ); + + gtk_container_add (GTK_CONTAINER (frame), scroll); + + gtk_box_pack_start (GTK_BOX (vbox2), frame, TRUE, TRUE, 2); + /* + * Vertical box 3 contains: + * 1. Breakpoints Frame + * 2. Status Flags Frame + */ + vbox3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); + + gtk_box_pack_start (GTK_BOX (hbox1), vbox3, TRUE, TRUE, 2); + + /* + * Breakpoints Frame contains: + * 1. Breakpoints tree view + * 2. Add, delete, edit breakpoint button row. + * 3. Break on bad opcodes checkbox/label + */ + frame = gtk_frame_new ("Breakpoints"); + + vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3); + + gtk_container_add (GTK_CONTAINER (frame), vbox); + + gtk_box_pack_start (GTK_BOX (vbox3), frame, TRUE, TRUE, 2); + + dw->bp_store = + gtk_tree_store_new (1, G_TYPE_STRING ); + + dw->bp_tree = + gtk_tree_view_new_with_model (GTK_TREE_MODEL + (dw->bp_store)); + + renderer = gtk_cell_renderer_text_new (); + g_object_set (renderer, "family", "MonoSpace", NULL); + column = gtk_tree_view_column_new_with_attributes ("Breakpoint", renderer, + "text", 0, NULL); + gtk_tree_view_append_column (GTK_TREE_VIEW (dw->bp_tree), column); + + scroll = gtk_scrolled_window_new (NULL, NULL); + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), + GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); + gtk_container_add (GTK_CONTAINER (scroll), dw->bp_tree); + gtk_box_pack_start (GTK_BOX (vbox), scroll, TRUE, TRUE, 1); + + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3); + + gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 1); + + button = gtk_button_new_with_label ("Add"); + + gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 2); + + button = gtk_button_new_with_label ("Delete"); + + gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 2); + + button = gtk_button_new_with_label ("Edit"); + + gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 2); + + button = gtk_check_button_new_with_label("Break on Bad Opcodes"); + + gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 1); + + // Status Flags Frame + frame = gtk_frame_new ("Status Flags"); + + grid = gtk_grid_new(); + + gtk_grid_set_row_homogeneous( GTK_GRID(grid), TRUE ); + gtk_grid_set_column_homogeneous( GTK_GRID(grid), TRUE ); + gtk_grid_set_row_spacing( GTK_GRID(grid), 5 ); + gtk_grid_set_column_spacing( GTK_GRID(grid), 10 ); + + button = gtk_check_button_new_with_label("N"); + gtk_grid_attach( GTK_GRID(grid), button, 0, 0, 1, 1 ); + + button = gtk_check_button_new_with_label("V"); + gtk_grid_attach( GTK_GRID(grid), button, 1, 0, 1, 1 ); + + button = gtk_check_button_new_with_label("U"); + gtk_grid_attach( GTK_GRID(grid), button, 2, 0, 1, 1 ); + + button = gtk_check_button_new_with_label("B"); + gtk_grid_attach( GTK_GRID(grid), button, 3, 0, 1, 1 ); + + button = gtk_check_button_new_with_label("D"); + gtk_grid_attach( GTK_GRID(grid), button, 0, 1, 1, 1 ); + + button = gtk_check_button_new_with_label("I"); + gtk_grid_attach( GTK_GRID(grid), button, 1, 1, 1, 1 ); + + button = gtk_check_button_new_with_label("Z"); + gtk_grid_attach( GTK_GRID(grid), button, 2, 1, 1, 1 ); + + button = gtk_check_button_new_with_label("C"); + gtk_grid_attach( GTK_GRID(grid), button, 3, 1, 1, 1 ); + + gtk_container_add (GTK_CONTAINER (frame), grid); + + gtk_box_pack_start (GTK_BOX (vbox3), frame, FALSE, FALSE, 2); + + /* + * End Vertical Box 3 + */ + + gtk_box_pack_start (GTK_BOX (main_hbox), vbox1, TRUE, TRUE, 2); + + gtk_box_pack_start (GTK_BOX + (gtk_dialog_get_content_area + (GTK_DIALOG (dw->win))), main_hbox, TRUE, TRUE, + 0); + + g_signal_connect (dw->win, "delete-event", + G_CALLBACK (closeDebuggerWindow), dw); + g_signal_connect (dw->win, "response", + G_CALLBACK (closeDebuggerWindow), dw); + + gtk_widget_show_all (dw->win); + + return; +} diff --git a/src/drivers/sdl/debugger.h b/src/drivers/sdl/debugger.h new file mode 100644 index 00000000..de1eb3bb --- /dev/null +++ b/src/drivers/sdl/debugger.h @@ -0,0 +1,3 @@ +// debugger.h +// +void openDebuggerWindow (void); diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index eb49537c..d022b633 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -18,6 +18,7 @@ #include "icon.xpm" #include "memview.h" #include "ramwatch.h" +#include "debugger.h" #ifdef _S9XLUA_H #include "../../fceulua.h" @@ -2881,6 +2882,17 @@ static GtkWidget *CreateMenubar (GtkWidget * window) gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + //-Tools --> Debugger --------------------- + item = gtk_menu_item_new_with_label ("Debugger"); + + g_signal_connect (item, "activate", G_CALLBACK (openDebuggerWindow), + NULL); + + //gtk_widget_add_accelerator( item, "activate", accel_group, + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + //--------------------------------------- // Create Movie Menu item = gtk_menu_item_new_with_label ("Movie"); From 4c199ef4feda5d8ae7766183b0f94115f5b43990 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 23 May 2020 23:25:28 -0400 Subject: [PATCH 098/156] Added initial framework for debugger window. --- src/drivers/sdl/debugger.cpp | 150 ++++++++++++++++++++++++++++++++++- 1 file changed, 148 insertions(+), 2 deletions(-) diff --git a/src/drivers/sdl/debugger.cpp b/src/drivers/sdl/debugger.cpp index 916ed90e..31702929 100644 --- a/src/drivers/sdl/debugger.cpp +++ b/src/drivers/sdl/debugger.cpp @@ -49,11 +49,21 @@ struct debuggerWin_t GtkTextView *stackview; GtkTextBuffer *stackTextBuf; GtkTreeStore *bp_store; + GtkTreeStore *bkm_store; GtkWidget *bp_tree; + GtkWidget *bkm_tree; GtkWidget *pc_entry; GtkWidget *A_entry; GtkWidget *X_entry; GtkWidget *Y_entry; + GtkWidget *ppu_label; + GtkWidget *sprite_label; + GtkWidget *scanline_label; + GtkWidget *pixel_label; + GtkWidget *cpu_label1; + GtkWidget *cpu_label2; + GtkWidget *instr_label1; + GtkWidget *instr_label2; debuggerWin_t(void) { @@ -64,6 +74,14 @@ struct debuggerWin_t bp_tree = NULL; stackview = NULL; stackTextBuf = NULL; + ppu_label = NULL; + sprite_label = NULL; + scanline_label = NULL; + pixel_label = NULL; + cpu_label1 = NULL; + cpu_label2 = NULL; + instr_label1 = NULL; + instr_label2 = NULL; } ~debuggerWin_t(void) @@ -97,7 +115,7 @@ void openDebuggerWindow (void) { GtkWidget *main_hbox; GtkWidget *vbox1, *vbox2, *vbox3; - GtkWidget *hbox1; + GtkWidget *hbox1, *hbox2; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *label; @@ -121,7 +139,7 @@ void openDebuggerWindow (void) "_Close", GTK_RESPONSE_OK, NULL); - gtk_window_set_default_size (GTK_WINDOW (dw->win), 800, 600); + gtk_window_set_default_size (GTK_WINDOW (dw->win), 800, 800); main_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); @@ -410,6 +428,134 @@ void openDebuggerWindow (void) * End Vertical Box 3 */ + /* + * Start PPU Frame + */ + grid = gtk_grid_new(); + + gtk_grid_set_row_homogeneous( GTK_GRID(grid), TRUE ); + gtk_grid_set_column_homogeneous( GTK_GRID(grid), TRUE ); + gtk_grid_set_row_spacing( GTK_GRID(grid), 5 ); + gtk_grid_set_column_spacing( GTK_GRID(grid), 10 ); + + frame = gtk_frame_new (""); + + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 1); + vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4); + + dw->ppu_label = gtk_label_new("PPU:"); + dw->sprite_label = gtk_label_new("Sprite:"); + dw->scanline_label = gtk_label_new("Scanline:"); + dw->pixel_label = gtk_label_new("Pixel:"); + + gtk_box_pack_start (GTK_BOX (vbox), dw->ppu_label , FALSE, FALSE, 2); + gtk_box_pack_start (GTK_BOX (vbox), dw->sprite_label , FALSE, FALSE, 2); + gtk_box_pack_start (GTK_BOX (vbox), dw->scanline_label, FALSE, FALSE, 2); + gtk_box_pack_start (GTK_BOX (vbox), dw->pixel_label , FALSE, FALSE, 2); + + gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 2); + gtk_container_add (GTK_CONTAINER (frame), hbox); + + gtk_grid_attach( GTK_GRID(grid), frame, 0, 0, 1, 4 ); + /* + * End PPU Frame + */ + + /* + * Start Cycle Break Block + */ + dw->cpu_label1 = gtk_label_new("CPU Cycles:"); + dw->cpu_label2 = gtk_label_new("+(0)"); + + dw->instr_label1 = gtk_label_new("Instructions:"); + dw->instr_label2 = gtk_label_new("+(0)"); + + gtk_grid_attach( GTK_GRID(grid), dw->cpu_label1, 1, 0, 1, 1 ); + gtk_grid_attach( GTK_GRID(grid), dw->cpu_label2, 2, 0, 1, 1 ); + gtk_grid_attach( GTK_GRID(grid), dw->instr_label1, 1, 2, 1, 1 ); + gtk_grid_attach( GTK_GRID(grid), dw->instr_label2, 2, 2, 1, 1 ); + + button = gtk_check_button_new_with_label("Break when exceed"); + gtk_grid_attach( GTK_GRID(grid), button, 1, 1, 1, 1 ); + entry = gtk_entry_new (); + gtk_grid_attach( GTK_GRID(grid), entry, 2, 1, 1, 1 ); + + button = gtk_check_button_new_with_label("Break when exceed"); + gtk_grid_attach( GTK_GRID(grid), button, 1, 3, 1, 1 ); + entry = gtk_entry_new (); + gtk_grid_attach( GTK_GRID(grid), entry, 2, 3, 1, 1 ); + + gtk_box_pack_start (GTK_BOX (vbox1), grid, FALSE, FALSE, 2); + /* + * End Cycle Break Block + */ + + /* + * Start Address Bookmarks + */ + hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); + + frame = gtk_frame_new ("Address Bookmarks"); + + vbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 1); + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); + + gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 1); + + gtk_container_add (GTK_CONTAINER (frame), vbox); + + dw->bkm_store = + gtk_tree_store_new (1, G_TYPE_STRING ); + + dw->bkm_tree = + gtk_tree_view_new_with_model (GTK_TREE_MODEL + (dw->bkm_store)); + + renderer = gtk_cell_renderer_text_new (); + g_object_set (renderer, "family", "MonoSpace", NULL); + column = gtk_tree_view_column_new_with_attributes ("Bookmarks", renderer, + "text", 0, NULL); + gtk_tree_view_append_column (GTK_TREE_VIEW (dw->bkm_tree), column); + + scroll = gtk_scrolled_window_new (NULL, NULL); + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), + GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); + gtk_container_add (GTK_CONTAINER (scroll), dw->bkm_tree); + gtk_box_pack_start (GTK_BOX (hbox), scroll, TRUE, TRUE, 1); + + vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4); + gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 1); + entry = gtk_entry_new (); + gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 2); + button = gtk_button_new_with_label ("Add"); + gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 2); + button = gtk_button_new_with_label ("Delete"); + gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 2); + button = gtk_button_new_with_label ("Name"); + gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 2); + + gtk_box_pack_start (GTK_BOX (hbox2), frame, TRUE, TRUE, 2); + + vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4); + gtk_box_pack_start (GTK_BOX (hbox2), vbox, FALSE, FALSE, 2); + + button = gtk_button_new_with_label ("Reset Counters"); + gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 2); + button = gtk_check_button_new_with_label("ROM Offsets"); + gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 2); + button = gtk_check_button_new_with_label("Symbolic Debug"); + gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 2); + button = gtk_check_button_new_with_label("Register Names"); + gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 2); + button = gtk_button_new_with_label ("Reload Symbols"); + gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 2); + button = gtk_button_new_with_label ("ROM Patcher"); + gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 2); + + gtk_box_pack_start (GTK_BOX (vbox1), hbox2, TRUE, TRUE, 2); + /* + * End Address Bookmarks + */ gtk_box_pack_start (GTK_BOX (main_hbox), vbox1, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX From df236e3628babde4be950837b0269f3998512385 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sun, 24 May 2020 11:06:31 -0400 Subject: [PATCH 099/156] Added framework for breakpoint add/edit window. --- src/drivers/sdl/debugger.cpp | 372 +++++++++++++++++++++++++++++++++++ 1 file changed, 372 insertions(+) diff --git a/src/drivers/sdl/debugger.cpp b/src/drivers/sdl/debugger.cpp index 31702929..d49a90ec 100644 --- a/src/drivers/sdl/debugger.cpp +++ b/src/drivers/sdl/debugger.cpp @@ -64,6 +64,20 @@ struct debuggerWin_t GtkWidget *cpu_label2; GtkWidget *instr_label1; GtkWidget *instr_label2; + GtkWidget *bp_start_entry; + GtkWidget *bp_end_entry; + GtkWidget *bp_read_chkbox; + GtkWidget *bp_write_chkbox; + GtkWidget *bp_execute_chkbox; + GtkWidget *bp_enable_chkbox; + GtkWidget *bp_forbid_chkbox; + GtkWidget *bp_cond_entry; + GtkWidget *bp_name_entry; + GtkWidget *cpu_radio_btn; + GtkWidget *ppu_radio_btn; + GtkWidget *sprite_radio_btn; + + int dialog_op; debuggerWin_t(void) { @@ -82,16 +96,371 @@ struct debuggerWin_t cpu_label2 = NULL; instr_label1 = NULL; instr_label2 = NULL; + bp_start_entry = NULL; + bp_end_entry = NULL; + bp_cond_entry = NULL; + bp_name_entry = NULL; + bp_read_chkbox = NULL; + bp_write_chkbox = NULL; + bp_execute_chkbox = NULL; + bp_enable_chkbox = NULL; + bp_forbid_chkbox = NULL; + cpu_radio_btn = NULL; + ppu_radio_btn = NULL; + sprite_radio_btn = NULL; + dialog_op = 0; } ~debuggerWin_t(void) { } + + void bpListUpdate(void); }; static std::list debuggerWinList; + +void debuggerWin_t::bpListUpdate(void) +{ + GtkTreeIter iter; + char line[256], addrStr[32], flags[16]; + + gtk_tree_store_clear( bp_store ); + + for (int i=0; i 0 ) + { + sprintf( addrStr, "$%04X-%04X:", watchpoint[i].address, watchpoint[i].endaddress ); + } + else + { + sprintf( addrStr, "$%04X:", watchpoint[i].address ); + } + + flags[0] = (watchpoint[i].flags & WP_E) ? 'E' : '-'; + + if ( watchpoint[i].flags & BT_P ) + { + flags[1] = 'P'; + } + else if ( watchpoint[i].flags & BT_S ) + { + flags[1] = 'S'; + } + else + { + flags[1] = 'C'; + } + + flags[2] = (watchpoint[i].flags & WP_R) ? 'R' : '-'; + flags[3] = (watchpoint[i].flags & WP_W) ? 'W' : '-'; + flags[4] = (watchpoint[i].flags & WP_X) ? 'X' : '-'; + flags[5] = (watchpoint[i].flags & WP_F) ? 'F' : '-'; + flags[6] = 0; + + strcpy( line, addrStr ); + strcat( line, flags ); + + if (watchpoint[i].desc ) + { + strcat( line, " "); + strcat( line, watchpoint[i].desc); + strcat( line, " "); + } + + if (watchpoint[i].condText ) + { + strcat( line, " Condition:"); + strcat( line, watchpoint[i].condText); + strcat( line, " "); + } + gtk_tree_store_set( bp_store, &iter, 0, line, -1 ); + } + +} + +static void handleDialogResponse (GtkWidget * w, gint response_id, debuggerWin_t * dw) +{ + //printf("Response %i\n", response_id ); + + if ( response_id == GTK_RESPONSE_OK ) + { + const char *txt; + + ////printf("Reponse OK\n"); + switch ( dw->dialog_op ) + { + case 1: // Breakpoint Add + { + int start_addr = -1, end_addr = -1, type = 0, enable = 1;; + const char *name; + const char *cond; + + txt = gtk_entry_get_text( GTK_ENTRY( dw->bp_start_entry ) ); + + if ( txt[0] != 0 ) + { + start_addr = strtol( txt, NULL, 16 ); + } + + txt = gtk_entry_get_text( GTK_ENTRY( dw->bp_end_entry ) ); + + if ( txt[0] != 0 ) + { + end_addr = strtol( txt, NULL, 16 ); + } + + if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( dw->cpu_radio_btn ) ) ) + { + type |= BT_C; + } + else if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( dw->ppu_radio_btn ) ) ) + { + type |= BT_P; + } + else if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( dw->sprite_radio_btn ) ) ) + { + type |= BT_S; + } + + if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( dw->bp_read_chkbox ) ) ) + { + type |= WP_R; + } + + if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( dw->bp_write_chkbox ) ) ) + { + type |= WP_W; + } + + if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( dw->bp_execute_chkbox ) ) ) + { + type |= WP_X; + } + + //this overrides all + if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( dw->bp_forbid_chkbox ) ) ) + { + type = WP_F; + } + + enable = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( dw->bp_enable_chkbox ) ); + + name = gtk_entry_get_text( GTK_ENTRY( dw->bp_name_entry ) ); + cond = gtk_entry_get_text( GTK_ENTRY( dw->bp_cond_entry ) ); + + if ( (start_addr >= 0) && (numWPs < 64) ) + { + unsigned int retval; + + retval = NewBreak( name, start_addr, end_addr, type, cond, numWPs, enable); + + if ( (retval == 1) || (retval == 2) ) + { + printf("Breakpoint Add Failed\n"); + } + else + { + numWPs++; + + dw->bpListUpdate(); + } + } + } + break; + } + + + //if ( txt != NULL ) + //{ + // //printf("Text: '%s'\n", txt ); + // switch (mv->dialog_op) + // { + // case 1: + // if ( isxdigit(txt[0]) ) + // { // Address is always treated as hex number + // mv->gotoLocation( strtol( txt, NULL, 16 ) ); + // } + // break; + // case 2: + // if ( isdigit(txt[0]) ) + // { // Value is numerical + // mv->writeMem( mv->selAddr, strtol( txt, NULL, 0 ) ); + // } + // else if ( (txt[0] == '\'') && (txt[2] == '\'') ) + // { // Byte to be written is expressed as ASCII character + // mv->writeMem( mv->selAddr, txt[1] ); + // } + // break; + // } + //} + } + //else if ( response_id == GTK_RESPONSE_CANCEL ) + //{ + // printf("Reponse Cancel\n"); + //} + gtk_widget_destroy (w); + +} + +static void closeDialogWindow (GtkWidget * w, GdkEvent * e, debuggerWin_t * dw) +{ + gtk_widget_destroy (w); +} + +static void create_breakpoint_dialog( int index, debuggerWin_t * dw ) +{ + GtkWidget *win; + GtkWidget *vbox; + GtkWidget *hbox; + GtkWidget *vbox1; + GtkWidget *label; + GtkWidget *frame; + GtkWidget *grid; + + if ( index < 0 ) + { + win = gtk_dialog_new_with_buttons ("Add Breakpoint", + GTK_WINDOW (dw->win), + (GtkDialogFlags) + (GTK_DIALOG_DESTROY_WITH_PARENT), + "_Cancel", GTK_RESPONSE_CANCEL, + "_Add", GTK_RESPONSE_OK, NULL); + } + else + { + win = gtk_dialog_new_with_buttons ("Edit Breakpoint", + GTK_WINDOW (dw->win), + (GtkDialogFlags) + (GTK_DIALOG_DESTROY_WITH_PARENT), + "_Cancel", GTK_RESPONSE_CANCEL, + "_Edit", GTK_RESPONSE_OK, NULL); + } + + gtk_dialog_set_default_response( GTK_DIALOG(win), GTK_RESPONSE_OK ); + + vbox1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4); + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5); + + // Adress entry fields + label = gtk_label_new("Address:"); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2); + + dw->bp_start_entry = gtk_entry_new (); + gtk_entry_set_max_length (GTK_ENTRY (dw->bp_start_entry), 4); + gtk_entry_set_width_chars (GTK_ENTRY (dw->bp_start_entry), 4); + + gtk_box_pack_start (GTK_BOX (hbox), dw->bp_start_entry, FALSE, FALSE, 2); + + label = gtk_label_new("-"); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2); + + dw->bp_end_entry = gtk_entry_new (); + gtk_entry_set_max_length (GTK_ENTRY (dw->bp_end_entry), 4); + gtk_entry_set_width_chars (GTK_ENTRY (dw->bp_end_entry), 4); + + gtk_box_pack_start (GTK_BOX (hbox), dw->bp_end_entry, FALSE, FALSE, 2); + + dw->bp_forbid_chkbox = gtk_check_button_new_with_label("Forbid"); + gtk_box_pack_start (GTK_BOX (hbox), dw->bp_forbid_chkbox, FALSE, FALSE, 2); + + gtk_box_pack_start (GTK_BOX (vbox1), hbox, FALSE, FALSE, 2); + + // flags frame + frame = gtk_frame_new (""); + gtk_box_pack_start (GTK_BOX (vbox1), frame, FALSE, FALSE, 2); + + vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); + + dw->bp_read_chkbox = gtk_check_button_new_with_label("Read"); + dw->bp_write_chkbox = gtk_check_button_new_with_label("Write"); + dw->bp_execute_chkbox = gtk_check_button_new_with_label("Execute"); + dw->bp_enable_chkbox = gtk_check_button_new_with_label("Enable"); + + gtk_box_pack_start (GTK_BOX (hbox), dw->bp_read_chkbox , FALSE, FALSE, 2); + gtk_box_pack_start (GTK_BOX (hbox), dw->bp_write_chkbox , FALSE, FALSE, 2); + gtk_box_pack_start (GTK_BOX (hbox), dw->bp_execute_chkbox, FALSE, FALSE, 2); + gtk_box_pack_start (GTK_BOX (hbox), dw->bp_enable_chkbox , FALSE, FALSE, 2); + + gtk_box_pack_start (GTK_BOX (vbox), hbox , FALSE, FALSE, 2); + + gtk_container_add (GTK_CONTAINER (frame), vbox); + + frame = gtk_frame_new ("Memory"); + gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 2); + + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3); + + dw->cpu_radio_btn = gtk_radio_button_new_with_label (NULL, "CPU"); + dw->ppu_radio_btn = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON(dw->cpu_radio_btn), "PPU"); + dw->sprite_radio_btn = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON(dw->cpu_radio_btn), "Sprite"); + + gtk_box_pack_start (GTK_BOX (hbox), dw->cpu_radio_btn , TRUE, TRUE, 2); + gtk_box_pack_start (GTK_BOX (hbox), dw->ppu_radio_btn , TRUE, TRUE, 2); + gtk_box_pack_start (GTK_BOX (hbox), dw->sprite_radio_btn, TRUE, TRUE, 2); + + gtk_container_add (GTK_CONTAINER (frame), hbox); + + grid = gtk_grid_new(); + + gtk_grid_set_row_homogeneous( GTK_GRID(grid), TRUE ); + gtk_grid_set_column_homogeneous( GTK_GRID(grid), TRUE ); + gtk_grid_set_row_spacing( GTK_GRID(grid), 5 ); + gtk_grid_set_column_spacing( GTK_GRID(grid), 10 ); + + label = gtk_label_new("Condition:"); + gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1 ); + + label = gtk_label_new("Name:"); + gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1 ); + + dw->bp_cond_entry = gtk_entry_new (); + dw->bp_name_entry = gtk_entry_new (); + + gtk_grid_attach (GTK_GRID (grid), dw->bp_cond_entry, 1, 0, 3, 1 ); + gtk_grid_attach (GTK_GRID (grid), dw->bp_name_entry, 1, 1, 3, 1 ); + + gtk_box_pack_start (GTK_BOX (vbox1), grid, FALSE, FALSE, 2); + + gtk_box_pack_start (GTK_BOX + (gtk_dialog_get_content_area + (GTK_DIALOG (win))), vbox1, TRUE, TRUE, 1); + + gtk_widget_show_all (win); + + g_signal_connect (win, "delete-event", + G_CALLBACK (closeDialogWindow), dw); + g_signal_connect (win, "response", + G_CALLBACK (handleDialogResponse), dw); + +} + +static void addBreakpointCB (GtkButton * button, debuggerWin_t * dw) +{ + dw->dialog_op = 1; + + create_breakpoint_dialog( -1, dw ); +} + +//this code enters the debugger when a breakpoint was hit +void FCEUD_DebugBreakpoint(int bp_num) +{ + + //std::list < debuggerWin_t * >::iterator it; + + //for (it = debuggerWinList.begin (); it != debuggerWinList.end (); it++) + //{ + + //} + +} + static void closeDebuggerWindow (GtkWidget * w, GdkEvent * e, debuggerWin_t * dw) { std::list < debuggerWin_t * >::iterator it; @@ -372,6 +741,9 @@ void openDebuggerWindow (void) button = gtk_button_new_with_label ("Add"); + g_signal_connect (button, "clicked", + G_CALLBACK (addBreakpointCB), (gpointer) dw); + gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 2); button = gtk_button_new_with_label ("Delete"); From 613dd479d447876fa73b78e04332ae2eadeb0a79 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sun, 24 May 2020 12:50:13 -0400 Subject: [PATCH 100/156] Added logic to set values for debugger window register displays. --- src/drivers/sdl/debugger.cpp | 132 +++++++++++++++++++++++++++++------ 1 file changed, 112 insertions(+), 20 deletions(-) diff --git a/src/drivers/sdl/debugger.cpp b/src/drivers/sdl/debugger.cpp index d49a90ec..1bc7529e 100644 --- a/src/drivers/sdl/debugger.cpp +++ b/src/drivers/sdl/debugger.cpp @@ -25,6 +25,7 @@ #include "../../fds.h" #include "../../cart.h" #include "../../ines.h" +#include "../../x6502.h" #include "../common/configSys.h" #include "sdl.h" @@ -56,6 +57,15 @@ struct debuggerWin_t GtkWidget *A_entry; GtkWidget *X_entry; GtkWidget *Y_entry; + GtkWidget *P_N_chkbox; + GtkWidget *P_V_chkbox; + GtkWidget *P_U_chkbox; + GtkWidget *P_B_chkbox; + GtkWidget *P_D_chkbox; + GtkWidget *P_I_chkbox; + GtkWidget *P_Z_chkbox; + GtkWidget *P_C_chkbox; + GtkWidget *stack_frame; GtkWidget *ppu_label; GtkWidget *sprite_label; GtkWidget *scanline_label; @@ -108,6 +118,15 @@ struct debuggerWin_t cpu_radio_btn = NULL; ppu_radio_btn = NULL; sprite_radio_btn = NULL; + stack_frame = NULL; + P_N_chkbox = NULL; + P_V_chkbox = NULL; + P_U_chkbox = NULL; + P_B_chkbox = NULL; + P_D_chkbox = NULL; + P_I_chkbox = NULL; + P_Z_chkbox = NULL; + P_C_chkbox = NULL; dialog_op = 0; } @@ -117,6 +136,8 @@ struct debuggerWin_t } void bpListUpdate(void); + void updateViewPort(void); + void updateRegisterView(void); }; static std::list debuggerWinList; @@ -184,6 +205,75 @@ void debuggerWin_t::bpListUpdate(void) } +void debuggerWin_t::updateRegisterView(void) +{ + int stackPtr; + char stmp[32]; + std::string stackLine; + + sprintf( stmp, "%04X", X.PC ); + + gtk_entry_set_text( GTK_ENTRY(pc_entry), stmp ); + + sprintf( stmp, "%02X", X.A ); + + gtk_entry_set_text( GTK_ENTRY(A_entry), stmp ); + + sprintf( stmp, "%02X", X.X ); + + gtk_entry_set_text( GTK_ENTRY(X_entry), stmp ); + + sprintf( stmp, "%02X", X.Y ); + + gtk_entry_set_text( GTK_ENTRY(Y_entry), stmp ); + + gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( P_N_chkbox ), (X.P & N_FLAG) ? TRUE : FALSE ); + gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( P_V_chkbox ), (X.P & V_FLAG) ? TRUE : FALSE ); + gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( P_U_chkbox ), (X.P & U_FLAG) ? TRUE : FALSE ); + gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( P_B_chkbox ), (X.P & B_FLAG) ? TRUE : FALSE ); + gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( P_D_chkbox ), (X.P & D_FLAG) ? TRUE : FALSE ); + gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( P_I_chkbox ), (X.P & I_FLAG) ? TRUE : FALSE ); + gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( P_Z_chkbox ), (X.P & Z_FLAG) ? TRUE : FALSE ); + gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( P_C_chkbox ), (X.P & C_FLAG) ? TRUE : FALSE ); + + stackPtr = X.S | 0x0100; + + sprintf( stmp, "Stack: %04X", stackPtr ); + gtk_frame_set_label( GTK_FRAME(stack_frame), stmp ); + + stackPtr++; + + if ( stackPtr <= 0x01FF ) + { + sprintf( stmp, "%02X", GetMem(stackPtr) ); + + stackLine.assign( stmp ); + + for (int i = 1; i < 128; i++) + { + //tmp = ((tmp+1)|0x0100)&0x01FF; //increment and fix pointer to $0100-$01FF range + stackPtr++; + if (stackPtr > 0x1FF) + break; + if ((i & 7) == 0) + sprintf( stmp, ",\r\n%02X", GetMem(stackPtr) ); + else + sprintf( stmp, ",%02X", GetMem(stackPtr) ); + + stackLine.append( stmp ); + } + } + + gtk_text_buffer_set_text( stackTextBuf, stackLine.c_str(), -1 ) ; + +} + +void debuggerWin_t::updateViewPort(void) +{ + updateRegisterView(); + +} + static void handleDialogResponse (GtkWidget * w, gint response_id, debuggerWin_t * dw) { //printf("Response %i\n", response_id ); @@ -615,7 +705,7 @@ void openDebuggerWindow (void) gtk_entry_set_max_length (GTK_ENTRY (dw->pc_entry), 4); gtk_entry_set_width_chars (GTK_ENTRY (dw->pc_entry), 4); - gtk_box_pack_start (GTK_BOX (hbox), dw->pc_entry, FALSE, FALSE, 2); + gtk_box_pack_start (GTK_BOX (hbox), dw->pc_entry, TRUE, TRUE, 2); gtk_grid_attach( GTK_GRID(grid), hbox, 0, 4, 1, 1 ); @@ -673,7 +763,7 @@ void openDebuggerWindow (void) gtk_box_pack_start (GTK_BOX (vbox2), grid, FALSE, FALSE, 2); // Stack Frame - frame = gtk_frame_new ("Stack"); + dw->stack_frame = gtk_frame_new ("Stack"); dw->stackview = (GtkTextView*) gtk_text_view_new(); @@ -690,9 +780,9 @@ void openDebuggerWindow (void) GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS); gtk_container_add (GTK_CONTAINER (scroll), GTK_WIDGET(dw->stackview) ); - gtk_container_add (GTK_CONTAINER (frame), scroll); + gtk_container_add (GTK_CONTAINER (dw->stack_frame), scroll); - gtk_box_pack_start (GTK_BOX (vbox2), frame, TRUE, TRUE, 2); + gtk_box_pack_start (GTK_BOX (vbox2), dw->stack_frame, TRUE, TRUE, 2); /* * Vertical box 3 contains: * 1. Breakpoints Frame @@ -768,29 +858,29 @@ void openDebuggerWindow (void) gtk_grid_set_row_spacing( GTK_GRID(grid), 5 ); gtk_grid_set_column_spacing( GTK_GRID(grid), 10 ); - button = gtk_check_button_new_with_label("N"); - gtk_grid_attach( GTK_GRID(grid), button, 0, 0, 1, 1 ); + dw->P_N_chkbox = gtk_check_button_new_with_label("N"); + gtk_grid_attach( GTK_GRID(grid), dw->P_N_chkbox, 0, 0, 1, 1 ); - button = gtk_check_button_new_with_label("V"); - gtk_grid_attach( GTK_GRID(grid), button, 1, 0, 1, 1 ); + dw->P_V_chkbox = gtk_check_button_new_with_label("V"); + gtk_grid_attach( GTK_GRID(grid), dw->P_V_chkbox, 1, 0, 1, 1 ); - button = gtk_check_button_new_with_label("U"); - gtk_grid_attach( GTK_GRID(grid), button, 2, 0, 1, 1 ); + dw->P_U_chkbox = gtk_check_button_new_with_label("U"); + gtk_grid_attach( GTK_GRID(grid), dw->P_U_chkbox, 2, 0, 1, 1 ); - button = gtk_check_button_new_with_label("B"); - gtk_grid_attach( GTK_GRID(grid), button, 3, 0, 1, 1 ); + dw->P_B_chkbox = gtk_check_button_new_with_label("B"); + gtk_grid_attach( GTK_GRID(grid), dw->P_B_chkbox, 3, 0, 1, 1 ); - button = gtk_check_button_new_with_label("D"); - gtk_grid_attach( GTK_GRID(grid), button, 0, 1, 1, 1 ); + dw->P_D_chkbox = gtk_check_button_new_with_label("D"); + gtk_grid_attach( GTK_GRID(grid), dw->P_D_chkbox, 0, 1, 1, 1 ); - button = gtk_check_button_new_with_label("I"); - gtk_grid_attach( GTK_GRID(grid), button, 1, 1, 1, 1 ); + dw->P_I_chkbox = gtk_check_button_new_with_label("I"); + gtk_grid_attach( GTK_GRID(grid), dw->P_I_chkbox, 1, 1, 1, 1 ); - button = gtk_check_button_new_with_label("Z"); - gtk_grid_attach( GTK_GRID(grid), button, 2, 1, 1, 1 ); + dw->P_Z_chkbox = gtk_check_button_new_with_label("Z"); + gtk_grid_attach( GTK_GRID(grid), dw->P_Z_chkbox, 2, 1, 1, 1 ); - button = gtk_check_button_new_with_label("C"); - gtk_grid_attach( GTK_GRID(grid), button, 3, 1, 1, 1 ); + dw->P_C_chkbox = gtk_check_button_new_with_label("C"); + gtk_grid_attach( GTK_GRID(grid), dw->P_C_chkbox, 3, 1, 1, 1 ); gtk_container_add (GTK_CONTAINER (frame), grid); @@ -942,5 +1032,7 @@ void openDebuggerWindow (void) gtk_widget_show_all (dw->win); + dw->updateViewPort(); + return; } From 9f009a18507232d8f9d8eddb3e3d75f6593db051 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sun, 24 May 2020 21:10:10 -0400 Subject: [PATCH 101/156] Successful test of basic debugger functions. --- SConstruct | 2 +- src/debug.cpp | 4 +- src/drivers/sdl/debugger.cpp | 527 +++++++++++++++++++++++++++++++++-- src/ppu.cpp | 6 + 4 files changed, 512 insertions(+), 27 deletions(-) diff --git a/SConstruct b/SConstruct index 86133ba5..a5e5ec1c 100644 --- a/SConstruct +++ b/SConstruct @@ -186,7 +186,7 @@ else: if env['OPENGL'] and conf.CheckLibWithHeader('GL', 'GL/gl.h', 'c', autoadd=1): conf.env.Append(CCFLAGS = "-DOPENGL") - conf.env.Append(CPPDEFINES = ['PSS_STYLE=1']) + conf.env.Append(CPPDEFINES = ['PSS_STYLE=1',"FCEUDEF_DEBUGGER"]) env = conf.Finish() diff --git a/src/debug.cpp b/src/debug.cpp index 04a7cf73..c88e581a 100644 --- a/src/debug.cpp +++ b/src/debug.cpp @@ -565,9 +565,9 @@ void BreakHit(int bp_num) { FCEUI_SetEmulationPaused(EMULATIONPAUSED_PAUSED); //mbg merge 7/19/06 changed to use EmulationPaused() -#ifdef WIN32 +//#ifdef WIN32 FCEUD_DebugBreakpoint(bp_num); -#endif +//#endif } int StackAddrBackup; diff --git a/src/drivers/sdl/debugger.cpp b/src/drivers/sdl/debugger.cpp index 1bc7529e..d43e7c80 100644 --- a/src/drivers/sdl/debugger.cpp +++ b/src/drivers/sdl/debugger.cpp @@ -25,6 +25,7 @@ #include "../../fds.h" #include "../../cart.h" #include "../../ines.h" +#include "../../asm.h" #include "../../x6502.h" #include "../common/configSys.h" @@ -88,6 +89,8 @@ struct debuggerWin_t GtkWidget *sprite_radio_btn; int dialog_op; + int bpEditIdx; + char displayROMoffsets; debuggerWin_t(void) { @@ -128,6 +131,8 @@ struct debuggerWin_t P_Z_chkbox = NULL; P_C_chkbox = NULL; dialog_op = 0; + bpEditIdx = -1; + displayROMoffsets = 0; } ~debuggerWin_t(void) @@ -138,10 +143,55 @@ struct debuggerWin_t void bpListUpdate(void); void updateViewPort(void); void updateRegisterView(void); + void updateAssemblyView(void); + int get_bpList_selrow(void); }; static std::list debuggerWinList; +int debuggerWin_t::get_bpList_selrow(void) +{ + int retval = -1, numListRows; + GList *selListRows, *tmpList; + GtkTreeModel *model = NULL; + GtkTreeSelection *treeSel; + + treeSel = + gtk_tree_view_get_selection (GTK_TREE_VIEW(bp_tree) ); + + numListRows = gtk_tree_selection_count_selected_rows (treeSel); + + if (numListRows == 0) + { + return retval; + } + //printf("Number of Rows Selected: %i\n", numListRows ); + + selListRows = gtk_tree_selection_get_selected_rows (treeSel, &model); + + tmpList = selListRows; + + while (tmpList) + { + int depth; + int *indexArray; + GtkTreePath *path = (GtkTreePath *) tmpList->data; + + depth = gtk_tree_path_get_depth (path); + indexArray = gtk_tree_path_get_indices (path); + + if (depth > 0) + { + retval = indexArray[0]; + break; + } + tmpList = tmpList->next; + } + + g_list_free_full (selListRows, (GDestroyNotify) gtk_tree_path_free); + + return retval; +} void debuggerWin_t::bpListUpdate(void) { @@ -266,11 +316,191 @@ void debuggerWin_t::updateRegisterView(void) gtk_text_buffer_set_text( stackTextBuf, stackLine.c_str(), -1 ) ; + // update counters + int64 counter_value = timestampbase + (uint64)timestamp - total_cycles_base; + if (counter_value < 0) // sanity check + { + ResetDebugStatisticsCounters(); + counter_value = 0; + } + sprintf( stmp, "CPU Cycles: %llu", counter_value); + + gtk_label_set_text( GTK_LABEL(cpu_label1), stmp ); + + //SetDlgItemText(hDebug, IDC_DEBUGGER_VAL_CYCLES_COUNT, str); + counter_value = timestampbase + (uint64)timestamp - delta_cycles_base; + if (counter_value < 0) // sanity check + { + ResetDebugStatisticsCounters(); + counter_value = 0; + } + sprintf(stmp, "(+%llu)", counter_value); + + gtk_label_set_text( GTK_LABEL(cpu_label2), stmp ); + + sprintf(stmp, "Instructions: %llu", total_instructions); + gtk_label_set_text( GTK_LABEL(instr_label1), stmp ); + + sprintf(stmp, "(+%llu)", delta_instructions); + gtk_label_set_text( GTK_LABEL(instr_label2), stmp ); + +} + +// This function is for "smart" scrolling... +// it attempts to scroll up one line by a whole instruction +static int InstructionUp(int from) +{ + int i = std::min(16, from), j; + + while (i > 0) + { + j = i; + while (j > 0) + { + if (GetMem(from - j) == 0x00) + break; // BRK usually signifies data + if (opsize[GetMem(from - j)] == 0) + break; // invalid instruction! + if (opsize[GetMem(from - j)] > j) + break; // instruction is too long! + if (opsize[GetMem(from - j)] == j) + return (from - j); // instruction is just right! :D + j -= opsize[GetMem(from - j)]; + } + i--; + } + + // if we get here, no suitable instruction was found + if ((from >= 2) && (GetMem(from - 2) == 0x00)) + return (from - 2); // if a BRK instruction is possible, use that + if (from) + return (from - 1); // else, scroll up one byte + return 0; // of course, if we can't scroll up, just return 0! +} +static int InstructionDown(int from) +{ + int tmp = opsize[GetMem(from)]; + if ((tmp)) + return from + tmp; + else + return from + 1; // this is data or undefined instruction +} + +void debuggerWin_t::updateAssemblyView(void) +{ + int starting_address, start_address_lp, addr, size; + int instruction_addr; + std::string line, block; + char chr[64]; + uint8 opcode[3]; + const char *disassemblyText = NULL; + + start_address_lp = starting_address = X.PC; + + for (int i=0; i < 32; i++) + { + //printf("%i: Start Address: 0x%04X \n", i, start_address_lp ); + + starting_address = InstructionUp( start_address_lp ); + + if ( starting_address == start_address_lp ) + { + break; + } + start_address_lp = starting_address; + } + + addr = starting_address; + + for (int i=0; i < 64; i++) + { + line.clear(); + + // PC pointer + if (addr > 0xFFFF) break; + + instruction_addr = addr; + + if (addr == X.PC) + { + line.assign(">"); + } + else + { + line.assign(" "); + } + + if (addr >= 0x8000) + { + if (displayROMoffsets && (GetNesFileAddress(addr) != -1) ) + { + sprintf(chr, " %06X: ", GetNesFileAddress(addr)); + } + else + { + sprintf(chr, "%02X:%04X: ", getBank(addr), addr); + } + } else + { + sprintf(chr, " :%04X: ", addr); + } + line.append(chr); + + size = opsize[GetMem(addr)]; + if (size == 0) + { + sprintf(chr, "%02X UNDEFINED", GetMem(addr++)); + line.append(chr); + } else + { + if ((addr + size) > 0xFFFF) + { + while (addr < 0xFFFF) + { + sprintf(chr, "%02X OVERFLOW\n", GetMem(addr++)); + line.append(chr); + } + break; + } + for (int j = 0; j < size; j++) + { + sprintf(chr, "%02X ", opcode[j] = GetMem(addr++)); + line.append(chr); + } + while (size < 3) + { + line.append(" "); //pad output to align ASM + size++; + } + + disassemblyText = Disassemble(addr, opcode); + + if ( disassemblyText ) + { + line.append( disassemblyText ); + } + } + + // special case: an RTS opcode + if (GetMem(instruction_addr) == 0x60) + { + line.append("-------------------------"); + } + line.append("\n"); + + //printf("%s", line.c_str() ); + + block.append( line ); + } + + gtk_text_buffer_set_text( textbuf, block.c_str(), -1 ); + } void debuggerWin_t::updateViewPort(void) { updateRegisterView(); + updateAssemblyView(); } @@ -286,24 +516,13 @@ static void handleDialogResponse (GtkWidget * w, gint response_id, debuggerWin_t switch ( dw->dialog_op ) { case 1: // Breakpoint Add + case 2: // Breakpoint Edit { - int start_addr = -1, end_addr = -1, type = 0, enable = 1;; + int start_addr = -1, end_addr = -1, type = 0, enable = 1, slot; const char *name; const char *cond; - txt = gtk_entry_get_text( GTK_ENTRY( dw->bp_start_entry ) ); - - if ( txt[0] != 0 ) - { - start_addr = strtol( txt, NULL, 16 ); - } - - txt = gtk_entry_get_text( GTK_ENTRY( dw->bp_end_entry ) ); - - if ( txt[0] != 0 ) - { - end_addr = strtol( txt, NULL, 16 ); - } + slot = (dw->dialog_op == 1) ? numWPs : dw->bpEditIdx; if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( dw->cpu_radio_btn ) ) ) { @@ -318,6 +537,20 @@ static void handleDialogResponse (GtkWidget * w, gint response_id, debuggerWin_t type |= BT_S; } + txt = gtk_entry_get_text( GTK_ENTRY( dw->bp_start_entry ) ); + + if ( txt[0] != 0 ) + { + start_addr = offsetStringToInt( type, txt ); + } + + txt = gtk_entry_get_text( GTK_ENTRY( dw->bp_end_entry ) ); + + if ( txt[0] != 0 ) + { + end_addr = offsetStringToInt( type, txt ); + } + if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( dw->bp_read_chkbox ) ) ) { type |= WP_R; @@ -348,7 +581,7 @@ static void handleDialogResponse (GtkWidget * w, gint response_id, debuggerWin_t { unsigned int retval; - retval = NewBreak( name, start_addr, end_addr, type, cond, numWPs, enable); + retval = NewBreak( name, start_addr, end_addr, type, cond, slot, enable); if ( (retval == 1) || (retval == 2) ) { @@ -356,7 +589,10 @@ static void handleDialogResponse (GtkWidget * w, gint response_id, debuggerWin_t } else { - numWPs++; + if (dw->dialog_op == 1) + { + numWPs++; + } dw->bpListUpdate(); } @@ -430,6 +666,8 @@ static void create_breakpoint_dialog( int index, debuggerWin_t * dw ) (GTK_DIALOG_DESTROY_WITH_PARENT), "_Cancel", GTK_RESPONSE_CANCEL, "_Edit", GTK_RESPONSE_OK, NULL); + + dw->bpEditIdx = index; } gtk_dialog_set_default_response( GTK_DIALOG(win), GTK_RESPONSE_OK ); @@ -529,6 +767,25 @@ static void create_breakpoint_dialog( int index, debuggerWin_t * dw ) g_signal_connect (win, "response", G_CALLBACK (handleDialogResponse), dw); + if ( index >= 0 ) + { + if ( watchpoint[index].flags & BT_P ) + { + gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( dw->ppu_radio_btn ), TRUE ); + } + else if ( watchpoint[index].flags & BT_S ) + { + gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( dw->sprite_radio_btn ), TRUE ); + } + else + { + gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( dw->cpu_radio_btn ), TRUE ); + } + } + else + { + + } } static void addBreakpointCB (GtkButton * button, debuggerWin_t * dw) @@ -538,17 +795,214 @@ static void addBreakpointCB (GtkButton * button, debuggerWin_t * dw) create_breakpoint_dialog( -1, dw ); } +static void editBreakpointCB (GtkButton * button, debuggerWin_t * dw) +{ + int selRow; + + selRow = dw->get_bpList_selrow(); + + if ( selRow >= 0 ) + { + dw->dialog_op = 2; + + create_breakpoint_dialog( selRow, dw ); + } +} + +static void DeleteBreak(int sel) +{ + if(sel<0) return; + if(sel>=numWPs) return; + if (watchpoint[sel].cond) + { + freeTree(watchpoint[sel].cond); + } + if (watchpoint[sel].condText) + { + free(watchpoint[sel].condText); + } + if (watchpoint[sel].desc) + { + free(watchpoint[sel].desc); + } + // move all BP items up in the list + for (int i = sel; i < numWPs; i++) + { + watchpoint[i].address = watchpoint[i+1].address; + watchpoint[i].endaddress = watchpoint[i+1].endaddress; + watchpoint[i].flags = watchpoint[i+1].flags; +// ################################## Start of SP CODE ########################### + watchpoint[i].cond = watchpoint[i+1].cond; + watchpoint[i].condText = watchpoint[i+1].condText; + watchpoint[i].desc = watchpoint[i+1].desc; +// ################################## End of SP CODE ########################### + } + // erase last BP item + watchpoint[numWPs].address = 0; + watchpoint[numWPs].endaddress = 0; + watchpoint[numWPs].flags = 0; + watchpoint[numWPs].cond = 0; + watchpoint[numWPs].condText = 0; + watchpoint[numWPs].desc = 0; + numWPs--; +} + +static void deleteBreakpointCB (GtkButton * button, debuggerWin_t * dw) +{ + int selRow; + + selRow = dw->get_bpList_selrow(); + + if ( (selRow >= 0) && (selRow < numWPs) ) + { + DeleteBreak( selRow ); + dw->bpListUpdate(); + } +} + +static void debugRunCB (GtkButton * button, debuggerWin_t * dw) +{ + if (FCEUI_EmulationPaused()) + { + //UpdateRegs(hwndDlg); + FCEUI_ToggleEmulationPause(); + //DebuggerWasUpdated = false done in above function; + } +} + +static void debugStepIntoCB (GtkButton * button, debuggerWin_t * dw) +{ + FCEUI_Debugger().step = true; + FCEUI_SetEmulationPaused(0); +} + +static void debugStepOutCB (GtkButton * button, debuggerWin_t * dw) +{ + if (FCEUI_EmulationPaused() > 0) + { + DebuggerState &dbgstate = FCEUI_Debugger(); + //UpdateRegs(hwndDlg); + if (dbgstate.stepout) + { + printf("Step Out is currently in process.\n"); + return; + } + if (GetMem(X.PC) == 0x20) + { + dbgstate.jsrcount = 1; + } + else + { + dbgstate.jsrcount = 0; + } + dbgstate.stepout = 1; + FCEUI_SetEmulationPaused(0); + } +} + +static void debugStepOverCB (GtkButton * button, debuggerWin_t * dw) +{ + if (FCEUI_EmulationPaused()) + { + //UpdateRegs(hwndDlg); + int tmp=X.PC; + uint8 opcode = GetMem(X.PC); + bool jsr = opcode==0x20; + bool call = jsr; + #ifdef BRK_3BYTE_HACK + //with this hack, treat BRK similar to JSR + if(opcode == 0x00) + { + call = true; + } + #endif + if (call) + { + if (watchpoint[64].flags) + { + printf("Step Over is currently in process.\n"); + return; + } + watchpoint[64].address = (tmp+3); + watchpoint[64].flags = WP_E|WP_X; + } + else + { + FCEUI_Debugger().step = true; + } + FCEUI_SetEmulationPaused(0); + } +} +static void debugRunLineCB (GtkButton * button, debuggerWin_t * dw) +{ + uint64 ts=timestampbase; + ts+=timestamp; + ts+=341/3; + //if (scanline == 240) vblankScanLines++; + //else vblankScanLines = 0; + FCEUI_Debugger().runline = true; + FCEUI_Debugger().runline_end_time=ts; + FCEUI_SetEmulationPaused(0); +} + +static void debugRunLine128CB (GtkButton * button, debuggerWin_t * dw) +{ + //if (FCEUI_EmulationPaused()) + //{ + // UpdateRegs(hwndDlg); + //} + FCEUI_Debugger().runline = true; + { + uint64 ts=timestampbase; + ts+=timestamp; + ts+=128*341/3; + FCEUI_Debugger().runline_end_time=ts; + //if (scanline+128 >= 240 && scanline+128 <= 257) vblankScanLines = (scanline+128)-240; + //else vblankScanLines = 0; + } + FCEUI_SetEmulationPaused(0); +} +static void romOffsetToggleCB( GtkToggleButton *togglebutton, debuggerWin_t * dw) +{ + dw->displayROMoffsets = gtk_toggle_button_get_active( togglebutton ); + + dw->updateViewPort(); + + //printf("Toggle ROM Offset: %i \n", dw->displayROMoffsets ); +} + +static void updateAllDebugWindows(void) +{ + std::list < debuggerWin_t * >::iterator it; + + for (it = debuggerWinList.begin (); it != debuggerWinList.end (); it++) + { + (*it)->updateViewPort(); + } +} + +static void winDebuggerLoopStep(void) +{ + FCEUD_UpdateInput(); + + while(gtk_events_pending()) + { + gtk_main_iteration_do(FALSE); + } +} + //this code enters the debugger when a breakpoint was hit void FCEUD_DebugBreakpoint(int bp_num) { + //printf("Breakpoint Hit: %i \n", bp_num); + + updateAllDebugWindows(); - //std::list < debuggerWin_t * >::iterator it; - - //for (it = debuggerWinList.begin (); it != debuggerWinList.end (); it++) - //{ - - //} - + while(FCEUI_EmulationPaused() && !FCEUI_EmulationFrameStepped()) + { + usleep(50000); + winDebuggerLoopStep(); + } } static void closeDebuggerWindow (GtkWidget * w, GdkEvent * e, debuggerWin_t * dw) @@ -559,7 +1013,6 @@ static void closeDebuggerWindow (GtkWidget * w, GdkEvent * e, debuggerWin_t * dw { if (dw == *it) { - //printf("Removing MemView Window %p from List\n", cw); debuggerWinList.erase (it); break; } @@ -660,28 +1113,46 @@ void openDebuggerWindow (void) // Row 1 button = gtk_button_new_with_label ("Run"); + g_signal_connect (button, "clicked", + G_CALLBACK (debugRunCB), (gpointer) dw); + gtk_grid_attach( GTK_GRID(grid), button, 0, 0, 1, 1 ); button = gtk_button_new_with_label ("Step Into"); + g_signal_connect (button, "clicked", + G_CALLBACK (debugStepIntoCB), (gpointer) dw); + gtk_grid_attach( GTK_GRID(grid), button, 1, 0, 1, 1 ); // Row 2 button = gtk_button_new_with_label ("Step Out"); + g_signal_connect (button, "clicked", + G_CALLBACK (debugStepOutCB), (gpointer) dw); + gtk_grid_attach( GTK_GRID(grid), button, 0, 1, 1, 1 ); button = gtk_button_new_with_label ("Step Over"); + g_signal_connect (button, "clicked", + G_CALLBACK (debugStepOverCB), (gpointer) dw); + gtk_grid_attach( GTK_GRID(grid), button, 1, 1, 1, 1 ); // Row 3 button = gtk_button_new_with_label ("Run Line"); + g_signal_connect (button, "clicked", + G_CALLBACK (debugRunLineCB), (gpointer) dw); + gtk_grid_attach( GTK_GRID(grid), button, 0, 2, 1, 1 ); button = gtk_button_new_with_label ("128 Lines"); + g_signal_connect (button, "clicked", + G_CALLBACK (debugRunLine128CB), (gpointer) dw); + gtk_grid_attach( GTK_GRID(grid), button, 1, 2, 1, 1 ); // Row 4 @@ -838,10 +1309,16 @@ void openDebuggerWindow (void) button = gtk_button_new_with_label ("Delete"); + g_signal_connect (button, "clicked", + G_CALLBACK (deleteBreakpointCB), (gpointer) dw); + gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 2); button = gtk_button_new_with_label ("Edit"); + g_signal_connect (button, "clicked", + G_CALLBACK (editBreakpointCB), (gpointer) dw); + gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 2); button = gtk_check_button_new_with_label("Break on Bad Opcodes"); @@ -1004,6 +1481,8 @@ void openDebuggerWindow (void) button = gtk_button_new_with_label ("Reset Counters"); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 2); button = gtk_check_button_new_with_label("ROM Offsets"); + g_signal_connect (button, "toggled", + G_CALLBACK (romOffsetToggleCB), dw); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 2); button = gtk_check_button_new_with_label("Symbolic Debug"); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 2); diff --git a/src/ppu.cpp b/src/ppu.cpp index 56466383..ca2ee0e7 100644 --- a/src/ppu.cpp +++ b/src/ppu.cpp @@ -1375,7 +1375,9 @@ static void DoLine(void) { GameHBIRQHook(); } +#ifdef WIN32 DEBUG(FCEUD_UpdateNTView(scanline, 0)); +#endif if (SpriteON) RefreshSprites(); @@ -1852,7 +1854,9 @@ int FCEUPPU_Loop(int skip) { for (scanline = 0; scanline < totalscanlines; ) { //scanline is incremented in DoLine. Evil. :/ deempcnt[deemp]++; if (scanline < 240) +#ifdef WIN32 DEBUG(FCEUD_UpdatePPUView(scanline, 1)); +#endif DoLine(); if (scanline < normalscanlines || scanline == totalscanlines) @@ -2145,8 +2149,10 @@ int FCEUX_PPU_Loop(int skip) { ppuphase = PPUPHASE_BG; if (sl != 0 && sl < 241) { // ignore the invisible +#ifdef WIN32 DEBUG(FCEUD_UpdatePPUView(scanline = yp, 1)); DEBUG(FCEUD_UpdateNTView(scanline = yp, 1)); +#endif } //hack to fix SDF ship intro screen with split. is it right? From 2755c9cdb210603067556990ed4919eaa8e40337 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sun, 24 May 2020 21:31:29 -0400 Subject: [PATCH 102/156] Added logic to allow for use of a enable checkbox to next to each breakpoint in the list --- src/drivers/sdl/debugger.cpp | 64 +++++++++++++++++++++++++++++++++--- 1 file changed, 59 insertions(+), 5 deletions(-) diff --git a/src/drivers/sdl/debugger.cpp b/src/drivers/sdl/debugger.cpp index d43e7c80..b88932b1 100644 --- a/src/drivers/sdl/debugger.cpp +++ b/src/drivers/sdl/debugger.cpp @@ -196,7 +196,7 @@ int debuggerWin_t::get_bpList_selrow(void) void debuggerWin_t::bpListUpdate(void) { GtkTreeIter iter; - char line[256], addrStr[32], flags[16]; + char line[256], addrStr[32], flags[16], enable; gtk_tree_store_clear( bp_store ); @@ -234,6 +234,8 @@ void debuggerWin_t::bpListUpdate(void) flags[5] = (watchpoint[i].flags & WP_F) ? 'F' : '-'; flags[6] = 0; + enable = (watchpoint[i].flags & WP_E) ? 1 : 0; + strcpy( line, addrStr ); strcat( line, flags ); @@ -250,7 +252,7 @@ void debuggerWin_t::bpListUpdate(void) strcat( line, watchpoint[i].condText); strcat( line, " "); } - gtk_tree_store_set( bp_store, &iter, 0, line, -1 ); + gtk_tree_store_set( bp_store, &iter, 0, enable, 1, line, -1 ); } } @@ -809,6 +811,43 @@ static void editBreakpointCB (GtkButton * button, debuggerWin_t * dw) } } +static void enableBreakpointCB (GtkCellRendererToggle * renderer, + gchar * pathStr, debuggerWin_t * dw) +{ + GtkTreePath *path; + int depth; + int *indexArray; + + path = gtk_tree_path_new_from_string (pathStr); + + if (path == NULL) + { + printf ("Error: gtk_tree_path_new_from_string failed\n"); + return; + } + + depth = gtk_tree_path_get_depth (path); + indexArray = gtk_tree_path_get_indices (path); + + if (depth > 0) + { + if ( !gtk_cell_renderer_toggle_get_active(renderer) ) + { + //printf("Toggle: %i On\n", indexArray[0] ); + watchpoint[indexArray[0]].flags |= WP_E; + } + else + { + //printf("Toggle: %i Off\n", indexArray[0] ); + watchpoint[indexArray[0]].flags &= ~WP_E; + } + } + + gtk_tree_path_free (path); + + dw->bpListUpdate(); +} + static void DeleteBreak(int sel) { if(sel<0) return; @@ -1037,6 +1076,7 @@ void openDebuggerWindow (void) GtkWidget *entry; GtkWidget *grid; GtkCellRenderer *renderer; + GtkCellRenderer *chkbox_renderer; GtkTreeViewColumn *column; debuggerWin_t *dw; @@ -1278,16 +1318,30 @@ void openDebuggerWindow (void) gtk_box_pack_start (GTK_BOX (vbox3), frame, TRUE, TRUE, 2); dw->bp_store = - gtk_tree_store_new (1, G_TYPE_STRING ); + gtk_tree_store_new (2, G_TYPE_BOOLEAN, G_TYPE_STRING ); dw->bp_tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (dw->bp_store)); + gtk_tree_view_set_grid_lines (GTK_TREE_VIEW (dw->bp_tree), + GTK_TREE_VIEW_GRID_LINES_VERTICAL); + + chkbox_renderer = gtk_cell_renderer_toggle_new (); + gtk_cell_renderer_toggle_set_activatable ((GtkCellRendererToggle *) + chkbox_renderer, TRUE); + column = gtk_tree_view_column_new_with_attributes ("Ena", + chkbox_renderer, + "active", 0, NULL); + gtk_tree_view_append_column (GTK_TREE_VIEW (dw->bp_tree), column); + + g_signal_connect (chkbox_renderer, "toggled", + G_CALLBACK (enableBreakpointCB), (void *) dw); + renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "family", "MonoSpace", NULL); - column = gtk_tree_view_column_new_with_attributes ("Breakpoint", renderer, - "text", 0, NULL); + column = gtk_tree_view_column_new_with_attributes ("Addr/Flags", renderer, + "text", 1, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (dw->bp_tree), column); scroll = gtk_scrolled_window_new (NULL, NULL); From c50b5581d67b4b573f7aae4ad72be63876f45b36 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Mon, 25 May 2020 08:11:01 -0400 Subject: [PATCH 103/156] Added logic to sync breakpoint edit window parameters to actual state upon opening. --- src/drivers/sdl/debugger.cpp | 49 +++++++++++++++++++++++++++++++++--- 1 file changed, 46 insertions(+), 3 deletions(-) diff --git a/src/drivers/sdl/debugger.cpp b/src/drivers/sdl/debugger.cpp index b88932b1..c800ae76 100644 --- a/src/drivers/sdl/debugger.cpp +++ b/src/drivers/sdl/debugger.cpp @@ -650,6 +650,7 @@ static void create_breakpoint_dialog( int index, debuggerWin_t * dw ) GtkWidget *label; GtkWidget *frame; GtkWidget *grid; + char stmp[64]; if ( index < 0 ) { @@ -685,7 +686,7 @@ static void create_breakpoint_dialog( int index, debuggerWin_t * dw ) gtk_entry_set_max_length (GTK_ENTRY (dw->bp_start_entry), 4); gtk_entry_set_width_chars (GTK_ENTRY (dw->bp_start_entry), 4); - gtk_box_pack_start (GTK_BOX (hbox), dw->bp_start_entry, FALSE, FALSE, 2); + gtk_box_pack_start (GTK_BOX (hbox), dw->bp_start_entry, TRUE, TRUE, 2); label = gtk_label_new("-"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2); @@ -694,7 +695,7 @@ static void create_breakpoint_dialog( int index, debuggerWin_t * dw ) gtk_entry_set_max_length (GTK_ENTRY (dw->bp_end_entry), 4); gtk_entry_set_width_chars (GTK_ENTRY (dw->bp_end_entry), 4); - gtk_box_pack_start (GTK_BOX (hbox), dw->bp_end_entry, FALSE, FALSE, 2); + gtk_box_pack_start (GTK_BOX (hbox), dw->bp_end_entry, TRUE, TRUE, 2); dw->bp_forbid_chkbox = gtk_check_button_new_with_label("Forbid"); gtk_box_pack_start (GTK_BOX (hbox), dw->bp_forbid_chkbox, FALSE, FALSE, 2); @@ -770,7 +771,7 @@ static void create_breakpoint_dialog( int index, debuggerWin_t * dw ) G_CALLBACK (handleDialogResponse), dw); if ( index >= 0 ) - { + { // Sync entries to current breakpoint if ( watchpoint[index].flags & BT_P ) { gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( dw->ppu_radio_btn ), TRUE ); @@ -783,6 +784,48 @@ static void create_breakpoint_dialog( int index, debuggerWin_t * dw ) { gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( dw->cpu_radio_btn ), TRUE ); } + + sprintf( stmp, "%04X", watchpoint[index].address ); + + gtk_entry_set_text (GTK_ENTRY (dw->bp_start_entry), stmp ); + + if ( watchpoint[index].endaddress > 0 ) + { + sprintf( stmp, "%04X", watchpoint[index].endaddress ); + + gtk_entry_set_text (GTK_ENTRY (dw->bp_end_entry), stmp ); + } + + if ( watchpoint[index].flags & WP_R ) + { + gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( dw->bp_read_chkbox ), TRUE ); + } + if ( watchpoint[index].flags & WP_W ) + { + gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( dw->bp_write_chkbox ), TRUE ); + } + if ( watchpoint[index].flags & WP_X ) + { + gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( dw->bp_execute_chkbox ), TRUE ); + } + if ( watchpoint[index].flags & WP_F ) + { + gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( dw->bp_forbid_chkbox ), TRUE ); + } + if ( watchpoint[index].flags & WP_E ) + { + gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( dw->bp_enable_chkbox ), TRUE ); + } + + if ( watchpoint[index].condText ) + { + gtk_entry_set_text (GTK_ENTRY (dw->bp_cond_entry), watchpoint[index].condText ); + } + + if ( watchpoint[index].desc ) + { + gtk_entry_set_text (GTK_ENTRY (dw->bp_name_entry), watchpoint[index].desc ); + } } else { From db17dc06e647d4d28176551e41fad05a61cb4b3c Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Mon, 25 May 2020 09:28:22 -0400 Subject: [PATCH 104/156] Added logic to capture asm list. --- src/drivers/sdl/debugger.cpp | 121 +++++++++++++++++++++++++++++++++-- 1 file changed, 116 insertions(+), 5 deletions(-) diff --git a/src/drivers/sdl/debugger.cpp b/src/drivers/sdl/debugger.cpp index c800ae76..2b7d5b64 100644 --- a/src/drivers/sdl/debugger.cpp +++ b/src/drivers/sdl/debugger.cpp @@ -43,6 +43,26 @@ extern Config *g_config; //******************************************************************************************************* // +struct dbg_asm_entry_t +{ + int addr; + int bank; + int rom; + int size; + uint8 opcode[3]; + + + dbg_asm_entry_t(void) + { + addr = 0; bank = 0; rom = -1; size = 0; + + for (int i=0; i<3; i++) + { + opcode[i] = 0; + } + } +}; + struct debuggerWin_t { GtkWidget *win; @@ -92,6 +112,8 @@ struct debuggerWin_t int bpEditIdx; char displayROMoffsets; + std::vector asmEntry; + debuggerWin_t(void) { win = NULL; @@ -137,9 +159,10 @@ struct debuggerWin_t ~debuggerWin_t(void) { - + asmClear(); } + void asmClear(void); void bpListUpdate(void); void updateViewPort(void); void updateRegisterView(void); @@ -149,6 +172,15 @@ struct debuggerWin_t static std::list debuggerWinList; +void debuggerWin_t::asmClear(void) +{ + for (size_t i=0; i 0xFFFF) break; + a = new dbg_asm_entry_t; + instruction_addr = addr; if (addr == X.PC) @@ -431,16 +468,20 @@ void debuggerWin_t::updateAssemblyView(void) { line.assign(" "); } + a->addr = addr; if (addr >= 0x8000) { - if (displayROMoffsets && (GetNesFileAddress(addr) != -1) ) + a->bank = getBank(addr); + a->rom = GetNesFileAddress(addr); + + if (displayROMoffsets && (a->rom != -1) ) { - sprintf(chr, " %06X: ", GetNesFileAddress(addr)); + sprintf(chr, " %06X: ", a->rom); } else { - sprintf(chr, "%02X:%04X: ", getBank(addr), addr); + sprintf(chr, "%02X:%04X: ", a->bank, addr); } } else { @@ -482,6 +523,11 @@ void debuggerWin_t::updateAssemblyView(void) line.append( disassemblyText ); } } + for (int j=0; jopcode[j] = opcode[j]; + } + a->size = size; // special case: an RTS opcode if (GetMem(instruction_addr) == 0x60) @@ -493,6 +539,8 @@ void debuggerWin_t::updateAssemblyView(void) //printf("%s", line.c_str() ); block.append( line ); + + asmEntry.push_back(a); } gtk_text_buffer_set_text( textbuf, block.c_str(), -1 ); @@ -503,7 +551,7 @@ void debuggerWin_t::updateViewPort(void) { updateRegisterView(); updateAssemblyView(); - + bpListUpdate(); } static void handleDialogResponse (GtkWidget * w, gint response_id, debuggerWin_t * dw) @@ -1044,6 +1092,66 @@ static void debugRunLine128CB (GtkButton * button, debuggerWin_t * dw) } FCEUI_SetEmulationPaused(0); } + +static gboolean +populate_context_menu (GtkWidget *popup, + debuggerWin_t * dw ) +{ + GtkWidget *menu = NULL; + GtkWidget *item; + GtkTextIter iter; + char stmp[256]; + gint cpos, lineNum; + int addr; + + g_object_get( dw->textbuf, "cursor-position", &cpos, NULL ); + + gtk_text_buffer_get_iter_at_offset( dw->textbuf, &iter, cpos ); + + lineNum = gtk_text_iter_get_line( &iter ); + + if ( (lineNum < 0) || (lineNum >= (int)dw->asmEntry.size() ) ) + { + return TRUE; + } + addr = dw->asmEntry[lineNum]->addr; + + //printf("Context Menu: CP:%i Line:%i Addr:0x%04X\n", cpos, lineNum, addr ); + + menu = gtk_menu_new (); + + sprintf( stmp, "Add Breakpoint at 0x%04X", addr ); + + item = gtk_menu_item_new_with_label( stmp ); + + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + + //g_signal_connect (item, "activate", + // G_CALLBACK (setValueCB), mv); + + gtk_menu_popup_at_pointer (GTK_MENU (menu), NULL ); + //gtk_widget_show_all (popup); + gtk_widget_show_all (menu); + + return TRUE; +} + +static gboolean +textview_button_press_cb (GtkWidget *widget, + GdkEventButton *event, + debuggerWin_t * dw ) +{ + gboolean ret = FALSE; + //printf("Press Button %i %u\n", event->type, event->button ); + + if ( event->button == 3 ) + { + ret = populate_context_menu( widget, dw ); + } + + return ret; +} + static void romOffsetToggleCB( GtkToggleButton *togglebutton, debuggerWin_t * dw) { dw->displayROMoffsets = gtk_toggle_button_get_active( togglebutton ); @@ -1146,6 +1254,9 @@ void openDebuggerWindow (void) gtk_text_view_set_wrap_mode( dw->textview, GTK_WRAP_NONE ); gtk_text_view_set_cursor_visible( dw->textview, TRUE ); + g_signal_connect (dw->textview, "button-press-event", + G_CALLBACK (textview_button_press_cb), dw); + dw->textbuf = gtk_text_view_get_buffer( dw->textview ); scroll = gtk_scrolled_window_new (NULL, NULL); From 41e1bdc592f8d34c5cf00c5004c0ff5a7f50765c Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Mon, 25 May 2020 20:06:16 -0400 Subject: [PATCH 105/156] Added logic to context menu to prefill breakpoint add popup. --- src/drivers/sdl/debugger.cpp | 121 ++++++++++++++++++----------------- 1 file changed, 61 insertions(+), 60 deletions(-) diff --git a/src/drivers/sdl/debugger.cpp b/src/drivers/sdl/debugger.cpp index 2b7d5b64..a12b0cd4 100644 --- a/src/drivers/sdl/debugger.cpp +++ b/src/drivers/sdl/debugger.cpp @@ -110,6 +110,7 @@ struct debuggerWin_t int dialog_op; int bpEditIdx; + int ctx_menu_addr; char displayROMoffsets; std::vector asmEntry; @@ -154,6 +155,7 @@ struct debuggerWin_t P_C_chkbox = NULL; dialog_op = 0; bpEditIdx = -1; + ctx_menu_addr = 0; displayROMoffsets = 0; } @@ -411,14 +413,14 @@ static int InstructionUp(int from) return (from - 1); // else, scroll up one byte return 0; // of course, if we can't scroll up, just return 0! } -static int InstructionDown(int from) -{ - int tmp = opsize[GetMem(from)]; - if ((tmp)) - return from + tmp; - else - return from + 1; // this is data or undefined instruction -} +//static int InstructionDown(int from) +//{ +// int tmp = opsize[GetMem(from)]; +// if ((tmp)) +// return from + tmp; +// else +// return from + 1; // this is data or undefined instruction +//} void debuggerWin_t::updateAssemblyView(void) { @@ -649,32 +651,10 @@ static void handleDialogResponse (GtkWidget * w, gint response_id, debuggerWin_t } } break; + default: + // Do Nothing + break; } - - - //if ( txt != NULL ) - //{ - // //printf("Text: '%s'\n", txt ); - // switch (mv->dialog_op) - // { - // case 1: - // if ( isxdigit(txt[0]) ) - // { // Address is always treated as hex number - // mv->gotoLocation( strtol( txt, NULL, 16 ) ); - // } - // break; - // case 2: - // if ( isdigit(txt[0]) ) - // { // Value is numerical - // mv->writeMem( mv->selAddr, strtol( txt, NULL, 0 ) ); - // } - // else if ( (txt[0] == '\'') && (txt[2] == '\'') ) - // { // Byte to be written is expressed as ASCII character - // mv->writeMem( mv->selAddr, txt[1] ); - // } - // break; - // } - //} } //else if ( response_id == GTK_RESPONSE_CANCEL ) //{ @@ -689,7 +669,7 @@ static void closeDialogWindow (GtkWidget * w, GdkEvent * e, debuggerWin_t * dw) gtk_widget_destroy (w); } -static void create_breakpoint_dialog( int index, debuggerWin_t * dw ) +static void create_breakpoint_dialog( int index, watchpointinfo *wp, debuggerWin_t * dw ) { GtkWidget *win; GtkWidget *vbox; @@ -702,6 +682,8 @@ static void create_breakpoint_dialog( int index, debuggerWin_t * dw ) if ( index < 0 ) { + dw->dialog_op = 1; + win = gtk_dialog_new_with_buttons ("Add Breakpoint", GTK_WINDOW (dw->win), (GtkDialogFlags) @@ -711,6 +693,8 @@ static void create_breakpoint_dialog( int index, debuggerWin_t * dw ) } else { + dw->dialog_op = 2; + win = gtk_dialog_new_with_buttons ("Edit Breakpoint", GTK_WINDOW (dw->win), (GtkDialogFlags) @@ -818,13 +802,13 @@ static void create_breakpoint_dialog( int index, debuggerWin_t * dw ) g_signal_connect (win, "response", G_CALLBACK (handleDialogResponse), dw); - if ( index >= 0 ) - { // Sync entries to current breakpoint - if ( watchpoint[index].flags & BT_P ) + if ( wp != NULL ) + { // Sync entries to passed in breakpoint + if ( wp->flags & BT_P ) { gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( dw->ppu_radio_btn ), TRUE ); } - else if ( watchpoint[index].flags & BT_S ) + else if ( wp->flags & BT_S ) { gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( dw->sprite_radio_btn ), TRUE ); } @@ -833,59 +817,62 @@ static void create_breakpoint_dialog( int index, debuggerWin_t * dw ) gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( dw->cpu_radio_btn ), TRUE ); } - sprintf( stmp, "%04X", watchpoint[index].address ); + sprintf( stmp, "%04X", wp->address ); gtk_entry_set_text (GTK_ENTRY (dw->bp_start_entry), stmp ); - if ( watchpoint[index].endaddress > 0 ) + if ( wp->endaddress > 0 ) { - sprintf( stmp, "%04X", watchpoint[index].endaddress ); + sprintf( stmp, "%04X", wp->endaddress ); gtk_entry_set_text (GTK_ENTRY (dw->bp_end_entry), stmp ); } - if ( watchpoint[index].flags & WP_R ) + if ( wp->flags & WP_R ) { gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( dw->bp_read_chkbox ), TRUE ); } - if ( watchpoint[index].flags & WP_W ) + if ( wp->flags & WP_W ) { gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( dw->bp_write_chkbox ), TRUE ); } - if ( watchpoint[index].flags & WP_X ) + if ( wp->flags & WP_X ) { gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( dw->bp_execute_chkbox ), TRUE ); } - if ( watchpoint[index].flags & WP_F ) + if ( wp->flags & WP_F ) { gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( dw->bp_forbid_chkbox ), TRUE ); } - if ( watchpoint[index].flags & WP_E ) + if ( wp->flags & WP_E ) { gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( dw->bp_enable_chkbox ), TRUE ); } - if ( watchpoint[index].condText ) + if ( wp->condText ) { - gtk_entry_set_text (GTK_ENTRY (dw->bp_cond_entry), watchpoint[index].condText ); + gtk_entry_set_text (GTK_ENTRY (dw->bp_cond_entry), wp->condText ); } - if ( watchpoint[index].desc ) + if ( wp->desc ) { - gtk_entry_set_text (GTK_ENTRY (dw->bp_name_entry), watchpoint[index].desc ); + gtk_entry_set_text (GTK_ENTRY (dw->bp_name_entry), wp->desc ); } } else - { + { // New entry, fill in current PC + sprintf( stmp, "%04X", X.PC ); + gtk_entry_set_text (GTK_ENTRY (dw->bp_start_entry), stmp ); + + gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( dw->bp_enable_chkbox ), TRUE ); + gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( dw->bp_execute_chkbox ), TRUE ); } } static void addBreakpointCB (GtkButton * button, debuggerWin_t * dw) { - dw->dialog_op = 1; - - create_breakpoint_dialog( -1, dw ); + create_breakpoint_dialog( -1, NULL, dw ); } static void editBreakpointCB (GtkButton * button, debuggerWin_t * dw) @@ -896,9 +883,7 @@ static void editBreakpointCB (GtkButton * button, debuggerWin_t * dw) if ( selRow >= 0 ) { - dw->dialog_op = 2; - - create_breakpoint_dialog( selRow, dw ); + create_breakpoint_dialog( selRow, &watchpoint[selRow], dw ); } } @@ -1093,6 +1078,22 @@ static void debugRunLine128CB (GtkButton * button, debuggerWin_t * dw) FCEUI_SetEmulationPaused(0); } +static void +addBreakpointMenuCB (GtkMenuItem *menuitem, + debuggerWin_t * dw) +{ + watchpointinfo wp; + + wp.address = dw->ctx_menu_addr; + wp.endaddress = 0; + wp.flags = WP_X | WP_E; + wp.condText = "K==#00"; + wp.desc = NULL; + + create_breakpoint_dialog( -1, &wp, dw ); + +} + static gboolean populate_context_menu (GtkWidget *popup, debuggerWin_t * dw ) @@ -1114,7 +1115,7 @@ populate_context_menu (GtkWidget *popup, { return TRUE; } - addr = dw->asmEntry[lineNum]->addr; + dw->ctx_menu_addr = addr = dw->asmEntry[lineNum]->addr; //printf("Context Menu: CP:%i Line:%i Addr:0x%04X\n", cpos, lineNum, addr ); @@ -1126,8 +1127,8 @@ populate_context_menu (GtkWidget *popup, gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); - //g_signal_connect (item, "activate", - // G_CALLBACK (setValueCB), mv); + g_signal_connect (item, "activate", + G_CALLBACK (addBreakpointMenuCB), dw); gtk_menu_popup_at_pointer (GTK_MENU (menu), NULL ); //gtk_widget_show_all (popup); From 20af46341957c4f81a95f4abf046be71863ccc20 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Mon, 25 May 2020 20:28:42 -0400 Subject: [PATCH 106/156] Added a few hooks for break on cycles, instructions and bad opcode checkboxes. Still TODO add break cycle/instruction limit set logic. --- src/drivers/sdl/debugger.cpp | 60 +++++++++++++++++++++++++++++++----- 1 file changed, 53 insertions(+), 7 deletions(-) diff --git a/src/drivers/sdl/debugger.cpp b/src/drivers/sdl/debugger.cpp index a12b0cd4..ef441fa2 100644 --- a/src/drivers/sdl/debugger.cpp +++ b/src/drivers/sdl/debugger.cpp @@ -38,6 +38,7 @@ extern Config *g_config; +static void updateAllDebugWindows(void); //******************************************************************************************************* // Debugger Window //******************************************************************************************************* @@ -107,6 +108,9 @@ struct debuggerWin_t GtkWidget *cpu_radio_btn; GtkWidget *ppu_radio_btn; GtkWidget *sprite_radio_btn; + GtkWidget *badop_chkbox; + GtkWidget *brkcycles_chkbox; + GtkWidget *brkinstrs_chkbox; int dialog_op; int bpEditIdx; @@ -153,6 +157,9 @@ struct debuggerWin_t P_I_chkbox = NULL; P_Z_chkbox = NULL; P_C_chkbox = NULL; + badop_chkbox = NULL; + brkcycles_chkbox = NULL; + brkinstrs_chkbox = NULL; dialog_op = 0; bpEditIdx = -1; ctx_menu_addr = 0; @@ -380,6 +387,10 @@ void debuggerWin_t::updateRegisterView(void) sprintf(stmp, "(+%llu)", delta_instructions); gtk_label_set_text( GTK_LABEL(instr_label2), stmp ); + gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(badop_chkbox ), FCEUI_Debugger().badopbreak ); + gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(brkcycles_chkbox), break_on_cycles ); + gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(brkinstrs_chkbox), break_on_instructions ); + } // This function is for "smart" scrolling... @@ -1153,6 +1164,34 @@ textview_button_press_cb (GtkWidget *widget, return ret; } +static void resetCountersCB( GtkWidget *button, debuggerWin_t * dw) +{ + ResetDebugStatisticsCounters(); + + updateAllDebugWindows(); +} + +static void breakOnBadOpcodeCB( GtkToggleButton *togglebutton, debuggerWin_t * dw) +{ + FCEUI_Debugger().badopbreak = !FCEUI_Debugger().badopbreak; + + updateAllDebugWindows(); +} + +static void breakOnCyclesCB( GtkToggleButton *togglebutton, debuggerWin_t * dw) +{ + break_on_cycles = !break_on_cycles; + + updateAllDebugWindows(); +} + +static void breakOnInstructionsCB( GtkToggleButton *togglebutton, debuggerWin_t * dw) +{ + break_on_instructions = !break_on_instructions; + + updateAllDebugWindows(); +} + static void romOffsetToggleCB( GtkToggleButton *togglebutton, debuggerWin_t * dw) { dw->displayROMoffsets = gtk_toggle_button_get_active( togglebutton ); @@ -1530,9 +1569,10 @@ void openDebuggerWindow (void) gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 2); - button = gtk_check_button_new_with_label("Break on Bad Opcodes"); - - gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 1); + dw->badop_chkbox = gtk_check_button_new_with_label("Break on Bad Opcodes"); + g_signal_connect (dw->badop_chkbox, "toggled", + G_CALLBACK (breakOnBadOpcodeCB), dw); + gtk_box_pack_start (GTK_BOX (vbox), dw->badop_chkbox, FALSE, FALSE, 1); // Status Flags Frame frame = gtk_frame_new ("Status Flags"); @@ -1623,13 +1663,17 @@ void openDebuggerWindow (void) gtk_grid_attach( GTK_GRID(grid), dw->instr_label1, 1, 2, 1, 1 ); gtk_grid_attach( GTK_GRID(grid), dw->instr_label2, 2, 2, 1, 1 ); - button = gtk_check_button_new_with_label("Break when exceed"); - gtk_grid_attach( GTK_GRID(grid), button, 1, 1, 1, 1 ); + dw->brkcycles_chkbox = gtk_check_button_new_with_label("Break when exceed"); + g_signal_connect (dw->brkcycles_chkbox, "toggled", + G_CALLBACK (breakOnCyclesCB), dw); + gtk_grid_attach( GTK_GRID(grid), dw->brkcycles_chkbox, 1, 1, 1, 1 ); entry = gtk_entry_new (); gtk_grid_attach( GTK_GRID(grid), entry, 2, 1, 1, 1 ); - button = gtk_check_button_new_with_label("Break when exceed"); - gtk_grid_attach( GTK_GRID(grid), button, 1, 3, 1, 1 ); + dw->brkinstrs_chkbox = gtk_check_button_new_with_label("Break when exceed"); + g_signal_connect (dw->brkinstrs_chkbox, "toggled", + G_CALLBACK (breakOnInstructionsCB), dw); + gtk_grid_attach( GTK_GRID(grid), dw->brkinstrs_chkbox, 1, 3, 1, 1 ); entry = gtk_entry_new (); gtk_grid_attach( GTK_GRID(grid), entry, 2, 3, 1, 1 ); @@ -1688,6 +1732,8 @@ void openDebuggerWindow (void) gtk_box_pack_start (GTK_BOX (hbox2), vbox, FALSE, FALSE, 2); button = gtk_button_new_with_label ("Reset Counters"); + g_signal_connect (button, "clicked", + G_CALLBACK (resetCountersCB), dw); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 2); button = gtk_check_button_new_with_label("ROM Offsets"); g_signal_connect (button, "toggled", From 64444129c34463dd9fbebfa222aaa34e610cff63 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Mon, 25 May 2020 20:44:39 -0400 Subject: [PATCH 107/156] Added callback functions for editing break cycle/instruction limit text fields --- src/drivers/sdl/debugger.cpp | 39 ++++++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/src/drivers/sdl/debugger.cpp b/src/drivers/sdl/debugger.cpp index ef441fa2..3804e23f 100644 --- a/src/drivers/sdl/debugger.cpp +++ b/src/drivers/sdl/debugger.cpp @@ -1185,6 +1185,23 @@ static void breakOnCyclesCB( GtkToggleButton *togglebutton, debuggerWin_t * dw) updateAllDebugWindows(); } +static void +breakOnCyclesLimitCB (GtkEntry *entry, +// gchar *string, + gpointer user_data) +{ + const char *txt; + + txt = gtk_entry_get_text( entry ); + + //printf("'%s'\n", txt ); + + if ( isdigit(txt[0]) ) + { + break_cycles_limit = strtoul( txt, NULL, 0 ); + } +} + static void breakOnInstructionsCB( GtkToggleButton *togglebutton, debuggerWin_t * dw) { break_on_instructions = !break_on_instructions; @@ -1192,6 +1209,23 @@ static void breakOnInstructionsCB( GtkToggleButton *togglebutton, debuggerWin_t updateAllDebugWindows(); } +static void +breakOnInstructionsLimitCB (GtkEntry *entry, +// gchar *string, + gpointer user_data) +{ + const char *txt; + + txt = gtk_entry_get_text( entry ); + + //printf("'%s'\n", txt ); + + if ( isdigit(txt[0]) ) + { + break_instructions_limit = strtoul( txt, NULL, 0 ); + } +} + static void romOffsetToggleCB( GtkToggleButton *togglebutton, debuggerWin_t * dw) { dw->displayROMoffsets = gtk_toggle_button_get_active( togglebutton ); @@ -1668,6 +1702,9 @@ void openDebuggerWindow (void) G_CALLBACK (breakOnCyclesCB), dw); gtk_grid_attach( GTK_GRID(grid), dw->brkcycles_chkbox, 1, 1, 1, 1 ); entry = gtk_entry_new (); + //g_signal_connect (entry, "preedit-changed", + g_signal_connect (entry, "activate", + G_CALLBACK (breakOnCyclesLimitCB), dw); gtk_grid_attach( GTK_GRID(grid), entry, 2, 1, 1, 1 ); dw->brkinstrs_chkbox = gtk_check_button_new_with_label("Break when exceed"); @@ -1675,6 +1712,8 @@ void openDebuggerWindow (void) G_CALLBACK (breakOnInstructionsCB), dw); gtk_grid_attach( GTK_GRID(grid), dw->brkinstrs_chkbox, 1, 3, 1, 1 ); entry = gtk_entry_new (); + g_signal_connect (entry, "activate", + G_CALLBACK (breakOnInstructionsLimitCB), dw); gtk_grid_attach( GTK_GRID(grid), entry, 2, 3, 1, 1 ); gtk_box_pack_start (GTK_BOX (vbox1), grid, FALSE, FALSE, 2); From 27e326ce90a3f93b8a727da70089560c69b9ee31 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Wed, 27 May 2020 05:48:38 -0400 Subject: [PATCH 108/156] Added seek to PC and seek to Addr logic. --- src/drivers/sdl/debugger.cpp | 164 +++++++++++++++++++++++++++++++---- 1 file changed, 148 insertions(+), 16 deletions(-) diff --git a/src/drivers/sdl/debugger.cpp b/src/drivers/sdl/debugger.cpp index 3804e23f..931cfd97 100644 --- a/src/drivers/sdl/debugger.cpp +++ b/src/drivers/sdl/debugger.cpp @@ -50,12 +50,14 @@ struct dbg_asm_entry_t int bank; int rom; int size; + int line; uint8 opcode[3]; dbg_asm_entry_t(void) { - addr = 0; bank = 0; rom = -1; size = 0; + addr = 0; bank = 0; rom = -1; + size = 0; line = 0; for (int i=0; i<3; i++) { @@ -111,12 +113,16 @@ struct debuggerWin_t GtkWidget *badop_chkbox; GtkWidget *brkcycles_chkbox; GtkWidget *brkinstrs_chkbox; + GtkWidget *brk_cycles_lim_entry; + GtkWidget *brk_instrs_lim_entry; + GtkWidget *seektoEntry; int dialog_op; int bpEditIdx; int ctx_menu_addr; char displayROMoffsets; + dbg_asm_entry_t *asmPC; std::vector asmEntry; debuggerWin_t(void) @@ -160,10 +166,14 @@ struct debuggerWin_t badop_chkbox = NULL; brkcycles_chkbox = NULL; brkinstrs_chkbox = NULL; + brk_cycles_lim_entry = NULL; + brk_instrs_lim_entry = NULL; + seektoEntry = NULL; dialog_op = 0; bpEditIdx = -1; ctx_menu_addr = 0; displayROMoffsets = 0; + asmPC = NULL; } ~debuggerWin_t(void) @@ -177,6 +187,8 @@ struct debuggerWin_t void updateRegisterView(void); void updateAssemblyView(void); int get_bpList_selrow(void); + int getAsmLineFromAddr(int addr); + int scrollAsmLine(int line); }; static std::list debuggerWinList; @@ -190,6 +202,39 @@ void debuggerWin_t::asmClear(void) asmEntry.clear(); } +int debuggerWin_t::getAsmLineFromAddr(int addr) +{ + int line = -1; + + if ( asmEntry.size() <= 0 ) + { + return -1; + } + + line = 0; + + for (size_t i=0; iaddr >= addr ) + { + line = i; break; + } + } + + return line; +} + +int debuggerWin_t::scrollAsmLine(int line) +{ + GtkTextIter iter; + + gtk_text_buffer_get_iter_at_line( textbuf, &iter, line ); + gtk_text_view_scroll_to_iter ( textview, &iter, 0.0, 1, 0.0, 0.50 ); + gtk_text_buffer_place_cursor( textbuf, &iter ); + + return 0; +} + int debuggerWin_t::get_bpList_selrow(void) { int retval = -1, numListRows; @@ -391,6 +436,12 @@ void debuggerWin_t::updateRegisterView(void) gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(brkcycles_chkbox), break_on_cycles ); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(brkinstrs_chkbox), break_on_instructions ); + sprintf(stmp, "%llu", break_cycles_limit); + gtk_entry_set_text( GTK_ENTRY(brk_cycles_lim_entry), stmp ); + + sprintf(stmp, "%llu", break_instructions_limit); + gtk_entry_set_text( GTK_ENTRY(brk_instrs_lim_entry), stmp ); + } // This function is for "smart" scrolling... @@ -445,7 +496,7 @@ void debuggerWin_t::updateAssemblyView(void) start_address_lp = starting_address = X.PC; - for (int i=0; i < 32; i++) + for (int i=0; i < 0xFFFF; i++) { //printf("%i: Start Address: 0x%04X \n", i, start_address_lp ); @@ -455,14 +506,20 @@ void debuggerWin_t::updateAssemblyView(void) { break; } + if ( starting_address <= 0x8000 ) + { + //starting_address = 0x8000; + break; + } start_address_lp = starting_address; } asmClear(); - addr = starting_address; + addr = starting_address; + asmPC = NULL; - for (int i=0; i < 64; i++) + for (int i=0; i < 0xFFFF; i++) { line.clear(); @@ -475,6 +532,7 @@ void debuggerWin_t::updateAssemblyView(void) if (addr == X.PC) { + asmPC = a; line.assign(">"); } else @@ -553,6 +611,8 @@ void debuggerWin_t::updateAssemblyView(void) block.append( line ); + a->line = asmEntry.size(); + asmEntry.push_back(a); } @@ -1089,6 +1149,46 @@ static void debugRunLine128CB (GtkButton * button, debuggerWin_t * dw) FCEUI_SetEmulationPaused(0); } +static void seekPCCB (GtkButton * button, debuggerWin_t * dw) +{ + int line; + //const char *txt; + + //txt = gtk_entry_get_text( GTK_ENTRY(dw->seektoEntry) ); + + //addr = strtol( txt, NULL, 16 ); + + if ( dw->asmPC == NULL ) + { + line = dw->getAsmLineFromAddr( X.PC ); + } + else + { + line = dw->asmPC->line; + } + + dw->scrollAsmLine( line ); + + //printf("Seek: 0x%04X Line:%i\n", addr, line); +} + +static void seekToCB (GtkButton * button, debuggerWin_t * dw) +{ + int addr, line; + const char *txt; + + txt = gtk_entry_get_text( GTK_ENTRY(dw->seektoEntry) ); + + //addr = strtol( txt, NULL, 16 ); + addr = offsetStringToInt( BT_C, txt ); + + line = dw->getAsmLineFromAddr( addr ); + + dw->scrollAsmLine( line ); + + //printf("Seek: 0x%04X Line:%i\n", addr, line); +} + static void addBreakpointMenuCB (GtkMenuItem *menuitem, debuggerWin_t * dw) @@ -1180,8 +1280,19 @@ static void breakOnBadOpcodeCB( GtkToggleButton *togglebutton, debuggerWin_t * d static void breakOnCyclesCB( GtkToggleButton *togglebutton, debuggerWin_t * dw) { + const char *txt; + break_on_cycles = !break_on_cycles; + txt = gtk_entry_get_text( GTK_ENTRY(dw->brk_cycles_lim_entry) ); + + //printf("'%s'\n", txt ); + + if ( isdigit(txt[0]) ) + { + break_cycles_limit = strtoul( txt, NULL, 0 ); + } + updateAllDebugWindows(); } @@ -1200,12 +1311,24 @@ breakOnCyclesLimitCB (GtkEntry *entry, { break_cycles_limit = strtoul( txt, NULL, 0 ); } + updateAllDebugWindows(); } static void breakOnInstructionsCB( GtkToggleButton *togglebutton, debuggerWin_t * dw) { + const char *txt; + break_on_instructions = !break_on_instructions; + txt = gtk_entry_get_text( GTK_ENTRY(dw->brk_instrs_lim_entry) ); + + //printf("'%s'\n", txt ); + + if ( isdigit(txt[0]) ) + { + break_instructions_limit = strtoul( txt, NULL, 0 ); + } + updateAllDebugWindows(); } @@ -1224,6 +1347,7 @@ breakOnInstructionsLimitCB (GtkEntry *entry, { break_instructions_limit = strtoul( txt, NULL, 0 ); } + updateAllDebugWindows(); } static void romOffsetToggleCB( GtkToggleButton *togglebutton, debuggerWin_t * dw) @@ -1327,6 +1451,7 @@ void openDebuggerWindow (void) gtk_text_view_set_editable( dw->textview, FALSE ); gtk_text_view_set_wrap_mode( dw->textview, GTK_WRAP_NONE ); gtk_text_view_set_cursor_visible( dw->textview, TRUE ); + //gtk_widget_set_size_request( GTK_WIDGET(dw->textview), 400, 400 ); g_signal_connect (dw->textview, "button-press-event", G_CALLBACK (textview_button_press_cb), dw); @@ -1335,7 +1460,8 @@ void openDebuggerWindow (void) scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), - GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS); + //GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS); + GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_container_add (GTK_CONTAINER (scroll), GTK_WIDGET(dw->textview) ); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1); @@ -1426,13 +1552,16 @@ void openDebuggerWindow (void) // Row 4 button = gtk_button_new_with_label ("Seek To:"); + g_signal_connect (button, "clicked", + G_CALLBACK (seekToCB), (gpointer) dw); + gtk_grid_attach( GTK_GRID(grid), button, 0, 3, 1, 1 ); - entry = gtk_entry_new (); - gtk_entry_set_max_length (GTK_ENTRY (entry), 4); - gtk_entry_set_width_chars (GTK_ENTRY (entry), 4); + dw->seektoEntry = gtk_entry_new (); + gtk_entry_set_max_length (GTK_ENTRY (dw->seektoEntry), 4); + gtk_entry_set_width_chars (GTK_ENTRY (dw->seektoEntry), 4); - gtk_grid_attach( GTK_GRID(grid), entry, 1, 3, 1, 1 ); + gtk_grid_attach( GTK_GRID(grid), dw->seektoEntry, 1, 3, 1, 1 ); // Row 5 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); @@ -1450,6 +1579,9 @@ void openDebuggerWindow (void) button = gtk_button_new_with_label ("Seek PC"); + g_signal_connect (button, "clicked", + G_CALLBACK (seekPCCB), (gpointer) dw); + gtk_grid_attach( GTK_GRID(grid), button, 1, 4, 1, 1 ); // Row 6 @@ -1701,20 +1833,20 @@ void openDebuggerWindow (void) g_signal_connect (dw->brkcycles_chkbox, "toggled", G_CALLBACK (breakOnCyclesCB), dw); gtk_grid_attach( GTK_GRID(grid), dw->brkcycles_chkbox, 1, 1, 1, 1 ); - entry = gtk_entry_new (); - //g_signal_connect (entry, "preedit-changed", - g_signal_connect (entry, "activate", + dw->brk_cycles_lim_entry = gtk_entry_new (); + //g_signal_connect (dw->brk_cycles_lim_entry, "preedit-changed", + g_signal_connect (dw->brk_cycles_lim_entry, "activate", G_CALLBACK (breakOnCyclesLimitCB), dw); - gtk_grid_attach( GTK_GRID(grid), entry, 2, 1, 1, 1 ); + gtk_grid_attach( GTK_GRID(grid), dw->brk_cycles_lim_entry, 2, 1, 1, 1 ); dw->brkinstrs_chkbox = gtk_check_button_new_with_label("Break when exceed"); g_signal_connect (dw->brkinstrs_chkbox, "toggled", G_CALLBACK (breakOnInstructionsCB), dw); gtk_grid_attach( GTK_GRID(grid), dw->brkinstrs_chkbox, 1, 3, 1, 1 ); - entry = gtk_entry_new (); - g_signal_connect (entry, "activate", + dw->brk_instrs_lim_entry = gtk_entry_new (); + g_signal_connect (dw->brk_instrs_lim_entry, "activate", G_CALLBACK (breakOnInstructionsLimitCB), dw); - gtk_grid_attach( GTK_GRID(grid), entry, 2, 3, 1, 1 ); + gtk_grid_attach( GTK_GRID(grid), dw->brk_instrs_lim_entry, 2, 3, 1, 1 ); gtk_box_pack_start (GTK_BOX (vbox1), grid, FALSE, FALSE, 2); /* From d15623b7e66f98bf1d57db529833c321ac4f7b0c Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Wed, 27 May 2020 06:46:20 -0400 Subject: [PATCH 109/156] Added logic to seek the PC on the debug window every time a breakpoint is hit. --- src/drivers/sdl/debugger.cpp | 165 ++++++++++++++++++++++++++++------- 1 file changed, 132 insertions(+), 33 deletions(-) diff --git a/src/drivers/sdl/debugger.cpp b/src/drivers/sdl/debugger.cpp index 931cfd97..45b3d8a9 100644 --- a/src/drivers/sdl/debugger.cpp +++ b/src/drivers/sdl/debugger.cpp @@ -38,6 +38,7 @@ extern Config *g_config; +static int breakpoint_hit = 0; static void updateAllDebugWindows(void); //******************************************************************************************************* // Debugger Window @@ -189,6 +190,8 @@ struct debuggerWin_t int get_bpList_selrow(void); int getAsmLineFromAddr(int addr); int scrollAsmLine(int line); + int seekAsmPC(void); + int seekAsmAddr(int addr); }; static std::list debuggerWinList; @@ -205,22 +208,88 @@ void debuggerWin_t::asmClear(void) int debuggerWin_t::getAsmLineFromAddr(int addr) { int line = -1; + int incr, nextLine; + int run = 1; if ( asmEntry.size() <= 0 ) { return -1; } + incr = asmEntry.size() / 2; - line = 0; - - for (size_t i=0; iaddr ) { - if ( asmEntry[i]->addr >= addr ) + return 0; + } + else if ( addr > asmEntry[ asmEntry.size() - 1 ]->addr ) + { + return asmEntry.size() - 1; + } + + if ( incr < 1 ) incr = 1; + + nextLine = line = incr; + + // algorithm to efficiently find line from address. Starts in middle of list and + // keeps dividing the list in 2 until it arrives at an answer. + while ( run ) + { + //printf("incr:%i line:%i addr:%04X delta:%i\n", incr, line, asmEntry[line]->addr, addr - asmEntry[line]->addr); + + if ( incr == 1 ) { - line = i; break; + if ( asmEntry[line]->addr < addr ) + { + nextLine = line + 1; + if ( asmEntry[line]->addr > nextLine ) + { + break; + } + line = nextLine; + } + else if ( asmEntry[line]->addr > addr ) + { + nextLine = line - 1; + if ( asmEntry[line]->addr < nextLine ) + { + break; + } + line = nextLine; + } + else + { + run = 0; break; + } + } + else + { + incr = incr / 2; + if ( incr < 1 ) incr = 1; + + if ( asmEntry[line]->addr < addr ) + { + nextLine = line + incr; + } + else if ( asmEntry[line]->addr > addr ) + { + nextLine = line - incr; + } + else + { + run = 0; break; + } + line = nextLine; } } + //for (size_t i=0; iaddr >= addr ) + // { + // line = i; break; + // } + //} + return line; } @@ -228,6 +297,10 @@ int debuggerWin_t::scrollAsmLine(int line) { GtkTextIter iter; + if ( line < 0 ) + { + return -1; + } gtk_text_buffer_get_iter_at_line( textbuf, &iter, line ); gtk_text_view_scroll_to_iter ( textview, &iter, 0.0, 1, 0.0, 0.50 ); gtk_text_buffer_place_cursor( textbuf, &iter ); @@ -235,6 +308,35 @@ int debuggerWin_t::scrollAsmLine(int line) return 0; } +int debuggerWin_t::seekAsmPC(void) +{ + int line; + + if ( asmPC == NULL ) + { + line = getAsmLineFromAddr( X.PC ); + } + else + { + line = asmPC->line; + } + + scrollAsmLine( line ); + + return 0; +} + +int debuggerWin_t::seekAsmAddr( int addr ) +{ + int line; + + line = getAsmLineFromAddr( addr ); + + scrollAsmLine( line ); + + return 0; +} + int debuggerWin_t::get_bpList_selrow(void) { int retval = -1, numListRows; @@ -506,9 +608,9 @@ void debuggerWin_t::updateAssemblyView(void) { break; } - if ( starting_address <= 0x8000 ) + if ( starting_address < 0x8000 ) { - //starting_address = 0x8000; + starting_address = start_address_lp; break; } start_address_lp = starting_address; @@ -1151,42 +1253,19 @@ static void debugRunLine128CB (GtkButton * button, debuggerWin_t * dw) static void seekPCCB (GtkButton * button, debuggerWin_t * dw) { - int line; - //const char *txt; - - //txt = gtk_entry_get_text( GTK_ENTRY(dw->seektoEntry) ); - - //addr = strtol( txt, NULL, 16 ); - - if ( dw->asmPC == NULL ) - { - line = dw->getAsmLineFromAddr( X.PC ); - } - else - { - line = dw->asmPC->line; - } - - dw->scrollAsmLine( line ); - - //printf("Seek: 0x%04X Line:%i\n", addr, line); + dw->seekAsmPC(); } static void seekToCB (GtkButton * button, debuggerWin_t * dw) { - int addr, line; + int addr; const char *txt; txt = gtk_entry_get_text( GTK_ENTRY(dw->seektoEntry) ); - //addr = strtol( txt, NULL, 16 ); addr = offsetStringToInt( BT_C, txt ); - line = dw->getAsmLineFromAddr( addr ); - - dw->scrollAsmLine( line ); - - //printf("Seek: 0x%04X Line:%i\n", addr, line); + dw->seekAsmAddr(addr); } static void @@ -1369,6 +1448,16 @@ static void updateAllDebugWindows(void) } } +static void seekPC_AllDebugWindows(void) +{ + std::list < debuggerWin_t * >::iterator it; + + for (it = debuggerWinList.begin (); it != debuggerWinList.end (); it++) + { + (*it)->seekAsmPC(); + } +} + static void winDebuggerLoopStep(void) { FCEUD_UpdateInput(); @@ -1377,6 +1466,12 @@ static void winDebuggerLoopStep(void) { gtk_main_iteration_do(FALSE); } + + if ( breakpoint_hit ) + { + seekPC_AllDebugWindows(); + breakpoint_hit = 0; + } } //this code enters the debugger when a breakpoint was hit @@ -1384,8 +1479,12 @@ void FCEUD_DebugBreakpoint(int bp_num) { //printf("Breakpoint Hit: %i \n", bp_num); + breakpoint_hit = 1; + updateAllDebugWindows(); + winDebuggerLoopStep(); + while(FCEUI_EmulationPaused() && !FCEUI_EmulationFrameStepped()) { usleep(50000); From 7d08906a896e2367ac9727ac40a608543a92a923 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Thu, 28 May 2020 21:30:12 -0400 Subject: [PATCH 110/156] Efficiency fixes for the debugger asm text view window. --- src/drivers/sdl/debugger.cpp | 84 ++++++++++++++++++++++++++++++------ 1 file changed, 70 insertions(+), 14 deletions(-) diff --git a/src/drivers/sdl/debugger.cpp b/src/drivers/sdl/debugger.cpp index 45b3d8a9..944cb3da 100644 --- a/src/drivers/sdl/debugger.cpp +++ b/src/drivers/sdl/debugger.cpp @@ -53,6 +53,7 @@ struct dbg_asm_entry_t int size; int line; uint8 opcode[3]; + std::string text; dbg_asm_entry_t(void) @@ -589,12 +590,14 @@ static int InstructionUp(int from) void debuggerWin_t::updateAssemblyView(void) { int starting_address, start_address_lp, addr, size; - int instruction_addr; - std::string line, block; + int instruction_addr, textview_lines_allocated; + std::string line; char chr[64]; uint8 opcode[3]; const char *disassemblyText = NULL; dbg_asm_entry_t *a; + GtkTextIter iter, next_iter; + char pc_found = 0; start_address_lp = starting_address = X.PC; @@ -621,6 +624,12 @@ void debuggerWin_t::updateAssemblyView(void) addr = starting_address; asmPC = NULL; + gtk_text_buffer_get_start_iter( textbuf, &iter ); + + textview_lines_allocated = gtk_text_buffer_get_line_count( textbuf ) - 1; + + //printf("Num Lines: %i\n", textview_lines_allocated ); + for (int i=0; i < 0xFFFF; i++) { line.clear(); @@ -632,12 +641,26 @@ void debuggerWin_t::updateAssemblyView(void) instruction_addr = addr; - if (addr == X.PC) + if ( !pc_found ) { - asmPC = a; - line.assign(">"); - } - else + if (addr > X.PC) + { + asmPC = a; + line.assign(">"); + pc_found = 1; + } + else if (addr == X.PC) + { + asmPC = a; + line.assign(">"); + pc_found = 1; + } + else + { + line.assign(" "); + } + } + else { line.assign(" "); } @@ -656,7 +679,8 @@ void debuggerWin_t::updateAssemblyView(void) { sprintf(chr, "%02X:%04X: ", a->bank, addr); } - } else + } + else { sprintf(chr, " :%04X: ", addr); } @@ -707,19 +731,51 @@ void debuggerWin_t::updateAssemblyView(void) { line.append("-------------------------"); } - line.append("\n"); - //printf("%s", line.c_str() ); - - block.append( line ); + a->text.assign( line ); a->line = asmEntry.size(); + if ( i < textview_lines_allocated ) + { + char *txt; + + //gtk_text_buffer_get_iter_at_line( textbuf, &iter, i ); + + next_iter = iter; + + gtk_text_iter_forward_to_line_end( &next_iter ); + + //gtk_text_iter_backward_chars( &next_iter, -1 ); + txt = gtk_text_buffer_get_text( textbuf, &iter, &next_iter, FALSE); + + if ( strcmp( txt, line.c_str() ) != 0 ) + { + //printf("Text is the diff\n%s\n", txt); + + gtk_text_buffer_delete( textbuf, &iter, &next_iter ); + + gtk_text_buffer_insert( textbuf, &iter, line.c_str(), -1 ); + } + else + { + iter = next_iter; + } + gtk_text_iter_forward_chars( &iter, 1 ); + + g_free(txt); + } + else + { + line.append("\n"); + + gtk_text_buffer_insert( textbuf, &iter, line.c_str(), -1 ); + //gtk_text_buffer_get_end_iter( textbuf, &iter ); + } + asmEntry.push_back(a); } - gtk_text_buffer_set_text( textbuf, block.c_str(), -1 ); - } void debuggerWin_t::updateViewPort(void) From 05de1a835644cded2f0540ff618322977a7e5d13 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Thu, 28 May 2020 21:54:14 -0400 Subject: [PATCH 111/156] Added PPU data display to debug window. --- src/drivers/sdl/debugger.cpp | 56 +++++++++++++++++++++++++++++++++++- 1 file changed, 55 insertions(+), 1 deletion(-) diff --git a/src/drivers/sdl/debugger.cpp b/src/drivers/sdl/debugger.cpp index 944cb3da..37fc7d1d 100644 --- a/src/drivers/sdl/debugger.cpp +++ b/src/drivers/sdl/debugger.cpp @@ -26,6 +26,7 @@ #include "../../cart.h" #include "../../ines.h" #include "../../asm.h" +#include "../../ppu.h" #include "../../x6502.h" #include "../common/configSys.h" @@ -37,6 +38,8 @@ #include "debugger.h" extern Config *g_config; +extern int vblankScanLines; +extern int vblankPixel; static int breakpoint_hit = 0; static void updateAllDebugWindows(void); @@ -449,7 +452,8 @@ void debuggerWin_t::bpListUpdate(void) void debuggerWin_t::updateRegisterView(void) { int stackPtr; - char stmp[32]; + char stmp[64]; + char str[32], str2[32]; std::string stackLine; sprintf( stmp, "%04X", X.PC ); @@ -545,6 +549,56 @@ void debuggerWin_t::updateRegisterView(void) sprintf(stmp, "%llu", break_instructions_limit); gtk_entry_set_text( GTK_ENTRY(brk_instrs_lim_entry), stmp ); + sprintf(stmp, "PPU: 0x%04X", (int)FCEUPPU_PeekAddress()); + gtk_label_set_text( GTK_LABEL(ppu_label), stmp ); + + sprintf(stmp, "Sprite: 0x%02X", PPU[3] ); + gtk_label_set_text( GTK_LABEL(sprite_label), stmp ); + + extern int linestartts; + #define GETLASTPIXEL (PAL?((timestamp*48-linestartts)/15) : ((timestamp*48-linestartts)/16) ) + + int ppupixel = GETLASTPIXEL; + + if (ppupixel>341) //maximum number of pixels per scanline + ppupixel = 0; //Currently pixel display is borked until Run 128 lines is clicked, this keeps garbage from displaying + + // If not in the 0-239 pixel range, make special cases for display + if (scanline == 240 && vblankScanLines < (PAL?72:22)) + { + if (!vblankScanLines) + { + // Idle scanline (240) + sprintf(str, "%d", scanline); // was "Idle %d" + } else if (scanline + vblankScanLines == (PAL?311:261)) + { + // Pre-render + sprintf(str, "-1"); // was "Prerender -1" + } else + { + // Vblank lines (241-260/310) + sprintf(str, "%d", scanline + vblankScanLines); // was "Vblank %d" + } + sprintf(str2, "%d", vblankPixel); + } else + { + // Scanlines 0 - 239 + sprintf(str, "%d", scanline); + sprintf(str2, "%d", ppupixel); + } + + if(newppu) + { + sprintf(str ,"%d",newppu_get_scanline()); + sprintf(str2,"%d",newppu_get_dot()); + } + + sprintf( stmp, "Scanline: %s", str ); + gtk_label_set_text( GTK_LABEL(scanline_label), stmp ); + + sprintf( stmp, "Pixel: %s", str2 ); + gtk_label_set_text( GTK_LABEL(pixel_label), stmp ); + } // This function is for "smart" scrolling... From 4c3bf6cf6cdc367cc6efbb9d73964c9498504f3c Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Thu, 28 May 2020 21:57:40 -0400 Subject: [PATCH 112/156] Removed automatic condition insertion on asm debug breakpoint entry window. --- src/drivers/sdl/debugger.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/drivers/sdl/debugger.cpp b/src/drivers/sdl/debugger.cpp index 37fc7d1d..64a2e7a6 100644 --- a/src/drivers/sdl/debugger.cpp +++ b/src/drivers/sdl/debugger.cpp @@ -1387,7 +1387,7 @@ addBreakpointMenuCB (GtkMenuItem *menuitem, wp.address = dw->ctx_menu_addr; wp.endaddress = 0; wp.flags = WP_X | WP_E; - wp.condText = "K==#00"; + wp.condText = 0; wp.desc = NULL; create_breakpoint_dialog( -1, &wp, dw ); From 0d9b9254ff877e45ff573c6f47e9d8cbfca392f1 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Fri, 29 May 2020 06:52:53 -0400 Subject: [PATCH 113/156] memory viewer (hex editor) window viewport calculation improvement. Much more accurate and efficient than previous. --- src/drivers/sdl/memview.cpp | 56 ++++++++++++++++++++++++++----------- 1 file changed, 39 insertions(+), 17 deletions(-) diff --git a/src/drivers/sdl/memview.cpp b/src/drivers/sdl/memview.cpp index 67689ffa..67128656 100644 --- a/src/drivers/sdl/memview.cpp +++ b/src/drivers/sdl/memview.cpp @@ -523,31 +523,50 @@ void memViewWin_t::showMemViewResults (int reset) int memViewWin_t::calcVisibleRange( int *start_out, int *end_out, int *center_out ) { - GtkAdjustment *ivadj; - double v, l, u, r; + //GtkAdjustment *ivadj; + //double v, l, u, r; int start, end, center; + GdkRectangle rect; + GtkTextIter iter; - ivadj = gtk_range_get_adjustment( GTK_RANGE(ivbar) ); + gtk_text_view_get_visible_rect( textview, &rect ); + + gtk_text_view_get_line_at_y( textview, &iter, rect.y, NULL ); + start = gtk_text_iter_get_line( &iter ) - 1; + + gtk_text_view_get_line_at_y( textview, &iter, rect.y+rect.height, NULL ); + end = gtk_text_iter_get_line( &iter ) + 1; + + if ( start < 0 ) start = 0; + + if ( end > numLines ) + { + end = numLines; + } + + //printf("Line Iter: %i -> %i\n", start, end ); + + //ivadj = gtk_range_get_adjustment( GTK_RANGE(ivbar) ); - v = gtk_range_get_value( GTK_RANGE(ivbar) ); - l = gtk_adjustment_get_lower( ivadj ); - u = gtk_adjustment_get_upper( ivadj ); + //v = gtk_range_get_value( GTK_RANGE(ivbar) ); + //l = gtk_adjustment_get_lower( ivadj ); + //u = gtk_adjustment_get_upper( ivadj ); - r = (v - l) / (u - l); + //r = (v - l) / (u - l); - start = ((int)( r * (double)numLines )) - 16; + //start = ((int)( r * (double)numLines )) - 16; - if ( start < 0 ) - { - start = 0; - } - end = start + 64; + //if ( start < 0 ) + //{ + // start = 0; + //} + //end = start + 64; - if ( end > numLines ) - { - end = numLines; - } + //if ( end > numLines ) + //{ + // end = numLines; + //} center = start + (end - start)/2; @@ -557,6 +576,9 @@ int memViewWin_t::calcVisibleRange( int *start_out, int *end_out, int *center_ou if ( end_out ) *end_out = end; if ( center_out ) *center_out = center; + //printf("Start:%i End:%i StartADDR:%08X EndADDR:%08X Rect: X:%i Y:%i W:%i H:%i \n", + // start, end, start*16, end*16, rect.x, rect.y, rect.width, rect.height ); + return 0; } From 5e0cbc1cbc04a86285a7b78a48299087e28921fb Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Fri, 29 May 2020 09:24:28 -0400 Subject: [PATCH 114/156] Improved logic for hex editor button inputs. --- src/drivers/sdl/gui.cpp | 2 +- src/drivers/sdl/memview.cpp | 220 ++++++++++++++++++++++++++---------- 2 files changed, 159 insertions(+), 63 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index d022b633..4ef6d207 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -2360,7 +2360,7 @@ unsigned short GDKToSDLKeyval (int gdk_key) // Function adapted from Gens/GS (source/gens/input/input_sdl.c) -static gint convertKeypress (GtkWidget * grab, GdkEventKey * event, +static gboolean convertKeypress (GtkWidget * grab, GdkEventKey * event, gpointer user_data) { SDL_Event sdlev; diff --git a/src/drivers/sdl/memview.cpp b/src/drivers/sdl/memview.cpp index 67128656..f50bc850 100644 --- a/src/drivers/sdl/memview.cpp +++ b/src/drivers/sdl/memview.cpp @@ -333,9 +333,8 @@ void memViewWin_t::showMemViewResults (int reset) int i, row, row_start, row_end, totalChars; gint cpos; char addrStr[128], valStr[16][8], ascii[18]; - char row_changed; - std::string line; - GtkTextIter iter, start_iter, end_iter; + char addrChg, valChg[16]; + GtkTextIter iter, next_iter, start_iter, end_iter; if ( redraw ) { @@ -404,40 +403,68 @@ void memViewWin_t::showMemViewResults (int reset) row_start = 0; row_end = numLines; + + gtk_text_buffer_get_iter_at_offset( textbuf, &iter, 0 ); } else { calcVisibleRange( &row_start, &row_end, NULL ); + + gtk_text_buffer_get_iter_at_line( textbuf, &iter, row_start ); } - gtk_text_buffer_get_iter_at_offset( textbuf, &iter, 0 ); + //gtk_text_buffer_get_iter_at_offset( textbuf, &iter, 0 ); totalChars = row_start * numCharsPerLine; for (row=row_start; row> 4; ln = ( c & 0x000f ); - valStr[i][0] = conv2xchar(un); - valStr[i][1] = conv2xchar(ln); - valStr[i][2] = 0; + valStr[i][0] = ' '; + valStr[i][1] = conv2xchar(un); + valStr[i][2] = conv2xchar(ln); + valStr[i][3] = ' '; + valStr[i][4] = 0; if ( isprint(c) ) { @@ -447,46 +474,73 @@ void memViewWin_t::showMemViewResults (int reset) { ascii[i] = '.'; } - if ( c != mbuf[addr] ) + + if ( valChg[i] ) { - row_changed = 1; - mbuf[addr] = c; + next_iter = iter; + gtk_text_iter_forward_chars( &next_iter, 4 ); + + if ( !reset ) + { + gtk_text_buffer_delete( textbuf, &iter, &next_iter ); + } + gtk_text_buffer_insert( textbuf, &iter, valStr[i], -1 ); + } + else + { + gtk_text_iter_forward_chars( &iter, 4 ); } } ascii[16] = 0; - line.assign( addrStr ); - for (i=0; i<16; i++) { - line.append( " "); - line.append( valStr[i] ); - line.append( " "); - } - line.append( ascii ); - line.append( "\n"); - - numCharsPerLine = line.size(); - - if ( row_changed ) - { - if ( reset ) + if ( valChg[i] ) { - gtk_text_buffer_get_iter_at_offset( textbuf, &iter, totalChars ); - gtk_text_buffer_insert ( textbuf, &iter, line.c_str(), -1 ); + next_iter = iter; + gtk_text_iter_forward_chars( &next_iter, 1 ); + + if ( !reset ) + { + gtk_text_buffer_delete( textbuf, &iter, &next_iter ); + } + gtk_text_buffer_insert( textbuf, &iter, &ascii[i], 1 ); } else { - GtkTextIter next_iter; - - gtk_text_buffer_get_iter_at_offset( textbuf, &next_iter, totalChars + numCharsPerLine - 1 ); - gtk_text_buffer_delete ( textbuf, &iter, &next_iter ); - - gtk_text_buffer_get_iter_at_offset( textbuf, &iter, totalChars ); - gtk_text_buffer_insert ( textbuf, &iter, line.c_str(), line.size()-1 ); + gtk_text_iter_forward_chars( &iter, 1 ); } } + numCharsPerLine = 9 + (4*16) + 16 + 1; + + if ( reset ) + { + gtk_text_buffer_insert ( textbuf, &iter, "\n", -1 ); + } + else + { + gtk_text_iter_forward_chars( &iter, 1 ); + } + //if ( row_changed ) + //{ + // if ( reset ) + // { + // gtk_text_buffer_get_iter_at_offset( textbuf, &iter, totalChars ); + // gtk_text_buffer_insert ( textbuf, &iter, line.c_str(), -1 ); + // } + // else + // { + // GtkTextIter next_iter; + + // gtk_text_buffer_get_iter_at_offset( textbuf, &next_iter, totalChars + numCharsPerLine - 1 ); + // gtk_text_buffer_delete ( textbuf, &iter, &next_iter ); + + // gtk_text_buffer_get_iter_at_offset( textbuf, &iter, totalChars ); + // gtk_text_buffer_insert ( textbuf, &iter, line.c_str(), line.size()-1 ); + // } + //} + totalChars += numCharsPerLine; } @@ -711,20 +765,66 @@ textview_string_insert (GtkTextView *text_view, } -static void -textbuffer_string_insert (GtkTextBuffer *textbuffer, - GtkTextIter *location, - gchar *text, - gint len, - memViewWin_t * mv ) +//static void +//textbuffer_string_insert (GtkTextBuffer *textbuffer, +// GtkTextIter *location, +// gchar *text, +// gint len, +// memViewWin_t * mv ) +static gboolean textbuffer_string_insert (GtkWidget * grab, GdkEventKey * event, memViewWin_t * mv) { - if ( len == 1 ) + int addr, line, offs, byte0, byte, bcol, c, d; + gint cpos; + gboolean stopKeyPropagate = TRUE; + + g_object_get( mv->textbuf, "cursor-position", &cpos, NULL ); + + line = cpos / mv->numCharsPerLine; + offs = cpos % mv->numCharsPerLine; + + byte0 = (offs - 10); + + byte = byte0 / 4; + bcol = byte0 % 4; + + addr = (line*16) + byte; + + //printf("Line: %i Offset: %i Byte:%i Bcol:%i\n", line, offs, byte, bcol ); + + d = event->keyval; + + //printf("Key: %i '%c' \n", d, d ); + + stopKeyPropagate = (d != GDK_KEY_Up ) && + (d != GDK_KEY_Down ) && + (d != GDK_KEY_Left ) && + (d != GDK_KEY_Right ) && + (d != GDK_KEY_Page_Up ) && + (d != GDK_KEY_Page_Down); + + if ( !isascii( d ) ) { - int addr, line, offs, byte0, byte, bcol, c, d; + return stopKeyPropagate; + } - line = gtk_text_iter_get_line( location ), - offs = gtk_text_iter_get_line_offset( location ); + if ( offs > (9 + (16*4)) ) + { // ASCII Text Area + byte = (offs - 73); + if ( (byte < 0) || (byte >= 16) ) + { + return stopKeyPropagate; + } + addr = (line*16) + byte; + + c = d; + } + else + { // Hex Text Area + if ( !isxdigit( d ) ) + { + return stopKeyPropagate; + } byte0 = (offs - 10); byte = byte0 / 4; @@ -732,15 +832,6 @@ textbuffer_string_insert (GtkTextBuffer *textbuffer, addr = (line*16) + byte; - //printf("Line: %i Offset: %i Byte:%i Bcol:%i\n", line, offs, byte, bcol ); - //printf("Text: '%s' \n", text ); - - if ( !isxdigit( text[0] ) ) - { - return; - } - d = text[0]; - if ( (d >= '0') && (d <= '9') ) { d = d - '0'; @@ -749,7 +840,7 @@ textbuffer_string_insert (GtkTextBuffer *textbuffer, { d = d - 'a' + 10; } - else + else { d = d - 'A' + 10; } @@ -768,10 +859,13 @@ textbuffer_string_insert (GtkTextBuffer *textbuffer, c = c & 0xf0; c = c | d; } - //printf(" to:0x%02x \n", c ); - - mv->writeMem( addr, c ); } + //printf(" to:0x%02x \n", c ); + + mv->writeMem( addr, c ); + + // Return wether to allow GTK+ to process this key. + return stopKeyPropagate; } static void @@ -1116,7 +1210,9 @@ void openMemoryViewWindow (void) mv->textbuf = gtk_text_view_get_buffer( mv->textview ); - g_signal_connect (mv->textbuf, "insert-text", + //g_signal_connect (mv->textbuf, "insert-text", + // G_CALLBACK (textbuffer_string_insert), mv); + g_signal_connect (G_OBJECT (mv->textview), "key-press-event", G_CALLBACK (textbuffer_string_insert), mv); scroll = gtk_scrolled_window_new (NULL, NULL); From d362161269ed1f89e0dadff1cb9cc02676e9a96d Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Fri, 29 May 2020 09:30:07 -0400 Subject: [PATCH 115/156] Added logic to only allow select key presses through to the textview widget on the debugger window. --- src/drivers/sdl/debugger.cpp | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/drivers/sdl/debugger.cpp b/src/drivers/sdl/debugger.cpp index 64a2e7a6..dc8cfc92 100644 --- a/src/drivers/sdl/debugger.cpp +++ b/src/drivers/sdl/debugger.cpp @@ -1437,6 +1437,20 @@ populate_context_menu (GtkWidget *popup, return TRUE; } +static gboolean textview_keypress_cb (GtkWidget * grab, GdkEventKey * event, debuggerWin_t * dw) +{ + gboolean stopKeyPropagate; + + stopKeyPropagate = (event->keyval != GDK_KEY_Up ) && + (event->keyval != GDK_KEY_Down ) && + (event->keyval != GDK_KEY_Left ) && + (event->keyval != GDK_KEY_Right ) && + (event->keyval != GDK_KEY_Page_Up ) && + (event->keyval != GDK_KEY_Page_Down); + + return stopKeyPropagate; +} + static gboolean textview_button_press_cb (GtkWidget *widget, GdkEventButton *event, @@ -1657,11 +1671,13 @@ void openDebuggerWindow (void) gtk_text_view_set_monospace( dw->textview, TRUE ); gtk_text_view_set_overwrite( dw->textview, TRUE ); - gtk_text_view_set_editable( dw->textview, FALSE ); + gtk_text_view_set_editable( dw->textview, TRUE ); gtk_text_view_set_wrap_mode( dw->textview, GTK_WRAP_NONE ); gtk_text_view_set_cursor_visible( dw->textview, TRUE ); //gtk_widget_set_size_request( GTK_WIDGET(dw->textview), 400, 400 ); + g_signal_connect (dw->textview, "key-press-event", + G_CALLBACK (textview_keypress_cb), dw); g_signal_connect (dw->textview, "button-press-event", G_CALLBACK (textview_button_press_cb), dw); From 6e33c48a1f7f1bbb7cf9856af0ebb1ab2e6586cc Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Fri, 29 May 2020 15:00:33 -0400 Subject: [PATCH 116/156] Added memory view highlight activity coloring. Still TODO, add logic to switch colors in menu. --- src/drivers/sdl/memview.cpp | 71 +++++++++++++++++++++++++++++++++---- 1 file changed, 64 insertions(+), 7 deletions(-) diff --git a/src/drivers/sdl/memview.cpp b/src/drivers/sdl/memview.cpp index f50bc850..8d025876 100644 --- a/src/drivers/sdl/memview.cpp +++ b/src/drivers/sdl/memview.cpp @@ -36,6 +36,15 @@ extern Config *g_config; +#define HIGHLIGHT_ACTIVITY_NUM_COLORS 16 + +static unsigned int highlightActivityColors[HIGHLIGHT_ACTIVITY_NUM_COLORS] = +{ + 0x000000, 0x004035, 0x185218, 0x5e5c34, + 0x804c00, 0xba0300, 0xd10038, 0xb21272, + 0xba00ab, 0x6f00b0, 0x3700c2, 0x000cba, + 0x002cc9, 0x0053bf, 0x0072cf, 0x3c8bc7 +}; //******************************************************************************************************* // Memory View (Hex Editor) Window //******************************************************************************************************* @@ -112,6 +121,7 @@ struct memViewWin_t GtkWidget *memSelRadioItem[4]; GtkTextView *textview; GtkTextBuffer *textbuf; + GtkTextTag *highlight[ HIGHLIGHT_ACTIVITY_NUM_COLORS ]; int selAddr; int selRomAddr; int jumpAddr; @@ -122,6 +132,7 @@ struct memViewWin_t int numLines; int numCharsPerLine; unsigned char *mbuf; + unsigned char *colorbuf; int mbuf_size; GtkCellRenderer *hexByte_renderer[16]; bool redraw; @@ -149,6 +160,7 @@ struct memViewWin_t dialog_op = 0; mode = MODE_NES_RAM; mbuf = NULL; + colorbuf = NULL; mbuf_size = 0; numLines = 0; evntSrcID = 0; @@ -164,6 +176,10 @@ struct memViewWin_t { hexByte_renderer[i] = NULL; } + for (int i=0; i 0 ) + { + colorbuf[addr]--; + valChg[i] = 1; + } } un = ( c & 0x00f0 ) >> 4; @@ -484,7 +524,8 @@ void memViewWin_t::showMemViewResults (int reset) { gtk_text_buffer_delete( textbuf, &iter, &next_iter ); } - gtk_text_buffer_insert( textbuf, &iter, valStr[i], -1 ); + //gtk_text_buffer_insert( textbuf, &iter, valStr[i], -1 ); + gtk_text_buffer_insert_with_tags( textbuf, &iter, valStr[i], -1, highlight[ colorbuf[addr] ], NULL ); } else { @@ -765,12 +806,6 @@ textview_string_insert (GtkTextView *text_view, } -//static void -//textbuffer_string_insert (GtkTextBuffer *textbuffer, -// GtkTextIter *location, -// gchar *text, -// gint len, -// memViewWin_t * mv ) static gboolean textbuffer_string_insert (GtkWidget * grab, GdkEventKey * event, memViewWin_t * mv) { int addr, line, offs, byte0, byte, bcol, c, d; @@ -1169,6 +1204,7 @@ void openMemoryViewWindow (void) GtkWidget *scroll; GtkWidget *menubar; memViewWin_t *mv; + GdkRGBA color; mv = new memViewWin_t; @@ -1215,6 +1251,27 @@ void openMemoryViewWindow (void) g_signal_connect (G_OBJECT (mv->textview), "key-press-event", G_CALLBACK (textbuffer_string_insert), mv); + for (int i=0; i> 8; + b = (highlightActivityColors[i] & 0x00ff0000) >> 16; + + color.red = (double)r / 255.0f; + color.green = (double)g / 255.0f; + color.blue = (double)b / 255.0f; + color.alpha = 1.0; + + printf("%i R:%f G:%f B:%f \n", i, color.red, color.green, color.blue ); + + mv->highlight[i] = gtk_text_buffer_create_tag( mv->textbuf, stmp, "foreground-rgba", &color, NULL ); + } + scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS); From 7500446b2c7ea2fbeb0e19ad960565264c38487a Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Fri, 29 May 2020 16:53:20 -0400 Subject: [PATCH 117/156] Changed memory buffer setup to allow for color and activity data to be stored for each address. --- src/drivers/sdl/memview.cpp | 48 ++++++++++++++++--------------------- 1 file changed, 21 insertions(+), 27 deletions(-) diff --git a/src/drivers/sdl/memview.cpp b/src/drivers/sdl/memview.cpp index 8d025876..0912dfc8 100644 --- a/src/drivers/sdl/memview.cpp +++ b/src/drivers/sdl/memview.cpp @@ -45,6 +45,13 @@ static unsigned int highlightActivityColors[HIGHLIGHT_ACTIVITY_NUM_COLORS] = 0xba00ab, 0x6f00b0, 0x3700c2, 0x000cba, 0x002cc9, 0x0053bf, 0x0072cf, 0x3c8bc7 }; + +struct memByte_t +{ + unsigned char data; + unsigned char color; + unsigned char actv; +}; //******************************************************************************************************* // Memory View (Hex Editor) Window //******************************************************************************************************* @@ -131,13 +138,14 @@ struct memViewWin_t int evntSrcID; int numLines; int numCharsPerLine; - unsigned char *mbuf; - unsigned char *colorbuf; + struct memByte_t *mbuf; int mbuf_size; GtkCellRenderer *hexByte_renderer[16]; bool redraw; int (*memAccessFunc)( unsigned int offset); + std::vector colorList; + enum { MODE_NES_RAM = 0, MODE_NES_PPU, @@ -160,7 +168,6 @@ struct memViewWin_t dialog_op = 0; mode = MODE_NES_RAM; mbuf = NULL; - colorbuf = NULL; mbuf_size = 0; numLines = 0; evntSrcID = 0; @@ -188,10 +195,6 @@ struct memViewWin_t { free(mbuf); mbuf = NULL; } - if ( colorbuf != NULL ) - { - free(colorbuf); colorbuf = NULL; - } } void setMode(int new_mode) @@ -295,11 +298,13 @@ static int conv2xchar( int i ) return c; } -static void initMem( unsigned char *c, int size ) +static void initMem( struct memByte_t *c, int size ) { for (int i=0; i 0 ) + if ( mbuf[addr].color > 0 ) { - colorbuf[addr]--; + mbuf[addr].color--; valChg[i] = 1; } } @@ -525,7 +519,7 @@ void memViewWin_t::showMemViewResults (int reset) gtk_text_buffer_delete( textbuf, &iter, &next_iter ); } //gtk_text_buffer_insert( textbuf, &iter, valStr[i], -1 ); - gtk_text_buffer_insert_with_tags( textbuf, &iter, valStr[i], -1, highlight[ colorbuf[addr] ], NULL ); + gtk_text_buffer_insert_with_tags( textbuf, &iter, valStr[i], -1, highlight[ mbuf[addr].color ], NULL ); } else { From a92874a5b6bee53e9d207892c469ef2256d5021d Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Fri, 29 May 2020 17:19:44 -0400 Subject: [PATCH 118/156] Added logic to sync memory last pass values at startup. --- src/drivers/sdl/memview.cpp | 20 ++++++++++++++------ 1 file changed, 14 insertions(+), 6 deletions(-) diff --git a/src/drivers/sdl/memview.cpp b/src/drivers/sdl/memview.cpp index 0912dfc8..f2d23fc4 100644 --- a/src/drivers/sdl/memview.cpp +++ b/src/drivers/sdl/memview.cpp @@ -280,6 +280,8 @@ struct memViewWin_t void showMemViewResults (int reset); int calcVisibleRange( int *start_out, int *end_out, int *center_out ); int getAddrFromCursor( int CursorTextOffset = -1 ); + int checkMemActivity(void); + void initMem(void); }; @@ -298,16 +300,22 @@ static int conv2xchar( int i ) return c; } -static void initMem( struct memByte_t *c, int size ) +void memViewWin_t::initMem(void) { - for (int i=0; i Date: Sat, 30 May 2020 11:26:36 -0400 Subject: [PATCH 119/156] Added configurable fore and back ground color picking for memview window. --- src/drivers/sdl/memview.cpp | 266 ++++++++++++++++++++++++++++++++---- 1 file changed, 242 insertions(+), 24 deletions(-) diff --git a/src/drivers/sdl/memview.cpp b/src/drivers/sdl/memview.cpp index f2d23fc4..700fee64 100644 --- a/src/drivers/sdl/memview.cpp +++ b/src/drivers/sdl/memview.cpp @@ -129,6 +129,7 @@ struct memViewWin_t GtkTextView *textview; GtkTextBuffer *textbuf; GtkTextTag *highlight[ HIGHLIGHT_ACTIVITY_NUM_COLORS ]; + GtkCssProvider *cssProvider; int selAddr; int selRomAddr; int jumpAddr; @@ -142,7 +143,12 @@ struct memViewWin_t int mbuf_size; GtkCellRenderer *hexByte_renderer[16]; bool redraw; + bool useActivityColors; int (*memAccessFunc)( unsigned int offset); + uint64 total_instructions_lp; + + GdkRGBA bgColor; + GdkRGBA fgColor; std::vector colorList; @@ -174,6 +180,9 @@ struct memViewWin_t numCharsPerLine = 90; redraw = 1; memAccessFunc = getRAM; + useActivityColors = 1; + total_instructions_lp = 0; + cssProvider = NULL; for (int i=0; i<4; i++) { @@ -282,6 +291,7 @@ struct memViewWin_t int getAddrFromCursor( int CursorTextOffset = -1 ); int checkMemActivity(void); void initMem(void); + int upDateTextViewStyle(void); }; @@ -313,6 +323,37 @@ void memViewWin_t::initMem(void) int memViewWin_t::checkMemActivity(void) { + int c; + + // Don't perform memory activity checks when: + // 1. In ROM View Mode + // 2. The simulation is not cycling (paused) + + if ( ( mode == MODE_NES_ROM ) || + ( total_instructions_lp == total_instructions ) ) + { + return -1; + } + + for (int i=0; i 0 ) + { + mbuf[i].actv--; + } + } + } + total_instructions_lp = total_instructions; + return 0; } @@ -391,8 +432,25 @@ void memViewWin_t::showMemViewResults (int reset) memSize = 0x100; break; case MODE_NES_ROM: - memAccessFunc = getROM; - memSize = 16 + CHRsize[0] + PRGsize[0]; + + if ( GameInfo != NULL ) + { + memAccessFunc = getROM; + memSize = 16 + CHRsize[0] + PRGsize[0]; + } + else + { // No Game Loaded!!! Get out of Function + memAccessFunc = NULL; + memSize = 0; + if ( mbuf ) + { + free(mbuf); mbuf = NULL; + } + mbuf_size = 0; + redraw = 1; + gtk_text_buffer_set_text( textbuf, "", -1 ); + return; + } break; } numLines = memSize / 16; @@ -406,7 +464,7 @@ void memViewWin_t::showMemViewResults (int reset) { free(mbuf); mbuf = NULL; } - mbuf = (struct memByte_t *)malloc( memSize * sizeof(struct memByte_t) ); + mbuf = (struct memByte_t *)malloc( memSize * sizeof(struct memByte_t) ); if ( mbuf ) { @@ -427,25 +485,26 @@ void memViewWin_t::showMemViewResults (int reset) //printf("CPOS: %i \n", cpos ); - gtk_text_buffer_get_start_iter( textbuf, &start_iter ); - gtk_text_buffer_get_end_iter( textbuf, &end_iter ); - if ( reset ) { + gtk_text_buffer_get_bounds( textbuf, &start_iter, &end_iter ); + gtk_text_buffer_delete( textbuf, &start_iter, &end_iter ); row_start = 0; row_end = numLines; - gtk_text_buffer_get_iter_at_offset( textbuf, &iter, 0 ); + gtk_text_buffer_get_iter_at_offset( textbuf, &iter, 0 ); } else { calcVisibleRange( &row_start, &row_end, NULL ); - gtk_text_buffer_get_iter_at_line( textbuf, &iter, row_start ); + gtk_text_buffer_get_iter_at_line( textbuf, &iter, row_start ); } + checkMemActivity(); + //gtk_text_buffer_get_iter_at_offset( textbuf, &iter, 0 ); totalChars = row_start * numCharsPerLine; @@ -484,19 +543,30 @@ void memViewWin_t::showMemViewResults (int reset) c = memAccessFunc(addr); - if ( c != mbuf[addr].data ) + //if ( c != mbuf[addr].data ) + //{ + // printf("Value Change: %04X %02X %02X \n", addr, c, mbuf[addr].data ); + // mbuf[addr].data = c; + // mbuf[addr].color = 15; + // valChg[i] = 1; + //} + //else + //{ + // if ( mbuf[addr].color > 0 ) + // { + // mbuf[addr].color--; + // valChg[i] = 1; + // } + //} + + if ( mbuf[addr].actv ) { - mbuf[addr].data = c; - mbuf[addr].color = 15; - valChg[i] = 1; + valChg[i] = mbuf[addr].actv; } - else + + if ( useActivityColors ) { - if ( mbuf[addr].color > 0 ) - { - mbuf[addr].color--; - valChg[i] = 1; - } + mbuf[addr].color = mbuf[addr].actv; } un = ( c & 0x00f0 ) >> 4; @@ -517,13 +587,15 @@ void memViewWin_t::showMemViewResults (int reset) ascii[i] = '.'; } + next_iter = iter; + if ( valChg[i] ) { - next_iter = iter; - gtk_text_iter_forward_chars( &next_iter, 4 ); - if ( !reset ) { + next_iter = iter; + gtk_text_iter_forward_chars( &next_iter, 4 ); + gtk_text_buffer_delete( textbuf, &iter, &next_iter ); } //gtk_text_buffer_insert( textbuf, &iter, valStr[i], -1 ); @@ -531,6 +603,13 @@ void memViewWin_t::showMemViewResults (int reset) } else { + if ( !reset ) + { + gtk_text_iter_forward_chars( &next_iter, 4 ); + + gtk_text_buffer_remove_all_tags( textbuf, &iter, &next_iter ); + } + gtk_text_iter_forward_chars( &iter, 4 ); } } @@ -540,11 +619,10 @@ void memViewWin_t::showMemViewResults (int reset) { if ( valChg[i] ) { - next_iter = iter; - gtk_text_iter_forward_chars( &next_iter, 1 ); - if ( !reset ) { + next_iter = iter; + gtk_text_iter_forward_chars( &next_iter, 1 ); gtk_text_buffer_delete( textbuf, &iter, &next_iter ); } gtk_text_buffer_insert( textbuf, &iter, &ascii[i], 1 ); @@ -636,6 +714,10 @@ int memViewWin_t::calcVisibleRange( int *start_out, int *end_out, int *center_ou if ( start < 0 ) start = 0; + if ( end > (start+32) ) + { + end = start + 32; + } if ( end > numLines ) { end = numLines; @@ -699,6 +781,30 @@ int memViewWin_t::gotoLocation( int addr ) return 0; } +static void gdkColorConv( GdkRGBA *in, int *out ) +{ + *out = 0; + *out |= ( (int)( (in->red * 256.0) ) & 0x00ff) << 16; + *out |= ( (int)( (in->green * 256.0) ) & 0x00ff) << 8; + *out |= ( (int)( (in->blue * 256.0) ) & 0x00ff); +} + +int memViewWin_t::upDateTextViewStyle(void) +{ + char styleString[256]; + int fg, bg; + + gdkColorConv( &bgColor, &bg ); + gdkColorConv( &fgColor, &fg ); + + sprintf( styleString, + "#hex_editor text { color: #%06X;\n background-color: #%06X;\n }", fg, bg ); + + gtk_css_provider_load_from_data(cssProvider, styleString, -1, NULL); + + return 0; +} + static int memViewEvntSrcID = 0; static std::list memViewWinList; @@ -723,6 +829,71 @@ static void changeModeROM (GtkRadioMenuItem * radiomenuitem, memViewWin_t *mv) mv->setMode( memViewWin_t::MODE_NES_ROM ); } +static void colorPickCB (GtkDialog *dialog, + gint response_id, + memViewWin_t *mv) +{ + GdkRGBA color; + const char *title; + + gtk_color_chooser_get_rgba ( GTK_COLOR_CHOOSER( dialog ), &color ); + + title = gtk_window_get_title( GTK_WINDOW(dialog) ); + + //printf("Response: %s %i R:%f G:%f B:%f\n", + // gtk_window_get_title( GTK_WINDOW(dialog) ), + // response_id, color.red, color.green, color.blue ); + + if ( GTK_RESPONSE_OK == response_id ) + { + if ( strstr( title, "Background" ) ) + { + mv->bgColor = color; + mv->upDateTextViewStyle(); + } + else if ( strstr( title, "Foreground" ) ) + { + mv->fgColor = color; + mv->upDateTextViewStyle(); + } + } + + gtk_widget_destroy ( GTK_WIDGET(dialog) ); +} + +static void openColorPicker (memViewWin_t *mv, int mode) +{ + GtkWidget *w; + char title[256]; + + printf("Open Color Picker \n"); + + if ( mode ) + { + strcpy( title, "Pick Background Color"); + } + else + { + strcpy( title, "Pick Foreground Color"); + } + + w = gtk_color_chooser_dialog_new( title, GTK_WINDOW(mv->win) ); + + g_signal_connect (w, "response", G_CALLBACK (colorPickCB), + (gpointer) mv); + + gtk_widget_show_all (w); +} + +static void openColorPicker_FG_CB (GtkMenuItem * item, memViewWin_t *mv) +{ + openColorPicker (mv,0); +} +static void openColorPicker_BG_CB (GtkMenuItem * item, memViewWin_t *mv) +{ + openColorPicker (mv,1); +} + static GtkWidget *CreateMemViewMenubar (memViewWin_t * mv) { GtkWidget *menubar, *menu, *item; @@ -775,6 +946,31 @@ static GtkWidget *CreateMemViewMenubar (memViewWin_t * mv) g_signal_connect (mv->memSelRadioItem[3], "activate", G_CALLBACK (changeModeROM), (gpointer) mv); + //-Color ------------------ + item = gtk_menu_item_new_with_label ("Colors"); + + gtk_menu_shell_append (GTK_MENU_SHELL (menubar), item); + + menu = gtk_menu_new (); + + gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), menu); + + //-Color --> Set Foreground ------------------ + item = gtk_menu_item_new_with_label ("Set Foreground"); + + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item ); + + g_signal_connect (item, "activate", G_CALLBACK (openColorPicker_FG_CB), + (gpointer) mv); + + //-Color --> Set Background ------------------ + item = gtk_menu_item_new_with_label ("Set Background"); + + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item ); + + g_signal_connect (item, "activate", G_CALLBACK (openColorPicker_BG_CB), + (gpointer) mv); + // Finally, return the actual menu bar created return menubar; } @@ -1229,6 +1425,7 @@ void openMemoryViewWindow (void) mv->textview = (GtkTextView*) gtk_text_view_new(); + gtk_widget_set_name( GTK_WIDGET(mv->textview), "hex_editor"); gtk_text_view_set_monospace( mv->textview, TRUE ); gtk_text_view_set_overwrite( mv->textview, TRUE ); gtk_text_view_set_editable( mv->textview, TRUE ); @@ -1305,6 +1502,27 @@ void openMemoryViewWindow (void) g_signal_connect (mv->win, "response", G_CALLBACK (closeMemoryViewWindow), mv); + mv->bgColor.red = 0.0; + mv->bgColor.green = 0.0; + mv->bgColor.blue = 0.0; + mv->bgColor.alpha = 1.0; + + mv->fgColor.red = 1.0; + mv->fgColor.green = 1.0; + mv->fgColor.blue = 1.0; + mv->fgColor.alpha = 1.0; + + mv->cssProvider = gtk_css_provider_new(); + + mv->upDateTextViewStyle(); + + gtk_style_context_add_provider( gtk_widget_get_style_context( GTK_WIDGET(mv->textview) ), + GTK_STYLE_PROVIDER(mv->cssProvider), + GTK_STYLE_PROVIDER_PRIORITY_USER); + //gtk_style_context_add_provider_for_screen(gdk_screen_get_default(), + // GTK_STYLE_PROVIDER(cssProvider), + // GTK_STYLE_PROVIDER_PRIORITY_USER); + gtk_widget_show_all (mv->win); mv->showMemViewResults(1); From 8c04403062b722e01355766b0deccea2d031a8cf Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 30 May 2020 17:20:06 -0400 Subject: [PATCH 120/156] Added logic to allow for configurable coloring on memory view window. --- src/drivers/sdl/memview.cpp | 266 ++++++++++++++++++++++++------------ 1 file changed, 175 insertions(+), 91 deletions(-) diff --git a/src/drivers/sdl/memview.cpp b/src/drivers/sdl/memview.cpp index 700fee64..f6349197 100644 --- a/src/drivers/sdl/memview.cpp +++ b/src/drivers/sdl/memview.cpp @@ -128,7 +128,6 @@ struct memViewWin_t GtkWidget *memSelRadioItem[4]; GtkTextView *textview; GtkTextBuffer *textbuf; - GtkTextTag *highlight[ HIGHLIGHT_ACTIVITY_NUM_COLORS ]; GtkCssProvider *cssProvider; int selAddr; int selRomAddr; @@ -144,6 +143,7 @@ struct memViewWin_t GtkCellRenderer *hexByte_renderer[16]; bool redraw; bool useActivityColors; + bool actv_color_reverse_video; int (*memAccessFunc)( unsigned int offset); uint64 total_instructions_lp; @@ -183,6 +183,17 @@ struct memViewWin_t useActivityColors = 1; total_instructions_lp = 0; cssProvider = NULL; + actv_color_reverse_video = 1; + + bgColor.red = 1.0; + bgColor.green = 1.0; + bgColor.blue = 1.0; + bgColor.alpha = 1.0; + + fgColor.red = 0.0; + fgColor.green = 0.0; + fgColor.blue = 0.0; + fgColor.alpha = 1.0; for (int i=0; i<4; i++) { @@ -192,10 +203,6 @@ struct memViewWin_t { hexByte_renderer[i] = NULL; } - for (int i=0; i 0 ) - // { - // mbuf[addr].color--; - // valChg[i] = 1; - // } - //} - if ( mbuf[addr].actv ) { valChg[i] = mbuf[addr].actv; @@ -566,7 +562,14 @@ void memViewWin_t::showMemViewResults (int reset) if ( useActivityColors ) { - mbuf[addr].color = mbuf[addr].actv; + if ( actv_color_reverse_video ) + { + mbuf[addr].color = mbuf[addr].actv + HIGHLIGHT_ACTIVITY_NUM_COLORS; + } + else + { + mbuf[addr].color = mbuf[addr].actv; + } } un = ( c & 0x00f0 ) >> 4; @@ -599,7 +602,28 @@ void memViewWin_t::showMemViewResults (int reset) gtk_text_buffer_delete( textbuf, &iter, &next_iter ); } //gtk_text_buffer_insert( textbuf, &iter, valStr[i], -1 ); - gtk_text_buffer_insert_with_tags( textbuf, &iter, valStr[i], -1, highlight[ mbuf[addr].color ], NULL ); + if ( colorEnable ) + { + if ( activityColoringOn ) + { + if ( actv_color_reverse_video ) + { + gtk_text_buffer_insert_with_tags( textbuf, &iter, valStr[i], -1, colorList[ mbuf[addr].actv + HIGHLIGHT_ACTIVITY_NUM_COLORS ], NULL ); + } + else + { + gtk_text_buffer_insert_with_tags( textbuf, &iter, valStr[i], -1, colorList[ mbuf[addr].actv ], NULL ); + } + } + else + { + gtk_text_buffer_insert_with_tags( textbuf, &iter, valStr[i], -1, colorList[ mbuf[addr].color ], NULL ); + } + } + else + { + gtk_text_buffer_insert( textbuf, &iter, valStr[i], -1 ); + } } else { @@ -609,7 +633,6 @@ void memViewWin_t::showMemViewResults (int reset) gtk_text_buffer_remove_all_tags( textbuf, &iter, &next_iter ); } - gtk_text_iter_forward_chars( &iter, 4 ); } } @@ -723,34 +746,8 @@ int memViewWin_t::calcVisibleRange( int *start_out, int *end_out, int *center_ou end = numLines; } - //printf("Line Iter: %i -> %i\n", start, end ); - - //ivadj = gtk_range_get_adjustment( GTK_RANGE(ivbar) ); - - - //v = gtk_range_get_value( GTK_RANGE(ivbar) ); - //l = gtk_adjustment_get_lower( ivadj ); - //u = gtk_adjustment_get_upper( ivadj ); - - //r = (v - l) / (u - l); - - //start = ((int)( r * (double)numLines )) - 16; - - //if ( start < 0 ) - //{ - // start = 0; - //} - //end = start + 64; - - //if ( end > numLines ) - //{ - // end = numLines; - //} - center = start + (end - start)/2; - //printf(" Start:%i End:%i 0x%08x -> 0x%08x \n", start, end, start * 16, end * 16 ); - if ( start_out ) *start_out = start; if ( end_out ) *end_out = end; if ( center_out ) *center_out = center; @@ -784,21 +781,99 @@ int memViewWin_t::gotoLocation( int addr ) static void gdkColorConv( GdkRGBA *in, int *out ) { *out = 0; - *out |= ( (int)( (in->red * 256.0) ) & 0x00ff) << 16; - *out |= ( (int)( (in->green * 256.0) ) & 0x00ff) << 8; - *out |= ( (int)( (in->blue * 256.0) ) & 0x00ff); + *out |= ( (int)( (in->red * 255.0) ) & 0x00ff) << 16; + *out |= ( (int)( (in->green * 255.0) ) & 0x00ff) << 8; + *out |= ( (int)( (in->blue * 255.0) ) & 0x00ff); +} + +void memViewWin_t::initColors(void) +{ + GdkRGBA color, ivcolor; + GtkTextTag *tag; + float avg, grayScale; + + // Normal Activity Colors + for (int i=0; i> 8; + b = (highlightActivityColors[i] & 0x00ff0000) >> 16; + + color.red = (double)r / 255.0f; + color.green = (double)g / 255.0f; + color.blue = (double)b / 255.0f; + color.alpha = 1.0; + + tag = gtk_text_buffer_create_tag( textbuf, stmp, + "foreground-rgba", &color, NULL ); + + colorList.push_back( tag ); + } + + // Reverse Video Activity Colors + for (int i=0; i> 8; + b = (highlightActivityColors[i] & 0x00ff0000) >> 16; + + color.red = (double)r / 255.0f; + color.green = (double)g / 255.0f; + color.blue = (double)b / 255.0f; + color.alpha = 1.0; + + avg = (color.red + color.green + color.blue) / 3.0; + + if ( avg >= 0.5 ) + { + grayScale = 0.0; + } + else + { + grayScale = 1.0; + } + + ivcolor.red = grayScale; + ivcolor.green = grayScale; + ivcolor.blue = grayScale; + ivcolor.alpha = 1.0; + + //printf("%i R:%f G:%f B:%f \n", i, color.red, color.green, color.blue ); + + tag = gtk_text_buffer_create_tag( textbuf, stmp, + "background-rgba", &color, "foreground-rgba", &ivcolor, NULL ); + + colorList.push_back( tag ); + } + return; } int memViewWin_t::upDateTextViewStyle(void) { - char styleString[256]; + char styleString[512]; int fg, bg; gdkColorConv( &bgColor, &bg ); gdkColorConv( &fgColor, &fg ); sprintf( styleString, - "#hex_editor text { color: #%06X;\n background-color: #%06X;\n }", fg, bg ); +"#hex_editor text \ +{\ + color: #%06X;\ + background-color: #%06X; \ +}", fg, bg ); + + //printf("Style: %s\n", styleString ); gtk_css_provider_load_from_data(cssProvider, styleString, -1, NULL); @@ -894,6 +969,22 @@ static void openColorPicker_BG_CB (GtkMenuItem * item, memViewWin_t *mv) openColorPicker (mv,1); } +static void toggleActivityHighlight (GtkCheckMenuItem * item, memViewWin_t *mv) +{ + mv->useActivityColors = gtk_check_menu_item_get_active (item); + + //printf("ToggleMenu: %i\n", (int)toggleMenu); + //g_config->setOption ("SDL.ToggleMenu", (int) toggleMenu); +} + +static void toggleActivityReverseVideo (GtkCheckMenuItem * item, memViewWin_t *mv) +{ + mv->actv_color_reverse_video = gtk_check_menu_item_get_active (item); + + //printf("ToggleMenu: %i\n", (int)toggleMenu); + //g_config->setOption ("SDL.ToggleMenu", (int) toggleMenu); +} + static GtkWidget *CreateMemViewMenubar (memViewWin_t * mv) { GtkWidget *menubar, *menu, *item; @@ -971,6 +1062,31 @@ static GtkWidget *CreateMemViewMenubar (memViewWin_t * mv) g_signal_connect (item, "activate", G_CALLBACK (openColorPicker_BG_CB), (gpointer) mv); + //-HighLight ------------------ + item = gtk_menu_item_new_with_label ("Highlight"); + + gtk_menu_shell_append (GTK_MENU_SHELL (menubar), item); + + menu = gtk_menu_new (); + + gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), menu); + + //-HighLight --> Activity ------------------ + item = gtk_check_menu_item_new_with_label ("Activity"); + + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item ); + + g_signal_connect (item, "activate", G_CALLBACK (toggleActivityHighlight), + (gpointer) mv); + + //-HighLight --> Reverse Video ------------------ + item = gtk_check_menu_item_new_with_label ("Reverse Video"); + + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item ); + + g_signal_connect (item, "activate", G_CALLBACK (toggleActivityReverseVideo), + (gpointer) mv); + // Finally, return the actual menu bar created return menubar; } @@ -1402,7 +1518,6 @@ void openMemoryViewWindow (void) GtkWidget *scroll; GtkWidget *menubar; memViewWin_t *mv; - GdkRGBA color; mv = new memViewWin_t; @@ -1445,31 +1560,10 @@ void openMemoryViewWindow (void) mv->textbuf = gtk_text_view_get_buffer( mv->textview ); - //g_signal_connect (mv->textbuf, "insert-text", - // G_CALLBACK (textbuffer_string_insert), mv); g_signal_connect (G_OBJECT (mv->textview), "key-press-event", G_CALLBACK (textbuffer_string_insert), mv); - for (int i=0; i> 8; - b = (highlightActivityColors[i] & 0x00ff0000) >> 16; - - color.red = (double)r / 255.0f; - color.green = (double)g / 255.0f; - color.blue = (double)b / 255.0f; - color.alpha = 1.0; - - printf("%i R:%f G:%f B:%f \n", i, color.red, color.green, color.blue ); - - mv->highlight[i] = gtk_text_buffer_create_tag( mv->textbuf, stmp, "foreground-rgba", &color, NULL ); - } + mv->initColors(); scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), @@ -1502,16 +1596,6 @@ void openMemoryViewWindow (void) g_signal_connect (mv->win, "response", G_CALLBACK (closeMemoryViewWindow), mv); - mv->bgColor.red = 0.0; - mv->bgColor.green = 0.0; - mv->bgColor.blue = 0.0; - mv->bgColor.alpha = 1.0; - - mv->fgColor.red = 1.0; - mv->fgColor.green = 1.0; - mv->fgColor.blue = 1.0; - mv->fgColor.alpha = 1.0; - mv->cssProvider = gtk_css_provider_new(); mv->upDateTextViewStyle(); From 9eab3f9e5db6b284608fa5983436b9c616da8627 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 30 May 2020 19:44:30 -0400 Subject: [PATCH 121/156] Added logic to sync memview activity coloring menu options at startup. --- src/drivers/sdl/memview.cpp | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/drivers/sdl/memview.cpp b/src/drivers/sdl/memview.cpp index f6349197..1b40709c 100644 --- a/src/drivers/sdl/memview.cpp +++ b/src/drivers/sdl/memview.cpp @@ -941,7 +941,7 @@ static void openColorPicker (memViewWin_t *mv, int mode) GtkWidget *w; char title[256]; - printf("Open Color Picker \n"); + //printf("Open Color Picker \n"); if ( mode ) { @@ -1079,6 +1079,8 @@ static GtkWidget *CreateMemViewMenubar (memViewWin_t * mv) g_signal_connect (item, "activate", G_CALLBACK (toggleActivityHighlight), (gpointer) mv); + gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(item), mv->useActivityColors ); + //-HighLight --> Reverse Video ------------------ item = gtk_check_menu_item_new_with_label ("Reverse Video"); @@ -1087,6 +1089,8 @@ static GtkWidget *CreateMemViewMenubar (memViewWin_t * mv) g_signal_connect (item, "activate", G_CALLBACK (toggleActivityReverseVideo), (gpointer) mv); + gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(item), mv->actv_color_reverse_video ); + // Finally, return the actual menu bar created return menubar; } From 34e8afe39d82733feb0c665c7113fab6b35c85cb Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sun, 31 May 2020 06:48:37 -0400 Subject: [PATCH 122/156] Bug fix for memory view window when handling large ROM displays. --- src/drivers/sdl/memview.cpp | 101 +++++++++++++++++++----------------- 1 file changed, 52 insertions(+), 49 deletions(-) diff --git a/src/drivers/sdl/memview.cpp b/src/drivers/sdl/memview.cpp index 1b40709c..65afda5b 100644 --- a/src/drivers/sdl/memview.cpp +++ b/src/drivers/sdl/memview.cpp @@ -51,6 +51,7 @@ struct memByte_t unsigned char data; unsigned char color; unsigned char actv; + unsigned char draw; }; //******************************************************************************************************* // Memory View (Hex Editor) Window @@ -326,6 +327,7 @@ void memViewWin_t::initMem(void) mbuf[i].data = memAccessFunc(i); mbuf[i].color = 0; mbuf[i].actv = 0; + mbuf[i].draw = 1; } } @@ -351,11 +353,13 @@ int memViewWin_t::checkMemActivity(void) { mbuf[i].actv = 15; mbuf[i].data = c; + mbuf[i].draw = 1; } else { if ( mbuf[i].actv > 0 ) { + mbuf[i].draw = 1; mbuf[i].actv--; } } @@ -413,7 +417,7 @@ void memViewWin_t::showMemViewResults (int reset) int addr, memSize = 0; int lineAddr = 0, c, un, ln; int i, row, row_start, row_end, totalChars; - gint cpos; + gint cpos, textview_lines_allocated; char addrStr[128], valStr[16][8], ascii[18]; char addrChg, valChg[16], activityColoringOn, colorEnable; GtkTextIter iter, next_iter, start_iter, end_iter; @@ -495,9 +499,10 @@ void memViewWin_t::showMemViewResults (int reset) if ( reset ) { - gtk_text_buffer_get_bounds( textbuf, &start_iter, &end_iter ); + //gtk_text_buffer_get_bounds( textbuf, &start_iter, &end_iter ); - gtk_text_buffer_delete( textbuf, &start_iter, &end_iter ); + //gtk_text_buffer_delete( textbuf, &start_iter, &end_iter ); + gtk_text_buffer_set_text( textbuf, "", -1 ); row_start = 0; row_end = numLines; @@ -521,9 +526,15 @@ void memViewWin_t::showMemViewResults (int reset) totalChars = row_start * numCharsPerLine; + textview_lines_allocated = gtk_text_buffer_get_line_count( textbuf ) - 1; + for (row=row_start; row= textview_lines_allocated ) + { + reset = 1; + } addrChg = reset; @@ -555,21 +566,10 @@ void memViewWin_t::showMemViewResults (int reset) c = memAccessFunc(addr); - if ( mbuf[addr].actv ) + if ( mbuf[addr].draw ) { - valChg[i] = mbuf[addr].actv; - } - - if ( useActivityColors ) - { - if ( actv_color_reverse_video ) - { - mbuf[addr].color = mbuf[addr].actv + HIGHLIGHT_ACTIVITY_NUM_COLORS; - } - else - { - mbuf[addr].color = mbuf[addr].actv; - } + mbuf[addr].draw = 0; + valChg[i] = 1; } un = ( c & 0x00f0 ) >> 4; @@ -601,18 +601,24 @@ void memViewWin_t::showMemViewResults (int reset) gtk_text_buffer_delete( textbuf, &iter, &next_iter ); } - //gtk_text_buffer_insert( textbuf, &iter, valStr[i], -1 ); if ( colorEnable ) { if ( activityColoringOn ) { - if ( actv_color_reverse_video ) + if ( mbuf[addr].actv > 0 ) { - gtk_text_buffer_insert_with_tags( textbuf, &iter, valStr[i], -1, colorList[ mbuf[addr].actv + HIGHLIGHT_ACTIVITY_NUM_COLORS ], NULL ); + if ( actv_color_reverse_video ) + { + gtk_text_buffer_insert_with_tags( textbuf, &iter, valStr[i], -1, colorList[ mbuf[addr].actv + HIGHLIGHT_ACTIVITY_NUM_COLORS ], NULL ); + } + else + { + gtk_text_buffer_insert_with_tags( textbuf, &iter, valStr[i], -1, colorList[ mbuf[addr].actv ], NULL ); + } } else { - gtk_text_buffer_insert_with_tags( textbuf, &iter, valStr[i], -1, colorList[ mbuf[addr].actv ], NULL ); + gtk_text_buffer_insert( textbuf, &iter, valStr[i], -1 ); } } else @@ -627,13 +633,24 @@ void memViewWin_t::showMemViewResults (int reset) } else { - if ( !reset ) - { - gtk_text_iter_forward_chars( &next_iter, 4 ); + //if ( !reset ) + //{ + // next_iter = iter; - gtk_text_buffer_remove_all_tags( textbuf, &iter, &next_iter ); + // if ( gtk_text_iter_forward_chars( &next_iter, 4 ) == FALSE ) + // { + // return; + // } + + // //gtk_text_buffer_remove_all_tags( textbuf, &iter, &next_iter ); + // //gtk_text_buffer_delete( textbuf, &iter, &next_iter ); + + // //gtk_text_buffer_insert( textbuf, &iter, valStr[i], -1 ); + //} + if ( gtk_text_iter_forward_chars( &iter, 4 ) == FALSE) + { + return; } - gtk_text_iter_forward_chars( &iter, 4 ); } } ascii[16] = 0; @@ -645,14 +662,21 @@ void memViewWin_t::showMemViewResults (int reset) if ( !reset ) { next_iter = iter; - gtk_text_iter_forward_chars( &next_iter, 1 ); + + if ( gtk_text_iter_forward_chars( &next_iter, 1 ) == FALSE ) + { + return; + } gtk_text_buffer_delete( textbuf, &iter, &next_iter ); } gtk_text_buffer_insert( textbuf, &iter, &ascii[i], 1 ); } else { - gtk_text_iter_forward_chars( &iter, 1 ); + if ( gtk_text_iter_forward_chars( &iter, 1 ) == FALSE ) + { + return; + } } } @@ -666,24 +690,6 @@ void memViewWin_t::showMemViewResults (int reset) { gtk_text_iter_forward_chars( &iter, 1 ); } - //if ( row_changed ) - //{ - // if ( reset ) - // { - // gtk_text_buffer_get_iter_at_offset( textbuf, &iter, totalChars ); - // gtk_text_buffer_insert ( textbuf, &iter, line.c_str(), -1 ); - // } - // else - // { - // GtkTextIter next_iter; - - // gtk_text_buffer_get_iter_at_offset( textbuf, &next_iter, totalChars + numCharsPerLine - 1 ); - // gtk_text_buffer_delete ( textbuf, &iter, &next_iter ); - - // gtk_text_buffer_get_iter_at_offset( textbuf, &iter, totalChars ); - // gtk_text_buffer_insert ( textbuf, &iter, line.c_str(), line.size()-1 ); - // } - //} totalChars += numCharsPerLine; } @@ -1607,9 +1613,6 @@ void openMemoryViewWindow (void) gtk_style_context_add_provider( gtk_widget_get_style_context( GTK_WIDGET(mv->textview) ), GTK_STYLE_PROVIDER(mv->cssProvider), GTK_STYLE_PROVIDER_PRIORITY_USER); - //gtk_style_context_add_provider_for_screen(gdk_screen_get_default(), - // GTK_STYLE_PROVIDER(cssProvider), - // GTK_STYLE_PROVIDER_PRIORITY_USER); gtk_widget_show_all (mv->win); From 358a2309db250e5b24df159687452ec977d6cc96 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sun, 31 May 2020 10:11:52 -0400 Subject: [PATCH 123/156] Created separate debug menu for debugger and hex editor on main window. --- src/drivers/sdl/gui.cpp | 22 +++++++++++++++++++++- src/drivers/sdl/memview.cpp | 4 ++-- 2 files changed, 23 insertions(+), 3 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 4ef6d207..63f20ed4 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -2882,7 +2882,16 @@ static GtkWidget *CreateMenubar (GtkWidget * window) gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); - //-Tools --> Debugger --------------------- + //--------------------------------------- + // Create Debug Menu + item = gtk_menu_item_new_with_label ("Debug"); + + gtk_menu_shell_append (GTK_MENU_SHELL (menubar), item); + + menu = gtk_menu_new (); + + gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), menu); + //-Debugger --> Debugger --------------------- item = gtk_menu_item_new_with_label ("Debugger"); g_signal_connect (item, "activate", G_CALLBACK (openDebuggerWindow), @@ -2893,6 +2902,17 @@ static GtkWidget *CreateMenubar (GtkWidget * window) gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + //-Debug --> Hex Editor --------------------- + item = gtk_menu_item_new_with_label ("Hex Editor"); + + g_signal_connect (item, "activate", G_CALLBACK (openMemoryViewWindow), + NULL); + + //gtk_widget_add_accelerator( item, "activate", accel_group, + // GDK_KEY_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); + + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + //--------------------------------------- // Create Movie Menu item = gtk_menu_item_new_with_label ("Movie"); diff --git a/src/drivers/sdl/memview.cpp b/src/drivers/sdl/memview.cpp index 65afda5b..c89dbf3c 100644 --- a/src/drivers/sdl/memview.cpp +++ b/src/drivers/sdl/memview.cpp @@ -420,7 +420,7 @@ void memViewWin_t::showMemViewResults (int reset) gint cpos, textview_lines_allocated; char addrStr[128], valStr[16][8], ascii[18]; char addrChg, valChg[16], activityColoringOn, colorEnable; - GtkTextIter iter, next_iter, start_iter, end_iter; + GtkTextIter iter, next_iter; //, start_iter, end_iter; if ( redraw ) { @@ -627,7 +627,7 @@ void memViewWin_t::showMemViewResults (int reset) } } else - { + { // No Color Options Active, other than regular fore/back ground coloring. gtk_text_buffer_insert( textbuf, &iter, valStr[i], -1 ); } } From acbd2cf3c813280f700e8989850ca552d72929b1 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sun, 31 May 2020 13:48:58 -0400 Subject: [PATCH 124/156] Added logic to debugger to make breakpoint edit/delete button sensitive only when a breakpoint is selected in the tree view. --- src/drivers/sdl/debugger.cpp | 47 +++++++++++++++++++++++++++++------- 1 file changed, 38 insertions(+), 9 deletions(-) diff --git a/src/drivers/sdl/debugger.cpp b/src/drivers/sdl/debugger.cpp index dc8cfc92..3991cd17 100644 --- a/src/drivers/sdl/debugger.cpp +++ b/src/drivers/sdl/debugger.cpp @@ -94,6 +94,9 @@ struct debuggerWin_t GtkWidget *P_I_chkbox; GtkWidget *P_Z_chkbox; GtkWidget *P_C_chkbox; + GtkWidget *add_bp_button; + GtkWidget *edit_bp_button; + GtkWidget *del_bp_button; GtkWidget *stack_frame; GtkWidget *ppu_label; GtkWidget *sprite_label; @@ -156,6 +159,9 @@ struct debuggerWin_t bp_execute_chkbox = NULL; bp_enable_chkbox = NULL; bp_forbid_chkbox = NULL; + add_bp_button = NULL; + edit_bp_button = NULL; + del_bp_button = NULL; cpu_radio_btn = NULL; ppu_radio_btn = NULL; sprite_radio_btn = NULL; @@ -947,6 +953,22 @@ static void handleDialogResponse (GtkWidget * w, gint response_id, debuggerWin_t } +static void +tree_select_rowCB (GtkTreeView *treeview, + debuggerWin_t * dw ) +{ + int row, row_is_selected; + + row = dw->get_bpList_selrow(); + + row_is_selected = (row >= 0); + + //printf("Selected row = %i\n", row); + + gtk_widget_set_sensitive( dw->del_bp_button , row_is_selected ); + gtk_widget_set_sensitive( dw->edit_bp_button, row_is_selected ); +} + static void closeDialogWindow (GtkWidget * w, GdkEvent * e, debuggerWin_t * dw) { gtk_widget_destroy (w); @@ -1909,6 +1931,9 @@ void openDebuggerWindow (void) gtk_tree_view_new_with_model (GTK_TREE_MODEL (dw->bp_store)); + g_signal_connect (dw->bp_tree, "cursor-changed", + G_CALLBACK (tree_select_rowCB), (gpointer) dw); + gtk_tree_view_set_grid_lines (GTK_TREE_VIEW (dw->bp_tree), GTK_TREE_VIEW_GRID_LINES_VERTICAL); @@ -1939,26 +1964,30 @@ void openDebuggerWindow (void) gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 1); - button = gtk_button_new_with_label ("Add"); + dw->add_bp_button = gtk_button_new_with_label ("Add"); - g_signal_connect (button, "clicked", + g_signal_connect (dw->add_bp_button, "clicked", G_CALLBACK (addBreakpointCB), (gpointer) dw); - gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 2); + gtk_box_pack_start (GTK_BOX (hbox), dw->add_bp_button, TRUE, TRUE, 2); - button = gtk_button_new_with_label ("Delete"); + dw->del_bp_button = gtk_button_new_with_label ("Delete"); - g_signal_connect (button, "clicked", + gtk_widget_set_sensitive( dw->del_bp_button, FALSE ); + + g_signal_connect (dw->del_bp_button, "clicked", G_CALLBACK (deleteBreakpointCB), (gpointer) dw); - gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 2); + gtk_box_pack_start (GTK_BOX (hbox), dw->del_bp_button, TRUE, TRUE, 2); - button = gtk_button_new_with_label ("Edit"); + dw->edit_bp_button = gtk_button_new_with_label ("Edit"); - g_signal_connect (button, "clicked", + gtk_widget_set_sensitive( dw->edit_bp_button, FALSE ); + + g_signal_connect (dw->edit_bp_button, "clicked", G_CALLBACK (editBreakpointCB), (gpointer) dw); - gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 2); + gtk_box_pack_start (GTK_BOX (hbox), dw->edit_bp_button, TRUE, TRUE, 2); dw->badop_chkbox = gtk_check_button_new_with_label("Break on Bad Opcodes"); g_signal_connect (dw->badop_chkbox, "toggled", From 8a0165f54bcd00627b1a20aa6e4d841bb3ba6dcf Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sun, 31 May 2020 13:53:07 -0400 Subject: [PATCH 125/156] changed unimplemented functions on debugger window to be have insensitive widgets for now. --- src/drivers/sdl/debugger.cpp | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/drivers/sdl/debugger.cpp b/src/drivers/sdl/debugger.cpp index 3991cd17..c9da90b8 100644 --- a/src/drivers/sdl/debugger.cpp +++ b/src/drivers/sdl/debugger.cpp @@ -2147,8 +2147,10 @@ void openDebuggerWindow (void) button = gtk_button_new_with_label ("Add"); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 2); button = gtk_button_new_with_label ("Delete"); + gtk_widget_set_sensitive( button , FALSE ); // TODO Insensitive until functionality implemented gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 2); button = gtk_button_new_with_label ("Name"); + gtk_widget_set_sensitive( button , FALSE ); // TODO Insensitive until functionality implemented gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (hbox2), frame, TRUE, TRUE, 2); @@ -2165,12 +2167,16 @@ void openDebuggerWindow (void) G_CALLBACK (romOffsetToggleCB), dw); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 2); button = gtk_check_button_new_with_label("Symbolic Debug"); + gtk_widget_set_sensitive( button , FALSE ); // TODO Insensitive until functionality implemented gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 2); button = gtk_check_button_new_with_label("Register Names"); + gtk_widget_set_sensitive( button , FALSE ); // TODO Insensitive until functionality implemented gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 2); button = gtk_button_new_with_label ("Reload Symbols"); + gtk_widget_set_sensitive( button , FALSE ); // TODO Insensitive until functionality implemented gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 2); button = gtk_button_new_with_label ("ROM Patcher"); + gtk_widget_set_sensitive( button , FALSE ); // TODO Insensitive until functionality implemented gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (vbox1), hbox2, TRUE, TRUE, 2); From 51be2877ef3e4f0a3fe1afc5250be101bbd37278 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sun, 31 May 2020 14:28:49 -0400 Subject: [PATCH 126/156] Added logic to set registers via text entry boxes prior to running new instructions in debugger window. --- src/drivers/sdl/debugger.cpp | 89 +++++++++++++++++++++++++++++++++--- 1 file changed, 82 insertions(+), 7 deletions(-) diff --git a/src/drivers/sdl/debugger.cpp b/src/drivers/sdl/debugger.cpp index c9da90b8..a9573928 100644 --- a/src/drivers/sdl/debugger.cpp +++ b/src/drivers/sdl/debugger.cpp @@ -202,10 +202,19 @@ struct debuggerWin_t int scrollAsmLine(int line); int seekAsmPC(void); int seekAsmAddr(int addr); + void setRegsFromEntry(void); }; static std::list debuggerWinList; +void debuggerWin_t::setRegsFromEntry(void) +{ + X.PC = strtol( gtk_entry_get_text( GTK_ENTRY( pc_entry ) ), NULL, 16 ); + X.A = strtol( gtk_entry_get_text( GTK_ENTRY( A_entry ) ), NULL, 16 ); + X.X = strtol( gtk_entry_get_text( GTK_ENTRY( X_entry ) ), NULL, 16 ); + X.Y = strtol( gtk_entry_get_text( GTK_ENTRY( Y_entry ) ), NULL, 16 ); +} + void debuggerWin_t::asmClear(void) { for (size_t i=0; isetRegsFromEntry(); FCEUI_ToggleEmulationPause(); //DebuggerWasUpdated = false done in above function; } @@ -1292,6 +1301,10 @@ static void debugRunCB (GtkButton * button, debuggerWin_t * dw) static void debugStepIntoCB (GtkButton * button, debuggerWin_t * dw) { + if (FCEUI_EmulationPaused()) + { + dw->setRegsFromEntry(); + } FCEUI_Debugger().step = true; FCEUI_SetEmulationPaused(0); } @@ -1301,7 +1314,7 @@ static void debugStepOutCB (GtkButton * button, debuggerWin_t * dw) if (FCEUI_EmulationPaused() > 0) { DebuggerState &dbgstate = FCEUI_Debugger(); - //UpdateRegs(hwndDlg); + dw->setRegsFromEntry(); if (dbgstate.stepout) { printf("Step Out is currently in process.\n"); @@ -1324,7 +1337,7 @@ static void debugStepOverCB (GtkButton * button, debuggerWin_t * dw) { if (FCEUI_EmulationPaused()) { - //UpdateRegs(hwndDlg); + dw->setRegsFromEntry(); int tmp=X.PC; uint8 opcode = GetMem(X.PC); bool jsr = opcode==0x20; @@ -1355,6 +1368,10 @@ static void debugStepOverCB (GtkButton * button, debuggerWin_t * dw) } static void debugRunLineCB (GtkButton * button, debuggerWin_t * dw) { + if (FCEUI_EmulationPaused()) + { + dw->setRegsFromEntry(); + } uint64 ts=timestampbase; ts+=timestamp; ts+=341/3; @@ -1367,10 +1384,10 @@ static void debugRunLineCB (GtkButton * button, debuggerWin_t * dw) static void debugRunLine128CB (GtkButton * button, debuggerWin_t * dw) { - //if (FCEUI_EmulationPaused()) - //{ - // UpdateRegs(hwndDlg); - //} + if (FCEUI_EmulationPaused()) + { + dw->setRegsFromEntry(); + } FCEUI_Debugger().runline = true; { uint64 ts=timestampbase; @@ -1385,6 +1402,11 @@ static void debugRunLine128CB (GtkButton * button, debuggerWin_t * dw) static void seekPCCB (GtkButton * button, debuggerWin_t * dw) { + if (FCEUI_EmulationPaused()) + { + dw->setRegsFromEntry(); + updateAllDebugWindows(); + } dw->seekAsmPC(); } @@ -1393,6 +1415,10 @@ static void seekToCB (GtkButton * button, debuggerWin_t * dw) int addr; const char *txt; + if (FCEUI_EmulationPaused()) + { + dw->setRegsFromEntry(); + } txt = gtk_entry_get_text( GTK_ENTRY(dw->seektoEntry) ); addr = offsetStringToInt( BT_C, txt ); @@ -1400,6 +1426,39 @@ static void seekToCB (GtkButton * button, debuggerWin_t * dw) dw->seekAsmAddr(addr); } +static void Flag_N_CB (GtkToggleButton * button, debuggerWin_t * dw) +{ + X.P ^= N_FLAG; +} +static void Flag_V_CB (GtkToggleButton * button, debuggerWin_t * dw) +{ + X.P ^= V_FLAG; +} +static void Flag_U_CB (GtkToggleButton * button, debuggerWin_t * dw) +{ + X.P ^= U_FLAG; +} +static void Flag_B_CB (GtkToggleButton * button, debuggerWin_t * dw) +{ + X.P ^= B_FLAG; +} +static void Flag_D_CB (GtkToggleButton * button, debuggerWin_t * dw) +{ + X.P ^= D_FLAG; +} +static void Flag_I_CB (GtkToggleButton * button, debuggerWin_t * dw) +{ + X.P ^= I_FLAG; +} +static void Flag_Z_CB (GtkToggleButton * button, debuggerWin_t * dw) +{ + X.P ^= Z_FLAG; +} +static void Flag_C_CB (GtkToggleButton * button, debuggerWin_t * dw) +{ + X.P ^= C_FLAG; +} + static void addBreakpointMenuCB (GtkMenuItem *menuitem, debuggerWin_t * dw) @@ -2005,27 +2064,43 @@ void openDebuggerWindow (void) gtk_grid_set_column_spacing( GTK_GRID(grid), 10 ); dw->P_N_chkbox = gtk_check_button_new_with_label("N"); + g_signal_connect (dw->P_N_chkbox, "toggled", + G_CALLBACK (Flag_N_CB), dw); gtk_grid_attach( GTK_GRID(grid), dw->P_N_chkbox, 0, 0, 1, 1 ); dw->P_V_chkbox = gtk_check_button_new_with_label("V"); + g_signal_connect (dw->P_V_chkbox, "toggled", + G_CALLBACK (Flag_V_CB), dw); gtk_grid_attach( GTK_GRID(grid), dw->P_V_chkbox, 1, 0, 1, 1 ); dw->P_U_chkbox = gtk_check_button_new_with_label("U"); + g_signal_connect (dw->P_U_chkbox, "toggled", + G_CALLBACK (Flag_U_CB), dw); gtk_grid_attach( GTK_GRID(grid), dw->P_U_chkbox, 2, 0, 1, 1 ); dw->P_B_chkbox = gtk_check_button_new_with_label("B"); + g_signal_connect (dw->P_B_chkbox, "toggled", + G_CALLBACK (Flag_B_CB), dw); gtk_grid_attach( GTK_GRID(grid), dw->P_B_chkbox, 3, 0, 1, 1 ); dw->P_D_chkbox = gtk_check_button_new_with_label("D"); + g_signal_connect (dw->P_D_chkbox, "toggled", + G_CALLBACK (Flag_D_CB), dw); gtk_grid_attach( GTK_GRID(grid), dw->P_D_chkbox, 0, 1, 1, 1 ); dw->P_I_chkbox = gtk_check_button_new_with_label("I"); + g_signal_connect (dw->P_I_chkbox, "toggled", + G_CALLBACK (Flag_I_CB), dw); gtk_grid_attach( GTK_GRID(grid), dw->P_I_chkbox, 1, 1, 1, 1 ); dw->P_Z_chkbox = gtk_check_button_new_with_label("Z"); + g_signal_connect (dw->P_Z_chkbox, "toggled", + G_CALLBACK (Flag_Z_CB), dw); gtk_grid_attach( GTK_GRID(grid), dw->P_Z_chkbox, 2, 1, 1, 1 ); dw->P_C_chkbox = gtk_check_button_new_with_label("C"); + g_signal_connect (dw->P_C_chkbox, "toggled", + G_CALLBACK (Flag_C_CB), dw); gtk_grid_attach( GTK_GRID(grid), dw->P_C_chkbox, 3, 1, 1, 1 ); gtk_container_add (GTK_CONTAINER (frame), grid); From 1ace69f5f9c1c026036dd5238c8824ff4259a7dc Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sun, 31 May 2020 14:53:54 -0400 Subject: [PATCH 127/156] Updated cheat list tree view to update entry fields when a line in the tree is selected with corresponding to the selected lines data. --- src/drivers/sdl/cheat.cpp | 152 ++++++++++++++++++++++++++++++++------ 1 file changed, 130 insertions(+), 22 deletions(-) diff --git a/src/drivers/sdl/cheat.cpp b/src/drivers/sdl/cheat.cpp index 763aeeaa..f396b1a8 100644 --- a/src/drivers/sdl/cheat.cpp +++ b/src/drivers/sdl/cheat.cpp @@ -61,6 +61,10 @@ class cheat_win_t GtkWidget *neq_chkbox; GtkWidget *lt_chkbox; GtkWidget *gt_chkbox; + GtkWidget *cheat_name_entry; + GtkWidget *cheat_addr_entry; + GtkWidget *cheat_val_entry; + GtkWidget *cheat_cmp_entry; cheat_win_t (void) { @@ -81,10 +85,15 @@ class cheat_win_t neq_chkbox = NULL; lt_chkbox = NULL; gt_chkbox = NULL; + cheat_name_entry = NULL; + cheat_addr_entry = NULL; + cheat_val_entry = NULL; + cheat_cmp_entry = NULL; } void showActiveCheatList (bool reset); void showCheatSearchResults (void); + int getSelCheatRow(void); }; static cheat_win_t *curr_cw = NULL; @@ -359,6 +368,51 @@ void cheat_win_t::showActiveCheatList (bool reset) actv_cheat_redraw = false; } +int cheat_win_t::getSelCheatRow(void) +{ + int numListRows, retval = -1; + GList *selListRows, *tmpList; + GtkTreeModel *model = NULL; + GtkTreeSelection *treeSel; + + treeSel = + gtk_tree_view_get_selection (GTK_TREE_VIEW + (actv_cheat_tree)); + + numListRows = gtk_tree_selection_count_selected_rows (treeSel); + + if (numListRows == 0) + { + return -1; + } + //printf("Number of Rows Selected: %i\n", numListRows ); + + selListRows = gtk_tree_selection_get_selected_rows (treeSel, &model); + + tmpList = selListRows; + + while (tmpList) + { + int depth; + int *indexArray; + GtkTreePath *path = (GtkTreePath *) tmpList->data; + + depth = gtk_tree_path_get_depth (path); + indexArray = gtk_tree_path_get_indices (path); + + if (depth > 0) + { + retval = indexArray[0]; + } + + tmpList = tmpList->next; + } + + g_list_free_full (selListRows, (GDestroyNotify) gtk_tree_path_free); + + return retval; +} + static void cheatListEnableToggle (GtkCellRendererToggle * renderer, gchar * pathStr, cheat_win_t * cw) { @@ -389,6 +443,57 @@ static void cheatListEnableToggle (GtkCellRendererToggle * renderer, } +static void +cheat_select_rowCB (GtkTreeView *treeview, + cheat_win_t * cw ) +{ + int row, row_is_selected; + + row = cw->getSelCheatRow(); + + row_is_selected = (row >= 0); + + //printf("Selected row = %i\n", row); + + if ( !row_is_selected ) + { + return; + } + uint32 a; + uint8 v; + int c, s, type; + char *name = NULL; + + if (FCEUI_GetCheat (row, &name, &a, &v, &c, &s, &type)) + { + char txt[64]; + + if ( name ) + { + gtk_entry_set_text( GTK_ENTRY(cw->cheat_name_entry), name ); + } + + sprintf( txt, "%04X", a ); + gtk_entry_set_text( GTK_ENTRY(cw->cheat_addr_entry), txt ); + + sprintf( txt, "%02X", v ); + gtk_entry_set_text( GTK_ENTRY(cw->cheat_val_entry), txt ); + + if ( c >= 0 ) + { + sprintf( txt, "%02X", c ); + } + else + { + txt[0] = 0; + } + gtk_entry_set_text( GTK_ENTRY(cw->cheat_cmp_entry), txt ); + } + + //gtk_widget_set_sensitive( dw->del_bp_button , row_is_selected ); + //gtk_widget_set_sensitive( dw->edit_bp_button, row_is_selected ); +} + static void openCheatFile (GtkWidget * widget, cheat_win_t * cw) { GtkWidget *fileChooser; @@ -840,6 +945,9 @@ void openCheatsWindow (void) GtkCellRenderer *chkbox_renderer; GtkTreeViewColumn *column; + g_signal_connect (cw->actv_cheat_tree, "cursor-changed", + G_CALLBACK (cheat_select_rowCB), (gpointer) cw); + gtk_tree_view_set_grid_lines (GTK_TREE_VIEW (cw->actv_cheat_tree), GTK_TREE_VIEW_GRID_LINES_VERTICAL); @@ -904,57 +1012,57 @@ void openCheatsWindow (void) hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); label = gtk_label_new ("Name:"); - txt_entry = gtk_entry_new (); + cw->cheat_name_entry = gtk_entry_new (); - g_signal_connect (txt_entry, "activate", + g_signal_connect (cw->cheat_name_entry, "activate", G_CALLBACK (newCheatEntryCB4), (void *) cw); - g_signal_connect (txt_entry, "changed", + g_signal_connect (cw->cheat_name_entry, "changed", G_CALLBACK (newCheatEntryCB4), (void *) cw); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 1); - gtk_box_pack_start (GTK_BOX (hbox), txt_entry, TRUE, TRUE, 1); + gtk_box_pack_start (GTK_BOX (hbox), cw->cheat_name_entry, TRUE, TRUE, 1); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 1); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("Addr:"); - txt_entry = gtk_entry_new (); - gtk_entry_set_max_length (GTK_ENTRY (txt_entry), 4); - gtk_entry_set_width_chars (GTK_ENTRY (txt_entry), 4); + cw->cheat_addr_entry = gtk_entry_new (); + gtk_entry_set_max_length (GTK_ENTRY (cw->cheat_addr_entry), 4); + gtk_entry_set_width_chars (GTK_ENTRY (cw->cheat_addr_entry), 4); - g_signal_connect (txt_entry, "activate", + g_signal_connect (cw->cheat_addr_entry, "activate", G_CALLBACK (newCheatEntryCB1), (void *) cw); - g_signal_connect (txt_entry, "changed", + g_signal_connect (cw->cheat_addr_entry, "changed", G_CALLBACK (newCheatEntryCB1), (void *) cw); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 1); - gtk_box_pack_start (GTK_BOX (hbox), txt_entry, TRUE, TRUE, 1); + gtk_box_pack_start (GTK_BOX (hbox), cw->cheat_addr_entry, TRUE, TRUE, 1); label = gtk_label_new ("Val:"); - txt_entry = gtk_entry_new (); - gtk_entry_set_max_length (GTK_ENTRY (txt_entry), 2); - gtk_entry_set_width_chars (GTK_ENTRY (txt_entry), 2); + cw->cheat_val_entry = gtk_entry_new (); + gtk_entry_set_max_length (GTK_ENTRY (cw->cheat_val_entry), 2); + gtk_entry_set_width_chars (GTK_ENTRY (cw->cheat_val_entry), 2); - g_signal_connect (txt_entry, "activate", + g_signal_connect (cw->cheat_val_entry, "activate", G_CALLBACK (newCheatEntryCB2), (void *) cw); - g_signal_connect (txt_entry, "changed", + g_signal_connect (cw->cheat_val_entry, "changed", G_CALLBACK (newCheatEntryCB2), (void *) cw); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 1); - gtk_box_pack_start (GTK_BOX (hbox), txt_entry, TRUE, TRUE, 1); + gtk_box_pack_start (GTK_BOX (hbox), cw->cheat_val_entry, TRUE, TRUE, 1); label = gtk_label_new ("Cmp:"); - txt_entry = gtk_entry_new (); - gtk_entry_set_max_length (GTK_ENTRY (txt_entry), 2); - gtk_entry_set_width_chars (GTK_ENTRY (txt_entry), 2); + cw->cheat_cmp_entry = gtk_entry_new (); + gtk_entry_set_max_length (GTK_ENTRY (cw->cheat_cmp_entry), 2); + gtk_entry_set_width_chars (GTK_ENTRY (cw->cheat_cmp_entry), 2); - g_signal_connect (txt_entry, "activate", + g_signal_connect (cw->cheat_cmp_entry, "activate", G_CALLBACK (newCheatEntryCB3), (void *) cw); - g_signal_connect (txt_entry, "changed", + g_signal_connect (cw->cheat_cmp_entry, "changed", G_CALLBACK (newCheatEntryCB3), (void *) cw); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 1); - gtk_box_pack_start (GTK_BOX (hbox), txt_entry, TRUE, TRUE, 1); + gtk_box_pack_start (GTK_BOX (hbox), cw->cheat_cmp_entry, TRUE, TRUE, 1); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 1); From a58f5dc5e0d8eb57f203aa962fd179d3840de931 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Mon, 1 Jun 2020 09:19:55 -0400 Subject: [PATCH 128/156] Added logic to make cheat window edit/delete buttons insensitive unless a row is selected in treeview list. --- src/drivers/sdl/cheat.cpp | 29 ++++++++++++++++++++++------- 1 file changed, 22 insertions(+), 7 deletions(-) diff --git a/src/drivers/sdl/cheat.cpp b/src/drivers/sdl/cheat.cpp index f396b1a8..37609d71 100644 --- a/src/drivers/sdl/cheat.cpp +++ b/src/drivers/sdl/cheat.cpp @@ -56,6 +56,7 @@ class cheat_win_t bool pauseWhileCheatsActv; bool actv_cheat_redraw; + GtkWidget *win; GtkWidget *actv_cheat_tree; GtkWidget *search_cheat_tree; GtkWidget *neq_chkbox; @@ -65,9 +66,12 @@ class cheat_win_t GtkWidget *cheat_addr_entry; GtkWidget *cheat_val_entry; GtkWidget *cheat_cmp_entry; + GtkWidget *cheat_del_button; + GtkWidget *cheat_edit_button; cheat_win_t (void) { + win = NULL; actv_cheats_store = NULL; ram_match_store = NULL; cheat_search_known_value = 0; @@ -89,6 +93,8 @@ class cheat_win_t cheat_addr_entry = NULL; cheat_val_entry = NULL; cheat_cmp_entry = NULL; + cheat_del_button = NULL; + cheat_edit_button = NULL; } void showActiveCheatList (bool reset); @@ -454,6 +460,9 @@ cheat_select_rowCB (GtkTreeView *treeview, row_is_selected = (row >= 0); //printf("Selected row = %i\n", row); + // + gtk_widget_set_sensitive( cw->cheat_del_button , row_is_selected ); + gtk_widget_set_sensitive( cw->cheat_edit_button, row_is_selected ); if ( !row_is_selected ) { @@ -511,7 +520,7 @@ static void openCheatFile (GtkWidget * widget, cheat_win_t * cw) fileChooser = gtk_file_chooser_dialog_new ("Open Cheat", - GTK_WINDOW (MainWindow), + GTK_WINDOW (cw->win), GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel", GTK_RESPONSE_CANCEL, "_Open", GTK_RESPONSE_ACCEPT, @@ -927,6 +936,8 @@ void openCheatsWindow (void) "_Close", GTK_RESPONSE_OK, NULL); gtk_window_set_default_size (GTK_WINDOW (win), 600, 600); + cw->win = win; + main_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5); frame = gtk_frame_new ("Active Cheats"); @@ -1073,16 +1084,20 @@ void openCheatsWindow (void) g_signal_connect (button, "clicked", G_CALLBACK (addCheat2Active), (gpointer) cw); - button = gtk_button_new_with_label ("Delete"); - gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, FALSE, 1); + cw->cheat_del_button = gtk_button_new_with_label ("Delete"); + gtk_box_pack_start (GTK_BOX (hbox), cw->cheat_del_button, TRUE, FALSE, 1); - g_signal_connect (button, "clicked", + gtk_widget_set_sensitive( cw->cheat_del_button, FALSE ); + + g_signal_connect (cw->cheat_del_button, "clicked", G_CALLBACK (removeCheatFromActive), (gpointer) cw); - button = gtk_button_new_with_label ("Update"); - gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, FALSE, 1); + cw->cheat_edit_button = gtk_button_new_with_label ("Update"); + gtk_box_pack_start (GTK_BOX (hbox), cw->cheat_edit_button, TRUE, FALSE, 1); - g_signal_connect (button, "clicked", + gtk_widget_set_sensitive( cw->cheat_edit_button, FALSE ); + + g_signal_connect (cw->cheat_edit_button, "clicked", G_CALLBACK (updateCheatList), (gpointer) cw); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 1); From f929a7cc238cd9fd6c0baa20ae00a34cdca3b16d Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Mon, 1 Jun 2020 09:32:51 -0400 Subject: [PATCH 129/156] Added logic to cheat search window to make all sorting buttons insentive until the search reset button is hit once. --- src/drivers/sdl/cheat.cpp | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/src/drivers/sdl/cheat.cpp b/src/drivers/sdl/cheat.cpp index 37609d71..bb8a337b 100644 --- a/src/drivers/sdl/cheat.cpp +++ b/src/drivers/sdl/cheat.cpp @@ -68,6 +68,11 @@ class cheat_win_t GtkWidget *cheat_cmp_entry; GtkWidget *cheat_del_button; GtkWidget *cheat_edit_button; + GtkWidget *cheat_search_known_btn; + GtkWidget *cheat_search_eq_btn; + GtkWidget *cheat_search_neq_btn; + GtkWidget *cheat_search_gr_btn; + GtkWidget *cheat_search_lt_btn; cheat_win_t (void) { @@ -95,6 +100,11 @@ class cheat_win_t cheat_cmp_entry = NULL; cheat_del_button = NULL; cheat_edit_button = NULL; + cheat_search_known_btn = NULL; + cheat_search_eq_btn = NULL; + cheat_search_neq_btn = NULL; + cheat_search_gr_btn = NULL; + cheat_search_lt_btn = NULL; } void showActiveCheatList (bool reset); @@ -150,6 +160,12 @@ static void cheatSearchReset (GtkButton * button, cheat_win_t * cw) //cheat_search_gt_value = 0; //cheat_search_lt_value = 0; + gtk_widget_set_sensitive( cw->cheat_search_known_btn , TRUE ); + gtk_widget_set_sensitive( cw->cheat_search_eq_btn , TRUE ); + gtk_widget_set_sensitive( cw->cheat_search_neq_btn , TRUE ); + gtk_widget_set_sensitive( cw->cheat_search_gr_btn , TRUE ); + gtk_widget_set_sensitive( cw->cheat_search_lt_btn , TRUE ); + FCEUI_CheatSearchBegin (); cw->showCheatSearchResults (); // Enable Cheat Search Buttons - Change Sensitivity @@ -1125,6 +1141,7 @@ void openCheatsWindow (void) hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3); button = gtk_button_new_with_label ("Known Value:"); + cw->cheat_search_known_btn = button; g_signal_connect (button, "clicked", G_CALLBACK (cheatSearchKnown), (gpointer) cw); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 5); @@ -1156,6 +1173,7 @@ void openCheatsWindow (void) hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 1); button = gtk_button_new_with_label ("Equal"); + cw->cheat_search_eq_btn = button; //gtk_widget_set_halign( button, GTK_ALIGN_BASELINE); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5); @@ -1165,6 +1183,7 @@ void openCheatsWindow (void) hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); button = gtk_button_new_with_label ("Not Equal"); + cw->cheat_search_neq_btn = button; //gtk_widget_set_halign( button, GTK_ALIGN_BASELINE); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5); cw->neq_chkbox = gtk_check_button_new (); @@ -1186,6 +1205,7 @@ void openCheatsWindow (void) hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); button = gtk_button_new_with_label ("Greater Than"); + cw->cheat_search_gr_btn = button; //gtk_widget_set_halign( button, GTK_ALIGN_BASELINE); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5); cw->gt_chkbox = gtk_check_button_new (); @@ -1207,6 +1227,7 @@ void openCheatsWindow (void) hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); button = gtk_button_new_with_label ("Less Than"); + cw->cheat_search_lt_btn = button; //gtk_widget_set_halign( button, GTK_ALIGN_BASELINE); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5); cw->lt_chkbox = gtk_check_button_new (); @@ -1229,6 +1250,12 @@ void openCheatsWindow (void) hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 1); + gtk_widget_set_sensitive( cw->cheat_search_known_btn , FALSE ); + gtk_widget_set_sensitive( cw->cheat_search_eq_btn , FALSE ); + gtk_widget_set_sensitive( cw->cheat_search_neq_btn , FALSE ); + gtk_widget_set_sensitive( cw->cheat_search_gr_btn , FALSE ); + gtk_widget_set_sensitive( cw->cheat_search_lt_btn , FALSE ); + frame = gtk_frame_new ("Cheat Search"); gtk_container_add (GTK_CONTAINER (frame), hbox); gtk_box_pack_start (GTK_BOX (main_hbox), frame, TRUE, TRUE, 5); From a25a5c914ccf2664592b338e3a801d6211415a3f Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Mon, 1 Jun 2020 09:37:36 -0400 Subject: [PATCH 130/156] Added a refresh list button to the active cheat list window to allow for the displayed list to be resync'd to the true active cheat list in case a new game ROM is loaded and new cheats are automatically loaded as a result. --- src/drivers/sdl/cheat.cpp | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/src/drivers/sdl/cheat.cpp b/src/drivers/sdl/cheat.cpp index bb8a337b..2cf3f91e 100644 --- a/src/drivers/sdl/cheat.cpp +++ b/src/drivers/sdl/cheat.cpp @@ -518,6 +518,10 @@ cheat_select_rowCB (GtkTreeView *treeview, //gtk_widget_set_sensitive( dw->del_bp_button , row_is_selected ); //gtk_widget_set_sensitive( dw->edit_bp_button, row_is_selected ); } +static void refreshCheatListCB(GtkWidget * widget, cheat_win_t * cw) +{ + updateAllActvCheatLists (1); +} static void openCheatFile (GtkWidget * widget, cheat_win_t * cw) { @@ -1118,7 +1122,12 @@ void openCheatsWindow (void) gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 1); - hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 1); + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); + button = gtk_button_new_with_label ("Refresh List"); + gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, FALSE, 1); + g_signal_connect (button, "clicked", + G_CALLBACK (refreshCheatListCB), (gpointer) cw); + button = gtk_button_new_with_label ("Add from CHT file..."); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, FALSE, 1); g_signal_connect (button, "clicked", From a59f1421b58b0c3cc7879cbf34238570cecc1ca3 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Tue, 2 Jun 2020 05:02:43 -0400 Subject: [PATCH 131/156] Added logic to refresh video display with last pass image data when inside debug loop. --- src/drivers/sdl/debugger.cpp | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/drivers/sdl/debugger.cpp b/src/drivers/sdl/debugger.cpp index a9573928..4aeb27ab 100644 --- a/src/drivers/sdl/debugger.cpp +++ b/src/drivers/sdl/debugger.cpp @@ -20,6 +20,7 @@ #include "../../debug.h" #include "../../driver.h" #include "../../version.h" +#include "../../video.h" #include "../../movie.h" #include "../../palette.h" #include "../../fds.h" @@ -1672,6 +1673,11 @@ static void winDebuggerLoopStep(void) gtk_main_iteration_do(FALSE); } + if ( XBackBuf ) + { + BlitScreen(XBackBuf); + } + if ( breakpoint_hit ) { seekPC_AllDebugWindows(); From 1fc0725e9469f371a29d24699b864f73a7d595ee Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Fri, 5 Jun 2020 21:08:53 -0400 Subject: [PATCH 132/156] Successful display of graphics using cairo. Not as efficient as other methods but works. --- SConstruct | 2 +- src/drivers/sdl/gui.cpp | 161 ++++++++++++- src/drivers/sdl/gui.h | 5 +- src/drivers/sdl/input.cpp | 94 ++++---- src/drivers/sdl/input.h | 3 +- src/drivers/sdl/sdl-opengl.cpp | 28 +++ src/drivers/sdl/sdl-opengl.h | 11 +- src/drivers/sdl/sdl-video.cpp | 404 ++++++++++++++++++++++++++++----- 8 files changed, 589 insertions(+), 119 deletions(-) diff --git a/SConstruct b/SConstruct index a5e5ec1c..97b30bce 100644 --- a/SConstruct +++ b/SConstruct @@ -28,7 +28,7 @@ opts.AddVariables( BoolVariable('SYSTEM_MINIZIP', 'Use system minizip instead of static minizip provided with fceux', 0), BoolVariable('LSB_FIRST', 'Least signficant byte first (non-PPC)', 1), BoolVariable('CLANG', 'Compile with llvm-clang instead of gcc', 0), - BoolVariable('SDL2', 'Compile using SDL2 instead of SDL 1.2 (experimental/non-functional)', 0) + BoolVariable('SDL2', 'Compile using SDL2 instead of SDL 1.2 (experimental/non-functional)', 1) ) AddOption('--prefix', dest='prefix', type='string', nargs=1, action='store', metavar='DIR', help='installation prefix') diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 63f20ed4..0402b086 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -72,6 +72,7 @@ static unsigned int gtk_win_width = 0; static unsigned int gtk_win_height = 0; static int gtk_win_menu_ysize = 30; static GtkTreeStore *hotkey_store = NULL; +static cairo_surface_t *cairo_surface = NULL; static gint convertKeypress (GtkWidget * grab, GdkEventKey * event, gpointer user_data); @@ -2215,7 +2216,7 @@ static void changeState (GtkRadioMenuItem * radiomenuitem, gpointer user_data) #define SDLK_RMETA 0 #endif // Adapted from Gens/GS. Converts a GDK key value into an SDL key value. -unsigned short GDKToSDLKeyval (int gdk_key) +unsigned int GDKToSDLKeyval (int gdk_key) { if (!(gdk_key & 0xFF00)) { @@ -2242,7 +2243,7 @@ unsigned short GDKToSDLKeyval (int gdk_key) } // Non-ASCII symbol. - static const uint16_t gdk_to_sdl_table[0x100] = { + static const int gdk_to_sdl_table[0x100] = { // 0x00 - 0x0F 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, @@ -2340,7 +2341,7 @@ unsigned short GDKToSDLKeyval (int gdk_key) 0x0000, 0x0000, 0x0000, SDLK_DELETE, }; - unsigned short sdl_key = gdk_to_sdl_table[gdk_key & 0xFF]; + unsigned int sdl_key = gdk_to_sdl_table[gdk_key & 0xFF]; if (sdl_key == 0) { // Unhandled GDK key. @@ -3070,8 +3071,126 @@ gint handleMouseClick (GtkWidget * widget, GdkEvent * event, return 0; } +uint32_t *getGuiPixelBuffer( int *w, int *h, int *s ) +{ + + if ( cairo_surface == NULL ) + { + if ( w ) *w = 0; + if ( h ) *h = 0; + if ( s ) *s = 0; + return NULL; + } + cairo_surface_flush( cairo_surface ); + + if ( w ) + { + *w = cairo_image_surface_get_width (cairo_surface); + } + if ( h ) + { + *h = cairo_image_surface_get_height (cairo_surface); + } + if ( s ) + { + *s = cairo_image_surface_get_stride(cairo_surface); + } + + //return NULL; + return (uint32_t*)cairo_image_surface_get_data (cairo_surface); +} + +int guiPixelBufferReDraw(void) +{ + if ( cairo_surface != NULL ) + { + cairo_surface_mark_dirty( cairo_surface ); + + gtk_widget_queue_draw( evbox ); + } + return 0; +} + +int guiClearSurface(void) +{ + uint32_t *p; + int w, h, z, i; + if ( cairo_surface != NULL ) + { + cairo_surface_flush( cairo_surface ); + + p = (uint32_t*)cairo_image_surface_get_data (cairo_surface); + + w = cairo_image_surface_get_width (cairo_surface); + h = cairo_image_surface_get_height (cairo_surface); + + z = w * h; + for (i=0; i xscale) yscale = xscale; + if (cairo_surface) + { + cairo_surface_destroy (cairo_surface); cairo_surface = NULL; + } + + //cairo_surface = gdk_window_create_similar_surface ( + // gtk_widget_get_window (evbox), + // CAIRO_CONTENT_COLOR_ALPHA, + // gtk_widget_get_allocated_width (evbox), + // gtk_widget_get_allocated_height (evbox) ); + + //cairo_surface = cairo_image_surface_create( CAIRO_FORMAT_ARGB32, + cairo_surface = cairo_image_surface_create( CAIRO_FORMAT_RGB24, + gtk_widget_get_allocated_width (evbox), + gtk_widget_get_allocated_height (evbox) ); + + printf("Cairo Surface: %p \n", cairo_surface ); + + cairo_format = cairo_image_surface_get_format( cairo_surface ); + + printf("Cairo Format: %i \n", cairo_format ); + if ( cairo_format == CAIRO_FORMAT_ARGB32 ) + { + printf("Cairo Format: ARGB32 \n" ); + } + guiClearSurface(); + + //setPixels(); + cairo_surface_mark_dirty( cairo_surface ); + //TODO if openGL make these integers g_config->setOption ("SDL.XScale", xscale); g_config->setOption ("SDL.YScale", yscale); @@ -3150,6 +3299,10 @@ static gboolean draw_cb (GtkWidget * widget, cairo_t * cr, gpointer data) gtk_win_menu_ysize = gtk_win_height - gtk_draw_area_height; + cairo_set_source_surface (cr, cairo_surface, 0, 0); + cairo_paint (cr); + return FALSE; + // Clear the screen on a window redraw //if (GameInfo == 0) //{ @@ -3229,7 +3382,7 @@ int InitGTKSubsystem (int argc, char **argv) g_signal_connect (MainWindow, "delete-event", quit, NULL); g_signal_connect (MainWindow, "destroy-event", quit, NULL); // resize handler - g_signal_connect (MainWindow, "configure-event", + g_signal_connect (evbox, "configure-event", G_CALLBACK (handle_resize), NULL); g_signal_connect (evbox, "draw", G_CALLBACK (draw_cb), NULL); diff --git a/src/drivers/sdl/gui.h b/src/drivers/sdl/gui.h index 3edb5782..73147ee9 100644 --- a/src/drivers/sdl/gui.h +++ b/src/drivers/sdl/gui.h @@ -83,7 +83,10 @@ void saveStateAs(); void loadStateFrom(); void quickLoad(); void quickSave(); -unsigned short GDKToSDLKeyval(int gdk_key); +unsigned int GDKToSDLKeyval(int gdk_key); int InitGTKSubsystem(int argc, char** argv); +uint32_t *getGuiPixelBuffer( int *w, int *h, int *s ); +int guiPixelBufferReDraw(void); + #endif // ifndef FCEUX_GUI_H diff --git a/src/drivers/sdl/input.cpp b/src/drivers/sdl/input.cpp index 31cd81fe..c0d972aa 100644 --- a/src/drivers/sdl/input.cpp +++ b/src/drivers/sdl/input.cpp @@ -1019,65 +1019,65 @@ int ButtonConfigBegin () g_config->getOption ("SDL.NoGUI", &noGui); if (noGui == 1) { - SDL_QuitSubSystem (SDL_INIT_VIDEO); + //SDL_QuitSubSystem (SDL_INIT_VIDEO); bcpv = KillVideo (); } #else // XXX soules - why are we doing this right before KillVideo()? - SDL_QuitSubSystem (SDL_INIT_VIDEO); + //SDL_QuitSubSystem (SDL_INIT_VIDEO); // shut down the video and joystick subsystems bcpv = KillVideo (); #endif - SDL_Surface *screen; + //SDL_Surface *screen; bcpj = KillJoysticks (); // reactivate the video subsystem - if (!SDL_WasInit (SDL_INIT_VIDEO)) - { - if (!bcpv) - { - InitVideo (GameInfo); - } - else - { -#if defined(_GTK) && defined(SDL_VIDEO_DRIVER_X11) - if (noGui == 0) - { - while (gtk_events_pending ()) - gtk_main_iteration_do (FALSE); - - char SDL_windowhack[128]; - if (gtk_widget_get_window (evbox)) - sprintf (SDL_windowhack, "SDL_WINDOWID=%u", - (unsigned int) GDK_WINDOW_XID (gtk_widget_get_window (evbox))); -#if SDL_VERSION_ATLEAST(2, 0, 0) - // TODO - SDL2 -#else - SDL_putenv (SDL_windowhack); -#endif - } -#endif - if (SDL_InitSubSystem (SDL_INIT_VIDEO) == -1) - { - FCEUD_Message (SDL_GetError ()); - return 0; - } - - // set the screen and notify the user of button configuration -#if SDL_VERSION_ATLEAST(2, 0, 0) - // TODO - SDL2 -#else - screen = SDL_SetVideoMode (420, 200, 8, 0); - if ( screen == NULL ) - { - printf("Error: SDL_SetVideoMode Failed\n"); - } - SDL_WM_SetCaption ("Button Config", 0); -#endif - } - } +// if (!SDL_WasInit (SDL_INIT_VIDEO)) +// { +// if (!bcpv) +// { +// InitVideo (GameInfo); +// } +// else +// { +//#if defined(_GTK) && defined(SDL_VIDEO_DRIVER_X11) +// if (noGui == 0) +// { +// while (gtk_events_pending ()) +// gtk_main_iteration_do (FALSE); +// +// char SDL_windowhack[128]; +// if (gtk_widget_get_window (evbox)) +// sprintf (SDL_windowhack, "SDL_WINDOWID=%u", +// (unsigned int) GDK_WINDOW_XID (gtk_widget_get_window (evbox))); +//#if SDL_VERSION_ATLEAST(2, 0, 0) +// // TODO - SDL2 +//#else +// SDL_putenv (SDL_windowhack); +//#endif +// } +//#endif +// if (SDL_InitSubSystem (SDL_INIT_VIDEO) == -1) +// { +// FCEUD_Message (SDL_GetError ()); +// return 0; +// } +// +// // set the screen and notify the user of button configuration +//#if SDL_VERSION_ATLEAST(2, 0, 0) +// // TODO - SDL2 +//#else +// screen = SDL_SetVideoMode (420, 200, 8, 0); +// if ( screen == NULL ) +// { +// printf("Error: SDL_SetVideoMode Failed\n"); +// } +// SDL_WM_SetCaption ("Button Config", 0); +//#endif +// } +// } // XXX soules - why did we shut this down? // initialize the joystick subsystem diff --git a/src/drivers/sdl/input.h b/src/drivers/sdl/input.h index bd3d4994..033d5077 100644 --- a/src/drivers/sdl/input.h +++ b/src/drivers/sdl/input.h @@ -7,7 +7,8 @@ typedef struct { uint8 ButtType[MAXBUTTCONFIG]; uint8 DeviceNum[MAXBUTTCONFIG]; - uint16 ButtonNum[MAXBUTTCONFIG]; + //uint16 ButtonNum[MAXBUTTCONFIG]; + int ButtonNum[MAXBUTTCONFIG]; uint32 NumC; //uint64 DeviceID[MAXBUTTCONFIG]; /* TODO */ } ButtConfig; diff --git a/src/drivers/sdl/sdl-opengl.cpp b/src/drivers/sdl/sdl-opengl.cpp index ce8562fc..24456a5f 100644 --- a/src/drivers/sdl/sdl-opengl.cpp +++ b/src/drivers/sdl/sdl-opengl.cpp @@ -21,6 +21,9 @@ #define APIENTRY #endif +#if SDL_VERSION_ATLEAST(2, 0, 0) +static SDL_Window *s_window = NULL; +#endif static GLuint textures[2]={0,0}; // Normal image, scanline overlay. static int left,right,top,bottom; // right and bottom are not inclusive. @@ -104,7 +107,11 @@ BlitOpenGL(uint8 *buf) glEnd(); glDisable(GL_BLEND); } + #if SDL_VERSION_ATLEAST(2, 0, 0) + SDL_GL_SwapWindow(s_window); + #else SDL_GL_SwapBuffers(); + #endif } void @@ -132,6 +139,9 @@ InitOpenGL(int l, int ipolate, int stretchx, int stretchy, +#if SDL_VERSION_ATLEAST(2, 0, 0) + SDL_Window *window, +#endif SDL_Surface *screen) { const char *extensions; @@ -167,6 +177,9 @@ InitOpenGL(int l, HiBuffer=0; +#if SDL_VERSION_ATLEAST(2, 0, 0) + s_window = window; +#endif extensions=(const char*)glGetString(GL_EXTENSIONS); if((efx&2) || !extensions || !p_glColorTableEXT || !strstr(extensions,"GL_EXT_paletted_texture")) @@ -182,6 +195,9 @@ InitOpenGL(int l, #endif } +#if SDL_VERSION_ATLEAST(2, 0, 0) + // FIXME +#else if(screen->flags & SDL_FULLSCREEN) { xscale=(double)screen->w / (double)(r-l); @@ -189,6 +205,7 @@ InitOpenGL(int l, if(xscalepixels; + + i=0; j=0; + for (int x=0; xw; x++) + { + for (int y=0; yh; y++) + { + pixel = buf[i]; i++; + + if ( pixel != 0 ) + { + printf("(%i,%i) %08x ", x, y, pixel ); j++; + if ( j % 10 == 0 ) + { + printf("\n"); + } + } + //printf("(%i,%i) %08x ", x, y, pixel ); + + } + } + + + +} + //draw input aids if we are fullscreen bool FCEUD_ShouldDrawInputAids() { @@ -100,7 +137,8 @@ int KillVideo() { // if the IconSurface has been initialized, destroy it - if(s_IconSurface) { + if (s_IconSurface) + { SDL_FreeSurface(s_IconSurface); s_IconSurface=0; } @@ -113,15 +151,46 @@ KillVideo() #ifdef OPENGL // check for OpenGL and shut it down if(s_useOpenGL) + { KillOpenGL(); + } else #endif + { // shut down the system that converts from 8 to 16/32 bpp - if(s_curbpp > 8) + if (s_curbpp > 8) + { KillBlitToHigh(); + } + } + +#if SDL_VERSION_ATLEAST(2, 0, 0) + + if ( s_screen != NULL ) + { + SDL_FreeSurface( s_screen ); s_screen = NULL; + } + + if ( s_texture != NULL ) + { + SDL_DestroyTexture( s_texture ); s_texture = NULL; + } + + if ( s_renderer != NULL ) + { + SDL_DestroyRenderer( s_renderer ); s_renderer = NULL; + } + + if ( s_window != NULL ) + { + SDL_DestroyWindow( s_window ); + s_window = NULL; + } + +#endif // shut down the SDL video sub-system - SDL_QuitSubSystem(SDL_INIT_VIDEO); + //SDL_QuitSubSystem(SDL_INIT_VIDEO); s_inited = 0; return 0; @@ -158,6 +227,203 @@ int InitVideo(FCEUGI *gi) // This is a big TODO. Stubbing this off into its own function, // as the SDL surface routines have changed drastically in SDL2 // TODO - SDL2 + // XXX soules - const? is this necessary? + //const SDL_VideoInfo *vinf; + int error, flags = 0; + int doublebuf, xstretch, ystretch, xres, yres, show_fps; + + FCEUI_printf("Initializing video..."); + + // load the relevant configuration variables + g_config->getOption("SDL.Fullscreen", &s_fullscreen); + g_config->getOption("SDL.DoubleBuffering", &doublebuf); +#ifdef OPENGL + g_config->getOption("SDL.OpenGL", &s_useOpenGL); +#endif + g_config->getOption("SDL.SpecialFilter", &s_sponge); + g_config->getOption("SDL.XStretch", &xstretch); + g_config->getOption("SDL.YStretch", &ystretch); + //g_config->getOption("SDL.LastXRes", &xres); + //g_config->getOption("SDL.LastYRes", &yres); + g_config->getOption("SDL.ClipSides", &s_clipSides); + g_config->getOption("SDL.NoFrame", &noframe); + g_config->getOption("SDL.ShowFPS", &show_fps); + g_config->getOption("SDL.XScale", &s_exs); + g_config->getOption("SDL.YScale", &s_eys); + uint32_t rmask, gmask, bmask; + + //s_exs = 1.0; + //s_eys = 1.0; + xres = gtk_draw_area_width; + yres = gtk_draw_area_height; + // check the starting, ending, and total scan lines + + FCEUI_GetCurrentVidSystem(&s_srendline, &s_erendline); + s_tlines = s_erendline - s_srendline + 1; + + // check if we should auto-set x/y resolution + + // check for OpenGL and set the global flags +#ifdef OPENGL + // FIXME + //if(s_useOpenGL && !s_sponge) { + // flags = SDL_OPENGL; + //} +#endif + + s_inited = 1; + + // check to see if we are showing FPS + FCEUI_SetShowFPS(show_fps); + +#ifdef LSB_FIRST + //rmask = 0x000000FF; + //gmask = 0x0000FF00; + //bmask = 0x00FF0000; + rmask = 0x00FF0000; + gmask = 0x0000FF00; + bmask = 0x000000FF; +#else + rmask = 0x00FF0000; + gmask = 0x0000FF00; + bmask = 0x000000FF; +#endif + + // if all this hex scares you, check out SDL_PixelFormatEnumToMasks()! +//#ifdef LSB_FIRST +// //printf("Little Endian\n"); +// s_screen = SDL_CreateRGBSurface(0, xres, yres, 32, +// 0xFF, 0xFF00, 0xFF0000, 0x00); +//#else +// //printf("Big Endian\n"); +// s_screen = SDL_CreateRGBSurface(0, xres, yres, 32, +// 0xFF0000, 0xFF00, 0xFF, 0x00); +//#endif +// +// if ( s_screen == NULL ) +// { +// fprintf(stderr, "Couldn't init SDL screen: %s\n", SDL_GetError()); +// KillVideo(); +// exit(-1); +// } +// +// s_texture = SDL_CreateTexture(s_renderer, +//#ifdef LSB_FIRST +// SDL_PIXELFORMAT_ABGR8888, +//#else +// SDL_PIXELFORMAT_ARGB8888, +//#endif +// SDL_TEXTUREACCESS_STREAMING | SDL_TEXTUREACCESS_TARGET, +// xres, yres ); +// +// if ( s_texture == NULL ) +// { +// fprintf(stderr, "Couldn't init SDL texture: %s\n", SDL_GetError()); +// KillVideo(); +// exit(-1); +// } +// #endif + + //s_curbpp = s_screen->format->BitsPerPixel; + s_curbpp = 32; + + //FCEU_printf(" Video Mode: %d x %d x %d bpp %s\n", + // s_screen->w, s_screen->h, s_screen->format->BitsPerPixel, + // s_fullscreen ? "full screen" : ""); + FCEU_printf(" Video Mode: %d x %d x %d bpp %s\n", + xres, yres, s_curbpp, + s_fullscreen ? "full screen" : ""); + + if (s_curbpp != 8 && s_curbpp != 16 && s_curbpp != 24 && s_curbpp != 32) + { + FCEU_printf(" Sorry, %dbpp modes are not supported by FCE Ultra. Supported bit depths are 8bpp, 16bpp, and 32bpp.\n", s_curbpp); + KillVideo(); + return -1; + } + + // create the surface for displaying graphical messages +//#ifdef LSB_FIRST +// s_IconSurface = SDL_CreateRGBSurfaceFrom((void *)fceu_playicon.pixel_data, +// 32, 32, 24, 32 * 3, +// 0xFF, 0xFF00, 0xFF0000, 0x00); +//#else +// s_IconSurface = SDL_CreateRGBSurfaceFrom((void *)fceu_playicon.pixel_data, +// 32, 32, 24, 32 * 3, +// 0xFF0000, 0xFF00, 0xFF, 0x00); +//#endif +// SDL_SetWindowIcon( s_window, s_IconSurface); + + //s_paletterefresh = 1; + + // -Video Modes Tag- + if (s_sponge) + { + if (s_sponge <= 3 && s_sponge >= 1) + { + s_exs = s_eys = 2; + } + else if (s_sponge >=4 && s_sponge <= 5) + { + s_exs = s_eys = 3; + } + else if (s_sponge >= 6 && s_sponge <= 8) + { + s_exs = s_eys = s_sponge - 4; + } + else if(s_sponge == 9) + { + s_exs = s_eys = 3; + } + else + { + s_exs = s_eys = 1; + } + if(s_sponge == 3) { + xres = 301 * s_exs; + } + s_eefx = 0; + //if(s_sponge == 1 || s_sponge == 4) { + // desbpp = 32; + //} + } + + //int scrw = NWIDTH * s_exs; + //if(s_sponge == 3) { + // scrw = 301 * s_exs; + //} + +#ifdef OPENGL + if(!s_useOpenGL) { + s_exs = (int)s_exs; + s_eys = (int)s_eys; + } + if(s_exs <= 0.01) { + FCEUD_PrintError("xscale out of bounds."); + KillVideo(); + return -1; + } + if(s_eys <= 0.01) { + FCEUD_PrintError("yscale out of bounds."); + KillVideo(); + return -1; + } + if(s_sponge && s_useOpenGL) { + FCEUD_PrintError("scalers not compatible with openGL mode."); + KillVideo(); + return -1; + } +#endif + + if (s_curbpp > 8) + { + InitBlitToHigh(s_curbpp >> 3, + rmask, + gmask, + bmask, + s_eefx, s_sponge, 0); + } + + return 0; } #else /** @@ -632,13 +898,14 @@ void UnlockConsole(){} void BlitScreen(uint8 *XBuf) { - SDL_Surface *TmpScreen; + //SDL_Surface *TmpScreen; uint8 *dest; int xo = 0, yo = 0; + int w, h, pitch; - if(!s_screen) { - return; - } + //if(!s_screen) { + // return; + //} // refresh the palette if required if(s_paletterefresh) { @@ -657,27 +924,32 @@ BlitScreen(uint8 *XBuf) // XXX soules - not entirely sure why this is being done yet XBuf += s_srendline * 256; - if(s_BlitBuf) { - TmpScreen = s_BlitBuf; - } else { - TmpScreen = s_screen; - } + //if(s_BlitBuf) { + // TmpScreen = s_BlitBuf; + //} else { + // TmpScreen = s_screen; + //} // lock the display, if necessary - if(SDL_MUSTLOCK(TmpScreen)) { - if(SDL_LockSurface(TmpScreen) < 0) { - return; - } - } + //if(SDL_MUSTLOCK(TmpScreen)) { + // if(SDL_LockSurface(TmpScreen) < 0) { + // return; + // } + //} - dest = (uint8*)TmpScreen->pixels; + //dest = (uint8*)TmpScreen->pixels; + dest = (uint8*)getGuiPixelBuffer( &w, &h, &pitch ); + + pitch = w * 4; + + if ( dest == NULL ) return; //if(s_fullscreen) { // Always do this calculation now. Screen resolution is always provided. - xo = (int)(((TmpScreen->w - NWIDTH * s_exs)) / 2); + xo = (int)(((w - NWIDTH * s_exs)) / 2); dest += xo * (s_curbpp >> 3); - if(TmpScreen->h > (s_tlines * s_eys)) { - yo = (int)((TmpScreen->h - s_tlines * s_eys) / 2); - dest += yo * TmpScreen->pitch; + if(h > (s_tlines * s_eys)) { + yo = (int)((h - s_tlines * s_eys) / 2); + dest += yo * pitch; } //} @@ -686,26 +958,29 @@ BlitScreen(uint8 *XBuf) if(s_curbpp > 8) { if(s_BlitBuf) { Blit8ToHigh(XBuf + NOFFSET, dest, NWIDTH, s_tlines, - TmpScreen->pitch, 1, 1); + pitch, 1, 1); } else { Blit8ToHigh(XBuf + NOFFSET, dest, NWIDTH, s_tlines, - TmpScreen->pitch, (int)s_exs, (int)s_eys); + pitch, (int)s_exs, (int)s_eys); } } else { if(s_BlitBuf) { Blit8To8(XBuf + NOFFSET, dest, NWIDTH, s_tlines, - TmpScreen->pitch, 1, 1, 0, s_sponge); + pitch, 1, 1, 0, s_sponge); } else { Blit8To8(XBuf + NOFFSET, dest, NWIDTH, s_tlines, - TmpScreen->pitch, (int)s_exs, (int)s_eys, + pitch, (int)s_exs, (int)s_eys, s_eefx, s_sponge); } } + //print_pixels(); + // + guiPixelBufferReDraw(); // unlock the display, if necessary - if(SDL_MUSTLOCK(TmpScreen)) { - SDL_UnlockSurface(TmpScreen); - } + //if(SDL_MUSTLOCK(TmpScreen)) { + // SDL_UnlockSurface(TmpScreen); + //} int scrw; if(s_sponge == 3) { // NTSC 2x @@ -715,29 +990,32 @@ BlitScreen(uint8 *XBuf) } // if we have a hardware video buffer, do a fast video->video copy - if(s_BlitBuf) { - SDL_Rect srect; - SDL_Rect drect; + //if(s_BlitBuf) { + // SDL_Rect srect; + // SDL_Rect drect; - srect.x = 0; - srect.y = 0; - srect.w = scrw; - srect.h = s_tlines; + // srect.x = 0; + // srect.y = 0; + // srect.w = scrw; + // srect.h = s_tlines; - drect.x = 0; - drect.y = 0; - drect.w = (Uint16)(s_exs * scrw); - drect.h = (Uint16)(s_eys * s_tlines); + // drect.x = 0; + // drect.y = 0; + // drect.w = (Uint16)(s_exs * scrw); + // drect.h = (Uint16)(s_eys * s_tlines); - SDL_BlitSurface(s_BlitBuf, &srect, s_screen, &drect); - } + // SDL_BlitSurface(s_BlitBuf, &srect, s_screen, &drect); + //} // ensure that the display is updated #if SDL_VERSION_ATLEAST(2, 0, 0) - //TODO - SDL2 + //SDL_UpdateTexture(s_texture, NULL, s_screen->pixels, s_screen->pitch); + //SDL_RenderClear(s_renderer); + //SDL_RenderCopy(s_renderer, s_texture, NULL, NULL); + //SDL_RenderPresent(s_renderer); #else - SDL_UpdateRect(s_screen, xo, yo, - (Uint32)(scrw * s_exs), (Uint32)(s_tlines * s_eys)); + //SDL_UpdateRect(s_screen, xo, yo, + // (Uint32)(scrw * s_exs), (Uint32)(s_tlines * s_eys)); #endif #ifdef CREATE_AVI @@ -781,7 +1059,7 @@ BlitScreen(uint8 *XBuf) break; #endif default: - NESVideoLoggingVideo(s_screen->pixels, width,height, fps, s_curbpp); + NESVideoLoggingVideo( dest, width,height, fps, s_curbpp); } } #endif @@ -814,14 +1092,14 @@ BlitScreen(uint8 *XBuf) #endif #endif -#if SDL_VERSION_ATLEAST(2, 0, 0) - // TODO -#else - // have to flip the displayed buffer in the case of double buffering - if(s_screen->flags & SDL_DOUBLEBUF) { - SDL_Flip(s_screen); - } -#endif +//#if SDL_VERSION_ATLEAST(2, 0, 0) +// // TODO +//#else +// // have to flip the displayed buffer in the case of double buffering +// if(s_screen->flags & SDL_DOUBLEBUF) { +// SDL_Flip(s_screen); +// } +//#endif } /** From 8c2cea1ed40704e583c1583c00b77d5178884e62 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Fri, 5 Jun 2020 21:23:33 -0400 Subject: [PATCH 133/156] Added logic to change how full screen mode works with cairo drawing. --- src/drivers/sdl/gui.cpp | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 0402b086..d766c218 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -3005,9 +3005,19 @@ void pushOutputToGTK (const char *str) void showGui (bool b) { if (b) + { + //gtk_window_unmaximize( GTK_WINDOW(MainWindow) ); + gtk_window_unfullscreen( GTK_WINDOW(MainWindow) ); gtk_widget_show_all (MainWindow); + //gtk_window_unfullscreen( GTK_WINDOW(MainWindow) ); + } else - gtk_widget_hide (MainWindow); + { + //gtk_widget_hide (MainWindow); + //gtk_widget_hide (Menubar); + //gtk_window_maximize( GTK_WINDOW(MainWindow) ); + gtk_window_fullscreen( GTK_WINDOW(MainWindow) ); + } } gint handleKeyRelease (GtkWidget * w, GdkEvent * event, gpointer cb_data) From 6b406e411f933bcfb6145e172d614717334ddba1 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 6 Jun 2020 09:02:36 -0400 Subject: [PATCH 134/156] Bug fixes for SDL2 keyboard interaction. --- src/drivers/sdl/gui.cpp | 2 ++ src/drivers/sdl/input.cpp | 38 ++++++++++++++++++++++++++++++-------- 2 files changed, 32 insertions(+), 8 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index d766c218..8962f88f 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -2399,7 +2399,9 @@ static gboolean convertKeypress (GtkWidget * grab, GdkEventKey * event, #endif // Create an SDL event from the keypress. + sdlev.key.keysym.scancode = SDL_GetScancodeFromKey(sdlkey); sdlev.key.keysym.sym = sdlkey; + sdlev.key.keysym.mod = 0; if (sdlkey != 0) { SDL_PushEvent (&sdlev); diff --git a/src/drivers/sdl/input.cpp b/src/drivers/sdl/input.cpp index c0d972aa..c41665d7 100644 --- a/src/drivers/sdl/input.cpp +++ b/src/drivers/sdl/input.cpp @@ -137,7 +137,11 @@ DoCheatSeq () } #include "keyscan.h" +#if SDL_VERSION_ATLEAST(2, 0, 0) +static uint8 g_keyState[SDL_NUM_SCANCODES]; +#else static uint8 *g_keyState = 0; +#endif static int DIPS = 0; static uint8 keyonce[MKK_COUNT]; @@ -451,7 +455,7 @@ static void KeyboardCommands () char *movie_fname = ""; // get the keyboard input #if SDL_VERSION_ATLEAST(1, 3, 0) - g_keyState = (Uint8*)SDL_GetKeyboardState (NULL); + //g_keyState = (Uint8*)SDL_GetKeyboardState (NULL); #else g_keyState = SDL_GetKeyState (NULL); #endif @@ -461,7 +465,7 @@ static void KeyboardCommands () { #if SDL_VERSION_ATLEAST(1, 3, 0) // TODO - SDL2 - if (0) + if ( g_keyState[SDL_SCANCODE_SCROLLLOCK] ) #else if (keyonly (SCROLLLOCK)) #endif @@ -482,8 +486,8 @@ static void KeyboardCommands () } #if SDL_VERSION_ATLEAST(2, 0, 0) - if (g_keyState[SDL_GetScancodeFromKey (SDLK_LSHIFT)] - || g_keyState[SDL_GetScancodeFromKey (SDLK_RSHIFT)]) + if (g_keyState[SDL_SCANCODE_LSHIFT] + || g_keyState[SDL_SCANCODE_RSHIFT]) #else if (g_keyState[SDLK_LSHIFT] || g_keyState[SDLK_RSHIFT]) #endif @@ -491,8 +495,8 @@ static void KeyboardCommands () else is_shift = 0; #if SDL_VERSION_ATLEAST(2, 0, 0) - if (g_keyState[SDL_GetScancodeFromKey (SDLK_LALT)] - || g_keyState[SDL_GetScancodeFromKey (SDLK_RALT)]) + if (g_keyState[SDL_SCANCODE_LALT] + || g_keyState[SDL_SCANCODE_RALT]) #else if (g_keyState[SDLK_LALT] || g_keyState[SDLK_RALT]) #endif @@ -684,13 +688,13 @@ static void KeyboardCommands () // Toggle throttling NoWaiting &= ~1; - if (g_keyState[Hotkeys[HK_TURBO]]) + if ( _keyonly(Hotkeys[HK_TURBO]) ) { NoWaiting |= 1; } static bool frameAdvancing = false; - if (g_keyState[Hotkeys[HK_FRAME_ADVANCE]]) + if ( _keyonly(Hotkeys[HK_FRAME_ADVANCE])) { if (frameAdvancing == false) { @@ -968,6 +972,10 @@ void GetMouseRelative (int32 (&d)[3]) d[2] = md[2]; // buttons } +//static void checkKeyBoardState( int scanCode ) +//{ +// printf("Key State is: %i \n", g_keyState[ scanCode ] ); +//} /** * Handles outstanding SDL events. */ @@ -995,6 +1003,15 @@ UpdatePhysicalInput () FCEU_printf ("Warning: unknown hotkey event %d\n", event.user.code); } + break; + case SDL_KEYDOWN: + case SDL_KEYUP: + //printf("SDL_Event.type: %i Keysym: %i ScanCode: %i\n", + // event.type, event.key.keysym.sym, event.key.keysym.scancode ); + + g_keyState[ event.key.keysym.scancode ] = (event.type == SDL_KEYDOWN) ? 1 : 0; + //checkKeyBoardState( event.key.keysym.scancode ); + break; default: break; } @@ -1200,6 +1217,7 @@ UpdateGamepad(void) { if (DTestButton (&GamePadConfig[wg][x])) { + //printf("GamePad%i Button Hit: %i \n", wg, x ); if(opposite_dirs == 0) { // test for left+right and up+down @@ -1426,6 +1444,10 @@ void InitInputInterface () int x; int attrib; +#if SDL_VERSION_ATLEAST(2, 0, 0) + memset( g_keyState, 0, sizeof(g_keyState) ); +#endif + for (t = 0, x = 0; x < 2; x++) { attrib = 0; From 76df04d8300eca6529049c00cb9047acf19cb2df Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 6 Jun 2020 22:53:34 -0400 Subject: [PATCH 135/156] Added an experimental shared memory interface to allow for the video window to be a separate process. --- src/drivers/sdl/SConscript | 1 + src/drivers/sdl/glxwin.cpp | 330 ++++++++++++++++++++++++++++++++++ src/drivers/sdl/glxwin.h | 59 ++++++ src/drivers/sdl/gui.cpp | 303 +++++++++++++++++++++++++++++-- src/drivers/sdl/sdl-video.cpp | 40 ++--- src/drivers/sdl/sdl.cpp | 2 + 6 files changed, 702 insertions(+), 33 deletions(-) create mode 100644 src/drivers/sdl/glxwin.cpp create mode 100644 src/drivers/sdl/glxwin.h diff --git a/src/drivers/sdl/SConscript b/src/drivers/sdl/SConscript index a8bde4ac..b16ffbe7 100644 --- a/src/drivers/sdl/SConscript +++ b/src/drivers/sdl/SConscript @@ -13,6 +13,7 @@ source_list = Split( memview.cpp ramwatch.cpp debugger.cpp + glxwin.cpp sdl.cpp sdl-joystick.cpp sdl-sound.cpp diff --git a/src/drivers/sdl/glxwin.cpp b/src/drivers/sdl/glxwin.cpp new file mode 100644 index 00000000..7f00b5c8 --- /dev/null +++ b/src/drivers/sdl/glxwin.cpp @@ -0,0 +1,330 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "glxwin.h" + +static Display *dpy = NULL; +static Window root; +static GLint att[] = { GLX_RGBA, GLX_DEPTH_SIZE, 24, GLX_DOUBLEBUFFER, None }; +static XVisualInfo *vi = NULL; +static Colormap cmap; +static XSetWindowAttributes swa; +static Window win; +static GLXContext glc; +static XWindowAttributes gwa; +static XEvent xev; + +static GLuint gltexture = 0; + +glxwin_shm_t *glx_shm = NULL; + +static int screen_width = 512; +static int screen_height = 512; +//************************************************************************ +static glxwin_shm_t *open_shm(void) +{ + int shmId; + glxwin_shm_t *vaddr; + struct shmid_ds ds; + + shmId = shmget( IPC_PRIVATE, sizeof(struct glxwin_shm_t), IPC_CREAT | S_IRWXU | S_IRWXG ); + + if ( shmId == -1 ) + { + perror("Error: GLX shmget Failed:"); + return NULL; + } + printf("Created ShmID: %i \n", shmId ); + + vaddr = (glxwin_shm_t*)shmat( shmId, NULL, 0); + + if ( vaddr == (glxwin_shm_t*)-1 ) + { + perror("Error: GLX shmat Failed:"); + return NULL; + } + memset( vaddr, 0, sizeof(struct glxwin_shm_t)); + + if ( shmctl( shmId, IPC_RMID, &ds ) != 0 ) + { + perror("Error: GLX shmctl IPC_RMID Failed:"); + } + + sem_init( &vaddr->sem, 1, 1 ); + + return vaddr; +} +//************************************************************************ +static void genTextures(void) +{ + int ipolate = 1; + + glEnable(GL_TEXTURE_2D); + glGenTextures(1, &gltexture); + + glBindTexture(GL_TEXTURE_2D, gltexture); + + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,ipolate?GL_LINEAR:GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,ipolate?GL_LINEAR:GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP); + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP); + +} +//************************************************************************ +static int open_window(void) +{ + + dpy = XOpenDisplay(NULL); + + if (dpy == NULL) { + printf("\n\tcannot connect to X server\n\n"); + exit(0); + } + root = DefaultRootWindow(dpy); + + vi = glXChooseVisual(dpy, 0, att); + + if (vi == NULL) + { + printf("\n\tno appropriate visual found\n\n"); + exit(0); + } + else { + printf("\n\tvisual %p selected\n", (void *)vi->visualid); /* %p creates hexadecimal output like in glxinfo */ + } + + cmap = XCreateColormap(dpy, root, vi->visual, AllocNone); + + swa.colormap = cmap; + swa.event_mask = ExposureMask | KeyPressMask | KeyReleaseMask | StructureNotifyMask; + + win = XCreateWindow(dpy, root, 0, 0, screen_width, screen_height, 0, + vi->depth, InputOutput, vi->visual, + CWColormap | CWEventMask, &swa); + + XMapWindow(dpy, win); + + XStoreName(dpy, win, "FCEUX VIEWPORT"); + + glc = glXCreateContext(dpy, vi, NULL, GL_TRUE); + glXMakeCurrent(dpy, win, glc); + + genTextures(); + glDisable(GL_DEPTH_TEST); + glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // Background color to black. + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + + // In a double buffered setup with page flipping, be sure to clear both buffers. + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + return 0; +} +//************************************************************************ +static void print_pixbuf(void) +{ + for (int x=0; x<256; x++) + { + for (int y=0; y<256; y++) + { + printf("(%i,%i) = %08X \n", x, y, glx_shm->pixbuf[x*256+y] ); + } + } +} +//************************************************************************ +static void render_image(void) +{ + int l=0, r=GLX_NES_WIDTH; + int t=0, b=GLX_NES_HEIGHT; + + float xscale = (float)screen_width / (float)GLX_NES_WIDTH; + float yscale = (float)screen_height / (float)GLX_NES_HEIGHT; + if (xscale < yscale ) + { + yscale = xscale; + } + else + { + xscale = yscale; + } + int rw=(int)((r-l)*xscale); + int rh=(int)((b-t)*yscale); + int sx=(screen_width-rw)/2; + int sy=(screen_height-rh)/2; + + glXMakeCurrent(dpy, win, glc); + //printf("Viewport: (%i,%i) %i %i %i %i \n", + // screen_width, screen_height, sx, sy, rw, rh ); + //glViewport(sx, sy, rw, rh); + glViewport( 0, 0, screen_width, screen_height); + + glLoadIdentity(); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glMatrixMode(GL_MODELVIEW); + glOrtho( -1.0, 1.0, -1.0, 1.0, -1.0, 1.0); + + glDisable(GL_DEPTH_TEST); + glClearColor( 0.0, 0.0f, 0.0f, 0.0f); // Background color to black. + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + glEnable(GL_LINE_SMOOTH); + glEnable(GL_TEXTURE_2D); + //glBindTexture(GL_TEXTURE_2D, gltexture); + glBindTexture(GL_TEXTURE_2D, gltexture); + + //print_pixbuf(); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 256, 256, 0, + GL_RGBA, GL_UNSIGNED_BYTE, glx_shm->pixbuf ); + + glBegin(GL_QUADS); + glTexCoord2f(1.0f*l/256, 1.0f*b/256); // Bottom left of picture. + glVertex2f(-1.0f, -1.0f); // Bottom left of target. + + glTexCoord2f(1.0f*r/256, 1.0f*b/256);// Bottom right of picture. + glVertex2f( 1.0f, -1.0f); // Bottom right of target. + + glTexCoord2f(1.0f*r/256, 1.0f*t/256); // Top right of our picture. + glVertex2f( 1.0f, 1.0f); // Top right of target. + + glTexCoord2f(1.0f*l/256, 1.0f*t/256); // Top left of our picture. + glVertex2f(-1.0f, 1.0f); // Top left of target. + glEnd(); + + glDisable(GL_TEXTURE_2D); + + glColor4f( 1.0, 1.0, 1.0, 1.0 ); + glLineWidth(5.0); + glBegin(GL_LINES); + glVertex2f(-1.0f, -1.0f); // Bottom left of target. + glVertex2f( 1.0f, 1.0f); // Top right of target. + glEnd(); + + glFlush(); + + glXSwapBuffers( dpy, win ); +} +//************************************************************************ +static int mainWindowLoop(void) +{ + + while( glx_shm->run ) + { + while ( XPending( dpy ) ) + { + XNextEvent(dpy, &xev); + + if (xev.type == Expose) + { + XGetWindowAttributes(dpy, win, &gwa); + //glViewport(0, 0, gwa.width, gwa.height); + //DrawAQuad(); + glXSwapBuffers(dpy, win); + printf("Expose\n"); + } + else if (xev.type == ConfigureNotify) + { + //XGetWindowAttributes(dpy, win, &gwa); + + screen_width = xev.xconfigure.width; + screen_height = xev.xconfigure.height; + + //if (gltexture) { + // glDeleteTextures(1, &gltexture); + //} + //gltexture=0; + + //genTextures(); + + printf("Resize Request: (%i,%i)\n", screen_width, screen_height ); + render_image(); + //glViewport(0, 0, gwa.width, gwa.height); + //DrawAQuad(); + //glXSwapBuffers(dpy, win); + } + else if (xev.type == KeyPress) + { + printf("Key press: %i %08X \n", xev.xkey.keycode, xev.xkey.state ); + + } + else if (xev.type == DestroyNotify) + { + printf("DestroyNotify\n"); + glx_shm->run = 0; + //glXMakeCurrent(dpy, None, NULL); + //glXDestroyContext(dpy, glc); + //XDestroyWindow(dpy, win); + //XCloseDisplay(dpy); + //exit(0); + } + } + + if ( glx_shm->blit_count != glx_shm->render_count ) + { + render_image(); + glx_shm->render_count++; + } + + usleep(10000); + } + + glXMakeCurrent(dpy, None, NULL); + glXDestroyContext(dpy, glc); + XDestroyWindow(dpy, win); + XCloseDisplay(dpy); + exit(0); + return 0; +} +//************************************************************************ +int spawn_glxwin( int flags ) +{ + int pid; + + glx_shm = open_shm(); + + pid = fork(); + + if ( pid == 0 ) + { + // Child Process + glx_shm->run = 1; + glx_shm->pid = getpid(); + + printf("Child Process Running: %i\n", glx_shm->pid ); + + open_window(); + + mainWindowLoop(); + + exit(0); + } + else if ( pid > 0 ) + { // Parent Process + + } + else + { + // Error + printf("Error: Failed to Fork GLX Window Process\n"); + } + + return pid; +} +//************************************************************************ + +//************************************************************************ diff --git a/src/drivers/sdl/glxwin.h b/src/drivers/sdl/glxwin.h new file mode 100644 index 00000000..03f162c3 --- /dev/null +++ b/src/drivers/sdl/glxwin.h @@ -0,0 +1,59 @@ +// glxwin.cpp +// + +#ifndef __GLXWIN_H__ +#define __GLXWIN_H__ + +#include + +#include + +int spawn_glxwin( int flags ); + +#define GLX_NES_WIDTH 256 +#define GLX_NES_HEIGHT 256 + +struct glxwin_shm_t +{ + int pid; + int run; + uint32_t render_count; + uint32_t blit_count; + sem_t sem; + + // Pass Key Events back to GTK Gui + struct + { + int head; + int tail; + + struct { + int type; + int keycode; + int state; + } data[64]; + + } keyEventBuf; + + // Gui Command Event Queue + struct + { + int head; + int tail; + + struct { + int id; + + union { + int i32[4]; + float f32[4]; + } param; + } cmd[64]; + } guiEvent; + + uint32_t pixbuf[65536]; // 256 x 256 +}; + +extern glxwin_shm_t *glx_shm; + +#endif diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 8962f88f..ac71ef00 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -34,11 +34,23 @@ #include #endif +#ifdef APPLEOPENGL +#include +#include +#include +#else +#include +#include +#include +#endif + #include #include #include #include +#include "glxwin.h" + // Fix compliation errors for older version of GTK (Ubuntu 10.04 LTS) #if GTK_MINOR_VERSION < 24 && GTK_MAJOR_VERSION == 2 #define GTK_COMBO_BOX_TEXT GTK_COMBO_BOX @@ -66,6 +78,9 @@ static GtkRadioMenuItem *stateSlot[10] = { NULL }; bool gtkIsStarted = false; bool menuTogglingEnabled = false; +static int drawAreaGL = 0; +static GLuint gltexture = 0; +static uint32_t *drawAreaGLpixBuf = NULL; unsigned int gtk_draw_area_width = NES_WIDTH; unsigned int gtk_draw_area_height = NES_HEIGHT; static unsigned int gtk_win_width = 0; @@ -3085,6 +3100,15 @@ gint handleMouseClick (GtkWidget * widget, GdkEvent * event, uint32_t *getGuiPixelBuffer( int *w, int *h, int *s ) { + if ( drawAreaGL ) + { + if ( w ) *w = 256; + if ( h ) *h = 256; + if ( s ) *s = 256*4; + + //return NULL; + return glx_shm->pixbuf; + } if ( cairo_surface == NULL ) { @@ -3114,6 +3138,13 @@ uint32_t *getGuiPixelBuffer( int *w, int *h, int *s ) int guiPixelBufferReDraw(void) { + glx_shm->blit_count++; + + if ( drawAreaGL ) + { + gtk_gl_area_queue_render( (GtkGLArea*)evbox); + return 0; + } if ( cairo_surface != NULL ) { cairo_surface_mark_dirty( cairo_surface ); @@ -3148,20 +3179,30 @@ int guiClearSurface(void) static void setPixels(void) { - int32_t *p; + uint32_t *p; int i,x,y,width,height,w2,h2; - width = cairo_image_surface_get_width (cairo_surface); - height = cairo_image_surface_get_height (cairo_surface); + if ( drawAreaGL ) + { + width = 256; + height = 256; + //p = (uint32_t*)drawAreaGLpixBuf; + p = (uint32_t*)glx_shm->pixbuf; + } + else + { + width = cairo_image_surface_get_width (cairo_surface); + height = cairo_image_surface_get_height (cairo_surface); - cairo_surface_flush( cairo_surface ); + cairo_surface_flush( cairo_surface ); - p = (int32_t*)cairo_image_surface_get_data (cairo_surface); + p = (uint32_t*)cairo_image_surface_get_data (cairo_surface); + } w2 = width / 2; h2 = height / 2; - printf("W:%i H:%i W/2:%i H/2:%i\n", width, height, w2, h2 ); + //printf("W:%i H:%i W/2:%i H/2:%i\n", width, height, w2, h2 ); i=0; for (y=0; y 1.0 ) + { + red = 1.0; dir = 0; + } + } + else + { + red -= 0.01; + if ( red < 0.0 ) + { + red = 0.0; dir = 1; + } + } + //if(stretchx) { sx=0; rw=screen->w; } + //if(stretchy) { sy=0; rh=screen->h; } + //glViewport(sx, sy, rw, rh); + //glViewport(0, 0, gtk_draw_area_width, gtk_draw_area_height); + + //glLoadIdentity(); + //glPushMatrix(); + //glLoadIdentity(); + //glMatrixMode(GL_MODELVIEW); + //glOrtho( -1.0, 1.0, -1.0, 1.0, -1.0, 1.0); + + //printf("GL Render!\n"); + + glDisable(GL_DEPTH_TEST); + glClearColor( red, 0.0f, 0.0f, 0.0f); // Background color to black. + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + glDisable(GL_TEXTURE_2D); + glEnable(GL_LINE_SMOOTH); + //glEnable(GL_TEXTURE_2D); + //glBindTexture(GL_TEXTURE_2D, gltexture); + glBindTexture(GL_TEXTURE_2D, gltexture); + + + //setPixels(); + + //glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 256, 256, 0, + // GL_RGBA, GL_UNSIGNED_BYTE, drawAreaGLpixBuf ); + + //glBegin(GL_QUADS); + //glTexCoord2f(1.0f*l/256, 1.0f*b/256); // Bottom left of picture. + //glVertex2f(-1.0f, -1.0f); // Bottom left of target. + + //glTexCoord2f(1.0f*r/256, 1.0f*b/256);// Bottom right of picture. + //glVertex2f( 1.0f, -1.0f); // Bottom right of target. + + //glTexCoord2f(1.0f*r/256, 1.0f*t/256); // Top right of our picture. + //glVertex2f( 1.0f, 1.0f); // Top right of target. + + //glTexCoord2f(1.0f*l/256, 1.0f*t/256); // Top left of our picture. + //glVertex2f(-1.0f, 1.0f); // Top left of target. + //glEnd(); + + //glPushMatrix(); + + //glColor4f( 1.0, 1.0, 1.0, 1.0 ); + //glLineWidth(5.0); + //glBegin(GL_LINES); + //glVertex2f(-1.0f, -1.0f); // Bottom left of target. + //glVertex2f( 1.0f, 1.0f); // Top right of target. + //glEnd(); + + //glPopMatrix(); + + glDisable(GL_TEXTURE_2D); + + glFlush(); + + return TRUE; +} + +static void +glwin_realize (GtkGLArea *area) +{ + int ipolate = 0; + gboolean has_alpha; + + printf("GL Realize!\n"); + // We need to make the context current if we want to + // call GL API + gtk_gl_area_make_current (area); + + // If there were errors during the initialization or + // when trying to make the context current, this + // function will return a #GError for you to catch + if (gtk_gl_area_get_error (area) != NULL) + { + printf("GL Realize Error\n"); + return; + } + + if ( drawAreaGLpixBuf == NULL ) + { + int bufSize; + + bufSize = 256 * 256 * sizeof(uint32_t); + + drawAreaGLpixBuf = (uint32_t*)malloc ( bufSize ); + + if ( drawAreaGLpixBuf ) + { + memset( drawAreaGLpixBuf, 0, bufSize ); + } + } + + has_alpha = gtk_gl_area_get_has_alpha( area ); + + printf("Has Alpha: %i \n", has_alpha ); + + if ( has_alpha ) + { + gtk_gl_area_set_has_alpha( area, 0 ); + } + // Enable depth buffer: + gtk_gl_area_set_has_depth_buffer(area, TRUE); + + has_alpha = gtk_gl_area_get_has_alpha( area ); + + printf("Has Alpha: %i \n", has_alpha ); + + glEnable(GL_TEXTURE_2D); + glGenTextures(1, &gltexture); + + glBindTexture(GL_TEXTURE_2D, gltexture); + + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,ipolate?GL_LINEAR:GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,ipolate?GL_LINEAR:GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP); + glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP); + glDisable(GL_TEXTURE_2D); + glDisable(GL_DEPTH_TEST); + glClearColor(1.0f, 0.0f, 0.0f, 0.0f); // Background color to black. + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + + // In a double buffered setup with page flipping, be sure to clear both buffers. + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + +} + /* Redraw the screen from the surface. Note that the ::draw * signal receives a ready-to-be-used cairo_t that is already * clipped to only draw the exposed areas of the widget @@ -3335,6 +3586,8 @@ static gboolean draw_cb (GtkWidget * widget, cairo_t * cr, gpointer data) int InitGTKSubsystem (int argc, char **argv) { + + int s_useOpenGL=0; GtkWidget *vbox; MainWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL); @@ -3367,8 +3620,22 @@ int InitGTKSubsystem (int argc, char **argv) // // prg - Bryan Cain, you are the man! - //evbox = gtk_event_box_new(); - evbox = gtk_drawing_area_new (); + #ifdef OPENGL + g_config->getOption("SDL.OpenGL", &s_useOpenGL); + #endif + + drawAreaGL = s_useOpenGL; + + if ( drawAreaGL ) + { + evbox = gtk_gl_area_new (); + gtk_gl_area_set_has_alpha( GTK_GL_AREA(evbox), TRUE); + gtk_gl_area_set_has_depth_buffer( GTK_GL_AREA(evbox), TRUE); + } + else + { + evbox = gtk_drawing_area_new (); + } gtk_box_pack_start (GTK_BOX (vbox), evbox, TRUE, TRUE, 0); double xscale, yscale; @@ -3394,9 +3661,19 @@ int InitGTKSubsystem (int argc, char **argv) g_signal_connect (MainWindow, "delete-event", quit, NULL); g_signal_connect (MainWindow, "destroy-event", quit, NULL); // resize handler - g_signal_connect (evbox, "configure-event", - G_CALLBACK (handle_resize), NULL); - g_signal_connect (evbox, "draw", G_CALLBACK (draw_cb), NULL); + if ( s_useOpenGL ) + { + g_signal_connect (evbox, "resize" , G_CALLBACK (glwin_resize ), NULL); + g_signal_connect (evbox, "realize", G_CALLBACK (glwin_realize), NULL); + g_signal_connect (evbox, "render" , G_CALLBACK (glwin_render ), NULL); + } + else + { + g_signal_connect (evbox, "configure-event", + G_CALLBACK (handle_resize), NULL); + + g_signal_connect (evbox, "draw", G_CALLBACK (draw_cb), NULL); + } gtk_widget_set_size_request (evbox, NES_WIDTH * xscale, NES_HEIGHT * yscale); diff --git a/src/drivers/sdl/sdl-video.cpp b/src/drivers/sdl/sdl-video.cpp index 7f5c0364..38aa34b1 100644 --- a/src/drivers/sdl/sdl-video.cpp +++ b/src/drivers/sdl/sdl-video.cpp @@ -252,8 +252,8 @@ int InitVideo(FCEUGI *gi) g_config->getOption("SDL.YScale", &s_eys); uint32_t rmask, gmask, bmask; - //s_exs = 1.0; - //s_eys = 1.0; + s_exs = 1.0; + s_eys = 1.0; xres = gtk_draw_area_width; yres = gtk_draw_area_height; // check the starting, ending, and total scan lines @@ -277,12 +277,12 @@ int InitVideo(FCEUGI *gi) FCEUI_SetShowFPS(show_fps); #ifdef LSB_FIRST - //rmask = 0x000000FF; - //gmask = 0x0000FF00; - //bmask = 0x00FF0000; - rmask = 0x00FF0000; + rmask = 0x000000FF; gmask = 0x0000FF00; - bmask = 0x000000FF; + bmask = 0x00FF0000; + //rmask = 0x00FF0000; + //gmask = 0x0000FF00; + //bmask = 0x000000FF; #else rmask = 0x00FF0000; gmask = 0x0000FF00; @@ -866,11 +866,11 @@ FCEUD_GetPalette(uint8 index, */ static void RedoPalette() { -#ifdef OPENGL - if(s_useOpenGL) - SetOpenGLPalette((uint8*)s_psdl); - else -#endif +//#ifdef OPENGL +// if(s_useOpenGL) +// SetOpenGLPalette((uint8*)s_psdl); +// else +//#endif { if(s_curbpp > 8) { SetPaletteBlitToHigh((uint8*)s_psdl); @@ -913,13 +913,13 @@ BlitScreen(uint8 *XBuf) s_paletterefresh = 0; } -#ifdef OPENGL - // OpenGL is handled separately - if(s_useOpenGL) { - BlitOpenGL(XBuf); - return; - } -#endif +//#ifdef OPENGL +// // OpenGL is handled separately +// if(s_useOpenGL) { +// BlitOpenGL(XBuf); +// return; +// } +//#endif // XXX soules - not entirely sure why this is being done yet XBuf += s_srendline * 256; @@ -956,7 +956,7 @@ BlitScreen(uint8 *XBuf) // XXX soules - again, I'm surprised SDL can't handle this // perform the blit, converting bpp if necessary if(s_curbpp > 8) { - if(s_BlitBuf) { + if(s_useOpenGL) { Blit8ToHigh(XBuf + NOFFSET, dest, NWIDTH, s_tlines, pitch, 1, 1); } else { diff --git a/src/drivers/sdl/sdl.cpp b/src/drivers/sdl/sdl.cpp index a2c00cda..2e8beda7 100644 --- a/src/drivers/sdl/sdl.cpp +++ b/src/drivers/sdl/sdl.cpp @@ -16,6 +16,7 @@ #include "sdl.h" #include "sdl-video.h" #include "unix-netplay.h" +#include "glxwin.h" #include "../common/configSys.h" #include "../../oldmovie.h" @@ -857,6 +858,7 @@ int main(int argc, char *argv[]) #ifdef _GTK if(noGui == 0) { + int glxwin_pid = spawn_glxwin(0); gtk_init(&argc, &argv); InitGTKSubsystem(argc, argv); while(gtk_events_pending()) From 4f27c58856eb0cc8bbadc2a667774a9ae28cde9b Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sun, 7 Jun 2020 09:32:47 -0400 Subject: [PATCH 136/156] Moved poor performing cairo draw routines into their own functions. Removed GtkGlArea experimental code that did not work. --- src/drivers/sdl/gui.cpp | 439 ++++++++++------------------------------ 1 file changed, 103 insertions(+), 336 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index ac71ef00..26ee1cc7 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -78,9 +78,8 @@ static GtkRadioMenuItem *stateSlot[10] = { NULL }; bool gtkIsStarted = false; bool menuTogglingEnabled = false; +static char useCairoDraw = 0; static int drawAreaGL = 0; -static GLuint gltexture = 0; -static uint32_t *drawAreaGLpixBuf = NULL; unsigned int gtk_draw_area_width = NES_WIDTH; unsigned int gtk_draw_area_height = NES_HEIGHT; static unsigned int gtk_win_width = 0; @@ -3100,51 +3099,43 @@ gint handleMouseClick (GtkWidget * widget, GdkEvent * event, uint32_t *getGuiPixelBuffer( int *w, int *h, int *s ) { - if ( drawAreaGL ) - { - if ( w ) *w = 256; - if ( h ) *h = 256; - if ( s ) *s = 256*4; - - //return NULL; - return glx_shm->pixbuf; - } - - if ( cairo_surface == NULL ) - { - if ( w ) *w = 0; - if ( h ) *h = 0; - if ( s ) *s = 0; - return NULL; - } - cairo_surface_flush( cairo_surface ); - - if ( w ) - { - *w = cairo_image_surface_get_width (cairo_surface); - } - if ( h ) - { - *h = cairo_image_surface_get_height (cairo_surface); - } - if ( s ) - { - *s = cairo_image_surface_get_stride(cairo_surface); - } + if ( w ) *w = GLX_NES_WIDTH; + if ( h ) *h = GLX_NES_HEIGHT; + if ( s ) *s = GLX_NES_WIDTH*4; //return NULL; - return (uint32_t*)cairo_image_surface_get_data (cairo_surface); + return glx_shm->pixbuf; + + //if ( cairo_surface == NULL ) + //{ + // if ( w ) *w = 0; + // if ( h ) *h = 0; + // if ( s ) *s = 0; + // return NULL; + //} + //cairo_surface_flush( cairo_surface ); + + //if ( w ) + //{ + // *w = cairo_image_surface_get_width (cairo_surface); + //} + //if ( h ) + //{ + // *h = cairo_image_surface_get_height (cairo_surface); + //} + //if ( s ) + //{ + // *s = cairo_image_surface_get_stride(cairo_surface); + //} + + ////return NULL; + //return (uint32_t*)cairo_image_surface_get_data (cairo_surface); } int guiPixelBufferReDraw(void) { glx_shm->blit_count++; - if ( drawAreaGL ) - { - gtk_gl_area_queue_render( (GtkGLArea*)evbox); - return 0; - } if ( cairo_surface != NULL ) { cairo_surface_mark_dirty( cairo_surface ); @@ -3158,6 +3149,7 @@ int guiClearSurface(void) { uint32_t *p; int w, h, z, i; + if ( cairo_surface != NULL ) { cairo_surface_flush( cairo_surface ); @@ -3177,27 +3169,14 @@ int guiClearSurface(void) return 0; } -static void setPixels(void) +static void loadPixelTestPattern(void) { uint32_t *p; int i,x,y,width,height,w2,h2; - if ( drawAreaGL ) - { - width = 256; - height = 256; - //p = (uint32_t*)drawAreaGLpixBuf; - p = (uint32_t*)glx_shm->pixbuf; - } - else - { - width = cairo_image_surface_get_width (cairo_surface); - height = cairo_image_surface_get_height (cairo_surface); - - cairo_surface_flush( cairo_surface ); - - p = (uint32_t*)cairo_image_surface_get_data (cairo_surface); - } + width = 256; + height = 256; + p = (uint32_t*)glx_shm->pixbuf; w2 = width / 2; h2 = height / 2; @@ -3234,23 +3213,41 @@ static void setPixels(void) i++; } } - //cairo_surface_mark_dirty( cairo_surface ); - if ( drawAreaGL ) - { - gtk_gl_area_queue_render( (GtkGLArea*)evbox); - } - else - { - gtk_widget_queue_draw( evbox ); - } } +static void cairo_handle_resize( int width, int height ) +{ + cairo_format_t cairo_format; + + if (cairo_surface) + { + cairo_surface_destroy (cairo_surface); cairo_surface = NULL; + } + + cairo_surface = cairo_image_surface_create( CAIRO_FORMAT_RGB24, + gtk_widget_get_allocated_width (evbox), + gtk_widget_get_allocated_height (evbox) ); + + printf("Cairo Surface: %p \n", cairo_surface ); + + cairo_format = cairo_image_surface_get_format( cairo_surface ); + + printf("Cairo Format: %i \n", cairo_format ); + + if ( cairo_format == CAIRO_FORMAT_ARGB32 ) + { + printf("Cairo Format: ARGB32 \n" ); + } + guiClearSurface(); + + cairo_surface_mark_dirty( cairo_surface ); +} + gboolean handle_resize (GtkWindow * win, GdkEvent * event, gpointer data) { - cairo_format_t cairo_format; // This should handle resizing so the emulation takes up as much // of the GTK window as possible @@ -3291,36 +3288,11 @@ gboolean handle_resize (GtkWindow * win, GdkEvent * event, gpointer data) if (yscale > xscale) yscale = xscale; - if (cairo_surface) + if ( useCairoDraw ) { - cairo_surface_destroy (cairo_surface); cairo_surface = NULL; + cairo_handle_resize( draw_width, draw_height ); } - //cairo_surface = gdk_window_create_similar_surface ( - // gtk_widget_get_window (evbox), - // CAIRO_CONTENT_COLOR_ALPHA, - // gtk_widget_get_allocated_width (evbox), - // gtk_widget_get_allocated_height (evbox) ); - - //cairo_surface = cairo_image_surface_create( CAIRO_FORMAT_ARGB32, - cairo_surface = cairo_image_surface_create( CAIRO_FORMAT_RGB24, - gtk_widget_get_allocated_width (evbox), - gtk_widget_get_allocated_height (evbox) ); - - printf("Cairo Surface: %p \n", cairo_surface ); - - cairo_format = cairo_image_surface_get_format( cairo_surface ); - - printf("Cairo Format: %i \n", cairo_format ); - if ( cairo_format == CAIRO_FORMAT_ARGB32 ) - { - printf("Cairo Format: ARGB32 \n" ); - } - guiClearSurface(); - - //setPixels(); - cairo_surface_mark_dirty( cairo_surface ); - //TODO if openGL make these integers g_config->setOption ("SDL.XScale", xscale); g_config->setOption ("SDL.YScale", yscale); @@ -3342,219 +3314,31 @@ gboolean handle_resize (GtkWindow * win, GdkEvent * event, gpointer data) return FALSE; } -static void -glwin_resize (GtkGLArea *area, - gint width, - gint height, - gpointer user_data) -{ - //char sizeChange = 0; - //printf("GL Resize: %ix%i \n", width, height ); - - //sizeChange = (width != gtk_draw_area_width) || (height != gtk_draw_area_height); - - //if ( sizeChange ) - //{ - // if ( drawAreaGLpixBuf != NULL) - // { - // free( drawAreaGLpixBuf ); drawAreaGLpixBuf = NULL; - // } - //} - gtk_draw_area_width = width; - gtk_draw_area_height = height; - - if ( drawAreaGLpixBuf == NULL ) - { - int bufSize; - - bufSize = 256 * 256 * sizeof(uint32_t); - - drawAreaGLpixBuf = (uint32_t*)malloc ( bufSize ); - - if ( drawAreaGLpixBuf ) - { - memset( drawAreaGLpixBuf, 0, bufSize ); - } - } - glViewport(0, 0, gtk_draw_area_width, gtk_draw_area_height); - glMatrixMode(GL_PROJECTION); - glLoadIdentity(); - glMatrixMode(GL_MODELVIEW); - glLoadIdentity(); -} - -static gboolean -glwin_render (GtkGLArea *area, - GdkGLContext *context, - gpointer user_data) -{ - int l=0, r=256; - int t=0, b=256; - - float xscale = 1.0; - float yscale = 1.0; - int rw=(int)((r-l)*xscale); - int rh=(int)((b-t)*yscale); - int sx=(gtk_draw_area_width-rw)/2; // Start x - int sy=(gtk_draw_area_height-rh)/2; // Start y - static float red = 1.0; - static int dir = 0; - - if ( dir ) - { - red += 0.01; - if ( red > 1.0 ) - { - red = 1.0; dir = 0; - } - } - else - { - red -= 0.01; - if ( red < 0.0 ) - { - red = 0.0; dir = 1; - } - } - //if(stretchx) { sx=0; rw=screen->w; } - //if(stretchy) { sy=0; rh=screen->h; } - //glViewport(sx, sy, rw, rh); - //glViewport(0, 0, gtk_draw_area_width, gtk_draw_area_height); - - //glLoadIdentity(); - //glPushMatrix(); - //glLoadIdentity(); - //glMatrixMode(GL_MODELVIEW); - //glOrtho( -1.0, 1.0, -1.0, 1.0, -1.0, 1.0); - - //printf("GL Render!\n"); - - glDisable(GL_DEPTH_TEST); - glClearColor( red, 0.0f, 0.0f, 0.0f); // Background color to black. - glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); - glDisable(GL_TEXTURE_2D); - glEnable(GL_LINE_SMOOTH); - //glEnable(GL_TEXTURE_2D); - //glBindTexture(GL_TEXTURE_2D, gltexture); - glBindTexture(GL_TEXTURE_2D, gltexture); - - - //setPixels(); - - //glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 256, 256, 0, - // GL_RGBA, GL_UNSIGNED_BYTE, drawAreaGLpixBuf ); - - //glBegin(GL_QUADS); - //glTexCoord2f(1.0f*l/256, 1.0f*b/256); // Bottom left of picture. - //glVertex2f(-1.0f, -1.0f); // Bottom left of target. - - //glTexCoord2f(1.0f*r/256, 1.0f*b/256);// Bottom right of picture. - //glVertex2f( 1.0f, -1.0f); // Bottom right of target. - - //glTexCoord2f(1.0f*r/256, 1.0f*t/256); // Top right of our picture. - //glVertex2f( 1.0f, 1.0f); // Top right of target. - - //glTexCoord2f(1.0f*l/256, 1.0f*t/256); // Top left of our picture. - //glVertex2f(-1.0f, 1.0f); // Top left of target. - //glEnd(); - - //glPushMatrix(); - - //glColor4f( 1.0, 1.0, 1.0, 1.0 ); - //glLineWidth(5.0); - //glBegin(GL_LINES); - //glVertex2f(-1.0f, -1.0f); // Bottom left of target. - //glVertex2f( 1.0f, 1.0f); // Top right of target. - //glEnd(); - - //glPopMatrix(); - - glDisable(GL_TEXTURE_2D); - - glFlush(); - - return TRUE; -} - -static void -glwin_realize (GtkGLArea *area) -{ - int ipolate = 0; - gboolean has_alpha; - - printf("GL Realize!\n"); - // We need to make the context current if we want to - // call GL API - gtk_gl_area_make_current (area); - - // If there were errors during the initialization or - // when trying to make the context current, this - // function will return a #GError for you to catch - if (gtk_gl_area_get_error (area) != NULL) - { - printf("GL Realize Error\n"); - return; - } - - if ( drawAreaGLpixBuf == NULL ) - { - int bufSize; - - bufSize = 256 * 256 * sizeof(uint32_t); - - drawAreaGLpixBuf = (uint32_t*)malloc ( bufSize ); - - if ( drawAreaGLpixBuf ) - { - memset( drawAreaGLpixBuf, 0, bufSize ); - } - } - - has_alpha = gtk_gl_area_get_has_alpha( area ); - - printf("Has Alpha: %i \n", has_alpha ); - - if ( has_alpha ) - { - gtk_gl_area_set_has_alpha( area, 0 ); - } - // Enable depth buffer: - gtk_gl_area_set_has_depth_buffer(area, TRUE); - - has_alpha = gtk_gl_area_get_has_alpha( area ); - - printf("Has Alpha: %i \n", has_alpha ); - - glEnable(GL_TEXTURE_2D); - glGenTextures(1, &gltexture); - - glBindTexture(GL_TEXTURE_2D, gltexture); - - glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,ipolate?GL_LINEAR:GL_NEAREST); - glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,ipolate?GL_LINEAR:GL_NEAREST); - glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP); - glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP); - glDisable(GL_TEXTURE_2D); - glDisable(GL_DEPTH_TEST); - glClearColor(1.0f, 0.0f, 0.0f, 0.0f); // Background color to black. - glMatrixMode(GL_MODELVIEW); - glLoadIdentity(); - - // In a double buffered setup with page flipping, be sure to clear both buffers. - glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); - -} - -/* Redraw the screen from the surface. Note that the ::draw - * signal receives a ready-to-be-used cairo_t that is already - * clipped to only draw the exposed areas of the widget - */ -static gboolean draw_cb (GtkWidget * widget, cairo_t * cr, gpointer data) +static gboolean cairo_clear_cb (GtkWidget * widget, cairo_t * cr, gpointer data) { GdkRGBA color; GtkStyleContext *context; - gtk_draw_area_width = gtk_widget_get_allocated_width (widget); + context = gtk_widget_get_style_context (widget); + + color.red = 0, color.blue = 0; color.green = 0; color.alpha = 1.0; + + gtk_render_background( context, cr, 0, 0, gtk_draw_area_width, gtk_draw_area_height ); + gdk_cairo_set_source_rgba (cr, &color); + + cairo_fill (cr); + cairo_paint (cr); + + return FALSE; +} +/* Redraw the screen from the surface. Note that the ::draw + * signal receives a ready-to-be-used cairo_t that is already + * clipped to only draw the exposed areas of the widget + */ + +static gboolean cairo_draw_cb (GtkWidget * widget, cairo_t * cr, gpointer data) +{ + gtk_draw_area_width = gtk_widget_get_allocated_width (widget); gtk_draw_area_height = gtk_widget_get_allocated_height (widget); if ( gtk_draw_area_width < NES_WIDTH ) gtk_draw_area_width = NES_WIDTH; @@ -3564,21 +3348,21 @@ static gboolean draw_cb (GtkWidget * widget, cairo_t * cr, gpointer data) cairo_set_source_surface (cr, cairo_surface, 0, 0); cairo_paint (cr); + return FALSE; +} - // Clear the screen on a window redraw - //if (GameInfo == 0) - //{ - context = gtk_widget_get_style_context (widget); +static gboolean draw_cb (GtkWidget * widget, cairo_t * cr, gpointer data) +{ - color.red = 0, color.blue = 0; color.green = 0; color.alpha = 1.0; + if ( useCairoDraw ) + { + cairo_draw_cb( widget, cr, data ); + } + else + { - gtk_render_background( context, cr, 0, 0, gtk_draw_area_width, gtk_draw_area_height ); - gdk_cairo_set_source_rgba (cr, &color); - - cairo_fill (cr); - cairo_paint (cr); - //} + } return FALSE; } @@ -3626,16 +3410,8 @@ int InitGTKSubsystem (int argc, char **argv) drawAreaGL = s_useOpenGL; - if ( drawAreaGL ) - { - evbox = gtk_gl_area_new (); - gtk_gl_area_set_has_alpha( GTK_GL_AREA(evbox), TRUE); - gtk_gl_area_set_has_depth_buffer( GTK_GL_AREA(evbox), TRUE); - } - else - { - evbox = gtk_drawing_area_new (); - } + evbox = gtk_drawing_area_new (); + gtk_box_pack_start (GTK_BOX (vbox), evbox, TRUE, TRUE, 0); double xscale, yscale; @@ -3660,20 +3436,11 @@ int InitGTKSubsystem (int argc, char **argv) // signal handlers g_signal_connect (MainWindow, "delete-event", quit, NULL); g_signal_connect (MainWindow, "destroy-event", quit, NULL); - // resize handler - if ( s_useOpenGL ) - { - g_signal_connect (evbox, "resize" , G_CALLBACK (glwin_resize ), NULL); - g_signal_connect (evbox, "realize", G_CALLBACK (glwin_realize), NULL); - g_signal_connect (evbox, "render" , G_CALLBACK (glwin_render ), NULL); - } - else - { - g_signal_connect (evbox, "configure-event", - G_CALLBACK (handle_resize), NULL); - g_signal_connect (evbox, "draw", G_CALLBACK (draw_cb), NULL); - } + g_signal_connect (evbox, "configure-event", + G_CALLBACK (handle_resize), NULL); + + g_signal_connect (evbox, "draw", G_CALLBACK (draw_cb), NULL); gtk_widget_set_size_request (evbox, NES_WIDTH * xscale, NES_HEIGHT * yscale); From 5bbbd0e8e70f084b3e1eebce157f5862a5b46284 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sun, 7 Jun 2020 10:54:00 -0400 Subject: [PATCH 137/156] Successful use of GLX openGL inside gtk3 window. This eliminates the need for SDL video. --- src/drivers/sdl/glxwin.cpp | 110 ++++++++++++++++++++++++++++++++++--- src/drivers/sdl/glxwin.h | 4 ++ src/drivers/sdl/gui.cpp | 15 ++++- 3 files changed, 120 insertions(+), 9 deletions(-) diff --git a/src/drivers/sdl/glxwin.cpp b/src/drivers/sdl/glxwin.cpp index 7f00b5c8..1166169c 100644 --- a/src/drivers/sdl/glxwin.cpp +++ b/src/drivers/sdl/glxwin.cpp @@ -15,6 +15,12 @@ #include #include +#include +#include +#ifdef GDK_WINDOWING_X11 +#include +#endif + #include "glxwin.h" static Display *dpy = NULL; @@ -29,11 +35,16 @@ static XWindowAttributes gwa; static XEvent xev; static GLuint gltexture = 0; +static int spawn_new_window = 0; glxwin_shm_t *glx_shm = NULL; static int screen_width = 512; static int screen_height = 512; + +extern GtkWidget *evbox; +extern unsigned int gtk_draw_area_width; +extern unsigned int gtk_draw_area_height; //************************************************************************ static glxwin_shm_t *open_shm(void) { @@ -121,6 +132,11 @@ static int open_window(void) XStoreName(dpy, win, "FCEUX VIEWPORT"); glc = glXCreateContext(dpy, vi, NULL, GL_TRUE); + + if ( glc == NULL ) + { + printf("Error: glXCreateContext Failed\n"); + } glXMakeCurrent(dpy, win, glc); genTextures(); @@ -171,8 +187,8 @@ static void render_image(void) glXMakeCurrent(dpy, win, glc); //printf("Viewport: (%i,%i) %i %i %i %i \n", // screen_width, screen_height, sx, sy, rw, rh ); - //glViewport(sx, sy, rw, rh); - glViewport( 0, 0, screen_width, screen_height); + glViewport(sx, sy, rw, rh); + //glViewport( 0, 0, screen_width, screen_height); glLoadIdentity(); glMatrixMode(GL_PROJECTION); @@ -208,12 +224,12 @@ static void render_image(void) glDisable(GL_TEXTURE_2D); - glColor4f( 1.0, 1.0, 1.0, 1.0 ); - glLineWidth(5.0); - glBegin(GL_LINES); - glVertex2f(-1.0f, -1.0f); // Bottom left of target. - glVertex2f( 1.0f, 1.0f); // Top right of target. - glEnd(); + //glColor4f( 1.0, 1.0, 1.0, 1.0 ); + //glLineWidth(5.0); + //glBegin(GL_LINES); + //glVertex2f(-1.0f, -1.0f); // Bottom left of target. + //glVertex2f( 1.0f, 1.0f); // Top right of target. + //glEnd(); glFlush(); @@ -297,6 +313,10 @@ int spawn_glxwin( int flags ) glx_shm = open_shm(); + if ( !spawn_new_window ) + { + return 0; + } pid = fork(); if ( pid == 0 ) @@ -326,5 +346,79 @@ int spawn_glxwin( int flags ) return pid; } //************************************************************************ +int init_gtk3_GLXContext( void ) +{ + XWindowAttributes xattrb; + GdkWindow *gdkWin = gtk_widget_get_window(evbox); + + if ( gdkWin == NULL ) + { + printf("Error: Failed to obtain gdkWindow Handle for evbox widget\n"); + return -1; + } + win = GDK_WINDOW_XID( gdkWin ); + + root = GDK_ROOT_WINDOW(); + + dpy = gdk_x11_get_default_xdisplay(); + + if ( dpy == NULL ) + { + printf("Error: Failed to obtain X Display Handle for evbox widget\n"); + return -1; + } + + if ( XGetWindowAttributes( dpy, win, &xattrb ) == 0 ) + { + printf("Error: XGetWindowAttributes failed\n"); + return -1; + } + printf("XWinLocation: (%i,%i) \n", xattrb.x, xattrb.y ); + printf("XWinSize: (%i x %i) \n", xattrb.width, xattrb.height ); + printf("XWinDepth: %i \n", xattrb.depth ); + printf("XWinVisual: %p \n", xattrb.visual ); + + vi = glXChooseVisual(dpy, 0, att); + + if (vi == NULL) + { + printf("\n\tno appropriate visual found\n\n"); + exit(0); + } + else { + printf("\n\tvisual %p selected\n", (void *)vi->visualid); /* %p creates hexadecimal output like in glxinfo */ + } + + glc = glXCreateContext(dpy, vi, NULL, GL_TRUE); + + if ( glc == NULL ) + { + printf("Error: glXCreateContext Failed\n"); + } + glXMakeCurrent(dpy, win, glc); + + genTextures(); + glDisable(GL_DEPTH_TEST); + glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // Background color to black. + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + + // In a double buffered setup with page flipping, be sure to clear both buffers. + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + return 0; +} +//************************************************************************ +int gtk3_glx_render(void) +{ + screen_width = gtk_draw_area_width; + screen_height = gtk_draw_area_height; + + render_image(); + + return 0; +} //************************************************************************ diff --git a/src/drivers/sdl/glxwin.h b/src/drivers/sdl/glxwin.h index 03f162c3..ed1b64e5 100644 --- a/src/drivers/sdl/glxwin.h +++ b/src/drivers/sdl/glxwin.h @@ -10,6 +10,10 @@ int spawn_glxwin( int flags ); +int init_gtk3_GLXContext( void ); + +int gtk3_glx_render(void); + #define GLX_NES_WIDTH 256 #define GLX_NES_HEIGHT 256 diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 26ee1cc7..cb1dc137 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -3136,6 +3136,8 @@ int guiPixelBufferReDraw(void) { glx_shm->blit_count++; + gtk3_glx_render(); + if ( cairo_surface != NULL ) { cairo_surface_mark_dirty( cairo_surface ); @@ -3361,12 +3363,21 @@ static gboolean draw_cb (GtkWidget * widget, cairo_t * cr, gpointer data) } else { - + gtk3_glx_render(); } return FALSE; } +static void +drawAreaRealizeCB (GtkWidget *widget, + gpointer user_data) +{ + printf("Draw Area Realize\n"); + + init_gtk3_GLXContext(); +} + int InitGTKSubsystem (int argc, char **argv) { @@ -3440,6 +3451,8 @@ int InitGTKSubsystem (int argc, char **argv) g_signal_connect (evbox, "configure-event", G_CALLBACK (handle_resize), NULL); + g_signal_connect (evbox, "realize", G_CALLBACK (drawAreaRealizeCB), NULL); + g_signal_connect (evbox, "draw", G_CALLBACK (draw_cb), NULL); gtk_widget_set_size_request (evbox, NES_WIDTH * xscale, From 79b796f790d7ea40b8348ed7cf1f1c3d6011b5fc Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sun, 7 Jun 2020 13:58:09 -0400 Subject: [PATCH 138/156] Implementing secondary cairo interface. --- src/drivers/sdl/glxwin.cpp | 2 +- src/drivers/sdl/gui.cpp | 212 ++++++++++++++++++++++++++++------ src/drivers/sdl/sdl-video.cpp | 65 ++++++----- 3 files changed, 213 insertions(+), 66 deletions(-) diff --git a/src/drivers/sdl/glxwin.cpp b/src/drivers/sdl/glxwin.cpp index 1166169c..12a84801 100644 --- a/src/drivers/sdl/glxwin.cpp +++ b/src/drivers/sdl/glxwin.cpp @@ -35,7 +35,7 @@ static XWindowAttributes gwa; static XEvent xev; static GLuint gltexture = 0; -static int spawn_new_window = 0; +static int spawn_new_window = 1; glxwin_shm_t *glx_shm = NULL; diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index cb1dc137..796ca4be 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -82,11 +82,9 @@ static char useCairoDraw = 0; static int drawAreaGL = 0; unsigned int gtk_draw_area_width = NES_WIDTH; unsigned int gtk_draw_area_height = NES_HEIGHT; -static unsigned int gtk_win_width = 0; -static unsigned int gtk_win_height = 0; -static int gtk_win_menu_ysize = 30; static GtkTreeStore *hotkey_store = NULL; static cairo_surface_t *cairo_surface = NULL; +static int *cairo_pix_remapper = NULL; static gint convertKeypress (GtkWidget * grab, GdkEventKey * event, gpointer user_data); @@ -3097,6 +3095,53 @@ gint handleMouseClick (GtkWidget * widget, GdkEvent * event, return 0; } +union cairo_pixel_t +{ + uint32_t u32; + uint8_t u8[4]; +}; + +static void transferPix2CairoSurface(void) +{ + union cairo_pixel_t *p; + int x, y, i,j, w, h; + + if ( cairo_surface == NULL ) + { + return; + } + cairo_surface_flush( cairo_surface ); + + w = cairo_image_surface_get_width (cairo_surface); + h = cairo_image_surface_get_height (cairo_surface); + + p = (cairo_pixel_t*)cairo_image_surface_get_data (cairo_surface); + + i=0; + for (y=0; ypixbuf[j]; + //p[i].u32 = 0xffffffff; + } + i++; + } + } + + cairo_surface_mark_dirty( cairo_surface ); + + gtk_widget_queue_draw( evbox ); +} + uint32_t *getGuiPixelBuffer( int *w, int *h, int *s ) { if ( w ) *w = GLX_NES_WIDTH; @@ -3136,14 +3181,15 @@ int guiPixelBufferReDraw(void) { glx_shm->blit_count++; - gtk3_glx_render(); - - if ( cairo_surface != NULL ) + if ( useCairoDraw ) { - cairo_surface_mark_dirty( cairo_surface ); - - gtk_widget_queue_draw( evbox ); + transferPix2CairoSurface(); } + else + { + gtk3_glx_render(); + } + return 0; } @@ -3218,19 +3264,119 @@ static void loadPixelTestPattern(void) } +static void cairo_recalc_mapper(void) +{ + int w, h, s; + int i, j, x, y; + int sw, sh, rx, ry; + int llx, lly, urx, ury; + float sx, sy, nw, nh; + + w = cairo_image_surface_get_width (cairo_surface); + h = cairo_image_surface_get_height (cairo_surface); + s = w * h * 4; + + if ( cairo_pix_remapper != NULL ) + { + ::free( cairo_pix_remapper ); cairo_pix_remapper = NULL; + } + cairo_pix_remapper = (int*)malloc(s); + + if ( cairo_pix_remapper == NULL ) + { + printf("Error: Failed to allocate memory for Pixel Surface Remapper\n"); + return; + } + memset( cairo_pix_remapper, 0, s ); + + sx = (float)w / (float)GLX_NES_WIDTH; + sy = (float)h / (float)GLX_NES_HEIGHT; + + if (sx < sy ) + { + sy = sx; + } + else + { + sx = sy; + } + + sw = (int) ( (float)GLX_NES_WIDTH * sx ); + sh = (int) ( (float)GLX_NES_HEIGHT * sy ); + + llx = (w - sw) / 2; + lly = (h - sh) / 2; + urx = llx + sw; + ury = lly + sh; + + i=0; + for (y=0; y ury) ) + { + for (x=0; x urx) ) + { + cairo_pix_remapper[i] = -1; i++; + } + else + { + nw = (float)(x - llx) / (float)sw; + nh = (float)(y - lly) / (float)sh; + + rx = (int)((float)GLX_NES_WIDTH * nw); + ry = (int)((float)GLX_NES_HEIGHT * nh); + + if ( rx < 0 ) + { + rx = 0; + } + else if ( rx >= GLX_NES_WIDTH ) + { + rx = GLX_NES_WIDTH-1; + } + if ( ry < 0 ) + { + ry = 0; + } + else if ( ry >= GLX_NES_HEIGHT ) + { + ry = GLX_NES_HEIGHT-1; + } + + j = (ry * GLX_NES_WIDTH) + rx; + //j = (rx * GLX_NES_WIDTH) + ry; + + cairo_pix_remapper[i] = j; i++; + + //printf("Remap: (%i,%i)=%i (%i,%i)=%i \n", x,y,i, rx,ry,j ); + } + } + } + } +} static void cairo_handle_resize( int width, int height ) { + int w, h; cairo_format_t cairo_format; if (cairo_surface) { cairo_surface_destroy (cairo_surface); cairo_surface = NULL; } + w = gtk_widget_get_allocated_width( evbox ); + h = gtk_widget_get_allocated_height( evbox ); - cairo_surface = cairo_image_surface_create( CAIRO_FORMAT_RGB24, - gtk_widget_get_allocated_width (evbox), - gtk_widget_get_allocated_height (evbox) ); + cairo_surface = cairo_image_surface_create( CAIRO_FORMAT_RGB24, w, h ); printf("Cairo Surface: %p \n", cairo_surface ); @@ -3242,9 +3388,13 @@ static void cairo_handle_resize( int width, int height ) { printf("Cairo Format: ARGB32 \n" ); } + cairo_recalc_mapper(); + guiClearSurface(); - cairo_surface_mark_dirty( cairo_surface ); + transferPix2CairoSurface(); + + //cairo_surface_mark_dirty( cairo_surface ); } @@ -3254,31 +3404,26 @@ gboolean handle_resize (GtkWindow * win, GdkEvent * event, gpointer data) // of the GTK window as possible // get new window width/height - int width, height, draw_width, draw_height, winsize_changed = 0; + int width, height, winsize_changed = 0; + width = event->configure.width; height = event->configure.height; //printf ("DEBUG: Configure new window size: %dx%d\n", width, height); - winsize_changed = (width != gtk_win_width) || (height != gtk_win_height); - - gtk_win_width = width; - gtk_win_height = height; + winsize_changed = 0; // get width/height multipliers double xscale = width / (double) NES_WIDTH; double yscale = height / (double) NES_HEIGHT; - draw_width = gtk_win_width; - draw_height = gtk_win_height - gtk_win_menu_ysize; - //printf("DRAW: %ix%i MenuY: %i \n", draw_width, draw_height, gtk_win_menu_ysize ); - if ( (draw_width != gtk_draw_area_width) || (draw_height != gtk_draw_area_height) ) + if ( (width != gtk_draw_area_width) || (height != gtk_draw_area_height) ) { winsize_changed = 1; } - gtk_draw_area_width = draw_width; - gtk_draw_area_height = draw_height; + gtk_draw_area_width = width; + gtk_draw_area_height = height; if ( gtk_draw_area_width < NES_WIDTH ) gtk_draw_area_width = NES_WIDTH; if ( gtk_draw_area_height < NES_HEIGHT ) gtk_draw_area_height = NES_HEIGHT; @@ -3292,7 +3437,7 @@ gboolean handle_resize (GtkWindow * win, GdkEvent * event, gpointer data) if ( useCairoDraw ) { - cairo_handle_resize( draw_width, draw_height ); + cairo_handle_resize( width, height ); } //TODO if openGL make these integers @@ -3340,14 +3485,6 @@ static gboolean cairo_clear_cb (GtkWidget * widget, cairo_t * cr, gpointer data) static gboolean cairo_draw_cb (GtkWidget * widget, cairo_t * cr, gpointer data) { - gtk_draw_area_width = gtk_widget_get_allocated_width (widget); - gtk_draw_area_height = gtk_widget_get_allocated_height (widget); - - if ( gtk_draw_area_width < NES_WIDTH ) gtk_draw_area_width = NES_WIDTH; - if ( gtk_draw_area_height < NES_HEIGHT ) gtk_draw_area_height = NES_HEIGHT; - - gtk_win_menu_ysize = gtk_win_height - gtk_draw_area_height; - cairo_set_source_surface (cr, cairo_surface, 0, 0); cairo_paint (cr); @@ -3357,6 +3494,12 @@ static gboolean cairo_draw_cb (GtkWidget * widget, cairo_t * cr, gpointer data) static gboolean draw_cb (GtkWidget * widget, cairo_t * cr, gpointer data) { + gtk_draw_area_width = gtk_widget_get_allocated_width (widget); + gtk_draw_area_height = gtk_widget_get_allocated_height (widget); + + if ( gtk_draw_area_width < NES_WIDTH ) gtk_draw_area_width = NES_WIDTH; + if ( gtk_draw_area_height < NES_HEIGHT ) gtk_draw_area_height = NES_HEIGHT; + if ( useCairoDraw ) { cairo_draw_cb( widget, cr, data ); @@ -3419,7 +3562,8 @@ int InitGTKSubsystem (int argc, char **argv) g_config->getOption("SDL.OpenGL", &s_useOpenGL); #endif - drawAreaGL = s_useOpenGL; + drawAreaGL = s_useOpenGL; + useCairoDraw = !drawAreaGL; evbox = gtk_drawing_area_new (); diff --git a/src/drivers/sdl/sdl-video.cpp b/src/drivers/sdl/sdl-video.cpp index 38aa34b1..7a42a3c2 100644 --- a/src/drivers/sdl/sdl-video.cpp +++ b/src/drivers/sdl/sdl-video.cpp @@ -908,7 +908,8 @@ BlitScreen(uint8 *XBuf) //} // refresh the palette if required - if(s_paletterefresh) { + if (s_paletterefresh) + { RedoPalette(); s_paletterefresh = 0; } @@ -945,34 +946,36 @@ BlitScreen(uint8 *XBuf) if ( dest == NULL ) return; //if(s_fullscreen) { // Always do this calculation now. Screen resolution is always provided. - xo = (int)(((w - NWIDTH * s_exs)) / 2); - dest += xo * (s_curbpp >> 3); - if(h > (s_tlines * s_eys)) { - yo = (int)((h - s_tlines * s_eys) / 2); - dest += yo * pitch; - } +// xo = (int)(((w - NWIDTH * s_exs)) / 2); +// dest += xo * (s_curbpp >> 3); +// if(h > (s_tlines * s_eys)) { +// yo = (int)((h - s_tlines * s_eys) / 2); +// dest += yo * pitch; +// } //} + Blit8ToHigh(XBuf + NOFFSET, dest, NWIDTH, s_tlines, pitch, 1, 1); + // XXX soules - again, I'm surprised SDL can't handle this // perform the blit, converting bpp if necessary - if(s_curbpp > 8) { - if(s_useOpenGL) { - Blit8ToHigh(XBuf + NOFFSET, dest, NWIDTH, s_tlines, - pitch, 1, 1); - } else { - Blit8ToHigh(XBuf + NOFFSET, dest, NWIDTH, s_tlines, - pitch, (int)s_exs, (int)s_eys); - } - } else { - if(s_BlitBuf) { - Blit8To8(XBuf + NOFFSET, dest, NWIDTH, s_tlines, - pitch, 1, 1, 0, s_sponge); - } else { - Blit8To8(XBuf + NOFFSET, dest, NWIDTH, s_tlines, - pitch, (int)s_exs, (int)s_eys, - s_eefx, s_sponge); - } - } + //if(s_curbpp > 8) { + // if(s_useOpenGL) { + // Blit8ToHigh(XBuf + NOFFSET, dest, NWIDTH, s_tlines, + // pitch, 1, 1); + // } else { + // Blit8ToHigh(XBuf + NOFFSET, dest, NWIDTH, s_tlines, + // pitch, (int)s_exs, (int)s_eys); + // } + //} else { + // if(s_BlitBuf) { + // Blit8To8(XBuf + NOFFSET, dest, NWIDTH, s_tlines, + // pitch, 1, 1, 0, s_sponge); + // } else { + // Blit8To8(XBuf + NOFFSET, dest, NWIDTH, s_tlines, + // pitch, (int)s_exs, (int)s_eys, + // s_eefx, s_sponge); + // } + //} //print_pixels(); // guiPixelBufferReDraw(); @@ -982,12 +985,12 @@ BlitScreen(uint8 *XBuf) // SDL_UnlockSurface(TmpScreen); //} - int scrw; - if(s_sponge == 3) { // NTSC 2x - scrw = 301; - } else { - scrw = NWIDTH; - } + //int scrw; + //if(s_sponge == 3) { // NTSC 2x + // scrw = 301; + //} else { + // scrw = NWIDTH; + //} // if we have a hardware video buffer, do a fast video->video copy //if(s_BlitBuf) { From 9db334275fa9879f3aceb623ff89dca0862a0110 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Mon, 8 Jun 2020 09:14:01 -0400 Subject: [PATCH 139/156] Added logic to allow for switching from openGL to cairo draw functions. There is still an issue with the GTK draw update stops getting called when switch from openGL to cairo. --- src/drivers/sdl/glxwin.cpp | 81 +++++++++++++--- src/drivers/sdl/glxwin.h | 10 ++ src/drivers/sdl/gui.cpp | 104 ++++++++++++++++---- src/drivers/sdl/gui.h | 5 + src/drivers/sdl/sdl-video.cpp | 178 ++++++++++++++++++---------------- 5 files changed, 266 insertions(+), 112 deletions(-) diff --git a/src/drivers/sdl/glxwin.cpp b/src/drivers/sdl/glxwin.cpp index 12a84801..6e496dfe 100644 --- a/src/drivers/sdl/glxwin.cpp +++ b/src/drivers/sdl/glxwin.cpp @@ -30,7 +30,7 @@ static XVisualInfo *vi = NULL; static Colormap cmap; static XSetWindowAttributes swa; static Window win; -static GLXContext glc; +static GLXContext glc = NULL; static XWindowAttributes gwa; static XEvent xev; @@ -77,6 +77,10 @@ static glxwin_shm_t *open_shm(void) sem_init( &vaddr->sem, 1, 1 ); + vaddr->ncol = 256; + vaddr->nrow = 256; + vaddr->pitch = 256 * 4; + return vaddr; } //************************************************************************ @@ -84,6 +88,11 @@ static void genTextures(void) { int ipolate = 1; + if ( gltexture ) + { + printf("GL Texture already exists\n"); + return; + } glEnable(GL_TEXTURE_2D); glGenTextures(1, &gltexture); @@ -131,11 +140,18 @@ static int open_window(void) XStoreName(dpy, win, "FCEUX VIEWPORT"); - glc = glXCreateContext(dpy, vi, NULL, GL_TRUE); - if ( glc == NULL ) { - printf("Error: glXCreateContext Failed\n"); + glc = glXCreateContext(dpy, vi, NULL, GL_TRUE); + + if ( glc == NULL ) + { + printf("Error: glXCreateContext Failed\n"); + } + } + else + { + printf("GLX Context Already Exists\n"); } glXMakeCurrent(dpy, win, glc); @@ -166,11 +182,13 @@ static void print_pixbuf(void) //************************************************************************ static void render_image(void) { - int l=0, r=GLX_NES_WIDTH; - int t=0, b=GLX_NES_HEIGHT; + static int null_glc_error = 0; + int l=0, r=glx_shm->ncol; + int t=0, b=glx_shm->nrow; + + float xscale = (float)screen_width / (float)glx_shm->ncol; + float yscale = (float)screen_height / (float)glx_shm->nrow; - float xscale = (float)screen_width / (float)GLX_NES_WIDTH; - float yscale = (float)screen_height / (float)GLX_NES_HEIGHT; if (xscale < yscale ) { yscale = xscale; @@ -184,6 +202,17 @@ static void render_image(void) int sx=(screen_width-rw)/2; int sy=(screen_height-rh)/2; + if ( glc == NULL ) + { + if ( !null_glc_error ) + { + printf("Error: GLX Render has NULL Context\n"); + null_glc_error = 1; + } + return; + } + null_glc_error = 0; + glXMakeCurrent(dpy, win, glc); //printf("Viewport: (%i,%i) %i %i %i %i \n", // screen_width, screen_height, sx, sy, rw, rh ); @@ -251,7 +280,7 @@ static int mainWindowLoop(void) //glViewport(0, 0, gwa.width, gwa.height); //DrawAQuad(); glXSwapBuffers(dpy, win); - printf("Expose\n"); + //printf("Expose\n"); } else if (xev.type == ConfigureNotify) { @@ -267,7 +296,7 @@ static int mainWindowLoop(void) //genTextures(); - printf("Resize Request: (%i,%i)\n", screen_width, screen_height ); + //printf("Resize Request: (%i,%i)\n", screen_width, screen_height ); render_image(); //glViewport(0, 0, gwa.width, gwa.height); //DrawAQuad(); @@ -350,6 +379,8 @@ int init_gtk3_GLXContext( void ) { XWindowAttributes xattrb; + printf("Init GLX Context\n"); + GdkWindow *gdkWin = gtk_widget_get_window(evbox); if ( gdkWin == NULL ) @@ -390,11 +421,14 @@ int init_gtk3_GLXContext( void ) printf("\n\tvisual %p selected\n", (void *)vi->visualid); /* %p creates hexadecimal output like in glxinfo */ } - glc = glXCreateContext(dpy, vi, NULL, GL_TRUE); - if ( glc == NULL ) { - printf("Error: glXCreateContext Failed\n"); + glc = glXCreateContext(dpy, vi, NULL, GL_TRUE); + + if ( glc == NULL ) + { + printf("Error: glXCreateContext Failed\n"); + } } glXMakeCurrent(dpy, win, glc); @@ -412,6 +446,27 @@ int init_gtk3_GLXContext( void ) return 0; } //************************************************************************ +int destroy_gtk3_GLXContext(void) +{ + if ( dpy != NULL ) + { + glXMakeCurrent(dpy, None, NULL); + } + + if (gltexture) + { + printf("Destroying GLX Texture\n"); + glDeleteTextures(1, &gltexture); + gltexture=0; + } + if ( glc != NULL ) + { + printf("Destroying GLX Context\n"); + glXDestroyContext(dpy, glc); glc = NULL; + } + return 0; +} +//************************************************************************ int gtk3_glx_render(void) { screen_width = gtk_draw_area_width; diff --git a/src/drivers/sdl/glxwin.h b/src/drivers/sdl/glxwin.h index ed1b64e5..2f2fad40 100644 --- a/src/drivers/sdl/glxwin.h +++ b/src/drivers/sdl/glxwin.h @@ -11,6 +11,7 @@ int spawn_glxwin( int flags ); int init_gtk3_GLXContext( void ); +int destroy_gtk3_GLXContext( void ); int gtk3_glx_render(void); @@ -25,6 +26,10 @@ struct glxwin_shm_t uint32_t blit_count; sem_t sem; + int ncol; + int nrow; + int pitch; + // Pass Key Events back to GTK Gui struct { @@ -56,6 +61,11 @@ struct glxwin_shm_t } guiEvent; uint32_t pixbuf[65536]; // 256 x 256 + + void clear_pixbuf(void) + { + memset( pixbuf, 0, sizeof(pixbuf) ); + } }; extern glxwin_shm_t *glx_shm; diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 796ca4be..90e006ac 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -85,6 +85,8 @@ unsigned int gtk_draw_area_height = NES_HEIGHT; static GtkTreeStore *hotkey_store = NULL; static cairo_surface_t *cairo_surface = NULL; static int *cairo_pix_remapper = NULL; +static int numRendLines = 0; +static void cairo_recalc_mapper(void); static gint convertKeypress (GtkWidget * grab, GdkEventKey * event, gpointer user_data); @@ -3104,6 +3106,7 @@ union cairo_pixel_t static void transferPix2CairoSurface(void) { union cairo_pixel_t *p; + union cairo_pixel_t *g; int x, y, i,j, w, h; if ( cairo_surface == NULL ) @@ -3112,10 +3115,16 @@ static void transferPix2CairoSurface(void) } cairo_surface_flush( cairo_surface ); + if ( numRendLines != glx_shm->nrow ) + { + cairo_recalc_mapper(); + } + w = cairo_image_surface_get_width (cairo_surface); h = cairo_image_surface_get_height (cairo_surface); p = (cairo_pixel_t*)cairo_image_surface_get_data (cairo_surface); + g = (cairo_pixel_t*)glx_shm->pixbuf; i=0; for (y=0; ypixbuf[j]; + // RGBA to ARGB + #ifdef LSB_FIRST + p[i].u8[2] = g[j].u8[0]; + p[i].u8[1] = g[j].u8[1]; + p[i].u8[0] = g[j].u8[2]; + p[i].u8[3] = g[j].u8[3]; + #else + p[i].u32 = g[j].u32; + #endif //p[i].u32 = 0xffffffff; } i++; @@ -3268,7 +3285,7 @@ static void cairo_recalc_mapper(void) { int w, h, s; int i, j, x, y; - int sw, sh, rx, ry; + int sw, sh, rx, ry, gw, gh; int llx, lly, urx, ury; float sx, sy, nw, nh; @@ -3276,6 +3293,9 @@ static void cairo_recalc_mapper(void) h = cairo_image_surface_get_height (cairo_surface); s = w * h * 4; + gw = glx_shm->ncol; + gh = glx_shm->nrow; + if ( cairo_pix_remapper != NULL ) { ::free( cairo_pix_remapper ); cairo_pix_remapper = NULL; @@ -3289,8 +3309,8 @@ static void cairo_recalc_mapper(void) } memset( cairo_pix_remapper, 0, s ); - sx = (float)w / (float)GLX_NES_WIDTH; - sy = (float)h / (float)GLX_NES_HEIGHT; + sx = (float)w / (float)gw; + sy = (float)h / (float)gh; if (sx < sy ) { @@ -3301,8 +3321,8 @@ static void cairo_recalc_mapper(void) sx = sy; } - sw = (int) ( (float)GLX_NES_WIDTH * sx ); - sh = (int) ( (float)GLX_NES_HEIGHT * sy ); + sw = (int) ( (float)gw * sx ); + sh = (int) ( (float)gh * sy ); llx = (w - sw) / 2; lly = (h - sh) / 2; @@ -3332,8 +3352,8 @@ static void cairo_recalc_mapper(void) nw = (float)(x - llx) / (float)sw; nh = (float)(y - lly) / (float)sh; - rx = (int)((float)GLX_NES_WIDTH * nw); - ry = (int)((float)GLX_NES_HEIGHT * nh); + rx = (int)((float)gw * nw); + ry = (int)((float)gh * nh); if ( rx < 0 ) { @@ -3353,7 +3373,6 @@ static void cairo_recalc_mapper(void) } j = (ry * GLX_NES_WIDTH) + rx; - //j = (rx * GLX_NES_WIDTH) + ry; cairo_pix_remapper[i] = j; i++; @@ -3362,9 +3381,10 @@ static void cairo_recalc_mapper(void) } } } + numRendLines = gh; } -static void cairo_handle_resize( int width, int height ) +static void cairo_handle_resize(void) { int w, h; cairo_format_t cairo_format; @@ -3376,18 +3396,15 @@ static void cairo_handle_resize( int width, int height ) w = gtk_widget_get_allocated_width( evbox ); h = gtk_widget_get_allocated_height( evbox ); + //cairo_surface = cairo_image_surface_create( CAIRO_FORMAT_ARGB32, w, h ); cairo_surface = cairo_image_surface_create( CAIRO_FORMAT_RGB24, w, h ); printf("Cairo Surface: %p \n", cairo_surface ); cairo_format = cairo_image_surface_get_format( cairo_surface ); - printf("Cairo Format: %i \n", cairo_format ); + //printf("Cairo Format: %i \n", cairo_format ); - if ( cairo_format == CAIRO_FORMAT_ARGB32 ) - { - printf("Cairo Format: ARGB32 \n" ); - } cairo_recalc_mapper(); guiClearSurface(); @@ -3397,6 +3414,54 @@ static void cairo_handle_resize( int width, int height ) //cairo_surface_mark_dirty( cairo_surface ); } +int destroy_gui_video( void ) +{ + printf("Destroy GUI Video\n"); + + destroy_cairo_screen(); + + destroy_gtk3_GLXContext(); + + return 0; +} + +int init_gui_video( int use_openGL ) +{ + drawAreaGL = use_openGL; + useCairoDraw = !drawAreaGL; + + if ( use_openGL ) + { + destroy_cairo_screen(); + init_gtk3_GLXContext(); + } + else + { + destroy_gtk3_GLXContext(); + init_cairo_screen(); + } + return 0; +} + +void init_cairo_screen(void) +{ + cairo_handle_resize(); +} + +void destroy_cairo_screen(void) +{ + if (cairo_surface) + { + printf("Destroying Cairo Surface\n"); + cairo_surface_destroy (cairo_surface); cairo_surface = NULL; + } + if ( cairo_pix_remapper != NULL ) + { + printf("Destroying Cairo Pixel Remapper\n"); + ::free( cairo_pix_remapper ); cairo_pix_remapper = NULL; + } +} + gboolean handle_resize (GtkWindow * win, GdkEvent * event, gpointer data) { @@ -3435,9 +3500,9 @@ gboolean handle_resize (GtkWindow * win, GdkEvent * event, gpointer data) if (yscale > xscale) yscale = xscale; - if ( useCairoDraw ) + if ( useCairoDraw && winsize_changed ) { - cairo_handle_resize( width, height ); + cairo_handle_resize(); } //TODO if openGL make these integers @@ -3518,7 +3583,10 @@ drawAreaRealizeCB (GtkWidget *widget, { printf("Draw Area Realize\n"); - init_gtk3_GLXContext(); + if ( drawAreaGL ) + { + init_gtk3_GLXContext(); + } } diff --git a/src/drivers/sdl/gui.h b/src/drivers/sdl/gui.h index 73147ee9..b3313bb6 100644 --- a/src/drivers/sdl/gui.h +++ b/src/drivers/sdl/gui.h @@ -89,4 +89,9 @@ int InitGTKSubsystem(int argc, char** argv); uint32_t *getGuiPixelBuffer( int *w, int *h, int *s ); int guiPixelBufferReDraw(void); +int init_gui_video( int use_openGL ); +int destroy_gui_video( void ); +void init_cairo_screen(void); +void destroy_cairo_screen(void); + #endif // ifndef FCEUX_GUI_H diff --git a/src/drivers/sdl/sdl-video.cpp b/src/drivers/sdl/sdl-video.cpp index 7a42a3c2..bc555fcb 100644 --- a/src/drivers/sdl/sdl-video.cpp +++ b/src/drivers/sdl/sdl-video.cpp @@ -23,6 +23,7 @@ #include "sdl.h" #include "sdl-opengl.h" +#include "glxwin.h" #include "../common/vidblit.h" #include "../../fceu.h" #include "../../version.h" @@ -80,6 +81,7 @@ static int s_fullscreen = 0; static int noframe = 0; static int s_nativeWidth = -1; static int s_nativeHeight = -1; +static int initBlitToHighDone = 0; #define NWIDTH (256 - (s_clipSides ? 16 : 0)) #define NOFFSET (s_clipSides ? 8 : 0) @@ -136,6 +138,13 @@ bool FCEUD_ShouldDrawInputAids() int KillVideo() { + printf("Killing Video\n"); + + if ( glx_shm != NULL ) + { + glx_shm->clear_pixbuf(); + } + // if the IconSurface has been initialized, destroy it if (s_IconSurface) { @@ -143,51 +152,53 @@ KillVideo() s_IconSurface=0; } + //destroy_gui_video(); + // return failure if the video system was not initialized - if(s_inited == 0) + if (s_inited == 0) return -1; - + // if the rest of the system has been initialized, shut it down -#ifdef OPENGL - // check for OpenGL and shut it down - if(s_useOpenGL) - { - KillOpenGL(); - } - else -#endif - { - // shut down the system that converts from 8 to 16/32 bpp - if (s_curbpp > 8) - { - KillBlitToHigh(); - } - } +//#ifdef OPENGL +// // check for OpenGL and shut it down +// if(s_useOpenGL) +// { +// KillOpenGL(); +// } +// else +//#endif +// { +// // shut down the system that converts from 8 to 16/32 bpp +// if (s_curbpp > 8) +// { +// KillBlitToHigh(); +// } +// } -#if SDL_VERSION_ATLEAST(2, 0, 0) - - if ( s_screen != NULL ) - { - SDL_FreeSurface( s_screen ); s_screen = NULL; - } - - if ( s_texture != NULL ) - { - SDL_DestroyTexture( s_texture ); s_texture = NULL; - } - - if ( s_renderer != NULL ) - { - SDL_DestroyRenderer( s_renderer ); s_renderer = NULL; - } - - if ( s_window != NULL ) - { - SDL_DestroyWindow( s_window ); - s_window = NULL; - } - -#endif +//#if SDL_VERSION_ATLEAST(2, 0, 0) +// +// if ( s_screen != NULL ) +// { +// SDL_FreeSurface( s_screen ); s_screen = NULL; +// } +// +// if ( s_texture != NULL ) +// { +// SDL_DestroyTexture( s_texture ); s_texture = NULL; +// } +// +// if ( s_renderer != NULL ) +// { +// SDL_DestroyRenderer( s_renderer ); s_renderer = NULL; +// } +// +// if ( s_window != NULL ) +// { +// SDL_DestroyWindow( s_window ); +// s_window = NULL; +// } +// +//#endif // shut down the SDL video sub-system //SDL_QuitSubSystem(SDL_INIT_VIDEO); @@ -198,7 +209,7 @@ KillVideo() // this variable contains information about the special scaling filters -static int s_sponge; +static int s_sponge = 0; /** * These functions determine an appropriate scale factor for fullscreen/ @@ -240,7 +251,7 @@ int InitVideo(FCEUGI *gi) #ifdef OPENGL g_config->getOption("SDL.OpenGL", &s_useOpenGL); #endif - g_config->getOption("SDL.SpecialFilter", &s_sponge); + //g_config->getOption("SDL.SpecialFilter", &s_sponge); g_config->getOption("SDL.XStretch", &xstretch); g_config->getOption("SDL.YStretch", &ystretch); //g_config->getOption("SDL.LastXRes", &xres); @@ -248,10 +259,11 @@ int InitVideo(FCEUGI *gi) g_config->getOption("SDL.ClipSides", &s_clipSides); g_config->getOption("SDL.NoFrame", &noframe); g_config->getOption("SDL.ShowFPS", &show_fps); - g_config->getOption("SDL.XScale", &s_exs); - g_config->getOption("SDL.YScale", &s_eys); + //g_config->getOption("SDL.XScale", &s_exs); + //g_config->getOption("SDL.YScale", &s_eys); uint32_t rmask, gmask, bmask; + s_sponge = 0; s_exs = 1.0; s_eys = 1.0; xres = gtk_draw_area_width; @@ -271,6 +283,8 @@ int InitVideo(FCEUGI *gi) //} #endif + init_gui_video( s_useOpenGL ); + s_inited = 1; // check to see if we are showing FPS @@ -280,9 +294,6 @@ int InitVideo(FCEUGI *gi) rmask = 0x000000FF; gmask = 0x0000FF00; bmask = 0x00FF0000; - //rmask = 0x00FF0000; - //gmask = 0x0000FF00; - //bmask = 0x000000FF; #else rmask = 0x00FF0000; gmask = 0x0000FF00; @@ -356,36 +367,36 @@ int InitVideo(FCEUGI *gi) //s_paletterefresh = 1; // -Video Modes Tag- - if (s_sponge) - { - if (s_sponge <= 3 && s_sponge >= 1) - { - s_exs = s_eys = 2; - } - else if (s_sponge >=4 && s_sponge <= 5) - { - s_exs = s_eys = 3; - } - else if (s_sponge >= 6 && s_sponge <= 8) - { - s_exs = s_eys = s_sponge - 4; - } - else if(s_sponge == 9) - { - s_exs = s_eys = 3; - } - else - { - s_exs = s_eys = 1; - } - if(s_sponge == 3) { - xres = 301 * s_exs; - } - s_eefx = 0; - //if(s_sponge == 1 || s_sponge == 4) { - // desbpp = 32; - //} - } + //if (s_sponge) + //{ + // if (s_sponge <= 3 && s_sponge >= 1) + // { + // s_exs = s_eys = 2; + // } + // else if (s_sponge >=4 && s_sponge <= 5) + // { + // s_exs = s_eys = 3; + // } + // else if (s_sponge >= 6 && s_sponge <= 8) + // { + // s_exs = s_eys = s_sponge - 4; + // } + // else if(s_sponge == 9) + // { + // s_exs = s_eys = 3; + // } + // else + // { + // s_exs = s_eys = 1; + // } + // if(s_sponge == 3) { + // xres = 301 * s_exs; + // } + // s_eefx = 0; + // //if(s_sponge == 1 || s_sponge == 4) { + // // desbpp = 32; + // //} + //} //int scrw = NWIDTH * s_exs; //if(s_sponge == 3) { @@ -414,13 +425,15 @@ int InitVideo(FCEUGI *gi) } #endif - if (s_curbpp > 8) + if ( !initBlitToHighDone ) { InitBlitToHigh(s_curbpp >> 3, rmask, gmask, bmask, s_eefx, s_sponge, 0); + + initBlitToHighDone = 1; } return 0; @@ -466,7 +479,7 @@ InitVideo(FCEUGI *gi) // check for OpenGL and set the global flags #ifdef OPENGL - if(s_useOpenGL && !s_sponge) { + if (s_useOpenGL && !s_sponge) { flags = SDL_OPENGL; } #endif @@ -941,7 +954,9 @@ BlitScreen(uint8 *XBuf) //dest = (uint8*)TmpScreen->pixels; dest = (uint8*)getGuiPixelBuffer( &w, &h, &pitch ); - pitch = w * 4; + glx_shm->ncol = NWIDTH; + glx_shm->nrow = s_tlines; + glx_shm->pitch = pitch; if ( dest == NULL ) return; @@ -954,6 +969,7 @@ BlitScreen(uint8 *XBuf) // } //} + //Blit8ToHigh(XBuf + NOFFSET, dest, NWIDTH, s_tlines, pitch, 1, 1); Blit8ToHigh(XBuf + NOFFSET, dest, NWIDTH, s_tlines, pitch, 1, 1); // XXX soules - again, I'm surprised SDL can't handle this From 3e2802a2de28e4fabe07f54b4fa51ae8959b22e4 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Tue, 9 Jun 2020 08:44:51 -0400 Subject: [PATCH 140/156] Bug fix for switching between openGL and cairo graphics contexts. --- src/drivers/sdl/glxwin.cpp | 17 +++++++++++++---- src/drivers/sdl/gui.cpp | 33 +++++++++++++++++++++++++++------ src/drivers/sdl/sdl.cpp | 6 +++--- 3 files changed, 43 insertions(+), 13 deletions(-) diff --git a/src/drivers/sdl/glxwin.cpp b/src/drivers/sdl/glxwin.cpp index 6e496dfe..0ee7a691 100644 --- a/src/drivers/sdl/glxwin.cpp +++ b/src/drivers/sdl/glxwin.cpp @@ -153,6 +153,8 @@ static int open_window(void) { printf("GLX Context Already Exists\n"); } + XFree(vi); vi = NULL; + glXMakeCurrent(dpy, win, glc); genTextures(); @@ -405,10 +407,10 @@ int init_gtk3_GLXContext( void ) printf("Error: XGetWindowAttributes failed\n"); return -1; } - printf("XWinLocation: (%i,%i) \n", xattrb.x, xattrb.y ); - printf("XWinSize: (%i x %i) \n", xattrb.width, xattrb.height ); - printf("XWinDepth: %i \n", xattrb.depth ); - printf("XWinVisual: %p \n", xattrb.visual ); + //printf("XWinLocation: (%i,%i) \n", xattrb.x, xattrb.y ); + //printf("XWinSize: (%i x %i) \n", xattrb.width, xattrb.height ); + //printf("XWinDepth: %i \n", xattrb.depth ); + //printf("XWinVisual: %p \n", xattrb.visual ); vi = glXChooseVisual(dpy, 0, att); @@ -430,6 +432,8 @@ int init_gtk3_GLXContext( void ) printf("Error: glXCreateContext Failed\n"); } } + XFree(vi); vi = NULL; + glXMakeCurrent(dpy, win, glc); genTextures(); @@ -464,6 +468,11 @@ int destroy_gtk3_GLXContext(void) printf("Destroying GLX Context\n"); glXDestroyContext(dpy, glc); glc = NULL; } + if ( dpy != NULL ) + { + XSync( dpy, False ); + } + return 0; } //************************************************************************ diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 90e006ac..0c1ab7fc 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -84,6 +84,7 @@ unsigned int gtk_draw_area_width = NES_WIDTH; unsigned int gtk_draw_area_height = NES_HEIGHT; static GtkTreeStore *hotkey_store = NULL; static cairo_surface_t *cairo_surface = NULL; +static cairo_pattern_t *cairo_pattern = NULL; static int *cairo_pix_remapper = NULL; static int numRendLines = 0; static void cairo_recalc_mapper(void); @@ -3113,6 +3114,7 @@ static void transferPix2CairoSurface(void) { return; } + //printf("Cairo Pixel ReMap\n"); cairo_surface_flush( cairo_surface ); if ( numRendLines != glx_shm->nrow ) @@ -3135,7 +3137,7 @@ static void transferPix2CairoSurface(void) if ( j < 0 ) { - p[i].u32 = 0; + p[i].u32 = 0xff000000; } else { @@ -3144,9 +3146,13 @@ static void transferPix2CairoSurface(void) p[i].u8[2] = g[j].u8[0]; p[i].u8[1] = g[j].u8[1]; p[i].u8[0] = g[j].u8[2]; - p[i].u8[3] = g[j].u8[3]; + p[i].u8[3] = 0xff; // Force Alpha to full #else - p[i].u32 = g[j].u32; + // Big-Endian is untested. + p[i].u8[2] = g[j].u8[0]; + p[i].u8[1] = g[j].u8[1]; + p[i].u8[0] = g[j].u8[2]; + p[i].u8[3] = 0xff; // Force Alpha to full #endif //p[i].u32 = 0xffffffff; } @@ -3396,13 +3402,19 @@ static void cairo_handle_resize(void) w = gtk_widget_get_allocated_width( evbox ); h = gtk_widget_get_allocated_height( evbox ); - //cairo_surface = cairo_image_surface_create( CAIRO_FORMAT_ARGB32, w, h ); - cairo_surface = cairo_image_surface_create( CAIRO_FORMAT_RGB24, w, h ); + cairo_surface = cairo_image_surface_create( CAIRO_FORMAT_ARGB32, w, h ); + //cairo_surface = cairo_image_surface_create( CAIRO_FORMAT_RGB24, w, h ); printf("Cairo Surface: %p \n", cairo_surface ); cairo_format = cairo_image_surface_get_format( cairo_surface ); + if (cairo_pattern) + { + cairo_pattern_destroy (cairo_pattern); cairo_pattern = NULL; + } + cairo_pattern = cairo_pattern_create_for_surface( cairo_surface ); + //printf("Cairo Format: %i \n", cairo_format ); cairo_recalc_mapper(); @@ -3450,6 +3462,11 @@ void init_cairo_screen(void) void destroy_cairo_screen(void) { + if (cairo_pattern) + { + printf("Destroying Cairo Pattern\n"); + cairo_pattern_destroy (cairo_pattern); cairo_pattern = NULL; + } if (cairo_surface) { printf("Destroying Cairo Surface\n"); @@ -3550,7 +3567,11 @@ static gboolean cairo_clear_cb (GtkWidget * widget, cairo_t * cr, gpointer data) static gboolean cairo_draw_cb (GtkWidget * widget, cairo_t * cr, gpointer data) { - cairo_set_source_surface (cr, cairo_surface, 0, 0); + //printf("Cairo Draw\n"); + //cairo_clear_cb( widget, cr, data ); + //cairo_surface_mark_dirty( cairo_surface ); + //cairo_set_source_surface (cr, cairo_surface, 0, 0); + cairo_set_source (cr, cairo_pattern); cairo_paint (cr); return FALSE; diff --git a/src/drivers/sdl/sdl.cpp b/src/drivers/sdl/sdl.cpp index 2e8beda7..137a1deb 100644 --- a/src/drivers/sdl/sdl.cpp +++ b/src/drivers/sdl/sdl.cpp @@ -561,9 +561,9 @@ int main(int argc, char *argv[]) return(-1); } -#ifdef OPENGL - SDL_GL_LoadLibrary(0); -#endif +//#ifdef OPENGL +// SDL_GL_LoadLibrary(0); +//#endif // Initialize the configuration system g_config = InitConfig(); From cfbe2dc5f3f2b8902d39206ea25ecd4f49701aaa Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Tue, 9 Jun 2020 09:23:32 -0400 Subject: [PATCH 141/156] Bug fixes for GL linear filters and double buffering options. --- src/drivers/sdl/config.cpp | 6 +-- src/drivers/sdl/glxwin.cpp | 78 ++++++++++++++++++++++---------------- src/drivers/sdl/glxwin.h | 6 ++- src/drivers/sdl/gui.cpp | 17 ++++++--- 4 files changed, 65 insertions(+), 42 deletions(-) diff --git a/src/drivers/sdl/config.cpp b/src/drivers/sdl/config.cpp index 0c91e621..9774e0d0 100644 --- a/src/drivers/sdl/config.cpp +++ b/src/drivers/sdl/config.cpp @@ -206,7 +206,7 @@ InitConfig() config->addOption("SDL.LastXRes", 0); config->addOption("SDL.LastYRes", 0); config->addOption('b', "bpp", "SDL.BitsPerPixel", 32); - config->addOption("doublebuf", "SDL.DoubleBuffering", 0); + config->addOption("doublebuf", "SDL.DoubleBuffering", 1); config->addOption("autoscale", "SDL.AutoScale", 1); config->addOption("keepratio", "SDL.KeepRatio", 1); config->addOption("xscale", "SDL.XScale", 1.0); @@ -219,8 +219,8 @@ InitConfig() config->addOption("togglemenu", "SDL.ToggleMenu", 0); // OpenGL options - config->addOption("opengl", "SDL.OpenGL", 0); - config->addOption("openglip", "SDL.OpenGLip", 0); + config->addOption("opengl", "SDL.OpenGL", 1); + config->addOption("openglip", "SDL.OpenGLip", 1); config->addOption("SDL.SpecialFilter", 0); config->addOption("SDL.SpecialFX", 0); config->addOption("SDL.Vsync", 1); diff --git a/src/drivers/sdl/glxwin.cpp b/src/drivers/sdl/glxwin.cpp index 0ee7a691..ab000ee3 100644 --- a/src/drivers/sdl/glxwin.cpp +++ b/src/drivers/sdl/glxwin.cpp @@ -25,7 +25,6 @@ static Display *dpy = NULL; static Window root; -static GLint att[] = { GLX_RGBA, GLX_DEPTH_SIZE, 24, GLX_DOUBLEBUFFER, None }; static XVisualInfo *vi = NULL; static Colormap cmap; static XSetWindowAttributes swa; @@ -33,9 +32,10 @@ static Window win; static GLXContext glc = NULL; static XWindowAttributes gwa; static XEvent xev; +static GLint double_buffer_ena = True; static GLuint gltexture = 0; -static int spawn_new_window = 1; +static int spawn_new_window = 0; glxwin_shm_t *glx_shm = NULL; @@ -84,17 +84,32 @@ static glxwin_shm_t *open_shm(void) return vaddr; } //************************************************************************ -static void genTextures(void) +static void getAttrbList( GLint *buf ) { - int ipolate = 1; + int i=0; + + buf[i] = GLX_RGBA; i++; + buf[i] = GLX_DEPTH_SIZE; i++; + buf[i] = 24; i++; + buf[i] = GLX_DOUBLEBUFFER ; i++; + buf[i] = double_buffer_ena; i++; + buf[i] = None; + +} +//************************************************************************ +static void genTextures( int ipolate ) +{ + glEnable(GL_TEXTURE_2D); if ( gltexture ) { printf("GL Texture already exists\n"); - return; } - glEnable(GL_TEXTURE_2D); - glGenTextures(1, &gltexture); + else + { + glGenTextures(1, &gltexture); + } + printf("Linear Interpolation on GL Texture: %s \n", ipolate ? "Enabled" : "Disabled"); glBindTexture(GL_TEXTURE_2D, gltexture); @@ -107,6 +122,9 @@ static void genTextures(void) //************************************************************************ static int open_window(void) { + GLint att[32]; + + getAttrbList( att ); dpy = XOpenDisplay(NULL); @@ -157,7 +175,7 @@ static int open_window(void) glXMakeCurrent(dpy, win, glc); - genTextures(); + genTextures(1); glDisable(GL_DEPTH_TEST); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // Background color to black. glMatrixMode(GL_PROJECTION); @@ -171,16 +189,16 @@ static int open_window(void) return 0; } //************************************************************************ -static void print_pixbuf(void) -{ - for (int x=0; x<256; x++) - { - for (int y=0; y<256; y++) - { - printf("(%i,%i) = %08X \n", x, y, glx_shm->pixbuf[x*256+y] ); - } - } -} +//static void print_pixbuf(void) +//{ +// for (int x=0; x<256; x++) +// { +// for (int y=0; y<256; y++) +// { +// printf("(%i,%i) = %08X \n", x, y, glx_shm->pixbuf[y*256+x] ); +// } +// } +//} //************************************************************************ static void render_image(void) { @@ -286,23 +304,10 @@ static int mainWindowLoop(void) } else if (xev.type == ConfigureNotify) { - //XGetWindowAttributes(dpy, win, &gwa); - screen_width = xev.xconfigure.width; screen_height = xev.xconfigure.height; - //if (gltexture) { - // glDeleteTextures(1, &gltexture); - //} - //gltexture=0; - - //genTextures(); - - //printf("Resize Request: (%i,%i)\n", screen_width, screen_height ); render_image(); - //glViewport(0, 0, gwa.width, gwa.height); - //DrawAQuad(); - //glXSwapBuffers(dpy, win); } else if (xev.type == KeyPress) { @@ -377,11 +382,18 @@ int spawn_glxwin( int flags ) return pid; } //************************************************************************ -int init_gtk3_GLXContext( void ) +int init_gtk3_GLXContext( int flags ) { + GLint att[32]; + XWindowAttributes xattrb; + double_buffer_ena = (flags & GLXWIN_DOUBLE_BUFFER) ? 1 : 0; + + getAttrbList( att ); + printf("Init GLX Context\n"); + printf("Double Buffering: %s\n", double_buffer_ena ? "Enabled" : "Disabled"); GdkWindow *gdkWin = gtk_widget_get_window(evbox); @@ -436,7 +448,7 @@ int init_gtk3_GLXContext( void ) glXMakeCurrent(dpy, win, glc); - genTextures(); + genTextures( flags & GLXWIN_PIXEL_LINEAR_FILTER ? 1 : 0 ); glDisable(GL_DEPTH_TEST); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // Background color to black. glMatrixMode(GL_PROJECTION); diff --git a/src/drivers/sdl/glxwin.h b/src/drivers/sdl/glxwin.h index 2f2fad40..ba2d8224 100644 --- a/src/drivers/sdl/glxwin.h +++ b/src/drivers/sdl/glxwin.h @@ -10,7 +10,11 @@ int spawn_glxwin( int flags ); -int init_gtk3_GLXContext( void ); +#define GLXWIN_PIXEL_LINEAR_FILTER 0x0001 +#define GLXWIN_DOUBLE_BUFFER 0x0002 + +int init_gtk3_GLXContext( int flags ); + int destroy_gtk3_GLXContext( void ); int gtk3_glx_render(void); diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 0c1ab7fc..180de200 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -3444,8 +3444,18 @@ int init_gui_video( int use_openGL ) if ( use_openGL ) { + int flags=0; + int linear_interpolation_ena=0; + int double_buffer_ena=0; + + g_config->getOption("SDL.OpenGLip" , &linear_interpolation_ena ); + g_config->getOption("SDL.DoubleBuffering", &double_buffer_ena ); + + if ( linear_interpolation_ena ) flags |= GLXWIN_PIXEL_LINEAR_FILTER; + if ( double_buffer_ena ) flags |= GLXWIN_DOUBLE_BUFFER; + destroy_cairo_screen(); - init_gtk3_GLXContext(); + init_gtk3_GLXContext( flags ); } else { @@ -3604,10 +3614,7 @@ drawAreaRealizeCB (GtkWidget *widget, { printf("Draw Area Realize\n"); - if ( drawAreaGL ) - { - init_gtk3_GLXContext(); - } + init_gui_video( drawAreaGL ); } From d08671404011fd81931ba71d7396476b0d509898 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Tue, 9 Jun 2020 21:47:07 -0400 Subject: [PATCH 142/156] Bug fix for full screen mode update. --- src/drivers/sdl/gui.cpp | 23 +++++++++++++++++++--- src/drivers/sdl/input.cpp | 40 +++++++++++---------------------------- 2 files changed, 31 insertions(+), 32 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 180de200..ea945496 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -2366,10 +2366,11 @@ unsigned int GDKToSDLKeyval (int gdk_key) } // ignore pause and screenshot hotkeys since they is handled by GTK+ as accelerators - if (sdl_key == Hotkeys[HK_PAUSE] || sdl_key == Hotkeys[HK_SCREENSHOT] || - sdl_key == Hotkeys[HK_SAVE_STATE] - || sdl_key == Hotkeys[HK_LOAD_STATE]) + if ( (sdl_key == Hotkeys[HK_PAUSE]) || (sdl_key == Hotkeys[HK_SCREENSHOT]) || + (sdl_key == Hotkeys[HK_SAVE_STATE]) || (sdl_key == Hotkeys[HK_LOAD_STATE]) ) + { return 0; + } return sdl_key; } @@ -2416,7 +2417,23 @@ static gboolean convertKeypress (GtkWidget * grab, GdkEventKey * event, // Create an SDL event from the keypress. sdlev.key.keysym.scancode = SDL_GetScancodeFromKey(sdlkey); sdlev.key.keysym.sym = sdlkey; + sdlev.key.keysym.mod = 0; + + if ( event->state & GDK_SHIFT_MASK ) + { + sdlev.key.keysym.mod |= KMOD_SHIFT; + } + if ( event->state & GDK_CONTROL_MASK ) + { + sdlev.key.keysym.mod |= KMOD_CTRL; + } + if ( event->state & GDK_MOD1_MASK ) + { + sdlev.key.keysym.mod |= KMOD_ALT; + } + sdlev.key.repeat = 0; + if (sdlkey != 0) { SDL_PushEvent (&sdlev); diff --git a/src/drivers/sdl/input.cpp b/src/drivers/sdl/input.cpp index c41665d7..618a480f 100644 --- a/src/drivers/sdl/input.cpp +++ b/src/drivers/sdl/input.cpp @@ -49,7 +49,7 @@ #include /** GLOBALS **/ -int NoWaiting = 1; +int NoWaiting = 0; extern Config *g_config; extern bool bindSavestate, frameAdvanceLagSkip, lagCounterDisplay; @@ -448,7 +448,7 @@ unsigned int *GetKeyboard(void) /** * Parse keyboard commands and execute accordingly. */ -static void KeyboardCommands () +static void KeyboardCommands (void) { int is_shift, is_alt; @@ -474,11 +474,6 @@ static void KeyboardCommands () FCEUI_DispMessage ("Family Keyboard %sabled.", 0, g_fkbEnabled ? "en" : "dis"); } -#if SDL_VERSION_ATLEAST(2, 0, 0) - // TODO - SDL2 -#else - SDL_WM_GrabInput (g_fkbEnabled ? SDL_GRAB_ON : SDL_GRAB_OFF); -#endif if (g_fkbEnabled) { return; @@ -502,23 +497,11 @@ static void KeyboardCommands () #endif { is_alt = 1; -#if !SDL_VERSION_ATLEAST(2, 0, 0) - // workaround for GDK->SDL in GTK problems where ALT release is never - // getting sent - // I know this is sort of an ugly hack to fix this, but the bug is - // rather annoying - // prg318 10/23/11 - int fullscreen; - g_config->getOption ("SDL.Fullscreen", &fullscreen); - if (!fullscreen) - { - g_keyState[SDLK_LALT] = 0; - g_keyState[SDLK_RALT] = 0; - } -#endif } else + { is_alt = 0; + } if (_keyonly (Hotkeys[HK_TOGGLE_BG])) @@ -534,12 +517,11 @@ static void KeyboardCommands () } // Alt-Enter to toggle full-screen - if (keyonly (ENTER) && is_alt) - { - ToggleFS (); - } - - + // This is already handled by GTK Accelerator + //if (keyonly (ENTER) && is_alt) + //{ + // ToggleFS (); + //} // Toggle Movie auto-backup if (keyonly (M) && is_shift) @@ -687,10 +669,10 @@ static void KeyboardCommands () } // Toggle throttling - NoWaiting &= ~1; if ( _keyonly(Hotkeys[HK_TURBO]) ) { - NoWaiting |= 1; + NoWaiting ^= 1; + //printf("NoWaiting: 0x%04x\n", NoWaiting ); } static bool frameAdvancing = false; From 1463e7c0f8ba7622f0b1af654388cf2ecde4116a Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Tue, 9 Jun 2020 22:09:29 -0400 Subject: [PATCH 143/156] Added logic to now pass ALT + Return to the SDL event queue as the is fullscreen toggle that is handled by GTK. --- src/drivers/sdl/gui.cpp | 11 +++++++++++ src/drivers/sdl/input.cpp | 9 +++++++++ src/drivers/sdl/input.h | 1 + 3 files changed, 21 insertions(+) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index ea945496..ccf53e0d 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -2434,6 +2434,17 @@ static gboolean convertKeypress (GtkWidget * grab, GdkEventKey * event, } sdlev.key.repeat = 0; + + if ( (event->state & GDK_MOD1_MASK) || + getKeyState( SDL_SCANCODE_LALT ) || getKeyState( SDL_SCANCODE_RALT ) ) + { + // Don't pass ALT + Enter to game, as this toggles fullscreen in GTK + if ( sdlkey == SDLK_RETURN ) + { + return FALSE; + } + } + if (sdlkey != 0) { SDL_PushEvent (&sdlev); diff --git a/src/drivers/sdl/input.cpp b/src/drivers/sdl/input.cpp index 618a480f..731624cf 100644 --- a/src/drivers/sdl/input.cpp +++ b/src/drivers/sdl/input.cpp @@ -147,6 +147,15 @@ static int DIPS = 0; static uint8 keyonce[MKK_COUNT]; #define KEY(__a) g_keyState[MKK(__a)] +int getKeyState( int k ) +{ + if ( (k >= 0) && (k < SDL_NUM_SCANCODES) ) + { + return g_keyState[k]; + } + return 0; +} + static int _keyonly (int a) { diff --git a/src/drivers/sdl/input.h b/src/drivers/sdl/input.h index 033d5077..331d2795 100644 --- a/src/drivers/sdl/input.h +++ b/src/drivers/sdl/input.h @@ -20,6 +20,7 @@ extern ARGPSTRUCT InputArgs[]; extern int Hotkeys[]; void ParseGIInput(FCEUGI *GI); void setHotKeys(); +int getKeyState( int k ); int ButtonConfigBegin(); void ButtonConfigEnd(); void ConfigButton(char *text, ButtConfig *bc); From 4cbfed2a726bb829fabdf4efbeaab73378df4b61 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Fri, 12 Jun 2020 18:59:38 -0400 Subject: [PATCH 144/156] Clean up of input and video files. Removed SDL1 code. --- src/drivers/sdl/input.cpp | 154 ++------ src/drivers/sdl/sdl-video.cpp | 691 +--------------------------------- 2 files changed, 31 insertions(+), 814 deletions(-) diff --git a/src/drivers/sdl/input.cpp b/src/drivers/sdl/input.cpp index 731624cf..30626c8d 100644 --- a/src/drivers/sdl/input.cpp +++ b/src/drivers/sdl/input.cpp @@ -137,14 +137,10 @@ DoCheatSeq () } #include "keyscan.h" -#if SDL_VERSION_ATLEAST(2, 0, 0) static uint8 g_keyState[SDL_NUM_SCANCODES]; -#else -static uint8 *g_keyState = 0; -#endif static int DIPS = 0; -static uint8 keyonce[MKK_COUNT]; +static uint8 keyonce[SDL_NUM_SCANCODES]; #define KEY(__a) g_keyState[MKK(__a)] int getKeyState( int k ) @@ -161,12 +157,11 @@ _keyonly (int a) { // check for valid key if (a > SDLK_LAST + 1 || a < 0) + { return 0; -#if SDL_VERSION_ATLEAST(2, 0, 0) + } + if (g_keyState[SDL_GetScancodeFromKey (a)]) -#else - if (g_keyState[a]) -#endif { if (!keyonce[a]) { @@ -215,24 +210,6 @@ TogglePause () int fullscreen; g_config->getOption ("SDL.Fullscreen", &fullscreen); - // Don't touch grab when in windowed mode - if(fullscreen == 0) - return; - -#if SDL_VERSION_ATLEAST(2, 0, 0) - // TODO - SDL2 -#else - if (FCEUI_EmulationPaused () == 0) - { - SDL_WM_GrabInput (SDL_GRAB_ON); - if(no_cursor) - SDL_ShowCursor (0); - } - else { - SDL_WM_GrabInput (SDL_GRAB_OFF); - SDL_ShowCursor (1); - } -#endif return; } @@ -446,11 +423,9 @@ void FCEUD_LoadStateFrom () unsigned int *GetKeyboard(void) { int size = 256; -#if SDL_VERSION_ATLEAST(2, 0, 0) + Uint8* keystate = (Uint8*)SDL_GetKeyboardState(&size); -#else - Uint8* keystate = SDL_GetKeyState(&size); -#endif + return (unsigned int*)(keystate); } @@ -463,47 +438,32 @@ static void KeyboardCommands (void) char *movie_fname = ""; // get the keyboard input -#if SDL_VERSION_ATLEAST(1, 3, 0) - //g_keyState = (Uint8*)SDL_GetKeyboardState (NULL); -#else - g_keyState = SDL_GetKeyState (NULL); -#endif // check if the family keyboard is enabled if (CurInputType[2] == SIFC_FKB) { -#if SDL_VERSION_ATLEAST(1, 3, 0) - // TODO - SDL2 if ( g_keyState[SDL_SCANCODE_SCROLLLOCK] ) -#else - if (keyonly (SCROLLLOCK)) -#endif - { - g_fkbEnabled ^= 1; - FCEUI_DispMessage ("Family Keyboard %sabled.", 0, - g_fkbEnabled ? "en" : "dis"); - } + { + g_fkbEnabled ^= 1; + FCEUI_DispMessage ("Family Keyboard %sabled.", 0, + g_fkbEnabled ? "en" : "dis"); + } if (g_fkbEnabled) { return; } } -#if SDL_VERSION_ATLEAST(2, 0, 0) - if (g_keyState[SDL_SCANCODE_LSHIFT] - || g_keyState[SDL_SCANCODE_RSHIFT]) -#else - if (g_keyState[SDLK_LSHIFT] || g_keyState[SDLK_RSHIFT]) -#endif - is_shift = 1; - else - is_shift = 0; -#if SDL_VERSION_ATLEAST(2, 0, 0) - if (g_keyState[SDL_SCANCODE_LALT] - || g_keyState[SDL_SCANCODE_RALT]) -#else - if (g_keyState[SDLK_LALT] || g_keyState[SDLK_RALT]) -#endif + if (g_keyState[SDL_SCANCODE_LSHIFT] || g_keyState[SDL_SCANCODE_RSHIFT]) + { + is_shift = 1; + } + else + { + is_shift = 0; + } + + if (g_keyState[SDL_SCANCODE_LALT] || g_keyState[SDL_SCANCODE_RALT]) { is_alt = 1; } @@ -1041,52 +1001,6 @@ int ButtonConfigBegin () bcpj = KillJoysticks (); - // reactivate the video subsystem -// if (!SDL_WasInit (SDL_INIT_VIDEO)) -// { -// if (!bcpv) -// { -// InitVideo (GameInfo); -// } -// else -// { -//#if defined(_GTK) && defined(SDL_VIDEO_DRIVER_X11) -// if (noGui == 0) -// { -// while (gtk_events_pending ()) -// gtk_main_iteration_do (FALSE); -// -// char SDL_windowhack[128]; -// if (gtk_widget_get_window (evbox)) -// sprintf (SDL_windowhack, "SDL_WINDOWID=%u", -// (unsigned int) GDK_WINDOW_XID (gtk_widget_get_window (evbox))); -//#if SDL_VERSION_ATLEAST(2, 0, 0) -// // TODO - SDL2 -//#else -// SDL_putenv (SDL_windowhack); -//#endif -// } -//#endif -// if (SDL_InitSubSystem (SDL_INIT_VIDEO) == -1) -// { -// FCEUD_Message (SDL_GetError ()); -// return 0; -// } -// -// // set the screen and notify the user of button configuration -//#if SDL_VERSION_ATLEAST(2, 0, 0) -// // TODO - SDL2 -//#else -// screen = SDL_SetVideoMode (420, 200, 8, 0); -// if ( screen == NULL ) -// { -// printf("Error: SDL_SetVideoMode Failed\n"); -// } -// SDL_WM_SetCaption ("Button Config", 0); -//#endif -// } -// } - // XXX soules - why did we shut this down? // initialize the joystick subsystem InitJoysticks (); @@ -1128,13 +1042,8 @@ DTestButton (ButtConfig * bc) { if (bc->ButtType[x] == BUTTC_KEYBOARD) { -#if SDL_VERSION_ATLEAST(2, 0, 0) if (g_keyState[SDL_GetScancodeFromKey (bc->ButtonNum[x])]) { -#else - if (g_keyState[bc->ButtonNum[x]]) - { -#endif return 1; } } @@ -1145,8 +1054,8 @@ DTestButton (ButtConfig * bc) return 1; } } - } - return 0; + } + return 0; } @@ -1156,15 +1065,9 @@ DTestButton (ButtConfig * bc) #define GPZ() {MKZ(), MKZ(), MKZ(), MKZ()} ButtConfig GamePadConfig[4][10] = { -#if SDL_VERSION_ATLEAST(2, 0, 0) /* Gamepad 1 */ {MK (KP_3), MK (KP_2), MK (SLASH), MK (ENTER), MK (W), MK (Z), MK (A), MK (S), MKZ (), MKZ ()}, -#else - /* Gamepad 1 */ - {MK (KP3), MK (KP2), MK (SLASH), MK (ENTER), - MK (W), MK (Z), MK (A), MK (S), MKZ (), MKZ ()}, -#endif /* Gamepad 2 */ GPZ (), @@ -1435,9 +1338,7 @@ void InitInputInterface () int x; int attrib; -#if SDL_VERSION_ATLEAST(2, 0, 0) memset( g_keyState, 0, sizeof(g_keyState) ); -#endif for (t = 0, x = 0; x < 2; x++) { @@ -1684,11 +1585,7 @@ const char * ButtonName (const ButtConfig * bc, int which) switch (bc->ButtType[which]) { case BUTTC_KEYBOARD: -#if SDL_VERSION_ATLEAST(2,0,0) return SDL_GetKeyName (bc->ButtonNum[which]); -#else - return SDL_GetKeyName ((SDLKey) bc->ButtonNum[which]); -#endif break; case BUTTC_JOYSTICK: { @@ -1754,11 +1651,8 @@ int DWaitButton (const uint8 * text, ButtConfig * bc, int wb) { std::string title = "Press a key for "; title += (const char *) text; -#if SDL_VERSION_ATLEAST(2,0,0) // TODO - SDL2 -#else - SDL_WM_SetCaption (title.c_str (), 0); -#endif + //SDL_WM_SetCaption (title.c_str (), 0); puts ((const char *) text); } diff --git a/src/drivers/sdl/sdl-video.cpp b/src/drivers/sdl/sdl-video.cpp index bc555fcb..c6361311 100644 --- a/src/drivers/sdl/sdl-video.cpp +++ b/src/drivers/sdl/sdl-video.cpp @@ -56,16 +56,6 @@ extern Config *g_config; // STATIC GLOBALS -#if SDL_VERSION_ATLEAST(2, 0, 0) -static SDL_Window *s_window = NULL; -static SDL_Renderer *s_renderer = NULL; -static SDL_Texture *s_texture = NULL; -#endif -static SDL_Surface *s_screen = NULL; - -static SDL_Surface *s_BlitBuf; // Buffer when using hardware-accelerated blits. -static SDL_Surface *s_IconSurface = NULL; - static int s_curbpp = 0; static int s_srendline, s_erendline; static int s_tlines; @@ -79,8 +69,6 @@ static int s_eefx = 0; static int s_clipSides = 0; static int s_fullscreen = 0; static int noframe = 0; -static int s_nativeWidth = -1; -static int s_nativeHeight = -1; static int initBlitToHighDone = 0; #define NWIDTH (256 - (s_clipSides ? 16 : 0)) @@ -97,38 +85,6 @@ extern unsigned int gtk_draw_area_height; * success, -1 on failure. */ -static void print_pixels(void) -{ - uint32_t i,j; - uint32_t *buf; - uint32_t pixel; - - buf = (uint32_t*)s_screen->pixels; - - i=0; j=0; - for (int x=0; xw; x++) - { - for (int y=0; yh; y++) - { - pixel = buf[i]; i++; - - if ( pixel != 0 ) - { - printf("(%i,%i) %08x ", x, y, pixel ); j++; - if ( j % 10 == 0 ) - { - printf("\n"); - } - } - //printf("(%i,%i) %08x ", x, y, pixel ); - - } - } - - - -} - //draw input aids if we are fullscreen bool FCEUD_ShouldDrawInputAids() { @@ -138,68 +94,27 @@ bool FCEUD_ShouldDrawInputAids() int KillVideo() { - printf("Killing Video\n"); + //printf("Killing Video\n"); if ( glx_shm != NULL ) { glx_shm->clear_pixbuf(); } - // if the IconSurface has been initialized, destroy it - if (s_IconSurface) - { - SDL_FreeSurface(s_IconSurface); - s_IconSurface=0; - } - //destroy_gui_video(); // return failure if the video system was not initialized if (s_inited == 0) return -1; - // if the rest of the system has been initialized, shut it down -//#ifdef OPENGL -// // check for OpenGL and shut it down -// if(s_useOpenGL) -// { -// KillOpenGL(); -// } -// else -//#endif -// { + // if the rest of the system has been initialized, shut it down // // shut down the system that converts from 8 to 16/32 bpp // if (s_curbpp > 8) // { // KillBlitToHigh(); // } -// } - -//#if SDL_VERSION_ATLEAST(2, 0, 0) -// -// if ( s_screen != NULL ) -// { -// SDL_FreeSurface( s_screen ); s_screen = NULL; -// } -// -// if ( s_texture != NULL ) -// { -// SDL_DestroyTexture( s_texture ); s_texture = NULL; -// } -// -// if ( s_renderer != NULL ) -// { -// SDL_DestroyRenderer( s_renderer ); s_renderer = NULL; -// } -// -// if ( s_window != NULL ) -// { -// SDL_DestroyWindow( s_window ); -// s_window = NULL; -// } -// -//#endif + // SDL Video system is not used. // shut down the SDL video sub-system //SDL_QuitSubSystem(SDL_INIT_VIDEO); @@ -232,15 +147,8 @@ void FCEUD_VideoChanged() PAL = 0; // NTSC and Dendy } -#if SDL_VERSION_ATLEAST(2, 0, 0) int InitVideo(FCEUGI *gi) { - // This is a big TODO. Stubbing this off into its own function, - // as the SDL surface routines have changed drastically in SDL2 - // TODO - SDL2 - // XXX soules - const? is this necessary? - //const SDL_VideoInfo *vinf; - int error, flags = 0; int doublebuf, xstretch, ystretch, xres, yres, show_fps; FCEUI_printf("Initializing video..."); @@ -273,16 +181,6 @@ int InitVideo(FCEUGI *gi) FCEUI_GetCurrentVidSystem(&s_srendline, &s_erendline); s_tlines = s_erendline - s_srendline + 1; - // check if we should auto-set x/y resolution - - // check for OpenGL and set the global flags -#ifdef OPENGL - // FIXME - //if(s_useOpenGL && !s_sponge) { - // flags = SDL_OPENGL; - //} -#endif - init_gui_video( s_useOpenGL ); s_inited = 1; @@ -300,47 +198,8 @@ int InitVideo(FCEUGI *gi) bmask = 0x000000FF; #endif - // if all this hex scares you, check out SDL_PixelFormatEnumToMasks()! -//#ifdef LSB_FIRST -// //printf("Little Endian\n"); -// s_screen = SDL_CreateRGBSurface(0, xres, yres, 32, -// 0xFF, 0xFF00, 0xFF0000, 0x00); -//#else -// //printf("Big Endian\n"); -// s_screen = SDL_CreateRGBSurface(0, xres, yres, 32, -// 0xFF0000, 0xFF00, 0xFF, 0x00); -//#endif -// -// if ( s_screen == NULL ) -// { -// fprintf(stderr, "Couldn't init SDL screen: %s\n", SDL_GetError()); -// KillVideo(); -// exit(-1); -// } -// -// s_texture = SDL_CreateTexture(s_renderer, -//#ifdef LSB_FIRST -// SDL_PIXELFORMAT_ABGR8888, -//#else -// SDL_PIXELFORMAT_ARGB8888, -//#endif -// SDL_TEXTUREACCESS_STREAMING | SDL_TEXTUREACCESS_TARGET, -// xres, yres ); -// -// if ( s_texture == NULL ) -// { -// fprintf(stderr, "Couldn't init SDL texture: %s\n", SDL_GetError()); -// KillVideo(); -// exit(-1); -// } -// #endif + s_curbpp = 32; // Bits per pixel is always 32 - //s_curbpp = s_screen->format->BitsPerPixel; - s_curbpp = 32; - - //FCEU_printf(" Video Mode: %d x %d x %d bpp %s\n", - // s_screen->w, s_screen->h, s_screen->format->BitsPerPixel, - // s_fullscreen ? "full screen" : ""); FCEU_printf(" Video Mode: %d x %d x %d bpp %s\n", xres, yres, s_curbpp, s_fullscreen ? "full screen" : ""); @@ -352,62 +211,7 @@ int InitVideo(FCEUGI *gi) return -1; } - // create the surface for displaying graphical messages -//#ifdef LSB_FIRST -// s_IconSurface = SDL_CreateRGBSurfaceFrom((void *)fceu_playicon.pixel_data, -// 32, 32, 24, 32 * 3, -// 0xFF, 0xFF00, 0xFF0000, 0x00); -//#else -// s_IconSurface = SDL_CreateRGBSurfaceFrom((void *)fceu_playicon.pixel_data, -// 32, 32, 24, 32 * 3, -// 0xFF0000, 0xFF00, 0xFF, 0x00); -//#endif -// SDL_SetWindowIcon( s_window, s_IconSurface); - - //s_paletterefresh = 1; - - // -Video Modes Tag- - //if (s_sponge) - //{ - // if (s_sponge <= 3 && s_sponge >= 1) - // { - // s_exs = s_eys = 2; - // } - // else if (s_sponge >=4 && s_sponge <= 5) - // { - // s_exs = s_eys = 3; - // } - // else if (s_sponge >= 6 && s_sponge <= 8) - // { - // s_exs = s_eys = s_sponge - 4; - // } - // else if(s_sponge == 9) - // { - // s_exs = s_eys = 3; - // } - // else - // { - // s_exs = s_eys = 1; - // } - // if(s_sponge == 3) { - // xres = 301 * s_exs; - // } - // s_eefx = 0; - // //if(s_sponge == 1 || s_sponge == 4) { - // // desbpp = 32; - // //} - //} - - //int scrw = NWIDTH * s_exs; - //if(s_sponge == 3) { - // scrw = 301 * s_exs; - //} - #ifdef OPENGL - if(!s_useOpenGL) { - s_exs = (int)s_exs; - s_eys = (int)s_eys; - } if(s_exs <= 0.01) { FCEUD_PrintError("xscale out of bounds."); KillVideo(); @@ -438,376 +242,11 @@ int InitVideo(FCEUGI *gi) return 0; } -#else -/** - * Attempts to initialize the graphical video display. Returns 0 on - * success, -1 on failure. - */ -int -InitVideo(FCEUGI *gi) -{ - // XXX soules - const? is this necessary? - const SDL_VideoInfo *vinf; - int error, flags = 0; - int doublebuf, xstretch, ystretch, xres, yres, show_fps; - - FCEUI_printf("Initializing video..."); - - // load the relevant configuration variables - g_config->getOption("SDL.Fullscreen", &s_fullscreen); - g_config->getOption("SDL.DoubleBuffering", &doublebuf); -#ifdef OPENGL - g_config->getOption("SDL.OpenGL", &s_useOpenGL); -#endif - g_config->getOption("SDL.SpecialFilter", &s_sponge); - g_config->getOption("SDL.XStretch", &xstretch); - g_config->getOption("SDL.YStretch", &ystretch); - //g_config->getOption("SDL.LastXRes", &xres); - //g_config->getOption("SDL.LastYRes", &yres); - g_config->getOption("SDL.ClipSides", &s_clipSides); - g_config->getOption("SDL.NoFrame", &noframe); - g_config->getOption("SDL.ShowFPS", &show_fps); - - xres = gtk_draw_area_width; - yres = gtk_draw_area_height; - // check the starting, ending, and total scan lines - - FCEUI_GetCurrentVidSystem(&s_srendline, &s_erendline); - s_tlines = s_erendline - s_srendline + 1; - - // check if we should auto-set x/y resolution - - // check for OpenGL and set the global flags -#ifdef OPENGL - if (s_useOpenGL && !s_sponge) { - flags = SDL_OPENGL; - } -#endif - - // initialize the SDL video subsystem if it is not already active - if(!SDL_WasInit(SDL_INIT_VIDEO)) { - error = SDL_InitSubSystem(SDL_INIT_VIDEO); - if(error) { - FCEUD_PrintError(SDL_GetError()); - return -1; - } - } - s_inited = 1; - - // shows the cursor within the display window - SDL_ShowCursor(1); - - // determine if we can allocate the display on the video card - vinf = SDL_GetVideoInfo(); - if(vinf->hw_available) { - flags |= SDL_HWSURFACE; - } - - // get the monitor's current resolution if we do not already have it - if(s_nativeWidth < 0) { - s_nativeWidth = vinf->current_w; - } - if(s_nativeHeight < 0) { - s_nativeHeight = vinf->current_h; - } - - // check to see if we are showing FPS - FCEUI_SetShowFPS(show_fps); - - // check if we are rendering fullscreen - if(s_fullscreen) { - int no_cursor; - g_config->getOption("SDL.NoFullscreenCursor", &no_cursor); - flags |= SDL_FULLSCREEN; - SDL_ShowCursor(!no_cursor); - } - else { - SDL_ShowCursor(1); - } - - if(noframe) { - flags |= SDL_NOFRAME; - } - - // gives the SDL exclusive palette control... ensures the requested colors - flags |= SDL_HWPALETTE; - - // enable double buffering if requested and we have hardware support -#ifdef OPENGL - if(s_useOpenGL) { - FCEU_printf("Initializing with OpenGL (Disable with '--opengl 0').\n"); - if(doublebuf) { - SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); - } - } else -#endif - if(doublebuf && (flags & SDL_HWSURFACE)) { - flags |= SDL_DOUBLEBUF; - } - - if(s_fullscreen) { - int desbpp, autoscale; - g_config->getOption("SDL.BitsPerPixel", &desbpp); - g_config->getOption("SDL.AutoScale", &autoscale); - if (autoscale) - { - double auto_xscale = GetXScale(xres); - double auto_yscale = GetYScale(yres); - double native_ratio = ((double)NWIDTH) / s_tlines; - double screen_ratio = ((double)xres) / yres; - int keep_ratio; - - g_config->getOption("SDL.KeepRatio", &keep_ratio); - - // Try to choose resolution - if (screen_ratio < native_ratio) - { - // The screen is narrower than the original. Maximizing width will not clip - auto_xscale = auto_yscale = GetXScale(xres); - if (keep_ratio) - auto_yscale = GetYScale(yres); - } - else - { - auto_yscale = auto_xscale = GetYScale(yres); - if (keep_ratio) - auto_xscale = GetXScale(xres); - } - s_exs = auto_xscale; - s_eys = auto_yscale; - } - else - { - g_config->getOption("SDL.XScale", &s_exs); - g_config->getOption("SDL.YScale", &s_eys); - } - g_config->getOption("SDL.SpecialFX", &s_eefx); - -#ifdef OPENGL - if(!s_useOpenGL) { - s_exs = (int)s_exs; - s_eys = (int)s_eys; - } else { - desbpp = 0; - } - - - if((s_useOpenGL && !xstretch) || !s_useOpenGL) -#endif - if(xres < (NWIDTH * s_exs) || s_exs <= 0.01) { - FCEUD_PrintError("xscale out of bounds."); - KillVideo(); - return -1; - } - -#ifdef OPENGL - if((s_useOpenGL && !ystretch) || !s_useOpenGL) -#endif - if(yres < int(s_tlines * s_eys) || s_eys <= 0.01) { - FCEUD_PrintError("yscale out of bounds."); - KillVideo(); - return -1; - } - -#ifdef OPENGL - s_screen = SDL_SetVideoMode(s_useOpenGL ? s_nativeWidth : xres, - s_useOpenGL ? s_nativeHeight : yres, - desbpp, flags); -#else - s_screen = SDL_SetVideoMode(xres, yres, desbpp, flags); -#endif - - if(!s_screen) { - FCEUD_PrintError(SDL_GetError()); - return -1; - } - } else { - int desbpp; - g_config->getOption("SDL.BitsPerPixel", &desbpp); - - g_config->getOption("SDL.XScale", &s_exs); - g_config->getOption("SDL.YScale", &s_eys); - g_config->getOption("SDL.SpecialFX", &s_eefx); - - // -Video Modes Tag- - if(s_sponge) { - if(s_sponge <= 3 && s_sponge >= 1) - { - s_exs = s_eys = 2; - } else if (s_sponge >=4 && s_sponge <= 5) - { - s_exs = s_eys = 3; - } else if (s_sponge >= 6 && s_sponge <= 8) - { - s_exs = s_eys = s_sponge - 4; - } - else if(s_sponge == 9) - { - s_exs = s_eys = 3; - } - else - { - s_exs = s_eys = 1; - } - if(s_sponge == 3) { - xres = 301 * s_exs; - } - s_eefx = 0; - if(s_sponge == 1 || s_sponge == 4) { - desbpp = 32; - } - } - - //int scrw = NWIDTH * s_exs; - //if(s_sponge == 3) { - // scrw = 301 * s_exs; - //} - -#ifdef OPENGL - if(!s_useOpenGL) { - s_exs = (int)s_exs; - s_eys = (int)s_eys; - } - if(s_exs <= 0.01) { - FCEUD_PrintError("xscale out of bounds."); - KillVideo(); - return -1; - } - if(s_eys <= 0.01) { - FCEUD_PrintError("yscale out of bounds."); - KillVideo(); - return -1; - } - if(s_sponge && s_useOpenGL) { - FCEUD_PrintError("scalers not compatible with openGL mode."); - KillVideo(); - return -1; - } -#endif - -#if defined(_GTK) && defined(SDL_VIDEO_DRIVER_X11) && defined(GDK_WINDOWING_X11) - if(noGui == 0) - { - while (gtk_events_pending()) - gtk_main_iteration_do(FALSE); - - char SDL_windowhack[128]; - sprintf(SDL_windowhack, "SDL_WINDOWID=%u", (unsigned int)GDK_WINDOW_XID(gtk_widget_get_window(evbox))); - SDL_putenv(SDL_windowhack); - - // init SDL video - if (SDL_WasInit(SDL_INIT_VIDEO)) - SDL_QuitSubSystem(SDL_INIT_VIDEO); - if ( SDL_InitSubSystem(SDL_INIT_VIDEO) < 0 ) - { - fprintf(stderr, "Couldn't init SDL video: %s\n", SDL_GetError()); - gtk_main_quit(); - } - } -#endif - - //s_screen = SDL_SetVideoMode(scrw, (int)(s_tlines * s_eys), - s_screen = SDL_SetVideoMode( xres, yres, - desbpp, flags); - if(!s_screen) { - FCEUD_PrintError(SDL_GetError()); - return -1; - } - - // This code is not needed, gui.cpp handles all window sizing. -//#ifdef _GTK -// if(noGui == 0) -// { -// GtkRequisition req; -// gtk_widget_get_preferred_size(GTK_WIDGET(MainWindow), NULL, &req); -// gtk_window_resize(GTK_WINDOW(MainWindow), req.width, req.height); -// } -//#endif - } - if(!s_screen) { - FCEUD_PrintError(SDL_GetError()); - KillVideo(); - return -1; - } - s_curbpp = s_screen->format->BitsPerPixel; - -#if 0 - // XXX soules - this would be creating a surface on the video - // card, but was commented out for some reason... - s_BlitBuf = SDL_CreateRGBSurface(SDL_HWSURFACE, 256, 240, - s_screen->format->BitsPerPixel, - s_screen->format->Rmask, - s_screen->format->Gmask, - s_screen->format->Bmask, 0); -#endif - - FCEU_printf(" Video Mode: %d x %d x %d bpp %s\n", - s_screen->w, s_screen->h, s_screen->format->BitsPerPixel, - s_fullscreen ? "full screen" : ""); - - if(s_curbpp != 8 && s_curbpp != 16 && s_curbpp != 24 && s_curbpp != 32) { - FCEU_printf(" Sorry, %dbpp modes are not supported by FCE Ultra. Supported bit depths are 8bpp, 16bpp, and 32bpp.\n", s_curbpp); - KillVideo(); - return -1; - } - - // if the game being run has a name, set it as the window name - if(gi) - { - if(gi->name) { - SDL_WM_SetCaption((const char *)gi->name, (const char *)gi->name); - } else { - SDL_WM_SetCaption(FCEU_NAME_AND_VERSION,"FCE Ultra"); - } - } - - // create the surface for displaying graphical messages -#ifdef LSB_FIRST - s_IconSurface = SDL_CreateRGBSurfaceFrom((void *)fceu_playicon.pixel_data, - 32, 32, 24, 32 * 3, - 0xFF, 0xFF00, 0xFF0000, 0x00); -#else - s_IconSurface = SDL_CreateRGBSurfaceFrom((void *)fceu_playicon.pixel_data, - 32, 32, 24, 32 * 3, - 0xFF0000, 0xFF00, 0xFF, 0x00); -#endif - SDL_WM_SetIcon(s_IconSurface,0); - s_paletterefresh = 1; - - // XXX soules - can't SDL do this for us? - // if using more than 8bpp, initialize the conversion routines - if(s_curbpp > 8) { - InitBlitToHigh(s_curbpp >> 3, - s_screen->format->Rmask, - s_screen->format->Gmask, - s_screen->format->Bmask, - s_eefx, s_sponge, 0); -#ifdef OPENGL - if(s_useOpenGL) - { - int openGLip; - g_config->getOption("SDL.OpenGLip", &openGLip); - - if(!InitOpenGL(NOFFSET, 256 - (s_clipSides ? 8 : 0), - s_srendline, s_erendline + 1, - s_exs, s_eys, s_eefx, - openGLip, xstretch, ystretch, s_screen)) - { - FCEUD_PrintError("Error initializing OpenGL."); - KillVideo(); - return -1; - } - } -#endif - } - return 0; -} -#endif /** * Toggles the full-screen display. */ -void ToggleFS() +void ToggleFS(void) { // pause while we we are making the switch bool paused = FCEUI_EmulationPaused(); @@ -913,7 +352,6 @@ BlitScreen(uint8 *XBuf) { //SDL_Surface *TmpScreen; uint8 *dest; - int xo = 0, yo = 0; int w, h, pitch; //if(!s_screen) { @@ -927,31 +365,9 @@ BlitScreen(uint8 *XBuf) s_paletterefresh = 0; } -//#ifdef OPENGL -// // OpenGL is handled separately -// if(s_useOpenGL) { -// BlitOpenGL(XBuf); -// return; -// } -//#endif - // XXX soules - not entirely sure why this is being done yet XBuf += s_srendline * 256; - //if(s_BlitBuf) { - // TmpScreen = s_BlitBuf; - //} else { - // TmpScreen = s_screen; - //} - - // lock the display, if necessary - //if(SDL_MUSTLOCK(TmpScreen)) { - // if(SDL_LockSurface(TmpScreen) < 0) { - // return; - // } - //} - - //dest = (uint8*)TmpScreen->pixels; dest = (uint8*)getGuiPixelBuffer( &w, &h, &pitch ); glx_shm->ncol = NWIDTH; @@ -960,95 +376,11 @@ BlitScreen(uint8 *XBuf) if ( dest == NULL ) return; - //if(s_fullscreen) { // Always do this calculation now. Screen resolution is always provided. -// xo = (int)(((w - NWIDTH * s_exs)) / 2); -// dest += xo * (s_curbpp >> 3); -// if(h > (s_tlines * s_eys)) { -// yo = (int)((h - s_tlines * s_eys) / 2); -// dest += yo * pitch; -// } - //} - - //Blit8ToHigh(XBuf + NOFFSET, dest, NWIDTH, s_tlines, pitch, 1, 1); Blit8ToHigh(XBuf + NOFFSET, dest, NWIDTH, s_tlines, pitch, 1, 1); - // XXX soules - again, I'm surprised SDL can't handle this - // perform the blit, converting bpp if necessary - //if(s_curbpp > 8) { - // if(s_useOpenGL) { - // Blit8ToHigh(XBuf + NOFFSET, dest, NWIDTH, s_tlines, - // pitch, 1, 1); - // } else { - // Blit8ToHigh(XBuf + NOFFSET, dest, NWIDTH, s_tlines, - // pitch, (int)s_exs, (int)s_eys); - // } - //} else { - // if(s_BlitBuf) { - // Blit8To8(XBuf + NOFFSET, dest, NWIDTH, s_tlines, - // pitch, 1, 1, 0, s_sponge); - // } else { - // Blit8To8(XBuf + NOFFSET, dest, NWIDTH, s_tlines, - // pitch, (int)s_exs, (int)s_eys, - // s_eefx, s_sponge); - // } - //} - //print_pixels(); - // guiPixelBufferReDraw(); - // unlock the display, if necessary - //if(SDL_MUSTLOCK(TmpScreen)) { - // SDL_UnlockSurface(TmpScreen); - //} - - //int scrw; - //if(s_sponge == 3) { // NTSC 2x - // scrw = 301; - //} else { - // scrw = NWIDTH; - //} - - // if we have a hardware video buffer, do a fast video->video copy - //if(s_BlitBuf) { - // SDL_Rect srect; - // SDL_Rect drect; - - // srect.x = 0; - // srect.y = 0; - // srect.w = scrw; - // srect.h = s_tlines; - - // drect.x = 0; - // drect.y = 0; - // drect.w = (Uint16)(s_exs * scrw); - // drect.h = (Uint16)(s_eys * s_tlines); - - // SDL_BlitSurface(s_BlitBuf, &srect, s_screen, &drect); - //} - - // ensure that the display is updated -#if SDL_VERSION_ATLEAST(2, 0, 0) - //SDL_UpdateTexture(s_texture, NULL, s_screen->pixels, s_screen->pitch); - //SDL_RenderClear(s_renderer); - //SDL_RenderCopy(s_renderer, s_texture, NULL, NULL); - //SDL_RenderPresent(s_renderer); -#else - //SDL_UpdateRect(s_screen, xo, yo, - // (Uint32)(scrw * s_exs), (Uint32)(s_tlines * s_eys)); -#endif - #ifdef CREATE_AVI -#if 0 /* PAL INTO NTSC HACK */ - { int fps = FCEUI_GetDesiredFPS(); - if(FCEUI_GetDesiredFPS() == 838977920) fps = 1008307711; - NESVideoLoggingVideo(s_screen->pixels, width,height, fps, s_curbpp); - if(FCEUI_GetDesiredFPS() == 838977920) - { - static unsigned dup=0; - if(++dup==5) { dup=0; - NESVideoLoggingVideo(s_screen->pixels, width,height, fps, s_curbpp); } - } } -#else { int fps = FCEUI_GetDesiredFPS(); static unsigned char* result = NULL; static unsigned resultsize = 0; @@ -1081,7 +413,7 @@ BlitScreen(uint8 *XBuf) NESVideoLoggingVideo( dest, width,height, fps, s_curbpp); } } -#endif +#endif // CREATE_AVI #if REALTIME_LOGGING { @@ -1108,17 +440,8 @@ BlitScreen(uint8 *XBuf) } memcpy(&last_time, &cur_time, sizeof(last_time)); } -#endif -#endif +#endif // REALTIME_LOGGING -//#if SDL_VERSION_ATLEAST(2, 0, 0) -// // TODO -//#else -// // have to flip the displayed buffer in the case of double buffering -// if(s_screen->flags & SDL_DOUBLEBUF) { -// SDL_Flip(s_screen); -// } -//#endif } /** From 0a61bab99e42732cff12f728996a2892f7661df4 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Fri, 12 Jun 2020 19:14:26 -0400 Subject: [PATCH 145/156] More SDL1 cleanup. --- src/drivers/sdl/SConscript | 2 - src/drivers/sdl/sdl-opengl.cpp | 279 --------------------------------- src/drivers/sdl/sdl-opengl.h | 13 -- src/drivers/sdl/sdl-sound.cpp | 32 ++-- src/drivers/sdl/sdl-video.cpp | 25 +-- 5 files changed, 23 insertions(+), 328 deletions(-) delete mode 100644 src/drivers/sdl/sdl-opengl.cpp delete mode 100644 src/drivers/sdl/sdl-opengl.h diff --git a/src/drivers/sdl/SConscript b/src/drivers/sdl/SConscript index b16ffbe7..22fbb644 100644 --- a/src/drivers/sdl/SConscript +++ b/src/drivers/sdl/SConscript @@ -23,8 +23,6 @@ source_list = Split( """) Import('env') -if 'GL' in env['LIBS']: - source_list.append('sdl-opengl.cpp') if env['GTK'] or env['GTK3']: source_list.append('gui.cpp') diff --git a/src/drivers/sdl/sdl-opengl.cpp b/src/drivers/sdl/sdl-opengl.cpp deleted file mode 100644 index 24456a5f..00000000 --- a/src/drivers/sdl/sdl-opengl.cpp +++ /dev/null @@ -1,279 +0,0 @@ -#define GL_GLEXT_LEGACY - -#include "sdl.h" -#include "sdl-opengl.h" -#include "../common/vidblit.h" -#include "../../utils/memory.h" - -#ifdef APPLEOPENGL -#include -#include -#include -#else -#include -#include -#include -#endif -#include -#include - -#ifndef APIENTRY -#define APIENTRY -#endif - -#if SDL_VERSION_ATLEAST(2, 0, 0) -static SDL_Window *s_window = NULL; -#endif -static GLuint textures[2]={0,0}; // Normal image, scanline overlay. - -static int left,right,top,bottom; // right and bottom are not inclusive. -static int scanlines; -static void *HiBuffer; - -typedef void APIENTRY (*glColorTableEXT_Func)(GLenum target, - GLenum internalformat, GLsizei width, GLenum format, GLenum type, - const GLvoid *table); -glColorTableEXT_Func p_glColorTableEXT; - -void -SetOpenGLPalette(uint8 *data) -{ - if(!HiBuffer) { - glBindTexture(GL_TEXTURE_2D, textures[0]); - p_glColorTableEXT(GL_TEXTURE_2D, GL_RGB, 256, - GL_RGBA, GL_UNSIGNED_BYTE, data); - } else { - SetPaletteBlitToHigh((uint8*)data); - } -} - -void -BlitOpenGL(uint8 *buf) -{ - glClear(GL_COLOR_BUFFER_BIT); - glBindTexture(GL_TEXTURE_2D, textures[0]); - - if(HiBuffer) { - Blit8ToHigh(buf, (uint8*)HiBuffer, 256, 240, 256*4, 1, 1); - - glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 256, 256, 0, - GL_RGBA, GL_UNSIGNED_BYTE, HiBuffer); - } - else { - //glPixelStorei(GL_UNPACK_ROW_LENGTH, 256); - glTexImage2D(GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, 256, 256, 0, - GL_COLOR_INDEX,GL_UNSIGNED_BYTE,buf); - } - - glBegin(GL_QUADS); - glTexCoord2f(1.0f*left/256, 1.0f*bottom/256); // Bottom left of picture. - glVertex2f(-1.0f, -1.0f); // Bottom left of target. - - glTexCoord2f(1.0f*right/256, 1.0f*bottom/256);// Bottom right of picture. - glVertex2f( 1.0f, -1.0f); // Bottom right of target. - - glTexCoord2f(1.0f*right/256, 1.0f*top/256); // Top right of our picture. - glVertex2f( 1.0f, 1.0f); // Top right of target. - - glTexCoord2f(1.0f*left/256, 1.0f*top/256); // Top left of our picture. - glVertex2f(-1.0f, 1.0f); // Top left of target. - glEnd(); - - //glDisable(GL_BLEND); - if(scanlines) { - glEnable(GL_BLEND); - - glBindTexture(GL_TEXTURE_2D, textures[1]); - glBlendFunc(GL_DST_COLOR, GL_SRC_ALPHA); - - glBegin(GL_QUADS); - - glTexCoord2f(1.0f*left/256, - 1.0f*bottom/256); // Bottom left of our picture. - glVertex2f(-1.0f, -1.0f); // Bottom left of target. - - glTexCoord2f(1.0f*right/256, - 1.0f*bottom/256); // Bottom right of our picture. - glVertex2f( 1.0f, -1.0f); // Bottom right of target. - - glTexCoord2f(1.0f*right/256, - 1.0f*top/256); // Top right of our picture. - glVertex2f( 1.0f, 1.0f); // Top right of target. - - glTexCoord2f(1.0f*left/256, - 1.0f*top/256); // Top left of our picture. - glVertex2f(-1.0f, 1.0f); // Top left of target. - - glEnd(); - glDisable(GL_BLEND); - } - #if SDL_VERSION_ATLEAST(2, 0, 0) - SDL_GL_SwapWindow(s_window); - #else - SDL_GL_SwapBuffers(); - #endif -} - -void -KillOpenGL(void) -{ - if(textures[0]) { - glDeleteTextures(2, &textures[0]); - } - textures[0]=0; - if(HiBuffer) { - free(HiBuffer); - HiBuffer=0; - } -} -/* Rectangle, left, right(not inclusive), top, bottom(not inclusive). */ - -int -InitOpenGL(int l, - int r, - int t, - int b, - double xscale, - double yscale, - int efx, - int ipolate, - int stretchx, - int stretchy, -#if SDL_VERSION_ATLEAST(2, 0, 0) - SDL_Window *window, -#endif - SDL_Surface *screen) -{ - const char *extensions; - -#define LFG(x) if(!(##x = (x##_Func) SDL_GL_GetProcAddress(#x))) return(0); - -#define LFGN(x) p_##x = (x##_Func) SDL_GL_GetProcAddress(#x) - -// LFG(glBindTexture); - LFGN(glColorTableEXT); -// LFG(glTexImage2D); -// LFG(glBegin); -// LFG(glVertex2f); -// LFG(glTexCoord2f); -// LFG(glEnd); -// LFG(glEnable); -// LFG(glBlendFunc); -// LFG(glGetString); -// LFG(glViewport); -// LFG(glGenTextures); -// LFG(glDeleteTextures); -// LFG(glTexParameteri); -// LFG(glClearColor); -// LFG(glLoadIdentity); -// LFG(glClear); -// LFG(glMatrixMode); -// LFG(glDisable); - - left=l; - right=r; - top=t; - bottom=b; - - HiBuffer=0; - -#if SDL_VERSION_ATLEAST(2, 0, 0) - s_window = window; -#endif - extensions=(const char*)glGetString(GL_EXTENSIONS); - - if((efx&2) || !extensions || !p_glColorTableEXT || !strstr(extensions,"GL_EXT_paletted_texture")) - { - if(!(efx&2)) // Don't want to print out a warning message in this case... - FCEU_printf("Paletted texture extension not found. Using slower texture format...\n"); - HiBuffer=FCEU_malloc(4*256*256); - memset(HiBuffer,0x00,4*256*256); - #ifndef LSB_FIRST - InitBlitToHigh(4,0xFF000000,0xFF0000,0xFF00,efx&2,0,0); - #else - InitBlitToHigh(4,0xFF,0xFF00,0xFF0000,efx&2,0,0); - #endif - } - -#if SDL_VERSION_ATLEAST(2, 0, 0) - // FIXME -#else - if(screen->flags & SDL_FULLSCREEN) - { - xscale=(double)screen->w / (double)(r-l); - yscale=(double)screen->h / (double)(b-t); - if(xscalew-rw)/2; // Start x - int sy=(screen->h-rh)/2; // Start y - - if(stretchx) { sx=0; rw=screen->w; } - if(stretchy) { sy=0; rh=screen->h; } - glViewport(sx, sy, rw, rh); - } - glGenTextures(2, &textures[0]); - scanlines=0; - - if(efx&1) - { - uint8 *buf; - int x,y; - - scanlines=1; - - glBindTexture(GL_TEXTURE_2D, textures[1]); - glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,ipolate?GL_LINEAR:GL_NEAREST); - glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,ipolate?GL_LINEAR:GL_NEAREST); - - buf=(uint8*)FCEU_dmalloc(256*(256*2)*4); - - for(y=0;y<(256*2);y++) - for(x=0;x<256;x++) - { - buf[y*256*4+x*4]=0; - buf[y*256*4+x*4+1]=0; - buf[y*256*4+x*4+2]=0; - buf[y*256*4+x*4+3]=(y&1)?0x00:0xFF; //?0xa0:0xFF; // <-- Pretty - //buf[y*256+x]=(y&1)?0x00:0xFF; - } - glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 256, (scanlines==2)?256*4:512, 0, - GL_RGBA,GL_UNSIGNED_BYTE,buf); - FCEU_dfree(buf); - } - glBindTexture(GL_TEXTURE_2D, textures[0]); - - glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,ipolate?GL_LINEAR:GL_NEAREST); - glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,ipolate?GL_LINEAR:GL_NEAREST); - glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP); - glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP); - glEnable(GL_TEXTURE_2D); - glDisable(GL_DEPTH_TEST); - glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // Background color to black. - glMatrixMode(GL_MODELVIEW); - glLoadIdentity(); - - // In a double buffered setup with page flipping, be sure to clear both buffers. - glClear(GL_COLOR_BUFFER_BIT); - - #if SDL_VERSION_ATLEAST(2, 0, 0) - SDL_GL_SwapWindow(s_window); - #else - SDL_GL_SwapBuffers(); - #endif - - glClear(GL_COLOR_BUFFER_BIT); - - #if SDL_VERSION_ATLEAST(2, 0, 0) - SDL_GL_SwapWindow(s_window); - #else - SDL_GL_SwapBuffers(); - #endif - - return 1; -} diff --git a/src/drivers/sdl/sdl-opengl.h b/src/drivers/sdl/sdl-opengl.h deleted file mode 100644 index 4fe18d4f..00000000 --- a/src/drivers/sdl/sdl-opengl.h +++ /dev/null @@ -1,13 +0,0 @@ -void SetOpenGLPalette(uint8 *data); -void BlitOpenGL(uint8 *buf); -void KillOpenGL(void); - -int InitOpenGL(int l, int r, int t, int b, - double xscale, double yscale, - int efx, int ipolate, - int stretchx, int stretchy, -#if SDL_VERSION_ATLEAST(2, 0, 0) - SDL_Window *window, -#endif - SDL_Surface *screen); - diff --git a/src/drivers/sdl/sdl-sound.cpp b/src/drivers/sdl/sdl-sound.cpp index 36830ca3..00b7c9a6 100644 --- a/src/drivers/sdl/sdl-sound.cpp +++ b/src/drivers/sdl/sdl-sound.cpp @@ -75,25 +75,21 @@ InitSound() { int sound, soundrate, soundbufsize, soundvolume, soundtrianglevolume, soundsquare1volume, soundsquare2volume, soundnoisevolume, soundpcmvolume, soundq; SDL_AudioSpec spec; + const char *driverName; g_config->getOption("SDL.Sound", &sound); - if(!sound) { + if (!sound) + { return 0; } memset(&spec, 0, sizeof(spec)); - if(SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) { + if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) + { puts(SDL_GetError()); KillSound(); return 0; } - char driverName[8]; -#if SDL_VERSION_ATLEAST(2, 0, 0) - // TODO - SDL 2 -#else - SDL_AudioDriverName(driverName, 8); - fprintf(stderr, "Loading SDL sound with %s driver...\n", driverName); -#endif // load configuration variables g_config->getOption("SDL.Sound.Rate", &soundrate); @@ -117,21 +113,33 @@ InitSound() // For safety, set a bare minimum: if (s_BufferSize < spec.samples * 2) - s_BufferSize = spec.samples * 2; + { + s_BufferSize = spec.samples * 2; + } s_Buffer = (int *)FCEU_dmalloc(sizeof(int) * s_BufferSize); + if (!s_Buffer) + { return 0; + } s_BufferRead = s_BufferWrite = s_BufferIn = 0; - if(SDL_OpenAudio(&spec, 0) < 0) + if (SDL_OpenAudio(&spec, 0) < 0) { puts(SDL_GetError()); KillSound(); return 0; - } + } SDL_PauseAudio(0); + driverName = SDL_GetCurrentAudioDriver(); + + if ( driverName ) + { + fprintf(stderr, "Loading SDL sound with %s driver...\n", driverName); + } + FCEUI_SetSoundVolume(soundvolume); FCEUI_SetSoundQuality(soundq); FCEUI_Sound(soundrate); diff --git a/src/drivers/sdl/sdl-video.cpp b/src/drivers/sdl/sdl-video.cpp index c6361311..39ca7cb8 100644 --- a/src/drivers/sdl/sdl-video.cpp +++ b/src/drivers/sdl/sdl-video.cpp @@ -22,7 +22,6 @@ /// \brief Handles the graphical game display for the SDL implementation. #include "sdl.h" -#include "sdl-opengl.h" #include "glxwin.h" #include "../common/vidblit.h" #include "../../fceu.h" @@ -318,23 +317,10 @@ FCEUD_GetPalette(uint8 index, */ static void RedoPalette() { -//#ifdef OPENGL -// if(s_useOpenGL) -// SetOpenGLPalette((uint8*)s_psdl); -// else -//#endif + if (s_curbpp > 8) { - if(s_curbpp > 8) { - SetPaletteBlitToHigh((uint8*)s_psdl); - } else - { -#if SDL_VERSION_ATLEAST(2, 0, 0) - //TODO - SDL2 -#else - SDL_SetPalette(s_screen, SDL_PHYSPAL, s_psdl, 0, 256); -#endif - } - } + SetPaletteBlitToHigh((uint8*)s_psdl); + } } // XXX soules - console lock/unlock unimplemented? @@ -350,14 +336,9 @@ void UnlockConsole(){} void BlitScreen(uint8 *XBuf) { - //SDL_Surface *TmpScreen; uint8 *dest; int w, h, pitch; - //if(!s_screen) { - // return; - //} - // refresh the palette if required if (s_paletterefresh) { From 47ad3b1dee93ec45b3ead47d4f09ece2e805a1ae Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Fri, 12 Jun 2020 19:40:46 -0400 Subject: [PATCH 146/156] More SDL1 cleanup. --- src/drivers/sdl/input.cpp | 24 +++++++++++++++------ src/drivers/sdl/keyscan.h | 4 ---- src/drivers/sdl/sdl.cpp | 45 +++------------------------------------ 3 files changed, 20 insertions(+), 53 deletions(-) diff --git a/src/drivers/sdl/input.cpp b/src/drivers/sdl/input.cpp index 30626c8d..666725c7 100644 --- a/src/drivers/sdl/input.cpp +++ b/src/drivers/sdl/input.cpp @@ -155,22 +155,32 @@ int getKeyState( int k ) static int _keyonly (int a) { - // check for valid key - if (a > SDLK_LAST + 1 || a < 0) + int sc; + + if ( a < 0 ) { return 0; } - if (g_keyState[SDL_GetScancodeFromKey (a)]) + sc = SDL_GetScancodeFromKey(a); + + // check for valid key + if (sc >= SDL_NUM_SCANCODES || sc < 0) { - if (!keyonce[a]) + return 0; + } + + if (g_keyState[sc]) + { + if (!keyonce[sc]) { - keyonce[a] = 1; + keyonce[sc] = 1; return 1; } } - else { - keyonce[a] = 0; + else + { + keyonce[sc] = 0; } return 0; } diff --git a/src/drivers/sdl/keyscan.h b/src/drivers/sdl/keyscan.h index 0a73804b..b3973c20 100644 --- a/src/drivers/sdl/keyscan.h +++ b/src/drivers/sdl/keyscan.h @@ -42,7 +42,3 @@ #define SDLK_SCROLLLOCK SDLK_SCROLLOCK /* I guess the SDL people don't like lots of Ls... */ #define SDLK_GRAVE SDLK_BACKQUOTE #define MKK(k) SDLK_##k -#if SDL_VERSION_ATLEAST(2, 0, 0) -#define SDLK_LAST SDL_NUM_SCANCODES -#endif -#define MKK_COUNT (SDLK_LAST+1) diff --git a/src/drivers/sdl/sdl.cpp b/src/drivers/sdl/sdl.cpp index 137a1deb..6859af71 100644 --- a/src/drivers/sdl/sdl.cpp +++ b/src/drivers/sdl/sdl.cpp @@ -172,13 +172,9 @@ static void ShowUsage(char *prog) #endif puts(""); printf("Compiled with SDL version %d.%d.%d\n", SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL ); -#if SDL_VERSION_ATLEAST(2, 0, 0) - SDL_version* v; - SDL_GetVersion(v); -#else - const SDL_version* v = SDL_Linked_Version(); -#endif - printf("Linked with SDL version %d.%d.%d\n", v->major, v->minor, v->patch); + SDL_version v; + SDL_GetVersion(&v); + printf("Linked with SDL version %d.%d.%d\n", v.major, v.minor, v.patch); #ifdef GTK printf("Compiled with GTK version %d.%d.%d\n", GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION ); //printf("Linked with GTK version %d.%d.%d\n", GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION ); @@ -680,41 +676,6 @@ int main(int argc, char *argv[]) int yres, xres; g_config->getOption("SDL.XResolution", &xres); g_config->getOption("SDL.YResolution", &yres); -#if SDL_VERSION_ATLEAST(2, 0, 0) - // TODO _ SDL 2.0 -#else - const SDL_VideoInfo* vid_info = SDL_GetVideoInfo(); - if(xres == 0) - { - if(vid_info != NULL) - { - g_config->setOption("SDL.LastXRes", vid_info->current_w); - } - else - { - g_config->setOption("SDL.LastXRes", 512); - } - } - else - { - g_config->setOption("SDL.LastXRes", xres); - } - if(yres == 0) - { - if(vid_info != NULL) - { - g_config->setOption("SDL.LastYRes", vid_info->current_h); - } - else - { - g_config->setOption("SDL.LastYRes", 448); - } - } - else - { - g_config->setOption("SDL.LastYRes", yres); - } -#endif int autoResume; g_config->getOption("SDL.AutoResume", &autoResume); From d340c1465ee178fa95af76d4e48fdc86d3798743 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Fri, 12 Jun 2020 19:48:51 -0400 Subject: [PATCH 147/156] Removed the last of the SDL1 specific functions. --- src/drivers/sdl/gui.cpp | 205 +++++++++++++++------------------------- 1 file changed, 78 insertions(+), 127 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index ccf53e0d..c4abaa09 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -553,11 +553,7 @@ static void hotKeyWindowRefresh (void) g_config->getOption (optionName.c_str (), &keycode); gtk_tree_store_set (hotkey_store, &iter, 0, optionName.c_str (), 1, -#if SDL_VERSION_ATLEAST(2, 0, 0) SDL_GetKeyName (keycode), -#else - SDL_GetKeyName ((SDLKey) keycode), -#endif -1); gtk_tree_store_append (hotkey_store, &iter, NULL); // acquire child iterator } @@ -602,11 +598,8 @@ static gint hotKeyPressCB (GtkTreeView * tree, GdkEventKey * event, hotKeyName.append ( getHotkeyString(indexArray[0]) ); // Convert this keypress from GDK to SDL. -#if SDL_VERSION_ATLEAST(2, 0, 0) sdlkey = GDKToSDLKeyval (event->keyval); -#else - sdlkey = (SDLKey) GDKToSDLKeyval (event->keyval); -#endif + printf ("HotKey Index: %i '%s' %i %i \n", indexArray[0], hotKeyName.c_str (), event->keyval, sdlkey); @@ -706,16 +699,9 @@ void updateGamepadConfig (GtkWidget * w, gpointer p) if (GamePadConfig[padNo][i].ButtType[configNo] == BUTTC_KEYBOARD) { -#if SDL_VERSION_ATLEAST(2, 0, 0) snprintf (strBuf, sizeof (strBuf), "%s", SDL_GetKeyName (GamePadConfig[padNo][i]. ButtonNum[configNo])); -#else - snprintf (strBuf, sizeof (strBuf), "%s", - SDL_GetKeyName ((SDLKey) - GamePadConfig[padNo][i]. - ButtonNum[configNo])); -#endif } else sprintf (strBuf, "%s", ButtonName( &GamePadConfig[padNo][i], configNo ) ); @@ -2208,28 +2194,15 @@ static void changeState (GtkRadioMenuItem * radiomenuitem, gpointer user_data) FCEUI_SelectState ((long) user_data, 1); } -#if SDL_VERSION_ATLEAST(2, 0, 0) // SDL 1.2/2.0 compatibility macros #define SDLK_SCROLLOCK SDLK_SCROLLLOCK #define SDLK_PRINT SDLK_PRINTSCREEN #define SDLK_BREAK 0 #define SDLK_COMPOSE 0 #define SDLK_NUMLOCK SDLK_NUMLOCKCLEAR -#define SDLK_KP0 SDLK_KP_0 -#define SDLK_KP1 SDLK_KP_1 -#define SDLK_KP2 SDLK_KP_2 -#define SDLK_KP3 SDLK_KP_3 -#define SDLK_KP4 SDLK_KP_4 -#define SDLK_KP5 SDLK_KP_5 -#define SDLK_KP6 SDLK_KP_6 -#define SDLK_KP7 SDLK_KP_7 -#define SDLK_KP8 SDLK_KP_8 -#define SDLK_KP9 SDLK_KP_9 -#define SDLK_LSUPER SDLK_LGUI -#define SDLK_RSUPER SDLK_RGUI #define SDLK_LMETA 0 #define SDLK_RMETA 0 -#endif + // Adapted from Gens/GS. Converts a GDK key value into an SDL key value. unsigned int GDKToSDLKeyval (int gdk_key) { @@ -2308,16 +2281,16 @@ unsigned int GDKToSDLKeyval (int gdk_key) 0x0000, 0x0000, SDLK_MODE, SDLK_NUMLOCK, // 0x80 - 0x8F [mostly unused, except for some numeric keypad keys] - SDLK_KP5, 0x0000, 0x0000, 0x0000, + SDLK_KP_5, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, SDLK_KP_ENTER, 0x0000, 0x0000, // 0x90 - 0x9F 0x0000, 0x0000, 0x0000, 0x0000, - 0x0000, SDLK_KP7, SDLK_KP4, SDLK_KP8, - SDLK_KP6, SDLK_KP2, SDLK_KP9, SDLK_KP3, - SDLK_KP1, SDLK_KP5, SDLK_KP0, SDLK_KP_PERIOD, + 0x0000, SDLK_KP_7, SDLK_KP_4, SDLK_KP_8, + SDLK_KP_6, SDLK_KP_2, SDLK_KP_9, SDLK_KP_3, + SDLK_KP_1, SDLK_KP_5, SDLK_KP_0, SDLK_KP_PERIOD, // 0xA0 - 0xAF 0x0000, 0x0000, 0x0000, 0x0000, @@ -2326,9 +2299,9 @@ unsigned int GDKToSDLKeyval (int gdk_key) 0x0000, SDLK_KP_MINUS, SDLK_KP_PERIOD, SDLK_KP_DIVIDE, // 0xB0 - 0xBF - SDLK_KP0, SDLK_KP1, SDLK_KP2, SDLK_KP3, - SDLK_KP4, SDLK_KP5, SDLK_KP6, SDLK_KP7, - SDLK_KP8, SDLK_KP9, 0x0000, 0x0000, + SDLK_KP_0, SDLK_KP_1, SDLK_KP_2, SDLK_KP_3, + SDLK_KP_4, SDLK_KP_5, SDLK_KP_6, SDLK_KP_7, + SDLK_KP_8, SDLK_KP_9, 0x0000, 0x0000, 0x0000, SDLK_KP_EQUALS, SDLK_F1, SDLK_F2, // 0xC0 - 0xCF @@ -2346,8 +2319,8 @@ unsigned int GDKToSDLKeyval (int gdk_key) // 0xE0 - 0xEF 0x0000, SDLK_LSHIFT, SDLK_RSHIFT, SDLK_LCTRL, SDLK_RCTRL, SDLK_CAPSLOCK, 0x0000, SDLK_LMETA, - SDLK_RMETA, SDLK_LALT, SDLK_RALT, SDLK_LSUPER, - SDLK_RSUPER, 0x0000, 0x0000, 0x0000, + SDLK_RMETA, SDLK_LALT, SDLK_RALT, SDLK_LGUI, + SDLK_RGUI, 0x0000, 0x0000, 0x0000, // 0xF0 - 0xFF [mostly unused, except for Delete] 0x0000, 0x0000, 0x0000, 0x0000, @@ -2381,24 +2354,18 @@ static gboolean convertKeypress (GtkWidget * grab, GdkEventKey * event, gpointer user_data) { SDL_Event sdlev; - int keystate; -#if SDL_VERSION_ATLEAST(2, 0, 0) SDL_Keycode sdlkey; -#else - SDLKey sdlkey; -#endif + switch (event->type) { case GDK_KEY_PRESS: sdlev.type = SDL_KEYDOWN; sdlev.key.state = SDL_PRESSED; - keystate = 1; break; case GDK_KEY_RELEASE: sdlev.type = SDL_KEYUP; sdlev.key.state = SDL_RELEASED; - keystate = 0; break; default: @@ -2408,11 +2375,7 @@ static gboolean convertKeypress (GtkWidget * grab, GdkEventKey * event, } // Convert this keypress from GDK to SDL. -#if SDL_VERSION_ATLEAST(2, 0, 0) sdlkey = GDKToSDLKeyval (event->keyval); -#else - sdlkey = (SDLKey) GDKToSDLKeyval (event->keyval); -#endif // Create an SDL event from the keypress. sdlev.key.keysym.scancode = SDL_GetScancodeFromKey(sdlkey); @@ -2448,19 +2411,6 @@ static gboolean convertKeypress (GtkWidget * grab, GdkEventKey * event, if (sdlkey != 0) { SDL_PushEvent (&sdlev); - - // Only let the emulator handle the key event if this window has the input focus. - //if (keystate == 0 - // || gtk_window_is_active (GTK_WINDOW (MainWindow))) - //{ -#if SDL_VERSION_ATLEAST(2, 0, 0) - // Not sure how to do this yet with SDL 2.0 - // TODO - SDL 2.0 - //SDL_GetKeyboardState(NULL)[SDL_GetScancodeFromKey(sdlkey)] = keystate; -#else - SDL_GetKeyState (NULL)[sdlkey] = keystate; -#endif - //} } // Allow GTK+ to process this key. @@ -3268,52 +3218,52 @@ int guiClearSurface(void) return 0; } -static void loadPixelTestPattern(void) -{ - uint32_t *p; - int i,x,y,width,height,w2,h2; - - width = 256; - height = 256; - p = (uint32_t*)glx_shm->pixbuf; - - w2 = width / 2; - h2 = height / 2; - - //printf("W:%i H:%i W/2:%i H/2:%i\n", width, height, w2, h2 ); - - i=0; - for (y=0; ypixbuf; +// +// w2 = width / 2; +// h2 = height / 2; +// +// //printf("W:%i H:%i W/2:%i H/2:%i\n", width, height, w2, h2 ); +// +// i=0; +// for (y=0; y Date: Fri, 12 Jun 2020 20:34:26 -0400 Subject: [PATCH 148/156] Bugfix for GUI hanging when gamepad config window is closed while waiting a button press. --- src/drivers/sdl/gui.cpp | 58 +++++++++++++++++++++++++++------------ src/drivers/sdl/input.cpp | 14 ++++++++-- src/drivers/sdl/input.h | 2 +- 3 files changed, 54 insertions(+), 20 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index c4abaa09..daa1f08d 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -72,11 +72,12 @@ GtkWidget *MainWindow = NULL; GtkWidget *evbox = NULL; GtkWidget *padNoCombo = NULL; GtkWidget *configNoCombo = NULL; -GtkWidget *buttonMappings[10]; +GtkWidget *buttonMappings[10] = { NULL }; static GtkWidget *Menubar = NULL; static GtkRadioMenuItem *stateSlot[10] = { NULL }; bool gtkIsStarted = false; bool menuTogglingEnabled = false; +static int buttonConfigStatus = 0; static char useCairoDraw = 0; static int drawAreaGL = 0; @@ -145,11 +146,13 @@ int configGamepadButton (GtkButton * button, gpointer p) if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button))) return 0; + buttonConfigStatus = 2; + ButtonConfigBegin (); snprintf (buf, sizeof(buf)-1, "SDL.Input.GamePad.%d.", padNo); prefix = buf; - DWaitButton (NULL, &GamePadConfig[padNo][x], configNo); + DWaitButton (NULL, &GamePadConfig[padNo][x], configNo, &buttonConfigStatus ); g_config->setOption (prefix + GamePadNames[x], GamePadConfig[padNo][x].ButtonNum[configNo]); @@ -171,10 +174,16 @@ int configGamepadButton (GtkButton * button, gpointer p) snprintf (buf, sizeof (buf), "%s", ButtonName (&GamePadConfig[padNo][x], configNo)); - gtk_label_set_markup (GTK_LABEL (buttonMappings[x]), buf); + + if ( buttonMappings[x] != NULL ) + { + gtk_label_set_markup (GTK_LABEL (buttonMappings[x]), buf); + } ButtonConfigEnd (); + buttonConfigStatus = 1; + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE); return 0; @@ -686,6 +695,11 @@ void updateGamepadConfig (GtkWidget * w, gpointer p) { int i; char strBuf[128]; + + if ( (padNoCombo == NULL) || (configNoCombo == NULL) ) + { + return; + } int padNo = atoi (gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT (padNoCombo))) - 1; @@ -696,8 +710,7 @@ void updateGamepadConfig (GtkWidget * w, gpointer p) for (i = 0; i < 10; i++) { GtkWidget *mappedKey = buttonMappings[i]; - if (GamePadConfig[padNo][i].ButtType[configNo] == - BUTTC_KEYBOARD) + if (GamePadConfig[padNo][i].ButtType[configNo] == BUTTC_KEYBOARD) { snprintf (strBuf, sizeof (strBuf), "%s", SDL_GetKeyName (GamePadConfig[padNo][i]. @@ -706,22 +719,31 @@ void updateGamepadConfig (GtkWidget * w, gpointer p) else sprintf (strBuf, "%s", ButtonName( &GamePadConfig[padNo][i], configNo ) ); - gtk_label_set_text (GTK_LABEL (mappedKey), strBuf); - gtk_label_set_use_markup (GTK_LABEL (mappedKey), TRUE); + if ( mappedKey != NULL ) + { + gtk_label_set_text (GTK_LABEL (mappedKey), strBuf); + gtk_label_set_use_markup (GTK_LABEL (mappedKey), TRUE); + } } } +static void closeGamepadConfig (GtkWidget * w, GdkEvent * e, gpointer p) +{ + gtk_widget_destroy (w); + + padNoCombo = NULL; + configNoCombo = NULL; + + for (int i = 0; i < 10; i++) + { + buttonMappings[i] = NULL; + } + buttonConfigStatus = 0; +} + // creates and opens the gamepad config window (requires GTK 2.24) void openGamepadConfig (void) { - // GTK 2.24 required for this dialog - if (checkGTKVersion (2, 24) == false) - { - // TODO: present this in a GTK MessageBox? - printf (" Warning: GTK >= 2.24 required for this dialog.\nTo configure the gamepads, use \"--inputcfg\" from the command line (ie: \"fceux --inputcfg gamepad1\").\n"); - return; - } - GtkWidget *win; GtkWidget *vbox; GtkWidget *hboxPadNo; @@ -861,8 +883,8 @@ void openGamepadConfig (void) gtk_box_pack_start (GTK_BOX (vbox), buttonFrame, TRUE, TRUE, 5); - g_signal_connect (win, "delete-event", G_CALLBACK (closeDialog), NULL); - g_signal_connect (win, "response", G_CALLBACK (closeDialog), NULL); + g_signal_connect (win, "delete-event", G_CALLBACK (closeGamepadConfig), NULL); + g_signal_connect (win, "response", G_CALLBACK (closeGamepadConfig), NULL); gtk_widget_show_all (win); @@ -871,6 +893,8 @@ void openGamepadConfig (void) g_signal_connect (G_OBJECT (win), "key-release-event", G_CALLBACK (convertKeypress), NULL); + buttonConfigStatus = 1; + return; } diff --git a/src/drivers/sdl/input.cpp b/src/drivers/sdl/input.cpp index 666725c7..897508af 100644 --- a/src/drivers/sdl/input.cpp +++ b/src/drivers/sdl/input.cpp @@ -1651,7 +1651,7 @@ const char * ButtonName (const ButtConfig * bc, int which) * Waits for a button input and returns the information as to which * button was pressed. Used in button configuration. */ -int DWaitButton (const uint8 * text, ButtConfig * bc, int wb) +int DWaitButton (const uint8 * text, ButtConfig * bc, int wb, int *buttonConfigStatus ) { SDL_Event event; static int32 LastAx[64][64]; @@ -1742,6 +1742,16 @@ int DWaitButton (const uint8 * text, ButtConfig * bc, int wb) } if (done) break; + + // If the button config window is Closed, + // get out of loop. + if ( buttonConfigStatus != NULL ) + { + if ( *buttonConfigStatus == 0 ) + { + break; + } + } } return (0); @@ -1763,7 +1773,7 @@ ConfigButton (char *text, ButtConfig * bc) for (wc = 0; wc < MAXBUTTCONFIG; wc++) { sprintf ((char *) buf, "%s (%d)", text, wc + 1); - DWaitButton (buf, bc, wc); + DWaitButton (buf, bc, wc, NULL); if (wc && bc->ButtType[wc] == bc->ButtType[wc - 1] && diff --git a/src/drivers/sdl/input.h b/src/drivers/sdl/input.h index 331d2795..2a1a2d85 100644 --- a/src/drivers/sdl/input.h +++ b/src/drivers/sdl/input.h @@ -24,7 +24,7 @@ int getKeyState( int k ); int ButtonConfigBegin(); void ButtonConfigEnd(); void ConfigButton(char *text, ButtConfig *bc); -int DWaitButton(const uint8 *text, ButtConfig *bc, int wb); +int DWaitButton(const uint8 *text, ButtConfig *bc, int wb, int *buttonConfigStatus = NULL); #define BUTTC_KEYBOARD 0x00 #define BUTTC_JOYSTICK 0x01 From 6dd0ef841e56ae2874a55359e5a3d1af53e802c5 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Fri, 12 Jun 2020 20:51:46 -0400 Subject: [PATCH 149/156] Cleaned up unused variable. --- src/drivers/sdl/sdl.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/drivers/sdl/sdl.cpp b/src/drivers/sdl/sdl.cpp index 6859af71..3d10af15 100644 --- a/src/drivers/sdl/sdl.cpp +++ b/src/drivers/sdl/sdl.cpp @@ -819,7 +819,7 @@ int main(int argc, char *argv[]) #ifdef _GTK if(noGui == 0) { - int glxwin_pid = spawn_glxwin(0); + spawn_glxwin(0); // even though it is not spawning a window, still needed for shared memory segment. gtk_init(&argc, &argv); InitGTKSubsystem(argc, argv); while(gtk_events_pending()) From a4309af84782b23a566ec38383a0b35a5185b3f1 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Fri, 12 Jun 2020 21:10:52 -0400 Subject: [PATCH 150/156] Removed SDL1 from pipeline build script. --- pipelines/linux_build.sh | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/pipelines/linux_build.sh b/pipelines/linux_build.sh index 5acd73b1..118422fa 100755 --- a/pipelines/linux_build.sh +++ b/pipelines/linux_build.sh @@ -32,11 +32,12 @@ sudo apt-get --assume-yes install lua5.1-dev pkg-config --cflags --libs lua5.1 # Install libSDL-1.2 and libSDL-2 -echo '****************************************' -echo 'Install Dependency libsdl1.2-dev' -echo '****************************************' -sudo apt-get --assume-yes install libsdl1.2-dev -sdl-config --cflags --libs +# libSDL-1.2 no long needed +#echo '****************************************' +#echo 'Install Dependency libsdl1.2-dev' +#echo '****************************************' +#sudo apt-get --assume-yes install libsdl1.2-dev +#sdl-config --cflags --libs echo '****************************************' echo 'Install Dependency libsdl2-dev' echo '****************************************' From 6de7a681495fd99da2ecff3fe2c2b2d5c18d9a7b Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Fri, 12 Jun 2020 21:34:18 -0400 Subject: [PATCH 151/156] Added a TODO for fixing the menu bar hide function. --- src/drivers/sdl/gui.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index daa1f08d..286e12b5 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -3685,6 +3685,7 @@ int InitGTKSubsystem (int argc, char **argv) g_signal_connect (G_OBJECT (evbox), "button-release-event", G_CALLBACK (handleMouseClick), NULL); + // TODO Menu Bar Toggle Needs Work //g_signal_connect(G_OBJECT(MainWindow), "key-release-event", G_CALLBACK(handleKeyRelease), NULL); // signal handlers From b4b2cca9ec4ad7f70e5a3ba0d28950f6e4af47ac Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 13 Jun 2020 12:51:57 -0400 Subject: [PATCH 152/156] Bug fix for menu visibility toggle. --- src/drivers/sdl/gui.cpp | 27 ++++++-------------- src/drivers/sdl/gui.h | 1 + src/drivers/sdl/input.cpp | 52 +++++++++++++++++++++++++-------------- 3 files changed, 42 insertions(+), 38 deletions(-) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 286e12b5..48bb3b6b 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -2698,7 +2698,7 @@ static GtkWidget *CreateMenubar (GtkWidget * window) gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); //-Options --> Toggle Menubar --------------------- - item = gtk_check_menu_item_new_with_label ("Toggle Menubar (alt)"); + item = gtk_check_menu_item_new_with_label ("Toggle Menubar (Alt+M)"); //gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(item), FALSE); @@ -3039,27 +3039,19 @@ void showGui (bool b) } } -gint handleKeyRelease (GtkWidget * w, GdkEvent * event, gpointer cb_data) +void toggleMenuVis(void) { if (menuTogglingEnabled) { - static bool menuShown = true; - if (((GdkEventKey *) event)->keyval == GDK_KEY_Alt_L - || ((GdkEventKey *) event)->keyval == GDK_KEY_Alt_R) + if ( gtk_widget_get_visible(Menubar) ) { - if (menuShown) - { - gtk_widget_hide (Menubar); - menuShown = false; - } - else - { - gtk_widget_show (Menubar); - menuShown = true; - } + gtk_widget_hide (Menubar); + } + else + { + gtk_widget_show (Menubar); } } - return 0; }; int GtkMouseData[3] = { 0, 0, 0 }; @@ -3685,9 +3677,6 @@ int InitGTKSubsystem (int argc, char **argv) g_signal_connect (G_OBJECT (evbox), "button-release-event", G_CALLBACK (handleMouseClick), NULL); - // TODO Menu Bar Toggle Needs Work - //g_signal_connect(G_OBJECT(MainWindow), "key-release-event", G_CALLBACK(handleKeyRelease), NULL); - // signal handlers g_signal_connect (MainWindow, "delete-event", quit, NULL); g_signal_connect (MainWindow, "destroy-event", quit, NULL); diff --git a/src/drivers/sdl/gui.h b/src/drivers/sdl/gui.h index b3313bb6..e824d4a2 100644 --- a/src/drivers/sdl/gui.h +++ b/src/drivers/sdl/gui.h @@ -33,6 +33,7 @@ extern bool gtkIsStarted; int InitGTKSubsystem(int argc, char** argv); void pushOutputToGTK(const char* str); void showGui(bool b); +void toggleMenuVis(void); bool checkGTKVersion(int major_required, int minor_required); diff --git a/src/drivers/sdl/input.cpp b/src/drivers/sdl/input.cpp index 897508af..3943f35f 100644 --- a/src/drivers/sdl/input.cpp +++ b/src/drivers/sdl/input.cpp @@ -501,31 +501,45 @@ static void KeyboardCommands (void) //{ // ToggleFS (); //} + // + + // Alt-M to toggle Main Menu Visibility + if ( is_alt ) + { + if (keyonly (M)) + { + toggleMenuVis(); + } + } // Toggle Movie auto-backup - if (keyonly (M) && is_shift) + if ( is_shift ) { - autoMovieBackup ^= 1; - FCEUI_DispMessage ("Automatic movie backup %sabled.", 0, - autoMovieBackup ? "en" : "dis"); + if (keyonly (M)) + { + autoMovieBackup ^= 1; + FCEUI_DispMessage ("Automatic movie backup %sabled.", 0, + autoMovieBackup ? "en" : "dis"); + } } - // Start recording an FM2 movie on Alt+R - if (keyonly (R) && is_alt) + if ( is_alt ) { - FCEUD_MovieRecordTo (); - } - - // Save a state from a file - if (keyonly (S) && is_alt) - { - FCEUD_SaveStateAs (); - } - - // Load a state from a file - if (keyonly (L) && is_alt) - { - FCEUD_LoadStateFrom (); + // Start recording an FM2 movie on Alt+R + if (keyonly (R)) + { + FCEUD_MovieRecordTo (); + } + // Save a state from a file + if (keyonly (S)) + { + FCEUD_SaveStateAs (); + } + // Load a state from a file + if (keyonly (L)) + { + FCEUD_LoadStateFrom (); + } } // Famicom disk-system games From a1c0e86026e4e056c221a677216ee06095260f1e Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sat, 13 Jun 2020 20:07:01 -0400 Subject: [PATCH 153/156] Code cleanup, found that rendering of openGL graphics are limiting the max frame speed to 60 hz. Have not solution for it yet. --- src/drivers/sdl/sdl-throttle.cpp | 10 +++++++--- src/drivers/sdl/sdl.cpp | 9 ++++++++- 2 files changed, 15 insertions(+), 4 deletions(-) diff --git a/src/drivers/sdl/sdl-throttle.cpp b/src/drivers/sdl/sdl-throttle.cpp index 6832f954..498d4fe7 100644 --- a/src/drivers/sdl/sdl-throttle.cpp +++ b/src/drivers/sdl/sdl-throttle.cpp @@ -75,9 +75,13 @@ SpeedThrottle() else InFrame = 0; - /*fprintf(stderr, "attempting to sleep %Ld ms, frame complete=%s\n", - time_left, InFrame?"no":"yes");*/ - SDL_Delay(time_left); + //fprintf(stderr, "attempting to sleep %Ld ms, frame complete=%s\n", + // time_left, InFrame?"no":"yes"); + + if ( time_left > 0 ) + { + SDL_Delay(time_left); + } if(!InFrame) { diff --git a/src/drivers/sdl/sdl.cpp b/src/drivers/sdl/sdl.cpp index 3d10af15..fb421832 100644 --- a/src/drivers/sdl/sdl.cpp +++ b/src/drivers/sdl/sdl.cpp @@ -911,11 +911,18 @@ int main(int argc, char *argv[]) while(1) { if(GameInfo) + { DoFun(frameskip, periodic_saves); + } else + { SDL_Delay(1); + } + while(gtk_events_pending()) - gtk_main_iteration_do(FALSE); + { + gtk_main_iteration_do(FALSE); + } } } else From f5e8b09200b3501411db39511295d198d1ac3ae0 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sun, 14 Jun 2020 10:15:47 -0400 Subject: [PATCH 154/156] Bug fix for enable/disabling of glx double buffering. Single buffering allows for faster emulation rates, double buffering is not allowing faster than 60hz due to vsync. --- src/drivers/sdl/glxwin.cpp | 20 ++++++++++++++------ src/drivers/sdl/gui.cpp | 14 +++++++------- src/drivers/sdl/sdl-video.cpp | 2 +- 3 files changed, 22 insertions(+), 14 deletions(-) diff --git a/src/drivers/sdl/glxwin.cpp b/src/drivers/sdl/glxwin.cpp index ab000ee3..547df24f 100644 --- a/src/drivers/sdl/glxwin.cpp +++ b/src/drivers/sdl/glxwin.cpp @@ -32,7 +32,7 @@ static Window win; static GLXContext glc = NULL; static XWindowAttributes gwa; static XEvent xev; -static GLint double_buffer_ena = True; +static GLint double_buffer_ena = 1; static GLuint gltexture = 0; static int spawn_new_window = 0; @@ -91,8 +91,11 @@ static void getAttrbList( GLint *buf ) buf[i] = GLX_RGBA; i++; buf[i] = GLX_DEPTH_SIZE; i++; buf[i] = 24; i++; - buf[i] = GLX_DOUBLEBUFFER ; i++; - buf[i] = double_buffer_ena; i++; + + if ( double_buffer_ena ) + { + buf[i] = GLX_DOUBLEBUFFER ; i++; + } buf[i] = None; } @@ -280,9 +283,14 @@ static void render_image(void) //glVertex2f( 1.0f, 1.0f); // Top right of target. //glEnd(); - glFlush(); - - glXSwapBuffers( dpy, win ); + if ( double_buffer_ena ) + { + glXSwapBuffers( dpy, win ); + } + else + { + glFlush(); + } } //************************************************************************ static int mainWindowLoop(void) diff --git a/src/drivers/sdl/gui.cpp b/src/drivers/sdl/gui.cpp index 48bb3b6b..fe82a062 100644 --- a/src/drivers/sdl/gui.cpp +++ b/src/drivers/sdl/gui.cpp @@ -191,7 +191,7 @@ int configGamepadButton (GtkButton * button, gpointer p) void resetVideo (void) { - resizeGtkWindow (); + //resizeGtkWindow (); KillVideo (); InitVideo (GameInfo); } @@ -3399,7 +3399,7 @@ static void cairo_handle_resize(void) cairo_surface = cairo_image_surface_create( CAIRO_FORMAT_ARGB32, w, h ); //cairo_surface = cairo_image_surface_create( CAIRO_FORMAT_RGB24, w, h ); - printf("Cairo Surface: %p \n", cairo_surface ); + //printf("Cairo Surface: %p \n", cairo_surface ); //cairo_format = cairo_image_surface_get_format( cairo_surface ); @@ -3532,11 +3532,11 @@ gboolean handle_resize (GtkWindow * win, GdkEvent * event, gpointer data) //gtk_widget_realize(evbox); //flushGtkEvents (); - if ( winsize_changed && (GameInfo != 0) ) - { - KillVideo (); - InitVideo (GameInfo); - } + //if ( winsize_changed && (GameInfo != 0) ) + //{ + // KillVideo (); + // InitVideo (GameInfo); + //} gtk_widget_queue_draw( evbox ); diff --git a/src/drivers/sdl/sdl-video.cpp b/src/drivers/sdl/sdl-video.cpp index 39ca7cb8..2b5e44f2 100644 --- a/src/drivers/sdl/sdl-video.cpp +++ b/src/drivers/sdl/sdl-video.cpp @@ -100,7 +100,7 @@ KillVideo() glx_shm->clear_pixbuf(); } - //destroy_gui_video(); + destroy_gui_video(); // return failure if the video system was not initialized if (s_inited == 0) From c5bbd3cec53f0edbf212364f79d21b1b3683c602 Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sun, 14 Jun 2020 19:55:36 -0400 Subject: [PATCH 155/156] Added uninitialized class members to constructor for debug window. --- src/drivers/sdl/debugger.cpp | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/drivers/sdl/debugger.cpp b/src/drivers/sdl/debugger.cpp index 4aeb27ab..c5982e24 100644 --- a/src/drivers/sdl/debugger.cpp +++ b/src/drivers/sdl/debugger.cpp @@ -141,6 +141,12 @@ struct debuggerWin_t textbuf = NULL; bp_store = NULL; bp_tree = NULL; + bkm_store = NULL; + bkm_tree = NULL; + pc_entry = NULL; + A_entry = NULL; + X_entry = NULL; + Y_entry = NULL; stackview = NULL; stackTextBuf = NULL; ppu_label = NULL; From 9748d3916936cca40d902a9b27b03152d7f6d22e Mon Sep 17 00:00:00 2001 From: Matthew Budd Date: Sun, 14 Jun 2020 20:11:59 -0400 Subject: [PATCH 156/156] Resolved dangerous usage of c_str(). The value returned by c_str() is invalid after this call --- src/drivers/sdl/input.cpp | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/src/drivers/sdl/input.cpp b/src/drivers/sdl/input.cpp index 3943f35f..f4246e96 100644 --- a/src/drivers/sdl/input.cpp +++ b/src/drivers/sdl/input.cpp @@ -446,7 +446,6 @@ static void KeyboardCommands (void) { int is_shift, is_alt; - char *movie_fname = ""; // get the keyboard input // check if the family keyboard is enabled @@ -573,10 +572,9 @@ static void KeyboardCommands (void) { if (is_shift) { - movie_fname = - const_cast (FCEU_MakeFName (FCEUMKF_MOVIE, 0, 0).c_str ()); - FCEUI_printf ("Recording movie to %s\n", movie_fname); - FCEUI_SaveMovie (movie_fname, MOVIE_FLAG_NONE, L""); + std::string movie_fname = FCEU_MakeFName (FCEUMKF_MOVIE, 0, 0); + FCEUI_printf ("Recording movie to %s\n", movie_fname.c_str() ); + FCEUI_SaveMovie(movie_fname.c_str() , MOVIE_FLAG_NONE, L""); } else {