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

Diff for /np2/win9x/np2.cpp between versions 1.3 and 1.15

version 1.3, 2003/10/17 04:11:23 version 1.15, 2003/10/28 22:05:46
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
 #include        <time.h>  #include        <time.h>
   #ifndef __GNUC__
 #include        <winnls32.h>  #include        <winnls32.h>
   #endif
 #include        "resource.h"  #include        "resource.h"
 #include        "strres.h"  #include        "strres.h"
   #include        "parts.h"
 #include        "np2.h"  #include        "np2.h"
 #include        "np2arg.h"  #include        "np2arg.h"
   #include        "cputype.h"
 #include        "dosio.h"  #include        "dosio.h"
 #include        "extromio.h"  #include        "extromio.h"
 #include        "commng.h"  #include        "commng.h"
Line 16 Line 20
 #include        "winkbd.h"  #include        "winkbd.h"
 #include        "ini.h"  #include        "ini.h"
 #include        "menu.h"  #include        "menu.h"
 #include        "dialog.h"  
 #include        "winloc.h"  #include        "winloc.h"
 #include        "sstp.h"  #include        "sstp.h"
 #include        "sstpmsg.h"  #include        "sstpmsg.h"
 #include        "dclock.h"  #include        "dclock.h"
   #include        "toolwin.h"
   #ifdef USE_ROMEO
   #include        "juliet.h"
   #endif
   #include        "dialog.h"
 #include        "memory.h"  #include        "memory.h"
 #include        "pccore.h"  #include        "pccore.h"
 #include        "iocore.h"  #include        "iocore.h"
 #include        "pc9861k.h"  #include        "pc9861k.h"
 #include        "mpu98ii.h"  #include        "mpu98ii.h"
 #include        "timing.h"  
 #include        "debugsub.h"  
 #include        "bios.h"  #include        "bios.h"
 #include        "scrndraw.h"  #include        "scrndraw.h"
 #include        "sound.h"  #include        "sound.h"
Line 35 Line 41
 #include        "s98.h"  #include        "s98.h"
 #include        "diskdrv.h"  #include        "diskdrv.h"
 #include        "fddfile.h"  #include        "fddfile.h"
   #include        "timing.h"
 #ifdef USE_ROMEO  #include        "statsave.h"
 #include        "juliet.h"  #include        "debugsub.h"
 #endif  
   
 #include        "keydisp.h"  #include        "keydisp.h"
 #include        "viewer.h"  #include        "viewer.h"
 #include        "statsave.h"  
   
   
 #ifdef BETA_RELEASE  #ifdef BETA_RELEASE
Line 55  static char  szClassName[] = "NP2-MainWi Line 58  static char  szClassName[] = "NP2-MainWi
                 HWND            hWndMain;                  HWND            hWndMain;
                 HINSTANCE       hInst;                  HINSTANCE       hInst;
                 HINSTANCE       hPrev;                  HINSTANCE       hPrev;
                   int                     mmxflag;
   
                 NP2OSCFG        np2oscfg = {                  NP2OSCFG        np2oscfg = {
                                                 "Neko Project II", "NP2",                                                  "Neko Project II", "NP2",
Line 66  static char  szClassName[] = "NP2-MainWi Line 70  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};                       // ver0.38
   
                 char    fddfolder[MAX_PATH];                  char    fddfolder[MAX_PATH];
                 char    hddfolder[MAX_PATH];                  char    hddfolder[MAX_PATH];
Line 87  static const char np2help[] = "np2.hlp"; Line 91  static const char np2help[] = "np2.hlp";
 static const char np2resume[] = "sav";  static const char np2resume[] = "sav";
   
   
 typedef struct {  
 const char      *str;  
         int             id;  
 } SYSMENU_ITEM;  
   
 static SYSMENU_ITEM smenu_item[] = {  
                         {"&Centering",                  IDM_SCREENCENTER},  
                         {"&Window Snap",                IDM_SNAPENABLE},  
                         {"&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  BYTE    scrnmode;  static  BYTE    scrnmode;
   
 static void changescreen(BYTE newmode) {  static void changescreen(BYTE newmode) {
Line 125  static void changescreen(BYTE newmode) { Line 107  static void changescreen(BYTE newmode) {
                 renewal |= (change & SCRNMODE_ROTATEMASK);                  renewal |= (change & SCRNMODE_ROTATEMASK);
         }          }
         if (renewal) {          if (renewal) {
                   if (renewal & SCRNMODE_FULLSCREEN) {
                           toolwin_close();
                   }
                 soundmng_stop();                  soundmng_stop();
                 mouse_running(MOUSE_STOP);                  mouse_running(MOUSE_STOP);
                 keydisp_destroy();                  keydisp_destroy();
Line 139  static void changescreen(BYTE newmode) { Line 124  static void changescreen(BYTE newmode) {
                         }                          }
                 }                  }
                 scrndraw_redraw();                  scrndraw_redraw();
                   if ((renewal & SCRNMODE_FULLSCREEN) &&
                           (!scrnmng_isfullscreen()) && (np2oscfg.toolwin)) {
                           toolwin_open();
                   }
                 mouse_running(MOUSE_CONT);                  mouse_running(MOUSE_CONT);
                 soundmng_play();                  soundmng_play();
         }          }
Line 217  static int flagsave(const char *ext) { Line 206  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 241  static int flagload(const char *ext, con Line 238  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);
Line 275  LRESULT CALLBACK WndProc(HWND hWnd, UINT Line 274  LRESULT CALLBACK WndProc(HWND hWnd, UINT
         switch (msg) {          switch (msg) {
                 case WM_CREATE:                  case WM_CREATE:
                         sstp_construct(hWnd);                          sstp_construct(hWnd);
   #ifndef __GNUC__
                         WINNLSEnableIME(hWnd, FALSE);                          WINNLSEnableIME(hWnd, FALSE);
 //                      DragAcceptFiles(hWnd, TRUE);  #endif
                         break;                          break;
   
                 case WM_SYSCOMMAND:                  case WM_SYSCOMMAND:
                         update = 0;                          update = 0;
                         switch(wParam) {                          switch(wParam) {
                                 case IDM_SCREENCENTER:                                                  // ver0.26                                  case IDM_TOOLWIN:
                                           xmenu_settoolwin(np2oscfg.toolwin ^ 1);
                                           if (np2oscfg.toolwin) {
                                                   toolwin_open();
                                           }
                                           else {
                                                   toolwin_close();
                                           }
                                           update |= SYS_UPDATEOSCFG;
                                           break;
   
                                   case IDM_SCREENCENTER:
                                         if ((!scrnmng_isfullscreen()) &&                                          if ((!scrnmng_isfullscreen()) &&
                                                 (!(GetWindowLong(hWnd, GWL_STYLE) &                                                  (!(GetWindowLong(hWnd, GWL_STYLE) &
                                                                                         (WS_MAXIMIZE | WS_MINIMIZE)))) {                                                                                          (WS_MAXIMIZE | WS_MINIMIZE)))) {
                                                   toolwin_movingstart();
                                                 wincentering(hWnd);                                                  wincentering(hWnd);
                                                   toolwin_movingend();
                                         }                                          }
                                         break;                                          break;
   
                                 case IDM_SNAPENABLE:                                  case IDM_SNAPENABLE:
                                         xmenu_setwinsnap(np2oscfg.WINSNAP ^ 1);                                          xmenu_setwinsnap(np2oscfg.WINSNAP ^ 1);
                                         update |= SYS_UPDATECFG;                                          update |= SYS_UPDATEOSCFG;
                                         break;                                          break;
   
                                 case IDM_BACKGROUND:                                  case IDM_BACKGROUND:
                                         xmenu_setbackground(np2oscfg.background ^ 1);                                          xmenu_setbackground(np2oscfg.background ^ 1);
                                         update |= SYS_UPDATECFG;                                          update |= SYS_UPDATEOSCFG;
                                         break;                                          break;
   
                                 case IDM_BGSOUND:                                  case IDM_BGSOUND:
                                         xmenu_setbgsound(np2oscfg.background ^ 2);                                          xmenu_setbgsound(np2oscfg.background ^ 2);
                                         update |= SYS_UPDATECFG;                                          update |= SYS_UPDATEOSCFG;
                                         break;                                          break;
   
                                 case IDM_KEYDISP:                                  case IDM_KEYDISP:
Line 323  LRESULT CALLBACK WndProc(HWND hWnd, UINT Line 336  LRESULT CALLBACK WndProc(HWND hWnd, UINT
                                 case IDM_SCRNMUL10:                                  case IDM_SCRNMUL10:
                                 case IDM_SCRNMUL12:                                  case IDM_SCRNMUL12:
                                 case IDM_SCRNMUL16:                                  case IDM_SCRNMUL16:
 #if 0                                          if ((!scrnmng_isfullscreen()) &&
                                         if ((SCREENMODE & SCMD_WINDOWED) &&  
                                                 !(GetWindowLong(hWndMain, GWL_STYLE) & WS_MINIMIZE)) {                                                  !(GetWindowLong(hWndMain, GWL_STYLE) & WS_MINIMIZE)) {
                                                 xmenu_setscrnmul(wParam - IDM_SCRNMUL);                                                  xmenu_setscrnmul(wParam - IDM_SCRNMUL);
                                                 ddraws_setmul(wParam - IDM_SCRNMUL);                                                  scrnmng_setmultiple(wParam - IDM_SCRNMUL);
                                         }                                          }
 #endif  
                                         break;                                          break;
   
                                 default:                                  default:
Line 393  LRESULT CALLBACK WndProc(HWND hWnd, UINT Line 404  LRESULT CALLBACK WndProc(HWND hWnd, UINT
   
                                 case IDM_FDD1EJECT:                                  case IDM_FDD1EJECT:
                                         diskdrv_setfdd(0, NULL, 0);                                          diskdrv_setfdd(0, NULL, 0);
                                           toolwin_setfdd(0, NULL);
                                         break;                                          break;
   
                                 case IDM_FDD2OPEN:                                  case IDM_FDD2OPEN:
Line 403  LRESULT CALLBACK WndProc(HWND hWnd, UINT Line 415  LRESULT CALLBACK WndProc(HWND hWnd, UINT
   
                                 case IDM_FDD2EJECT:                                  case IDM_FDD2EJECT:
                                         diskdrv_setfdd(1, NULL, 0);                                          diskdrv_setfdd(1, NULL, 0);
                                           toolwin_setfdd(1, NULL);
                                         break;                                          break;
   
                                 case IDM_SASI1OPEN:                                  case IDM_SASI1OPEN:
Line 810  LRESULT CALLBACK WndProc(HWND hWnd, UINT Line 823  LRESULT CALLBACK WndProc(HWND hWnd, UINT
                         if (LOWORD(wParam) != WA_INACTIVE) {                          if (LOWORD(wParam) != WA_INACTIVE) {
                                 np2break &= ~NP2BREAK_MAIN;                                  np2break &= ~NP2BREAK_MAIN;
                                 scrnmng_update();                                  scrnmng_update();
                                   keystat_allrelease();
                                 mouse_running(MOUSE_CONT_M);                                  mouse_running(MOUSE_CONT_M);
                         }                          }
                         else {                          else {
Line 822  LRESULT CALLBACK WndProc(HWND hWnd, UINT Line 836  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,
                                                                                                   GetStockObject(BLACK_BRUSH));
                                   PatBlt(hdc, 0, 0, width, height, PATCOPY);
                                   SelectObject(hdc, hbrush);
                                   hmdc = CreateCompatibleDC(hdc);
                                   SelectObject(hmdc, hbmp);
                                   BitBlt(hdc, (width - bmp.bmWidth) / 2,
                                                   (height - bmp.bmHeight) / 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);
 #else  
                         hbmp = LoadBitmap(hinst, "NP2EXT");  
                             GetObject(hbmp, sizeof(BITMAP), &bmp);  
                             hmdc = CreateCompatibleDC(hdc);  
                             SelectObject(hmdc, hbmp);  
                             BitBlt(hdc, (sx - 160) / 2, (sy - 140) / 2,  
                                                         bmp.bmWidth, bmp.bmHeight, hmdc, 0, 0, SRCCOPY);  
                             DeleteDC(hmdc);  
                         DeleteObject(hbmp);  
 #endif  
                         }                          }
                         else {                          else {
 //                              scrnmng_update();  //                              scrnmng_update();
Line 863  LRESULT CALLBACK WndProc(HWND hWnd, UINT Line 874  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);
                                   }
                                   if (GetWindowLong(hWnd, GWL_STYLE) & WS_MINIMIZE) {
                                           toolwin_close();
                                   }
                                   else if (np2oscfg.toolwin) {
                                           toolwin_open();
                                   }
                         }                          }
                         break;                          break;
   
Line 888  LRESULT CALLBACK WndProc(HWND hWnd, UINT Line 906  LRESULT CALLBACK WndProc(HWND hWnd, UINT
                         soundmng_stop();                          soundmng_stop();
                         mouse_running(MOUSE_STOP);                          mouse_running(MOUSE_STOP);
                         winloc_movingstart();                          winloc_movingstart();
                           toolwin_movingstart();
                         break;                          break;
   
                 case WM_EXITSIZEMOVE:                  case WM_EXITSIZEMOVE:
                           toolwin_movingend();
                         mouse_running(MOUSE_CONT);                          mouse_running(MOUSE_CONT);
                         soundmng_play();                          soundmng_play();
                         break;                          break;
Line 903  LRESULT CALLBACK WndProc(HWND hWnd, UINT Line 923  LRESULT CALLBACK WndProc(HWND hWnd, UINT
   
                 case WM_KEYDOWN:                  case WM_KEYDOWN:
                         if (wParam == VK_F11) {                          if (wParam == VK_F11) {
                                   scrnmng_enablemenubar();
                                 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)) {
Line 914  LRESULT CALLBACK WndProc(HWND hWnd, UINT Line 935  LRESULT CALLBACK WndProc(HWND hWnd, UINT
                                 winkeydown106(wParam, lParam);                                  winkeydown106(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));
Line 941  LRESULT CALLBACK WndProc(HWND hWnd, UINT Line 963  LRESULT CALLBACK WndProc(HWND hWnd, UINT
                         winkeyup106(wParam, lParam);                          winkeyup106(wParam, lParam);
                         break;                          break;
   
                   case WM_MOUSEMOVE:
                           if (scrnmng_isfullscreen()) {
                                   POINT p;
                                   if (GetCursorPos(&p)) {
                                           scrnmng_fullscrnmenu(p.y);
                                   }
                           }
                           break;
   
                 case WM_LBUTTONDOWN:                  case WM_LBUTTONDOWN:
                         if (!mouse_btn(MOUSE_LEFTDOWN)) {                          if (!mouse_btn(MOUSE_LEFTDOWN)) {
                                 if (scrnmng_isfullscreen()) {                                  if (scrnmng_isfullscreen()) {
                                         POINT   p;                                          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 954  LRESULT CALLBACK WndProc(HWND hWnd, UINT Line 985  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 (!mouse_btn(MOUSE_LEFTUP)) {
                                 return(DefWindowProc(hWnd, msg, wParam, lParam));                                  return(DefWindowProc(hWnd, msg, wParam, lParam));
Line 1071  LRESULT CALLBACK WndProc(HWND hWnd, UINT Line 1103  LRESULT CALLBACK WndProc(HWND hWnd, UINT
 }  }
   
   
 static void processwait(WORD cnt) {  static void processwait(UINT cnt) {
   
         if (timing_getcount() >= cnt) {          if (timing_getcount() >= cnt) {
                 timing_setcount(0);                  timing_setcount(0);
                 framecnt = 0;                  framecnt = 0;
                 scrnmng_dispclock();                  scrnmng_dispclock();
                 keydisp_draw(np2oscfg.DRAW_SKIP);                  keydisp_draw((BYTE)cnt);
                   toolwin_draw((BYTE)cnt);
                 viewer_allreload(FALSE);                  viewer_allreload(FALSE);
                 if (np2oscfg.DISPCLK & 3) {                  if (np2oscfg.DISPCLK & 3) {
                         if (sysmng_workclockrenewal()) {                          if (sysmng_workclockrenewal()) {
Line 1097  int WINAPI WinMain(HINSTANCE hInstance,  Line 1130  int WINAPI WinMain(HINSTANCE hInstance, 
         MSG                     msg;          MSG                     msg;
         HMENU           hMenu;          HMENU           hMenu;
         HWND            hwndorg;          HWND            hwndorg;
         int                     i;          UINT            i;
 #ifdef OPENING_WAIT  #ifdef OPENING_WAIT
         UINT32          tick;          UINT32          tick;
 #endif  #endif
Line 1105  int WINAPI WinMain(HINSTANCE hInstance,  Line 1138  int WINAPI WinMain(HINSTANCE hInstance, 
         GetModuleFileName(NULL, modulefile, sizeof(modulefile));          GetModuleFileName(NULL, modulefile, sizeof(modulefile));
         dosio_init();          dosio_init();
         file_setcd(modulefile);          file_setcd(modulefile);
         np2arg_analize(lpszCmdLine);                            // タイミング修正       // ver0.29          np2arg_analize(lpszCmdLine);
         initload();          initload();
           toolwin_readini();
   
         srand((unsigned)time(NULL));          rand_setseed((unsigned)time(NULL));
   
 //      np2arg_analize(lpszCmdLine);  
   
         CopyMemory(szClassName, np2oscfg.winid, 3);          CopyMemory(szClassName, np2oscfg.winid, 3);
   
Line 1124  int WINAPI WinMain(HINSTANCE hInstance,  Line 1156  int WINAPI WinMain(HINSTANCE hInstance, 
   
         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 1148  int WINAPI WinMain(HINSTANCE hInstance,  Line 1182  int WINAPI WinMain(HINSTANCE hInstance, 
                 np2.hInstance = hInstance;                  np2.hInstance = hInstance;
                 np2.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ICON1));                  np2.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ICON1));
                 np2.hCursor = LoadCursor(NULL, IDC_ARROW);                  np2.hCursor = LoadCursor(NULL, IDC_ARROW);
                 np2.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);                  np2.hbrBackground = (HBRUSH)GetStockObject(NULL_BRUSH);
                 np2.lpszMenuName = MAKEINTRESOURCE(IDM_MAIN);                  np2.lpszMenuName = MAKEINTRESOURCE(IDM_MAIN);
                 np2.lpszClassName = szClassName;                  np2.lpszClassName = szClassName;
                 if (!RegisterClass(&np2)) {                  if (!RegisterClass(&np2)) {
                         return(FALSE);                          return(FALSE);
                 }                  }
                   toolwin_initapp(hInstance);
         }          }
         keydisp_initialize(hPreInst);          keydisp_initialize(hPreInst);
         viewer_init(hPreInst);                                                                          // ver0.30          viewer_init(hPreInst);                                                                          // ver0.30
Line 1209  int WINAPI WinMain(HINSTANCE hInstance,  Line 1244  int WINAPI WinMain(HINSTANCE hInstance, 
                 }                  }
                 InsertMenu(hMenu, 1, MF_BYPOSITION | MF_POPUP, (UINT)hStat, "S&tat");                  InsertMenu(hMenu, 1, MF_BYPOSITION | MF_POPUP, (UINT)hStat, "S&tat");
         }          }
           sysmenu_init();
         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);          DrawMenuBar(hWndMain);
   
         // ver0.30          // ver0.30
Line 1234  int WINAPI WinMain(HINSTANCE hInstance,  Line 1252  int WINAPI WinMain(HINSTANCE hInstance, 
                 EnableMenuItem(GetMenu(hWndMain), IDM_HELP, MF_GRAYED);                  EnableMenuItem(GetMenu(hWndMain), IDM_HELP, MF_GRAYED);
         }          }
   
           xmenu_settoolwin(np2oscfg.toolwin);
         xmenu_setwinsnap(np2oscfg.WINSNAP);          xmenu_setwinsnap(np2oscfg.WINSNAP);
         xmenu_setbackground(np2oscfg.background);          xmenu_setbackground(np2oscfg.background);
         xmenu_setbgsound(np2oscfg.background);          xmenu_setbgsound(np2oscfg.background);
         xmenu_setscrnmul(8);                                                                            // ver0.26          xmenu_setscrnmul(8);                                                                            // ver0.26
   
           if (np2oscfg.toolwin) {
                   toolwin_open();
           }
   
         scrnmode = 0;          scrnmode = 0;
         if (np2arg.fullscreen) {          if (np2arg.fullscreen) {
                 scrnmode |= SCRNMODE_FULLSCREEN;                  scrnmode |= SCRNMODE_FULLSCREEN;
Line 1369  int WINAPI WinMain(HINSTANCE hInstance,  Line 1392  int WINAPI WinMain(HINSTANCE hInstance, 
                                 }                                  }
                                 else {                                                          // auto skip                                  else {                                                          // auto skip
                                         if (!waitcnt) {                                          if (!waitcnt) {
                                                   UINT cnt;
                                                 joy_flash();                                                  joy_flash();
                                                 mouse_callback();                                                  mouse_callback();
                                                 pccore_exec(framecnt == 0);                                                  pccore_exec(framecnt == 0);
                                                 dclock_callback();                                                  dclock_callback();
                                                 framecnt++;                                                  framecnt++;
                                                 if (timing_getcount() < framecnt) {                                                  cnt = timing_getcount();
                                                   if (framecnt > cnt) {
                                                         waitcnt = framecnt;                                                          waitcnt = framecnt;
                                                         if (framemax > 1) {                                                          if (framemax > 1) {
                                                                 framemax--;                                                                  framemax--;
                                                         }                                                          }
                                                 }                                                  }
                                                 else if (framecnt >= framemax) {                                                  else if (framecnt >= framemax) {
                                                         waitcnt = framecnt;  
                                                         if (framemax < 12) {                                                          if (framemax < 12) {
                                                                 framemax++;                                                                  framemax++;
                                                         }                                                          }
                                                           if (cnt >= 12) {
                                                                   timing_reset();
                                                           }
                                                           else {
                                                                   timing_setcount(cnt - framecnt);
                                                           }
                                                           processwait(0);
                                                 }                                                  }
                                         }                                          }
                                         else {                                          else {
Line 1403  int WINAPI WinMain(HINSTANCE hInstance,  Line 1434  int WINAPI WinMain(HINSTANCE hInstance, 
                         DispatchMessage(&msg);                          DispatchMessage(&msg);
                 }                  }
         }          }
           toolwin_close();
   
         pccore_cfgupdate();          pccore_cfgupdate();
   
Line 1413  int WINAPI WinMain(HINSTANCE hInstance,  Line 1445  int WINAPI WinMain(HINSTANCE hInstance, 
                 flagsave(np2resume);                  flagsave(np2resume);
         }          }
         else {          else {
 //              DeleteFile(file_getcd(np2resume));                  flagdelete(np2resume);
         }          }
   
 #ifdef USE_ROMEO  #ifdef USE_ROMEO
Line 1432  int WINAPI WinMain(HINSTANCE hInstance,  Line 1464  int WINAPI WinMain(HINSTANCE hInstance, 
   
         if (sys_updates & (SYS_UPDATECFG | SYS_UPDATEOSCFG)) {          if (sys_updates & (SYS_UPDATECFG | SYS_UPDATEOSCFG)) {
                 initsave();                  initsave();
                   toolwin_writeini();
         }          }
   
         TRACETERM();          TRACETERM();
Removed from v.1.3  
changed lines
  Added in v.1.15

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