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

Diff for /np2/win9x/dialog/d_config.cpp between versions 1.7 and 1.15

version 1.7, 2003/11/24 07:40:02 version 1.15, 2007/11/11 07:11:28
Line 2 Line 2
 #include        "strres.h"  #include        "strres.h"
 #include        "resource.h"  #include        "resource.h"
 #include        "np2.h"  #include        "np2.h"
   #include        "oemtext.h"
 #include        "dosio.h"  #include        "dosio.h"
 #include        "sysmng.h"  #include        "sysmng.h"
 #include        "dialog.h"  #include        "dialog.h"
Line 9 Line 10
 #include        "pccore.h"  #include        "pccore.h"
   
   
 static const char str_2halfmhz[] = "2.4576MHz";  static const CBPARAM cpBase[] =
 static const char str_2mhz[] = "1.9968MHz";  {
 static const char *basecstr[2] = {str_2mhz, str_2halfmhz};          {MAKEINTRESOURCE(IDS_2_0MHZ),   PCBASECLOCK20},
           {MAKEINTRESOURCE(IDS_2_5MHZ),   PCBASECLOCK25},
   };
 static const UINT32 mulval[10] = {1, 2, 4, 5, 6, 8, 10, 12, 16, 20};  static const UINT32 mulval[10] = {1, 2, 4, 5, 6, 8, 10, 12, 16, 20};
 static const char str_clockfmt[] = "%2u.%.4u";  static const TCHAR str_clockfmt[] = _T("%2u.%.4u");
   
   
 static void setclock(HWND hWnd, UINT multiple) {  static void setclock(HWND hWnd, UINT uMultiple)
   {
           UINT    uClock;
           TCHAR   szWork[32];
   
         UINT32  clock;          uClock = dlgs_getcbcur(hWnd, IDC_BASECLOCK, PCBASECLOCK20);
         char    work[32];  
   
         GetDlgItemText(hWnd, IDC_BASECLOCK, work, sizeof(work));          if (uMultiple == 0)
         if (work[0] == '1') {          {
                 clock = PCBASECLOCK20 / 100;                  GetDlgItemText(hWnd, IDC_MULTIPLE, szWork, NELEMENTS(szWork));
                   uMultiple = (UINT)miltchar_solveINT(szWork);
         }          }
         else {          uMultiple = max(uMultiple, 1);
                 clock = PCBASECLOCK25 / 100;          uMultiple = min(uMultiple, 32);
         }  
         if (multiple == 0) {          uClock = (uClock / 100) * uMultiple;
                 GetDlgItemText(hWnd, IDC_MULTIPLE, work, sizeof(work));          wsprintf(szWork, str_clockfmt, uClock / 10000, uClock % 10000);
                 multiple = (UINT)milstr_solveINT(work);          SetDlgItemText(hWnd, IDC_CLOCKMSG, szWork);
         }  
         if (multiple < 1) {  
                 multiple = 1;  
         }  
         else if (multiple > 32) {  
                 multiple = 32;  
         }  
         clock *= multiple;  
         wsprintf(work, str_clockfmt, clock / 10000, clock % 10000);  
         SetDlgItemText(hWnd, IDC_CLOCKMSG, work);  
 }  }
   
 static void cfgcreate(HWND hWnd) {  static void cfgcreate(HWND hWnd) {
   
         char    work[32];          TCHAR   work[32];
         UINT    val;          UINT    val;
   
         SETLISTSTR(hWnd, IDC_BASECLOCK, basecstr);          dlgs_setcbitem(hWnd, IDC_BASECLOCK, cpBase, NELEMENTS(cpBase));
         if (np2cfg.baseclock < AVE(PCBASECLOCK25, PCBASECLOCK20)) {          if (np2cfg.baseclock < AVE(PCBASECLOCK25, PCBASECLOCK20))
                 val = 0;          {
                   val = PCBASECLOCK20;
         }          }
         else {          else
                 val = 1;          {
                   val = PCBASECLOCK25;
         }          }
         SendDlgItemMessage(hWnd, IDC_BASECLOCK, CB_SETCURSEL, val, 0);          dlgs_setcbcur(hWnd, IDC_BASECLOCK, val);
   
         SETLISTUINT32(hWnd, IDC_MULTIPLE, mulval);          SETLISTUINT32(hWnd, IDC_MULTIPLE, mulval);
         wsprintf(work, str_u, np2cfg.multiple);          wsprintf(work, tchar_u, np2cfg.multiple);
         SetDlgItemText(hWnd, IDC_MULTIPLE, work);          SetDlgItemText(hWnd, IDC_MULTIPLE, work);
   
         if (np2cfg.samplingrate < AVE(11025, 22050)) {          if (!milstr_cmp(np2cfg.model, str_VM))
           {
                   val = IDC_MODELVM;
           }
           else if (!milstr_cmp(np2cfg.model, str_EPSON))
           {
                   val = IDC_MODELEPSON;
           }
           else
           {
                   val = IDC_MODELVX;
           }
           SetDlgItemCheck(hWnd, val, TRUE);
   
           if (np2cfg.samplingrate < AVE(11025, 22050))
           {
                 val = IDC_RATE11;                  val = IDC_RATE11;
         }          }
         else if (np2cfg.samplingrate < AVE(22050, 44100)) {          else if (np2cfg.samplingrate < AVE(22050, 44100))
           {
                 val = IDC_RATE22;                  val = IDC_RATE22;
         }          }
         else {          else
           {
                 val = IDC_RATE44;                  val = IDC_RATE44;
         }          }
         SetDlgItemCheck(hWnd, val, TRUE);          SetDlgItemCheck(hWnd, val, TRUE);
         wsprintf(work, str_u, np2cfg.delayms);          wsprintf(work, tchar_u, np2cfg.delayms);
         SetDlgItemText(hWnd, IDC_SOUNDBUF, work);          SetDlgItemText(hWnd, IDC_SOUNDBUF, work);
   
         if (mmxflag & MMXFLAG_NOTSUPPORT) {          SetDlgItemCheck(hWnd, IDC_ALLOWRESIZE, np2oscfg.thickframe);
   #if !defined(_WIN64)
           if (mmxflag & MMXFLAG_NOTSUPPORT)
           {
                 EnableWindow(GetDlgItem(hWnd, IDC_DISABLEMMX), FALSE);                  EnableWindow(GetDlgItem(hWnd, IDC_DISABLEMMX), FALSE);
                 SetDlgItemCheck(hWnd, IDC_DISABLEMMX, TRUE);                  SetDlgItemCheck(hWnd, IDC_DISABLEMMX, TRUE);
         }          }
         else {          else
           {
                 SetDlgItemCheck(hWnd, IDC_DISABLEMMX, np2oscfg.disablemmx);                  SetDlgItemCheck(hWnd, IDC_DISABLEMMX, np2oscfg.disablemmx);
         }          }
   #endif
         SetDlgItemCheck(hWnd, IDC_COMFIRM, np2oscfg.comfirm);          SetDlgItemCheck(hWnd, IDC_COMFIRM, np2oscfg.comfirm);
         SetDlgItemCheck(hWnd, IDC_RESUME, np2oscfg.resume);          SetDlgItemCheck(hWnd, IDC_RESUME, np2oscfg.resume);
         setclock(hWnd, 0);          setclock(hWnd, 0);
         SetFocus(GetDlgItem(hWnd, IDC_BASECLOCK));          SetFocus(GetDlgItem(hWnd, IDC_BASECLOCK));
 }  }
   
 static void cfgupdate(HWND hWnd) {  static void cfgupdate(HWND hWnd)
   {
         UINT    update;          UINT            update;
         char    work[32];          TCHAR           work[32];
         UINT    val;          UINT            val;
   const OEMCHAR   *str;
   
         update = 0;          update = 0;
         GetDlgItemText(hWnd, IDC_BASECLOCK, work, sizeof(work));  
         if (work[0] == '1') {          val = dlgs_getcbcur(hWnd, IDC_BASECLOCK, PCBASECLOCK20);
                 val = PCBASECLOCK20;          if (np2cfg.baseclock != val)
         }          {
         else {  
                 val = PCBASECLOCK25;  
         }  
         if (np2cfg.baseclock != val) {  
                 np2cfg.baseclock = val;                  np2cfg.baseclock = val;
                 update |= SYS_UPDATECFG | SYS_UPDATECLOCK;                  update |= SYS_UPDATECFG | SYS_UPDATECLOCK;
         }          }
   
         GetDlgItemText(hWnd, IDC_MULTIPLE, work, sizeof(work));          GetDlgItemText(hWnd, IDC_MULTIPLE, work, sizeof(work));
         val = (UINT)milstr_solveINT(work);          val = (UINT)miltchar_solveINT(work);
         if (val < 1) {          if (val < 1) {
                 val = 1;                  val = 1;
         }          }
Line 118  static void cfgupdate(HWND hWnd) { Line 136  static void cfgupdate(HWND hWnd) {
                 update |= SYS_UPDATECFG | SYS_UPDATECLOCK;                  update |= SYS_UPDATECFG | SYS_UPDATECLOCK;
         }          }
   
           if (GetDlgItemCheck(hWnd, IDC_MODELVM)) {
                   str = str_VM;
           }
           else if (GetDlgItemCheck(hWnd, IDC_MODELEPSON)) {
                   str = str_EPSON;
           }
           else {
                   str = str_VX;
           }
           if (milstr_cmp(np2cfg.model, str)) {
                   milstr_ncpy(np2cfg.model, str, NELEMENTS(np2cfg.model));
                   update |= SYS_UPDATECFG;
           }
   
         if (GetDlgItemCheck(hWnd, IDC_RATE11)) {          if (GetDlgItemCheck(hWnd, IDC_RATE11)) {
                 val = 11025;                  val = 11025;
         }          }
Line 133  static void cfgupdate(HWND hWnd) { Line 165  static void cfgupdate(HWND hWnd) {
                 soundrenewal = 1;                  soundrenewal = 1;
         }          }
   
         GetDlgItemText(hWnd, IDC_SOUNDBUF, work, sizeof(work));          GetDlgItemText(hWnd, IDC_SOUNDBUF, work, NELEMENTS(work));
         val = (UINT)milstr_solveINT(work);          val = (UINT)miltchar_solveINT(work);
         if (val < 40) {          if (val < 40) {
                 val = 40;                  val = 40;
         }          }
Line 147  static void cfgupdate(HWND hWnd) { Line 179  static void cfgupdate(HWND hWnd) {
                 soundrenewal = 1;                  soundrenewal = 1;
         }          }
   
         if (!(mmxflag & MMXFLAG_NOTSUPPORT)) {          val = GetDlgItemCheck(hWnd, IDC_ALLOWRESIZE);
           if (np2oscfg.thickframe != (UINT8)val) {
                   np2oscfg.thickframe = (UINT8)val;
                   update |= SYS_UPDATEOSCFG;
           }
   
   #if !defined(_WIN64)
           if (!(mmxflag & MMXFLAG_NOTSUPPORT))
           {
                 val = GetDlgItemCheck(hWnd, IDC_DISABLEMMX);                  val = GetDlgItemCheck(hWnd, IDC_DISABLEMMX);
                 if (np2oscfg.disablemmx != (BYTE)val) {                  if (np2oscfg.disablemmx != (UINT8)val)
                         np2oscfg.disablemmx = (BYTE)val;                  {
                           np2oscfg.disablemmx = (UINT8)val;
                         mmxflag &= ~MMXFLAG_DISABLE;                          mmxflag &= ~MMXFLAG_DISABLE;
                         mmxflag |= (val)?MMXFLAG_DISABLE:0;                          mmxflag |= (val)?MMXFLAG_DISABLE:0;
                         update |= SYS_UPDATEOSCFG;                          update |= SYS_UPDATEOSCFG;
                 }                  }
         }          }
   #endif
   
         val = GetDlgItemCheck(hWnd, IDC_COMFIRM);          val = GetDlgItemCheck(hWnd, IDC_COMFIRM);
         if (np2oscfg.comfirm != (BYTE)val) {          if (np2oscfg.comfirm != (UINT8)val)
                 np2oscfg.comfirm = (BYTE)val;          {
                   np2oscfg.comfirm = (UINT8)val;
                 update |= SYS_UPDATEOSCFG;                  update |= SYS_UPDATEOSCFG;
         }          }
   
         val = GetDlgItemCheck(hWnd, IDC_RESUME);          val = GetDlgItemCheck(hWnd, IDC_RESUME);
         if (np2oscfg.resume != (BYTE)val) {          if (np2oscfg.resume != (UINT8)val)
                 np2oscfg.resume = (BYTE)val;          {
                   np2oscfg.resume = (UINT8)val;
                 update |= SYS_UPDATEOSCFG;                  update |= SYS_UPDATEOSCFG;
         }          }
         sysmng_update(update);          sysmng_update(update);
Line 179  LRESULT CALLBACK CfgDialogProc(HWND hWnd Line 223  LRESULT CALLBACK CfgDialogProc(HWND hWnd
                         return(FALSE);                          return(FALSE);
   
                 case WM_COMMAND:                  case WM_COMMAND:
                         switch (LOWORD(wp)) {                          switch(LOWORD(wp)) {
                                 case IDOK:                                  case IDOK:
                                         cfgupdate(hWnd);                                          cfgupdate(hWnd);
                                         EndDialog(hWnd, IDOK);                                          EndDialog(hWnd, IDOK);
Line 198  LRESULT CALLBACK CfgDialogProc(HWND hWnd Line 242  LRESULT CALLBACK CfgDialogProc(HWND hWnd
                                                 UINT val;                                                  UINT val;
                                                 val = (UINT)SendDlgItemMessage(hWnd, IDC_MULTIPLE,                                                  val = (UINT)SendDlgItemMessage(hWnd, IDC_MULTIPLE,
                                                                                                                 CB_GETCURSEL, 0, 0);                                                                                                                  CB_GETCURSEL, 0, 0);
                                                 if (val < sizeof(mulval)/sizeof(UINT32)) {                                                  if (val < NELEMENTS(mulval)) {
                                                         setclock(hWnd, mulval[val]);                                                          setclock(hWnd, mulval[val]);
                                                 }                                                  }
                                         }                                          }
Removed from v.1.7  
changed lines
  Added in v.1.15

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