[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.6 and 1.21

version 1.6, 2003/10/30 12:45:38 version 1.21, 2007/11/11 07:11:28
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
 #include        <windowsx.h>  
 #include        <commctrl.h>  #include        <commctrl.h>
 #include        <prsht.h>  #include        <prsht.h>
 #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        "joymng.h"  #include        "joymng.h"
 #include        "sysmng.h"  #include        "sysmng.h"
 #include        "menu.h"  #include        "menu.h"
   #include        "np2class.h"
 #include        "dialog.h"  #include        "dialog.h"
 #include        "dialogs.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        "s98.h"  #include        "s98.h"
   #include        "dipswbmp.h"
   
   
 static const char *sndioport[4] = {"0088", "0188", "0288", "0388"};  static const CBPARAM cpIO26[] =
 static const char *sndinterrupt[4] = {str_int0, str_int4, str_int5, str_int6};  {
 static const char *sndromaddr[5] = {"C8000", "CC000", "D0000", "D4000", "N/C"};          {MAKEINTRESOURCE(IDS_0088),             0x00},
 static const char *sndid[8] = {"0x", "1x", "2x", "3x", "4x", "5x", "6x", "7x"};          {MAKEINTRESOURCE(IDS_0188),             0x10},
   };
   
   static const CBPARAM cpIO86[] =
   {
           {MAKEINTRESOURCE(IDS_0188),             0x01},
           {MAKEINTRESOURCE(IDS_0288),             0x00},
   };
   
   static const CBPARAM cpInt26[] =
   {
           {MAKEINTRESOURCE(IDS_INT0),             0x00},
           {MAKEINTRESOURCE(IDS_INT41),    0x80},
           {MAKEINTRESOURCE(IDS_INT5),             0xc0},
           {MAKEINTRESOURCE(IDS_INT6),             0x40},
   };
   
   static const CBPARAM cpInt86[] =
   {
           {MAKEINTRESOURCE(IDS_INT0),             0x00},
           {MAKEINTRESOURCE(IDS_INT41),    0x08},
           {MAKEINTRESOURCE(IDS_INT5),             0x0c},
           {MAKEINTRESOURCE(IDS_INT6),             0x04},
   };
   
   static const TCHAR *sndinterrupt[4] =
                                                   {str_int0, str_int4, str_int5, str_int6};
   
   static const CBPARAM cpAddr[] =
   {
           {MAKEINTRESOURCE(IDS_C8000),            0x00},
           {MAKEINTRESOURCE(IDS_CC000),            0x01},
           {MAKEINTRESOURCE(IDS_D0000),            0x02},
           {MAKEINTRESOURCE(IDS_D4000),            0x03},
           {MAKEINTRESOURCE(IDS_NONCONNECT),       0x04},
   };
   
   static const CBPARAM cpID[] =
   {
           {MAKEINTRESOURCE(IDS_0X),       0xe0},
           {MAKEINTRESOURCE(IDS_1X),       0xc0},
           {MAKEINTRESOURCE(IDS_2X),       0xa0},
           {MAKEINTRESOURCE(IDS_3X),       0x80},
           {MAKEINTRESOURCE(IDS_4X),       0x60},
           {MAKEINTRESOURCE(IDS_5X),       0x40},
           {MAKEINTRESOURCE(IDS_6X),       0x20},
           {MAKEINTRESOURCE(IDS_7X),       0x00},
   };
   
 static const char str_sndopt[] = "Sound board option";  static const TCHAR str_sndopt[] = _T("Sound board option");
   
   
 typedef struct {  typedef struct {
         int             res;          UINT16  res;
         int             resstr;          UINT16  resstr;
         BYTE    *value;          UINT8   *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, UINT8 value) {
   
         char    work[32];          TCHAR   work[32];
   
         wsprintf(work, str_d, value);          wsprintf(work, tchar_d, value);
         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, UINT8 value) {
   
         if (value > (BYTE)(item->max)) {          if (value > (UINT8)item->max) {
                 value = (BYTE)(item->max);                  value = (UINT8)item->max;
         }          }
         else if (value < (BYTE)(item->min)) {          else if (value < (UINT8)item->min) {
                 value = (BYTE)(item->min);                  value = (UINT8)item->min;
         }          }
         SendDlgItemMessage(hWnd, item->res, TBM_SETPOS, TRUE, value);          SendDlgItemMessage(hWnd, item->res, TBM_SETPOS, TRUE, value);
         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;          UINT8   value;
   
         value = (BYTE)SendDlgItemMessage(hWnd, item->res, TBM_GETPOS, 0, 0);          value = (UINT8)SendDlgItemMessage(hWnd, item->res, TBM_GETPOS, 0, 0);
         if (value > (BYTE)(item->max)) {          if (value > (UINT8)item->max) {
                 value = (BYTE)(item->max);                  value = (UINT8)item->max;
         }          }
         else if (value < (BYTE)(item->min)) {          else if (value < (UINT8)item->min) {
                 value = (BYTE)(item->min);                  value = (UINT8)item->min;
         }          }
         slidersetvaluestr(hWnd, item, value);          slidersetvaluestr(hWnd, item, value);
 }  }
   
 static BYTE sliderrestore(HWND hWnd, const SLIDER_T *item) {  static UINT8 sliderrestore(HWND hWnd, const SLIDERTBL *item) {
   
         BYTE    value;          UINT8   value;
         BYTE    ret;          UINT8   ret;
   
         value = (BYTE)SendDlgItemMessage(hWnd, item->res, TBM_GETPOS, 0, 0);          value = (UINT8)SendDlgItemMessage(hWnd, item->res, TBM_GETPOS, 0, 0);
         if (value > (BYTE)(item->max)) {          if (value > (UINT8)item->max) {
                 value = (BYTE)(item->max);                  value = (UINT8)item->max;
         }          }
         else if (value < (BYTE)(item->min)) {          else if (value < (UINT8)item->min) {
                 value = (BYTE)(item->min);                  value = (UINT8)item->min;
         }          }
         ret = (*(item->value)) - value;          ret = (*(item->value)) - value;
         if (ret) {          if (ret) {
Line 95  static BYTE sliderrestore(HWND hWnd, con Line 143  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 118  static LRESULT CALLBACK SndmixDlgProc(HW Line 166  static LRESULT CALLBACK SndmixDlgProc(HW
                         return(TRUE);                          return(TRUE);
   
                 case WM_COMMAND:                  case WM_COMMAND:
                         switch (LOWORD(wp)) {                          switch(LOWORD(wp)) {
                                 case IDC_SNDMIXDEF:                                  case IDC_SNDMIXDEF:
                                         for (i=0; i<5; i++) {                                          for (i=0; i<5; i++) {
                                                 slidersetvalue(hWnd, &sndmixitem[i], 64);                                                  slidersetvalue(hWnd, &sndmixitem[i], 64);
Line 160  static LRESULT CALLBACK SndmixDlgProc(HW Line 208  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 208  static LRESULT CALLBACK Snd14optDlgProc( Line 256  static LRESULT CALLBACK Snd14optDlgProc(
         return(FALSE);          return(FALSE);
 }  }
   
 // -------------------------------------------------------- 26K, SPB jumper  
   
 static void setsnd26iopara(HWND hWnd, BYTE value) {  // ---- 26K, SPB jumper
   
         SendMessage(hWnd, CB_SETCURSEL, (WPARAM)((value >> 4) & 1), (LPARAM)0);  static void setsnd26io(HWND hWnd, UINT uID, UINT8 cValue)
   {
           dlgs_setcbcur(hWnd, uID, cValue & 0x10);
 }  }
   
 static BYTE getsnd26io(HWND hWnd, WORD res) {  static UINT8 getsnd26io(HWND hWnd, UINT uID)
   {
         char    work[8];          return dlgs_getcbcur(hWnd, uID, 0x10);
   
         GetDlgItemText(hWnd, res, work, sizeof(work));  
         return((BYTE)((work[1] == '1')?0x10:0x00));  
 }  }
   
 static void setsnd26intpara(HWND hWnd, BYTE value) {  static void setsnd26int(HWND hWnd, UINT uID, UINT8 cValue)
   {
 static WPARAM paranum[4] = {(WPARAM)0, (WPARAM)3, (WPARAM)1, (WPARAM)2};          dlgs_setcbcur(hWnd, uID, cValue & 0xc0);
   
         SendMessage(hWnd, CB_SETCURSEL, paranum[(value >> 6) & 3], (LPARAM)0);  
 }  }
   
 static BYTE getsnd26int(HWND hWnd, WORD res) {  static UINT8 getsnd26int(HWND hWnd, UINT uID)
   {
         char    work[8];          return dlgs_getcbcur(hWnd, uID, 0xc0);
   
         GetDlgItemText(hWnd, res, work, sizeof(work));  
         switch(work[3]) {  
                 case '0':  
                         return(0x00);  
   
                 case '4':  
                         return(0x80);  
   
                 case '6':  
                         return(0x40);  
         }  
         return(0xc0);  
 }  }
   
 static void setsnd26rompara(HWND hWnd, BYTE value) {  static void setsnd26rom(HWND hWnd, UINT uID, UINT8 cValue)
   {
           UINT    uParam;
   
         int             para;          uParam = cValue & 0x07;
           uParam = min(uParam, 0x04);
         para = value & 7;          dlgs_setcbcur(hWnd, uID, uParam);
         if (para > 4) {  
                 para = 4;  
         }  
         SendMessage(hWnd, CB_SETCURSEL, (WPARAM)para, (LPARAM)0);  
 }  }
   
 static BYTE getsnd26rom(HWND hWnd, WORD res) {  static UINT8 getsnd26rom(HWND hWnd, UINT uID)
   {
         char    work[8];          return dlgs_getcbcur(hWnd, uID, 0x04);
         DWORD   adrs;  
   
         GetDlgItemText(hWnd, res, work, sizeof(work));  
         adrs = ((DWORD)milstr_solveHEX(work) - 0xc8000) >> 14;  
         if (adrs < 4) {  
                 return((BYTE)adrs);  
         }  
         return(4);  
 }  }
   
 void setsnd26iodip(BYTE *image, int px, int py, int align, BYTE v) {  
   
         if (v & 0x10) {  // ---- PC-9801-26
                 px++;  
         }  
         dlgs_setjumpery(image, px, py, align);  
 }  
   
 void setsnd26intdip(BYTE *image, int px, int py, int align, BYTE v) {  static  UINT8   snd26 = 0;
   
         dlgs_setjumperx(image, px + ((v & 0x80)?0:1), py, align);  static void snd26set(HWND hWnd, UINT8 cValue)
         dlgs_setjumperx(image, px + ((v & 0x40)?0:1), py + 1, align);  {
           setsnd26io(hWnd, IDC_SND26IO, cValue);
           setsnd26int(hWnd, IDC_SND26INT, cValue);
           setsnd26rom(hWnd, IDC_SND26ROM, cValue);
 }  }
   
 void setsnd26romdip(BYTE *image, int px, int py, int align, BYTE v) {  static void set26jmp(HWND hWnd, UINT8 value, UINT8 bit) {
   
         v &= 7;          if ((snd26 ^ value) & bit) {
         if (v >= 4) {                  snd26 &= ~bit;
                 v = 4;                  snd26 |= value;
                   InvalidateRect(GetDlgItem(hWnd, IDC_SND26JMP), NULL, TRUE);
         }          }
         dlgs_setjumpery(image, px + v, py, align);  
 }  }
   
 // -------------------------------------------------------- PC-9801-26  static void snd26cmdjmp(HWND hWnd) {
   
 static  BYTE                    snd26 = 0;  
 static  SUBCLASSPROC    oldidc_snd26jmp = NULL;  
   
 static LRESULT CALLBACK Snd26jmp(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp) {  
   
         PAINTSTRUCT                     ps;          RECT    rect1;
         HDC                                     hdc;          RECT    rect2;
         HBITMAP                         hBitmap;          POINT   p;
         HDC                                     hMemDC;          BOOL    redraw;
         BYTE                            *image;          UINT8   b;
         HANDLE                          hwork;          UINT8   bit;
         BITMAPINFO                      *work;  
         BYTE                            *imgbtm;          GetWindowRect(GetDlgItem(hWnd, IDC_SND26JMP), &rect1);
         int                                     align;          GetClientRect(GetDlgItem(hWnd, IDC_SND26JMP), &rect2);
           GetCursorPos(&p);
           redraw = FALSE;
           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 = (UINT8)(p.x - 2);
                   if ((snd26 ^ b) & 7) {
                           snd26 &= ~0x07;
                           snd26 |= b;
                           setsnd26rom(hWnd, IDC_SND26ROM, b);
                           redraw = TRUE;
                   }
           }
           else if ((p.x >= 9) && (p.x < 12)) {
                   b = snd26;
                   bit = 0x40 << (2 - p.y);
                   switch(p.x) {
                           case 9:
                                   b |= bit;
                                   break;
   
         switch(msg) {                          case 10:
                 case WM_PAINT:                                  b ^= bit;
                         hdc = BeginPaint(hWnd, &ps);  
                         if ((hwork = GlobalAlloc(GPTR, bit2res_getsize(&snd26dip)))  
                                                                                                                                 == NULL) {  
                                 break;                                  break;
                         }  
                         if ((work = (BITMAPINFO *)GlobalLock(hwork)) == NULL) {                          case 11:
                                 GlobalFree(hwork);                                  b &= ~bit;
                                 break;                                  break;
                         }                  }
                         bit2res_sethead(work, &snd26dip);                  if (snd26 != b) {
                         hBitmap = CreateDIBSection(hdc, work, DIB_RGB_COLORS,                          snd26 = b;
                                                                                                 (void **)&image, NULL, 0);                          setsnd26int(hWnd, IDC_SND26INT, b);
                         bit2res_setdata(image, &snd26dip);                          redraw = TRUE;
                         align = ((snd26dip.x + 7) / 2) & ~3;                  }
                         imgbtm = image + align * (snd26dip.y - 1);          }
                         setsnd26iodip(imgbtm, 15, 1, align, snd26);          else if ((p.x >= 15) && (p.x < 17)) {
                         setsnd26intdip(imgbtm, 9, 1, align, snd26);                  b = (UINT8)((p.x - 15) << 4);
                         setsnd26romdip(imgbtm, 2, 1, align, snd26);                  if ((snd26 ^ b) & 0x10) {
                         if ((hMemDC = CreateCompatibleDC(hdc)) != NULL) {                          snd26 &= ~0x10;
                                 SelectObject(hMemDC, hBitmap);                          snd26 |= b;
                                 StretchBlt(hdc, 0, 0, snd26dip.x, snd26dip.y, hMemDC,                          setsnd26io(hWnd, IDC_SND26IO, b);
                                                                         0, 0, snd26dip.x, snd26dip.y, SRCCOPY);                          redraw = TRUE;
                                 DeleteDC(hMemDC);                  }
                         }  
                         DeleteObject(hBitmap);  
                         EndPaint(hWnd, &ps);  
                         GlobalUnlock(hwork);  
                         GlobalFree(hwork);  
                         break;  
                 default:  
                         return(CallWindowProc(oldidc_snd26jmp, hWnd, msg, wp, lp));  
         }          }
         return(FALSE);          if (redraw) {
 }  
   
 static void set26jmp(HWND hWnd, BYTE value, BYTE bit) {  
   
         if ((snd26 ^ value) & bit) {  
                 snd26 &= ~bit;  
                 snd26 |= value;  
                 InvalidateRect(GetDlgItem(hWnd, IDC_SND26JMP), NULL, TRUE);                  InvalidateRect(GetDlgItem(hWnd, IDC_SND26JMP), NULL, TRUE);
         }          }
 }  }
   
 static LRESULT CALLBACK Snd26optDlgProc(HWND hWnd, UINT msg,  static LRESULT CALLBACK Snd26optDlgProc(HWND hWnd, UINT msg,
                                                                                                         WPARAM wp, LPARAM lp) {                                                                                                          WPARAM wp, LPARAM lp) {
         BYTE    b, bit;  
         RECT    rect1;          HWND    sub;
         RECT    rect2;  
         POINT   p;  
   
         switch(msg) {          switch(msg) {
                 case WM_INITDIALOG:                  case WM_INITDIALOG:
                         snd26 = np2cfg.snd26opt;                          snd26 = np2cfg.snd26opt;
                         SETnLISTSTR(hWnd, IDC_SND26IO, sndioport, 2);                          dlgs_setcbitem(hWnd, IDC_SND26IO, cpIO26, NELEMENTS(cpIO26));
                         setsnd26iopara(GetDlgItem(hWnd, IDC_SND26IO), snd26);                          dlgs_setcbitem(hWnd, IDC_SND26INT, cpInt26, NELEMENTS(cpInt26));
                         SETLISTSTR(hWnd, IDC_SND26INT, sndinterrupt);                          dlgs_setcbitem(hWnd, IDC_SND26ROM, cpAddr, NELEMENTS(cpAddr));
                         setsnd26intpara(GetDlgItem(hWnd, IDC_SND26INT), snd26);                          snd26set(hWnd, snd26);
                         SETLISTSTR(hWnd, IDC_SND26ROM, sndromaddr);                          sub = GetDlgItem(hWnd, IDC_SND26JMP);
                         setsnd26rompara(GetDlgItem(hWnd, IDC_SND26ROM), snd26);                          SetWindowLong(sub, GWL_STYLE, SS_OWNERDRAW +
                         oldidc_snd26jmp = (SUBCLASSPROC)GetWindowLong(GetDlgItem(hWnd,                                                          (GetWindowLong(sub, GWL_STYLE) & (~SS_TYPEMASK)));
                                                                                                 IDC_SND26JMP), GWL_WNDPROC);  
                         SetWindowLong(GetDlgItem(hWnd, IDC_SND26JMP), GWL_WNDPROC,  
                                                                                                         (LONG)Snd26jmp);  
                         return(TRUE);                          return(TRUE);
   
                 case WM_COMMAND:                  case WM_COMMAND:
                         switch (LOWORD(wp)) {                          switch(LOWORD(wp)) {
                                 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);                                          snd26set(hWnd, snd26);
                                         setsnd26intpara(GetDlgItem(hWnd, IDC_SND26INT), 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);                                          snd26cmdjmp(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;
Line 465  static LRESULT CALLBACK Snd26optDlgProc( Line 431  static LRESULT CALLBACK Snd26optDlgProc(
                                 return(TRUE);                                  return(TRUE);
                         }                          }
                         break;                          break;
         }  
         return(FALSE);  
 }  
   
 // ------------------------------------------------------ PC-9801-86                  case WM_DRAWITEM:
                           if (LOWORD(wp) == IDC_SND26JMP) {
 static  BYTE                    snd86 = 0;                                  dlgs_drawbmp(((LPDRAWITEMSTRUCT)lp)->hDC,
 static  SUBCLASSPROC    oldidc_snd86dip = NULL;                                                                                                  dipswbmp_getsnd26(snd26));
   
 static LRESULT CALLBACK snd86jmp(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp) {  
   
         PAINTSTRUCT                     ps;  
         HDC                                     hdc;  
         HBITMAP                         hBitmap;  
         HDC                                     hMemDC;  
         BYTE                            *image;  
         HANDLE                          hwork;  
         BITMAPINFO                      *work;  
         BYTE                            *imgbtm;  
         int                                     align;  
         int                                     i;  
         int                                     x, y, yl;  
   
         switch(msg) {  
                 case WM_PAINT:  
                         hdc = BeginPaint(hWnd, &ps);  
                         if ((hwork = GlobalAlloc(GPTR, bit2res_getsize(&snd86dip)))  
                                                                                                                                 == NULL) {  
                                 break;  
                         }  
                         if ((work = (BITMAPINFO *)GlobalLock(hwork)) == NULL) {  
                                 GlobalFree(hwork);  
                                 break;  
                         }  
                         bit2res_sethead(work, &snd86dip);  
                         hBitmap = CreateDIBSection(hdc, work, DIB_RGB_COLORS,  
                                                                                                 (void **)&image, NULL, 0);  
                         bit2res_setdata(image, &snd86dip);  
                         align = ((snd86dip.x + 7) / 2) & ~3;  
                         imgbtm = image + align * (snd86dip.y - 1);  
                         for (i=0; i<8; i++) {  
                                 x = i * 8 + 17;  
                                 y = ((snd86&(1<<i))?16:9);  
                                 for (yl=0; yl<7; yl++) {  
                                         dlgs_linex(imgbtm, x, y++, 6, align, 3);  
                                 }  
                         }                          }
                         if ((hMemDC = CreateCompatibleDC(hdc)) != NULL) {  
                                 SelectObject(hMemDC, hBitmap);  
                                 StretchBlt(hdc, 0, 0, snd86dip.x, snd86dip.y, hMemDC,  
                                                                         0, 0, snd86dip.x, snd86dip.y, SRCCOPY);  
                                 DeleteDC(hMemDC);  
                         }  
                         DeleteObject(hBitmap);  
                         EndPaint(hWnd, &ps);  
                         GlobalUnlock(hwork);  
                         GlobalFree(hwork);  
                         break;                          break;
                 default:  
                         return(CallWindowProc(oldidc_snd86dip, hWnd, msg, wp, lp));  
         }          }
         return(FALSE);          return(FALSE);
 }  }
   
   
 static void setsnd86iopara(HWND hWnd, BYTE value) {  // ---- PC-9801-86
   
         SendMessage(hWnd, CB_SETCURSEL, (WPARAM)((~value) & 1), (LPARAM)0);  
 }  
   
 static BYTE getsnd86io(HWND hWnd, WORD res) {  static  UINT8   snd86 = 0;
   
         char    work[8];  static void setsnd86io(HWND hWnd, UINT uID, UINT8 cValue)
   {
           dlgs_setcbcur(hWnd, uID, cValue & 0x01);
   }
   
         GetDlgItemText(hWnd, res, work, sizeof(work));  static UINT8 getsnd86io(HWND hWnd, UINT uID)
         return((BYTE)((work[1] == '1')?0x01:0x00));  {
           return dlgs_getcbcur(hWnd, uID, 0x01);
 }  }
   
 static void setsnd86intpara(HWND hWnd, BYTE value) {  static void setsnd86int(HWND hWnd, UINT uID, UINT8 cValue)
   {
           dlgs_setcbcur(hWnd, uID, cValue & 0x0c);
   }
   
 static WPARAM paranum[4] = {(WPARAM)0, (WPARAM)1, (WPARAM)3, (WPARAM)2};  static UINT8 getsnd86int(HWND hWnd, INT uID)
   {
           return dlgs_getcbcur(hWnd, uID, 0x0c);
   }
   
         SendMessage(hWnd, CB_SETCURSEL, paranum[(value >> 2) & 3], (LPARAM)0);  static void setsnd86id(HWND hWnd, UINT uID, UINT8 cValue)
   {
           dlgs_setcbcur(hWnd, uID, cValue & 0xe0);
 }  }
   
 static BYTE getsnd86int(HWND hWnd) {  static UINT8 getsnd86id(HWND hWnd, UINT uID)
   {
           return dlgs_getcbcur(hWnd, uID, 0x00);
   }
   
         char    work[8];  static void set86jmp(HWND hWnd, UINT8 value, UINT8 bit) {
   
         Edit_GetText(hWnd, work, sizeof(work));          if ((snd86 ^ value) & bit) {
         switch(work[3]) {                  snd86 &= ~bit;
                 case '0':                  snd86 |= value;
                         return(0x00);                  InvalidateRect(GetDlgItem(hWnd, IDC_SND86DIP), NULL, TRUE);
                 case '4':  
                         return(0x04);  
                 case '6':  
                         return(0x08);  
         }          }
         return(0x0c);  
 }  }
   
 static void setsnd86idpara(HWND hWnd, BYTE value) {  static void snd86cmddipsw(HWND hWnd) {
   
         SendMessage(hWnd, CB_SETCURSEL, (WPARAM)(((~value) >> 5) & 7), (LPARAM)0);          RECT    rect1;
 }          RECT    rect2;
           POINT   p;
   
 static BYTE getsnd86id(HWND hWnd) {          GetWindowRect(GetDlgItem(hWnd, IDC_SND86DIP), &rect1);
           GetClientRect(GetDlgItem(hWnd, IDC_SND86DIP), &rect2);
           GetCursorPos(&p);
           p.x += rect2.left - rect1.left;
           p.y += rect2.top - rect1.top;
           p.x /= 8;
           p.y /= 8;
           if ((p.x < 2) || (p.x >= 10) ||
                   (p.y < 1) || (p.y >= 3)) {
                   return;
           }
           p.x -= 2;
           snd86 ^= (1 << p.x);
           switch(p.x) {
                   case 0:
                           setsnd86io(hWnd, IDC_SND86IO, snd86);
                           break;
   
         char    work[8];                  case 1:
                           SetDlgItemCheck(hWnd, IDC_SND86ROM, snd86 & 2);
                           break;
   
         Edit_GetText(hWnd, work, sizeof(work));                  case 2:
         return((~work[0] & 7) << 5);                  case 3:
 }                          setsnd86int(hWnd, IDC_SND86INTA, snd86);
                           break;
   
 static void set86jmp(HWND hWnd, BYTE value, BYTE bit) {                  case 4:
                           SetDlgItemCheck(hWnd, IDC_SND86INT, snd86 & 0x10);
                           break;
   
         if ((snd86 ^ value) & bit) {                  case 5:
                 snd86 &= ~bit;                  case 6:
                 snd86 |= value;                  case 7:
                 InvalidateRect(GetDlgItem(hWnd, IDC_SND86DIP), NULL, TRUE);                          setsnd86id(hWnd, IDC_SND86ID, snd86);
                           break;
         }          }
           InvalidateRect(GetDlgItem(hWnd, IDC_SND86DIP), NULL, TRUE);
 }  }
   
 static LRESULT CALLBACK Snd86optDlgProc(HWND hWnd, UINT msg,  static LRESULT CALLBACK Snd86optDlgProc(HWND hWnd, UINT msg,
                                                                                                         WPARAM wp, LPARAM lp) {                                                                                                          WPARAM wp, LPARAM lp) {
   
         RECT    rect1;          HWND    sub;
         RECT    rect2;  
         POINT   p;  
   
         switch(msg) {          switch(msg) {
                 case WM_INITDIALOG:                  case WM_INITDIALOG:
                         snd86 = np2cfg.snd86opt;                          snd86 = np2cfg.snd86opt;
                         SETnLISTSTR(hWnd, IDC_SND86IO, sndioport+1, 2);                          dlgs_setcbitem(hWnd, IDC_SND86IO, cpIO86, NELEMENTS(cpIO86));
                         setsnd86iopara(GetDlgItem(hWnd, IDC_SND86IO), snd86);                          setsnd86io(hWnd, IDC_SND86IO, snd86);
                         Button_SetCheck(GetDlgItem(hWnd, IDC_SND86INT), snd86 & 0x10);                          SetDlgItemCheck(hWnd, IDC_SND86INT, snd86 & 0x10);
                         SETLISTSTR(hWnd, IDC_SND86INTA, sndinterrupt);                          dlgs_setcbitem(hWnd, IDC_SND86INTA, cpInt86, NELEMENTS(cpInt86));
                         setsnd86intpara(GetDlgItem(hWnd, IDC_SND86INTA), snd86);                          setsnd86int(hWnd, IDC_SND86INTA, snd86);
                         SETLISTSTR(hWnd, IDC_SND86ID, sndid);                          dlgs_setcbitem(hWnd, IDC_SND86ID, cpID, NELEMENTS(cpID));
                         setsnd86idpara(GetDlgItem(hWnd, IDC_SND86ID), snd86);                          setsnd86id(hWnd, IDC_SND86ID, snd86);
                         Button_SetCheck(GetDlgItem(hWnd, IDC_SND86ROM), snd86 & 2);                          SetDlgItemCheck(hWnd, IDC_SND86ROM, snd86 & 2);
                         oldidc_snd86dip = (SUBCLASSPROC)GetWindowLong(GetDlgItem(hWnd,  
                                                                                                 IDC_SND86DIP), GWL_WNDPROC);                          sub = GetDlgItem(hWnd, IDC_SND86DIP);
                         SetWindowLong(GetDlgItem(hWnd, IDC_SND86DIP), GWL_WNDPROC,                          SetWindowLong(sub, GWL_STYLE, SS_OWNERDRAW +
                                                                                                         (LONG)snd86jmp);                                                          (GetWindowLong(sub, GWL_STYLE) & (~SS_TYPEMASK)));
                         return(TRUE);                          return(TRUE);
   
                 case WM_COMMAND:                  case WM_COMMAND:
                         switch (LOWORD(wp)) {                          switch(LOWORD(wp)) {
                                 case IDC_SND86IO:                                  case IDC_SND86IO:
                                         set86jmp(hWnd, getsnd86io(hWnd, IDC_SND86IO), 0x01);                                          set86jmp(hWnd, getsnd86io(hWnd, IDC_SND86IO), 0x01);
                                         break;                                          break;
   
                                 case IDC_SND86INT:                                  case IDC_SND86INT:
                                         set86jmp(hWnd,                                          set86jmp(hWnd,
                                                 ((Button_GetCheck(GetDlgItem(hWnd, IDC_SND86INT)))                                                          (GetDlgItemCheck(hWnd, IDC_SND86INT))?0x10:0x00,
                                                                                                                 ?0x10:0x00), 0x10);                                                                                                                                                  0x10);
                                         break;                                          break;
   
                                 case IDC_SND86INTA:                                  case IDC_SND86INTA:
                                         set86jmp(hWnd,                                          set86jmp(hWnd, getsnd86int(hWnd, IDC_SND86INTA), 0x0c);
                                                 getsnd86int(GetDlgItem(hWnd, IDC_SND86INTA)), 0x0c);  
                                         break;                                          break;
   
                                 case IDC_SND86ROM:                                  case IDC_SND86ROM:
                                         set86jmp(hWnd,                                          set86jmp(hWnd,
                                                 ((Button_GetCheck(GetDlgItem(hWnd, IDC_SND86ROM)))                                                          (GetDlgItemCheck(hWnd, IDC_SND86ROM))?0x02:0x00,
                                                                                                                 ?0x02:0x00), 0x02);                                                                                                                                                  0x02);
                                         break;                                          break;
   
                                 case IDC_SND86ID:                                  case IDC_SND86ID:
                                         set86jmp(hWnd,                                          set86jmp(hWnd, getsnd86id(hWnd, IDC_SND86ID), 0xe0);
                                                 getsnd86id(GetDlgItem(hWnd, IDC_SND86ID)), 0xe0);  
                                         break;                                          break;
   
                                 case IDC_SND86DEF:                                  case IDC_SND86DEF:
                                         snd86 = 0x7f;                                          snd86 = 0x7f;
                                         setsnd86iopara(GetDlgItem(hWnd, IDC_SND86IO), snd86);                                          setsnd86io(hWnd, IDC_SND86IO, snd86);
                                         Button_SetCheck(GetDlgItem(hWnd, IDC_SND86INT), TRUE);                                          SetDlgItemCheck(hWnd, IDC_SND86INT, TRUE);
                                         setsnd86intpara(GetDlgItem(hWnd, IDC_SND86INTA), snd86);                                          setsnd86int(hWnd, IDC_SND86INTA, snd86);
                                         setsnd86idpara(GetDlgItem(hWnd, IDC_SND86ID), snd86);                                          setsnd86id(hWnd, IDC_SND86ID, snd86);
                                         Button_SetCheck(GetDlgItem(hWnd, IDC_SND86ROM), TRUE);                                          SetDlgItemCheck(hWnd, IDC_SND86ROM, TRUE);
                                         InvalidateRect(GetDlgItem(hWnd, IDC_SND86DIP), NULL, TRUE);                                          InvalidateRect(GetDlgItem(hWnd, IDC_SND86DIP), NULL, TRUE);
                                         break;                                          break;
   
                                 case IDC_SND86DIP:                                  case IDC_SND86DIP:
                                         GetWindowRect(GetDlgItem(hWnd, IDC_SND86DIP), &rect1);                                          snd86cmddipsw(hWnd);
                                         GetClientRect(GetDlgItem(hWnd, IDC_SND86DIP), &rect2);  
                                         GetCursorPos(&p);  
                                         p.x += rect2.left - rect1.left;  
                                         p.y += rect2.top - rect1.top;  
                                         p.x /= 8;  
                                         p.y /= 8;  
                                         if ((p.x < 2) || (p.x >= 10) ||  
                                                 (p.y < 1) || (p.y >= 3)) {  
                                                 break;  
                                         }  
                                         p.x -= 2;  
                                         snd86 ^= (1 << p.x);  
                                         switch(p.x) {  
                                                 case 0:  
                                                         setsnd86iopara(GetDlgItem(hWnd, IDC_SND86IO),  
                                                                                                                                 snd86);  
                                                         break;  
                                                 case 1:  
                                                         Button_SetCheck(GetDlgItem(hWnd, IDC_SND86ROM),  
                                                                                                                                 snd86 & 2);  
                                                         break;  
                                                 case 2:  
                                                 case 3:  
                                                         setsnd86intpara(GetDlgItem(hWnd, IDC_SND86INTA),  
                                                                                                                                 snd86);  
                                                         break;  
                                                 case 4:  
                                                         Button_SetCheck(GetDlgItem(hWnd, IDC_SND86INT),  
                                                                                                                                 snd86 & 0x10);  
                                                         break;  
                                                 case 5:  
                                                 case 6:  
                                                 case 7:  
                                                         setsnd86idpara(GetDlgItem(hWnd, IDC_SND86ID),  
                                                                                                                                 snd86);  
                                                         break;  
                                         }  
                                         InvalidateRect(GetDlgItem(hWnd, IDC_SND86DIP),  
                                                                                                                                 NULL, TRUE);  
                                         break;                                          break;
                         }                          }
                         break;                          break;
Line 698  static LRESULT CALLBACK Snd86optDlgProc( Line 605  static LRESULT CALLBACK Snd86optDlgProc(
                                 return(TRUE);                                  return(TRUE);
                         }                          }
                         break;                          break;
   
                   case WM_DRAWITEM:
                           if (LOWORD(wp) == IDC_SND86DIP) {
                                   dlgs_drawbmp(((LPDRAWITEMSTRUCT)lp)->hDC,
                                                                                                   dipswbmp_getsnd86(snd86));
                           }
                           return(FALSE);
         }          }
         return(FALSE);          return(FALSE);
 }  }
   
 // ------------------------------------------------------ Speak board  
   
 static  BYTE                    spb = 0;  // ---- Speak board
 static  BYTE                    spbvrc = 0;  
 static  SUBCLASSPROC    oldidc_spbjmp = NULL;  
   
   
 static LRESULT CALLBACK spbjmp(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp) {  
   
         PAINTSTRUCT                     ps;  
         HDC                                     hdc;  
         HBITMAP                         hBitmap;  
         HDC                                     hMemDC;  
         BYTE                            *image;  
         HANDLE                          hwork;  
         BITMAPINFO                      *work;  
         BYTE                            *imgbtm;  
         int                                     align;  
   
         switch(msg) {  static  UINT8   spb = 0;
                 case WM_PAINT:  static  UINT8   spbvrc = 0;
                         hdc = BeginPaint(hWnd, &ps);  
                         if ((hwork = GlobalAlloc(GPTR, bit2res_getsize(&spbdip)))  static void setspbVRch(HWND hWnd) {
                                                                                                                                 == NULL) {  
           SetDlgItemCheck(hWnd, IDC_SPBVRL, spbvrc & 1);
           SetDlgItemCheck(hWnd, IDC_SPBVRR, spbvrc & 2);
   }
   
   static void spbcreate(HWND hWnd)
   {
           HWND    sub;
   
           spb = np2cfg.spbopt;
   
           dlgs_setcbitem(hWnd, IDC_SPBIO, cpIO26, NELEMENTS(cpIO26));
           setsnd26io(hWnd, IDC_SPBIO, spb);
           dlgs_setcbitem(hWnd, IDC_SPBINT, cpInt26, NELEMENTS(cpInt26));
           setsnd26int(hWnd, IDC_SPBINT, spb);
           dlgs_setcbitem(hWnd, IDC_SPBROM, cpAddr, NELEMENTS(cpAddr));
           setsnd26rom(hWnd, IDC_SPBROM, spb);
           spbvrc = np2cfg.spb_vrc;                                                                // ver0.30
           setspbVRch(hWnd);
           SendDlgItemMessage(hWnd, IDC_SPBVRLEVEL, TBM_SETRANGE, TRUE,
                                                                                                                           MAKELONG(0, 24));
           SendDlgItemMessage(hWnd, IDC_SPBVRLEVEL, TBM_SETPOS, TRUE,
                                                                                                                           np2cfg.spb_vrl);
           SetDlgItemCheck(hWnd, IDC_SPBREVERSE, np2cfg.spb_x);
   
           sub = GetDlgItem(hWnd, IDC_SPBJMP);
           SetWindowLong(sub, GWL_STYLE, SS_OWNERDRAW +
                                                           (GetWindowLong(sub, GWL_STYLE) & (~SS_TYPEMASK)));
   }
   
   static void spbcmdjmp(HWND hWnd) {
   
           RECT    rect1;
           RECT    rect2;
           POINT   p;
           BOOL    redraw;
           UINT8   b;
           UINT8   bit;
   
           GetWindowRect(GetDlgItem(hWnd, IDC_SPBJMP), &rect1);
           GetClientRect(GetDlgItem(hWnd, IDC_SPBJMP), &rect2);
           GetCursorPos(&p);
           redraw = FALSE;
           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 < 5)) {
                   b = spb;
                   bit = 0x40 << (2 - p.y);
                   switch(p.x) {
                           case 2:
                                   b |= bit;
                                 break;                                  break;
                         }  
                         if ((work = (BITMAPINFO *)GlobalLock(hwork)) == NULL) {                          case 3:
                                 GlobalFree(hwork);                                  b ^= bit;
                                 break;                                  break;
                         }  
                         bit2res_sethead(work, &spbdip);                          case 4:
                         hBitmap = CreateDIBSection(hdc, work, DIB_RGB_COLORS,                                  b &= ~bit;
                                                                                                 (void **)&image, NULL, 0);                                  break;
                         bit2res_setdata(image, &spbdip);                  }
                         align = ((spbdip.x + 7) / 2) & ~3;                  if (spb != b) {
                         imgbtm = image + align * (spbdip.y - 1);                          spb = b;
                         setsnd26intdip(imgbtm, 2, 1, align, spb);                          setsnd26int(hWnd, IDC_SPBINT, b);
                         setsnd26iodip(imgbtm, 10, 1, align, spb);                          redraw = TRUE;
                         setsnd26romdip(imgbtm, 14, 1, align, spb);                  }
                         if (spb & 0x20) {          }
                                 dlgs_setjumpery(imgbtm, 7, 1, align);          else if (p.x == 7) {
                         }                  spb ^= 0x20;
                         dlgs_setjumperx(imgbtm, ((spbvrc&2)?21:22), 1, align);                  redraw = TRUE;
                         dlgs_setjumperx(imgbtm, ((spbvrc&1)?21:22), 2, align);          }
                         if ((hMemDC = CreateCompatibleDC(hdc)) != NULL) {          else if ((p.x >= 10) && (p.x < 12)) {
                                 SelectObject(hMemDC, hBitmap);                  b = (UINT8)((p.x - 10) << 4);
                                 StretchBlt(hdc, 0, 0, spbdip.x, spbdip.y, hMemDC,                  if ((spb ^ b) & 0x10) {
                                                                         0, 0, spbdip.x, spbdip.y, SRCCOPY);                          spb &= ~0x10;
                                 DeleteDC(hMemDC);                          spb |= b;
                         }                          setsnd26io(hWnd, IDC_SPBIO, b);
                         DeleteObject(hBitmap);                          redraw = TRUE;
                         EndPaint(hWnd, &ps);                  }
                         GlobalUnlock(hwork);          }
                         GlobalFree(hwork);          else if ((p.x >= 14) && (p.x < 19)) {
                         break;                  b = (UINT8)(p.x - 14);
                 default:                  if ((spb ^ b) & 7) {
                         return(CallWindowProc(oldidc_spbjmp, hWnd, msg, wp, lp));                          spb &= ~0x07;
                           spb |= b;
                           setsnd26rom(hWnd, IDC_SPBROM, b);
                           redraw = TRUE;
                   }
           }
           else if ((p.x >= 21) && (p.x < 24)) {
                   spbvrc ^= (UINT8)(3 - p.y);
                   setspbVRch(hWnd);
                   redraw = TRUE;
           }
           if (redraw) {
                   InvalidateRect(GetDlgItem(hWnd, IDC_SPBJMP), NULL, TRUE);
         }          }
         return(FALSE);  
 }  }
   
 static void setspbjmp(HWND hWnd, BYTE value, BYTE bit) {  static void setspbjmp(HWND hWnd, UINT8 value, UINT8 bit) {
   
         if ((spb ^ value) & bit) {          if ((spb ^ value) & bit) {
                 spb &= ~bit;                  spb &= ~bit;
Line 772  static void setspbjmp(HWND hWnd, BYTE va Line 736  static void setspbjmp(HWND hWnd, BYTE va
         }          }
 }  }
   
 static void setspbVRch(HWND hWnd) {  static UINT8 getspbVRch(HWND hWnd) {
   
         Button_SetCheck(GetDlgItem(hWnd, IDC_SPBVRL), spbvrc & 1);  
         Button_SetCheck(GetDlgItem(hWnd, IDC_SPBVRR), spbvrc & 2);  
 }  
   
 static BYTE getspbVRch(HWND hWnd) {          UINT8   ret;
   
         BYTE    ret = 0;          ret = 0;
           if (GetDlgItemCheck(hWnd, IDC_SPBVRL)) {
         if (Button_GetCheck(GetDlgItem(hWnd, IDC_SPBVRL))) {                  ret += 1;
                 ret++;  
         }          }
         if (Button_GetCheck(GetDlgItem(hWnd, IDC_SPBVRR))) {          if (GetDlgItemCheck(hWnd, IDC_SPBVRR)) {
                 ret += 2;                  ret += 2;
         }          }
         return(ret);          return(ret);
 }  }
   
   
 static LRESULT CALLBACK SPBoptDlgProc(HWND hWnd, UINT msg,  static LRESULT CALLBACK SPBoptDlgProc(HWND hWnd, UINT msg,
                                                                                                         WPARAM wp, LPARAM lp) {                                                                                                          WPARAM wp, LPARAM lp) {
         BYTE    b, bit;          UINT8   b;
         RECT    rect1;  
         RECT    rect2;  
         POINT   p;  
         UINT    update;          UINT    update;
   
         switch(msg) {          switch(msg) {
                 case WM_INITDIALOG:                  case WM_INITDIALOG:
                         spb = np2cfg.spbopt;                          spbcreate(hWnd);
                         SETnLISTSTR(hWnd, IDC_SPBIO, sndioport, 2);  
                         setsnd26iopara(GetDlgItem(hWnd, IDC_SPBIO), spb);  
                         SETLISTSTR(hWnd, IDC_SPBINT, sndinterrupt);  
                         setsnd26intpara(GetDlgItem(hWnd, IDC_SPBINT), spb);  
                         SETLISTSTR(hWnd, IDC_SPBROM, sndromaddr);  
                         setsnd26rompara(GetDlgItem(hWnd, IDC_SPBROM), spb);  
                         spbvrc = np2cfg.spb_vrc;                                                                // ver0.30  
                         setspbVRch(hWnd);  
                         SendDlgItemMessage(hWnd, IDC_SPBVRLEVEL, TBM_SETRANGE, TRUE,  
                                                                                                                         MAKELONG(0, 24));  
                         SendDlgItemMessage(hWnd, IDC_SPBVRLEVEL, TBM_SETPOS, TRUE,  
                                                                                                                         np2cfg.spb_vrl);  
                         Button_SetCheck(GetDlgItem(hWnd, IDC_SPBREVERSE), np2cfg.spb_x);  
   
                         oldidc_spbjmp = (SUBCLASSPROC)GetWindowLong(GetDlgItem(hWnd,  
                                                                                                 IDC_SPBJMP), GWL_WNDPROC);  
                         SetWindowLong(GetDlgItem(hWnd, IDC_SPBJMP), GWL_WNDPROC,  
                                                                                                         (LONG)spbjmp);  
                         return(TRUE);                          return(TRUE);
   
                 case WM_COMMAND:                  case WM_COMMAND:
                         switch (LOWORD(wp)) {                          switch(LOWORD(wp)) {
                                 case IDC_SPBIO:                                  case IDC_SPBIO:
                                         setspbjmp(hWnd, getsnd26io(hWnd, IDC_SPBIO), 0x10);                                          setspbjmp(hWnd, getsnd26io(hWnd, IDC_SPBIO), 0x10);
                                         break;                                          break;
   
                                 case IDC_SPBINT:                                  case IDC_SPBINT:
                                         setspbjmp(hWnd, getsnd26int(hWnd, IDC_SPBINT), 0xc0);                                          setspbjmp(hWnd, getsnd26int(hWnd, IDC_SPBINT), 0xc0);
                                         break;                                          break;
   
                                 case IDC_SPBROM:                                  case IDC_SPBROM:
                                         setspbjmp(hWnd, getsnd26rom(hWnd, IDC_SPBROM), 0x07);                                          setspbjmp(hWnd, getsnd26rom(hWnd, IDC_SPBROM), 0x07);
                                         break;                                          break;
   
                                 case IDC_SPBDEF:                                  case IDC_SPBDEF:
                                         spb = 0xd1;                                          spb = 0xd1;
                                         setsnd26iopara(GetDlgItem(hWnd, IDC_SPBIO), spb);                                          setsnd26io(hWnd, IDC_SPBIO, spb);
                                         setsnd26intpara(GetDlgItem(hWnd, IDC_SPBINT), spb);                                          setsnd26int(hWnd, IDC_SPBINT, spb);
                                         setsnd26rompara(GetDlgItem(hWnd, IDC_SPBROM), spb);                                          setsnd26rom(hWnd, IDC_SPBROM, spb);
                                         spbvrc = 0;                                          spbvrc = 0;
                                         setspbVRch(hWnd);                                          setspbVRch(hWnd);
                                         InvalidateRect(GetDlgItem(hWnd, IDC_SPBJMP), NULL, TRUE);                                          InvalidateRect(GetDlgItem(hWnd, IDC_SPBJMP), NULL, TRUE);
                                         break;                                          break;
   
                                 case IDC_SPBVRL:                                  case IDC_SPBVRL:
                                 case IDC_SPBVRR:                                  case IDC_SPBVRR:
                                         b = getspbVRch(hWnd);                                          b = getspbVRch(hWnd);
Line 852  static LRESULT CALLBACK SPBoptDlgProc(HW Line 793  static LRESULT CALLBACK SPBoptDlgProc(HW
                                                                                                                                 NULL, TRUE);                                                                                                                                  NULL, TRUE);
                                         }                                          }
                                         break;                                          break;
   
                                 case IDC_SPBJMP:                                  case IDC_SPBJMP:
                                         GetWindowRect(GetDlgItem(hWnd, IDC_SPBJMP), &rect1);                                          spbcmdjmp(hWnd);
                                         GetClientRect(GetDlgItem(hWnd, IDC_SPBJMP), &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 < 5)) {  
                                                 b = spb;  
                                                 bit = 0x40 << (2 - p.y);  
                                                 switch(p.x) {  
                                                         case 2:  
                                                                 b |= bit;  
                                                                 break;  
                                                         case 3:  
                                                                 b ^= bit;  
                                                                 break;  
                                                         case 4:  
                                                                 b &= ~bit;  
                                                                 break;  
                                                 }  
                                                 if (spb != b) {  
                                                         spb = b;  
                                                         setsnd26intpara(GetDlgItem(hWnd, IDC_SPBINT), b);  
                                                         InvalidateRect(GetDlgItem(hWnd, IDC_SPBJMP),  
                                                                                                                         NULL, TRUE);  
                                                 }  
                                         }  
                                         else if (p.x == 7) {  
                                                 spb ^= 0x20;  
                                                 InvalidateRect(GetDlgItem(hWnd, IDC_SPBJMP),  
                                                                                                                         NULL, TRUE);  
                                         }  
                                         else if ((p.x >= 10) && (p.x < 12)) {  
                                                 b = (BYTE)((p.x - 10) << 4);  
                                                 if ((spb ^ b) & 0x10) {  
                                                         spb &= ~0x10;  
                                                         spb |= b;  
                                                         setsnd26iopara(GetDlgItem(hWnd, IDC_SPBIO), b);  
                                                         InvalidateRect(GetDlgItem(hWnd, IDC_SPBJMP),  
                                                                                                                         NULL, TRUE);  
                                                 }  
                                         }  
                                         else if ((p.x >= 14) && (p.x < 19)) {  
                                                 b = (BYTE)(p.x - 14);  
                                                 if ((spb ^ b) & 7) {  
                                                         spb &= ~0x07;  
                                                         spb |= b;  
                                                         setsnd26rompara(GetDlgItem(hWnd, IDC_SPBROM), b);  
                                                         InvalidateRect(GetDlgItem(hWnd, IDC_SPBJMP),  
                                                                                                                         NULL, TRUE);  
                                                 }  
                                         }  
                                         else if ((p.x >= 21) && (p.x < 24)) {  
                                                 spbvrc ^= (BYTE)(3 - p.y);  
                                                 setspbVRch(hWnd);  
                                                 InvalidateRect(GetDlgItem(hWnd, IDC_SPBJMP),  
                                                                                                                         NULL, TRUE);  
                                         }  
                                         break;                                          break;
                         }                          }
                         break;                          break;
Line 930  static LRESULT CALLBACK SPBoptDlgProc(HW Line 811  static LRESULT CALLBACK SPBoptDlgProc(HW
                                         np2cfg.spb_vrc = spbvrc;                                          np2cfg.spb_vrc = spbvrc;
                                         update |= SYS_UPDATECFG;                                          update |= SYS_UPDATECFG;
                                 }                                  }
                                 b = (BYTE)SendDlgItemMessage(hWnd, IDC_SPBVRLEVEL,                                  b = (UINT8)SendDlgItemMessage(hWnd, IDC_SPBVRLEVEL,
                                                                                                                         TBM_GETPOS, 0, 0);                                                                                                                          TBM_GETPOS, 0, 0);
                                 if (np2cfg.spb_vrl != b) {                                  if (np2cfg.spb_vrl != b) {
                                         np2cfg.spb_vrl = b;                                          np2cfg.spb_vrl = b;
                                         update |= SYS_UPDATECFG;                                          update |= SYS_UPDATECFG;
                                 }                                  }
                                 opngen_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 = (UINT8)GetDlgItemCheck(hWnd, IDC_SPBREVERSE);
                                 if (np2cfg.spb_x != b) {                                  if (np2cfg.spb_x != b) {
                                         np2cfg.spb_x = b;                                          np2cfg.spb_x = b;
                                         update |= SYS_UPDATECFG;                                          update |= SYS_UPDATECFG;
Line 946  static LRESULT CALLBACK SPBoptDlgProc(HW Line 827  static LRESULT CALLBACK SPBoptDlgProc(HW
                                 return(TRUE);                                  return(TRUE);
                         }                          }
                         break;                          break;
   
                   case WM_DRAWITEM:
                           if (LOWORD(wp) == IDC_SPBJMP) {
                                   dlgs_drawbmp(((LPDRAWITEMSTRUCT)lp)->hDC,
                                                                                           dipswbmp_getsndspb(spb, spbvrc));
                           }
                           return(FALSE);
         }          }
         return(FALSE);          return(FALSE);
 }  }
   
 // ----------------------------------------------------------- JOYPAD  
                                                                                                                                 // ver0.28  // ---- JOYPAD
   
 typedef struct {  typedef struct {
         int                     res;          UINT16  res;
         BYTE            *ptr;          UINT16  bit;
         DWORD           bit;          UINT8   *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),          SetDlgItemCheck(hWnd, item->res, (*(item->ptr)) & (1 << (item->bit)));
                                                                 (*(item->ptr)) & (1 << (item->bit)));  }
 }  
   static UINT8 checkbtnres_store(HWND hWnd, const CHECKTBL *item) {
 static BYTE checkbtnres_store(HWND hWnd, const CHKBTN_RES *item) {  
           UINT8   value;
         BYTE    value;          UINT8   bit;
         BYTE    bit;          UINT8   ret;
         BYTE    ret;  
   
         bit = 1 << (item->bit);          bit = 1 << (item->bit);
         value = ((Button_GetCheck(GetDlgItem(hWnd, item->res)))?0xff:0) & bit;          value = GetDlgItemCheck(hWnd, item->res)?bit:0;
         ret = ((*(item->ptr)) ^ value) & bit;          ret = ((*(item->ptr)) ^ value) & bit;
         if (ret) {          if (ret) {
                 (*(item->ptr)) ^= bit;                  (*(item->ptr)) ^= bit;
Line 995  static BYTE checkbtnres_store(HWND hWnd, Line 883  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) {
   
         int             i;          int             i;
         BYTE    renewal;          UINT8   renewal;
   
         switch(msg) {          switch(msg) {
                 case WM_INITDIALOG:                  case WM_INITDIALOG:
Line 1008  static LRESULT CALLBACK PAD1optDlgProc(H Line 895  static LRESULT CALLBACK PAD1optDlgProc(H
                                 checkbtnres_load(hWnd, pad1opt + i);                                  checkbtnres_load(hWnd, pad1opt + i);
                         }                          }
                         if (np2oscfg.JOYPAD1 & 2) {                          if (np2oscfg.JOYPAD1 & 2) {
                                 Button_Enable(GetDlgItem(hWnd, IDC_JOYPAD1), FALSE);                                  EnableWindow(GetDlgItem(hWnd, IDC_JOYPAD1), FALSE);
                         }                          }
                         return(TRUE);                          return(TRUE);
   
Line 1019  static LRESULT CALLBACK PAD1optDlgProc(H Line 906  static LRESULT CALLBACK PAD1optDlgProc(H
                                         renewal |= checkbtnres_store(hWnd, pad1opt + i);                                          renewal |= checkbtnres_store(hWnd, pad1opt + i);
                                 }                                  }
                                 if (renewal) {                                  if (renewal) {
                                         joy_init();                                          joymng_initialize();
                                         sysmng_update(SYS_UPDATECFG);                                          sysmng_update(SYS_UPDATECFG);
                                 }                                  }
                                 return(TRUE);                                  return(TRUE);
Line 1030  static LRESULT CALLBACK PAD1optDlgProc(H Line 917  static LRESULT CALLBACK PAD1optDlgProc(H
 }  }
   
   
 // --------------------------------------------------------------------------  // ----
   
 void dialog_sndopt(HWND hWnd) {  void dialog_sndopt(HWND hWnd) {
   
         HINSTANCE               hinst;          HINSTANCE               hinst;
         PROPSHEETPAGE   psp;          PROPSHEETPAGE   psp;
         PROPSHEETHEADER psh;          PROPSHEETHEADER psh;
         HPROPSHEETPAGE  hpsp[6];                                                                                // ver0.29          HPROPSHEETPAGE  hpsp[6];
   
         hinst = (HINSTANCE)GetWindowLong(hWnd, GWL_HINSTANCE);          hinst = (HINSTANCE)GetWindowLongPtr(hWnd, GWLP_HINSTANCE);
   
         ZeroMemory(&psp, sizeof(psp));          ZeroMemory(&psp, sizeof(psp));
         psp.dwSize = sizeof(PROPSHEETPAGE);          psp.dwSize = sizeof(PROPSHEETPAGE);
Line 1072  void dialog_sndopt(HWND hWnd) { Line 959  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_USEHICON;          psh.dwFlags = PSH_NOAPPLYNOW | PSH_USEHICON | PSH_USECALLBACK;
         psh.hwndParent = hWnd;          psh.hwndParent = hWnd;
         psh.hInstance = hinst;          psh.hInstance = hinst;
         psh.hIcon = LoadIcon(hinst, MAKEINTRESOURCE(IDI_ICON2));          psh.hIcon = LoadIcon(hinst, MAKEINTRESOURCE(IDI_ICON2));
         psh.nPages = 6;          psh.nPages = 6;
         psh.phpage = hpsp;          psh.phpage = hpsp;
         psh.pszCaption = str_sndopt;          psh.pszCaption = str_sndopt;
           psh.pfnCallback = np2class_propetysheet;
         PropertySheet(&psh);          PropertySheet(&psh);
         InvalidateRect(hWndMain, NULL, TRUE);          InvalidateRect(hWnd, NULL, TRUE);
 }  }
   
   
 // ----  // ----
   
 static const char s98ui_file[] = "NP2_%04d.S98";  #if defined(SUPPORT_S98)
 static const char s98ui_title[] = "Save as S98 log";  
 static const char s98ui_ext[] = "s98";  
 static const char s98ui_filter[] = "S98 log (*.s98)\0*.s98\0";  
 static const FILESEL s98ui = {s98ui_title, s98ui_ext, s98ui_filter, 1};  
   
 void dialog_s98(HWND hWnd) {  
   
         BOOL    check;  static const FSPARAM fpS98 =
         char    path[MAX_PATH];  {
           MAKEINTRESOURCE(IDS_S98TITLE),
           MAKEINTRESOURCE(IDS_S98EXT),
           MAKEINTRESOURCE(IDS_S98FILTER),
           1
   };
   static const OEMCHAR szS98File[] = OEMTEXT("NP2_####.S98");
   
   void dialog_s98(HWND hWnd)
   {
           BOOL    bCheck;
           OEMCHAR szPath[MAX_PATH];
   
         S98_close();          S98_close();
         check = FALSE;          bCheck = FALSE;
         file_cpyname(path, bmpfilefolder, sizeof(path));          file_cpyname(szPath, bmpfilefolder, NELEMENTS(szPath));
         file_cutname(path);          file_cutname(szPath);
         file_catname(path, s98ui_file, sizeof(path));          file_catname(szPath, szS98File, NELEMENTS(szPath));
         if ((dlgs_selectwritenum(hWnd, &s98ui, path, sizeof(path))) &&          if ((dlgs_createfilenum(hWnd, &fpS98, szPath, NELEMENTS(szPath))) &&
                 (S98_open(path) == SUCCESS)) {                  (S98_open(szPath) == SUCCESS))
                 file_cpyname(bmpfilefolder, path, sizeof(bmpfilefolder));          {
                   file_cpyname(bmpfilefolder, szPath, NELEMENTS(bmpfilefolder));
                   sysmng_update(SYS_UPDATEOSCFG);
                   bCheck = TRUE;
           }
           xmenu_sets98logging(bCheck);
   }
   #endif  // defined(SUPPORT_S98)
   
   
   // ----
   
   #if defined(SUPPORT_WAVEREC)
   
   static const FSPARAM fpWave =
   {
           MAKEINTRESOURCE(IDS_WAVETITLE),
           MAKEINTRESOURCE(IDS_WAVEEXT),
           MAKEINTRESOURCE(IDS_WAVEFILTER),
           1
   };
   static const OEMCHAR szWaveFile[] = OEMTEXT("NP2_####.WAV");
   
   void dialog_waverec(HWND hWnd)
   {
           UINT8   bCheck;
           OEMCHAR szPath[MAX_PATH];
   
           bCheck = FALSE;
           sound_recstop();
           file_cpyname(szPath, bmpfilefolder, NELEMENTS(szPath));
           file_cutname(szPath);
           file_catname(szPath, szWaveFile, NELEMENTS(szPath));
           if ((dlgs_createfilenum(hWnd, &fpWave, szPath, NELEMENTS(szPath))) &&
                   (sound_recstart(szPath) == SUCCESS))
           {
                   file_cpyname(bmpfilefolder, szPath, NELEMENTS(bmpfilefolder));
                 sysmng_update(SYS_UPDATEOSCFG);                  sysmng_update(SYS_UPDATEOSCFG);
                 check = TRUE;                  bCheck = TRUE;
         }          }
         xmenu_sets98logging(check);          xmenu_setwaverec(bCheck);
 }  }
   #endif  // defined(SUPPORT_WAVEREC)
   
Removed from v.1.6  
changed lines
  Added in v.1.21

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