From 57c8281242f3a86e63f11211c09c8c23ee356380 Mon Sep 17 00:00:00 2001 From: arcum42 Date: Sat, 7 Feb 2009 06:15:22 +0000 Subject: [PATCH] Linux: Reorganized the files to a somewhat familiar file structure. Adjusted some Linux code to be closer to the Windows version. git-svn-id: http://pcsx2.googlecode.com/svn/trunk@443 96395faa-99c1-11dd-bbfe-3dabce05a288 --- pcsx2/Linux/AboutDlg.cpp | 62 +++ pcsx2/Linux/AdvancedDlg.cpp | 160 ++++++ pcsx2/Linux/ConfigDlg.cpp | 414 ++++++++------- pcsx2/Linux/ConfigDlg.h | 18 +- pcsx2/Linux/CpuDlg.cpp | 113 ++++ pcsx2/Linux/DebugDlg.cpp | 249 +++++---- pcsx2/Linux/DebugDlg.h | 11 +- pcsx2/Linux/GtkGui.cpp | 993 ------------------------------------ pcsx2/Linux/GtkGui.h | 83 --- pcsx2/Linux/HacksDlg.cpp | 104 ++++ pcsx2/Linux/Linux.h | 59 ++- pcsx2/Linux/LnxConsole.cpp | 180 +++---- pcsx2/Linux/LnxMain.cpp | 642 +++++++++++++---------- pcsx2/Linux/LnxMain.h | 93 +++- pcsx2/Linux/LnxSysExec.cpp | 792 ++++++++++++++++++++++++++++ pcsx2/Linux/Makefile.am | 5 +- pcsx2/Linux/Pref.cpp | 43 +- 17 files changed, 2229 insertions(+), 1792 deletions(-) create mode 100644 pcsx2/Linux/AboutDlg.cpp create mode 100644 pcsx2/Linux/AdvancedDlg.cpp create mode 100644 pcsx2/Linux/CpuDlg.cpp delete mode 100644 pcsx2/Linux/GtkGui.cpp delete mode 100644 pcsx2/Linux/GtkGui.h create mode 100644 pcsx2/Linux/HacksDlg.cpp create mode 100644 pcsx2/Linux/LnxSysExec.cpp diff --git a/pcsx2/Linux/AboutDlg.cpp b/pcsx2/Linux/AboutDlg.cpp new file mode 100644 index 0000000000..cf70a18f37 --- /dev/null +++ b/pcsx2/Linux/AboutDlg.cpp @@ -0,0 +1,62 @@ +/* Pcsx2 - Pc Ps2 Emulator + * Copyright (C) 2002-2008 Pcsx2 Team + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + + #include "Linux.h" + +GtkWidget *AboutDlg, *about_version , *about_authors, *about_greets; + + void OnHelp_Help() +{ +} + +void OnHelpAbout_Ok(GtkButton *button, gpointer user_data) +{ + gtk_widget_destroy(AboutDlg); + gtk_widget_set_sensitive(MainWindow, TRUE); + gtk_main_quit(); +} + +void OnHelp_About(GtkMenuItem *menuitem, gpointer user_data) +{ + char str[g_MaxPath]; + GtkWidget *Label; + + AboutDlg = create_AboutDlg(); + gtk_window_set_title(GTK_WINDOW(AboutDlg), _("About")); + + Label = lookup_widget(AboutDlg, "GtkAbout_LabelVersion"); + + // Include the SVN revision + if (SVN_REV != 0) + sprintf(str, _("PCSX2 For Linux\nVersion %s %s\n"), PCSX2_VERSION, SVN_REV); + else + //Use this instead for a non-svn version + sprintf(str, _("PCSX2 For Linux\nVersion %s\n"), PCSX2_VERSION); + + gtk_label_set_text(GTK_LABEL(Label), str); + + Label = lookup_widget(AboutDlg, "GtkAbout_LabelAuthors"); + gtk_label_set_text(GTK_LABEL(Label), _(LabelAuthors)); + + Label = lookup_widget(AboutDlg, "GtkAbout_LabelGreets"); + gtk_label_set_text(GTK_LABEL(Label), _(LabelGreets)); + + gtk_widget_show_all(AboutDlg); + gtk_widget_set_sensitive(MainWindow, FALSE); + gtk_main(); +} \ No newline at end of file diff --git a/pcsx2/Linux/AdvancedDlg.cpp b/pcsx2/Linux/AdvancedDlg.cpp new file mode 100644 index 0000000000..157913ea59 --- /dev/null +++ b/pcsx2/Linux/AdvancedDlg.cpp @@ -0,0 +1,160 @@ +/* Pcsx2 - Pc Ps2 Emulator + * Copyright (C) 2002-2008 Pcsx2 Team + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + + #include "Linux.h" + +GtkWidget *AdvDlg; + +void setAdvancedOptions() +{ + if (!cpucaps.hasStreamingSIMD2Extensions) + { + // SSE1 cpus do not support Denormals Are Zero flag. + + Config.sseMXCSR &= ~FLAG_DENORMAL_ZERO; + Config.sseVUMXCSR &= ~FLAG_DENORMAL_ZERO; + } + + switch ((Config.sseMXCSR & 0x6000) >> 13) + { + case 0: + set_checked(AdvDlg, "radio_EE_Round_Near", TRUE); + break; + case 1: + set_checked(AdvDlg, "radio_EE_Round_Negative", TRUE); + break; + case 2: + set_checked(AdvDlg, "radio_EE_Round_Positive", TRUE); + break; + case 3: + set_checked(AdvDlg, "radio_EE_Round_Zero", TRUE); + break; + } + + switch ((Config.sseVUMXCSR & 0x6000) >> 13) + { + case 0: + set_checked(AdvDlg, "radio_VU_Round_Near", TRUE); + break; + case 1: + set_checked(AdvDlg, "radio_VU_Round_Negative", TRUE); + break; + case 2: + set_checked(AdvDlg, "radio_VU_Round_Positive", TRUE); + break; + case 3: + set_checked(AdvDlg, "radio_VU_Round_Zero", TRUE); + break; + } + + + switch (Config.eeOptions) + { + case FLAG_EE_CLAMP_NONE: + set_checked(AdvDlg, "radio_EE_Clamp_None", TRUE); + break; + case FLAG_EE_CLAMP_NORMAL: + set_checked(AdvDlg, "radio_EE_Clamp_Normal", TRUE); + break; + case FLAG_EE_CLAMP_EXTRA_PRESERVE: + set_checked(AdvDlg, "radio_EE_Clamp_Extra_Preserve", TRUE); + break; + } + + switch (Config.vuOptions) + { + case FLAG_VU_CLAMP_NONE: + set_checked(AdvDlg, "radio_VU_Clamp_None", TRUE); + break; + case FLAG_VU_CLAMP_NORMAL: + set_checked(AdvDlg, "radio_VU_Clamp_Normal", TRUE); + break; + case FLAG_VU_CLAMP_EXTRA: + set_checked(AdvDlg, "radio_VU_Clamp_Extra", TRUE); + break; + case FLAG_VU_CLAMP_EXTRA_PRESERVE: + set_checked(AdvDlg, "radio_VU_Clamp_Extra_Preserve", TRUE); + break; + } + set_checked(AdvDlg, "check_EE_Flush_Zero", (Config.sseMXCSR & FLAG_FLUSH_ZERO) ? TRUE : FALSE); + set_checked(AdvDlg, "check_EE_Denormal_Zero", (Config.sseMXCSR & FLAG_DENORMAL_ZERO) ? TRUE : FALSE); + + set_checked(AdvDlg, "check_VU_Flush_Zero", (Config.sseVUMXCSR & FLAG_FLUSH_ZERO) ? TRUE : FALSE); + set_checked(AdvDlg, "check_VU_Denormal_Zero", (Config.sseVUMXCSR & FLAG_DENORMAL_ZERO) ? TRUE : FALSE); +} + +void on_Advanced(GtkMenuItem *menuitem, gpointer user_data) +{ + AdvDlg = create_AdvDlg(); + + setAdvancedOptions(); + + gtk_widget_show_all(AdvDlg); + gtk_widget_set_sensitive(MainWindow, FALSE); + gtk_main(); +} + +void on_Advanced_Defaults(GtkButton *button, gpointer user_data) +{ + Config.sseMXCSR = DEFAULT_sseMXCSR; + Config.sseVUMXCSR = DEFAULT_sseVUMXCSR; + Config.eeOptions = DEFAULT_eeOptions; + Config.vuOptions = DEFAULT_vuOptions; + + setAdvancedOptions(); +} + +void on_Advanced_OK(GtkButton *button, gpointer user_data) +{ + Config.sseMXCSR &= 0x1fbf; + Config.sseVUMXCSR &= 0x1fbf; + Config.eeOptions = 0; + Config.vuOptions = 0; + + Config.sseMXCSR |= is_checked(AdvDlg, "radio_EE_Round_Near") ? FLAG_ROUND_NEAR : 0; + Config.sseMXCSR |= is_checked(AdvDlg, "radio_EE_Round_Negative") ? FLAG_ROUND_NEGATIVE : 0; + Config.sseMXCSR |= is_checked(AdvDlg, "radio_EE_Round_Positive") ? FLAG_ROUND_POSITIVE : 0; + Config.sseMXCSR |= is_checked(AdvDlg, "radio_EE_Round_Zero") ? FLAG_ROUND_ZERO : 0; + + Config.sseMXCSR |= is_checked(AdvDlg, "check_EE_Denormal_Zero") ? FLAG_DENORMAL_ZERO : 0; + Config.sseMXCSR |= is_checked(AdvDlg, "check_EE_Flush_Zero") ? FLAG_FLUSH_ZERO : 0; + + Config.sseVUMXCSR |= is_checked(AdvDlg, "radio_VU_Round_Near") ? FLAG_ROUND_NEAR : 0; + Config.sseVUMXCSR |= is_checked(AdvDlg, "radio_VU_Round_Negative") ? FLAG_ROUND_NEGATIVE : 0; + Config.sseVUMXCSR |= is_checked(AdvDlg, "radio_VU_Round_Positive") ? FLAG_ROUND_POSITIVE : 0; + Config.sseVUMXCSR |= is_checked(AdvDlg, "radio_VU_Round_Zero") ? FLAG_ROUND_ZERO : 0; + + Config.sseVUMXCSR |= is_checked(AdvDlg, "check_VU_Denormal_Zero") ? FLAG_DENORMAL_ZERO : 0; + Config.sseVUMXCSR |= is_checked(AdvDlg, "check_VU_Flush_Zero") ? FLAG_FLUSH_ZERO : 0; + + Config.eeOptions |= is_checked(AdvDlg, "radio_EE_Clamp_None") ? FLAG_EE_CLAMP_NONE : 0; + Config.eeOptions |= is_checked(AdvDlg, "radio_EE_Clamp_Normal") ? FLAG_EE_CLAMP_NORMAL : 0; + Config.eeOptions |= is_checked(AdvDlg, "radio_EE_Clamp_Extra_Preserve") ? FLAG_EE_CLAMP_EXTRA_PRESERVE : 0; + + Config.vuOptions |= is_checked(AdvDlg, "radio_VU_Clamp_None") ? FLAG_VU_CLAMP_NONE : 0; + Config.vuOptions |= is_checked(AdvDlg, "radio_VU_Clamp_Normal") ? FLAG_VU_CLAMP_NORMAL : 0; + Config.vuOptions |= is_checked(AdvDlg, "radio_VU_Clamp_Extra") ? FLAG_VU_CLAMP_EXTRA : 0; + Config.vuOptions |= is_checked(AdvDlg, "radio_VU_Clamp_Extra_Preserve") ? FLAG_VU_CLAMP_EXTRA_PRESERVE : 0; + + SetCPUState(Config.sseMXCSR, Config.sseVUMXCSR); + SaveConfig(); + + gtk_widget_destroy(AdvDlg); + gtk_widget_set_sensitive(MainWindow, TRUE); + gtk_main_quit(); +} diff --git a/pcsx2/Linux/ConfigDlg.cpp b/pcsx2/Linux/ConfigDlg.cpp index 7261de8312..08bc54a64a 100644 --- a/pcsx2/Linux/ConfigDlg.cpp +++ b/pcsx2/Linux/ConfigDlg.cpp @@ -5,12 +5,12 @@ * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. - * + * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. - * + * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA @@ -23,23 +23,25 @@ using namespace R5900; static void FindComboText(GtkWidget *combo, char plist[255][255], GList *list, char *conf) { - if (strlen(conf) > 0) SetActiveComboItem(GTK_COMBO_BOX(combo), plist, list, conf); + if (strlen(conf) > 0) SetActiveComboItem(GTK_COMBO_BOX(combo), plist, list, conf); } - + static bool GetComboText(GtkWidget *combo, char plist[255][255], char *conf) { - int i; - - char *tmp = (char*)gtk_combo_box_get_active_text(GTK_COMBO_BOX(combo)); - + int i; + + char *tmp = (char*)gtk_combo_box_get_active_text(GTK_COMBO_BOX(combo)); + if (tmp == NULL) return FALSE; - for (i=2;i<255;i+=2) { - if (!strcmp(tmp, plist[i-1])) { - strcpy(conf, plist[i-2]); - break; - } - } + for (i = 2;i < 255;i += 2) + { + if (!strcmp(tmp, plist[i-1])) + { + strcpy(conf, plist[i-2]); + break; + } + } return TRUE; } @@ -48,23 +50,23 @@ static void ConfPlugin(PluginConf confs, char* plugin, const char* name) void *drv; void (*conf)(); char file[g_MaxPath]; - - GetComboText(confs.Combo, confs.plist, plugin); - strcpy(file, Config.PluginsDir); - strcat(file, plugin); + + GetComboText(confs.Combo, confs.plist, plugin); + strcpy(file, Config.PluginsDir); + strcat(file, plugin); drv = SysLoadLibrary(file); - #ifndef LOCAL_PLUGIN_INIS - getcwd(file, ARRAYSIZE(file)); /* store current dir */ - chdir(Config.PluginsDir); /* change dirs so that plugins can find their config file*/ - #endif +#ifndef LOCAL_PLUGIN_INIS + getcwd(file, ARRAYSIZE(file)); /* store current dir */ + chdir(Config.PluginsDir); /* change dirs so that plugins can find their config file*/ +#endif if (drv == NULL) return; conf = (void (*)()) SysLoadSym(drv, name); - if (SysLibError() == NULL) conf(); - #ifndef LOCAL_PLUGIN_INIS - chdir(file); /* change back*/ - #endif + if (SysLibError() == NULL) conf(); +#ifndef LOCAL_PLUGIN_INIS + chdir(file); /* change back*/ +#endif SysCloseLibrary(drv); } @@ -72,22 +74,22 @@ static void ConfPlugin(PluginConf confs, char* plugin, const char* name) static void TestPlugin(PluginConf confs, char* plugin, const char* name) { void *drv; - s32 (* (*conf)())(); + s32(* (*conf)())(); char file[g_MaxPath]; int ret = 0; - - GetComboText(confs.Combo, confs.plist, plugin); - strcpy(file, Config.PluginsDir); - strcat(file, plugin); + + GetComboText(confs.Combo, confs.plist, plugin); + strcpy(file, Config.PluginsDir); + strcat(file, plugin); drv = SysLoadLibrary(file); - getcwd(file, ARRAYSIZE(file)); /* store current dir */ - chdir(Config.PluginsDir); /* change dirs so that plugins can find their config file*/ + getcwd(file, ARRAYSIZE(file)); /* store current dir */ + chdir(Config.PluginsDir); /* change dirs so that plugins can find their config file*/ if (drv == NULL) return; - conf = (s32 (* (*)())()) SysLoadSym(drv, name); + conf = (s32(* (*)())()) SysLoadSym(drv, name); if (SysLibError() == NULL) ret = (s32) conf(); - chdir(file); /* change back*/ + chdir(file); /* change back*/ SysCloseLibrary(drv); if (ret == 0) @@ -99,7 +101,7 @@ static void TestPlugin(PluginConf confs, char* plugin, const char* name) void OnConf_Gs(GtkMenuItem *menuitem, gpointer user_data) { char file[255]; - + getcwd(file, ARRAYSIZE(file)); chdir(Config.PluginsDir); gtk_widget_set_sensitive(MainWindow, FALSE); @@ -108,9 +110,10 @@ void OnConf_Gs(GtkMenuItem *menuitem, gpointer user_data) gtk_widget_set_sensitive(MainWindow, TRUE); } -void OnConf_Pads(GtkMenuItem *menuitem, gpointer user_data) { +void OnConf_Pads(GtkMenuItem *menuitem, gpointer user_data) +{ char file[255]; - + getcwd(file, ARRAYSIZE(file)); chdir(Config.PluginsDir); gtk_widget_set_sensitive(MainWindow, FALSE); @@ -120,9 +123,10 @@ void OnConf_Pads(GtkMenuItem *menuitem, gpointer user_data) { gtk_widget_set_sensitive(MainWindow, TRUE); } -void OnConf_Spu2(GtkMenuItem *menuitem, gpointer user_data) { +void OnConf_Spu2(GtkMenuItem *menuitem, gpointer user_data) +{ char file[255]; - + getcwd(file, ARRAYSIZE(file)); chdir(Config.PluginsDir); gtk_widget_set_sensitive(MainWindow, FALSE); @@ -131,20 +135,22 @@ void OnConf_Spu2(GtkMenuItem *menuitem, gpointer user_data) { chdir(file); } -void OnConf_Cdvd(GtkMenuItem *menuitem, gpointer user_data) { +void OnConf_Cdvd(GtkMenuItem *menuitem, gpointer user_data) +{ char file[255]; - + getcwd(file, ARRAYSIZE(file)); chdir(Config.PluginsDir); gtk_widget_set_sensitive(MainWindow, FALSE); CDVDconfigure(); gtk_widget_set_sensitive(MainWindow, TRUE); - chdir(file); + chdir(file); } -void OnConf_Dev9(GtkMenuItem *menuitem, gpointer user_data) { +void OnConf_Dev9(GtkMenuItem *menuitem, gpointer user_data) +{ char file[255]; - + getcwd(file, ARRAYSIZE(file)); chdir(Config.PluginsDir); gtk_widget_set_sensitive(MainWindow, FALSE); @@ -153,9 +159,10 @@ void OnConf_Dev9(GtkMenuItem *menuitem, gpointer user_data) { chdir(file); } -void OnConf_Usb(GtkMenuItem *menuitem, gpointer user_data) { +void OnConf_Usb(GtkMenuItem *menuitem, gpointer user_data) +{ char file[255]; - + getcwd(file, ARRAYSIZE(file)); chdir(Config.PluginsDir); gtk_widget_set_sensitive(MainWindow, FALSE); @@ -164,9 +171,10 @@ void OnConf_Usb(GtkMenuItem *menuitem, gpointer user_data) { chdir(file); } -void OnConf_Fw(GtkMenuItem *menuitem, gpointer user_data) { +void OnConf_Fw(GtkMenuItem *menuitem, gpointer user_data) +{ char file[255]; - + getcwd(file, ARRAYSIZE(file)); chdir(Config.PluginsDir); gtk_widget_set_sensitive(MainWindow, FALSE); @@ -175,39 +183,43 @@ void OnConf_Fw(GtkMenuItem *menuitem, gpointer user_data) { chdir(file); } -void SetActiveComboItem(GtkComboBox *widget,char plist[255][255], GList *list, char *conf) +void SetActiveComboItem(GtkComboBox *widget, char plist[255][255], GList *list, char *conf) { GList *temp; int i = 0, pindex = 0, item = -1; - - if (strlen(conf) > 0) { - for (i=2;i<255;i+=2) { - if (!strcmp(conf, plist[i-2])) { + + if (strlen(conf) > 0) + { + for (i = 2;i < 255;i += 2) + { + if (!strcmp(conf, plist[i-2])) + { pindex = i - 1; - break; - } - } + break; + } + } } - + i = 0; temp = list; - + while (temp) { - if (!strcmp(plist[pindex],(char*)temp->data)) + if (!strcmp(plist[pindex], (char*)temp->data)) item = i; - + temp = temp->next; i++; } - + if (item <= 0) item = 0; gtk_combo_box_set_active(GTK_COMBO_BOX(widget), item); } -void OnConfConf_Ok(GtkButton *button, gpointer user_data) { +void OnConfConf_Ok(GtkButton *button, gpointer user_data) +{ applychanges = TRUE; - + if (!GetComboText(GSConfS.Combo, GSConfS.plist, Config.GS)) applychanges = FALSE; if (!GetComboText(PAD1ConfS.Combo, PAD1ConfS.plist, Config.PAD1)) @@ -229,7 +241,8 @@ void OnConfConf_Ok(GtkButton *button, gpointer user_data) { SaveConfig(); - if (configuringplug == FALSE) { + if (configuringplug == FALSE) + { ReleasePlugins(); LoadPlugins(); } @@ -239,146 +252,171 @@ void OnConfConf_Ok(GtkButton *button, gpointer user_data) { gtk_main_quit(); } -void OnConfConf_GsConf(GtkButton *button, gpointer user_data) { +void OnConfConf_GsConf(GtkButton *button, gpointer user_data) +{ ConfPlugin(GSConfS, Config.GS, "GSconfigure"); } -void OnConfConf_GsTest(GtkButton *button, gpointer user_data) { +void OnConfConf_GsTest(GtkButton *button, gpointer user_data) +{ TestPlugin(GSConfS, Config.GS, "GStest"); } -void OnConfConf_GsAbout(GtkButton *button, gpointer user_data) { +void OnConfConf_GsAbout(GtkButton *button, gpointer user_data) +{ ConfPlugin(GSConfS, Config.GS, "GSabout"); } -void OnConfConf_Pad1Conf(GtkButton *button, gpointer user_data) { +void OnConfConf_Pad1Conf(GtkButton *button, gpointer user_data) +{ ConfPlugin(PAD1ConfS, Config.PAD1, "PADconfigure"); } -void OnConfConf_Pad1Test(GtkButton *button, gpointer user_data) { +void OnConfConf_Pad1Test(GtkButton *button, gpointer user_data) +{ TestPlugin(PAD1ConfS, Config.PAD1, "PADtest"); } -void OnConfConf_Pad1About(GtkButton *button, gpointer user_data) { +void OnConfConf_Pad1About(GtkButton *button, gpointer user_data) +{ ConfPlugin(PAD1ConfS, Config.PAD1, "PADabout"); } -void OnConfConf_Pad2Conf(GtkButton *button, gpointer user_data) { +void OnConfConf_Pad2Conf(GtkButton *button, gpointer user_data) +{ ConfPlugin(PAD2ConfS, Config.PAD2, "PADconfigure"); } -void OnConfConf_Pad2Test(GtkButton *button, gpointer user_data) { +void OnConfConf_Pad2Test(GtkButton *button, gpointer user_data) +{ TestPlugin(PAD2ConfS, Config.PAD2, "PADtest"); } -void OnConfConf_Pad2About(GtkButton *button, gpointer user_data) { +void OnConfConf_Pad2About(GtkButton *button, gpointer user_data) +{ ConfPlugin(PAD2ConfS, Config.PAD2, "PADabout"); } -void OnConfConf_Spu2Conf(GtkButton *button, gpointer user_data) { +void OnConfConf_Spu2Conf(GtkButton *button, gpointer user_data) +{ ConfPlugin(SPU2ConfS, Config.SPU2, "SPU2configure"); } -void OnConfConf_Spu2Test(GtkButton *button, gpointer user_data) { +void OnConfConf_Spu2Test(GtkButton *button, gpointer user_data) +{ TestPlugin(SPU2ConfS, Config.SPU2, "SPU2test"); } -void OnConfConf_Spu2About(GtkButton *button, gpointer user_data) { +void OnConfConf_Spu2About(GtkButton *button, gpointer user_data) +{ ConfPlugin(SPU2ConfS, Config.SPU2, "SPU2about"); } -void OnConfConf_CdvdConf(GtkButton *button, gpointer user_data) { +void OnConfConf_CdvdConf(GtkButton *button, gpointer user_data) +{ ConfPlugin(CDVDConfS, Config.CDVD, "CDVDconfigure"); } -void OnConfConf_CdvdTest(GtkButton *button, gpointer user_data) { +void OnConfConf_CdvdTest(GtkButton *button, gpointer user_data) +{ TestPlugin(CDVDConfS, Config.CDVD, "CDVDtest"); } -void OnConfConf_CdvdAbout(GtkButton *button, gpointer user_data) { +void OnConfConf_CdvdAbout(GtkButton *button, gpointer user_data) +{ ConfPlugin(CDVDConfS, Config.CDVD, "CDVDabout"); } -void OnConfConf_Dev9Conf(GtkButton *button, gpointer user_data) { - ConfPlugin( DEV9ConfS, Config.DEV9, "DEV9configure"); +void OnConfConf_Dev9Conf(GtkButton *button, gpointer user_data) +{ + ConfPlugin(DEV9ConfS, Config.DEV9, "DEV9configure"); } -void OnConfConf_Dev9Test(GtkButton *button, gpointer user_data) { +void OnConfConf_Dev9Test(GtkButton *button, gpointer user_data) +{ TestPlugin(DEV9ConfS, Config.DEV9, "DEV9test"); } -void OnConfConf_Dev9About(GtkButton *button, gpointer user_data) { - ConfPlugin( DEV9ConfS, Config.DEV9, "DEV9about"); +void OnConfConf_Dev9About(GtkButton *button, gpointer user_data) +{ + ConfPlugin(DEV9ConfS, Config.DEV9, "DEV9about"); } -void OnConfConf_UsbConf(GtkButton *button, gpointer user_data) { +void OnConfConf_UsbConf(GtkButton *button, gpointer user_data) +{ ConfPlugin(USBConfS, Config.USB, "USBconfigure"); } -void OnConfConf_UsbTest(GtkButton *button, gpointer user_data) { +void OnConfConf_UsbTest(GtkButton *button, gpointer user_data) +{ TestPlugin(USBConfS, Config.USB, "USBtest"); } -void OnConfConf_UsbAbout(GtkButton *button, gpointer user_data) { +void OnConfConf_UsbAbout(GtkButton *button, gpointer user_data) +{ ConfPlugin(USBConfS, Config.USB, "USBabout"); } -void OnConfConf_FWConf(GtkButton *button, gpointer user_data) { - ConfPlugin( FWConfS, Config.FW, "FWconfigure"); +void OnConfConf_FWConf(GtkButton *button, gpointer user_data) +{ + ConfPlugin(FWConfS, Config.FW, "FWconfigure"); } -void OnConfConf_FWTest(GtkButton *button, gpointer user_data) { +void OnConfConf_FWTest(GtkButton *button, gpointer user_data) +{ TestPlugin(FWConfS, Config.FW, "FWtest"); } -void OnConfConf_FWAbout(GtkButton *button, gpointer user_data) { - ConfPlugin( FWConfS, Config.FW, "FWabout"); +void OnConfConf_FWAbout(GtkButton *button, gpointer user_data) +{ + ConfPlugin(FWConfS, Config.FW, "FWabout"); } void SetComboToGList(GtkComboBox *widget, GList *list) { GList *temp; - + while (gtk_combo_box_get_active_text(widget) != NULL) { gtk_combo_box_remove_text(GTK_COMBO_BOX(widget), 0); gtk_combo_box_set_active(GTK_COMBO_BOX(widget), 0); } - + temp = list; while (temp != NULL) { - gtk_combo_box_append_text(GTK_COMBO_BOX (widget), (char*)temp->data); - + gtk_combo_box_append_text(GTK_COMBO_BOX(widget), (char*)temp->data); + temp = temp->next; } - + gtk_combo_box_set_active(GTK_COMBO_BOX(widget), 0); } static void ConfCreatePConf(const char *name, PluginConf *confs, char *config) { char tmp[50]; - - sprintf (tmp, "GtkCombo_%s", name); - confs->Combo = lookup_widget(ConfDlg, tmp); - SetComboToGList(GTK_COMBO_BOX(confs->Combo), confs->PluginNameList); - FindComboText(confs->Combo, confs->plist, confs->PluginNameList, config); + + sprintf(tmp, "GtkCombo_%s", name); + confs->Combo = lookup_widget(ConfDlg, tmp); + SetComboToGList(GTK_COMBO_BOX(confs->Combo), confs->PluginNameList); + FindComboText(confs->Combo, confs->plist, confs->PluginNameList, config); } -void UpdateConfDlg() { - FindPlugins(); +void UpdateConfDlg() +{ + FindPlugins(); - ConfCreatePConf("Gs", &GSConfS, Config.GS); - ConfCreatePConf("Pad1", &PAD1ConfS, Config.PAD1); - ConfCreatePConf("Pad2", &PAD2ConfS, Config.PAD2); - ConfCreatePConf("Spu2", &SPU2ConfS, Config.SPU2); - ConfCreatePConf("Cdvd", &CDVDConfS, Config.CDVD); - ConfCreatePConf("Dev9", &DEV9ConfS, Config.DEV9); - ConfCreatePConf("Usb", &USBConfS, Config.USB); - ConfCreatePConf("FW", &FWConfS, Config.FW); - ConfCreatePConf("Bios", &BiosConfS, Config.Bios); + ConfCreatePConf("Gs", &GSConfS, Config.GS); + ConfCreatePConf("Pad1", &PAD1ConfS, Config.PAD1); + ConfCreatePConf("Pad2", &PAD2ConfS, Config.PAD2); + ConfCreatePConf("Spu2", &SPU2ConfS, Config.SPU2); + ConfCreatePConf("Cdvd", &CDVDConfS, Config.CDVD); + ConfCreatePConf("Dev9", &DEV9ConfS, Config.DEV9); + ConfCreatePConf("Usb", &USBConfS, Config.USB); + ConfCreatePConf("FW", &FWConfS, Config.FW); + ConfCreatePConf("Bios", &BiosConfS, Config.Bios); } void GetDirectory(GtkWidget *topWindow, const char *message, char *reply) @@ -386,45 +424,46 @@ void GetDirectory(GtkWidget *topWindow, const char *message, char *reply) gchar *File; GtkWidget *dialog; gint result; - - dialog = gtk_file_chooser_dialog_new (message, GTK_WINDOW (topWindow), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL); - result = gtk_dialog_run (GTK_DIALOG (dialog)); - + + dialog = gtk_file_chooser_dialog_new(message, GTK_WINDOW(topWindow), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL); + result = gtk_dialog_run(GTK_DIALOG(dialog)); + switch (result) { - case (GTK_RESPONSE_OK): - File = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER (dialog)); + case(GTK_RESPONSE_OK): + File = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); + + strcpy(reply, File); + if (reply[strlen(reply)-1] != '/') + strcat(reply, "/"); - strcpy(reply, File); - if (reply[strlen(reply)-1] != '/') - strcat(reply, "/"); - default: - gtk_widget_destroy (dialog); + gtk_widget_destroy(dialog); } } -void OnConfConf_PluginsPath(GtkButton *button, gpointer user_data) +void OnConfConf_PluginsPath(GtkButton *button, gpointer user_data) { char reply[g_MaxPath]; - - GetDirectory(ConfDlg,"Choose the Plugin Directory:", reply); + + GetDirectory(ConfDlg, "Choose the Plugin Directory:", reply); strcpy(Config.PluginsDir, reply); - + UpdateConfDlg(); } -void OnConfConf_BiosPath(GtkButton *button, gpointer user_data) +void OnConfConf_BiosPath(GtkButton *button, gpointer user_data) { char reply[g_MaxPath]; - - GetDirectory(ConfDlg,"Choose the Bios Directory:", reply); + + GetDirectory(ConfDlg, "Choose the Bios Directory:", reply); strcpy(Config.BiosDir, reply); - + UpdateConfDlg(); } -void OnConf_Conf(GtkMenuItem *menuitem, gpointer user_data) { +void OnConf_Conf(GtkMenuItem *menuitem, gpointer user_data) +{ FindPlugins(); ConfDlg = create_ConfDlg(); @@ -437,50 +476,54 @@ void OnConf_Conf(GtkMenuItem *menuitem, gpointer user_data) { gtk_main(); } -static void ComboAddPlugin(char name[g_MaxPath], PluginConf *confs, u32 version, struct dirent *ent) { - sprintf (name, "%s %ld.%ld.%ld", PS2EgetLibName(), (version>>8)&0xff ,version&0xff, (version>>24)&0xff); - confs->plugins+=2; - strcpy(confs->plist[confs->plugins-1], name); - strcpy(confs->plist[confs->plugins-2], ent->d_name); - confs->PluginNameList = g_list_append(confs->PluginNameList, confs->plist[confs->plugins-1]); +static void ComboAddPlugin(char name[g_MaxPath], PluginConf *confs, u32 version, struct dirent *ent) +{ + sprintf(name, "%s %ld.%ld.%ld", PS2EgetLibName(), (version >> 8)&0xff , version&0xff, (version >> 24)&0xff); + confs->plugins += 2; + strcpy(confs->plist[confs->plugins-1], name); + strcpy(confs->plist[confs->plugins-2], ent->d_name); + confs->PluginNameList = g_list_append(confs->PluginNameList, confs->plist[confs->plugins-1]); } -void FindPlugins() { +void FindPlugins() +{ DIR *dir; struct dirent *ent; void *Handle; - char plugin[g_MaxPath],name[g_MaxPath]; - - GSConfS.plugins = 0; CDVDConfS.plugins = 0; DEV9ConfS.plugins = 0; - PAD1ConfS.plugins = 0; PAD2ConfS.plugins = 0; SPU2ConfS.plugins = 0; - USBConfS.plugins = 0; FWConfS.plugins = 0; BiosConfS.plugins = 0; - GSConfS.PluginNameList = NULL; CDVDConfS.PluginNameList = NULL; DEV9ConfS.PluginNameList = NULL; + char plugin[g_MaxPath], name[g_MaxPath]; + + GSConfS.plugins = 0; CDVDConfS.plugins = 0; DEV9ConfS.plugins = 0; + PAD1ConfS.plugins = 0; PAD2ConfS.plugins = 0; SPU2ConfS.plugins = 0; + USBConfS.plugins = 0; FWConfS.plugins = 0; BiosConfS.plugins = 0; + GSConfS.PluginNameList = NULL; CDVDConfS.PluginNameList = NULL; DEV9ConfS.PluginNameList = NULL; PAD1ConfS.PluginNameList = NULL; PAD2ConfS.PluginNameList = NULL; SPU2ConfS.PluginNameList = NULL; - USBConfS.PluginNameList = NULL; FWConfS.PluginNameList = NULL; BiosConfS.PluginNameList = NULL; + USBConfS.PluginNameList = NULL; FWConfS.PluginNameList = NULL; BiosConfS.PluginNameList = NULL; dir = opendir(Config.PluginsDir); - if (dir == NULL) { + if (dir == NULL) + { Msgbox::Alert("Could not open '%s' directory", params Config.PluginsDir); return; } - while ((ent = readdir(dir)) != NULL) { + while ((ent = readdir(dir)) != NULL) + { u32 version; u32 type; - sprintf (plugin, "%s%s", Config.PluginsDir, ent->d_name); + sprintf(plugin, "%s%s", Config.PluginsDir, ent->d_name); if (strstr(plugin, ".so") == NULL) continue; Handle = dlopen(plugin, RTLD_NOW); - if (Handle == NULL) + if (Handle == NULL) { - Console::Error("Can't open %s: %s\n", params ent->d_name, dlerror()); + Console::Error("Can't open %s: %s\n", params ent->d_name, dlerror()); continue; } PS2EgetLibType = (_PS2EgetLibType) dlsym(Handle, "PS2EgetLibType"); PS2EgetLibName = (_PS2EgetLibName) dlsym(Handle, "PS2EgetLibName"); PS2EgetLibVersion2 = (_PS2EgetLibVersion2) dlsym(Handle, "PS2EgetLibVersion2"); - + if (PS2EgetLibType == NULL) { Console::Error("PS2EgetLibType==NULL for %s", params ent->d_name); @@ -496,100 +539,101 @@ void FindPlugins() { Console::Error("PS2EgetLibVersion2==NULL for %s", params ent->d_name); continue; } - + type = PS2EgetLibType(); - if (type & PS2E_LT_GS) + if (type & PS2E_LT_GS) { version = PS2EgetLibVersion2(PS2E_LT_GS); - - if (((version >> 16)&0xff) == PS2E_GS_VERSION) + + if (((version >> 16)&0xff) == PS2E_GS_VERSION) ComboAddPlugin(name, &GSConfS, version, ent); else Console::Notice("Plugin %s: Version %x != %x", params plugin, (version >> 16)&0xff, PS2E_GS_VERSION); } - if (type & PS2E_LT_PAD) + if (type & PS2E_LT_PAD) { _PADquery query; query = (_PADquery)dlsym(Handle, "PADquery"); version = PS2EgetLibVersion2(PS2E_LT_PAD); - + if (((version >> 16)&0xff) == PS2E_PAD_VERSION && query) { if (query() & 0x1) ComboAddPlugin(name, &PAD1ConfS, version, ent); if (query() & 0x2) ComboAddPlugin(name, &PAD2ConfS, version, ent); } - else + else Console::Notice("Plugin %s: Version %x != %x", params plugin, (version >> 16)&0xff, PS2E_PAD_VERSION); } - if (type & PS2E_LT_SPU2) + if (type & PS2E_LT_SPU2) { version = PS2EgetLibVersion2(PS2E_LT_SPU2); - - if (((version >> 16)&0xff) == PS2E_SPU2_VERSION) + + if (((version >> 16)&0xff) == PS2E_SPU2_VERSION) ComboAddPlugin(name, &SPU2ConfS, version, ent); - else + else Console::Notice("Plugin %s: Version %x != %x", params plugin, (version >> 16)&0xff, PS2E_SPU2_VERSION); } - if (type & PS2E_LT_CDVD) + if (type & PS2E_LT_CDVD) { version = PS2EgetLibVersion2(PS2E_LT_CDVD); - - if (((version >> 16)&0xff) == PS2E_CDVD_VERSION) + + if (((version >> 16)&0xff) == PS2E_CDVD_VERSION) ComboAddPlugin(name, &CDVDConfS, version, ent); - else + else Console::Notice("Plugin %s: Version %x != %x", params plugin, (version >> 16)&0xff, PS2E_CDVD_VERSION); } - if (type & PS2E_LT_DEV9) + if (type & PS2E_LT_DEV9) { version = PS2EgetLibVersion2(PS2E_LT_DEV9); - - if (((version >> 16)&0xff) == PS2E_DEV9_VERSION) + + if (((version >> 16)&0xff) == PS2E_DEV9_VERSION) ComboAddPlugin(name, &DEV9ConfS, version, ent); else Console::Notice("DEV9Plugin %s: Version %x != %x", params plugin, (version >> 16)&0xff, PS2E_DEV9_VERSION); } - if (type & PS2E_LT_USB) + if (type & PS2E_LT_USB) { version = PS2EgetLibVersion2(PS2E_LT_USB); - - if (((version >> 16)&0xff) == PS2E_USB_VERSION) + + if (((version >> 16)&0xff) == PS2E_USB_VERSION) ComboAddPlugin(name, &USBConfS, version, ent); - else + else Console::Notice("USBPlugin %s: Version %x != %x", params plugin, (version >> 16)&0xff, PS2E_USB_VERSION); } - if (type & PS2E_LT_FW) + if (type & PS2E_LT_FW) { version = PS2EgetLibVersion2(PS2E_LT_FW); - - if (((version >> 16)&0xff) == PS2E_FW_VERSION) + + if (((version >> 16)&0xff) == PS2E_FW_VERSION) ComboAddPlugin(name, &FWConfS, version, ent); - else + else Console::Notice("FWPlugin %s: Version %x != %x", params plugin, (version >> 16)&0xff, PS2E_FW_VERSION); } } closedir(dir); dir = opendir(Config.BiosDir); - if (dir == NULL) + if (dir == NULL) { Msgbox::Alert("Could not open '%s' directory", params Config.BiosDir); return; } - while ((ent = readdir(dir)) != NULL) { + while ((ent = readdir(dir)) != NULL) + { struct stat buf; char description[50]; //2002-09-28 (Florin) - sprintf (plugin, "%s%s", Config.BiosDir, ent->d_name); + sprintf(plugin, "%s%s", Config.BiosDir, ent->d_name); if (stat(plugin, &buf) == -1) continue; if (buf.st_size > (1024*4096)) continue; //2002-09-28 (Florin) if (!IsBIOS(ent->d_name, description)) continue;//2002-09-28 (Florin) - BiosConfS.plugins+=2; + BiosConfS.plugins += 2; snprintf(BiosConfS.plist[BiosConfS.plugins-1], sizeof(BiosConfS.plist[0]), "%s (", description); - strncat(BiosConfS.plist[BiosConfS.plugins-1], ent->d_name, min(sizeof(BiosConfS.plist[0]-2), strlen(ent->d_name))); + strncat(BiosConfS.plist[BiosConfS.plugins-1], ent->d_name, min(sizeof(BiosConfS.plist[0] - 2), strlen(ent->d_name))); strcat(BiosConfS.plist[BiosConfS.plugins-1], ")"); strcpy(BiosConfS.plist[BiosConfS.plugins-2], ent->d_name); BiosConfS.PluginNameList = g_list_append(BiosConfS.PluginNameList, BiosConfS.plist[BiosConfS.plugins-1]); diff --git a/pcsx2/Linux/ConfigDlg.h b/pcsx2/Linux/ConfigDlg.h index 10c9064048..a4aa0dfad1 100644 --- a/pcsx2/Linux/ConfigDlg.h +++ b/pcsx2/Linux/ConfigDlg.h @@ -15,25 +15,26 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA */ - - #ifndef __CONFIGDLG_H__ + +#ifndef __CONFIGDLG_H__ #define __CONFIGDLG_H__ #include "Linux.h" #ifdef __cplusplus -extern "C" { +extern "C" +{ #endif - + #include "support.h" #include "callbacks.h" #include "interface.h" - + #ifdef __cplusplus } #endif #include "R3000A.h" #include "IopMem.h" - + // Helper Functions void FindPlugins(); @@ -41,7 +42,8 @@ void OnConf_Gs(GtkMenuItem *menuitem, gpointer user_data); void OnConf_Pads(GtkMenuItem *menuitem, gpointer user_data); void OnConf_Cpu(GtkMenuItem *menuitem, gpointer user_data); void OnConf_Conf(GtkMenuItem *menuitem, gpointer user_data); -typedef struct { +typedef struct +{ GtkWidget *Combo; GList *PluginNameList; char plist[255][255]; @@ -64,7 +66,7 @@ _PS2EgetLibType PS2EgetLibType = NULL; _PS2EgetLibVersion2 PS2EgetLibVersion2 = NULL; _PS2EgetLibName PS2EgetLibName = NULL; -void SetActiveComboItem(GtkComboBox *widget,char plist[255][255], GList *list, char *conf); +void SetActiveComboItem(GtkComboBox *widget, char plist[255][255], GList *list, char *conf); void SetComboToGList(GtkComboBox *widget, GList *list); static void ConfPlugin(PluginConf confs, char* plugin, const char* name); static void TestPlugin(PluginConf confs, char* plugin, const char* name); diff --git a/pcsx2/Linux/CpuDlg.cpp b/pcsx2/Linux/CpuDlg.cpp new file mode 100644 index 0000000000..d5e7ee223b --- /dev/null +++ b/pcsx2/Linux/CpuDlg.cpp @@ -0,0 +1,113 @@ +/* Pcsx2 - Pc Ps2 Emulator + * Copyright (C) 2002-2008 Pcsx2 Team + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + + #include "Linux.h" + +void OnCpu_Ok(GtkButton *button, gpointer user_data) +{ + u32 newopts = 0; + + if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkCheckButton_EERec")))) + newopts |= PCSX2_EEREC; + if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkCheckButton_VU0rec")))) + newopts |= PCSX2_VU0REC; + if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkCheckButton_VU1rec")))) + newopts |= PCSX2_VU1REC; + if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkCheckButton_MTGS")))) + newopts |= PCSX2_GSMULTITHREAD; + if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkRadioButton_LimitNormal")))) + newopts |= PCSX2_FRAMELIMIT_NORMAL; + else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkRadioButton_LimitLimit")))) + newopts |= PCSX2_FRAMELIMIT_LIMIT; + else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkRadioButton_LimitFS")))) + newopts |= PCSX2_FRAMELIMIT_SKIP; + else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkRadioButton_VUSkip")))) + newopts |= PCSX2_FRAMELIMIT_VUSKIP; + + Config.CustomFps = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(lookup_widget(CpuDlg, "CustomFPSLimit"))); + Config.CustomFrameSkip = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(lookup_widget(CpuDlg, "FrameThreshold"))); + Config.CustomConsecutiveFrames = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(lookup_widget(CpuDlg, "FramesBeforeSkipping"))); + Config.CustomConsecutiveSkip = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(lookup_widget(CpuDlg, "FramesToSkip"))); + + if (Config.Options != newopts) + { + SysRestorableReset(); + + if ((Config.Options&PCSX2_GSMULTITHREAD) ^(newopts&PCSX2_GSMULTITHREAD)) + { + // Need the MTGS setting to take effect, so close out the plugins: + PluginsResetGS(); + + if (CHECK_MULTIGS) + Console::Notice("MTGS mode disabled.\n\tEnjoy the fruits of single-threaded simpicity."); + else + Console::Notice("MTGS mode enabled.\n\tWelcome to multi-threaded awesomeness. And random crashes."); + } + + Config.Options = newopts; + } + else + UpdateVSyncRate(); + + SaveConfig(); + + gtk_widget_destroy(CpuDlg); + if (MainWindow) gtk_widget_set_sensitive(MainWindow, TRUE); + gtk_main_quit(); +} + +void OnConf_Cpu(GtkMenuItem *menuitem, gpointer user_data) +{ + char str[512]; + + CpuDlg = create_CpuDlg(); + gtk_window_set_title(GTK_WINDOW(CpuDlg), _("Configuration")); + + gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkCheckButton_EERec")), !!CHECK_EEREC); + gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkCheckButton_VU0rec")), !!CHECK_VU0REC); + gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkCheckButton_VU1rec")), !!CHECK_VU1REC); + gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkCheckButton_MTGS")), !!CHECK_MULTIGS); + gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkRadioButton_LimitNormal")), CHECK_FRAMELIMIT == PCSX2_FRAMELIMIT_NORMAL); + gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkRadioButton_LimitLimit")), CHECK_FRAMELIMIT == PCSX2_FRAMELIMIT_LIMIT); + gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkRadioButton_LimitFS")), CHECK_FRAMELIMIT == PCSX2_FRAMELIMIT_SKIP); + gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkRadioButton_VUSkip")), CHECK_FRAMELIMIT == PCSX2_FRAMELIMIT_VUSKIP); + + sprintf(str, "Cpu Vendor: %s", cpuinfo.x86ID); + gtk_label_set_text(GTK_LABEL(lookup_widget(CpuDlg, "GtkLabel_CpuVendor")), str); + sprintf(str, "Familly: %s", cpuinfo.x86Fam); + gtk_label_set_text(GTK_LABEL(lookup_widget(CpuDlg, "GtkLabel_Family")), str); + sprintf(str, "Cpu Speed: %d MHZ", cpuinfo.cpuspeed); + gtk_label_set_text(GTK_LABEL(lookup_widget(CpuDlg, "GtkLabel_CpuSpeed")), str); + + strcpy(str, "Features: "); + if (cpucaps.hasMultimediaExtensions) strcat(str, "MMX"); + if (cpucaps.hasStreamingSIMDExtensions) strcat(str, ",SSE"); + if (cpucaps.hasStreamingSIMD2Extensions) strcat(str, ",SSE2"); + if (cpucaps.hasStreamingSIMD3Extensions) strcat(str, ",SSE3"); + if (cpucaps.hasAMD64BitArchitecture) strcat(str, ",x86-64"); + gtk_label_set_text(GTK_LABEL(lookup_widget(CpuDlg, "GtkLabel_Features")), str); + + gtk_spin_button_set_value(GTK_SPIN_BUTTON(lookup_widget(CpuDlg, "CustomFPSLimit")), (gdouble)Config.CustomFps); + gtk_spin_button_set_value(GTK_SPIN_BUTTON(lookup_widget(CpuDlg, "FrameThreshold")), (gdouble)Config.CustomFrameSkip); + gtk_spin_button_set_value(GTK_SPIN_BUTTON(lookup_widget(CpuDlg, "FramesBeforeSkipping")), (gdouble)Config.CustomConsecutiveFrames); + gtk_spin_button_set_value(GTK_SPIN_BUTTON(lookup_widget(CpuDlg, "FramesToSkip")), (gdouble)Config.CustomConsecutiveSkip); + + gtk_widget_show_all(CpuDlg); + if (MainWindow) gtk_widget_set_sensitive(MainWindow, FALSE); + gtk_main(); +} \ No newline at end of file diff --git a/pcsx2/Linux/DebugDlg.cpp b/pcsx2/Linux/DebugDlg.cpp index 4c27702c95..094274cbee 100644 --- a/pcsx2/Linux/DebugDlg.cpp +++ b/pcsx2/Linux/DebugDlg.cpp @@ -5,12 +5,12 @@ * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. - * + * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. - * + * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA @@ -19,35 +19,39 @@ #include "DebugDlg.h" using namespace R5900; -void UpdateDebugger() { +void UpdateDebugger() +{ char *str; int i; std::string output; - - DebugAdj->value = (gfloat)dPC/4; + + DebugAdj->value = (gfloat)dPC / 4; gtk_list_store_clear(ListDVModel); - for (i=0; i<23; i++) { + for (i = 0; i < 23; i++) + { GtkTreeIter iter; u32 *mem; - u32 pc = dPC + i*4; - if (DebugMode) { + u32 pc = dPC + i * 4; + if (DebugMode) + { mem = (u32*)PSXM(pc); - } + } else - mem = (u32*)PSM(pc); - - if (mem == NULL) { + mem = (u32*)PSM(pc); + + if (mem == NULL) + { sprintf(nullAddr, "%8.8lX:\tNULL MEMORY", pc); - str = nullAddr; - } - else + str = nullAddr; + } + else { std::string output; - + disR5900Fasm(output, *mem, pc); - output.copy( str, 256 ); + output.copy(str, 256); } gtk_list_store_append(ListDVModel, &iter); gtk_list_store_set(ListDVModel, &iter, 0, str, -1); @@ -55,25 +59,28 @@ void UpdateDebugger() { } } -void OnDebug_Close(GtkButton *button, gpointer user_data) { +void OnDebug_Close(GtkButton *button, gpointer user_data) +{ ClosePlugins(); gtk_widget_destroy(DebugWnd); gtk_main_quit(); gtk_widget_set_sensitive(MainWindow, TRUE); } -void OnDebug_ScrollChange(GtkAdjustment *adj) { - dPC = (u32)adj->value*4; - dPC&= ~0x3; - +void OnDebug_ScrollChange(GtkAdjustment *adj) +{ + dPC = (u32)adj->value * 4; + dPC &= ~0x3; + UpdateDebugger(); } -void OnSetPC_Ok(GtkButton *button, gpointer user_data) { +void OnSetPC_Ok(GtkButton *button, gpointer user_data) +{ char *str = (char*)gtk_entry_get_text(GTK_ENTRY(SetPCEntry)); sscanf(str, "%lx", &dPC); - dPC&= ~0x3; + dPC &= ~0x3; gtk_widget_destroy(SetPCDlg); gtk_main_quit(); @@ -81,27 +88,30 @@ void OnSetPC_Ok(GtkButton *button, gpointer user_data) { UpdateDebugger(); } -void OnSetPC_Cancel(GtkButton *button, gpointer user_data) { +void OnSetPC_Cancel(GtkButton *button, gpointer user_data) +{ gtk_widget_destroy(SetPCDlg); gtk_main_quit(); gtk_widget_set_sensitive(DebugWnd, TRUE); } -void OnDebug_SetPC(GtkButton *button, gpointer user_data) { +void OnDebug_SetPC(GtkButton *button, gpointer user_data) +{ SetPCDlg = create_SetPCDlg(); - + SetPCEntry = lookup_widget(SetPCDlg, "GtkEntry_dPC"); - + gtk_widget_show_all(SetPCDlg); gtk_widget_set_sensitive(DebugWnd, FALSE); gtk_main(); } -void OnSetBPA_Ok(GtkButton *button, gpointer user_data) { +void OnSetBPA_Ok(GtkButton *button, gpointer user_data) +{ char *str = (char*)gtk_entry_get_text(GTK_ENTRY(SetBPAEntry)); sscanf(str, "%lx", &dBPA); - dBPA&= ~0x3; + dBPA &= ~0x3; gtk_widget_destroy(SetBPADlg); gtk_main_quit(); @@ -109,23 +119,26 @@ void OnSetBPA_Ok(GtkButton *button, gpointer user_data) { UpdateDebugger(); } -void OnSetBPA_Cancel(GtkButton *button, gpointer user_data) { +void OnSetBPA_Cancel(GtkButton *button, gpointer user_data) +{ gtk_widget_destroy(SetBPADlg); gtk_main_quit(); gtk_widget_set_sensitive(DebugWnd, TRUE); } -void OnDebug_SetBPA(GtkButton *button, gpointer user_data) { +void OnDebug_SetBPA(GtkButton *button, gpointer user_data) +{ SetBPADlg = create_SetBPADlg(); - + SetBPAEntry = lookup_widget(SetBPADlg, "GtkEntry_BPA"); - gtk_widget_show_all(SetBPADlg); + gtk_widget_show_all(SetBPADlg); gtk_widget_set_sensitive(DebugWnd, FALSE); gtk_main(); } -void OnSetBPC_Ok(GtkButton *button, gpointer user_data) { +void OnSetBPC_Ok(GtkButton *button, gpointer user_data) +{ char *str = (char*)gtk_entry_get_text(GTK_ENTRY(SetBPCEntry)); sscanf(str, "%lx", &dBPC); @@ -136,63 +149,73 @@ void OnSetBPC_Ok(GtkButton *button, gpointer user_data) { UpdateDebugger(); } -void OnSetBPC_Cancel(GtkButton *button, gpointer user_data) { +void OnSetBPC_Cancel(GtkButton *button, gpointer user_data) +{ gtk_widget_destroy(SetBPCDlg); gtk_main_quit(); gtk_widget_set_sensitive(DebugWnd, TRUE); } -void OnDebug_SetBPC(GtkButton *button, gpointer user_data) { +void OnDebug_SetBPC(GtkButton *button, gpointer user_data) +{ SetBPCDlg = create_SetBPCDlg(); - + SetBPCEntry = lookup_widget(SetBPCDlg, "GtkEntry_BPC"); - gtk_widget_show_all(SetBPCDlg); + gtk_widget_show_all(SetBPCDlg); gtk_widget_set_sensitive(DebugWnd, FALSE); gtk_main(); } -void OnDebug_ClearBPs(GtkButton *button, gpointer user_data) { +void OnDebug_ClearBPs(GtkButton *button, gpointer user_data) +{ dBPA = -1; dBPC = -1; } -void OnDumpC_Ok(GtkButton *button, gpointer user_data) { +void OnDumpC_Ok(GtkButton *button, gpointer user_data) +{ FILE *f; char *str = (char*)gtk_entry_get_text(GTK_ENTRY(DumpCFEntry)); u32 addrf, addrt; - sscanf(str, "%lx", &addrf); addrf&=~0x3; + sscanf(str, "%lx", &addrf); + addrf &= ~0x3; str = (char*)gtk_entry_get_text(GTK_ENTRY(DumpCTEntry)); - sscanf(str, "%lx", &addrt); addrt&=~0x3; + sscanf(str, "%lx", &addrt); + addrt &= ~0x3; f = fopen("dump.txt", "w"); if (f == NULL) return; - while (addrf != addrt) { + while (addrf != addrt) + { u32 *mem; - if (DebugMode) { + if (DebugMode) + { mem = (u32*)PSXM(addrf); - } - else { + } + else + { mem = (u32*)PSM(addrf); } - - if (mem == NULL) { - sprintf(nullAddr, "%8.8lX:\tNULL MEMORY", addrf); - str = nullAddr; + + if (mem == NULL) + { + sprintf(nullAddr, "%8.8lX:\tNULL MEMORY", addrf); + str = nullAddr; } - else + else { std::string output; - + disR5900Fasm(output, *mem, addrf); - output.copy( str, 256 ); + output.copy(str, 256); } fprintf(f, "%s\n", str); - addrf+= 4; + addrf += 4; } fclose(f); @@ -201,49 +224,58 @@ void OnDumpC_Ok(GtkButton *button, gpointer user_data) { gtk_widget_set_sensitive(DebugWnd, TRUE); } -void OnDumpC_Cancel(GtkButton *button, gpointer user_data) { -gtk_widget_destroy(DumpCDlg); +void OnDumpC_Cancel(GtkButton *button, gpointer user_data) +{ + gtk_widget_destroy(DumpCDlg); gtk_main_quit(); gtk_widget_set_sensitive(DebugWnd, TRUE); } -void OnDebug_DumpCode(GtkButton *button, gpointer user_data) { +void OnDebug_DumpCode(GtkButton *button, gpointer user_data) +{ DumpCDlg = create_DumpCDlg(); - + DumpCFEntry = lookup_widget(DumpCDlg, "GtkEntry_DumpCF"); DumpCTEntry = lookup_widget(DumpCDlg, "GtkEntry_DumpCT"); - gtk_widget_show_all(DumpCDlg); + gtk_widget_show_all(DumpCDlg); gtk_widget_set_sensitive(DebugWnd, FALSE); gtk_main(); } -void OnDumpR_Ok(GtkButton *button, gpointer user_data) { +void OnDumpR_Ok(GtkButton *button, gpointer user_data) +{ FILE *f; char *str = (char*)gtk_entry_get_text(GTK_ENTRY(DumpRFEntry)); u32 addrf, addrt; - sscanf(str, "%lx", &addrf); addrf&=~0x3; + sscanf(str, "%lx", &addrf); + addrf &= ~0x3; str = (char*)gtk_entry_get_text(GTK_ENTRY(DumpRTEntry)); - sscanf(str, "%lx", &addrt); addrt&=~0x3; + sscanf(str, "%lx", &addrt); + addrt &= ~0x3; f = fopen("dump.txt", "w"); if (f == NULL) return; - while (addrf != addrt) { + while (addrf != addrt) + { u32 *mem; u32 out; - if (DebugMode) { + if (DebugMode) + { mem = (u32*)PSXM(addrf); - } else { + } + else + { mem = (u32*)PSM(addrf); } if (mem == NULL) out = 0; else out = *mem; fwrite(&out, 4, 1, f); - addrf+= 4; + addrf += 4; } fclose(f); @@ -252,49 +284,59 @@ void OnDumpR_Ok(GtkButton *button, gpointer user_data) { gtk_widget_set_sensitive(DebugWnd, TRUE); } -void OnDumpR_Cancel(GtkButton *button, gpointer user_data) { +void OnDumpR_Cancel(GtkButton *button, gpointer user_data) +{ gtk_widget_destroy(DumpRDlg); gtk_main_quit(); gtk_widget_set_sensitive(DebugWnd, TRUE); } -void OnDebug_RawDump(GtkButton *button, gpointer user_data) { +void OnDebug_RawDump(GtkButton *button, gpointer user_data) +{ DumpRDlg = create_DumpRDlg(); - + DumpRFEntry = lookup_widget(DumpRDlg, "GtkEntry_DumpRF"); DumpRTEntry = lookup_widget(DumpRDlg, "GtkEntry_DumpRT"); - gtk_widget_show_all(DumpRDlg); + gtk_widget_show_all(DumpRDlg); gtk_widget_set_sensitive(DebugWnd, FALSE); gtk_main(); } -void OnDebug_Step(GtkButton *button, gpointer user_data) { +void OnDebug_Step(GtkButton *button, gpointer user_data) +{ Cpu->Step(); dPC = cpuRegs.pc; UpdateDebugger(); } -void OnDebug_Skip(GtkButton *button, gpointer user_data) { - cpuRegs.pc+= 4; +void OnDebug_Skip(GtkButton *button, gpointer user_data) +{ + cpuRegs.pc += 4; dPC = cpuRegs.pc; UpdateDebugger(); } -int HasBreakPoint(u32 pc) { +int HasBreakPoint(u32 pc) +{ if (pc == dBPA) return 1; - if (DebugMode == 0) { + if (DebugMode == 0) + { if ((cpuRegs.cycle - 10) <= dBPC && - (cpuRegs.cycle + 10) >= dBPC) return 1; - } else { + (cpuRegs.cycle + 10) >= dBPC) return 1; + } + else + { if ((psxRegs.cycle - 100) <= dBPC && - (psxRegs.cycle + 100) >= dBPC) return 1; + (psxRegs.cycle + 100) >= dBPC) return 1; } return 0; } -void OnDebug_Go(GtkButton *button, gpointer user_data) { - for (;;) { +void OnDebug_Go(GtkButton *button, gpointer user_data) +{ + for (;;) + { if (HasBreakPoint(cpuRegs.pc)) break; Cpu->Step(); } @@ -302,25 +344,29 @@ void OnDebug_Go(GtkButton *button, gpointer user_data) { UpdateDebugger(); } -void OnDebug_Log(GtkButton *button, gpointer user_data) { +void OnDebug_Log(GtkButton *button, gpointer user_data) +{ #ifdef PCSX2_DEVBUILD //Log = 1 - Log; #endif } -void OnDebug_EEMode(GtkToggleButton *togglebutton, gpointer user_data) { +void OnDebug_EEMode(GtkToggleButton *togglebutton, gpointer user_data) +{ DebugMode = 0; dPC = cpuRegs.pc; UpdateDebugger(); } -void OnDebug_IOPMode(GtkToggleButton *togglebutton, gpointer user_data) { +void OnDebug_IOPMode(GtkToggleButton *togglebutton, gpointer user_data) +{ DebugMode = 1; dPC = psxRegs.pc; UpdateDebugger(); } -void OnMemWrite32_Ok(GtkButton *button, gpointer user_data) { +void OnMemWrite32_Ok(GtkButton *button, gpointer user_data) +{ char *mem = (char*)gtk_entry_get_text(GTK_ENTRY(MemEntry)); char *data = (char*)gtk_entry_get_text(GTK_ENTRY(DataEntry)); @@ -331,26 +377,29 @@ void OnMemWrite32_Ok(GtkButton *button, gpointer user_data) { gtk_widget_set_sensitive(DebugWnd, TRUE); } -void OnMemWrite32_Cancel(GtkButton *button, gpointer user_data) { +void OnMemWrite32_Cancel(GtkButton *button, gpointer user_data) +{ gtk_widget_destroy(MemWriteDlg); gtk_main_quit(); gtk_widget_set_sensitive(DebugWnd, TRUE); } -void OnDebug_memWrite32(GtkButton *button, gpointer user_data) { +void OnDebug_memWrite32(GtkButton *button, gpointer user_data) +{ MemWriteDlg = create_MemWrite32(); MemEntry = lookup_widget(MemWriteDlg, "GtkEntry_Mem"); DataEntry = lookup_widget(MemWriteDlg, "GtkEntry_Data"); - gtk_widget_show_all(MemWriteDlg); + gtk_widget_show_all(MemWriteDlg); gtk_widget_set_sensitive(DebugWnd, FALSE); gtk_main(); UpdateDebugger(); } -void OnDebug_Debugger(GtkMenuItem *menuitem, gpointer user_data) { +void OnDebug_Debugger(GtkMenuItem *menuitem, gpointer user_data) +{ GtkWidget *scroll; GtkCellRenderer *renderer; GtkTreeViewColumn *column; @@ -364,29 +413,29 @@ void OnDebug_Debugger(GtkMenuItem *menuitem, gpointer user_data) { efile=0;*/ dPC = cpuRegs.pc; - + DebugWnd = create_DebugWnd(); - - ListDVModel = gtk_list_store_new (1, G_TYPE_STRING); + + ListDVModel = gtk_list_store_new(1, G_TYPE_STRING); ListDV = lookup_widget(DebugWnd, "GtkList_DisView"); gtk_tree_view_set_model(GTK_TREE_VIEW(ListDV), GTK_TREE_MODEL(ListDVModel)); - renderer = gtk_cell_renderer_text_new (); - column = gtk_tree_view_column_new_with_attributes ("heading", renderer, - "text", 0, - NULL); - gtk_tree_view_append_column (GTK_TREE_VIEW (ListDV), column); + renderer = gtk_cell_renderer_text_new(); + column = gtk_tree_view_column_new_with_attributes("heading", renderer, + "text", 0, + NULL); + gtk_tree_view_append_column(GTK_TREE_VIEW(ListDV), column); scroll = lookup_widget(DebugWnd, "GtkVScrollbar_VList"); DebugAdj = GTK_RANGE(scroll)->adjustment; - DebugAdj->lower = (gfloat)0x00000000/4; - DebugAdj->upper = (gfloat)0xffffffff/4; + DebugAdj->lower = (gfloat)0x00000000 / 4; + DebugAdj->upper = (gfloat)0xffffffff / 4; DebugAdj->step_increment = (gfloat)1; DebugAdj->page_increment = (gfloat)20; DebugAdj->page_size = (gfloat)23; gtk_signal_connect(GTK_OBJECT(DebugAdj), "value_changed", GTK_SIGNAL_FUNC(OnDebug_ScrollChange), - NULL); + NULL); UpdateDebugger(); diff --git a/pcsx2/Linux/DebugDlg.h b/pcsx2/Linux/DebugDlg.h index fd8582c6ec..a9636eff72 100644 --- a/pcsx2/Linux/DebugDlg.h +++ b/pcsx2/Linux/DebugDlg.h @@ -15,25 +15,26 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA */ - - #ifndef __DEBUGDLG_H__ + +#ifndef __DEBUGDLG_H__ #define __DEBUGDLG_H__ #include "Linux.h" #ifdef __cplusplus -extern "C" { +extern "C" +{ #endif #include "support.h" #include "callbacks.h" #include "interface.h" - + #ifdef __cplusplus } #endif #include "R3000A.h" #include "IopMem.h" - + GtkWidget *ListDV; GtkListStore *ListDVModel; diff --git a/pcsx2/Linux/GtkGui.cpp b/pcsx2/Linux/GtkGui.cpp deleted file mode 100644 index c36664e841..0000000000 --- a/pcsx2/Linux/GtkGui.cpp +++ /dev/null @@ -1,993 +0,0 @@ -/* Pcsx2 - Pc Ps2 Emulator - * Copyright (C) 2002-2008 Pcsx2 Team - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA - */ - -#include "GtkGui.h" - -using namespace R5900; - -void On_Dialog_Cancelled(GtkButton* button, gpointer user_data) { - gtk_widget_destroy((GtkWidget*)gtk_widget_get_toplevel ((GtkWidget*)button)); - gtk_widget_set_sensitive(MainWindow, TRUE); - gtk_main_quit(); -} - -void StartGui() { - GtkWidget *Menu; - GtkWidget *Item; - - u32 i; - - add_pixmap_directory(".pixmaps"); - MainWindow = create_MainWindow(); - - if (SVN_REV != 0) - gtk_window_set_title(GTK_WINDOW(MainWindow), "PCSX2 "PCSX2_VERSION" "SVN_REV); - else - gtk_window_set_title(GTK_WINDOW(MainWindow), "PCSX2 "PCSX2_VERSION); - - // status bar - pStatusBar = gtk_statusbar_new (); - gtk_box_pack_start (GTK_BOX(lookup_widget(MainWindow, "status_box")), pStatusBar, TRUE, TRUE, 0); - gtk_widget_show (pStatusBar); - - gtk_statusbar_push(GTK_STATUSBAR(pStatusBar),0, - "F1 - save, F2 - next state, Shift+F2 - prev state, F3 - load, F8 - snapshot"); - - // add all the languages - Item = lookup_widget(MainWindow, "GtkMenuItem_Language"); - Menu = gtk_menu_new(); - gtk_menu_item_set_submenu(GTK_MENU_ITEM(Item), Menu); - - for (i=0; i < langsMax; i++) { - Item = gtk_check_menu_item_new_with_label(ParseLang(langs[i].lang)); - gtk_widget_show(Item); - gtk_container_add(GTK_CONTAINER(Menu), Item); - gtk_check_menu_item_set_show_toggle(GTK_CHECK_MENU_ITEM(Item), TRUE); - if (!strcmp(Config.Lang, langs[i].lang)) - gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(Item), TRUE); - - gtk_signal_connect(GTK_OBJECT(Item), "activate", - GTK_SIGNAL_FUNC(OnLanguage), - (gpointer)(uptr)i); - } - - // check the appropriate menu items - gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(lookup_widget(MainWindow, "enable_console1")), Config.PsxOut); - gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(lookup_widget(MainWindow, "enable_patches1")), Config.Patch); - - // disable anything not implemented or not working properly. - gtk_widget_set_sensitive(GTK_WIDGET(lookup_widget(MainWindow, "patch_browser1")), FALSE); - gtk_widget_set_sensitive(GTK_WIDGET(lookup_widget(MainWindow, "patch_finder2")), FALSE); - #ifndef PCSX2_DEVBUILD - gtk_widget_set_sensitive(GTK_WIDGET(lookup_widget(MainWindow, "GtkMenuItem_Logging")), FALSE); - #endif - - gtk_widget_show_all(MainWindow); - gtk_window_activate_focus(GTK_WINDOW(MainWindow)); - gtk_main(); -} - -void RunGui() { - StartGui(); -} - -void FixCPUState(void) -{ - //Config.sseMXCSR = LinuxsseMXCSR; - //Config.sseVUMXCSR = LinuxsseVUMXCSR; - SetCPUState(Config.sseMXCSR, Config.sseVUMXCSR); -} - -void OnDestroy(GtkObject *object, gpointer user_data) {} - -gboolean OnDelete(GtkWidget *widget, GdkEvent *event, gpointer user_data) -{ - pcsx2_exit(); - return (FALSE); -} -int Pcsx2Configure() { - if (!UseGui) return 0; - - configuringplug = TRUE; - MainWindow = NULL; - OnConf_Conf(NULL, 0); - configuringplug = FALSE; - - return applychanges; -} - -void OnLanguage(GtkMenuItem *menuitem, gpointer user_data) { - ChangeLanguage(langs[(int)(uptr)user_data].lang); - gtk_widget_destroy(MainWindow); - gtk_main_quit(); - while (gtk_events_pending()) gtk_main_iteration(); - StartGui(); -} - -void SignalExit(int sig) { - ClosePlugins(); - pcsx2_exit(); -} - -void ExecuteCpu() -{ - // Make sure any left-over recovery states are cleaned up. - safe_delete( g_RecoveryState ); - - // Destroy the window. Ugly thing. - gtk_widget_destroy(MainWindow); - gtk_main_quit(); - while (gtk_events_pending()) gtk_main_iteration(); - - g_GameInProgress = true; - m_ReturnToGame = false; - - signal(SIGINT, SignalExit); - signal(SIGPIPE, SignalExit); - - // Make sure any left-over recovery states are cleaned up. - safe_delete( g_RecoveryState ); - - // Just in case they weren't initialized earlier (no harm in calling this multiple times) - if (OpenPlugins(NULL) == -1) return; - - // this needs to be called for every new game! (note: sometimes launching games through bios will give a crc of 0) - if( GSsetGameCRC != NULL ) GSsetGameCRC(ElfCRC, g_ZeroGSOptions); - - // Optimization: We hardcode two versions of the EE here -- one for recs and one for ints. - // This is because recs are performance critical, and being able to inline them into the - // function here helps a small bit (not much but every small bit counts!). - - g_EmulationInProgress = true; - g_ReturnToGui = false; - - PCSX2_MEM_PROTECT_BEGIN(); - - if( CHECK_EEREC ) - { - while( !g_ReturnToGui ) - { - recExecute(); - SysUpdate(); - } - } - else - { - while( !g_ReturnToGui ) - { - Cpu->Execute(); - SysUpdate(); - } - } - PCSX2_MEM_PROTECT_END(); -} - -void RunExecute( const char* elf_file, bool use_bios ) -{ - - // (air notes:) - // If you want to use the new to-memory savestate feature, take a look at the new - // RunExecute in WinMain.c, and secondly the CpuDlg.c or AdvancedDlg.cpp. The - // objects used are MemoryAlloc, memLoadingState, and memSavingState. - - // It's important to make sure to reset the CPU and the plugins correctly, which is - // where the new RunExecute comes into play. It can be kind of tricky knowing - // when to call cpuExecuteBios and loadElfFile, and with what parameters. - - // (or, as an alternative maybe we should switch to wxWidgets and have a unified - // cross platform gui?) - Air - - try - { - cpuReset(); - } - - catch( std::exception& ex ) - { - Msgbox::Alert( ex.what() ); - return; - } - - if (OpenPlugins(NULL) == -1) - { - RunGui(); - return; - } - - if (elf_file == NULL ) - { - if (g_RecoveryState != NULL) - { - try - { - memLoadingState( *g_RecoveryState ).FreezeAll(); - } - catch( std::runtime_error& ex ) - { - Msgbox::Alert( - "Gamestate recovery failed. Your game progress will be lost (sorry!)\n" - "\nError: %s\n", params ex.what() ); - - // Take the user back to the GUI... - safe_delete( g_RecoveryState ); - ClosePlugins(); - return; - } - safe_delete( g_RecoveryState ); - } - else - { - // Not recovering a state, so need to execute the bios and load the ELF information. - - // if the elf_file is null we use the CDVD elf file. - // But if the elf_file is an empty string then we boot the bios instead. - - char ename[g_MaxPath]; - ename[0] = 0; - if( !use_bios ) - GetPS2ElfName( ename ); - - loadElfFile( ename ); - } - } - else - { - // Custom ELF specified (not using CDVD). - // Run the BIOS and load the ELF. - - loadElfFile( elf_file ); - } - - FixCPUState(); - - ExecuteCpu(); -} - -void OnFile_RunCD(GtkMenuItem *menuitem, gpointer user_data) { - safe_free( g_RecoveryState ); - ResetPlugins(); - RunExecute( NULL ); -} - -void OnRunElf_Ok(GtkButton* button, gpointer user_data) { - gchar *File; - - File = (gchar*)gtk_file_selection_get_filename(GTK_FILE_SELECTION(FileSel)); - strcpy(elfname, File); - gtk_widget_destroy(FileSel); - - RunExecute(elfname); -} - -void OnRunElf_Cancel(GtkButton* button, gpointer user_data) { - gtk_widget_destroy(FileSel); -} - -void OnFile_LoadElf(GtkMenuItem *menuitem, gpointer user_data) { - GtkWidget *Ok,*Cancel; - - FileSel = gtk_file_selection_new("Select Psx Elf File"); - - Ok = GTK_FILE_SELECTION(FileSel)->ok_button; - gtk_signal_connect (GTK_OBJECT(Ok), "clicked", GTK_SIGNAL_FUNC(OnRunElf_Ok), NULL); - gtk_widget_show(Ok); - - Cancel = GTK_FILE_SELECTION(FileSel)->cancel_button; - gtk_signal_connect (GTK_OBJECT(Cancel), "clicked", GTK_SIGNAL_FUNC(OnRunElf_Cancel), NULL); - gtk_widget_show(Cancel); - - gtk_widget_show(FileSel); - gdk_window_raise(FileSel->window); -} -void pcsx2_exit() -{ - DIR *dir; - struct dirent *ent; - void *Handle; - char plugin[g_MaxPath]; - - // with this the problem with plugins that are linked with the pthread - // library is solved - - dir = opendir(Config.PluginsDir); - if (dir != NULL) { - while ((ent = readdir(dir)) != NULL) { - sprintf (plugin, "%s%s", Config.PluginsDir, ent->d_name); - - if (strstr(plugin, ".so") == NULL) continue; - Handle = dlopen(plugin, RTLD_NOW); - if (Handle == NULL) continue; - } - } - - printf("PCSX2 Quitting\n"); - - if (UseGui) - { - gtk_main_quit(); - SysClose(); - gtk_exit(0); - } - else - { - SysClose(); - exit(0); - } -} -void OnFile_Exit(GtkMenuItem *menuitem, gpointer user_data) -{ - pcsx2_exit(); -} - -void OnEmu_Run(GtkMenuItem *menuitem, gpointer user_data) -{ - if( g_EmulationInProgress ) - ExecuteCpu(); - else - RunExecute( NULL, true ); // boots bios if no savestate is to be recovered - -} - -void OnEmu_Reset(GtkMenuItem *menuitem, gpointer user_data) -{ - SysReset(); -} - - - void ResetMenuSlots(GtkMenuItem *menuitem, gpointer user_data) { - GtkWidget *Item; - char str[g_MaxPath]; - int i; - - for (i=0; i<5; i++) { - sprintf(str, "GtkMenuItem_LoadSlot%d", i+1); - Item = lookup_widget(MainWindow, str); - if (Slots[i] == -1) - gtk_widget_set_sensitive(Item, FALSE); - else - gtk_widget_set_sensitive(Item, TRUE); - } - } - -/*void UpdateMenuSlots(GtkMenuItem *menuitem, gpointer user_data) { - char str[g_MaxPath]; - int i = 0; - - for (i=0; i<5; i++) { - sprintf(str, SSTATES_DIR "/%8.8X.%3.3d", ElfCRC, i); - Slots[i] = CheckState(str); - } -}*/ - -void States_Load(string file, int num = -1 ) -{ - efile = 2; - try - { - // when we init joe it'll throw an UnsupportedStateVersion. - // So reset the cpu afterward so that trying to load a bum save - // doesn't fry the current emulation state. - gzLoadingState joe( file ); - - // Make sure the cpu and plugins are ready to be state-ified! - cpuReset(); - OpenPlugins( NULL ); - - joe.FreezeAll(); - } - catch( Exception::UnsupportedStateVersion& ) - { - if( num != -1 ) - Msgbox::Alert("Savestate slot %d is an unsupported version." , params num); - else - Msgbox::Alert( "%s : This is an unsupported savestate version." , params file.c_str()); - - // At this point the cpu hasn't been reset, so we can return - // control to the user safely... - - return; - } - catch( std::exception& ex ) - { - if (num != -1) - Console::Error("Error occured while trying to load savestate slot %d", params num); - else - Console::Error("Error occured while trying to load savestate file: %d", params file.c_str()); - - Console::Error( "%s", params ex.what() ); - - // The emulation state is ruined. Might as well give them a popup and start the gui. - - Msgbox::Alert( - "An error occured while trying to load the savestate data.\n" - "Pcsx2 emulation state has been reset." - ); - - cpuShutdown(); - return; - } - - ExecuteCpu(); -} - -void States_Load(int num) { - string Text; - - SaveState::GetFilename( Text, num ); - - struct stat buf; - if( stat(Text.c_str(), &buf ) == -1 ) - { - Console::Notice( "Saveslot %d is empty.", params num ); - return; - } - States_Load( Text, num ); -} - -void States_Save( string file, int num = -1 ) -{ - try - { - gzSavingState(file).FreezeAll(); - if( num != -1 ) - Console::Notice("State saved to slot %d", params num ); - else - Console::Notice( "State saved to file: %s", params file.c_str() ); - } - catch( std::exception& ex ) - { - if( num != -1 ) - Msgbox::Alert("An error occurred while trying to save to slot %d", params num ); - else - Msgbox::Alert("An error occurred while trying to save to file: %s", params file.c_str() ); - - Console::Error("Save state request failed with the following error:" ); - Console::Error( "%s", params ex.what() ); - } -} - -void States_Save(int num) { - string Text; - - SaveState::GetFilename( Text, num ); - States_Save( Text, num ); -} - -void OnStates_Load1(GtkMenuItem *menuitem, gpointer user_data) { States_Load(0); } -void OnStates_Load2(GtkMenuItem *menuitem, gpointer user_data) { States_Load(1); } -void OnStates_Load3(GtkMenuItem *menuitem, gpointer user_data) { States_Load(2); } -void OnStates_Load4(GtkMenuItem *menuitem, gpointer user_data) { States_Load(3); } -void OnStates_Load5(GtkMenuItem *menuitem, gpointer user_data) { States_Load(4); } - -void OnLoadOther_Ok(GtkButton* button, gpointer user_data) { - gchar *File; - char str[g_MaxPath]; - - File = (gchar*)gtk_file_selection_get_filename(GTK_FILE_SELECTION(FileSel)); - strcpy(str, File); - gtk_widget_destroy(FileSel); - - States_Load( str ); -} - -void OnLoadOther_Cancel(GtkButton* button, gpointer user_data) { - gtk_widget_destroy(FileSel); -} - -void OnStates_LoadOther(GtkMenuItem *menuitem, gpointer user_data) { - GtkWidget *Ok,*Cancel; - - FileSel = gtk_file_selection_new(_("Select State File")); - gtk_file_selection_set_filename(GTK_FILE_SELECTION(FileSel), SSTATES_DIR "/"); - - Ok = GTK_FILE_SELECTION(FileSel)->ok_button; - gtk_signal_connect (GTK_OBJECT(Ok), "clicked", GTK_SIGNAL_FUNC(OnLoadOther_Ok), NULL); - gtk_widget_show(Ok); - - Cancel = GTK_FILE_SELECTION(FileSel)->cancel_button; - gtk_signal_connect (GTK_OBJECT(Cancel), "clicked", GTK_SIGNAL_FUNC(OnLoadOther_Cancel), NULL); - gtk_widget_show(Cancel); - - gtk_widget_show(FileSel); - gdk_window_raise(FileSel->window); -} - -void OnStates_Save1(GtkMenuItem *menuitem, gpointer user_data) { States_Save(0); } -void OnStates_Save2(GtkMenuItem *menuitem, gpointer user_data) { States_Save(1); } -void OnStates_Save3(GtkMenuItem *menuitem, gpointer user_data) { States_Save(2); } -void OnStates_Save4(GtkMenuItem *menuitem, gpointer user_data) { States_Save(3); } -void OnStates_Save5(GtkMenuItem *menuitem, gpointer user_data) { States_Save(4); } - -void OnSaveOther_Ok(GtkButton* button, gpointer user_data) { - gchar *File; - char str[g_MaxPath]; - - File = (gchar*)gtk_file_selection_get_filename(GTK_FILE_SELECTION(FileSel)); - strcpy(str, File); - gtk_widget_destroy(FileSel); - - States_Save( str ); -} - -void OnSaveOther_Cancel(GtkButton* button, gpointer user_data) { - gtk_widget_destroy(FileSel); -} - -void OnStates_SaveOther(GtkMenuItem *menuitem, gpointer user_data) { - GtkWidget *Ok,*Cancel; - - FileSel = gtk_file_selection_new(_("Select State File")); - gtk_file_selection_set_filename(GTK_FILE_SELECTION(FileSel), SSTATES_DIR "/"); - - Ok = GTK_FILE_SELECTION(FileSel)->ok_button; - gtk_signal_connect (GTK_OBJECT(Ok), "clicked", GTK_SIGNAL_FUNC(OnSaveOther_Ok), NULL); - gtk_widget_show(Ok); - - Cancel = GTK_FILE_SELECTION(FileSel)->cancel_button; - gtk_signal_connect (GTK_OBJECT(Cancel), "clicked", GTK_SIGNAL_FUNC(OnSaveOther_Cancel), NULL); - gtk_widget_show(Cancel); - - gtk_widget_show(FileSel); - gdk_window_raise(FileSel->window); -} - -//2002-09-28 (Florin) -void OnArguments_Ok(GtkButton *button, gpointer user_data) { - char *str; - - str = (char*)gtk_entry_get_text(GTK_ENTRY(widgetCmdLine)); - memcpy(args, str, g_MaxPath); - - gtk_widget_destroy(CmdLine); - gtk_widget_set_sensitive(MainWindow, TRUE); - gtk_main_quit(); -} - -void OnEmu_Arguments(GtkMenuItem *menuitem, gpointer user_data) { - GtkWidget *widgetCmdLine; - - CmdLine = create_CmdLine(); - gtk_window_set_title(GTK_WINDOW(CmdLine), _("Program arguments")); - - widgetCmdLine = lookup_widget(CmdLine, "GtkEntry_dCMDLINE"); - - gtk_entry_set_text(GTK_ENTRY(widgetCmdLine), args); - gtk_widget_show_all(CmdLine); - gtk_widget_set_sensitive(MainWindow, FALSE); - gtk_main(); -} - -void OnCpu_Ok(GtkButton *button, gpointer user_data) { - u32 newopts = 0; - - //Cpu->Shutdown(); - //vu0Shutdown(); - //vu1Shutdown(); - - if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkCheckButton_EERec")))) - newopts |= PCSX2_EEREC; - if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkCheckButton_VU0rec")))) - newopts |= PCSX2_VU0REC; - if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkCheckButton_VU1rec")))) - newopts |= PCSX2_VU1REC; - if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkCheckButton_MTGS")))) - newopts |= PCSX2_GSMULTITHREAD; - if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkRadioButton_LimitNormal")))) - newopts |= PCSX2_FRAMELIMIT_NORMAL; - else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkRadioButton_LimitLimit")))) - newopts |= PCSX2_FRAMELIMIT_LIMIT; - else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkRadioButton_LimitFS")))) - newopts |= PCSX2_FRAMELIMIT_SKIP; - else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkRadioButton_VUSkip")))) - newopts |= PCSX2_FRAMELIMIT_VUSKIP; - - Config.CustomFps = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(lookup_widget(CpuDlg, "CustomFPSLimit"))); - Config.CustomFrameSkip = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(lookup_widget(CpuDlg, "FrameThreshold"))); - Config.CustomConsecutiveFrames = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(lookup_widget(CpuDlg, "FramesBeforeSkipping"))); - Config.CustomConsecutiveSkip = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(lookup_widget(CpuDlg, "FramesToSkip"))); - - if (Config.Options != newopts) - { - SysRestorableReset(); - - if ((Config.Options&PCSX2_GSMULTITHREAD) ^ (newopts&PCSX2_GSMULTITHREAD)) - { - // Need the MTGS setting to take effect, so close out the plugins: - PluginsResetGS(); - - if (CHECK_MULTIGS) - Console::Notice( "MTGS mode disabled.\n\tEnjoy the fruits of single-threaded simpicity." ); - else - Console::Notice( "MTGS mode enabled.\n\tWelcome to multi-threaded awesomeness. And random crashes." ); - } - - Config.Options = newopts; - } - else - UpdateVSyncRate(); - - SaveConfig(); - - gtk_widget_destroy(CpuDlg); - if (MainWindow) gtk_widget_set_sensitive(MainWindow, TRUE); - gtk_main_quit(); -} - -void OnConf_Cpu(GtkMenuItem *menuitem, gpointer user_data) -{ - char str[512]; - - CpuDlg = create_CpuDlg(); - gtk_window_set_title(GTK_WINDOW(CpuDlg), _("Configuration")); - - gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkCheckButton_EERec")), !!CHECK_EEREC); - gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkCheckButton_VU0rec")), !!CHECK_VU0REC); - gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkCheckButton_VU1rec")), !!CHECK_VU1REC); - gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkCheckButton_MTGS")), !!CHECK_MULTIGS); - gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkRadioButton_LimitNormal")), CHECK_FRAMELIMIT==PCSX2_FRAMELIMIT_NORMAL); - gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkRadioButton_LimitLimit")), CHECK_FRAMELIMIT==PCSX2_FRAMELIMIT_LIMIT); - gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkRadioButton_LimitFS")), CHECK_FRAMELIMIT==PCSX2_FRAMELIMIT_SKIP); - gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(lookup_widget(CpuDlg, "GtkRadioButton_VUSkip")), CHECK_FRAMELIMIT==PCSX2_FRAMELIMIT_VUSKIP); - - sprintf(str, "Cpu Vendor: %s", cpuinfo.x86ID); - gtk_label_set_text(GTK_LABEL(lookup_widget(CpuDlg, "GtkLabel_CpuVendor")), str); - sprintf(str, "Familly: %s", cpuinfo.x86Fam); - gtk_label_set_text(GTK_LABEL(lookup_widget(CpuDlg, "GtkLabel_Family")), str); - sprintf(str, "Cpu Speed: %d MHZ", cpuinfo.cpuspeed); - gtk_label_set_text(GTK_LABEL(lookup_widget(CpuDlg, "GtkLabel_CpuSpeed")), str); - - strcpy(str,"Features: "); - if(cpucaps.hasMultimediaExtensions) strcat(str,"MMX"); - if(cpucaps.hasStreamingSIMDExtensions) strcat(str,",SSE"); - if(cpucaps.hasStreamingSIMD2Extensions) strcat(str,",SSE2"); - if(cpucaps.hasStreamingSIMD3Extensions) strcat(str,",SSE3"); - if(cpucaps.hasAMD64BitArchitecture) strcat(str,",x86-64"); - gtk_label_set_text(GTK_LABEL(lookup_widget(CpuDlg, "GtkLabel_Features")), str); - - gtk_spin_button_set_value(GTK_SPIN_BUTTON(lookup_widget(CpuDlg, "CustomFPSLimit")), (gdouble)Config.CustomFps); - gtk_spin_button_set_value(GTK_SPIN_BUTTON(lookup_widget(CpuDlg, "FrameThreshold")), (gdouble)Config.CustomFrameSkip); - gtk_spin_button_set_value(GTK_SPIN_BUTTON(lookup_widget(CpuDlg, "FramesBeforeSkipping")), (gdouble)Config.CustomConsecutiveFrames); - gtk_spin_button_set_value(GTK_SPIN_BUTTON(lookup_widget(CpuDlg, "FramesToSkip")), (gdouble)Config.CustomConsecutiveSkip); - - gtk_widget_show_all(CpuDlg); - if (MainWindow) gtk_widget_set_sensitive(MainWindow, FALSE); - gtk_main(); -} - -void OnLogging_Ok(GtkButton *button, gpointer user_data) { -#ifdef PCSX2_DEVBUILD - GtkWidget *Btn; - char str[32]; - int i, ret; - - - for (i=0; i<32; i++) { - if (((i > 16) && (i < 20)) || (i == 29)) - continue; - - sprintf(str, "Log%d", i); - Btn = lookup_widget(LogDlg, str); - ret = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(Btn)); - if (ret) varLog|= 1< 16) && (i < 20)) || (i == 29)) - continue; - - sprintf(str, "Log%d", i); - Btn = lookup_widget(LogDlg, str); - gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(Btn), varLog & (1<> 13) - { - case 0: - set_checked(AdvDlg, "radio_EE_Round_Near", TRUE); - break; - case 1: - set_checked(AdvDlg, "radio_EE_Round_Negative",TRUE); - break; - case 2: - set_checked(AdvDlg, "radio_EE_Round_Positive", TRUE); - break; - case 3: - set_checked(AdvDlg, "radio_EE_Round_Zero", TRUE); - break; - } - - switch((Config.sseVUMXCSR & 0x6000) >> 13) - { - case 0: - set_checked(AdvDlg, "radio_VU_Round_Near", TRUE); - break; - case 1: - set_checked(AdvDlg, "radio_VU_Round_Negative",TRUE); - break; - case 2: - set_checked(AdvDlg, "radio_VU_Round_Positive", TRUE); - break; - case 3: - set_checked(AdvDlg, "radio_VU_Round_Zero", TRUE); - break; - } - - - switch(Config.eeOptions) - { - case FLAG_EE_CLAMP_NONE: - set_checked(AdvDlg, "radio_EE_Clamp_None", TRUE); - break; - case FLAG_EE_CLAMP_NORMAL: - set_checked(AdvDlg, "radio_EE_Clamp_Normal",TRUE); - break; - case FLAG_EE_CLAMP_EXTRA_PRESERVE: - set_checked(AdvDlg, "radio_EE_Clamp_Extra_Preserve", TRUE); - break; - } - - switch(Config.vuOptions) - { - case FLAG_VU_CLAMP_NONE: - set_checked(AdvDlg, "radio_VU_Clamp_None", TRUE); - break; - case FLAG_VU_CLAMP_NORMAL: - set_checked(AdvDlg, "radio_VU_Clamp_Normal",TRUE); - break; - case FLAG_VU_CLAMP_EXTRA: - set_checked(AdvDlg, "radio_VU_Clamp_Extra", TRUE); - break; - case FLAG_VU_CLAMP_EXTRA_PRESERVE: - set_checked(AdvDlg, "radio_VU_Clamp_Extra_Preserve", TRUE); - break; - } - set_checked(AdvDlg, "check_EE_Flush_Zero", (Config.sseMXCSR & FLAG_FLUSH_ZERO) ? TRUE : FALSE); - set_checked(AdvDlg, "check_EE_Denormal_Zero", (Config.sseMXCSR & FLAG_DENORMAL_ZERO) ? TRUE : FALSE); - - set_checked(AdvDlg, "check_VU_Flush_Zero", (Config.sseVUMXCSR & FLAG_FLUSH_ZERO) ? TRUE : FALSE); - set_checked(AdvDlg, "check_VU_Denormal_Zero", (Config.sseVUMXCSR & FLAG_DENORMAL_ZERO) ? TRUE : FALSE); -} -void on_Advanced(GtkMenuItem *menuitem, gpointer user_data) -{ - AdvDlg = create_AdvDlg(); - - setAdvancedOptions(); - - gtk_widget_show_all(AdvDlg); - gtk_widget_set_sensitive(MainWindow, FALSE); - gtk_main(); - } - -void on_Advanced_Defaults(GtkButton *button, gpointer user_data) -{ - Config.sseMXCSR = DEFAULT_sseMXCSR; - Config.sseVUMXCSR = DEFAULT_sseVUMXCSR; - Config.eeOptions = DEFAULT_eeOptions; - Config.vuOptions = DEFAULT_vuOptions; - - setAdvancedOptions(); - } - -void on_Advanced_OK(GtkButton *button, gpointer user_data) -{ - Config.sseMXCSR &= 0x1fbf; - Config.sseVUMXCSR &= 0x1fbf; - Config.eeOptions = 0; - Config.vuOptions = 0; - - Config.sseMXCSR |= is_checked(AdvDlg, "radio_EE_Round_Near") ? FLAG_ROUND_NEAR : 0; - Config.sseMXCSR |= is_checked(AdvDlg, "radio_EE_Round_Negative") ? FLAG_ROUND_NEGATIVE : 0; - Config.sseMXCSR |= is_checked(AdvDlg, "radio_EE_Round_Positive") ? FLAG_ROUND_POSITIVE : 0; - Config.sseMXCSR |= is_checked(AdvDlg, "radio_EE_Round_Zero") ? FLAG_ROUND_ZERO : 0; - - Config.sseMXCSR |= is_checked(AdvDlg, "check_EE_Denormal_Zero") ? FLAG_DENORMAL_ZERO : 0; - Config.sseMXCSR |= is_checked(AdvDlg, "check_EE_Flush_Zero") ? FLAG_FLUSH_ZERO : 0; - - Config.sseVUMXCSR |= is_checked(AdvDlg, "radio_VU_Round_Near") ? FLAG_ROUND_NEAR : 0; - Config.sseVUMXCSR |= is_checked(AdvDlg, "radio_VU_Round_Negative") ? FLAG_ROUND_NEGATIVE : 0; - Config.sseVUMXCSR |= is_checked(AdvDlg, "radio_VU_Round_Positive") ? FLAG_ROUND_POSITIVE : 0; - Config.sseVUMXCSR |= is_checked(AdvDlg, "radio_VU_Round_Zero") ? FLAG_ROUND_ZERO : 0; - - Config.sseVUMXCSR |= is_checked(AdvDlg, "check_VU_Denormal_Zero") ? FLAG_DENORMAL_ZERO : 0; - Config.sseVUMXCSR |= is_checked(AdvDlg, "check_VU_Flush_Zero") ? FLAG_FLUSH_ZERO : 0; - - Config.eeOptions |= is_checked(AdvDlg, "radio_EE_Clamp_None") ? FLAG_EE_CLAMP_NONE : 0; - Config.eeOptions |= is_checked(AdvDlg, "radio_EE_Clamp_Normal") ? FLAG_EE_CLAMP_NORMAL : 0; - Config.eeOptions |= is_checked(AdvDlg, "radio_EE_Clamp_Extra_Preserve") ? FLAG_EE_CLAMP_EXTRA_PRESERVE : 0; - - Config.vuOptions |= is_checked(AdvDlg, "radio_VU_Clamp_None") ? FLAG_VU_CLAMP_NONE : 0; - Config.vuOptions |= is_checked(AdvDlg, "radio_VU_Clamp_Normal") ? FLAG_VU_CLAMP_NORMAL : 0; - Config.vuOptions |= is_checked(AdvDlg, "radio_VU_Clamp_Extra") ? FLAG_VU_CLAMP_EXTRA : 0; - Config.vuOptions |= is_checked(AdvDlg, "radio_VU_Clamp_Extra_Preserve") ? FLAG_VU_CLAMP_EXTRA_PRESERVE : 0; - - SetCPUState(Config.sseMXCSR, Config.sseVUMXCSR); - SaveConfig(); - - gtk_widget_destroy(AdvDlg); - gtk_widget_set_sensitive(MainWindow, TRUE); - gtk_main_quit(); -} diff --git a/pcsx2/Linux/GtkGui.h b/pcsx2/Linux/GtkGui.h deleted file mode 100644 index 395a3867ac..0000000000 --- a/pcsx2/Linux/GtkGui.h +++ /dev/null @@ -1,83 +0,0 @@ -/* Pcsx2 - Pc Ps2 Emulator - * Copyright (C) 2002-2008 Pcsx2 Team - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA - */ - - #ifndef __GTKGUI_H__ -#define __GTKGUI_H__ - - -#include "PrecompiledHeader.h" -#include "Linux.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#include "support.h" -#include "callbacks.h" -#include "interface.h" - -#ifdef __cplusplus -} -#endif - -bool applychanges = FALSE; -bool configuringplug = FALSE; -bool UseGui = TRUE; - - MemoryAlloc* g_RecoveryState = NULL; -bool g_GameInProgress = false; // Set TRUE if a game is actively running. - -//static bool AccBreak = false; -static bool m_ReturnToGame = false; // set to exit the RunGui message pump - - -int efile = 0; -char elfname[g_MaxPath]; -int Slots[5] = { -1, -1, -1, -1, -1 }; - -GtkWidget *CpuDlg; - -// Functions Callbacks -void OnFile_LoadElf(GtkMenuItem *menuitem, gpointer user_data); -void OnFile_Exit(GtkMenuItem *menuitem, gpointer user_data); -void OnEmu_Run(GtkMenuItem *menuitem, gpointer user_data); -void OnEmu_Reset(GtkMenuItem *menuitem, gpointer user_data); -void OnEmu_Arguments(GtkMenuItem *menuitem, gpointer user_data); -void OnLanguage(GtkMenuItem *menuitem, gpointer user_data); -void OnHelp_Help(); -void OnHelp_About(GtkMenuItem *menuitem, gpointer user_data); -void ExecuteCpu(); - -void StartGui(); -void pcsx2_exit(); -GtkWidget *MainWindow; -GtkWidget *pStatusBar = NULL, *Status_Box; -GtkWidget *CmdLine; //2002-09-28 (Florin) -GtkWidget *widgetCmdLine; -GtkWidget *LogDlg; -GtkWidget *FileSel; -GtkWidget *AboutDlg, *about_version , *about_authors, *about_greets; - -void init_widgets(); - -GtkAccelGroup *AccelGroup; - -GtkWidget *GameFixDlg, *SpeedHacksDlg, *AdvDlg; - -#endif - diff --git a/pcsx2/Linux/HacksDlg.cpp b/pcsx2/Linux/HacksDlg.cpp new file mode 100644 index 0000000000..57ef8860e2 --- /dev/null +++ b/pcsx2/Linux/HacksDlg.cpp @@ -0,0 +1,104 @@ +/* Pcsx2 - Pc Ps2 Emulator + * Copyright (C) 2002-2008 Pcsx2 Team + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + + #include "Linux.h" + +GtkWidget *GameFixDlg, *SpeedHacksDlg; + + void on_Game_Fixes(GtkMenuItem *menuitem, gpointer user_data) +{ + GameFixDlg = create_GameFixDlg(); + + set_checked(GameFixDlg, "check_VU_Add_Sub", (Config.GameFixes & FLAG_VU_ADD_SUB)); + set_checked(GameFixDlg, "check_FPU_Clamp", (Config.GameFixes & FLAG_FPU_CLAMP)); + set_checked(GameFixDlg, "check_VU_Branch", (Config.GameFixes & FLAG_VU_BRANCH)); + + gtk_widget_show_all(GameFixDlg); + gtk_widget_set_sensitive(MainWindow, FALSE); + gtk_main(); +} + +void on_Game_Fix_OK(GtkButton *button, gpointer user_data) +{ + + Config.GameFixes = 0; + Config.GameFixes |= is_checked(GameFixDlg, "check_VU_Add_Sub") ? FLAG_VU_ADD_SUB : 0; + Config.GameFixes |= is_checked(GameFixDlg, "check_FPU_Clamp") ? FLAG_FPU_CLAMP : 0; + Config.GameFixes |= is_checked(GameFixDlg, "check_VU_Branch") ? FLAG_VU_BRANCH : 0; + + SaveConfig(); + gtk_widget_destroy(GameFixDlg); + gtk_widget_set_sensitive(MainWindow, TRUE); + gtk_main_quit(); +} + +void on_Speed_Hacks(GtkMenuItem *menuitem, gpointer user_data) +{ + SpeedHacksDlg = create_SpeedHacksDlg(); + + switch (CHECK_EE_CYCLERATE) + { + case 0: + set_checked(SpeedHacksDlg, "check_default_cycle_rate", true); + break; + case 1: + set_checked(SpeedHacksDlg, "check_1_5_cycle_rate", true); + break; + case 2: + set_checked(SpeedHacksDlg, "check_2_cycle_rate", true); + break; + case 3: + set_checked(SpeedHacksDlg, "check_3_cycle_rate", true); + break; + default: + set_checked(SpeedHacksDlg, "check_default_cycle_rate", true); + break; + } + + set_checked(SpeedHacksDlg, "check_iop_cycle_rate", CHECK_IOP_CYCLERATE); + set_checked(SpeedHacksDlg, "check_wait_cycles_sync_hack", CHECK_WAITCYCLE_HACK); + set_checked(SpeedHacksDlg, "check_ESC_hack", CHECK_ESCAPE_HACK); + + gtk_widget_show_all(SpeedHacksDlg); + gtk_widget_set_sensitive(MainWindow, FALSE); + gtk_main(); +} + +void on_Speed_Hack_OK(GtkButton *button, gpointer user_data) +{ + Config.Hacks = 0; + + if is_checked(SpeedHacksDlg, "check_default_cycle_rate") + Config.Hacks = 0; + else if is_checked(SpeedHacksDlg, "check_1_5_cycle_rate") + Config.Hacks = 1; + else if is_checked(SpeedHacksDlg, "check_2_cycle_rate") + Config.Hacks = 2; + else if is_checked(SpeedHacksDlg, "check_3_cycle_rate") + Config.Hacks = 3; + + Config.Hacks |= is_checked(SpeedHacksDlg, "check_iop_cycle_rate") << 3; + Config.Hacks |= is_checked(SpeedHacksDlg, "check_wait_cycles_sync_hack") << 4; + Config.Hacks |= is_checked(SpeedHacksDlg, "check_ESC_hack") << 10; + + SaveConfig(); + + gtk_widget_destroy(SpeedHacksDlg); + gtk_widget_set_sensitive(MainWindow, TRUE); + gtk_main_quit(); +} diff --git a/pcsx2/Linux/Linux.h b/pcsx2/Linux/Linux.h index a8b11759d3..83a981b654 100644 --- a/pcsx2/Linux/Linux.h +++ b/pcsx2/Linux/Linux.h @@ -19,7 +19,7 @@ #ifndef __LINUX_H__ #define __LINUX_H__ -#include +#include #include #include #include @@ -35,7 +35,7 @@ #include -#include +#include #include #include @@ -54,19 +54,31 @@ #include "x86/ix86/ix86.h" #include "x86/iR5900.h" + #ifdef __cplusplus +extern "C" +{ +#endif + +#include "support.h" +#include "callbacks.h" +#include "interface.h" + +#ifdef __cplusplus +} +#endif + /* Misc.c */ extern void vu0Shutdown(); extern void vu1Shutdown(); extern void SaveConfig(); extern bool UseGui; - + extern int efile; extern int g_SaveGSStream; extern int g_ZeroGSOptions; extern void FixCPUState(void); - -/* LnxMain */ + extern void InitLanguages(); extern char *GetLanguageNext(); extern void CloseLanguages(); @@ -75,24 +87,23 @@ extern void StartGui(); extern void RunGui(); extern int Pcsx2Configure(); extern GtkWidget *CpuDlg; -extern void SysMessage(const char *fmt, ...); -/* Config.c */ extern int LoadConfig(); extern void SaveConfig(); -/* GtkGui */ extern void init_widgets(); extern MemoryAlloc* g_RecoveryState; extern void SysRestorableReset(); extern void SysDetect(); -extern void RunExecute( const char* elf_file, bool use_bios = false); +void SignalExit(int sig); +extern void RunExecute(const char* elf_file, bool use_bios = false); extern void ExecuteCpu(); extern bool g_ReturnToGui; // set to exit the execution of the emulator and return control to the GUI extern bool g_EmulationInProgress; // Set TRUE if a game is actively running (set to false on reset) -typedef struct { +typedef struct +{ char lang[g_MaxPath]; } _langs; @@ -127,7 +138,7 @@ char cfgfile[g_MaxPath]; int Config_hacks_backup; -#define is_checked(main_widget, widget_name) (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lookup_widget(main_widget, widget_name)))) +#define is_checked(main_widget, widget_name) (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lookup_widget(main_widget, widget_name)))) #define set_checked(main_widget,widget_name, state) gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(lookup_widget(main_widget, widget_name)), state) #define set_flag(v, flag, value) if (value == TRUE) v |= flag; else v &= flag; @@ -136,22 +147,23 @@ int Config_hacks_backup; /*static __forceinline void print_flags(char *name, u32 num, char *flag_names[16]) { int i; - + DevCon::WriteLn("%s:", name); - + if (flag_names != NULL) { for(i=0; i<=15; i++) DevCon::WriteLn("%s %x: %x", params flag_names[i], (1< -#include - #include "LnxMain.h" using namespace R5900; DIR *dir; +GtkWidget *FileSel; #ifdef PCSX2_DEVBUILD TESTRUNARGS g_TestRun; @@ -31,14 +29,8 @@ TESTRUNARGS g_TestRun; GtkWidget *MsgDlg; -static int sinit=0; - -// These two status vars replace the old g_GameInProgress status var. - -bool g_ReturnToGui = false; // set to exit the execution of the emulator and return control to the GUI -bool g_EmulationInProgress = false; // Set TRUE if a game is actively running (set to false on reset) - -int main(int argc, char *argv[]) { +int main(int argc, char *argv[]) +{ char *file = NULL; char elfname[g_MaxPath]; int i = 1; @@ -59,79 +51,101 @@ int main(int argc, char *argv[]) { memset(&g_TestRun, 0, sizeof(g_TestRun)); #endif - while(i < argc) { + while (i < argc) + { char* token = argv[i++]; - if( stricmp(token, "-help") == 0 || stricmp(token, "--help") == 0 || stricmp(token, "-h") == 0 ) { + if (stricmp(token, "-help") == 0 || stricmp(token, "--help") == 0 || stricmp(token, "-h") == 0) + { //Msgbox::Alert( phelpmsg ); return 0; } - else if( stricmp(token, "-efile") == 0 ) { + else if (stricmp(token, "-efile") == 0) + { token = argv[i++]; - if( token != NULL ) { + if (token != NULL) + { efile = atoi(token); } } - else if( stricmp(token, "-nogui") == 0 ) { + else if (stricmp(token, "-nogui") == 0) + { UseGui = FALSE; } - else if( stricmp(token, "-loadgs") == 0 ) { + else if (stricmp(token, "-loadgs") == 0) + { g_pRunGSState = argv[i++]; } #ifdef PCSX2_DEVBUILD - else if( stricmp(token, "-image") == 0 ) { + else if (stricmp(token, "-image") == 0) + { g_TestRun.pimagename = argv[i++]; } - else if( stricmp(token, "-log") == 0 ) { + else if (stricmp(token, "-log") == 0) + { g_TestRun.plogname = argv[i++]; } - else if( stricmp(token, "-logopt") == 0 ) { + else if (stricmp(token, "-logopt") == 0) + { token = argv[i++]; - if( token != NULL ) { - if( token[0] == '0' && token[1] == 'x' ) token += 2; + if (token != NULL) + { + if (token[0] == '0' && token[1] == 'x') token += 2; sscanf(token, "%x", &varLog); } } - else if( stricmp(token, "-frame") == 0 ) { + else if (stricmp(token, "-frame") == 0) + { token = argv[i++]; - if( token != NULL ) { + if (token != NULL) + { g_TestRun.frame = atoi(token); } } - else if( stricmp(token, "-numimages") == 0 ) { + else if (stricmp(token, "-numimages") == 0) + { token = argv[i++]; - if( token != NULL ) { + if (token != NULL) + { g_TestRun.numimages = atoi(token); } } - else if( stricmp(token, "-jpg") == 0 ) { + else if (stricmp(token, "-jpg") == 0) + { g_TestRun.jpgcapture = 1; } - else if( stricmp(token, "-gs") == 0 ) { + else if (stricmp(token, "-gs") == 0) + { token = argv[i++]; g_TestRun.pgsdll = token; } - else if( stricmp(token, "-cdvd") == 0 ) { + else if (stricmp(token, "-cdvd") == 0) + { token = argv[i++]; g_TestRun.pcdvddll = token; } - else if( stricmp(token, "-spu") == 0 ) { + else if (stricmp(token, "-spu") == 0) + { token = argv[i++]; g_TestRun.pspudll = token; } - else if( stricmp(token, "-test") == 0 ) { + else if (stricmp(token, "-test") == 0) + { g_TestRun.enabled = 1; } #endif - else if( stricmp(token, "-pad") == 0 ) { + else if (stricmp(token, "-pad") == 0) + { token = argv[i++]; printf("-pad ignored\n"); } - else if( stricmp(token, "-loadgs") == 0 ) { + else if (stricmp(token, "-loadgs") == 0) + { token = argv[i++]; g_pRunGSState = token; } - else { + else + { file = token; printf("opening file %s\n", file); } @@ -143,16 +157,19 @@ int main(int argc, char *argv[]) { #endif // make gtk thread safe if using MTGS - if( CHECK_MULTIGS ) { + if (CHECK_MULTIGS) + { g_thread_init(NULL); gdk_threads_init(); } - if (UseGui) { + if (UseGui) + { gtk_init(NULL, NULL); } - - if (LoadConfig() == -1) { + + if (LoadConfig() == -1) + { memset(&Config, 0, sizeof(Config)); strcpy(Config.BiosDir, DEFAULT_BIOS_DIR "/"); @@ -168,9 +185,10 @@ int main(int argc, char *argv[]) { return 0; } - InitLanguages(); - - if( Config.PsxOut ) { + InitLanguages(); + + if (Config.PsxOut) + { // output the help commands Console::WriteLn("\tF1 - save state"); Console::WriteLn("\t(Shift +) F2 - cycle states"); @@ -186,14 +204,16 @@ int main(int argc, char *argv[]) { if (!SysInit()) return 1; #ifdef PCSX2_DEVBUILD - if( g_pRunGSState ) { + if (g_pRunGSState) + { LoadGSState(g_pRunGSState); SysClose(); return 0; } #endif - if (UseGui && (file == NULL)) { + if (UseGui && (file == NULL)) + { StartGui(); return 0; } @@ -205,7 +225,7 @@ int main(int argc, char *argv[]) { FixCPUState(); cpuExecuteBios(); if (file) strcpy(elfname, file); - if (!efile) efile=GetPS2ElfName(elfname); + if (!efile) efile = GetPS2ElfName(elfname); loadElfFile(elfname); ExecuteCpu(); @@ -213,33 +233,38 @@ int main(int argc, char *argv[]) { return 0; } -void InitLanguages() { +void InitLanguages() +{ char *lang; int i = 1; - - if (Config.Lang[0] == 0) { + + if (Config.Lang[0] == 0) + { strcpy(Config.Lang, "en"); } langs = (_langs*)malloc(sizeof(_langs)); strcpy(langs[0].lang, "en"); dir = opendir(LANGS_DIR); - - while ((lang = GetLanguageNext()) != NULL) { - langs = (_langs*)realloc(langs, sizeof(_langs)*(i+1)); + + while ((lang = GetLanguageNext()) != NULL) + { + langs = (_langs*)realloc(langs, sizeof(_langs) * (i + 1)); strcpy(langs[i].lang, lang); i++; } - + CloseLanguages(); langsMax = i; } -char *GetLanguageNext() { +char *GetLanguageNext() +{ struct dirent *ent; if (dir == NULL) return NULL; - for (;;) { + for (;;) + { ent = readdir(dir); if (ent == NULL) return NULL; @@ -251,251 +276,354 @@ char *GetLanguageNext() { return ent->d_name; } -void CloseLanguages() { +void CloseLanguages() +{ if (dir) closedir(dir); } -void ChangeLanguage(char *lang) { - strcpy(Config.Lang, lang); +void ChangeLanguage(char *lang) +{ + strcpy(Config.Lang, lang); SaveConfig(); } -/* Quick macros for checking shift, control, alt, and caps lock. */ -#define SHIFT_EVT(evt) ((evt == XK_Shift_L) || (evt == XK_Shift_R)) -#define CTRL_EVT(evt) ((evt == XK_Control_L) || (evt == XK_Control_L)) -#define ALT_EVT(evt) ((evt == XK_Alt_L) || (evt == XK_Alt_R)) -#define CAPS_LOCK_EVT(evt) (evt == XK_Caps_Lock) - -void KeyEvent(keyEvent* ev) { - static int shift = 0; - - if (ev == NULL) return; - - if( GSkeyEvent != NULL ) GSkeyEvent(ev); - - if (ev->evt == KEYPRESS) - { - if (SHIFT_EVT(ev->key)) - shift = 1; - if (CAPS_LOCK_EVT(ev->key)) - { - //Set up anything we want to happen while caps lock is down. - //Config_hacks_backup = Config.Hacks; - } - - switch (ev->key) - { - case XK_F1: case XK_F2: case XK_F3: case XK_F4: - case XK_F5: case XK_F6: case XK_F7: case XK_F8: - case XK_F9: case XK_F10: case XK_F11: case XK_F12: - try - { - ProcessFKeys(ev->key-XK_F1 + 1, shift); - } - catch( Exception::CpuStateShutdown& ) - { - // Woops! Something was unrecoverable. Bummer. - // Let's give the user a RunGui! - - g_EmulationInProgress = false; - g_ReturnToGui = true; - } - break; - - case XK_Escape: - signal(SIGINT, SIG_DFL); - signal(SIGPIPE, SIG_DFL); - - #ifdef PCSX2_DEVBUILD - if( g_SaveGSStream >= 3 ) { - g_SaveGSStream = 4;// gs state - break; - } - #endif - - ClosePlugins(); - if (!UseGui) exit(0); - - // fixme: The GUI is now capable of recieving control back from the - // emulator. Which means that when I set g_ReturnToGui here, the emulation - // loop in ExecuteCpu() will exit. You should be able to set it up so - // that it returns control to the existing GTK event loop, instead of - // always starting a new one via RunGui(). (but could take some trial and - // error) -- (air) - g_ReturnToGui = true; - RunGui(); - break; - - default: - GSkeyEvent(ev); - break; - } - } - else if (ev->evt == KEYRELEASE) - { - if (SHIFT_EVT(ev->key)) - shift = 0; - if (CAPS_LOCK_EVT(ev->key)) - { - //Release caps lock - //Config_hacks_backup = Config.Hacks; - } - } - - return; -} - -void OnMsg_Ok() { +void OnMsg_Ok() +{ gtk_widget_destroy(MsgDlg); gtk_main_quit(); } -void SysMessage(const char *fmt, ...) { - va_list list; - char msg[512]; - va_start(list,fmt); - vsnprintf(msg,511,fmt,list); - msg[511] = '\0'; - va_end(list); - - Msgbox::Alert(msg); +void On_Dialog_Cancelled(GtkButton* button, gpointer user_data) +{ + gtk_widget_destroy((GtkWidget*)gtk_widget_get_toplevel((GtkWidget*)button)); + gtk_widget_set_sensitive(MainWindow, TRUE); + gtk_main_quit(); } -bool SysInit() +void StartGui() { - if( sinit ) return true; - sinit = true; - - mkdir(SSTATES_DIR, 0755); - mkdir(MEMCARDS_DIR, 0755); + GtkWidget *Menu; + GtkWidget *Item; - mkdir(LOGS_DIR, 0755); + u32 i; -#ifdef PCSX2_DEVBUILD - if( g_TestRun.plogname != NULL ) - emuLog = fopen(g_TestRun.plogname, "w"); - if( emuLog == NULL ) - emuLog = fopen(LOGS_DIR "/emuLog.txt","wb"); + add_pixmap_directory(".pixmaps"); + MainWindow = create_MainWindow(); + + if (SVN_REV != 0) + gtk_window_set_title(GTK_WINDOW(MainWindow), "PCSX2 "PCSX2_VERSION" "SVN_REV); + else + gtk_window_set_title(GTK_WINDOW(MainWindow), "PCSX2 "PCSX2_VERSION); + + // status bar + pStatusBar = gtk_statusbar_new(); + gtk_box_pack_start(GTK_BOX(lookup_widget(MainWindow, "status_box")), pStatusBar, TRUE, TRUE, 0); + gtk_widget_show(pStatusBar); + + gtk_statusbar_push(GTK_STATUSBAR(pStatusBar), 0, + "F1 - save, F2 - next state, Shift+F2 - prev state, F3 - load, F8 - snapshot"); + + // add all the languages + Item = lookup_widget(MainWindow, "GtkMenuItem_Language"); + Menu = gtk_menu_new(); + gtk_menu_item_set_submenu(GTK_MENU_ITEM(Item), Menu); + + for (i = 0; i < langsMax; i++) + { + Item = gtk_check_menu_item_new_with_label(ParseLang(langs[i].lang)); + gtk_widget_show(Item); + gtk_container_add(GTK_CONTAINER(Menu), Item); + gtk_check_menu_item_set_show_toggle(GTK_CHECK_MENU_ITEM(Item), TRUE); + if (!strcmp(Config.Lang, langs[i].lang)) + gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(Item), TRUE); + + gtk_signal_connect(GTK_OBJECT(Item), "activate", + GTK_SIGNAL_FUNC(OnLanguage), + (gpointer)(uptr)i); + } + + // check the appropriate menu items + gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(lookup_widget(MainWindow, "enable_console1")), Config.PsxOut); + gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(lookup_widget(MainWindow, "enable_patches1")), Config.Patch); + + // disable anything not implemented or not working properly. + gtk_widget_set_sensitive(GTK_WIDGET(lookup_widget(MainWindow, "patch_browser1")), FALSE); + gtk_widget_set_sensitive(GTK_WIDGET(lookup_widget(MainWindow, "patch_finder2")), FALSE); +#ifndef PCSX2_DEVBUILD + gtk_widget_set_sensitive(GTK_WIDGET(lookup_widget(MainWindow, "GtkMenuItem_Logging")), FALSE); #endif - if( emuLog != NULL ) - setvbuf(emuLog, NULL, _IONBF, 0); + gtk_widget_show_all(MainWindow); + gtk_window_activate_focus(GTK_WINDOW(MainWindow)); + gtk_main(); +} - PCSX2_MEM_PROTECT_BEGIN(); - SysDetect(); - if( !SysAllocateMem() ) - return false; // critical memory allocation failure; +void RunGui() +{ + StartGui(); +} - SysAllocateDynarecs(); - PCSX2_MEM_PROTECT_END(); +void FixCPUState(void) +{ + //Config.sseMXCSR = LinuxsseMXCSR; + //Config.sseVUMXCSR = LinuxsseVUMXCSR; + SetCPUState(Config.sseMXCSR, Config.sseVUMXCSR); +} - while (LoadPlugins() == -1) { - if (Pcsx2Configure() == FALSE) +void OnDestroy(GtkObject *object, gpointer user_data) {} + +gboolean OnDelete(GtkWidget *widget, GdkEvent *event, gpointer user_data) +{ + pcsx2_exit(); + return (FALSE); +} +int Pcsx2Configure() +{ + if (!UseGui) return 0; + + configuringplug = TRUE; + MainWindow = NULL; + OnConf_Conf(NULL, 0); + configuringplug = FALSE; + + return applychanges; +} + +void OnLanguage(GtkMenuItem *menuitem, gpointer user_data) +{ + ChangeLanguage(langs[(int)(uptr)user_data].lang); + gtk_widget_destroy(MainWindow); + gtk_main_quit(); + while (gtk_events_pending()) gtk_main_iteration(); + StartGui(); +} + +void OnFile_RunCD(GtkMenuItem *menuitem, gpointer user_data) +{ + safe_free(g_RecoveryState); + ResetPlugins(); + RunExecute(NULL); +} + +void OnRunElf_Ok(GtkButton* button, gpointer user_data) +{ + gchar *File; + + File = (gchar*)gtk_file_selection_get_filename(GTK_FILE_SELECTION(FileSel)); + strcpy(elfname, File); + gtk_widget_destroy(FileSel); + + RunExecute(elfname); +} + +void OnRunElf_Cancel(GtkButton* button, gpointer user_data) +{ + gtk_widget_destroy(FileSel); +} + +void OnFile_LoadElf(GtkMenuItem *menuitem, gpointer user_data) +{ + GtkWidget *Ok, *Cancel; + + FileSel = gtk_file_selection_new("Select Psx Elf File"); + + Ok = GTK_FILE_SELECTION(FileSel)->ok_button; + gtk_signal_connect(GTK_OBJECT(Ok), "clicked", GTK_SIGNAL_FUNC(OnRunElf_Ok), NULL); + gtk_widget_show(Ok); + + Cancel = GTK_FILE_SELECTION(FileSel)->cancel_button; + gtk_signal_connect(GTK_OBJECT(Cancel), "clicked", GTK_SIGNAL_FUNC(OnRunElf_Cancel), NULL); + gtk_widget_show(Cancel); + + gtk_widget_show(FileSel); + gdk_window_raise(FileSel->window); +} + +void pcsx2_exit() +{ + DIR *dir; + struct dirent *ent; + void *Handle; + char plugin[g_MaxPath]; + + // with this the problem with plugins that are linked with the pthread + // library is solved + + dir = opendir(Config.PluginsDir); + if (dir != NULL) + { + while ((ent = readdir(dir)) != NULL) { - Msgbox::Alert("Configuration failed. Exiting."); - exit(1); + sprintf(plugin, "%s%s", Config.PluginsDir, ent->d_name); + + if (strstr(plugin, ".so") == NULL) continue; + Handle = dlopen(plugin, RTLD_NOW); + if (Handle == NULL) continue; } } - - return true; -} -void SysRestorableReset() -{ - // already reset? and saved? - if( !g_EmulationInProgress ) return; - if( g_RecoveryState != NULL ) return; + printf("PCSX2 Quitting\n"); - try + if (UseGui) { - g_RecoveryState = new MemoryAlloc( "Memory Savestate Recovery" ); - memSavingState( *g_RecoveryState ).FreezeAll(); - cpuShutdown(); - g_EmulationInProgress = false; + gtk_main_quit(); + SysClose(); + gtk_exit(0); } - catch( Exception::RuntimeError& ex ) + else { - Msgbox::Alert( - "Pcsx2 gamestate recovery failed. Some options may have been reverted to protect your game's state.\n" - "Error: %s", params ex.cMessage() ); - safe_delete( g_RecoveryState ); + SysClose(); + exit(0); } } -void SysReset() +void SignalExit(int sig) { - if (!sinit) return; - - g_EmulationInProgress = false; - safe_free( g_RecoveryState ); - - ResetPlugins(); - - ElfCRC = 0; -} - -void SysClose() { - if (sinit == 0) return; - cpuShutdown(); ClosePlugins(); - ReleasePlugins(); + pcsx2_exit(); +} - if (emuLog != NULL) +void OnFile_Exit(GtkMenuItem *menuitem, gpointer user_data) +{ + pcsx2_exit(); +} + +void OnEmu_Run(GtkMenuItem *menuitem, gpointer user_data) +{ + if (g_EmulationInProgress) + ExecuteCpu(); + else + RunExecute(NULL, true); // boots bios if no savestate is to be recovered + +} + +void OnEmu_Reset(GtkMenuItem *menuitem, gpointer user_data) +{ + SysReset(); +} + + +void ResetMenuSlots(GtkMenuItem *menuitem, gpointer user_data) +{ + GtkWidget *Item; + char str[g_MaxPath]; + int i; + + for (i = 0; i < 5; i++) { - fclose(emuLog); - emuLog = NULL; + sprintf(str, "GtkMenuItem_LoadSlot%d", i + 1); + Item = lookup_widget(MainWindow, str); + if (Slots[i] == -1) + gtk_widget_set_sensitive(Item, FALSE); + else + gtk_widget_set_sensitive(Item, TRUE); } - sinit=0; } -void SysPrintf(const char *fmt, ...) { - va_list list; - char msg[512]; +/*void UpdateMenuSlots(GtkMenuItem *menuitem, gpointer user_data) { + char str[g_MaxPath]; + int i = 0; - va_start(list,fmt); - vsnprintf(msg,511,fmt,list); - msg[511] = '\0'; - va_end(list); + for (i=0; i<5; i++) { + sprintf(str, SSTATES_DIR "/%8.8X.%3.3d", ElfCRC, i); + Slots[i] = CheckState(str); + } +}*/ - Console::Write( msg ); -} - -void *SysLoadLibrary(const char *lib) { - return dlopen(lib, RTLD_NOW); -} - -void *SysLoadSym(void *lib, const char *sym) { - return dlsym(lib, sym); -} - -const char *SysLibError() { - return dlerror(); -} - -void SysCloseLibrary(void *lib) { - dlclose(lib); -} - -void SysUpdate() { - KeyEvent(PAD1keyEvent()); - KeyEvent(PAD2keyEvent()); -} - -void SysRunGui() { - RunGui(); -} - -void *SysMmap(uptr base, u32 size) +//2002-09-28 (Florin) +void OnArguments_Ok(GtkButton *button, gpointer user_data) { - u8 *Mem; - Mem = mmap((uptr*)base, size, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0); - if (Mem == MAP_FAILED) Console::Notice("Mmap Failed!"); - - return Mem; + char *str; + + str = (char*)gtk_entry_get_text(GTK_ENTRY(widgetCmdLine)); + memcpy(args, str, g_MaxPath); + + gtk_widget_destroy(CmdLine); + gtk_widget_set_sensitive(MainWindow, TRUE); + gtk_main_quit(); } -void SysMunmap(uptr base, u32 size) +void OnEmu_Arguments(GtkMenuItem *menuitem, gpointer user_data) { - munmap((uptr*)base, size); + GtkWidget *widgetCmdLine; + + CmdLine = create_CmdLine(); + gtk_window_set_title(GTK_WINDOW(CmdLine), _("Program arguments")); + + widgetCmdLine = lookup_widget(CmdLine, "GtkEntry_dCMDLINE"); + + gtk_entry_set_text(GTK_ENTRY(widgetCmdLine), args); + gtk_widget_show_all(CmdLine); + gtk_widget_set_sensitive(MainWindow, FALSE); + gtk_main(); } + +void OnLogging_Ok(GtkButton *button, gpointer user_data) +{ +#ifdef PCSX2_DEVBUILD + GtkWidget *Btn; + char str[32]; + int i, ret; + + + for (i = 0; i < 32; i++) + { + if (((i > 16) && (i < 20)) || (i == 29)) + continue; + + sprintf(str, "Log%d", i); + Btn = lookup_widget(LogDlg, str); + ret = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(Btn)); + if (ret) varLog |= 1 << i; + else varLog &= ~(1 << i); + } + + SaveConfig(); +#endif + + gtk_widget_destroy(LogDlg); + gtk_widget_set_sensitive(MainWindow, TRUE); + gtk_main_quit(); +} + +void OnDebug_Logging(GtkMenuItem *menuitem, gpointer user_data) +{ + GtkWidget *Btn; + char str[32]; + int i; + + LogDlg = create_Logging(); + + + for (i = 0; i < 32; i++) + { + if (((i > 16) && (i < 20)) || (i == 29)) + continue; + + sprintf(str, "Log%d", i); + Btn = lookup_widget(LogDlg, str); + gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(Btn), varLog & (1 << i)); + } + + gtk_widget_show_all(LogDlg); + gtk_widget_set_sensitive(MainWindow, FALSE); + gtk_main(); +} + +void on_patch_browser1_activate(GtkMenuItem *menuitem, gpointer user_data) {} + +void on_patch_finder2_activate(GtkMenuItem *menuitem, gpointer user_data) {} + +void on_enable_console1_activate(GtkMenuItem *menuitem, gpointer user_data) +{ + Config.PsxOut = (int)gtk_check_menu_item_get_active((GtkCheckMenuItem*)menuitem); + SaveConfig(); +} + +void on_enable_patches1_activate(GtkMenuItem *menuitem, gpointer user_data) +{ + Config.Patch = (int)gtk_check_menu_item_get_active((GtkCheckMenuItem*)menuitem); + SaveConfig(); +} + diff --git a/pcsx2/Linux/LnxMain.h b/pcsx2/Linux/LnxMain.h index 8c5b24538a..059086cfd9 100644 --- a/pcsx2/Linux/LnxMain.h +++ b/pcsx2/Linux/LnxMain.h @@ -15,39 +15,76 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA */ - + #ifndef __LNXMAIN_H__ #define __LNXMAIN_H__ #include "Linux.h" -char* g_pRunGSState = NULL; +extern char* g_pRunGSState; -const char* phelpmsg = - "\tpcsx2 [options] [file]\n\n" - "-cfg [file] {configuration file}\n" - "-efile [efile] {0 - reset, 1 - runcd (default), 2 - loadelf}\n" - "-help {display this help file}\n" - "-nogui {Don't use gui when launching}\n" - "-loadgs [file} {Loads a gsstate}\n" - "\n" +void SignalExit(int sig); +bool applychanges = FALSE; +bool configuringplug = FALSE; +extern bool UseGui; + +extern MemoryAlloc* g_RecoveryState; +extern bool g_ReturnToGui; // set to exit the execution of the emulator and return control to the GUI +extern bool g_EmulationInProgress; // Set TRUE if a game is actively running (set to false on reset) + +int efile = 0; +char elfname[g_MaxPath]; +int Slots[5] = { -1, -1, -1, -1, -1 }; + +GtkWidget *CpuDlg; + +// Functions Callbacks +void OnFile_LoadElf(GtkMenuItem *menuitem, gpointer user_data); +void OnFile_Exit(GtkMenuItem *menuitem, gpointer user_data); +void OnEmu_Run(GtkMenuItem *menuitem, gpointer user_data); +void OnEmu_Reset(GtkMenuItem *menuitem, gpointer user_data); +void OnEmu_Arguments(GtkMenuItem *menuitem, gpointer user_data); +void OnLanguage(GtkMenuItem *menuitem, gpointer user_data); +void OnHelp_Help(); +void OnHelp_About(GtkMenuItem *menuitem, gpointer user_data); +void ExecuteCpu(); + +void StartGui(); +void pcsx2_exit(); +GtkWidget *MainWindow; +GtkWidget *pStatusBar = NULL, *Status_Box; +GtkWidget *CmdLine; //2002-09-28 (Florin) +GtkWidget *widgetCmdLine; +GtkWidget *LogDlg; + +void init_widgets(); + +GtkAccelGroup *AccelGroup; + +const char* phelpmsg = + "\tpcsx2 [options] [file]\n\n" + "-cfg [file] {configuration file}\n" + "-efile [efile] {0 - reset, 1 - runcd (default), 2 - loadelf}\n" + "-help {display this help file}\n" + "-nogui {Don't use gui when launching}\n" + "-loadgs [file} {Loads a gsstate}\n" + "\n" #ifdef PCSX2_DEVBUILD - "Testing Options: \n" - "\t-frame [frame] {game will run up to this frame before exiting}\n" - "\t-image [name] {path and base name of image (do not include the .ext)}\n" - "\t-jpg {save images to jpg format}\n" - "\t-log [name] {log path to save log file in}\n" - "\t-logopt [hex] {log options in hex (see debug.h) }\n" - "\t-numimages [num] {after hitting frame, this many images will be captures every 20 frames}\n" - "\t-test {Triggers testing mode (only for dev builds)}\n" - "\n" + "Testing Options: \n" + "\t-frame [frame] {game will run up to this frame before exiting}\n" + "\t-image [name] {path and base name of image (do not include the .ext)}\n" + "\t-jpg {save images to jpg format}\n" + "\t-log [name] {log path to save log file in}\n" + "\t-logopt [hex] {log options in hex (see debug.h) }\n" + "\t-numimages [num] {after hitting frame, this many images will be captures every 20 frames}\n" + "\t-test {Triggers testing mode (only for dev builds)}\n" + "\n" +#endif + "Load Plugins:\n" + "\t-cdvd [libpath] {specify the library load path of the CDVD plugin}\n" + "\t-gs [libpath] {specify the library load path of the GS plugin}\n" + "-pad [tsxcal] {specify to hold down on the triangle, square, circle, x, start, select buttons}\n" + "\t-spu [libpath] {specify the library load path of the SPU2 plugin}\n" + "\n"; + #endif - "Load Plugins:\n" - "\t-cdvd [libpath] {specify the library load path of the CDVD plugin}\n" - "\t-gs [libpath] {specify the library load path of the GS plugin}\n" - "-pad [tsxcal] {specify to hold down on the triangle, square, circle, x, start, select buttons}\n" - "\t-spu [libpath] {specify the library load path of the SPU2 plugin}\n" - "\n"; - - #endif - \ No newline at end of file diff --git a/pcsx2/Linux/LnxSysExec.cpp b/pcsx2/Linux/LnxSysExec.cpp new file mode 100644 index 0000000000..ad46ac9524 --- /dev/null +++ b/pcsx2/Linux/LnxSysExec.cpp @@ -0,0 +1,792 @@ +/* Pcsx2 - Pc Ps2 Emulator + * Copyright (C) 2002-2008 Pcsx2 Team + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + + #include "Linux.h" + +#include +#include + +bool UseGui = true; + +MemoryAlloc* g_RecoveryState = NULL; +MemoryAlloc* g_gsRecoveryState = NULL; +const char* g_pRunGSState = NULL; + +bool g_ReturnToGui = false; // set to exit the execution of the emulator and return control to the GUI +bool g_EmulationInProgress = false; // Set TRUE if a game is actively running (set to false on reset) + +static bool sinit = false; +GtkWidget *FileSel; + +void SysPrintf(const char *fmt, ...) +{ + va_list list; + char msg[512]; + + va_start(list, fmt); + vsnprintf(msg, 511, fmt, list); + msg[511] = '\0'; + va_end(list); + + Console::Write(msg); +} + +static void KeyEvent(keyEvent* ev); + +void SysUpdate() +{ + KeyEvent(PAD1keyEvent()); + KeyEvent(PAD2keyEvent()); +} + +static void TryRecoverFromGsState() +{ + if( g_gsRecoveryState != NULL ) + { + s32 dummylen; + + memLoadingState eddie( *g_gsRecoveryState ); + eddie.FreezePlugin( "GS", gsSafeFreeze ); + eddie.Freeze( dummylen ); // reads the length value recorded earlier. + eddie.gsFreeze(); + } +} + +void ExecuteCpu() +{ + // Make sure any left-over recovery states are cleaned up. + safe_delete( g_RecoveryState ); + + // Just in case they weren't initialized earlier (no harm in calling this multiple times) + if (OpenPlugins(NULL) == -1) return; + + // this needs to be called for every new game! + // (note: sometimes launching games through bios will give a crc of 0) + + if( GSsetGameCRC != NULL ) GSsetGameCRC(ElfCRC, g_ZeroGSOptions); + + TryRecoverFromGsState(); + + safe_delete( g_gsRecoveryState ); + + // Destroy the window. Ugly thing. + gtk_widget_destroy(MainWindow); + gtk_main_quit(); + + while (gtk_events_pending()) gtk_main_iteration(); + + g_EmulationInProgress = true; + g_ReturnToGui = false; + + signal(SIGINT, SignalExit); + signal(SIGPIPE, SignalExit); + + // Optimization: We hardcode two versions of the EE here -- one for recs and one for ints. + // This is because recs are performance critical, and being able to inline them into the + // function here helps a small bit (not much but every small bit counts!). + + if (CHECK_EEREC) + { + while (!g_ReturnToGui) + { + recExecute(); + SysUpdate(); + } + } + else + { + while (!g_ReturnToGui) + { + Cpu->Execute(); + SysUpdate(); + } + } +} + + +// Runs an ELF image directly (ISO or ELF program or BIN) +// Used by Run::FromCD and such +void RunExecute(const char* elf_file, bool use_bios) +{ + + // (air notes:) + // If you want to use the new to-memory savestate feature, take a look at the new + // RunExecute in WinMain.c, and secondly the CpuDlg.c or AdvancedDlg.cpp. The + // objects used are MemoryAlloc, memLoadingState, and memSavingState. + + // It's important to make sure to reset the CPU and the plugins correctly, which is + // where the new RunExecute comes into play. It can be kind of tricky knowing + // when to call cpuExecuteBios and loadElfFile, and with what parameters. + + // (or, as an alternative maybe we should switch to wxWidgets and have a unified + // cross platform gui?) - Air + + // Sounds like a good idea, at this point. + + try + { + cpuReset(); + } + + catch( Exception::BaseException& ex ) + { + Msgbox::Alert( ex.cMessage() ); + return; + } + + if (OpenPlugins(NULL) == -1) + { + RunGui(); + return; + } + + if (elf_file == NULL) + { + if (g_RecoveryState != NULL) + { + try + { + memLoadingState(*g_RecoveryState).FreezeAll(); + } + catch (std::runtime_error& ex) + { + Msgbox::Alert( + "Gamestate recovery failed. Your game progress will be lost (sorry!)\n" + "\nError: %s\n", params ex.what()); + + // Take the user back to the GUI... + safe_delete(g_RecoveryState); + ClosePlugins(); + return; + } + safe_delete(g_RecoveryState); + } + else if( g_gsRecoveryState == NULL ) + { + // Not recovering a state, so need to execute the bios and load the ELF information. + + // if the elf_file is null we use the CDVD elf file. + // But if the elf_file is an empty string then we boot the bios instead. + + char ename[g_MaxPath]; + ename[0] = 0; + + if (!use_bios) GetPS2ElfName(ename); + loadElfFile(ename); + } + } + else + { + // Custom ELF specified (not using CDVD). + // Run the BIOS and load the ELF. + + loadElfFile(elf_file); + } + //FixCPUState(); + ExecuteCpu(); +} + +class RecoveryMemSavingState : public memSavingState, Sealed +{ +public: + virtual ~RecoveryMemSavingState() { } + RecoveryMemSavingState() : memSavingState( *g_RecoveryState ) + { + } + + void gsFreeze() + { + if (g_gsRecoveryState != NULL) + { + // just copy the data from src to dst. + // the normal savestate doesn't expect a length prefix for internal structures, + // so don't copy that part. + const u32 pluginlen = *((u32*)g_gsRecoveryState->GetPtr()); + const u32 gslen = *((u32*)g_gsRecoveryState->GetPtr(pluginlen+4)); + memcpy( m_memory.GetPtr(m_idx), g_gsRecoveryState->GetPtr(pluginlen+8), gslen ); + m_idx += gslen; + } + else + memSavingState::gsFreeze(); + } + + void FreezePlugin( const char* name, s32 (CALLBACK* freezer)(int mode, freezeData *data) ) + { + if ((freezer == gsSafeFreeze) && (g_gsRecoveryState != NULL)) + { + // Gs data is already in memory, so just copy from src to dest: + // length of the GS data is stored as the first u32, so use that to run the copy: + const u32 len = *((u32*)g_gsRecoveryState->GetPtr()); + memcpy( m_memory.GetPtr(m_idx), g_gsRecoveryState->GetPtr(), len+4 ); + m_idx += len+4; + } + else + memSavingState::FreezePlugin( name, freezer ); + } +}; + +class RecoveryZipSavingState : public gzSavingState, Sealed +{ +public: + virtual ~RecoveryZipSavingState() { } + RecoveryZipSavingState( const string& filename ) : gzSavingState( filename ) + { + } + + void gsFreeze() + { + if (g_gsRecoveryState != NULL) + { + // read data from the gsRecoveryState allocation instead of the GS, since the gs + // info was invalidated when the plugin was shut down. + + // the normal savestate doesn't expect a length prefix for internal structures, + // so don't copy that part. + + u32& pluginlen = *((u32*)g_gsRecoveryState->GetPtr(0)); + u32& gslen = *((u32*)g_gsRecoveryState->GetPtr(pluginlen+4)); + gzwrite( m_file, g_gsRecoveryState->GetPtr(pluginlen+4), gslen ); + } + else + gzSavingState::gsFreeze(); + } + + void FreezePlugin( const char* name, s32 (CALLBACK* freezer)(int mode, freezeData *data) ) + { + if ((freezer == gsSafeFreeze) && (g_gsRecoveryState != NULL)) + { + // Gs data is already in memory, so just copy from there into the gzip file. + // length of the GS data is stored as the first u32, so use that to run the copy: + u32& len = *((u32*)g_gsRecoveryState->GetPtr()); + gzwrite( m_file, g_gsRecoveryState->GetPtr(), len+4 ); + } + else + gzSavingState::FreezePlugin( name, freezer ); + } +}; + + +void States_Load(const string& file, int num = -1) +{ + if( !Path::isFile( file ) ) + { + Console::Notice( "Saveslot %d is empty.", params num ); + return; + } + try + { + char Text[g_MaxPath]; + gzLoadingState joe( file ); // this'll throw an StateLoadError_Recoverable. + + // Make sure the cpu and plugins are ready to be state-ified! + cpuReset(); + OpenPlugins( NULL ); + + joe.FreezeAll(); + + if( num != -1 ) + sprintf (Text, _("*PCSX2*: Loaded State %d"), num); + else + sprintf (Text, _("*PCSX2*: Loaded State %s"), file.c_str()); + + //StatusBar_Notice( Text ); + Console::Notice(Text); + + if( GSsetGameCRC != NULL ) GSsetGameCRC(ElfCRC, g_ZeroGSOptions); + } + catch( Exception::StateLoadError_Recoverable& ex) + { + if( num != -1 ) + Console::Notice( "Could not load savestate from slot %d.\n\n%s", params num, ex.cMessage() ); + else + Console::Notice( "Could not load savestate file: %s.\n\n%s", params file.c_str(), ex.cMessage() ); + + // At this point the cpu hasn't been reset, so we can return + // control to the user safely... (that's why we use a console notice instead of a popup) + + return; + } + catch( Exception::BaseException& ex ) + { + // The emulation state is ruined. Might as well give them a popup and start the gui. + + string message; + + if( num != -1 ) + ssprintf( message, + "Encountered an error while loading savestate from slot %d.\n", num ); + else + ssprintf( message, + "Encountered an error while loading savestate from file: %s.\n", file.c_str() ); + + if( g_EmulationInProgress ) + message += "Since the savestate load was incomplete, the emulator has been reset.\n"; + + message += "\nError: " + ex.Message(); + + Msgbox::Alert( message.c_str() ); + SysClose(); + return; + } + + // Start emulating! + ExecuteCpu(); +} + +void States_Load(int num) +{ + States_Load( SaveState::GetFilename( num ), num ); +} + +void States_Save( const string& file, int num = -1 ) +{ + try + { + string text; + RecoveryZipSavingState( file ).FreezeAll(); + if( num != -1 ) + ssprintf( text, _( "State saved to slot %d" ), num ); + else + ssprintf( text, _( "State saved to file: %s" ), file.c_str() ); + + Console::Notice(text.c_str()); + } + catch( Exception::BaseException& ex ) + { + string message; + + if( num != -1 ) + ssprintf( message, "An error occurred while trying to save to slot %d\n", num ); + else + ssprintf( message, "An error occurred while trying to save to file: %s\n", file.c_str() ); + + message += "Your emulation state has not been saved!\n\nError: " + ex.Message(); + + Console::Error( message.c_str() ); + } +} + +void States_Save(int num) +{ + if( g_RecoveryState != NULL ) + { + // State is already saved into memory, and the emulator (and in-progress flag) + // have likely been cleared out. So save from the Recovery buffer instead of + // doing a "standard" save: + + string text; + SaveState::GetFilename( text, num ); + gzFile fileptr = gzopen( text.c_str(), "wb" ); + if( fileptr == NULL ) + { + Msgbox::Alert( _("File permissions error while trying to save to slot %d"), params num ); + return; + } + gzwrite( fileptr, &g_SaveVersion, sizeof( u32 ) ); + gzwrite( fileptr, g_RecoveryState->GetPtr(), g_RecoveryState->GetSizeInBytes() ); + gzclose( fileptr ); + return; + } + + if( !g_EmulationInProgress ) + { + Msgbox::Alert( "You need to start a game first before you can save it's state." ); + return; + } + + States_Save( SaveState::GetFilename( num ), num ); +} + +class JustGsSavingState : public memSavingState, Sealed +{ +public: + virtual ~JustGsSavingState() { } + JustGsSavingState() : memSavingState( *g_gsRecoveryState ) + { + } + + // This special override saves the gs info to m_idx+4, and then goes back and + // writes in the length of data saved. + void gsFreeze() + { + int oldmidx = m_idx; + m_idx += 4; + memSavingState::gsFreeze(); + if( IsSaving() ) + { + s32& len = *((s32*)m_memory.GetPtr( oldmidx )); + len = (m_idx - oldmidx)-4; + } + } +}; + +void OnStates_Load1(GtkMenuItem *menuitem, gpointer user_data) +{ + States_Load(0); +} +void OnStates_Load2(GtkMenuItem *menuitem, gpointer user_data) +{ + States_Load(1); +} +void OnStates_Load3(GtkMenuItem *menuitem, gpointer user_data) +{ + States_Load(2); +} +void OnStates_Load4(GtkMenuItem *menuitem, gpointer user_data) +{ + States_Load(3); +} +void OnStates_Load5(GtkMenuItem *menuitem, gpointer user_data) +{ + States_Load(4); +} + +void OnLoadOther_Ok(GtkButton* button, gpointer user_data) +{ + gchar *File; + char str[g_MaxPath]; + + File = (gchar*)gtk_file_selection_get_filename(GTK_FILE_SELECTION(FileSel)); + strcpy(str, File); + gtk_widget_destroy(FileSel); + + States_Load(str); +} + +void OnLoadOther_Cancel(GtkButton* button, gpointer user_data) +{ + gtk_widget_destroy(FileSel); +} + +void OnStates_LoadOther(GtkMenuItem *menuitem, gpointer user_data) +{ + GtkWidget *Ok, *Cancel; + + FileSel = gtk_file_selection_new(_("Select State File")); + gtk_file_selection_set_filename(GTK_FILE_SELECTION(FileSel), SSTATES_DIR "/"); + + Ok = GTK_FILE_SELECTION(FileSel)->ok_button; + gtk_signal_connect(GTK_OBJECT(Ok), "clicked", GTK_SIGNAL_FUNC(OnLoadOther_Ok), NULL); + gtk_widget_show(Ok); + + Cancel = GTK_FILE_SELECTION(FileSel)->cancel_button; + gtk_signal_connect(GTK_OBJECT(Cancel), "clicked", GTK_SIGNAL_FUNC(OnLoadOther_Cancel), NULL); + gtk_widget_show(Cancel); + + gtk_widget_show(FileSel); + gdk_window_raise(FileSel->window); +} + +void OnStates_Save1(GtkMenuItem *menuitem, gpointer user_data) +{ + States_Save(0); +} +void OnStates_Save2(GtkMenuItem *menuitem, gpointer user_data) +{ + States_Save(1); +} +void OnStates_Save3(GtkMenuItem *menuitem, gpointer user_data) +{ + States_Save(2); +} +void OnStates_Save4(GtkMenuItem *menuitem, gpointer user_data) +{ + States_Save(3); +} +void OnStates_Save5(GtkMenuItem *menuitem, gpointer user_data) +{ + States_Save(4); +} + +void OnSaveOther_Ok(GtkButton* button, gpointer user_data) +{ + gchar *File; + char str[g_MaxPath]; + + File = (gchar*)gtk_file_selection_get_filename(GTK_FILE_SELECTION(FileSel)); + strcpy(str, File); + gtk_widget_destroy(FileSel); + + States_Save(str); +} + +void OnSaveOther_Cancel(GtkButton* button, gpointer user_data) +{ + gtk_widget_destroy(FileSel); +} + +void OnStates_SaveOther(GtkMenuItem *menuitem, gpointer user_data) +{ + GtkWidget *Ok, *Cancel; + + FileSel = gtk_file_selection_new(_("Select State File")); + gtk_file_selection_set_filename(GTK_FILE_SELECTION(FileSel), SSTATES_DIR "/"); + + Ok = GTK_FILE_SELECTION(FileSel)->ok_button; + gtk_signal_connect(GTK_OBJECT(Ok), "clicked", GTK_SIGNAL_FUNC(OnSaveOther_Ok), NULL); + gtk_widget_show(Ok); + + Cancel = GTK_FILE_SELECTION(FileSel)->cancel_button; + gtk_signal_connect(GTK_OBJECT(Cancel), "clicked", GTK_SIGNAL_FUNC(OnSaveOther_Cancel), NULL); + gtk_widget_show(Cancel); + + gtk_widget_show(FileSel); + gdk_window_raise(FileSel->window); +} + +/* Quick macros for checking shift, control, alt, and caps lock. */ +#define SHIFT_EVT(evt) ((evt == XK_Shift_L) || (evt == XK_Shift_R)) +#define CTRL_EVT(evt) ((evt == XK_Control_L) || (evt == XK_Control_L)) +#define ALT_EVT(evt) ((evt == XK_Alt_L) || (evt == XK_Alt_R)) +#define CAPS_LOCK_EVT(evt) (evt == XK_Caps_Lock) + +void KeyEvent(keyEvent* ev) +{ + static int shift = 0; + + if (ev == NULL) return; + + if (GSkeyEvent != NULL) GSkeyEvent(ev); + + if (ev->evt == KEYPRESS) + { + if (SHIFT_EVT(ev->key)) + shift = 1; + if (CAPS_LOCK_EVT(ev->key)) + { + //Set up anything we want to happen while caps lock is down. + //Config_hacks_backup = Config.Hacks; + } + + switch (ev->key) + { + case XK_F1: + case XK_F2: + case XK_F3: + case XK_F4: + case XK_F5: + case XK_F6: + case XK_F7: + case XK_F8: + case XK_F9: + case XK_F10: + case XK_F11: + case XK_F12: + try + { + ProcessFKeys(ev->key - XK_F1 + 1, shift); + } + catch (Exception::CpuStateShutdown&) + { + // Woops! Something was unrecoverable. Bummer. + // Let's give the user a RunGui! + + g_EmulationInProgress = false; + g_ReturnToGui = true; + } + break; + + case XK_Escape: + signal(SIGINT, SIG_DFL); + signal(SIGPIPE, SIG_DFL); + +#ifdef PCSX2_DEVBUILD + if (g_SaveGSStream >= 3) + { + g_SaveGSStream = 4;// gs state + break; + } +#endif + if( Config.closeGSonEsc ) + { + safe_delete( g_gsRecoveryState ); + safe_delete( g_RecoveryState ); + g_gsRecoveryState = new MemoryAlloc(); + JustGsSavingState eddie; + eddie.FreezePlugin( "GS", gsSafeFreeze ) ; + eddie.gsFreeze(); + PluginsResetGS(); + } + + ClosePlugins(); + + if (!UseGui) exit(0); + + // fixme: The GUI is now capable of recieving control back from the + // emulator. Which means that when I set g_ReturnToGui here, the emulation + // loop in ExecuteCpu() will exit. You should be able to set it up so + // that it returns control to the existing GTK event loop, instead of + // always starting a new one via RunGui(). (but could take some trial and + // error) -- (air) + + // Easier said then done; running gtk in two threads at the same time can't be + // done, and working around that is pretty fiddly. + g_ReturnToGui = true; + RunGui(); + break; + + default: + GSkeyEvent(ev); + break; + } + } + else if (ev->evt == KEYRELEASE) + { + if (SHIFT_EVT(ev->key)) + shift = 0; + if (CAPS_LOCK_EVT(ev->key)) + { + //Release caps lock + //Config_hacks_backup = Config.Hacks; + } + } + + return; +} + + +void SysRestorableReset() +{ + // already reset? and saved? + if( !g_EmulationInProgress ) return; + if( g_RecoveryState != NULL ) return; + + try + { + g_RecoveryState = new MemoryAlloc( "Memory Savestate Recovery" ); + RecoveryMemSavingState().FreezeAll(); + safe_delete( g_gsRecoveryState ); + g_EmulationInProgress = false; + } + catch( Exception::RuntimeError& ex ) + { + Msgbox::Alert( + "Pcsx2 gamestate recovery failed. Some options may have been reverted to protect your game's state.\n" + "Error: %s", params ex.cMessage() ); + safe_delete( g_RecoveryState ); + } +} + +void SysReset() +{ + if (!sinit) return; + + g_EmulationInProgress = false; + safe_delete( g_RecoveryState ); + safe_delete( g_gsRecoveryState ); + ResetPlugins(); + + ElfCRC = 0; + + // Note : No need to call cpuReset() here. It gets called automatically before the + // emulator resumes execution. +} + +bool SysInit() +{ + if (sinit) return true; + sinit = true; + + mkdir(SSTATES_DIR, 0755); + mkdir(MEMCARDS_DIR, 0755); + + mkdir(LOGS_DIR, 0755); + +#ifdef PCSX2_DEVBUILD + if (g_TestRun.plogname != NULL) + emuLog = fopen(g_TestRun.plogname, "w"); + if (emuLog == NULL) + emuLog = fopen(LOGS_DIR "/emuLog.txt", "wb"); +#endif + + if (emuLog != NULL) + setvbuf(emuLog, NULL, _IONBF, 0); + + PCSX2_MEM_PROTECT_BEGIN(); + SysDetect(); + if (!SysAllocateMem()) return false; // critical memory allocation failure; + + SysAllocateDynarecs(); + PCSX2_MEM_PROTECT_END(); + + while (LoadPlugins() == -1) + { + if (Pcsx2Configure() == FALSE) + { + Msgbox::Alert("Configuration failed. Exiting."); + exit(1); + } + } + + return true; +} + +void SysClose() +{ + if (sinit == 0) return; + cpuShutdown(); + ClosePlugins(); + ReleasePlugins(); + + if (emuLog != NULL) + { + fclose(emuLog); + emuLog = NULL; + } + sinit = 0; +} + +void *SysLoadLibrary(const char *lib) +{ + return dlopen(lib, RTLD_NOW); +} + +void *SysLoadSym(void *lib, const char *sym) +{ + return dlsym(lib, sym); +} + +const char *SysLibError() +{ + return dlerror(); +} + +void SysCloseLibrary(void *lib) +{ + dlclose(lib); +} + +void SysRunGui() +{ + RunGui(); +} + +void *SysMmap(uptr base, u32 size) +{ + u8 *Mem; + Mem = mmap((uptr*)base, size, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0); + if (Mem == MAP_FAILED) Console::Notice("Mmap Failed!"); + + return Mem; +} + +void SysMunmap(uptr base, u32 size) +{ + munmap((uptr*)base, size); +} + diff --git a/pcsx2/Linux/Makefile.am b/pcsx2/Linux/Makefile.am index 224c135bcf..c56b73563b 100644 --- a/pcsx2/Linux/Makefile.am +++ b/pcsx2/Linux/Makefile.am @@ -4,7 +4,10 @@ INCLUDES = $(shell pkg-config --cflags gtk+-2.0) -I@srcdir@/../ -I@srcdir@/../ bin_PROGRAMS = pcsx2 # the application source, library search path, and link libraries -pcsx2_SOURCES = Pref.cpp interface.c ConfigDlg.cpp DebugDlg.cpp GtkGui.cpp LnxMain.cpp LnxConsole.cpp LnxThreads.cpp support.c +pcsx2_SOURCES = \ +interface.c support.c LnxMain.cpp LnxThreads.cpp LnxConsole.cpp LnxSysExec.cpp \ +AboutDlg.cpp ConfigDlg.cpp DebugDlg.cpp AdvancedDlg.cpp CpuDlg.cpp HacksDlg.cpp Pref.cpp \ +GtkGui.h Linux.h LnxMain.h ConfigDlg.h DebugDlg.h interface.h callbacks.h memzero.h support.h pcsx2_LDFLAGS = diff --git a/pcsx2/Linux/Pref.cpp b/pcsx2/Linux/Pref.cpp index c804fe1c57..9ff433914b 100644 --- a/pcsx2/Linux/Pref.cpp +++ b/pcsx2/Linux/Pref.cpp @@ -5,12 +5,12 @@ * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. - * + * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. - * + * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA @@ -21,14 +21,14 @@ FILE *pref_file; char *data; -static void SetValue( const char *name, char *var) +static void SetValue(const char *name, char *var) { - fprintf (pref_file,"%s = %s\n", name, var); + fprintf(pref_file, "%s = %s\n", name, var); } -static void SetValuel( const char *name, s32 var) +static void SetValuel(const char *name, s32 var) { - fprintf (pref_file,"%s = %x\n", name, var); + fprintf(pref_file, "%s = %x\n", name, var); } #define GetValue(name, var) {\ @@ -50,15 +50,16 @@ static void SetValuel( const char *name, s32 var) if (*tmp != '\n') sscanf(tmp, "%x", &var); \ } \ } - -int LoadConfig() { + +int LoadConfig() +{ struct stat buf; int size; - + if (stat(cfgfile, &buf) == -1) return -1; size = buf.st_size; - pref_file = fopen(cfgfile,"r"); + pref_file = fopen(cfgfile, "r"); if (pref_file == NULL) return -1; data = (char*)malloc(size); @@ -85,7 +86,7 @@ int LoadConfig() { GetValue("DEV9", Config.DEV9); GetValue("USB", Config.USB); GetValue("FW", Config.FW); - + GetValuel("Patch", Config.Patch); #ifdef PCSX2_DEVBUILD GetValuel("varLog", varLog); @@ -93,7 +94,7 @@ int LoadConfig() { GetValuel("Options", Config.Options); GetValuel("Hacks", Config.Hacks); GetValuel("Fixes", Config.GameFixes); - + GetValuel("CustomFps", Config.CustomFps); GetValuel("CustomFrameskip", Config.CustomFrameSkip); GetValuel("CustomConsecutiveFrames", Config.CustomConsecutiveFrames); @@ -104,11 +105,12 @@ int LoadConfig() { GetValuel("sseVUMXCSR", Config.sseVUMXCSR); GetValuel("eeOptions", Config.eeOptions); GetValuel("vuOptions", Config.vuOptions); - + free(data); #ifdef ENABLE_NLS - if (Config.Lang[0]) { + if (Config.Lang[0]) + { extern int _nl_msg_cat_cntr; setenv("LANGUAGE", Config.Lang, 1); @@ -121,9 +123,10 @@ int LoadConfig() { ///////////////////////////////////////////////////////// -void SaveConfig() { +void SaveConfig() +{ - pref_file = fopen(cfgfile,"w"); + pref_file = fopen(cfgfile, "w"); if (pref_file == NULL) return; SetValue("Bios", Config.Bios); @@ -143,12 +146,12 @@ void SaveConfig() { SetValue("DEV9", Config.DEV9); SetValue("USB", Config.USB); SetValue("FW", Config.FW); - + SetValuel("Options", Config.Options); - + // Remove Fast Branches hack for now: Config.Hacks &= ~0x80; - + SetValuel("Hacks", Config.Hacks); SetValuel("Fixes", Config.GameFixes); @@ -163,7 +166,7 @@ void SaveConfig() { SetValuel("sseVUMXCSR", Config.sseVUMXCSR); SetValuel("eeOptions", Config.eeOptions); SetValuel("vuOptions", Config.vuOptions); - + #ifdef PCSX2_DEVBUILD SetValuel("varLog", varLog); #endif