![[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 / gui-gtk|
Return to gtkui.c CVS log | Up to [UNIX Amiga Emulator] / uae / src / gui-gtk |
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: * Copyright 1998 Michael Krause
8: *
9: * The Tk GUI doesn't work.
10: * The X Forms Library isn't available as source, and there aren't any
11: * binaries compiled against glibc
12: *
13: * So let's try this...
14: */
15:
16: #include "sysconfig.h"
17: #include "sysdeps.h"
18:
19: #include "options.h"
20: #include "uae.h"
21: #include "memory.h"
22: #include "custom.h"
23: #include "audio.h"
24: #include "gui.h"
25: #include "newcpu.h"
26: #include "autoconf.h"
27: #include "filesys.h"
28: #include "threaddep/thread.h"
29: #include "sounddep/sound.h"
30: #include "savestate.h"
31: #include "debug.h"
32: #include "inputdevice.h"
33: #include "romlist.h"
34: #include "zfile.h"
35:
36: #include <gtk/gtk.h>
37: #include <gdk/gdk.h>
38:
39: /* One of the 1.1.6 "features" is a gratuitous name change */
40: #ifndef HAVE_GTK_FEATURES_1_1_6
41: #define gtk_container_set_border_width gtk_container_border_width
42: #endif
43: /* Likewise for 1.1.8. */
44: #ifndef HAVE_GTK_FEATURES_1_1_8
45: #define gtk_label_set_text gtk_label_set
46: #endif
47: /* This is beginning to suck... */
48: #ifndef HAVE_GTK_FEATURES_1_1_13
49: #define gtk_toggle_button_set_active gtk_toggle_button_set_state
50: #endif
51:
52: #include "util.h"
53:
54: static int gui_active, gui_available;
55:
56: static GtkWidget *gui_window;
57:
58: static GtkWidget *pause_uae_widget, *snap_save_widget, *snap_load_widget;
59:
60: static GtkWidget *chipsize_widget[5];
61: static GtkWidget *bogosize_widget[4];
62: static GtkWidget *fastsize_widget[5];
63: static GtkWidget *z3size_widget[10];
64: static GtkWidget *p96size_widget[7];
65: static GtkWidget *rom_text_widget, *rom_path_widget, *key_text_widget;
66: static GtkWidget *romlist_widget, *romsel_button;
67: static int romlist_nr_entries;
68:
69: static GtkWidget *disk_insert_widget[4], *disk_eject_widget[4], *disk_text_widget[4];
70: static GtkWidget *dftype_widget[4];
71: static GtkWidget *disk_type_widget[4];
72:
73: static GtkAdjustment *cpuspeed_adj;
74: static GtkWidget *cpuspeed_widgets[4], *cpuspeed_scale;
75: static GtkWidget *cpu_widget[7], *fpu_widget[5];
76: static GtkWidget *sound_widget[4], *sound_ch_widget[3], *sound_interpol_widget[5];
77: static GtkWidget *sound_filter_widget[5];
78: static GtkAdjustment *stereo_sep_adj, *stereo_delay_adj;
79: static GtkWidget *stereo_sep_scale, *stereo_delay_scale;
80:
81: static GtkWidget *coll_widget[4], *cslevel_widget[4], *ntsc_widget[2];
82: static GtkWidget *mbtype_widget, *mbtype_labelled;
83: static GtkWidget *fcop_widget;
84:
85: static GtkAdjustment *framerate_adj;
86: static GtkWidget *bimm_widget, *b32_widget, *afscr_widget, *pfscr_widget;
87:
88: struct scrmode_widgets
89: {
90: GtkWidget *frame, *modelist;
91: GtkWidget *hcenter, *vcenter, *aspect, *linedbl, *leds;
92: GtkWidget *hc_label, *vc_label, *ld_label;
93: };
94:
95: static struct scrmode_widgets gw_windowed, gw_fullscreen;
96:
97: static GtkWidget *joy_widget[2][6], *legacy_widget, *kbdlang_widget;
98:
99: static GtkWidget *led_widgets[5];
100: static GdkColor led_on[5], led_off[5];
101: static unsigned int prevledstate;
102:
103: static GtkListStore *hd_store;
104: static GtkWidget *hdlist_widget, *bootrom_widget;
105: static GtkWidget *hdchange_button, *hddel_button;
106: static GtkTreeSelection *hd_selection;
107:
108: static GtkWidget *preset_list, *preset_button;
109: static GtkTreeSelection *preset_selection;
110:
111: static GtkWidget *req68020, *req68ec020, *req68030, *reqa4000, *reqa1000;
112: static int rom_req;
113:
114: static GtkWidget *lab_info;
115: static GtkWidget *notebook;
116:
117: GtkWidget *disk_selector;
118:
119: static uae_sem_t gui_sem;
120:
121: /* Copies of certain changed_prefs elements, local to the GUI thread and
122: protected by the gui_sem. */
123: static struct gfx_params gfx_w, gfx_f;
124: static char *gui_snapname, *gui_romname, *gui_keyname;
125: static char *new_disk_string[4];
126:
127:
128: static smp_comm_pipe to_gui_pipe, from_gui_pipe;
129:
130: /* Set to ignore the widget callbacks while we're in the process of updating
131: them with new data. */
132: static int ignore_gui_changes;
133:
134: /*
135: * Messages sent to GUI from UAE via to_gui_pipe
136: */
137: enum gui_commands {
138: GUICMD_SHOW, // Show yourself
139: GUICMD_UPDATE, // Refresh your state from changed preferences
140: GUICMD_DISKCHANGE, // Hey! A disk has been changed. Do something!
141: GUICMD_MSGBOX, // Display a message box for me, please
142: GUICMD_NEW_ROMLIST, // The ROM list has been updated.
143: GUICMD_FLOPPYDLG, // Open a floppy insert dialog
144: GUICMD_FULLSCREEN, // Fullscreen mode was toggled; update checkboxes
145: GUICMD_PAUSE, // We're now paused, in case you didn't notice
146: GUICMD_UNPAUSE // We're now running.
147: };
148:
149: static uae_sem_t gui_sem, gui_init_sem, gui_quit_sem; /* gui_sem protects the DFx fields */
150:
151: static volatile int quit_gui = 0;
152:
153: /* Message box functions. */
154:
155:
156: static GtkWidget *make_labelled_button (guchar *label, GtkAccelGroup *accel_group)
157: {
158: return gtk_button_new_with_mnemonic (label);
159: }
160:
161: static int find_current_toggle (GtkWidget **widgets, int count)
162: {
163: int i;
164: for (i = 0; i < count; i++)
165: if (GTK_TOGGLE_BUTTON (*widgets++)->active)
166: return i;
167: write_log ("GTKUI: Can't happen!\n");
168: return -1;
169: }
170:
171: /*
172: * make_message_box()
173: *
174: * This does the actual work of constructing the message dialog.
175: *
176: * title - displayed in the dialog's titlebar
177: * message - the message itself
178: * modal - whether the dialog should block input to the rest of the GUI
179: * sem - semaphore used for signalling that the dialog's finished
180: *
181: * TODO: Make that semaphore go away. We shouldn't need to know about it here.
182: */
183:
184: static void make_message_box (const char *title, const char *message, int modal)
185: {
186: GtkWidget *dialog;
187: GtkWidget *vbox, *hbox;
188: GtkWidget *label;
189:
190: if (title == NULL || strlen (title) == 0)
191: title = PACKAGE_NAME " information";
192: dialog = gtk_dialog_new_with_buttons (title, NULL,
193: (modal ? GTK_DIALOG_MODAL : 0),
194: GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
195: NULL);
196:
197: gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
198:
199: vbox = GTK_DIALOG (dialog)->vbox;
200:
201: hbox = gtk_hbox_new (FALSE, 0);
202: gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 20);
203: gtk_widget_show (hbox);
204:
205: label = gtk_label_new (message);
206: gtk_widget_show (label);
207: gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 20);
208: gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
209:
210: gtk_dialog_run (GTK_DIALOG (dialog));
211:
212: gtk_widget_destroy (dialog);
213: }
214:
215: static void mkmsgbox (const char *title, const char *message)
216: {
217: make_message_box (title, message, 1);
218: }
219:
220: /*
221: * handle_message_box_request()
222: *
223: * This is called from the GUI's context in repsonse to do_message_box()
224: * to actually create the dialog box
225: */
226: static void handle_message_box_request (smp_comm_pipe *msg_pipe)
227: {
228: const char *title = (const char *) read_comm_pipe_pvoid_blocking (msg_pipe);
229: const char *msg = (const char *) read_comm_pipe_pvoid_blocking (msg_pipe);
230: int modal = read_comm_pipe_int_blocking (msg_pipe);
231: uae_sem_t *msg_quit_sem = (uae_sem_t *) read_comm_pipe_pvoid_blocking (msg_pipe);
232:
233: make_message_box (title, msg, modal);
234: uae_sem_post (msg_quit_sem);
235: }
236:
237: /*
238: * do_message_box()
239: *
240: * This makes up for GTK's lack of a function for creating simple message dialogs.
241: * It can be called from any context. gui_init() must have been called at some point
242: * previously.
243: *
244: * title - will be displayed in the dialog's titlebar (or NULL for default)
245: * message - the message itself
246: * modal - should the dialog block input to the rest of the GUI
247: * wait - should the dialog wait until the user has acknowledged it
248: */
249: static void do_message_box (const guchar *title, const guchar *message, gboolean modal, gboolean wait)
250: {
251: uae_sem_t msg_quit_sem;
252:
253: // If we a need reply, then this semaphore which will be used
254: // to signal us when the dialog has been exited.
255: uae_sem_init (&msg_quit_sem, 0, 0);
256:
257: write_comm_pipe_int (&to_gui_pipe, GUICMD_MSGBOX, 0);
258: write_comm_pipe_pvoid (&to_gui_pipe, (void *) title, 0);
259: write_comm_pipe_pvoid (&to_gui_pipe, (void *) message, 0);
260: write_comm_pipe_int (&to_gui_pipe, (int) modal, 0);
261: write_comm_pipe_pvoid (&to_gui_pipe, wait?&msg_quit_sem:NULL, 1);
262:
263: if (wait)
264: uae_sem_wait (&msg_quit_sem);
265: }
266:
267: void gui_message (const char *format, ...)
268: {
269: char msg[2048];
270: va_list parms;
271:
272: va_start (parms,format);
273: vsprintf ( msg, format, parms);
274: va_end (parms);
275:
276: if (gui_available)
277: do_message_box (NULL, msg, TRUE, TRUE);
278:
279: write_log (msg);
280: }
281:
282: /* Config save/load. */
283:
284: static void save_config (void)
285: {
286: FILE *f;
287: char tmp[257];
288:
289: /* Backup the options file. */
290: strcpy (tmp, optionsfile);
291: strcat (tmp, "~");
292: rename (optionsfile, tmp);
293:
294: f = fopen (optionsfile, "w");
295: if (f == NULL) {
296: write_log ("Error saving options file!\n");
297: return;
298: }
299: save_options (f, &changed_prefs);
300: fclose (f);
301: }
302:
303: static int nr_for_led (GtkWidget *led)
304: {
305: int i;
306: i = 0;
307: while (led_widgets[i] != led)
308: i++;
309: return i;
310: }
311:
312: static void enable_disk_buttons (int enable)
313: {
314: int i;
315: for (i = 0; i < 4; i++) {
316: drive_type t = changed_prefs.dfxtype[i];
317: gtk_widget_set_sensitive (disk_insert_widget[i], enable && t != DRV_NONE);
318: gtk_widget_set_sensitive (disk_eject_widget[i], enable && t != DRV_NONE);
319: gtk_widget_set_sensitive (dftype_widget[i], enable);
320: }
321: }
322:
323: static void set_disk_state (void)
324: {
325: int i;
326: ignore_gui_changes++;
327: for (i = 0; i < 4; i++) {
328: drive_type t = changed_prefs.dfxtype[i];
329: int n;
330: if (i == 0)
331: n = t == DRV_35_DD ? 0 : 1;
332: else
333: n = t == DRV_35_DD ? 1 : t == DRV_35_HD ? 2 : 0;
334: gtk_combo_box_set_active (GTK_COMBO_BOX (dftype_widget[i]), n);
335: }
336: ignore_gui_changes--;
337: }
338:
339: static void set_romlist_state (void)
340: {
341: int i;
342: int active_entry = 0;
343:
344: for (i = 1; i < romlist_nr_entries; i++)
345: gtk_combo_box_remove_text (GTK_COMBO_BOX (romlist_widget), 1);
346: romlist_nr_entries = 1;
347:
348: for (i = 0;; i++) {
349: struct romlist *rl = romlist_from_idx (i, ROMTYPE_KICK, 1);
350: if (!rl)
351: break;
352: if ((changed_prefs.rom_crc32 != 0 && rl->rd->crc32 == changed_prefs.rom_crc32)
353: || (changed_prefs.rom_crc32 == 0 && strcmp (rl->path, changed_prefs.romfile) == 0))
354: active_entry = romlist_nr_entries;
355: gtk_combo_box_append_text (GTK_COMBO_BOX (romlist_widget), rl->rd->name);
356: romlist_nr_entries++;
357: }
358: gtk_combo_box_set_active (GTK_COMBO_BOX (romlist_widget), active_entry);
359: gtk_widget_set_sensitive (romsel_button, active_entry == 0);
360: gtk_widget_set_sensitive (rom_text_widget, active_entry == 0);
361: }
362:
363: static void set_cpu_state (void)
364: {
365: gtk_widget_set_sensitive (cpuspeed_scale, changed_prefs.m68k_speed > 0);
366:
367: gtk_widget_set_sensitive (fpu_widget[0], changed_prefs.cpu_model != 68040 && changed_prefs.cpu_model != 68060);
368: gtk_widget_set_sensitive (fpu_widget[1], changed_prefs.cpu_model == 68020 || changed_prefs.cpu_model == 68030);
369: gtk_widget_set_sensitive (fpu_widget[2], changed_prefs.cpu_model == 68020 || changed_prefs.cpu_model == 68030);
370: gtk_widget_set_sensitive (fpu_widget[3], changed_prefs.cpu_model == 68040);
371: gtk_widget_set_sensitive (fpu_widget[4], changed_prefs.cpu_model == 68060);
372: }
373:
374: static void set_cpu_widget (void)
375: {
376: int nr = (changed_prefs.cpu_model == 68000 ? 0
377: : changed_prefs.cpu_model == 68010 ? 1
378: : changed_prefs.cpu_model == 68020 ? 2
379: : changed_prefs.cpu_model == 68030 ? 4
380: : changed_prefs.cpu_model == 68040 ? 5
381: : 6);
382:
383: if (nr == 2 && !changed_prefs.address_space_24)
384: nr++;
385: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (cpu_widget[nr]), TRUE);
386:
387: nr = (changed_prefs.fpu_model == 68881 ? 1
388: : changed_prefs.fpu_model == 68882 ? 2
389: : changed_prefs.cpu_model == 68040 ? 3
390: : changed_prefs.cpu_model == 68060 ? 4
391: : 0);
392: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (fpu_widget[nr]), TRUE);
393: nr = changed_prefs.m68k_speed + 1 < 3 ? changed_prefs.m68k_speed + 1 : 2;
394: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (cpuspeed_widgets[nr]), TRUE);
395: }
396:
397: /* The idea behind this is to keep entries in aspect/centering boxes even
398: if a screen mode is selected where they are unnecessary, but set the
399: prefs to sane values. */
400: static void adjust_gfx_prefs (struct gfx_params *gp, struct scrmode_widgets *w)
401: {
402: int need_hcenter, need_vcenter, need_aspect, need_linedbl;
403: need_hcenter = gp->width < 400 || (gp->width > 512 && gp->width < 800);
404: need_vcenter = gp->height <= 256 || (gp->height > 300 && gp->height <= 512);
405: need_linedbl = gp->height >= 400;
406: need_aspect = ((gp->height < 256 || (gp->height > 300 && gp->height < 512))
407: && gp->height * 5 / 4 < gp->width);
408:
409: gtk_widget_set_sensitive (w->vc_label, need_vcenter);
410: gtk_widget_set_sensitive (w->hc_label, need_hcenter);
411: gtk_widget_set_sensitive (w->aspect, need_aspect);
412: gtk_widget_set_sensitive (w->ld_label, need_linedbl);
413:
414: if (!need_linedbl)
415: gp->linedbl = 0;
416: if (!need_aspect)
417: gp->correct_aspect = FALSE;
418: if (!need_vcenter)
419: gp->ycenter = 0;
420: if (!need_hcenter)
421: gp->xcenter = 0;
422: }
423:
424: static void set_gfx_mode_state (struct gfx_params *gp, struct scrmode_widgets *w)
425: {
426: ignore_gui_changes++;
427:
428: gtk_combo_box_set_active (GTK_COMBO_BOX (w->linedbl), gp->linedbl ? gp->linedbl - 1 : 1);
429: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w->aspect), gp->correct_aspect);
430: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w->leds), gp->leds_on_screen);
431:
432: gtk_combo_box_set_active (GTK_COMBO_BOX (w->hcenter), gp->xcenter);
433: gtk_combo_box_set_active (GTK_COMBO_BOX (w->vcenter), gp->ycenter);
434: ignore_gui_changes--;
435: }
436:
437: static void set_fullscreen_state (void)
438: {
439: ignore_gui_changes++;
440: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (afscr_widget), changed_prefs.gfx_afullscreen != 0);
441: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pfscr_widget), changed_prefs.gfx_pfullscreen != 0);
442: ignore_gui_changes--;
443: }
444:
445: static void set_gfx_state (void)
446: {
447: int t;
448:
449: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (bimm_widget), changed_prefs.immediate_blits != 0);
450:
451: ignore_gui_changes++;
452: uae_sem_wait (&gui_sem);
453: t = fixup_prefs_dimensions (&gfx_w, gfx_windowed_modes, n_windowed_modes);
454: gtk_combo_box_set_active (GTK_COMBO_BOX (gw_windowed.modelist), t);
455: t = fixup_prefs_dimensions (&gfx_f, gfx_fullscreen_modes, n_fullscreen_modes);
456: gtk_combo_box_set_active (GTK_COMBO_BOX (gw_fullscreen.modelist), t);
457: ignore_gui_changes--;
458:
459: adjust_gfx_prefs (&gfx_w, &gw_windowed);
460: adjust_gfx_prefs (&gfx_f, &gw_fullscreen);
461: uae_sem_post (&gui_sem);
462:
463: set_gfx_mode_state (&gfx_w, &gw_windowed);
464: set_gfx_mode_state (&gfx_f, &gw_fullscreen);
465:
466: set_fullscreen_state ();
467: #if 0
468: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (b32_widget), changed_prefs.blits_32bit_enabled != 0);
469: #endif
470: }
471:
472: /* The intended behaviour here is that on startup, and when loading a state
473: file, we examine the prefs to see if they match a given motherboard, and
474: initialize the combo box accordingly. When the user changes it, default
475: settings are automatically chosen unless the user sets "Generic", in which
476: case he has control over all the options. */
477: static void discover_cstype (void)
478: {
479: int t0;
480: int cstype = cstype_from_prefs (&changed_prefs);
481:
482: t0 = (cstype == CP_GENERIC ? 0
483: : cstype == CP_A1000 ? 1
484: : cstype == CP_A500 || cstype == CP_A500P ? 2
485: : cstype == CP_A600 ? 3
486: : cstype == CP_A1200 ? 4
487: : cstype == CP_A3000 ? 5
488: : 6);
489:
490: ignore_gui_changes++;
491: gtk_combo_box_set_active (GTK_COMBO_BOX (mbtype_widget), t0);
492: ignore_gui_changes--;
493: }
494:
495: static void set_chipset_state (void)
496: {
497: int t0 = 0;
498:
499: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (coll_widget[changed_prefs.collision_level]), TRUE);
500: if (changed_prefs.chipset_mask & CSMASK_AGA)
501: t0 = 3;
502: else if (changed_prefs.chipset_mask & CSMASK_ECS_DENISE)
503: t0 = 2;
504: else if (changed_prefs.chipset_mask & CSMASK_ECS_AGNUS)
505: t0 = 1;
506: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (cslevel_widget[t0]), TRUE);
507: }
508:
509: static void set_sound_state (void)
510: {
511: int n;
512: int stereo = changed_prefs.sound_stereo;
513:
514: gtk_widget_set_sensitive (stereo_sep_scale, changed_prefs.sound_stereo != SND_MONO);
515: gtk_widget_set_sensitive (stereo_delay_scale, changed_prefs.sound_stereo != SND_MONO);
516:
517: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (sound_widget[changed_prefs.produce_sound]), 1);
518: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (sound_ch_widget[stereo]), 1);
519: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (sound_interpol_widget[changed_prefs.sound_interpol]), 1);
520: n = (changed_prefs.sound_filter == FILTER_SOUND_OFF ? 0
521: : ((changed_prefs.sound_filter == FILTER_SOUND_EMUL ? 1 : 2)
522: + (changed_prefs.sound_filter_type == FILTER_SOUND_TYPE_A500 ? 0 : 2)));
523: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (sound_filter_widget[n]), 1);
524: }
525:
526: static void set_mem_state (void)
527: {
528: int bogo2m_ok;
529: int t, t2, i;
530:
531: for (i = 0; i < 10; i++)
532: gtk_widget_set_sensitive (z3size_widget[i], ! changed_prefs.address_space_24);
533: for (i = 0; i < 7; i++)
534: gtk_widget_set_sensitive (p96size_widget[i],
535: changed_prefs.bootrom && ! changed_prefs.address_space_24);
536:
537: bogo2m_ok = !((changed_prefs.chipset_mask & CSMASK_AGA) || changed_prefs.cpu_model >= 68020);
538: gtk_widget_set_sensitive (bogosize_widget[3], bogo2m_ok);
539:
540: t = 0;
541: t2 = changed_prefs.chipmem_size;
542: while (t < 4 && t2 > 0x80000)
543: t++, t2 >>= 1;
544: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (chipsize_widget[t]), 1);
545:
546: t = 0;
547: t2 = changed_prefs.bogomem_size;
548: if (t2 > 0x100000 && !bogo2m_ok)
549: t2 = 0x100000;
550: changed_prefs.bogomem_size = t2;
551: while (t < 3 && t2 >= 0x80000)
552: t++, t2 >>= 1;
553: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (bogosize_widget[t]), 1);
554:
555: t = 0;
556: t2 = changed_prefs.fastmem_size;
557: while (t < 4 && t2 >= 0x100000)
558: t++, t2 >>= 1;
559: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (fastsize_widget[t]), 1);
560:
561: t = 0;
562: t2 = changed_prefs.z3fastmem_size;
563: while (t < 9 && t2 >= 0x100000)
564: t++, t2 >>= 1;
565: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (z3size_widget[t]), 1);
566:
567: t = 0;
568: t2 = changed_prefs.gfxmem_size;
569: while (t < 6 && t2 >= 0x100000)
570: t++, t2 >>= 1;
571: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (p96size_widget[t]), 1);
572:
573: gtk_label_set_text (GTK_LABEL (rom_path_widget), changed_prefs.path_rom);
574: gtk_label_set_text (GTK_LABEL (rom_text_widget), changed_prefs.romfile);
575: gtk_label_set_text (GTK_LABEL (key_text_widget), changed_prefs.keyfile);
576: }
577:
578: static void set_joy_state (void)
579: {
580: int joy_count = inputdevice_get_device_total (IDTYPE_JOYSTICK);
581: int j0j = jsem_isjoy (0, &changed_prefs);
582: int j0m = jsem_ismouse (0, &changed_prefs);
583: int j0k = jsem_iskbdjoy (0, &changed_prefs);
584: int j1j = jsem_isjoy (1, &changed_prefs);
585: int j1m = jsem_ismouse (1, &changed_prefs);
586: int j1k = jsem_iskbdjoy (1, &changed_prefs);
587: int j0t = (j0j == 0 || j0j == 1 ? j0j
588: : j0m == 0 ? 2
589: : j0k + 3);
590: int j1t = (j1j == 0 || j1j == 1 ? j1j
591: : j1m == 0 ? 2
592: : j1k + 3);
593: int i;
594:
595: if (j0t == j1t) {
596: /* Can't happen */
597: j0t++;
598: j0t %= 6;
599: }
600:
601: for (i = 0; i < 6; i++) {
602: int available = i >= 2 || joy_count > i;
603: if (changed_prefs.input_selected_setting != 0)
604: available = 0;
605: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (joy_widget[0][i]), j0t == i);
606: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (joy_widget[1][i]), j1t == i);
607: gtk_widget_set_sensitive (joy_widget[0][i], available && j1t != i);
608: gtk_widget_set_sensitive (joy_widget[1][i], available && j0t != i);
609: }
610:
611: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (legacy_widget),
612: changed_prefs.input_selected_setting == 0);
613:
614: gtk_combo_box_set_active (GTK_COMBO_BOX (kbdlang_widget),
615: changed_prefs.keyboard_lang);
616: }
617:
618: static void set_hd_state (void)
619: {
620: char texts[9][256];
621: int nr = nr_units (currprefs.mountinfo);
622: int i;
623:
624: gtk_list_store_clear (hd_store);
625: for (i = 0; i < nr; i++) {
626: GtkTreeIter iter;
627: int secspertrack, surfaces, reserved, blocksize, size;
628: int cylinders, readonly, pri;
629: char *volname, *rootdir, *devname;
630: char *failure;
631:
632: /* We always use currprefs.mountinfo for the GUI. The filesystem
633: code makes a private copy which is updated every reset. */
634: failure = get_filesys_unit (currprefs.mountinfo, i,
635: &devname, &volname, &rootdir, &readonly,
636: &secspertrack, &surfaces, &reserved,
637: &cylinders, &size, &blocksize, &pri);
638:
639: if (is_hardfile (currprefs.mountinfo, i)) {
640: sprintf (texts[0], "DH%d", i );
641: sprintf (texts[3], "%d", surfaces);
642: sprintf (texts[4], "%d", cylinders);
643: sprintf (texts[5], "%d", secspertrack);
644: sprintf (texts[6], "%d", reserved);
645: sprintf (texts[7], "%d", size);
646: sprintf (texts[8], "%d", blocksize);
647: } else {
648: strcpy (texts[0], volname);
649: strcpy (texts[3], "n/a");
650: strcpy (texts[4], "n/a");
651: strcpy (texts[5], "n/a");
652: strcpy (texts[6], "n/a");
653: strcpy (texts[7], "n/a");
654: strcpy (texts[8], "n/a");
655: }
656: strcpy (texts[1], rootdir);
657: gtk_list_store_append (hd_store, &iter);
658:
659: gtk_list_store_set (hd_store, &iter,
660: 0, i,
661: 1, texts[0],
662: 2, texts[1],
663: 3, readonly,
664: 4, texts[3],
665: 5, texts[4],
666: 6, texts[5],
667: 7, texts[6],
668: 8, texts[7],
669: 9, texts[8],
670: 10, pri,
671: -1);
672: if (volname)
673: free (volname);
674: if (devname)
675: free (devname);
676: if (rootdir)
677: free (rootdir);
678: }
679: gtk_widget_set_sensitive (hdchange_button, FALSE);
680: gtk_widget_set_sensitive (hddel_button, FALSE);
681:
682: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (bootrom_widget),
683: changed_prefs.bootrom != 0);
684: }
685:
686: static void rom_requirements_change (void)
687: {
688: int i, min_widget = 0;
689:
690: gtk_widget_hide (req68020);
691: gtk_widget_hide (req68ec020);
692: gtk_widget_hide (req68030);
693: gtk_widget_hide (reqa1000);
694: gtk_widget_hide (reqa4000);
695: if ((rom_req & ROMREQ_CPUMASK) == ROMREQ_68EC020) {
696: min_widget = 2;
697: gtk_widget_show (req68ec020);
698: } else if ((rom_req & ROMREQ_CPUMASK) == ROMREQ_68020) {
699: min_widget = 3;
700: gtk_widget_show (req68020);
701: } else if ((rom_req & ROMREQ_CPUMASK) == ROMREQ_68030) {
702: min_widget = 4;
703: gtk_widget_show (req68030);
704: }
705: if (rom_req & ROMREQ_A4000MB) {
706: gtk_widget_show (reqa4000);
707: gtk_combo_box_set_active (GTK_COMBO_BOX (mbtype_widget), 6);
708: gtk_widget_set_sensitive (mbtype_labelled, 0);
709: } else if (rom_req & ROMREQ_A1000) {
710: gtk_widget_show (reqa1000);
711: gtk_combo_box_set_active (GTK_COMBO_BOX (mbtype_widget), 1);
712: gtk_widget_set_sensitive (mbtype_labelled, 0);
713: } else
714: gtk_widget_set_sensitive (mbtype_labelled, 1);
715:
716: i = find_current_toggle (cpu_widget, 7);
717: if (i < min_widget)
718: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (cpu_widget[min_widget]), TRUE);
719:
720: for (i = 0; i < 7; i++)
721: gtk_widget_set_sensitive (cpu_widget[i], i >= min_widget);
722: }
723:
724: static void draw_led (int nr)
725: {
726: GtkWidget *thing = led_widgets[nr];
727: GdkWindow *window = thing->window;
728: GdkGC *gc = gdk_gc_new (window);
729: GdkColor *col;
730:
731: if (gui_ledstate & (1 << nr))
732: col = led_on + nr;
733: else
734: col = led_off + nr;
735: gdk_gc_set_foreground (gc, col);
736: gdk_draw_rectangle (window, gc, 1, 0, 0, -1, -1);
737: gdk_gc_destroy (gc);
738: }
739:
740: static void set_widgets_from_config (void)
741: {
742: gfx_w = changed_prefs.gfx_w;
743: gfx_f = changed_prefs.gfx_f;
744: set_disk_state ();
745: enable_disk_buttons (1);
746: set_romlist_state ();
747: set_cpu_widget ();
748: set_cpu_state ();
749: set_gfx_state ();
750: set_joy_state ();
751: set_sound_state ();
752: set_mem_state ();
753: set_hd_state ();
754: discover_cstype ();
755: set_chipset_state ();
756: rom_requirements_change ();
757: }
758:
759: static int my_idle (void)
760: {
761: unsigned int leds = gui_ledstate;
762: int i;
763:
764: if (quit_gui) {
765: gui_active = 0;
766: gtk_main_quit ();
767: goto out;
768: }
769:
770: while (comm_pipe_has_data (&to_gui_pipe)) {
771: int cmd = read_comm_pipe_int_blocking (&to_gui_pipe);
772: int n;
773: switch (cmd) {
774: case GUICMD_DISKCHANGE:
775: n = read_comm_pipe_int_blocking (&to_gui_pipe);
776: gtk_label_set_text (GTK_LABEL (disk_text_widget[n]), currprefs.df[n]);
777: break;
778: case GUICMD_UPDATE:
779: /* Initialization. */
780: set_widgets_from_config ();
781:
782: gtk_widget_show (gui_window);
783: uae_sem_post (&gui_init_sem);
784: gui_active = 1;
785: break;
786: case GUICMD_PAUSE:
787: /* Set Pause-Button active */
788: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pause_uae_widget), TRUE);
789: break;
790: case GUICMD_UNPAUSE:
791: /* Set Pause-Button inactive */
792: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pause_uae_widget), FALSE);
793: break;
794: case GUICMD_NEW_ROMLIST:
795: set_romlist_state ();
796: break;
797: case GUICMD_FULLSCREEN:
798: set_fullscreen_state ();
799: break;
800: case GUICMD_MSGBOX:
801: handle_message_box_request(&to_gui_pipe);
802: break;
803: }
804: }
805:
806: if (gui_active) {
807: int n = gtk_notebook_get_current_page (GTK_NOTEBOOK (notebook)) == 0 ? 5 : 1;
808: for (i = 0; i < n; i++) {
809: unsigned int mask = 1 << i;
810: unsigned int on = leds & mask;
811:
812: if (on == (prevledstate & mask))
813: continue;
814:
815: /* printf(": %d %d\n", i, on);*/
816: draw_led (i);
817: }
818: prevledstate = leds;
819: }
820: out:
821: return 1;
822: }
823:
824: static gint gui_delete_event (GtkWidget *widget, GdkEvent *event, gpointer data)
825: {
826: gui_active = gui_available = 0;
827: gtk_widget_destroy (disk_selector);
828: disk_selector = 0;
829: return FALSE;
830: }
831:
832: static void dftype_changed (GtkWidget *w, gpointer data)
833: {
834: int i;
835:
836: if (ignore_gui_changes)
837: return;
838: for (i = 0; i < 4; i++) {
839: int which = gtk_combo_box_get_active (GTK_COMBO_BOX (dftype_widget[i]));
840: if (i == 0)
841: which++;
842: changed_prefs.dfxtype[i] = (which == 0 ? DRV_NONE : which == 1 ? DRV_35_DD : DRV_35_HD);
843: }
844: enable_disk_buttons (1);
845: }
846:
847: static void kbdlang_changed (GtkWidget *w, gpointer data)
848: {
849: int which = gtk_combo_box_get_active (GTK_COMBO_BOX (kbdlang_widget));
850: changed_prefs.keyboard_lang = which;
851: }
852:
853: static void joy_changed (void)
854: {
855: int j0t, j1t;
856: if (! gui_active)
857: return;
858:
859: j0t = find_current_toggle (joy_widget[0], 6);
860: j1t = find_current_toggle (joy_widget[1], 6);
861: changed_prefs.jport0 = (j0t == 0 || j0t == 1 ? JSEM_JOYS + j0t
862: : j0t == 2 ? JSEM_MICE
863: : JSEM_KBDLAYOUT + j0t - 3);
864: changed_prefs.jport1 = (j1t == 0 || j1t == 1 ? JSEM_JOYS + j1t
865: : j1t == 2 ? JSEM_MICE
866: : JSEM_KBDLAYOUT + j1t - 3);
867:
868: changed_prefs.input_selected_setting = GTK_TOGGLE_BUTTON (legacy_widget)->active ? 0 : 1;
869:
870: if (changed_prefs.input_selected_setting != currprefs.input_selected_setting
871: || changed_prefs.jport0 != currprefs.jport0
872: || changed_prefs.jport1 != currprefs.jport1)
873: inputdevice_config_change ();
874:
875: set_joy_state ();
876: }
877:
878: static void coll_changed (void)
879: {
880: changed_prefs.collision_level = find_current_toggle (coll_widget, 4);
881: }
882:
883: static void cslevel_changed (void)
884: {
885: int t = find_current_toggle (cslevel_widget, 4);
886: int t1 = 0;
887: if (t > 0)
888: t1 |= CSMASK_ECS_AGNUS;
889: if (t > 1)
890: t1 |= CSMASK_ECS_DENISE;
891: if (t > 2)
892: t1 |= CSMASK_AGA;
893: changed_prefs.chipset_mask = t1;
894: set_mem_state ();
895: }
896:
897: static void custom_changed (void)
898: {
899: if (ignore_gui_changes)
900: return;
901: changed_prefs.gfx_framerate = framerate_adj->value;
902: changed_prefs.immediate_blits = GTK_TOGGLE_BUTTON (bimm_widget)->active;
903: changed_prefs.gfx_afullscreen = GTK_TOGGLE_BUTTON (afscr_widget)->active;
904: changed_prefs.gfx_pfullscreen = GTK_TOGGLE_BUTTON (pfscr_widget)->active;
905: #if 0
906: changed_prefs.blits_32bit_enabled = GTK_TOGGLE_BUTTON (b32_widget)->active;
907: #endif
908: }
909:
910: static void leds_changed (void)
911: {
912: int w_leds = GTK_TOGGLE_BUTTON (gw_windowed.leds)->active;
913: int f_leds = GTK_TOGGLE_BUTTON (gw_fullscreen.leds)->active;
914: gfx_w.leds_on_screen = w_leds;
915: gfx_f.leds_on_screen = f_leds;
916: write_comm_pipe_int (&from_gui_pipe, 11, 1);
917: }
918:
919: static void aspect_changed (void)
920: {
921: int w_aspect = GTK_TOGGLE_BUTTON (gw_windowed.aspect)->active;
922: int f_aspect = GTK_TOGGLE_BUTTON (gw_fullscreen.aspect)->active;
923: int w_ldbl = gtk_combo_box_get_active (GTK_COMBO_BOX (gw_windowed.linedbl)) + 1;
924: int f_ldbl = gtk_combo_box_get_active (GTK_COMBO_BOX (gw_fullscreen.linedbl)) + 1;
925: int w_hc = gtk_combo_box_get_active (GTK_COMBO_BOX (gw_windowed.hcenter));
926: int f_hc = gtk_combo_box_get_active (GTK_COMBO_BOX (gw_fullscreen.hcenter));
927: int w_vc = gtk_combo_box_get_active (GTK_COMBO_BOX (gw_windowed.vcenter));
928: int f_vc = gtk_combo_box_get_active (GTK_COMBO_BOX (gw_fullscreen.vcenter));
929:
930: if (ignore_gui_changes)
931: return;
932:
933: uae_sem_wait (&gui_sem);
934: gfx_w.ycenter = w_vc;
935: gfx_w.xcenter = w_hc;
936: gfx_w.correct_aspect = w_aspect;
937: gfx_w.linedbl = w_ldbl;
938: gfx_f.ycenter = f_vc;
939: gfx_f.xcenter = f_hc;
940: gfx_f.correct_aspect = f_aspect;
941: gfx_f.linedbl = f_ldbl;
942:
943: adjust_gfx_prefs (&gfx_w, &gw_windowed);
944: adjust_gfx_prefs (&gfx_f, &gw_fullscreen);
945: uae_sem_post (&gui_sem);
946: write_comm_pipe_int (&from_gui_pipe, 11, 1);
947: }
948:
949: static void screenmode_changed (void)
950: {
951: int w = gtk_combo_box_get_active (GTK_COMBO_BOX (gw_windowed.modelist));
952: int f = gtk_combo_box_get_active (GTK_COMBO_BOX (gw_fullscreen.modelist));
953: int need_set_w = 0, need_set_f = 0;
954:
955: if (ignore_gui_changes)
956: return;
957:
958: uae_sem_wait (&gui_sem);
959: if (w != -1) {
960: need_set_w = (gfx_w.width != gfx_windowed_modes[w].w
961: || gfx_w.height != gfx_windowed_modes[w].h);
962: gfx_w.width = gfx_windowed_modes[w].w;
963: gfx_w.height = gfx_windowed_modes[w].h;
964: }
965: if (f != -1) {
966: need_set_f = (gfx_f.width != gfx_fullscreen_modes[f].w
967: || gfx_f.height != gfx_fullscreen_modes[f].h);
968: gfx_f.width = gfx_fullscreen_modes[f].w;
969: gfx_f.height = gfx_fullscreen_modes[f].h;
970: }
971: if (need_set_w) {
972: fixup_prefs_dimensions (&gfx_w, gfx_windowed_modes, n_windowed_modes);
973: }
974: if (need_set_f) {
975: fixup_prefs_dimensions (&gfx_f, gfx_fullscreen_modes, n_fullscreen_modes);
976: }
977: uae_sem_post (&gui_sem);
978:
979: if (!need_set_w && !need_set_f)
980: return;
981:
982: /* We may have switched to a screenmode that has centering or other
983: modifiers enabled; re-set the members of the prefs structure
984: according to the new mode. See comment before adjust_gfx_prefs.
985:
986: aspect_changed also sends the message to the main thread. */
987: aspect_changed ();
988: }
989:
990: static void cpuspeed_changed (void)
991: {
992: int which = find_current_toggle (cpuspeed_widgets, 3);
993: changed_prefs.m68k_speed = (which == 0 ? -1
994: : which == 1 ? 0
995: : cpuspeed_adj->value);
996: set_cpu_state ();
997: }
998:
999: static void cputype_changed (void)
1000: {
1001: int i, oldcl;
1002: int whichtoggle;
1003: if (! gui_active)
1004: return;
1005:
1006: whichtoggle = find_current_toggle (cpu_widget, 7);
1007: changed_prefs.address_space_24 = whichtoggle < 3;
1008: if (whichtoggle >= 3)
1009: whichtoggle--;
1010:
1011: if (whichtoggle == 5)
1012: whichtoggle = 6;
1013: changed_prefs.cpu_model = 68000 + 10 * whichtoggle;
1014:
1015: if (changed_prefs.cpu_model == 68060) {
1016: changed_prefs.fpu_model = 68060;
1017: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (fpu_widget[4]), 1);
1018: } else if (changed_prefs.cpu_model == 68040) {
1019: changed_prefs.fpu_model = 68040;
1020: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (fpu_widget[3]), 1);
1021: } else if ((changed_prefs.cpu_model != 68020 && changed_prefs.cpu_model != 68030)
1022: || changed_prefs.fpu_model == 68040
1023: || changed_prefs.fpu_model == 68060) {
1024: changed_prefs.fpu_model = 0;
1025: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (fpu_widget[0]), 1);
1026: } else {
1027: whichtoggle = find_current_toggle (fpu_widget, 5);
1028: changed_prefs.fpu_model = (whichtoggle == 0 ? 0
1029: : whichtoggle == 1 ? 68881
1030: : whichtoggle == 2 ? 68882
1031: : whichtoggle == 3 ? 68040
1032: : 68060);
1033: }
1034:
1035: set_cpu_state ();
1036: /* May influence bogomem size and Z3/GFXcard memory. */
1037: set_mem_state();
1038: }
1039:
1040: static void chipsize_changed (void)
1041: {
1042: int t = find_current_toggle (chipsize_widget, 5);
1043: changed_prefs.chipmem_size = 0x80000 << t;
1044: for (t = 0; t < 5; t++)
1045: gtk_widget_set_sensitive (fastsize_widget[t], changed_prefs.chipmem_size <= 0x200000);
1046: if (changed_prefs.chipmem_size > 0x200000) {
1047: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (fastsize_widget[0]), 1);
1048: changed_prefs.fastmem_size = 0;
1049: }
1050: }
1051:
1052: static void bogosize_changed (void)
1053: {
1054: int t = find_current_toggle (bogosize_widget, 4);
1055: changed_prefs.bogomem_size = (0x40000 << t) & ~0x40000;
1056: }
1057:
1058: static void fastsize_changed (void)
1059: {
1060: int t = find_current_toggle (fastsize_widget, 5);
1061: changed_prefs.fastmem_size = (0x80000 << t) & ~0x80000;
1062: }
1063:
1064: static void z3size_changed (void)
1065: {
1066: int t = find_current_toggle (z3size_widget, 10);
1067: changed_prefs.z3fastmem_size = (0x80000 << t) & ~0x80000;
1068: }
1069:
1070: static void p96size_changed (void)
1071: {
1072: int t = find_current_toggle (p96size_widget, 7);
1073: changed_prefs.gfxmem_size = (0x80000 << t) & ~0x80000;
1074: }
1075:
1076: static void rom_combo_changed (void)
1077: {
1078: int t = gtk_combo_box_get_active (GTK_COMBO_BOX (romlist_widget));
1079: gtk_widget_set_sensitive (romsel_button, t == 0);
1080: gtk_widget_set_sensitive (rom_text_widget, t == 0);
1081:
1082: rom_req = 0;
1083:
1084: if (t == 0) {
1085: changed_prefs.rom_crc32 = 0;
1086: } else {
1087: struct romlist *rl = romlist_from_idx (t - 1, ROMTYPE_KICK, 1);
1088: if (rl) {
1089: changed_prefs.rom_crc32 = rl->rd->crc32;
1090: rom_req = rl->rd->cpu;
1091: }
1092: }
1093: rom_requirements_change ();
1094: }
1095:
1096: static void sound_changed (void)
1097: {
1098: int n;
1099:
1100: changed_prefs.produce_sound = find_current_toggle (sound_widget, 4);
1101: n = find_current_toggle (sound_ch_widget, 3);
1102: changed_prefs.sound_stereo = n == 0 ? SND_MONO : SND_STEREO;
1103: changed_prefs.sound_interpol = find_current_toggle (sound_interpol_widget, 5);
1104: n = find_current_toggle (sound_filter_widget, 5);
1105: if (n == 0)
1106: changed_prefs.sound_filter = FILTER_SOUND_OFF;
1107: else {
1108: changed_prefs.sound_filter = (n & 1) ? FILTER_SOUND_EMUL : FILTER_SOUND_ON;
1109: changed_prefs.sound_filter_type = (n > 2 ? FILTER_SOUND_TYPE_A1200 : FILTER_SOUND_TYPE_A500);
1110: }
1111: changed_prefs.sound_mixed_stereo_delay = stereo_delay_adj->value;
1112: changed_prefs.sound_stereo_separation = stereo_sep_adj->value;
1113:
1114: gtk_widget_set_sensitive (stereo_sep_scale, changed_prefs.sound_stereo == SND_STEREO);
1115: gtk_widget_set_sensitive (stereo_delay_scale, changed_prefs.sound_stereo == SND_STEREO);
1116: }
1117:
1118: static void bootrom_changed (void)
1119: {
1120: changed_prefs.bootrom = GTK_TOGGLE_BUTTON (bootrom_widget)->active ? 1 : 0;
1121: set_mem_state ();
1122: }
1123:
1124: static void ntsc_changed (void)
1125: {
1126: changed_prefs.ntscmode = find_current_toggle (ntsc_widget, 2);
1127: }
1128:
1129: static void mbtype_changed (void)
1130: {
1131: int needs_aga, allows_ocs, allows_ecs;
1132: int n, cstype;
1133:
1134: if (ignore_gui_changes)
1135: return;
1136:
1137: n = gtk_combo_box_get_active (GTK_COMBO_BOX (mbtype_widget));
1138: cstype = (n == 0 ? CP_GENERIC
1139: : n == 1 ? CP_A1000
1140: : n == 2 ? CP_A500
1141: : n == 3 ? CP_A600
1142: : n == 4 ? CP_A1200
1143: : n == 5 ? CP_A3000
1144: : CP_A4000);
1145: if (cstype != CP_GENERIC)
1146: built_in_chipset_prefs (&changed_prefs, cstype);
1147:
1148: needs_aga = cstype == CP_A1200 || cstype == CP_A4000 || cstype == CP_A4000T || cstype == CP_CD32;
1149: allows_ocs = cstype == CP_A1000 || cstype == CP_A500 || cstype == CP_A2000;
1150: allows_ecs = !needs_aga && cstype != CP_A1000;
1151:
1152: gtk_widget_set_sensitive (cslevel_widget[0], cstype == CP_GENERIC || allows_ocs);
1153: gtk_widget_set_sensitive (cslevel_widget[1], cstype == CP_GENERIC || allows_ecs);
1154: gtk_widget_set_sensitive (cslevel_widget[2], cstype == CP_GENERIC || allows_ecs);
1155: gtk_widget_set_sensitive (cslevel_widget[3], cstype == CP_GENERIC || needs_aga);
1156:
1157: if (cstype != CP_GENERIC) {
1158: if (needs_aga)
1159: changed_prefs.chipset_mask = CSMASK_AGA | CSMASK_FULL_ECS;
1160: else if (! allows_ecs)
1161: changed_prefs.chipset_mask = 0;
1162: }
1163: set_chipset_state ();
1164: }
1165:
1166: static void did_reset (void)
1167: {
1168: if (quit_gui)
1169: return;
1170:
1171: write_comm_pipe_int (&from_gui_pipe, 2, 1);
1172: }
1173:
1174: static void did_debug (void)
1175: {
1176: if (quit_gui)
1177: return;
1178:
1179: write_comm_pipe_int (&from_gui_pipe, 3, 1);
1180: }
1181:
1182: static void did_quit (void)
1183: {
1184: if (quit_gui)
1185: return;
1186:
1187: write_comm_pipe_int (&from_gui_pipe, 4, 1);
1188: }
1189:
1190: static void did_eject (GtkWidget *w, gpointer data_p)
1191: {
1192: int data = GPOINTER_TO_INT (data_p);
1193: if (quit_gui)
1194: return;
1195:
1196: write_comm_pipe_int (&from_gui_pipe, 0, 0);
1197: write_comm_pipe_int (&from_gui_pipe, data, 1);
1198: gtk_label_set_text (GTK_LABEL (disk_text_widget[data]), "");
1199: }
1200:
1201: static void pause_uae (void)
1202: {
1203: if (quit_gui)
1204: return;
1205:
1206: write_comm_pipe_int (&from_gui_pipe, GTK_TOGGLE_BUTTON (pause_uae_widget)->active ? 5 : 6, 1);
1207: if (! GTK_TOGGLE_BUTTON (pause_uae_widget)->active)
1208: gtk_widget_hide (lab_info);
1209: }
1210:
1211: static void end_pause_uae (void)
1212: {
1213: write_comm_pipe_int (&to_gui_pipe, GUICMD_UNPAUSE, 1);
1214: }
1215:
1216: static char fsbuffer[100];
1217:
1218: static GtkWidget *make_file_selector (const char *title,
1219: GtkFileChooserAction action)
1220: {
1221: GtkWidget *p = gtk_file_chooser_dialog_new (title, GTK_WINDOW (gui_window), action,
1222: GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1223: action == GTK_FILE_CHOOSER_ACTION_SAVE ? GTK_STOCK_SAVE : GTK_STOCK_OPEN,
1224: GTK_RESPONSE_ACCEPT,
1225: NULL);
1226:
1227: return p;
1228: }
1229:
1230: static void filesel_set_path (GtkWidget *p, const char *path)
1231: {
1232: size_t len = strlen (path);
1233: if (len > 0 && ! access (path, R_OK)) {
1234: char *tmp = xmalloc (len + 2);
1235: strcpy (tmp, path);
1236: strcat (tmp, "/");
1237: gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (p), tmp);
1238: }
1239: }
1240:
1241: static void make_disk_selector (void)
1242: {
1243: if (disk_selector)
1244: return;
1245: disk_selector = make_file_selector ("Select a disk image file to mount",
1246: GTK_FILE_CHOOSER_ACTION_OPEN);
1247: filesel_set_path (disk_selector, currprefs.path_floppy);
1248: }
1249:
1250: static void did_insert (GtkWidget *w, gpointer data)
1251: {
1252: int n = GPOINTER_TO_INT (data);
1253:
1254: make_disk_selector ();
1255: sprintf (fsbuffer, "Select a disk image file for DF%d", n);
1256: gtk_window_set_title (GTK_WINDOW (disk_selector), fsbuffer);
1257:
1258: if (gtk_dialog_run (GTK_DIALOG (disk_selector)) == GTK_RESPONSE_ACCEPT) {
1259: char *filename;
1260:
1261: filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (disk_selector));
1262:
1263: uae_sem_wait (&gui_sem);
1264: if (new_disk_string[n] != 0)
1265: free (new_disk_string[n]);
1266: new_disk_string[n] = strdup (filename);
1267: uae_sem_post (&gui_sem);
1268: write_comm_pipe_int (&from_gui_pipe, 1, 0);
1269: write_comm_pipe_int (&from_gui_pipe, n, 1);
1270: gtk_label_set_text (GTK_LABEL (disk_text_widget[n]), filename);
1271:
1272: g_free (filename);
1273: }
1274: gtk_widget_hide (disk_selector);
1275: }
1276:
1277: static gint driveled_event (GtkWidget *thing, GdkEvent *event)
1278: {
1279: int lednr = nr_for_led (thing);
1280:
1281: switch (event->type) {
1282: case GDK_MAP:
1283: draw_led (lednr);
1284: break;
1285: case GDK_EXPOSE:
1286: draw_led (lednr);
1287: break;
1288: default:
1289: break;
1290: }
1291:
1292: return 0;
1293: }
1294:
1295: static GtkWidget *snap_selector;
1296:
1297: static void did_loadstate (void)
1298: {
1299: GtkWidget *dialog;
1300:
1301: dialog = make_file_selector ("Select a state file to restore", GTK_FILE_CHOOSER_ACTION_OPEN);
1302:
1303: if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) {
1304: char *filename;
1305:
1306: filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
1307:
1308: uae_sem_wait (&gui_sem);
1309: gui_snapname = strdup (filename);
1310: uae_sem_post (&gui_sem);
1311: write_comm_pipe_int (&from_gui_pipe, 7, 0);
1312: write_comm_pipe_int (&from_gui_pipe, STATE_DORESTORE, 1);
1313:
1314: g_free (filename);
1315: }
1316:
1317: gtk_widget_destroy (dialog);
1318: }
1319:
1320: static void did_savestate (void)
1321: {
1322: GtkWidget *dialog;
1323:
1324: dialog = make_file_selector ("Select a filename for the state file",
1325: GTK_FILE_CHOOSER_ACTION_SAVE);
1326:
1327: if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) {
1328: char *filename;
1329:
1330: filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
1331:
1332: uae_sem_wait (&gui_sem);
1333: gui_snapname = strdup (filename);
1334: uae_sem_post (&gui_sem);
1335: write_comm_pipe_int (&from_gui_pipe, 7, 0);
1336: write_comm_pipe_int (&from_gui_pipe, STATE_DOSAVE, 1);
1337:
1338: g_free (filename);
1339: }
1340:
1341: gtk_widget_destroy (dialog);
1342: }
1343:
1344: static void did_rompathchange (GtkWidget *w, gpointer data)
1345: {
1346: GtkWidget *pathsel;
1347: pathsel = make_file_selector ("Select a ROM path",
1348: GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
1349: filesel_set_path (pathsel, currprefs.path_rom);
1350: if (gtk_dialog_run (GTK_DIALOG (pathsel)) == GTK_RESPONSE_ACCEPT) {
1351: char *filename;
1352:
1353: filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (pathsel));
1354:
1355: uae_sem_wait (&gui_sem);
1356: gui_romname = strdup (filename);
1357: uae_sem_post (&gui_sem);
1358: write_comm_pipe_int (&from_gui_pipe, 10, 0);
1359: gtk_label_set_text (GTK_LABEL (rom_path_widget), gui_romname);
1360:
1361: g_free (filename);
1362: }
1363:
1364: gtk_widget_destroy (pathsel);
1365: }
1366:
1367: static void did_romchange (GtkWidget *w, gpointer data)
1368: {
1369: GtkWidget *romsel;
1370:
1371: romsel = make_file_selector ("Select a ROM file",
1372: GTK_FILE_CHOOSER_ACTION_OPEN);
1373: filesel_set_path (romsel, currprefs.path_rom);
1374: if (gtk_dialog_run (GTK_DIALOG (romsel)) == GTK_RESPONSE_ACCEPT) {
1375: char *filename;
1376:
1377: filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (romsel));
1378: rom_req = 0;
1379: rom_requirements_change ();
1380:
1381: uae_sem_wait (&gui_sem);
1382: gui_romname = strdup (filename);
1383: uae_sem_post (&gui_sem);
1384: write_comm_pipe_int (&from_gui_pipe, 8, 0);
1385: gtk_label_set_text (GTK_LABEL (rom_text_widget), gui_romname);
1386:
1387: g_free (filename);
1388: }
1389:
1390: gtk_widget_destroy (romsel);
1391: }
1392:
1393: static void did_keychange (GtkWidget *w, gpointer data)
1394: {
1395: GtkWidget *keysel;
1396:
1397: keysel = make_file_selector ("Select a Kickstart key file",
1398: GTK_FILE_CHOOSER_ACTION_OPEN);
1399: filesel_set_path (keysel, currprefs.path_rom);
1400:
1401: if (gtk_dialog_run (GTK_DIALOG (keysel)) == GTK_RESPONSE_ACCEPT) {
1402: char *filename;
1403:
1404: filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (keysel));
1405: uae_sem_wait (&gui_sem);
1406: gui_keyname = strdup (filename);
1407: uae_sem_post (&gui_sem);
1408: write_comm_pipe_int (&from_gui_pipe, 9, 0);
1409: gtk_label_set_text (GTK_LABEL (key_text_widget), gui_keyname);
1410:
1411: g_free (filename);
1412: }
1413:
1414: gtk_widget_destroy (keysel);
1415: }
1416:
1417: static void add_empty_vbox (GtkWidget *tobox)
1418: {
1419: GtkWidget *thing = gtk_vbox_new (FALSE, 0);
1420: gtk_widget_show (thing);
1421: gtk_box_pack_start (GTK_BOX (tobox), thing, TRUE, TRUE, 0);
1422: }
1423:
1424: static void add_centered_to_vbox (GtkWidget *vbox, GtkWidget *w, int vexpand)
1425: {
1426: GtkWidget *hbox = gtk_hbox_new (TRUE, 0);
1427: gtk_widget_show (hbox);
1428: gtk_box_pack_start (GTK_BOX (hbox), w, TRUE, FALSE, 0);
1429: gtk_box_pack_start (GTK_BOX (vbox), hbox, vexpand, vexpand, 0);
1430: }
1431:
1432: static GtkWidget *make_labelled_widget (const char *str, GtkWidget *thing, int expand)
1433: {
1434: GtkWidget *label = gtk_label_new (str);
1435: GtkWidget *hbox2 = gtk_hbox_new (FALSE, 4);
1436:
1437: gtk_widget_show (label);
1438: gtk_widget_show (thing);
1439:
1440: gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
1441: gtk_box_pack_start (GTK_BOX (hbox2), thing, expand, TRUE, 0);
1442:
1443: return hbox2;
1444: }
1445:
1446: static GtkWidget *add_labelled_widget_centered (const char *str, GtkWidget *thing, GtkWidget *vbox)
1447: {
1448: GtkWidget *w = make_labelled_widget (str, thing, FALSE);
1449: gtk_widget_show (w);
1450: add_centered_to_vbox (vbox, w, 0);
1451: return w;
1452: }
1453:
1454: static int make_radio_group (const char **labels, GtkWidget *tobox,
1455: GtkWidget **saveptr, gint t1, gint t2,
1456: void (*sigfunc) (void), int count, GSList *group)
1457: {
1458: int t = 0;
1459:
1460: while (*labels && (count == -1 || count-- > 0)) {
1461: GtkWidget *thing = gtk_radio_button_new_with_label (group, *labels++);
1462: group = gtk_radio_button_group (GTK_RADIO_BUTTON (thing));
1463:
1464: *saveptr++ = thing;
1465: gtk_widget_show (thing);
1466: gtk_box_pack_start (GTK_BOX (tobox), thing, t1, t2, 0);
1467: gtk_signal_connect (GTK_OBJECT (thing), "clicked", (GtkSignalFunc) sigfunc, NULL);
1468: t++;
1469: }
1470: return t;
1471: }
1472:
1473: static GtkWidget *make_radio_group_box (const char *title, const char **labels,
1474: GtkWidget **saveptr, int horiz,
1475: void (*sigfunc) (void), GtkWidget **boxp)
1476: {
1477: GtkWidget *frame, *newbox;
1478:
1479: frame = gtk_frame_new (title);
1480: newbox = (horiz ? gtk_hbox_new : gtk_vbox_new) (FALSE, 4);
1481: gtk_widget_show (newbox);
1482: gtk_container_set_border_width (GTK_CONTAINER (newbox), 4);
1483: gtk_container_add (GTK_CONTAINER (frame), newbox);
1484: make_radio_group (labels, newbox, saveptr, horiz, !horiz, sigfunc, -1, NULL);
1485: if (boxp)
1486: *boxp = newbox;
1487: return frame;
1488: }
1489:
1490: static GtkWidget *make_radio_group_box_1 (const char *title, const char **labels,
1491: GtkWidget **saveptr, int horiz,
1492: void (*sigfunc) (void), int elts_per_column)
1493: {
1494: GtkWidget *frame, *newbox;
1495: GtkWidget *column;
1496: GSList *group = 0;
1497:
1498: frame = gtk_frame_new (title);
1499: column = (horiz ? gtk_vbox_new : gtk_hbox_new) (FALSE, 4);
1500: gtk_container_add (GTK_CONTAINER (frame), column);
1501: gtk_widget_show (column);
1502:
1503: while (*labels) {
1504: int count;
1505: newbox = (horiz ? gtk_hbox_new : gtk_vbox_new) (FALSE, 4);
1506: gtk_widget_show (newbox);
1507: gtk_container_set_border_width (GTK_CONTAINER (newbox), 4);
1508: gtk_container_add (GTK_CONTAINER (column), newbox);
1509: count = make_radio_group (labels, newbox, saveptr, horiz, !horiz, sigfunc, elts_per_column, group);
1510: labels += count;
1511: saveptr += count;
1512: group = gtk_radio_button_group (GTK_RADIO_BUTTON (saveptr[-1]));
1513: }
1514: return frame;
1515: }
1516:
1517: static GtkWidget *make_led (int nr)
1518: {
1519: GtkWidget *subframe, *the_led, *thing;
1520: GdkColormap *colormap;
1521:
1522: the_led = gtk_vbox_new (FALSE, 0);
1523: gtk_widget_show (the_led);
1524:
1525: thing = gtk_preview_new (GTK_PREVIEW_COLOR);
1526: gtk_box_pack_start (GTK_BOX (the_led), thing, TRUE, TRUE, 0);
1527: gtk_widget_show (thing);
1528:
1529: subframe = gtk_frame_new (NULL);
1530: gtk_box_pack_start (GTK_BOX (the_led), subframe, TRUE, TRUE, 0);
1531: gtk_widget_show (subframe);
1532:
1533: thing = gtk_drawing_area_new ();
1534: gtk_drawing_area_size (GTK_DRAWING_AREA (thing), 20, 5);
1535: gtk_widget_set_events (thing, GDK_EXPOSURE_MASK);
1536: gtk_container_add (GTK_CONTAINER (subframe), thing);
1537: colormap = gtk_widget_get_colormap (thing);
1538: led_on[nr].red = nr == 0 ? 0xEEEE : 0xCCCC;
1539: led_on[nr].green = nr == 0 ? 0: 0xFFFF;
1540: led_on[nr].blue = 0;
1541: led_on[nr].pixel = 0;
1542: led_off[nr].red = 0;
1543: led_off[nr].green = 0;
1544: led_off[nr].blue = 0;
1545: led_off[nr].pixel = 0;
1546: gdk_color_alloc (colormap, led_on + nr);
1547: gdk_color_alloc (colormap, led_off + nr);
1548: led_widgets[nr] = thing;
1549: gtk_signal_connect (GTK_OBJECT (thing), "event",
1550: (GtkSignalFunc) driveled_event, (gpointer) thing);
1551: gtk_widget_show (thing);
1552:
1553: thing = gtk_preview_new (GTK_PREVIEW_COLOR);
1554: gtk_box_pack_start (GTK_BOX (the_led), thing, TRUE, TRUE, 0);
1555: gtk_widget_show (thing);
1556:
1557: return the_led;
1558: }
1559:
1560: static GtkWidget *make_file_container (const char *title, GtkWidget *vbox, int vertical)
1561: {
1562: GtkWidget *thing = gtk_frame_new (title);
1563: GtkWidget *file_vbox = vertical ? gtk_vbox_new (FALSE, 4) : gtk_hbox_new (FALSE, 4);
1564:
1565: gtk_container_set_border_width (GTK_CONTAINER (file_vbox), 4);
1566: gtk_container_add (GTK_CONTAINER (thing), file_vbox);
1567: gtk_box_pack_start (GTK_BOX (vbox), thing, FALSE, TRUE, 0);
1568: gtk_widget_show (file_vbox);
1569: gtk_widget_show (thing);
1570:
1571: return file_vbox;
1572: }
1573:
1574: static GtkWidget *make_file_widget (GtkWidget *buttonbox)
1575: {
1576: GtkWidget *thing, *subthing;
1577: GtkWidget *subframe = gtk_frame_new (NULL);
1578:
1579: gtk_frame_set_shadow_type (GTK_FRAME (subframe), GTK_SHADOW_ETCHED_OUT);
1580: gtk_box_pack_start (GTK_BOX (buttonbox), subframe, TRUE, TRUE, 0);
1581: gtk_widget_show (subframe);
1582: subthing = gtk_vbox_new (FALSE, 0);
1583: gtk_widget_show (subthing);
1584: gtk_container_add (GTK_CONTAINER (subframe), subthing);
1585: thing = gtk_label_new ("");
1586: gtk_widget_show (thing);
1587: gtk_box_pack_start (GTK_BOX (subthing), thing, TRUE, TRUE, 0);
1588:
1589: return thing;
1590: }
1591:
1592: static void make_floppy_disks (GtkWidget *vbox)
1593: {
1594: GtkWidget *thing, *subthing, *subframe, *buttonbox, *file_vbox;
1595: char buf[5];
1596: int i;
1597:
1598: add_empty_vbox (vbox);
1599:
1600: for (i = 0; i < 4; i++) {
1601: /* Frame with an hbox and the "DFx:" title */
1602: sprintf (buf, "DF%d:", i);
1603: file_vbox = make_file_container (buf, vbox, 1);
1604:
1605: buttonbox = gtk_hbox_new (FALSE, 4);
1606: gtk_box_pack_start (GTK_BOX (file_vbox), buttonbox, FALSE, TRUE, 0);
1607: gtk_widget_show (buttonbox);
1608:
1609: /* LED */
1610: subthing = make_led (i + 1);
1611: gtk_box_pack_start (GTK_BOX (buttonbox), subthing, FALSE, TRUE, 0);
1612:
1613: /* Current file display */
1614: disk_text_widget[i] = make_file_widget (buttonbox);
1615:
1616: /* Now, the buttons. */
1617: thing = gtk_button_new_with_label ("Eject");
1618: gtk_box_pack_start (GTK_BOX (buttonbox), thing, FALSE, TRUE, 0);
1619: gtk_widget_show (thing);
1620: disk_eject_widget[i] = thing;
1621: gtk_signal_connect (GTK_OBJECT (thing), "clicked", (GtkSignalFunc) did_eject,
1622: GINT_TO_POINTER (i));
1623:
1624: thing = gtk_button_new_with_label ("Insert");
1625: gtk_box_pack_start (GTK_BOX (buttonbox), thing, FALSE, TRUE, 0);
1626: gtk_widget_show (thing);
1627: disk_insert_widget[i] = thing;
1628: gtk_signal_connect (GTK_OBJECT (thing), "clicked", (GtkSignalFunc) did_insert,
1629: GINT_TO_POINTER (i));
1630:
1631: buttonbox = gtk_hbox_new (FALSE, 4);
1632: gtk_box_pack_start (GTK_BOX (file_vbox), buttonbox, FALSE, FALSE, 0);
1633: gtk_widget_show (buttonbox);
1634:
1635: if (i == 0)
1636: thing = make_chooser (2, "3.5 DD", "3.5 HD");
1637: else
1638: thing = make_chooser (3, "Disabled", "3.5 DD", "3.5 HD");
1639: gtk_signal_connect (GTK_OBJECT (thing), "changed", (GtkSignalFunc) dftype_changed,
1640: GINT_TO_POINTER (i));
1641: dftype_widget[i] = thing;
1642:
1643: thing = make_labelled_widget ("Type:", thing, 0);
1644: gtk_box_pack_end (GTK_BOX (buttonbox), thing, FALSE, FALSE, 0);
1645: gtk_widget_show (thing);
1646: }
1647:
1648: add_empty_vbox (vbox);
1649: }
1650:
1651: static GtkWidget *make_cpu_speed_sel (void)
1652: {
1653: int t;
1654: static const char *labels[] = {
1655: "Optimize for host CPU speed", "Approximate 68000/7MHz speed", "Adjustable",
1656: NULL
1657: };
1658: GtkWidget *frame, *newbox;
1659:
1660: frame = gtk_frame_new ("CPU speed");
1661: newbox = gtk_vbox_new (FALSE, 4);
1662: gtk_widget_show (newbox);
1663: gtk_container_set_border_width (GTK_CONTAINER (newbox), 4);
1664: gtk_container_add (GTK_CONTAINER (frame), newbox);
1665: make_radio_group (labels, newbox, cpuspeed_widgets, 0, 1, cpuspeed_changed, -1, NULL);
1666:
1667: t = currprefs.m68k_speed > 0 ? currprefs.m68k_speed : 4 * CYCLE_UNIT;
1668: cpuspeed_adj = GTK_ADJUSTMENT (gtk_adjustment_new (t, 1.0, 5120.0, 1.0, 1.0, 1.0));
1669: gtk_signal_connect (GTK_OBJECT (cpuspeed_adj), "value_changed",
1670: GTK_SIGNAL_FUNC (cpuspeed_changed), NULL);
1671:
1672: cpuspeed_scale = gtk_hscale_new (cpuspeed_adj);
1673: gtk_range_set_update_policy (GTK_RANGE (cpuspeed_scale), GTK_UPDATE_DELAYED);
1674: gtk_scale_set_digits (GTK_SCALE (cpuspeed_scale), 0);
1675: gtk_scale_set_value_pos (GTK_SCALE (cpuspeed_scale), GTK_POS_RIGHT);
1676: cpuspeed_scale = make_labelled_widget ("Cycles/insn:", cpuspeed_scale, TRUE);
1677: gtk_widget_show (cpuspeed_scale);
1678: gtk_box_pack_start (GTK_BOX (newbox), cpuspeed_scale, FALSE, FALSE, 0);
1679:
1680: return frame;
1681: }
1682:
1683: static void make_cpu_widgets (GtkWidget *vbox)
1684: {
1685: int i;
1686: GtkWidget *newbox, *hbox, *frame;
1687: GtkWidget *thing, *label;
1688: static const char *cpulabels[] = {
1689: "68000", "68010", "68EC020", "68020", "68030", "68040", "68060",
1690: NULL
1691: };
1692: static const char *fpulabels[] = {
1693: "None", "68881", "68882", "68040", "68060",
1694: NULL
1695: };
1696:
1697: add_empty_vbox (vbox);
1698:
1699: hbox = gtk_hbox_new (FALSE, 0);
1700: add_empty_vbox (hbox);
1701:
1702: newbox = make_radio_group_box ("CPU type", cpulabels, cpu_widget, 0, cputype_changed, NULL);
1703: gtk_widget_show (newbox);
1704: gtk_box_pack_start (GTK_BOX (hbox), newbox, FALSE, FALSE, 0);
1705:
1706: newbox = make_radio_group_box ("FPU type", fpulabels, fpu_widget, 0, cputype_changed, NULL);
1707: gtk_widget_show (newbox);
1708: gtk_box_pack_start (GTK_BOX (hbox), newbox, FALSE, FALSE, 0);
1709:
1710: newbox = make_cpu_speed_sel ();
1711: gtk_widget_show (newbox);
1712: gtk_box_pack_start (GTK_BOX (hbox), newbox, FALSE, FALSE, 0);
1713:
1714: add_empty_vbox (hbox);
1715: gtk_widget_show (hbox);
1716: gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
1717:
1718: req68ec020 = gtk_label_new ("The selected ROM requires at least a 68ec020.");
1719: add_centered_to_vbox (vbox, req68ec020, 0);
1720:
1721: req68020 = gtk_label_new ("The selected ROM requires at least a 68020.");
1722: add_centered_to_vbox (vbox, req68020, 0);
1723:
1724: req68030 = gtk_label_new ("The selected ROM requires at least a 68030.");
1725: add_centered_to_vbox (vbox, req68030, 0);
1726:
1727: add_empty_vbox (vbox);
1728:
1729: label = gtk_label_new ("CPU type settings take effect after the next reset.");
1730: gtk_widget_show (label);
1731: add_centered_to_vbox (vbox, label, 0);
1732: }
1733:
1734: static GtkWidget *make_screenmode_box (const char *title, struct scrmode_widgets *mw,
1735: struct uae_rect *modes, int n_modes)
1736: {
1737: GtkWidget *vbox;
1738: int i;
1739:
1740: mw->frame = gtk_frame_new (title);
1741: gtk_widget_show (mw->frame);
1742:
1743: vbox = gtk_vbox_new (FALSE, 10);
1744: gtk_widget_show (vbox);
1745: gtk_container_add (GTK_CONTAINER (mw->frame), vbox);
1746: gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
1747:
1748: mw->modelist = gtk_combo_box_new_text ();
1749: gtk_widget_show (mw->modelist);
1750: gtk_box_pack_start (GTK_BOX (vbox), mw->modelist, FALSE, TRUE, 0);
1751:
1752: for (i = 0; i < n_modes; i++) {
1753: char t[200];
1754: sprintf (t, "%dx%d", modes[i].w, modes[i].h);
1755: gtk_combo_box_append_text (GTK_COMBO_BOX (mw->modelist), t);
1756: }
1757: if (n_modes == 0)
1758: gtk_widget_set_sensitive (mw->frame, FALSE);
1759:
1760: mw->hcenter = make_chooser (3, "Off", "Simple", "Smart");
1761: mw->hc_label = make_labelled_widget ("Horizontal bounds detect:", mw->hcenter, TRUE);
1762: gtk_widget_show (mw->hc_label);
1763: gtk_box_pack_start (GTK_BOX (vbox), mw->hc_label, FALSE, TRUE, 0);
1764:
1765: mw->vcenter = make_chooser (3, "Off", "Simple", "Smart");
1766: mw->vc_label = make_labelled_widget ("Vertical bounds detect:", mw->vcenter, TRUE);
1767: gtk_widget_show (mw->vc_label);
1768: gtk_box_pack_start (GTK_BOX (vbox), mw->vc_label, FALSE, TRUE, 0);
1769:
1770: mw->linedbl = make_chooser (2, "Double", "Scanlines");
1771: mw->ld_label = make_labelled_widget ("Line doubling:", mw->linedbl, TRUE);
1772: gtk_widget_show (mw->ld_label);
1773: gtk_box_pack_start (GTK_BOX (vbox), mw->ld_label, FALSE, TRUE, 0);
1774:
1775: mw->aspect = gtk_check_button_new_with_label ("Correct aspect ratio");
1776: gtk_widget_show (mw->aspect);
1777: gtk_box_pack_start (GTK_BOX (vbox), mw->aspect, FALSE, TRUE, 0);
1778:
1779: mw->leds = gtk_check_button_new_with_label ("Show LEDs on screen");
1780: gtk_widget_show (mw->leds);
1781: gtk_box_pack_start (GTK_BOX (vbox), mw->leds, FALSE, TRUE, 0);
1782:
1783: gtk_signal_connect (GTK_OBJECT (mw->leds), "clicked",
1784: (GtkSignalFunc) leds_changed, NULL);
1785: gtk_signal_connect (GTK_OBJECT (mw->aspect), "clicked",
1786: (GtkSignalFunc) aspect_changed, NULL);
1787: gtk_signal_connect (GTK_OBJECT (mw->linedbl), "changed",
1788: (GtkSignalFunc) aspect_changed, NULL);
1789: gtk_signal_connect (GTK_OBJECT (mw->hcenter), "changed",
1790: (GtkSignalFunc) aspect_changed, NULL);
1791: gtk_signal_connect (GTK_OBJECT (mw->vcenter), "changed",
1792: (GtkSignalFunc) aspect_changed, NULL);
1793: gtk_signal_connect (GTK_OBJECT (mw->modelist), "changed",
1794: (GtkSignalFunc) screenmode_changed, NULL);
1795:
1796: return mw->frame;
1797: }
1798:
1799: static void make_gfx_widgets (GtkWidget *vbox)
1800: {
1801: GtkWidget *thing, *frame, *newbox, *hbox;
1802:
1803: add_empty_vbox (vbox);
1804:
1805: hbox = gtk_hbox_new (FALSE, 10);
1806: gtk_widget_show (hbox);
1807: add_centered_to_vbox (vbox, hbox, 0);
1808:
1809: thing = make_screenmode_box ("Fullscreen mode", &gw_fullscreen, gfx_fullscreen_modes, n_fullscreen_modes);
1810: gtk_box_pack_start (GTK_BOX (hbox), thing, FALSE, FALSE, 0);
1811: thing = make_screenmode_box ("Windowed mode", &gw_windowed, gfx_windowed_modes, n_windowed_modes);
1812: gtk_box_pack_start (GTK_BOX (hbox), thing, FALSE, FALSE, 0);
1813:
1814: hbox = gtk_hbox_new (FALSE, 10);
1815: gtk_widget_show (hbox);
1816: add_centered_to_vbox (vbox, hbox, 0);
1817:
1818: frame = gtk_frame_new ("Miscellaneous");
1819: gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
1820:
1821: gtk_widget_show (frame);
1822: newbox = gtk_vbox_new (FALSE, 4);
1823: gtk_widget_show (newbox);
1824: gtk_container_set_border_width (GTK_CONTAINER (newbox), 4);
1825: gtk_container_add (GTK_CONTAINER (frame), newbox);
1826:
1827: framerate_adj = GTK_ADJUSTMENT (gtk_adjustment_new (currprefs.gfx_framerate, 1, 21, 1, 1, 1));
1828: gtk_signal_connect (GTK_OBJECT (framerate_adj), "value_changed",
1829: GTK_SIGNAL_FUNC (custom_changed), NULL);
1830:
1831: thing = gtk_hscale_new (framerate_adj);
1832: gtk_range_set_update_policy (GTK_RANGE (thing), GTK_UPDATE_DELAYED);
1833: gtk_scale_set_digits (GTK_SCALE (thing), 0);
1834: gtk_scale_set_value_pos (GTK_SCALE (thing), GTK_POS_RIGHT);
1835: thing = make_labelled_widget ("Framerate:", thing, TRUE);
1836: gtk_widget_show (thing);
1837: gtk_box_pack_start (GTK_BOX (newbox), thing, FALSE, FALSE, 0);
1838:
1839: b32_widget = gtk_check_button_new_with_label ("32 bit blitter");
1840: add_centered_to_vbox (newbox, b32_widget, 0);
1841: #if 0
1842: gtk_widget_show (b32_widget);
1843: #endif
1844: bimm_widget = gtk_check_button_new_with_label ("Immediate blits");
1845: gtk_box_pack_start (GTK_BOX (newbox), bimm_widget, FALSE, FALSE, 0);
1846: gtk_widget_show (bimm_widget);
1847:
1848: afscr_widget = gtk_check_button_new_with_label ("Amiga modes fullscreen");
1849: gtk_box_pack_start (GTK_BOX (newbox), afscr_widget, FALSE, FALSE, 0);
1850: gtk_widget_show (afscr_widget);
1851: pfscr_widget = gtk_check_button_new_with_label ("Picasso modes fullscreen");
1852: gtk_box_pack_start (GTK_BOX (newbox), pfscr_widget, FALSE, FALSE, 0);
1853: gtk_widget_show (pfscr_widget);
1854: add_empty_vbox (vbox);
1855:
1856: gtk_signal_connect (GTK_OBJECT (bimm_widget), "clicked",
1857: (GtkSignalFunc) custom_changed, NULL);
1858: gtk_signal_connect (GTK_OBJECT (afscr_widget), "clicked",
1859: (GtkSignalFunc) custom_changed, NULL);
1860: gtk_signal_connect (GTK_OBJECT (pfscr_widget), "clicked",
1861: (GtkSignalFunc) custom_changed, NULL);
1862: #if 0
1863: gtk_signal_connect (GTK_OBJECT (b32_widget), "clicked",
1864: (GtkSignalFunc) custom_changed, NULL);
1865: #endif
1866: }
1867:
1868: static void make_chipset_widgets (GtkWidget *vbox)
1869: {
1870: GtkWidget *newbox, *hbox, *thing, *tmpbox;
1871: static const char *colllabels[] = {
1872: "None (fastest)", "Sprites only", "Sprites & playfields", "Full (very slow)",
1873: NULL
1874: };
1875: static const char *cslevellabels[] = {
1876: "OCS", "ECS Agnus", "Full ECS", "AGA", NULL
1877: };
1878: static const char *ntsclabels[] = {
1879: "PAL (European)", "NTSC (American)", NULL
1880: };
1881:
1882: add_empty_vbox (vbox);
1883:
1884: mbtype_widget = make_chooser (7, "Generic", "A1000", "A500/A2000", "A600", "A1200", "A3000", "A4000");
1885: gtk_widget_show (mbtype_widget);
1886: gtk_signal_connect (GTK_OBJECT (mbtype_widget), "changed", (GtkSignalFunc) mbtype_changed,
1887: NULL);
1888: mbtype_labelled = make_labelled_widget ("Motherboard type:", mbtype_widget, TRUE);
1889: gtk_widget_show (mbtype_labelled);
1890: add_centered_to_vbox (vbox, mbtype_labelled, 0);
1891:
1892: hbox = gtk_hbox_new (FALSE, 10);
1893: gtk_widget_show (hbox);
1894: add_centered_to_vbox (vbox, hbox, 0);
1895:
1896: newbox = make_radio_group_box ("Sprite collisions", colllabels, coll_widget, 0, coll_changed, NULL);
1897: gtk_widget_show (newbox);
1898: gtk_box_pack_start (GTK_BOX (hbox), newbox, FALSE, TRUE, 0);
1899:
1900: newbox = make_radio_group_box ("Chipset", cslevellabels, cslevel_widget, 0, cslevel_changed, NULL);
1901: gtk_widget_show (newbox);
1902: gtk_box_pack_start (GTK_BOX (hbox), newbox, FALSE, TRUE, 0);
1903:
1904: newbox = make_radio_group_box ("Chipset video output", ntsclabels, ntsc_widget, 0, ntsc_changed, NULL);
1905: gtk_widget_show (newbox);
1906: gtk_box_pack_start (GTK_BOX (hbox), newbox, FALSE, TRUE, 0);
1907:
1908: reqa4000 = gtk_label_new ("The selected ROM requires at least an A4000.");
1909: add_centered_to_vbox (vbox, reqa4000, 0);
1910:
1911: reqa1000 = gtk_label_new ("The selected ROM requires an A1000 motherboard.");
1912: add_centered_to_vbox (vbox, reqa1000, 0);
1913:
1914: add_empty_vbox (vbox);
1915:
1916: thing = gtk_label_new ("Chipset type settings take effect after the next reset.");
1917: gtk_widget_show (thing);
1918: add_centered_to_vbox (vbox, thing, 0);
1919: }
1920:
1921: static void make_sound_widgets (GtkWidget *vbox)
1922: {
1923: GtkWidget *frame, *newbox;
1924: int t;
1925: GtkWidget *hbox, *inner_vbox, *outer_hbox;
1926: static const char *soundlabels1[] = {
1927: "None", "No output", "Normal", "Accurate",
1928: NULL
1929: }, *soundlabels2[] = {
1930: "None", "RH", "BS", "Sinc", "Anti",
1931: NULL
1932: }, *soundlabels3[] = {
1933: "Mono", "Stereo",
1934: NULL
1935: }, *soundlabels4[] = {
1936: "Off", "A500 (power LED)", "A500 (always on)",
1937: "A1200 (power LED)", "A1200 (always on)",
1938: NULL
1939: };
1940:
1941: add_empty_vbox (vbox);
1942:
1943: outer_hbox = gtk_hbox_new (FALSE, 0);
1944: gtk_widget_show (outer_hbox);
1945: add_centered_to_vbox (vbox, outer_hbox, 0);
1946:
1947: inner_vbox = gtk_vbox_new (FALSE, 0);
1948: gtk_widget_show (inner_vbox);
1949: gtk_box_pack_start (GTK_BOX (outer_hbox), inner_vbox, FALSE, TRUE, 0);
1950:
1951: hbox = gtk_hbox_new (FALSE, 0);
1952: add_empty_vbox (hbox);
1953:
1954: newbox = make_radio_group_box ("Mode", soundlabels1, sound_widget, 0, sound_changed, NULL);
1955: gtk_widget_show (newbox);
1956: gtk_box_pack_start (GTK_BOX (hbox), newbox, FALSE, FALSE, 0);
1957:
1958: frame = gtk_frame_new ("Channels");
1959: gtk_widget_show (frame);
1960: gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
1961: newbox = gtk_vbox_new (FALSE, 4);
1962: gtk_widget_show (newbox);
1963: gtk_container_set_border_width (GTK_CONTAINER (newbox), 4);
1964: gtk_container_add (GTK_CONTAINER (frame), newbox);
1965: make_radio_group (soundlabels3, newbox, sound_ch_widget, 0, 1, sound_changed, -1, NULL);
1966:
1967: newbox = make_radio_group_box ("Interpolation", soundlabels2, sound_interpol_widget, 0, sound_changed, NULL);
1968: gtk_widget_show (newbox);
1969: gtk_box_pack_start (GTK_BOX (hbox), newbox, FALSE, TRUE, 0);
1970:
1971: newbox = make_radio_group_box ("Filter", soundlabels4, sound_filter_widget, 0, sound_changed, NULL);
1972: gtk_widget_show (newbox);
1973: gtk_box_pack_start (GTK_BOX (hbox), newbox, FALSE, TRUE, 0);
1974:
1975: add_empty_vbox (hbox);
1976: gtk_widget_show (hbox);
1977: gtk_box_pack_start (GTK_BOX (inner_vbox), hbox, FALSE, FALSE, 0);
1978:
1979: t = currprefs.sound_stereo_separation;
1980: if (t == 0)
1981: t = MIXED_STEREO_MAX;
1982: stereo_sep_adj = GTK_ADJUSTMENT (gtk_adjustment_new (t, 1, MIXED_STEREO_MAX, 1, 1, 0));
1983: gtk_signal_connect (GTK_OBJECT (stereo_sep_adj), "value_changed",
1984: GTK_SIGNAL_FUNC (sound_changed), NULL);
1985:
1986: stereo_sep_scale = gtk_hscale_new (stereo_sep_adj);
1987: gtk_range_set_update_policy (GTK_RANGE (stereo_sep_scale), GTK_UPDATE_DELAYED);
1988: gtk_scale_set_digits (GTK_SCALE (stereo_sep_scale), 0);
1989: gtk_scale_set_value_pos (GTK_SCALE (stereo_sep_scale), GTK_POS_RIGHT);
1990: stereo_sep_scale = make_labelled_widget ("Stereo separation:", stereo_sep_scale, TRUE);
1991: gtk_widget_show (stereo_sep_scale);
1992: gtk_box_pack_start (GTK_BOX (inner_vbox), stereo_sep_scale, FALSE, FALSE, 0);
1993:
1994: t = currprefs.sound_mixed_stereo_delay;
1995: stereo_delay_adj = GTK_ADJUSTMENT (gtk_adjustment_new (t, 0, SOUND_MAX_LOG_DELAY, 1, 1, 1));
1996: gtk_signal_connect (GTK_OBJECT (stereo_delay_adj), "value_changed",
1997: GTK_SIGNAL_FUNC (sound_changed), NULL);
1998:
1999: stereo_delay_scale = gtk_hscale_new (stereo_delay_adj);
2000: gtk_range_set_update_policy (GTK_RANGE (stereo_delay_scale), GTK_UPDATE_DELAYED);
2001: gtk_scale_set_digits (GTK_SCALE (stereo_delay_scale), 0);
2002: gtk_scale_set_value_pos (GTK_SCALE (stereo_delay_scale), GTK_POS_RIGHT);
2003: stereo_delay_scale = make_labelled_widget ("Stereo mixing delay:", stereo_delay_scale, TRUE);
2004: gtk_widget_show (stereo_delay_scale);
2005: gtk_box_pack_start (GTK_BOX (inner_vbox), stereo_delay_scale, FALSE, FALSE, 0);
2006:
2007: add_empty_vbox (vbox);
2008: }
2009:
2010: static void make_rom_widgets (GtkWidget *dvbox)
2011: {
2012: GtkWidget *hbox = gtk_hbox_new (FALSE, 10);
2013: GtkWidget *label, *frame;
2014:
2015: rom_req = 0;
2016:
2017: add_empty_vbox (dvbox);
2018:
2019: {
2020: GtkWidget *buttonbox = make_file_container ("ROM search path:", dvbox, 0);
2021: GtkWidget *thing = gtk_button_new_with_label ("Change");
2022:
2023: /* Current file display */
2024: rom_path_widget = make_file_widget (buttonbox);
2025:
2026: gtk_box_pack_start (GTK_BOX (buttonbox), thing, FALSE, TRUE, 0);
2027: gtk_widget_show (thing);
2028: gtk_signal_connect (GTK_OBJECT (thing), "clicked", (GtkSignalFunc) did_rompathchange, 0);
2029: }
2030:
2031: {
2032: GtkWidget *buttonbox = make_file_container ("Kickstart ROM file:", dvbox, 1);
2033: GtkWidget *hbox, *thing;
2034:
2035: romlist_widget = gtk_combo_box_new_text ();
2036: gtk_widget_show (romlist_widget);
2037: gtk_box_pack_start (GTK_BOX (buttonbox), romlist_widget, FALSE, TRUE, 0);
2038: gtk_combo_box_append_text (GTK_COMBO_BOX (romlist_widget),
2039: "Manually select a ROM file");
2040: romlist_nr_entries = 1;
2041: gtk_signal_connect (GTK_OBJECT (romlist_widget), "changed", (GtkSignalFunc) rom_combo_changed, 0);
2042:
2043: hbox = gtk_hbox_new (FALSE, 0);
2044: gtk_box_pack_start (GTK_BOX (buttonbox), hbox, FALSE, TRUE, 0);
2045: gtk_widget_show (hbox);
2046:
2047: /* Current file display */
2048: rom_text_widget = make_file_widget (hbox);
2049:
2050: romsel_button = gtk_button_new_with_label ("Change");
2051: gtk_box_pack_start (GTK_BOX (hbox), romsel_button, FALSE, TRUE, 0);
2052: gtk_widget_show (romsel_button);
2053: gtk_signal_connect (GTK_OBJECT (romsel_button), "clicked", (GtkSignalFunc) did_romchange, 0);
2054: }
2055:
2056: {
2057: GtkWidget *buttonbox = make_file_container ("ROM key file for Cloanto Amiga Forever:", dvbox, 0);
2058: GtkWidget *thing = gtk_button_new_with_label ("Change");
2059:
2060: /* Current file display */
2061: key_text_widget = make_file_widget (buttonbox);
2062:
2063: gtk_box_pack_start (GTK_BOX (buttonbox), thing, FALSE, TRUE, 0);
2064: gtk_widget_show (thing);
2065: gtk_signal_connect (GTK_OBJECT (thing), "clicked", (GtkSignalFunc) did_keychange, 0);
2066: }
2067:
2068: label = gtk_label_new ("These settings take effect after the next reset.");
2069: gtk_widget_show (label);
2070: add_centered_to_vbox (dvbox, label, 0);
2071:
2072: add_empty_vbox (dvbox);
2073: }
2074:
2075: static void make_ram_widgets (GtkWidget *dvbox)
2076: {
2077: GtkWidget *hbox = gtk_hbox_new (FALSE, 10);
2078: GtkWidget *label, *frame;
2079:
2080: static const char *chiplabels[] = {
2081: "512 KB", "1 MB", "2 MB", "4 MB", "8 MB", NULL
2082: };
2083: static const char *bogolabels[] = {
2084: "None", "512 KB", "1 MB", "1.8 MB", NULL
2085: };
2086: static const char *fastlabels[] = {
2087: "None", "1 MB", "2 MB", "4 MB", "8 MB", NULL
2088: };
2089: static const char *z3labels[] = {
2090: "None", "1 MB", "2 MB", "4 MB", "8 MB",
2091: "16 MB", "32 MB", "64 MB", "128 MB", "256 MB",
2092: NULL
2093: };
2094: static const char *p96labels[] = {
2095: "None", "1 MB", "2 MB", "4 MB", "8 MB", "16 MB", "32 MB", NULL
2096: };
2097:
2098: add_empty_vbox (dvbox);
2099:
2100: gtk_widget_show (hbox);
2101: add_centered_to_vbox (dvbox, hbox, 0);
2102:
2103: add_empty_vbox (dvbox);
2104:
2105: label = gtk_label_new ("These settings take effect after the next reset.");
2106: gtk_widget_show (label);
2107: add_centered_to_vbox (dvbox, label, 0);
2108:
2109: frame = make_radio_group_box ("Chip Mem", chiplabels, chipsize_widget, 0, chipsize_changed, NULL);
2110: gtk_widget_show (frame);
2111: gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
2112:
2113: frame = make_radio_group_box ("Slow Mem", bogolabels, bogosize_widget, 0, bogosize_changed, NULL);
2114: gtk_widget_show (frame);
2115: gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
2116:
2117: frame = make_radio_group_box ("Fast Mem", fastlabels, fastsize_widget, 0, fastsize_changed, NULL);
2118: gtk_widget_show (frame);
2119: gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
2120:
2121: frame = make_radio_group_box_1 ("Z3 Mem", z3labels, z3size_widget, 0, z3size_changed, 5);
2122: gtk_widget_show (frame);
2123: gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
2124:
2125: frame = make_radio_group_box_1 ("P96 RAM", p96labels, p96size_widget, 0, p96size_changed, 4);
2126: gtk_widget_show (frame);
2127: gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
2128: }
2129:
2130: static void make_joy_widgets (GtkWidget *dvbox)
2131: {
2132: int i;
2133: GtkWidget *hbox = gtk_hbox_new (FALSE, 10);
2134: GtkWidget *thing;
2135: static const char *joylabels[] = {
2136: "Joystick 0", "Joystick 1", "Mouse", "Numeric pad",
2137: "Cursor keys/Right Ctrl", "T/F/H/B/Left Alt",
2138: NULL
2139: };
2140:
2141: add_empty_vbox (dvbox);
2142: gtk_widget_show (hbox);
2143: add_centered_to_vbox (dvbox, hbox, 0);
2144:
2145: legacy_widget = gtk_check_button_new_with_label ("Use legacy configuration");
2146: add_centered_to_vbox (dvbox, legacy_widget, 0);
2147: gtk_widget_show (legacy_widget);
2148: gtk_signal_connect (GTK_OBJECT (legacy_widget), "clicked",
2149: (GtkSignalFunc) joy_changed, NULL);
2150:
2151: for (i = 0; i < 2; i++) {
2152: GtkWidget *vbox, *frame;
2153: char buffer[20];
2154: int j;
2155:
2156: sprintf (buffer, "Port %d", i);
2157: frame = make_radio_group_box (buffer, joylabels, joy_widget[i], 0, joy_changed, NULL);
2158: gtk_widget_show (frame);
2159: gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
2160: }
2161:
2162: thing = make_chooser (7, "English (QWERTY)", "Danish", "Deutsch (QWERTZ)", "Swedish",
2163: "Francais (AZERTY)", "Italian", "Spanish");
2164: gtk_signal_connect (GTK_OBJECT (thing), "changed", (GtkSignalFunc) kbdlang_changed,
2165: GINT_TO_POINTER (i));
2166: kbdlang_widget = thing;
2167: thing = add_labelled_widget_centered ("Keyboard language:", thing, dvbox);
2168:
2169: add_empty_vbox (dvbox);
2170: }
2171:
2172: static GtkWidget *leftalign (GtkWidget *thing)
2173: {
2174: GtkWidget *hbox = gtk_hbox_new (FALSE, 0);
2175: gtk_box_pack_start (GTK_BOX (hbox), thing, FALSE, FALSE, 0);
2176: return hbox;
2177: }
2178:
2179: static GtkWidget *create_dirdlg (const char *title, int row)
2180: {
2181: GtkWidget *vbox, *pathsel, *dirdlg;
2182: GtkWidget *path_entry, *volname_entry, *pri_entry;
2183:
2184: dirdlg = gtk_dialog_new_with_buttons (title, GTK_WINDOW (gui_window),
2185: GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
2186: GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
2187: GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
2188: NULL);
2189:
2190: gtk_window_set_position (GTK_WINDOW (dirdlg), GTK_WIN_POS_MOUSE);
2191:
2192: vbox = GTK_DIALOG (dirdlg)->vbox;
2193:
2194: pathsel = make_file_selector ("Select a path to mount",
2195: GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
2196:
2197: gtkutil_add_table (GTK_WIDGET (vbox),
2198: leftalign (gtk_label_new ("Path:")), 1, 1, GTK_FILL,
2199: leftalign (path_entry = gtk_file_chooser_button_new_with_dialog (pathsel)), 2, 1, GTK_FILL,
2200: GTKUTIL_ROW_END,
2201: leftalign (gtk_label_new ("Volume name:")), 1, 1, GTK_FILL,
2202: leftalign (volname_entry = gtk_entry_new_with_max_length (32)), 2, 1, GTK_FILL,
2203: GTKUTIL_ROW_END,
2204: leftalign (gtk_label_new ("Boot priority:")), 1, 1, GTK_FILL,
2205: leftalign (pri_entry = gtk_entry_new_with_max_length (2)), 2, 1, GTK_FILL,
2206: GTKUTIL_TABLE_END);
2207:
2208: if (row != -1) {
2209: char *failure;
2210: char t[20];
2211: int secspertrack, surfaces, reserved, blocksize, size;
2212: int cylinders, readonly, pri;
2213: char *volname, *rootdir, *devname;
2214:
2215: failure = get_filesys_unit (currprefs.mountinfo, row,
2216: &devname, &volname, &rootdir, &readonly,
2217: &secspertrack, &surfaces, &reserved,
2218: &cylinders, &size, &blocksize, &pri);
2219: if (failure) {
2220: mkmsgbox ("Error", failure);
2221: goto out;
2222: }
2223: gtk_entry_set_text (GTK_ENTRY (volname_entry), volname);
2224: gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (path_entry), rootdir);
2225: sprintf (t, "%d", pri);
2226: gtk_entry_set_text (GTK_ENTRY (pri_entry), t);
2227: if (volname)
2228: free (volname);
2229: if (devname)
2230: free (devname);
2231: if (rootdir)
2232: free (rootdir);
2233: }
2234:
2235: retry:
2236: if (gtk_dialog_run (GTK_DIALOG (dirdlg)) == GTK_RESPONSE_ACCEPT) {
2237: const char *failure;
2238: const char *pathname = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (path_entry));
2239: const char *volname = gtk_entry_get_text (GTK_ENTRY (volname_entry));
2240: const char *bprstr = gtk_entry_get_text (GTK_ENTRY (pri_entry));
2241: char fixed_volname[256];
2242: int n, bpr;
2243:
2244: if (pathname == NULL || strlen (pathname) == 0 || access (pathname, R_OK) != 0) {
2245: mkmsgbox ("Error", "You must select a valid path.");
2246: goto retry;
2247: }
2248: n = volname == NULL ? 0 : strlen (volname);
2249: if (n > 255) {
2250: mkmsgbox ("Error", "Volume name too long.");
2251: goto retry;
2252: }
2253: /* Strip colons from the end. */
2254: if (n > 0) {
2255: strcpy (fixed_volname, volname);
2256: if (fixed_volname[n - 1] == ':') {
2257: fixed_volname[n - 1] = '\0';
2258: n--;
2259: }
2260: }
2261:
2262: if (n == 0) {
2263: mkmsgbox ("Error", "You must enter a volume name.");
2264: goto retry;
2265: }
2266:
2267: if (strlen (bprstr) == 0) {
2268: mkmsgbox ("Error", "You must enter a valid number of surfaces.");
2269: goto retry;
2270: }
2271: bpr = atoi (bprstr);
2272:
2273: if (row == -1) {
2274: failure = add_filesys_unit (currprefs.mountinfo, NULL, fixed_volname, pathname,
2275: 0, 0, 0, 0, 0, bpr);
2276: } else {
2277: failure = set_filesys_unit (currprefs.mountinfo, row, NULL, fixed_volname, pathname,
2278: 0, 0, 0, 0, 0, bpr);
2279: }
2280: if (failure) {
2281: mkmsgbox ("Error", failure);
2282: goto retry;
2283: }
2284: set_hd_state ();
2285: }
2286:
2287: out:
2288: gtk_widget_destroy (dirdlg);
2289: return 0;
2290: }
2291:
2292: static void create_hdfdlg (const char *title, int row)
2293: {
2294: GtkWidget *vbox, *pathsel;
2295: GtkWidget *hdfdlg;
2296: static GtkWidget *bpt_entry, *surfaces_entry, *pri_entry;
2297: static GtkWidget *blocksize_entry, *reserved_entry, *path_entry;
2298:
2299: int readonly = 0;
2300:
2301: hdfdlg = gtk_dialog_new_with_buttons (title, GTK_WINDOW (gui_window),
2302: GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
2303: GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
2304: GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
2305: NULL);
2306:
2307: gtk_window_set_position (GTK_WINDOW (hdfdlg), GTK_WIN_POS_MOUSE);
2308:
2309: pathsel = make_file_selector ("Select a path to mount",
2310: GTK_FILE_CHOOSER_ACTION_OPEN);
2311:
2312: vbox = GTK_DIALOG (hdfdlg)->vbox;
2313:
2314: gtkutil_add_table (GTK_WIDGET (vbox),
2315: leftalign (gtk_label_new ("File:")), 1, 1, GTK_FILL,
2316: leftalign (path_entry = gtk_file_chooser_button_new_with_dialog (pathsel)), 2, 1, GTK_FILL,
2317: GTKUTIL_ROW_END,
2318: leftalign (gtk_label_new ("Reserved blocks:")), 1, 1, GTK_FILL,
2319: leftalign (reserved_entry = gtk_entry_new_with_max_length (6)), 2, 1, GTK_FILL,
2320: GTKUTIL_ROW_END,
2321: leftalign (gtk_label_new ("Surfaces:")), 1, 1, GTK_FILL,
2322: leftalign (surfaces_entry = gtk_entry_new_with_max_length (2)), 2, 1, GTK_FILL,
2323: GTKUTIL_ROW_END,
2324: leftalign (gtk_label_new ("Blocksize:")), 1, 1, GTK_FILL,
2325: leftalign (blocksize_entry = gtk_entry_new_with_max_length (6)), 2, 1, GTK_FILL,
2326: GTKUTIL_ROW_END,
2327: leftalign (gtk_label_new ("Blocks per track:")), 1, 1, GTK_FILL,
2328: leftalign (bpt_entry = gtk_entry_new_with_max_length (6)), 2, 1, GTK_FILL,
2329: GTKUTIL_ROW_END,
2330: leftalign (gtk_label_new ("Boot priority:")), 1, 1, GTK_FILL,
2331: leftalign (pri_entry = gtk_entry_new_with_max_length (2)), 2, 1, GTK_FILL,
2332:
2333: GTKUTIL_TABLE_END);
2334:
2335: gtk_file_chooser_button_set_width_chars (GTK_FILE_CHOOSER_BUTTON (path_entry), 40);
2336:
2337: if (row != -1) {
2338: char *failure;
2339: char *devname, *volname, *rootdir;
2340: int secspertrack, surfaces, reserved, blocksize, size;
2341: int cylinders, pri;
2342: char t[20];
2343:
2344: failure = get_filesys_unit (currprefs.mountinfo, row,
2345: &devname, &volname, &rootdir, &readonly,
2346: &secspertrack, &surfaces, &reserved,
2347: &cylinders, &size, &blocksize, &pri);
2348: if (failure) {
2349: mkmsgbox ("Error", failure);
2350: goto out;
2351: }
2352: gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (path_entry), rootdir);
2353: sprintf (t, "%d", blocksize);
2354: gtk_entry_set_text (GTK_ENTRY (blocksize_entry), t);
2355: sprintf (t, "%d", secspertrack);
2356: gtk_entry_set_text (GTK_ENTRY (bpt_entry), t);
2357: sprintf (t, "%d", surfaces);
2358: gtk_entry_set_text (GTK_ENTRY (surfaces_entry), t);
2359: sprintf (t, "%d", reserved);
2360: gtk_entry_set_text (GTK_ENTRY (reserved_entry), t);
2361: sprintf (t, "%d", pri);
2362: gtk_entry_set_text (GTK_ENTRY (pri_entry), t);
2363: if (volname)
2364: free (volname);
2365: if (devname)
2366: free (devname);
2367: if (rootdir)
2368: free (rootdir);
2369: }
2370:
2371: retry:
2372: if (gtk_dialog_run (GTK_DIALOG (hdfdlg)) == GTK_RESPONSE_ACCEPT) {
2373: const char *failure;
2374: const char *new_filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (path_entry));
2375: const char *bptstr = gtk_entry_get_text (GTK_ENTRY (bpt_entry));
2376: const char *sfstr = gtk_entry_get_text (GTK_ENTRY (surfaces_entry));
2377: const char *bsstr = gtk_entry_get_text (GTK_ENTRY (blocksize_entry));
2378: const char *rsrvstr = gtk_entry_get_text (GTK_ENTRY (reserved_entry));
2379: const char *bprstr = gtk_entry_get_text (GTK_ENTRY (pri_entry));
2380: int n, sf, bpt, bs, rsrv, bpr;
2381:
2382: if (new_filename == NULL || strlen (new_filename) == 0) {
2383: mkmsgbox ("Error", "You must enter a valid filename.");
2384: goto retry;
2385: }
2386:
2387: if (strlen (bptstr) == 0 || (bpt = atoi (bptstr)) == 0) {
2388: mkmsgbox ("Error", "You must enter a valid number of blocks per track.");
2389: goto retry;
2390: }
2391: if (strlen (rsrvstr) == 0) {
2392: mkmsgbox ("Error", "You must enter the number of reserved blocks.");
2393: goto retry;
2394: }
2395: rsrv = atoi (rsrvstr);
2396: if (strlen (sfstr) == 0 || (sf = atoi (sfstr)) == 0) {
2397: mkmsgbox ("Error", "You must enter a valid number of surfaces.");
2398: goto retry;
2399: }
2400: if (strlen (bsstr) == 0 || (bs = atoi (bsstr)) == 0) {
2401: mkmsgbox ("Error", "You must enter a valid number of surfaces.");
2402: goto retry;
2403: }
2404: if (strlen (bprstr) == 0) {
2405: mkmsgbox ("Error", "You must enter a valid number of surfaces.");
2406: goto retry;
2407: }
2408: bpr = atoi (bprstr);
2409:
2410: if (row == -1) {
2411: failure = add_filesys_unit (currprefs.mountinfo, NULL, NULL, new_filename,
2412: readonly, bpt, sf, rsrv, bs, bpr);
2413: } else {
2414: failure = set_filesys_unit (currprefs.mountinfo, row, NULL, NULL, new_filename,
2415: readonly, bpt, sf, rsrv, bs, bpr);
2416: }
2417: if (failure) {
2418: mkmsgbox ("Error", failure);
2419: goto retry;
2420: }
2421: set_hd_state ();
2422: }
2423: out:
2424: gtk_widget_destroy (hdfdlg);
2425: return;
2426: }
2427:
2428: static void did_newdir (void)
2429: {
2430: create_dirdlg ("Add a new mounted directory", -1);
2431: }
2432:
2433: static void did_newhdf (void)
2434: {
2435: create_hdfdlg ("Add a new hardfile", -1);
2436: }
2437:
2438: static void did_newadf (void)
2439: {
2440: make_disk_selector ();
2441:
2442: if (gtk_dialog_run (GTK_DIALOG (disk_selector)) == GTK_RESPONSE_ACCEPT) {
2443: char *filename;
2444: struct zfile *f;
2445: filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (disk_selector));
2446:
2447: f = zfile_open (filename, "rb");
2448: if (f) {
2449: const char *failure;
2450: char buf[512];
2451: long size;
2452: zfile_fread (buf, 1, 512, f);
2453: zfile_fseek (f, 0, SEEK_END);
2454: size = zfile_ftell (f);
2455: if (buf[0] != 'D' || buf[1] != 'O' || buf[2] != 'S'
2456: || (buf[3] != 0 && buf[3] != 1)
2457: || size != 901120)
2458: {
2459: mkmsgbox ("Error", "Not an ADF diskfile.");
2460: } else {
2461: failure = add_filesys_unit (currprefs.mountinfo, NULL, NULL, filename,
2462: 0, 11, 2, 2, 512, -2);
2463: if (failure)
2464: mkmsgbox ("Error", failure);
2465: else
2466: set_hd_state ();
2467: }
2468: zfile_fclose (f);
2469: }
2470:
2471: g_free (filename);
2472: }
2473:
2474: gtk_widget_hide (disk_selector);
2475: }
2476:
2477: static void did_hdchange (void)
2478: {
2479: GtkTreeIter iter;
2480: GtkTreeModel *model;
2481: int idx;
2482:
2483: if (gtk_tree_selection_get_selected (hd_selection, &model, &iter))
2484: gtk_tree_model_get (model, &iter, 0, &idx, -1);
2485: else
2486: return;
2487:
2488: if (is_hardfile (currprefs.mountinfo, idx)) {
2489: create_hdfdlg ("Change a hardfile", idx);
2490: } else {
2491: create_dirdlg ("Change a mounted directory", idx);
2492: }
2493: }
2494: static void did_hddel (void)
2495: {
2496: GtkTreeIter iter;
2497: GtkTreeModel *model;
2498: int idx;
2499:
2500: if (gtk_tree_selection_get_selected (hd_selection, &model, &iter))
2501: gtk_tree_model_get (model, &iter, 0, &idx, -1);
2502: else
2503: return;
2504:
2505: kill_filesys_unit (currprefs.mountinfo, idx);
2506: set_hd_state ();
2507: }
2508:
2509: static void hdsel_changed (GtkWidget *widget, gint row, gint column, GdkEventButton *bevent,
2510: gpointer user_data)
2511: {
2512: GtkTreeIter iter;
2513: GtkTreeModel *model;
2514:
2515: if (gtk_tree_selection_get_selected (hd_selection, &model, &iter)) {
2516: gtk_widget_set_sensitive (hdchange_button, TRUE);
2517: gtk_widget_set_sensitive (hddel_button, TRUE);
2518: } else {
2519: gtk_widget_set_sensitive (hdchange_button, FALSE);
2520: gtk_widget_set_sensitive (hddel_button, FALSE);
2521: }
2522: }
2523:
2524: static void hdunselect (GtkWidget *widget, gint row, gint column, GdkEventButton *bevent,
2525: gpointer user_data)
2526: {
2527: gtk_widget_set_sensitive (hdchange_button, FALSE);
2528: gtk_widget_set_sensitive (hddel_button, FALSE);
2529: }
2530:
2531: static void preset_changed (GtkTreeSelection *selection, gpointer data)
2532: {
2533: GtkTreeIter iter;
2534: GtkTreeModel *model;
2535:
2536: if (gtk_tree_selection_get_selected (selection, &model, &iter))
2537: gtk_widget_set_sensitive (preset_button, TRUE);
2538: else
2539: gtk_widget_set_sensitive (preset_button, FALSE);
2540: }
2541:
2542: static void did_set_preset (void)
2543: {
2544: GtkTreeIter iter;
2545: GtkTreeModel *model;
2546: gchar *filename;
2547:
2548: if (gtk_tree_selection_get_selected (preset_selection, &model, &iter)) {
2549: gtk_tree_model_get (model, &iter, 1, &filename, -1);
2550:
2551: if (filename) {
2552: cfgfile_load (&changed_prefs, filename);
2553: set_widgets_from_config ();
2554: }
2555: g_free (filename);
2556: }
2557: }
2558:
2559: static GtkWidget *make_buttons_1 (const char *label, GtkWidget *box, void (*sigfunc) (void),
2560: GtkWidget *(*create)(const char *label), int expand)
2561: {
2562: GtkWidget *thing = create (label);
2563: gtk_widget_show (thing);
2564: gtk_signal_connect (GTK_OBJECT (thing), "clicked", (GtkSignalFunc) sigfunc, NULL);
2565: gtk_box_pack_start (GTK_BOX (box), thing, expand, expand, 0);
2566:
2567: return thing;
2568: }
2569: #define make_buttons(label, box, sigfunc, create) make_buttons_1(label, box, sigfunc, create, 1)
2570: #define make_button(label, box, sigfunc) make_buttons(label, box, sigfunc, gtk_button_new_with_label)
2571:
2572: static void new_text_cell_renderer (GtkWidget *treeview, const char *title, int colnr,
2573: int expand, int ellipsize)
2574: {
2575: GtkCellRenderer *renderer = gtk_cell_renderer_text_new ();
2576: GtkTreeViewColumn *column;
2577: column = gtk_tree_view_column_new_with_attributes (title, renderer,
2578: "text", colnr, NULL);
2579: gtk_tree_view_column_set_expand (column, expand);
2580: gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
2581: if (ellipsize)
2582: g_object_set (renderer,
2583: "ellipsize", PANGO_ELLIPSIZE_START,
2584: "ellipsize-set", TRUE,
2585: NULL);
2586: }
2587:
2588: static void make_hd_widgets (GtkWidget *dvbox)
2589: {
2590: GtkCellRenderer *renderer;
2591: GtkTreeViewColumn *column;
2592: GtkAdjustment *adj;
2593: GtkWidget *scrolled, *buttonbox, *vbox, *hbox;
2594: int i;
2595:
2596: hd_store = gtk_list_store_new (11,
2597: G_TYPE_INT,
2598: G_TYPE_STRING, G_TYPE_STRING,
2599: G_TYPE_BOOLEAN,
2600: G_TYPE_STRING, G_TYPE_STRING,
2601: G_TYPE_STRING, G_TYPE_STRING,
2602: G_TYPE_STRING, G_TYPE_STRING,
2603: G_TYPE_INT);
2604:
2605: #if 0
2606: add_empty_vbox (dvbox);
2607: #endif
2608:
2609: hbox = gtk_hbox_new (FALSE, 0);
2610: gtk_box_pack_start (GTK_BOX (dvbox), hbox, TRUE, TRUE, 20);
2611: gtk_widget_show (hbox);
2612:
2613: vbox = gtk_vbox_new (FALSE, 4);
2614: gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
2615: gtk_widget_show (vbox);
2616:
2617: hdlist_widget = gtk_tree_view_new_with_model (GTK_TREE_MODEL (hd_store));
2618:
2619: new_text_cell_renderer (hdlist_widget, "Volume", 1, 0, 0);
2620: new_text_cell_renderer (hdlist_widget, "Path/File", 2, 1, 1);
2621:
2622: renderer = gtk_cell_renderer_toggle_new ();
2623: column = gtk_tree_view_column_new_with_attributes ("R/O", renderer,
2624: "active", 3, NULL);
2625: gtk_tree_view_column_set_expand (column, 0);
2626: gtk_tree_view_append_column (GTK_TREE_VIEW (hdlist_widget), column);
2627:
2628: new_text_cell_renderer (hdlist_widget, "Heads", 4, 0, 0);
2629: new_text_cell_renderer (hdlist_widget, "Cyl.", 5, 0, 0);
2630: new_text_cell_renderer (hdlist_widget, "Sec.", 6, 0, 0);
2631: new_text_cell_renderer (hdlist_widget, "Rsrvd", 7, 0, 0);
2632: new_text_cell_renderer (hdlist_widget, "Size", 8, 0, 0);
2633: new_text_cell_renderer (hdlist_widget, "Blksize", 9, 0, 0);
2634: new_text_cell_renderer (hdlist_widget, "Pri", 10, 0, 0);
2635:
2636: gtk_widget_show (hdlist_widget);
2637:
2638: scrolled = gtk_scrolled_window_new (NULL, NULL);
2639: gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
2640: GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
2641: gtk_box_pack_start (GTK_BOX (vbox), scrolled, TRUE, TRUE, 0);
2642: gtk_widget_show (scrolled);
2643:
2644: gtk_container_add (GTK_CONTAINER (scrolled), hdlist_widget);
2645:
2646: hd_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (hdlist_widget));
2647: gtk_tree_selection_set_mode (hd_selection, GTK_SELECTION_SINGLE);
2648: g_signal_connect (G_OBJECT (hd_selection), "changed",
2649: G_CALLBACK (hdsel_changed), NULL);
2650:
2651: /* The buttons */
2652: buttonbox = gtk_hbox_new (FALSE, 4);
2653: gtk_widget_show (buttonbox);
2654: gtk_box_pack_start (GTK_BOX (vbox), buttonbox, FALSE, FALSE, 0);
2655: make_button ("New filesystem...", buttonbox, did_newdir);
2656: make_button ("New hardfile...", buttonbox, did_newhdf);
2657: make_button ("Mount floppy as HD...", buttonbox, did_newadf);
2658:
2659: buttonbox = gtk_hbox_new (FALSE, 4);
2660: gtk_widget_show (buttonbox);
2661: gtk_box_pack_start (GTK_BOX (vbox), buttonbox, FALSE, FALSE, 0);
2662: hdchange_button = make_button ("Change...", buttonbox, did_hdchange);
2663: hddel_button = make_button ("Delete", buttonbox, did_hddel);
2664:
2665: bootrom_widget = gtk_check_button_new_with_label ("Enable bootrom - needed for filesystem, Picasso96 and better mouse support;\ndisable only in case of (unlikely) compatibility issues");
2666: add_centered_to_vbox (dvbox, bootrom_widget, 0);
2667: gtk_widget_show (bootrom_widget);
2668: gtk_signal_connect (GTK_OBJECT (bootrom_widget), "clicked",
2669: (GtkSignalFunc) bootrom_changed, NULL);
2670: #if 0
2671: add_empty_vbox (dvbox);
2672: #endif
2673: }
2674:
2675: static void make_presets (GtkWidget *dvbox)
2676: {
2677: GtkListStore *store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
2678: GtkCellRenderer *renderer = gtk_cell_renderer_text_new ();
2679: GtkTreeViewColumn *column;
2680: GtkWidget *scrolled, *buttonbox, *vbox, *hbox;
2681: int i;
2682:
2683: add_empty_vbox (dvbox);
2684:
2685: hbox = gtk_hbox_new (FALSE, 0);
2686: gtk_box_pack_start (GTK_BOX (dvbox), hbox, TRUE, TRUE, 0);
2687: gtk_widget_show (hbox);
2688:
2689: add_empty_vbox (hbox);
2690:
2691: vbox = gtk_vbox_new (FALSE, 4);
2692: gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
2693: gtk_widget_show (vbox);
2694:
2695: for (i = 0; i < n_predef_configs; i++) {
2696: GtkTreeIter iter;
2697: gtk_list_store_append (store, &iter);
2698:
2699: gtk_list_store_set (store, &iter,
2700: 0, predef_configs[i].description,
2701: 1, predef_configs[i].filename,
2702: -1);
2703: }
2704: preset_list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
2705: gtk_widget_show (preset_list);
2706:
2707: new_text_cell_renderer (preset_list, "Hardware configuration presets", 0, 1, 0);
2708:
2709: scrolled = gtk_scrolled_window_new (NULL, NULL);
2710: gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
2711: GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
2712: gtk_box_pack_start (GTK_BOX (vbox), scrolled, TRUE, TRUE, 0);
2713: gtk_widget_show (scrolled);
2714:
2715: gtk_container_add (GTK_CONTAINER (scrolled), preset_list);
2716:
2717: preset_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (preset_list));
2718: gtk_tree_selection_set_mode (preset_selection, GTK_SELECTION_SINGLE);
2719: g_signal_connect (G_OBJECT (preset_selection), "changed",
2720: G_CALLBACK (preset_changed),
2721: NULL);
2722:
2723: /* The buttons */
2724: buttonbox = gtk_hbox_new (FALSE, 4);
2725: gtk_widget_show (buttonbox);
2726: gtk_box_pack_start (GTK_BOX (vbox), buttonbox, FALSE, FALSE, 0);
2727: preset_button = make_buttons_1 ("Set configuration to chosen preset", buttonbox, did_set_preset,
2728: gtk_button_new_with_label, 0);
2729:
2730: add_empty_vbox (hbox);
2731:
2732: add_empty_vbox (dvbox);
2733: }
2734:
2735: static void make_about_widgets (GtkWidget *dvbox)
2736: {
2737: GtkWidget *lab_version;
2738: GtkStyle *style;
2739: GdkFont *font;
2740: char t[20];
2741:
2742: add_empty_vbox (dvbox);
2743:
2744: sprintf (t, "%s %s", PACKAGE_NAME, PACKAGE_VERSION);
2745: lab_version = gtk_label_new (t);
2746: lab_info = gtk_label_new ("Choose your settings, then deselect the Pause button to start!");
2747:
2748: style = gtk_style_copy (GTK_WIDGET (lab_version)->style);
2749: pango_font_description_free (style->font_desc);
2750: style->font_desc = pango_font_description_from_string ("Sans 24");
2751: gtk_widget_set_style (lab_version, style);
2752:
2753: add_centered_to_vbox (dvbox, lab_version, 0);
2754: add_centered_to_vbox (dvbox, lab_info, 0);
2755: gtk_widget_show (lab_version);
2756: if (currprefs.start_gui == 1)
2757: gtk_widget_show (lab_info);
2758:
2759: add_empty_vbox (dvbox);
2760: }
2761:
2762: static void create_guidlg (void)
2763: {
2764: GtkWidget *window;
2765: GtkWidget *buttonbox, *vbox, *hbox;
2766: GtkWidget *thing;
2767: unsigned int i;
2768: int argc = 1;
2769: char *a[] = {"UAE"};
2770: char **argv = a;
2771: static const struct _pages {
2772: const char *title;
2773: void (*createfunc)(GtkWidget *);
2774: } pages[] = {
2775: /* ??? If this isn't the first page, there are errors in draw_led. */
2776: { "Floppies", make_floppy_disks },
2777: { "ROM", make_rom_widgets },
2778: { "RAM", make_ram_widgets },
2779: { "CPU", make_cpu_widgets },
2780: { "Graphics", make_gfx_widgets },
2781: { "Chipset", make_chipset_widgets },
2782: { "Sound", make_sound_widgets },
2783: { "Input devices", make_joy_widgets },
2784: { "Harddisks", make_hd_widgets },
2785: { "Presets", make_presets },
2786: { "About", make_about_widgets }
2787: };
2788:
2789: gtk_init (&argc, &argv);
2790: gtk_rc_parse ("uaegtkrc");
2791:
2792: gui_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2793: gtk_window_set_title (GTK_WINDOW (gui_window), "UAE control");
2794:
2795: gtk_signal_connect (GTK_OBJECT (gui_window), "delete_event",
2796: GTK_SIGNAL_FUNC (gui_delete_event), NULL);
2797:
2798: vbox = gtk_vbox_new (FALSE, 4);
2799: gtk_container_add (GTK_CONTAINER (gui_window), vbox);
2800: gtk_container_set_border_width (GTK_CONTAINER (gui_window), 10);
2801:
2802: /* First line - buttons and power LED */
2803: hbox = gtk_hbox_new (FALSE, 10);
2804: gtk_widget_show (hbox);
2805: gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
2806:
2807: /* The buttons */
2808: buttonbox = gtk_hbox_new (TRUE, 4);
2809: gtk_widget_show (buttonbox);
2810: gtk_box_pack_start (GTK_BOX (hbox), buttonbox, TRUE, TRUE, 0);
2811: make_button ("Reset", buttonbox, did_reset);
2812: make_button ("Debug", buttonbox, did_debug);
2813: make_button ("Quit", buttonbox, did_quit);
2814: make_button ("Save config", buttonbox, save_config);
2815: pause_uae_widget = make_buttons ("Pause", buttonbox, pause_uae, gtk_toggle_button_new_with_label);
2816:
2817: /* The LED */
2818: thing = make_led (0);
2819: thing = make_labelled_widget ("Power:", thing, FALSE);
2820: gtk_widget_show (thing);
2821: gtk_box_pack_start (GTK_BOX (hbox), thing, FALSE, TRUE, 0);
2822:
2823: /* More buttons */
2824: buttonbox = gtk_hbox_new (TRUE, 4);
2825: gtk_widget_show (buttonbox);
2826: gtk_box_pack_start (GTK_BOX (vbox), buttonbox, TRUE, TRUE, 0);
2827: snap_save_widget = make_button ("Save state", buttonbox, did_savestate);
2828: snap_load_widget = make_button ("Load state", buttonbox, did_loadstate);
2829:
2830: /* Place a separator below those buttons. */
2831: thing = gtk_hseparator_new ();
2832: gtk_box_pack_start (GTK_BOX (vbox), thing, FALSE, TRUE, 0);
2833: gtk_widget_show (thing);
2834:
2835: /* Now the notebook */
2836: notebook = gtk_notebook_new ();
2837: gtk_box_pack_start (GTK_BOX (vbox), notebook, TRUE, TRUE, 0);
2838: gtk_widget_show (notebook);
2839:
2840: for (i = 0; i < sizeof pages / sizeof (struct _pages); i++) {
2841: thing = gtk_vbox_new (FALSE, 4);
2842: gtk_widget_show (thing);
2843: gtk_container_set_border_width (GTK_CONTAINER (thing), 10);
2844: pages[i].createfunc (thing);
2845: gtk_notebook_append_page (GTK_NOTEBOOK (notebook), thing, gtk_label_new (pages[i].title));
2846: }
2847:
2848: /* Put "about" screen first. */
2849: gtk_notebook_set_page (GTK_NOTEBOOK (notebook), i - 1);
2850: enable_disk_buttons (1);
2851:
2852: gtk_widget_show (vbox);
2853:
2854: gtk_timeout_add (1000, (GtkFunction)my_idle, 0);
2855: }
2856:
2857: static void *gtk_gui_thread (void *dummy)
2858: {
2859: gui_available = 1;
2860: gtk_main ();
2861:
2862: gui_available = 0;
2863: uae_sem_post (&gui_quit_sem);
2864: return 0;
2865: }
2866:
2867: void gui_fps (int x)
2868: {
2869: }
2870:
2871: void gui_display (int shortcut)
2872: {
2873: if (shortcut == -1 && !gui_available) {
2874: gui_init (0);
2875: }
2876: }
2877:
2878: void gui_led (int num, int on)
2879: {
2880: if (no_gui)
2881: return;
2882:
2883: /* if (num == 0)
2884: return;
2885: printf("LED %d %d\n", num, on);
2886: write_comm_pipe_int (&to_gui_pipe, 1, 0);
2887: write_comm_pipe_int (&to_gui_pipe, num == 0 ? 4 : num - 1, 0);
2888: write_comm_pipe_int (&to_gui_pipe, on, 1);
2889: printf("#LED %d %d\n", num, on);*/
2890: }
2891:
2892: void gui_filename (int num, const char *name)
2893: {
2894: if (no_gui)
2895: return;
2896:
2897: write_comm_pipe_int (&to_gui_pipe, GUICMD_DISKCHANGE, 0);
2898: write_comm_pipe_int (&to_gui_pipe, num, 1);
2899:
2900: /* gui_update ();*/
2901: }
2902:
2903: void gui_handle_events (void)
2904: {
2905: int pause_uae = FALSE;
2906:
2907: if (no_gui)
2908: return;
2909:
2910: do {
2911: while (pause_uae || comm_pipe_has_data (&from_gui_pipe)) {
2912: int cmd = read_comm_pipe_int_blocking (&from_gui_pipe);
2913: int n;
2914: switch (cmd) {
2915: case 0:
2916: n = read_comm_pipe_int_blocking (&from_gui_pipe);
2917: changed_prefs.df[n][0] = '\0';
2918: break;
2919: case 1:
2920: n = read_comm_pipe_int_blocking (&from_gui_pipe);
2921: uae_sem_wait (&gui_sem);
2922: strncpy (changed_prefs.df[n], new_disk_string[n], 255);
2923: free (new_disk_string[n]);
2924: new_disk_string[n] = 0;
2925: changed_prefs.df[n][255] = '\0';
2926: uae_sem_post (&gui_sem);
2927: break;
2928: case 2:
2929: uae_reset (1);
2930: end_pause_uae ();
2931: break;
2932: case 3:
2933: activate_debugger ();
2934: end_pause_uae ();
2935: break;
2936: case 4:
2937: uae_quit ();
2938: end_pause_uae ();
2939: break;
2940: case 5:
2941: pause_uae = TRUE;
2942: break;
2943: case 6:
2944: pause_uae = FALSE;
2945: break;
2946: case 7:
2947: printf ("STATESAVE\n");
2948: savestate_state = read_comm_pipe_int_blocking (&from_gui_pipe);
2949: uae_sem_wait (&gui_sem);
2950: savestate_filename = gui_snapname;
2951: uae_sem_post (&gui_sem);
2952: break;
2953: case 8:
2954: uae_sem_wait (&gui_sem);
2955: strncpy (changed_prefs.romfile, gui_romname, 255);
2956: changed_prefs.romfile[255] = '\0';
2957: free (gui_romname);
2958: uae_sem_post (&gui_sem);
2959: break;
2960: case 9:
2961: uae_sem_wait (&gui_sem);
2962: strncpy (changed_prefs.keyfile, gui_keyname, 255);
2963: changed_prefs.keyfile[255] = '\0';
2964: free (gui_keyname);
2965: uae_sem_post (&gui_sem);
2966: break;
2967: case 10:
2968: uae_sem_wait (&gui_sem);
2969: strncpy (changed_prefs.path_rom, gui_romname, 255);
2970: changed_prefs.path_rom[255] = '\0';
2971: free (gui_romname);
2972: uae_sem_post (&gui_sem);
2973: break;
2974: case 11:
2975: uae_sem_wait (&gui_sem);
2976: changed_prefs.gfx_w = gfx_w;
2977: changed_prefs.gfx_f = gfx_f;
2978: uae_sem_post (&gui_sem);
2979: break;
2980: }
2981: }
2982: } while (pause_uae);
2983: }
2984:
2985: void gui_update_gfx (void)
2986: {
2987: if (no_gui)
2988: return;
2989:
2990: write_comm_pipe_int (&to_gui_pipe, GUICMD_FULLSCREEN, 1);
2991: }
2992:
2993: int gui_init (int at_start)
2994: {
2995: uae_thread_id tid;
2996:
2997: if (gui_available)
2998: return 0;
2999:
3000: if (at_start) {
3001: init_comm_pipe (&to_gui_pipe, 20, 1);
3002: init_comm_pipe (&from_gui_pipe, 20, 1);
3003: uae_sem_init (&gui_sem, 0, 1);
3004: uae_sem_init (&gui_init_sem, 0, 0);
3005: uae_sem_init (&gui_quit_sem, 0, 0);
3006: }
3007:
3008: create_guidlg ();
3009: if (at_start)
3010: uae_start_thread (gtk_gui_thread, NULL, &tid);
3011:
3012: gui_update ();
3013:
3014: if (at_start && currprefs.start_gui == 1) {
3015: write_comm_pipe_int (&to_gui_pipe, GUICMD_PAUSE, 1);
3016: write_comm_pipe_int (&from_gui_pipe, 5, 1);
3017: /* Handle events until Pause is unchecked. */
3018: gui_handle_events ();
3019: /* Quit requested? */
3020: if (quit_program == -1) {
3021: gui_exit ();
3022: return -2;
3023: }
3024: }
3025:
3026: return 1;
3027: }
3028:
3029: int gui_update (void)
3030: {
3031: if (!gui_available)
3032: return 0;
3033:
3034: write_comm_pipe_int (&to_gui_pipe, GUICMD_UPDATE, 1);
3035: uae_sem_wait (&gui_init_sem);
3036: return 0;
3037: }
3038:
3039: void gui_romlist_changed (void)
3040: {
3041: if (!gui_available)
3042: return;
3043:
3044: write_comm_pipe_int (&to_gui_pipe, GUICMD_NEW_ROMLIST, 1);
3045: return;
3046: }
3047:
3048: void gui_exit (void)
3049: {
3050: if (!gui_available)
3051: return;
3052:
3053: quit_gui = 1;
3054: uae_sem_wait (&gui_quit_sem);
3055: }
3056:
3057: void gui_lock (void)
3058: {
3059: if (!gui_available)
3060: return;
3061: uae_sem_wait (&gui_sem);
3062: }
3063:
3064: void gui_unlock (void)
3065: {
3066: if (!gui_available)
3067: return;
3068:
3069: uae_sem_post (&gui_sem);
3070: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.