![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gtkui.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [UNIX Amiga Emulator] / uae / src|
Return to gtkui.c CVS log | Up to [UNIX Amiga Emulator] / uae / src |
1.1 root 1: /*
2: * UAE - the Un*x Amiga Emulator
3: *
4: * Yet Another User Interface for the X11 version
5: *
6: * Copyright 1997, 1998 Bernd Schmidt
7: *
8: * The Tk GUI doesn't work.
9: * The X Forms Library isn't available as source, and there aren't any
10: * binaries compiled against glibc
11: *
12: * So let's try this...
13: */
14:
15: #include "sysconfig.h"
16: #include "sysdeps.h"
17:
18: #include "config.h"
19: #include "options.h"
20: #include "uae.h"
21: #include "memory.h"
22: #include "custom.h"
23: #include "readcpu.h"
24: #include "gui.h"
25: #include "newcpu.h"
26: #include "threaddep/penguin.h"
27:
28: #include <gtk/gtk.h>
29:
30: static int gui_active;
31:
32: static GtkWidget *disk_insert_widget[4], *disk_eject_widget[4], *disk_text_widget[4];
33: static char *disk_string[4];
34: static char *new_disk_string[4];
35:
36: static GtkAdjustment *cpuspeed_adj;
37: static GtkWidget *cpu_widget[4], *a24m_widget, *ccpu_widget;
38:
39: static GtkAdjustment *framerate_adj;
40: static GtkWidget *bimm_widget, *b32_widget;
41:
42: static GtkWidget *joy_widget[2][6];
43:
44: static GtkWidget *led_widgets[5];
45: static GdkColor led_on[5], led_off[5];
46: static unsigned int prevledstate;
47:
48: static void save_config (void)
49: {
50: FILE *f;
51: char tmp[257];
52:
53: /* Backup the options file. */
54: strcpy (tmp, optionsfile);
55: strcat (tmp, "~");
56: rename (optionsfile, tmp);
57:
58: f = fopen (optionsfile, "w");
59: if (f == NULL) {
60: fprintf(stderr, "Error saving options file!\n");
61: return;
62: }
63: save_options (f);
64: fclose (f);
65: }
66:
67: static int nr_for_led (GtkWidget *led)
68: {
69: int i;
70: i = 0;
71: while (led_widgets[i] != led)
72: i++;
73: return i;
74: }
75:
76: static smp_comm_pipe to_gui_pipe, from_gui_pipe;
77: static uae_sem_t gui_sem, gui_quit_sem;
78:
79: static volatile int quit_gui = 0, quitted_gui = 0;
80:
81: static void enable_disk_buttons (int enable)
82: {
83: int i;
84: for (i = 0; i < 4; i++) {
85: gtk_widget_set_sensitive (disk_insert_widget[i], enable);
86: gtk_widget_set_sensitive (disk_eject_widget[i], enable);
87: }
88: }
89:
90: static void set_cpu_state (void)
91: {
92: gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (a24m_widget), changed_prefs.address_space_24 != 0);
93: gtk_widget_set_sensitive (a24m_widget, changed_prefs.cpu_level > 1);
94: gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (ccpu_widget), changed_prefs.cpu_compatible != 0);
95: gtk_widget_set_sensitive (ccpu_widget, changed_prefs.cpu_level == 0);
96: }
97:
98: static void set_cpu_widget (void)
99: {
100: int nr = changed_prefs.cpu_level;
101: gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (cpu_widget[nr]), TRUE);
102: }
103:
104: static void set_gfx_state (void)
105: {
106: gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (bimm_widget), currprefs.immediate_blits != 0);
107: gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (b32_widget), currprefs.blits_32bit_enabled != 0);
108: }
109:
110: static void set_joy_state (void)
111: {
112: int j0t = changed_prefs.fake_joystick & 255;
113: int j1t = (changed_prefs.fake_joystick >> 8) & 255;
114: int i;
115:
116: if (j0t == j1t) {
117: /* Can't happen */
118: j0t++;
119: j0t %= 6;
120: }
121: for (i = 0; i < 6; i++) {
122: gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (joy_widget[0][i]), j0t == i);
123: gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (joy_widget[1][i]), j1t == i);
124: gtk_widget_set_sensitive (joy_widget[0][i], j1t != i);
125: gtk_widget_set_sensitive (joy_widget[1][i], j0t != i);
126: }
127: }
128:
129: static void draw_led (int nr)
130: {
131: GtkWidget *thing = led_widgets[nr];
132: GdkWindow *window = thing->window;
133: GdkGC *gc = gdk_gc_new (window);
134: GdkColor *col;
135:
136: if (gui_ledstate & (1 << nr))
137: col = led_on + nr;
138: else
139: col = led_off + nr;
140: gdk_gc_set_foreground (gc, col);
141: gdk_draw_rectangle (window, gc, 1, 0, 0, -1, -1);
142: gdk_gc_destroy (gc);
143: }
144:
145: static int my_idle (void)
146: {
147: unsigned int leds = gui_ledstate;
148: int i;
149:
150: if (quit_gui) {
151: /*printf("Foo...\n");*/
152: gtk_main_quit ();
153: goto out;
154: }
155: while (comm_pipe_has_data (&to_gui_pipe)) {
156: int cmd = read_comm_pipe_int_blocking (&to_gui_pipe);
157: int n;
158: /*printf ("cmd %d\n", cmd);*/
159: switch (cmd) {
160: case 0:
161: n = read_comm_pipe_int_blocking (&to_gui_pipe);
162: gtk_label_set (GTK_LABEL (disk_text_widget[n]), currprefs.df[n]);
163: break;
164: case 1:
165: /* Initialization. */
166: set_cpu_widget ();
167: set_cpu_state ();
168: set_gfx_state ();
169: set_joy_state ();
170: gui_active = 1;
171: break;
172: }
173: }
174:
175: for (i = 0; i < 5; i++) {
176: unsigned int mask = 1 << i;
177: int on = leds & mask;
178:
179: if (on == (prevledstate & mask))
180: continue;
181:
182: /* printf(": %d %d\n", i, on);*/
183: draw_led (i);
184: }
185: prevledstate = leds;
186: out:
187: return 1;
188: }
189:
190: static void joy_changed (void)
191: {
192: int j0t = 0, j1t = 0;
193: int i;
194: if (! gui_active)
195: return;
196:
197: for (i = 0; i < 6; i++)
198: if (GTK_TOGGLE_BUTTON (joy_widget[0][i])->active) {
199: j0t = i;
200: break;
201: }
202: for (i = 0; i < 6; i++)
203: if (GTK_TOGGLE_BUTTON (joy_widget[1][i])->active) {
204: j1t = i;
205: break;
206: }
207: changed_prefs.fake_joystick = j0t | (j1t << 8);
208: set_joy_state ();
209: }
210:
211: static void gfx_changed (void)
212: {
213: changed_prefs.framerate = framerate_adj->value;
214: changed_prefs.blits_32bit_enabled = GTK_TOGGLE_BUTTON (b32_widget)->active;
215: changed_prefs.immediate_blits = GTK_TOGGLE_BUTTON (bimm_widget)->active;
216: }
217:
218: static void cpuspeed_changed (void)
219: {
220: changed_prefs.m68k_speed = cpuspeed_adj->value;
221: }
222:
223: static void cputype_changed (void)
224: {
225: int i, oldcl;
226: if (! gui_active)
227: return;
228:
229: oldcl = changed_prefs.cpu_level;
230:
231: changed_prefs.cpu_level = 0;
232: for (i = 0; i < 4; i++)
233: if (GTK_TOGGLE_BUTTON (cpu_widget[i])->active) {
234: changed_prefs.cpu_level = i;
235: break;
236: }
237:
238: changed_prefs.cpu_compatible = GTK_TOGGLE_BUTTON (ccpu_widget)->active;
239: changed_prefs.address_space_24 = GTK_TOGGLE_BUTTON (a24m_widget)->active;
240:
241: if (changed_prefs.cpu_level != 0)
242: changed_prefs.cpu_compatible = 0;
243: /* 68000/68010 always have a 24 bit address space. */
244: if (changed_prefs.cpu_level < 2)
245: changed_prefs.address_space_24 = 1;
246: /* Changing from 68000/68010 to 68020 should set a sane default. */
247: else if (oldcl < 2)
248: changed_prefs.address_space_24 = 0;
249:
250: set_cpu_state ();
251: }
252:
253: static void did_reset (void)
254: {
255: if (quit_gui)
256: return;
257:
258: write_comm_pipe_int (&from_gui_pipe, 2, 1);
259: }
260:
261: static void did_debug (void)
262: {
263: if (quit_gui)
264: return;
265:
266: write_comm_pipe_int (&from_gui_pipe, 3, 1);
267: }
268:
269: static void did_quit (void)
270: {
271: if (quit_gui)
272: return;
273:
274: write_comm_pipe_int (&from_gui_pipe, 4, 1);
275: }
276:
277: static void did_eject (int n)
278: {
279: if (quit_gui)
280: return;
281:
282: write_comm_pipe_int (&from_gui_pipe, 0, 0);
283: write_comm_pipe_int (&from_gui_pipe, n, 1);
284: }
285:
286: static int filesel_active = -1;
287: static GtkWidget *selector;
288:
289: static void did_close_insert (GtkObject *o, GtkWidget *w)
290: {
291: filesel_active = -1;
292: enable_disk_buttons (1);
293: gtk_widget_hide (selector);
294: }
295:
296: static void did_cancel_insert (GtkObject *o)
297: {
298: filesel_active = -1;
299: enable_disk_buttons (1);
300: gtk_widget_hide (selector);
301: }
302:
303: static void did_insert_select (GtkObject *o)
304: {
305: char *s = gtk_file_selection_get_filename (GTK_FILE_SELECTION (selector));
306: printf ("%s\n", s);
307: if (quit_gui)
308: return;
309:
310: uae_sem_wait (&gui_sem);
311: if (new_disk_string[filesel_active] != 0)
312: free (new_disk_string[filesel_active]);
313: new_disk_string[filesel_active] = strdup (s);
314: uae_sem_post (&gui_sem);
315: write_comm_pipe_int (&from_gui_pipe, 1, 0);
316: write_comm_pipe_int (&from_gui_pipe, filesel_active, 1);
317: filesel_active = -1;
318: enable_disk_buttons (1);
319: gtk_widget_hide (selector);
320: }
321:
322: static char fsbuffer[100];
323:
324: static void did_insert (int n)
325: {
326: if (filesel_active != -1)
327: return;
328: filesel_active = n;
329: enable_disk_buttons (0);
330:
331: sprintf (fsbuffer, "Select a disk image file for DF%d", n);
332: gtk_window_set_title (GTK_WINDOW (selector), fsbuffer);
333:
334: /*printf("%p\n", selector);*/
335: gtk_widget_show (selector);
336: }
337:
338: static void did_eject_0 (void) { did_eject (0); }
339: static void did_eject_1 (void) { did_eject (1); }
340: static void did_eject_2 (void) { did_eject (2); }
341: static void did_eject_3 (void) { did_eject (3); }
342:
343: static void did_insert_0 (void) { did_insert (0); }
344: static void did_insert_1 (void) { did_insert (1); }
345: static void did_insert_2 (void) { did_insert (2); }
346: static void did_insert_3 (void) { did_insert (3); }
347:
348: static gint driveled_event (GtkWidget *thing, GdkEvent *event)
349: {
350: gint x, y;
351: GtkStyle *style;
352: int lednr = nr_for_led (thing);
353:
354: switch (event->type) {
355: case GDK_MAP:
356: draw_led (lednr);
357: break;
358: case GDK_EXPOSE:
359: draw_led (lednr);
360: break;
361: default:
362: break;
363: }
364:
365: return 0;
366: }
367:
368: static GtkWidget *make_led (int nr)
369: {
370: GtkWidget *subframe, *the_led, *thing;
371: GdkColormap *colormap;
372:
373: the_led = gtk_vbox_new (FALSE, 0);
374: gtk_widget_show (the_led);
375:
376: thing = gtk_preview_new (GTK_PREVIEW_COLOR);
377: gtk_box_pack_start (GTK_BOX (the_led), thing, TRUE, TRUE, 0);
378: gtk_widget_show (thing);
379:
380: subframe = gtk_frame_new (NULL);
381: gtk_box_pack_start (GTK_BOX (the_led), subframe, TRUE, TRUE, 0);
382: gtk_widget_show (subframe);
383:
384: thing = gtk_drawing_area_new ();
385: gtk_drawing_area_size (GTK_DRAWING_AREA (thing), 20, 5);
386: gtk_widget_set_events (thing, GDK_EXPOSURE_MASK);
387: gtk_container_add (GTK_CONTAINER (subframe), thing);
388: colormap = gtk_widget_get_colormap (thing);
389: led_on[nr].red = nr == 0 ? 0xEEEE : 0xCCCC;
390: led_on[nr].green = nr == 0 ? 0: 0xFFFF;
391: led_on[nr].blue = 0;
392: led_on[nr].pixel = 0;
393: led_off[nr].red = 0;
394: led_off[nr].green = 0;
395: led_off[nr].blue = 0;
396: led_off[nr].pixel = 0;
397: gdk_color_alloc (colormap, led_on + nr);
398: gdk_color_alloc (colormap, led_off + nr);
399: led_widgets[nr] = thing;
400: gtk_signal_connect (GTK_OBJECT (thing), "event",
401: (GtkSignalFunc) driveled_event, (gpointer) thing);
402: gtk_widget_show (thing);
403:
404: thing = gtk_preview_new (GTK_PREVIEW_COLOR);
405: gtk_box_pack_start (GTK_BOX (the_led), thing, TRUE, TRUE, 0);
406: gtk_widget_show (thing);
407:
408: return the_led;
409: }
410:
411: static void make_floppy_disks (GtkWidget *vbox)
412: {
413: int i;
414: /* Now, the floppy disk control. */
415: for (i = 0; i < 4; i++) {
416: GtkWidget *thing, *subthing, *subframe, *buttonbox;
417: char buf[5];
418: sprintf (buf, "DF%d:", i);
419:
420: /* Each line: a frame with a hbox in it. The hbox contains
421: * the LED, the name of the drive and the diskfile in it, an
422: * Insert button, and an Eject button. */
423: buttonbox = gtk_frame_new (buf);
424: thing = gtk_hbox_new (FALSE, 4);
425: gtk_container_add (GTK_CONTAINER (buttonbox), thing);
426: gtk_box_pack_start (GTK_BOX (vbox), buttonbox, FALSE, TRUE, 0);
427: gtk_widget_show (buttonbox);
428: gtk_widget_show (thing);
429: buttonbox = thing;
430:
431: subthing = make_led (i + 1);
432: gtk_box_pack_start (GTK_BOX (buttonbox), subthing, FALSE, TRUE, 0);
433:
434: /* Make the "DF0:xxx" label. */
435: subframe = gtk_frame_new (NULL);
436: gtk_frame_set_shadow_type (GTK_FRAME (subframe), GTK_SHADOW_ETCHED_OUT);
437: gtk_box_pack_start (GTK_BOX (buttonbox), subframe, FALSE, TRUE, 0);
438: gtk_widget_show (subframe);
439:
440: subthing = gtk_vbox_new (FALSE, 0);
441: gtk_widget_show (subthing);
442: gtk_container_add (GTK_CONTAINER (subframe), subthing);
443:
444: thing = gtk_label_new ("");
445: disk_text_widget[i] = thing;
446: gtk_widget_show (thing);
447: gtk_box_pack_start (GTK_BOX (subthing), thing, FALSE, TRUE, 0);
448:
449: gtk_widget_set_usize (subthing,
450: gdk_string_measure (subframe->style->font,
451: "This is a very long name for a disk file, should be enough") + 7, 0);
452: gtk_container_disable_resize (GTK_CONTAINER (subthing));
453:
454: /* Now, the buttons. */
455: thing = gtk_button_new_with_label ("Eject");
456: gtk_box_pack_start (GTK_BOX (buttonbox), thing, FALSE, TRUE, 0);
457: gtk_widget_show (thing);
458: disk_eject_widget[i] = thing;
459: gtk_signal_connect (GTK_OBJECT (thing), "clicked",
460: (GtkSignalFunc) (i == 0 ? did_eject_0
461: : i == 1 ? did_eject_1
462: : i == 2 ? did_eject_2 : did_eject_3),
463: NULL);
464:
465: thing = gtk_button_new_with_label ("Insert");
466: gtk_box_pack_start (GTK_BOX (buttonbox), thing, FALSE, TRUE, 0);
467: gtk_widget_show (thing);
468: disk_insert_widget[i] = thing;
469: gtk_signal_connect (GTK_OBJECT (thing), "clicked",
470: (GtkSignalFunc) (i == 0 ? did_insert_0
471: : i == 1 ? did_insert_1
472: : i == 2 ? did_insert_2 : did_insert_3),
473: NULL);
474: }
475: }
476:
477: static void make_cpu_widgets (GtkWidget *hbox)
478: {
479: int i;
480: GtkWidget *vbox, *hbox2, *frame;
481: GtkWidget *thing;
482:
483: frame = gtk_frame_new ("CPU type");
484: gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
485: gtk_widget_show (frame);
486: vbox = gtk_vbox_new (FALSE, 4);
487: gtk_widget_show (vbox);
488: gtk_container_add (GTK_CONTAINER (frame), vbox);
489:
490: thing = gtk_radio_button_new_with_label (0, "68000");
491: gtk_box_pack_start (GTK_BOX (vbox), thing, FALSE, TRUE, 0);
492: gtk_widget_show (thing);
493: cpu_widget[0] = thing;
494: thing = gtk_radio_button_new_with_label (gtk_radio_button_group (GTK_RADIO_BUTTON (thing)), "68010");
495: gtk_box_pack_start (GTK_BOX (vbox), thing, FALSE, TRUE, 0);
496: gtk_widget_show (thing);
497: cpu_widget[1] = thing;
498: thing = gtk_radio_button_new_with_label (gtk_radio_button_group (GTK_RADIO_BUTTON (thing)), "68020");
499: gtk_box_pack_start (GTK_BOX (vbox), thing, FALSE, TRUE, 0);
500: gtk_widget_show (thing);
501: cpu_widget[2] = thing;
502: thing = gtk_radio_button_new_with_label (gtk_radio_button_group (GTK_RADIO_BUTTON (thing)), "68020/68881");
503: gtk_box_pack_start (GTK_BOX (vbox), thing, FALSE, TRUE, 0);
504: gtk_widget_show (thing);
505: cpu_widget[3] = thing;
506:
507: for (i = 0; i < 4; i++)
508: gtk_signal_connect (GTK_OBJECT (cpu_widget[i]), "clicked",
509: (GtkSignalFunc) cputype_changed, NULL);
510:
511: frame = gtk_frame_new ("CPU flags");
512: gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
513: gtk_widget_show (frame);
514: vbox = gtk_vbox_new (FALSE, 4);
515: gtk_widget_show (vbox);
516: gtk_container_add (GTK_CONTAINER (frame), vbox);
517:
518: hbox2 = gtk_hbox_new (FALSE, 4);
519: gtk_widget_show (hbox2);
520: gtk_box_pack_start (GTK_BOX (vbox), hbox2, FALSE, TRUE, 0);
521:
522: thing = gtk_label_new ("Cycles per instruction:");
523: gtk_box_pack_start (GTK_BOX (hbox2), thing, FALSE, TRUE, 0);
524: gtk_widget_show (thing);
525:
526: cpuspeed_adj = GTK_ADJUSTMENT (gtk_adjustment_new (currprefs.m68k_speed, 1.0, 10.0, 1.0, 1.0, 1.0));
527: gtk_signal_connect (GTK_OBJECT (cpuspeed_adj), "value_changed",
528: GTK_SIGNAL_FUNC (cpuspeed_changed), NULL);
529:
530: thing = gtk_hscale_new (cpuspeed_adj);
531: gtk_range_set_update_policy (GTK_RANGE (thing), GTK_UPDATE_DELAYED);
532: gtk_scale_set_digits (GTK_SCALE (thing), 0);
533: gtk_scale_set_value_pos (GTK_SCALE (thing), GTK_POS_RIGHT);
534: gtk_box_pack_start (GTK_BOX (hbox2), thing, FALSE, TRUE, 0);
535: gtk_widget_show (thing);
536:
537: a24m_widget = gtk_check_button_new_with_label ("24 bit address space");
538: gtk_box_pack_start (GTK_BOX (vbox), a24m_widget, FALSE, TRUE, 0);
539: gtk_widget_show (a24m_widget);
540: ccpu_widget = gtk_check_button_new_with_label ("Slow but compatible");
541: gtk_box_pack_start (GTK_BOX (vbox), ccpu_widget, FALSE, TRUE, 0);
542: gtk_widget_show (ccpu_widget);
543:
544: gtk_signal_connect (GTK_OBJECT (ccpu_widget), "clicked",
545: (GtkSignalFunc) cputype_changed, NULL);
546: gtk_signal_connect (GTK_OBJECT (a24m_widget), "clicked",
547: (GtkSignalFunc) cputype_changed, NULL);
548: }
549:
550: static void make_gfx_widgets (GtkWidget *hbox)
551: {
552: int i;
553: GtkWidget *vbox, *hbox2, *frame;
554: GtkWidget *thing;
555:
556: #if 0
557: frame = gtk_frame_new ("CPU type");
558: gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
559: gtk_widget_show (frame);
560: #endif
561: vbox = gtk_vbox_new (FALSE, 4);
562: gtk_widget_show (vbox);
563: gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, TRUE, 0);
564: #if 0
565: gtk_container_add (GTK_CONTAINER (frame), vbox);
566: #endif
567:
568: hbox2 = gtk_hbox_new (FALSE, 4);
569: gtk_widget_show (hbox2);
570: gtk_box_pack_start (GTK_BOX (vbox), hbox2, FALSE, TRUE, 0);
571:
572: thing = gtk_label_new ("Framerate:");
573: gtk_box_pack_start (GTK_BOX (hbox2), thing, FALSE, TRUE, 0);
574: gtk_widget_show (thing);
575:
576: framerate_adj = GTK_ADJUSTMENT (gtk_adjustment_new (currprefs.framerate, 1.0, 21.0, 1.0, 1.0, 1.0));
577: gtk_signal_connect (GTK_OBJECT (framerate_adj), "value_changed",
578: GTK_SIGNAL_FUNC (gfx_changed), NULL);
579:
580: thing = gtk_hscale_new (framerate_adj);
581: gtk_range_set_update_policy (GTK_RANGE (thing), GTK_UPDATE_DELAYED);
582: gtk_scale_set_digits (GTK_SCALE (thing), 0);
583: gtk_scale_set_value_pos (GTK_SCALE (thing), GTK_POS_RIGHT);
584: gtk_box_pack_start (GTK_BOX (hbox2), thing, FALSE, TRUE, 0);
585: gtk_widget_show (thing);
586:
587: b32_widget = gtk_check_button_new_with_label ("32 bit blitter");
588: gtk_box_pack_start (GTK_BOX (vbox), b32_widget, FALSE, TRUE, 0);
589: gtk_widget_show (b32_widget);
590: bimm_widget = gtk_check_button_new_with_label ("Immediate blits");
591: gtk_box_pack_start (GTK_BOX (vbox), bimm_widget, FALSE, TRUE, 0);
592: gtk_widget_show (bimm_widget);
593:
594: gtk_signal_connect (GTK_OBJECT (bimm_widget), "clicked",
595: (GtkSignalFunc) gfx_changed, NULL);
596: gtk_signal_connect (GTK_OBJECT (b32_widget), "clicked",
597: (GtkSignalFunc) gfx_changed, NULL);
598: }
599:
600: static void make_joy_widgets (GtkWidget *hbox)
601: {
602: int i;
603:
604: for (i = 0; i < 2; i++) {
605: GtkWidget *vbox, *frame;
606: GtkWidget *thing;
607: char buffer[20];
608: int j;
609:
610: sprintf (buffer, "Port %d", i);
611: frame = gtk_frame_new (buffer);
612: gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
613: gtk_widget_show (frame);
614: vbox = gtk_vbox_new (FALSE, 4);
615: gtk_widget_show (vbox);
616: gtk_container_add (GTK_CONTAINER (frame), vbox);
617:
618: thing = gtk_radio_button_new_with_label (0, "Joystick 0");
619: gtk_box_pack_start (GTK_BOX (vbox), thing, FALSE, TRUE, 0);
620: gtk_widget_show (thing);
621: joy_widget[i][0] = thing;
622: thing = gtk_radio_button_new_with_label (gtk_radio_button_group (GTK_RADIO_BUTTON (thing)), "Joystick 1");
623: gtk_box_pack_start (GTK_BOX (vbox), thing, FALSE, TRUE, 0);
624: gtk_widget_show (thing);
625: joy_widget[i][1] = thing;
626: thing = gtk_radio_button_new_with_label (gtk_radio_button_group (GTK_RADIO_BUTTON (thing)), "Mouse");
627: gtk_box_pack_start (GTK_BOX (vbox), thing, FALSE, TRUE, 0);
628: gtk_widget_show (thing);
629: joy_widget[i][2] = thing;
630: thing = gtk_radio_button_new_with_label (gtk_radio_button_group (GTK_RADIO_BUTTON (thing)), "Numeric pad");
631: gtk_box_pack_start (GTK_BOX (vbox), thing, FALSE, TRUE, 0);
632: gtk_widget_show (thing);
633: joy_widget[i][3] = thing;
634: thing = gtk_radio_button_new_with_label (gtk_radio_button_group (GTK_RADIO_BUTTON (thing)), "Cursor keys/Right Ctrl");
635: gtk_box_pack_start (GTK_BOX (vbox), thing, FALSE, TRUE, 0);
636: gtk_widget_show (thing);
637: joy_widget[i][4] = thing;
638: thing = gtk_radio_button_new_with_label (gtk_radio_button_group (GTK_RADIO_BUTTON (thing)), "T/F/H/B/Left Alt");
639: gtk_box_pack_start (GTK_BOX (vbox), thing, FALSE, TRUE, 0);
640: gtk_widget_show (thing);
641: joy_widget[i][5] = thing;
642:
643: for (j = 0; j < 6; j++)
644: gtk_signal_connect (GTK_OBJECT (joy_widget[i][j]), "clicked",
645: (GtkSignalFunc) joy_changed, NULL);
646: }
647: }
648:
649: static void *gtk_penguin (void *dummy)
650: {
651: GtkWidget *window, *notebook;
652: GtkWidget *buttonbox, *vbox, *vbox2, *hbox;
653: GtkWidget *thing;
654:
655: int i;
656:
657: int argc = 1;
658: char *a[] = {"UAE"};
659: char **argv = a;
660:
661: gtk_init (&argc, &argv);
662: gtk_rc_parse ("uaegtkrc");
663:
664: window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
665: gtk_widget_set_name (window, "UAE control");
666:
667: vbox = gtk_vbox_new (FALSE, 4);
668: gtk_container_add (GTK_CONTAINER (window), vbox);
669:
670: /* Make a box with the Reset/Debug/Quit buttons and place it at the top
671: * of our vbox. */
672: buttonbox = gtk_hbox_new (FALSE, 4);
673: gtk_box_pack_start (GTK_BOX (vbox), buttonbox, FALSE, TRUE, 0);
674: gtk_widget_show (buttonbox);
675: thing = gtk_button_new_with_label ("Reset");
676: gtk_signal_connect (GTK_OBJECT (thing), "clicked", (GtkSignalFunc) did_reset, NULL);
677: gtk_box_pack_start (GTK_BOX (buttonbox), thing, FALSE, TRUE, 0);
678: gtk_widget_show (thing);
679: thing = gtk_button_new_with_label ("Debug");
680: gtk_signal_connect (GTK_OBJECT (thing), "clicked", (GtkSignalFunc) did_debug, NULL);
681: gtk_box_pack_start (GTK_BOX (buttonbox), thing, FALSE, TRUE, 0);
682: gtk_widget_show (thing);
683: thing = gtk_button_new_with_label ("Quit");
684: gtk_signal_connect (GTK_OBJECT (thing), "clicked", (GtkSignalFunc) did_quit, NULL);
685: gtk_box_pack_start (GTK_BOX (buttonbox), thing, FALSE, TRUE, 0);
686: gtk_widget_show (thing);
687: /* An empty but expanded vbox to make the LED appear at the right border. */
688: thing = gtk_vbox_new (FALSE, 0);
689: gtk_box_pack_start (GTK_BOX (buttonbox), thing, TRUE, TRUE, 0);
690: gtk_widget_show (thing);
691: thing = make_led (0);
692: gtk_box_pack_start (GTK_BOX (buttonbox), thing, FALSE, TRUE, 0);
693: gtk_widget_show (thing);
694:
695: /* The next box contains the "Save configuration" button. */
696: buttonbox = gtk_hbox_new (FALSE, 4);
697: gtk_box_pack_start (GTK_BOX (vbox), buttonbox, FALSE, TRUE, 0);
698: gtk_widget_show (buttonbox);
699:
700: thing = gtk_button_new_with_label ("Save config");
701: gtk_signal_connect (GTK_OBJECT (thing), "clicked", (GtkSignalFunc) save_config, NULL);
702: gtk_box_pack_start (GTK_BOX (buttonbox), thing, FALSE, TRUE, 0);
703: gtk_widget_show (thing);
704:
705: /* Place a separator below those three buttons. */
706: thing = gtk_hseparator_new ();
707: gtk_box_pack_start (GTK_BOX (vbox), thing, FALSE, TRUE, 0);
708: gtk_widget_show (thing);
709:
710: notebook = gtk_notebook_new ();
711: gtk_box_pack_start (GTK_BOX (vbox), notebook, FALSE, TRUE, 0);
712: gtk_widget_show (notebook);
713:
714: thing = gtk_vbox_new (FALSE, 4);
715: gtk_widget_show (thing);
716: make_floppy_disks (thing);
717: gtk_notebook_append_page (GTK_NOTEBOOK (notebook), thing, gtk_label_new ("Floppy disks"));
718:
719: thing = gtk_hbox_new (FALSE, 4);
720: gtk_widget_show (thing);
721: make_cpu_widgets (thing);
722: gtk_notebook_append_page (GTK_NOTEBOOK (notebook), thing, gtk_label_new ("CPU emulation"));
723:
724: thing = gtk_hbox_new (FALSE, 4);
725: gtk_widget_show (thing);
726: make_gfx_widgets (thing);
727: gtk_notebook_append_page (GTK_NOTEBOOK (notebook), thing, gtk_label_new ("Graphics"));
728:
729: thing = gtk_hbox_new (FALSE, 4);
730: gtk_widget_show (thing);
731: make_joy_widgets (thing);
732: gtk_notebook_append_page (GTK_NOTEBOOK (notebook), thing, gtk_label_new ("Game ports"));
733:
734: enable_disk_buttons (1);
735:
736: gtk_widget_show (vbox);
737: gtk_widget_show (window);
738:
739: /* We're going to need that later. */
740: selector = gtk_file_selection_new ("");
741: gtk_signal_connect (GTK_OBJECT (selector), "destroy",
742: (GtkSignalFunc) did_close_insert, selector);
743:
744: gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (selector)->ok_button),
745: "clicked", (GtkSignalFunc) did_insert_select,
746: GTK_OBJECT (selector));
747: gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (selector)->cancel_button),
748: "clicked", (GtkSignalFunc) did_cancel_insert,
749: GTK_OBJECT (selector));
750: filesel_active = -1;
751:
752: gtk_timeout_add (1000, (GtkFunction)my_idle, 0);
753: gtk_main ();
754:
755: quitted_gui = 1;
756: uae_sem_post (&gui_quit_sem);
757: return 0;
758: }
759:
760: void gui_changesettings(void)
761: {
762:
763: }
764:
765: int gui_init (void)
766: {
767: penguin_id tid;
768:
769: gui_active = 0;
770:
771: init_comm_pipe (&to_gui_pipe, 20, 1);
772: init_comm_pipe (&from_gui_pipe, 20, 1);
773: uae_sem_init (&gui_sem, 0, 1);
774: uae_sem_init (&gui_quit_sem, 0, 0);
775: start_penguin (gtk_penguin, NULL, &tid);
776: return 1;
777: }
778:
779: int gui_update (void)
780: {
781: if (no_gui)
782: return 0;
783:
784: write_comm_pipe_int (&to_gui_pipe, 1, 1);
785: return 0;
786: }
787:
788: void gui_exit (void)
789: {
790: if (no_gui)
791: return;
792:
793: quit_gui = 1;
794: uae_sem_wait (&gui_quit_sem);
795: }
796:
797: void gui_led(int num, int on)
798: {
799: if (no_gui)
800: return;
801:
802: /* if (num == 0)
803: return;
804: printf("LED %d %d\n", num, on);
805: write_comm_pipe_int (&to_gui_pipe, 1, 0);
806: write_comm_pipe_int (&to_gui_pipe, num == 0 ? 4 : num - 1, 0);
807: write_comm_pipe_int (&to_gui_pipe, on, 1);
808: printf("#LED %d %d\n", num, on);*/
809: }
810:
811: void gui_filename(int num, const char *name)
812: {
813: if (no_gui)
814: return;
815:
816: write_comm_pipe_int (&to_gui_pipe, 0, 0);
817: write_comm_pipe_int (&to_gui_pipe, num, 1);
818:
819: /* gui_update ();*/
820: }
821:
822: void gui_handle_events(void)
823: {
824: if (no_gui)
825: return;
826:
827: while (comm_pipe_has_data (&from_gui_pipe)) {
828: int cmd = read_comm_pipe_int_blocking (&from_gui_pipe);
829: int n;
830: switch (cmd) {
831: case 0:
832: n = read_comm_pipe_int_blocking (&from_gui_pipe);
833: changed_prefs.df[n][0] = '\0';
834: break;
835: case 1:
836: n = read_comm_pipe_int_blocking (&from_gui_pipe);
837: uae_sem_wait (&gui_sem);
838: strncpy (changed_prefs.df[n], new_disk_string[n], 255);
839: changed_prefs.df[n][255] = '\0';
840: uae_sem_post (&gui_sem);
841: break;
842: case 2:
843: uae_reset ();
844: break;
845: case 3:
846: activate_debugger ();
847: break;
848: case 4:
849: uae_quit ();
850: break;
851: }
852: }
853:
854: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.