![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ui-gtk.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Generator SEGA Genesis emulator] / generator / main|
Return to ui-gtk.c CVS log | Up to [Generator SEGA Genesis emulator] / generator / main |
1.1 root 1: /* Generator is (c) James Ponder, 1997-2001 http://www.squish.net/generator/ */
2:
3: /* gtk user interface */
4:
5: #include <sys/types.h>
6: #include <sys/stat.h>
7: #include <unistd.h>
8: #include <fcntl.h>
9: #include <errno.h>
10: #include <stdio.h>
11: #include <stdlib.h>
12: #include <string.h>
13: #include <pwd.h>
14:
15: #include <gtk/gtk.h>
16: #include <gdk/gdkx.h>
17:
18: /* need Xlib.h for XAutoRepeatOff - how poo is X */
19: #include "X11/Xlib.h"
20:
21: #include "SDL.h"
22:
23: #include "generator.h"
24: #include "snprintf.h"
25:
26: #include "glade/interface.h"
27: #include "glade/support.h"
28:
29: #include "ui.h"
30: #include "ui-gtk.h"
31: #include "uiplot.h"
32: #include "gtkopts.h"
33:
34: #include "vdp.h"
35: #include "gensound.h"
36: #include "cpu68k.h"
37: #include "mem68k.h"
38: #include "cpuz80.h"
39: #include "event.h"
40: #include "state.h"
41: #include "initcart.h"
42:
43: #define HBORDER_MAX 32
44: #define HBORDER_DEFAULT 8
45:
46: #define VBORDER_MAX 32
47: #define VBORDER_DEFAULT 8
48:
49: #define HMAXSIZE (320 + 2 * HBORDER_MAX)
50: #define VMAXSIZE (240 + 2 * VBORDER_MAX)
51:
52: #define HSIZE (320 + 2 * ui_hborder)
53: #define VSIZE ((vdp_vislines ? vdp_vislines : 224) + 2 * ui_vborder)
54:
55: typedef struct {
56: unsigned int a;
57: unsigned int b;
58: unsigned int c;
59: unsigned int up;
60: unsigned int down;
61: unsigned int left;
62: unsigned int right;
63: unsigned int start;
64: } t_gtkkeys;
65:
66: const char *ui_gtk_keys[] = {
67: "a", "b", "c", "start", "left", "right", "up", "down"
68: };
69:
70: /*** static variables ***/
71:
72: static SDL_Surface *screen = NULL; /* SDL screen */
73:
74: static char *ui_initload = NULL; /* filename to load on init */
75: static char *ui_configfile = NULL; /* configuration file */
76: static uint8 ui_plotfield = 0; /* flag indicating plotting this field */
77: static uint8 ui_vdpsimple = 0; /* 0=raster, 1=cell based plotter */
78: static int ui_running = 0; /* running a game */
79: static GtkWidget *ui_win_main; /* main window */
80: static GtkWidget *ui_win_about; /* about window */
81: static GtkWidget *ui_win_console; /* console window */
82: static GtkWidget *ui_win_opts; /* options window */
83: static GtkWidget *ui_win_filesel; /* file selection window */
84: static int ui_filesel_type; /* selection type: 0=rom, 1=state */
85: static int ui_filesel_save; /* 0=load, 1=save */
86: static GtkWidget *ui_gtk_dialog(const char *msg);
87: static uint8 ui_frameskip = 0; /* 0 for dynamic */
88: static uint8 ui_actualskip = 0; /* the last skip we did (1..) */
89: static uint8 ui_statusbar = 1; /* status-bar? */
90: static uint8 ui_screen[3][4 * HMAXSIZE * VMAXSIZE]; /* screen buffers */
91: static uint8 *ui_screen0; /* pointer to screen block for bank 0 */
92: static uint8 *ui_screen1; /* pointer to screen block for bank 1 */
93: static uint8 *ui_newscreen; /* pointer to new screen block */
94: static int ui_whichbank; /* current viewed screen */
95: static int ui_locksurface; /* lock SDL surface? */
96: static unsigned int ui_hborder = HBORDER_DEFAULT; /* horizontal border */
97: static unsigned int ui_vborder = VBORDER_DEFAULT; /* vertical border */
98: static int ui_query_response = -1; /* query response */
99: t_gtkkeys ui_cont[2]; /* keyboard key codes */
100: static int ui_musicfile = -1; /* fd of output file for GYM/GNM logging */
101:
102: static enum {
103: SCREEN_100, SCREEN_200, SCREEN_FULL
104: } ui_screenmode = SCREEN_100;
105:
106: t_interlace ui_interlace = DEINTERLACE_WEAVEFILTER;
107:
108: /*** Forward references ***/
109:
110: static void ui_usage(void);
111: static void ui_gtk_filesel_ok(GtkFileSelection * obj, gpointer user_data);
112: static void ui_gtk_sizechange(void);
113: static void ui_newframe(void);
114: static void ui_rendertoscreen(void);
115: static gint ui_gtk_configuremain(GtkWidget * widget,
116: GdkEventConfigure * event);
117: static int ui_topbit(unsigned long int bits);
118: static void ui_gtk_opts_to_window(void);
119: static void ui_gtk_opts_from_window(void);
120: static int ui_gtk_query(const char *msg, int style);
121: static void ui_gtk_opts_to_menu(void);
122: static void ui_simpleplot(void);
123:
124: /*** Program entry point ***/
125:
126: int ui_init(int argc, char *argv[])
127: {
128: char ch;
129: GtkWidget *button, *draw, *obj;
130: struct passwd *passwd;
131: struct stat statbuf;
132:
133: gtk_set_locale();
134: gtk_init(&argc, &argv);
135:
136: while ((ch = getopt(argc, argv, "?dc:w:")) != -1) {
137: switch (ch) {
138: case 'd': /* turn on debug mode */
139: gen_debugmode = 1;
140: break;
141: case 'c': /* configuration file */
142: ui_configfile = optarg;
143: break;
144: case 'w': /* saved game work dir */
145: chdir(optarg); /* for the moment this will do */
146: break;
147: case '?':
148: default:
149: ui_usage();
150: }
151: }
152: argc -= optind;
153: argv += optind;
154:
155: if (argc > 0) {
156: ui_initload = argv[0];
157: argc--;
158: argv++;
159: }
160:
161: if (argc != 0)
162: ui_usage();
163:
164: if (ui_configfile == NULL) {
165: if ((passwd = getpwuid(getuid())) == NULL) {
166: fprintf(stderr, "Who are you? (getpwent failed)\n");
167: exit(1);
168: }
169: ui_configfile = malloc(strlen(passwd->pw_dir) + sizeof("/.genrc"));
170: sprintf(ui_configfile, "%s/.genrc", passwd->pw_dir);
171: }
172: if (stat(ui_configfile, &statbuf) != 0) {
173: fprintf(stderr, "No configuration file found, using defaults.\n");
174: } else {
175: if (gtkopts_load(ui_configfile) != 0)
176: fprintf(stderr, "Error loading configuration file, using defaults.\n");
177: }
178:
179: /* create gtk windows */
180:
181: ui_win_main = create_mainwin();
182: ui_win_about = create_about();
183: ui_win_console = create_console();
184: ui_win_opts = create_opts();
185: ui_win_filesel = gtk_file_selection_new("Select file...");
186: button = GTK_FILE_SELECTION(ui_win_filesel)->ok_button;
187: gtk_signal_connect(GTK_OBJECT(button), "clicked",
188: GTK_SIGNAL_FUNC(ui_gtk_filesel_ok), NULL);
189: button = GTK_FILE_SELECTION(ui_win_filesel)->cancel_button;
190: gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
191: GTK_SIGNAL_FUNC(gtk_widget_hide),
192: GTK_OBJECT(ui_win_filesel));
193:
194: /* open main window */
195:
196: gtk_widget_add_events(ui_win_main, GDK_KEY_RELEASE_MASK);
197: gtk_window_set_title(GTK_WINDOW(ui_win_main), "Generator/gtk " VERSION);
198: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_main), "debug"));
199: if (!gen_debugmode)
200: gtk_widget_hide(obj);
201: gtk_widget_show(ui_win_main);
202: draw = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_main),
203: "drawingarea_main"));
204: gtk_signal_connect(GTK_OBJECT(ui_win_main), "configure_event",
205: GTK_SIGNAL_FUNC(ui_gtk_configuremain), 0);
206: {
207: char SDL_windowhack[32];
208: snprintf(SDL_windowhack, sizeof(SDL_windowhack), "SDL_WINDOWID=%ld",
209: GDK_WINDOW_XWINDOW(draw->window));
210: putenv(SDL_windowhack);
211: }
212: if (SDL_Init(SDL_INIT_VIDEO) < 0) {
213: fprintf(stderr, "Couldn't initialise SDL: %s\n", SDL_GetError());
214: return -1;
215: }
216: ui_gtk_sizechange();
217: ui_gtk_newoptions();
218: ui_gtk_opts_to_menu();
219:
220: /* ui_newscreen is where the emulation data is rendered to - it is
221: then compared with ui_screen0 or ui_screen1 depending on which
222: screen bank it is being written to, and the delta changes are sent
223: to screen memory. The ui_screenX and ui_newscreen pointers are then
224: switched, and the next frame/field begins... */
225: memset(ui_screen[0], 0, sizeof(ui_screen[0]));
226: memset(ui_screen[1], 0, sizeof(ui_screen[1]));
227: ui_screen0 = ui_screen[0];
228: ui_screen1 = ui_screen[1];
229: ui_newscreen = ui_screen[2];
230: ui_whichbank = 0; /* viewing 0 */
231: return 0;
232: }
233:
234: static void ui_usage(void)
235: {
236: fprintf(stderr, "Generator is (c) James Ponder 1997-2001, all rights "
237: "reserved. v" VERSION "\n\n");
238: fprintf(stderr, "generator [options] [<rom>]\n\n");
239: fprintf(stderr, " -d debug mode\n");
240: fprintf(stderr, " -w <work dir> set work directory\n");
241: fprintf(stderr, " -c <config file> use alternative config file\n\n");
242: fprintf(stderr, " ROM types supported: .rom or .smd interleaved "
243: "(autodetected)\n");
244: exit(1);
245: }
246:
247: void ui_final(void)
248: {
249: SDL_Quit();
250: }
251:
252: int ui_loop(void)
253: {
254: char *p;
255:
256: if (ui_initload) {
257: p = gen_loadimage(ui_initload);
258: if (p)
259: ui_gtk_dialog(p);
260: } else {
261: gen_loadmemrom(initcart, initcart_len);
262: }
263: while (!gen_quit) {
264: if (ui_running) {
265: while (gtk_events_pending())
266: gtk_main_iteration_do(0);
267: ui_newframe();
268: event_doframe();
269: } else {
270: gtk_main();
271: }
272: }
273: return 0;
274: }
275:
276: void ui_newframe(void)
277: {
278: static int vmode = -1;
279: static int pal = -1;
280: static int skipcount = 0;
281: static char frameplots[60]; /* 60 for NTSC, 50 for PAL */
282: static unsigned int frameplots_i = 0;
283: unsigned int i;
284: int fps;
285: char fps_string[8];
286: GtkWidget *entry_fps;
287: static int lasttype = -1;
288:
289: if (frameplots_i > vdp_framerate)
290: frameplots_i = 0;
291: if (((vdp_reg[12] >> 1) & 3) && vdp_oddframe) {
292: /* interlace mode, and we're about to do an odd field - we always leave
293: ui_plotfield alone so we do fields in pairs, this stablises the
294: display, reduces blurring */
295: } else {
296: ui_plotfield = 0;
297: if (ui_frameskip == 0) {
298: if (sound_feedback != -1)
299: ui_plotfield = 1;
300: } else {
301: if (cpu68k_frames % ui_frameskip == 0)
302: ui_plotfield = 1;
303: }
304: }
305: if (!ui_plotfield) {
306: skipcount++;
307: frameplots[frameplots_i++] = 0;
308: return;
309: }
310: lasttype = vdp_oddframe;
311: /* check for ROM or user changing the vertical size */
312: if (vmode == (int)(vdp_reg[1] & (1 << 3)) || pal != (int)vdp_pal) {
313: vdp_setupvideo();
314: vmode = vdp_reg[1] & (1 << 3);
315: pal = vdp_pal;
316: }
317: /* count the frames we've plotted in the last vdp_framerate real frames */
318: fps = 0;
319: for (i = 0; i < vdp_framerate; i++) {
320: if (frameplots[i])
321: fps++;
322: }
323: frameplots[frameplots_i++] = 1;
324: if (!ui_statusbar)
325: return;
326: snprintf(fps_string, sizeof(fps_string), "%d", fps);
327: entry_fps = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_main),
328: "entry_fps"));
329: gtk_entry_set_text(GTK_ENTRY(entry_fps), fps_string);
330: skipcount = 0;
331: }
332:
333: /* ui_line is called for all vdp_totlines but is offset so that line=0
334: is the first line, line=(vdp_totlines-vdp_visstartline)-1 is the
335: last */
336:
337: void ui_line(int line)
338: {
339: static uint8 gfx[320];
340: unsigned int width = (vdp_reg[12] & 1) ? 320 : 256;
341: unsigned int offset = ui_hborder + ((vdp_reg[12] & 1) ? 0 : 32);
342: uint8 bg;
343: uint32 bgpix;
344: uint8 *location;
345: unsigned int i;
346:
347: if (!ui_plotfield)
348: return;
349: if (ui_vdpsimple) {
350: if (line == (int)(vdp_vislines >> 1))
351: /* if we're in simple cell-based mode, plot when half way down screen */
352: ui_simpleplot();
353: return;
354: }
355: if (line < -(int)ui_vborder || line >= (int)(vdp_vislines + ui_vborder))
356: return;
357:
358: bg = (vdp_reg[7] & 63);
359: uiplot_checkpalcache(0);
360: bgpix = uiplot_palcache[bg];
361: location = ui_newscreen +
362: (line + ui_vborder) * HMAXSIZE * screen->format->BytesPerPixel;
363: if (line < 0 || line >= (int)vdp_vislines) {
364: /* in border */
365: switch (screen->format->BytesPerPixel) {
366: case 2:
367: for (i = 0; i < HSIZE; i++) {
368: ((uint16 *)location)[i] = bgpix;
369: }
370: break;
371: case 4:
372: for (i = 0; i < HSIZE; i++) {
373: ((uint32 *)location)[i] = bgpix;
374: }
375: break;
376: }
377: return;
378: }
379: /* normal line */
380: switch ((vdp_reg[12] >> 1) & 3) {
381: case 0: /* normal */
382: case 1: /* interlace simply doubled up */
383: case 2: /* invalid */
384: vdp_renderline(line, gfx, 0);
385: break;
386: case 3: /* interlace with double resolution */
387: vdp_renderline(line, gfx, vdp_oddframe);
388: break;
389: }
390: switch (screen->format->BytesPerPixel) {
391: case 2:
392: uiplot_convertdata16(gfx, ((uint16 *)location) + offset, width);
393: for (i = 0; i < offset; i++) {
394: ((uint16 *)location)[i] = bgpix;
395: ((uint16 *)location)[i + offset + width] = bgpix;
396: }
397: break;
398: case 4:
399: uiplot_convertdata32(gfx, ((uint32 *)location) + offset, width);
400: for (i = 0; i < offset; i++) {
401: ((uint32 *)location)[i] = bgpix;
402: ((uint32 *)location)[i + offset + width] = bgpix;
403: }
404: break;
405: }
406: }
407:
408: static void ui_simpleplot(void)
409: {
410: static uint8 gfx[(320 + 16) * (240 + 16)];
411: unsigned int width = (vdp_reg[12] & 1) ? 320 : 256;
412: unsigned int offset = ui_hborder + ((vdp_reg[12] & 1) ? 0 : 32);
413: unsigned int line, i;
414: uint8 *location, *location2;
415: uint8 bg;
416: uint32 bgpix;
417: /* cell mode - entire frame done here */
418: bg = (vdp_reg[7] & 63);
419: uiplot_checkpalcache(0);
420: bgpix = uiplot_palcache[bg];
421: vdp_renderframe(gfx + (8 * (320 + 16)) + 8, 320 + 16); /* plot frame */
422: location = ui_newscreen +
423: ui_vborder * HMAXSIZE * screen->format->BytesPerPixel;
424: switch (screen->format->BytesPerPixel) {
425: case 2:
426: for (line = 0; line < vdp_vislines; line++) {
427: for (i = 0; i < offset; i++) {
428: ((uint16 *)location)[i] = bgpix;
429: ((uint16 *)location)[width + offset + i] = bgpix;
430: }
431: uiplot_convertdata16(gfx + 8 + (line + 8) * (320 + 16),
432: ((uint16 *)location) + offset, width);
433: location += HMAXSIZE * 2;
434: }
435: break;
436: case 4:
437: for (line = 0; line < vdp_vislines; line++) {
438: for (i = 0; i < offset; i++) {
439: ((uint32 *)location)[i] = bgpix;
440: ((uint32 *)location)[width + offset + i] = bgpix;
441: }
442: uiplot_convertdata32(gfx + 8 + (line + 8) * (320 + 16),
443: ((uint32 *)location) + offset, width);
444: location += HMAXSIZE * 4;
445: }
446: break;
447: }
448: location = ui_newscreen;
449: location2 = ui_newscreen + (ui_vborder + vdp_vislines) *
450: HMAXSIZE * screen->format->BytesPerPixel;
451: switch (screen->format->BytesPerPixel) {
452: case 2:
453: for (line = 0; line < ui_vborder; line++) {
454: for (i = 0; i < HSIZE; i++) {
455: ((uint16 *)location)[i] = bgpix;
456: ((uint16 *)location2)[i] = bgpix;
457: }
458: location += HMAXSIZE * 2;
459: location2 += HMAXSIZE * 2;
460: }
461: break;
462: case 4:
463: for (line = 0; line < ui_vborder; line++) {
464: for (i = 0; i < HSIZE; i++) {
465: ((uint32 *)location)[i] = bgpix;
466: ((uint32 *)location2)[i] = bgpix;
467: }
468: location += HMAXSIZE * 4;
469: location2 += HMAXSIZE * 4;
470: }
471: break;
472: }
473: }
474:
475: /*** ui_endfield - end of field reached ***/
476:
477: void ui_endfield(void)
478: {
479: static int counter = 0;
480:
481: if (ui_plotfield) {
482: ui_rendertoscreen(); /* plot ui_newscreen to screen */
483: }
484: if (ui_frameskip == 0) {
485: /* dynamic frame skipping */
486: counter++;
487: if (sound_feedback >= 0) {
488: ui_actualskip = counter;
489: counter = 0;
490: }
491: } else {
492: ui_actualskip = ui_frameskip;
493: }
494: }
495:
496: void ui_rendertoscreen(void)
497: {
498: uint8 **oldscreenpp = ui_whichbank ? &ui_screen1 : &ui_screen0;
499: uint8 *scrtmp;
500: uint8 *newlinedata, *oldlinedata;
501: unsigned int line;
502: uint8 *location;
503: uint8 *evenscreen; /* interlace: lines 0,2,etc. */
504: uint8 *oddscreen; /* lines 1,3,etc. */
505:
506: if (ui_locksurface && SDL_LockSurface(screen) != 0)
507: ui_err("Failed to lock SDL surface");
508: for (line = 0; line < VSIZE; line++) {
509: newlinedata = ui_newscreen +
510: line * HMAXSIZE * screen->format->BytesPerPixel;
511: oldlinedata = *oldscreenpp +
512: line * HMAXSIZE * screen->format->BytesPerPixel;
513: switch (ui_screenmode) {
514: case SCREEN_100:
515: location = screen->pixels + line * screen->pitch;
516: /* we could use uiplot_renderXX_x1 routines here, but SDL wouldn't
517: pick up our delta changes so we don't */
518: memcpy(location, newlinedata, HSIZE * screen->format->BytesPerPixel);
519: break;
520: case SCREEN_200:
521: location = screen->pixels + 2 * line * screen->pitch;
522: if (screen->format->BytesPerPixel != 2 &&
523: screen->format->BytesPerPixel != 4)
524: ui_err("unsupported mode for 200%% scaling\n");
525: switch ((vdp_reg[12] >> 1) & 3) { /* interlace mode */
526: case 0:
527: case 1:
528: case 2:
529: switch (screen->format->BytesPerPixel) {
530: case 2:
531: uiplot_render16_x2((uint16 *)newlinedata, NULL, location,
532: screen->pitch, HSIZE);
533: break;
534: case 4:
535: uiplot_render32_x2((uint32 *)newlinedata, NULL, location,
536: screen->pitch, HSIZE);
537: break;
538: }
539: break;
540: case 3:
541: /* work out which buffer contains the odd and even fields */
542: if (vdp_oddframe) {
543: oddscreen = ui_newscreen;
544: evenscreen = ui_whichbank ? ui_screen0 : ui_screen1;
545: } else {
546: evenscreen = ui_newscreen;
547: oddscreen = ui_whichbank ? ui_screen0 : ui_screen1;
548: }
549: switch (ui_interlace) {
550: case DEINTERLACE_BOB:
551: switch (screen->format->BytesPerPixel) {
552: case 2:
553: uiplot_render16_x2((uint16 *)newlinedata, NULL, location,
554: screen->pitch, HSIZE);
555: break;
556: case 4:
557: uiplot_render32_x2((uint32 *)newlinedata, NULL, location,
558: screen->pitch, HSIZE);
559: break;
560: }
561: break;
562: case DEINTERLACE_WEAVE:
563: evenscreen += line * HMAXSIZE * screen->format->BytesPerPixel;
564: oddscreen += line * HMAXSIZE * screen->format->BytesPerPixel;
565: switch (screen->format->BytesPerPixel) {
566: case 2:
567: uiplot_render16_x2h((uint16 *)evenscreen, NULL, location, HSIZE);
568: uiplot_render16_x2h((uint16 *)oddscreen, NULL,
569: location + screen->pitch, HSIZE);
570: break;
571: case 4:
572: uiplot_render32_x2h((uint32 *)evenscreen, NULL, location, HSIZE);
573: uiplot_render32_x2h((uint32 *)oddscreen, NULL,
574: location + screen->pitch, HSIZE);
575: break;
576: }
577: break;
578: case DEINTERLACE_WEAVEFILTER:
579: evenscreen += line * HMAXSIZE * screen->format->BytesPerPixel;
580: oddscreen += line * HMAXSIZE * screen->format->BytesPerPixel;
581: switch (screen->format->BytesPerPixel) {
582: case 2:
583: /* lines line+0 and line+1 */
584: uiplot_irender16_weavefilter((uint16 *)evenscreen,
585: (uint16 *)oddscreen,
586: location, HSIZE);
587: /* lines line+1 and line+2 */
588: uiplot_irender16_weavefilter((uint16 *)oddscreen,
589: ((uint16 *)evenscreen) + HMAXSIZE,
590: location + screen->pitch, HSIZE);
591: break;
592: case 4:
593: /* lines line+0 and line+1 */
594: uiplot_irender32_weavefilter((uint32 *)evenscreen,
595: (uint32 *)oddscreen,
596: location, HSIZE);
597: /* lines line+1 and line+2 */
598: uiplot_irender32_weavefilter((uint32 *)oddscreen,
599: ((uint32 *)evenscreen) + HMAXSIZE,
600: location + screen->pitch, HSIZE);
601: break;
602: }
603: }
604: break;
605: }
606: break;
607: case SCREEN_FULL:
608: default:
609: ui_err("invalid screen mode\n");
610: }
611: }
612: if (ui_locksurface)
613: SDL_UnlockSurface(screen);
614: SDL_UpdateRect(screen, 0, 0, screen->w, screen->h);
615: ui_whichbank ^= 1;
616: // if (ui_vsync)
617: // uip_vsync();
618: /* swap ui_screenX and ui_newscreen pointers */
619: scrtmp = *oldscreenpp;
620: *oldscreenpp = ui_newscreen;
621: ui_newscreen = scrtmp;
622: }
623:
624: /*** logging functions ***/
625:
626: /* logging is done this way because this was the best I could come up with
627: whilst battling with macros that can only take fixed numbers of arguments */
628:
629: #define LOG_FUNC(name,level,txt) void ui_log_ ## name ## (const char *text, ...) \
630: { \
631: va_list ap; \
632: if (gen_loglevel >= level) { \
633: printf("[%s] ", txt); \
634: va_start(ap, text); \
635: vprintf(text, ap); \
636: va_end(ap); \
637: putchar(10); \
638: } \
639: }
640:
641: /* *INDENT-OFF* */
642:
643: LOG_FUNC(debug3, 7, "DEBG ");
644: LOG_FUNC(debug2, 6, "DEBG ");
645: LOG_FUNC(debug1, 5, "DEBG ");
646: LOG_FUNC(user, 4, "USER ");
647: LOG_FUNC(verbose, 3, "---- ");
648: LOG_FUNC(normal, 2, "---- ");
649: LOG_FUNC(critical, 1, "CRIT ");
650: LOG_FUNC(request, 0, "---- "); /* this generates a warning, such is life */
651:
652: /* *INDENT-ON* */
653:
654: /*** ui_err - log error message and quit ***/
655:
656: void ui_err(const char *text, ...)
657: {
658: va_list ap;
659:
660: printf("ERROR: ");
661:
662: va_start(ap, text);
663: vfprintf(stderr, text, ap);
664: va_end(ap);
665: putc(10, stderr);
666: exit(0);
667: }
668:
669: /*** ui_topbit - given an integer return the top most bit set ***/
670:
671: int ui_topbit(unsigned long int bits)
672: {
673: long int bit = 31;
674: unsigned long int mask = 1 << 31;
675:
676: for (; bit >= 0; bit--, mask >>= 1) {
677: if (bits & mask)
678: return bit;
679: }
680: return -1;
681: }
682:
683: /*** ui_setinfo - there is new cart information ***/
684:
685: char *ui_setinfo(t_cartinfo *cartinfo)
686: {
687: (void)cartinfo;
688: return NULL;
689: }
690:
691: /*** gtk functions ***/
692:
693: gint ui_gtk_configuremain(GtkWidget * widget, GdkEventConfigure * event)
694: {
695: (void)widget;
696: (void)event;
697: /* if we were allowing resizing this is where we'd do it, but note
698: to check whether it's just the location or the size being changed
699: as a call to SDL to set the video mode will erase the screen and
700: then everything would go black */
701: return TRUE;
702: }
703:
704: void ui_gtk_filesel_ok(GtkFileSelection * obj, gpointer user_data)
705: {
706: char msg[512];
707: char buf[8];
708: char *file, *p;
709: int fd;
710: struct stat s;
711:
712: (void)obj;
713: (void)user_data;
714: file = gtk_file_selection_get_filename(GTK_FILE_SELECTION(ui_win_filesel));
715: gtk_widget_hide(ui_win_filesel);
716:
717: if (ui_filesel_save) {
718: if (stat(file, &s) == 0) {
719: snprintf(msg, sizeof(msg), "The file '%s' already exists - overwrite?",
720: file);
721: if (ui_gtk_query(msg, 0) != 0)
722: return;
723: }
724: }
725: *msg = '\0';
726:
727: switch ((ui_filesel_type << 1) | ui_filesel_save) {
728: case 0:
729: p = gen_loadimage(file);
730: if (p)
731: snprintf(msg, sizeof(msg), "An error occured whilst tring to load "
732: "the ROM '%s': %s", file, p);
733: break;
734: case 1:
735: if (cpu68k_rom == NULL || cpu68k_romlen == 0) {
736: snprintf(msg, sizeof(msg), "There is no ROM currently in memory to "
737: "save!");
738: break;
739: }
740: if ((fd = open(file, O_CREAT | O_WRONLY | O_TRUNC, 0777)) == -1
741: || write(fd, cpu68k_rom, cpu68k_romlen) == -1 || close(fd) == -1) {
742: snprintf(msg, sizeof(msg), "An error occured whilst trying to save the "
743: "ROM as '%s': %s", file, strerror(errno));
744: }
745: break;
746: case 2:
747: if (stat(file, &s) != 0) {
748: snprintf(msg, sizeof(msg), "%s: %s", file, strerror(errno));
749: break;
750: }
751: if (state_loadfile(file) != 0)
752: snprintf(msg, sizeof(msg), "An error occured whilst trying to load "
753: "state from '%s': %s", file, strerror(errno));
754: break;
755: case 3:
756: if (state_savefile(file) != 0)
757: snprintf(msg, sizeof(msg), "An error occured whilst trying to save "
758: "state to '%s': %s", file, strerror(errno));
759: break;
760: case 5:
761: if (ui_musicfile != -1) {
762: snprintf(msg, sizeof(msg), "There is already a music log in progress");
763: break;
764: }
765: if ((ui_musicfile = open(file, O_CREAT | O_WRONLY | O_TRUNC, 0777)) == -1) {
766: snprintf(msg, sizeof(msg), "An error occured whilst trying to start "
767: "a GYM log to '%s': %s", file, strerror(errno));
768: }
769: gen_musiclog = 1;
770: break;
771: case 7:
772: if (ui_musicfile != -1) {
773: snprintf(msg, sizeof(msg), "There is already a music log in progress");
774: break;
775: }
776: if ((ui_musicfile = open(file, O_CREAT | O_WRONLY | O_TRUNC, 0777)) == -1) {
777: snprintf(msg, sizeof(msg), "An error occured whilst trying to start "
778: "a GNM log to '%s': %s", file, strerror(errno));
779: }
780: buf[0] = 'G'; buf[1] = 'N'; buf[2] = 'M';
781: buf[3] = vdp_framerate;
782: write(ui_musicfile, buf, 4);
783: gen_musiclog = 2;
784: break;
785: default:
786: strcpy(msg, "Not implemented.");
787: break;
788: }
789: if (msg[0])
790: ui_gtk_dialog(msg);
791: }
792:
793: GtkWidget *ui_gtk_dialog(const char *msg)
794: {
795: GtkWidget *dialog, *label, *button_ok;
796:
797: dialog = gtk_dialog_new();
798: label = gtk_label_new(msg);
799: gtk_label_set_line_wrap(GTK_LABEL(label), 1);
800: button_ok = gtk_button_new_with_label("OK");
801: gtk_signal_connect_object(GTK_OBJECT(button_ok), "clicked",
802: GTK_SIGNAL_FUNC(gtk_widget_destroy),
803: GTK_OBJECT(dialog));
804: gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area),
805: button_ok);
806: gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), label);
807: gtk_window_set_modal(GTK_WINDOW(dialog), 1);
808: gtk_window_set_default_size(GTK_WINDOW(dialog), 350, 150);
809: gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER);
810: gtk_widget_show_all(dialog);
811: return dialog;
812: }
813:
814: /* supporting function for ui_gtk_query */
815:
816: static void ui_gtk_response(GtkButton *button, gpointer func_data)
817: {
818: (void)button;
819: ui_query_response = GPOINTER_TO_INT(func_data);
820: gtk_main_quit();
821: }
822:
823: /* ask a question and return 0 for OK/Yes, -1 for Cancel/No */
824:
825: static int ui_gtk_query(const char *msg, int style)
826: {
827: GtkWidget *dialog, *label, *button_a, *button_b, *hbox;
828:
829: dialog = gtk_dialog_new();
830: label = gtk_label_new(msg);
831: hbox = gtk_hbox_new(1, 8);
832: gtk_label_set_line_wrap(GTK_LABEL(label), 1);
833: switch (style) {
834: default:
835: case 0:
836: button_a = gtk_button_new_with_label("OK");
837: button_b = gtk_button_new_with_label("Cancel");
838: break;
839: case 1:
840: button_a = gtk_button_new_with_label("Yes");
841: button_b = gtk_button_new_with_label("No");
842: break;
843: }
844: gtk_box_pack_end(GTK_BOX(hbox), button_b, 0, 1, 0);
845: gtk_box_pack_end(GTK_BOX(hbox), button_a, 0, 1, 0);
846: gtk_signal_connect(GTK_OBJECT(button_a), "clicked",
847: GTK_SIGNAL_FUNC(ui_gtk_response),
848: GINT_TO_POINTER(0));
849: gtk_signal_connect(GTK_OBJECT(button_b), "clicked",
850: GTK_SIGNAL_FUNC(ui_gtk_response),
851: GINT_TO_POINTER(-1));
852: gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area),
853: hbox);
854: gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), label);
855: gtk_window_set_modal(GTK_WINDOW(dialog), 1);
856: gtk_window_set_default_size(GTK_WINDOW(dialog), 350, 150);
857: gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER);
858: gtk_widget_show_all(dialog);
859: ui_query_response = -1;
860: gtk_main();
861: gtk_widget_destroy(dialog);
862: return ui_query_response;
863: }
864:
865: void ui_gtk_filesel(int type, int save)
866: {
867: ui_filesel_type = type;
868: ui_filesel_save = save;
869:
870: switch ((type << 1) | save) {
871: case 0:
872: gtk_window_set_title(GTK_WINDOW(ui_win_filesel),
873: "Choose ROM file (BIN or SMD format) to load");
874: break;
875: case 1:
876: gtk_window_set_title(GTK_WINDOW(ui_win_filesel),
877: "Choose filename to save ROM file (BIN format) to");
878: break;
879: case 2:
880: gtk_window_set_title(GTK_WINDOW(ui_win_filesel),
881: "Choose state file to load");
882: break;
883: case 3:
884: gtk_window_set_title(GTK_WINDOW(ui_win_filesel),
885: "Choose filename to save state to");
886: break;
887: case 5:
888: gtk_window_set_title(GTK_WINDOW(ui_win_filesel),
889: "Choose where to start GYM logging");
890: break;
891: case 7:
892: gtk_window_set_title(GTK_WINDOW(ui_win_filesel),
893: "Choose where to start GNM logging");
894: break;
895: }
896: gtk_widget_show(ui_win_filesel);
897: }
898:
899: void ui_gtk_about(void)
900: {
901: gtk_widget_show(ui_win_about);
902: }
903:
904: void ui_gtk_options(void)
905: {
906: ui_gtk_opts_to_window();
907: gtk_widget_show(ui_win_opts);
908: }
909:
910: void ui_gtk_console(void)
911: {
912: gtk_widget_show(ui_win_console);
913: }
914:
915: void ui_gtk_quit(void)
916: {
917: gen_quit = 1;
918: gtk_main_quit();
919: }
920:
921: void ui_gtk_closeconsole(void)
922: {
923: gtk_widget_hide(ui_win_console);
924: }
925:
926: void ui_gtk_play(void)
927: {
928: if (ui_running) {
929: ui_gtk_dialog("Generator is already playing a ROM");
930: return;
931: }
932: if (cpu68k_rom == NULL || cpu68k_romlen == 0) {
933: ui_gtk_dialog("You must load a ROM into Generator");
934: return;
935: }
936: /* start running the game */
937: ui_running = 1;
938: ui_gtk_sizechange();
939: gtk_main_quit();
940: }
941:
942: void ui_gtk_pause(void)
943: {
944: if (!ui_running) {
945: ui_gtk_dialog("Generator is not playing a ROM");
946: return;
947: }
948: ui_running = 0;
949: }
950:
951: void ui_gtk_softreset(void)
952: {
953: gen_softreset();
954: }
955:
956: void ui_gtk_hardreset(void)
957: {
958: gen_reset();
959: }
960:
961: /* set main window size from current parameters */
962:
963: void ui_gtk_sizechange(void)
964: {
965: GtkWidget *w;
966:
967: w = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_main),
968: "drawingarea_main"));
969: switch (ui_screenmode) {
970: case SCREEN_100:
971: gtk_widget_set_usize(w, HSIZE, VSIZE);
972: screen = SDL_SetVideoMode(HSIZE, VSIZE, 0, 0);
973: break;
974: case SCREEN_200:
975: gtk_widget_set_usize(w, HSIZE * 2, VSIZE * 2);
976: screen = SDL_SetVideoMode(HSIZE * 2, VSIZE * 2, 0, 0);
977: break;
978: default:
979: ui_err("invalid screen mode\n");
980: }
981: w = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_main), "hbox_bottom"));
982: if (ui_statusbar)
983: gtk_widget_show(w);
984: else
985: gtk_widget_hide(w);
986: ui_locksurface = SDL_MUSTLOCK(screen);
987: uiplot_setshifts(ui_topbit(screen->format->Rmask) - 4,
988: ui_topbit(screen->format->Gmask) - 4,
989: ui_topbit(screen->format->Bmask) - 4);
990: }
991:
992: void ui_gtk_newoptions(void)
993: {
994: char buf[32];
995: const char *v;
996: int i, c;
997: unsigned int old_ui_screenmode = ui_screenmode;
998: unsigned int old_sound_minfields = sound_minfields;
999: unsigned int old_sound_maxfields = sound_maxfields;
1000: unsigned int old_ui_hborder = ui_hborder;
1001: unsigned int old_ui_vborder = ui_vborder;
1002: unsigned int old_ui_statusbar = ui_statusbar;
1003:
1004: i = atoi(gtkopts_getvalue("view"));
1005: ui_screenmode = (i == 200) ? SCREEN_200 : SCREEN_100;
1006:
1007: v = gtkopts_getvalue("region");
1008: vdp_overseas = !strcasecmp(v, "overseas");
1009:
1010: v = gtkopts_getvalue("videostd");
1011: vdp_pal = !strcasecmp(v, "pal");
1012:
1013: v = gtkopts_getvalue("autodetect");
1014: gen_autodetect = !strcasecmp(v, "on");
1015:
1016: v = gtkopts_getvalue("plotter");
1017: ui_vdpsimple = !strcasecmp(v, "cell");
1018:
1019: v = gtkopts_getvalue("interlace");
1020: if (!strcasecmp(v, "weave"))
1021: ui_interlace = DEINTERLACE_WEAVE;
1022: else if (!strcasecmp(v, "weave-filter"))
1023: ui_interlace = DEINTERLACE_WEAVEFILTER;
1024: else
1025: ui_interlace = DEINTERLACE_BOB;
1026:
1027: v = gtkopts_getvalue("frameskip");
1028: if (!strcasecmp(v, "auto")) {
1029: ui_frameskip = 0;
1030: } else {
1031: ui_frameskip = atoi(v);
1032: }
1033:
1034: v = gtkopts_getvalue("hborder");
1035: ui_hborder = atoi(v);
1036: if (ui_hborder > HBORDER_MAX)
1037: ui_hborder = HBORDER_MAX;
1038:
1039: v = gtkopts_getvalue("vborder");
1040: ui_vborder = atoi(v);
1041: if (ui_vborder > VBORDER_MAX)
1042: ui_vborder = VBORDER_MAX;
1043:
1044: v = gtkopts_getvalue("z80");
1045: cpuz80_on = !strcasecmp(v, "on");
1046:
1047: v = gtkopts_getvalue("sound");
1048: sound_on = !strcasecmp(v, "on");
1049:
1050: v = gtkopts_getvalue("fm");
1051: sound_fm = !strcasecmp(v, "on");
1052:
1053: v = gtkopts_getvalue("psg");
1054: sound_psg = !strcasecmp(v, "on");
1055:
1056: v = gtkopts_getvalue("sound_minfields");
1057: sound_minfields = atoi(v);
1058:
1059: v = gtkopts_getvalue("sound_maxfields");
1060: sound_maxfields = atoi(v);
1061:
1062: v = gtkopts_getvalue("loglevel");
1063: gen_loglevel = atoi(v);
1064:
1065: v = gtkopts_getvalue("statusbar");
1066: ui_statusbar = !strcasecmp(v, "on");
1067:
1068: for (c = 0; c < 2; c++) {
1069: snprintf(buf, sizeof(buf), "key%d_a", c + 1);
1070: v = gtkopts_getvalue(buf);
1071: ui_cont[c].a = gdk_keyval_from_name(v);
1072: snprintf(buf, sizeof(buf), "key%d_b", c + 1);
1073: v = gtkopts_getvalue(buf);
1074: ui_cont[c].b = gdk_keyval_from_name(v);
1075: snprintf(buf, sizeof(buf), "key%d_c", c + 1);
1076: v = gtkopts_getvalue(buf);
1077: ui_cont[c].c = gdk_keyval_from_name(v);
1078: snprintf(buf, sizeof(buf), "key%d_up", c + 1);
1079: v = gtkopts_getvalue(buf);
1080: ui_cont[c].up = gdk_keyval_from_name(v);
1081: snprintf(buf, sizeof(buf), "key%d_down", c + 1);
1082: v = gtkopts_getvalue(buf);
1083: ui_cont[c].down = gdk_keyval_from_name(v);
1084: snprintf(buf, sizeof(buf), "key%d_left", c + 1);
1085: v = gtkopts_getvalue(buf);
1086: ui_cont[c].left = gdk_keyval_from_name(v);
1087: snprintf(buf, sizeof(buf), "key%d_right", c + 1);
1088: v = gtkopts_getvalue(buf);
1089: ui_cont[c].right = gdk_keyval_from_name(v);
1090: snprintf(buf, sizeof(buf), "key%d_start", c + 1);
1091: v = gtkopts_getvalue(buf);
1092: ui_cont[c].start = gdk_keyval_from_name(v);
1093: }
1094: if (ui_screenmode != old_ui_screenmode ||
1095: ui_hborder != old_ui_hborder ||
1096: ui_vborder != old_ui_vborder || ui_statusbar != old_ui_statusbar)
1097: ui_gtk_sizechange();
1098:
1099: if (sound_minfields != old_sound_minfields ||
1100: sound_maxfields != old_sound_maxfields) {
1101: sound_reset();
1102: }
1103: }
1104:
1105: static void ui_gtk_opts_from_window(void)
1106: {
1107: GtkWidget *obj, *active;
1108: char buf[64];
1109: int c;
1110: const char *v;
1111: const char **key;
1112:
1113: /* hardware - region */
1114:
1115: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1116: "radiobutton_domestic"));
1117: if (GTK_TOGGLE_BUTTON(obj)->active)
1118: gtkopts_setvalue("region", "domestic");
1119: else
1120: gtkopts_setvalue("region", "overseas");
1121:
1122: /* hardware - video standard */
1123:
1124: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1125: "radiobutton_pal"));
1126: if (GTK_TOGGLE_BUTTON(obj)->active)
1127: gtkopts_setvalue("videostd", "pal");
1128: else
1129: gtkopts_setvalue("videostd", "ntsc");
1130:
1131: /* hardware - auto detect */
1132:
1133: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1134: "checkbutton_autodetect"));
1135: if (GTK_TOGGLE_BUTTON(obj)->active)
1136: gtkopts_setvalue("autodetect", "on");
1137: else
1138: gtkopts_setvalue("autodetect", "off");
1139:
1140: /* video - plotter */
1141:
1142: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1143: "radiobutton_line"));
1144: if (GTK_TOGGLE_BUTTON(obj)->active)
1145: gtkopts_setvalue("plotter", "line");
1146: else
1147: gtkopts_setvalue("plotter", "cell");
1148:
1149: /* video - interlace mode */
1150:
1151: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1152: "optionmenu_interlace"));
1153: /* now get active widget on menu */
1154: obj = GTK_BIN(GTK_OPTION_MENU(obj))->child;
1155: gtkopts_setvalue("interlace", GTK_LABEL(obj)->label);
1156:
1157: /* video - frame skip */
1158:
1159: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1160: "checkbutton_auto"));
1161: if (GTK_TOGGLE_BUTTON(obj)->active) {
1162: gtkopts_setvalue("frameskip", "auto");
1163: } else {
1164: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1165: "hscale_skip"));
1166: snprintf(buf, sizeof(buf), "%d",
1167: (int)(gtk_range_get_adjustment(GTK_RANGE(obj))->value));
1168: gtkopts_setvalue("frameskip", buf);
1169: }
1170:
1171: /* video - hborder */
1172:
1173: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1174: "spinbutton_hborder"));
1175: snprintf(buf, sizeof(buf), "%d",
1176: gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(obj)));
1177: gtkopts_setvalue("hborder", buf);
1178:
1179: /* video - vborder */
1180:
1181: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1182: "spinbutton_vborder"));
1183: snprintf(buf, sizeof(buf), "%d",
1184: gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(obj)));
1185: gtkopts_setvalue("vborder", buf);
1186:
1187: /* sound - z80 */
1188:
1189: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1190: "checkbutton_z80"));
1191: if (GTK_TOGGLE_BUTTON(obj)->active)
1192: gtkopts_setvalue("z80", "on");
1193: else
1194: gtkopts_setvalue("z80", "off");
1195:
1196: /* sound - on/off */
1197:
1198: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1199: "checkbutton_sound"));
1200: if (GTK_TOGGLE_BUTTON(obj)->active)
1201: gtkopts_setvalue("sound", "on");
1202: else
1203: gtkopts_setvalue("sound", "off");
1204:
1205: /* sound - psg */
1206:
1207: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1208: "checkbutton_psg"));
1209: if (GTK_TOGGLE_BUTTON(obj)->active)
1210: gtkopts_setvalue("psg", "on");
1211: else
1212: gtkopts_setvalue("psg", "off");
1213:
1214: /* sound - fm */
1215:
1216: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1217: "checkbutton_fm"));
1218: if (GTK_TOGGLE_BUTTON(obj)->active)
1219: gtkopts_setvalue("fm", "on");
1220: else
1221: gtkopts_setvalue("fm", "off");
1222:
1223: /* sound - min fields */
1224:
1225: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1226: "spinbutton_minfields"));
1227: snprintf(buf, sizeof(buf), "%d",
1228: gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(obj)));
1229: gtkopts_setvalue("sound_minfields", buf);
1230:
1231: /* sound - min fields */
1232:
1233: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1234: "spinbutton_maxfields"));
1235: snprintf(buf, sizeof(buf), "%d",
1236: gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(obj)));
1237: gtkopts_setvalue("sound_maxfields", buf);
1238:
1239: /* info - verbosity */
1240:
1241: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1242: "optionmenu_level"));
1243: obj = GTK_OPTION_MENU(obj)->menu;
1244: /* now get active widget on menu */
1245: active = gtk_menu_get_active(GTK_MENU(obj));
1246: snprintf(buf, sizeof(buf), "%d",
1247: g_list_index(GTK_MENU_SHELL(obj)->children, active));
1248: gtkopts_setvalue("loglevel", buf);
1249:
1250: /* info - sound */
1251:
1252: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1253: "checkbutton_debugsound"));
1254: if (GTK_TOGGLE_BUTTON(obj)->active)
1255: gtkopts_setvalue("debugsound", "on");
1256: else
1257: gtkopts_setvalue("debugsound", "off");
1258:
1259: /* info - status bar */
1260: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1261: "checkbutton_statusbar"));
1262: if (GTK_TOGGLE_BUTTON(obj)->active)
1263: gtkopts_setvalue("statusbar", "on");
1264: else
1265: gtkopts_setvalue("statusbar", "off");
1266:
1267: /* controls */
1268:
1269: for (c = 1; c <= 2; c++) {
1270: for (key = ui_gtk_keys;
1271: (char *)key < ((char *)ui_gtk_keys + sizeof(ui_gtk_keys));
1272: key++) {
1273: snprintf(buf, sizeof(buf), "entry_player%d_%s", c, *key);
1274: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts), buf));
1275: v = gtk_entry_get_text(GTK_ENTRY(obj));
1276: snprintf(buf, sizeof(buf), "key%d_%s", c, *key);
1277: gtkopts_setvalue(buf, v);
1278: }
1279: }
1280: }
1281:
1282: static void ui_gtk_opts_to_window(void)
1283: {
1284: GtkWidget *obj;
1285: const char *v;
1286: const char **key;
1287: int i, c;
1288: char buf[32];
1289:
1290: /* hardware - region */
1291:
1292: v = gtkopts_getvalue("region");
1293: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1294: "radiobutton_domestic"));
1295: gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(obj),
1296: !strcasecmp(v, "domestic"));
1297: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1298: "radiobutton_overseas"));
1299: gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(obj),
1300: !strcasecmp(v, "overseas"));
1301:
1302: /* hardware - video standard */
1303:
1304: v = gtkopts_getvalue("videostd");
1305: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1306: "radiobutton_pal"));
1307: gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(obj), !strcasecmp(v, "pal"));
1308: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1309: "radiobutton_ntsc"));
1310: gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(obj),
1311: !strcasecmp(v, "ntsc"));
1312:
1313: /* hardware - auto detect */
1314:
1315: v = gtkopts_getvalue("autodetect");
1316: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1317: "checkbutton_autodetect"));
1318: gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(obj), !strcasecmp(v, "on"));
1319:
1320: /* video - plotter */
1321:
1322: v = gtkopts_getvalue("plotter");
1323: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1324: "radiobutton_line"));
1325: gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(obj),
1326: !strcasecmp(v, "line"));
1327: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1328: "radiobutton_cell"));
1329: gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(obj),
1330: !strcasecmp(v, "cell"));
1331:
1332: /* video - interlace mode */
1333:
1334: v = gtkopts_getvalue("interlace");
1335: if (!strcasecmp(v, "bob")) {
1336: i = 0;
1337: } else if (!strcasecmp(v, "weave")) {
1338: i = 1;
1339: } else {
1340: i = 2;
1341: }
1342: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1343: "optionmenu_interlace"));
1344: gtk_option_menu_set_history(GTK_OPTION_MENU(obj), i);
1345:
1346: /* video - frame skip */
1347:
1348: v = gtkopts_getvalue("frameskip");
1349: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1350: "checkbutton_auto"));
1351: gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(obj),
1352: !strcasecmp(v, "auto"));
1353: i = atoi(v);
1354: if (i < 1)
1355: i = 1;
1356: if (i > 10)
1357: i = 10;
1358: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1359: "hscale_skip"));
1360: gtk_adjustment_set_value(gtk_range_get_adjustment(GTK_RANGE(obj)), i);
1361:
1362: /* video - hborder */
1363:
1364: v = gtkopts_getvalue("hborder");
1365: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1366: "spinbutton_hborder"));
1367: i = atoi(v);
1368: if (i < 0)
1369: i = 0;
1370: if (i > HBORDER_MAX)
1371: i = HBORDER_MAX;
1372: gtk_spin_button_set_value(GTK_SPIN_BUTTON(obj), i);
1373:
1374: /* video - vborder */
1375:
1376: v = gtkopts_getvalue("vborder");
1377: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1378: "spinbutton_vborder"));
1379: i = atoi(v);
1380: if (i < 0)
1381: i = 0;
1382: if (i > VBORDER_MAX)
1383: i = VBORDER_MAX;
1384: gtk_spin_button_set_value(GTK_SPIN_BUTTON(obj), i);
1385:
1386: /* sound - z80 */
1387:
1388: v = gtkopts_getvalue("z80");
1389: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1390: "checkbutton_z80"));
1391: gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(obj), !strcasecmp(v, "on"));
1392:
1393: /* sound - on/off */
1394:
1395: v = gtkopts_getvalue("sound");
1396: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1397: "checkbutton_sound"));
1398: gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(obj), !strcasecmp(v, "on"));
1399:
1400: /* sound - psg */
1401:
1402: v = gtkopts_getvalue("psg");
1403: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1404: "checkbutton_psg"));
1405: gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(obj), !strcasecmp(v, "on"));
1406:
1407: /* sound - fm */
1408:
1409: v = gtkopts_getvalue("fm");
1410: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1411: "checkbutton_fm"));
1412: gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(obj), !strcasecmp(v, "on"));
1413:
1414: /* sound - min fields */
1415:
1416: v = gtkopts_getvalue("sound_minfields");
1417: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1418: "spinbutton_minfields"));
1419: i = atoi(v);
1420: if (i < 1)
1421: i = 1;
1422: gtk_spin_button_set_value(GTK_SPIN_BUTTON(obj), i);
1423:
1424: /* sound - max fields */
1425:
1426: v = gtkopts_getvalue("sound_maxfields");
1427: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1428: "spinbutton_maxfields"));
1429: i = atoi(v);
1430: if (i < 1)
1431: i = 1;
1432: gtk_spin_button_set_value(GTK_SPIN_BUTTON(obj), i);
1433:
1434: /* info - verbosity */
1435:
1436: v = gtkopts_getvalue("loglevel");
1437: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1438: "optionmenu_level"));
1439: i = atoi(v);
1440: gtk_option_menu_set_history(GTK_OPTION_MENU(obj), i);
1441:
1442: /* info - sound */
1443:
1444: v = gtkopts_getvalue("debugsound");
1445: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1446: "checkbutton_debugsound"));
1447: gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(obj), !strcasecmp(v, "on"));
1448:
1449: /* info - status bar */
1450:
1451: v = gtkopts_getvalue("statusbar");
1452: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts),
1453: "checkbutton_statusbar"));
1454: gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(obj), !strcasecmp(v, "on"));
1455:
1456: /* controls */
1457:
1458: for (c = 1; c <= 2; c++) {
1459: for (key = ui_gtk_keys;
1460: (char *)key < ((char *)ui_gtk_keys + sizeof(ui_gtk_keys));
1461: key++) {
1462: snprintf(buf, sizeof(buf), "key%d_%s", c, *key);
1463: v = gtkopts_getvalue(buf);
1464: i = gdk_keyval_from_name(v);
1465: if (i) {
1466: v = gdk_keyval_name(i); /* just incase case is different etc. */
1467: } else {
1468: v = "";
1469: }
1470: snprintf(buf, sizeof(buf), "entry_player%d_%s", c, *key);
1471: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_opts), buf));
1472: gtk_entry_set_text(GTK_ENTRY(obj), v);
1473: }
1474: }
1475: }
1476:
1477: void ui_gtk_applyoptions(void)
1478: {
1479: ui_gtk_opts_from_window();
1480: gtk_widget_hide(ui_win_opts);
1481: ui_gtk_newoptions();
1482: ui_gtk_opts_to_menu();
1483: }
1484:
1485: void ui_gtk_saveoptions(void)
1486: {
1487: char buf[256];
1488:
1489: ui_gtk_opts_from_window();
1490: if (gtkopts_save(ui_configfile) != 0) {
1491: snprintf(buf, sizeof(buf), "Failed to save configuration to '%s': %s",
1492: ui_configfile, strerror(errno));
1493: ui_gtk_dialog(buf);
1494: return;
1495: }
1496: gtk_widget_hide(ui_win_opts);
1497: ui_gtk_newoptions();
1498: ui_gtk_opts_to_menu();
1499: }
1500:
1501: void ui_gtk_redraw(void)
1502: {
1503: SDL_UpdateRect(screen, 0, 0, screen->w, screen->h);
1504: }
1505:
1506: void ui_gtk_key(unsigned long key, int press)
1507: {
1508: t_gtkkeys *cont;
1509: int c;
1510:
1511: for (c = 0; c < 2; c++) {
1512: cont = &ui_cont[c];
1513: if (key == cont->a) {
1514: mem68k_cont[c].a = press;
1515: } else if (key == cont->b) {
1516: mem68k_cont[c].b = press;
1517: } else if (key == cont->c) {
1518: mem68k_cont[c].c = press;
1519: } else if (key == cont->left) {
1520: mem68k_cont[c].left = press;
1521: } else if (key == cont->right) {
1522: mem68k_cont[c].right = press;
1523: } else if (key == cont->up) {
1524: mem68k_cont[c].up = press;
1525: } else if (key == cont->down) {
1526: mem68k_cont[c].down = press;
1527: } else if (key == cont->start) {
1528: mem68k_cont[c].start = press;
1529: }
1530: }
1531: }
1532:
1533: void ui_gtk_mainenter(void)
1534: {
1535: /* clear out current state */
1536: memset(mem68k_cont, 0, sizeof(mem68k_cont));
1537: XAutoRepeatOff(GDK_DISPLAY());
1538: }
1539:
1540: void ui_gtk_mainleave(void)
1541: {
1542: XAutoRepeatOn(GDK_DISPLAY());
1543: }
1544:
1545: static void ui_gtk_opts_to_menu(void)
1546: {
1547: GtkWidget *obj;
1548: const char *v;
1549:
1550: /* view */
1551:
1552: v = gtkopts_getvalue("view");
1553: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_main), "_100"));
1554: gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(obj),
1555: !strcasecmp(v, "100"));
1556: obj = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(ui_win_main), "_200"));
1557: gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(obj),
1558: !strcasecmp(v, "200"));
1559: }
1560:
1561: void ui_musiclog(uint8 *data, unsigned int length)
1562: {
1563: if (ui_musicfile != -1)
1564: write(ui_musicfile, data, length);
1565: }
1566:
1567: void ui_gtk_closemusiclog(void)
1568: {
1569: if (ui_musicfile == -1) {
1570: ui_gtk_dialog("There is no log to close");
1571: return;
1572: }
1573: close(ui_musicfile);
1574: ui_musicfile = -1;
1575: gen_musiclog = 0;
1576: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.