[BACK]Return to np2.cpp CVS log [TXT] [DIR] Up to [RetroPC.NET] / np2 / win9xc

Diff for /np2/win9xc/np2.cpp between versions 1.4 and 1.31

version 1.4, 2003/10/23 12:58:44 version 1.31, 2005/02/07 14:46:15
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
 #include        <time.h>  #include        <time.h>
   #ifndef __GNUC__
 #include        <winnls32.h>  #include        <winnls32.h>
   #endif
 #include        "resource.h"  #include        "resource.h"
 #include        "strres.h"  #include        "strres.h"
   #include        "parts.h"
 #include        "np2.h"  #include        "np2.h"
 #include        "np2arg.h"  #include        "np2arg.h"
 #include        "dosio.h"  #include        "dosio.h"
Line 12 Line 15
 #include        "scrnmng.h"  #include        "scrnmng.h"
 #include        "soundmng.h"  #include        "soundmng.h"
 #include        "sysmng.h"  #include        "sysmng.h"
   #include        "winkbd.h"
 #include        "timing.h"  #include        "ini.h"
   #include        "menu.h"
 #include        "memory.h"  #include        "subwind.h"
   #include        "dialog.h"
   #include        "cpucore.h"
 #include        "pccore.h"  #include        "pccore.h"
 #include        "iocore.h"  #include        "iocore.h"
   #include        "pc9861k.h"
   #include        "mpu98ii.h"
 #include        "bios.h"  #include        "bios.h"
   
 #include        "scrndraw.h"  #include        "scrndraw.h"
 #include        "sound.h"  #include        "sound.h"
   #include        "beep.h"
 #include        "ini.h"  
 #include        "menu.h"  
 #include        "dialog.h"  
 #include        "mpu98ii.h"  
 #include        "fddfile.h"  
 #include        "diskdrv.h"  
 #include        "s98.h"  #include        "s98.h"
 #include        "font.h"  #include        "diskdrv.h"
 #include        "pc9861k.h"  #include        "fddfile.h"
 #include        "winkbd.h"  #include        "timing.h"
   #include        "keystat.h"
 #include        "debugsub.h"  #include        "debugsub.h"
 #include        "beep.h"  
   
   
 #ifdef BETA_RELEASE  #ifdef BETA_RELEASE
 #define OPENING_WAIT    1500  #define         OPENING_WAIT            1500
 #endif  #endif
   
 #define STATSAVEMAX             10  #if defined(SUPPORT_PC9821)
                   const char szAppCaption[] = "Neko Project-21";
 static  char            np2help[] = "np2.hlp";  #elif defined(CPUCORE_IA32)
 static  char            np2resume[] = "sav";                  const char szAppCaption[] = "Neko Project II (IA-32)";
   #else
 static  const char      szAppCaption[] = "Neko Project II - C version";                  const char szAppCaption[] = "Neko Project II (C Version)";
   #endif
 static  const char      szClassName[] = "NP2-MainWindow";  static  const char      szClassName[] = "NP2-MainWindow";
                   HWND            hWndMain;
                   HINSTANCE       hInst;
                   HINSTANCE       hPrev;
   
                 NP2OSCFG        np2oscfg = {                  NP2OSCFG        np2oscfg = {
                                                 CW_USEDEFAULT, CW_USEDEFAULT, 0, 2,                                                  CW_USEDEFAULT, CW_USEDEFAULT, 0, 0,
                                                 KEY_UNKNOWN, 0,                                                  KEY_UNKNOWN, 0,
                                                 0, 0, 0, {1, 2, 2, 1},                                                  0, 0, 0, {1, 2, 2, 1},
                                                 0};                                                  0, 0, 0};
   
                 HWND            hWndMain;  
                 HINSTANCE       hInst;  
                 HINSTANCE       hPrev;  
                 char            modulefile[MAX_PATH];                  char            modulefile[MAX_PATH];
                 char            fddfolder[MAX_PATH];                  char            fddfolder[MAX_PATH];
                 char            hddfolder[MAX_PATH];                  char            hddfolder[MAX_PATH];
                 char            bmpfilefolder[MAX_PATH];                  char            bmpfilefolder[MAX_PATH];
   
 static  UINT            framecnt;  static  UINT            framecnt = 0;
 static  UINT            waitcnt;  static  UINT            waitcnt = 0;
 static  UINT            framemax = 1;  static  UINT            framemax = 1;
 static  int                     np2opening = 1;  static  int                     np2opening = 1;
 static  int                     np2quitmsg = 0;  static  int                     np2quitmsg = 0;
   static  UINT8   scrnmode;
   
   
 static  BYTE    scrnmode;  static const char np2help[] = "np2.chm";
   static const char np2flagext[] = "S%02d";
   
 static void changescreen(BYTE newmode) {  
   
         BYTE    change;  static void winuienter(void) {
         BYTE    renewal;  
           soundmng_disable(SNDPROC_MAIN);
           scrnmng_topwinui();
   }
   
   static void winuileave(void) {
   
           scrnmng_clearwinui();
           soundmng_enable(SNDPROC_MAIN);
   }
   
   static void changescreen(UINT8 newmode) {
   
           UINT8   change;
           UINT8   renewal;
   
         change = scrnmode ^ newmode;          change = scrnmode ^ newmode;
         renewal = (change & SCRNMODE_FULLSCREEN);          renewal = (change & SCRNMODE_FULLSCREEN);
Line 88  static void changescreen(BYTE newmode) { Line 103  static void changescreen(BYTE newmode) {
         }          }
         if (renewal) {          if (renewal) {
                 soundmng_stop();                  soundmng_stop();
                 mouse_running(MOUSE_STOP);                  mousemng_disable(MOUSEPROC_WINUI);
                 scrnmng_destroy();                  scrnmng_destroy();
                 if (scrnmng_create(newmode) == SUCCESS) {                  if (scrnmng_create(newmode) == SUCCESS) {
                         scrnmode = newmode;                          scrnmode = newmode;
Line 100  static void changescreen(BYTE newmode) { Line 115  static void changescreen(BYTE newmode) {
                         }                          }
                 }                  }
                 scrndraw_redraw();                  scrndraw_redraw();
                 mouse_running(MOUSE_CONT);                  mousemng_enable(MOUSEPROC_WINUI);
                 soundmng_play();                  soundmng_play();
         }          }
         else {          else {
Line 109  static void changescreen(BYTE newmode) { Line 124  static void changescreen(BYTE newmode) {
 }  }
   
   
 // ---- proc  // ---- resume and statsave
   
 static void winuienter(void) {  #define SUPPORT_RESUME
   
         soundmng_stop();  #if defined(SUPPORT_RESUME) || defined(SUPPORT_STATSAVE)
         scrnmng_topwinui();  static void getstatfilename(char *path, const char *ext, int size) {
   
           file_cpyname(path, modulefile, size);
           file_cutext(path);
           file_catname(path, str_dot, size);
           file_catname(path, ext, size);
 }  }
   
 static void winuileave(void) {  static int flagsave(const char *ext) {
   
         scrnmng_clearwinui();          int             ret;
           char    path[MAX_PATH];
   
           getstatfilename(path, ext, sizeof(path));
           soundmng_stop();
           ret = statsave_save(path);
           if (ret) {
                   file_delete(path);
           }
         soundmng_play();          soundmng_play();
           return(ret);
 }  }
   
 LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {  static void flagdelete(const char *ext) {
   
         PAINTSTRUCT     ps;          char    path[MAX_PATH];
         RECT            rc;  
         HDC                     hdc;  
         UINT            update;  
   
         switch (msg) {          getstatfilename(path, ext, sizeof(path));
                 case WM_CREATE:          file_delete(path);
                         WINNLSEnableIME(hWnd, FALSE);  }
 //                      DragAcceptFiles(hWnd, TRUE);  
                         break;  
   
                 case WM_SYSCOMMAND:  static int flagload(const char *ext, const char *title, BOOL force) {
                         update = 0;  
                         switch(wParam) {  
                                 case IDM_MEMORYDUMP:  
                                         debugsub_memorydump();  
                                         break;  
   
                                 default:          int             ret;
                                         return(DefWindowProc(hWnd, msg, wParam, lParam));          int             id;
                         }          char    path[MAX_PATH];
                         sysmng_update(update);          char    buf[1024];
                         break;  
           getstatfilename(path, ext, sizeof(path));
           winuienter();
           id = IDYES;
           ret = statsave_check(path, buf, sizeof(buf));
           if (ret & (~STATFLAG_DISKCHG)) {
                   MessageBox(hWndMain, "Couldn't restart", title, MB_OK | MB_ICONSTOP);
                   id = IDNO;
           }
           else if ((!force) && (ret & STATFLAG_DISKCHG)) {
                   char buf2[1024 + 256];
                   wsprintf(buf2, "Conflict!\n\n%s\nContinue?", buf);
                   id = MessageBox(hWndMain, buf2, title,
                                                                                   MB_YESNOCANCEL | MB_ICONQUESTION);
           }
           if (id == IDYES) {
                   statsave_load(path);
           }
           sysmng_workclockreset();
           sysmng_updatecaption();
           winuileave();
           return(id);
   }
   #endif
   
                 case WM_COMMAND:  
                         update = 0;  
                         switch(LOWORD(wParam)) {  
                                 case IDM_RESET:  
                                         pccore_cfgupdate();  
                                         pccore_reset();  
                                         break;  
   
                                 case IDM_CONFIG:  // ---- proc
                                         winuienter();  
                                         DialogBox(hInst, MAKEINTRESOURCE(IDD_CONFIG),  
                                                                         hWnd, (DLGPROC)CfgDialogProc);  
                                         winuileave();  
                                         break;  
   
                                 case IDM_NEWDISK:  static void np2cmd(HWND hWnd, UINT16 cmd) {
                                         winuienter();  
                                         dialog_newdisk(hWnd);  
                                         winuileave();  
                                         break;  
   
                                 case IDM_CHANGEFONT:          UINT    update;
                                         winuienter();  
                                         dialog_font(hWnd);  
                                         winuileave();  
                                         break;  
   
                                 case IDM_EXIT:          update = 0;
                                         SendMessage(hWnd, WM_CLOSE, 0, 0L);          switch(cmd) {
                                         break;                  case IDM_RESET:
                           pccore_cfgupdate();
                           pccore_reset();
                           break;
   
                                 case IDM_FDD1OPEN:                  case IDM_CONFIG:
                                         winuienter();                          winuienter();
                                         dialog_changefdd(hWnd, 0);                          DialogBox(hInst, MAKEINTRESOURCE(IDD_CONFIG),
                                         winuileave();                                                                                          hWnd, (DLGPROC)CfgDialogProc);
                                         break;                          winuileave();
                           break;
   
                                 case IDM_FDD1EJECT:                  case IDM_NEWDISK:
                                         diskdrv_setfdd(0, NULL, 0);                          winuienter();
                                         break;                          dialog_newdisk(hWnd);
                           winuileave();
                           break;
   
                                 case IDM_FDD2OPEN:                  case IDM_CHANGEFONT:
                                         winuienter();                          winuienter();
                                         dialog_changefdd(hWnd, 1);                          dialog_font(hWnd);
                                         winuileave();                          winuileave();
                                         break;                          break;
   
                                 case IDM_FDD2EJECT:                  case IDM_EXIT:
                                         diskdrv_setfdd(1, NULL, 0);                          SendMessage(hWnd, WM_CLOSE, 0, 0L);
                                         break;                          break;
   
                                 case IDM_SASI1OPEN:                  case IDM_FDD1OPEN:
                                         winuienter();                          winuienter();
                                         dialog_changehdd(hWnd, 0);                          dialog_changefdd(hWnd, 0);
                                         winuileave();                          winuileave();
                                         break;                          break;
   
                                 case IDM_SASI1EJECT:                  case IDM_FDD1EJECT:
                                         diskdrv_sethdd(0, NULL);                          diskdrv_setfdd(0, NULL, 0);
                                         break;                          break;
   
                                 case IDM_SASI2OPEN:                  case IDM_FDD2OPEN:
                                         winuienter();                          winuienter();
                                         dialog_changehdd(hWnd, 1);                          dialog_changefdd(hWnd, 1);
                                         winuileave();                          winuileave();
                                         break;                          break;
   
                                 case IDM_SASI2EJECT:                  case IDM_FDD2EJECT:
                                         diskdrv_sethdd(1, NULL);                          diskdrv_setfdd(1, NULL, 0);
                                         break;                          break;
   
                                 case IDM_WINDOW:                  case IDM_SASI1OPEN:
                                         changescreen(scrnmode & (~SCRNMODE_FULLSCREEN));                          winuienter();
                                         break;                          dialog_changehdd(hWnd, 0);
                           winuileave();
                           break;
   
                                 case IDM_FULLSCREEN:                  case IDM_SASI1EJECT:
                                         changescreen(scrnmode | SCRNMODE_FULLSCREEN);                          diskdrv_sethdd(0, NULL);
                                         break;                          break;
   
                                 case IDM_ROLNORMAL:                  case IDM_SASI2OPEN:
                                         xmenu_setroltate(0);                          winuienter();
                                         changescreen(scrnmode & (~SCRNMODE_ROTATEMASK));                          dialog_changehdd(hWnd, 1);
                                         break;                          winuileave();
                           break;
   
                   case IDM_SASI2EJECT:
                           diskdrv_sethdd(1, NULL);
                           break;
   
                                 case IDM_ROLLEFT:                  case IDM_WINDOW:
                                         xmenu_setroltate(1);                          changescreen(scrnmode & (~SCRNMODE_FULLSCREEN));
                                         changescreen((scrnmode & (~SCRNMODE_ROTATEMASK)) |                          break;
   
                   case IDM_FULLSCREEN:
                           changescreen(scrnmode | SCRNMODE_FULLSCREEN);
                           break;
   
                   case IDM_ROLNORMAL:
                           xmenu_setroltate(0);
                           changescreen(scrnmode & (~SCRNMODE_ROTATEMASK));
                           break;
   
                   case IDM_ROLLEFT:
                           xmenu_setroltate(1);
                           changescreen((scrnmode & (~SCRNMODE_ROTATEMASK)) |
                                                                                                                 SCRNMODE_ROTATELEFT);                                                                                                                  SCRNMODE_ROTATELEFT);
                                         break;                          break;
   
                                 case IDM_ROLRIGHT:                  case IDM_ROLRIGHT:
                                         xmenu_setroltate(2);                          xmenu_setroltate(2);
                                         changescreen((scrnmode & (~SCRNMODE_ROTATEMASK)) |                          changescreen((scrnmode & (~SCRNMODE_ROTATEMASK)) |
                                                                                                                 SCRNMODE_ROTATERIGHT);                                                                                                                  SCRNMODE_ROTATERIGHT);
                                         break;                          break;
   
                                 case IDM_DISPSYNC:                  case IDM_DISPSYNC:
                                         xmenu_setdispmode(np2cfg.DISPSYNC ^ 1);                          xmenu_setdispmode(np2cfg.DISPSYNC ^ 1);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_RASTER:                  case IDM_RASTER:
                                         xmenu_setraster(np2cfg.RASTER ^ 1);                          xmenu_setraster(np2cfg.RASTER ^ 1);
                                         if (np2cfg.RASTER) {                          if (np2cfg.RASTER) {
                                                 changescreen(scrnmode | SCRNMODE_HIGHCOLOR);                                  changescreen(scrnmode | SCRNMODE_HIGHCOLOR);
                                         }                          }
                                         else {                          else {
                                                 changescreen(scrnmode & (~SCRNMODE_HIGHCOLOR));                                  changescreen(scrnmode & (~SCRNMODE_HIGHCOLOR));
                                         }                          }
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_NOWAIT:                  case IDM_NOWAIT:
                                         xmenu_setwaitflg(np2oscfg.NOWAIT ^ 1);                          xmenu_setwaitflg(np2oscfg.NOWAIT ^ 1);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_AUTOFPS:                  case IDM_AUTOFPS:
                                         xmenu_setframe(0);                          xmenu_setframe(0);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_60FPS:                  case IDM_60FPS:
                                         xmenu_setframe(1);                          xmenu_setframe(1);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_30FPS:                  case IDM_30FPS:
                                         xmenu_setframe(2);                          xmenu_setframe(2);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_20FPS:                  case IDM_20FPS:
                                         xmenu_setframe(3);                          xmenu_setframe(3);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_15FPS:                  case IDM_15FPS:
                                         xmenu_setframe(4);                          xmenu_setframe(4);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_SCREENOPT:                  case IDM_SCREENOPT:
                                         winuienter();                          winuienter();
                                         dialog_scropt(hWnd);                          dialog_scropt(hWnd);
                                         winuileave();                          winuileave();
                                         break;                          break;
   
                                 case IDM_KEY:                  case IDM_KEY:
                                         xmenu_setkey(0);                          xmenu_setkey(0);
                                         break;                          update |= SYS_UPDATECFG;
                           break;
   
                                 case IDM_JOY1:                  case IDM_JOY1:
                                         xmenu_setkey(1);                          xmenu_setkey(1);
                                         break;                          update |= SYS_UPDATECFG;
                           break;
   
                                 case IDM_JOY2:                  case IDM_JOY2:
                                         xmenu_setkey(2);                          xmenu_setkey(2);
                                         break;                          update |= SYS_UPDATECFG;
                           break;
   
                                 case IDM_XSHIFT:                  case IDM_XSHIFT:
                                         xmenu_setxshift(np2cfg.XSHIFT ^ 1);                          xmenu_setxshift(np2cfg.XSHIFT ^ 1);
                                         keystat_forcerelease(0x70);                          keystat_forcerelease(0x70);
                                         break;                          update |= SYS_UPDATECFG;
                           break;
   
                                 case IDM_XCTRL:                  case IDM_XCTRL:
                                         xmenu_setxshift(np2cfg.XSHIFT ^ 2);                          xmenu_setxshift(np2cfg.XSHIFT ^ 2);
                                         keystat_forcerelease(0x74);                          keystat_forcerelease(0x74);
                                         break;                          update |= SYS_UPDATECFG;
                           break;
   
                                 case IDM_XGRPH:                  case IDM_XGRPH:
                                         xmenu_setxshift(np2cfg.XSHIFT ^ 4);                          xmenu_setxshift(np2cfg.XSHIFT ^ 4);
                                         keystat_forcerelease(0x73);                          keystat_forcerelease(0x73);
                                         break;                          update |= SYS_UPDATECFG;
                           break;
   
                                 case IDM_F12MOUSE:                  case IDM_F12MOUSE:
                                         xmenu_setf12copy(0);                          xmenu_setf12copy(0);
                                         keystat_resetcopyhelp();                          winkbd_resetf12();
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATEOSCFG;
                                         break;                          break;
   
                                 case IDM_F12COPY:                  case IDM_F12COPY:
                                         xmenu_setf12copy(1);                          xmenu_setf12copy(1);
                                         keystat_resetcopyhelp();                          winkbd_resetf12();
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATEOSCFG;
                                         break;                          break;
   
                                 case IDM_F12STOP:                  case IDM_F12STOP:
                                         xmenu_setf12copy(2);                          xmenu_setf12copy(2);
                                         keystat_resetcopyhelp();                          winkbd_resetf12();
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATEOSCFG;
                                         break;                          break;
   
                                 case IDM_BEEPOFF:                  case IDM_F12EQU:
                                         xmenu_setbeepvol(0);                          xmenu_setf12copy(3);
                                         beep_setvol(0);                          winkbd_resetf12();
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATEOSCFG;
                                         break;                          break;
   
                                 case IDM_BEEPLOW:                  case IDM_F12COMMA:
                                         xmenu_setbeepvol(1);                          xmenu_setf12copy(4);
                                         beep_setvol(1);                          winkbd_resetf12();
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATEOSCFG;
                                         break;                          break;
   
                                 case IDM_BEEPMID:                  case IDM_BEEPOFF:
                                         xmenu_setbeepvol(2);                          xmenu_setbeepvol(0);
                                         beep_setvol(2);                          beep_setvol(0);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_BEEPHIGH:                  case IDM_BEEPLOW:
                                         xmenu_setbeepvol(3);                          xmenu_setbeepvol(1);
                                         beep_setvol(3);                          beep_setvol(1);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_NOSOUND:                  case IDM_BEEPMID:
                                         xmenu_setsound(0);                          xmenu_setbeepvol(2);
                                         update |= SYS_UPDATECFG;                          beep_setvol(2);
                                         break;                          update |= SYS_UPDATECFG;
                           break;
   
                                 case IDM_PC9801_14:                  case IDM_BEEPHIGH:
                                         xmenu_setsound(1);                          xmenu_setbeepvol(3);
                                         update |= SYS_UPDATECFG;                          beep_setvol(3);
                                         break;                          update |= SYS_UPDATECFG;
                           break;
   
                                 case IDM_PC9801_26K:                  case IDM_NOSOUND:
                                         {                          xmenu_setsound(0x00);
                                                 BYTE    sw;                          update |= SYS_UPDATECFG;
                                                 sw = np2cfg.SOUND_SW;                          break;
                                                 if (sw & 4) {  
                                                         sw &= 6;  
                                                         sw ^= 2;  
                                                 }  
                                                 else {  
                                                         sw = 2;  
                                                 }  
                                                 xmenu_setsound(sw);  
                                                 update |= SYS_UPDATECFG;  
                                         }  
                                         break;  
   
                                 case IDM_PC9801_86:                  case IDM_PC9801_14:
                                         {                          xmenu_setsound(0x01);
                                                 BYTE    sw;                          update |= SYS_UPDATECFG;
                                                 sw = np2cfg.SOUND_SW;                          break;
                                                 if (sw & 2) {  
                                                         sw &= 6;  
                                                         sw ^= 4;  
                                                 }  
                                                 else if (!(sw & 4)) {  
                                                         sw = 4;  
                                                 }  
                                                 xmenu_setsound(sw);  
                                                 update |= SYS_UPDATECFG;  
                                         }  
                                         break;  
   
                                 case IDM_PC9801_118:                  case IDM_PC9801_26K:
                                         xmenu_setsound(8);                          xmenu_setsound(0x02);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_CHIBIOTO:                  case IDM_PC9801_86:
                                         {                          xmenu_setsound(0x04);
                                                 BYTE    sw;                          update |= SYS_UPDATECFG;
                                                 sw = np2cfg.SOUND_SW;                          break;
                                                 if (sw & 4) {  
                                                         sw &= 0x14;  
                                                         sw ^= 0x10;  
                                                 }  
                                                 else {  
                                                         sw = 0x14;  
                                                 }  
                                                 xmenu_setsound(sw);  
                                                 update |= SYS_UPDATECFG;  
                                         }  
                                         break;  
   
                                 case IDM_SPEAKBOARD:                  case IDM_PC9801_26_86:
                                         xmenu_setsound(0x20);                          xmenu_setsound(0x06);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_SPARKBOARD:                  case IDM_PC9801_86_CB:
                                         xmenu_setsound(0x40);                          xmenu_setsound(0x14);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_AMD98:                  case IDM_PC9801_118:
                                         xmenu_setsound(0x80);                          xmenu_setsound(0x08);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_SNDOPT:                  case IDM_SPEAKBOARD:
                                         winuienter();                          xmenu_setsound(0x20);
                                         dialog_sndopt(hWnd);                          update |= SYS_UPDATECFG;
                                         winuileave();                          break;
                                         break;  
   
                                 case IDM_SEEKSND:                  case IDM_SPARKBOARD:
                                         xmenu_setmotorflg(np2cfg.MOTOR ^ 1);                          xmenu_setsound(0x40);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_MEM640:                  case IDM_AMD98:
                                         xmenu_setextmem(0);                          xmenu_setsound(0x80);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_MEM16:                  case IDM_JASTSOUND:
                                         xmenu_setextmem(1);                          xmenu_setjastsound(np2oscfg.jastsnd ^ 1);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATEOSCFG;
                                         break;                          break;
   
                                 case IDM_MEM36:                  case IDM_SEEKSND:
                                         xmenu_setextmem(3);                          xmenu_setmotorflg(np2cfg.MOTOR ^ 1);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_MEM76:                  case IDM_MEM640:
                                         xmenu_setextmem(7);                          xmenu_setextmem(0);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_MOUSE:                  case IDM_MEM16:
                                         mouse_running(MOUSE_XOR);                          xmenu_setextmem(1);
                                         xmenu_setmouse(np2oscfg.MOUSE_SW ^ 1);                          update |= SYS_UPDATECFG;
                                         update |= SYS_UPDATECFG;                          break;
                                         break;  
   
                                 case IDM_MPUPC98:                  case IDM_MEM36:
                                         winuienter();                          xmenu_setextmem(3);
                                         DialogBox(hInst, MAKEINTRESOURCE(IDD_MPUPC98),                          update |= SYS_UPDATECFG;
                                                                                         hWnd, (DLGPROC)MidiDialogProc);                          break;
                                         winuileave();  
                                         break;  
   
                                 case IDM_MIDIPANIC:                                                                     // ver0.29                  case IDM_MEM76:
                                         rs232c_midipanic();                          xmenu_setextmem(7);
                                         mpu98ii_midipanic();                          update |= SYS_UPDATECFG;
                                         pc9861k_midipanic();                          break;
                                         break;  
   
                                 case IDM_BMPSAVE:                  case IDM_MEM116:
                                         winuienter();                          xmenu_setextmem(11);
                                         dialog_writebmp(hWnd);                          update |= SYS_UPDATECFG;
                                         winuileave();                          break;
                                         break;  
   
                                 case IDM_S98LOGGING:                  case IDM_MEM136:
                                         winuienter();                          xmenu_setextmem(13);
                                         dialog_s98(hWnd);                          update |= SYS_UPDATECFG;
                                         winuileave();                          break;
                                         break;  
                   case IDM_MOUSE:
                           mousemng_toggle(MOUSEPROC_SYSTEM);
                           xmenu_setmouse(np2oscfg.MOUSE_SW ^ 1);
                           update |= SYS_UPDATECFG;
                           break;
   
                   case IDM_MPUPC98:
                           winuienter();
                           DialogBox(hInst, MAKEINTRESOURCE(IDD_MPUPC98),
                                                                                           hWnd, (DLGPROC)MidiDialogProc);
                           winuileave();
                           break;
   
                   case IDM_MIDIPANIC:                                                                     // ver0.29
                           rs232c_midipanic();
                           mpu98ii_midipanic();
                           pc9861k_midipanic();
                           break;
   
                   case IDM_SNDOPT:
                           winuienter();
                           dialog_sndopt(hWnd);
                           winuileave();
                           break;
   
                                 case IDM_CALENDAR:                  case IDM_BMPSAVE:
                                         winuienter();                          winuienter();
                                         DialogBox(hInst, MAKEINTRESOURCE(IDD_CALENDAR),                          dialog_writebmp(hWnd);
                           winuileave();
                           break;
   #if defined(SUPPPORT_S98)
                   case IDM_S98LOGGING:
                           winuienter();
                           dialog_s98(hWnd);
                           winuileave();
                           break;
   #endif
   #if defined(SUPPORT_WAVEREC)
                   case IDM_WAVEREC:
                           winuienter();
                           dialog_waverec(hWnd);
                           winuileave();
                           break;
   #endif
                   case IDM_CALENDAR:
                           winuienter();
                           DialogBox(hInst, MAKEINTRESOURCE(IDD_CALENDAR),
                                                                                         hWnd, (DLGPROC)ClndDialogProc);                                                                                          hWnd, (DLGPROC)ClndDialogProc);
                                         winuileave();                          winuileave();
                                         break;                          break;
   
                                 case IDM_JOYX:                  case IDM_JOYX:
                                         xmenu_setbtnmode(np2cfg.BTN_MODE ^ 1);                          xmenu_setbtnmode(np2cfg.BTN_MODE ^ 1);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_RAPID:                  case IDM_RAPID:
                                         xmenu_setbtnrapid(np2cfg.BTN_RAPID ^ 1);                          xmenu_setbtnrapid(np2cfg.BTN_RAPID ^ 1);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_MSRAPID:                  case IDM_MSRAPID:
                                         xmenu_setmsrapid(np2cfg.MOUSERAPID ^ 1);                          xmenu_setmsrapid(np2cfg.MOUSERAPID ^ 1);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_I286SAVE:                  case IDM_I286SAVE:
                                         debugsub_status();                          debugsub_status();
                                         break;                          break;
   
                                 case IDM_HELP:                  case IDM_HELP:
                                         ShellExecute(hWnd, NULL, file_getcd(np2help),                          ShellExecute(hWnd, NULL, file_getcd(np2help),
                                                                                         NULL, NULL, SW_SHOWNORMAL);                                                                                          NULL, NULL, SW_SHOWNORMAL);
                                         break;                          break;
   
                                 case IDM_ABOUT:                  case IDM_ABOUT:
                                         winuienter();                          winuienter();
                                         DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUT),                          DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUT),
                                                                         hWnd, (DLGPROC)AboutDialogProc);                                                                          hWnd, (DLGPROC)AboutDialogProc);
                                         winuileave();                          winuileave();
                           break;
           }
           sysmng_update(update);
   }
   
   LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
   
           PAINTSTRUCT     ps;
           RECT            rc;
           HDC                     hdc;
           UINT            update;
   
           switch (msg) {
                   case WM_CREATE:
   #ifndef __GNUC__
                           WINNLSEnableIME(hWnd, FALSE);
   #endif
                           break;
   
                   case WM_SYSCOMMAND:
                           update = 0;
                           switch(wParam) {
                                   case IDM_MEMORYDUMP:
                                           debugsub_memorydump();
                                         break;                                          break;
   
                                   default:
                                           return(DefWindowProc(hWnd, msg, wParam, lParam));
                         }                          }
                         sysmng_update(update);                          sysmng_update(update);
                         break;                          break;
   
                   case WM_COMMAND:
                           np2cmd(hWnd, LOWORD(wParam));
                           break;
   
                 case WM_ACTIVATE:                  case WM_ACTIVATE:
                         if (LOWORD(wParam) != WA_INACTIVE) {                          if (LOWORD(wParam) != WA_INACTIVE) {
                                 scrnmng_update();                                  scrnmng_update();
                                 mouse_running(MOUSE_CONT_M);                                  keystat_allrelease();
                                   mousemng_enable(MOUSEPROC_BG);
                         }                          }
                         else {                          else {
                                 mouse_running(MOUSE_STOP_M);                                  mousemng_disable(MOUSEPROC_BG);
                         }                          }
                         break;                          break;
   
                 case WM_PAINT:                  case WM_PAINT:
                         hdc = BeginPaint(hWnd, &ps);                          hdc = BeginPaint(hWnd, &ps);
                         if (np2opening) {                          if (np2opening) {
                               HINSTANCE   hinst;
                             HDC                 hmdc;                                  RECT            rect;
                                   int                     width;
                                   int                     height;
                             HBITMAP             hbmp;                              HBITMAP             hbmp;
                             BITMAP              bmp;                              BITMAP              bmp;
                             HINSTANCE   hinst;                              HDC                 hmdc;
                                 int                     sx = 640;                                  HBRUSH          hbrush;
                                 int                     sy = 400;  
   
                             hinst = (HINSTANCE)GetWindowLong(hWnd, GWL_HINSTANCE);                              hinst = (HINSTANCE)GetWindowLong(hWnd, GWL_HINSTANCE);
 #if 1                                  GetClientRect(hWnd, &rect);
                         hbmp = LoadBitmap(hinst, "NP2BMP");                                  width = rect.right - rect.left;
                             GetObject(hbmp, sizeof(BITMAP), &bmp);                                  height = rect.bottom - rect.top;
                             hmdc = CreateCompatibleDC(hdc);                                  hbmp = LoadBitmap(hinst, "NP2BMP");
                             SelectObject(hmdc, hbmp);                                  GetObject(hbmp, sizeof(BITMAP), &bmp);
                             BitBlt(hdc, (sx - 252) / 2, (sy - 28) / 2,                                  hbrush = (HBRUSH)SelectObject(hdc,
                                                         bmp.bmWidth, bmp.bmHeight, hmdc, 0, 0, SRCCOPY);                                                                                                  GetStockObject(BLACK_BRUSH));
                             DeleteDC(hmdc);                                  PatBlt(hdc, 0, 0, width, height, PATCOPY);
                         DeleteObject(hbmp);                                  SelectObject(hdc, hbrush);
 #else                                  hmdc = CreateCompatibleDC(hdc);
                         hbmp = LoadBitmap(hinst, "NP2EXT");                                  SelectObject(hmdc, hbmp);
                             GetObject(hbmp, sizeof(BITMAP), &bmp);                                  BitBlt(hdc, (width - bmp.bmWidth) / 2,
                             hmdc = CreateCompatibleDC(hdc);                                                  (height - bmp.bmHeight) / 2,
                             SelectObject(hmdc, hbmp);  
                             BitBlt(hdc, (sx - 160) / 2, (sy - 140) / 2,  
                                                         bmp.bmWidth, bmp.bmHeight, hmdc, 0, 0, SRCCOPY);                                                          bmp.bmWidth, bmp.bmHeight, hmdc, 0, 0, SRCCOPY);
                             DeleteDC(hmdc);                                  DeleteDC(hmdc);
                         DeleteObject(hbmp);                                  DeleteObject(hbmp);
 #endif  
                         }                          }
                         else {                          else {
 //                              scrnmng_update();  //                              scrnmng_update();
Line 602  LRESULT CALLBACK WndProc(HWND hWnd, UINT Line 691  LRESULT CALLBACK WndProc(HWND hWnd, UINT
   
                 case WM_MOVE:                  case WM_MOVE:
                         if ((!scrnmng_isfullscreen()) &&                          if ((!scrnmng_isfullscreen()) &&
                                 (!(GetWindowLong(hWndMain, GWL_STYLE) &                                  (!(GetWindowLong(hWnd, GWL_STYLE) &
                                                                         (WS_MAXIMIZE | WS_MINIMIZE)))) {                                                                          (WS_MAXIMIZE | WS_MINIMIZE)))) {
                                 GetWindowRect(hWnd, &rc);                                  GetWindowRect(hWnd, &rc);
                                 np2oscfg.winx = rc.left;                                  np2oscfg.winx = rc.left;
Line 611  LRESULT CALLBACK WndProc(HWND hWnd, UINT Line 700  LRESULT CALLBACK WndProc(HWND hWnd, UINT
                         }                          }
                         break;                          break;
   
                   case WM_SIZE:
                           if (wParam == SIZE_RESTORED) {
                                   scrnmng_restoresize();
                           }
                           break;
   
                 case WM_ENTERMENULOOP:                  case WM_ENTERMENULOOP:
                         winuienter();                          winuienter();
                         if (scrnmng_isfullscreen()) {                          if (scrnmng_isfullscreen()) {
Line 623  LRESULT CALLBACK WndProc(HWND hWnd, UINT Line 718  LRESULT CALLBACK WndProc(HWND hWnd, UINT
                         break;                          break;
   
                 case WM_ENTERSIZEMOVE:                  case WM_ENTERSIZEMOVE:
                         soundmng_stop();                          soundmng_disable(SNDPROC_MAIN);
                         mouse_running(MOUSE_STOP);                          mousemng_disable(MOUSEPROC_WINUI);
                         break;                          break;
   
                 case WM_EXITSIZEMOVE:                  case WM_EXITSIZEMOVE:
                         mouse_running(MOUSE_CONT);                          mousemng_enable(MOUSEPROC_WINUI);
                         soundmng_play();                          soundmng_enable(SNDPROC_MAIN);
                         break;                          break;
   
                 case WM_KEYDOWN:                  case WM_KEYDOWN:
Line 637  LRESULT CALLBACK WndProc(HWND hWnd, UINT Line 732  LRESULT CALLBACK WndProc(HWND hWnd, UINT
                                 return(DefWindowProc(hWnd, WM_SYSKEYDOWN, VK_F10, lParam));                                  return(DefWindowProc(hWnd, WM_SYSKEYDOWN, VK_F10, lParam));
                         }                          }
                         if ((wParam == VK_F12) && (!np2oscfg.F12COPY)) {                          if ((wParam == VK_F12) && (!np2oscfg.F12COPY)) {
                                 mouse_running(MOUSE_XOR);                                  mousemng_toggle(MOUSEPROC_SYSTEM);
                                 xmenu_setmouse(np2oscfg.MOUSE_SW ^ 1);                                  xmenu_setmouse(np2oscfg.MOUSE_SW ^ 1);
                                 sysmng_update(SYS_UPDATECFG);                                  sysmng_update(SYS_UPDATECFG);
                         }                          }
                         else {                          else {
                                 winkeydown106(wParam, lParam);                                  winkbd_keydown(wParam, lParam);
                         }                          }
                         break;                          break;
   
                 case WM_KEYUP:                  case WM_KEYUP:
                         if (wParam == VK_F11) {                          if (wParam == VK_F11) {
                                 return(DefWindowProc(hWnd, WM_SYSKEYUP, VK_F10, lParam));                                  return(DefWindowProc(hWnd, WM_SYSKEYUP, VK_F10, lParam));
                         }                          }
                         if ((wParam != VK_F12) || (np2oscfg.F12COPY)) {                          if ((wParam != VK_F12) || (np2oscfg.F12COPY)) {
                                 winkeyup106(wParam, lParam);                                  winkbd_keyup(wParam, lParam);
                         }                          }
                         break;                          break;
   
                 case WM_SYSKEYDOWN:                  case WM_SYSKEYDOWN:
                         winkeydown106(wParam, lParam);                          winkbd_keydown(wParam, lParam);
                         break;                          break;
   
                 case WM_SYSKEYUP:                  case WM_SYSKEYUP:
                         winkeyup106(wParam, lParam);                          winkbd_keyup(wParam, lParam);
                         break;                          break;
   
                 case WM_LBUTTONDOWN:                  case WM_LBUTTONDOWN:
                         if (!mouse_btn(MOUSE_LEFTDOWN)) {                          if (!mousemng_buttonevent(MOUSEMNG_LEFTDOWN)) {
                                 return(DefWindowProc(hWnd, msg, wParam, lParam));                                  return(DefWindowProc(hWnd, msg, wParam, lParam));
                         }                          }
                         break;                          break;
   
                 case WM_LBUTTONUP:                  case WM_LBUTTONUP:
                         if (!mouse_btn(MOUSE_LEFTUP)) {                          if (!mousemng_buttonevent(MOUSEMNG_LEFTUP)) {
                                 return(DefWindowProc(hWnd, msg, wParam, lParam));                                  return(DefWindowProc(hWnd, msg, wParam, lParam));
                         }                          }
                         break;                          break;
   
                 case WM_MBUTTONDOWN:                                                                    // ver0.26                  case WM_MBUTTONDOWN:                                                                    // ver0.26
                         mouse_running(MOUSE_XOR);                          mousemng_toggle(MOUSEPROC_SYSTEM);
                         xmenu_setmouse(np2oscfg.MOUSE_SW ^ 1);                          xmenu_setmouse(np2oscfg.MOUSE_SW ^ 1);
                         sysmng_update(SYS_UPDATECFG);                          sysmng_update(SYS_UPDATECFG);
                         break;                          break;
   
                 case WM_RBUTTONDOWN:                  case WM_RBUTTONDOWN:
                         if (!mouse_btn(MOUSE_RIGHTDOWN)) {                          if (!mousemng_buttonevent(MOUSEMNG_RIGHTDOWN)) {
                                 return(DefWindowProc(hWnd, msg, wParam, lParam));                                  return(DefWindowProc(hWnd, msg, wParam, lParam));
                         }                          }
                         break;                          break;
   
                 case WM_RBUTTONUP:                  case WM_RBUTTONUP:
                         if (!mouse_btn(MOUSE_RIGHTUP)) {                          if (!mousemng_buttonevent(MOUSEMNG_RIGHTUP)) {
                                 return(DefWindowProc(hWnd, msg, wParam, lParam));                                  return(DefWindowProc(hWnd, msg, wParam, lParam));
                         }                          }
                         break;                          break;
Line 724  LRESULT CALLBACK WndProc(HWND hWnd, UINT Line 821  LRESULT CALLBACK WndProc(HWND hWnd, UINT
         return(0L);          return(0L);
 }  }
   
   static void framereset(void) {
   
 static void processwait(UINT waitcnt) {          framecnt = 0;
           sysmng_updatecaption();
           memdbg_process();
           skbdwin_process();
   }
   
   static void processwait(UINT cnt) {
   
         if (timing_getcount() >= waitcnt) {          if (timing_getcount() >= cnt) {
                 timing_setcount(0);                  timing_setcount(0);
                 framecnt = 0;                  framereset();
         }          }
         else {          else {
                 Sleep(1);                  Sleep(1);
         }          }
           soundmng_sync();
 }  }
   
   
 int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPreInst,  int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPreInst,
                                                                                 LPSTR lpszCmdLine, int nCmdShow) {                                                                                  LPSTR lpszCmdLine, int nCmdShow) {
         WNDCLASS        np2;          WNDCLASS        wc;
         MSG                     msg;          MSG                     msg;
         HMENU           hMenu;          HWND            hWnd;
         HWND            hwndorg;  
         int                     i;          int                     i;
 #ifdef OPENING_WAIT  #ifdef OPENING_WAIT
         UINT32          tick;          UINT32          tick;
 #endif  #endif
   
           _MEM_INIT();
   
         GetModuleFileName(NULL, modulefile, sizeof(modulefile));          GetModuleFileName(NULL, modulefile, sizeof(modulefile));
         dosio_init();          dosio_init();
         file_setcd(modulefile);          file_setcd(modulefile);
         np2arg_analize(lpszCmdLine);                            // タイミング修正       // ver0.29          np2arg_analize(lpszCmdLine);
         initload();          initload();
           memdbg_readini();
           skbdwin_readini();
   
         srand((unsigned)time(NULL));          rand_setseed((unsigned)time(NULL));
   
         if ((hwndorg = FindWindow(szClassName, NULL)) != NULL) {          if ((hWnd = FindWindow(szClassName, NULL)) != NULL) {
                 ShowWindow(hwndorg, SW_RESTORE);                  ShowWindow(hWnd, SW_RESTORE);
                 SetForegroundWindow(hwndorg);                  SetForegroundWindow(hWnd);
                 dosio_term();                  dosio_term();
                 return(FALSE);                  return(FALSE);
         }          }
Line 779  int WINAPI WinMain(HINSTANCE hInstance,  Line 887  int WINAPI WinMain(HINSTANCE hInstance, 
                         np2oscfg.KEYBOARD = KEY_KEY106;                          np2oscfg.KEYBOARD = KEY_KEY106;
                 }                  }
         }          }
         keystat_reset();          keystat_initialize();
   
         if (!hPreInst) {          if (!hPreInst) {
                 np2.style = CS_BYTEALIGNCLIENT | CS_HREDRAW | CS_VREDRAW;                  wc.style = CS_BYTEALIGNCLIENT | CS_HREDRAW | CS_VREDRAW;
                 np2.lpfnWndProc = WndProc;                  wc.lpfnWndProc = WndProc;
                 np2.cbClsExtra = 0;                  wc.cbClsExtra = 0;
                 np2.cbWndExtra = 0;                  wc.cbWndExtra = 0;
                 np2.hInstance = hInstance;                  wc.hInstance = hInstance;
                 np2.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ICON1));                  wc.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ICON1));
                 np2.hCursor = LoadCursor(NULL, IDC_ARROW);                  wc.hCursor = LoadCursor(NULL, IDC_ARROW);
                 np2.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);                  wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
                 np2.lpszMenuName = MAKEINTRESOURCE(IDM_MAIN);                  wc.lpszMenuName = MAKEINTRESOURCE(IDR_MAIN);
                 np2.lpszClassName = szClassName;                  wc.lpszClassName = szClassName;
                 if (!RegisterClass(&np2)) {                  if (!RegisterClass(&wc)) {
                         return(FALSE);                          return(FALSE);
                 }                  }
         }          }
           memdbg_initialize(hInstance);
           skbdwin_initialize(hInstance);
   
         hWndMain = CreateWindowEx(0, szClassName, szAppCaption,          mousemng_initialize();
   
           hWnd = CreateWindowEx(0, szClassName, szAppCaption,
                                                 WS_OVERLAPPED | WS_SYSMENU | WS_CAPTION |                                                  WS_OVERLAPPED | WS_SYSMENU | WS_CAPTION |
                                                 WS_MINIMIZEBOX,                                                  WS_MINIMIZEBOX,
                                                 np2oscfg.winx, np2oscfg.winy, 640, 400,                                                  np2oscfg.winx, np2oscfg.winy, 640, 400,
                                                 NULL, NULL, hInstance, NULL);                                                  NULL, NULL, hInstance, NULL);
           hWndMain = hWnd;
         scrnmng_initialize();          scrnmng_initialize();
   
         xmenu_setsound(np2cfg.SOUND_SW);          xmenu_setroltate(0);
         xmenu_setbeepvol(np2cfg.BEEP_VOL);          xmenu_setdispmode(np2cfg.DISPSYNC);
         xmenu_setkey(0);          xmenu_setraster(np2cfg.RASTER);
         xmenu_setbtnrapid(np2cfg.BTN_RAPID);  
         xmenu_setbtnmode(np2cfg.BTN_MODE);  
         xmenu_setmsrapid(np2cfg.MOUSERAPID);  
         xmenu_setwaitflg(np2oscfg.NOWAIT);          xmenu_setwaitflg(np2oscfg.NOWAIT);
         xmenu_setframe(np2oscfg.DRAW_SKIP);          xmenu_setframe(np2oscfg.DRAW_SKIP);
         xmenu_setdispmode(np2cfg.DISPSYNC);  
         xmenu_seti286save(np2oscfg.I286SAVE);          xmenu_setkey(0);
         xmenu_setmotorflg(np2cfg.MOTOR);  
         xmenu_setroltate(0);  
         xmenu_setxshift(0);          xmenu_setxshift(0);
         xmenu_setf12copy(np2oscfg.F12COPY);          xmenu_setf12copy(np2oscfg.F12COPY);
           xmenu_setbeepvol(np2cfg.BEEP_VOL);
           xmenu_setsound(np2cfg.SOUND_SW);
           xmenu_setjastsound(np2oscfg.jastsnd);
           xmenu_setmotorflg(np2cfg.MOTOR);
         xmenu_setextmem(np2cfg.EXTMEM);          xmenu_setextmem(np2cfg.EXTMEM);
         xmenu_setraster(np2cfg.RASTER);  
         xmenu_setmouse(np2oscfg.MOUSE_SW);          xmenu_setmouse(np2oscfg.MOUSE_SW);
   
         ShowWindow(hWndMain, nCmdShow);          xmenu_setbtnmode(np2cfg.BTN_MODE);
         UpdateWindow(hWndMain);          xmenu_setbtnrapid(np2cfg.BTN_RAPID);
           xmenu_setmsrapid(np2cfg.MOUSERAPID);
   
           ShowWindow(hWnd, nCmdShow);
           UpdateWindow(hWnd);
   
 #ifdef OPENING_WAIT  #ifdef OPENING_WAIT
         tick = GetTickCount();          tick = GetTickCount();
 #endif  #endif
   
         if (np2oscfg.I286SAVE) {          sysmenu_initialize();
                 hMenu = GetSystemMenu(hWndMain, FALSE);          xmenu_initialize();
                 InsertMenu(hMenu, 0, MF_BYPOSITION | MF_STRING, IDM_MEMORYDUMP,          DrawMenuBar(hWnd);
                                                         "&Memory Dump");  
                 InsertMenu(hMenu, 1, MF_BYPOSITION | MF_SEPARATOR, 0, NULL);  
         }  
         DrawMenuBar(hWndMain);  
   
         // ver0.30          // ver0.30
         if (file_attr_c(np2help) == (short)-1) {          if (file_attr_c(np2help) == (short)-1) {
                 EnableMenuItem(GetMenu(hWndMain), IDM_HELP, MF_GRAYED);                  EnableMenuItem(GetMenu(hWnd), IDM_HELP, MF_GRAYED);
         }          }
   
         scrnmode = 0;          scrnmode = 0;
Line 853  int WINAPI WinMain(HINSTANCE hInstance,  Line 963  int WINAPI WinMain(HINSTANCE hInstance, 
         if (scrnmng_create(scrnmode) != SUCCESS) {          if (scrnmng_create(scrnmode) != SUCCESS) {
                 scrnmode ^= SCRNMODE_FULLSCREEN;                  scrnmode ^= SCRNMODE_FULLSCREEN;
                 if (scrnmng_create(scrnmode) != SUCCESS) {                  if (scrnmng_create(scrnmode) != SUCCESS) {
                         MessageBox(hWndMain, "Couldn't create DirectDraw Object",                          MessageBox(hWnd, "Couldn't create DirectDraw Object",
                                                                                 szAppCaption, MB_OK | MB_ICONSTOP);                                                                                  szAppCaption, MB_OK | MB_ICONSTOP);
                         return(FALSE);                          return(FALSE);
                 }                  }
         }          }
   
         soundmng_initialize();          soundmng_initialize();
           if (np2oscfg.MOUSE_SW) {                                                                                // ver0.30
                   mousemng_enable(MOUSEPROC_SYSTEM);
           }
   
         commng_initialize();          commng_initialize();
         sysmng_initialize();          sysmng_initialize();
   
         joy_init();          joy_init();
         pccore_init();          pccore_init();
         S98_init();          S98_init();
Line 870  int WINAPI WinMain(HINSTANCE hInstance,  Line 985  int WINAPI WinMain(HINSTANCE hInstance, 
         while((GetTickCount() - tick) < OPENING_WAIT);          while((GetTickCount() - tick) < OPENING_WAIT);
 #endif  #endif
   
         if (np2oscfg.MOUSE_SW) {                                                                                // ver0.30  
                 mouse_running(MOUSE_ON);  
         }  
         scrndraw_redraw();          scrndraw_redraw();
   
         pccore_reset();          pccore_reset();
   
         np2opening = 0;          np2opening = 0;
   
           // れじうむ
   #if defined(SUPPORT_RESUME)
           if (np2oscfg.resume) {
                   int             id;
   
                   id = flagload(str_sav, str_resume, FALSE);
                   if (id == IDYES) {
                           for (i=0; i<4; i++) np2arg.disk[i] = NULL;
                   }
                   else if (id == IDCANCEL) {
                           DestroyWindow(hWnd);
                           mousemng_disable(MOUSEPROC_WINUI);
                           S98_trash();
                           pccore_term();
                           soundmng_deinitialize();
                           scrnmng_destroy();
                           TRACETERM();
                           dosio_term();
                           return(0);
                   }
           }
   #endif
   
 //      リセットしてから… コマンドラインのディスク挿入。                               // ver0.29  //      リセットしてから… コマンドラインのディスク挿入。                               // ver0.29
         for (i=0; i<4; i++) {          for (i=0; i<4; i++) {
                 if (np2arg.disk[i]) {                  if (np2arg.disk[i]) {
Line 886  int WINAPI WinMain(HINSTANCE hInstance,  Line 1022  int WINAPI WinMain(HINSTANCE hInstance, 
                 }                  }
         }          }
   
           memdbg_create();
           skbdwin_create();
   
         while(1) {          while(1) {
                 if (PeekMessage(&msg, 0, 0, 0, PM_NOREMOVE)) {                  if (PeekMessage(&msg, 0, 0, 0, PM_NOREMOVE)) {
                         if (!GetMessage(&msg, NULL, 0, 0)) {                          if (!GetMessage(&msg, NULL, 0, 0)) {
Line 900  int WINAPI WinMain(HINSTANCE hInstance,  Line 1039  int WINAPI WinMain(HINSTANCE hInstance, 
                 else {                  else {
                         if (np2oscfg.NOWAIT) {                          if (np2oscfg.NOWAIT) {
                                 joy_flash();                                  joy_flash();
                                 mouse_callback();                                  mousemng_sync();
                                 pccore_exec(framecnt == 0);                                  pccore_exec(framecnt == 0);
                                 if (np2oscfg.DRAW_SKIP) {                       // nowait frame skip                                  if (np2oscfg.DRAW_SKIP) {                       // nowait frame skip
                                         framecnt++;                                          framecnt++;
Line 918  int WINAPI WinMain(HINSTANCE hInstance,  Line 1057  int WINAPI WinMain(HINSTANCE hInstance, 
                         else if (np2oscfg.DRAW_SKIP) {          // frame skip                          else if (np2oscfg.DRAW_SKIP) {          // frame skip
                                 if (framecnt < np2oscfg.DRAW_SKIP) {                                  if (framecnt < np2oscfg.DRAW_SKIP) {
                                         joy_flash();                                          joy_flash();
                                         mouse_callback();                                          mousemng_sync();
                                         pccore_exec(framecnt == 0);                                          pccore_exec(framecnt == 0);
                                         framecnt++;                                          framecnt++;
                                 }                                  }
Line 930  int WINAPI WinMain(HINSTANCE hInstance,  Line 1069  int WINAPI WinMain(HINSTANCE hInstance, 
                                 if (!waitcnt) {                                  if (!waitcnt) {
                                         UINT cnt;                                          UINT cnt;
                                         joy_flash();                                          joy_flash();
                                         mouse_callback();                                          mousemng_sync();
                                         pccore_exec(framecnt == 0);                                          pccore_exec(framecnt == 0);
                                         framecnt++;                                          framecnt++;
                                         cnt = timing_getcount();                                          cnt = timing_getcount();
Line 950  int WINAPI WinMain(HINSTANCE hInstance,  Line 1089  int WINAPI WinMain(HINSTANCE hInstance, 
                                                 else {                                                  else {
                                                         timing_setcount(cnt - framecnt);                                                          timing_setcount(cnt - framecnt);
                                                 }                                                  }
                                                 framecnt = 0;                                                  framereset();
                                         }                                          }
                                 }                                  }
                                 else {                                  else {
Line 962  int WINAPI WinMain(HINSTANCE hInstance,  Line 1101  int WINAPI WinMain(HINSTANCE hInstance, 
         }          }
   
         pccore_cfgupdate();          pccore_cfgupdate();
         pccore_term();  
           mousemng_disable(MOUSEPROC_WINUI);
         S98_trash();          S98_trash();
   
         mouse_running(MOUSE_OFF);  #if defined(SUPPORT_RESUME)
           if (np2oscfg.resume) {
                   flagsave(str_sav);
           }
           else {
                   flagdelete(str_sav);
           }
   #endif
   
           pccore_term();
           memdbg_destroy();
           skbdwin_destroy();
   
         soundmng_deinitialize();          soundmng_deinitialize();
         scrnmng_destroy();          scrnmng_destroy();
   
         if (sys_updates & (SYS_UPDATECFG | SYS_UPDATEOSCFG)) {          if (sys_updates & (SYS_UPDATECFG | SYS_UPDATEOSCFG)) {
                 initsave();                  initsave();
                   memdbg_writeini();
                   skbdwin_writeini();
         }          }
   
           skbdwin_deinitialize();
   
         TRACETERM();          TRACETERM();
           _MEM_USED("report.txt");
         dosio_term();          dosio_term();
   
         return(msg.wParam);          return(msg.wParam);
Removed from v.1.4  
changed lines
  Added in v.1.31

RetroPC.NET-CVS <cvs@retropc.net>