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

Diff for /np2/win9x/subwind.cpp between versions 1.1 and 1.9

version 1.1, 2004/03/25 08:51:24 version 1.9, 2004/04/09 10:52:21
Line 10 Line 10
 #include        "subwind.h"  #include        "subwind.h"
 #include        "np2class.h"  #include        "np2class.h"
 #include        "keydisp.h"  #include        "keydisp.h"
   #include        "memdbg32.h"
 #include        "softkbd.h"  #include        "softkbd.h"
   
   
Line 43  typedef struct { Line 44  typedef struct {
         HWND            hwnd;          HWND            hwnd;
         WINLOCEX        wlex;          WINLOCEX        wlex;
         DD2HDL          dd2hdl;          DD2HDL          dd2hdl;
 } KDWIN;  } KDISPWIN;
   
 typedef struct {  typedef struct {
         int             posx;          int             posx;
Line 52  typedef struct { Line 53  typedef struct {
         BYTE    type;          BYTE    type;
 } KDISPCFG;  } KDISPCFG;
   
 static  KDWIN           kdwin;  static  KDISPWIN        kdispwin;
 static  KDISPCFG        kdispcfg;  static  KDISPCFG        kdispcfg;
   
 static const char np2kdcaption[] = "Key Display";  static const char kdispapp[] = "Key Display";
 static const char np2kdclass[] = "NP2-KeyDispWin";  static const char kdispclass[] = "NP2-KeyDispWin";
 static const char str_kdclose[] = "&Close";  static const char str_kdclose[] = "&Close";
   
 static const UINT32 kdwinpal[KEYDISP_PALS] =  static const UINT32 kdisppal[KEYDISP_PALS] =
                                                                         {0x00000000, 0xffffffff, 0xf9ff0000};                                                                          {0x00000000, 0xffffffff, 0xf9ff0000};
   
 static const char np2kdapp[] = "NP2 keydisp";  static const INITBL kdispini[] = {
   
 static const INITBL np2kdini[] = {  
         {"WindposX", INITYPE_SINT32,    &kdispcfg.posx,                 0},          {"WindposX", INITYPE_SINT32,    &kdispcfg.posx,                 0},
         {"WindposY", INITYPE_SINT32,    &kdispcfg.posy,                 0},          {"WindposY", INITYPE_SINT32,    &kdispcfg.posy,                 0},
         {"keydmode", INITYPE_UINT8,             &kdispcfg.mode,                 0},          {"keydmode", INITYPE_UINT8,             &kdispcfg.mode,                 0},
Line 74  static const INITBL np2kdini[] = { Line 73  static const INITBL np2kdini[] = {
 static BYTE kdgetpal8(CMNPALFN *self, UINT num) {  static BYTE kdgetpal8(CMNPALFN *self, UINT num) {
   
         if (num < KEYDISP_PALS) {          if (num < KEYDISP_PALS) {
                 return(kdwinpal[num] >> 24);                  return(kdisppal[num] >> 24);
         }          }
         return(0);          return(0);
 }  }
Line 82  static BYTE kdgetpal8(CMNPALFN *self, UI Line 81  static BYTE kdgetpal8(CMNPALFN *self, UI
 static UINT32 kdgetpal32(CMNPALFN *self, UINT num) {  static UINT32 kdgetpal32(CMNPALFN *self, UINT num) {
   
         if (num < KEYDISP_PALS) {          if (num < KEYDISP_PALS) {
                 return(kdwinpal[num] & 0xffffff);                  return(kdisppal[num] & 0xffffff);
         }          }
         return(0);          return(0);
 }  }
Line 106  static void kddrawkeys(HWND hWnd, BOOL r Line 105  static void kddrawkeys(HWND hWnd, BOOL r
         if ((draw.right <= 0) || (draw.bottom <= 0)) {          if ((draw.right <= 0) || (draw.bottom <= 0)) {
                 return;                  return;
         }          }
         vram = dd2_bsurflock(kdwin.dd2hdl);          vram = dd2_bsurflock(kdispwin.dd2hdl);
         if (vram) {          if (vram) {
                 keydisp_paint(vram, redraw);                  keydisp_paint(vram, redraw);
                 dd2_bsurfunlock(kdwin.dd2hdl);                  dd2_bsurfunlock(kdispwin.dd2hdl);
                 dd2_blt(kdwin.dd2hdl, NULL, &draw);                  dd2_blt(kdispwin.dd2hdl, NULL, &draw);
         }          }
 }  }
   
Line 121  static void kdsetwinsize(void) { Line 120  static void kdsetwinsize(void) {
         WINLOCEX        wlex;          WINLOCEX        wlex;
   
         wlex = np2_winlocexallwin(hWndMain);          wlex = np2_winlocexallwin(hWndMain);
         winlocex_setholdwnd(wlex, kdwin.hwnd);          winlocex_setholdwnd(wlex, kdispwin.hwnd);
         keydisp_getsize(&width, &height);          keydisp_getsize(&width, &height);
         winloc_setclientsize(kdwin.hwnd, width, height);          winloc_setclientsize(kdispwin.hwnd, width, height);
         winlocex_move(wlex);          winlocex_move(wlex);
         winlocex_destroy(wlex);          winlocex_destroy(wlex);
 }  }
Line 133  static void kdsetdispmode(BYTE mode) { Line 132  static void kdsetdispmode(BYTE mode) {
         HMENU   hmenu;          HMENU   hmenu;
   
         keydisp_setmode(mode);          keydisp_setmode(mode);
         hmenu = np2class_gethmenu(kdwin.hwnd);          hmenu = np2class_gethmenu(kdispwin.hwnd);
         CheckMenuItem(hmenu, IDM_KDISPFM,          CheckMenuItem(hmenu, IDM_KDISPFM,
                                         ((mode == KEYDISP_MODEFM)?MF_CHECKED:MF_UNCHECKED));                                          ((mode == KEYDISP_MODEFM)?MF_CHECKED:MF_UNCHECKED));
         CheckMenuItem(hmenu, IDM_KDISPMIDI,          CheckMenuItem(hmenu, IDM_KDISPMIDI,
Line 235  static LRESULT CALLBACK kdproc(HWND hWnd Line 234  static LRESULT CALLBACK kdproc(HWND hWnd
   
                 case WM_ENTERSIZEMOVE:                  case WM_ENTERSIZEMOVE:
                         soundmng_disable(SNDPROC_SUBWIND);                          soundmng_disable(SNDPROC_SUBWIND);
                         winlocex_destroy(kdwin.wlex);                          winlocex_destroy(kdispwin.wlex);
                         kdwin.wlex = np2_winlocexallwin(hWnd);                          kdispwin.wlex = np2_winlocexallwin(hWnd);
                         break;                          break;
   
                 case WM_MOVING:                  case WM_MOVING:
                         winlocex_moving(kdwin.wlex, (RECT *)lp);                          winlocex_moving(kdispwin.wlex, (RECT *)lp);
                         break;                          break;
   
                 case WM_EXITSIZEMOVE:                  case WM_EXITSIZEMOVE:
                         winlocex_destroy(kdwin.wlex);                          winlocex_destroy(kdispwin.wlex);
                         kdwin.wlex = NULL;                          kdispwin.wlex = NULL;
                         soundmng_enable(SNDPROC_SUBWIND);                          soundmng_enable(SNDPROC_SUBWIND);
                         break;                          break;
   
Line 268  static LRESULT CALLBACK kdproc(HWND hWnd Line 267  static LRESULT CALLBACK kdproc(HWND hWnd
   
                 case WM_DESTROY:                  case WM_DESTROY:
                         np2class_wmdestroy(hWnd);                          np2class_wmdestroy(hWnd);
                         dd2_release(kdwin.dd2hdl);                          dd2_release(kdispwin.dd2hdl);
                         kdwin.hwnd = NULL;                          kdispwin.hwnd = NULL;
                         kdsetdispmode(KEYDISP_MODENONE);                          kdsetdispmode(KEYDISP_MODENONE);
                         break;                          break;
   
Line 279  static LRESULT CALLBACK kdproc(HWND hWnd Line 278  static LRESULT CALLBACK kdproc(HWND hWnd
         return(0L);          return(0L);
 }  }
   
   
 // ----  
   
 BOOL kdispwin_initialize(HINSTANCE hPreInst) {  BOOL kdispwin_initialize(HINSTANCE hPreInst) {
   
         WNDCLASS        wc;          WNDCLASS        wc;
Line 297  BOOL kdispwin_initialize(HINSTANCE hPreI Line 293  BOOL kdispwin_initialize(HINSTANCE hPreI
                 wc.hCursor = LoadCursor(NULL, IDC_ARROW);                  wc.hCursor = LoadCursor(NULL, IDC_ARROW);
                 wc.hbrBackground = (HBRUSH)GetStockObject(NULL_BRUSH);                  wc.hbrBackground = (HBRUSH)GetStockObject(NULL_BRUSH);
                 wc.lpszMenuName = MAKEINTRESOURCE(IDR_KEYDISP);                  wc.lpszMenuName = MAKEINTRESOURCE(IDR_KEYDISP);
                 wc.lpszClassName = np2kdclass;                  wc.lpszClassName = kdispclass;
                 if (!RegisterClass(&wc)) {                  if (!RegisterClass(&wc)) {
                         return(FAILURE);                          return(FAILURE);
                 }                  }
Line 312  void kdispwin_create(void) { Line 308  void kdispwin_create(void) {
         BYTE            mode;          BYTE            mode;
         CMNPALFN        palfn;          CMNPALFN        palfn;
   
         if (kdwin.hwnd != NULL) {          if (kdispwin.hwnd != NULL) {
                 return;                  return;
         }          }
         ZeroMemory(&kdwin, sizeof(kdwin));          ZeroMemory(&kdispwin, sizeof(kdispwin));
         hwnd = CreateWindow(np2kdclass, np2kdcaption,          hwnd = CreateWindow(kdispclass, kdispapp,
                                                 WS_OVERLAPPED | WS_SYSMENU | WS_CAPTION |                                                  WS_OVERLAPPED | WS_SYSMENU | WS_CAPTION |
                                                 WS_MINIMIZEBOX,                                                  WS_MINIMIZEBOX,
                                                 kdispcfg.posx, kdispcfg.posy,                                                  kdispcfg.posx, kdispcfg.posy,
                                                 CW_USEDEFAULT, CW_USEDEFAULT,                                                  KEYDISP_WIDTH, KEYDISP_HEIGHT,
                                                 NULL, NULL, hInst, NULL);                                                  NULL, NULL, hInst, NULL);
         kdwin.hwnd = hwnd;          kdispwin.hwnd = hwnd;
         if (hwnd == NULL) {          if (hwnd == NULL) {
                 goto kdcre_err1;                  goto kdcre_err1;
         }          }
Line 339  void kdispwin_create(void) { Line 335  void kdispwin_create(void) {
         kdsetdispmode(mode);          kdsetdispmode(mode);
         ShowWindow(hwnd, SW_SHOWNOACTIVATE);          ShowWindow(hwnd, SW_SHOWNOACTIVATE);
         UpdateWindow(hwnd);          UpdateWindow(hwnd);
         kdwin.dd2hdl = dd2_create(hwnd, KEYDISP_WIDTH, KEYDISP_HEIGHT);          kdispwin.dd2hdl = dd2_create(hwnd, KEYDISP_WIDTH, KEYDISP_HEIGHT);
         if (kdwin.dd2hdl == NULL) {          if (kdispwin.dd2hdl == NULL) {
                 goto kdcre_err2;                  goto kdcre_err2;
         }          }
         palfn.get8 = kdgetpal8;          palfn.get8 = kdgetpal8;
         palfn.get32 = kdgetpal32;          palfn.get32 = kdgetpal32;
         palfn.cnv16 = kdcnvpal16;          palfn.cnv16 = kdcnvpal16;
         palfn.userdata = (long)kdwin.dd2hdl;          palfn.userdata = (long)kdispwin.dd2hdl;
         keydisp_setpal(&palfn);          keydisp_setpal(&palfn);
         kdispwin_draw(0);          kdispwin_draw(0);
         SetForegroundWindow(hWndMain);          SetForegroundWindow(hWndMain);
Line 362  kdcre_err1: Line 358  kdcre_err1:
   
 void kdispwin_destroy(void) {  void kdispwin_destroy(void) {
   
         if (kdwin.hwnd != NULL) {          if (kdispwin.hwnd != NULL) {
                 DestroyWindow(kdwin.hwnd);                  DestroyWindow(kdispwin.hwnd);
         }          }
 }  }
   
 HWND kdispwin_gethwnd(void) {  HWND kdispwin_gethwnd(void) {
   
         return(kdwin.hwnd);          return(kdispwin.hwnd);
 }  }
   
 void kdispwin_draw(BYTE cnt) {  void kdispwin_draw(BYTE cnt) {
   
         BYTE    flag;          BYTE    flag;
   
         if (kdwin.hwnd) {          if (kdispwin.hwnd) {
                 if (!cnt) {                  if (!cnt) {
                         cnt = 1;                          cnt = 1;
                 }                  }
Line 384  void kdispwin_draw(BYTE cnt) { Line 380  void kdispwin_draw(BYTE cnt) {
                 if (flag & KEYDISP_FLAGSIZING) {                  if (flag & KEYDISP_FLAGSIZING) {
                         kdsetwinsize();                          kdsetwinsize();
                 }                  }
                 kddrawkeys(kdwin.hwnd, FALSE);                  kddrawkeys(kdispwin.hwnd, FALSE);
         }          }
 }  }
   
Line 396  void kdispwin_readini(void) { Line 392  void kdispwin_readini(void) {
         kdispcfg.posx = CW_USEDEFAULT;          kdispcfg.posx = CW_USEDEFAULT;
         kdispcfg.posy = CW_USEDEFAULT;          kdispcfg.posy = CW_USEDEFAULT;
         initgetfile(path, sizeof(path));          initgetfile(path, sizeof(path));
         ini_read(path, np2kdapp, np2kdini, sizeof(np2kdini)/sizeof(INITBL));          ini_read(path, kdispapp, kdispini, sizeof(kdispini)/sizeof(INITBL));
 }  }
   
 void kdispwin_writeini(void) {  void kdispwin_writeini(void) {
Line 404  void kdispwin_writeini(void) { Line 400  void kdispwin_writeini(void) {
         char    path[MAX_PATH];          char    path[MAX_PATH];
   
         initgetfile(path, sizeof(path));          initgetfile(path, sizeof(path));
         ini_write(path, np2kdapp, np2kdini, sizeof(np2kdini)/sizeof(INITBL));          ini_write(path, kdispapp, kdispini, sizeof(kdispini)/sizeof(INITBL));
   }
   #endif
   
   
   // ---- memdbg
   
   #if defined(CPUCORE_IA32) && defined(SUPPORT_MEMDBG32)
   
   typedef struct {
           HWND            hwnd;
           WINLOCEX        wlex;
           DD2HDL          dd2hdl;
           int                     width;
           int                     height;
   } MDBGWIN;
   
   typedef struct {
           int             posx;
           int             posy;
           UINT8   type;
   } MDBGCFG;
   
   static  MDBGWIN         mdbgwin;
   static  MDBGCFG         mdbgcfg;
   
   static const char mdbgapp[] = "Memory Map";
   static const char mdbgclass[] = "NP2-MemDbgWin";
   static const INITBL mdbgini[] = {
           {"WindposX", INITYPE_SINT32,    &mdbgcfg.posx,                  0},
           {"WindposY", INITYPE_SINT32,    &mdbgcfg.posy,                  0},
           {"windtype", INITYPE_BOOL,              &mdbgcfg.type,                  0}};
   
   
   static void mdpalcnv(CMNPAL *dst, const RGB32 *src, UINT pals, UINT bpp) {
   
           UINT    i;
   
           switch(bpp) {
   #if defined(SUPPORT_16BPP)
                   case 16:
                           for (i=0; i<pals; i++) {
                                   dst[i].pal16 = dd2_get16pal(mdbgwin.dd2hdl, src[i]);
                           }
                           break;
   #endif
   #if defined(SUPPORT_24BPP)
                   case 24:
   #endif
   #if defined(SUPPORT_32BPP)
                   case 32:
   #endif
   #if defined(SUPPORT_24BPP) || defined(SUPPORT_32BPP)
                           for (i=0; i<pals; i++) {
                                   dst[i].pal32.d = src[i].d;
                           }
                           break;
   #endif
           }
   }
   
   static void mdwincreate(HWND hWnd) {
   
           int                     width;
           int                     height;
   
           memdbg32_getsize(&width, &height);
   }
   
   static void mddrawwin(HWND hWnd, BOOL redraw) {
   
           RECT            rect;
           RECT            draw;
           CMNVRAM         *vram;
   
           GetClientRect(hWnd, &rect);
           draw.left = 0;
           draw.top = 0;
           draw.right = min(mdbgwin.width, rect.right - rect.left);
           draw.bottom = min(mdbgwin.height, rect.bottom - rect.top);
           vram = dd2_bsurflock(mdbgwin.dd2hdl);
           if (vram) {
                   memdbg32_paint(vram, mdpalcnv, redraw);
                   dd2_bsurfunlock(mdbgwin.dd2hdl);
                   dd2_blt(mdbgwin.dd2hdl, NULL, &draw);
           }
   }
   
   static void mdpaintmsg(HWND hWnd) {
   
           HDC                     hdc;
           PAINTSTRUCT     ps;
   
           hdc = BeginPaint(hWnd, &ps);
           mddrawwin(hWnd, TRUE);
           EndPaint(hWnd, &ps);
   }
   
   static LRESULT CALLBACK mdproc(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp) {
   
           switch(msg) {
                   case WM_CREATE:
                           np2class_wmcreate(hWnd);
                           winloc_setclientsize(hWnd, mdbgwin.width, mdbgwin.height);
                           np2class_windowtype(hWnd, (mdbgcfg.type & 1) + 1);
                           break;
   
                   case WM_PAINT:
                           mdpaintmsg(hWnd);
                           break;
   
                   case WM_KEYDOWN:
                   case WM_KEYUP:
                           SendMessage(hWndMain, msg, wp, lp);
                           break;
   
                   case WM_ENTERMENULOOP:
                           soundmng_disable(SNDPROC_SUBWIND);
                           break;
   
                   case WM_EXITMENULOOP:
                           soundmng_enable(SNDPROC_SUBWIND);
                           break;
   
                   case WM_ENTERSIZEMOVE:
                           soundmng_disable(SNDPROC_SUBWIND);
                           winlocex_destroy(mdbgwin.wlex);
                           mdbgwin.wlex = np2_winlocexallwin(hWnd);
                           break;
   
                   case WM_MOVING:
                           winlocex_moving(mdbgwin.wlex, (RECT *)lp);
                           break;
   
                   case WM_EXITSIZEMOVE:
                           winlocex_destroy(mdbgwin.wlex);
                           mdbgwin.wlex = NULL;
                           soundmng_enable(SNDPROC_SUBWIND);
                           break;
   
                   case WM_MOVE:
                           if (!(GetWindowLong(hWnd, GWL_STYLE) &
                                                                           (WS_MAXIMIZE | WS_MINIMIZE))) {
                                   RECT rc;
                                   GetWindowRect(hWnd, &rc);
                                   mdbgcfg.posx = rc.left;
                                   mdbgcfg.posy = rc.top;
                                   sysmng_update(SYS_UPDATEOSCFG);
                           }
                           break;
   
                   case WM_CLOSE:
                           DestroyWindow(hWnd);
                           break;
   
                   case WM_DESTROY:
                           np2class_wmdestroy(hWnd);
                           dd2_release(mdbgwin.dd2hdl);
                           mdbgwin.hwnd = NULL;
                           break;
   
                   default:
                           return(DefWindowProc(hWnd, msg, wp, lp));
           }
           return(0);
   }
   
   BOOL mdbgwin_initialize(HINSTANCE hInstance) {
   
           WNDCLASS        wc;
   
           wc.style = CS_BYTEALIGNCLIENT | CS_HREDRAW | CS_VREDRAW;
           wc.lpfnWndProc = mdproc;
           wc.cbClsExtra = 0;
           wc.cbWndExtra = 0;
           wc.hInstance = hInstance;
           wc.hIcon = NULL;
           wc.hCursor = LoadCursor(NULL, IDC_ARROW);
           wc.hbrBackground = (HBRUSH)GetStockObject(NULL_BRUSH);
           wc.lpszMenuName = NULL;
           wc.lpszClassName = mdbgclass;
           if (!RegisterClass(&wc)) {
                   return(FAILURE);
           }
           memdbg32_initialize();
           return(SUCCESS);
   }
   
   void mdbgwin_create(void) {
   
           HWND    hwnd;
   
           if (mdbgwin.hwnd != NULL) {
                   return;
           }
           ZeroMemory(&mdbgwin, sizeof(mdbgwin));
           memdbg32_getsize(&mdbgwin.width, &mdbgwin.height);
           hwnd = CreateWindow(mdbgclass, mdbgapp,
                                                   WS_OVERLAPPED | WS_SYSMENU | WS_CAPTION |
                                                   WS_MINIMIZEBOX,
                                                   mdbgcfg.posx, mdbgcfg.posy,
                                                   mdbgwin.width, mdbgwin.height,
                                                   NULL, NULL, hInst, NULL);
           mdbgwin.hwnd = hwnd;
           if (hwnd == NULL) {
                   goto mdcre_err1;
           }
           ShowWindow(hwnd, SW_SHOWNOACTIVATE);
           UpdateWindow(hwnd);
           mdbgwin.dd2hdl = dd2_create(hwnd, mdbgwin.width, mdbgwin.height);
           if (mdbgwin.dd2hdl == NULL) {
                   goto mdcre_err2;
           }
           InvalidateRect(hwnd, NULL, TRUE);
           SetForegroundWindow(hWndMain);
           return;
   
   mdcre_err2:
           DestroyWindow(hwnd);
   
   mdcre_err1:
           return;
   }
   
   void mdbgwin_destroy(void) {
   
           if (mdbgwin.hwnd) {
                   DestroyWindow(mdbgwin.hwnd);
           }
   }
   
   void mdbgwin_process(void) {
   
           if ((mdbgwin.hwnd) && (memdbg32_process())) {
                   mddrawwin(mdbgwin.hwnd, FALSE);
           }
   }
   
   HWND mdbgwin_gethwnd(void) {
   
           return(mdbgwin.hwnd);
   }
   
   void mdbgwin_readini(void) {
   
           char    path[MAX_PATH];
   
           mdbgcfg.posx = CW_USEDEFAULT;
           mdbgcfg.posy = CW_USEDEFAULT;
           initgetfile(path, sizeof(path));
           ini_read(path, mdbgapp, mdbgini, sizeof(mdbgini)/sizeof(INITBL));
   }
   
   void mdbgwin_writeini(void) {
   
           char    path[MAX_PATH];
   
           initgetfile(path, sizeof(path));
           ini_write(path, mdbgapp, mdbgini, sizeof(mdbgini)/sizeof(INITBL));
 }  }
 #endif  #endif
   
Line 416  typedef struct { Line 670  typedef struct {
         HWND            hwnd;          HWND            hwnd;
         WINLOCEX        wlex;          WINLOCEX        wlex;
         DD2HDL          dd2hdl;          DD2HDL          dd2hdl;
           int                     width;
           int                     height;
 } SKBDWIN;  } SKBDWIN;
   
 typedef struct {  typedef struct {
Line 427  typedef struct { Line 683  typedef struct {
 static  SKBDWIN         skbdwin;  static  SKBDWIN         skbdwin;
 static  SKBDCFG         skbdcfg;  static  SKBDCFG         skbdcfg;
   
 static const char np2skcaption[] = "Soft Keyboard";  static const char skbdapp[] = "Soft Keyboard";
 static const char np2skclass[] = "NP2-SoftKBDWin";  static const char skbdclass[] = "NP2-SoftKBDWin";
 static const char np2skapp[] = "NP2 softbkd";  static const INITBL skbdini[] = {
 static const INITBL np2skini[] = {  
         {"WindposX", INITYPE_SINT32,    &skbdcfg.posx,                  0},          {"WindposX", INITYPE_SINT32,    &skbdcfg.posx,                  0},
         {"WindposY", INITYPE_SINT32,    &skbdcfg.posy,                  0},          {"WindposY", INITYPE_SINT32,    &skbdcfg.posy,                  0},
         {"windtype", INITYPE_BOOL,              &skbdcfg.type,                  0}};          {"windtype", INITYPE_BOOL,              &skbdcfg.type,                  0}};
   
 static void skpalcnv(CMNPAL *dst, RGB32 *src, UINT pals, UINT bpp) {  static void skpalcnv(CMNPAL *dst, const RGB32 *src, UINT pals, UINT bpp) {
   
         UINT    i;          UINT    i;
   
         switch(bpp) {          switch(bpp) {
   #if defined(SUPPORT_16BPP)
                   case 16:
                           for (i=0; i<pals; i++) {
                                   dst[i].pal16 = dd2_get16pal(skbdwin.dd2hdl, src[i]);
                           }
                           break;
   #endif
   #if defined(SUPPORT_24BPP)
                   case 24:
   #endif
   #if defined(SUPPORT_32BPP)
                 case 32:                  case 32:
   #endif
   #if defined(SUPPORT_24BPP) || defined(SUPPORT_32BPP)
                         for (i=0; i<pals; i++) {                          for (i=0; i<pals; i++) {
                                 dst[i].pal32.d = src[i].d;                                  dst[i].pal32.d = src[i].d;
                         }                          }
                         break;                          break;
   #endif
         }          }
 }  }
   
 static void skpaintmsg(HWND hWnd) {  static void skdrawkeys(HWND hWnd, BOOL redraw) {
   
         HDC                     hdc;  
         PAINTSTRUCT     ps;  
         RECT            rect;          RECT            rect;
         RECT            draw;          RECT            draw;
         CMNVRAM         *vram;          CMNVRAM         *vram;
   
         TRACEOUT(("skpaintmsg"));  
         GetClientRect(hWnd, &rect);          GetClientRect(hWnd, &rect);
         draw.left = 0;          draw.left = 0;
         draw.top = 0;          draw.top = 0;
         draw.right = min(SOFTKBD_WIDTH, rect.right - rect.left);          draw.right = min(skbdwin.width, rect.right - rect.left);
         draw.bottom = min(SOFTKBD_HEIGHT, rect.bottom - rect.top);          draw.bottom = min(skbdwin.height, rect.bottom - rect.top);
         hdc = BeginPaint(hWnd, &ps);  
         vram = dd2_bsurflock(skbdwin.dd2hdl);          vram = dd2_bsurflock(skbdwin.dd2hdl);
         if (vram) {          if (vram) {
                 softkbd_paint(vram, skpalcnv);                  softkbd_paint(vram, skpalcnv, redraw);
                 dd2_bsurfunlock(skbdwin.dd2hdl);                  dd2_bsurfunlock(skbdwin.dd2hdl);
                 dd2_blt(skbdwin.dd2hdl, NULL, &draw);                  dd2_blt(skbdwin.dd2hdl, NULL, &draw);
         }          }
   }
   
   static void skpaintmsg(HWND hWnd) {
   
           HDC                     hdc;
           PAINTSTRUCT     ps;
   
           hdc = BeginPaint(hWnd, &ps);
           skdrawkeys(hWnd, TRUE);
         EndPaint(hWnd, &ps);          EndPaint(hWnd, &ps);
 }  }
   
Line 477  static LRESULT CALLBACK skproc(HWND hWnd Line 751  static LRESULT CALLBACK skproc(HWND hWnd
         switch(msg) {          switch(msg) {
                 case WM_CREATE:                  case WM_CREATE:
                         np2class_wmcreate(hWnd);                          np2class_wmcreate(hWnd);
                         winloc_setclientsize(hWnd, SOFTKBD_WIDTH, SOFTKBD_HEIGHT);                          winloc_setclientsize(hWnd, skbdwin.width, skbdwin.height);
                         np2class_windowtype(hWnd, (skbdcfg.type & 1) + 1);                          np2class_windowtype(hWnd, (skbdcfg.type & 1) + 1);
                         break;                          break;
   
Line 560  static LRESULT CALLBACK skproc(HWND hWnd Line 834  static LRESULT CALLBACK skproc(HWND hWnd
         return(0L);          return(0L);
 }  }
   
   
 // ----  
   
 BOOL skbdwin_initialize(HINSTANCE hPreInst) {  BOOL skbdwin_initialize(HINSTANCE hPreInst) {
   
         WNDCLASS        wc;          WNDCLASS        wc;
Line 578  BOOL skbdwin_initialize(HINSTANCE hPreIn Line 849  BOOL skbdwin_initialize(HINSTANCE hPreIn
                 wc.hCursor = LoadCursor(NULL, IDC_ARROW);                  wc.hCursor = LoadCursor(NULL, IDC_ARROW);
                 wc.hbrBackground = (HBRUSH)GetStockObject(NULL_BRUSH);                  wc.hbrBackground = (HBRUSH)GetStockObject(NULL_BRUSH);
                 wc.lpszMenuName = NULL;                  wc.lpszMenuName = NULL;
                 wc.lpszClassName = np2skclass;                  wc.lpszClassName = skbdclass;
                 if (!RegisterClass(&wc)) {                  if (!RegisterClass(&wc)) {
                         return(FAILURE);                          return(FAILURE);
                 }                  }
         }          }
           softkbd_initialize();
         return(SUCCESS);          return(SUCCESS);
 }  }
   
   void skbdwin_deinitialize(void) {
   
           softkbd_deinitialize();
   }
   
 void skbdwin_create(void) {  void skbdwin_create(void) {
   
         HWND    hwnd;          HWND    hwnd;
Line 594  void skbdwin_create(void) { Line 871  void skbdwin_create(void) {
                 return;                  return;
         }          }
         ZeroMemory(&skbdwin, sizeof(skbdwin));          ZeroMemory(&skbdwin, sizeof(skbdwin));
         hwnd = CreateWindow(np2skclass, np2skcaption,          if (softkbd_getsize(&skbdwin.width, &skbdwin.height) != SUCCESS) {
                   return;
           }
           hwnd = CreateWindow(skbdclass, skbdapp,
                                                 WS_OVERLAPPED | WS_SYSMENU | WS_CAPTION |                                                  WS_OVERLAPPED | WS_SYSMENU | WS_CAPTION |
                                                 WS_MINIMIZEBOX,                                                  WS_MINIMIZEBOX,
                                                 skbdcfg.posx, skbdcfg.posy,                                                  skbdcfg.posx, skbdcfg.posy,
                                                 SOFTKBD_WIDTH, SOFTKBD_HEIGHT,                                                  skbdwin.width, skbdwin.height,
                                                 NULL, NULL, hInst, NULL);                                                  NULL, NULL, hInst, NULL);
         skbdwin.hwnd = hwnd;          skbdwin.hwnd = hwnd;
         if (hwnd == NULL) {          if (hwnd == NULL) {
Line 606  void skbdwin_create(void) { Line 886  void skbdwin_create(void) {
         }          }
         ShowWindow(hwnd, SW_SHOWNOACTIVATE);          ShowWindow(hwnd, SW_SHOWNOACTIVATE);
         UpdateWindow(hwnd);          UpdateWindow(hwnd);
         skbdwin.dd2hdl = dd2_create(hwnd, SOFTKBD_WIDTH, SOFTKBD_HEIGHT);          skbdwin.dd2hdl = dd2_create(hwnd, skbdwin.width, skbdwin.height);
         if (skbdwin.dd2hdl == NULL) {          if (skbdwin.dd2hdl == NULL) {
                 goto skcre_err2;                  goto skcre_err2;
         }          }
Line 633  HWND skbdwin_gethwnd(void) { Line 913  HWND skbdwin_gethwnd(void) {
         return(skbdwin.hwnd);          return(skbdwin.hwnd);
 }  }
   
   void skbdwin_process(void) {
   
           if ((skbdwin.hwnd) && (softkbd_process())) {
                   skdrawkeys(skbdwin.hwnd, FALSE);
           }
   }
   
 void skbdwin_readini(void) {  void skbdwin_readini(void) {
   
         char    path[MAX_PATH];          char    path[MAX_PATH];
Line 640  void skbdwin_readini(void) { Line 927  void skbdwin_readini(void) {
         skbdcfg.posx = CW_USEDEFAULT;          skbdcfg.posx = CW_USEDEFAULT;
         skbdcfg.posy = CW_USEDEFAULT;          skbdcfg.posy = CW_USEDEFAULT;
         initgetfile(path, sizeof(path));          initgetfile(path, sizeof(path));
         ini_read(path, np2skapp, np2skini, sizeof(np2skini)/sizeof(INITBL));          ini_read(path, skbdapp, skbdini, sizeof(skbdini)/sizeof(INITBL));
 }  }
   
 void skbdwin_writeini(void) {  void skbdwin_writeini(void) {
Line 648  void skbdwin_writeini(void) { Line 935  void skbdwin_writeini(void) {
         char    path[MAX_PATH];          char    path[MAX_PATH];
   
         initgetfile(path, sizeof(path));          initgetfile(path, sizeof(path));
         ini_write(path, np2skapp, np2skini, sizeof(np2skini)/sizeof(INITBL));          ini_write(path, skbdapp, skbdini, sizeof(skbdini)/sizeof(INITBL));
 }  }
 #endif  #endif
   
Removed from v.1.1  
changed lines
  Added in v.1.9

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