562 lines
18 KiB
C
562 lines
18 KiB
C
#include "settings.h"
|
|
|
|
#define get_object(id) gtk_builder_get_object(builder, id)
|
|
#define builder_get(type, id) type(get_object(id))
|
|
|
|
static void print_config_error(GError *error) {
|
|
if (error == NULL) return;
|
|
|
|
if (!g_error_matches(error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_KEY_NOT_FOUND) && !g_error_matches(error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND)) {
|
|
g_warning("Config error: %s", error->message);
|
|
}
|
|
}
|
|
|
|
void _print_config(config_t *config, GLogLevelFlags log_level) {
|
|
#define EXPAND_GROUP(name, members) { \
|
|
g_log(G_LOG_DOMAIN, log_level, "[%s]", #name); \
|
|
struct config_ ## name ## _t *group = &config->name; \
|
|
members \
|
|
}
|
|
|
|
#define EXPAND_GROUP_MEMBER(member, key_type, default_value) \
|
|
g_log(G_LOG_DOMAIN, log_level, "%s="FORMAT_FOR_KEY_TYPE(key_type)"", #member, group->member);
|
|
|
|
EXPAND_CONFIG
|
|
#undef EXPAND_GROUP
|
|
#undef EXPAND_GROUP_MEMBER
|
|
}
|
|
|
|
// Duplicates the input and converts the first character to uppercase
|
|
gchar* ascii_ucfirst(gchar *str) {
|
|
gchar *out = g_strdup(str);
|
|
out[0] = g_ascii_toupper(str[0]);
|
|
|
|
return out;
|
|
}
|
|
|
|
void load_config_from_key_file(config_t *config, GKeyFile *key_file) {
|
|
g_message("Loading config from key file");
|
|
GError *error = NULL;
|
|
|
|
#define EXPAND_GROUP(name_arg, members) { \
|
|
struct config_ ## name_arg ## _t *group = &config->name_arg; \
|
|
g_autofree gchar *group_name = ascii_ucfirst(#name_arg); \
|
|
members \
|
|
}
|
|
|
|
#define EXPAND_GROUP_MEMBER(member, key_type, default_value) \
|
|
group->member = g_key_file_get_##key_type(key_file, group_name, #member, &error); \
|
|
if (error != NULL) { \
|
|
group->member = default_value; \
|
|
print_config_error(error); \
|
|
g_clear_error(&error); \
|
|
}
|
|
|
|
EXPAND_CONFIG
|
|
|
|
if (config->emulation.rewind_duration > 600) {
|
|
g_warning("Setting Emulation.rewind_duration too high might affect performance.");
|
|
}
|
|
|
|
#undef EXPAND_GROUP
|
|
#undef EXPAND_GROUP_MEMBER
|
|
}
|
|
|
|
void print_config(config_t *config) {
|
|
_print_config(config, G_LOG_LEVEL_MESSAGE);
|
|
}
|
|
|
|
void save_config_to_key_file(config_t *config, GKeyFile *key_file) {
|
|
g_message("Saving config to key file");
|
|
GError *error = NULL;
|
|
gchar *group_name;
|
|
|
|
#define EXPAND_GROUP(name_arg, members) { \
|
|
struct config_ ## name_arg ## _t *group = &config->name_arg; \
|
|
g_autofree gchar *group_name = ascii_ucfirst(#name_arg); \
|
|
members \
|
|
}
|
|
|
|
#define EXPAND_GROUP_MEMBER_IF_0(member, key_type, default_value) \
|
|
g_key_file_set_##key_type(key_file, group_name, #member, group->member);
|
|
|
|
#define EXPAND_GROUP_MEMBER_IF_1(member, key_type, default_value) \
|
|
if (group->member != NULL) { \
|
|
g_key_file_set_##key_type(key_file, group_name, #member, group->member); \
|
|
} \
|
|
else if (g_key_file_has_key(key_file, group_name, #member, &error)) { \
|
|
if (error != NULL) { \
|
|
g_warning("%s", error->message); \
|
|
g_clear_error(&error); \
|
|
} \
|
|
g_key_file_remove_key(key_file, group_name, #member, &error); \
|
|
if (error != NULL) { \
|
|
g_warning("%s", error->message); \
|
|
g_clear_error(&error); \
|
|
} \
|
|
}
|
|
|
|
#define EXPAND_GROUP_MEMBER_IF_EVAL(y, member, key_type, default_value) EXPAND_GROUP_MEMBER_IF_ ## y(member, key_type, default_value)
|
|
#define EXPAND_GROUP_MEMBER_IF(member, key_type, is_pointer, default_value) EXPAND_GROUP_MEMBER_IF_EVAL(is_pointer, member, key_type, default_value)
|
|
#define EXPAND_GROUP_MEMBER(member, key_type, default_value) EXPAND_GROUP_MEMBER_IF(member, key_type, GTYPE_IS_POINTER(key_type), default_value)
|
|
|
|
EXPAND_CONFIG
|
|
|
|
#undef EXPAND_GROUP
|
|
#undef EXPAND_GROUP_MEMBER
|
|
#undef EXPAND_GROUP_MEMBER_IF
|
|
#undef EXPAND_GROUP_MEMBER_IF_EVAL
|
|
#undef EXPAND_GROUP_MEMBER_IF_0
|
|
#undef EXPAND_GROUP_MEMBER_IF_1
|
|
}
|
|
|
|
void on_preferences_realize(GtkWidget *w, gpointer builder_ptr) {
|
|
GtkWindow *preferences = GTK_WINDOW(w);
|
|
GtkBuilder *builder = (GtkBuilder *) builder_ptr;
|
|
GApplication *app = G_APPLICATION(gtk_builder_get_application(builder));
|
|
|
|
update_boot_rom_selector(builder);
|
|
|
|
// Hook up the static preferences
|
|
gtk_combo_box_set_active_id(builder_get(GTK_COMBO_BOX, "rewind_duration_selector"), g_strdup_printf("%i", config.emulation.rewind_duration));
|
|
gtk_combo_box_set_active_id(builder_get(GTK_COMBO_BOX, "dmg_revision_selector"), config.emulation.dmg_revision_name);
|
|
gtk_combo_box_set_active_id(builder_get(GTK_COMBO_BOX, "sgb_revision_selector"), config.emulation.sgb_revision_name);
|
|
gtk_combo_box_set_active_id(builder_get(GTK_COMBO_BOX, "cgb_revision_selector"), config.emulation.cgb_revision_name);
|
|
|
|
gtk_combo_box_set_active_id(builder_get(GTK_COMBO_BOX, "shader_selector"), config.video.shader);
|
|
gtk_combo_box_set_active_id(builder_get(GTK_COMBO_BOX, "color_correction_selector"), config.video.color_correction_id);
|
|
gtk_combo_box_set_active_id(builder_get(GTK_COMBO_BOX, "frame_blending_selector"), config.video.frame_blending_mode);
|
|
gtk_combo_box_set_active_id(builder_get(GTK_COMBO_BOX, "display_border_selector"), config.video.display_border_mode);
|
|
gtk_combo_box_set_active_id(builder_get(GTK_COMBO_BOX, "monochrome_palette_selector"), config.video.monochrome_palette_id);
|
|
gtk_toggle_button_set_active(builder_get(GTK_TOGGLE_BUTTON, "integer_scaling_toggle"), config.video.use_integer_scaling);
|
|
gtk_toggle_button_set_active(builder_get(GTK_TOGGLE_BUTTON, "aspect_ratio_toggle"), config.video.keep_aspect_ratio);
|
|
|
|
gtk_combo_box_set_active_id(builder_get(GTK_COMBO_BOX, "highpass_filter_selector"), config.audio.high_pass_filter_id);
|
|
gtk_combo_box_set_active_id(builder_get(GTK_COMBO_BOX, "sample_rate_selector"), g_strdup_printf("%i", config.audio.sample_rate));
|
|
|
|
gtk_toggle_button_set_active(builder_get(GTK_TOGGLE_BUTTON, "analog_speed_controls_toggle"), config.controls.analog_speed_controls);
|
|
gtk_combo_box_set_active_id(builder_get(GTK_COMBO_BOX, "rumble_mode_selector"), config.controls.rumble_mode);
|
|
|
|
#if ! NDEBUG
|
|
gtk_combo_box_set_active_id(builder_get(GTK_COMBO_BOX, "menubar_override_selector"), config.window.menubar_override);
|
|
#else
|
|
if (builder_get(GTK_COMBO_BOX, "menubar_override_selector") != NULL) {
|
|
gtk_widget_destroy(GTK_WIDGET(builder_get(GTK_COMBO_BOX, "menubar_override_selector")));
|
|
gtk_widget_destroy(GTK_WIDGET(builder_get(GTK_COMBO_BOX, "menubar_override_selector_label")));
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void init_settings(GApplication *app, gchar *path, GtkWindow *preferences) {
|
|
free_settings();
|
|
key_file = g_key_file_new();
|
|
|
|
if (path != NULL) {
|
|
settings_file_path = path;
|
|
}
|
|
else {
|
|
settings_file_path = g_build_filename(g_get_user_config_dir(), SETTINGS_FILE, NULL);
|
|
}
|
|
|
|
load_settings(app);
|
|
}
|
|
|
|
int load_settings(GApplication *app) {
|
|
GError *error = NULL;
|
|
|
|
g_message("Trying to load settings from %s", settings_file_path);
|
|
|
|
if (!g_key_file_load_from_file(key_file, settings_file_path, G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS, &error)) {
|
|
if (error->domain == G_FILE_ERROR) {
|
|
g_warning("Unable to load %s: %s", settings_file_path, error->message);
|
|
}
|
|
else if (error->domain == G_KEY_FILE_ERROR) {
|
|
g_warning("Failed to parse %s: %s", settings_file_path, error->message);
|
|
}
|
|
|
|
g_error_free(error);
|
|
}
|
|
|
|
load_config_from_key_file(&config, key_file);
|
|
_print_config(&config, G_LOG_LEVEL_DEBUG);
|
|
|
|
// Update GAction states
|
|
g_action_group_change_action_state(G_ACTION_GROUP(app), "toggle_mute", g_variant_new_boolean(config.audio.muted));
|
|
|
|
return 0;
|
|
}
|
|
|
|
void save_settings(void) {
|
|
GError *error = NULL;
|
|
|
|
g_message("Trying to save settings to %s", settings_file_path);
|
|
|
|
save_config_to_key_file(&config, key_file);
|
|
|
|
if (!g_key_file_save_to_file(key_file, settings_file_path, &error)) {
|
|
g_warning ("Failed to save %s: %s", settings_file_path, error->message);
|
|
g_error_free(error);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void free_settings(void) {
|
|
if (key_file != NULL) {
|
|
g_key_file_free(key_file);
|
|
key_file = NULL;
|
|
}
|
|
}
|
|
|
|
void update_boot_rom_selector(GtkBuilder *builder) {
|
|
GtkComboBoxText *combo_box = builder_get(GTK_COMBO_BOX_TEXT, "boot_rom_selector");
|
|
gtk_combo_box_text_remove_all(combo_box);
|
|
gtk_combo_box_text_append(combo_box, "auto", "Use Built-in Boot ROMs");
|
|
if (config.emulation.boot_rom_path != NULL && !g_str_equal(config.emulation.boot_rom_path, "auto") && !g_str_equal(config.emulation.boot_rom_path, "other")) {
|
|
gtk_combo_box_text_append(combo_box, config.emulation.boot_rom_path, config.emulation.boot_rom_path);
|
|
gtk_combo_box_set_active_id(GTK_COMBO_BOX(combo_box), config.emulation.boot_rom_path);
|
|
}
|
|
else {
|
|
gtk_combo_box_set_active_id(GTK_COMBO_BOX(combo_box), "auto");
|
|
}
|
|
gtk_combo_box_text_append_text(combo_box, "<separator>");
|
|
gtk_combo_box_text_append(combo_box, "other", "Other");
|
|
}
|
|
|
|
enum menubar_type_t get_show_menubar(void) {
|
|
if (config.window.menubar_override == NULL) goto default_value;
|
|
|
|
if (g_strcmp0(config.window.menubar_override, "auto") == 0) {
|
|
return MENUBAR_AUTO;
|
|
}
|
|
else if (g_strcmp0(config.window.menubar_override, "show_in_shell") == 0) {
|
|
return MENUBAR_SHOW_IN_SHELL;
|
|
}
|
|
else if (g_strcmp0(config.window.menubar_override, "show_in_window") == 0) {
|
|
return MENUBAR_SHOW_IN_WINDOW;
|
|
}
|
|
else if (g_strcmp0(config.window.menubar_override, "show_hamburger") == 0) {
|
|
return MENUBAR_SHOW_HAMBURGER;
|
|
}
|
|
|
|
// This should not happen
|
|
g_warning("Unknown menubar setting: %s\nFalling back to “Auto”", config.window.menubar_override);
|
|
default_value: return MENUBAR_AUTO;
|
|
}
|
|
|
|
void set_show_menubar(enum menubar_type_t value) {
|
|
switch (value) {
|
|
case MENUBAR_AUTO:
|
|
config.window.menubar_override = "auto";
|
|
break;
|
|
case MENUBAR_SHOW_IN_SHELL:
|
|
config.window.menubar_override = "show_in_shell";
|
|
break;
|
|
case MENUBAR_SHOW_IN_WINDOW:
|
|
config.window.menubar_override = "show_in_window";
|
|
break;
|
|
case MENUBAR_SHOW_HAMBURGER:
|
|
config.window.menubar_override = "show_hamburger";
|
|
break;
|
|
}
|
|
}
|
|
|
|
GB_color_correction_mode_t get_color_correction_mode(void) {
|
|
if (config.video.color_correction_id == NULL) goto default_value;
|
|
|
|
if (g_strcmp0(config.video.color_correction_id, "disabled") == 0) {
|
|
return GB_COLOR_CORRECTION_DISABLED;
|
|
}
|
|
else if (g_strcmp0(config.video.color_correction_id, "correct_color_curves") == 0) {
|
|
return GB_COLOR_CORRECTION_CORRECT_CURVES;
|
|
}
|
|
else if (g_strcmp0(config.video.color_correction_id, "emulate_hardware") == 0) {
|
|
return GB_COLOR_CORRECTION_EMULATE_HARDWARE;
|
|
}
|
|
else if (g_strcmp0(config.video.color_correction_id, "preserve_brightness") == 0) {
|
|
return GB_COLOR_CORRECTION_PRESERVE_BRIGHTNESS;
|
|
}
|
|
else if (g_strcmp0(config.video.color_correction_id, "reduce_contrast") == 0) {
|
|
return GB_COLOR_CORRECTION_REDUCE_CONTRAST;
|
|
}
|
|
|
|
// This should not happen
|
|
g_warning("Unknown color correction mode: %s\nFalling back to “Emulate Hardware”", config.video.color_correction_id);
|
|
default_value: return GB_COLOR_CORRECTION_EMULATE_HARDWARE;
|
|
}
|
|
|
|
void set_color_correction_mode(GB_color_correction_mode_t mode) {
|
|
switch (mode) {
|
|
case GB_COLOR_CORRECTION_DISABLED:
|
|
config.video.color_correction_id = "disabled";
|
|
break;
|
|
case GB_COLOR_CORRECTION_CORRECT_CURVES:
|
|
config.video.color_correction_id = "correct_color_curves";
|
|
break;
|
|
case GB_COLOR_CORRECTION_EMULATE_HARDWARE:
|
|
config.video.color_correction_id = "emulate_hardware";
|
|
break;
|
|
case GB_COLOR_CORRECTION_PRESERVE_BRIGHTNESS:
|
|
config.video.color_correction_id = "preserve_brightness";
|
|
break;
|
|
case GB_COLOR_CORRECTION_REDUCE_CONTRAST:
|
|
config.video.color_correction_id = "reduce_contrast";
|
|
break;
|
|
}
|
|
}
|
|
|
|
GB_frame_blending_mode_t get_frame_blending_mode(void) {
|
|
if (config.video.frame_blending_mode == NULL) goto default_value;
|
|
|
|
if (g_strcmp0(config.video.frame_blending_mode, "disabled") == 0) {
|
|
return GB_FRAME_BLENDING_MODE_DISABLED;
|
|
}
|
|
else if (g_strcmp0(config.video.frame_blending_mode, "simple") == 0) {
|
|
return GB_FRAME_BLENDING_MODE_SIMPLE;
|
|
}
|
|
else if (g_strcmp0(config.video.frame_blending_mode, "accurate") == 0) {
|
|
return GB_FRAME_BLENDING_MODE_ACCURATE;
|
|
}
|
|
|
|
// This should not happen
|
|
g_warning("Unknown frame blending mode: %s\nFalling back to “Disabled”", config.video.frame_blending_mode);
|
|
default_value: return GB_FRAME_BLENDING_MODE_DISABLED;
|
|
}
|
|
|
|
void set_frame_blending_mode(GB_frame_blending_mode_t mode) {
|
|
switch (mode) {
|
|
case GB_FRAME_BLENDING_MODE_DISABLED:
|
|
config.video.frame_blending_mode = "disabled";
|
|
break;
|
|
case GB_FRAME_BLENDING_MODE_SIMPLE:
|
|
config.video.frame_blending_mode = "simple";
|
|
break;
|
|
case GB_FRAME_BLENDING_MODE_ACCURATE:
|
|
case GB_FRAME_BLENDING_MODE_ACCURATE_ODD:
|
|
config.video.frame_blending_mode = "accurate";
|
|
break;
|
|
}
|
|
}
|
|
|
|
GB_border_mode_t get_display_border_mode(void) {
|
|
if (config.video.display_border_mode == NULL) goto default_value;
|
|
|
|
if (g_strcmp0(config.video.display_border_mode, "never") == 0) {
|
|
return GB_BORDER_NEVER;
|
|
}
|
|
else if (g_strcmp0(config.video.display_border_mode, "sgb_only") == 0) {
|
|
return GB_BORDER_SGB;
|
|
}
|
|
else if (g_strcmp0(config.video.display_border_mode, "always") == 0) {
|
|
return GB_BORDER_ALWAYS;
|
|
}
|
|
|
|
// This should not happen
|
|
g_warning("Unknown SGB border mode: %s\nFalling back to “Never”", config.video.display_border_mode);
|
|
default_value: return GB_BORDER_NEVER;
|
|
}
|
|
|
|
void set_display_border_mode(GB_border_mode_t mode) {
|
|
switch (mode) {
|
|
case GB_BORDER_NEVER:
|
|
config.video.display_border_mode = "never";
|
|
break;
|
|
case GB_BORDER_SGB:
|
|
config.video.display_border_mode = "sgb_only";
|
|
break;
|
|
case GB_BORDER_ALWAYS:
|
|
config.video.display_border_mode = "always";
|
|
break;
|
|
}
|
|
}
|
|
|
|
const GB_palette_t* get_monochrome_palette(void) {
|
|
if (config.video.monochrome_palette_id == NULL) goto default_value;
|
|
|
|
if (g_strcmp0(config.video.monochrome_palette_id, "greyscale") == 0) {
|
|
return &GB_PALETTE_GREY;
|
|
}
|
|
else if (g_strcmp0(config.video.monochrome_palette_id, "lime") == 0) {
|
|
return &GB_PALETTE_DMG;
|
|
}
|
|
else if (g_strcmp0(config.video.monochrome_palette_id, "olive") == 0) {
|
|
return &GB_PALETTE_MGB;
|
|
}
|
|
else if (g_strcmp0(config.video.monochrome_palette_id, "teal") == 0) {
|
|
return &GB_PALETTE_GBL;
|
|
}
|
|
|
|
// This should not happen
|
|
g_warning("Unknown monochrome palette: %s\nFalling back to “Greyscale”", config.video.monochrome_palette_id);
|
|
default_value: return &GB_PALETTE_GREY;
|
|
}
|
|
|
|
void set_monochrome_palette(const GB_palette_t *mode) {
|
|
g_message("%p | %p | %p | %p | %p", mode, &GB_PALETTE_GREY, &GB_PALETTE_DMG, &GB_PALETTE_MGB, &GB_PALETTE_GBL);
|
|
|
|
if (mode == &GB_PALETTE_GREY) {
|
|
config.video.monochrome_palette_id = "greyscale";
|
|
}
|
|
else if (mode == &GB_PALETTE_DMG) {
|
|
config.video.monochrome_palette_id = "lime";
|
|
}
|
|
else if (mode == &GB_PALETTE_MGB) {
|
|
config.video.monochrome_palette_id = "olive";
|
|
}
|
|
else if (mode == &GB_PALETTE_GBL) {
|
|
config.video.monochrome_palette_id = "teal";
|
|
}
|
|
}
|
|
|
|
GB_highpass_mode_t get_highpass_mode(void) {
|
|
if (config.audio.high_pass_filter_id == NULL) goto default_value;
|
|
|
|
if (g_strcmp0(config.audio.high_pass_filter_id, "disabled") == 0) {
|
|
return GB_HIGHPASS_OFF;
|
|
}
|
|
else if (g_strcmp0(config.audio.high_pass_filter_id, "emulate_hardware") == 0) {
|
|
return GB_HIGHPASS_ACCURATE;
|
|
}
|
|
else if (g_strcmp0(config.audio.high_pass_filter_id, "preserve_waveform") == 0) {
|
|
return GB_HIGHPASS_REMOVE_DC_OFFSET;
|
|
}
|
|
|
|
// This should not happen
|
|
g_warning("Unknown highpass mode: %s\nFalling back to “Accurate”", config.audio.high_pass_filter_id);
|
|
default_value: return GB_HIGHPASS_ACCURATE;
|
|
}
|
|
|
|
void set_highpass_mode(GB_highpass_mode_t mode) {
|
|
switch (mode) {
|
|
case GB_HIGHPASS_OFF:
|
|
config.audio.high_pass_filter_id = "disabled";
|
|
break;
|
|
case GB_HIGHPASS_MAX:
|
|
g_warning("GB_HIGHPASS_MAX is not a valid highpass mode, falling back to “Accurate”.");
|
|
case GB_HIGHPASS_ACCURATE:
|
|
config.audio.high_pass_filter_id = "emulate_hardware";
|
|
break;
|
|
case GB_HIGHPASS_REMOVE_DC_OFFSET:
|
|
config.audio.high_pass_filter_id = "preserve_waveform";
|
|
break;
|
|
}
|
|
}
|
|
|
|
const GB_rumble_mode_t get_rumble_mode(void) {
|
|
if (config.controls.rumble_mode == NULL) goto default_value;
|
|
|
|
if (g_strcmp0(config.controls.rumble_mode, "never") == 0) {
|
|
return GB_RUMBLE_DISABLED;
|
|
}
|
|
else if (g_strcmp0(config.controls.rumble_mode, "rumble_cartridges") == 0) {
|
|
return GB_RUMBLE_CARTRIDGE_ONLY;
|
|
}
|
|
else if (g_strcmp0(config.controls.rumble_mode, "always") == 0) {
|
|
return GB_RUMBLE_ALL_GAMES;
|
|
}
|
|
|
|
// This should not happen
|
|
g_warning("Unknown highpass mode: %s\nFalling back to “Never”", config.controls.rumble_mode);
|
|
default_value: return GB_RUMBLE_DISABLED;
|
|
}
|
|
|
|
void set_rumble_mode(GB_rumble_mode_t mode) {
|
|
switch (mode) {
|
|
case GB_RUMBLE_DISABLED:
|
|
config.controls.rumble_mode = "never";
|
|
break;
|
|
case GB_RUMBLE_CARTRIDGE_ONLY:
|
|
config.controls.rumble_mode = "rumble_cartridges";
|
|
break;
|
|
case GB_RUMBLE_ALL_GAMES:
|
|
config.controls.rumble_mode = "always";
|
|
break;
|
|
}
|
|
}
|
|
|
|
GB_model_t get_model(void) {
|
|
if (g_strcmp0(config.emulation.model, "DMG") == 0) {
|
|
return get_dmg_model();
|
|
}
|
|
else if (g_strcmp0(config.emulation.model, "MGB") == 0) {
|
|
g_warning("Emulation of MGBs is unsupported, falling back to DMG.");
|
|
|
|
return get_dmg_model();
|
|
}
|
|
else if (g_strcmp0(config.emulation.model, "AGB") == 0) {
|
|
return GB_MODEL_AGB;
|
|
}
|
|
else if (g_strcmp0(config.emulation.model, "SGB") == 0) {
|
|
return get_sgb_model();
|
|
}
|
|
|
|
return get_cgb_model();
|
|
}
|
|
|
|
void set_model(GB_model_t model) {
|
|
switch (model & GB_MODEL_FAMILY_MASK) {
|
|
case GB_MODEL_DMG_FAMILY:
|
|
if (model & GB_MODEL_SGB) {
|
|
config.emulation.model = "SGB";
|
|
}
|
|
else {
|
|
config.emulation.model = "DMG";
|
|
}
|
|
break;
|
|
|
|
case GB_MODEL_MGB_FAMILY:
|
|
config.emulation.model = "MGB";
|
|
break;
|
|
|
|
case GB_MODEL_CGB_FAMILY:
|
|
if (model & GB_MODEL_AGB) {
|
|
config.emulation.model = "AGB";
|
|
}
|
|
else {
|
|
config.emulation.model = "CGB";
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
GB_model_t get_dmg_model(void) {
|
|
if (config.emulation.dmg_revision_name == NULL) goto default_value;
|
|
|
|
// TODO: Synchronize with GB_model_t (Core/gb.h)
|
|
if (g_strcmp0(config.emulation.dmg_revision_name, "DMG_CPU_B") == 0) {
|
|
return GB_MODEL_DMG_B;
|
|
}
|
|
|
|
default_value: return GB_MODEL_DMG_B;
|
|
}
|
|
|
|
GB_model_t get_sgb_model(void) {
|
|
if (config.emulation.sgb_revision_name == NULL) goto default_value;
|
|
|
|
// TODO: Synchronize with GB_model_t (Core/gb.h)
|
|
if (g_strcmp0(config.emulation.sgb_revision_name, "SGB1_NTSC") == 0) {
|
|
return GB_MODEL_SGB_NTSC;
|
|
}
|
|
else if (g_strcmp0(config.emulation.sgb_revision_name, "SGB1_PAL") == 0) {
|
|
return GB_MODEL_SGB_PAL;
|
|
}
|
|
else if (g_strcmp0(config.emulation.sgb_revision_name, "SGB2") == 0) {
|
|
return GB_MODEL_SGB2;
|
|
}
|
|
|
|
default_value: return GB_MODEL_SGB2;
|
|
}
|
|
|
|
GB_model_t get_cgb_model(void) {
|
|
if (config.emulation.cgb_revision_name == NULL) goto default_value;
|
|
|
|
// TODO: Synchronize with GB_model_t (Core/gb.h)
|
|
if (g_strcmp0(config.emulation.cgb_revision_name, "CPU_CGB_C") == 0) {
|
|
return GB_MODEL_CGB_C;
|
|
}
|
|
else if (g_strcmp0(config.emulation.cgb_revision_name, "CPU_CGB_E") == 0) {
|
|
return GB_MODEL_CGB_E;
|
|
}
|
|
|
|
default_value: return GB_MODEL_CGB_E;
|
|
}
|