/** \file settings_model.c * \brief Model settings dialog * * \author Bas Wassink * \author Groepaz */ /* * $VICERES IECReset x64 x64sc xscpu64 * $VICERES GlueLogic x64 x64sc xscpu64 * $VICERES Go64Mode x128 * $VICERES DtvRevision x64dtv * $VICERES VICIINewLuminances x64dtv * $VICERES HummerADC x64dtv * * following are set internally: * * $VICERES BoardType x64 x64sc xscpu64 * $VICERES DTVFlashRevision x64dtv * * (for more, see used widgets) */ /* * This file is part of VICE, the Versatile Commodore Emulator. * See README for copyright notice. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA * 02111-1307 USA. * */ #include "vice.h" #include #include #include #include #include "archdep.h" #include "c128machinetypewidget.h" #include "c64dtvmodel.h" #include "c64model.h" #include "cbm2hardwiredswitcheswidget.h" #include "cbm2memorysizewidget.h" #include "cbm2rammappingwidget.h" #include "ciamodelwidget.h" #include "crtcontrolwidget.h" #include "debug_gtk3.h" #include "kernalrevisionwidget.h" #include "machine.h" #include "machinemodelwidget.h" #include "machinepowerfrequencywidget.h" #include "petiosizewidget.h" #include "petkeyboardtypewidget.h" #include "petmiscwidget.h" #include "petmodel.h" #include "petram9widget.h" #include "petramawidget.h" #include "petramsizewidget.h" #include "petvideosizewidget.h" #include "plus4aciawidget.h" #include "plus4memhacks.h" #include "plus4memoryexpansionwidget.h" #include "plus4memorysizewidget.h" #include "resourcecheckbutton.h" #include "resources.h" #include "sidmodelwidget.h" #include "superpetwidget.h" #include "uistatusbar.h" #include "v364speechwidget.h" #include "vdcmodelwidget.h" #include "vic20memoryexpansionwidget.h" #include "vice_gtk3.h" #include "videomodelwidget.h" #include "settings_model.h" /* * Forward declarations */ static void plus4_debug_dump_resources(void); static void machine_model_handler_pet(int model); /** \brief List of C64DTV revisions * */ static const vice_gtk3_radiogroup_entry_t c64dtv_revisions[] = { { "DTV2", DTVREV_2 }, { "DTV3", DTVREV_3 }, { NULL, -1 } }; /* * Function pointers */ /** \brief Function to call to get the model for the current machine */ static int (*get_model_func)(void); /** \brief Function to call to get the memhack name */ static const char *(*get_memhack_func)(int hack); /** \brief Machine model widget * * This widget controls which machine model is used. * * Changing the machine model means a lot of other resources being changed, and * changing a resource changes the model (or invalidates it). */ static GtkWidget *machine_widget = NULL; /** \brief CIA model widget * * Used by C64, C64SC, SCPU64, C64DTV, C128, CBM5x0, CBM-II, VSID */ static GtkWidget *cia_widget = NULL; /** \brief Video model widget */ static GtkWidget *video_widget = NULL; /** \brief Machine power frequency widget */ static GtkWidget *power_frequency_widget; /** \brief RAM widget */ static GtkWidget *ram_widget = NULL; /** \brief Memhacks widget * * Hardware hacks related to installed memory, x64/x64sc only. */ static GtkWidget *memhack_widget = NULL; /** \brief ACIA widget * * Plus4 only. */ static GtkWidget *acia_widget = NULL; /** \brief V364 speech widget * * Used only in xplus4. */ static GtkWidget *speech_widget = NULL; /** \brief VDC display widget * * Used in x128. */ static GtkWidget *vdc_widget = NULL; /** \brief SID widget */ static GtkWidget *sid_widget = NULL; /** \brief KERNAL widget */ static GtkWidget *kernal_widget = NULL; /** \brief PET video widget */ static GtkWidget *pet_video_size_widget = NULL; /** \brief PET keyboard widget */ static GtkWidget *pet_keyboard_widget = NULL; /** \brief PET miscellaneous settings widget */ static GtkWidget *pet_misc_widget = NULL; /** \brief PET I/O size widget */ static GtkWidget *pet_io_widget = NULL; /** \brief PET RAM9 ($9000-$9fff) widget */ static GtkWidget *pet_ram9_widget = NULL; /** \brief PET RAMA ($a000-$afff) widget */ static GtkWidget *pet_rama_widget = NULL; /** \brief C64 DTV revision widget */ static GtkWidget *c64dtv_rev_widget = NULL; /** \brief C64 DTV Hummer ADC widget */ static GtkWidget *c64dtv_hummer_adc_widget = NULL; /** \brief Reset with IEC checkbox */ static GtkWidget *reset_with_iec_widget = NULL; /** \brief C64 "discrete glue logic" radio button */ static GtkWidget *c64_discrete_radio = NULL; /** \brief C64 "custom glue logic" radio button */ static GtkWidget *c64_custom_radio = NULL; /** \brief Current value of MachineVideoStandard resource * * Is set in the constructor and checked and updated in update_crt_controls() */ static int mvs_current = 0; /** \brief Update CRT controls * * Checks old and new values for the "MachineVideoStandard" resource and if the * values switched from PAL to NTSC or vice versa the status bar CRT widgets * are recreated. */ static void update_crt_controls(void) { int mvs_new = 0; bool pal_cur; bool pal_new; resources_get_int("MachineVideoStandard", &mvs_new); debug_gtk3("called: machine sync was %d, is now %d\n", mvs_current, mvs_new); pal_cur = (mvs_current == MACHINE_SYNC_PAL || mvs_current == MACHINE_SYNC_PALN); pal_new = (mvs_new == MACHINE_SYNC_PAL || mvs_new == MACHINE_SYNC_PALN); if (pal_cur != pal_new) { debug_gtk3("recreating CRT controls"); ui_statusbar_recreate_crt_controls(); } mvs_current = mvs_new; } /** \brief Function called video model changes * * \param[in] model new videochip model */ static void video_model_callback(int model) { if (get_model_func != NULL) { machine_model_widget_update(machine_widget, false); if (machine_class == VICE_MACHINE_PLUS4) { plus4_debug_dump_resources(); } update_crt_controls(); } } /* {{{ C128 glue logic * * x128-specific callbacks */ /** \brief Function called on VDC revision changes * * \param[in] revision new VDC revision (unused) */ static void vdc_revision_callback(int revision) { if (get_model_func != NULL) { machine_model_widget_update(machine_widget, false); } } /** \brief Function called on VDC RAM changes * * \param[in] state new VDC RAM state (unused) */ static void vdc_ram_callback(int state) { if (get_model_func != NULL) { machine_model_widget_update(machine_widget, false); } } /* }}} */ /** \brief Function called on SID model changes * * \param[in] model new SID model */ static void sid_model_callback(int model) { if (get_model_func != NULL) { machine_model_widget_update(machine_widget, false); } } /** \brief Custom callback for the Kernal Revision widget * * Triggers an update of the 'machine model' widget when a different kernal rev * has been selected. Only valid for x64/x64sc as far as I know. * * \param[in] rev new KERNAL revision */ static void kernal_revision_callback(int rev) { machine_model_widget_update(machine_widget, false); } /** \brief Function called on IEC checkbox toggles * * \param[in] widget IEC widget (unused) * \param[in] data extra event data (unused) */ static void iec_callback(GtkWidget *widget, gpointer data) { machine_model_widget_update(machine_widget, false); } /** \brief Callback for CIA model changes * * \param[in] cia_num CIA number (1 or 2) * \param[in] cia_model CIA model ID */ static void cia_model_callback(int cia_num, int cia_model) { if (get_model_func != NULL) { machine_model_widget_update(machine_widget, false); } } /** \brief Callback for machine power frequency changes * * \param[in] self radio group with the frequency radio buttons (ignored) * \param[in] frequency new frequency of the "MachinePowerFrequency" resource (ignored) */ static void power_frequency_callback(GtkWidget *self, int frequency) { debug_gtk3("called with frequency %d", frequency); if (get_model_func != NULL) { machine_model_widget_update(machine_widget, false); } } /* {{{ PET glue logic */ /** \brief Callback for PET RAM size changes * * \param[in] size RAM size in KiB (unused) */ static void pet_ram_size_callback(int size) { if (get_model_func != NULL) { /* resources may have changed; sync widgets */ machine_model_widget_update(machine_widget, true); } } /** \brief Function called on PET I/O size changes * * \param[in] size new I/O size (unused) */ static void pet_video_size_callback(int size) { if (get_model_func != NULL) { /* resources may have changed; sync widgets */ machine_model_widget_update(machine_widget, true); } } /** \brief Function called on PET keyboard type changes * * \param[in] type new keyboard type (unused) */ static void pet_keyboard_type_callback(int type) { if (get_model_func != NULL) { /* resources may have changed; sync widgets */ machine_model_widget_update(machine_widget, true); } } /** \brief Function called on PET CRTC changes * * \param[in] state new CRTC state (unused) */ static void pet_crtc_callback(int state) { if (get_model_func != NULL) { /* resources may have changed; sync widgets */ machine_model_widget_update(machine_widget, true); } } /** \brief Function called on PET blank-on-eoi changes * * \param[in] state new blank-on-eoi state (unused) */ static void pet_blank_callback(int state) { if (get_model_func != NULL) { /* resources may have changed; sync widgets */ machine_model_widget_update(machine_widget, true); } } /** \brief Function called on PET screen-mirrors-like-2001 changes * * \param[in] state new blank-on-eoi state (unused) */ static void pet_screen2001_callback(int state) { if (get_model_func != NULL) { /* resources may have changed; sync widgets */ machine_model_widget_update(machine_widget, true); } } /** \brief Callback for SuperPET I/O changes * * \param[in] state enabled */ static void superpet_enable_callback(int state) { if (get_model_func != NULL) { /* resources may have changed; sync widgets */ machine_model_widget_update(machine_widget, true); } } /** \brief Function called on PET I/O changes * * \param[in] state new I/O state (unused) */ static void pet_io_callback(int state) { if (get_model_func != NULL) { /* resources may have changed; sync widgets */ machine_model_widget_update(machine_widget, true); } } /** \brief Function called on PET RAM9 changes * * \param[in] state new RAM9 state (unused) */ static void pet_ram9_callback(int state) { if (get_model_func != NULL) { /* resources may have changed; sync widgets */ machine_model_widget_update(machine_widget, true); } } /** \brief Function called on PET RAMA changes * * \param[in] state new RAMA state (unused) */ static void pet_rama_callback(int state) { if (get_model_func != NULL) { /* resources may have changed; sync widgets */ machine_model_widget_update(machine_widget, true); } } /* }}} */ /* {{{ Plus4 glue logic and helpers */ /** \brief Debug hook: dump Plus4-related resources on stdoud */ static void plus4_debug_dump_resources(void) { #ifdef HAVE_DEBUG_GTK3UI int model = -1; int video = 0; int ram = 0; int hack = -1; const char *rom = NULL; const char *vidmodes[] = { "UNKNOWN", "PAL", "NTSC" }; /* get model */ if (get_model_func != NULL) { model = get_model_func(); } /* get TED PAL/NTSC mode */ if (resources_get_int("MachineVideoStandard", &video) < 0) { video = 0; } /* get RAM size */ resources_get_int("RamSize", &ram); /* get memory exp hack */ resources_get_int("MemoryHack", &hack); g_print("Plus4 resources dump:\n"); g_print(" get_model_func() : %d\n", model); g_print(" MachineVideoStandard: %d (%s)\n", video, vidmodes[video]); g_print(" RAM size : %dKiB\n", ram); g_print(" MemoryHack : %d (%s)\n", hack, get_memhack_func != NULL ? get_memhack_func(hack) : "get_memhack_func not set"); /* dump active ROMs */ resources_get_string("KernalName", &rom); g_print(" KernalName : %s\n", rom); resources_get_string("BasicName", &rom); g_print(" BasicName : %s\n", rom); resources_get_string("FunctionLoWName", &rom); g_print(" FunctionLoWName : %s\n", rom); resources_get_string("FunctionHighName", &rom); g_print(" FunctionHighName: : %s\n", rom); resources_get_string("c1loName", &rom); g_print(" c1loName : %s\n", rom); resources_get_string("c1hiName", &rom); g_print(" c1hiName : %s\n", rom); resources_get_string("c2loName", &rom); g_print(" c2loName : %s\n", rom); resources_get_string("c2hiName", &rom); g_print(" c2hiName : %s\n", rom); #endif } /** \brief Extra calback for the Plus4 memory size widget * * Triggered when the widget changes value. * * \param[in,out] widget plus4 ram size widget * \param[in] value new size in KiB */ static void plus4_mem_size_callback(GtkWidget *widget, int value) { int size = 0; resources_get_int("RamSize", &size); #if 0 debug_gtk3("Got new value: %dKiB, RamSize = %d", value, size); debug_gtk3("Calling plus4_memory_expansion_widget_sync(): "); #endif plus4_memory_expansion_widget_sync(); machine_model_widget_update(machine_widget, false); plus4_debug_dump_resources(); } /** \brief Extra calback for the Plus4 memory expansion hack widget * * Triggered when the widget changes value. * * \param[in,out] widget plus4 memory expansion hack widget * \param[in] value new size in KiB */ static void plus4_mem_hack_callback(GtkWidget *widget, int value) { int size = 0; resources_get_int("RamSize", &size); plus4_memory_size_widget_sync(); gtk_widget_set_sensitive(ram_widget, value == MEMORY_HACK_NONE); plus4_memory_size_widget_sync(); machine_model_widget_update(machine_widget, false); plus4_debug_dump_resources(); } /** \brief Callback to update the Plus4 model widget on ACIA widget change * * \param[in] widget ACIA widget * \param[in] value new value */ static void plus4_acia_widget_callback(GtkWidget *widget, int value) { machine_model_widget_update(machine_widget, false); } /** \brief Callback to update the Plus4 model widget on v364 widget change * * \param[in] widget v364 widget * \param[in] value new value */ static void v364_speech_widget_callback(GtkWidget *widget, int value) { machine_model_widget_update(machine_widget, false); } /* }}} */ /* * C64(sc) model change handling */ static void c64_misc_widget_sync(void); /** \brief Callback triggered on changing machine model * * \param[in] model machine model */ static void machine_model_handler_c64(int model) { GtkWidget *sid_group; /* synchronize video chip widget */ video_model_widget_update(video_widget); /* synchronize SID chip widget */ sid_group = gtk_grid_get_child_at(GTK_GRID(sid_widget), 0, 1); if (sid_group != NULL) { vice_gtk3_resource_radiogroup_sync(sid_group); } /* synchronize CIA widget */ cia_model_widget_sync(cia_widget); /* synchronize kernal-revision widget */ if (machine_class != VICE_MACHINE_SCPU64) { kernal_revision_widget_sync(kernal_widget); } /* synchronize power frequency widget */ if (power_frequency_widget != NULL) { machine_power_frequency_widget_sync(power_frequency_widget); } /* synchronize misc widget */ c64_misc_widget_sync(); } /** \brief Callback triggered on changing machine model * * \param[in] model machine model */ static void machine_model_handler_c128(int model) { GtkWidget *sid_group; #ifdef HAVE_DEBUG_GTK3UI int res_board_type = -1; int res_vdc_revision = -1; int res_vdc_64kb = -1; int res_machine_type = -1; int res_video_standard = -1; int res_cia1 = -1; int res_cia2 = -1; int res_sid = -1; debug_gtk3("Got model change for C128: %d.", model); resources_get_int("BoardType", &res_board_type); resources_get_int("VDCRevision", &res_vdc_revision); resources_get_int("VDC64KB", &res_vdc_64kb); resources_get_int("MachineType", &res_machine_type); resources_get_int("MachineVideoStandard", &res_video_standard); resources_get_int("CIA1Model", &res_cia1); resources_get_int("CIA2Model", &res_cia2); resources_get_int("SIDModel", &res_sid); printf("=== %s ===\n", __func__); printf(" BoardType : %d\n", res_board_type); printf(" VDCRevision : %d\n", res_vdc_revision); printf(" VDC64KB : %d\n", res_vdc_64kb); printf(" MachineType : %d\n", res_machine_type); printf(" MachineVideoStandard: : %d\n", res_video_standard); printf(" CIA1 : %d\n", res_cia1); printf(" CIA2 : %d\n", res_cia2); printf(" SIDModel : %d\n", res_sid); #endif /* sync video chip (VICIIe) widget */ video_model_widget_update(video_widget); /* sync VDC widget */ vdc_model_widget_update(vdc_widget); /* sync SID chip widget */ sid_group = gtk_grid_get_child_at(GTK_GRID(sid_widget), 0, 1); if (sid_group != NULL) { vice_gtk3_resource_radiogroup_sync(sid_group); } /* synchronize CIA widget */ cia_model_widget_sync(cia_widget); /* synchronize machine power frequency widget */ machine_power_frequency_widget_sync(power_frequency_widget); } /* * C64DTV widget glue logic */ /** \brief Callback for the DTV revision * * Calls model widget update * * \param[in] widget radio button triggering the callback (unused) * \param[in] revision new DTV revision (unused) */ static void dtv_revision_callback(GtkWidget *widget, int revision) { if (get_model_func != NULL) { machine_model_widget_update(machine_widget, false); } } /** \brief Callback for the DTV VIC-II model (sync factor) * * Calls model widget update * * \param[in] model new VIC-II model (unused) */ static void dtv_video_callback(int model) { machine_model_widget_update(machine_widget, false); } /** \brief Sync "Hummer ADC" widget with the associated resource * */ static void c64dtv_hummer_adc_sync(void) { int hummer_adc = 0; resources_get_int("HummerAdc", &hummer_adc); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(c64dtv_hummer_adc_widget), (gboolean)hummer_adc); } /** \brief Update DTV widget on 'Hummer ADC' toggle * * \param[in] widget check button * \param[in] value new value (ignored) */ static void c64dtv_hummer_adc_callback(GtkWidget *widget, gboolean value) { machine_model_widget_update(machine_widget, false); } /** \brief Callback for DTV machine model changes * * Updates the DTV revision and VIC-II model widgets. * * \param[in] model DTV model */ static void machine_model_handler_c64dtv(int model) { GtkWidget *group; int rev; switch (model) { case DTVMODEL_V2_PAL: /* fall through */ case DTVMODEL_V2_NTSC: rev = DTVREV_2; break; case DTVMODEL_V3_PAL: /* fall through */ case DTVMODEL_V3_NTSC: /* fall through */ case DTVMODEL_HUMMER_PAL: case DTVMODEL_HUMMER_NTSC: rev = DTVREV_3; break; default: rev = -1; break; } /* update revision widget */ group = gtk_grid_get_child_at(GTK_GRID(c64dtv_rev_widget), 0, 1); if (group != NULL && GTK_IS_GRID(group)) { vice_gtk3_resource_radiogroup_set(group, rev); } /* update VIC-II model widget */ video_model_widget_update(video_widget); /* update Hummer ADC widget */ c64dtv_hummer_adc_sync(); } /* * VIC-20 glue logic */ /** \brief Callback for the VIC-2- VIC model (sync factor) * * Calls model widget update * * \param[in] model new VIC model */ static void vic20_video_callback(int model) { machine_model_widget_update(machine_widget, false); } /** \brief Callback for VIC-20 machine model changes * * \param[in] model VIC-20 model */ static void machine_model_handler_vic20(int model) { /* update VIC model widget */ video_model_widget_update(video_widget); /* FIXME: */ /* vic20_memory_expansion_widget_sync(); */ } /* * Plus4 glue logic * * This logic won't appear to work very well due to the Plus4 model depending * on other resources that aren't presented in the model setting widgets, but * in separate widgets/dialogs such as KernalName, ACIA1Enable, Speech, etc. * * For example having the model 'Plus4 PAL' enabled and selecting NTSC won't * select the model 'Plus 4 NTSC', but 'Unknown' due to the NSTC Plus4 using * a different Kernal. */ /** \brief Callback for the Plus4 TED model (sync factor) * * Calls model widget update * * \param[in] model new TED model */ static void plus4_video_callback(int model) { machine_model_widget_update(machine_widget, false); plus4_debug_dump_resources(); } /** \brief Handler for the model change for Plus4 * * \param[in] model new model (unused, it seems) */ static void machine_model_handler_plus4(int model) { video_model_widget_update(video_widget); plus4_memory_size_widget_sync(); plus4_acia_widget_sync(); v364_speech_widget_sync(); plus4_debug_dump_resources(); } /* * CBM-II glue logic */ /** \brief Callback for the CBM-II 5x0 VIC-II model (sync factor) * * Calls model widget update. * * \param[in] model new VIC-II model */ static void cbm5x0_video_callback(int model) { machine_model_widget_update(machine_widget, false); } /** \brief Callback for the CBM-II 6x0/7x0 CRTC model (sync factor) * * Calls model widget update. * * \param[in] model new VIC-II model */ static void cbm2_video_callback(int model) { machine_model_widget_update(machine_widget, false); } /** \brief Callback for the CBM-II 6x0/7x0 ModelLine switches * * Calls model widget update. * * \param[in] widget switches widget (unused) * \param[in] model_line new mode line value (unused) */ static void cbm2_switches_callback(GtkWidget *widget, int model_line) { machine_model_widget_update(machine_widget, false); } /** \brief Callback for CBM-II 6x0/7x0 memory size changes * * Calls model widget update. * * \param[in] widget memory size widget (unused) * \param[in] size new memory size (unused) */ static void cbm2_memory_size_callback(GtkWidget *widget, int size) { machine_model_widget_update(machine_widget, false); } /** \brief Callback for CBM 5x0 model changes * * \param[in] model new model */ static void machine_model_handler_cbm5x0(int model) { video_model_widget_update(video_widget); cbm2_memory_size_widget_update(ram_widget); /* synchronize machine power frequency widget */ machine_power_frequency_widget_sync(power_frequency_widget); } /** \brief Callback for CBM 6x0/7x0 model changes * * \param[in] model new model */ static void machine_model_handler_cbm6x0(int model) { video_model_widget_update(video_widget); cbm2_memory_size_widget_update(ram_widget); /* synchronize machine power frequency widget */ machine_power_frequency_widget_sync(power_frequency_widget); } /** \brief Set sensitivity of PET Ram9 and RamA widgets * * Only the 8296 memory mapping has the Ram9 and RamA resources. * Use RamSize as a proxy to determine this. */ static void pet_set_ram9a_sensitivity(void) { int ramSize; gboolean model_is_8296; resources_get_int("RamSize", &ramSize); model_is_8296 = (ramSize == 128); gtk_widget_set_sensitive(pet_ram9_widget, model_is_8296); gtk_widget_set_sensitive(pet_rama_widget, model_is_8296); } /** \brief Callback for PET model changes. * Also called if the model doesn't apparently change; * one resource change may have triggered another so all widgets must * be synced. * * \param[in] model new model */ static void machine_model_handler_pet(int model) { pet_ram_size_widget_sync(ram_widget); pet_video_size_widget_sync(pet_video_size_widget); pet_keyboard_type_widget_sync(pet_keyboard_widget); pet_misc_widget_sync(pet_misc_widget); pet_io_size_widget_sync(pet_io_widget); pet_ram9_widget_sync(pet_ram9_widget); pet_rama_widget_sync(pet_rama_widget); pet_superpet_enable_widget_sync(); pet_set_ram9a_sensitivity(); } /** \brief Generic callback for machine model changes * * \param[in] model */ static void machine_model_callback(int model) { switch (machine_class) { case VICE_MACHINE_C64: /* fall through */ case VICE_MACHINE_C64SC: /* fall through */ case VICE_MACHINE_SCPU64: machine_model_handler_c64(model); break; case VICE_MACHINE_C64DTV: machine_model_handler_c64dtv(model); break; case VICE_MACHINE_VIC20: machine_model_handler_vic20(model); break; case VICE_MACHINE_PLUS4: machine_model_handler_plus4(model); break; case VICE_MACHINE_CBM5x0: machine_model_handler_cbm5x0(model); break; case VICE_MACHINE_CBM6x0: machine_model_handler_cbm6x0(model); break; case VICE_MACHINE_PET: machine_model_handler_pet(model); break; case VICE_MACHINE_C128: machine_model_handler_c128(model); break; default: debug_gtk3("unsupported machine_class %d.", machine_class); return; } update_crt_controls(); } /** \brief Handler for the 'toggled' event of the C64 "Glue Logic" radio buttons * * \param[in] widget radio button triggering the event * \param[in] user_data glue value (int) */ static void on_c64_glue_toggled(GtkWidget *widget, gpointer user_data) { int glue = GPOINTER_TO_INT(user_data); if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) { resources_set_int("GlueLogic", glue); machine_model_widget_update(machine_widget, false); } } /** \brief Sync "Reset-to-IEC" widget with the associated resource * */ static void c64_reset_with_iec_sync(void) { int iecreset = 0; resources_get_int("IECReset", &iecreset); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(reset_with_iec_widget), iecreset); } /** \brief Create widget to toggle "Reset-to-IEC" * * \return GtkGrid */ static GtkWidget *create_reset_with_iec_widget(void) { reset_with_iec_widget = vice_gtk3_resource_check_button_new("IECReset", "Reset goes to IEC"); g_signal_connect(GTK_WIDGET(reset_with_iec_widget), "toggled", G_CALLBACK(iec_callback), NULL); return reset_with_iec_widget; } /** \brief Create widget to toggle "Go64Mode" * * \return GtkGrid */ static GtkWidget *create_go64_widget(void) { return vice_gtk3_resource_check_button_new("Go64Mode", "Always switch to C64 mode on reset"); } /** \brief Sync "Glue Logic" widget with the associated resource * */ static void c64_glue_widget_sync(void) { int glue; GtkWidget *radio; resources_get_int("GlueLogic", &glue); radio = (glue == 0) ? c64_discrete_radio : c64_custom_radio; if (radio) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio), TRUE); } } /** \brief Create left-aligned label with Pango markup * * \param[in] text text for label using Pango markup * * \return GtkLabel */ static GtkWidget *label_helper(const char *text) { GtkWidget *label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label), text); gtk_widget_set_halign(label, GTK_ALIGN_START); return label; } /** \brief Create widget to select C64SC Glue Logic * * \return GtkGrid */ static GtkWidget *create_c64_glue_widget(void) { GtkWidget *grid; GtkWidget *label; GtkWidget *radio; GSList *group = NULL; int glue; resources_get_int("GlueLogic", &glue); grid = gtk_grid_new(); gtk_grid_set_column_spacing(GTK_GRID(grid), 8); label = gtk_label_new("Glue logic"); gtk_widget_set_margin_start(label, 8); gtk_grid_attach(GTK_GRID(grid), label, 0, 0, 1, 1); c64_discrete_radio = gtk_radio_button_new_with_label(group, "Discrete"); c64_custom_radio = gtk_radio_button_new_with_label(group, "Custom IC"); gtk_radio_button_join_group(GTK_RADIO_BUTTON(c64_custom_radio), GTK_RADIO_BUTTON(c64_discrete_radio)); radio = glue == 0 ? c64_discrete_radio : c64_custom_radio; gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio), TRUE); g_signal_connect(c64_discrete_radio, "toggled", G_CALLBACK(on_c64_glue_toggled), GINT_TO_POINTER(0)); g_signal_connect(c64_custom_radio, "toggled", G_CALLBACK(on_c64_glue_toggled), GINT_TO_POINTER(1)); gtk_grid_attach(GTK_GRID(grid), c64_discrete_radio, 1, 0, 1, 1); gtk_grid_attach(GTK_GRID(grid), c64_custom_radio, 1, 1, 1, 1); gtk_widget_show_all(grid); return grid; } /** \brief Create 'misc' widget for C64/C64SC/SCPU64 * * \return GtkGrid */ static GtkWidget *create_c64_misc_widget(void) { GtkWidget *grid; GtkWidget *label; GtkWidget *iec_widget; GtkWidget *glue_widget = NULL; grid = gtk_grid_new(); gtk_grid_set_row_spacing(GTK_GRID(grid), 8); label = label_helper("Miscellaneous"); gtk_grid_attach(GTK_GRID(grid), label, 0, 0, 1, 1); iec_widget = create_reset_with_iec_widget(); gtk_grid_attach(GTK_GRID(grid), iec_widget, 0, 1, 1, 1); /* * GlueLogic seems to cause timing issues when set to 'custom' on x64, so * don't show the widget for x64 until it is fixed (if ever) */ if (machine_class == VICE_MACHINE_C64SC || machine_class == VICE_MACHINE_SCPU64) { glue_widget = create_c64_glue_widget(); gtk_grid_attach(GTK_GRID(grid), glue_widget, 0, 2, 1, 1); } gtk_widget_show_all(grid); return grid; } /** \brief Synchronize Glue logic and IEC widget with their resources */ static void c64_misc_widget_sync(void) { c64_glue_widget_sync(); c64_reset_with_iec_sync(); } /** \brief Create 'misc' widget for C128 * * \return GtkGrid */ static GtkWidget *create_c128_misc_widget(void) { GtkWidget *grid; GtkWidget *label; GtkWidget *go64_widget; /* no row spacing, we use a margin since more widgets might be added in * the future for which we don't want extra row spacing */ grid = gtk_grid_new(); label = label_helper("Miscellaneous"); /* we do the extra spacing here */ gtk_widget_set_margin_bottom(label, 8); go64_widget = create_go64_widget(); gtk_grid_attach(GTK_GRID(grid), label, 0, 0, 1, 1); gtk_grid_attach(GTK_GRID(grid), go64_widget, 0, 1, 1, 1); gtk_widget_show_all(grid); return grid; } /** \brief Create widget to select DTV revision * * Creates a grid with a label and a vice_gtk3_resource_radiogroup widget. * * \return GtkGrid */ static GtkWidget *create_c64dtv_revision_widget(void) { GtkWidget *grid; GtkWidget *group; GtkWidget *label; grid = gtk_grid_new(); gtk_grid_set_row_spacing(GTK_GRID(grid), 8); label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label), "DTV Revision"); gtk_widget_set_halign(label, GTK_ALIGN_START); group = vice_gtk3_resource_radiogroup_new("DtvRevision", c64dtv_revisions, GTK_ORIENTATION_VERTICAL); vice_gtk3_resource_radiogroup_add_callback(group, dtv_revision_callback); gtk_grid_attach(GTK_GRID(grid), label, 0, 0, 1, 1); gtk_grid_attach(GTK_GRID(grid), group, 0, 1, 1, 1); gtk_widget_show_all(grid); return grid; } /** \brief Create widget layout for C64/C64SC * * \param[in,out] grid GtkGrid to use for layout * * \return \a grid */ static GtkWidget *create_c64_layout(GtkWidget *grid) { GtkWidget *misc_widget; /* add machine widget */ gtk_grid_attach(GTK_GRID(grid), machine_widget, 0, 0, 1, 2); /* VIC-II model widget */ video_widget = video_model_widget_create(machine_widget); video_model_widget_set_callback(video_widget, video_model_callback); gtk_grid_attach(GTK_GRID(grid), video_widget, 1, 0, 1, 1); /* SID widget */ sid_widget = sid_model_widget_create(machine_widget); sid_model_widget_set_callback(sid_widget, sid_model_callback); gtk_grid_attach(GTK_GRID(grid), sid_widget, 1, 1, 1, 1); /* CIA1 & CIA2 widget */ cia_widget = cia_model_widget_create(2); cia_model_widget_set_callback(cia_widget, cia_model_callback); gtk_widget_set_margin_top(cia_widget, 16); gtk_grid_attach(GTK_GRID(grid), cia_widget, 0, 2, 2, 1); /* Kernal revision widget */ if (machine_class != VICE_MACHINE_SCPU64) { kernal_widget = kernal_revision_widget_create(); gtk_grid_attach(GTK_GRID(grid), kernal_widget, 2, 0, 1, 1); /* add custom callback */ kernal_revision_widget_add_callback(kernal_revision_callback); } /* machine power frequency */ power_frequency_widget = machine_power_frequency_widget_new(); machine_power_frequency_widget_add_callback(power_frequency_widget, power_frequency_callback); if (machine_class == VICE_MACHINE_SCPU64) { gtk_grid_attach(GTK_GRID(grid), power_frequency_widget, 2, 0, 1, 1); } else { gtk_grid_attach(GTK_GRID(grid), power_frequency_widget, 2, 1, 1, 1); } /* C64 misc. model settings */ misc_widget = create_c64_misc_widget(); if (machine_class == VICE_MACHINE_SCPU64) { gtk_grid_attach(GTK_GRID(grid), misc_widget, 2, 1, 1, 1); } else { gtk_grid_attach(GTK_GRID(grid), misc_widget, 2, 2, 1, 1); } return grid; } /** \brief Create widget layout for C128 * * \param[in,out] grid GtkGrid to use for layout * * \return \a grid */ static GtkWidget *create_c128_layout(GtkWidget *grid) { GtkWidget *machine_type_widget; GtkWidget *misc_widget; /* wrap machine model and machine type widgets in a single widget */ /* machine_wrapper = vice_gtk3_grid_new_spaced(0, 16); */ /* add machine model widget (2 rows) */ gtk_grid_attach(GTK_GRID(grid), machine_widget, 0, 0, 1, 2); /* add machine type widget (2 rows) */ machine_type_widget = c128_machine_type_widget_create(); gtk_widget_set_margin_top(machine_type_widget, 16); gtk_grid_attach(GTK_GRID(grid), machine_type_widget, 0, 2, 1, 2); /* VIC-II model widget */ video_widget = video_model_widget_create(machine_widget); video_model_widget_set_callback(video_widget, video_model_callback); gtk_grid_attach(GTK_GRID(grid), video_widget, 1, 0, 1, 1); /* SID widget */ sid_widget = sid_model_widget_create(machine_widget); sid_model_widget_set_callback(sid_widget, sid_model_callback); gtk_grid_attach(GTK_GRID(grid), sid_widget, 1, 1, 1, 1); /* VDC model widget */ vdc_widget = vdc_model_widget_create(); vdc_model_widget_set_revision_callback(vdc_revision_callback); vdc_model_widget_set_ram_callback(vdc_ram_callback); gtk_grid_attach(GTK_GRID(grid), vdc_widget, 2, 0, 1, 2); /* CIA1 & CIA2 widget */ cia_widget = cia_model_widget_create(2); gtk_widget_set_margin_top(cia_widget, 16); cia_model_widget_set_callback(cia_widget, cia_model_callback); gtk_grid_attach(GTK_GRID(grid), cia_widget, 1, 2, 2, 1); /* machine power frequency */ power_frequency_widget = machine_power_frequency_widget_new(); machine_power_frequency_widget_add_callback(power_frequency_widget, power_frequency_callback); gtk_grid_attach(GTK_GRID(grid), power_frequency_widget, 1, 3, 2, 1); /* Misc widget */ misc_widget = create_c128_misc_widget(); gtk_grid_attach(GTK_GRID(grid), misc_widget, 1, 4, 2, 1); return grid; } /** \brief Create C64DTV model settings widget layout * * \param[in] grid GtkGrid to attach widgets to * * \return \a grid */ static GtkWidget *create_c64dtv_layout(GtkWidget *grid) { GtkWidget *luma_widget; /** add machine widget */ gtk_grid_attach(GTK_GRID(grid), machine_widget, 0, 0, 1, 2); /* add video widget */ video_widget = video_model_widget_create(machine_widget); video_model_widget_set_callback(video_widget, dtv_video_callback); gtk_grid_attach(GTK_GRID(grid), video_widget, 1, 0, 1, 1); /* create revision widget */ c64dtv_rev_widget = create_c64dtv_revision_widget(); gtk_widget_set_margin_top(c64dtv_rev_widget, 16); gtk_grid_attach(GTK_GRID(grid), c64dtv_rev_widget, 1, 1, 1, 1); /* SID widget */ sid_widget = sid_model_widget_create(machine_widget); sid_model_widget_set_callback(sid_widget, sid_model_callback); gtk_widget_set_margin_top(sid_widget, 16); gtk_grid_attach(GTK_GRID(grid), sid_widget, 0, 2, 1, 1); /* Luma fix widget */ luma_widget = vice_gtk3_resource_check_button_new("VICIINewLuminances", "Enable LumaFix (use new VICII luminances)"); gtk_widget_set_margin_top(luma_widget, 16); gtk_grid_attach(GTK_GRID(grid), luma_widget, 0, 3, 2, 1); /* Hummer ADC widget */ c64dtv_hummer_adc_widget = vice_gtk3_resource_check_button_new("HummerADC", "Enable Hummer ADC"); vice_gtk3_resource_check_button_add_callback(c64dtv_hummer_adc_widget, c64dtv_hummer_adc_callback); gtk_grid_attach(GTK_GRID(grid), c64dtv_hummer_adc_widget, 0, 4, 2, 1); return grid; } /** \brief Create VIC20 model settings widget layout * * \param[in] grid GtkGrid to attach widgets to * * \return \a grid */ static GtkWidget *create_vic20_layout(GtkWidget *grid) { /* add machine widget */ gtk_grid_attach(GTK_GRID(grid), machine_widget, 0, 0, 1, 1); /* VIC model widget */ video_widget = video_model_widget_create(machine_widget); video_model_widget_set_callback(video_widget, vic20_video_callback); gtk_grid_attach(GTK_GRID(grid), video_widget, 0, 1, 1, 1); ram_widget = vic20_memory_expansion_widget_create(); gtk_grid_attach(GTK_GRID(grid), ram_widget, 1, 0, 1, 2); gtk_widget_show_all(grid); return grid; } /** \brief Create Plus4 model settings widget layout * * \param[in] grid GtkGrid to attach widgets to * * \return \a grid */ static GtkWidget *create_plus4_layout(GtkWidget *grid) { GtkWidget *checkboxes; int hack = 0; /* add machine widget */ gtk_grid_attach(GTK_GRID(grid), machine_widget, 0, 0, 1, 1); /* Plus4 video widget */ video_widget = video_model_widget_create(machine_widget); video_model_widget_set_callback(video_widget, plus4_video_callback); gtk_widget_set_margin_top(video_widget, 16); gtk_grid_attach(GTK_GRID(grid), video_widget, 0, 1, 1, 1); /* memory size */ ram_widget = plus4_memory_size_widget_create(); plus4_memory_size_widget_add_callback(plus4_mem_size_callback); gtk_grid_attach(GTK_GRID(grid), ram_widget, 1, 0, 1, 1); /* memory expansion hacks */ memhack_widget = plus4_memory_expansion_widget_create(); plus4_memory_expansion_widget_add_callback(plus4_mem_hack_callback); gtk_grid_attach(GTK_GRID(grid), memhack_widget, 2, 0, 1, 1); resources_get_int("MemoryHack", &hack); gtk_widget_set_sensitive(ram_widget, hack == MEMORY_HACK_NONE); /* Wrap the check boxes in a grid to get them vertically aligned properly. * If we make the TED widget span two rows and add the check boxes next to * it, the check boxes "spread out" */ checkboxes = gtk_grid_new(); gtk_widget_set_margin_top(checkboxes, 16); /* ACIA widget */ acia_widget = plus4_acia_widget_create(); plus4_acia_widget_add_callback(plus4_acia_widget_callback); gtk_grid_attach(GTK_GRID(checkboxes), acia_widget, 0, 0, 1, 1); /* V364 speech widget */ speech_widget = v364_speech_widget_create(); v364_speech_widget_add_callback(v364_speech_widget_callback); gtk_grid_attach(GTK_GRID(checkboxes), speech_widget, 0, 1, 1, 1); gtk_grid_attach(GTK_GRID(grid), checkboxes, 1, 1, 2, 1); gtk_widget_show_all(grid); return grid; } /** \brief Creat PET layout * * Create PET layout using a GtkStack and GtkStackSwitcher to reduce space. * * \param[in,out] grid main grid to add widgets to * * \return \a grid */ static GtkWidget *create_pet_layout(GtkWidget *grid) { GtkWidget *stack; GtkWidget *switcher; GtkWidget *pet_grid; GtkWidget *superpet_grid; GtkWidget *ramrom_grid; pet_grid = gtk_grid_new(); /* PET model list */ gtk_grid_attach(GTK_GRID(pet_grid), machine_widget, 0, 0, 1, 3); pet_keyboard_widget = pet_keyboard_type_widget_create(); pet_keyboard_type_widget_set_callback(pet_keyboard_widget, pet_keyboard_type_callback); gtk_grid_attach(GTK_GRID(pet_grid), pet_keyboard_widget, 1, 0, 1, 1); pet_video_size_widget = pet_video_size_widget_create(); pet_video_size_widget_set_callback(pet_video_size_callback); gtk_widget_set_margin_top(pet_video_size_widget, 16); gtk_grid_attach(GTK_GRID(pet_grid), pet_video_size_widget, 1, 1, 1, 1); ram_widget = pet_ram_size_widget_create(); pet_ram_size_widget_set_callback(ram_widget, pet_ram_size_callback); gtk_grid_attach(GTK_GRID(pet_grid), ram_widget, 2, 0, 1, 1); pet_io_widget = pet_io_size_widget_create(); pet_io_size_widget_set_callback(pet_io_callback); gtk_widget_set_margin_top(pet_io_widget, 16); gtk_grid_attach(GTK_GRID(pet_grid), pet_io_widget, 2, 1, 1, 1); /* wrap RAM/ROM 9XXX/AXXX in a grid */ ramrom_grid = gtk_grid_new(); pet_ram9_widget = pet_ram9_widget_create(); pet_ram9_widget_set_callback(pet_ram9_callback); gtk_grid_attach(GTK_GRID(ramrom_grid), pet_ram9_widget, 0, 0, 1, 1); pet_rama_widget = pet_rama_widget_create(); pet_rama_widget_set_callback(pet_rama_callback); pet_set_ram9a_sensitivity(); gtk_grid_attach(GTK_GRID(ramrom_grid), pet_rama_widget, 0, 1, 1, 1); gtk_grid_attach(GTK_GRID(pet_grid), ramrom_grid, 3, 0, 1, 1); pet_misc_widget = pet_misc_widget_create(); pet_misc_widget_set_crtc_callback(pet_crtc_callback); pet_misc_widget_set_blank_callback(pet_blank_callback); pet_misc_widget_set_screen2001_callback(pet_screen2001_callback); gtk_widget_set_margin_top(pet_misc_widget, 16); gtk_grid_attach(GTK_GRID(pet_grid), pet_misc_widget, 1, 2, 3, 1); /* SuperPET widgets */ superpet_grid = superpet_widget_create(); pet_superpet_widget_set_superpet_enable_callback(superpet_enable_callback); stack = gtk_stack_new(); gtk_stack_add_titled(GTK_STACK(stack), pet_grid, "PET", "PET"); gtk_stack_add_titled(GTK_STACK(stack), superpet_grid, "SuperPET", "SuperPET"); gtk_stack_set_transition_type(GTK_STACK(stack), GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT); gtk_stack_set_transition_duration(GTK_STACK(stack), 500); gtk_stack_set_homogeneous(GTK_STACK(stack), TRUE); switcher = gtk_stack_switcher_new(); gtk_stack_switcher_set_stack(GTK_STACK_SWITCHER(switcher), GTK_STACK(stack)); gtk_widget_set_halign(switcher, GTK_ALIGN_CENTER); gtk_orientable_set_orientation(GTK_ORIENTABLE(switcher), GTK_ORIENTATION_HORIZONTAL); gtk_widget_set_margin_bottom(switcher, 8); gtk_widget_show_all(stack); gtk_widget_show_all(switcher); gtk_stack_set_visible_child_name(GTK_STACK(stack), "PET"); gtk_grid_attach(GTK_GRID(grid), switcher, 0, 0, 1, 1); gtk_grid_attach(GTK_GRID(grid), stack, 0, 1, 1, 1); gtk_widget_show_all(grid); return grid; } /** \brief Create CBM-II/5x0 model settings widget layout * * \param[in] grid GtkGrid to attach widgets to * * \return \a grid */ static GtkWidget *create_cbm5x0_layout(GtkWidget *grid) { GtkWidget *switches_widget; GtkWidget *bank15_widget; /* add machine widget */ gtk_grid_attach(GTK_GRID(grid), machine_widget, 0, 0, 1, 3); /* add video widget */ video_widget = video_model_widget_create(machine_widget); video_model_widget_set_callback(video_widget, cbm5x0_video_callback); gtk_grid_attach(GTK_GRID(grid), video_widget, 1, 0, 1, 1); /* Hardwired I/O port model switches */ switches_widget = cbm2_hardwired_switches_widget_create(); cbm2_hardwired_switches_widget_set_callback(switches_widget, cbm2_switches_callback); gtk_grid_attach(GTK_GRID(grid), switches_widget, 2, 0, 1, 1); /* machine power frequency */ power_frequency_widget = machine_power_frequency_widget_new(); machine_power_frequency_widget_add_callback(power_frequency_widget, power_frequency_callback); gtk_grid_attach(GTK_GRID(grid), power_frequency_widget, 2, 1, 2, 1); /* SID widget */ sid_widget = sid_model_widget_create(machine_widget); sid_model_widget_set_callback(sid_widget, sid_model_callback); gtk_widget_set_margin_top(sid_widget, 16); gtk_grid_attach(GTK_GRID(grid), sid_widget, 1, 1, 1, 1); /* CIA1 widget */ cia_widget = cia_model_widget_create(1); cia_model_widget_set_callback(cia_widget, cia_model_callback); gtk_widget_set_margin_top(cia_widget, 16); gtk_grid_attach(GTK_GRID(grid), cia_widget, 1, 2, 2, 1); /* RAM size widget */ ram_widget = cbm2_memory_size_widget_create(); cbm2_memory_size_widget_set_callback(ram_widget, cbm2_memory_size_callback); gtk_widget_set_margin_top(ram_widget, 16); gtk_grid_attach(GTK_GRID(grid), ram_widget, 0, 3, 1, 1); /* Mapping RAM into bank 15 */ bank15_widget = cbm2_ram_mapping_widget_create(); gtk_widget_set_margin_top(bank15_widget, 16); gtk_grid_attach(GTK_GRID(grid), bank15_widget, 1, 3, 2, 1); gtk_widget_show_all(grid); return grid; } /** \brief Create CBM-II/6x0-7x0 model settings widget layout * * \param[in] grid GtkGrid to attach widgets to * * \return \a grid */ static GtkWidget *create_cbm6x0_layout(GtkWidget *grid) { GtkWidget *switches_widget; GtkWidget *bank15_widget; /* add machine widget */ gtk_grid_attach(GTK_GRID(grid), machine_widget, 0, 0, 1, 3); /* add video widget */ video_widget = video_model_widget_create(machine_widget); video_model_widget_set_callback(video_widget, cbm2_video_callback); gtk_grid_attach(GTK_GRID(grid), video_widget, 1, 0, 1, 1); /* Hardwired I/O port model switches */ switches_widget = cbm2_hardwired_switches_widget_create(); cbm2_hardwired_switches_widget_set_callback(switches_widget, cbm2_switches_callback); gtk_grid_attach(GTK_GRID(grid), switches_widget, 2, 0, 1, 1); /* machine power frequency */ power_frequency_widget = machine_power_frequency_widget_new(); machine_power_frequency_widget_add_callback(power_frequency_widget, power_frequency_callback); gtk_grid_attach(GTK_GRID(grid), power_frequency_widget, 2, 1, 2, 1); /* SID widget */ sid_widget = sid_model_widget_create(machine_widget); sid_model_widget_set_callback(sid_widget, sid_model_callback); gtk_grid_attach(GTK_GRID(grid), sid_widget, 1, 1, 1, 1); /* CIA1 widget */ cia_widget = cia_model_widget_create(1); cia_model_widget_set_callback(cia_widget, cia_model_callback); gtk_grid_attach(GTK_GRID(grid), cia_widget, 1, 2, 2, 1); /* RAM size widget */ ram_widget = cbm2_memory_size_widget_create(); cbm2_memory_size_widget_set_callback(ram_widget, cbm2_memory_size_callback); gtk_widget_set_margin_top(ram_widget, 16); gtk_grid_attach(GTK_GRID(grid), ram_widget, 0, 3, 1, 1); /* Mapping RAM into bank 15 */ bank15_widget = cbm2_ram_mapping_widget_create(); gtk_widget_set_margin_top(bank15_widget, 16); gtk_grid_attach(GTK_GRID(grid), bank15_widget, 1, 3, 2, 1); gtk_widget_show_all(grid); return grid; } /** \brief Create VSID layout * * \param[in,out] grid GtkGrid to use for layout * * \return \a grid */ static GtkWidget *create_vsid_layout(GtkWidget *grid) { /* VIC-II model widget */ video_widget = video_model_widget_create(machine_widget); gtk_grid_attach(GTK_GRID(grid), video_widget, 1, 0, 1, 1); sid_widget = sid_model_widget_create(machine_widget); /*sid_model_widget_set_callback(sid_widget, sid_model_callback);*/ gtk_grid_attach(GTK_GRID(grid), sid_widget, 0, 0, 1, 1); return grid; } /** \brief Create machine-specific layout * * Creates a machine-specific layout, including creating the required widgets * * \return GtkGrid */ static GtkWidget *create_layout(void) { GtkWidget *grid = gtk_grid_new(); gtk_grid_set_column_spacing(GTK_GRID(grid), 16); gtk_grid_set_row_spacing(GTK_GRID(grid), 0); /* Can't add the machine model widget here, since it differs a lot in size * depending on the machine, which may result in odd layouts. So we need * to determine per machine how many grid rows the machine model widget * needs to occupy */ switch (machine_class) { case VICE_MACHINE_C64: /* fall through */ case VICE_MACHINE_C64SC: /* fall through */ case VICE_MACHINE_SCPU64: return create_c64_layout(grid); case VICE_MACHINE_C64DTV: return create_c64dtv_layout(grid); case VICE_MACHINE_C128: return create_c128_layout(grid); case VICE_MACHINE_VIC20: return create_vic20_layout(grid); case VICE_MACHINE_PLUS4: return create_plus4_layout(grid); case VICE_MACHINE_PET: return create_pet_layout(grid); case VICE_MACHINE_CBM5x0: return create_cbm5x0_layout(grid); case VICE_MACHINE_CBM6x0: return create_cbm6x0_layout(grid); case VICE_MACHINE_VSID: return create_vsid_layout(grid); default: /* shouldn't get here */ fprintf(stderr, "Aargs! machine %d does not exist!", machine_class); archdep_vice_exit(1); return NULL; /* unlike with ordinary exit(), GCC doesn't see this will never be reached */ } } /** \brief Create 'Model' widget for the settings UI * * \param[in] parent parent widget * * \return GtkGrid */ GtkWidget *settings_model_widget_create(GtkWidget *parent) { GtkWidget *layout; cia_widget = NULL; kernal_widget = NULL; sid_widget = NULL; vdc_widget = NULL; video_widget = NULL; /* every machine has a machine model widget */ machine_widget = machine_model_widget_create(); /* create machine-specific layout */ layout = create_layout(); /* connect signal handlers */ machine_model_widget_connect_signals(machine_widget); if ((machine_class != VICE_MACHINE_PET)) { /* * PET only has a simple CRTC, so no video widget used * (Is this still valid? I had to remove the cbm2 from this branch) */ video_model_widget_connect_signals(video_widget); } /* add callback */ machine_model_widget_set_callback(machine_model_callback); /* get current video standard */ resources_get_int("MachineVideoStandard", &mvs_current); gtk_widget_show_all(layout); return layout; } /** \brief Set function pointer to function that determines if the model * settings indicate a valid model * * \param[in] func function pointer */ void settings_model_widget_set_model_func(int (*func)(void)) { get_model_func = func; } /** \brief Set function to get a memory hack description * * \param[in] func function to get a string for a memhack ID (int) */ void settings_model_widget_set_memhack_func(const char *(*func)(int)) { get_memhack_func = func; }