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

Diff for /xmil/win9x/xmil.cpp between versions 1.15 and 1.23

version 1.15, 2004/08/12 11:03:09 version 1.23, 2004/08/19 09:50:23
Line 10 Line 10
 #include        "scrnmng.h"  #include        "scrnmng.h"
 #include        "soundmng.h"  #include        "soundmng.h"
 #include        "sysmng.h"  #include        "sysmng.h"
 #include        "ddrawbmp.h"  
 #include        "winloc.h"  #include        "winloc.h"
 #include        "dclock.h"  #include        "dclock.h"
 #include        "winkbd.h"  #include        "winkbd.h"
Line 23 Line 22
 #include        "pccore.h"  #include        "pccore.h"
 #include        "iocore.h"  #include        "iocore.h"
 #include        "timing.h"  #include        "timing.h"
 #include        "keystat.h"  #if defined(SUPPORT_RESUME) || defined(SUPPORT_STATSAVE)
   #include        "statsave.h"
   #endif
 #include        "debugsub.h"  #include        "debugsub.h"
 #include        "scrndraw.h"  #include        "scrndraw.h"
 #include        "makescrn.h"  #include        "makescrn.h"
Line 36  static const OEMCHAR szClassName[] = OEM Line 37  static const OEMCHAR szClassName[] = OEM
   
                 XMILOSCFG       xmiloscfg = {                  XMILOSCFG       xmiloscfg = {
                                                         CW_USEDEFAULT, CW_USEDEFAULT,                                                          CW_USEDEFAULT, CW_USEDEFAULT,
                                                         1, 0, 0, 0, 1,                                                          1, 0, 0, 0, 0,
                                                         0, 0, 0,                                                          0, 0, 0,
   #if defined(SUPPORT_RESUME)
                                                           0,
   #endif
   #if defined(SUPPORT_STATSAVE)
                                                           1,
   #endif
                                                         0, 0, 0xffffff, 0xffbf6a};                                                          0, 0, 0xffffff, 0xffbf6a};
   
                 OEMCHAR         szProgName[] = OEMTEXT("X millennium ねこちゅ〜ん");                  OEMCHAR         szProgName[] = OEMTEXT("X millennium ねこちゅ〜ん");
Line 93  static void winuileave(void) { Line 100  static void winuileave(void) {
 static void dispbmp(HINSTANCE hinst, HDC hdc,  static void dispbmp(HINSTANCE hinst, HDC hdc,
                                                                                 const OEMCHAR *res, int x, int y) {                                                                                  const OEMCHAR *res, int x, int y) {
   
         HBITMAP         hbmp;          HBITMAP hbmp;
         BITMAP          bmp;          BITMAP  bmp;
         HDC                     hmdc;          HDC             hmdc;
   
         hbmp = LoadBitmap(hinst, res);          hbmp = LoadBitmap(hinst, res);
         GetObject(hbmp, sizeof(bmp), &bmp);          GetObject(hbmp, sizeof(bmp), &bmp);
Line 109  static void dispbmp(HINSTANCE hinst, HDC Line 116  static void dispbmp(HINSTANCE hinst, HDC
   
 // ----  // ----
   
 LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {  #if defined(SUPPORT_RESUME)
   static const OEMCHAR xmilresumeext[] = OEMTEXT(".sav");
   static const OEMCHAR str_resume[] = OEMTEXT("Resume");
   #endif
   #if defined(SUPPORT_STATSAVE)
   static const OEMCHAR xmilflagext[] = OEMTEXT(".sv%u");
   static const OEMCHAR str_statload[] = OEMTEXT("Status Load");
   #endif
   
         PAINTSTRUCT     ps;  #if defined(SUPPORT_RESUME) || defined(SUPPORT_STATSAVE)
         RECT            rc;  static const OEMCHAR str_loaderr[] = OEMTEXT("Couldn't restart");
         HDC                     hdc;  static const OEMCHAR str_conflict[] = OEMTEXT("Conflict!\n\n%s\nContinue?");
         UINT            updateflag;  
   static void getstatfilename(OEMCHAR *path, const OEMCHAR *ext, UINT size) {
   
           file_cpyname(path, modulefile, size);
           file_cutext(path);
           file_catname(path, ext, size);
   }
   
         switch (msg) {  static int flagsave(const OEMCHAR *ext) {
                 case WM_CREATE:  
                         extclass_wmcreate(hWnd);          OEMCHAR path[MAX_PATH];
 #ifndef __GNUC__          int             ret;
                         WINNLSEnableIME(hWnd, FALSE);  
           getstatfilename(path, ext, NELEMENTS(path));
           soundmng_stop();
           ret = statsave_save(path);
           if (ret) {
                   file_delete(path);
           }
           soundmng_play();
           return(ret);
   }
   
   static void flagdelete(const OEMCHAR *ext) {
   
           OEMCHAR path[MAX_PATH];
   
           getstatfilename(path, ext, NELEMENTS(path));
           file_delete(path);
   }
   
   static int flagload(const OEMCHAR *ext, const OEMCHAR *title, BRESULT force) {
   
           int             ret;
           int             id;
           OEMCHAR path[MAX_PATH];
           OEMCHAR buf[1024];
           OEMCHAR buf2[1024 + 32];
   
           getstatfilename(path, ext, NELEMENTS(path));
           winuienter();
           id = IDYES;
           ret = statsave_check(path, buf, NELEMENTS(buf));
           if (ret & (~STATFLAG_DISKCHG)) {
                   MessageBox(hWndMain, str_loaderr, title, MB_OK | MB_ICONSTOP);
                   id = IDNO;
           }
           else if ((!force) && (ret & STATFLAG_DISKCHG)) {
                   OEMSPRINTF(buf2, str_conflict, buf);
                   id = MessageBox(hWndMain, buf2, title,
                                                                                   MB_YESNOCANCEL | MB_ICONQUESTION);
           }
           if (id == IDYES) {
                   statsave_load(path);
   //              toolwin_setfdd(0, fdd_diskname(0));
   //              toolwin_setfdd(1, fdd_diskname(1));
           }
           sysmng_workclockreset();
           sysmng_updatecaption(1);
           winuileave();
           return(id);
   }
 #endif  #endif
   
   
   // ----
   
   static void xmilcmd(HWND hWnd, UINT cmd) {
   
           UINT    update;
   #if defined(SUPPORT_STATSAVE)
           OEMCHAR ext[16];
   #endif
   
           update = 0;
           switch(cmd) {
                   case IDM_IPLRESET:
                           pccore_reset();
                         break;                          break;
   
                 case WM_SYSCOMMAND:                  case IDM_NMIRESET:
                         updateflag = 0;                          Z80_NMI();
                         switch(wParam) {                          break;
                                 case IDM_SCREENCENTER:  
                                         if (!scrnmng_isfullscreen()) {  
                                                 wincentering(hWnd);  
                                         }  
                                         break;  
   
                                 case IDM_SNAPENABLE:                  case IDM_CONFIG:
                                         sysmenu_setwinsnap(xmiloscfg.WINSNAP ^ 1);                          winuienter();
                                         updateflag = SYS_UPDATEOSCFG;                          DialogBox(hInst, MAKEINTRESOURCE(IDD_CONFIG),
                                         break;                                                                                          hWnd, (DLGPROC)CfgDialogProc);
                           winuileave();
                           break;
   
                                 case IDM_BACKGROUND:                  case IDM_NEWDISK:
                                         sysmenu_setbackground(xmiloscfg.background ^ 1);                          winuienter();
                                         updateflag = SYS_UPDATEOSCFG;                          dialog_newdisk(hWnd);
                                         break;                          winuileave();
                           break;
   
                                 case IDM_BGSOUND:                  case IDM_EXIT:
                                         sysmenu_setbgsound(xmiloscfg.background ^ 2);                          SendMessage(hWnd, WM_CLOSE, 0, 0L);
                                         updateflag = SYS_UPDATEOSCFG;                          break;
                                         break;  
   
                                 default:                  case IDM_FDD0OPEN:
                                         return(DefWindowProc(hWnd, msg, wParam, lParam));                          winuienter();
                         }                          dialog_changefdd(hWnd, 0);
                         sysmng_update(updateflag);                          winuileave();
                         break;                          break;
   
                 case WM_COMMAND:                  case IDM_FDD0EJECT:
                         updateflag = 0;                          diskdrv_setfdd(0, NULL, 0);
                         switch(LOWORD(wParam)) {                          break;
                                 case IDM_IPLRESET:  
 #if 1  
                                         pccore_reset();  
 #else  
                                         if ((!juliet_YM2151IsEnable()) && (changehz)) {  
                                                 changehz = 0;  
                                                 STREAM_TERM();  
                                                 STREAM_CREATE();  
                                         }  
                                         if (reset_x1(xmilcfg.ROM_TYPE,  
                                                                 xmilcfg.SOUND_SW, xmilcfg.DIP_SW)) {  
                                                 PostQuitMessage(0);  
                                         }  
 #endif  
                                         break;  
   
                                 case IDM_NMIRESET:                  case IDM_FDD1OPEN:
                                         Z80_NMI();                          winuienter();
                                         break;                          dialog_changefdd(hWnd, 1);
                           winuileave();
                           break;
   
                                 case IDM_CONFIG:                  case IDM_FDD1EJECT:
                                         winuienter();                          diskdrv_setfdd(1, NULL, 0);
                                         DialogBox(hInst, MAKEINTRESOURCE(IDD_CONFIG),                          break;
                                                                                         hWnd, (DLGPROC)CfgDialogProc);  
                                         winuileave();  
                                         break;  
   
                                 case IDM_NEWDISK:                  case IDM_FDD2OPEN:
                                         winuienter();                          winuienter();
                                         dialog_newdisk(hWnd);                          dialog_changefdd(hWnd, 2);
                                         winuileave();                          winuileave();
                                         break;                          break;
   
                                 case IDM_EXIT:                  case IDM_FDD2EJECT:
                                         SendMessage(hWnd, WM_CLOSE, 0, 0L);                          diskdrv_setfdd(2, NULL, 0);
                                         break;                          break;
   
                                 case IDM_FDD0OPEN:                  case IDM_FDD3OPEN:
                                         winuienter();                          winuienter();
                                         dialog_changefdd(hWnd, 0);                          dialog_changefdd(hWnd, 3);
                                         winuileave();                          winuileave();
                                         break;                          break;
   
                                 case IDM_FDD0EJECT:                  case IDM_FDD3EJECT:
                                         diskdrv_setfdd(0, NULL, 0);                          diskdrv_setfdd(3, NULL, 0);
                                         break;                          break;
   
                                 case IDM_FDD1OPEN:                  case IDM_X1ROM:
                                         winuienter();                          menu_setiplrom(1);
                                         dialog_changefdd(hWnd, 1);                          update = SYS_UPDATECFG;
                                         winuileave();                          break;
                                         break;  
   
                                 case IDM_FDD1EJECT:                  case IDM_TURBO:
                                         diskdrv_setfdd(1, NULL, 0);                          menu_setiplrom(2);
                                         break;                          update = SYS_UPDATECFG;
                           break;
   
                                 case IDM_TURBOZ:  #if defined(SUPPORT_TURBOZ)
                                         menu_setiplrom(3);                  case IDM_TURBOZ:
                                         updateflag = SYS_UPDATECFG;                          menu_setiplrom(3);
                                         break;                          update = SYS_UPDATECFG;
                           break;
   #endif
   
                                 case IDM_TURBO:                  case IDM_BOOT2D:
                                         menu_setiplrom(2);                          menu_setbootmedia(0);
                                         updateflag = SYS_UPDATECFG;                          update = SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_X1ROM:                  case IDM_BOOT2HD:
                                         menu_setiplrom(1);                          menu_setbootmedia(DIPSW_BOOTMEDIA);
                                         updateflag = SYS_UPDATECFG;                          update = SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_BOOT2D:                  case IDM_HIGHRES:
                                         menu_setbootmedia(0);                          menu_setresolute(0);
                                         updateflag = SYS_UPDATECFG;                          update = SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_BOOT2HD:                  case IDM_LOWRES:
                                         menu_setbootmedia(DIPSW_BOOTMEDIA);                          menu_setresolute(DIPSW_RESOLUTE);
                                         updateflag = SYS_UPDATECFG;                          update = SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_HIGHRES:                  case IDM_WINDOW:
                                         menu_setresolute(0);                          scrnmng_changescreen(scrnmode & (~SCRNMODE_FULLSCREEN));
                                         updateflag = SYS_UPDATECFG;                          break;
                                         break;  
   
                                 case IDM_LOWRES:                  case IDM_FULLSCREEN:
                                         menu_setresolute(DIPSW_RESOLUTE);                          scrnmng_changescreen(scrnmode | SCRNMODE_FULLSCREEN);
                                         updateflag = SYS_UPDATECFG;                          break;
                                         break;  
   
                                 case IDM_WINDOW:                  case IDM_DISPSYNC:
                                         scrnmng_changescreen(scrnmode & (~SCRNMODE_FULLSCREEN));                          menu_setdispmode(xmilcfg.DISPSYNC ^ 1);
                                         break;                          update = SYS_UPDATECFG;
                           break;
   
                                 case IDM_FULLSCREEN:                  case IDM_RASTER:
                                         scrnmng_changescreen(scrnmode | SCRNMODE_FULLSCREEN);                          menu_setraster(xmilcfg.RASTER ^ 1);
                                         break;                          if (xmilcfg.RASTER) {
                                   scrnmng_changescreen(scrnmode | SCRNMODE_SYSHIGHCOLOR);
                           }
                           else {
                                   scrnmng_changescreen(scrnmode & (~SCRNMODE_SYSHIGHCOLOR));
                           }
                           update = SYS_UPDATECFG;
                           break;
   
                                 case IDM_WIDTH80:                  case IDM_NOWAIT:
                                         crtc.s.TXT_XL = 80;                          menu_setwaitflg(xmiloscfg.NOWAIT ^ 1);
 //                                      crtc.s.GRP_XL = 640;                          update = SYS_UPDATECFG;
                                         vrambank_patch();                          break;
                                         scrnallflash = 1;  
                                         break;  
   
                                 case IDM_WIDTH40:                  case IDM_AUTOFPS:
                                         crtc.s.TXT_XL = 40;                          menu_setframe(0);
 //                                      crtc.s.GRP_XL = 320;                          update = SYS_UPDATECFG;
                                         vrambank_patch();                          break;
                                         scrnallflash = 1;  
                                         break;  
   
                                 case IDM_DISPSYNC:                  case IDM_60FPS:
                                         menu_setdispmode(xmilcfg.DISPSYNC ^ 1);                          menu_setframe(1);
                                         updateflag = SYS_UPDATECFG;                          update = SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_RASTER:                  case IDM_30FPS:
                                         menu_setraster(xmilcfg.RASTER ^ 1);                          menu_setframe(2);
                                         updateflag = SYS_UPDATECFG;                          update = SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_NOWAIT:                  case IDM_20FPS:
                                         menu_setwaitflg(xmiloscfg.NOWAIT ^ 1);                          menu_setframe(3);
                                         updateflag = SYS_UPDATECFG;                          update = SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_AUTOFPS:                  case IDM_15FPS:
                                         menu_setframe(0);                          menu_setframe(4);
                                         updateflag = SYS_UPDATECFG;                          update = SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_60FPS:                  case IDM_KEY:
                                         menu_setframe(1);                          menu_setkey(0);
                                         updateflag = SYS_UPDATECFG;                          break;
                                         break;  
   
                                 case IDM_30FPS:                  case IDM_JOY1:
                                         menu_setframe(2);                          menu_setkey(1);
                                         updateflag = SYS_UPDATECFG;                          break;
                                         break;  
   
                                 case IDM_20FPS:                  case IDM_JOY2:
                                         menu_setframe(3);                          menu_setkey(2);
                                         updateflag = SYS_UPDATECFG;                          break;
                                         break;  
   
                                 case IDM_15FPS:                  case IDM_FMBOARD:
                                         menu_setframe(4);                          menu_setsound(xmilcfg.SOUND_SW ^ 1);
                                         updateflag = SYS_UPDATECFG;                          update = SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_KEY:                  case IDM_JOYSTICK:
                                         menu_setkey(0);                          menu_setjoystick(xmiloscfg.JOYSTICK ^ 1);
                                         break;                          update = SYS_UPDATECFG;
                           break;
   
                                 case IDM_JOY1:                  case IDM_MOUSE:
                                         menu_setkey(1);                  //      mousemng_toggle(MOUSEPROC_SYSTEM);
                                         break;                          menu_setmouse(xmilcfg.MOUSE_SW ^ 1);
                           update = SYS_UPDATECFG;
                           break;
   
                                 case IDM_JOY2:                  case IDM_SEEKSND:
                                         menu_setkey(2);                          menu_setmotorflg(xmilcfg.MOTOR ^ 1);
                                         break;                          update = SYS_UPDATECFG;
                           break;
   
                                 case IDM_FMBOARD:                  case IDM_WIDTH40:
                                         menu_setsound(xmilcfg.SOUND_SW ^ 1);                          crtc_forcesetwidth(40);
                                         updateflag = SYS_UPDATECFG;                          break;
                                         break;  
   
                                 case IDM_JOYSTICK:                  case IDM_WIDTH80:
                                         menu_setjoystick(xmiloscfg.JOYSTICK ^ 1);                          crtc_forcesetwidth(80);
                                         updateflag = SYS_UPDATECFG;                          break;
                                         break;  
   
                                 case IDM_MOUSE:                  case IDM_Z80SAVE:
                                 //      mousemng_toggle(MOUSEPROC_SYSTEM);                          debugsub_status();
                                         menu_setmouse(xmilcfg.MOUSE_SW ^ 1);                          break;
                                         updateflag = SYS_UPDATECFG;  
                                         break;  
   
                                 case IDM_SEEKSND:                  case IDM_BMPSAVE:
                                         menu_setmotorflg(xmilcfg.MOTOR ^ 1);                          winuienter();
                                         updateflag = SYS_UPDATECFG;                          dialog_writebmp(hWnd);
                                         break;                          winuileave();
                           break;
   
                                 case IDM_BMPSAVE:                  case IDM_OPMLOG:
                                         winuienter();                          winuienter();
                                         bmpsave();                          dialog_x1f(hWnd);
                                         winuileave();                          winuileave();
                                         break;                          break;
   
                                 case IDM_OPMLOG:                  case IDM_DISPCLOCK:
                                         winuienter();                          menu_setdispclk(xmiloscfg.DISPCLK ^ 1);
                                         dialog_x1f(hWnd);                          update = SYS_UPDATECFG;
                                         winuileave();                          break;
                                         break;  
   
                                 case IDM_DISPCLOCK:                  case IDM_DISPFRAME:
                                         menu_setdispclk(xmiloscfg.DISPCLK ^ 1);                          menu_setdispclk(xmiloscfg.DISPCLK ^ 2);
                                         updateflag = SYS_UPDATECFG;                          update = SYS_UPDATECFG;
                                         break;                          break;
   
                                 case IDM_DISPFRAME:                  case IDM_JOYX:
                                         menu_setdispclk(xmiloscfg.DISPCLK ^ 2);                          menu_setbtnmode(xmilcfg.BTN_MODE ^ 1);
                                         updateflag = SYS_UPDATECFG;                          update = SYS_UPDATECFG;
                                         break;                          break;
   
                   case IDM_RAPID:
                           menu_setbtnrapid(xmilcfg.BTN_RAPID ^ 1);
                           update = SYS_UPDATECFG;
                           break;
   
                   case IDM_ABOUT:
                           winuienter();
                           DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUT),
                                                                                           hWnd, (DLGPROC)AboutDialogProc);
                           winuileave();
                           break;
   
                   default:
   #if defined(SUPPORT_STATSAVE)
                           if ((cmd >= IDM_FLAGSAVE) &&
                                   (cmd < (IDM_FLAGSAVE + SUPPORT_STATSAVE))) {
                                   OEMSPRINTF(ext, xmilflagext, cmd - IDM_FLAGSAVE);
                                   flagsave(ext);
                           }
                           else if ((cmd >= IDM_FLAGLOAD) &&
                                   (cmd < (IDM_FLAGLOAD + SUPPORT_STATSAVE))) {
                                   OEMSPRINTF(ext, xmilflagext, cmd - IDM_FLAGLOAD);
                                   flagload(ext, str_statload, TRUE);
                           }
   #endif
                           break;
           }
           sysmng_update(update);
   }
   
   LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
   
           PAINTSTRUCT     ps;
           RECT            rc;
           HDC                     hdc;
           UINT            updateflag;
   
                                 case IDM_JOYX:          switch (msg) {
                                         menu_setbtnmode(xmilcfg.BTN_MODE ^ 1);                  case WM_CREATE:
                                         updateflag = SYS_UPDATECFG;                          extclass_wmcreate(hWnd);
   #ifndef __GNUC__
                           WINNLSEnableIME(hWnd, FALSE);
   #endif
                           break;
   
                   case WM_SYSCOMMAND:
                           updateflag = 0;
                           switch(wParam) {
                                   case IDM_SCREENCENTER:
                                           if (!scrnmng_isfullscreen()) {
                                                   wincentering(hWnd);
                                           }
                                         break;                                          break;
   
                                 case IDM_RAPID:                                  case IDM_SNAPENABLE:
                                         menu_setbtnrapid(xmilcfg.BTN_RAPID ^ 1);                                          sysmenu_setwinsnap(xmiloscfg.WINSNAP ^ 1);
                                         updateflag = SYS_UPDATECFG;                                          updateflag = SYS_UPDATEOSCFG;
                                         break;                                          break;
   
                                 case IDM_Z80SAVE:                                  case IDM_BACKGROUND:
                                         debugsub_status();                                          sysmenu_setbackground(xmiloscfg.background ^ 1);
                                           updateflag = SYS_UPDATEOSCFG;
                                         break;                                          break;
   
                                 case IDM_ABOUT:                                  case IDM_BGSOUND:
                                         winuienter();                                          sysmenu_setbgsound(xmiloscfg.background ^ 2);
                                         DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUT),                                          updateflag = SYS_UPDATEOSCFG;
                                                                                         hWnd, (DLGPROC)AboutDialogProc);  
                                         winuileave();  
                                         break;                                          break;
   
                                   default:
                                           return(DefWindowProc(hWnd, msg, wParam, lParam));
                         }                          }
                         sysmng_update(updateflag);                          sysmng_update(updateflag);
                         break;                          break;
   
                   case WM_COMMAND:
                           xmilcmd(hWnd, LOWORD(wParam));
                           break;
   
                 case WM_ACTIVATE:                  case WM_ACTIVATE:
                         if (LOWORD(wParam) != WA_INACTIVE) {                          if (LOWORD(wParam) != WA_INACTIVE) {
                                 xmilstopemulate = FALSE;                                  xmilstopemulate = FALSE;
Line 743  int WINAPI WinMain(HINSTANCE hInstance,  Line 864  int WINAPI WinMain(HINSTANCE hInstance, 
   
         scrndraw_initialize();          scrndraw_initialize();
         scrnmode = 0;          scrnmode = 0;
           if (xmilcfg.RASTER) {
                   scrnmode |= SCRNMODE_SYSHIGHCOLOR;
           }
         if (scrnmng_create(scrnmode) != SUCCESS) {          if (scrnmng_create(scrnmode) != SUCCESS) {
                 scrnmode ^= SCRNMODE_FULLSCREEN;                  scrnmode ^= SCRNMODE_FULLSCREEN;
                 if (scrnmng_create(scrnmode) != SUCCESS) {                  if (scrnmng_create(scrnmode) != SUCCESS) {
Removed from v.1.15  
changed lines
  Added in v.1.23

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