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

Diff for /np2/win9x/np2.cpp between versions 1.8 and 1.37

version 1.8, 2003/10/23 12:58:44 version 1.37, 2004/02/03 08:24:40
Line 5 Line 5
 #endif  #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        "cputype.h"
 #include        "dosio.h"  #include        "dosio.h"
 #include        "extromio.h"  #include        "extromio.h"
 #include        "commng.h"  #include        "commng.h"
Line 22 Line 24
 #include        "sstp.h"  #include        "sstp.h"
 #include        "sstpmsg.h"  #include        "sstpmsg.h"
 #include        "dclock.h"  #include        "dclock.h"
 #ifdef USE_ROMEO  #include        "toolwin.h"
 #include        "juliet.h"  #include        "juliet.h"
 #endif  #include        "np2class.h"
 #include        "dialog.h"  #include        "dialog.h"
 #include        "memory.h"  #include        "memory.h"
 #include        "pccore.h"  #include        "pccore.h"
Line 39 Line 41
 #include        "diskdrv.h"  #include        "diskdrv.h"
 #include        "fddfile.h"  #include        "fddfile.h"
 #include        "timing.h"  #include        "timing.h"
 #include        "statsave.h"  
 #include        "debugsub.h"  #include        "debugsub.h"
 #include        "keydisp.h"  #include        "keydisp.h"
   #include        "kdispwin.h"
 #include        "viewer.h"  #include        "viewer.h"
   
   
Line 49 Line 51
 #define         OPENING_WAIT            1500  #define         OPENING_WAIT            1500
 #endif  #endif
   
 #define STATSAVEMAX             10  
   
 static  char            szClassName[] = "NP2-MainWindow";  static  char            szClassName[] = "NP2-MainWindow";
                 HWND            hWndMain;                  HWND            hWndMain;
                 HINSTANCE       hInst;                  HINSTANCE       hInst;
                 HINSTANCE       hPrev;                  HINSTANCE       hPrev;
                   int                     mmxflag;
                   BYTE            np2break = 0;                                                                   // ver0.30
                   BOOL            winui_en;
   
                 NP2OSCFG        np2oscfg = {                  NP2OSCFG        np2oscfg = {
                                                 "Neko Project II", "NP2",                                                  "Neko Project II", "NP2",
                                                 CW_USEDEFAULT, CW_USEDEFAULT, 1, 1, 0, 1, 0, 2,                                                  CW_USEDEFAULT, CW_USEDEFAULT, 1, 1, 0, 1, 0, 0,
                                                 0, 0, KEY_UNKNOWN, 0,                                                  0, 0, KEY_UNKNOWN, 0,
                                                 0, 0, 0, {1, 2, 2, 1},                                                  0, 0, 0, {1, 2, 2, 1},
                                                 {5, 0, 0x3e, 19200, "", "", "", ""},            // ver0.34                                                  {5, 0, 0x3e, 19200, "", "", "", ""},            // ver0.34
Line 66  static char  szClassName[] = "NP2-MainWi Line 69  static char  szClassName[] = "NP2-MainWi
                                                 {0, 0, 0x3e, 19200, "", "", "", ""},            // ver0.34                                                  {0, 0, 0x3e, 19200, "", "", "", ""},            // ver0.34
                                                 {0, 0, 0x3e, 19200, "", "", "", ""},            // ver0.34                                                  {0, 0, 0x3e, 19200, "", "", "", ""},            // ver0.34
                                                 0xffffff, 0xffbf6a, 0, 0,                                                  0xffffff, 0xffbf6a, 0, 0,
                                                 0, 1, 0, 9801, 0, 0, 0, 0};                                     // ver0.34                                                  0, 1, 0, 9801, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
   
                 char    fddfolder[MAX_PATH];                  char            fddfolder[MAX_PATH];
                 char    hddfolder[MAX_PATH];                  char            hddfolder[MAX_PATH];
                 char    bmpfilefolder[MAX_PATH];                  char            bmpfilefolder[MAX_PATH];
                 char    mimpideffile[MAX_PATH];                  char            modulefile[MAX_PATH];
                 char    modulefile[MAX_PATH];  
   static  UINT            framecnt = 0;
 static  UINT    framecnt = 0;  static  UINT            waitcnt = 0;
 static  UINT    waitcnt = 0;  static  UINT            framemax = 1;
 static  UINT    framemax = 1;  static  BYTE            np2stopemulate = 0;
                 BYTE    np2break = 0;                                                                   // ver0.30  static  int                     np2opening = 1;
 static  BYTE    np2stopemulate = 0;  static  int                     np2quitmsg = 0;
 static  int             np2opening = 1;  static  HMENU           hStat = NULL;
 static  int             np2quitmsg = 0;  static  BYTE            scrnmode;
                 HMENU   hStat = NULL;  static  WINLOCEX        smwlex;
   
 static const char np2help[] = "np2.hlp";  static const char np2help[] = "np2.chm";
 static const char np2resume[] = "sav";  static const char np2flagext[] = "S%02d";
   
   
 typedef struct {  static void winuienter(void) {
 const char      *str;  
         int             id;  
 } SYSMENU_ITEM;  
   
 static SYSMENU_ITEM smenu_item[] = {          winui_en = TRUE;
                         {"&Centering",                  IDM_SCREENCENTER},          soundmng_disable(SNDPROC_MAIN);
                         {"&Window Snap",                IDM_SNAPENABLE},          scrnmng_topwinui();
                         {"&Background",                 IDM_BACKGROUND},  }
                         {"Background &Sound",   IDM_BGSOUND},  
                         {"&Key display",                IDM_KEYDISP},  
                         {NULL,                                  0},  
                         {" 320x200",                    IDM_SCRNMUL4},  
                         {" 480x300",                    IDM_SCRNMUL6},  
                         {" 640x400",                    IDM_SCRNMUL8},  
                         {" 800x500",                    IDM_SCRNMUL10},  
                         {" 960x600",                    IDM_SCRNMUL12},  
                         {"1280x800",                    IDM_SCRNMUL16},  
                         {NULL,                                  0},  
                 };  
   
   static void winuileave(void) {
   
 static  BYTE    scrnmode;          scrnmng_clearwinui();
           soundmng_enable(SNDPROC_MAIN);
           winui_en = FALSE;
   }
   
   WINLOCEX np2_winlocexallwin(HWND base) {
   
           HWND    list[3];
           UINT    i;
   
           list[0] = hWndMain;
           list[1] = toolwin_gethwnd();
           list[2] = kdispwin_gethwnd();
           for (i=0; i<3; i++) {
                   if (list[i] == base) {
                           list[i] = NULL;
                   }
           }
           if (base != hWndMain) {         // hWndMainのみ全体移動
                   base = NULL;
           }
           return(winlocex_create(base, list, 3));
   }
   
 static void changescreen(BYTE newmode) {  static void changescreen(BYTE newmode) {
   
         BYTE    change;          BYTE            change;
         BYTE    renewal;          BYTE            renewal;
           WINLOCEX        wlex;
   
         change = scrnmode ^ newmode;          change = scrnmode ^ newmode;
         renewal = (change & SCRNMODE_FULLSCREEN);          renewal = (change & SCRNMODE_FULLSCREEN);
           wlex = NULL;
         if (newmode & SCRNMODE_FULLSCREEN) {          if (newmode & SCRNMODE_FULLSCREEN) {
                 renewal |= (change & SCRNMODE_HIGHCOLOR);                  renewal |= (change & SCRNMODE_HIGHCOLOR);
         }          }
Line 125  static void changescreen(BYTE newmode) { Line 139  static void changescreen(BYTE newmode) {
                 renewal |= (change & SCRNMODE_ROTATEMASK);                  renewal |= (change & SCRNMODE_ROTATEMASK);
         }          }
         if (renewal) {          if (renewal) {
                   if (renewal & SCRNMODE_FULLSCREEN) {
                           toolwin_destroy();
                           kdispwin_destroy();
                   }
                   else if (renewal & SCRNMODE_ROTATEMASK) {
                           wlex = np2_winlocexallwin(hWndMain);
                           winlocex_setholdwnd(wlex, hWndMain);
                   }
                 soundmng_stop();                  soundmng_stop();
                 mouse_running(MOUSE_STOP);                  mousemng_disable(MOUSEPROC_WINUI);
                 keydisp_destroy();  
                 scrnmng_destroy();                  scrnmng_destroy();
                 if (scrnmng_create(newmode) == SUCCESS) {                  if (scrnmng_create(newmode) == SUCCESS) {
                         scrnmode = newmode;                          scrnmode = newmode;
Line 139  static void changescreen(BYTE newmode) { Line 160  static void changescreen(BYTE newmode) {
                         }                          }
                 }                  }
                 scrndraw_redraw();                  scrndraw_redraw();
                 mouse_running(MOUSE_CONT);                  if (renewal & SCRNMODE_FULLSCREEN) {
                           if (!scrnmng_isfullscreen()) {
                                   if (np2oscfg.toolwin) {
                                           toolwin_create();
                                   }
                                   if (np2oscfg.keydisp) {
                                           kdispwin_create();
                                   }
                           }
                   }
                   else if (renewal & SCRNMODE_ROTATEMASK) {
                           winlocex_move(wlex);
                           winlocex_destroy(wlex);
                   }
                   mousemng_enable(MOUSEPROC_WINUI);
                 soundmng_play();                  soundmng_play();
         }          }
         else {          else {
Line 172  void np2active_renewal(void) {         / Line 207  void np2active_renewal(void) {         /
   
         if (np2break & (~NP2BREAK_MAIN)) {          if (np2break & (~NP2BREAK_MAIN)) {
                 np2stopemulate = 2;                  np2stopemulate = 2;
                 soundmng_disable();                  soundmng_disable(SNDPROC_MASTER);
         }          }
         else if (np2break & NP2BREAK_MAIN) {          else if (np2break & NP2BREAK_MAIN) {
                 if (np2oscfg.background & 1) {                  if (np2oscfg.background & 1) {
Line 182  void np2active_renewal(void) {         / Line 217  void np2active_renewal(void) {         /
                         np2stopemulate = 0;                          np2stopemulate = 0;
                 }                  }
                 if (np2oscfg.background) {                  if (np2oscfg.background) {
                         soundmng_disable();                          soundmng_disable(SNDPROC_MASTER);
                 }                  }
                 else {                  else {
                         soundmng_enable();                          soundmng_enable(SNDPROC_MASTER);
                 }                  }
         }          }
         else {          else {
                 np2stopemulate = 0;                  np2stopemulate = 0;
                 soundmng_enable();                  soundmng_enable(SNDPROC_MASTER);
         }          }
 }  }
   
Line 217  static int flagsave(const char *ext) { Line 252  static int flagsave(const char *ext) {
         return(ret);          return(ret);
 }  }
   
   static void flagdelete(const char *ext) {
   
           char    path[MAX_PATH];
   
           getstatfilename(path, ext, sizeof(path));
           file_delete(path);
   }
   
 static int flagload(const char *ext, const char *title, BOOL force) {  static int flagload(const char *ext, const char *title, BOOL force) {
   
         int             ret;          int             ret;
Line 225  static int flagload(const char *ext, con Line 268  static int flagload(const char *ext, con
         char    buf[1024];          char    buf[1024];
   
         getstatfilename(path, ext, sizeof(path));          getstatfilename(path, ext, sizeof(path));
         soundmng_stop();          winuienter();
         scrnmng_topwinui();  
         id = IDYES;          id = IDYES;
         ret = statsave_check(path, buf, sizeof(buf));          ret = statsave_check(path, buf, sizeof(buf));
         if (ret & (~NP2FLAG_DISKCHG)) {          if (ret & (~NP2FLAG_DISKCHG)) {
Line 241  static int flagload(const char *ext, con Line 283  static int flagload(const char *ext, con
         }          }
         if (id == IDYES) {          if (id == IDYES) {
                 statsave_load(path);                  statsave_load(path);
                   toolwin_setfdd(0, fdd_diskname(0));
                   toolwin_setfdd(1, fdd_diskname(1));
         }          }
         sysmng_workclockreset();          sysmng_workclockreset();
         sysmng_updatecaption(1);          sysmng_updatecaption(1);
         scrnmng_clearwinui();          winuileave();
         soundmng_play();  
         return(id);          return(id);
 }  }
   
   
 // ---- proc  // ---- proc
   
 static void winuienter(void) {  static void np2popup(HWND hWnd, LPARAM lp) {
   
         soundmng_stop();          HMENU   mainmenu;
         scrnmng_topwinui();          HMENU   hMenu;
           POINT   pt;
   
           mainmenu = (HMENU)GetWindowLong(hWnd, NP2GWL_HMENU);
           if (mainmenu == NULL) {
                   return;
           }
           hMenu = CreatePopupMenu();
           menu_addmenubar(hMenu, mainmenu);
           pt.x = LOWORD(lp);
           pt.y = HIWORD(lp);
           ClientToScreen(hWnd, &pt);
           TrackPopupMenu(hMenu, TPM_LEFTALIGN, pt.x, pt.y, 0, hWnd, NULL);
           DestroyMenu(hMenu);
 }  }
   
 static void winuileave(void) {  // extern "C" void iptrace_out(void);
   
         scrnmng_clearwinui();  static void np2cmd(HWND hWnd, UINT16 cmd) {
         soundmng_play();  
 }  
   
 LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {  
   
         PAINTSTRUCT     ps;          UINT    update;
         RECT            rc;          BOOL    b;
         HDC                     hdc;  
         BOOL            b;  
         UINT            update;  
   
         switch (msg) {          update = 0;
                 case WM_CREATE:          switch(cmd) {
                         sstp_construct(hWnd);                  case IDM_RESET:
 #ifndef __GNUC__                          b = FALSE;
                         WINNLSEnableIME(hWnd, FALSE);                          if (!np2oscfg.comfirm) {
 #endif                                  b = TRUE;
 //                      DragAcceptFiles(hWnd, TRUE);                          }
                           else if (sstpconfirm_reset()) {
                                   winuienter();
                                   if (MessageBox(hWnd, "Sure?", "Reset",
                                                                           MB_ICONQUESTION | MB_YESNO) == IDYES) {
                                           b = TRUE;
                                   }
                                   winuileave();
                           }
                           if (b) {
                                   sstpmsg_reset();
                                   juliet_YMF288Reset();
                                   pccore_cfgupdate();
                                   pccore_reset();
                           }
                         break;                          break;
   
                 case WM_SYSCOMMAND:                  case IDM_CONFIG:
                         update = 0;                          winuienter();
                         switch(wParam) {                          sstpmsg_config();
                                 case IDM_SCREENCENTER:                                                  // ver0.26                          DialogBox(hInst, MAKEINTRESOURCE(IDD_CONFIG),
                                         if ((!scrnmng_isfullscreen()) &&                                                                          hWnd, (DLGPROC)CfgDialogProc);
                                                 (!(GetWindowLong(hWnd, GWL_STYLE) &                          winuileave();
                                                                                         (WS_MAXIMIZE | WS_MINIMIZE)))) {                          break;
                                                 wincentering(hWnd);  
                                         }  
                                         break;  
   
                                 case IDM_SNAPENABLE:  
                                         xmenu_setwinsnap(np2oscfg.WINSNAP ^ 1);  
                                         update |= SYS_UPDATECFG;  
                                         break;  
   
                                 case IDM_BACKGROUND:                  case IDM_NEWDISK:
                                         xmenu_setbackground(np2oscfg.background ^ 1);                          winuienter();
                                         update |= SYS_UPDATECFG;                          dialog_newdisk(hWnd);
                                         break;                          winuileave();
                           break;
   
                                 case IDM_BGSOUND:                  case IDM_CHANGEFONT:
                                         xmenu_setbgsound(np2oscfg.background ^ 2);                          winuienter();
                                         update |= SYS_UPDATECFG;                          dialog_font(hWnd);
                                         break;                          winuileave();
                           break;
   
                                 case IDM_KEYDISP:                  case IDM_EXIT:
                                         keydisp_create();                          SendMessage(hWnd, WM_CLOSE, 0, 0L);
                                         break;                          break;
   
                                 case IDM_MEMORYDUMP:                  case IDM_FDD1OPEN:
                                         debugsub_memorydump();                          winuienter();
                                         break;                          dialog_changefdd(hWnd, 0);
                           winuileave();
                           break;
   
                                 case IDM_DEBUGUTY:                  case IDM_FDD1EJECT:
                                         viewer_open();                          diskdrv_setfdd(0, NULL, 0);
                                         break;                          toolwin_setfdd(0, NULL);
                           break;
   
                                 case IDM_SCRNMUL4:                                                              // ver0.26                  case IDM_FDD2OPEN:
                                 case IDM_SCRNMUL6:                          winuienter();
                                 case IDM_SCRNMUL8:                          dialog_changefdd(hWnd, 1);
                                 case IDM_SCRNMUL10:                          winuileave();
                                 case IDM_SCRNMUL12:                          break;
                                 case IDM_SCRNMUL16:  
                                         if ((!scrnmng_isfullscreen()) &&  
                                                 !(GetWindowLong(hWndMain, GWL_STYLE) & WS_MINIMIZE)) {  
                                                 xmenu_setscrnmul(wParam - IDM_SCRNMUL);  
                                                 scrnmng_setmultiple(wParam - IDM_SCRNMUL);  
                                         }  
                                         break;  
   
                                 default:                  case IDM_FDD2EJECT:
                                         return(DefWindowProc(hWnd, msg, wParam, lParam));                          diskdrv_setfdd(1, NULL, 0);
                         }                          toolwin_setfdd(1, NULL);
                         sysmng_update(update);  
                         break;                          break;
   
                 case WM_COMMAND:                  case IDM_SASI1OPEN:
                         update = 0;                          winuienter();
                         switch(LOWORD(wParam)) {                          dialog_changehdd(hWnd, 0x00);
                                 case IDM_RESET:                          winuileave();
                                         b = FALSE;                          break;
                                         if (!np2oscfg.comfirm) {  
                                                 b = TRUE;  
                                         }  
                                         else if (sstpconfirm_reset()) {  
                                                 winuienter();  
                                                 if (MessageBox(hWnd, "Sure?", "Reset",  
                                                                         MB_ICONQUESTION | MB_YESNO) == IDYES) {  
                                                         b = TRUE;  
                                                 }  
                                                 winuileave();  
                                         }  
                                         if (b) {  
                                                 sstpmsg_reset();  
                                                 pccore_cfgupdate();  
                                                 pccore_reset();  
                                         }  
                                         break;  
   
                                 case IDM_CONFIG:                  case IDM_SASI1EJECT:
                                         winuienter();                          diskdrv_sethdd(0x00, NULL);
                                         sstpmsg_config();                          break;
                                         DialogBox(hInst, MAKEINTRESOURCE(IDD_CONFIG),  
                                                                         hWnd, (DLGPROC)CfgDialogProc);  
                                         winuileave();  
                                         break;  
   
                                 case IDM_NEWDISK:                  case IDM_SASI2OPEN:
                                         winuienter();                          winuienter();
                                         dialog_newdisk(hWnd);                          dialog_changehdd(hWnd, 0x01);
                                         winuileave();                          winuileave();
                                         break;                          break;
   
                                 case IDM_CHANGEFONT:                  case IDM_SASI2EJECT:
                                         winuienter();                          diskdrv_sethdd(0x01, NULL);
                                         dialog_font(hWnd);                          break;
                                         winuileave();  #if defined(SUPPORT_SCSI)
                                         break;                  case IDM_SCSI0OPEN:
                           winuienter();
                           dialog_changehdd(hWnd, 0x20);
                           winuileave();
                           break;
   
                                 case IDM_EXIT:                  case IDM_SCSI0EJECT:
                                         SendMessage(hWnd, WM_CLOSE, 0, 0L);                          diskdrv_sethdd(0x20, NULL);
                                         break;                          break;
   
                                 case IDM_FDD1OPEN:                  case IDM_SCSI1OPEN:
                                         winuienter();                          winuienter();
                                         dialog_changefdd(hWnd, 0);                          dialog_changehdd(hWnd, 0x21);
                                         winuileave();                          winuileave();
                                         break;                          break;
   
                                 case IDM_FDD1EJECT:                  case IDM_SCSI1EJECT:
                                         diskdrv_setfdd(0, NULL, 0);                          diskdrv_sethdd(0x21, NULL);
                                         break;                          break;
   
                                 case IDM_FDD2OPEN:                  case IDM_SCSI2OPEN:
                                         winuienter();                          winuienter();
                                         dialog_changefdd(hWnd, 1);                          dialog_changehdd(hWnd, 0x22);
                                         winuileave();                          winuileave();
                                         break;                          break;
   
                                 case IDM_FDD2EJECT:                  case IDM_SCSI2EJECT:
                                         diskdrv_setfdd(1, NULL, 0);                          diskdrv_sethdd(0x22, NULL);
                                         break;                          break;
   
                                 case IDM_SASI1OPEN:                  case IDM_SCSI3OPEN:
                                         winuienter();                          winuienter();
                                         dialog_changehdd(hWnd, 0);                          dialog_changehdd(hWnd, 0x23);
                                         winuileave();                          winuileave();
                                         break;                          break;
   
                                 case IDM_SASI1EJECT:                  case IDM_SCSI3EJECT:
                                         diskdrv_sethdd(0, NULL);                          diskdrv_sethdd(0x23, NULL);
                                         break;                          break;
   #endif
                   case IDM_WINDOW:
                           changescreen(scrnmode & (~SCRNMODE_FULLSCREEN));
                           break;
   
                                 case IDM_SASI2OPEN:                  case IDM_FULLSCREEN:
                                         winuienter();                          changescreen(scrnmode | SCRNMODE_FULLSCREEN);
                                         dialog_changehdd(hWnd, 1);                          break;
                                         winuileave();  
                                         break;  
   
                                 case IDM_SASI2EJECT:                  case IDM_ROLNORMAL:
                                         diskdrv_sethdd(1, NULL);                          xmenu_setroltate(0);
                                         break;                          changescreen(scrnmode & (~SCRNMODE_ROTATEMASK));
                           break;
   
                                 case IDM_WINDOW:                  case IDM_ROLLEFT:
                                         changescreen(scrnmode & (~SCRNMODE_FULLSCREEN));                          xmenu_setroltate(1);
                                         break;                          changescreen((scrnmode & (~SCRNMODE_ROTATEMASK)) |
                                                                                                                   SCRNMODE_ROTATELEFT);
                           break;
   
                                 case IDM_FULLSCREEN:                  case IDM_ROLRIGHT:
                                         changescreen(scrnmode | SCRNMODE_FULLSCREEN);                          xmenu_setroltate(2);
                                         break;                          changescreen((scrnmode & (~SCRNMODE_ROTATEMASK)) |
                                                                                                                   SCRNMODE_ROTATERIGHT);
                           break;
   
                                 case IDM_ROLNORMAL:                  case IDM_DISPSYNC:
                                         xmenu_setroltate(0);                          xmenu_setdispmode(np2cfg.DISPSYNC ^ 1);
                                         changescreen(scrnmode & (~SCRNMODE_ROTATEMASK));                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_ROLLEFT:                  case IDM_RASTER:
                                         xmenu_setroltate(1);                          xmenu_setraster(np2cfg.RASTER ^ 1);
                                         changescreen((scrnmode & (~SCRNMODE_ROTATEMASK)) |                          if (np2cfg.RASTER) {
                                                                                                                 SCRNMODE_ROTATELEFT);                                  changescreen(scrnmode | SCRNMODE_HIGHCOLOR);
                                         break;                          }
                           else {
                                   changescreen(scrnmode & (~SCRNMODE_HIGHCOLOR));
                           }
                           update |= SYS_UPDATECFG;
                           break;
   
                                 case IDM_ROLRIGHT:                  case IDM_NOWAIT:
                                         xmenu_setroltate(2);                          xmenu_setwaitflg(np2oscfg.NOWAIT ^ 1);
                                         changescreen((scrnmode & (~SCRNMODE_ROTATEMASK)) |                          update |= SYS_UPDATECFG;
                                                                                                                 SCRNMODE_ROTATERIGHT);                          break;
                                         break;  
   
                                 case IDM_DISPSYNC:                  case IDM_AUTOFPS:
                                         xmenu_setdispmode(np2cfg.DISPSYNC ^ 1);                          xmenu_setframe(0);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_RASTER:                  case IDM_60FPS:
                                         xmenu_setraster(np2cfg.RASTER ^ 1);                          xmenu_setframe(1);
                                         if (np2cfg.RASTER) {                          update |= SYS_UPDATECFG;
                                                 changescreen(scrnmode | SCRNMODE_HIGHCOLOR);                          break;
                                         }  
                                         else {  
                                                 changescreen(scrnmode & (~SCRNMODE_HIGHCOLOR));  
                                         }  
                                         update |= SYS_UPDATECFG;  
                                         break;  
   
                                 case IDM_NOWAIT:                  case IDM_30FPS:
                                         xmenu_setwaitflg(np2oscfg.NOWAIT ^ 1);                          xmenu_setframe(2);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_AUTOFPS:                  case IDM_20FPS:
                                         xmenu_setframe(0);                          xmenu_setframe(3);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_60FPS:                  case IDM_15FPS:
                                         xmenu_setframe(1);                          xmenu_setframe(4);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_30FPS:                  case IDM_SCREENOPT:
                                         xmenu_setframe(2);                          winuienter();
                                         update |= SYS_UPDATECFG;                          dialog_scropt(hWnd);
                                         break;                          winuileave();
                           break;
   
                                 case IDM_20FPS:                  case IDM_KEY:
                                         xmenu_setframe(3);                          xmenu_setkey(0);
                                         update |= SYS_UPDATECFG;                          keystat_resetjoykey();
                                         break;                          update |= SYS_UPDATECFG;
                           break;
   
                                 case IDM_15FPS:                  case IDM_JOY1:
                                         xmenu_setframe(4);                          xmenu_setkey(1);
                                         update |= SYS_UPDATECFG;                          keystat_resetjoykey();
                                         break;                          update |= SYS_UPDATECFG;
                           break;
   
                                 case IDM_SCREENOPT:                  case IDM_JOY2:
                                         winuienter();                          xmenu_setkey(2);
                                         dialog_scropt(hWnd);                          keystat_resetjoykey();
                                         winuileave();                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_KEY:                  case IDM_XSHIFT:
                                         xmenu_setkey(0);                          xmenu_setxshift(np2cfg.XSHIFT ^ 1);
                                         keystat_resetjoykey();                          keystat_forcerelease(0x70);
                                         break;                          update |= SYS_UPDATECFG;
                           break;
   
                                 case IDM_JOY1:                  case IDM_XCTRL:
                                         xmenu_setkey(1);                          xmenu_setxshift(np2cfg.XSHIFT ^ 2);
                                         keystat_resetjoykey();                          keystat_forcerelease(0x74);
                                         break;                          update |= SYS_UPDATECFG;
                           break;
   
                                 case IDM_JOY2:                  case IDM_XGRPH:
                                         xmenu_setkey(2);                          xmenu_setxshift(np2cfg.XSHIFT ^ 4);
                                         keystat_resetjoykey();                          keystat_forcerelease(0x73);
                                         break;                          update |= SYS_UPDATECFG;
                           break;
   
                                 case IDM_XSHIFT:                  case IDM_F12MOUSE:
                                         xmenu_setxshift(np2cfg.XSHIFT ^ 1);                          xmenu_setf12copy(0);
                                         keystat_forcerelease(0x70);                          winkbd_resetf12();
                                         break;                          update |= SYS_UPDATEOSCFG;
                           break;
   
                                 case IDM_XCTRL:                  case IDM_F12COPY:
                                         xmenu_setxshift(np2cfg.XSHIFT ^ 2);                          xmenu_setf12copy(1);
                                         keystat_forcerelease(0x74);                          winkbd_resetf12();
                                         break;                          update |= SYS_UPDATEOSCFG;
                           break;
   
                                 case IDM_XGRPH:                  case IDM_F12STOP:
                                         xmenu_setxshift(np2cfg.XSHIFT ^ 4);                          xmenu_setf12copy(2);
                                         keystat_forcerelease(0x73);                          winkbd_resetf12();
                                         break;                          update |= SYS_UPDATEOSCFG;
                           break;
   
                                 case IDM_F12MOUSE:                  case IDM_F12EQU:
                                         xmenu_setf12copy(0);                          xmenu_setf12copy(3);
                                         keystat_resetcopyhelp();                          winkbd_resetf12();
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATEOSCFG;
                                         break;                          break;
   
                                 case IDM_F12COPY:                  case IDM_F12COMMA:
                                         xmenu_setf12copy(1);                          xmenu_setf12copy(4);
                                         keystat_resetcopyhelp();                          winkbd_resetf12();
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATEOSCFG;
                                         break;                          break;
   
                                 case IDM_F12STOP:                  case IDM_BEEPOFF:
                                         xmenu_setf12copy(2);                          xmenu_setbeepvol(0);
                                         keystat_resetcopyhelp();                          beep_setvol(0);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_BEEPOFF:                  case IDM_BEEPLOW:
                                         xmenu_setbeepvol(0);                          xmenu_setbeepvol(1);
                                         beep_setvol(0);                          beep_setvol(1);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_BEEPLOW:                  case IDM_BEEPMID:
                                         xmenu_setbeepvol(1);                          xmenu_setbeepvol(2);
                                         beep_setvol(1);                          beep_setvol(2);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_BEEPMID:                  case IDM_BEEPHIGH:
                                         xmenu_setbeepvol(2);                          xmenu_setbeepvol(3);
                                         beep_setvol(2);                          beep_setvol(3);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_BEEPHIGH:                  case IDM_NOSOUND:
                                         xmenu_setbeepvol(3);                          xmenu_setsound(0x00);
                                         beep_setvol(3);                          update |= SYS_UPDATECFG;
                                         update |= SYS_UPDATECFG;                          break;
                                         break;  
   
                                 case IDM_NOSOUND:                  case IDM_PC9801_14:
                                         xmenu_setsound(0);                          xmenu_setsound(0x01);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_PC9801_14:                  case IDM_PC9801_26K:
                                         xmenu_setsound(1);                          xmenu_setsound(0x02);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_PC9801_26K:                  case IDM_PC9801_86:
                                         {                          xmenu_setsound(0x04);
                                                 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_26_86:
                                         {                          xmenu_setsound(0x06);
                                                 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_86_CB:
                                         xmenu_setsound(8);                          xmenu_setsound(0x14);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_CHIBIOTO:                  case IDM_PC9801_118:
                                         {                          xmenu_setsound(0x08);
                                                 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_SPEAKBOARD:
                                         xmenu_setsound(0x20);                          xmenu_setsound(0x20);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_SPARKBOARD:                  case IDM_SPARKBOARD:
                                         xmenu_setsound(0x40);                          xmenu_setsound(0x40);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_AMD98:                  case IDM_AMD98:
                                         xmenu_setsound(0x80);                          xmenu_setsound(0x80);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_SNDOPT:                  case IDM_JASTSOUND:
                                         winuienter();                          xmenu_setjastsound(np2oscfg.jastsnd ^ 1);
                                         dialog_sndopt(hWnd);                          update |= SYS_UPDATEOSCFG;
                                         winuileave();                          break;
                                         break;  
   
                                 case IDM_SEEKSND:                  case IDM_SEEKSND:
                                         xmenu_setmotorflg(np2cfg.MOTOR ^ 1);                          xmenu_setmotorflg(np2cfg.MOTOR ^ 1);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_MEM640:                  case IDM_MEM640:
                                         xmenu_setextmem(0);                          xmenu_setextmem(0);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_MEM16:                  case IDM_MEM16:
                                         xmenu_setextmem(1);                          xmenu_setextmem(1);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_MEM36:                  case IDM_MEM36:
                                         xmenu_setextmem(3);                          xmenu_setextmem(3);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_MEM76:                  case IDM_MEM76:
                                         xmenu_setextmem(7);                          xmenu_setextmem(7);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_MOUSE:                  case IDM_MOUSE:
                                         mouse_running(MOUSE_XOR);                          mousemng_toggle(MOUSEPROC_SYSTEM);
                                         xmenu_setmouse(np2oscfg.MOUSE_SW ^ 1);                          xmenu_setmouse(np2oscfg.MOUSE_SW ^ 1);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_SERIAL1:                  case IDM_SERIAL1:
                                         winuienter();                          winuienter();
                                         dialog_serial(hWnd);                          dialog_serial(hWnd);
                                         winuileave();                          winuileave();
                                         break;                          break;
   
                                 case IDM_MPUPC98:                  case IDM_MPUPC98:
                                         winuienter();                          winuienter();
                                         DialogBox(hInst, MAKEINTRESOURCE(IDD_MPUPC98),                          DialogBox(hInst, MAKEINTRESOURCE(IDD_MPUPC98),
                                                                                         hWnd, (DLGPROC)MidiDialogProc);                                                                                          hWnd, (DLGPROC)MidiDialogProc);
                                         winuileave();                          winuileave();
                                         break;                          break;
   
                                 case IDM_MIDIPANIC:                                                                     // ver0.29                  case IDM_MIDIPANIC:                                                                     // ver0.29
                                         rs232c_midipanic();                          rs232c_midipanic();
                                         mpu98ii_midipanic();                          mpu98ii_midipanic();
                                         pc9861k_midipanic();                          pc9861k_midipanic();
                                         break;                          break;
   
                                 case IDM_BMPSAVE:                  case IDM_SNDOPT:
                                         winuienter();                          winuienter();
                                         dialog_writebmp(hWnd);                          dialog_sndopt(hWnd);
                                         winuileave();                          winuileave();
                                         break;                          break;
   
                                 case IDM_S98LOGGING:                  case IDM_BMPSAVE:
                                         winuienter();                          winuienter();
                                         dialog_s98(hWnd);                          dialog_writebmp(hWnd);
                                         winuileave();                          winuileave();
                                         break;                          break;
   
                                 case IDM_DISPCLOCK:                  case IDM_S98LOGGING:
                                         xmenu_setdispclk(np2oscfg.DISPCLK ^ 1);                          winuienter();
                                         update |= SYS_UPDATECFG;                          dialog_s98(hWnd);
                                         break;                          winuileave();
                           break;
   
                                 case IDM_DISPFRAME:                  case IDM_DISPCLOCK:
                                         xmenu_setdispclk(np2oscfg.DISPCLK ^ 2);                          xmenu_setdispclk(np2oscfg.DISPCLK ^ 1);
                                         update |= SYS_UPDATECFG;                          update |= SYS_UPDATECFG;
                                         break;                          break;
   
                   case IDM_DISPFRAME:
                           xmenu_setdispclk(np2oscfg.DISPCLK ^ 2);
                           update |= SYS_UPDATECFG;
                           break;
   
                                 case IDM_CALENDAR:                  case IDM_CALENDAR:
                                         winuienter();                          winuienter();
                                         DialogBox(hInst, MAKEINTRESOURCE(IDD_CALENDAR),                          DialogBox(hInst, MAKEINTRESOURCE(IDD_CALENDAR),
                                                                                         hWnd, (DLGPROC)ClndDialogProc);                                                                                          hWnd, (DLGPROC)ClndDialogProc);
                                         winuileave();                          winuileave();
                                         break;                          break;
   
                   case IDM_ALTENTER:
                           xmenu_setshortcut(np2oscfg.shortcut ^ 1);
                           update |= SYS_UPDATECFG;
                           break;
   
                   case IDM_ALTF4:
                           xmenu_setshortcut(np2oscfg.shortcut ^ 2);
                           update |= SYS_UPDATECFG;
                           break;
   
                   case IDM_JOYX:
                           xmenu_setbtnmode(np2cfg.BTN_MODE ^ 1);
                           update |= SYS_UPDATECFG;
                           break;
   
                   case IDM_RAPID:
                           xmenu_setbtnrapid(np2cfg.BTN_RAPID ^ 1);
                           update |= SYS_UPDATECFG;
                           break;
   
                   case IDM_MSRAPID:
                           xmenu_setmsrapid(np2cfg.MOUSERAPID ^ 1);
                           update |= SYS_UPDATECFG;
                           break;
   
                   case IDM_SSTP:
                           xmenu_setsstp(np2oscfg.sstp ^ 1);
                           update |= SYS_UPDATECFG;
                           break;
   
                   case IDM_I286SAVE:
                           debugsub_status();
                           break;
   
                   case IDM_HELP:
                           ShellExecute(hWnd, NULL, file_getcd(np2help),
                                                                           NULL, NULL, SW_SHOWNORMAL);
                           break;
   
                   case IDM_ABOUT:
                           sstpmsg_about();
                           if (sstp_result() != SSTP_SENDING) {
                                   winuienter();
                                   DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUT),
                                                                   hWnd, (DLGPROC)AboutDialogProc);
                                   winuileave();
                           }
                           break;
   
                   default:
                           if ((cmd >= IDM_FLAGSAVE) &&
                                   (cmd < (IDM_FLAGSAVE + STATSAVEMAX))) {
                                   char ext[4];
                                   wsprintf(ext, np2flagext, cmd - IDM_FLAGSAVE);
                                   flagsave(ext);
                           }
                           if ((cmd >= IDM_FLAGLOAD) &&
                                   (cmd < (IDM_FLAGLOAD + STATSAVEMAX))) {
                                   char ext[4];
                                   wsprintf(ext, np2flagext, cmd - IDM_FLAGLOAD);
                                   flagload(ext, "Status Load", TRUE);
                           }
                           break;
           }
           sysmng_update(update);
   }
   
   LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
   
           PAINTSTRUCT     ps;
           RECT            rc;
           HDC                     hdc;
           BOOL            b;
           UINT            update;
           HWND            subwin;
           WINLOCEX        wlex;
   
           switch (msg) {
                   case WM_CREATE:
                           np2class_wmcreate(hWnd);
                           np2class_windowtype(hWnd, np2oscfg.wintype);
                           sstp_construct(hWnd);
   #ifndef __GNUC__
                           WINNLSEnableIME(hWnd, FALSE);
   #endif
                           break;
   
                                 case IDM_ALTENTER:                  case WM_SYSCOMMAND:
                                         xmenu_setshortcut(np2oscfg.shortcut ^ 1);                          update = 0;
                                         update |= SYS_UPDATECFG;                          switch(wParam) {
                                   case IDM_TOOLWIN:
                                           sysmenu_settoolwin(np2oscfg.toolwin ^ 1);
                                           if (np2oscfg.toolwin) {
                                                   toolwin_create();
                                           }
                                           else {
                                                   toolwin_destroy();
                                           }
                                           update |= SYS_UPDATEOSCFG;
                                         break;                                          break;
   
                                 case IDM_ALTF4:                                  case IDM_KEYDISP:
                                         xmenu_setshortcut(np2oscfg.shortcut ^ 2);                                          sysmenu_setkeydisp(np2oscfg.keydisp ^ 1);
                                         update |= SYS_UPDATECFG;                                          if (np2oscfg.keydisp) {
                                                   kdispwin_create();
                                           }
                                           else {
                                                   kdispwin_destroy();
                                           }
                                         break;                                          break;
   
                                 case IDM_JOYX:                                  case IDM_SCREENCENTER:
                                         xmenu_setbtnmode(np2cfg.BTN_MODE ^ 1);                                          if ((!scrnmng_isfullscreen()) &&
                                         update |= SYS_UPDATECFG;                                                  (!(GetWindowLong(hWnd, GWL_STYLE) &
                                                                                           (WS_MAXIMIZE | WS_MINIMIZE)))) {
                                                   wlex = np2_winlocexallwin(hWnd);
                                                   wincentering(hWnd);
                                                   winlocex_move(wlex);
                                                   winlocex_destroy(wlex);
                                           }
                                         break;                                          break;
   
                                 case IDM_RAPID:                                  case IDM_SNAPENABLE:
                                         xmenu_setbtnrapid(np2cfg.BTN_RAPID ^ 1);                                          sysmenu_setwinsnap(np2oscfg.WINSNAP ^ 1);
                                         update |= SYS_UPDATECFG;                                          update |= SYS_UPDATEOSCFG;
                                         break;                                          break;
   
                                 case IDM_MSRAPID:                                  case IDM_BACKGROUND:
                                         xmenu_setmsrapid(np2cfg.MOUSERAPID ^ 1);                                          sysmenu_setbackground(np2oscfg.background ^ 1);
                                         update |= SYS_UPDATECFG;                                          update |= SYS_UPDATEOSCFG;
                                         break;                                          break;
   
                                 case IDM_SSTP:                                  case IDM_BGSOUND:
                                         xmenu_setsstp(np2oscfg.sstp ^ 1);                                          sysmenu_setbgsound(np2oscfg.background ^ 2);
                                         update |= SYS_UPDATECFG;                                          update |= SYS_UPDATEOSCFG;
                                         break;                                          break;
   
                                 case IDM_I286SAVE:                                  case IDM_MEMORYDUMP:
                                         debugsub_status();                                          debugsub_memorydump();
                                         break;                                          break;
   
                                 case IDM_HELP:                                  case IDM_DEBUGUTY:
                                         ShellExecute(hWnd, NULL, file_getcd(np2help),                                          viewer_open();
                                                                                         NULL, NULL, SW_SHOWNORMAL);  
                                         break;                                          break;
   
                                 case IDM_ABOUT:                                  case IDM_SCRNMUL4:                                                              // ver0.26
                                         sstpmsg_about();                                  case IDM_SCRNMUL6:
                                         if (sstp_result() != SSTP_SENDING) {                                  case IDM_SCRNMUL8:
                                                 winuienter();                                  case IDM_SCRNMUL10:
                                                 DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUT),                                  case IDM_SCRNMUL12:
                                                                                 hWnd, (DLGPROC)AboutDialogProc);                                  case IDM_SCRNMUL16:
                                                 winuileave();                                          if ((!scrnmng_isfullscreen()) &&
                                                   !(GetWindowLong(hWndMain, GWL_STYLE) & WS_MINIMIZE)) {
                                                   sysmenu_setscrnmul(wParam - IDM_SCRNMUL);
                                                   scrnmng_setmultiple(wParam - IDM_SCRNMUL);
                                         }                                          }
                                         break;                                          break;
   
                                 default:                                  case SC_MINIMIZE:
                                         if ((LOWORD(wParam) >= IDM_FLAGSAVE) &&                                          wlex = np2_winlocexallwin(hWnd);
                                                 (LOWORD(wParam) < IDM_FLAGSAVE + STATSAVEMAX)) {                                          winlocex_close(wlex);
                                                 char ext[4];                                          winlocex_destroy(wlex);
                                                 wsprintf(ext, "S%02d",                                          return(DefWindowProc(hWnd, msg, wParam, lParam));
                                                                         (LOWORD(wParam) - IDM_FLAGSAVE) % 100);  
                                                 flagsave(ext);                                  case SC_RESTORE:
                                         }                                          subwin = toolwin_gethwnd();
                                         if ((LOWORD(wParam) >= IDM_FLAGLOAD) &&                                          if (subwin) {
                                                 (LOWORD(wParam) < IDM_FLAGLOAD + STATSAVEMAX)) {                                                  ShowWindow(subwin, SW_SHOWNOACTIVATE);
                                                 char ext[4];                                          }
                                                 wsprintf(ext, "S%02d",                                          subwin = kdispwin_gethwnd();
                                                                         (LOWORD(wParam) - IDM_FLAGLOAD) % 100);                                          if (subwin) {
                                                 flagload(ext, "Status Load", TRUE);                                                  ShowWindow(subwin, SW_SHOWNOACTIVATE);
                                         }                                          }
                                         break;                                          return(DefWindowProc(hWnd, msg, wParam, lParam));
   
                                   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) {
                                 np2break &= ~NP2BREAK_MAIN;                                  np2break &= ~NP2BREAK_MAIN;
                                 scrnmng_update();                                  scrnmng_update();
                                 keystat_allrelease();                                  keystat_allrelease();
                                 mouse_running(MOUSE_CONT_M);                                  mousemng_enable(MOUSEPROC_BG);
                         }                          }
                         else {                          else {
                                 np2break |= NP2BREAK_MAIN;                                  np2break |= NP2BREAK_MAIN;
                                 mouse_running(MOUSE_STOP_M);                                  mousemng_disable(MOUSEPROC_BG);
                         }                          }
                         np2active_renewal();                          np2active_renewal();
                         break;                          break;
Line 823  LRESULT CALLBACK WndProc(HWND hWnd, UINT Line 959  LRESULT CALLBACK WndProc(HWND hWnd, UINT
                 case WM_PAINT:                  case WM_PAINT:
                         hdc = BeginPaint(hWnd, &ps);                          hdc = BeginPaint(hWnd, &ps);
                         if (np2opening) {                          if (np2opening) {
                                   HINSTANCE       hinst;
                             HDC                 hmdc;                                  RECT            rect;
                             HBITMAP             hbmp;                                  int                     width;
                             BITMAP              bmp;                                  int                     height;
                             HINSTANCE   hinst;                                  HBITMAP         hbmp;
                                 int                     sx = 640 + np2oscfg.paddingx;                                  BITMAP          bmp;
                                 int                     sy = 400 + np2oscfg.paddingy;                                  HDC                     hmdc;
                                   HBRUSH          hbrush;
                             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 864  LRESULT CALLBACK WndProc(HWND hWnd, UINT Line 997  LRESULT CALLBACK WndProc(HWND hWnd, UINT
                         break;                          break;
   
                 case WM_MOVE:                  case WM_MOVE:
                         if ((!scrnmng_isfullscreen()) &&                          if (!scrnmng_isfullscreen()) {
                                 (!(GetWindowLong(hWndMain, GWL_STYLE) &                                  if (!(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;
                                 np2oscfg.winy = rc.top;                                          np2oscfg.winy = rc.top;
                                 sysmng_update(SYS_UPDATEOSCFG);                                          sysmng_update(SYS_UPDATEOSCFG);
                                   }
                         }                          }
                         break;                          break;
   
Line 886  LRESULT CALLBACK WndProc(HWND hWnd, UINT Line 1020  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);
                         winloc_movingstart();                          winlocex_destroy(smwlex);
                         break;                          smwlex = np2_winlocexallwin(hWnd);
                           scrnmng_entersizing();
                 case WM_EXITSIZEMOVE:  
                         mouse_running(MOUSE_CONT);  
                         soundmng_play();  
                         break;                          break;
   
                 case WM_MOVING:                  case WM_MOVING:
                         if (np2oscfg.WINSNAP) {                          if (np2oscfg.WINSNAP) {
                                 winloc_movingproc((RECT *)lParam);                                  winlocex_moving(smwlex, (RECT *)lParam);
                         }                          }
                         break;                          break;
   
                   case WM_SIZING:
                           scrnmng_sizing((UINT)wParam, (RECT *)lParam);
                           break;
   
                   case WM_EXITSIZEMOVE:
                           scrnmng_exitsizing();
                           winlocex_move(smwlex);
                           winlocex_destroy(smwlex);
                           smwlex = NULL;
                           mousemng_enable(MOUSEPROC_WINUI);
                           soundmng_enable(SNDPROC_MAIN);
                           break;
   
                 case WM_KEYDOWN:                  case WM_KEYDOWN:
                         if (wParam == VK_F11) {                          if (wParam == VK_F11) {
                                   np2class_enablemenu(hWndMain, TRUE);
                                 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;
   
Line 935  LRESULT CALLBACK WndProc(HWND hWnd, UINT Line 1081  LRESULT CALLBACK WndProc(HWND hWnd, UINT
                                         break;                                          break;
                                 }                                  }
                         }                          }
                         winkeydown106(wParam, lParam);                          winkbd_keydown(wParam, lParam);
                         break;                          break;
   
                 case WM_SYSKEYUP:                  case WM_SYSKEYUP:
                         winkeyup106(wParam, lParam);                          winkbd_keyup(wParam, lParam);
                           break;
   
                   case WM_MOUSEMOVE:
                           if (scrnmng_isfullscreen()) {
                                   POINT p;
                                   if (GetCursorPos(&p)) {
                                           scrnmng_fullscrnmenu(p.y);
                                   }
                           }
                         break;                          break;
   
                 case WM_LBUTTONDOWN:                  case WM_LBUTTONDOWN:
                         if (!mouse_btn(MOUSE_LEFTDOWN)) {                          if (!mousemng_buttonevent(MOUSEMNG_LEFTDOWN)) {
                                 if (scrnmng_isfullscreen()) {                                  if (!scrnmng_isfullscreen()) {
                                         POINT   p;                                          if (np2oscfg.wintype == 2) {
                                                   return(SendMessage(hWnd, WM_NCLBUTTONDOWN,
                                                                                                                           HTCAPTION, 0L));
                                           }
                                   }
                                   else {
                                           POINT p;
                                         if ((GetCursorPos(&p)) && (p.y >= 466)) {                                          if ((GetCursorPos(&p)) && (p.y >= 466)) {
                                                 np2oscfg.clk_x++;                                                  np2oscfg.clk_x++;
                                                 sysmng_update(SYS_UPDATEOSCFG);                                                  sysmng_update(SYS_UPDATEOSCFG);
Line 955  LRESULT CALLBACK WndProc(HWND hWnd, UINT Line 1116  LRESULT CALLBACK WndProc(HWND hWnd, UINT
                                 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)) {
                                 if (scrnmng_isfullscreen()) {                                  if (!scrnmng_isfullscreen()) {
                                         POINT   p;                                          np2popup(hWnd, lParam);
                                   }
                                   else {
                                           POINT p;
                                         if ((GetCursorPos(&p)) && (p.y >= 466) &&                                          if ((GetCursorPos(&p)) && (p.y >= 466) &&
                                                                                                 (np2oscfg.clk_x)) {                                                                                                  (np2oscfg.clk_x)) {
                                                 np2oscfg.clk_fnt++;                                                  np2oscfg.clk_fnt++;
Line 983  LRESULT CALLBACK WndProc(HWND hWnd, UINT Line 1148  LRESULT CALLBACK WndProc(HWND hWnd, UINT
                         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;
   
                   case WM_LBUTTONDBLCLK:
                           if (!scrnmng_isfullscreen()) {
                                   np2oscfg.wintype++;
                                   if (np2oscfg.wintype >= 3) {
                                           np2oscfg.wintype = 0;
                                   }
                                   wlex = np2_winlocexallwin(hWnd);
                                   winlocex_setholdwnd(wlex, hWnd);
                                   np2class_windowtype(hWnd, np2oscfg.wintype);
                                   winlocex_move(wlex);
                                   winlocex_destroy(wlex);
                                   sysmng_update(SYS_UPDATEOSCFG);
                           }
                           break;
   
                 case WM_CLOSE:                  case WM_CLOSE:
                         b = FALSE;                          b = FALSE;
                         if (!np2oscfg.comfirm) {                          if (!np2oscfg.comfirm) {
Line 1002  LRESULT CALLBACK WndProc(HWND hWnd, UINT Line 1182  LRESULT CALLBACK WndProc(HWND hWnd, UINT
                                 winuileave();                                  winuileave();
                         }                          }
                         if (b) {                          if (b) {
                                 keydisp_destroy();  
                                 viewer_allclose();                                  viewer_allclose();
                                 DestroyWindow(hWnd);                                  DestroyWindow(hWnd);
                         }                          }
Line 1010  LRESULT CALLBACK WndProc(HWND hWnd, UINT Line 1189  LRESULT CALLBACK WndProc(HWND hWnd, UINT
   
                 case WM_DESTROY:                  case WM_DESTROY:
                         DestroyMenu(hStat);                          DestroyMenu(hStat);
                           np2class_wmdestroy(hWnd);
                         PostQuitMessage(0);                          PostQuitMessage(0);
                         break;                          break;
   
Line 1026  LRESULT CALLBACK WndProc(HWND hWnd, UINT Line 1206  LRESULT CALLBACK WndProc(HWND hWnd, UINT
                                         break;                                          break;
   
                                 case NP2CMD_RESET:                                  case NP2CMD_RESET:
                                           juliet_YMF288Reset();
                                         pccore_cfgupdate();                                          pccore_cfgupdate();
                                         pccore_reset();                                          pccore_reset();
                                         break;                                          break;
Line 1072  LRESULT CALLBACK WndProc(HWND hWnd, UINT Line 1253  LRESULT CALLBACK WndProc(HWND hWnd, UINT
 }  }
   
   
 static void processwait(WORD cnt) {  static void framereset(UINT cnt) {
   
           framecnt = 0;
           scrnmng_dispclock();
           kdispwin_draw((BYTE)cnt);
           toolwin_draw((BYTE)cnt);
           viewer_allreload(FALSE);
           if (np2oscfg.DISPCLK & 3) {
                   if (sysmng_workclockrenewal()) {
                           sysmng_updatecaption(3);
                   }
           }
   }
   
   static void processwait(UINT cnt) {
   
         if (timing_getcount() >= cnt) {          if (timing_getcount() >= cnt) {
                 timing_setcount(0);                  timing_setcount(0);
                 framecnt = 0;                  framereset(cnt);
                 scrnmng_dispclock();  
                 keydisp_draw(np2oscfg.DRAW_SKIP);  
                 viewer_allreload(FALSE);  
                 if (np2oscfg.DISPCLK & 3) {  
                         if (sysmng_workclockrenewal()) {  
                                 sysmng_updatecaption(3);  
                         }  
                 }  
         }          }
         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;  
         UINT            i;          UINT            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);          np2arg_analize(lpszCmdLine);
         initload();          initload();
           toolwin_readini();
           kdispwin_readini();
   
         srand((unsigned)time(NULL));          rand_setseed((unsigned)time(NULL));
   
         CopyMemory(szClassName, np2oscfg.winid, 3);          CopyMemory(szClassName, np2oscfg.winid, 3);
   
         if ((hwndorg = FindWindow(szClassName, NULL)) != NULL) {          if ((hWnd = FindWindow(szClassName, NULL)) != NULL) {
                 sstpmsg_running();                  sstpmsg_running();
                 ShowWindow(hwndorg, SW_RESTORE);                  ShowWindow(hWnd, SW_RESTORE);
                 SetForegroundWindow(hwndorg);                  SetForegroundWindow(hWnd);
                 dosio_term();                  dosio_term();
                 return(FALSE);                  return(FALSE);
         }          }
   
         hInst = hInstance;          hInst = hInstance;
         hPrev = hPreInst;          hPrev = hPreInst;
           mmxflag = (havemmx())?0:MMXFLAG_NOTSUPPORT;
           mmxflag += (np2oscfg.disablemmx)?MMXFLAG_DISABLE:0;
         TRACEINIT();          TRACEINIT();
   
         if (np2oscfg.KEYBOARD >= KEY_TYPEMAX) {                                                 // ver0.28          if (np2oscfg.KEYBOARD >= KEY_TYPEMAX) {                                                 // ver0.28
Line 1139  int WINAPI WinMain(HINSTANCE hInstance,  Line 1332  int WINAPI WinMain(HINSTANCE hInstance, 
         }          }
         keystat_reset();          keystat_reset();
   
           np2class_initialize(hInstance);
         if (!hPreInst) {          if (!hPreInst) {
                 np2.style = CS_BYTEALIGNCLIENT | CS_HREDRAW | CS_VREDRAW;                  wc.style = CS_BYTEALIGNCLIENT | CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
                 np2.lpfnWndProc = WndProc;                  wc.lpfnWndProc = WndProc;
                 np2.cbClsExtra = 0;                  wc.cbClsExtra = 0;
                 np2.cbWndExtra = 0;                  wc.cbWndExtra = NP2GWL_SIZE;
                 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(NULL_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);
                 }                  }
         }          }
         keydisp_initialize(hPreInst);          toolwin_initapp(hInstance);
         viewer_init(hPreInst);                                                                          // ver0.30          kdispwin_initialize(hPreInst);
           viewer_init(hPreInst);
   
         hWndMain = CreateWindowEx(0, szClassName, np2oscfg.titles,  #if 1
           hWndMain = CreateWindowEx(0,
                                                   szClassName, np2oscfg.titles,
                                                   WS_OVERLAPPED | WS_SYSMENU | WS_CAPTION |
                                                   WS_THICKFRAME | WS_MINIMIZEBOX,
                                                   np2oscfg.winx, np2oscfg.winy, 640, 400,
                                                   NULL, NULL, hInstance, NULL);
   #else   // テスト
           hWndMain = CreateWindowEx(0,
                                                   szClassName, np2oscfg.titles,
                                                 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);
   #endif
           hWnd = hWndMain;
         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_setdispclk(np2oscfg.DISPCLK);          xmenu_setkey(0);
         xmenu_seti286save(np2oscfg.I286SAVE);  
         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_setshortcut(np2oscfg.shortcut);                                           // ver0.30  
         xmenu_setsstp(np2oscfg.sstp);  
         xmenu_setmouse(np2oscfg.MOUSE_SW);          xmenu_setmouse(np2oscfg.MOUSE_SW);
   
         ShowWindow(hWndMain, nCmdShow);          xmenu_setshortcut(np2oscfg.shortcut);
         UpdateWindow(hWndMain);          xmenu_setdispclk(np2oscfg.DISPCLK);
           xmenu_setbtnmode(np2cfg.BTN_MODE);
           xmenu_setbtnrapid(np2cfg.BTN_RAPID);
           xmenu_setmsrapid(np2cfg.MOUSERAPID);
           xmenu_setsstp(np2oscfg.sstp);
           xmenu_seti286save(np2oscfg.I286SAVE);
   
           ShowWindow(hWnd, nCmdShow);
           UpdateWindow(hWnd);
   
 #ifdef OPENING_WAIT  #ifdef OPENING_WAIT
         tick = GetTickCount();          tick = GetTickCount();
 #endif  #endif
   
         // めにゅー追加          sysmenu_initialize();
         if (np2oscfg.statsave) {          xmenu_initialize();
                 char buf[16];          DrawMenuBar(hWnd);
                 hMenu = GetMenu(hWndMain);  
                 hStat = CreatePopupMenu();  
                 for (i=0; i<STATSAVEMAX; i++) {  
                         wsprintf(buf, "Save %d", i);  
                         AppendMenu(hStat, MF_STRING, IDM_FLAGSAVE + i, buf);  
                 }  
                 AppendMenu(hStat, MF_MENUBARBREAK, 0, NULL);  
                 for (i=0; i<STATSAVEMAX; i++) {  
                         wsprintf(buf, "Load %d", i);  
                         AppendMenu(hStat, MF_STRING, IDM_FLAGLOAD + i, buf);  
                 }  
                 InsertMenu(hMenu, 1, MF_BYPOSITION | MF_POPUP, (UINT)hStat, "S&tat");  
         }  
   
         hMenu = GetSystemMenu(hWndMain, FALSE);                                         // ver0.26  
         for (i=0; i<(sizeof(smenu_item)/sizeof(SYSMENU_ITEM)); i++) {  
                 if (smenu_item[i].str) {  
                         InsertMenu(hMenu, i, MF_BYPOSITION | MF_STRING,  
                                                         smenu_item[i].id, smenu_item[i].str);  
                 }  
                 else {  
                         InsertMenu(hMenu, i, MF_BYPOSITION | MF_SEPARATOR, 0, NULL);  
                 }  
         }  
   
         if (np2oscfg.I286SAVE) {  
                 InsertMenu(hMenu, 5, MF_BYPOSITION | MF_STRING, IDM_MEMORYDUMP,  
                                                         "&Memory Dump");  
                 InsertMenu(hMenu, 6, MF_BYPOSITION | MF_STRING, IDM_DEBUGUTY,  
                                                         "&Debug Utility");  
         }  
         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);
         }          }
   
         xmenu_setwinsnap(np2oscfg.WINSNAP);          sysmenu_settoolwin(np2oscfg.toolwin);
         xmenu_setbackground(np2oscfg.background);          sysmenu_setkeydisp(np2oscfg.keydisp);
         xmenu_setbgsound(np2oscfg.background);          sysmenu_setwinsnap(np2oscfg.WINSNAP);
         xmenu_setscrnmul(8);                                                                            // ver0.26          sysmenu_setbackground(np2oscfg.background);
           sysmenu_setbgsound(np2oscfg.background);
           sysmenu_setscrnmul(8);                                                                          // ver0.26
   
         scrnmode = 0;          scrnmode = 0;
         if (np2arg.fullscreen) {          if (np2arg.fullscreen) {
Line 1249  int WINAPI WinMain(HINSTANCE hInstance,  Line 1428  int WINAPI WinMain(HINSTANCE hInstance, 
                 scrnmode ^= SCRNMODE_FULLSCREEN;                  scrnmode ^= SCRNMODE_FULLSCREEN;
                 if (scrnmng_create(scrnmode) != SUCCESS) {                  if (scrnmng_create(scrnmode) != SUCCESS) {
                         if (sstpmsg_dxerror()) {                          if (sstpmsg_dxerror()) {
                                 MessageBox(hWndMain, "Couldn't create DirectDraw Object",                                  MessageBox(hWnd, "Couldn't create DirectDraw Object",
                                                                                 np2oscfg.titles, MB_OK | MB_ICONSTOP);                                                                                  np2oscfg.titles, MB_OK | MB_ICONSTOP);
                         }                          }
                         return(FALSE);                          return(FALSE);
Line 1263  int WINAPI WinMain(HINSTANCE hInstance,  Line 1442  int WINAPI WinMain(HINSTANCE hInstance, 
                 soundmng_pcmvolume(SOUND_PCMSEEK1, np2cfg.MOTORVOL);                  soundmng_pcmvolume(SOUND_PCMSEEK1, np2cfg.MOTORVOL);
         }          }
   
 #ifdef USE_ROMEO          if (np2oscfg.useromeo) {
         juliet_load();                  juliet_initialize();
         juliet_prepare();          }
 #endif  
   
           mousemng_initialize();
         if (np2oscfg.MOUSE_SW) {                                                                                // ver0.30          if (np2oscfg.MOUSE_SW) {                                                                                // ver0.30
                 mouse_running(MOUSE_ON);                  mousemng_enable(MOUSEPROC_SYSTEM);
         }          }
   //      mousemng_enable(MOUSEPROC_WINUI);
   //      mousemng_enable(MOUSEPROC_BG);
   
         commng_initialize();          commng_initialize();
         sysmng_initialize();          sysmng_initialize();
Line 1279  int WINAPI WinMain(HINSTANCE hInstance,  Line 1460  int WINAPI WinMain(HINSTANCE hInstance, 
         pccore_init();          pccore_init();
         S98_init();          S98_init();
   
   
         sstpmsg_welcome();          sstpmsg_welcome();
   
 #ifdef OPENING_WAIT  #ifdef OPENING_WAIT
Line 1296  int WINAPI WinMain(HINSTANCE hInstance,  Line 1476  int WINAPI WinMain(HINSTANCE hInstance, 
         if (np2oscfg.resume) {          if (np2oscfg.resume) {
                 int             id;                  int             id;
   
                 id = flagload(np2resume, "Resume", FALSE);                  id = flagload(str_sav, str_resume, FALSE);
                 if (id == IDYES) {                  if (id == IDYES) {
                         for (i=0; i<4; i++) np2arg.disk[i] = NULL;                          for (i=0; i<4; i++) np2arg.disk[i] = NULL;
                 }                  }
                 else if (id == IDCANCEL) {                  else if (id == IDCANCEL) {
                         DestroyWindow(hWndMain);                          DestroyWindow(hWnd);
                         mouse_running(MOUSE_OFF);                          mousemng_disable(MOUSEPROC_WINUI);
                         S98_trash();                          S98_trash();
                         pccore_term();                          pccore_term();
                         sstp_destruct();                          sstp_destruct();
Line 1323  int WINAPI WinMain(HINSTANCE hInstance,  Line 1503  int WINAPI WinMain(HINSTANCE hInstance, 
                 }                  }
         }          }
   
           if (!(scrnmode & SCRNMODE_FULLSCREEN)) {
                   if (np2oscfg.toolwin) {
                           toolwin_create();
                   }
                   if (np2oscfg.keydisp) {
                           kdispwin_create();
                   }
           }
   
         while(1) {          while(1) {
                 if (!np2stopemulate) {                  if (!np2stopemulate) {
                         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)) {
                                         break;                                          break;
                                 }                                  }
                                 if ((msg.message != WM_SYSKEYDOWN) &&                                  if ((msg.hwnd != hWnd) ||
                                         (msg.message != WM_SYSKEYUP)) {                                          ((msg.message != WM_SYSKEYDOWN) &&
                                           (msg.message != WM_SYSKEYUP))) {
                                         TranslateMessage(&msg);                                          TranslateMessage(&msg);
                                 }                                  }
                                 DispatchMessage(&msg);                                  DispatchMessage(&msg);
Line 1338  int WINAPI WinMain(HINSTANCE hInstance,  Line 1528  int WINAPI WinMain(HINSTANCE hInstance, 
                         else {                          else {
                                 if (np2oscfg.NOWAIT) {                                  if (np2oscfg.NOWAIT) {
                                         joy_flash();                                          joy_flash();
                                         mouse_callback();                                          mousemng_callback();
                                         pccore_exec(framecnt == 0);                                          pccore_exec(framecnt == 0);
                                         dclock_callback();                                          dclock_callback();
                                         if (np2oscfg.DRAW_SKIP) {               // nowait frame skip                                          if (np2oscfg.DRAW_SKIP) {               // nowait frame skip
Line 1357  int WINAPI WinMain(HINSTANCE hInstance,  Line 1547  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_callback();
                                                 pccore_exec(framecnt == 0);                                                  pccore_exec(framecnt == 0);
                                                 dclock_callback();                                                  dclock_callback();
                                                 framecnt++;                                                  framecnt++;
Line 1370  int WINAPI WinMain(HINSTANCE hInstance,  Line 1560  int WINAPI WinMain(HINSTANCE hInstance, 
                                         if (!waitcnt) {                                          if (!waitcnt) {
                                                 UINT cnt;                                                  UINT cnt;
                                                 joy_flash();                                                  joy_flash();
                                                 mouse_callback();                                                  mousemng_callback();
                                                 pccore_exec(framecnt == 0);                                                  pccore_exec(framecnt == 0);
                                                 dclock_callback();                                                  dclock_callback();
                                                 framecnt++;                                                  framecnt++;
Line 1391  int WINAPI WinMain(HINSTANCE hInstance,  Line 1581  int WINAPI WinMain(HINSTANCE hInstance, 
                                                         else {                                                          else {
                                                                 timing_setcount(cnt - framecnt);                                                                  timing_setcount(cnt - framecnt);
                                                         }                                                          }
                                                         framecnt = 0;                                                          framereset(0);
                                                 }                                                  }
                                         }                                          }
                                         else {                                          else {
Line 1410  int WINAPI WinMain(HINSTANCE hInstance,  Line 1600  int WINAPI WinMain(HINSTANCE hInstance, 
                         DispatchMessage(&msg);                          DispatchMessage(&msg);
                 }                  }
         }          }
           toolwin_destroy();
           kdispwin_destroy();
   
         pccore_cfgupdate();          pccore_cfgupdate();
   
         mouse_running(MOUSE_OFF);          mousemng_disable(MOUSEPROC_WINUI);
         S98_trash();          S98_trash();
   
         if (np2oscfg.resume) {          if (np2oscfg.resume) {
                 flagsave(np2resume);                  flagsave(str_sav);
         }          }
         else {          else {
 //              DeleteFile(file_getcd(np2resume));                  flagdelete(str_sav);
         }          }
   
 #ifdef USE_ROMEO  
         juliet_YMF288Reset();          juliet_YMF288Reset();
 #endif  
         pccore_term();          pccore_term();
   
         sstp_destruct();          sstp_destruct();
   
 #ifdef USE_ROMEO          juliet_deinitialize();
         juliet_unload();  
 #endif  
   
         soundmng_deinitialize();          soundmng_deinitialize();
         scrnmng_destroy();          scrnmng_destroy();
   
         if (sys_updates & (SYS_UPDATECFG | SYS_UPDATEOSCFG)) {          if (sys_updates & (SYS_UPDATECFG | SYS_UPDATEOSCFG)) {
                 initsave();                  initsave();
                   toolwin_writeini();
                   kdispwin_writeini();
         }          }
   
         TRACETERM();          TRACETERM();
           _MEM_USED("report.txt");
         dosio_term();          dosio_term();
   
         viewer_term();                                                                                          // ver0.30          viewer_term();                                                                                          // ver0.30
Removed from v.1.8  
changed lines
  Added in v.1.37

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