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

Diff for /np2/win9x/dialog/d_sound.cpp between versions 1.1 and 1.7

version 1.1, 2003/10/16 17:59:03 version 1.7, 2003/10/31 03:40:10
Line 2 Line 2
 #include        <windowsx.h>  #include        <windowsx.h>
 #include        <commctrl.h>  #include        <commctrl.h>
 #include        <prsht.h>  #include        <prsht.h>
 #include        "resource.h"  
 #include        "strres.h"  #include        "strres.h"
   #include        "resource.h"
 #include        "np2.h"  #include        "np2.h"
   #include        "dosio.h"
 #include        "joymng.h"  #include        "joymng.h"
 #include        "sysmng.h"  #include        "sysmng.h"
 #include        "menu.h"  #include        "menu.h"
   #include        "dialog.h"
   #include        "dialogs.h"
   #include        "bit2res.h"
 #include        "pccore.h"  #include        "pccore.h"
 #include        "iocore.h"  #include        "iocore.h"
 #include        "sound.h"  #include        "sound.h"
 #include        "fmboard.h"  #include        "fmboard.h"
 #include        "bit2res.h"  
 #include        "dialog.h"  
 #include        "dialogs.h"  
 #include        "s98.h"  #include        "s98.h"
   
   
Line 27  static const char str_sndopt[] = "Sound  Line 28  static const char str_sndopt[] = "Sound 
   
   
 typedef struct {  typedef struct {
         int             res;          UINT16  res;
         int             resstr;          UINT16  resstr;
         BYTE    *value;          BYTE    *value;
         WORD    min;          UINT16  min;
         WORD    max;          UINT16  max;
 } SLIDER_T;  } SLIDERTBL;
   
 static void slidersetvaluestr(HWND hWnd, const SLIDER_T *item, BYTE value) {  static void slidersetvaluestr(HWND hWnd, const SLIDERTBL *item, BYTE value) {
   
         char    work[32];          char    work[32];
   
Line 42  static void slidersetvaluestr(HWND hWnd, Line 43  static void slidersetvaluestr(HWND hWnd,
         SetDlgItemText(hWnd, item->resstr, work);          SetDlgItemText(hWnd, item->resstr, work);
 }  }
   
 static void slidersetvalue(HWND hWnd, const SLIDER_T *item, BYTE value) {  static void slidersetvalue(HWND hWnd, const SLIDERTBL *item, BYTE value) {
   
         if (value > (BYTE)(item->max)) {          if (value > (BYTE)(item->max)) {
                 value = (BYTE)(item->max);                  value = (BYTE)(item->max);
Line 54  static void slidersetvalue(HWND hWnd, co Line 55  static void slidersetvalue(HWND hWnd, co
         slidersetvaluestr(hWnd, item, value);          slidersetvaluestr(hWnd, item, value);
 }  }
   
 static void sliderinit(HWND hWnd, const SLIDER_T *item) {  static void sliderinit(HWND hWnd, const SLIDERTBL *item) {
   
         SendDlgItemMessage(hWnd, item->res, TBM_SETRANGE, TRUE,          SendDlgItemMessage(hWnd, item->res, TBM_SETRANGE, TRUE,
                                                                                         MAKELONG(item->min, item->max));                                                                                          MAKELONG(item->min, item->max));
         slidersetvalue(hWnd, item, *(item->value));          slidersetvalue(hWnd, item, *(item->value));
 }  }
   
 static void sliderresetpos(HWND hWnd, const SLIDER_T *item) {  static void sliderresetpos(HWND hWnd, const SLIDERTBL *item) {
   
         BYTE    value;          BYTE    value;
   
Line 75  static void sliderresetpos(HWND hWnd, co Line 76  static void sliderresetpos(HWND hWnd, co
         slidersetvaluestr(hWnd, item, value);          slidersetvaluestr(hWnd, item, value);
 }  }
   
 static BYTE sliderrestore(HWND hWnd, const SLIDER_T *item) {  static BYTE sliderrestore(HWND hWnd, const SLIDERTBL *item) {
   
         BYTE    value;          BYTE    value;
         BYTE    ret;          BYTE    ret;
Line 94  static BYTE sliderrestore(HWND hWnd, con Line 95  static BYTE sliderrestore(HWND hWnd, con
         return(ret);          return(ret);
 }  }
   
 // -------------------------------------------------------- mixer  // ---- mixer
   
 static const SLIDER_T sndmixitem[] = {  static const SLIDERTBL sndmixitem[] = {
                 {IDC_VOLFM,             IDC_VOLFMSTR,           &np2cfg.vol_fm,         0,128},                  {IDC_VOLFM,             IDC_VOLFMSTR,           &np2cfg.vol_fm,         0,128},
                 {IDC_VOLPSG,    IDC_VOLPSGSTR,          &np2cfg.vol_ssg,        0,128},                  {IDC_VOLPSG,    IDC_VOLPSGSTR,          &np2cfg.vol_ssg,        0,128},
                 {IDC_VOLADPCM,  IDC_VOLADPCMSTR,        &np2cfg.vol_adpcm,      0,128},                  {IDC_VOLADPCM,  IDC_VOLADPCMSTR,        &np2cfg.vol_adpcm,      0,128},
Line 137  static LRESULT CALLBACK SndmixDlgProc(HW Line 138  static LRESULT CALLBACK SndmixDlgProc(HW
                         break;                          break;
   
                 case WM_NOTIFY:                  case WM_NOTIFY:
                         if ((((NMHDR *)lp)->code) == PSN_APPLY) {                          if ((((NMHDR *)lp)->code) == (UINT)PSN_APPLY) {
                                 for (i=0; i<5; i++) {                                  for (i=0; i<5; i++) {
                                         if (sliderrestore(hWnd, &sndmixitem[i])) {                                          if (sliderrestore(hWnd, &sndmixitem[i])) {
                                                 sysmng_update(SYS_UPDATECFG);                                                  sysmng_update(SYS_UPDATECFG);
Line 161  static LRESULT CALLBACK SndmixDlgProc(HW Line 162  static LRESULT CALLBACK SndmixDlgProc(HW
   
 // -------------------------------------------------------- PC-9801-14  // -------------------------------------------------------- PC-9801-14
   
 const static SLIDER_T snd14item[] = {  static const SLIDERTBL snd14item[] = {
                 {IDC_VOL14L,    IDC_VOL14LSTR,          np2cfg.vol14+0,         0,15},                  {IDC_VOL14L,    IDC_VOL14LSTR,          np2cfg.vol14+0,         0,15},
                 {IDC_VOL14R,    IDC_VOL14RSTR,          np2cfg.vol14+1,         0,15},                  {IDC_VOL14R,    IDC_VOL14RSTR,          np2cfg.vol14+1,         0,15},
                 {IDC_VOLF2,             IDC_VOLF2STR,           np2cfg.vol14+2,         0,15},                  {IDC_VOLF2,             IDC_VOLF2STR,           np2cfg.vol14+2,         0,15},
Line 193  static LRESULT CALLBACK Snd14optDlgProc( Line 194  static LRESULT CALLBACK Snd14optDlgProc(
                         break;                          break;
   
                 case WM_NOTIFY:                  case WM_NOTIFY:
                         if ((((NMHDR *)lp)->code) == PSN_APPLY) {                          if ((((NMHDR *)lp)->code) == (UINT)PSN_APPLY) {
                                 for (i=0; i<6; i++) {                                  for (i=0; i<6; i++) {
                                         if (sliderrestore(hWnd, &snd14item[i])) {                                          if (sliderrestore(hWnd, &snd14item[i])) {
                                                 sysmng_update(SYS_UPDATECFG);                                                  sysmng_update(SYS_UPDATECFG);
Line 207  static LRESULT CALLBACK Snd14optDlgProc( Line 208  static LRESULT CALLBACK Snd14optDlgProc(
         return(FALSE);          return(FALSE);
 }  }
   
 // -------------------------------------------------------- 26K, SPB jumper  
   // ---- 26K, SPB jumper
   
   static const UINT snd26paranum[4] = {0, 3, 1, 2};
   
 static void setsnd26iopara(HWND hWnd, BYTE value) {  static void setsnd26iopara(HWND hWnd, BYTE value) {
   
Line 224  static BYTE getsnd26io(HWND hWnd, WORD r Line 228  static BYTE getsnd26io(HWND hWnd, WORD r
   
 static void setsnd26intpara(HWND hWnd, BYTE value) {  static void setsnd26intpara(HWND hWnd, BYTE value) {
   
 static WPARAM paranum[4] = {(WPARAM)0, (WPARAM)3, (WPARAM)1, (WPARAM)2};          SendMessage(hWnd, CB_SETCURSEL,
                                                   (WPARAM)snd26paranum[(value >> 6) & 3], (LPARAM)0);
         SendMessage(hWnd, CB_SETCURSEL, paranum[(value >> 6) & 3], (LPARAM)0);  
 }  }
   
 static BYTE getsnd26int(HWND hWnd, WORD res) {  static BYTE getsnd26int(HWND hWnd, WORD res) {
Line 294  void setsnd26romdip(BYTE *image, int px, Line 297  void setsnd26romdip(BYTE *image, int px,
         dlgs_setjumpery(image, px + v, py, align);          dlgs_setjumpery(image, px + v, py, align);
 }  }
   
 // -------------------------------------------------------- PC-9801-26  // ---- PC-9801-26
   
 static  BYTE                    snd26 = 0;  static  BYTE                    snd26 = 0;
 static  SUBCLASSPROC    oldidc_snd26jmp = NULL;  static  SUBCLASSPROC    oldidc_snd26jmp = NULL;
Line 357  static void set26jmp(HWND hWnd, BYTE val Line 360  static void set26jmp(HWND hWnd, BYTE val
         }          }
 }  }
   
 static LRESULT CALLBACK Snd26optDlgProc(HWND hWnd, UINT msg,  static void snd26cmddipsw(HWND hWnd) {
                                                                                                         WPARAM wp, LPARAM lp) {  
         BYTE    b, bit;  
         RECT    rect1;          RECT    rect1;
         RECT    rect2;          RECT    rect2;
         POINT   p;          POINT   p;
           BYTE    b, bit;
   
           GetWindowRect(GetDlgItem(hWnd, IDC_SND26JMP), &rect1);
           GetClientRect(GetDlgItem(hWnd, IDC_SND26JMP), &rect2);
           GetCursorPos(&p);
           p.x += rect2.left - rect1.left;
           p.y += rect2.top - rect1.top;
           p.x /= 9;
           p.y /= 9;
           if ((p.y < 1) || (p.y >= 3)) {
                   return;
           }
           if ((p.x >= 2) && (p.x < 7)) {
                   b = (BYTE)(p.x - 2);
                   if ((snd26 ^ b) & 7) {
                           snd26 &= ~0x07;
                           snd26 |= b;
                           setsnd26rompara(GetDlgItem(hWnd, IDC_SND26ROM), b);
                           InvalidateRect(GetDlgItem(hWnd, IDC_SND26JMP), NULL, TRUE);
                   }
           }
           else if ((p.x >= 9) && (p.x < 12)) {
                   b = snd26;
                   bit = 0x40 << (2 - p.y);
                   switch(p.x) {
                           case 9:
                                   b |= bit;
                                   break;
   
                           case 10:
                                   b ^= bit;
                                   break;
   
                           case 11:
                                   b &= ~bit;
                                   break;
                   }
                   if (snd26 != b) {
                           snd26 = b;
                           setsnd26intpara(GetDlgItem(hWnd, IDC_SND26INT), b);
                           InvalidateRect(GetDlgItem(hWnd, IDC_SND26JMP), NULL, TRUE);
                   }
           }
           else if ((p.x >= 15) && (p.x < 17)) {
                   b = (BYTE)((p.x - 15) << 4);
                   if ((snd26 ^ b) & 0x10) {
                           snd26 &= ~0x10;
                           snd26 |= b;
                           setsnd26iopara(GetDlgItem(hWnd, IDC_SND26IO), b);
                           InvalidateRect(GetDlgItem(hWnd, IDC_SND26JMP), NULL, TRUE);
                   }
           }
   }
   
   static LRESULT CALLBACK Snd26optDlgProc(HWND hWnd, UINT msg,
                                                                                                           WPARAM wp, LPARAM lp) {
   
         switch(msg) {          switch(msg) {
                 case WM_INITDIALOG:                  case WM_INITDIALOG:
Line 384  static LRESULT CALLBACK Snd26optDlgProc( Line 442  static LRESULT CALLBACK Snd26optDlgProc(
                                 case IDC_SND26IO:                                  case IDC_SND26IO:
                                         set26jmp(hWnd, getsnd26io(hWnd, IDC_SND26IO), 0x10);                                          set26jmp(hWnd, getsnd26io(hWnd, IDC_SND26IO), 0x10);
                                         break;                                          break;
   
                                 case IDC_SND26INT:                                  case IDC_SND26INT:
                                         set26jmp(hWnd, getsnd26int(hWnd, IDC_SND26INT), 0xc0);                                          set26jmp(hWnd, getsnd26int(hWnd, IDC_SND26INT), 0xc0);
                                         break;                                          break;
   
                                 case IDC_SND26ROM:                                  case IDC_SND26ROM:
                                         set26jmp(hWnd, getsnd26rom(hWnd, IDC_SND26ROM), 0x07);                                          set26jmp(hWnd, getsnd26rom(hWnd, IDC_SND26ROM), 0x07);
                                         break;                                          break;
   
                                 case IDC_SND26DEF:                                  case IDC_SND26DEF:
                                         snd26 = 0xd1;                                          snd26 = 0xd1;
                                         setsnd26iopara(GetDlgItem(hWnd, IDC_SND26IO), snd26);                                          setsnd26iopara(GetDlgItem(hWnd, IDC_SND26IO), snd26);
Line 397  static LRESULT CALLBACK Snd26optDlgProc( Line 458  static LRESULT CALLBACK Snd26optDlgProc(
                                         setsnd26rompara(GetDlgItem(hWnd, IDC_SND26ROM), snd26);                                          setsnd26rompara(GetDlgItem(hWnd, IDC_SND26ROM), snd26);
                                         InvalidateRect(GetDlgItem(hWnd, IDC_SND26JMP), NULL, TRUE);                                          InvalidateRect(GetDlgItem(hWnd, IDC_SND26JMP), NULL, TRUE);
                                         break;                                          break;
   
                                 case IDC_SND26JMP:                                  case IDC_SND26JMP:
                                         GetWindowRect(GetDlgItem(hWnd, IDC_SND26JMP), &rect1);                                          snd26cmddipsw(hWnd);
                                         GetClientRect(GetDlgItem(hWnd, IDC_SND26JMP), &rect2);  
                                         GetCursorPos(&p);  
                                         p.x += rect2.left - rect1.left;  
                                         p.y += rect2.top - rect1.top;  
                                         p.x /= 9;  
                                         p.y /= 9;  
                                         if ((p.y < 1) || (p.y >= 3)) {  
                                                 break;  
                                         }  
                                         if ((p.x >= 2) && (p.x < 7)) {  
                                                 b = (BYTE)(p.x - 2);  
                                                 if ((snd26 ^ b) & 7) {  
                                                         snd26 &= ~0x07;  
                                                         snd26 |= b;  
                                                         setsnd26rompara(GetDlgItem(hWnd, IDC_SND26ROM),  
                                                                                                                         b);  
                                                         InvalidateRect(GetDlgItem(hWnd, IDC_SND26JMP),  
                                                                                                                         NULL, TRUE);  
                                                 }  
                                         }  
                                         else if ((p.x >= 9) && (p.x < 12)) {  
                                                 b = snd26;  
                                                 bit = 0x40 << (2 - p.y);  
                                                 switch(p.x) {  
                                                         case 9:  
                                                                 b |= bit;  
                                                                 break;  
                                                         case 10:  
                                                                 b ^= bit;  
                                                                 break;  
                                                         case 11:  
                                                                 b &= ~bit;  
                                                                 break;  
                                                 }  
                                                 if (snd26 != b) {  
                                                         snd26 = b;  
                                                         setsnd26intpara(GetDlgItem(hWnd, IDC_SND26INT),  
                                                                                                                         b);  
                                                         InvalidateRect(GetDlgItem(hWnd, IDC_SND26JMP),  
                                                                                                                         NULL, TRUE);  
                                                 }  
                                         }  
                                         else if ((p.x >= 15) && (p.x < 17)) {  
                                                 b = (BYTE)((p.x - 15) << 4);  
                                                 if ((snd26 ^ b) & 0x10) {  
                                                         snd26 &= ~0x10;  
                                                         snd26 |= b;  
                                                         setsnd26iopara(GetDlgItem(hWnd, IDC_SND26IO), b);  
                                                         InvalidateRect(GetDlgItem(hWnd, IDC_SND26JMP),  
                                                                                                                         NULL, TRUE);  
                                                 }  
                                         }  
                                         break;                                          break;
                         }                          }
                         break;                          break;
   
                 case WM_NOTIFY:                  case WM_NOTIFY:
                         if ((((NMHDR *)lp)->code) == PSN_APPLY) {                          if ((((NMHDR *)lp)->code) == (UINT)PSN_APPLY) {
                                 if (np2cfg.snd26opt != snd26) {                                  if (np2cfg.snd26opt != snd26) {
                                         np2cfg.snd26opt = snd26;                                          np2cfg.snd26opt = snd26;
                                         sysmng_update(SYS_UPDATECFG);                                          sysmng_update(SYS_UPDATECFG);
Line 468  static LRESULT CALLBACK Snd26optDlgProc( Line 478  static LRESULT CALLBACK Snd26optDlgProc(
         return(FALSE);          return(FALSE);
 }  }
   
 // ------------------------------------------------------ PC-9801-86  // ---- PC-9801-86
   
 static  BYTE                    snd86 = 0;  static  BYTE                    snd86 = 0;
 static  SUBCLASSPROC    oldidc_snd86dip = NULL;  static  SUBCLASSPROC    oldidc_snd86dip = NULL;
   
   static const UINT snd86paranum[4] = {0, 1, 3, 2};
   
 static LRESULT CALLBACK snd86jmp(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp) {  static LRESULT CALLBACK snd86jmp(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp) {
   
         PAINTSTRUCT                     ps;          PAINTSTRUCT                     ps;
Line 544  static BYTE getsnd86io(HWND hWnd, WORD r Line 556  static BYTE getsnd86io(HWND hWnd, WORD r
   
 static void setsnd86intpara(HWND hWnd, BYTE value) {  static void setsnd86intpara(HWND hWnd, BYTE value) {
   
 static WPARAM paranum[4] = {(WPARAM)0, (WPARAM)1, (WPARAM)3, (WPARAM)2};          SendMessage(hWnd, CB_SETCURSEL,
                                                   (WPARAM)snd86paranum[(value >> 2) & 3], (LPARAM)0);
         SendMessage(hWnd, CB_SETCURSEL, paranum[(value >> 2) & 3], (LPARAM)0);  
 }  }
   
 static BYTE getsnd86int(HWND hWnd) {  static BYTE getsnd86int(HWND hWnd) {
Line 557  static BYTE getsnd86int(HWND hWnd) { Line 568  static BYTE getsnd86int(HWND hWnd) {
         switch(work[3]) {          switch(work[3]) {
                 case '0':                  case '0':
                         return(0x00);                          return(0x00);
   
                 case '4':                  case '4':
                         return(0x04);                          return(0x04);
   
                 case '6':                  case '6':
                         return(0x08);                          return(0x08);
         }          }
Line 689  static LRESULT CALLBACK Snd86optDlgProc( Line 702  static LRESULT CALLBACK Snd86optDlgProc(
                         break;                          break;
   
                 case WM_NOTIFY:                  case WM_NOTIFY:
                         if ((((NMHDR *)lp)->code) == PSN_APPLY) {                          if ((((NMHDR *)lp)->code) == (UINT)PSN_APPLY) {
                                 if (np2cfg.snd86opt != snd86) {                                  if (np2cfg.snd86opt != snd86) {
                                         np2cfg.snd86opt = snd86;                                          np2cfg.snd86opt = snd86;
                                         sysmng_update(SYS_UPDATECFG);                                          sysmng_update(SYS_UPDATECFG);
Line 919  static LRESULT CALLBACK SPBoptDlgProc(HW Line 932  static LRESULT CALLBACK SPBoptDlgProc(HW
                         break;                          break;
   
                 case WM_NOTIFY:                  case WM_NOTIFY:
                         if ((((NMHDR *)lp)->code) == PSN_APPLY) {                          if ((((NMHDR *)lp)->code) == (UINT)PSN_APPLY) {
                                 update = 0;                                  update = 0;
                                 if (np2cfg.spbopt != spb) {                                  if (np2cfg.spbopt != spb) {
                                         np2cfg.spbopt = spb;                                          np2cfg.spbopt = spb;
Line 935  static LRESULT CALLBACK SPBoptDlgProc(HW Line 948  static LRESULT CALLBACK SPBoptDlgProc(HW
                                         np2cfg.spb_vrl = b;                                          np2cfg.spb_vrl = b;
                                         update |= SYS_UPDATECFG;                                          update |= SYS_UPDATECFG;
                                 }                                  }
 //                              FM_setVR(np2cfg.spb_vrc, np2cfg.spb_vrl);                                  opngen_setVR(np2cfg.spb_vrc, np2cfg.spb_vrl);
                                 b = (BYTE)(Button_GetCheck(GetDlgItem(hWnd, IDC_SPBREVERSE))?                                                                                                                                                   1:0);                                  b = (BYTE)(Button_GetCheck(GetDlgItem(hWnd, IDC_SPBREVERSE))?                                                                                                                                                   1:0);
                                 if (np2cfg.spb_x != b) {                                  if (np2cfg.spb_x != b) {
                                         np2cfg.spb_x = b;                                          np2cfg.spb_x = b;
Line 949  static LRESULT CALLBACK SPBoptDlgProc(HW Line 962  static LRESULT CALLBACK SPBoptDlgProc(HW
         return(FALSE);          return(FALSE);
 }  }
   
 // ----------------------------------------------------------- JOYPAD  
                                                                                                                                 // ver0.28  // ---- JOYPAD
   
 typedef struct {  typedef struct {
         int                     res;          UINT16  res;
         BYTE            *ptr;          UINT16  bit;
         DWORD           bit;          BYTE    *ptr;
 } CHKBTN_RES;  } CHECKTBL;
   
 const static CHKBTN_RES pad1opt[13] = {  static const CHECKTBL pad1opt[13] = {
         {IDC_JOYPAD1,   &np2oscfg.JOYPAD1,              0},                          {IDC_JOYPAD1, 0, &np2oscfg.JOYPAD1},
         {IDC_PAD1_1A,   np2oscfg.JOY1BTN + 0,   0},                          {IDC_PAD1_1A, 0, np2oscfg.JOY1BTN + 0},
         {IDC_PAD1_1B,   np2oscfg.JOY1BTN + 1,   0},                          {IDC_PAD1_1B, 0, np2oscfg.JOY1BTN + 1},
         {IDC_PAD1_1C,   np2oscfg.JOY1BTN + 2,   0},                          {IDC_PAD1_1C, 0, np2oscfg.JOY1BTN + 2},
         {IDC_PAD1_1D,   np2oscfg.JOY1BTN + 3,   0},                          {IDC_PAD1_1D, 0, np2oscfg.JOY1BTN + 3},
         {IDC_PAD1_2A,   np2oscfg.JOY1BTN + 0,   1},                          {IDC_PAD1_2A, 1, np2oscfg.JOY1BTN + 0},
         {IDC_PAD1_2B,   np2oscfg.JOY1BTN + 1,   1},                          {IDC_PAD1_2B, 1, np2oscfg.JOY1BTN + 1},
         {IDC_PAD1_2C,   np2oscfg.JOY1BTN + 2,   1},                          {IDC_PAD1_2C, 1, np2oscfg.JOY1BTN + 2},
         {IDC_PAD1_2D,   np2oscfg.JOY1BTN + 3,   1},                          {IDC_PAD1_2D, 1, np2oscfg.JOY1BTN + 3},
         {IDC_PAD1_RA,   np2oscfg.JOY1BTN + 0,   2},                          {IDC_PAD1_RA, 2, np2oscfg.JOY1BTN + 0},
         {IDC_PAD1_RB,   np2oscfg.JOY1BTN + 1,   2},                          {IDC_PAD1_RB, 2, np2oscfg.JOY1BTN + 1},
         {IDC_PAD1_RC,   np2oscfg.JOY1BTN + 2,   2},                          {IDC_PAD1_RC, 2, np2oscfg.JOY1BTN + 2},
         {IDC_PAD1_RD,   np2oscfg.JOY1BTN + 3,   2}};                          {IDC_PAD1_RD, 2, np2oscfg.JOY1BTN + 3}};
   
   
 static void checkbtnres_load(HWND hWnd, const CHKBTN_RES *item) {  static void checkbtnres_load(HWND hWnd, const CHECKTBL *item) {
   
         Button_SetCheck(GetDlgItem(hWnd, item->res),          Button_SetCheck(GetDlgItem(hWnd, item->res),
                                                                 (*(item->ptr)) & (1 << (item->bit)));                                                                  (*(item->ptr)) & (1 << (item->bit)));
 }  }
   
 static BYTE checkbtnres_store(HWND hWnd, const CHKBTN_RES *item) {  static BYTE checkbtnres_store(HWND hWnd, const CHECKTBL *item) {
   
         BYTE    value;          BYTE    value;
         BYTE    bit;          BYTE    bit;
Line 994  static BYTE checkbtnres_store(HWND hWnd, Line 1008  static BYTE checkbtnres_store(HWND hWnd,
         return(ret);          return(ret);
 }  }
   
   
 static LRESULT CALLBACK PAD1optDlgProc(HWND hWnd, UINT msg,  static LRESULT CALLBACK PAD1optDlgProc(HWND hWnd, UINT msg,
                                                                                                         WPARAM wp, LPARAM lp) {                                                                                                          WPARAM wp, LPARAM lp) {
   
Line 1012  static LRESULT CALLBACK PAD1optDlgProc(H Line 1025  static LRESULT CALLBACK PAD1optDlgProc(H
                         return(TRUE);                          return(TRUE);
   
                 case WM_NOTIFY:                  case WM_NOTIFY:
                         if ((((NMHDR *)lp)->code) == PSN_APPLY) {                          if ((((NMHDR *)lp)->code) == (UINT)PSN_APPLY) {
                                 renewal = 0;                                  renewal = 0;
                                 for (i=0; i<13; i++) {                                  for (i=0; i<13; i++) {
                                         renewal |= checkbtnres_store(hWnd, pad1opt + i);                                          renewal |= checkbtnres_store(hWnd, pad1opt + i);
Line 1029  static LRESULT CALLBACK PAD1optDlgProc(H Line 1042  static LRESULT CALLBACK PAD1optDlgProc(H
 }  }
   
   
 // --------------------------------------------------------------------------  // ----
   
 void dialog_sndopt(HWND hWnd) {  void dialog_sndopt(HWND hWnd) {
   
Line 1071  void dialog_sndopt(HWND hWnd) { Line 1084  void dialog_sndopt(HWND hWnd) {
   
         ZeroMemory(&psh, sizeof(psh));          ZeroMemory(&psh, sizeof(psh));
         psh.dwSize = sizeof(PROPSHEETHEADER);          psh.dwSize = sizeof(PROPSHEETHEADER);
         psh.dwFlags = PSH_NOAPPLYNOW;          psh.dwFlags = PSH_NOAPPLYNOW | PSH_USEHICON;
         psh.hwndParent = hWnd;          psh.hwndParent = hWnd;
         psh.hInstance = hinst;          psh.hInstance = hinst;
         psh.nPages = 6;                                                                                                 // ver0.29          psh.hIcon = LoadIcon(hinst, MAKEINTRESOURCE(IDI_ICON2));
           psh.nPages = 6;
         psh.phpage = hpsp;          psh.phpage = hpsp;
         psh.pszCaption = str_sndopt;          psh.pszCaption = str_sndopt;
         PropertySheet(&psh);          PropertySheet(&psh);
         InvalidateRect(hWndMain, NULL, TRUE);          InvalidateRect(hWnd, NULL, TRUE);
 }  }
   
   
Line 1093  static const FILESEL s98ui = {s98ui_titl Line 1107  static const FILESEL s98ui = {s98ui_titl
 void dialog_s98(HWND hWnd) {  void dialog_s98(HWND hWnd) {
   
         BOOL    check;          BOOL    check;
 const char      *p;          char    path[MAX_PATH];
   
         S98_close();          S98_close();
         check = FALSE;          check = FALSE;
         p = dlgs_selectwritenum(hWnd, &s98ui, s98ui_file,          file_cpyname(path, bmpfilefolder, sizeof(path));
                                                                         bmpfilefolder, sizeof(bmpfilefolder));          file_cutname(path);
         if ((p != NULL) && (S98_open(p) == SUCCESS)) {          file_catname(path, s98ui_file, sizeof(path));
           if ((dlgs_selectwritenum(hWnd, &s98ui, path, sizeof(path))) &&
                   (S98_open(path) == SUCCESS)) {
                   file_cpyname(bmpfilefolder, path, sizeof(bmpfilefolder));
                   sysmng_update(SYS_UPDATEOSCFG);
                 check = TRUE;                  check = TRUE;
         }          }
         xmenu_sets98logging(check);          xmenu_sets98logging(check);
Removed from v.1.1  
changed lines
  Added in v.1.7

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