|
version 1.3, 2003/10/26 08:59:53
|
version 1.43, 2007/01/08 01:16:59
|
|
Line 1
|
Line 1
|
| #include "compiler.h" |
#include "compiler.h" |
| #include <windowsx.h> |
#include <windowsx.h> |
| #include <io.h> |
#include <io.h> |
| |
#include "strres.h" |
| |
#include "profile.h" |
| #include "np2.h" |
#include "np2.h" |
| #include "np2arg.h" |
#include "np2arg.h" |
| |
#if defined(OSLANG_UCS2) |
| |
#include "oemtext.h" |
| |
#endif |
| #include "dosio.h" |
#include "dosio.h" |
| #include "ini.h" |
#include "ini.h" |
| #include "winkbd.h" |
#include "winkbd.h" |
| #include "pccore.h" |
#include "pccore.h" |
| |
|
| |
|
| #define CFGLEN (MAX_PATH + 32) |
|
| |
|
| static const char ini_title[] = "NekoProjectII"; |
|
| |
|
| typedef struct { |
// ---- user |
| char item[9]; |
|
| BYTE itemtype; |
|
| WORD flag; |
|
| void *value; |
|
| DWORD arg; |
|
| } INI_ITEM; |
|
| |
|
| #define INI_RO 0x0001 |
|
| #define INIAND 0x0002 |
|
| #define INIMAX 0x0004 |
|
| #define INIA4 0x0008 |
|
| #define INIEND 0x8000 |
|
| |
|
| #define INI_STR 0x00 |
|
| #define INI_BOOL 0x01 |
|
| #define INI_ARG 0x02 |
|
| #define INI_BYTE 0x11 |
|
| #define INI_WORD 0x12 |
|
| #define INI_DWORD 0x14 |
|
| #define INI_HEXB 0x21 |
|
| #define INI_HEXD 0x24 |
|
| #define INI_EX 0x80 |
|
| |
|
| |
|
| static INI_ITEM iniitem[] = { |
|
| |
|
| {"np2title", INI_STR, INI_RO|INIMAX, |
|
| np2oscfg.titles, sizeof(np2oscfg.titles)}, |
|
| {"np2winid", INI_EX|0, INI_RO, np2oscfg.winid, 0}, |
|
| |
|
| {"WindposX", INI_DWORD, 0, &np2oscfg.winx, 0}, |
|
| {"WindposY", INI_DWORD, 0, &np2oscfg.winy, 0}, |
|
| {"paddingx", INI_DWORD, INI_RO|INIMAX, |
|
| &np2oscfg.paddingx, 32}, |
|
| {"paddingy", INI_DWORD, INI_RO|INIMAX, |
|
| &np2oscfg.paddingy, 32}, |
|
| {"Win_Snap", INI_BOOL, 0, &np2oscfg.WINSNAP, 0}, |
|
| |
|
| {"FDfolder", INI_STR, INIMAX, fddfolder, MAX_PATH}, |
|
| {"HDfolder", INI_STR, INIMAX, hddfolder, MAX_PATH}, |
|
| {"bmap_Dir", INI_STR, INIMAX, bmpfilefolder, MAX_PATH}, |
|
| |
|
| {"fontfile", INI_STR, INIMAX, np2cfg.fontfile, MAX_PATH}, |
|
| |
|
| {"clk_base", INI_DWORD, 0, &np2cfg.baseclock, 0}, |
|
| {"clk_mult", INI_DWORD, 0, &np2cfg.multiple, 0}, |
|
| |
|
| {"DIPswtch", INI_ARG, 0, np2cfg.dipsw, 3}, |
|
| {"MEMswtch", INI_ARG, 0, np2cfg.memsw, 8}, |
|
| {"ExMemory", INI_BYTE, INIMAX, &np2cfg.EXTMEM, 13}, |
|
| {"ITF_WORK", INI_BOOL, INI_RO, &np2cfg.ITF_WORK, 0}, |
|
| |
|
| {"HDD1FILE", INI_STR, INIMAX, np2cfg.hddfile[0], MAX_PATH}, |
|
| {"HDD2FILE", INI_STR, INIMAX, np2cfg.hddfile[1], MAX_PATH}, |
|
| // {"Removabl", INI_EX|1, 0, &np2cfg.REMOVEHD, 0}, |
|
| |
|
| {"SampleHz", INI_WORD, 0, &np2cfg.samplingrate, 0}, |
|
| {"Latencys", INI_WORD, 0, &np2cfg.delayms, 0}, |
|
| {"SNDboard", INI_HEXB, 0, &np2cfg.SOUND_SW, 0}, |
|
| {"BEEP_vol", INI_BYTE, INIAND, &np2cfg.BEEP_VOL, 0x03}, |
|
| {"xspeaker", INI_BOOL, INI_RO, &np2cfg.snd_x, 0}, |
|
| |
|
| {"SND14vol", INI_ARG, INIA4, np2cfg.vol14, 6}, // ver0.27 |
|
| // {"opt14BRD", INI_ARG, 0, np2cfg.snd14opt, 3}, |
|
| {"opt26BRD", INI_HEXB, 0, &np2cfg.snd26opt, 0}, |
|
| {"opt86BRD", INI_HEXB, 0, &np2cfg.snd86opt, 0}, |
|
| {"optSPBRD", INI_HEXB, 0, &np2cfg.spbopt, 0}, |
|
| {"optSPBVR", INI_HEXB, 0, &np2cfg.spb_vrc, 0}, // ver0.30 |
|
| {"optSPBVL", INI_BYTE, INIMAX, &np2cfg.spb_vrl, 24}, // ver0.30 |
|
| {"optSPB_X", INI_BOOL, 0, &np2cfg.spb_x, 0}, |
|
| {"optMPU98", INI_HEXB, 0, &np2cfg.mpuopt, 0}, |
|
| |
|
| {"volume_F", INI_BYTE, INIMAX, &np2cfg.vol_fm, 128}, // ver0.28 |
|
| {"volume_S", INI_BYTE, INIMAX, &np2cfg.vol_ssg, 128}, |
|
| {"volume_A", INI_BYTE, INIMAX, &np2cfg.vol_adpcm, 128}, |
|
| {"volume_P", INI_BYTE, INIMAX, &np2cfg.vol_pcm, 128}, |
|
| {"volume_R", INI_BYTE, INIMAX, &np2cfg.vol_rhythm, 128}, |
|
| |
|
| {"Seek_Snd", INI_BOOL, 0, &np2cfg.MOTOR, 0}, |
|
| {"Seek_Vol", INI_BYTE, INIMAX, &np2cfg.MOTORVOL, 100}, |
|
| |
|
| {"btnRAPID", INI_BOOL, 0, &np2cfg.BTN_RAPID, 0}, |
|
| {"btn_MODE", INI_BOOL, 0, &np2cfg.BTN_MODE, 0}, |
|
| {"Mouse_sw", INI_BOOL, 0, &np2oscfg.MOUSE_SW, 0}, |
|
| {"MS_RAPID", INI_BOOL, 0, &np2cfg.MOUSERAPID, 0}, |
|
| |
|
| {"backgrnd", INI_BYTE, INIAND, &np2oscfg.background, 0x03}, |
|
| {"VRAMwait", INI_ARG, 0, np2cfg.wait, 6}, |
|
| {"DspClock", INI_BYTE, INIAND, &np2oscfg.DISPCLK, 0x03}, |
|
| {"DispSync", INI_BOOL, 0, &np2cfg.DISPSYNC, 0}, |
|
| {"Real_Pal", INI_BOOL, 0, &np2cfg.RASTER, 0}, |
|
| {"RPal_tim", INI_BYTE, INIMAX, &np2cfg.realpal, 64}, |
|
| {"s_NOWAIT", INI_BOOL, 0, &np2oscfg.NOWAIT, 0}, |
|
| {"SkpFrame", INI_BYTE, 0, &np2oscfg.DRAW_SKIP, 0}, |
|
| {"uPD72020", INI_BOOL, 0, &np2cfg.uPD72020, 0}, |
|
| {"GRCG_EGC", INI_BYTE, INIAND, &np2cfg.grcg, 0x03}, |
|
| {"color16b", INI_BOOL, 0, &np2cfg.color16, 0}, |
|
| {"skipline", INI_BOOL, 0, &np2cfg.skipline, 0}, |
|
| {"skplight", INI_WORD, 0, &np2cfg.skiplight, 0}, |
|
| {"LCD_MODE", INI_BYTE, INIAND, &np2cfg.LCD_MODE, 0x03}, |
|
| {"BG_COLOR", INI_HEXD, INI_RO|INIAND, |
|
| &np2cfg.BG_COLOR, 0xffffff}, |
|
| {"FG_COLOR", INI_HEXD, INI_RO|INIAND, |
|
| &np2cfg.FG_COLOR, 0xffffff}, |
|
| |
|
| {"pc9861_e", INI_BOOL, 0, &np2cfg.pc9861enable, 0}, // ver0.29 |
|
| {"pc9861_s", INI_ARG, 0, np2cfg.pc9861sw, 3}, |
|
| {"pc9861_j", INI_ARG, 0, np2cfg.pc9861jmp, 6}, |
|
| |
|
| {"calendar", INI_BOOL, 0, &np2cfg.calendar, 0}, // ver0.34 |
|
| {"USE144FD", INI_BOOL, 0, &np2cfg.usefd144, 0}, // ver0.31 |
|
| |
|
| // OS°Í¸¡© // ver0.29 |
|
| {"keyboard", INI_EX|3, INI_RO, &np2oscfg.KEYBOARD, 0}, |
|
| {"F12_COPY", INI_BYTE, 0, &np2oscfg.F12COPY, 0}, |
|
| {"Joystick", INI_BOOL, 0, &np2oscfg.JOYPAD1, 0}, // ver0.28 |
|
| {"Joy1_btn", INI_ARG, 0, np2oscfg.JOY1BTN, 4}, |
|
| |
|
| {"clocknow", INI_BYTE, 0, &np2oscfg.clk_x, 0}, |
|
| {"clockfnt", INI_BYTE, 0, &np2oscfg.clk_fnt, 0}, |
|
| {"clock_up", INI_HEXD, INI_RO|INIAND, |
|
| &np2oscfg.clk_color1, 0xffffff}, |
|
| {"clock_dn", INI_HEXD, INI_RO|INIAND, |
|
| &np2oscfg.clk_color2, 0xffffff}, |
|
| |
|
| {"use_sstp", INI_BOOL, 0, &np2oscfg.sstp, 0}, |
|
| {"sstpport", INI_WORD, 0, &np2oscfg.sstpport, 0}, |
|
| {"comfirm_", INI_BOOL, 0, &np2oscfg.comfirm, 0}, |
|
| {"shortcut", INI_HEXB, 0, &np2oscfg.shortcut, 0}, // ver0.30 |
|
| |
|
| |
|
| {"mpu98map", INI_STR, INIMAX, np2oscfg.mpu.mout, MAXPNAMELEN}, |
|
| {"mpu98min", INI_STR, INIMAX, np2oscfg.mpu.min, MAXPNAMELEN}, |
|
| {"mpu98mdl", INI_STR, INIMAX, np2oscfg.mpu.mdl, 64}, |
|
| {"mpu98def", INI_STR, INIMAX, np2oscfg.mpu.def, MAX_PATH}, |
|
| |
|
| {"com1port", INI_BYTE, INIMAX, &np2oscfg.com1.port, 5}, // ver0.34 |
|
| {"com1para", INI_BYTE, 0, &np2oscfg.com1.param, 0}, |
|
| {"com1_bps", INI_DWORD, 0, &np2oscfg.com1.speed, 0}, |
|
| {"com1mmap", INI_STR, INIMAX, np2oscfg.com1.mout, MAXPNAMELEN}, |
|
| {"com1mmdl", INI_STR, INIMAX, np2oscfg.com1.mdl, 64}, |
|
| {"com1mdef", INI_STR, INIMAX, np2oscfg.com1.def, MAX_PATH}, |
|
| |
|
| {"com2port", INI_BYTE, INIMAX, &np2oscfg.com2.port, 5}, // ver0.34 |
|
| {"com2para", INI_BYTE, 0, &np2oscfg.com2.param, 0}, |
|
| {"com2_bps", INI_DWORD, 0, &np2oscfg.com2.speed, 0}, |
|
| {"com2mmap", INI_STR, INIMAX, np2oscfg.com2.mout, MAXPNAMELEN}, |
|
| {"com2mmdl", INI_STR, INIMAX, np2oscfg.com2.mdl, 64}, |
|
| {"com2mdef", INI_STR, INIMAX, np2oscfg.com2.def, MAX_PATH}, |
|
| |
|
| {"com3port", INI_BYTE, INIMAX, &np2oscfg.com3.port, 5}, // ver0.34 |
|
| {"com3para", INI_BYTE, 0, &np2oscfg.com3.param, 0}, |
|
| {"com3_bps", INI_DWORD, 0, &np2oscfg.com3.speed, 0}, |
|
| {"com3mmap", INI_STR, INIMAX, np2oscfg.com3.mout, MAXPNAMELEN}, |
|
| {"com3mmdl", INI_STR, INIMAX, np2oscfg.com3.mdl, 64}, |
|
| {"com3mdef", INI_STR, INIMAX, np2oscfg.com3.def, MAX_PATH}, |
|
| |
|
| {"force400", INI_BOOL, INI_RO, &np2oscfg.force400, 0}, |
|
| {"e_resume", INI_BOOL, 0, &np2oscfg.resume, 0}, // ver0.30 |
|
| {"STATSAVE", INI_BOOL, INI_RO, &np2oscfg.statsave, 0}, // ver0.30 |
|
| {"nousemmx", INI_BOOL, 0, &np2oscfg.disablemmx, 0}, // ver0.36 |
|
| {"I286SAVE", INI_BOOL, INI_RO|INIEND, |
|
| &np2oscfg.I286SAVE, 0}}; |
|
| |
|
| #define INIITEMS (sizeof(iniitem) / sizeof(INI_ITEM)) |
|
| |
|
| |
|
| static long solveHEX(char *str) { |
|
| |
|
| return(milstr_solveHEX(str)); |
|
| } |
|
| |
|
| static char *makeBOOL(BYTE value) { |
|
| |
|
| if (value) { |
|
| return("true"); |
|
| } |
|
| return("false"); |
|
| } |
|
| |
|
| static BYTE solveBOOL(LPSTR str) { |
|
| |
|
| if ((!milstr_cmp(str, "TRUE")) || (!milstr_cmp(str, "ON")) || |
|
| (!milstr_cmp(str, "+")) || (!milstr_cmp(str, "1")) || |
|
| (!milstr_cmp(str, "ENABLE"))) { |
|
| return(1); |
|
| } |
|
| return(0); |
|
| } |
|
| |
|
| |
static void inirdargs16(const OEMCHAR *src, const PFTBL *ini) { |
| |
|
| static void getinifile(char *initfile, int max) { |
SINT16 *dst; |
| |
int dsize; |
| |
int i; |
| |
OEMCHAR c; |
| |
|
| char *p; |
dst = (SINT16 *)ini->value; |
| |
dsize = ini->arg; |
| |
|
| milstr_ncpy(initfile, modulefile, max); |
for (i=0; i<dsize; i++) { |
| if (np2arg.ini) { |
while(*src == ' ') { |
| if ((np2arg.ini[0] == '/') || (np2arg.ini[0] == '-')) { |
src++; |
| file_cutname(initfile); |
|
| milstr_ncat(initfile, file_getname(np2arg.ini + 2), max); |
|
| } |
} |
| else { |
if (*src == '\0') { |
| milstr_ncpy(initfile, np2arg.ini, max); |
break; |
| |
} |
| |
dst[i] = (SINT16)milstr_solveINT(src); |
| |
while(*src != '\0') { |
| |
c = *src++; |
| |
if (c == ',') { |
| |
break; |
| |
} |
| |
} |
| |
} |
| |
} |
| |
|
| |
static void inirdbyte3(const OEMCHAR *src, const PFTBL *ini) { |
| |
|
| |
UINT i; |
| |
|
| |
for (i=0; i<3; i++) { |
| |
if (src[i] == '\0') { |
| |
break; |
| } |
} |
| p = file_getext(initfile); |
if ((((src[i] - '0') & 0xff) < 9) || |
| if (!(*p)) { |
(((src[i] - 'A') & 0xdf) < 26)) { |
| milstr_ncat(initfile, ".ini", max); |
((UINT8 *)ini->value)[i] = (UINT8)src[i]; |
| } |
} |
| } |
} |
| |
} |
| |
|
| |
static void inirdkb(const OEMCHAR *src, const PFTBL *ini) { |
| |
|
| |
if ((!milstr_extendcmp(src, OEMTEXT("PC98"))) || |
| |
(!milstr_cmp(src, OEMTEXT("98")))) { |
| |
*(UINT8 *)ini->value = KEY_PC98; |
| |
} |
| |
else if ((!milstr_extendcmp(src, OEMTEXT("DOS"))) || |
| |
(!milstr_cmp(src, OEMTEXT("PCAT"))) || |
| |
(!milstr_cmp(src, OEMTEXT("AT")))) { |
| |
*(UINT8 *)ini->value = KEY_KEY106; |
| |
} |
| |
else if ((!milstr_extendcmp(src, OEMTEXT("KEY101"))) || |
| |
(!milstr_cmp(src, OEMTEXT("101")))) { |
| |
*(UINT8 *)ini->value = KEY_KEY101; |
| |
} |
| |
} |
| |
|
| |
|
| |
// ---- Use WinAPI |
| |
|
| |
#if !defined(_UNICODE) |
| |
static void bitmapset(UINT8 *ptr, UINT pos, BOOL set) { |
| |
|
| |
UINT8 bit; |
| |
|
| |
ptr += (pos >> 3); |
| |
bit = 1 << (pos & 7); |
| |
if (set) { |
| |
*ptr |= bit; |
| |
} |
| else { |
else { |
| file_cutext(initfile); |
*ptr &= ~bit; |
| milstr_ncat(initfile, ".ini", max); |
|
| } |
} |
| } |
} |
| |
|
| |
static BOOL bitmapget(const UINT8 *ptr, UINT pos) { |
| |
|
| void initload(void) { |
return((ptr[pos >> 3] >> (pos & 7)) & 1); |
| |
} |
| |
|
| char initfile[MAX_PATH]; |
static void binset(UINT8 *bin, UINT binlen, const OEMCHAR *src) { |
| char cfgstr[CFGLEN]; |
|
| DWORD i; |
UINT i; |
| char *arg[8]; |
UINT8 val; |
| DWORD args; |
BOOL set; |
| INI_ITEM *p; |
OEMCHAR c; |
| |
|
| getinifile(initfile, MAX_PATH); // ver0.29 |
for (i=0; i<binlen; i++) { |
| p = iniitem; |
val = 0; |
| while(1) { |
set = FALSE; |
| if (!(p->itemtype & 0xf0)) { |
while(*src == ' ') { |
| switch(p->itemtype) { |
src++; |
| case INI_STR: |
} |
| GetPrivateProfileString(ini_title, p->item, |
while(1) { |
| (char *)p->value, (char *)p->value, |
c = *src; |
| p->arg, initfile); |
if ((c == '\0') || (c == ' ')) { |
| break; |
break; |
| case INI_BOOL: |
|
| GetPrivateProfileString(ini_title, p->item, |
|
| makeBOOL(*((BYTE *)p->value) & 1), |
|
| cfgstr, CFGLEN, initfile); |
|
| *(BYTE *)(p->value) = solveBOOL(cfgstr); |
|
| break; |
|
| case INI_ARG: |
|
| GetPrivateProfileString(ini_title, p->item, "", |
|
| cfgstr, CFGLEN, initfile); |
|
| args = milstr_getarg(cfgstr, arg, p->arg); |
|
| if (args == p->arg) { |
|
| for (i=0; i<args; i++) { |
|
| ((BYTE *)p->value)[i] = (BYTE)solveHEX(arg[i]); |
|
| if (p->flag & INIA4) { |
|
| ((BYTE *)p->value)[i] &= 0x0f; |
|
| } |
|
| } |
|
| } |
|
| break; |
|
| } |
} |
| } |
else if ((c >= '0') && (c <= '9')) { |
| else if (!(p->itemtype & INI_EX)) { |
val <<= 4; |
| switch(p->itemtype) { |
val += c - '0'; |
| case INI_BYTE: |
set = TRUE; |
| *(BYTE *)p->value = (BYTE)GetPrivateProfileInt( |
|
| ini_title, p->item, *(BYTE *)p->value, initfile); |
|
| break; |
|
| case INI_WORD: |
|
| *(WORD *)p->value = (WORD)GetPrivateProfileInt( |
|
| ini_title, p->item, *(WORD *)p->value, initfile); |
|
| break; |
|
| case INI_DWORD: |
|
| *(DWORD *)p->value = (DWORD)GetPrivateProfileInt( |
|
| ini_title, p->item, *(DWORD *)p->value, initfile); |
|
| break; |
|
| case INI_HEXB: |
|
| wsprintf(cfgstr, "%x", *(BYTE *)p->value), |
|
| GetPrivateProfileString(ini_title, p->item, |
|
| cfgstr, cfgstr, CFGLEN, initfile); |
|
| *(BYTE *)p->value = (BYTE)solveHEX(cfgstr); |
|
| break; |
|
| case INI_HEXD: |
|
| wsprintf(cfgstr, "%x", *(DWORD *)p->value), |
|
| GetPrivateProfileString(ini_title, p->item, |
|
| cfgstr, cfgstr, CFGLEN, initfile); |
|
| *(DWORD *)p->value = solveHEX(cfgstr); |
|
| break; |
|
| } |
} |
| if (p->flag & INIMAX) { |
else { |
| switch((p->itemtype) & 0x0f) { |
c |= 0x20; |
| case 1: |
if ((c >= 'a') && (c <= 'f')) { |
| if (*(BYTE *)p->value > (BYTE)p->arg) { |
val <<= 4; |
| *(BYTE *)p->value = (BYTE)p->arg; |
val += c - 'a' + 10; |
| } |
set = TRUE; |
| break; |
|
| case 2: |
|
| if (*(WORD *)p->value > (WORD)p->arg) { |
|
| *(WORD *)p->value = (WORD)p->arg; |
|
| } |
|
| break; |
|
| case 4: |
|
| if (*(DWORD *)p->value > (DWORD)p->arg) { |
|
| *(DWORD *)p->value = (DWORD)p->arg; |
|
| } |
|
| break; |
|
| } |
|
| } |
|
| if (p->flag & INIAND) { |
|
| switch((p->itemtype) & 0x0f) { |
|
| case 1: |
|
| *(BYTE *)p->value &= (BYTE)p->arg; |
|
| break; |
|
| case 2: |
|
| *(WORD *)p->value &= (WORD)p->arg; |
|
| break; |
|
| case 4: |
|
| *(DWORD *)p->value &= (DWORD)p->arg; |
|
| break; |
|
| } |
} |
| } |
} |
| |
src++; |
| } |
} |
| else { |
if (set == FALSE) { |
| switch(p->itemtype) { |
|
| case INI_EX|0: // winid |
|
| GetPrivateProfileString(ini_title, p->item, |
|
| (char *)p->value, cfgstr, CFGLEN, initfile); |
|
| for (i=0; i<3; i++) { |
|
| if (((cfgstr[i] >= '0') && (cfgstr[i] < '9')) || |
|
| ((cfgstr[i] >= 'A') && (cfgstr[i] < 'Z')) || |
|
| ((cfgstr[i] >= 'a') && (cfgstr[i] < 'z'))) { |
|
| ((BYTE *)p->value)[i] = cfgstr[i]; |
|
| } |
|
| } |
|
| break; |
|
| case INI_EX|1: // remove hdd |
|
| *(BYTE *)p->value = |
|
| (BYTE)((GetPrivateProfileInt(ini_title, p->item, |
|
| ((*(BYTE *)p->value) & 1) + 1, |
|
| initfile) - 1) & 1); |
|
| break; |
|
| #if 0 |
|
| case INI_EX|2: // midi module |
|
| GetPrivateProfileString(ini_title, p->item, |
|
| MIDI_num2module(*(BYTE *)p->value), |
|
| cfgstr, CFGLEN, initfile); |
|
| *(BYTE *)p->value = MIDI_module2num(cfgstr); |
|
| break; |
|
| #endif |
|
| case INI_EX|3: // keyboard |
|
| GetPrivateProfileString(ini_title, p->item, "unknown", |
|
| cfgstr, CFGLEN, initfile); |
|
| if ((!milstr_extendcmp(cfgstr, "PC98")) || |
|
| (!milstr_cmp(cfgstr, "98"))) { |
|
| *(BYTE *)p->value = KEY_PC98; |
|
| } |
|
| else if ((!milstr_extendcmp(cfgstr, "DOS")) || |
|
| (!milstr_cmp(cfgstr, "PCAT")) || |
|
| (!milstr_cmp(cfgstr, "AT"))) { |
|
| *(BYTE *)p->value = KEY_KEY106; |
|
| } |
|
| else if ((!milstr_extendcmp(cfgstr, "KEY101")) || |
|
| (!milstr_cmp(cfgstr, "101"))) { |
|
| *(BYTE *)p->value = KEY_KEY101; |
|
| } |
|
| break; |
|
| } |
|
| } |
|
| if (p->flag & INIEND) { |
|
| break; |
break; |
| } |
} |
| |
bin[i] = val; |
| |
} |
| |
} |
| |
|
| |
static void binget(OEMCHAR *work, int size, const UINT8 *bin, UINT binlen) { |
| |
|
| |
UINT i; |
| |
OEMCHAR tmp[8]; |
| |
|
| |
if (binlen) { |
| |
OEMSPRINTF(tmp, OEMTEXT("%.2x"), bin[0]); |
| |
milstr_ncpy(work, tmp, size); |
| |
} |
| |
for (i=1; i<binlen; i++) { |
| |
OEMSPRINTF(tmp, OEMTEXT(" %.2x"), bin[i]); |
| |
milstr_ncat(work, tmp, size); |
| |
} |
| |
} |
| |
|
| |
void ini_read(const OEMCHAR *path, const OEMCHAR *title, |
| |
const PFTBL *tbl, UINT count) { |
| |
|
| |
const PFTBL *p; |
| |
const PFTBL *pterm; |
| |
OEMCHAR work[512]; |
| |
UINT32 val; |
| |
|
| |
p = tbl; |
| |
pterm = tbl + count; |
| |
while(p < pterm) { |
| |
switch(p->itemtype & PFTYPE_MASK) { |
| |
case PFTYPE_STR: |
| |
GetPrivateProfileString(title, p->item, (OEMCHAR *)p->value, |
| |
(OEMCHAR *)p->value, p->arg, path); |
| |
break; |
| |
|
| |
case PFTYPE_BOOL: |
| |
GetPrivateProfileString(title, p->item, |
| |
(*((UINT8 *)p->value))?str_true:str_false, |
| |
work, NELEMENTS(work), path); |
| |
*((UINT8 *)p->value) = (!milstr_cmp(work, str_true))?1:0; |
| |
break; |
| |
|
| |
case PFTYPE_BITMAP: |
| |
GetPrivateProfileString(title, p->item, |
| |
(bitmapget((UINT8 *)p->value, p->arg))?str_true:str_false, |
| |
work, NELEMENTS(work), path); |
| |
bitmapset((UINT8 *)p->value, p->arg, |
| |
(milstr_cmp(work, str_true) == 0)); |
| |
break; |
| |
|
| |
case PFTYPE_BIN: |
| |
GetPrivateProfileString(title, p->item, str_null, |
| |
work, NELEMENTS(work), path); |
| |
binset((UINT8 *)p->value, p->arg, work); |
| |
break; |
| |
|
| |
case PFTYPE_SINT8: |
| |
case PFTYPE_UINT8: |
| |
val = (UINT8)GetPrivateProfileInt(title, p->item, |
| |
*(UINT8 *)p->value, path); |
| |
*(UINT8 *)p->value = (UINT8)val; |
| |
break; |
| |
|
| |
case PFTYPE_SINT16: |
| |
case PFTYPE_UINT16: |
| |
val = (UINT16)GetPrivateProfileInt(title, p->item, |
| |
*(UINT16 *)p->value, path); |
| |
*(UINT16 *)p->value = (UINT16)val; |
| |
break; |
| |
|
| |
case PFTYPE_SINT32: |
| |
case PFTYPE_UINT32: |
| |
val = (UINT32)GetPrivateProfileInt(title, p->item, |
| |
*(UINT32 *)p->value, path); |
| |
*(UINT32 *)p->value = (UINT32)val; |
| |
break; |
| |
|
| |
case PFTYPE_HEX8: |
| |
OEMSPRINTF(work, str_x, *(UINT8 *)p->value), |
| |
GetPrivateProfileString(title, p->item, work, |
| |
work, NELEMENTS(work), path); |
| |
val = (UINT8)milstr_solveHEX(work); |
| |
*(UINT8 *)p->value = (UINT8)val; |
| |
break; |
| |
|
| |
case PFTYPE_HEX16: |
| |
OEMSPRINTF(work, str_x, *(UINT16 *)p->value), |
| |
GetPrivateProfileString(title, p->item, work, |
| |
work, NELEMENTS(work), path); |
| |
val = (UINT16)milstr_solveHEX(work); |
| |
*(UINT16 *)p->value = (UINT16)val; |
| |
break; |
| |
|
| |
case PFTYPE_HEX32: |
| |
OEMSPRINTF(work, str_x, *(UINT32 *)p->value), |
| |
GetPrivateProfileString(title, p->item, work, |
| |
work, NELEMENTS(work), path); |
| |
val = (UINT32)milstr_solveHEX(work); |
| |
*(UINT32 *)p->value = (UINT32)val; |
| |
break; |
| |
|
| |
case PFTYPE_ARGS16: |
| |
GetPrivateProfileString(title, p->item, str_null, |
| |
work, NELEMENTS(work), path); |
| |
inirdargs16(work, p); |
| |
break; |
| |
|
| |
case PFTYPE_BYTE3: |
| |
GetPrivateProfileString(title, p->item, str_null, |
| |
work, NELEMENTS(work), path); |
| |
inirdbyte3(work, p); |
| |
break; |
| |
|
| |
case PFTYPE_KB: |
| |
GetPrivateProfileString(title, p->item, str_null, |
| |
work, NELEMENTS(work), path); |
| |
inirdkb(work, p); |
| |
break; |
| |
} |
| p++; |
p++; |
| } |
} |
| } |
} |
| |
|
| void initsave(void) { |
void ini_write(const OEMCHAR *path, const OEMCHAR *title, |
| |
const PFTBL *tbl, UINT count) { |
| |
|
| |
const PFTBL *p; |
| |
const PFTBL *pterm; |
| |
const OEMCHAR *set; |
| |
OEMCHAR work[512]; |
| |
|
| char initfile[MAX_PATH]; |
p = tbl; |
| char cfgstr[CFGLEN]; |
pterm = tbl + count; |
| DWORD i; |
while(p < pterm) { |
| INI_ITEM *p; |
if (!(p->itemtype & PFFLAG_RO)) { |
| |
work[0] = '\0'; |
| getinifile(initfile, MAX_PATH); // ver0.29 |
set = work; |
| p = iniitem; |
switch(p->itemtype & PFTYPE_MASK) { |
| while(!(p->flag & INIEND)) { |
case PFTYPE_STR: |
| if (p->flag & INI_RO) { |
set = (OEMCHAR *)p->value; |
| } |
|
| else if (!(p->itemtype & INI_EX)) { |
|
| switch(p->itemtype) { |
|
| case INI_STR: |
|
| WritePrivateProfileString(ini_title, p->item, |
|
| (char *)p->value, initfile); |
|
| break; |
|
| case INI_BOOL: |
|
| WritePrivateProfileString(ini_title, p->item, |
|
| makeBOOL(*((BYTE *)p->value) & 1), initfile); |
|
| break; |
|
| case INI_ARG: |
|
| for (i=0; i<p->arg; i++) { |
|
| wsprintf(&cfgstr[i*3], "%02x ", |
|
| ((BYTE *)p->value)[i]); |
|
| } |
|
| cfgstr[i*3-1] = '\0'; |
|
| WritePrivateProfileString(ini_title, p->item, |
|
| cfgstr, initfile); |
|
| break; |
|
| case INI_BYTE: |
|
| wsprintf(cfgstr, "%u", *(BYTE *)p->value); |
|
| WritePrivateProfileString(ini_title, p->item, |
|
| cfgstr, initfile); |
|
| break; |
|
| case INI_WORD: |
|
| wsprintf(cfgstr, "%u", *(WORD *)p->value); |
|
| WritePrivateProfileString(ini_title, p->item, |
|
| cfgstr, initfile); |
|
| break; |
|
| case INI_DWORD: |
|
| wsprintf(cfgstr, "%u", *(DWORD *)p->value); |
|
| WritePrivateProfileString(ini_title, p->item, |
|
| cfgstr, initfile); |
|
| break; |
|
| case INI_HEXB: |
|
| wsprintf(cfgstr, "%x", *(BYTE *)p->value); |
|
| WritePrivateProfileString(ini_title, p->item, |
|
| cfgstr, initfile); |
|
| break; |
|
| case INI_HEXD: |
|
| wsprintf(cfgstr, "%x", *(DWORD *)p->value); |
|
| WritePrivateProfileString(ini_title, p->item, |
|
| cfgstr, initfile); |
|
| break; |
break; |
| } |
|
| } |
case PFTYPE_BOOL: |
| else { |
set = (*((UINT8 *)p->value))?str_true:str_false; |
| switch(p->itemtype) { |
|
| case INI_EX|1: // remove hdd |
|
| wsprintf(cfgstr, "%u", (*(BYTE *)p->value) + 1); |
|
| WritePrivateProfileString(ini_title, p->item, |
|
| cfgstr, initfile); |
|
| break; |
|
| #if 0 |
|
| case INI_EX|2: // midi module |
|
| WritePrivateProfileString(ini_title, p->item, |
|
| MIDI_num2module(*(BYTE *)p->value), initfile); |
|
| break; |
break; |
| #endif |
|
| |
case PFTYPE_BITMAP: |
| |
set = (bitmapget((UINT8 *)p->value, p->arg))? |
| |
str_true:str_false; |
| |
break; |
| |
|
| |
case PFTYPE_BIN: |
| |
binget(work, NELEMENTS(work), (UINT8 *)p->value, p->arg); |
| |
break; |
| |
|
| |
case PFTYPE_SINT8: |
| |
OEMSPRINTF(work, str_d, *((SINT8 *)p->value)); |
| |
break; |
| |
|
| |
case PFTYPE_SINT16: |
| |
OEMSPRINTF(work, str_d, *((SINT16 *)p->value)); |
| |
break; |
| |
|
| |
case PFTYPE_SINT32: |
| |
OEMSPRINTF(work, str_d, *((SINT32 *)p->value)); |
| |
break; |
| |
|
| |
case PFTYPE_UINT8: |
| |
OEMSPRINTF(work, str_u, *((UINT8 *)p->value)); |
| |
break; |
| |
|
| |
case PFTYPE_UINT16: |
| |
OEMSPRINTF(work, str_u, *((UINT16 *)p->value)); |
| |
break; |
| |
|
| |
case PFTYPE_UINT32: |
| |
OEMSPRINTF(work, str_u, *((UINT32 *)p->value)); |
| |
break; |
| |
|
| |
case PFTYPE_HEX8: |
| |
OEMSPRINTF(work, str_x, *((UINT8 *)p->value)); |
| |
break; |
| |
|
| |
case PFTYPE_HEX16: |
| |
OEMSPRINTF(work, str_x, *((UINT16 *)p->value)); |
| |
break; |
| |
|
| |
case PFTYPE_HEX32: |
| |
OEMSPRINTF(work, str_x, *((UINT32 *)p->value)); |
| |
break; |
| |
|
| |
default: |
| |
set = NULL; |
| |
break; |
| |
} |
| |
if (set) { |
| |
WritePrivateProfileString(title, p->item, set, path); |
| } |
} |
| } |
} |
| if (p->flag & INIEND) { |
p++; |
| |
} |
| |
} |
| |
|
| |
#else // !defined(_UNICODE) |
| |
|
| |
// ---- Use profile.c |
| |
|
| |
static void pfread(const PFTBL *item, const OEMCHAR *string) { |
| |
|
| |
switch(item->itemtype & PFTYPE_MASK) { |
| |
case PFTYPE_ARGS16: |
| |
inirdargs16(string, item); |
| |
break; |
| |
|
| |
case PFTYPE_BYTE3: |
| |
inirdbyte3(string, item); |
| |
break; |
| |
|
| |
case PFTYPE_KB: |
| |
inirdkb(string, item); |
| break; |
break; |
| |
} |
| |
} |
| |
|
| |
void ini_read(const OEMCHAR *path, const OEMCHAR *title, |
| |
const PFTBL *tbl, UINT count) { |
| |
|
| |
profile_iniread(path, title, tbl, count, pfread); |
| |
} |
| |
|
| |
void ini_write(const OEMCHAR *path, const OEMCHAR *title, |
| |
const PFTBL *tbl, UINT count) { |
| |
|
| |
profile_iniwrite(path, title, tbl, count, NULL); |
| |
} |
| |
|
| |
#endif // !defined(_UNICODE) |
| |
|
| |
|
| |
// ---- |
| |
|
| |
#if !defined(SUPPORT_PC9821) |
| |
static const OEMCHAR ini_title[] = OEMTEXT("NekoProjectII"); |
| |
#else |
| |
static const OEMCHAR ini_title[] = OEMTEXT("NekoProject21"); |
| |
#endif |
| |
|
| |
enum { |
| |
PFRO_STR = PFFLAG_RO + PFTYPE_STR, |
| |
PFRO_BOOL = PFFLAG_RO + PFTYPE_BOOL, |
| |
PFRO_BITMAP = PFFLAG_RO + PFTYPE_BITMAP, |
| |
PFRO_UINT8 = PFFLAG_RO + PFTYPE_UINT8, |
| |
PFRO_SINT32 = PFFLAG_RO + PFTYPE_SINT32, |
| |
PFRO_HEX8 = PFFLAG_RO + PFTYPE_HEX8, |
| |
PFRO_HEX32 = PFFLAG_RO + PFTYPE_HEX32, |
| |
PFRO_BYTE3 = PFFLAG_RO + PFTYPE_BYTE3, |
| |
PFRO_KB = PFFLAG_RO + PFTYPE_KB |
| |
}; |
| |
|
| |
static const PFTBL iniitem[] = { |
| |
PFSTR("np2title", PFRO_STR, np2oscfg.titles), |
| |
PFVAL("np2winid", PFRO_BYTE3, np2oscfg.winid), |
| |
PFVAL("WindposX", PFTYPE_SINT32, &np2oscfg.winx), |
| |
PFVAL("WindposY", PFTYPE_SINT32, &np2oscfg.winy), |
| |
PFMAX("paddingx", PFRO_SINT32, &np2oscfg.paddingx, 32), |
| |
PFMAX("paddingy", PFRO_SINT32, &np2oscfg.paddingy, 32), |
| |
PFVAL("Win_Snap", PFTYPE_BOOL, &np2oscfg.WINSNAP), |
| |
|
| |
PFSTR("FDfolder", PFTYPE_STR, fddfolder), |
| |
PFSTR("HDfolder", PFTYPE_STR, hddfolder), |
| |
PFSTR("bmap_Dir", PFTYPE_STR, bmpfilefolder), |
| |
PFSTR("fontfile", PFTYPE_STR, np2cfg.fontfile), |
| |
PFSTR("biospath", PFRO_STR, np2cfg.biospath), |
| |
|
| |
#if defined(SUPPORT_HOSTDRV) |
| |
PFSTR("hdrvroot", PFRO_STR, np2cfg.hdrvroot), |
| |
PFVAL("hdrv_acc", PFRO_UINT8, &np2cfg.hdrvacc), |
| |
#endif |
| |
|
| |
PFSTR("pc_model", PFTYPE_STR, np2cfg.model), |
| |
PFVAL("clk_base", PFTYPE_UINT32, &np2cfg.baseclock), |
| |
PFVAL("clk_mult", PFTYPE_UINT32, &np2cfg.multiple), |
| |
|
| |
PFEXT("DIPswtch", PFTYPE_BIN, np2cfg.dipsw, 3), |
| |
PFEXT("MEMswtch", PFTYPE_BIN, np2cfg.memsw, 8), |
| |
PFMAX("ExMemory", PFTYPE_UINT8, &np2cfg.EXTMEM, 63), |
| |
PFVAL("ITF_WORK", PFRO_BOOL, &np2cfg.ITF_WORK), |
| |
|
| |
PFSTR("HDD1FILE", PFTYPE_STR, np2cfg.sasihdd[0]), |
| |
PFSTR("HDD2FILE", PFTYPE_STR, np2cfg.sasihdd[1]), |
| |
#if defined(SUPPORT_SCSI) |
| |
PFSTR("SCSIHDD0", PFTYPE_STR, np2cfg.scsihdd[0]), |
| |
PFSTR("SCSIHDD1", PFTYPE_STR, np2cfg.scsihdd[1]), |
| |
PFSTR("SCSIHDD2", PFTYPE_STR, np2cfg.scsihdd[2]), |
| |
PFSTR("SCSIHDD3", PFTYPE_STR, np2cfg.scsihdd[3]), |
| |
#endif |
| |
|
| |
PFVAL("SampleHz", PFTYPE_UINT16, &np2cfg.samplingrate), |
| |
PFVAL("Latencys", PFTYPE_UINT16, &np2cfg.delayms), |
| |
PFVAL("SNDboard", PFTYPE_HEX8, &np2cfg.SOUND_SW), |
| |
PFAND("BEEP_vol", PFTYPE_UINT8, &np2cfg.BEEP_VOL, 3), |
| |
PFVAL("xspeaker", PFRO_BOOL, &np2cfg.snd_x), |
| |
|
| |
PFEXT("SND14vol", PFTYPE_BIN, np2cfg.vol14, 6), |
| |
// PFEXT("opt14BRD", PFTYPE_BIN, np2cfg.snd14opt, 3), |
| |
PFVAL("opt26BRD", PFTYPE_HEX8, &np2cfg.snd26opt), |
| |
PFVAL("opt86BRD", PFTYPE_HEX8, &np2cfg.snd86opt), |
| |
PFVAL("optSPBRD", PFTYPE_HEX8, &np2cfg.spbopt), |
| |
PFVAL("optSPBVR", PFTYPE_HEX8, &np2cfg.spb_vrc), |
| |
PFMAX("optSPBVL", PFTYPE_UINT8, &np2cfg.spb_vrl, 24), |
| |
PFVAL("optSPB_X", PFTYPE_BOOL, &np2cfg.spb_x), |
| |
PFVAL("optMPU98", PFTYPE_HEX8, &np2cfg.mpuopt), |
| |
|
| |
PFMAX("volume_F", PFTYPE_UINT8, &np2cfg.vol_fm, 128), |
| |
PFMAX("volume_S", PFTYPE_UINT8, &np2cfg.vol_ssg, 128), |
| |
PFMAX("volume_A", PFTYPE_UINT8, &np2cfg.vol_adpcm, 128), |
| |
PFMAX("volume_P", PFTYPE_UINT8, &np2cfg.vol_pcm, 128), |
| |
PFMAX("volume_R", PFTYPE_UINT8, &np2cfg.vol_rhythm, 128), |
| |
|
| |
PFVAL("Seek_Snd", PFTYPE_BOOL, &np2cfg.MOTOR), |
| |
PFMAX("Seek_Vol", PFTYPE_UINT8, &np2cfg.MOTORVOL, 100), |
| |
|
| |
PFVAL("btnRAPID", PFTYPE_BOOL, &np2cfg.BTN_RAPID), |
| |
PFVAL("btn_MODE", PFTYPE_BOOL, &np2cfg.BTN_MODE), |
| |
PFVAL("Mouse_sw", PFTYPE_BOOL, &np2oscfg.MOUSE_SW), |
| |
PFVAL("MS_RAPID", PFTYPE_BOOL, &np2cfg.MOUSERAPID), |
| |
|
| |
PFAND("backgrnd", PFTYPE_UINT8, &np2oscfg.background, 3), |
| |
PFEXT("VRAMwait", PFTYPE_BIN, np2cfg.wait, 6), |
| |
PFAND("DspClock", PFTYPE_UINT8, &np2oscfg.DISPCLK, 3), |
| |
PFVAL("DispSync", PFTYPE_BOOL, &np2cfg.DISPSYNC), |
| |
PFVAL("Real_Pal", PFTYPE_BOOL, &np2cfg.RASTER), |
| |
PFMAX("RPal_tim", PFTYPE_UINT8, &np2cfg.realpal, 64), |
| |
PFVAL("s_NOWAIT", PFTYPE_BOOL, &np2oscfg.NOWAIT), |
| |
PFVAL("SkpFrame", PFTYPE_UINT8, &np2oscfg.DRAW_SKIP), |
| |
PFVAL("uPD72020", PFTYPE_BOOL, &np2cfg.uPD72020), |
| |
PFAND("GRCG_EGC", PFTYPE_UINT8, &np2cfg.grcg, 3), |
| |
PFVAL("color16b", PFTYPE_BOOL, &np2cfg.color16), |
| |
PFVAL("skipline", PFTYPE_BOOL, &np2cfg.skipline), |
| |
PFVAL("skplight", PFTYPE_UINT16, &np2cfg.skiplight), |
| |
PFAND("LCD_MODE", PFTYPE_UINT8, &np2cfg.LCD_MODE, 0x03), |
| |
PFAND("BG_COLOR", PFRO_HEX32, &np2cfg.BG_COLOR, 0xffffff), |
| |
PFAND("FG_COLOR", PFRO_HEX32, &np2cfg.FG_COLOR, 0xffffff), |
| |
|
| |
PFVAL("pc9861_e", PFTYPE_BOOL, &np2cfg.pc9861enable), |
| |
PFEXT("pc9861_s", PFTYPE_BIN, np2cfg.pc9861sw, 3), |
| |
PFEXT("pc9861_j", PFTYPE_BIN, np2cfg.pc9861jmp, 6), |
| |
|
| |
PFVAL("calendar", PFTYPE_BOOL, &np2cfg.calendar), |
| |
PFVAL("USE144FD", PFTYPE_BOOL, &np2cfg.usefd144), |
| |
PFEXT("FDDRIVE1", PFRO_BITMAP, &np2cfg.fddequip, 0), |
| |
PFEXT("FDDRIVE2", PFRO_BITMAP, &np2cfg.fddequip, 1), |
| |
PFEXT("FDDRIVE3", PFRO_BITMAP, &np2cfg.fddequip, 2), |
| |
PFEXT("FDDRIVE4", PFRO_BITMAP, &np2cfg.fddequip, 3), |
| |
|
| |
// OS°Í¸¡© |
| |
PFVAL("keyboard", PFRO_KB, &np2oscfg.KEYBOARD), |
| |
PFVAL("F12_COPY", PFTYPE_UINT8, &np2oscfg.F12COPY), |
| |
PFVAL("Joystick", PFTYPE_BOOL, &np2oscfg.JOYPAD1), |
| |
PFEXT("Joy1_btn", PFTYPE_BIN, np2oscfg.JOY1BTN, 4), |
| |
|
| |
PFVAL("clocknow", PFTYPE_UINT8, &np2oscfg.clk_x), |
| |
PFVAL("clockfnt", PFTYPE_UINT8, &np2oscfg.clk_fnt), |
| |
PFAND("clock_up", PFRO_HEX32, &np2oscfg.clk_color1, 0xffffff), |
| |
PFAND("clock_dn", PFRO_HEX32, &np2oscfg.clk_color2, 0xffffff), |
| |
|
| |
PFVAL("use_sstp", PFTYPE_BOOL, &np2oscfg.sstp), |
| |
PFVAL("sstpport", PFTYPE_UINT16, &np2oscfg.sstpport), |
| |
PFVAL("comfirm_", PFTYPE_BOOL, &np2oscfg.comfirm), |
| |
PFVAL("shortcut", PFTYPE_HEX8, &np2oscfg.shortcut), |
| |
|
| |
PFSTR("mpu98map", PFTYPE_STR, np2oscfg.mpu.mout), |
| |
PFSTR("mpu98min", PFTYPE_STR, np2oscfg.mpu.min), |
| |
PFSTR("mpu98mdl", PFTYPE_STR, np2oscfg.mpu.mdl), |
| |
PFSTR("mpu98def", PFTYPE_STR, np2oscfg.mpu.def), |
| |
|
| |
PFMAX("com1port", PFTYPE_UINT8, &np2oscfg.com1.port, 5), |
| |
PFVAL("com1para", PFTYPE_UINT8, &np2oscfg.com1.param), |
| |
PFVAL("com1_bps", PFTYPE_UINT32, &np2oscfg.com1.speed), |
| |
PFSTR("com1mmap", PFTYPE_STR, np2oscfg.com1.mout), |
| |
PFSTR("com1mmdl", PFTYPE_STR, np2oscfg.com1.mdl), |
| |
PFSTR("com1mdef", PFTYPE_STR, np2oscfg.com1.def), |
| |
|
| |
PFMAX("com2port", PFTYPE_UINT8, &np2oscfg.com2.port, 5), |
| |
PFVAL("com2para", PFTYPE_UINT8, &np2oscfg.com2.param), |
| |
PFVAL("com2_bps", PFTYPE_UINT32, &np2oscfg.com2.speed), |
| |
PFSTR("com2mmap", PFTYPE_STR, np2oscfg.com2.mout), |
| |
PFSTR("com2mmdl", PFTYPE_STR, np2oscfg.com2.mdl), |
| |
PFSTR("com2mdef", PFTYPE_STR, np2oscfg.com2.def), |
| |
|
| |
PFMAX("com3port", PFTYPE_UINT8, &np2oscfg.com3.port, 5), |
| |
PFVAL("com3para", PFTYPE_UINT8, &np2oscfg.com3.param), |
| |
PFVAL("com3_bps", PFTYPE_UINT32, &np2oscfg.com3.speed), |
| |
PFSTR("com3mmap", PFTYPE_STR, np2oscfg.com3.mout), |
| |
PFSTR("com3mmdl", PFTYPE_STR, np2oscfg.com3.mdl), |
| |
PFSTR("com3mdef", PFTYPE_STR, np2oscfg.com3.def), |
| |
|
| |
PFVAL("force400", PFRO_BOOL, &np2oscfg.force400), |
| |
PFVAL("e_resume", PFTYPE_BOOL, &np2oscfg.resume), |
| |
PFVAL("STATSAVE", PFRO_BOOL, &np2oscfg.statsave), |
| |
#if !defined(_WIN64) |
| |
PFVAL("nousemmx", PFTYPE_BOOL, &np2oscfg.disablemmx), |
| |
#endif |
| |
PFVAL("windtype", PFTYPE_UINT8, &np2oscfg.wintype), |
| |
PFVAL("toolwind", PFTYPE_BOOL, &np2oscfg.toolwin), |
| |
PFVAL("keydispl", PFTYPE_BOOL, &np2oscfg.keydisp), |
| |
PFVAL("jast_snd", PFTYPE_BOOL, &np2oscfg.jastsnd), |
| |
PFVAL("useromeo", PFTYPE_BOOL, &np2oscfg.useromeo), |
| |
PFVAL("thickfrm", PFTYPE_BOOL, &np2oscfg.thickframe), |
| |
PFVAL("xrollkey", PFRO_BOOL, &np2oscfg.xrollkey), |
| |
PFVAL("fscrn_cx", PFRO_SINT32, &np2oscfg.fscrn_cx), |
| |
PFVAL("fscrn_cy", PFRO_SINT32, &np2oscfg.fscrn_cy), |
| |
PFVAL("fscrnbpp", PFRO_UINT8, &np2oscfg.fscrnbpp), |
| |
PFVAL("fscrnmod", PFRO_HEX8, &np2oscfg.fscrnmod), |
| |
PFVAL("I286SAVE", PFRO_BOOL, &np2oscfg.I286SAVE)}; |
| |
|
| |
|
| |
static const OEMCHAR ext_ini[] = OEMTEXT(".ini"); |
| |
|
| |
void initgetfile(OEMCHAR *path, UINT size) { |
| |
|
| |
const OEMCHAR *ext; |
| |
|
| |
file_cpyname(path, modulefile, size); |
| |
if (np2arg.ini) { |
| |
if ((np2arg.ini[0] == '/') || (np2arg.ini[0] == '-')) { |
| |
file_cutname(path); |
| |
file_catname(path, file_getname(np2arg.ini + 2), size); |
| |
} |
| |
else { |
| |
file_cpyname(path, np2arg.ini, size); |
| |
} |
| |
ext = file_getext(path); |
| |
if (ext[0] != '\0') { |
| |
file_catname(path, ext_ini, size); |
| } |
} |
| p++; |
|
| } |
} |
| |
else { |
| |
file_cutext(path); |
| |
file_catname(path, ext_ini, size); |
| |
} |
| |
} |
| |
|
| |
void initload(void) { |
| |
|
| |
OEMCHAR path[MAX_PATH]; |
| |
|
| |
initgetfile(path, NELEMENTS(path)); |
| |
ini_read(path, ini_title, iniitem, NELEMENTS(iniitem)); |
| |
} |
| |
|
| |
void initsave(void) { |
| |
|
| |
OEMCHAR path[MAX_PATH]; |
| |
|
| |
initgetfile(path, NELEMENTS(path)); |
| |
ini_write(path, ini_title, iniitem, NELEMENTS(iniitem)); |
| } |
} |
| |
|
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to ini.cpp CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [RetroPC.NET] / np2 / win9x