summaryrefslogtreecommitdiffstats
path: root/docs/release/src/osd/winui/mui_opts.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'docs/release/src/osd/winui/mui_opts.cpp')
-rw-r--r--docs/release/src/osd/winui/mui_opts.cpp2808
1 files changed, 2808 insertions, 0 deletions
diff --git a/docs/release/src/osd/winui/mui_opts.cpp b/docs/release/src/osd/winui/mui_opts.cpp
new file mode 100644
index 00000000000..8f7ec93e316
--- /dev/null
+++ b/docs/release/src/osd/winui/mui_opts.cpp
@@ -0,0 +1,2808 @@
+// For licensing and usage information, read docs/winui_license.txt
+// MASTER
+//****************************************************************************
+
+ /***************************************************************************
+
+ mui_opts.cpp
+
+ Stores global options and per-game options;
+
+***************************************************************************/
+
+// standard windows headers
+#include <windows.h>
+#include <windowsx.h>
+#include <winreg.h>
+#include <commctrl.h>
+
+// standard C headers
+#include <assert.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <math.h>
+#include <direct.h>
+#include <emu.h>
+#include <mameopts.h>
+#include <ui/moptions.h>
+#include <stddef.h>
+#include <tchar.h>
+
+// MAME/MAMEUI headers
+#include "bitmask.h"
+#include "winui.h"
+#include "mui_util.h"
+#include "treeview.h"
+#include "splitters.h"
+#include "mui_opts.h"
+#include "winutf8.h"
+#include "strconv.h"
+#include "drivenum.h"
+#include "game_opts.h"
+
+#ifdef _MSC_VER
+#define snprintf _snprintf
+#endif
+
+/***************************************************************************
+ Internal function prototypes
+ ***************************************************************************/
+
+// static void LoadFolderFilter(int folder_index,int filters);
+
+static void LoadSettingsFile(winui_options &opts, const char *filename);
+static void SaveSettingsFile(winui_options &opts, const char *filename);
+static void LoadSettingsFile(windows_options &opts, const char *filename);
+static void SaveSettingsFile(windows_options &opts, const char *filename);
+
+static void LoadOptionsAndSettings(void);
+
+static void CusColorEncodeString(const COLORREF *value, char* str);
+static void CusColorDecodeString(const char* str, COLORREF *value);
+
+static void SplitterEncodeString(const int *value, char* str);
+static void SplitterDecodeString(const char *str, int *value);
+
+static void FontEncodeString(const LOGFONT *f, char *str);
+static void FontDecodeString(const char* str, LOGFONT *f);
+
+static void TabFlagsEncodeString(int data, char *str);
+static void TabFlagsDecodeString(const char *str, int *data);
+
+static DWORD DecodeFolderFlags(const char *buf);
+static const char * EncodeFolderFlags(DWORD value);
+
+static void ResetToDefaults(windows_options &opts, int priority);
+
+//static void ui_parse_ini_file(windows_options &opts, const char *name);
+
+
+#ifdef _MSC_VER
+#define snprintf _snprintf
+#endif
+
+/***************************************************************************
+ Internal defines
+ ***************************************************************************/
+
+#define GAMEINFO_INI_FILENAME MAMENAME "_g.ini"
+#define MEWUI_FILENAME "ini\\ui.ini"
+
+#define MUIOPTION_LIST_MODE "list_mode"
+#define MUIOPTION_CHECK_GAME "check_game"
+#define MUIOPTION_JOYSTICK_IN_INTERFACE "joystick_in_interface"
+#define MUIOPTION_KEYBOARD_IN_INTERFACE "keyboard_in_interface"
+#define MUIOPTION_CYCLE_SCREENSHOT "cycle_screenshot"
+#define MUIOPTION_STRETCH_SCREENSHOT_LARGER "stretch_screenshot_larger"
+#define MUIOPTION_SCREENSHOT_BORDER_SIZE "screenshot_bordersize"
+#define MUIOPTION_SCREENSHOT_BORDER_COLOR "screenshot_bordercolor"
+#define MUIOPTION_INHERIT_FILTER "inherit_filter"
+#define MUIOPTION_OFFSET_CLONES "offset_clones"
+#define MUIOPTION_DEFAULT_FOLDER_ID "default_folder_id"
+#define MUIOPTION_SHOW_IMAGE_SECTION "show_image_section"
+#define MUIOPTION_SHOW_FOLDER_SECTION "show_folder_section"
+#define MUIOPTION_HIDE_FOLDERS "hide_folders"
+#define MUIOPTION_SHOW_STATUS_BAR "show_status_bar"
+#define MUIOPTION_SHOW_TABS "show_tabs"
+#define MUIOPTION_SHOW_TOOLBAR "show_tool_bar"
+#define MUIOPTION_CURRENT_TAB "current_tab"
+#define MUIOPTION_WINDOW_X "window_x"
+#define MUIOPTION_WINDOW_Y "window_y"
+#define MUIOPTION_WINDOW_WIDTH "window_width"
+#define MUIOPTION_WINDOW_HEIGHT "window_height"
+#define MUIOPTION_WINDOW_STATE "window_state"
+#define MUIOPTION_CUSTOM_COLOR "custom_color"
+#define MUIOPTION_LIST_FONT "list_font"
+#define MUIOPTION_TEXT_COLOR "text_color"
+#define MUIOPTION_CLONE_COLOR "clone_color"
+#define MUIOPTION_HIDE_TABS "hide_tabs"
+#define MUIOPTION_HISTORY_TAB "history_tab"
+#define MUIOPTION_COLUMN_WIDTHS "column_widths"
+#define MUIOPTION_COLUMN_ORDER "column_order"
+#define MUIOPTION_COLUMN_SHOWN "column_shown"
+#define MUIOPTION_SPLITTERS "splitters"
+#define MUIOPTION_SORT_COLUMN "sort_column"
+#define MUIOPTION_SORT_REVERSED "sort_reversed"
+#define MUIOPTION_ICONS_DIRECTORY "icons_directory"
+#define MUIOPTION_BACKGROUND_DIRECTORY "background_directory"
+#define MUIOPTION_DATS_DIRECTORY "dats_directory"
+#define MUIOPTION_UI_KEY_UP "ui_key_up"
+#define MUIOPTION_UI_KEY_DOWN "ui_key_down"
+#define MUIOPTION_UI_KEY_LEFT "ui_key_left"
+#define MUIOPTION_UI_KEY_RIGHT "ui_key_right"
+#define MUIOPTION_UI_KEY_START "ui_key_start"
+#define MUIOPTION_UI_KEY_PGUP "ui_key_pgup"
+#define MUIOPTION_UI_KEY_PGDWN "ui_key_pgdwn"
+#define MUIOPTION_UI_KEY_HOME "ui_key_home"
+#define MUIOPTION_UI_KEY_END "ui_key_end"
+#define MUIOPTION_UI_KEY_SS_CHANGE "ui_key_ss_change"
+#define MUIOPTION_UI_KEY_HISTORY_UP "ui_key_history_up"
+#define MUIOPTION_UI_KEY_HISTORY_DOWN "ui_key_history_down"
+#define MUIOPTION_UI_KEY_CONTEXT_FILTERS "ui_key_context_filters"
+#define MUIOPTION_UI_KEY_SELECT_RANDOM "ui_key_select_random"
+#define MUIOPTION_UI_KEY_GAME_AUDIT "ui_key_game_audit"
+#define MUIOPTION_UI_KEY_GAME_PROPERTIES "ui_key_game_properties"
+#define MUIOPTION_UI_KEY_HELP_CONTENTS "ui_key_help_contents"
+#define MUIOPTION_UI_KEY_UPDATE_GAMELIST "ui_key_update_gamelist"
+#define MUIOPTION_UI_KEY_VIEW_FOLDERS "ui_key_view_folders"
+#define MUIOPTION_UI_KEY_VIEW_FULLSCREEN "ui_key_view_fullscreen"
+#define MUIOPTION_UI_KEY_VIEW_PAGETAB "ui_key_view_pagetab"
+#define MUIOPTION_UI_KEY_VIEW_PICTURE_AREA "ui_key_view_picture_area"
+#define MUIOPTION_UI_KEY_VIEW_STATUS "ui_key_view_status"
+#define MUIOPTION_UI_KEY_VIEW_TOOLBARS "ui_key_view_toolbars"
+#define MUIOPTION_UI_KEY_VIEW_TAB_CABINET "ui_key_view_tab_cabinet"
+#define MUIOPTION_UI_KEY_VIEW_TAB_CPANEL "ui_key_view_tab_cpanel"
+#define MUIOPTION_UI_KEY_VIEW_TAB_FLYER "ui_key_view_tab_flyer"
+#define MUIOPTION_UI_KEY_VIEW_TAB_HISTORY "ui_key_view_tab_history"
+#define MUIOPTION_UI_KEY_VIEW_TAB_MARQUEE "ui_key_view_tab_marquee"
+#define MUIOPTION_UI_KEY_VIEW_TAB_SCREENSHOT "ui_key_view_tab_screenshot"
+#define MUIOPTION_UI_KEY_VIEW_TAB_TITLE "ui_key_view_tab_title"
+#define MUIOPTION_UI_KEY_VIEW_TAB_PCB "ui_key_view_tab_pcb"
+#define MUIOPTION_UI_KEY_QUIT "ui_key_quit"
+#define MUIOPTION_UI_JOY_UP "ui_joy_up"
+#define MUIOPTION_UI_JOY_DOWN "ui_joy_down"
+#define MUIOPTION_UI_JOY_LEFT "ui_joy_left"
+#define MUIOPTION_UI_JOY_RIGHT "ui_joy_right"
+#define MUIOPTION_UI_JOY_START "ui_joy_start"
+#define MUIOPTION_UI_JOY_PGUP "ui_joy_pgup"
+#define MUIOPTION_UI_JOY_PGDWN "ui_joy_pgdwn"
+#define MUIOPTION_UI_JOY_HOME "ui_joy_home"
+#define MUIOPTION_UI_JOY_END "ui_joy_end"
+#define MUIOPTION_UI_JOY_SS_CHANGE "ui_joy_ss_change"
+#define MUIOPTION_UI_JOY_HISTORY_UP "ui_joy_history_up"
+#define MUIOPTION_UI_JOY_HISTORY_DOWN "ui_joy_history_down"
+#define MUIOPTION_UI_JOY_EXEC "ui_joy_exec"
+#define MUIOPTION_EXEC_COMMAND "exec_command"
+#define MUIOPTION_EXEC_WAIT "exec_wait"
+#define MUIOPTION_HIDE_MOUSE "hide_mouse"
+#define MUIOPTION_FULL_SCREEN "full_screen"
+#define MUIOPTION_SHOW_SOFTWARE_SECTION "show_software_section"
+#define MUIOPTION_UI_KEY_VIEW_SOFTWARE_AREA "ui_key_view_software_area"
+
+#ifdef MESS
+#define MUIOPTION_DEFAULT_GAME "default_system"
+#define MUIDEFAULT_SELECTION "3do"
+#define MUIDEFAULT_SPLITTERS "152,310,468"
+#else
+#define MUIOPTION_DEFAULT_GAME "default_machine"
+#define MUIDEFAULT_SELECTION "puckman"
+#define MUIDEFAULT_SPLITTERS "152,362"
+#endif
+
+#define MUIOPTION_VERSION "version"
+
+#define MESSUI_SL_COLUMN_SHOWN "sl_column_shown"
+#define MESSUI_SL_COLUMN_WIDTHS "sl_column_widths"
+#define MESSUI_SL_COLUMN_ORDER "sl_column_order"
+#define MESSUI_SL_SORT_REVERSED "sl_sort_reversed"
+#define MESSUI_SL_SORT_COLUMN "sl_sort_column"
+#define MESSUI_SW_COLUMN_SHOWN "sw_column_shown"
+#define MESSUI_SW_COLUMN_WIDTHS "sw_column_widths"
+#define MESSUI_SW_COLUMN_ORDER "sw_column_order"
+#define MESSUI_SW_SORT_REVERSED "sw_sort_reversed"
+#define MESSUI_SW_SORT_COLUMN "sw_sort_column"
+#define MESSUI_SOFTWARE_TAB "current_software_tab"
+#define MESSUI_SLPATH "slpath"
+
+
+/***************************************************************************
+ Internal structures
+ ***************************************************************************/
+
+ /***************************************************************************
+ Internal variables
+ ***************************************************************************/
+
+static mame_options mameopts; // core options
+static ui_options mewui; // ui.ini
+static winui_options settings; // mameui.ini
+
+static windows_options global; // Global 'default' options
+
+static game_options game_opts;
+
+// UI options in MAMEui.ini
+const options_entry winui_options::s_option_entries[] =
+{
+ // UI options
+ { NULL, NULL, OPTION_HEADER, "APPLICATION OPTIONS" },
+ { MUIOPTION_VERSION, "", OPTION_STRING, NULL },
+ { NULL, NULL, OPTION_HEADER, "DISPLAY STATE OPTIONS" },
+ { MUIOPTION_DEFAULT_GAME, MUIDEFAULT_SELECTION, OPTION_STRING, NULL },
+ { MUIOPTION_DEFAULT_FOLDER_ID, "0", OPTION_INTEGER, NULL },
+ { MUIOPTION_SHOW_IMAGE_SECTION, "1", OPTION_BOOLEAN, NULL },
+ { MUIOPTION_FULL_SCREEN, "0", OPTION_BOOLEAN, NULL },
+ { MUIOPTION_CURRENT_TAB, "0", OPTION_STRING, NULL },
+ { MESSUI_SOFTWARE_TAB, "0", OPTION_STRING, NULL },
+ { MUIOPTION_SHOW_TOOLBAR, "1", OPTION_BOOLEAN, NULL },
+ { MUIOPTION_SHOW_STATUS_BAR, "1", OPTION_BOOLEAN, NULL },
+ { MUIOPTION_HIDE_FOLDERS, "", OPTION_STRING, NULL },
+ { MUIOPTION_SHOW_FOLDER_SECTION, "1", OPTION_BOOLEAN, NULL },
+ { MUIOPTION_SHOW_TABS, "1", OPTION_BOOLEAN, NULL },
+ { MUIOPTION_HIDE_TABS, "marquee, title, cpanel, pcb, history", OPTION_STRING, NULL },
+ { MUIOPTION_HISTORY_TAB, "0", OPTION_INTEGER, NULL },
+ { MUIOPTION_SHOW_SOFTWARE_SECTION, "1", OPTION_BOOLEAN, NULL },
+ { MUIOPTION_SORT_COLUMN, "0", OPTION_INTEGER, NULL },
+ { MUIOPTION_SORT_REVERSED, "0", OPTION_BOOLEAN, NULL },
+ { MUIOPTION_WINDOW_X, "0", OPTION_INTEGER, NULL },
+ { MUIOPTION_WINDOW_Y, "0", OPTION_INTEGER, NULL },
+ { MUIOPTION_WINDOW_WIDTH, "800", OPTION_INTEGER, NULL },
+ { MUIOPTION_WINDOW_HEIGHT, "600", OPTION_INTEGER, NULL },
+ { MUIOPTION_WINDOW_STATE, "1", OPTION_INTEGER, NULL },
+ { MUIOPTION_TEXT_COLOR, "-1", OPTION_INTEGER, NULL },
+ { MUIOPTION_CLONE_COLOR, "-1", OPTION_INTEGER, NULL },
+ { MUIOPTION_CUSTOM_COLOR, "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0", OPTION_STRING, NULL },
+ /* ListMode needs to be before ColumnWidths settings */
+ { MUIOPTION_LIST_MODE, "5", OPTION_INTEGER, NULL },
+ { MUIOPTION_SPLITTERS, MUIDEFAULT_SPLITTERS, OPTION_STRING, NULL },
+ { MUIOPTION_LIST_FONT, "-8,0,0,0,400,0,0,0,0,0,0,0,MS Sans Serif", OPTION_STRING, NULL },
+ { MUIOPTION_COLUMN_WIDTHS, "185,78,84,84,64,88,74,108,60,144,84,40,40", OPTION_STRING, NULL },
+ { MUIOPTION_COLUMN_ORDER, "0,1,2,3,4,5,6,7,8,9,10,11,12", OPTION_STRING, NULL },
+ { MUIOPTION_COLUMN_SHOWN, "1,1,1,1,1,1,1,1,1,1,1,1,0", OPTION_STRING, NULL },
+ { MESSUI_SL_COLUMN_WIDTHS, "100,75,223,46,120,120", OPTION_STRING, NULL },
+ { MESSUI_SL_COLUMN_ORDER, "0,1,2,3,4,5", OPTION_STRING, NULL }, // order of columns
+ { MESSUI_SL_COLUMN_SHOWN, "1,1,1,1,1,1", OPTION_STRING, NULL }, // 0=hide,1=show
+ { MESSUI_SL_SORT_COLUMN, "0", OPTION_INTEGER, NULL },
+ { MESSUI_SL_SORT_REVERSED, "0", OPTION_BOOLEAN, NULL },
+ { MESSUI_SW_COLUMN_WIDTHS, "400", OPTION_STRING, NULL },
+ { MESSUI_SW_COLUMN_ORDER, "0", OPTION_STRING, NULL }, // 1= dummy column
+ { MESSUI_SW_COLUMN_SHOWN, "1", OPTION_STRING, NULL }, // 0=don't show it
+ { MESSUI_SW_SORT_COLUMN, "0", OPTION_INTEGER, NULL },
+ { MESSUI_SW_SORT_REVERSED, "0", OPTION_BOOLEAN, NULL },
+ { NULL, NULL, OPTION_HEADER, "INTERFACE OPTIONS" },
+ { MUIOPTION_CHECK_GAME, "0", OPTION_BOOLEAN, NULL },
+ { MUIOPTION_JOYSTICK_IN_INTERFACE, "1", OPTION_BOOLEAN, NULL },
+ { MUIOPTION_KEYBOARD_IN_INTERFACE, "0", OPTION_BOOLEAN, NULL },
+ { MUIOPTION_HIDE_MOUSE, "0", OPTION_BOOLEAN, NULL },
+ { MUIOPTION_INHERIT_FILTER, "0", OPTION_BOOLEAN, NULL },
+ { MUIOPTION_OFFSET_CLONES, "0", OPTION_BOOLEAN, NULL },
+ { MUIOPTION_STRETCH_SCREENSHOT_LARGER, "0", OPTION_BOOLEAN, NULL },
+ { MUIOPTION_CYCLE_SCREENSHOT, "0", OPTION_INTEGER, NULL },
+ { MUIOPTION_SCREENSHOT_BORDER_SIZE, "11", OPTION_INTEGER, NULL },
+ { MUIOPTION_SCREENSHOT_BORDER_COLOR, "-1", OPTION_INTEGER, NULL },
+ { MUIOPTION_EXEC_COMMAND, "", OPTION_STRING, NULL },
+ { MUIOPTION_EXEC_WAIT, "0", OPTION_INTEGER, NULL },
+ { NULL, NULL, OPTION_HEADER, "SEARCH PATH OPTIONS" },
+ { MUIOPTION_BACKGROUND_DIRECTORY, "bkground", OPTION_STRING, NULL },
+ { MUIOPTION_ICONS_DIRECTORY, "icons", OPTION_STRING, NULL },
+ { MUIOPTION_DATS_DIRECTORY, "dats", OPTION_STRING, NULL },
+ { MESSUI_SLPATH, "software", OPTION_STRING, NULL },
+ { NULL, NULL, OPTION_HEADER, "NAVIGATION KEY CODES" },
+ { MUIOPTION_UI_KEY_UP, "KEYCODE_UP", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_DOWN, "KEYCODE_DOWN", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_LEFT, "KEYCODE_LEFT", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_RIGHT, "KEYCODE_RIGHT", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_START, "KEYCODE_ENTER NOT KEYCODE_LALT", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_PGUP, "KEYCODE_PGUP", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_PGDWN, "KEYCODE_PGDN", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_HOME, "KEYCODE_HOME", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_END, "KEYCODE_END", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_SS_CHANGE, "KEYCODE_INSERT", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_HISTORY_UP, "KEYCODE_DEL", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_HISTORY_DOWN, "KEYCODE_LALT KEYCODE_0", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_CONTEXT_FILTERS, "KEYCODE_LCONTROL KEYCODE_F", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_SELECT_RANDOM, "KEYCODE_LCONTROL KEYCODE_R", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_GAME_AUDIT, "KEYCODE_LALT KEYCODE_A", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_GAME_PROPERTIES, "KEYCODE_LALT KEYCODE_ENTER", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_HELP_CONTENTS, "KEYCODE_F1", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_UPDATE_GAMELIST, "KEYCODE_F5", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_VIEW_FOLDERS, "KEYCODE_LALT KEYCODE_D", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_VIEW_FULLSCREEN, "KEYCODE_F11", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_VIEW_PAGETAB, "KEYCODE_LALT KEYCODE_B", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_VIEW_PICTURE_AREA, "KEYCODE_LALT KEYCODE_P", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_VIEW_SOFTWARE_AREA, "KEYCODE_LALT KEYCODE_W", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_VIEW_STATUS, "KEYCODE_LALT KEYCODE_S", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_VIEW_TOOLBARS, "KEYCODE_LALT KEYCODE_T", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_VIEW_TAB_CABINET, "KEYCODE_LALT KEYCODE_3", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_VIEW_TAB_CPANEL, "KEYCODE_LALT KEYCODE_6", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_VIEW_TAB_FLYER, "KEYCODE_LALT KEYCODE_2", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_VIEW_TAB_HISTORY, "KEYCODE_LALT KEYCODE_8", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_VIEW_TAB_MARQUEE, "KEYCODE_LALT KEYCODE_4", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_VIEW_TAB_SCREENSHOT, "KEYCODE_LALT KEYCODE_1", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_VIEW_TAB_TITLE, "KEYCODE_LALT KEYCODE_5", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_VIEW_TAB_PCB, "KEYCODE_LALT KEYCODE_7", OPTION_STRING, NULL },
+ { MUIOPTION_UI_KEY_QUIT, "KEYCODE_LALT KEYCODE_Q", OPTION_STRING, NULL },
+ { NULL, NULL, OPTION_HEADER, "NAVIGATION JOYSTICK CODES" },
+ { MUIOPTION_UI_JOY_UP, "1,1,1,1", OPTION_STRING, NULL },
+ { MUIOPTION_UI_JOY_DOWN, "1,1,1,2", OPTION_STRING, NULL },
+ { MUIOPTION_UI_JOY_LEFT, "1,1,2,1", OPTION_STRING, NULL },
+ { MUIOPTION_UI_JOY_RIGHT, "1,1,2,2", OPTION_STRING, NULL },
+ { MUIOPTION_UI_JOY_START, "1,0,1,0", OPTION_STRING, NULL },
+ { MUIOPTION_UI_JOY_PGUP, "2,1,2,1", OPTION_STRING, NULL },
+ { MUIOPTION_UI_JOY_PGDWN, "2,1,2,2", OPTION_STRING, NULL },
+ { MUIOPTION_UI_JOY_HOME, "0,0,0,0", OPTION_STRING, NULL },
+ { MUIOPTION_UI_JOY_END, "0,0,0,0", OPTION_STRING, NULL },
+ { MUIOPTION_UI_JOY_SS_CHANGE, "2,0,3,0", OPTION_STRING, NULL },
+ { MUIOPTION_UI_JOY_HISTORY_UP, "2,0,4,0", OPTION_STRING, NULL },
+ { MUIOPTION_UI_JOY_HISTORY_DOWN, "2,0,1,0", OPTION_STRING, NULL },
+ { MUIOPTION_UI_JOY_EXEC, "0,0,0,0", OPTION_STRING, NULL },
+ { NULL }
+};
+
+#if 0
+// no longer used, but keep in case we need to add more per-game options in the future
+static const options_entry perGameOptions[] =
+{
+ // per game options in messui.ini - transferred to swpath
+ { "_extra_software", "", OPTION_STRING, NULL },
+ { NULL }
+};
+#endif
+
+static const options_entry filterOptions[] =
+{
+ // filters
+ { "_filters", "0", OPTION_INTEGER, NULL },
+ { NULL }
+};
+
+
+
+// Screen shot Page tab control text
+// these must match the order of the options flags in options.h
+// (TAB_...)
+static const char *const image_tabs_long_name[MAX_TAB_TYPES] =
+{
+ "Snapshot",
+ "Flyer",
+ "Cabinet",
+ "Marquee",
+ "Title",
+ "Control Panel",
+ "PCB",
+ "History",
+};
+
+static const char *const image_tabs_short_name[MAX_TAB_TYPES] =
+{
+ "snapshot",
+ "flyer",
+ "cabinet",
+ "marquee",
+ "title",
+ "cpanel",
+ "pcb",
+ "history"
+};
+
+
+/***************************************************************************
+ External functions
+ ***************************************************************************/
+winui_options::winui_options()
+{
+ add_entries(s_option_entries);
+}
+
+void CreateGameOptions(windows_options &opts, OPTIONS_TYPE opt_type, int driver_index)
+{
+ if (driver_index >= 0)
+ mameopts.set_system_name(opts, driver_list::driver(driver_index).name);
+}
+
+BOOL OptionsInit()
+{
+#if 0
+// keep in case we need per-game options in the future
+ // set up per game options
+ {
+ char buffer[128];
+ int i, j;
+ int game_option_count = 0;
+
+ while(perGameOptions[game_option_count].name)
+ game_option_count++;
+
+ for (i = 0; i < driver_list::total(); i++)
+ {
+ for (j = 0; j < game_option_count; j++)
+ {
+ options_entry entry[2] = { { 0 }, { 0 } };
+ snprintf(buffer, ARRAY_LENGTH(buffer), "%s%s", driver_list::driver(i).name, perGameOptions[j].name);
+
+ entry[0].name = core_strdup(buffer);
+ entry[0].defvalue = perGameOptions[j].defvalue;
+ entry[0].flags = perGameOptions[j].flags;
+ entry[0].description = perGameOptions[j].description;
+ settings.add_entries(entry);
+ }
+ }
+ }
+#endif
+
+ game_opts.add_entries();
+ // set up global options
+ CreateGameOptions(global, OPTIONS_GLOBAL, GLOBAL_OPTIONS);
+ // now load the options and settings
+ LoadOptionsAndSettings();
+
+ return TRUE;
+
+}
+
+void OptionsExit(void)
+{
+}
+
+winui_options & MameUISettings(void)
+{
+ return settings;
+}
+
+windows_options & MameUIGlobal(void)
+{
+ return global;
+}
+
+// Restore ui settings to factory
+void ResetGUI(void)
+{
+ settings.revert(OPTION_PRIORITY_NORMAL);
+ // Save the new MAMEui.ini
+ SaveOptions();
+}
+
+const char * GetImageTabLongName(int tab_index)
+{
+ assert(tab_index >= 0);
+ assert(tab_index < ARRAY_LENGTH(image_tabs_long_name));
+ return image_tabs_long_name[tab_index];
+}
+
+const char * GetImageTabShortName(int tab_index)
+{
+ assert(tab_index >= 0);
+ assert(tab_index < ARRAY_LENGTH(image_tabs_short_name));
+ return image_tabs_short_name[tab_index];
+}
+
+//============================================================
+// OPTIONS WRAPPERS
+//============================================================
+
+static COLORREF options_get_color(winui_options &opts, const char *name)
+{
+ const char *value_str;
+ unsigned int r = 0, g = 0, b = 0;
+ COLORREF value;
+
+ value_str = opts.value(name);
+
+ if (sscanf(value_str, "%u,%u,%u", &r, &g, &b) == 3)
+ value = RGB(r,g,b);
+ else
+ value = (COLORREF) - 1;
+ return value;
+}
+
+static void options_set_color(winui_options &opts, const char *name, COLORREF value)
+{
+ char value_str[32];
+
+ if (value == (COLORREF) -1)
+ {
+ snprintf(value_str, ARRAY_LENGTH(value_str), "%d", (int) value);
+ }
+ else
+ {
+ snprintf(value_str, ARRAY_LENGTH(value_str), "%d,%d,%d", (((int) value) >> 0) & 0xFF, (((int) value) >> 8) & 0xFF, (((int) value) >> 16) & 0xFF);
+ }
+ std::string error_string;
+ opts.set_value(name, value_str, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+static COLORREF options_get_color_default(winui_options &opts, const char *name, int default_color)
+{
+ COLORREF value = options_get_color(opts, name);
+ if (value == (COLORREF) -1)
+ value = GetSysColor(default_color);
+ return value;
+}
+
+static void options_set_color_default(winui_options &opts, const char *name, COLORREF value, int default_color)
+{
+ if (value == GetSysColor(default_color))
+ options_set_color(settings, name, (COLORREF) -1);
+ else
+ options_set_color(settings, name, value);
+}
+
+static input_seq *options_get_input_seq(winui_options &opts, const char *name)
+{
+/* static input_seq seq;
+ const char *seq_string;
+
+ seq_string = opts.value( name);
+ input_seq_from_tokens(NULL, seq_string, &seq); // HACK
+ return &seq;*/
+ return NULL;
+}
+
+
+
+//============================================================
+// OPTIONS CALLS
+//============================================================
+
+void SetViewMode(int val)
+{
+ std::string error_string;
+ settings.set_value(MUIOPTION_LIST_MODE, val, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+int GetViewMode(void)
+{
+ return settings.int_value(MUIOPTION_LIST_MODE);
+}
+
+void SetGameCheck(BOOL game_check)
+{
+ std::string error_string;
+ settings.set_value(MUIOPTION_CHECK_GAME, game_check, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+BOOL GetGameCheck(void)
+{
+ return settings.bool_value(MUIOPTION_CHECK_GAME);
+}
+
+void SetJoyGUI(BOOL use_joygui)
+{
+ std::string error_string;
+ settings.set_value(MUIOPTION_JOYSTICK_IN_INTERFACE, use_joygui, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+BOOL GetJoyGUI(void)
+{
+ return settings.bool_value( MUIOPTION_JOYSTICK_IN_INTERFACE);
+}
+
+void SetKeyGUI(BOOL use_keygui)
+{
+ std::string error_string;
+ settings.set_value(MUIOPTION_KEYBOARD_IN_INTERFACE, use_keygui, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+BOOL GetKeyGUI(void)
+{
+ return settings.bool_value( MUIOPTION_KEYBOARD_IN_INTERFACE);
+}
+
+void SetCycleScreenshot(int cycle_screenshot)
+{
+ std::string error_string;
+ settings.set_value(MUIOPTION_CYCLE_SCREENSHOT, cycle_screenshot, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+int GetCycleScreenshot(void)
+{
+ return settings.int_value(MUIOPTION_CYCLE_SCREENSHOT);
+}
+
+void SetStretchScreenShotLarger(BOOL stretch)
+{
+ std::string error_string;
+ settings.set_value(MUIOPTION_STRETCH_SCREENSHOT_LARGER, stretch, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+BOOL GetStretchScreenShotLarger(void)
+{
+ return settings.bool_value( MUIOPTION_STRETCH_SCREENSHOT_LARGER);
+}
+
+void SetScreenshotBorderSize(int size)
+{
+ std::string error_string;
+ settings.set_value(MUIOPTION_SCREENSHOT_BORDER_SIZE, size, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+int GetScreenshotBorderSize(void)
+{
+ return settings.int_value(MUIOPTION_SCREENSHOT_BORDER_SIZE);
+}
+
+void SetScreenshotBorderColor(COLORREF uColor)
+{
+ options_set_color_default(settings, MUIOPTION_SCREENSHOT_BORDER_COLOR, uColor, COLOR_3DFACE);
+}
+
+COLORREF GetScreenshotBorderColor(void)
+{
+ return options_get_color_default(settings, MUIOPTION_SCREENSHOT_BORDER_COLOR, COLOR_3DFACE);
+}
+
+void SetFilterInherit(BOOL inherit)
+{
+ std::string error_string;
+ settings.set_value(MUIOPTION_INHERIT_FILTER, inherit, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+BOOL GetFilterInherit(void)
+{
+ return settings.bool_value( MUIOPTION_INHERIT_FILTER);
+}
+
+void SetOffsetClones(BOOL offset)
+{
+ std::string error_string;
+ settings.set_value(MUIOPTION_OFFSET_CLONES, offset, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+BOOL GetOffsetClones(void)
+{
+ return settings.bool_value( MUIOPTION_OFFSET_CLONES);
+}
+
+void SetSavedFolderID(UINT val)
+{
+ std::string error_string;
+ settings.set_value(MUIOPTION_DEFAULT_FOLDER_ID, (int) val, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+UINT GetSavedFolderID(void)
+{
+ return (UINT) settings.int_value(MUIOPTION_DEFAULT_FOLDER_ID);
+}
+
+void SetShowScreenShot(BOOL val)
+{
+ std::string error_string;
+ settings.set_value(MUIOPTION_SHOW_IMAGE_SECTION, val, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+BOOL GetShowScreenShot(void)
+{
+ return settings.bool_value(MUIOPTION_SHOW_IMAGE_SECTION);
+}
+
+void SetShowSoftware(BOOL val)
+{
+ std::string error_string;
+ settings.set_value(MUIOPTION_SHOW_SOFTWARE_SECTION, val, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+BOOL GetShowSoftware(void)
+{
+ return settings.bool_value(MUIOPTION_SHOW_SOFTWARE_SECTION);
+}
+
+void SetShowFolderList(BOOL val)
+{
+ std::string error_string;
+ settings.set_value(MUIOPTION_SHOW_FOLDER_SECTION, val, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+BOOL GetShowFolderList(void)
+{
+ return settings.bool_value(MUIOPTION_SHOW_FOLDER_SECTION);
+}
+
+static void GetsShowFolderFlags(LPBITS bits)
+{
+ char s[2000];
+ extern const FOLDERDATA g_folderData[];
+ char *token;
+
+ snprintf(s, ARRAY_LENGTH(s), "%s", settings.value( MUIOPTION_HIDE_FOLDERS));
+
+ SetAllBits(bits, TRUE);
+
+ token = strtok(s,", \t");
+ int j;
+ while (token)
+ {
+ for (j=0; g_folderData[j].m_lpTitle; j++)
+ {
+ if (strcmp(g_folderData[j].short_name,token) == 0)
+ {
+ ClearBit(bits, g_folderData[j].m_nFolderId);
+ break;
+ }
+ }
+ token = strtok(NULL,", \t");
+ }
+}
+
+BOOL GetShowFolder(int folder)
+{
+ LPBITS show_folder_flags = NewBits(MAX_FOLDERS);
+ GetsShowFolderFlags(show_folder_flags);
+ BOOL result = TestBit(show_folder_flags, folder);
+ DeleteBits(show_folder_flags);
+ return result;
+}
+
+void SetShowFolder(int folder,BOOL show)
+{
+ LPBITS show_folder_flags = NewBits(MAX_FOLDERS);
+ int i = 0, j = 0;
+ int num_saved = 0;
+ char str[10000];
+ extern const FOLDERDATA g_folderData[];
+
+ GetsShowFolderFlags(show_folder_flags);
+
+ if (show)
+ SetBit(show_folder_flags, folder);
+ else
+ ClearBit(show_folder_flags, folder);
+
+ strcpy(str, "");
+
+ // we save the ones that are NOT displayed, so we can add new ones
+ // and upgraders will see them
+ for (i=0; i<MAX_FOLDERS; i++)
+ {
+ if (TestBit(show_folder_flags, i) == FALSE)
+ {
+ if (num_saved != 0)
+ strcat(str,", ");
+
+ for (j=0; g_folderData[j].m_lpTitle; j++)
+ {
+ if (g_folderData[j].m_nFolderId == i)
+ {
+ strcat(str,g_folderData[j].short_name);
+ num_saved++;
+ break;
+ }
+ }
+ }
+ }
+ std::string error_string;
+ settings.set_value(MUIOPTION_HIDE_FOLDERS, str, OPTION_PRIORITY_CMDLINE,error_string);
+ DeleteBits(show_folder_flags);
+}
+
+void SetShowStatusBar(BOOL val)
+{
+ std::string error_string;
+ settings.set_value(MUIOPTION_SHOW_STATUS_BAR, val, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+BOOL GetShowStatusBar(void)
+{
+ return settings.bool_value( MUIOPTION_SHOW_STATUS_BAR);
+}
+
+void SetShowTabCtrl (BOOL val)
+{
+ std::string error_string;
+ settings.set_value(MUIOPTION_SHOW_TABS, val, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+BOOL GetShowTabCtrl (void)
+{
+ return settings.bool_value( MUIOPTION_SHOW_TABS);
+}
+
+void SetShowToolBar(BOOL val)
+{
+ std::string error_string;
+ settings.set_value(MUIOPTION_SHOW_TOOLBAR, val, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+BOOL GetShowToolBar(void)
+{
+ return settings.bool_value( MUIOPTION_SHOW_TOOLBAR);
+}
+
+void SetCurrentTab(const char *shortname)
+{
+ std::string error_string;
+ settings.set_value(MUIOPTION_CURRENT_TAB, shortname, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+const char *GetCurrentTab(void)
+{
+ return settings.value( MUIOPTION_CURRENT_TAB);
+}
+
+void SetDefaultGame(const char *name)
+{
+ std::string error_string;
+ settings.set_value(MUIOPTION_DEFAULT_GAME, name, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+const char *GetDefaultGame(void)
+{
+ return settings.value( MUIOPTION_DEFAULT_GAME);
+}
+
+void SetWindowArea(const AREA *area)
+{
+ std::string error_string;
+ settings.set_value(MUIOPTION_WINDOW_X, area->x, OPTION_PRIORITY_CMDLINE,error_string);
+ settings.set_value(MUIOPTION_WINDOW_Y, area->y, OPTION_PRIORITY_CMDLINE,error_string);
+ settings.set_value(MUIOPTION_WINDOW_WIDTH, area->width, OPTION_PRIORITY_CMDLINE,error_string);
+ settings.set_value(MUIOPTION_WINDOW_HEIGHT, area->height, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+void GetWindowArea(AREA *area)
+{
+ area->x = settings.int_value(MUIOPTION_WINDOW_X);
+ area->y = settings.int_value(MUIOPTION_WINDOW_Y);
+ area->width = settings.int_value(MUIOPTION_WINDOW_WIDTH);
+ area->height = settings.int_value(MUIOPTION_WINDOW_HEIGHT);
+}
+
+void SetWindowState(UINT state)
+{
+ std::string error_string;
+ settings.set_value(MUIOPTION_WINDOW_STATE, (int)state, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+UINT GetWindowState(void)
+{
+ return settings.int_value(MUIOPTION_WINDOW_STATE);
+}
+
+void SetCustomColor(int iIndex, COLORREF uColor)
+{
+ const char *custom_color_string;
+ COLORREF custom_color[256];
+ char buffer[80];
+
+ custom_color_string = settings.value( MUIOPTION_CUSTOM_COLOR);
+ CusColorDecodeString(custom_color_string, custom_color);
+
+ custom_color[iIndex] = uColor;
+
+ CusColorEncodeString(custom_color, buffer);
+ std::string error_string;
+ settings.set_value(MUIOPTION_CUSTOM_COLOR, buffer, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+COLORREF GetCustomColor(int iIndex)
+{
+ const char *custom_color_string;
+ COLORREF custom_color[256];
+
+ custom_color_string = settings.value( MUIOPTION_CUSTOM_COLOR);
+ CusColorDecodeString(custom_color_string, custom_color);
+
+ if (custom_color[iIndex] == (COLORREF)-1)
+ return (COLORREF)RGB(0,0,0);
+
+ return custom_color[iIndex];
+}
+
+void SetListFont(const LOGFONT *font)
+{
+ char font_string[10000];
+ FontEncodeString(font, font_string);
+ std::string error_string;
+ settings.set_value(MUIOPTION_LIST_FONT, font_string, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+void GetListFont(LOGFONT *font)
+{
+ const char *font_string = settings.value( MUIOPTION_LIST_FONT);
+ FontDecodeString(font_string, font);
+}
+
+void SetListFontColor(COLORREF uColor)
+{
+ options_set_color_default(settings, MUIOPTION_TEXT_COLOR, uColor, COLOR_WINDOWTEXT);
+}
+
+COLORREF GetListFontColor(void)
+{
+ return options_get_color_default(settings, MUIOPTION_TEXT_COLOR, COLOR_WINDOWTEXT);
+}
+
+void SetListCloneColor(COLORREF uColor)
+{
+ options_set_color_default(settings, MUIOPTION_CLONE_COLOR, uColor, COLOR_WINDOWTEXT);
+}
+
+COLORREF GetListCloneColor(void)
+{
+ return options_get_color_default(settings, MUIOPTION_CLONE_COLOR, COLOR_WINDOWTEXT);
+}
+
+int GetShowTab(int tab)
+{
+ const char *show_tabs_string;
+ int show_tab_flags = 0;
+
+ show_tabs_string = settings.value( MUIOPTION_HIDE_TABS);
+ TabFlagsDecodeString(show_tabs_string, &show_tab_flags);
+ return (show_tab_flags & (1 << tab)) != 0;
+}
+
+void SetShowTab(int tab,BOOL show)
+{
+ const char *show_tabs_string;
+ int show_tab_flags = 0;
+ char buffer[10000];
+
+ show_tabs_string = settings.value( MUIOPTION_HIDE_TABS);
+ TabFlagsDecodeString(show_tabs_string, &show_tab_flags);
+
+ if (show)
+ show_tab_flags |= 1 << tab;
+ else
+ show_tab_flags &= ~(1 << tab);
+
+ TabFlagsEncodeString(show_tab_flags, buffer);
+ std::string error_string;
+ settings.set_value(MUIOPTION_HIDE_TABS, buffer, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+// don't delete the last one
+BOOL AllowedToSetShowTab(int tab,BOOL show)
+{
+ const char *show_tabs_string;
+ int show_tab_flags = 0;
+
+ if (show == TRUE)
+ return TRUE;
+
+ show_tabs_string = settings.value( MUIOPTION_HIDE_TABS);
+ TabFlagsDecodeString(show_tabs_string, &show_tab_flags);
+
+ show_tab_flags &= ~(1 << tab);
+ return show_tab_flags != 0;
+}
+
+int GetHistoryTab(void)
+{
+ return settings.int_value(MUIOPTION_HISTORY_TAB);
+}
+
+void SetHistoryTab(int tab, BOOL show)
+{
+ std::string error_string;
+ if (show)
+ settings.set_value(MUIOPTION_HISTORY_TAB, tab, OPTION_PRIORITY_CMDLINE,error_string);
+ else
+ settings.set_value(MUIOPTION_HISTORY_TAB, TAB_NONE, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+void SetColumnWidths(int width[])
+{
+ char column_width_string[80];
+ ColumnEncodeStringWithCount(width, column_width_string, COLUMN_MAX);
+ std::string error_string;
+ settings.set_value(MUIOPTION_COLUMN_WIDTHS, column_width_string, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+void GetColumnWidths(int width[])
+{
+ const char *column_width_string;
+ column_width_string = settings.value(MUIOPTION_COLUMN_WIDTHS);
+ ColumnDecodeStringWithCount(column_width_string, width, COLUMN_MAX);
+}
+
+void SetSplitterPos(int splitterId, int pos)
+{
+ const char *splitter_string;
+ int *splitter;
+ char buffer[80];
+
+ if (splitterId < GetSplitterCount())
+ {
+ splitter_string = settings.value(MUIOPTION_SPLITTERS);
+ splitter = (int *) alloca(GetSplitterCount() * sizeof(*splitter));
+ SplitterDecodeString(splitter_string, splitter);
+
+ splitter[splitterId] = pos;
+
+ SplitterEncodeString(splitter, buffer);
+ std::string error_string;
+ settings.set_value(MUIOPTION_SPLITTERS, buffer, OPTION_PRIORITY_CMDLINE,error_string);
+ }
+}
+
+int GetSplitterPos(int splitterId)
+{
+ const char *splitter_string;
+ int *splitter;
+
+ splitter_string = settings.value( MUIOPTION_SPLITTERS);
+ splitter = (int *) alloca(GetSplitterCount() * sizeof(*splitter));
+ SplitterDecodeString(splitter_string, splitter);
+
+ if (splitterId < GetSplitterCount())
+ return splitter[splitterId];
+
+ return -1; /* Error */
+}
+
+void SetColumnOrder(int order[])
+{
+ char column_order_string[80];
+ ColumnEncodeStringWithCount(order, column_order_string, COLUMN_MAX);
+ std::string error_string;
+ settings.set_value(MUIOPTION_COLUMN_ORDER, column_order_string, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+void GetColumnOrder(int order[])
+{
+ const char *column_order_string;
+ column_order_string = settings.value( MUIOPTION_COLUMN_ORDER);
+ ColumnDecodeStringWithCount(column_order_string, order, COLUMN_MAX);
+}
+
+void SetColumnShown(int shown[])
+{
+ char column_shown_string[80];
+ ColumnEncodeStringWithCount(shown, column_shown_string, COLUMN_MAX);
+ std::string error_string;
+ settings.set_value(MUIOPTION_COLUMN_SHOWN, column_shown_string, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+void GetColumnShown(int shown[])
+{
+ const char *column_shown_string;
+ column_shown_string = settings.value( MUIOPTION_COLUMN_SHOWN);
+ ColumnDecodeStringWithCount(column_shown_string, shown, COLUMN_MAX);
+}
+
+void SetSortColumn(int column)
+{
+ std::string error_string;
+ settings.set_value(MUIOPTION_SORT_COLUMN, column, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+int GetSortColumn(void)
+{
+ return settings.int_value(MUIOPTION_SORT_COLUMN);
+}
+
+void SetSortReverse(BOOL reverse)
+{
+ std::string error_string;
+ settings.set_value(MUIOPTION_SORT_REVERSED, reverse, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+BOOL GetSortReverse(void)
+{
+ return settings.bool_value( MUIOPTION_SORT_REVERSED);
+}
+
+const char* GetLanguageUI(void)
+{
+ return global.value(OPTION_LANGUAGE);
+}
+
+bool GetEnablePlugins(void)
+{
+ return global.bool_value(OPTION_PLUGINS);
+}
+
+const char* GetPlugins(void)
+{
+ return global.value(OPTION_PLUGIN);
+}
+
+const char* GetRomDirs(void)
+{
+ return global.media_path();
+}
+
+void SetRomDirs(const char* paths)
+{
+ std::string error_string;
+ global.set_value(OPTION_MEDIAPATH, paths, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+const char* GetHashDirs(void)
+{
+ return global.hash_path();
+}
+
+void SetHashDirs(const char* paths)
+{
+ std::string error_string;
+ global.set_value(OPTION_HASHPATH, paths, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+const char* GetSampleDirs(void)
+{
+ return global.value(OPTION_SAMPLEPATH);
+}
+
+void SetSampleDirs(const char* paths)
+{
+ std::string error_string;
+ global.set_value(OPTION_SAMPLEPATH, paths, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+const char * GetIniDir(void)
+{
+ const char *ini_dir;
+// const char *s;
+
+// ini_dir = global.value(OPTION_INIPATH);
+// while((s = strchr(ini_dir, ';')) != NULL)
+// {
+// ini_dir = s + 1;
+// }
+ ini_dir = "ini\0";
+ return ini_dir;
+
+}
+
+void SetIniDir(const char *path)
+{
+ std::string error_string;
+ global.set_value(OPTION_INIPATH, path, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+const char* GetCtrlrDir(void)
+{
+ return global.value(OPTION_CTRLRPATH);
+}
+
+void SetCtrlrDir(const char* path)
+{
+ std::string error_string;
+ global.set_value(OPTION_CTRLRPATH, path, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+const char* GetSWDir(void)
+{
+ return global.value(OPTION_SWPATH);
+}
+
+void SetSWDir(const char* path)
+{
+ std::string error_string;
+ global.set_value(OPTION_SWPATH, path, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+const char* GetCfgDir(void)
+{
+ return global.value(OPTION_CFG_DIRECTORY);
+}
+
+void SetCfgDir(const char* path)
+{
+ std::string error_string;
+ global.set_value(OPTION_CFG_DIRECTORY, path, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+const char* GetNvramDir(void)
+{
+ return global.value(OPTION_NVRAM_DIRECTORY);
+}
+
+void SetNvramDir(const char* path)
+{
+ std::string error_string;
+ global.set_value(OPTION_NVRAM_DIRECTORY, path, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+const char* GetInpDir(void)
+{
+ return global.value(OPTION_INPUT_DIRECTORY);
+}
+
+void SetInpDir(const char* path)
+{
+ std::string error_string;
+ global.set_value(OPTION_INPUT_DIRECTORY, path, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+const char* GetImgDir(void)
+{
+ return global.value(OPTION_SNAPSHOT_DIRECTORY);
+}
+
+void SetImgDir(const char* path)
+{
+ std::string error_string;
+ global.set_value(OPTION_SNAPSHOT_DIRECTORY, path, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+const char* GetStateDir(void)
+{
+ return global.value(OPTION_STATE_DIRECTORY);
+}
+
+void SetStateDir(const char* path)
+{
+ std::string error_string;
+ global.set_value(OPTION_STATE_DIRECTORY, path, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+const char* GetArtDir(void)
+{
+ return global.value(OPTION_ARTPATH);
+}
+
+void SetArtDir(const char* path)
+{
+ std::string error_string;
+ global.set_value(OPTION_ARTPATH, path, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+const char* GetFontDir(void)
+{
+ return global.value(OPTION_FONTPATH);
+}
+
+void SetFontDir(const char* paths)
+{
+ std::string error_string;
+ global.set_value(OPTION_FONTPATH, paths, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+const char* GetCrosshairDir(void)
+{
+ return global.value(OPTION_CROSSHAIRPATH);
+}
+
+void SetCrosshairDir(const char* paths)
+{
+ std::string error_string;
+ global.set_value(OPTION_CROSSHAIRPATH, paths, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+const char* GetFlyerDir(void)
+{
+ return mewui.value(OPTION_FLYERS_PATH);
+}
+
+void SetFlyerDir(const char* path)
+{
+ std::string error_string;
+ mewui.set_value(OPTION_FLYERS_PATH, path, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+const char* GetCabinetDir(void)
+{
+ return mewui.value(OPTION_CABINETS_PATH);
+}
+
+void SetCabinetDir(const char* path)
+{
+ std::string error_string;
+ mewui.set_value(OPTION_CABINETS_PATH, path, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+const char* GetMarqueeDir(void)
+{
+ return mewui.value(OPTION_MARQUEES_PATH);
+}
+
+void SetMarqueeDir(const char* path)
+{
+ std::string error_string;
+ mewui.set_value(OPTION_MARQUEES_PATH, path, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+const char* GetTitlesDir(void)
+{
+ return mewui.value(OPTION_TITLES_PATH);
+}
+
+void SetTitlesDir(const char* path)
+{
+ std::string error_string;
+ mewui.set_value(OPTION_TITLES_PATH, path, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+const char * GetControlPanelDir(void)
+{
+ return mewui.value(OPTION_CPANELS_PATH);
+}
+
+void SetControlPanelDir(const char *path)
+{
+ std::string error_string;
+ mewui.set_value(OPTION_CPANELS_PATH, path, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+const char * GetPcbDir(void)
+{
+ return mewui.value(OPTION_PCBS_PATH);
+}
+
+void SetPcbDir(const char *path)
+{
+ std::string error_string;
+ mewui.set_value(OPTION_PCBS_PATH, path, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+const char* GetPluginsDir(void)
+{
+ return global.value(OPTION_PLUGINSPATH);
+}
+
+void SetPluginsDir(const char* path)
+{
+ std::string error_string;
+ global.set_value(OPTION_PLUGINSPATH, path, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+const char* GetLangDir(void)
+{
+ return global.value(OPTION_LANGUAGEPATH);
+}
+
+void SetLangDir(const char* path)
+{
+ std::string error_string;
+ global.set_value(OPTION_LANGUAGEPATH, path, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+const char * GetDiffDir(void)
+{
+ return global.value(OPTION_DIFF_DIRECTORY);
+}
+
+void SetDiffDir(const char* path)
+{
+ std::string error_string;
+ global.set_value(OPTION_DIFF_DIRECTORY, path, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+const char* GetIconsDir(void)
+{
+ return settings.value( MUIOPTION_ICONS_DIRECTORY);
+}
+
+void SetIconsDir(const char* path)
+{
+ std::string error_string;
+ settings.set_value(MUIOPTION_ICONS_DIRECTORY, path, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+const char* GetBgDir (void)
+{
+ return settings.value( MUIOPTION_BACKGROUND_DIRECTORY);
+}
+
+void SetBgDir (const char* path)
+{
+ std::string error_string;
+ settings.set_value(MUIOPTION_BACKGROUND_DIRECTORY, path, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+const char * GetDatsDir(void)
+{
+ const char* t = settings.value( MUIOPTION_DATS_DIRECTORY);
+ const char* t1 = strtok((char*)t, ";");
+ if (t1)
+ return t1;
+ else
+ return t;
+ //return settings.value( MUIOPTION_DATS_DIRECTORY);
+ //return mewui.value(OPTION_HISTORY_PATH);
+}
+
+void SetDatsDir(const char *path)
+{
+ std::string error_string;
+ settings.set_value(MUIOPTION_DATS_DIRECTORY, path, OPTION_PRIORITY_CMDLINE,error_string);
+ //mewui.set_value(OPTION_HISTORY_PATH, path, OPTION_PRIORITY_CMDLINE, error_string);
+}
+
+const char* GetFolderDir(void)
+{
+ return mewui.value(OPTION_EXTRAINI_PATH);
+}
+
+void SetFolderDir(const char* path)
+{
+ std::string error_string;
+ mewui.set_value(OPTION_EXTRAINI_PATH, path, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+const char* GetCheatDir(void)
+{
+ return global.value(OPTION_CHEATPATH);
+}
+
+void SetCheatDir(const char* path)
+{
+ std::string error_string;
+ global.set_value(OPTION_CHEATPATH, path, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+const char* GetSnapName(void)
+{
+ return global.value(OPTION_SNAPNAME);
+}
+
+void SetSnapName(const char* pattern)
+{
+ std::string error_string;
+ global.set_value(OPTION_SNAPNAME, pattern, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+void ResetGameOptions(int driver_index)
+{
+ assert(0 <= driver_index && driver_index < driver_list::total());
+
+ //save_options(NULL, OPTIONS_GAME, driver_index);
+}
+
+void ResetGameDefaults(void)
+{
+ // Walk the global settings and reset everything to defaults;
+ ResetToDefaults(global, OPTION_PRIORITY_CMDLINE);
+ save_options(global, OPTIONS_GLOBAL, GLOBAL_OPTIONS);
+}
+
+/*
+ * Reset all game, vector and source options to defaults.
+ * No reason to reboot if this is done.
+ */
+void ResetAllGameOptions(void)
+{
+ for (int i = 0; i < driver_list::total(); i++)
+ ResetGameOptions(i);
+}
+
+int GetRomAuditResults(int driver_index)
+{
+ return game_opts.rom(driver_index);
+}
+
+void SetRomAuditResults(int driver_index, int audit_results)
+{
+ game_opts.rom(driver_index, audit_results);
+}
+
+int GetSampleAuditResults(int driver_index)
+{
+ return game_opts.sample(driver_index);
+}
+
+void SetSampleAuditResults(int driver_index, int audit_results)
+{
+ game_opts.sample(driver_index, audit_results);
+}
+
+static void IncrementPlayVariable(int driver_index, const char *play_variable, int increment)
+{
+ int count = 0;
+
+ if (strcmp(play_variable, "count") == 0)
+ {
+ count = game_opts.play_count(driver_index);
+ game_opts.play_count(driver_index, count + increment);
+ }
+ else if (strcmp(play_variable, "time") == 0)
+ {
+ count = game_opts.play_time(driver_index);
+ game_opts.play_time(driver_index, count + increment);
+ }
+}
+
+void IncrementPlayCount(int driver_index)
+{
+ IncrementPlayVariable(driver_index, "count", 1);
+}
+
+int GetPlayCount(int driver_index)
+{
+ return game_opts.play_count(driver_index);
+}
+
+static void ResetPlayVariable(int driver_index, const char *play_variable)
+{
+ if (driver_index < 0)
+ {
+ /* all games */
+ for (int i = 0; i< driver_list::total(); i++)
+ {
+ ResetPlayVariable(i, play_variable);
+ }
+ }
+ else
+ {
+ if (strcmp(play_variable, "count") == 0)
+ game_opts.play_count(driver_index, 0);
+ else if (strcmp(play_variable, "time") == 0)
+ game_opts.play_time(driver_index, 0);
+ }
+}
+
+void ResetPlayCount(int driver_index)
+{
+ ResetPlayVariable(driver_index, "count");
+}
+
+void ResetPlayTime(int driver_index)
+{
+ ResetPlayVariable(driver_index, "time");
+}
+
+int GetPlayTime(int driver_index)
+{
+ return game_opts.play_time(driver_index);
+}
+
+void IncrementPlayTime(int driver_index,int playtime)
+{
+ IncrementPlayVariable(driver_index, "time", playtime);
+}
+
+void GetTextPlayTime(int driver_index, char *buf)
+{
+
+ assert(0 <= driver_index && driver_index < driver_list::total());
+ int temp = GetPlayTime(driver_index);
+ int hour = temp / 3600;
+ temp = temp - 3600*hour;
+ int minute = temp / 60; //Calc Minutes
+ int second = temp - 60*minute;
+
+ if (hour == 0)
+ sprintf(buf, "%d:%02d", minute, second );
+ else
+ sprintf(buf, "%d:%02d:%02d", hour, minute, second );
+}
+
+input_seq* Get_ui_key_up(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_UP);
+}
+
+input_seq* Get_ui_key_down(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_DOWN);
+}
+
+input_seq* Get_ui_key_left(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_LEFT);
+}
+
+input_seq* Get_ui_key_right(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_RIGHT);
+}
+
+input_seq* Get_ui_key_start(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_START);
+}
+
+input_seq* Get_ui_key_pgup(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_PGUP);
+}
+
+input_seq* Get_ui_key_pgdwn(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_PGDWN);
+}
+
+input_seq* Get_ui_key_home(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_HOME);
+}
+
+input_seq* Get_ui_key_end(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_END);
+}
+
+input_seq* Get_ui_key_ss_change(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_SS_CHANGE);
+}
+
+input_seq* Get_ui_key_history_up(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_HISTORY_UP);
+}
+
+input_seq* Get_ui_key_history_down(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_HISTORY_DOWN);
+}
+
+input_seq* Get_ui_key_context_filters(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_CONTEXT_FILTERS);
+}
+
+input_seq* Get_ui_key_select_random(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_SELECT_RANDOM);
+}
+
+input_seq* Get_ui_key_game_audit(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_GAME_AUDIT);
+}
+
+input_seq* Get_ui_key_game_properties(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_GAME_PROPERTIES);
+}
+
+input_seq* Get_ui_key_help_contents(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_HELP_CONTENTS);
+}
+
+input_seq* Get_ui_key_update_gamelist(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_UPDATE_GAMELIST);
+}
+
+input_seq* Get_ui_key_view_folders(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_VIEW_FOLDERS);
+}
+
+input_seq* Get_ui_key_view_fullscreen(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_VIEW_FULLSCREEN);
+}
+
+input_seq* Get_ui_key_view_pagetab(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_VIEW_PAGETAB);
+}
+
+input_seq* Get_ui_key_view_picture_area(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_VIEW_PICTURE_AREA);
+}
+
+input_seq* Get_ui_key_view_software_area(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_VIEW_SOFTWARE_AREA);
+}
+
+input_seq* Get_ui_key_view_status(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_VIEW_STATUS);
+}
+
+input_seq* Get_ui_key_view_toolbars(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_VIEW_TOOLBARS);
+}
+
+input_seq* Get_ui_key_view_tab_cabinet(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_VIEW_TAB_CABINET);
+}
+
+input_seq* Get_ui_key_view_tab_cpanel(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_VIEW_TAB_CPANEL);
+}
+
+input_seq* Get_ui_key_view_tab_flyer(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_VIEW_TAB_FLYER);
+}
+
+input_seq* Get_ui_key_view_tab_history(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_VIEW_TAB_HISTORY);
+}
+
+input_seq* Get_ui_key_view_tab_marquee(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_VIEW_TAB_MARQUEE);
+}
+
+input_seq* Get_ui_key_view_tab_screenshot(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_VIEW_TAB_SCREENSHOT);
+}
+
+input_seq* Get_ui_key_view_tab_title(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_VIEW_TAB_TITLE);
+}
+
+input_seq* Get_ui_key_view_tab_pcb(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_VIEW_TAB_PCB);
+}
+
+input_seq* Get_ui_key_quit(void)
+{
+ return options_get_input_seq(settings, MUIOPTION_UI_KEY_QUIT);
+}
+
+static int GetUIJoy(const char *option_name, int joycodeIndex)
+{
+ const char *joycodes_string;
+ int joycodes[4];
+
+ assert(0 <= joycodeIndex && joycodeIndex < 4);
+ joycodes_string = settings.value( option_name);
+ ColumnDecodeStringWithCount(joycodes_string, joycodes, ARRAY_LENGTH(joycodes));
+ return joycodes[joycodeIndex];
+}
+
+static void SetUIJoy(const char *option_name, int joycodeIndex, int val)
+{
+ const char *joycodes_string;
+ int joycodes[4];
+ char buffer[1024];
+
+ assert(0 <= joycodeIndex && joycodeIndex < 4);
+ joycodes_string = settings.value( option_name);
+ ColumnDecodeStringWithCount(joycodes_string, joycodes, ARRAY_LENGTH(joycodes));
+
+ joycodes[joycodeIndex] = val;
+ ColumnEncodeStringWithCount(joycodes, buffer, ARRAY_LENGTH(joycodes));
+ std::string error_string;
+ settings.set_value(option_name, buffer, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+int GetUIJoyUp(int joycodeIndex)
+{
+ return GetUIJoy(MUIOPTION_UI_JOY_UP, joycodeIndex);
+}
+
+void SetUIJoyUp(int joycodeIndex, int val)
+{
+ SetUIJoy(MUIOPTION_UI_JOY_UP, joycodeIndex, val);
+}
+
+int GetUIJoyDown(int joycodeIndex)
+{
+ return GetUIJoy(MUIOPTION_UI_JOY_DOWN, joycodeIndex);
+}
+
+void SetUIJoyDown(int joycodeIndex, int val)
+{
+ SetUIJoy(MUIOPTION_UI_JOY_DOWN, joycodeIndex, val);
+}
+
+int GetUIJoyLeft(int joycodeIndex)
+{
+ return GetUIJoy(MUIOPTION_UI_JOY_LEFT, joycodeIndex);
+}
+
+void SetUIJoyLeft(int joycodeIndex, int val)
+{
+ SetUIJoy(MUIOPTION_UI_JOY_LEFT, joycodeIndex, val);
+}
+
+int GetUIJoyRight(int joycodeIndex)
+{
+ return GetUIJoy(MUIOPTION_UI_JOY_RIGHT, joycodeIndex);
+}
+
+void SetUIJoyRight(int joycodeIndex, int val)
+{
+ SetUIJoy(MUIOPTION_UI_JOY_RIGHT, joycodeIndex, val);
+}
+
+int GetUIJoyStart(int joycodeIndex)
+{
+ return GetUIJoy(MUIOPTION_UI_JOY_START, joycodeIndex);
+}
+
+void SetUIJoyStart(int joycodeIndex, int val)
+{
+ SetUIJoy(MUIOPTION_UI_JOY_START, joycodeIndex, val);
+}
+
+int GetUIJoyPageUp(int joycodeIndex)
+{
+ return GetUIJoy(MUIOPTION_UI_JOY_PGUP, joycodeIndex);
+}
+
+void SetUIJoyPageUp(int joycodeIndex, int val)
+{
+ SetUIJoy(MUIOPTION_UI_JOY_PGUP, joycodeIndex, val);
+}
+
+int GetUIJoyPageDown(int joycodeIndex)
+{
+ return GetUIJoy(MUIOPTION_UI_JOY_PGDWN, joycodeIndex);
+}
+
+void SetUIJoyPageDown(int joycodeIndex, int val)
+{
+ SetUIJoy(MUIOPTION_UI_JOY_PGDWN, joycodeIndex, val);
+}
+
+int GetUIJoyHome(int joycodeIndex)
+{
+ return GetUIJoy(MUIOPTION_UI_JOY_HOME, joycodeIndex);
+}
+
+void SetUIJoyHome(int joycodeIndex, int val)
+{
+ SetUIJoy(MUIOPTION_UI_JOY_HOME, joycodeIndex, val);
+}
+
+int GetUIJoyEnd(int joycodeIndex)
+{
+ return GetUIJoy(MUIOPTION_UI_JOY_END, joycodeIndex);
+}
+
+void SetUIJoyEnd(int joycodeIndex, int val)
+{
+ SetUIJoy(MUIOPTION_UI_JOY_END, joycodeIndex, val);
+}
+
+int GetUIJoySSChange(int joycodeIndex)
+{
+ return GetUIJoy(MUIOPTION_UI_JOY_SS_CHANGE, joycodeIndex);
+}
+
+void SetUIJoySSChange(int joycodeIndex, int val)
+{
+ SetUIJoy(MUIOPTION_UI_JOY_SS_CHANGE, joycodeIndex, val);
+}
+
+int GetUIJoyHistoryUp(int joycodeIndex)
+{
+ return GetUIJoy(MUIOPTION_UI_JOY_HISTORY_UP, joycodeIndex);
+}
+
+void SetUIJoyHistoryUp(int joycodeIndex, int val)
+{
+ SetUIJoy(MUIOPTION_UI_JOY_HISTORY_UP, joycodeIndex, val);
+}
+
+int GetUIJoyHistoryDown(int joycodeIndex)
+{
+ return GetUIJoy(MUIOPTION_UI_JOY_HISTORY_DOWN, joycodeIndex);
+}
+
+void SetUIJoyHistoryDown(int joycodeIndex, int val)
+{
+ SetUIJoy(MUIOPTION_UI_JOY_HISTORY_DOWN, joycodeIndex, val);
+}
+
+void SetUIJoyExec(int joycodeIndex, int val)
+{
+ SetUIJoy(MUIOPTION_UI_JOY_EXEC, joycodeIndex, val);
+}
+
+int GetUIJoyExec(int joycodeIndex)
+{
+ return GetUIJoy(MUIOPTION_UI_JOY_EXEC, joycodeIndex);
+}
+
+const char * GetExecCommand(void)
+{
+ return settings.value( MUIOPTION_EXEC_COMMAND);
+}
+
+void SetExecCommand(char *cmd)
+{
+ std::string error_string;
+ settings.set_value(MUIOPTION_EXEC_COMMAND, cmd, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+int GetExecWait(void)
+{
+ return settings.int_value(MUIOPTION_EXEC_WAIT);
+}
+
+void SetExecWait(int wait)
+{
+ std::string error_string;
+ settings.set_value(MUIOPTION_EXEC_WAIT, wait, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+BOOL GetHideMouseOnStartup(void)
+{
+ return settings.bool_value( MUIOPTION_HIDE_MOUSE);
+}
+
+void SetHideMouseOnStartup(BOOL hide)
+{
+ std::string error_string;
+ settings.set_value(MUIOPTION_HIDE_MOUSE, hide, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+BOOL GetRunFullScreen(void)
+{
+ return settings.bool_value( MUIOPTION_FULL_SCREEN);
+}
+
+void SetRunFullScreen(BOOL fullScreen)
+{
+ std::string error_string;
+ settings.set_value(MUIOPTION_FULL_SCREEN, fullScreen, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+/***************************************************************************
+ Internal functions
+ ***************************************************************************/
+
+static void CusColorEncodeString(const COLORREF *value, char* str)
+{
+ char tmpStr[256];
+
+ sprintf(tmpStr, "%u", (int) value[0]);
+
+ strcpy(str, tmpStr);
+
+ for (int i = 1; i < 16; i++)
+ {
+ sprintf(tmpStr, ",%u", (unsigned) value[i]);
+ strcat(str, tmpStr);
+ }
+}
+
+static void CusColorDecodeString(const char* str, COLORREF *value)
+{
+ char *s, *p;
+ char tmpStr[256];
+
+ strcpy(tmpStr, str);
+ p = tmpStr;
+
+ for (int i = 0; p && i < 16; i++)
+ {
+ s = p;
+
+ if ((p = strchr(s,',')) != NULL && *p == ',')
+ {
+ *p = '\0';
+ p++;
+ }
+ value[i] = atoi(s);
+ }
+}
+
+
+void ColumnEncodeStringWithCount(const int *value, char *str, int count)
+{
+ char buffer[256];
+
+ snprintf(buffer,sizeof(buffer),"%d",value[0]);
+
+ strcpy(str,buffer);
+
+ for (int i = 1; i < count; i++)
+ {
+ snprintf(buffer,sizeof(buffer),",%d",value[i]);
+ strcat(str,buffer);
+ }
+}
+
+void ColumnDecodeStringWithCount(const char* str, int *value, int count)
+{
+ char *s, *p;
+ char tmpStr[256];
+
+ if (str == NULL)
+ return;
+
+ strcpy(tmpStr, str);
+ p = tmpStr;
+
+ for (int i = 0; p && i < count; i++)
+ {
+ s = p;
+
+ if ((p = strchr(s,',')) != NULL && *p == ',')
+ {
+ *p = '\0';
+ p++;
+ }
+ value[i] = atoi(s);
+ }
+}
+
+static void SplitterEncodeString(const int *value, char* str)
+{
+ char tmpStr[256];
+
+ sprintf(tmpStr, "%d", value[0]);
+
+ strcpy(str, tmpStr);
+
+ for (int i = 1; i < GetSplitterCount(); i++)
+ {
+ sprintf(tmpStr, ",%d", value[i]);
+ strcat(str, tmpStr);
+ }
+}
+
+static void SplitterDecodeString(const char *str, int *value)
+{
+ char *s, *p;
+ char tmpStr[256];
+
+ strcpy(tmpStr, str);
+ p = tmpStr;
+
+ for (int i = 0; p && i < GetSplitterCount(); i++)
+ {
+ s = p;
+
+ if ((p = strchr(s,',')) != NULL && *p == ',')
+ {
+ *p = '\0';
+ p++;
+ }
+ value[i] = atoi(s);
+ }
+}
+
+/* Parse the given comma-delimited string into a LOGFONT structure */
+static void FontDecodeString(const char* str, LOGFONT *f)
+{
+ const char* ptr;
+ TCHAR* t_ptr;
+
+ sscanf(str, "%li,%li,%li,%li,%li,%i,%i,%i,%i,%i,%i,%i,%i",
+ &f->lfHeight,
+ &f->lfWidth,
+ &f->lfEscapement,
+ &f->lfOrientation,
+ &f->lfWeight,
+ (int*)&f->lfItalic,
+ (int*)&f->lfUnderline,
+ (int*)&f->lfStrikeOut,
+ (int*)&f->lfCharSet,
+ (int*)&f->lfOutPrecision,
+ (int*)&f->lfClipPrecision,
+ (int*)&f->lfQuality,
+ (int*)&f->lfPitchAndFamily);
+ ptr = strrchr(str, ',');
+ if (ptr)
+ {
+ t_ptr = ui_wstring_from_utf8(ptr + 1);
+ if( !t_ptr )
+ return;
+ _tcscpy(f->lfFaceName, t_ptr);
+ free(t_ptr);
+ }
+}
+
+/* Encode the given LOGFONT structure into a comma-delimited string */
+static void FontEncodeString(const LOGFONT *f, char *str)
+{
+ char* utf8_FaceName = ui_utf8_from_wstring(f->lfFaceName);
+ if( !utf8_FaceName )
+ return;
+
+ sprintf(str, "%li,%li,%li,%li,%li,%i,%i,%i,%i,%i,%i,%i,%i,%s",
+ f->lfHeight,
+ f->lfWidth,
+ f->lfEscapement,
+ f->lfOrientation,
+ f->lfWeight,
+ f->lfItalic,
+ f->lfUnderline,
+ f->lfStrikeOut,
+ f->lfCharSet,
+ f->lfOutPrecision,
+ f->lfClipPrecision,
+ f->lfQuality,
+ f->lfPitchAndFamily,
+ utf8_FaceName);
+
+ free(utf8_FaceName);
+}
+
+static void TabFlagsEncodeString(int data, char *str)
+{
+ int num_saved = 0;
+
+ strcpy(str,"");
+
+ // we save the ones that are NOT displayed, so we can add new ones
+ // and upgraders will see them
+ for ( int i=0; i<MAX_TAB_TYPES; i++)
+ {
+ if (((data & (1 << i)) == 0) && GetImageTabShortName(i))
+ {
+ if (num_saved > 0)
+ strcat(str, ", ");
+
+ strcat(str,GetImageTabShortName(i));
+ num_saved++;
+ }
+ }
+}
+
+static void TabFlagsDecodeString(const char *str, int *data)
+{
+ int j = 0;
+ char s[2000];
+ char *token;
+
+ snprintf(s, ARRAY_LENGTH(s), "%s", str);
+
+ // simple way to set all tab bits "on"
+ *data = (1 << MAX_TAB_TYPES) - 1;
+
+ token = strtok(s,", \t");
+ while (token)
+ {
+ for (j=0; j<MAX_TAB_TYPES; j++)
+ {
+ if (!GetImageTabShortName(j) || (strcmp(GetImageTabShortName(j), token) == 0))
+ {
+ // turn off this bit
+ *data &= ~(1 << j);
+ break;
+ }
+ }
+ token = strtok(NULL,", \t");
+ }
+
+ if (*data == 0)
+ {
+ // not allowed to hide all tabs, because then why even show the area?
+ *data = (1 << TAB_SCREENSHOT);
+ }
+}
+
+static void LoadSettingsFile(ui_options &opts, const char *filename)
+{
+ osd_file::error filerr;
+ util::core_file::ptr file;
+
+ filerr = util::core_file::open(filename, OPEN_FLAG_READ, file);
+ if (filerr == osd_file::error::NONE)
+ {
+ std::string error_string;
+ opts.parse_ini_file(*file, OPTION_PRIORITY_CMDLINE, OPTION_PRIORITY_CMDLINE, error_string);
+ file.reset();
+ }
+}
+
+static void LoadSettingsFile(winui_options &opts, const char *filename)
+{
+ osd_file::error filerr;
+ util::core_file::ptr file;
+
+ filerr = util::core_file::open(filename, OPEN_FLAG_READ, file);
+ if (filerr == osd_file::error::NONE)
+ {
+ std::string error_string;
+ opts.parse_ini_file(*file, OPTION_PRIORITY_CMDLINE, OPTION_PRIORITY_CMDLINE, error_string);
+ file.reset();
+ }
+}
+
+static void LoadSettingsFile(windows_options &opts, const char *filename)
+{
+ osd_file::error filerr;
+ util::core_file::ptr file;
+
+ filerr = util::core_file::open(filename, OPEN_FLAG_READ, file);
+ if (filerr == osd_file::error::NONE)
+ {
+ std::string error_string;
+ opts.parse_ini_file(*file, OPTION_PRIORITY_CMDLINE, OPTION_PRIORITY_CMDLINE, error_string);
+ file.reset();
+ }
+}
+
+// This saves changes to UI.INI only
+static void SaveSettingsFile(ui_options &opts, const char *filename)
+{
+ osd_file::error filerr = osd_file::error::NONE;
+ util::core_file::ptr file;
+
+ filerr = util::core_file::open(filename, OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS, file);
+
+ if (filerr == osd_file::error::NONE)
+ {
+ std::string inistring = opts.output_ini();
+ file->puts(inistring.c_str());
+ file.reset();
+ }
+}
+
+
+
+// This saves changes to MAMEUI.INI only
+static void SaveSettingsFile(winui_options &opts, const char *filename)
+{
+ osd_file::error filerr = osd_file::error::NONE;
+ util::core_file::ptr file;
+
+ filerr = util::core_file::open(filename, OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS, file);
+
+ if (filerr == osd_file::error::NONE)
+ {
+ std::string inistring = opts.output_ini();
+ file->puts(inistring.c_str());
+ file.reset();
+ }
+}
+
+
+
+// This saves changes to <game>.INI or MAME.INI only
+static void SaveSettingsFile(windows_options &opts, const char *filename)
+{
+ osd_file::error filerr = osd_file::error::NONE;
+ util::core_file::ptr file;
+
+ filerr = util::core_file::open(filename, OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS, file);
+
+ if (filerr == osd_file::error::NONE)
+ {
+ std::string inistring = opts.output_ini();
+ // printf("=====%s=====\n%s\n",filename,inistring.c_str()); // for debugging
+ file->puts(inistring.c_str());
+ file.reset();
+ }
+}
+
+
+
+/* Register access functions below */
+static void LoadOptionsAndSettings(void)
+{
+// char buffer[MAX_PATH];
+
+ // parse MAMEui.ini - always in the current directory.
+ LoadSettingsFile(settings, UI_INI_FILENAME);
+ LoadSettingsFile(mewui, MEWUI_FILENAME);
+
+ // parse GameInfo.ini - game options.
+ game_opts.load_file(GAMEINFO_INI_FILENAME);
+
+ // parse global options ini/mame32.ini
+ load_options(global, OPTIONS_GLOBAL, GLOBAL_OPTIONS);
+}
+
+void SetDirectories(windows_options &opts)
+{
+ std::string error_string;
+ opts.set_value(OPTION_MEDIAPATH, GetRomDirs(), OPTION_PRIORITY_CMDLINE, error_string);
+ opts.set_value(OPTION_SAMPLEPATH, GetSampleDirs(), OPTION_PRIORITY_CMDLINE, error_string);
+ opts.set_value(OPTION_INIPATH, GetIniDir(), OPTION_PRIORITY_CMDLINE, error_string);
+ opts.set_value(OPTION_CFG_DIRECTORY, GetCfgDir(), OPTION_PRIORITY_CMDLINE, error_string);
+ opts.set_value(OPTION_SNAPSHOT_DIRECTORY, GetImgDir(), OPTION_PRIORITY_CMDLINE, error_string);
+ opts.set_value(OPTION_INPUT_DIRECTORY, GetInpDir(), OPTION_PRIORITY_CMDLINE, error_string);
+ opts.set_value(OPTION_STATE_DIRECTORY, GetStateDir(), OPTION_PRIORITY_CMDLINE, error_string);
+ opts.set_value(OPTION_ARTPATH, GetArtDir(), OPTION_PRIORITY_CMDLINE, error_string);
+ opts.set_value(OPTION_NVRAM_DIRECTORY, GetNvramDir(), OPTION_PRIORITY_CMDLINE, error_string);
+ opts.set_value(OPTION_CTRLRPATH, GetCtrlrDir(), OPTION_PRIORITY_CMDLINE, error_string);
+ opts.set_value(OPTION_CHEATPATH, GetCheatDir(), OPTION_PRIORITY_CMDLINE, error_string);
+ opts.set_value(OPTION_CROSSHAIRPATH, GetCrosshairDir(), OPTION_PRIORITY_CMDLINE, error_string);
+ opts.set_value(OPTION_FONTPATH, GetFontDir(), OPTION_PRIORITY_CMDLINE, error_string);
+ opts.set_value(OPTION_DIFF_DIRECTORY, GetDiffDir(), OPTION_PRIORITY_CMDLINE, error_string);
+ opts.set_value(OPTION_SNAPNAME, GetSnapName(), OPTION_PRIORITY_CMDLINE, error_string);
+}
+
+// not used
+#if 0
+const char * GetFolderNameByID(UINT nID)
+{
+ UINT i;
+ extern const FOLDERDATA g_folderData[];
+ extern LPEXFOLDERDATA ExtraFolderData[];
+
+ for (i = 0; i < MAX_EXTRA_FOLDERS * MAX_EXTRA_SUBFOLDERS; i++)
+ if( ExtraFolderData[i] )
+ if (ExtraFolderData[i]->m_nFolderId == nID)
+ return ExtraFolderData[i]->m_szTitle;
+
+ for( i = 0; i < MAX_FOLDERS; i++)
+ if (g_folderData[i].m_nFolderId == nID)
+ return g_folderData[i].m_lpTitle;
+
+ return NULL;
+}
+#endif
+
+DWORD GetFolderFlags(int folder_index)
+{
+ LPTREEFOLDER lpFolder = GetFolder(folder_index);
+
+ if (lpFolder)
+ return lpFolder->m_dwFlags & F_MASK;
+
+ return 0;
+}
+
+
+/* Decode the flags into a DWORD */
+static DWORD DecodeFolderFlags(const char *buf)
+{
+ DWORD flags = 0;
+ int shift = 0;
+ const char *ptr = buf;
+
+ while (*ptr && (1 << shift) & F_MASK)
+ {
+ if (*ptr++ == '1')
+ {
+ flags |= (1 << shift);
+ }
+ shift++;
+ }
+ return flags;
+}
+
+/* Encode the flags into a string */
+static const char * EncodeFolderFlags(DWORD value)
+{
+ static char buf[40];
+ int shift = 0;
+
+ memset(buf,'\0', sizeof(buf));
+
+ while ((1 << shift) & F_MASK)
+ {
+ buf[shift] = (value & (1 << shift)) ? '1' : '0';
+ shift++;
+ }
+
+ return buf;
+}
+
+/* MSH 20080813
+ * Read the folder filters from MAMEui.ini. This must only
+ * be called AFTER the folders have all been created.
+ */
+void LoadFolderFlags(void)
+{
+ winui_options opts;
+ int i, numFolders = 0;
+ LPTREEFOLDER lpFolder;
+ options_entry entries[2] = { { 0 }, { 0 } };
+
+ memcpy(entries, filterOptions, sizeof(filterOptions));
+
+ numFolders = GetNumFolders();
+
+ for (i = 0; i < numFolders; i++)
+ {
+ lpFolder = GetFolder(i);
+
+ if (lpFolder)
+ {
+ char folder_name[256];
+ char *ptr;
+
+ // Convert spaces to underscores
+ strcpy(folder_name, lpFolder->m_lpTitle);
+ ptr = folder_name;
+ while (*ptr && *ptr != '\0')
+ {
+ if (*ptr == ' ')
+ {
+ *ptr = '_';
+ }
+ ptr++;
+ }
+
+ std::string option_name = std::string(folder_name) + "_filters";
+ // create entry
+ entries[0].name = option_name.c_str();
+ opts.add_entries(entries);
+ }
+ }
+
+ // These are overlaid at the end of our UI ini
+ // The normal read will skip them.
+ LoadSettingsFile(opts, UI_INI_FILENAME);
+
+ // retrieve the stored values
+ for (i = 0; i < numFolders; i++)
+ {
+ lpFolder = GetFolder(i);
+
+ if (lpFolder)
+ {
+ char folder_name[256];
+ char *ptr;
+ const char *value;
+
+ // Convert spaces to underscores
+ strcpy(folder_name, lpFolder->m_lpTitle);
+ ptr = folder_name;
+ while (*ptr && *ptr != '\0')
+ {
+ if (*ptr == ' ')
+ {
+ *ptr = '_';
+ }
+ ptr++;
+ }
+ std::string option_name = std::string(folder_name) + "_filters";
+ // get entry and decode it
+ value = opts.value(option_name.c_str());
+
+ if (value)
+ lpFolder->m_dwFlags |= DecodeFolderFlags(value) & F_MASK;
+ }
+ }
+}
+
+
+
+// Adds our folder flags to a temporary winui_options, for saving.
+static void AddFolderFlags(winui_options &opts)
+{
+ int numFolders = 0, num_entries = 0;
+ LPTREEFOLDER lpFolder;
+ options_entry entries[2] = { { 0 }, { 0 } };
+
+ entries[0].name = NULL;
+ entries[0].defvalue = NULL;
+ entries[0].flags = OPTION_HEADER;
+ entries[0].description = "FOLDER FILTERS";
+ opts.add_entries(entries);
+
+ memcpy(entries, filterOptions, sizeof(filterOptions));
+
+ numFolders = GetNumFolders();
+
+ for (int i = 0; i < numFolders; i++)
+ {
+ lpFolder = GetFolder(i);
+ if (lpFolder && (lpFolder->m_dwFlags & F_MASK) != 0)
+ {
+ char folder_name[256];
+ char *ptr;
+
+ // Convert spaces to underscores
+ strcpy(folder_name, lpFolder->m_lpTitle);
+ ptr = folder_name;
+ while (*ptr && *ptr != '\0')
+ {
+ if (*ptr == ' ')
+ {
+ *ptr = '_';
+ }
+ ptr++;
+ }
+
+ std::string option_name = std::string(folder_name) + "_filters";
+
+ // create entry
+ entries[0].name = option_name.c_str();
+ opts.add_entries(entries);
+
+ // store entry
+ std::string error_string;
+ opts.set_value(option_name.c_str(), EncodeFolderFlags(lpFolder->m_dwFlags), OPTION_PRIORITY_CMDLINE,error_string);
+
+ // increment counter
+ num_entries++;
+ }
+ }
+}
+
+// Save MAMEUI.ini
+void SaveOptions(void)
+{
+ // Add the folder flag to settings.
+ AddFolderFlags(settings);
+ // Save opts if it is non-null, else save settings.
+ // It will be null if there are no filters set.
+ SaveSettingsFile(settings, UI_INI_FILENAME);
+ SaveSettingsFile(mewui, MEWUI_FILENAME);
+}
+
+void SaveGameListOptions(void)
+{
+ // Save GameInfo.ini - game options.
+ game_opts.save_file(GAMEINFO_INI_FILENAME);
+}
+
+void SaveDefaultOptions(void)
+{
+ std::string fname = std::string(GetIniDir()) + PATH_SEPARATOR + std::string(emulator_info::get_configname()).append(".ini");
+ SaveSettingsFile(global, fname.c_str());
+}
+
+const char * GetVersionString(void)
+{
+ return emulator_info::get_build_version();
+}
+
+
+/* get options, based on passed in game number. */
+void load_options(windows_options &opts, OPTIONS_TYPE opt_type, int game_num)
+{
+ const game_driver *driver = NULL;
+ if (game_num > -1)
+ driver = &driver_list::driver(game_num);
+ CreateGameOptions(opts, opt_type, game_num);
+
+ // Try base ini first
+ std::string fname = std::string(emulator_info::get_configname()).append(".ini");
+ LoadSettingsFile(opts, fname.c_str());
+
+ if (opt_type == OPTIONS_SOURCE)
+ {
+ fname = std::string(GetIniDir()) + PATH_SEPARATOR + "source" + PATH_SEPARATOR + core_filename_extract_base(driver->source_file, true) + ".ini";
+ LoadSettingsFile(opts, fname.c_str());
+ return;
+ }
+
+ if (game_num > -2)
+ {
+ driver = &driver_list::driver(game_num);
+ // Now try global ini
+ fname = std::string(GetIniDir()) + PATH_SEPARATOR + std::string(emulator_info::get_configname()).append(".ini");
+ LoadSettingsFile(opts, fname.c_str());
+
+ if (game_num > -1)
+ {
+ // global swpath serves a different purpose than for games, so blank it out
+ std::string error_string;
+ opts.set_value(OPTION_SWPATH, "", OPTION_PRIORITY_CMDLINE,error_string);
+ // Lastly, gamename.ini
+ if (driver)
+ {
+ fname = std::string(GetIniDir()) + PATH_SEPARATOR + std::string(driver->name).append(".ini");
+ LoadSettingsFile(opts, fname.c_str());
+ }
+ }
+ }
+ SetDirectories(opts);
+}
+
+/* Save ini file based on game_number. */
+void save_options(windows_options &opts, OPTIONS_TYPE opt_type, int game_num)
+{
+ const game_driver *driver = NULL;
+ std::string filename, filepath;
+
+ if (game_num >= 0)
+ {
+ driver = &driver_list::driver(game_num);
+ if (driver)
+ {
+ filename.assign(driver->name);
+ if (opt_type == OPTIONS_SOURCE)
+ filepath = std::string(GetIniDir()) + PATH_SEPARATOR + "source" + PATH_SEPARATOR + core_filename_extract_base(driver->source_file, true) + ".ini";
+ }
+ }
+ else
+ if (game_num == -1)
+ filename = std::string(emulator_info::get_configname());
+
+ if (!filename.empty() && filepath.empty())
+ filepath = std::string(GetIniDir()).append(PATH_SEPARATOR).append(filename.c_str()).append(".ini");
+
+ if (game_num == -2)
+ filepath = std::string(emulator_info::get_configname()).append(".ini");
+
+ if (!filepath.empty())
+ {
+ SetDirectories(opts);
+ SaveSettingsFile(opts, filepath.c_str());
+// printf("Settings saved to %s\n",filepath.c_str());
+ }
+// else
+// printf("Unable to save settings\n");
+}
+
+
+// Reset the given windows_options to their default settings.
+static void ResetToDefaults(windows_options &opts, int priority)
+{
+ // iterate through the options setting each one back to the default value.
+ opts.revert(priority);
+}
+
+int GetDriverCache(int driver_index)
+{
+ return game_opts.cache(driver_index);
+}
+
+void SetDriverCache(int driver_index, int val)
+{
+ game_opts.cache(driver_index, val);
+}
+
+BOOL RequiredDriverCache(void)
+{
+ bool ret = false;
+
+ if ( strcmp(settings.value(MUIOPTION_VERSION), GetVersionString()) != 0 )
+ ret = true;
+
+ std::string error_string;
+ settings.set_value(MUIOPTION_VERSION, GetVersionString(), OPTION_PRIORITY_CMDLINE,error_string);
+
+ return ret;
+}
+
+// from optionsms.cpp (MESSUI)
+
+
+#define LOG_SOFTWARE 0
+
+void SetSLColumnOrder(int order[])
+{
+ char column_order_string[80];
+ ColumnEncodeStringWithCount(order, column_order_string, SL_COLUMN_MAX);
+ std::string error_string;
+ MameUISettings().set_value(MESSUI_SL_COLUMN_ORDER, column_order_string, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+void GetSLColumnOrder(int order[])
+{
+ const char *column_order_string;
+ column_order_string = MameUISettings().value(MESSUI_SL_COLUMN_ORDER);
+ ColumnDecodeStringWithCount(column_order_string, order, SL_COLUMN_MAX);
+}
+
+void SetSLColumnShown(int shown[])
+{
+ char column_shown_string[80];
+ ColumnEncodeStringWithCount(shown, column_shown_string, SL_COLUMN_MAX);
+ std::string error_string;
+ MameUISettings().set_value(MESSUI_SL_COLUMN_SHOWN, column_shown_string, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+void GetSLColumnShown(int shown[])
+{
+ const char *column_shown_string;
+ column_shown_string = MameUISettings().value(MESSUI_SL_COLUMN_SHOWN);
+ ColumnDecodeStringWithCount(column_shown_string, shown, SL_COLUMN_MAX);
+}
+
+void SetSLColumnWidths(int width[])
+{
+ char column_width_string[80];
+ ColumnEncodeStringWithCount(width, column_width_string, SL_COLUMN_MAX);
+ std::string error_string;
+ MameUISettings().set_value(MESSUI_SL_COLUMN_WIDTHS, column_width_string, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+void GetSLColumnWidths(int width[])
+{
+ const char *column_width_string;
+ column_width_string = MameUISettings().value(MESSUI_SL_COLUMN_WIDTHS);
+ ColumnDecodeStringWithCount(column_width_string, width, SL_COLUMN_MAX);
+}
+
+void SetSLSortColumn(int column)
+{
+ std::string error_string;
+ MameUISettings().set_value(MESSUI_SL_SORT_COLUMN, column, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+int GetSLSortColumn(void)
+{
+ return MameUISettings().int_value(MESSUI_SL_SORT_COLUMN);
+}
+
+void SetSLSortReverse(BOOL reverse)
+{
+ std::string error_string;
+ MameUISettings().set_value( MESSUI_SL_SORT_REVERSED, reverse, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+BOOL GetSLSortReverse(void)
+{
+ return MameUISettings().bool_value(MESSUI_SL_SORT_REVERSED);
+}
+
+void SetSWColumnOrder(int order[])
+{
+ char column_order_string[80];
+ ColumnEncodeStringWithCount(order, column_order_string, SW_COLUMN_MAX);
+ std::string error_string;
+ MameUISettings().set_value(MESSUI_SW_COLUMN_ORDER, column_order_string, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+void GetSWColumnOrder(int order[])
+{
+ const char *column_order_string;
+ column_order_string = MameUISettings().value(MESSUI_SW_COLUMN_ORDER);
+ ColumnDecodeStringWithCount(column_order_string, order, SW_COLUMN_MAX);
+}
+
+void SetSWColumnShown(int shown[])
+{
+ char column_shown_string[80];
+ ColumnEncodeStringWithCount(shown, column_shown_string, SW_COLUMN_MAX);
+ std::string error_string;
+ MameUISettings().set_value(MESSUI_SW_COLUMN_SHOWN, column_shown_string, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+void GetSWColumnShown(int shown[])
+{
+ const char *column_shown_string;
+ column_shown_string = MameUISettings().value(MESSUI_SW_COLUMN_SHOWN);
+ ColumnDecodeStringWithCount(column_shown_string, shown, SW_COLUMN_MAX);
+}
+
+void SetSWColumnWidths(int width[])
+{
+ char column_width_string[80];
+ ColumnEncodeStringWithCount(width, column_width_string, SW_COLUMN_MAX);
+ std::string error_string;
+ MameUISettings().set_value(MESSUI_SW_COLUMN_WIDTHS, column_width_string, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+void GetSWColumnWidths(int width[])
+{
+ const char *column_width_string;
+ column_width_string = MameUISettings().value(MESSUI_SW_COLUMN_WIDTHS);
+ ColumnDecodeStringWithCount(column_width_string, width, SW_COLUMN_MAX);
+}
+
+void SetSWSortColumn(int column)
+{
+ std::string error_string;
+ MameUISettings().set_value(MESSUI_SW_SORT_COLUMN, column, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+int GetSWSortColumn(void)
+{
+ return MameUISettings().int_value(MESSUI_SW_SORT_COLUMN);
+}
+
+void SetSWSortReverse(BOOL reverse)
+{
+ std::string error_string;
+ MameUISettings().set_value( MESSUI_SW_SORT_REVERSED, reverse, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+BOOL GetSWSortReverse(void)
+{
+ return MameUISettings().bool_value(MESSUI_SW_SORT_REVERSED);
+}
+
+void SetSelectedSoftware(int driver_index, const machine_config *config, const device_image_interface *dev, const char *software)
+{
+ std::string opt_name = dev->instance_name();
+ windows_options o;
+ std::string error_string;
+
+ if (LOG_SOFTWARE)
+ {
+ dprintf("SetSelectedSoftware(): dev=%p (\'%s\') software='%s'\n", dev, driver_list::driver(driver_index).name, software);
+ }
+
+ load_options(o, OPTIONS_GAME, driver_index);
+ o.set_value(opt_name.c_str(), software, OPTION_PRIORITY_CMDLINE,error_string);
+ save_options(o, OPTIONS_GAME, driver_index);
+}
+
+void SetCurrentSoftwareTab(const char *shortname)
+{
+ std::string error_string;
+ MameUISettings().set_value(MESSUI_SOFTWARE_TAB, shortname, OPTION_PRIORITY_CMDLINE,error_string);
+}
+
+const char *GetCurrentSoftwareTab(void)
+{
+ return MameUISettings().value(MESSUI_SOFTWARE_TAB);
+}
+
+const char* GetSLDir(void)
+{
+ return MameUISettings().value(MESSUI_SLPATH);
+}
+
+void SetSLDir(const char* paths)
+{
+ std::string error_string;
+ MameUISettings().set_value(MESSUI_SLPATH, paths, OPTION_PRIORITY_CMDLINE,error_string);
+}
+