[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.7 and 1.9

version 1.7, 2003/10/31 03:40:10 version 1.9, 2003/11/04 19:23:03
Line 9 Line 9
 #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        "bit2res.h"
Line 160  static LRESULT CALLBACK SndmixDlgProc(HW Line 161  static LRESULT CALLBACK SndmixDlgProc(HW
 }  }
   
   
 // -------------------------------------------------------- PC-9801-14  // ---- PC-9801-14
   
 static const SLIDERTBL snd14item[] = {  static const SLIDERTBL snd14item[] = {
                 {IDC_VOL14L,    IDC_VOL14LSTR,          np2cfg.vol14+0,         0,15},                  {IDC_VOL14L,    IDC_VOL14LSTR,          np2cfg.vol14+0,         0,15},
Line 297  void setsnd26romdip(BYTE *image, int px, Line 298  void setsnd26romdip(BYTE *image, int px,
         dlgs_setjumpery(image, px + v, py, align);          dlgs_setjumpery(image, px + v, py, align);
 }  }
   
 // ---- PC-9801-26  
   
 static  BYTE                    snd26 = 0;  // ---- PC-9801-26
 static  SUBCLASSPROC    oldidc_snd26jmp = NULL;  
   
 static LRESULT CALLBACK Snd26jmp(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp) {  static  BYTE    snd26 = 0;
   
         PAINTSTRUCT                     ps;  
         HDC                                     hdc;  
         HBITMAP                         hBitmap;  
         HDC                                     hMemDC;  
         BYTE                            *image;  
         HANDLE                          hwork;  
         BITMAPINFO                      *work;  
         BYTE                            *imgbtm;  
         int                                     align;  
   
         switch(msg) {  
                 case WM_PAINT:  
                         hdc = BeginPaint(hWnd, &ps);  
                         if ((hwork = GlobalAlloc(GPTR, bit2res_getsize(&snd26dip)))  
                                                                                                                                 == NULL) {  
                                 break;  
                         }  
                         if ((work = (BITMAPINFO *)GlobalLock(hwork)) == NULL) {  
                                 GlobalFree(hwork);  
                                 break;  
                         }  
                         bit2res_sethead(work, &snd26dip);  
                         hBitmap = CreateDIBSection(hdc, work, DIB_RGB_COLORS,  
                                                                                                 (void **)&image, NULL, 0);  
                         bit2res_setdata(image, &snd26dip);  
                         align = ((snd26dip.x + 7) / 2) & ~3;  
                         imgbtm = image + align * (snd26dip.y - 1);  
                         setsnd26iodip(imgbtm, 15, 1, align, snd26);  
                         setsnd26intdip(imgbtm, 9, 1, align, snd26);  
                         setsnd26romdip(imgbtm, 2, 1, align, snd26);  
                         if ((hMemDC = CreateCompatibleDC(hdc)) != NULL) {  
                                 SelectObject(hMemDC, hBitmap);  
                                 StretchBlt(hdc, 0, 0, snd26dip.x, snd26dip.y, hMemDC,  
                                                                         0, 0, snd26dip.x, snd26dip.y, SRCCOPY);  
                                 DeleteDC(hMemDC);  
                         }  
                         DeleteObject(hBitmap);  
                         EndPaint(hWnd, &ps);  
                         GlobalUnlock(hwork);  
                         GlobalFree(hwork);  
                         break;  
                 default:  
                         return(CallWindowProc(oldidc_snd26jmp, hWnd, msg, wp, lp));  
         }  
         return(FALSE);  
 }  
   
 static void set26jmp(HWND hWnd, BYTE value, BYTE bit) {  static void set26jmp(HWND hWnd, BYTE value, BYTE bit) {
   
Line 360  static void set26jmp(HWND hWnd, BYTE val Line 313  static void set26jmp(HWND hWnd, BYTE val
         }          }
 }  }
   
 static void snd26cmddipsw(HWND hWnd) {  static void snd26cmdjmp(HWND hWnd) {
   
         RECT    rect1;          RECT    rect1;
         RECT    rect2;          RECT    rect2;
         POINT   p;          POINT   p;
         BYTE    b, bit;          BOOL    redraw;
           BYTE    b;
           BYTE    bit;
   
         GetWindowRect(GetDlgItem(hWnd, IDC_SND26JMP), &rect1);          GetWindowRect(GetDlgItem(hWnd, IDC_SND26JMP), &rect1);
         GetClientRect(GetDlgItem(hWnd, IDC_SND26JMP), &rect2);          GetClientRect(GetDlgItem(hWnd, IDC_SND26JMP), &rect2);
         GetCursorPos(&p);          GetCursorPos(&p);
           redraw = FALSE;
         p.x += rect2.left - rect1.left;          p.x += rect2.left - rect1.left;
         p.y += rect2.top - rect1.top;          p.y += rect2.top - rect1.top;
         p.x /= 9;          p.x /= 9;
Line 383  static void snd26cmddipsw(HWND hWnd) { Line 339  static void snd26cmddipsw(HWND hWnd) {
                         snd26 &= ~0x07;                          snd26 &= ~0x07;
                         snd26 |= b;                          snd26 |= b;
                         setsnd26rompara(GetDlgItem(hWnd, IDC_SND26ROM), b);                          setsnd26rompara(GetDlgItem(hWnd, IDC_SND26ROM), b);
                         InvalidateRect(GetDlgItem(hWnd, IDC_SND26JMP), NULL, TRUE);                          redraw = TRUE;
                 }                  }
         }          }
         else if ((p.x >= 9) && (p.x < 12)) {          else if ((p.x >= 9) && (p.x < 12)) {
Line 405  static void snd26cmddipsw(HWND hWnd) { Line 361  static void snd26cmddipsw(HWND hWnd) {
                 if (snd26 != b) {                  if (snd26 != b) {
                         snd26 = b;                          snd26 = b;
                         setsnd26intpara(GetDlgItem(hWnd, IDC_SND26INT), b);                          setsnd26intpara(GetDlgItem(hWnd, IDC_SND26INT), b);
                         InvalidateRect(GetDlgItem(hWnd, IDC_SND26JMP), NULL, TRUE);                          redraw = TRUE;
                 }                  }
         }          }
         else if ((p.x >= 15) && (p.x < 17)) {          else if ((p.x >= 15) && (p.x < 17)) {
Line 414  static void snd26cmddipsw(HWND hWnd) { Line 370  static void snd26cmddipsw(HWND hWnd) {
                         snd26 &= ~0x10;                          snd26 &= ~0x10;
                         snd26 |= b;                          snd26 |= b;
                         setsnd26iopara(GetDlgItem(hWnd, IDC_SND26IO), b);                          setsnd26iopara(GetDlgItem(hWnd, IDC_SND26IO), b);
                         InvalidateRect(GetDlgItem(hWnd, IDC_SND26JMP), NULL, TRUE);                          redraw = TRUE;
                 }                  }
         }          }
           if (redraw) {
                   InvalidateRect(GetDlgItem(hWnd, IDC_SND26JMP), NULL, TRUE);
           }
   }
   
   static void snd26drawjmp(HWND hWnd, HDC hdc) {
   
           BITMAPINFO      *bmi;
           HBITMAP         hbmp;
           BYTE            *image;
           int                     align;
           BYTE            *imgbtm;
           HDC                     hmdc;
   
           bmi = (BITMAPINFO *)_MALLOC(bit2res_getsize(&snd26dip), "bitmap");
           if (bmi == NULL) {
                   return;
           }
           bit2res_sethead(bmi, &snd26dip);
           hbmp = CreateDIBSection(hdc, bmi, DIB_RGB_COLORS,
                                                                                                   (void **)&image, NULL, 0);
           bit2res_setdata(image, &snd26dip);
           align = ((snd26dip.x + 7) / 2) & ~3;
           imgbtm = image + align * (snd26dip.y - 1);
           setsnd26iodip(imgbtm, 15, 1, align, snd26);
           setsnd26intdip(imgbtm, 9, 1, align, snd26);
           setsnd26romdip(imgbtm, 2, 1, align, snd26);
           hmdc = CreateCompatibleDC(hdc);
           SelectObject(hmdc, hbmp);
           BitBlt(hdc, 0, 0, snd26dip.x, snd26dip.y, hmdc, 0, 0, SRCCOPY);
           DeleteDC(hmdc);
           DeleteObject(hbmp);
           _MFREE(bmi);
 }  }
   
 static LRESULT CALLBACK Snd26optDlgProc(HWND hWnd, UINT msg,  static LRESULT CALLBACK Snd26optDlgProc(HWND hWnd, UINT msg,
                                                                                                         WPARAM wp, LPARAM lp) {                                                                                                          WPARAM wp, LPARAM lp) {
   
           HWND    sub;
   
         switch(msg) {          switch(msg) {
                 case WM_INITDIALOG:                  case WM_INITDIALOG:
                         snd26 = np2cfg.snd26opt;                          snd26 = np2cfg.snd26opt;
Line 431  static LRESULT CALLBACK Snd26optDlgProc( Line 422  static LRESULT CALLBACK Snd26optDlgProc(
                         setsnd26intpara(GetDlgItem(hWnd, IDC_SND26INT), snd26);                          setsnd26intpara(GetDlgItem(hWnd, IDC_SND26INT), snd26);
                         SETLISTSTR(hWnd, IDC_SND26ROM, sndromaddr);                          SETLISTSTR(hWnd, IDC_SND26ROM, sndromaddr);
                         setsnd26rompara(GetDlgItem(hWnd, IDC_SND26ROM), snd26);                          setsnd26rompara(GetDlgItem(hWnd, IDC_SND26ROM), snd26);
                         oldidc_snd26jmp = (SUBCLASSPROC)GetWindowLong(GetDlgItem(hWnd,                          sub = GetDlgItem(hWnd, IDC_SND26JMP);
                                                                                                 IDC_SND26JMP), GWL_WNDPROC);                          SetWindowLong(sub, GWL_STYLE, SS_OWNERDRAW +
                         SetWindowLong(GetDlgItem(hWnd, IDC_SND26JMP), GWL_WNDPROC,                                                          (GetWindowLong(sub, GWL_STYLE) & (~SS_TYPEMASK)));
                                                                                                         (LONG)Snd26jmp);  
                         return(TRUE);                          return(TRUE);
   
                 case WM_COMMAND:                  case WM_COMMAND:
Line 460  static LRESULT CALLBACK Snd26optDlgProc( Line 450  static LRESULT CALLBACK Snd26optDlgProc(
                                         break;                                          break;
   
                                 case IDC_SND26JMP:                                  case IDC_SND26JMP:
                                         snd26cmddipsw(hWnd);                                          snd26cmdjmp(hWnd);
                                         break;                                          break;
                         }                          }
                         break;                          break;
Line 474  static LRESULT CALLBACK Snd26optDlgProc( Line 464  static LRESULT CALLBACK Snd26optDlgProc(
                                 return(TRUE);                                  return(TRUE);
                         }                          }
                         break;                          break;
   
                   case WM_DRAWITEM:
                           if (LOWORD(wp) == IDC_SND26JMP) {
                                   snd26drawjmp(hWnd, ((LPDRAWITEMSTRUCT)lp)->hDC);
                           }
                           return(FALSE);
         }          }
         return(FALSE);          return(FALSE);
 }  }
   
   
 // ---- PC-9801-86  // ---- PC-9801-86
   
 static  BYTE                    snd86 = 0;  static  BYTE    snd86 = 0;
 static  SUBCLASSPROC    oldidc_snd86dip = NULL;  
   
 static const UINT snd86paranum[4] = {0, 1, 3, 2};  static const UINT snd86paranum[4] = {0, 1, 3, 2};
   
 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;  
                 default:  
                         return(CallWindowProc(oldidc_snd86dip, hWnd, msg, wp, lp));  
         }  
         return(FALSE);  
 }  
   
   
 static void setsnd86iopara(HWND hWnd, BYTE value) {  static void setsnd86iopara(HWND hWnd, BYTE value) {
Line 600  static void set86jmp(HWND hWnd, BYTE val Line 542  static void set86jmp(HWND hWnd, BYTE val
         }          }
 }  }
   
 static LRESULT CALLBACK Snd86optDlgProc(HWND hWnd, UINT msg,  static void snd86cmddipsw(HWND hWnd) {
                                                                                                         WPARAM wp, LPARAM lp) {  
   
         RECT    rect1;          RECT    rect1;
         RECT    rect2;          RECT    rect2;
         POINT   p;          POINT   p;
   
           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:
                           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);
   }
   
   static void snd86drawdipsw(HWND hWnd, HDC hdc) {
   
           BITMAPINFO      *bmi;
           HBITMAP         hbmp;
           BYTE            *image;
           int                     align;
           BYTE            *imgbtm;
           HDC                     hmdc;
           int                     i;
           int                     x, y, yl;
   
           bmi = (BITMAPINFO *)_MALLOC(bit2res_getsize(&snd86dip), "bitmap");
           if (bmi == NULL) {
                   return;
           }
           bit2res_sethead(bmi, &snd86dip);
           hbmp = CreateDIBSection(hdc, bmi, 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);
                   }
           }
           hmdc = CreateCompatibleDC(hdc);
           SelectObject(hmdc, hbmp);
           BitBlt(hdc, 0, 0, snd86dip.x, snd86dip.y, hmdc, 0, 0, SRCCOPY);
           DeleteDC(hmdc);
           DeleteObject(hbmp);
           _MFREE(bmi);
   }
   
   static LRESULT CALLBACK Snd86optDlgProc(HWND hWnd, UINT msg,
                                                                                                           WPARAM wp, LPARAM lp) {
   
           HWND    sub;
   
         switch(msg) {          switch(msg) {
                 case WM_INITDIALOG:                  case WM_INITDIALOG:
                         snd86 = np2cfg.snd86opt;                          snd86 = np2cfg.snd86opt;
Line 618  static LRESULT CALLBACK Snd86optDlgProc( Line 640  static LRESULT CALLBACK Snd86optDlgProc(
                         SETLISTSTR(hWnd, IDC_SND86ID, sndid);                          SETLISTSTR(hWnd, IDC_SND86ID, sndid);
                         setsnd86idpara(GetDlgItem(hWnd, IDC_SND86ID), snd86);                          setsnd86idpara(GetDlgItem(hWnd, IDC_SND86ID), snd86);
                         Button_SetCheck(GetDlgItem(hWnd, IDC_SND86ROM), snd86 & 2);                          Button_SetCheck(GetDlgItem(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:
Line 647  static LRESULT CALLBACK Snd86optDlgProc( Line 669  static LRESULT CALLBACK Snd86optDlgProc(
                                         set86jmp(hWnd,                                          set86jmp(hWnd,
                                                 getsnd86id(GetDlgItem(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);                                          setsnd86iopara(GetDlgItem(hWnd, IDC_SND86IO), snd86);
Line 656  static LRESULT CALLBACK Snd86optDlgProc( Line 679  static LRESULT CALLBACK Snd86optDlgProc(
                                         Button_SetCheck(GetDlgItem(hWnd, IDC_SND86ROM), TRUE);                                          Button_SetCheck(GetDlgItem(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 710  static LRESULT CALLBACK Snd86optDlgProc( Line 695  static LRESULT CALLBACK Snd86optDlgProc(
                                 return(TRUE);                                  return(TRUE);
                         }                          }
                         break;                          break;
   
                   case WM_DRAWITEM:
                           if (LOWORD(wp) == IDC_SND86DIP) {
                                   snd86drawdipsw(hWnd, ((LPDRAWITEMSTRUCT)lp)->hDC);
                           }
                           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  BYTE    spb = 0;
                 case WM_PAINT:  static  BYTE    spbvrc = 0;
                         hdc = BeginPaint(hWnd, &ps);  
                         if ((hwork = GlobalAlloc(GPTR, bit2res_getsize(&spbdip)))  
                                                                                                                                 == NULL) {  static void setspbVRch(HWND hWnd) {
   
           Button_SetCheck(GetDlgItem(hWnd, IDC_SPBVRL), spbvrc & 1);
           Button_SetCheck(GetDlgItem(hWnd, IDC_SPBVRR), spbvrc & 2);
   }
   
   static void spbcreate(HWND hWnd) {
   
           HWND    sub;
   
           spb = np2cfg.spbopt;
           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);
   
           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;
           BYTE    b;
           BYTE    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);                          setsnd26intpara(GetDlgItem(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);  
                         }  
                         dlgs_setjumperx(imgbtm, ((spbvrc&2)?21:22), 1, align);  
                         dlgs_setjumperx(imgbtm, ((spbvrc&1)?21:22), 2, align);  
                         if ((hMemDC = CreateCompatibleDC(hdc)) != NULL) {  
                                 SelectObject(hMemDC, hBitmap);  
                                 StretchBlt(hdc, 0, 0, spbdip.x, spbdip.y, hMemDC,  
                                                                         0, 0, spbdip.x, spbdip.y, SRCCOPY);  
                                 DeleteDC(hMemDC);  
                         }  
                         DeleteObject(hBitmap);  
                         EndPaint(hWnd, &ps);  
                         GlobalUnlock(hwork);  
                         GlobalFree(hwork);  
                         break;  
                 default:  
                         return(CallWindowProc(oldidc_spbjmp, hWnd, msg, wp, lp));  
         }          }
         return(FALSE);          else if (p.x == 7) {
                   spb ^= 0x20;
                   redraw = 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);
                           redraw = 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);
                           redraw = TRUE;
                   }
           }
           else if ((p.x >= 21) && (p.x < 24)) {
                   spbvrc ^= (BYTE)(3 - p.y);
                   setspbVRch(hWnd);
                   redraw = TRUE;
           }
           if (redraw) {
                   InvalidateRect(GetDlgItem(hWnd, IDC_SPBJMP), NULL, TRUE);
           }
   }
   
   static void spbdrawjumper(HWND hWnd, HDC hdc) {
   
           BITMAPINFO      *bmi;
           HBITMAP         hbmp;
           BYTE            *image;
           int                     align;
           BYTE            *imgbtm;
           HDC                     hmdc;
   
           bmi = (BITMAPINFO *)_MALLOC(bit2res_getsize(&spbdip), "bitmap");
           if (bmi == NULL) {
                   return;
           }
           bit2res_sethead(bmi, &spbdip);
           hbmp = CreateDIBSection(hdc, bmi, DIB_RGB_COLORS,
                                                                                                   (void **)&image, NULL, 0);
           bit2res_setdata(image, &spbdip);
           align = ((spbdip.x + 7) / 2) & ~3;
           imgbtm = image + align * (spbdip.y - 1);
           setsnd26intdip(imgbtm, 2, 1, align, spb);
           setsnd26iodip(imgbtm, 10, 1, align, spb);
           setsnd26romdip(imgbtm, 14, 1, align, spb);
           if (spb & 0x20) {
                   dlgs_setjumpery(imgbtm, 7, 1, align);
           }
           dlgs_setjumperx(imgbtm, ((spbvrc&2)?21:22), 1, align);
           dlgs_setjumperx(imgbtm, ((spbvrc&1)?21:22), 2, align);
           hmdc = CreateCompatibleDC(hdc);
           SelectObject(hmdc, hbmp);
           BitBlt(hdc, 0, 0, spbdip.x, spbdip.y, hmdc, 0, 0, SRCCOPY);
           DeleteDC(hmdc);
           DeleteObject(hbmp);
           _MFREE(bmi);
 }  }
   
 static void setspbjmp(HWND hWnd, BYTE value, BYTE bit) {  static void setspbjmp(HWND hWnd, BYTE value, BYTE bit) {
Line 784  static void setspbjmp(HWND hWnd, BYTE va Line 860  static void setspbjmp(HWND hWnd, BYTE va
         }          }
 }  }
   
 static void setspbVRch(HWND hWnd) {  
   
         Button_SetCheck(GetDlgItem(hWnd, IDC_SPBVRL), spbvrc & 1);  
         Button_SetCheck(GetDlgItem(hWnd, IDC_SPBVRR), spbvrc & 2);  
 }  
   
 static BYTE getspbVRch(HWND hWnd) {  static BYTE getspbVRch(HWND hWnd) {
   
         BYTE    ret = 0;          BYTE    ret;
   
           ret = 0;
         if (Button_GetCheck(GetDlgItem(hWnd, IDC_SPBVRL))) {          if (Button_GetCheck(GetDlgItem(hWnd, IDC_SPBVRL))) {
                 ret++;                  ret++;
         }          }
Line 803  static BYTE getspbVRch(HWND hWnd) { Line 874  static BYTE getspbVRch(HWND hWnd) {
         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;          BYTE    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:
Line 840  static LRESULT CALLBACK SPBoptDlgProc(HW Line 889  static LRESULT CALLBACK SPBoptDlgProc(HW
                                 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);                                          setsnd26iopara(GetDlgItem(hWnd, IDC_SPBIO), spb);
Line 855  static LRESULT CALLBACK SPBoptDlgProc(HW Line 907  static LRESULT CALLBACK SPBoptDlgProc(HW
                                         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 864  static LRESULT CALLBACK SPBoptDlgProc(HW Line 917  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 958  static LRESULT CALLBACK SPBoptDlgProc(HW Line 951  static LRESULT CALLBACK SPBoptDlgProc(HW
                                 return(TRUE);                                  return(TRUE);
                         }                          }
                         break;                          break;
   
                   case WM_DRAWITEM:
                           if (LOWORD(wp) == IDC_SPBJMP) {
                                   spbdrawjumper(hWnd, ((LPDRAWITEMSTRUCT)lp)->hDC);
                           }
                           return(FALSE);
         }          }
         return(FALSE);          return(FALSE);
 }  }
Line 1084  void dialog_sndopt(HWND hWnd) { Line 1083  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(hWnd, NULL, TRUE);          InvalidateRect(hWnd, NULL, TRUE);
 }  }
Removed from v.1.7  
changed lines
  Added in v.1.9

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