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

Diff for /np2/wince/scrnmng.cpp between versions 1.4 and 1.9

version 1.4, 2003/12/01 03:38:52 version 1.9, 2004/07/15 13:48:40
Line 6 Line 6
 #include        "vramhdl.h"  #include        "vramhdl.h"
 #include        "menubase.h"  #include        "menubase.h"
 #include        "nekop2.res"  #include        "nekop2.res"
 #if defined(SUPPORT_SOFTKBD)  #include        "cmndraw.h"
 #include        "softkbd.res"  #include        "softkbd.h"
   
   
   #if defined(GX_DLL)
   #pragma comment(lib, "gx.lib")
 #endif  #endif
   
   
Line 22  typedef struct { Line 26  typedef struct {
         long    xalign;          long    xalign;
         long    yalign;          long    yalign;
 #if defined(SUPPORT_SOFTKBD)  #if defined(SUPPORT_SOFTKBD)
           int             kbdposy;
           int             kbdheight;
         int             allflash;          int             allflash;
         BMPFILE *kbd;  
 #endif  #endif
 } SCRNMNG;  } SCRNMNG;
   
Line 39  static SCRNSTAT scrnstat; Line 44  static SCRNSTAT scrnstat;
 static  SCRNSURF        scrnsurf;  static  SCRNSURF        scrnsurf;
   
 static  BYTE            gx_disable = 1;  static  BYTE            gx_disable = 1;
   extern  GXKeyList       gx_keylist;
   
 static const TCHAR      errmsg[] = STRLITERAL("Error");  static const TCHAR      errmsg[] = STRLITERAL("Error");
   
Line 79  static BOOL calcdrawrect(DRAWRECT *dr, V Line 85  static BOOL calcdrawrect(DRAWRECT *dr, V
         return(SUCCESS);          return(SUCCESS);
 }  }
   
 static void bmp16draw(BMPFILE *bf, BYTE *dst, int width, int height,  static void palcnv(CMNPAL *dst, const RGB32 *src, UINT pals, UINT bpp) {
                                                                                                 int xalign, int yalign) {  
   
 const BMPINFO   *bi;          UINT    i;
 const BYTE              *pal;  
         BMPDATA         inf;  
         BYTE            *src;  
         int                     bmpalign;  
         UINT            pals;  
         UINT16          paltbl[16];  
         UINT            c;  
         int                     x;  
         int                     y;  
   
         if (bf == NULL) {          if (bpp == 16) {
                 goto b16d_err;                  for (i=0; i<pals; i++) {
         }                          dst[i].pal16 = ((src[i].p.r & 0xf8) << 8) |
         bi = (BMPINFO *)(bf + 1);                                                          ((src[i].p.g & 0xfc) << 3) |
         pal = (BYTE *)(bi + 1);                                                          (src[i].p.b >> 3);
         if (((bf->bfType[0] != 'B') && (bf->bfType[1] != 'M')) ||  
                 (bmpdata_getinfo(bi, &inf) != SUCCESS) || (inf.bpp != 4)) {  
                 goto b16d_err;  
         }  
         src = (BYTE *)bf + (LOADINTELDWORD(bf->bfOffBits));  
         bmpalign = bmpdata_getalign(bi);  
         if (inf.height > 0) {  
                 src += (inf.height - 1) * bmpalign;  
                 bmpalign *= -1;  
         }  
         else {  
                 inf.height *= -1;  
         }  
         if ((width < inf.width) || (height < inf.height)) {  
                 goto b16d_err;  
         }  
         dst += ((width - inf.width) / 2) * xalign;  
         dst += ((height - inf.height) / 2) * yalign;  
         yalign -= (inf.width * xalign);  
   
         pals = LOADINTELDWORD(bi->biClrUsed);  
         pals = min(pals, 16);  
         ZeroMemory(paltbl, sizeof(paltbl));  
         for (c=0; c<pals; c++) {  
                 paltbl[c] = ((pal[c*4+2] & 0xf8) << 8) +  
                                         ((pal[c*4+1] & 0xfc) << 3) + (pal[c*4+0] >> 3);  
         }  
   
         for (y=0; y<inf.height; y++) {  
                 for (x=0; x<inf.width; x++) {  
                         if (!(x & 1)) {  
                                 c = src[x >> 1] >> 4;  
                         }  
                         else {  
                                 c = src[x >> 1] & 15;  
                         }  
                         *(UINT16 *)dst = paltbl[c];  
                         dst += xalign;  
                 }                  }
                 src += bmpalign;  
                 dst += yalign;  
         }          }
   
 b16d_err:  
         return;  
 }  }
   
 void scrnmng_keybinds(struct GXKeyList *gxkey) {  static void bmp16draw(void *bmp, BYTE *dst, int width, int height,
                                                                                                   int xalign, int yalign) {
   
         short   tmp;          CMNVRAM vram;
   
         if (scrnmng.rotate) {          vram.ptr = dst;
                 tmp = gxkey->vkLeft;          vram.width = width;
                 gxkey->vkLeft = gxkey->vkDown;          vram.height = height;
                 gxkey->vkDown = gxkey->vkRight;          vram.xalign = xalign;
                 gxkey->vkRight = gxkey->vkUp;          vram.yalign = yalign;
                 gxkey->vkUp = tmp;          vram.bpp = 16;
         }          cmndraw_bmp16(&vram, bmp, palcnv, CMNBMP_CENTER | CMNBMP_MIDDLE);
 }  }
   
   
Line 170  void scrnmng_initialize(void) { Line 124  void scrnmng_initialize(void) {
 BOOL scrnmng_create(HWND hWnd, LONG width, LONG height) {  BOOL scrnmng_create(HWND hWnd, LONG width, LONG height) {
   
         TCHAR   msg[32];          TCHAR   msg[32];
   #if defined(SUPPORT_SOFTKBD)
           int             kbdheight;
   #endif
   
         if ((width <= 0) || (height <= 0)) {          if ((width <= 0) || (height <= 0)) {
                 return(FAILURE);                  return(FAILURE);
Line 228  BOOL scrnmng_create(HWND hWnd, LONG widt Line 185  BOOL scrnmng_create(HWND hWnd, LONG widt
         gx_disable = 0;          gx_disable = 0;
         scrnmng_clear(TRUE);          scrnmng_clear(TRUE);
 #if defined(SUPPORT_SOFTKBD)  #if defined(SUPPORT_SOFTKBD)
         scrnmng.kbd = (BMPFILE *)bmpdata_solvedata(np2kbd_bmp);          softkbd_initialize();
           if (softkbd_getsize(NULL, &kbdheight) != SUCCESS) {
                   kbdheight = 0;
           }
           kbdheight = min(kbdheight, height);
           scrnmng.kbdposy = height - kbdheight;
           scrnmng.kbdheight = kbdheight;
 #endif  #endif
         return(SUCCESS);          return(SUCCESS);
 }  }
Line 238  void scrnmng_destroy(void) { Line 201  void scrnmng_destroy(void) {
         gx_disable = 1;          gx_disable = 1;
         GXCloseDisplay();          GXCloseDisplay();
 #if defined(SUPPORT_SOFTKBD)  #if defined(SUPPORT_SOFTKBD)
         if (scrnmng.kbd) {          softkbd_deinitialize();
                 _MFREE(scrnmng.kbd);  
                 scrnmng.kbd = NULL;  
         }  
 #endif  #endif
 }  }
   
Line 257  RGB16 scrnmng_makepal16(RGB32 pal32) { Line 217  RGB16 scrnmng_makepal16(RGB32 pal32) {
         RGB16   ret;          RGB16   ret;
   
         ret = (pal32.p.r & 0xf8) << 8;          ret = (pal32.p.r & 0xf8) << 8;
 #if defined(SIZE_QVGA)  #if defined(SIZE_QVGA) && !defined(SIZE_VGATEST)
         ret += (pal32.p.g & 0xfc) << (3 + 16);          ret += (pal32.p.g & 0xfc) << (3 + 16);
 #else  #else
         ret += (pal32.p.g & 0xfc) << 3;          ret += (pal32.p.g & 0xfc) << 3;
Line 291  const SCRNSURF *scrnmng_surflock(void) { Line 251  const SCRNSURF *scrnmng_surflock(void) {
                 scrnsurf.xalign = 2;                  scrnsurf.xalign = 2;
                 scrnsurf.yalign = scrnmng.vram->yalign;                  scrnsurf.yalign = scrnmng.vram->yalign;
         }          }
   #if !defined(SIZE_VGATEST)
         scrnsurf.width = min(scrnstat.width, 640);          scrnsurf.width = min(scrnstat.width, 640);
         scrnsurf.height = min(scrnstat.height, 400);          scrnsurf.height = min(scrnstat.height, 400);
   #else
           scrnsurf.width = min(scrnstat.width, 320);
           scrnsurf.height = min(scrnstat.height, 200);
   #endif
         scrnsurf.bpp = 16;          scrnsurf.bpp = 16;
         scrnsurf.extend = 0;          scrnsurf.extend = 0;
         return(&scrnsurf);          return(&scrnsurf);
Line 355  const BYTE  *a; Line 320  const BYTE  *a;
   
 void scrnmng_surfunlock(const SCRNSURF *surf) {  void scrnmng_surfunlock(const SCRNSURF *surf) {
   
   #if defined(SUPPORT_SOFTKBD)
           CMNVRAM vram;
   #endif
   
         if (surf) {          if (surf) {
                 if (scrnmng.vram == NULL) {                  if (scrnmng.vram == NULL) {
 #if defined(SUPPORT_SOFTKBD)  #if defined(SUPPORT_SOFTKBD)
                         if (scrnmng.allflash) {                          if (scrnmng.allflash) {
                                 scrnmng.allflash = 0;                                  scrnmng.allflash = 0;
                                   vram.ptr = surf->ptr + (scrnmng.kbdposy * surf->yalign);
                                   vram.width = scrnmng.width;
                                   vram.height = scrnmng.kbdheight;
                                   vram.xalign = surf->xalign;
                                   vram.yalign = surf->yalign;
                                   vram.bpp = 16;
                                   softkbd_paint(&vram, palcnv, TRUE);
                         }                          }
                         bmp16draw(scrnmng.kbd, surf->ptr + (surf->yalign * 200), 320, 40,  
                                                                                                 surf->xalign, surf->yalign);  
 #endif  #endif
                         GXEndDraw();                          GXEndDraw();
                 }                  }
Line 407  BOOL scrnmng_mousepos(LPARAM *lp) { Line 381  BOOL scrnmng_mousepos(LPARAM *lp) {
         return(SUCCESS);          return(SUCCESS);
 }  }
   
   void scrnmng_clear(BOOL logo) {
   
           void    *bmp;
           BYTE    *p;
           BYTE    *q;
           int             y;
           int             x;
           long    yalign;
   
           if (gx_disable) {
                   return;
           }
           bmp = NULL;
           if (logo) {
                   bmp = (void *)bmpdata_solvedata(nekop2_bmp);
           }
           p = (BYTE *)GXBeginDraw();
           q = p;
           y = gx_dp.cyHeight;
           yalign = gx_dp.cbyPitch - (gx_dp.cbxPitch * gx_dp.cxWidth);
           do {
                   x = gx_dp.cxWidth;
                   do {
                           *(UINT16 *)q = 0;
                           q += gx_dp.cbxPitch;
                   } while(--x);
                   q += yalign;
           } while(--y);
           bmp16draw(bmp, p + scrnmng.start, scrnmng.width, scrnmng.height,
                                                                                                   scrnmng.xalign, scrnmng.yalign);        GXEndDraw();
           if (bmp) {
                   _MFREE(bmp);
           }
   }
   
   void scrnmng_keybinds(void) {
   
           short   tmp;
   
           if (scrnmng.rotate) {
                   tmp = gx_keylist.vkLeft;
                   gx_keylist.vkLeft = gx_keylist.vkDown;
                   gx_keylist.vkDown = gx_keylist.vkRight;
                   gx_keylist.vkRight = gx_keylist.vkUp;
                   gx_keylist.vkUp = tmp;
           }
   }
   
   
 // ---- for menubase  // ---- for menubase
   
 BOOL scrnmng_entermenu(SCRNMENU *smenu) {  BOOL scrnmng_entermenu(SCRNMENU *smenu) {
   
           VRAMHDL vram;
   #if defined(SUPPORT_SOFTKBD)
           CMNVRAM kbdvram;
   #endif
   
         if (smenu == NULL) {          if (smenu == NULL) {
                 goto smem_err;                  goto smem_err;
         }          }
         vram_destroy(scrnmng.vram);          vram_destroy(scrnmng.vram);
         scrnmng.vram = vram_create(scrnmng.width, scrnmng.height, FALSE, 16);          vram = vram_create(scrnmng.width, scrnmng.height, FALSE, 16);
         if (scrnmng.vram == NULL) {          scrnmng.vram = vram;
           if (vram == NULL) {
                 goto smem_err;                  goto smem_err;
         }          }
         scrndraw_redraw();          scrndraw_redraw();
 #if defined(SUPPORT_SOFTKBD)  #if defined(SUPPORT_SOFTKBD)
         bmp16draw(scrnmng.kbd, scrnmng.vram->ptr + (640 * 200), 320, 40, 2, 640);          kbdvram.ptr = vram->ptr + (vram->yalign * scrnmng.kbdposy);
           kbdvram.width = vram->width;
           kbdvram.height = scrnmng.kbdheight;
           kbdvram.xalign = vram->xalign;
           kbdvram.yalign = vram->yalign;
           kbdvram.bpp = vram->bpp;
           softkbd_paint(&kbdvram, palcnv, TRUE);
 #endif  #endif
         smenu->width = scrnmng.width;          smenu->width = scrnmng.width;
         smenu->height = scrnmng.height;          smenu->height = scrnmng.height;
Line 484  const BYTE  *q; Line 518  const BYTE  *q;
 }  }
   
   
 // ---- clear  // ----
   
 void scrnmng_clear(BOOL logo) {  #if defined(SUPPORT_SOFTKBD)
   BOOL scrnmng_kbdpos(LPARAM *lp) {
   
         BMPFILE *bf;          UINT    x;
         BYTE    *p;          UINT    y;
         BYTE    *q;  
         int             y;  
         int             x;  
         long    yalign;  
   
         if (gx_disable) {          x = LOWORD(*lp);
                 return;          y = HIWORD(*lp) - scrnmng.kbdposy;
         }          *lp = (x & 0xffff) | ((y << 16) & 0xffff0000);
         bf = NULL;          return(SUCCESS);
         if (logo) {  }
                 bf = (BMPFILE *)bmpdata_solvedata(nekop2_bmp);  
   BOOL scrnmng_ismenu(LPARAM lp) {
   
           if ((LOWORD(lp) < 32) && (HIWORD(lp) >= (scrnmng.height - 32))) {
                   return(TRUE);
         }          }
         p = (BYTE *)GXBeginDraw();          else {
         q = p;                  return(FALSE);
         y = gx_dp.cyHeight;  
         yalign = gx_dp.cbyPitch - (gx_dp.cbxPitch * gx_dp.cxWidth);  
         do {  
                 x = gx_dp.cxWidth;  
                 do {  
                         *(UINT16 *)q = 0;  
                         q += gx_dp.cbxPitch;  
                 } while(--x);  
                 q += yalign;  
         } while(--y);  
         bmp16draw(bf, p + scrnmng.start, scrnmng.width, scrnmng.height,  
                                                                                         scrnmng.xalign, scrnmng.yalign);  
         GXEndDraw();  
         if (bf) {  
                 _MFREE(bf);  
         }          }
 }  }
   #endif
   
Removed from v.1.4  
changed lines
  Added in v.1.9

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