Debian Codegraph @

gui/GtkGui.c

raw ◀ ▶
Source reconstructed at patch state 0 of 2 — not the installed (fully patched) source.
2 Debian patches touch this file
1 /* Pcsx - Pc Psx Emulator
2 * Copyright (C) 1999-2002 Pcsx Team
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <unistd.h>
22 #include <string.h>
23 #include <dirent.h>
24 #include <dlfcn.h>
25 #include <sys/stat.h>
26 #include <gdk/gdkkeysyms.h>
27 #include <gtk/gtk.h>
28 #include <signal.h>
29 #include <sys/time.h>
30 #include <regex.h>
31
32 #include "Linux.h"
33
34 #include "../libpcsxcore/plugins.h"
35 #include "../libpcsxcore/cheat.h"
36
37 #include "MemcardDlg.h"
38 #include "ConfDlg.h"
39 #include "DebugMemory.h"
40 #include "AboutDlg.h"
41
42 // Functions Callbacks
43 void OnFile_RunCd();
44 void OnFile_RunBios();
45 void OnFile_RunExe();
46 void OnFile_RunImage();
47 void OnEmu_Run();
48 void OnEmu_Reset();
49 void OnEmu_Shutdown();
50 void OnEmu_SwitchImage();
51 void OnHelp_Help();
52 void OnHelp_About();
53 void OnDestroy();
54 void OnFile_Exit();
55
56 void on_states_load(GtkWidget *widget, gpointer user_data);
57 void on_states_load_other();
58 void on_states_save(GtkWidget *widget, gpointer user_data);
59 void on_states_save_other();
60
61 static GtkBuilder *builder;
62 GtkWidget *Window = NULL;
63
64 int destroy = 0;
65
66 #define MAX_SLOTS 9
67
68 /* TODO - If MAX_SLOTS changes, need to find a way to automatically set all positions */
69 int Slots[MAX_SLOTS] = { -1, -1, -1, -1, -1, -1, -1, -1, -1 };
70
71 void ResetMenuSlots() {
72 GtkWidget *widget;
73 gchar *str;
74 int i;
75
76 if (CdromId[0] == '\0') {
77 // disable state saving/loading if no CD is loaded
78 for (i = 0; i < MAX_SLOTS; i++) {
79 str = g_strdup_printf("GtkMenuItem_SaveSlot%d", i+1);
80 widget = GTK_WIDGET(gtk_builder_get_object(builder, str));
81 g_free(str);
82
83 gtk_widget_set_sensitive(widget, FALSE);
84
85 str = g_strdup_printf("GtkMenuItem_LoadSlot%d", i+1);
86 widget = GTK_WIDGET(gtk_builder_get_object(builder, str));
87 g_free(str);
88
89 gtk_widget_set_sensitive(widget, FALSE);
90 }
91
92 // also disable certain menu/toolbar items
93 widget = GTK_WIDGET(gtk_builder_get_object(builder, "other1"));
94 gtk_widget_set_sensitive(widget, FALSE);
95 widget = GTK_WIDGET(gtk_builder_get_object(builder, "other2"));
96 gtk_widget_set_sensitive(widget, FALSE);
97 widget = GTK_WIDGET(gtk_builder_get_object(builder, "run1"));
98 gtk_widget_set_sensitive(widget, FALSE);
99 widget = GTK_WIDGET(gtk_builder_get_object(builder, "reset1"));
100 gtk_widget_set_sensitive(widget, FALSE);
101 widget = GTK_WIDGET(gtk_builder_get_object(builder, "shutdown1"));
102 gtk_widget_set_sensitive(widget, FALSE);
103 widget = GTK_WIDGET(gtk_builder_get_object(builder, "search1"));
104 gtk_widget_set_sensitive(widget, FALSE);
105 widget = GTK_WIDGET(gtk_builder_get_object(builder, "SwitchImage"));
106 gtk_widget_set_sensitive(widget, FALSE);
107 widget = GTK_WIDGET(gtk_builder_get_object(builder, "memorydump1"));
108 gtk_widget_set_sensitive(widget, FALSE);
109 widget = GTK_WIDGET(gtk_builder_get_object(builder, "toolbutton_run"));
110 gtk_widget_set_sensitive(widget, FALSE);
111 widget = GTK_WIDGET(gtk_builder_get_object(builder, "toolbutton_switchimage"));
112 gtk_widget_set_sensitive(widget, FALSE);
113 widget = GTK_WIDGET(gtk_builder_get_object(builder, "plugins_bios"));
114 gtk_widget_set_sensitive(widget, TRUE);
115 widget = GTK_WIDGET(gtk_builder_get_object(builder, "graphics1"));
116 gtk_widget_set_sensitive(widget, TRUE);
117 widget = GTK_WIDGET(gtk_builder_get_object(builder, "sound1"));
118 gtk_widget_set_sensitive(widget, TRUE);
119 widget = GTK_WIDGET(gtk_builder_get_object(builder, "cdrom1"));
120 gtk_widget_set_sensitive(widget, TRUE);
121 widget = GTK_WIDGET(gtk_builder_get_object(builder, "pad1"));
122 gtk_widget_set_sensitive(widget, TRUE);
123 #ifdef ENABLE_SIO1API
124 widget = GTK_WIDGET(gtk_builder_get_object(builder, "sio1"));
125 gtk_widget_set_sensitive(widget, TRUE);
126 #else
127 widget = GTK_WIDGET(gtk_builder_get_object(builder, "sio1"));
128 gtk_widget_set_sensitive(widget, FALSE);
129 #endif
130 widget = GTK_WIDGET(gtk_builder_get_object(builder, "net1"));
131 gtk_widget_set_sensitive(widget, TRUE);
132
133 widget = GTK_WIDGET(gtk_builder_get_object(builder, "toolbutton_switchimage"));
134 gtk_widget_set_sensitive(widget, UsingIso());
135 widget = GTK_WIDGET(gtk_builder_get_object(builder, "toolbutton_graphics"));
136 gtk_widget_set_sensitive(widget, TRUE);
137 widget = GTK_WIDGET(gtk_builder_get_object(builder, "toolbutton_sound"));
138 gtk_widget_set_sensitive(widget, TRUE);
139 widget = GTK_WIDGET(gtk_builder_get_object(builder, "toolbutton_cdrom"));
140 gtk_widget_set_sensitive(widget, TRUE);
141 widget = GTK_WIDGET(gtk_builder_get_object(builder, "toolbutton_controllers"));
142 gtk_widget_set_sensitive(widget, TRUE);
143
144 widget = GTK_WIDGET(gtk_builder_get_object(builder, "statusbar"));
145 gtk_statusbar_pop(GTK_STATUSBAR(widget), 1);
146 gtk_statusbar_push(GTK_STATUSBAR(widget), 1, _("Ready"));
147 }
148 else {
149 for (i = 0; i < MAX_SLOTS; i++) {
150 str = g_strdup_printf("GtkMenuItem_LoadSlot%d", i+1);
151 widget = GTK_WIDGET(gtk_builder_get_object (builder, str));
152 g_free (str);
153
154 if (Slots[i] == -1)
155 gtk_widget_set_sensitive(widget, FALSE);
156 else
157 gtk_widget_set_sensitive(widget, TRUE);
158 }
159
160 widget = GTK_WIDGET(gtk_builder_get_object(builder, "plugins_bios"));
161 gtk_widget_set_sensitive(widget, FALSE);
162 widget = GTK_WIDGET(gtk_builder_get_object(builder, "graphics1"));
163 gtk_widget_set_sensitive(widget, FALSE);
164 widget = GTK_WIDGET(gtk_builder_get_object(builder, "sound1"));
165 gtk_widget_set_sensitive(widget, FALSE);
166 widget = GTK_WIDGET(gtk_builder_get_object(builder, "cdrom1"));
167 gtk_widget_set_sensitive(widget, FALSE);
168 widget = GTK_WIDGET(gtk_builder_get_object(builder, "pad1"));
169 gtk_widget_set_sensitive(widget, FALSE);
170 #ifdef ENABLE_SIO1API
171 widget = GTK_WIDGET(gtk_builder_get_object(builder, "sio1"));
172 gtk_widget_set_sensitive(widget, FALSE);
173 #endif
174 widget = GTK_WIDGET(gtk_builder_get_object(builder, "net1"));
175 gtk_widget_set_sensitive(widget, FALSE);
176 widget = GTK_WIDGET(gtk_builder_get_object(builder, "SwitchImage"));
177 gtk_widget_set_sensitive(widget, UsingIso());
178 widget = GTK_WIDGET(gtk_builder_get_object(builder, "toolbutton_switchimage"));
179 gtk_widget_set_sensitive(widget, UsingIso());
180 widget = GTK_WIDGET(gtk_builder_get_object(builder, "toolbutton_graphics"));
181 gtk_widget_set_sensitive(widget, FALSE);
182 widget = GTK_WIDGET(gtk_builder_get_object(builder, "toolbutton_sound"));
183 gtk_widget_set_sensitive(widget, FALSE);
184 widget = GTK_WIDGET(gtk_builder_get_object(builder, "toolbutton_cdrom"));
185 gtk_widget_set_sensitive(widget, FALSE);
186 widget = GTK_WIDGET(gtk_builder_get_object(builder, "toolbutton_controllers"));
187 gtk_widget_set_sensitive(widget, FALSE);
188
189 widget = GTK_WIDGET(gtk_builder_get_object(builder, "statusbar"));
190 gtk_statusbar_pop(GTK_STATUSBAR(widget), 1);
191 gtk_statusbar_push(GTK_STATUSBAR(widget), 1, _("Emulation Paused."));
192 }
193 }
194
195 int match(const char *string, char *pattern) {
196 int status;
197 regex_t re;
198
199 if (regcomp(&re, pattern, REG_EXTENDED | REG_NOSUB) != 0) {
200 return 0;
201 }
202 status = regexec(&re, string, (size_t) 0, NULL, 0);
203 regfree(&re);
204 if (status != 0) {
205 return 0;
206 }
207
208 return 1;
209 }
210
211 gchar* get_state_filename(int i) {
212 gchar *state_filename, *trimlabel;
213 char SStateFile[64];
214 int j;
215
216 trimlabel = get_cdrom_label_trim();
217
218 sprintf(SStateFile, "%.32s-%.9s.%3.3d", trimlabel, CdromId, i);
219 state_filename = g_build_filename (getenv("HOME"), STATES_DIR, SStateFile, NULL);
220
221 g_free(trimlabel);
222
223 return state_filename;
224 }
225
226 gchar* get_cdrom_label_trim() {
227 char trimlabel[33];
228 int j;
229
230 strncpy(trimlabel, CdromLabel, 32);
231 trimlabel[32] = 0;
232 for (j = 31; j >= 0; j--) {
233 if (trimlabel[j] == ' ')
234 trimlabel[j] = 0;
235 else
236 continue;
237 }
238
239 return g_strdup(trimlabel);
240 }
241
242 gchar* get_cdrom_label_id(const gchar* suffix) {
243 const u8 lblmax = sizeof(CdromId) + sizeof(CdromLabel) + 20u;
244 //printf("MAx %u\n", lblmax);
245 char buf[lblmax];
246 gchar *trimlabel = get_cdrom_label_trim();
247
248 snprintf(buf, lblmax, "%.32s-%.9s%s", trimlabel, CdromId, suffix);
249
250 g_free(trimlabel);
251
252 return g_strdup(buf);
253 }
254
255 void UpdateMenuSlots() {
256 gchar *str;
257 int i;
258
259 for (i = 0; i < MAX_SLOTS; i++) {
260 str = get_state_filename (i);
261 Slots[i] = CheckState(str);
262 g_free (str);
263 }
264 }
265
266 void autoloadCheats() {
267 gchar *chtfile = get_cdrom_label_id(dot_extension_cht);
268 gchar *defaultChtFilePath = g_build_filename (getenv("HOME"), CHEATS_DIR, chtfile, NULL);
269 LoadCheats(defaultChtFilePath); // file existence/access check in LoadCheats()
270 g_free(defaultChtFilePath);
271 g_free(chtfile);
272 }
273
274 void StartGui() {
275 GtkWidget *widget;
276
277 /* If a plugin fails, the Window is not NULL, but is not initialised,
278 so the following causes a segfault
279 if (Window != NULL) {
280 gtk_window_present (GTK_WINDOW (Window));
281 return;
282 }*/
283 builder = gtk_builder_new();
284
285 if (!gtk_builder_add_from_file(builder, PACKAGE_DATA_DIR "pcsxr.ui", NULL)) {
286 g_warning("Error: interface could not be loaded!");
287 return;
288 }
289
290 Window = GTK_WIDGET(gtk_builder_get_object(builder, "MainWindow"));
291 gtk_widget_show(GTK_WIDGET(Window));
292
293 gtk_window_set_title(GTK_WINDOW(Window), "PCSXR");
294 gtk_window_set_icon_from_file(GTK_WINDOW(Window), PIXMAPDIR "pcsxr-icon.png", NULL);
295 gtk_window_set_default_icon_from_file(PIXMAPDIR "pcsxr-icon.png", NULL);
296 ResetMenuSlots();
297
298 // Set up callbacks
299 g_signal_connect_data(G_OBJECT(Window), "delete-event",
300 G_CALLBACK(OnDestroy), builder, (GClosureNotify)g_object_unref, G_CONNECT_AFTER);
301
302 // File menu
303 widget = GTK_WIDGET(gtk_builder_get_object(builder, "RunCd"));
304 g_signal_connect_data(G_OBJECT(widget), "activate",
305 G_CALLBACK(OnFile_RunCd), NULL, NULL, G_CONNECT_AFTER);
306
307 widget = GTK_WIDGET(gtk_builder_get_object(builder, "RunBios"));
308 g_signal_connect_data(G_OBJECT(widget), "activate",
309 G_CALLBACK(OnFile_RunBios), NULL, NULL, G_CONNECT_AFTER);
310
311 widget = GTK_WIDGET(gtk_builder_get_object(builder, "RunExe"));
312 g_signal_connect_data(G_OBJECT(widget), "activate",
313 G_CALLBACK(OnFile_RunExe), NULL, NULL, G_CONNECT_AFTER);
314
315 widget = GTK_WIDGET(gtk_builder_get_object(builder, "RunImage"));
316 g_signal_connect_data(G_OBJECT(widget), "activate",
317 G_CALLBACK(OnFile_RunImage), NULL, NULL, G_CONNECT_AFTER);
318
319 widget = GTK_WIDGET(gtk_builder_get_object(builder, "exit2"));
320 g_signal_connect_data(G_OBJECT(widget), "activate",
321 G_CALLBACK(OnFile_Exit), NULL, NULL, G_CONNECT_AFTER);
322
323 // States
324 widget = GTK_WIDGET(gtk_builder_get_object(builder, "GtkMenuItem_LoadSlot1"));
325 g_signal_connect_data(G_OBJECT(widget), "activate",
326 G_CALLBACK(on_states_load), GINT_TO_POINTER(0), NULL, G_CONNECT_AFTER);
327 widget = GTK_WIDGET(gtk_builder_get_object(builder, "GtkMenuItem_LoadSlot2"));
328 g_signal_connect_data(G_OBJECT(widget), "activate",
329 G_CALLBACK(on_states_load), GINT_TO_POINTER(1), NULL, G_CONNECT_AFTER);
330 widget = GTK_WIDGET(gtk_builder_get_object(builder, "GtkMenuItem_LoadSlot3"));
331 g_signal_connect_data(G_OBJECT(widget), "activate",
332 G_CALLBACK(on_states_load), GINT_TO_POINTER(2), NULL, G_CONNECT_AFTER);
333 widget = GTK_WIDGET(gtk_builder_get_object(builder, "GtkMenuItem_LoadSlot4"));
334 g_signal_connect_data(G_OBJECT(widget), "activate",
335 G_CALLBACK(on_states_load), GINT_TO_POINTER(3), NULL, G_CONNECT_AFTER);
336 widget = GTK_WIDGET(gtk_builder_get_object(builder, "GtkMenuItem_LoadSlot5"));
337 g_signal_connect_data(G_OBJECT(widget), "activate",
338 G_CALLBACK(on_states_load), GINT_TO_POINTER(4), NULL, G_CONNECT_AFTER);
339 widget = GTK_WIDGET(gtk_builder_get_object(builder, "GtkMenuItem_LoadSlot6"));
340 g_signal_connect_data(G_OBJECT(widget), "activate",
341 G_CALLBACK(on_states_load), GINT_TO_POINTER(5), NULL, G_CONNECT_AFTER);
342 widget = GTK_WIDGET(gtk_builder_get_object(builder, "GtkMenuItem_LoadSlot7"));
343 g_signal_connect_data(G_OBJECT(widget), "activate",
344 G_CALLBACK(on_states_load), GINT_TO_POINTER(6), NULL, G_CONNECT_AFTER);
345 widget = GTK_WIDGET(gtk_builder_get_object(builder, "GtkMenuItem_LoadSlot8"));
346 g_signal_connect_data(G_OBJECT(widget), "activate",
347 G_CALLBACK(on_states_load), GINT_TO_POINTER(7), NULL, G_CONNECT_AFTER);
348 widget = GTK_WIDGET(gtk_builder_get_object(builder, "GtkMenuItem_LoadSlot9"));
349 g_signal_connect_data(G_OBJECT(widget), "activate",
350 G_CALLBACK(on_states_load), GINT_TO_POINTER(8), NULL, G_CONNECT_AFTER);
351 widget = GTK_WIDGET(gtk_builder_get_object(builder, "other1"));
352 g_signal_connect_data(G_OBJECT(widget), "activate",
353 G_CALLBACK(on_states_load_other), NULL, NULL, G_CONNECT_AFTER);
354
355 widget = GTK_WIDGET(gtk_builder_get_object(builder, "GtkMenuItem_SaveSlot1"));
356 g_signal_connect_data(G_OBJECT(widget), "activate",
357 G_CALLBACK(on_states_save), GINT_TO_POINTER(0), NULL, G_CONNECT_AFTER);
358 widget = GTK_WIDGET(gtk_builder_get_object(builder, "GtkMenuItem_SaveSlot2"));
359 g_signal_connect_data(G_OBJECT(widget), "activate",
360 G_CALLBACK(on_states_save), GINT_TO_POINTER(1), NULL, G_CONNECT_AFTER);
361 widget = GTK_WIDGET(gtk_builder_get_object(builder, "GtkMenuItem_SaveSlot3"));
362 g_signal_connect_data(G_OBJECT(widget), "activate",
363 G_CALLBACK(on_states_save), GINT_TO_POINTER(2), NULL, G_CONNECT_AFTER);
364 widget = GTK_WIDGET(gtk_builder_get_object(builder, "GtkMenuItem_SaveSlot4"));
365 g_signal_connect_data(G_OBJECT(widget), "activate",
366 G_CALLBACK(on_states_save), GINT_TO_POINTER(3), NULL, G_CONNECT_AFTER);
367 widget = GTK_WIDGET(gtk_builder_get_object(builder, "GtkMenuItem_SaveSlot5"));
368 g_signal_connect_data(G_OBJECT(widget), "activate",
369 G_CALLBACK(on_states_save), GINT_TO_POINTER(4), NULL, G_CONNECT_AFTER);
370 widget = GTK_WIDGET(gtk_builder_get_object(builder, "GtkMenuItem_SaveSlot6"));
371 g_signal_connect_data(G_OBJECT(widget), "activate",
372 G_CALLBACK(on_states_save), GINT_TO_POINTER(5), NULL, G_CONNECT_AFTER);
373 widget = GTK_WIDGET(gtk_builder_get_object(builder, "GtkMenuItem_SaveSlot7"));
374 g_signal_connect_data(G_OBJECT(widget), "activate",
375 G_CALLBACK(on_states_save), GINT_TO_POINTER(6), NULL, G_CONNECT_AFTER);
376 widget = GTK_WIDGET(gtk_builder_get_object(builder, "GtkMenuItem_SaveSlot8"));
377 g_signal_connect_data(G_OBJECT(widget), "activate",
378 G_CALLBACK(on_states_save), GINT_TO_POINTER(7), NULL, G_CONNECT_AFTER);
379 widget = GTK_WIDGET(gtk_builder_get_object(builder, "GtkMenuItem_SaveSlot9"));
380 g_signal_connect_data(G_OBJECT(widget), "activate",
381 G_CALLBACK(on_states_save), GINT_TO_POINTER(8), NULL, G_CONNECT_AFTER);
382 widget = GTK_WIDGET(gtk_builder_get_object(builder, "other2"));
383 g_signal_connect_data(G_OBJECT(widget), "activate",
384 G_CALLBACK(on_states_save_other), NULL, NULL, G_CONNECT_AFTER);
385
386 // Emulation menu
387 widget = GTK_WIDGET(gtk_builder_get_object(builder, "run1"));
388 g_signal_connect_data(G_OBJECT(widget), "activate",
389 G_CALLBACK(OnEmu_Run), NULL, NULL, G_CONNECT_AFTER);
390 widget = GTK_WIDGET(gtk_builder_get_object(builder, "reset1"));
391 g_signal_connect_data(G_OBJECT(widget), "activate",
392 G_CALLBACK(OnEmu_Reset), NULL, NULL, G_CONNECT_AFTER);
393 widget = GTK_WIDGET(gtk_builder_get_object(builder, "shutdown1"));
394 g_signal_connect_data(G_OBJECT(widget), "activate",
395 G_CALLBACK(OnEmu_Shutdown), NULL, NULL, G_CONNECT_AFTER);
396 widget = GTK_WIDGET(gtk_builder_get_object(builder, "SwitchImage"));
397 g_signal_connect_data(G_OBJECT(widget), "activate",
398 G_CALLBACK(OnEmu_SwitchImage), NULL, NULL, G_CONNECT_AFTER);
399
400 // Configuration menu
401 widget = GTK_WIDGET(gtk_builder_get_object(builder, "plugins_bios"));
402 g_signal_connect_data(G_OBJECT(widget), "activate",
403 G_CALLBACK(ConfigurePlugins), NULL, NULL, G_CONNECT_AFTER);
404 widget = GTK_WIDGET(gtk_builder_get_object(builder, "graphics1"));
405 g_signal_connect_data(G_OBJECT(widget), "activate",
406 G_CALLBACK(OnConf_Graphics), NULL, NULL, G_CONNECT_AFTER);
407 widget = GTK_WIDGET(gtk_builder_get_object(builder, "sound1"));
408 g_signal_connect_data(G_OBJECT(widget), "activate",
409 G_CALLBACK(OnConf_Sound), NULL, NULL, G_CONNECT_AFTER);
410 widget = GTK_WIDGET(gtk_builder_get_object(builder, "cdrom1"));
411 g_signal_connect_data(G_OBJECT(widget), "activate",
412 G_CALLBACK(OnConf_CdRom), NULL, NULL, G_CONNECT_AFTER);
413 widget = GTK_WIDGET(gtk_builder_get_object(builder, "pad1"));
414 g_signal_connect_data(G_OBJECT(widget), "activate",
415 G_CALLBACK(OnConf_Pad), NULL, NULL, G_CONNECT_AFTER);
416 #ifdef ENABLE_SIO1API
417 widget = GTK_WIDGET(gtk_builder_get_object(builder, "sio1"));
418 g_signal_connect_data(G_OBJECT(widget), "activate",
419 G_CALLBACK(OnConf_Sio1), NULL, NULL, G_CONNECT_AFTER);
420 #endif
421 widget = GTK_WIDGET(gtk_builder_get_object(builder, "cpu1"));
422 g_signal_connect_data(G_OBJECT(widget), "activate",
423 G_CALLBACK(OnConf_Cpu), NULL, NULL, G_CONNECT_AFTER);
424 widget = GTK_WIDGET(gtk_builder_get_object(builder, "memory_cards1"));
425 g_signal_connect_data(G_OBJECT(widget), "activate",
426 G_CALLBACK(OnConf_Mcds), NULL, NULL, G_CONNECT_AFTER);
427 widget = GTK_WIDGET(gtk_builder_get_object(builder, "net1"));
428 g_signal_connect_data(G_OBJECT(widget), "activate",
429 G_CALLBACK(OnConf_Net), NULL, NULL, G_CONNECT_AFTER);
430 widget = GTK_WIDGET(gtk_builder_get_object(builder, "memorydump1"));
431 g_signal_connect_data(G_OBJECT(widget), "activate",
432 G_CALLBACK(RunDebugMemoryDialog), NULL, NULL, G_CONNECT_AFTER);
433
434 // Cheat menu
435 widget = GTK_WIDGET(gtk_builder_get_object(builder, "browse1"));
436 g_signal_connect_data(G_OBJECT(widget), "activate",
437 G_CALLBACK(RunCheatListDialog), NULL, NULL, G_CONNECT_AFTER);
438 widget = GTK_WIDGET(gtk_builder_get_object(builder, "search1"));
439 g_signal_connect_data(G_OBJECT(widget), "activate",
440 G_CALLBACK(RunCheatSearchDialog), NULL, NULL, G_CONNECT_AFTER);
441
442 // Help menu
443 widget = GTK_WIDGET(gtk_builder_get_object(builder, "about_pcsxr1"));
444 g_signal_connect_data(G_OBJECT(widget), "activate",
445 G_CALLBACK(OnHelp_About), NULL, NULL, G_CONNECT_AFTER);
446
447 // Toolbar
448 widget = GTK_WIDGET(gtk_builder_get_object(builder, "toolbutton_runcd"));
449 g_signal_connect_data(G_OBJECT(widget), "clicked",
450 G_CALLBACK(OnFile_RunCd), NULL, NULL, G_CONNECT_AFTER);
451
452 widget = GTK_WIDGET(gtk_builder_get_object(builder, "toolbutton_runimage"));
453 g_signal_connect_data(G_OBJECT(widget), "clicked",
454 G_CALLBACK(OnFile_RunImage), NULL, NULL, G_CONNECT_AFTER);
455
456 widget = GTK_WIDGET(gtk_builder_get_object(builder, "toolbutton_run"));
457 g_signal_connect_data(G_OBJECT(widget), "clicked",
458 G_CALLBACK(OnEmu_Run), NULL, NULL, G_CONNECT_AFTER);
459
460 widget = GTK_WIDGET(gtk_builder_get_object(builder, "toolbutton_switchimage"));
461 g_signal_connect_data(G_OBJECT(widget), "clicked",
462 G_CALLBACK(OnEmu_SwitchImage), NULL, NULL, G_CONNECT_AFTER);
463
464 widget = GTK_WIDGET(gtk_builder_get_object(builder, "toolbutton_memcards"));
465 g_signal_connect_data(G_OBJECT(widget), "clicked",
466 G_CALLBACK(OnConf_Mcds), NULL, NULL, G_CONNECT_AFTER);
467
468 widget = GTK_WIDGET(gtk_builder_get_object(builder, "toolbutton_graphics"));
469 g_signal_connect_data(G_OBJECT(widget), "clicked",
470 G_CALLBACK(OnConf_Graphics), NULL, NULL, G_CONNECT_AFTER);
471
472 widget = GTK_WIDGET(gtk_builder_get_object(builder, "toolbutton_sound"));
473 g_signal_connect_data(G_OBJECT(widget), "clicked",
474 G_CALLBACK(OnConf_Sound), NULL, NULL, G_CONNECT_AFTER);
475
476 widget = GTK_WIDGET(gtk_builder_get_object(builder, "toolbutton_cdrom"));
477 g_signal_connect_data(G_OBJECT(widget), "clicked",
478 G_CALLBACK(OnConf_CdRom), NULL, NULL, G_CONNECT_AFTER);
479
480 widget = GTK_WIDGET(gtk_builder_get_object(builder, "toolbutton_controllers"));
481 g_signal_connect_data(G_OBJECT(widget), "clicked",
482 G_CALLBACK(OnConf_Pad), NULL, NULL, G_CONNECT_AFTER);
483
484 gtk_main();
485 }
486
487 void OnDestroy() {
488 if (!destroy) OnFile_Exit();
489 }
490
491 void destroy_main_window () {
492 #ifdef DISABLE_GNOME_SCREENSAVER
493 // Disable GNOME screensaver
494 int response_token = 0;
495 GError *error;
496 GDBusProxy *proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
497 G_DBUS_PROXY_FLAGS_NONE, NULL,
498 "org.gnome.ScreenSaver",
499 "org/gnome/ScreenSaver",
500 "org.gnome.ScreenSaver",
501 NULL, &error);
502
503 GVariant *retval = g_dbus_proxy_call_sync (proxy,
504 "Inhibit",
505 g_variant_new ("(ssu)", "PCSXR",
506 "Emulating",
507 response_token),
508 G_DBUS_CALL_FLAGS_NONE,
509 2, /* timeout */
510 NULL, /* cancellable */
511 &error);
512 printf("Response %i\n", response_token);
513 #endif
514
515 destroy = 1;
516 gtk_widget_destroy(Window);
517 Window = NULL;
518 destroy = 0;
519 gtk_main_quit();
520 while (gtk_events_pending()) gtk_main_iteration();
521 }
522
523 void OnFile_RunExe() {
524 GtkWidget *file_chooser;
525
526 if (plugins_configured() == FALSE) {
527 ConfigurePlugins();
528 } else {
529 file_chooser = gtk_file_chooser_dialog_new(_("Select PSX EXE File"),
530 NULL, GTK_FILE_CHOOSER_ACTION_OPEN,
531 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
532 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
533
534 // Add file filters
535 GtkFileFilter *exefilter = gtk_file_filter_new ();
536 gtk_file_filter_add_pattern (exefilter, "*.exe");
537 gtk_file_filter_add_pattern (exefilter, "*.psx");
538 gtk_file_filter_add_pattern (exefilter, "*.cpe");
539 gtk_file_filter_add_pattern (exefilter, "*.EXE");
540 gtk_file_filter_add_pattern (exefilter, "*.PSX");
541 gtk_file_filter_add_pattern (exefilter, "*.CPE");
542 gtk_file_filter_set_name (exefilter, _("PlayStation Executable Files"));
543 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (file_chooser), exefilter);
544 GtkFileFilter *allfilter = gtk_file_filter_new ();
545 gtk_file_filter_add_pattern (allfilter, "*");
546 gtk_file_filter_set_name (allfilter, _("All Files"));
547 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (file_chooser), allfilter);
548
549 // Set this to the config object and retain it - maybe LastUsedDir
550 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(file_chooser), getenv("HOME"));
551
552 if (gtk_dialog_run(GTK_DIALOG(file_chooser)) == GTK_RESPONSE_ACCEPT) {
553 gchar *file;
554
555 /* TODO Need to validate the file */
556
557 file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(file_chooser));
558
559 gtk_widget_destroy (file_chooser);
560 destroy_main_window();
561
562 SetIsoFile(NULL);
563 LoadPlugins();
564 NetOpened = FALSE;
565
566 if (OpenPlugins() == -1) {
567 g_free(file);
568 SysRunGui();
569 } else {
570 // Auto-detect: get region first, then rcnt-bios reset
571 SysReset();
572
573 if (Load(file) == 0) {
574 g_free(file);
575 psxCpu->Execute();
576 } else {
577 g_free(file);
578 ClosePlugins();
579 SysErrorMessage(_("Not a valid PSX file"), _("The file does not appear to be a valid Playstation executable"));
580 SysRunGui();
581 }
582 }
583 } else
584 gtk_widget_destroy(file_chooser);
585 }
586 }
587
588 void OnFile_RunCd() {
589 if (plugins_configured() == FALSE) {
590 ConfigurePlugins();
591 return;
592 }
593
594 destroy_main_window();
595
596 SetIsoFile(NULL);
597 LoadPlugins();
598 NetOpened = FALSE;
599
600 if (OpenPlugins() == -1) {
601 SysRunGui();
602 return;
603 }
604
605 if (CheckCdrom() == -1) {
606 /* Only check the CD if we are starting the console with a CD */
607 ClosePlugins();
608 SysErrorMessage (_("CD ROM failed"), _("The CD does not appear to be a valid Playstation CD"));
609 SysRunGui();
610 return;
611 }
612
613 // Auto-detect: get region first, then rcnt-bios reset
614 SysReset();
615
616 // Read main executable directly from CDRom and start it
617 if (LoadCdrom() == -1) {
618 ClosePlugins();
619 SysErrorMessage(_("Could not load CD-ROM!"), _("The CD-ROM could not be loaded"));
620 SysRunGui();
621 }
622
623 autoloadCheats();
624 psxCpu->Execute();
625 }
626
627 void OnFile_RunBios() {
628 if (plugins_configured() == FALSE) {
629 ConfigurePlugins();
630 return;
631 }
632
633 if (strcmp(Config.Bios, "HLE") == 0) {
634 SysErrorMessage (_("Could not run BIOS"), _("Running BIOS is not supported with Internal HLE BIOS."));
635 return;
636 }
637
638 destroy_main_window();
639
640 SetIsoFile(NULL);
641 LoadPlugins();
642 NetOpened = FALSE;
643
644 if (OpenPlugins() == -1) {
645 SysRunGui();
646 return;
647 }
648
649 SysReset();
650
651 CdromId[0] = '\0';
652 CdromLabel[0] = '\0';
653
654 psxCpu->Execute();
655 }
656
657 static gchar *Open_Iso_Proc() {
658 struct stat sb;
659 GtkWidget *chooser;
660 gchar *filename;
661 GtkFileFilter *psxfilter, *allfilter;
662 static char current_folder[MAXPATHLEN] = "";
663
664 chooser = gtk_file_chooser_dialog_new (_("Open PSX Disc Image File"),
665 NULL, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
666 GTK_STOCK_OK, GTK_RESPONSE_OK,
667 NULL);
668
669 if (stat(Config.IsoImgDir, &sb) == 0 && S_ISDIR(sb.st_mode)) {
670 strcpy(current_folder, Config.IsoImgDir);
671 } else if (strlen(Config.IsoImgDir) <= 0) {
672 strcpy(current_folder, getenv("HOME"));
673 } else {
674 /* Using static (recent) PATH */
675 }
676
677 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (chooser), current_folder);
678
679 psxfilter = gtk_file_filter_new();
680 gtk_file_filter_add_pattern(psxfilter, "*.bin");
681 gtk_file_filter_add_pattern(psxfilter, "*.img");
682 gtk_file_filter_add_pattern(psxfilter, "*.mdf");
683 gtk_file_filter_add_pattern(psxfilter, "*.iso");
684 gtk_file_filter_add_pattern(psxfilter, "*.cue");
685 gtk_file_filter_add_pattern(psxfilter, "*.pbp");
686 gtk_file_filter_add_pattern(psxfilter, "*.cbn");
687 gtk_file_filter_add_pattern(psxfilter, "*.BIN");
688 gtk_file_filter_add_pattern(psxfilter, "*.IMG");
689 gtk_file_filter_add_pattern(psxfilter, "*.MDF");
690 gtk_file_filter_add_pattern(psxfilter, "*.ISO");
691 gtk_file_filter_add_pattern(psxfilter, "*.CUE");
692 gtk_file_filter_add_pattern(psxfilter, "*.PBP");
693 gtk_file_filter_add_pattern(psxfilter, "*.CBN");
694 gtk_file_filter_add_pattern(psxfilter, "*.ecm");
695 gtk_file_filter_set_name(psxfilter, _("PSX Image Files (*.bin, *.img, *.mdf, *.iso, *.ecm, *.cue, *.pbp, *.cbn)"));
696 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (chooser), psxfilter);
697
698 allfilter = gtk_file_filter_new();
699 gtk_file_filter_add_pattern(allfilter, "*");
700 gtk_file_filter_set_name(allfilter, _("All Files"));
701 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (chooser), allfilter);
702
703 if (gtk_dialog_run(GTK_DIALOG(chooser)) == GTK_RESPONSE_OK) {
704 gchar *path = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(chooser));
705
706 /* Workaround:
707 for some reasons gtk_file_chooser_get_current_folder return NULL
708 if a file is selected from "Recently Used" or "Searsh"*/
709 if(path != NULL) {
710 strcpy(current_folder, path);
711 g_free(path);
712 }
713
714 GSList * l = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER (chooser));
715 if(l) {
716 filename = l->data;
717
718 /* if the file was selected from "Recently Used" or "Searsh"
719 we need to extract the path from the filename to set it to current_folder*/
720 if(path == NULL) {
721 strncpy(current_folder, filename, strrchr(filename, '/') - filename);
722 }
723
724 /* If ISO path is NULL save current path. */
725 if (!S_ISDIR(sb.st_mode)) {
726 strcpy(Config.IsoImgDir, current_folder);
727 SaveConfig();
728 }
729
730 /* free useless data */
731 GSList * ll = l;
732 while(l->next) {
733 l = l->next;
734 g_free(l->data);
735 }
736 g_slist_free(ll);
737
738 gtk_widget_destroy(GTK_WIDGET(chooser));
739 while (gtk_events_pending()) gtk_main_iteration();
740 return filename;
741 } else {
742 gtk_widget_destroy (GTK_WIDGET(chooser));
743 while (gtk_events_pending()) gtk_main_iteration();
744 return NULL;
745 }
746 } else {
747 gtk_widget_destroy (GTK_WIDGET(chooser));
748 while (gtk_events_pending()) gtk_main_iteration();
749 return NULL;
750 }
751 }
752
753 void OnFile_RunImage() {
754 gchar *filename;
755
756 if (plugins_configured() == FALSE) {
757 ConfigurePlugins();
758 return;
759 }
760
761 filename = Open_Iso_Proc();
762 if (filename == NULL) {
763 return;
764 }
765
766 destroy_main_window();
767
768 SetIsoFile(filename);
769 g_free(filename);
770
771 LoadPlugins();
772 NetOpened = FALSE;
773
774 if (OpenPlugins() == -1) {
775 SysRunGui();
776 return;
777 }
778
779 if (CheckCdrom() == -1) {
780 // Only check the CD if we are starting the console with a CD
781 ClosePlugins();
782 SysErrorMessage (_("CD ROM failed"), _("The CD does not appear to be a valid Playstation CD"));
783 SysRunGui();
784 return;
785 }
786
787 // Auto-detect: get region first, then rcnt-bios reset
788 SysReset();
789
790 // Read main executable directly from CDRom and start it
791 if (LoadCdrom() == -1) {
792 ClosePlugins();
793 SysErrorMessage(_("Could not load CD-ROM!"), _("The CD-ROM could not be loaded"));
794 SysRunGui();
795 }
796
797 autoloadCheats();
798 psxCpu->Execute();
799 }
800
801 void OnEmu_Run() {
802 if (plugins_configured() == FALSE) {
803 ConfigurePlugins();
804 return;
805 }
806
807 destroy_main_window();
808
809 if (OpenPlugins() == -1) {
810 SysRunGui();
811 return;
812 }
813
814 CheatSearchBackupMemory();
815 psxCpu->Execute();
816 }
817
818 void OnEmu_Reset() {
819 if (plugins_configured() == FALSE) {
820 ConfigurePlugins();
821 return;
822 }
823
824 destroy_main_window();
825
826 if (OpenPlugins() == -1) {
827 SysRunGui();
828 return;
829 }
830
831 if (CheckCdrom() != -1) {
832 LoadCdrom();
833 }
834
835 // Auto-detect: get region first, then rcnt-bios reset
836 SysReset();
837
838 psxCpu->Execute();
839 }
840
841 void OnEmu_Shutdown() {
842 ReleasePlugins();
843 SetIsoFile(NULL);
844 CdromId[0] = '\0';
845 CdromLabel[0] = '\0';
846 ResetMenuSlots();
847 }
848
849 void OnEmu_SwitchImage() {
850 gchar *filename;
851
852 if (plugins_configured() == FALSE) {
853 ConfigurePlugins();
854 return;
855 }
856
857 filename = Open_Iso_Proc();
858 if (filename == NULL) {
859 return;
860 }
861
862 destroy_main_window();
863
864 SetIsoFile(filename);
865 g_free(filename);
866
867 if (OpenPlugins() == -1) {
868 SysRunGui();
869 return;
870 }
871
872 SetCdOpenCaseTime(time(NULL) + 2);
873 LidInterrupt(); // causes CD lid open event
874
875 CheatSearchBackupMemory();
876 psxCpu->Execute();
877 }
878
879 void OnFile_Exit() {
880 DIR *dir;
881 struct dirent *ent;
882 void *Handle;
883 gchar *plugin = NULL;
884 gchar *dotdir;
885
886 dotdir = g_build_filename(getenv("HOME"), PLUGINS_DIR, NULL);
887
888 // with this the problem with plugins that are linked with the pthread
889 // library is solved
890
891 dir = opendir(dotdir);
892 if (dir != NULL) {
893 while ((ent = readdir(dir)) != NULL) {
894 plugin = g_build_filename(dotdir, ent->d_name, NULL);
895
896 if (strstr(plugin, ".so") == NULL && strstr(plugin, ".dylib") == NULL)
897 continue;
898 Handle = dlopen(plugin, RTLD_NOW);
899 if (Handle == NULL)
900 continue;
901
902 g_free(plugin);
903 }
904 }
905 g_free(dotdir);
906
907 bind_textdomain_codeset(PACKAGE_NAME, "");
908 if (UseGui)
909 gtk_main_quit();
910 SysClose();
911 exit(0);
912 }
913
914 void state_load(gchar *state_filename) {
915 int ret;
916 char Text[MAXPATHLEN + 20];
917 FILE *fp;
918
919 // check if the state file actually exists
920 fp = fopen(state_filename, "rb");
921 if (fp == NULL) {
922 // file does not exist
923 return;
924 }
925
926 fclose(fp);
927
928 // If the window exists, then we are loading the state from within
929 // the PCSXR GUI. We need to initialise the plugins first.
930 if (Window) {
931 destroy_main_window();
932
933 if (OpenPlugins() == -1) {
934 SysRunGui();
935 return;
936 }
937 }
938
939 ret = CheckState(state_filename);
940
941 if (ret == 0) {
942 // Check the CD-ROM is valid
943 if (CheckCdrom() == -1) {
944 ClosePlugins();
945 SysRunGui();
946 return;
947 }
948
949 // Auto-detect: region first, then rcnt reset
950 SysReset();
951 ret = LoadState(state_filename);
952
953 sprintf(Text, _("Loaded state %s."), state_filename);
954 GPU_displayText(Text);
955 } else {
956 sprintf(Text, _("Error loading state %s!"), state_filename);
957 GPU_displayText(Text);
958 }
959 }
960
961 void state_save(gchar *state_filename) {
962 char Text[MAXPATHLEN + 20];
963
964 // If the window exists, then we are saving the state from within
965 // the PCSXR GUI. We need to initialise the plugins first.
966 if (Window) {
967 destroy_main_window();
968
969 if (OpenPlugins() == -1) {
970 SysRunGui();
971 return;
972 }
973 }
974
975 GPU_updateLace();
976
977 if (SaveState(state_filename) == 0)
978 sprintf(Text, _("Saved state %s."), state_filename);
979 else
980 sprintf(Text, _("Error saving state %s!"), state_filename);
981
982 GPU_displayText(Text);
983 }
984
985 void on_states_load (GtkWidget *widget, gpointer user_data) {
986 (void)widget; // unused
987
988 gchar *state_filename;
989 gint state = GPOINTER_TO_INT(user_data);
990
991 state_filename = get_state_filename(state);
992
993 state_load(state_filename);
994
995 g_free(state_filename);
996
997 psxCpu->Execute();
998 }
999
1000 void on_states_save (GtkWidget *widget, gpointer user_data) {
1001 (void)widget; // unused
1002
1003 gchar *state_filename;
1004 gint state = GPOINTER_TO_INT(user_data);
1005
1006 state_filename = get_state_filename(state);
1007
1008 state_save(state_filename);
1009
1010 g_free(state_filename);
1011 }
1012
1013 void on_states_load_other() {
1014 GtkWidget *file_chooser;
1015 gchar *SStateFile;
1016
1017 SStateFile = g_strconcat(getenv("HOME"), STATES_DIR, NULL);
1018
1019 file_chooser = gtk_file_chooser_dialog_new(_("Select State File"), NULL, GTK_FILE_CHOOSER_ACTION_OPEN,
1020 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1021 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
1022 NULL);
1023 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (file_chooser), SStateFile);
1024 g_free(SStateFile);
1025
1026 if (gtk_dialog_run(GTK_DIALOG(file_chooser)) == GTK_RESPONSE_ACCEPT) {
1027 gchar *filename;
1028
1029 filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(file_chooser));
1030 gtk_widget_destroy(file_chooser);
1031
1032 state_load(filename);
1033
1034 g_free(filename);
1035
1036 psxCpu->Execute();
1037 } else
1038 gtk_widget_destroy(file_chooser);
1039 }
1040
1041 void on_states_save_other() {
1042 GtkWidget *file_chooser;
1043 gchar *SStateFile;
1044
1045 SStateFile = g_strconcat (getenv("HOME"), STATES_DIR, NULL);
1046
1047 file_chooser = gtk_file_chooser_dialog_new(_("Select State File"),
1048 NULL, GTK_FILE_CHOOSER_ACTION_SAVE,
1049 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1050 GTK_STOCK_SAVE, GTK_RESPONSE_OK,
1051 NULL);
1052 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(file_chooser), SStateFile);
1053 g_free(SStateFile);
1054
1055 if (gtk_dialog_run (GTK_DIALOG(file_chooser)) == GTK_RESPONSE_OK) {
1056 gchar *filename;
1057
1058 filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER (file_chooser));
1059 gtk_widget_destroy(file_chooser);
1060
1061 state_save(filename);
1062
1063 g_free(filename);
1064 }
1065 else
1066 gtk_widget_destroy(file_chooser);
1067 }
1068
1069 void OnHelp_About(GtkWidget *widget, gpointer user_data) {
1070 RunAboutDialog();
1071 }
1072
1073 void SysMessage(const char *fmt, ...) {
1074 GtkWidget *Txt, *MsgDlg;
1075 va_list list;
1076 char msg[512];
1077
1078 va_start(list, fmt);
1079 vsprintf(msg, fmt, list);
1080 va_end(list);
1081
1082 if (msg[strlen(msg) - 1] == '\n')
1083 msg[strlen(msg) - 1] = 0;
1084
1085 if (!UseGui) {
1086 fprintf(stderr, "%s\n", msg);
1087 return;
1088 }
1089
1090 MsgDlg = gtk_dialog_new_with_buttons(_("Notice"), NULL,
1091 GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_OK, GTK_RESPONSE_NONE, NULL);
1092
1093 gtk_window_set_position (GTK_WINDOW(MsgDlg), GTK_WIN_POS_CENTER);
1094
1095 Txt = gtk_label_new (msg);
1096 gtk_label_set_line_wrap(GTK_LABEL(Txt), TRUE);
1097 gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area(GTK_DIALOG(MsgDlg))), Txt);
1098
1099 gtk_widget_show (Txt);
1100 gtk_widget_show_all (MsgDlg);
1101 gtk_dialog_run (GTK_DIALOG(MsgDlg));
1102 gtk_widget_destroy (MsgDlg);
1103 }
1104
1105 void SysErrorMessage(gchar *primary, gchar *secondary) {
1106 GtkWidget *message_dialog;
1107 if (!UseGui)
1108 printf ("%s - %s\n", primary, secondary);
1109 else {
1110 message_dialog = gtk_message_dialog_new(NULL,
1111 GTK_DIALOG_MODAL,
1112 GTK_MESSAGE_ERROR,
1113 GTK_BUTTONS_CLOSE,
1114 primary,
1115 NULL);
1116 gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(message_dialog),
1117 "s", secondary);
1118
1119 gtk_dialog_run(GTK_DIALOG(message_dialog));
1120 gtk_widget_destroy(message_dialog);
1121 }
1122 }
1123
1124 void SysInfoMessage(gchar *primary, gchar *secondary) {
1125 GtkWidget *message_dialog;
1126 if (!UseGui)
1127 printf ("%s - %s\n", primary, secondary);
1128 else {
1129 message_dialog = gtk_message_dialog_new(NULL,
1130 GTK_DIALOG_MODAL,
1131 GTK_MESSAGE_INFO,
1132 GTK_BUTTONS_CLOSE,
1133 primary,
1134 NULL);
1135 gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(message_dialog),
1136 "s", secondary);
1137
1138 gtk_dialog_run(GTK_DIALOG(message_dialog));
1139 gtk_widget_destroy(message_dialog);
1140 }
1141 }