source/src/config.cpp

   1 /*
   2         Skelton for retropc emulator
   3
   4         Author : Takeda.Toshiya
   5         Date   : 2006.08.18 -
   6
   7         [ config ]
   8 */
   9 #if defined(_USE_AGAR)
  10 #include <SDL/SDL.h>
  11 #include <agar/core.h>
  12 #include <string>
  13 #include <vector>
  14 #include "fileio.h"
  15 #include "agar_logger.h"
  16 #endif
  17
  18 #if defined(_USE_QT)
  19 #include <string>
  20 #include <vector>
  21 #include <QString>
  22 #include <QStringList>
  23 #include "fileio.h"
  24 #include "agar_logger.h"
  25 #include "qt_main.h"
  26 # if defined(Q_OS_WIN)
  27 # include <windows.h>
  28 # endif
  29 #else
  30 #include <windows.h>
  31 #endif
  32
  33
  34 #include <stdlib.h>
  35 #include <stdio.h>
  36 #include "common.h"
  37 #include "config.h"
  38 #include "fileio.h"
  39 #if defined(_USE_AGAR)
  40 #include "agar_main.h"
  41 #endif
  42
  43 config_t config;
  44
  45 #ifndef CONFIG_NAME
  46 #define CONFIG_NAME "conf"
  47 #endif
  48
  49 //extern _TCHAR* get_parent_dir(_TCHAR* file);
  50 BOOL MyWritePrivateProfileInt(LPCTSTR lpAppName, LPCTSTR lpKeyName, int Value, LPCTSTR lpFileName)
  51 {
  52         _TCHAR String[32];
  53         my_stprintf_s(String, 32, _T("%d"), Value);
  54         return MyWritePrivateProfileString(lpAppName, lpKeyName, String, lpFileName);
  55 }
  56
  57 BOOL MyWritePrivateProfileBool(LPCTSTR lpAppName, LPCTSTR lpKeyName, bool Value, LPCTSTR lpFileName)
  58 {
  59         _TCHAR String[32];
  60         my_stprintf_s(String, 32, _T("%d"), Value ? 1 : 0);
  61         return MyWritePrivateProfileString(lpAppName, lpKeyName, String, lpFileName);
  62 }
  63
  64 bool MyGetPrivateProfileBool(LPCTSTR lpAppName, LPCTSTR lpKeyName, bool bDefault, LPCTSTR lpFileName)
  65 {
  66         return (MyGetPrivateProfileInt(lpAppName, lpKeyName, bDefault ? 1 : 0, lpFileName) != 0);
  67 }
  68
  69 void init_config()
  70 {
  71         int i;
  72         // initial settings
  73         memset(&config, 0, sizeof(config_t));
  74         config.window_mode = 1;
  75 #ifdef _WIN32
  76         config.use_direct_input = true;
  77         config.disable_dwm = false;
  78 #endif
  79         config.swap_joy_buttons = false;
  80
  81 #ifndef ONE_BOARD_MICRO_COMPUTER
  82 #ifdef _WIN32
  83         config.use_d3d9 = true;
  84 #endif
  85         config.stretch_type = 1;        // Stretch (Aspect)
  86 #endif
  87         config.sound_frequency = 6;     // 48KHz
  88         config.sound_latency = 1;       // 100msec
  89
  90 #if defined(USE_TAPE)
  91         config.wave_shaper = true;
  92         config.direct_load_mzt = true;
  93         config.baud_high = true;
  94 #endif
  95 #if defined(USE_BOOT_MODE) && defined(BOOT_MODE_DEFAULT)
  96         config.boot_mode = BOOT_MODE_DEFAULT;
  97 #endif
  98 #if defined(USE_CPU_TYPE) && defined(CPU_TYPE_DEFAULT)
  99         config.cpu_type = CPU_TYPE_DEFAULT;
 100 #endif
 101 #if defined(USE_DIPSWITCH) && defined(DIPSWITCH_DEFAULT)
 102         config.dipswitch = DIPSWITCH_DEFAULT;
 103 #endif
 104 #if defined(USE_DEVICE_TYPE) && defined(DEVICE_TYPE_DEFAULT)
 105         config.device_type = DEVICE_TYPE_DEFAULT;
 106 #endif
 107 #if defined(USE_FD1)
 108         for(int drv = 0; drv < MAX_FD; drv++) {
 109 #if defined(CORRECT_DISK_TIMING_DEFAULT)
 110                 config.correct_disk_timing[drv] = CORRECT_DISK_TIMING_DEFAULT;
 111 #else
 112                 config.correct_disk_timing[drv] = true;
 113 #endif
 114 #if defined(IGNORE_DISK_CRC_DEFAULT)
 115                 config.ignore_disk_crc[drv] = IGNORE_DISK_CRC_DEFAULT;
 116 #endif
 117         }
 118 #elif defined(USE_FD1)
 119         for(int drv = 0; drv < MAX_FD; drv++) {
 120                 config.ignore_disk_crc[drv] = false;
 121         }
 122 #endif
 123 #if defined(USE_SOUND_DEVICE_TYPE) && defined(SOUND_DEVICE_TYPE_DEFAULT)
 124         config.sound_device_type = SOUND_DEVICE_TYPE_DEFAULT;
 125 #endif
 126         // FM7 Series:
 127         // 0 = PSG or NONE
 128         // 1 = OPN (+PSG)
 129         // 2 = WHG (+PSG)
 130         // 3 = WHG + OPN (+PSG)
 131         // 4 = THG  (+PSG)
 132         // 5 = THG + OPN (+PSG)
 133         // 6 = THG + WHG (+PSG)
 134         // 7 = THG + WHG + OPN (+PSG)
 135 #if defined(_FM8)
 136         config.sound_device_type = 0;   // WITHOUT PSG?
 137 #elif  defined(_FM7) || defined(_FMNEW7) || defined(_FM77) || defined(_FM77L4) || defined(_FM77L2)
 138         config.sound_device_type = 0;   // PSG ONLY
 139 #elif  defined(_FM77AV) || defined(_FM77AV20) || defined(_FM77AV40) || defined(_FM77AV40EX) || defined(_FM77AV40SX)
 140         config.sound_device_type = 1;   // OPN
 141 #endif
 142         config.multiple_speakers = false;
 143         config.general_sound_level = 0;
 144
 145 #if defined(_USE_QT)
 146         config.use_opengl_scanline = false;
 147         config.opengl_scanline_vert = false;
 148         config.opengl_scanline_horiz = false;
 149         config.use_opengl_filters = false;
 150         config.opengl_filter_num = 0;
 151 #endif
 152 #ifdef USE_MULTIPLE_SOUNDCARDS
 153         {
 154                 int ii;
 155                 for(ii = 0; ii < USE_MULTIPLE_SOUNDCARDS; ii++) {
 156                         config.sound_device_level[ii] = 0;
 157                 }
 158         }
 159 #endif
 160 }
 161
 162 void load_config()
 163 {
 164         int drv, i;
 165         // initial settings
 166         init_config();
 167
 168         // get config path
 169
 170         _TCHAR app_path[_MAX_PATH], config_path[_MAX_PATH], *ptr;
 171         memset(config_path, 0x00, _MAX_PATH);
 172         memset(app_path, 0x00, _MAX_PATH);
 173 #if defined(_USE_QT)
 174         strncpy(app_path , cpp_confdir.c_str(),  _MAX_PATH);
 175 #elif defined(_MSC_VER)
 176         GetModuleFileName(NULL, config_path, _MAX_PATH);
 177         GetFullPathName(config_path, _MAX_PATH, app_path, &ptr);
 178         if(ptr != NULL) *ptr = _T('\0');
 179 #endif
 180         my_stprintf_s(config_path, _MAX_PATH, _T("%s%s.ini"), app_path, _T(CONFIG_NAME));
 181
 182         // control
 183 #ifdef USE_BOOT_MODE
 184         config.boot_mode = MyGetPrivateProfileInt(_T("Control"), _T("BootMode"), config.boot_mode, config_path);
 185 #endif
 186 #ifdef USE_CPU_TYPE
 187         config.cpu_type = MyGetPrivateProfileInt(_T("Control"), _T("CPUType"), config.cpu_type, config_path);
 188 #endif
 189 #ifdef USE_DIPSWITCH
 190         config.dipswitch = MyGetPrivateProfileInt(_T("Control"), _T("DipSwitch"), config.dipswitch, config_path);
 191 #endif
 192 #ifdef USE_DEVICE_TYPE
 193         config.device_type = MyGetPrivateProfileInt(_T("Control"), _T("DeviceType"), config.device_type, config_path);
 194 #endif
 195 #ifdef USE_DRIVE_TYPE
 196         config.drive_type = MyGetPrivateProfileInt(_T("Control"), _T("DriveType"), config.drive_type, config_path);
 197 #endif
 198 #ifdef USE_FD1
 199         {
 200                 _TCHAR name[64];
 201                 for(drv = 0; drv < MAX_FD; drv++) {
 202                         memset(name, 0x00, sizeof(name));
 203                         my_stprintf_s(name, 64, _T("CorrectDiskTiming%d"), drv + 1);
 204                         config.correct_disk_timing[drv] = MyGetPrivateProfileBool(_T("Control"), (const _TCHAR *)name,
 205                                                                                                                                         config.correct_disk_timing[drv], config_path);
 206                         my_stprintf_s(name, 64, _T("IgnoreDiskCRC%d"), drv + 1);
 207                         config.ignore_disk_crc[drv] = MyGetPrivateProfileBool(_T("Control"), (const _TCHAR *)name,
 208                                                                                                                                 config.ignore_disk_crc[drv], config_path);
 209                 }
 210         }
 211 #endif
 212
 213 #ifdef USE_TAPE
 214         config.tape_sound = MyGetPrivateProfileBool(_T("Control"), _T("TapeSound"), config.tape_sound, config_path);
 215         config.wave_shaper = MyGetPrivateProfileBool(_T("Control"), _T("WaveShaper"), config.wave_shaper, config_path);
 216         config.direct_load_mzt = MyGetPrivateProfileBool(_T("Control"), _T("DirectLoadMZT"), config.direct_load_mzt, config_path);
 217         config.baud_high = MyGetPrivateProfileBool(_T("Control"), _T("BaudHigh"), config.baud_high, config_path);
 218 #endif
 219
 220         // recent files
 221 #ifdef USE_CART1
 222         MyGetPrivateProfileString(_T("RecentFiles"), _T("InitialCartDir"), _T(""), config.initial_cart_dir, _MAX_PATH, config_path);
 223         for(drv = 0; drv < MAX_CART; drv++) {
 224                 for(i = 0; i < MAX_HISTORY; i++) {
 225                         _TCHAR name[64];
 226                         my_stprintf_s(name, 64, _T("RecentCartPath%d_%d"), drv + 1, i + 1);
 227                         MyGetPrivateProfileString(_T("RecentFiles"), name, _T(""),
 228                                                                         config.recent_cart_path[drv][i], _MAX_PATH, config_path);
 229                 }
 230         }
 231 #endif
 232 #ifdef USE_FD1
 233         MyGetPrivateProfileString(_T("RecentFiles"), _T("InitialDiskDir"), _T(""),
 234                                                         config.initial_disk_dir, _MAX_PATH, config_path);
 235     //    get_parent_dir(config.initial_disk_dir);
 236         for(drv = 0; drv < MAX_FD; drv++) {
 237                 for(i = 0; i < MAX_HISTORY; i++) {
 238                         _TCHAR name[64];
 239                         my_stprintf_s(name, 64, _T("RecentDiskPath%d_%d"), drv + 1, i + 1);
 240                         MyGetPrivateProfileString(_T("RecentFiles"), (const _TCHAR *)name,
 241                                                                         _T(""), config.recent_disk_path[drv][i], _MAX_PATH, config_path);
 242                 }
 243         }
 244 #endif
 245 #ifdef USE_QD1
 246         MyGetPrivateProfileString(_T("RecentFiles"), _T("InitialQuickDiskDir"),
 247                                                         _T(""), config.initial_quickdisk_dir, _MAX_PATH, config_path);
 248         for(drv = 0; drv < MAX_QD; drv++) {
 249                 for(i = 0; i < MAX_HISTORY; i++) {
 250                         _TCHAR name[64];
 251                         my_stprintf_s(name, 64, _T("RecentQuickDiskPath%d_%d"), drv + 1, i + 1);
 252                         MyGetPrivateProfileString(_T("RecentFiles"), name, _T(""),
 253                                                                         config.recent_quickdisk_path[drv][i], _MAX_PATH, config_path);
 254                 }
 255         }
 256 #endif
 257
 258 #ifdef USE_TAPE
 259         MyGetPrivateProfileString(_T("RecentFiles"), _T("InitialTapeDir"), _T(""),
 260                                                         config.initial_tape_dir, _MAX_PATH, config_path);
 261         for(i = 0; i < MAX_HISTORY; i++) {
 262                 _TCHAR name[64];
 263                 my_stprintf_s(name, 64, _T("RecentTapePath1_%d"), i + 1);
 264                 MyGetPrivateProfileString(_T("RecentFiles"), (const _TCHAR *)name, _T(""),
 265                                                                 config.recent_tape_path[i], _MAX_PATH, config_path);
 266         }
 267 #endif
 268
 269 #ifdef USE_LASER_DISC
 270         MyGetPrivateProfileString(_T("RecentFiles"), _T("InitialLaserDiscDir"), _T(""),
 271                                                         config.initial_laser_disc_dir, _MAX_PATH, config_path);
 272         for(int i = 0; i < MAX_HISTORY; i++) {
 273                 _TCHAR name[64];
 274                 my_stprintf_s(name, 64, _T("RecentLaserDiscPath1_%d"), i + 1);
 275                 MyGetPrivateProfileString(_T("RecentFiles"), (const _TCHAR *)name, _T(""),
 276                                                                 config.recent_laser_disc_path[i], _MAX_PATH, config_path);
 277         }
 278 #endif
 279 #ifdef USE_BINARY_FILE1
 280         MyGetPrivateProfileString(_T("RecentFiles"), _T("InitialBinaryDir"), _T(""),
 281                                                         config.initial_binary_dir, _MAX_PATH, config_path);
 282         for(drv = 0; drv < MAX_BINARY; drv++) {
 283                 for(i = 0; i < MAX_HISTORY; i++) {
 284                         _TCHAR name[64];
 285                         my_stprintf_s(name, 64, _T("RecentBinaryPath%d_%d"), drv + 1, i + 1);
 286                         MyGetPrivateProfileString(_T("RecentFiles"), (const _TCHAR *)name, _T(""),
 287                                                                         config.recent_binary_path[drv][i], _MAX_PATH, config_path);
 288                 }
 289         }
 290 #endif
 291
 292         // screen
 293 #ifndef ONE_BOARD_MICRO_COMPUTER
 294         config.window_mode = MyGetPrivateProfileInt(_T("Screen"), _T("WindowMode"), config.window_mode, config_path);
 295 #ifdef _WIN32
 296         config.use_d3d9 = MyGetPrivateProfileBool(_T("Screen"), _T("UseD3D9"), config.use_d3d9, config_path);
 297         config.wait_vsync = MyGetPrivateProfileBool(_T("Screen"), _T("WaitVSync"), config.wait_vsync, config_path);
 298 #endif
 299         config.stretch_type = MyGetPrivateProfileInt(_T("Screen"), _T("StretchType"), config.stretch_type, config_path);
 300 #else
 301         config.window_mode = MyGetPrivateProfileInt(_T("Screen"), _T("WindowMode"), config.window_mode, config_path);
 302 #endif
 303 #ifdef USE_MONITOR_TYPE
 304         config.monitor_type = MyGetPrivateProfileInt(_T("Screen"), _T("MonitorType"), config.monitor_type, config_path);
 305 #endif
 306 #ifdef USE_CRT_FILTER
 307         config.crt_filter = MyGetPrivateProfileBool(_T("Screen"), _T("CRTFilter"), config.crt_filter, config_path);
 308 #endif
 309 #ifdef USE_SCANLINE
 310         config.scan_line = MyGetPrivateProfileBool(_T("Screen"), _T("ScanLine"), config.scan_line, config_path);
 311 #endif
 312
 313 #ifdef USE_SCREEN_ROTATE
 314         config.rotate_type = MyGetPrivateProfileInt(_T("Screen"), _T("RotateType"), config.rotate_type, config_path);
 315 #endif
 316 #if defined(_USE_QT)
 317         config.use_opengl_scanline = MyGetPrivateProfileBool(_T("Screen"), _T("UseOpenGLScanLine"),
 318                                                                                                            config.use_opengl_scanline, config_path);
 319         config.opengl_scanline_vert = MyGetPrivateProfileBool(_T("Screen"), _T("OpenGLScanLineVert"),
 320                                                                                                            config.opengl_scanline_vert, config_path);;
 321         config.opengl_scanline_horiz = MyGetPrivateProfileBool(_T("Screen"), _T("OpenGLScanLineHoriz"),
 322                                                                                                            config.opengl_scanline_horiz, config_path);;
 323         config.use_opengl_filters = MyGetPrivateProfileBool(_T("Screen"), _T("UseOpenGLFilters"),
 324                                                                                                            config.use_opengl_filters, config_path);
 325         config.opengl_filter_num =      MyGetPrivateProfileInt(_T("Screen"), _T("OpenGLFilterNum"),
 326                                                                                                          config.opengl_filter_num, config_path);
 327 #endif
 328         // sound
 329         config.sound_frequency = MyGetPrivateProfileInt(_T("Sound"), _T("Frequency"), config.sound_frequency, config_path);
 330         config.sound_latency = MyGetPrivateProfileInt(_T("Sound"), _T("Latency"), config.sound_latency, config_path);
 331 #ifdef USE_SOUND_DEVICE_TYPE
 332         config.sound_device_type = MyGetPrivateProfileInt(_T("Sound"), _T("DeviceType"), config.sound_device_type, config_path);
 333 #endif
 334 #if !defined(_USE_QT)
 335         MyGetPrivateProfileString(_T("Sound"), _T("FMGenDll"), _T("mamefm.dll"), config.fmgen_dll_path, _MAX_PATH, config_path);
 336 #endif
 337         // input
 338         config.multiple_speakers = MyGetPrivateProfileBool(_T("Sound"), _T("MultipleSpeakers"),
 339                                                                                                          config.multiple_speakers, config_path);
 340         config.general_sound_level = MyGetPrivateProfileInt(_T("Sound"), _T("GeneralSoundLevel"),
 341                                                                                                           config.general_sound_level, config_path);
 342 #ifdef USE_MULTIPLE_SOUNDCARDS
 343         {
 344                 _TCHAR _tag[128];
 345                 int ii;
 346                 for(ii = 0; ii < USE_MULTIPLE_SOUNDCARDS; ii++) {
 347                         memset(_tag, 0x00, sizeof(_tag));
 348                         my_stprintf_s(_tag, 64, _T("DeviceVolumeLevel_%d"), ii + 1);
 349                         config.sound_device_level[ii] = MyGetPrivateProfileInt(_T("Sound"), (const _TCHAR *)_tag, config.sound_device_level[ii], config_path);
 350                 }
 351         }
 352 #endif
 353 #ifdef _WIN32
 354         config.use_direct_input = MyGetPrivateProfileBool(_T("Input"), _T("UseDirectInput"), config.use_direct_input, config_path);
 355         config.disable_dwm = MyGetPrivateProfileBool(_T("Input"), _T("DisableDwm"), config.disable_dwm, config_path);
 356 #endif
 357         config.swap_joy_buttons = MyGetPrivateProfileBool(_T("Input"), _T("SwapJoyButtons"), config.swap_joy_buttons, config_path);
 358 #if defined(_USE_QT) && !defined(Q_OS_WIN)
 359         AGAR_DebugLog(AGAR_LOG_INFO, "Read Done.");
 360 #endif
 361 }
 362
 363 void save_config()
 364 {
 365         int drv, i;
 366         // get config path
 367         _TCHAR app_path[_MAX_PATH], config_path[_MAX_PATH], *ptr;
 368         memset(config_path, 0x00, _MAX_PATH);
 369         memset(app_path, 0x00, _MAX_PATH);
 370 #if defined(_USE_QT)
 371         strncpy(app_path , cpp_confdir.c_str(),  _MAX_PATH);
 372 #elif defined(_MSC_VER)
 373         GetModuleFileName(NULL, config_path, _MAX_PATH);
 374         GetFullPathName(config_path, _MAX_PATH, app_path, &ptr);
 375         if(ptr != NULL) *ptr = _T('\0');
 376 #endif
 377         my_stprintf_s(config_path, _MAX_PATH, _T("%s%s.ini"), app_path, _T(CONFIG_NAME));
 378 #if !defined(_MSC_VER)
 379         {
 380                 FILEIO *pt = new FILEIO;
 381                 if(pt->Fopen(config_path, FILEIO_WRITE_ASCII) != true) {
 382                         delete pt;
 383                         return;
 384                 }
 385                 pt->Fclose();
 386                 delete pt;
 387         }
 388
 389 #endif
 390         // control
 391 # ifdef USE_BOOT_MODE
 392         MyWritePrivateProfileInt(_T("Control"), _T("BootMode"), config.boot_mode, config_path);
 393 #endif
 394 #ifdef USE_CPU_TYPE
 395         MyWritePrivateProfileInt(_T("Control"), _T("CPUType"), config.cpu_type, config_path);
 396 #endif
 397 #ifdef USE_DIPSWITCH
 398         MyWritePrivateProfileInt(_T("Control"), _T("DipSwitch"), config.dipswitch, config_path);
 399 #endif
 400 #ifdef USE_DEVICE_TYPE
 401         MyWritePrivateProfileInt(_T("Control"), _T("DeviceType"), config.device_type, config_path);
 402 #endif
 403 #ifdef USE_DRIVE_TYPE
 404         MyWritePrivateProfileInt(_T("Control"), _T("DriveType"), config.drive_type, config_path);
 405 #endif
 406 #ifdef USE_FD1
 407         {
 408                 _TCHAR name[64];
 409                 for(drv = 0; drv < MAX_FD; drv++) {
 410                         memset(name, 0x00, sizeof(name));
 411                         my_stprintf_s(name, 64, _T("CorrectDiskTiming%d"), drv + 1);
 412                         MyWritePrivateProfileBool(_T("Control"), (const _TCHAR *)name, config.correct_disk_timing[drv], config_path);
 413                         my_stprintf_s(name, 64, _T("IgnoreDiskCRC%d"), drv + 1);
 414                         MyWritePrivateProfileBool(_T("Control"), (const _TCHAR *)name, config.ignore_disk_crc[drv], config_path);
 415                 }
 416         }
 417
 418 #endif
 419 #ifdef USE_TAPE
 420         MyWritePrivateProfileBool(_T("Control"), _T("TapeSound"), config.tape_sound, config_path);
 421         MyWritePrivateProfileBool(_T("Control"), _T("WaveShaper"), config.wave_shaper, config_path);
 422         MyWritePrivateProfileBool(_T("Control"), _T("DirectLoadMZT"), config.direct_load_mzt, config_path);
 423         MyWritePrivateProfileBool(_T("Control"), _T("BaudHigh"), config.baud_high, config_path);
 424 #endif
 425
 426         // recent files
 427 #ifdef USE_CART1
 428         MyWritePrivateProfileString(_T("RecentFiles"), _T("InitialCartDir"), config.initial_cart_dir, config_path);
 429         for(drv = 0; drv < MAX_CART; drv++) {
 430                 for(i = 0; i < MAX_HISTORY; i++) {
 431                         _TCHAR name[64];
 432                         my_stprintf_s(name, 64, _T("RecentCartPath%d_%d"), drv + 1, i + 1);
 433                         MyWritePrivateProfileString(_T("RecentFiles"), (const _TCHAR *)name, config.recent_cart_path[drv][i], config_path);
 434                 }
 435         }
 436 #endif
 437 #ifdef USE_FD1
 438         MyWritePrivateProfileString(_T("RecentFiles"), _T("InitialDiskDir"), config.initial_disk_dir, config_path);
 439         for(drv = 0; drv < MAX_FD; drv++) {
 440                 for(i = 0; i < MAX_HISTORY; i++) {
 441                         _TCHAR name[64];
 442                         my_stprintf_s(name, 64, _T("RecentDiskPath%d_%d"), drv + 1, i + 1);
 443                         MyWritePrivateProfileString(_T("RecentFiles"), (const _TCHAR *)name,
 444                                                                           config.recent_disk_path[drv][i], config_path);
 445                 }
 446         }
 447 #endif
 448 #ifdef USE_QD1
 449         MyWritePrivateProfileString(_T("RecentFiles"), _T("InitialQuickDiskDir"),
 450                                                           config.initial_quickdisk_dir, config_path);
 451         for(drv = 0; drv < MAX_QD; drv++) {
 452                 for(i = 0; i < MAX_HISTORY; i++) {
 453                         _TCHAR name[64];
 454                         my_stprintf_s(name, 64, _T("RecentQuickDiskPath%d_%d"), drv + 1, i + 1);
 455                         MyWritePrivateProfileString(_T("RecentFiles"), (const _TCHAR *)name,
 456                                                                           config.recent_quickdisk_path[drv][i], config_path);
 457                 }
 458         }
 459 #endif
 460 #ifdef USE_TAPE
 461         MyWritePrivateProfileString(_T("RecentFiles"), _T("InitialTapeDir"), config.initial_tape_dir, config_path);
 462         for(i = 0; i < MAX_HISTORY; i++) {
 463                 _TCHAR name[64];
 464                 my_stprintf_s(name, 64, _T("RecentTapePath1_%d"), i + 1);
 465                 MyWritePrivateProfileString(_T("RecentFiles"), (const _TCHAR *)name,
 466                                                                   config.recent_tape_path[i], config_path);
 467         }
 468 #endif
 469 #ifdef USE_LASER_DISC
 470         MyWritePrivateProfileString(_T("RecentFiles"), _T("InitialLaserDiscDir"), config.initial_laser_disc_dir, config_path);
 471         for(int i = 0; i < MAX_HISTORY; i++) {
 472                 _TCHAR name[64];
 473                 my_stprintf_s(name, 64, _T("RecentLaserDiscPath1_%d"), i + 1);
 474                 MyWritePrivateProfileString(_T("RecentFiles"), (const _TCHAR *)name,
 475                                                                   config.recent_laser_disc_path[i], config_path);
 476         }
 477 #endif
 478 #ifdef USE_BINARY_FILE1
 479         MyWritePrivateProfileString(_T("RecentFiles"), _T("InitialBinaryDir"), config.initial_binary_dir, config_path);
 480         for(drv = 0; drv < MAX_BINARY; drv++) {
 481                 for(i = 0; i < MAX_HISTORY; i++) {
 482                         _TCHAR name[64];
 483                         my_stprintf_s(name, 64, _T("RecentBinaryPath%d_%d"), drv + 1, i + 1);
 484                         MyWritePrivateProfileString(_T("RecentFiles"), (const _TCHAR *)name,
 485                                                                           config.recent_binary_path[drv][i], config_path);
 486                 }
 487         }
 488 #endif
 489
 490         // screen
 491 #ifndef ONE_BOARD_MICRO_COMPUTER
 492         MyWritePrivateProfileInt(_T("Screen"), _T("WindowMode"), config.window_mode, config_path);
 493 #ifdef _WIN32
 494         MyWritePrivateProfileBool(_T("Screen"), _T("UseD3D9"), config.use_d3d9, config_path);
 495         MyWritePrivateProfileBool(_T("Screen"), _T("WaitVSync"), config.wait_vsync, config_path);
 496 #endif
 497         MyWritePrivateProfileInt(_T("Screen"), _T("StretchType"), config.stretch_type, config_path);
 498 #else
 499         MyWritePrivateProfileInt(_T("Screen"), _T("WindowMode"), config.window_mode, config_path);
 500 #endif
 501 #ifdef USE_MONITOR_TYPE
 502         MyWritePrivateProfileInt(_T("Screen"), _T("MonitorType"), config.monitor_type, config_path);
 503 #endif
 504 #ifdef USE_CRT_FILTER
 505         MyWritePrivateProfileBool(_T("Screen"), _T("CRTFilter"), config.crt_filter, config_path);
 506 #endif
 507 #ifdef USE_SCANLINE
 508         MyWritePrivateProfileBool(_T("Screen"), _T("ScanLine"), config.scan_line, config_path);
 509 #endif
 510 #ifdef USE_SCREEN_ROTATE
 511         MyWritePrivateProfileInt(_T("Screen"), _T("RotateType"), config.rotate_type, config_path);
 512 #endif
 513 #if defined(_USE_QT)
 514         MyWritePrivateProfileBool(_T("Screen"), _T("UseOpenGLScanLine"),
 515                                                         config.use_opengl_scanline, config_path);
 516         MyWritePrivateProfileBool(_T("Screen"), _T("OpenGLScanLineVert"),
 517                                                         config.opengl_scanline_vert, config_path);;
 518         MyWritePrivateProfileBool(_T("Screen"), _T("OpenGLScanLineHoriz"),
 519                                                         config.opengl_scanline_horiz, config_path);;
 520         MyWritePrivateProfileBool(_T("Screen"), _T("UseOpenGLFilters"),
 521                                                         config.use_opengl_filters, config_path);
 522         MyWritePrivateProfileInt(_T("Screen"), _T("OpenGLFilterNum"),
 523                                                    config.opengl_filter_num, config_path);
 524 #endif
 525
 526         // sound
 527         MyWritePrivateProfileInt(_T("Sound"), _T("Frequency"), config.sound_frequency, config_path);
 528         MyWritePrivateProfileInt(_T("Sound"), _T("Latency"), config.sound_latency, config_path);
 529 #ifdef USE_SOUND_DEVICE_TYPE
 530         MyWritePrivateProfileInt(_T("Sound"), _T("DeviceType"), config.sound_device_type, config_path);
 531 #endif
 532 #if !defined(_USE_QT)
 533         MyWritePrivateProfileString(_T("Sound"), _T("FMGenDll"), config.fmgen_dll_path, config_path);
 534 #endif
 535         MyWritePrivateProfileBool(_T("Sound"), _T("MultipleSpeakers"),
 536                                                         config.multiple_speakers, config_path);
 537         MyWritePrivateProfileInt(_T("Sound"), _T("GeneralSoundLevel"),
 538                                                    config.general_sound_level, config_path);
 539 #ifdef USE_MULTIPLE_SOUNDCARDS
 540         {
 541                 _TCHAR _tag[128];
 542                 int ii;
 543                 for(ii = 0; ii < USE_MULTIPLE_SOUNDCARDS; ii++) {
 544                         memset(_tag, 0x00, sizeof(_tag));
 545                         my_stprintf_s(_tag, 64, _T("DeviceVolumeLevel_%d"), ii + 1);
 546                         MyWritePrivateProfileInt(_T("Sound"), (const _TCHAR *)_tag, config.sound_device_level[ii], config_path);
 547                 }
 548         }
 549 #endif
 550         // input
 551 #ifdef _WIN32
 552         MyWritePrivateProfileBool(_T("Input"), _T("UseDirectInput"), config.use_direct_input, config_path);
 553         MyWritePrivateProfileBool(_T("Input"), _T("DisableDwm"), config.disable_dwm, config_path);
 554 #endif
 555         MyWritePrivateProfileBool(_T("Input"), _T("SwapJoyButtons"), config.swap_joy_buttons, config_path);
 556 #if defined(_USE_QT) && !defined(Q_OS_WIN)
 557         AGAR_DebugLog(AGAR_LOG_INFO, "Write done.");
 558 #endif
 559 }
 560
 561 #define STATE_VERSION   3
 562
 563 void save_config_state(void *f)
 564 {
 565         FILEIO *state_fio = (FILEIO *)f;
 566         int drv;
 567
 568         state_fio->FputUint32(STATE_VERSION);
 569
 570 #ifdef USE_BOOT_MODE
 571         state_fio->FputInt32(config.boot_mode);
 572 #endif
 573 #ifdef USE_CPU_TYPE
 574         state_fio->FputInt32(config.cpu_type);
 575 #endif
 576 #ifdef USE_DIPSWITCH
 577         state_fio->FputUint32(config.dipswitch);
 578 #endif
 579 #ifdef USE_DEVICE_TYPE
 580         state_fio->FputInt32(config.device_type);
 581 #endif
 582 #ifdef USE_DRIVE_TYPE
 583         state_fio->FputInt32(config.drive_type);
 584 #endif
 585 #ifdef USE_FD1
 586         for(int drv = 0; drv < MAX_FD; drv++) {
 587                 state_fio->FputBool(config.correct_disk_timing[drv]);
 588                 state_fio->FputBool(config.ignore_disk_crc[drv]);
 589         }
 590 //      for(int drv = 0; drv < MAX_FD; drv++) {
 591 //              state_fio->FputBool(config.fdd_hack_fast_transfer[drv]);
 592 //      }
 593 #endif
 594 #ifdef USE_MONITOR_TYPE
 595         state_fio->FputInt32(config.monitor_type);
 596 #endif
 597 #ifdef USE_SOUND_DEVICE_TYPE
 598         state_fio->FputInt32(config.sound_device_type);
 599 #endif
 600
 601 }
 602
 603 bool load_config_state(void *f)
 604 {
 605         FILEIO *state_fio = (FILEIO *)f;
 606
 607         if(state_fio->FgetUint32() != STATE_VERSION) {
 608                 return false;
 609         }
 610 #ifdef USE_BOOT_MODE
 611         config.boot_mode = state_fio->FgetInt32();
 612 #endif
 613 #ifdef USE_CPU_TYPE
 614         config.cpu_type = state_fio->FgetInt32();
 615 #endif
 616 #ifdef USE_DIPSWITCH
 617         config.dipswitch = state_fio->FgetUint32();
 618 #endif
 619 #ifdef USE_DEVICE_TYPE
 620         config.device_type = state_fio->FgetInt32();
 621 #endif
 622 #ifdef USE_DRIVE_TYPE
 623         config.drive_type = state_fio->FgetInt32();
 624 #endif
 625 #ifdef USE_FD1
 626         for(int drv = 0; drv < MAX_FD; drv++) {
 627                 config.correct_disk_timing[drv] = state_fio->FgetBool();
 628                 config.ignore_disk_crc[drv] = state_fio->FgetBool();
 629         }
 630 //      for(int drv = 0; drv < MAX_FD; drv++) {
 631 //              config.fdd_hack_fast_transfer[drv] = state_fio->FgetBool();
 632 //      }
 633 #endif
 634 #ifdef USE_MONITOR_TYPE
 635         config.monitor_type = state_fio->FgetInt32();
 636 #endif
 637 #ifdef USE_SOUND_DEVICE_TYPE
 638         config.sound_device_type = state_fio->FgetInt32();
 639 #endif
 640         return true;
 641 }
 642