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

Diff for /np2/wince/scrnmng.cpp between versions 1.2 and 1.7

version 1.2, 2003/11/21 06:51:15 version 1.7, 2004/02/18 02:03:37
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        "softkbd.res"
   #endif
   
   
   #if defined(GX_DLL)
   #pragma comment(lib, "gx.lib")
   #endif
   
   
 typedef struct {  typedef struct {
Line 18  typedef struct { Line 26  typedef struct {
         long    start;          long    start;
         long    xalign;          long    xalign;
         long    yalign;          long    yalign;
   #if defined(SUPPORT_SOFTKBD)
           int             allflash;
           BMPFILE *kbd;
   #endif
 } SCRNMNG;  } SCRNMNG;
   
 typedef struct {  typedef struct {
Line 32  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 72  static BOOL calcdrawrect(DRAWRECT *dr, V Line 85  static BOOL calcdrawrect(DRAWRECT *dr, V
         return(SUCCESS);          return(SUCCESS);
 }  }
   
 void scrnmng_keybinds(struct GXKeyList *gxkey) {  static void bmp16draw(BMPFILE *bf, BYTE *dst, int width, int height,
                                                                                                   int xalign, int yalign) {
   
         short   tmp;  const BMPINFO   *bi;
   const BYTE              *pal;
           BMPDATA         inf;
           BYTE            *src;
           int                     bmpalign;
           UINT            pals;
           UINT16          paltbl[16];
           UINT            c;
           int                     x;
           int                     y;
   
         if (scrnmng.rotate) {          if (bf == NULL) {
                 tmp = gxkey->vkLeft;                  goto b16d_err;
                 gxkey->vkLeft = gxkey->vkDown;  
                 gxkey->vkDown = gxkey->vkRight;  
                 gxkey->vkRight = gxkey->vkUp;  
                 gxkey->vkUp = tmp;  
         }          }
           bi = (BMPINFO *)(bf + 1);
           pal = (BYTE *)(bi + 1);
           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;
 }  }
   
   
Line 154  BOOL scrnmng_create(HWND hWnd, LONG widt Line 220  BOOL scrnmng_create(HWND hWnd, LONG widt
         }          }
         gx_disable = 0;          gx_disable = 0;
         scrnmng_clear(TRUE);          scrnmng_clear(TRUE);
   #if defined(SUPPORT_SOFTKBD)
           scrnmng.kbd = (BMPFILE *)bmpdata_solvedata(np2kbd_bmp);
   #endif
         return(SUCCESS);          return(SUCCESS);
 }  }
   
Line 161  void scrnmng_destroy(void) { Line 230  void scrnmng_destroy(void) {
   
         gx_disable = 1;          gx_disable = 1;
         GXCloseDisplay();          GXCloseDisplay();
   #if defined(SUPPORT_SOFTKBD)
           if (scrnmng.kbd) {
                   _MFREE(scrnmng.kbd);
                   scrnmng.kbd = NULL;
           }
   #endif
 }  }
   
   #if defined(SUPPORT_SOFTKBD)
   void scrnmng_allflash(void) {
   
           scrnmng.allflash = 1;
   }
   #endif
   
 RGB16 scrnmng_makepal16(RGB32 pal32) {  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) && !defined(SIZE_VGATEST)
         ret += (pal32.p.g & 0xfc) << (3 + 16);          ret += (pal32.p.g & 0xfc) << (3 + 16);
   #else
           ret += (pal32.p.g & 0xfc) << 3;
   #endif
         ret += pal32.p.b >> 3;          ret += pal32.p.b >> 3;
         return(ret);          return(ret);
 }  }
Line 198  const SCRNSURF *scrnmng_surflock(void) { Line 284  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 218  const BYTE  *a; Line 309  const BYTE  *a;
   
         rt.left = 0;          rt.left = 0;
         rt.top = 0;          rt.top = 0;
         rt.right = min(scrnstat.width, 640);  #if defined(SUPPORT_SOFTKBD)
         rt.bottom = min(scrnstat.height, 400);          if (!scrnmng.allflash) {
   #endif
                   rt.right = min(scrnstat.width, 640);
                   rt.bottom = min(scrnstat.height, 400);
 #if defined(SIZE_QVGA)  #if defined(SIZE_QVGA)
         rt.right >>= 1;                  rt.right >>= 1;
         rt.bottom >>= 1;                  rt.bottom >>= 1;
   #endif
   #if defined(SUPPORT_SOFTKBD)
           }
           else {
                   scrnmng.allflash = 0;
                   rt.right = scrnmng.width;
                   rt.bottom = scrnmng.height;
           }
 #endif  #endif
         if (calcdrawrect(&dr, menuvram, &rt) != SUCCESS) {          if (calcdrawrect(&dr, menuvram, &rt) != SUCCESS) {
                 return;                  return;
Line 253  void scrnmng_surfunlock(const SCRNSURF * Line 355  void scrnmng_surfunlock(const SCRNSURF *
   
         if (surf) {          if (surf) {
                 if (scrnmng.vram == NULL) {                  if (scrnmng.vram == NULL) {
   #if defined(SUPPORT_SOFTKBD)
                           if (scrnmng.allflash) {
                                   scrnmng.allflash = 0;
                           }
                           bmp16draw(scrnmng.kbd, surf->ptr + (surf->yalign * 200), 320, 40,
                                                                                                   surf->xalign, surf->yalign);
   #endif
                         GXEndDraw();                          GXEndDraw();
                 }                  }
                 else {                  else {
Line 263  void scrnmng_surfunlock(const SCRNSURF * Line 372  void scrnmng_surfunlock(const SCRNSURF *
         }          }
 }  }
   
 void scrnmng_update(void) {  
 }  
   
   
 // ---- for wince  // ---- for wince
   
Line 299  BOOL scrnmng_mousepos(LPARAM *lp) { Line 405  BOOL scrnmng_mousepos(LPARAM *lp) {
         return(SUCCESS);          return(SUCCESS);
 }  }
   
   void scrnmng_clear(BOOL logo) {
   
           BMPFILE *bf;
           BYTE    *p;
           BYTE    *q;
           int             y;
           int             x;
           long    yalign;
   
           if (gx_disable) {
                   return;
           }
           bf = NULL;
           if (logo) {
                   bf = (BMPFILE *)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(bf, p + scrnmng.start, scrnmng.width, scrnmng.height,
                                                                                           scrnmng.xalign, scrnmng.yalign);
           GXEndDraw();
           if (bf) {
                   _MFREE(bf);
           }
   }
   
   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
   
Line 313  BOOL scrnmng_entermenu(SCRNMENU *smenu)  Line 468  BOOL scrnmng_entermenu(SCRNMENU *smenu) 
                 goto smem_err;                  goto smem_err;
         }          }
         scrndraw_redraw();          scrndraw_redraw();
   #if defined(SUPPORT_SOFTKBD)
           bmp16draw(scrnmng.kbd, scrnmng.vram->ptr + (640 * 200), 320, 40, 2, 640);
   #endif
         smenu->width = scrnmng.width;          smenu->width = scrnmng.width;
         smenu->height = scrnmng.height;          smenu->height = scrnmng.height;
         smenu->bpp = 16;          smenu->bpp = 16;
Line 372  const BYTE  *q; Line 530  const BYTE  *q;
         GXEndDraw();          GXEndDraw();
 }  }
   
   
 // ---- clear  
   
 static void np2open_draw(BYTE *dst, BMPFILE *bf) {  
   
 const BMPINFO   *bi;  
 const BYTE              *pal;  
         BMPDATA         inf;  
         BYTE            *src;  
         int                     bmpalign;  
         long            yalign;  
         UINT            pals;  
         UINT16          paltbl[16];  
         UINT            c;  
         int                     x;  
         int                     y;  
   
         if (bf == NULL) {  
                 goto nod_err;  
         }  
         bi = (BMPINFO *)(bf + 1);  
         pal = (BYTE *)(bi + 1);  
         if (((bf->bfType[0] != 'B') && (bf->bfType[1] != 'M')) ||  
                 (bmpdata_getinfo(bi, &inf) != SUCCESS) || (inf.bpp != 4)) {  
                 goto nod_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 ((scrnmng.width < inf.width) || (scrnmng.height < inf.height)) {  
                 goto nod_err;  
         }  
         dst += scrnmng.start;  
         dst += ((scrnmng.width - inf.width) / 2) * scrnmng.xalign;  
         dst += ((scrnmng.height - inf.height) / 2) * scrnmng.yalign;  
         yalign = scrnmng.yalign - (inf.width * scrnmng.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 += scrnmng.xalign;  
                 }  
                 src += bmpalign;  
                 dst += yalign;  
         }  
   
 nod_err:  
         return;  
 }  
   
 void scrnmng_clear(BOOL logo) {  
   
         BMPFILE *bf;  
         BYTE    *p;  
         BYTE    *q;  
         int             y;  
         int             x;  
         long    yalign;  
   
         if (gx_disable) {  
                 return;  
         }  
         bf = NULL;  
         if (logo) {  
                 bf = (BMPFILE *)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);  
         if (bf) {  
                 np2open_draw(p, bf);  
         }  
         GXEndDraw();  
         if (bf) {  
                 _MFREE(bf);  
         }  
 }  
   
Removed from v.1.2  
changed lines
  Added in v.1.7

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