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

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

version 1.1, 2003/10/21 14:57:41 version 1.9, 2004/07/15 13:48:40
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
 #include        <gx.h>  #include        <gx.h>
   #include        "bmpdata.h"
 #include        "scrnmng.h"  #include        "scrnmng.h"
 // #include     "pccore.h"  #include        "scrndraw.h"
 // #include     "scrndraw.h"  #include        "vramhdl.h"
 // #include     "palettes.h"  #include        "menubase.h"
 // #include     "menu.h"  #include        "nekop2.res"
   #include        "cmndraw.h"
   #include        "softkbd.h"
   
   
                 GXDisplayProperties             gx_dp;  #if defined(GX_DLL)
   #pragma comment(lib, "gx.lib")
 static  HWND            TagWnd = NULL;  #endif
 static  BOOL            TagRot = FALSE;  
 static  DWORD           TagPosx = 0;  
 static  DWORD           TagPosy = 0;  
 static  DWORD           TagWidth = 0;  
 static  DWORD           TagHeight = 0;  
 static  long            TagStart = 0;  
 static  BYTE            gx_disable = 1;  
   
 static const TCHAR      errmsg[] = STRLITERAL("Error");  
   
   typedef struct {
           BOOL    rotate;
           VRAMHDL vram;
           UINT    posx;
           UINT    posy;
           int             width;
           int             height;
           long    start;
           long    xalign;
           long    yalign;
   #if defined(SUPPORT_SOFTKBD)
           int             kbdposy;
           int             kbdheight;
           int             allflash;
   #endif
   } SCRNMNG;
   
   typedef struct {
           int             width;
           int             height;
   } SCRNSTAT;
   
 #if 0          GXDisplayProperties             gx_dp;
 void gdraws_enable(BOOL enable) {  
   
         if (enable) {  static  SCRNMNG         scrnmng;
                 gx_disable &= ~2;  static  SCRNSTAT        scrnstat;
         }  static  SCRNSURF        scrnsurf;
         else {  
                 gx_disable |= 2;  
         }  
 }  
   
 BOOL gdraws_mousepos(LPARAM *lp) {  static  BYTE            gx_disable = 1;
   extern  GXKeyList       gx_keylist;
   
         DWORD   x, y;  static const TCHAR      errmsg[] = STRLITERAL("Error");
   
         if (!TagRot) {  
                 x = LOWORD(*lp) - TagPosx;  typedef struct {
                 y = HIWORD(*lp) - TagPosy;          int             xalign;
         }          int             yalign;
         else {          int             width;
                 x = TagWidth - HIWORD(*lp) - 1 - TagPosy;          int             height;
                 y = LOWORD(*lp) - TagPosx;          int             srcpos;
           int             dstpos;
   } DRAWRECT;
   
   static BOOL calcdrawrect(DRAWRECT *dr, VRAMHDL s, const RECT_T *rt) {
   
           int             pos;
   
           dr->xalign = scrnmng.xalign;
           dr->yalign = scrnmng.yalign;
           dr->srcpos = 0;
           dr->dstpos = scrnmng.start;
           dr->width = min(scrnmng.width, s->width);
           dr->height = min(scrnmng.height, s->height);
           if (rt) {
                   pos = max(rt->left, 0);
                   dr->srcpos += pos;
                   dr->dstpos += pos * dr->xalign;
                   dr->width = min(rt->right, dr->width) - pos;
   
                   pos = max(rt->top, 0);
                   dr->srcpos += pos * s->width;
                   dr->dstpos += pos * dr->yalign;
                   dr->height = min(rt->bottom, dr->height) - pos;
         }          }
         if ((x >= TagWidth) || (y >= TagHeight)) {          if ((dr->width <= 0) || (dr->height <= 0)) {
                 return(FAILURE);                  return(FAILURE);
         }          }
         *lp = (x & 0xffff) | ((y << 16) & 0xffff0000);  
         return(SUCCESS);          return(SUCCESS);
 }  }
   
 void gdraws_keybinds(struct GXKeyList *gxkey) {  static void palcnv(CMNPAL *dst, const RGB32 *src, UINT pals, UINT bpp) {
   
         short   tmp;          UINT    i;
   
         if (TagRot) {          if (bpp == 16) {
                 tmp = gxkey->vkLeft;                  for (i=0; i<pals; i++) {
                 gxkey->vkLeft = gxkey->vkDown;                          dst[i].pal16 = ((src[i].p.r & 0xf8) << 8) |
                 gxkey->vkDown = gxkey->vkRight;                                                          ((src[i].p.g & 0xfc) << 3) |
                 gxkey->vkRight = gxkey->vkUp;                                                          (src[i].p.b >> 3);
                 gxkey->vkUp = tmp;                  }
         }          }
 }  }
   
 long gdraws_getyalign(void) {  static void bmp16draw(void *bmp, BYTE *dst, int width, int height,
                                                                                                   int xalign, int yalign) {
   
         if (!TagRot) {          CMNVRAM vram;
                 return(gx_dp.cbyPitch);  
         }  
         else {  
                 return(gx_dp.cbxPitch);  
         }  
 }  
 #endif  
   
   
 // ----  
   
 typedef struct {  
         int             width;  
         int             height;  
 } SCRNSTAT;  
   
 static  SCRNSTAT        scrnstat;          vram.ptr = dst;
 static  SCRNSURF        scrnsurf;          vram.width = width;
           vram.height = height;
           vram.xalign = xalign;
           vram.yalign = yalign;
           vram.bpp = 16;
           cmndraw_bmp16(&vram, bmp, palcnv, CMNBMP_CENTER | CMNBMP_MIDDLE);
   }
   
   
 // ----  // ----
Line 98  void scrnmng_initialize(void) { Line 123  void scrnmng_initialize(void) {
   
 BOOL scrnmng_create(HWND hWnd, LONG width, LONG height) {  BOOL scrnmng_create(HWND hWnd, LONG width, LONG height) {
   
         BOOL    ret = SUCCESS;          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 122  BOOL scrnmng_create(HWND hWnd, LONG widt Line 150  BOOL scrnmng_create(HWND hWnd, LONG widt
   
         if ((gx_dp.cxWidth >= (DWORD)width) &&          if ((gx_dp.cxWidth >= (DWORD)width) &&
                 (gx_dp.cyHeight >= (DWORD)height)) {                  (gx_dp.cyHeight >= (DWORD)height)) {
                 TagRot = FALSE;                  scrnmng.rotate = FALSE;
         }          }
         else if ((gx_dp.cxWidth >= (DWORD)height) &&          else if ((gx_dp.cxWidth >= (DWORD)height) &&
                         (gx_dp.cyHeight >= (DWORD)width)) {                          (gx_dp.cyHeight >= (DWORD)width)) {
                 TagRot = TRUE;                  scrnmng.rotate = TRUE;
         }          }
         else {          else {
                 TCHAR   msg[32];  
                 wsprintf(msg, STRLITERAL("Required %dx%d..."), width, height);                  wsprintf(msg, STRLITERAL("Required %dx%d..."), width, height);
                 MessageBox(hWnd, msg, errmsg, MB_OK | MB_ICONSTOP);                  MessageBox(hWnd, msg, errmsg, MB_OK | MB_ICONSTOP);
                 return(FAILURE);                  return(FAILURE);
         }          }
   
         if (!TagRot) {          if (!scrnmng.rotate) {
                 TagPosx = ((gx_dp.cxWidth - width) / 2);                  scrnmng.posx = ((gx_dp.cxWidth - width) / 2);
                 TagPosy = ((gx_dp.cyHeight - height) / 2);                  scrnmng.posy = ((gx_dp.cyHeight - height) / 2);
                 TagStart = TagPosx * gx_dp.cbxPitch + TagPosy * gx_dp.cbyPitch;                  scrnmng.start = scrnmng.posx * gx_dp.cbxPitch +
                 TagWidth = width;                                                  scrnmng.posy * gx_dp.cbyPitch;
                 TagHeight = height;                  scrnmng.width = width;
                   scrnmng.height = height;
                   scrnmng.xalign = gx_dp.cbxPitch;
                   scrnmng.yalign = gx_dp.cbyPitch;
         }          }
         else {          else {
                 TagPosx = ((gx_dp.cxWidth - height) / 2);                  scrnmng.posx = ((gx_dp.cxWidth - height) / 2);
                 TagPosy = ((gx_dp.cyHeight - width) / 2);                  scrnmng.posy = ((gx_dp.cyHeight - width) / 2);
                 TagStart = ((TagPosy + width - 1) * gx_dp.cbyPitch) +                  scrnmng.start = ((scrnmng.posy + width - 1) * gx_dp.cbyPitch) +
                                         (TagPosx * gx_dp.cbxPitch);                                                  (scrnmng.posx * gx_dp.cbxPitch);
                 TagWidth = width;                  scrnmng.width = width;
                 TagHeight = height;                  scrnmng.height = height;
                   scrnmng.xalign = -gx_dp.cbyPitch;
                   scrnmng.yalign = gx_dp.cbxPitch;
         }          }
         gx_disable = 0;          gx_disable = 0;
           scrnmng_clear(TRUE);
   #if defined(SUPPORT_SOFTKBD)
           softkbd_initialize();
           if (softkbd_getsize(NULL, &kbdheight) != SUCCESS) {
                   kbdheight = 0;
           }
           kbdheight = min(kbdheight, height);
           scrnmng.kbdposy = height - kbdheight;
           scrnmng.kbdheight = kbdheight;
   #endif
         return(SUCCESS);          return(SUCCESS);
 }  }
   
Line 158  void scrnmng_destroy(void) { Line 200  void scrnmng_destroy(void) {
   
         gx_disable = 1;          gx_disable = 1;
         GXCloseDisplay();          GXCloseDisplay();
   #if defined(SUPPORT_SOFTKBD)
           softkbd_deinitialize();
   #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 185  const SCRNSURF *scrnmng_surflock(void) { Line 241  const SCRNSURF *scrnmng_surflock(void) {
         if (gx_disable) {          if (gx_disable) {
                 return(NULL);                  return(NULL);
         }          }
         scrnsurf.ptr = (BYTE *)GXBeginDraw() + TagStart;          if (scrnmng.vram == NULL) {
         if (!TagRot) {                  scrnsurf.ptr = (BYTE *)GXBeginDraw() + scrnmng.start;
                 scrnsurf.xalign = gx_dp.cbxPitch;                  scrnsurf.xalign = scrnmng.xalign;
                 scrnsurf.yalign = gx_dp.cbyPitch;                  scrnsurf.yalign = scrnmng.yalign;
         }          }
         else {          else {
                 scrnsurf.xalign = -gx_dp.cbyPitch;                  scrnsurf.ptr = scrnmng.vram->ptr;
                 scrnsurf.yalign = gx_dp.cbxPitch;                  scrnsurf.xalign = 2;
                   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);
 }  }
   
   static void draw_onmenu(void) {
   
           RECT_T          rt;
           DRAWRECT        dr;
   const BYTE              *p;
           BYTE            *q;
   const BYTE              *a;
           int                     salign;
           int                     dalign;
           int                     r;
   
           rt.left = 0;
           rt.top = 0;
   #if defined(SUPPORT_SOFTKBD)
           if (!scrnmng.allflash) {
   #endif
                   rt.right = min(scrnstat.width, 640);
                   rt.bottom = min(scrnstat.height, 400);
   #if defined(SIZE_QVGA)
                   rt.right >>= 1;
                   rt.bottom >>= 1;
   #endif
   #if defined(SUPPORT_SOFTKBD)
           }
           else {
                   scrnmng.allflash = 0;
                   rt.right = scrnmng.width;
                   rt.bottom = scrnmng.height;
           }
   #endif
           if (calcdrawrect(&dr, menuvram, &rt) != SUCCESS) {
                   return;
           }
           p = scrnmng.vram->ptr + (dr.srcpos * 2);
           q = (BYTE *)GXBeginDraw() + dr.dstpos;
           a = menuvram->alpha + dr.srcpos;
           salign = menuvram->width - dr.width;
           dalign = dr.yalign - (dr.width * dr.xalign);
           do {
                   r = dr.width;
                   do {
                           if (a[0] == 0) {
                                   *(UINT16 *)q = *(UINT16 *)p;
                           }
                           p += 2;
                           q += dr.xalign;
                           a += 1;
                   } while(--r);
                   p += salign * 2;
                   q += dalign;
                   a += salign;
           } while(--dr.height);
           GXEndDraw();
   }
   
 void scrnmng_surfunlock(const SCRNSURF *surf) {  void scrnmng_surfunlock(const SCRNSURF *surf) {
   
   #if defined(SUPPORT_SOFTKBD)
           CMNVRAM vram;
   #endif
   
         if (surf) {          if (surf) {
                 GXEndDraw();                  if (scrnmng.vram == NULL) {
   #if defined(SUPPORT_SOFTKBD)
                           if (scrnmng.allflash) {
                                   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);
                           }
   #endif
                           GXEndDraw();
                   }
                   else {
                           if (menuvram) {
                                   draw_onmenu();
                           }
                   }
           }
   }
   
   
   // ---- for wince
   
   void scrnmng_enable(BOOL enable) {
   
           if (enable) {
                   gx_disable &= ~2;
           }
           else {
                   gx_disable |= 2;
           }
   }
   
   BOOL scrnmng_mousepos(LPARAM *lp) {
   
           UINT    x;
           UINT    y;
   
           if (!scrnmng.rotate) {
                   x = LOWORD(*lp) - scrnmng.posx;
                   y = HIWORD(*lp) - scrnmng.posy;
           }
           else {
                   x = scrnmng.width - HIWORD(*lp) - 1 - scrnmng.posy;
                   y = LOWORD(*lp) - scrnmng.posx;
           }
           if ((x >= (UINT)scrnmng.width) || (y >= (UINT)scrnmng.height)) {
                   return(FAILURE);
           }
           *lp = (x & 0xffff) | ((y << 16) & 0xffff0000);
           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;
         }          }
 }  }
   
 void scrnmng_update(void) {  
   // ---- for menubase
   
   BOOL scrnmng_entermenu(SCRNMENU *smenu) {
   
           VRAMHDL vram;
   #if defined(SUPPORT_SOFTKBD)
           CMNVRAM kbdvram;
   #endif
   
           if (smenu == NULL) {
                   goto smem_err;
           }
           vram_destroy(scrnmng.vram);
           vram = vram_create(scrnmng.width, scrnmng.height, FALSE, 16);
           scrnmng.vram = vram;
           if (vram == NULL) {
                   goto smem_err;
           }
           scrndraw_redraw();
   #if defined(SUPPORT_SOFTKBD)
           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
           smenu->width = scrnmng.width;
           smenu->height = scrnmng.height;
           smenu->bpp = 16;
           return(SUCCESS);
   
   smem_err:
           return(FAILURE);
   }
   
   void scrnmng_leavemenu(void) {
   
           VRAM_RELEASE(scrnmng.vram);
   }
   
   void scrnmng_menudraw(const RECT_T *rct) {
   
           DRAWRECT        dr;
   const BYTE              *p;
   const BYTE              *q;
           BYTE            *r;
           BYTE            *a;
           int                     salign;
           int                     dalign;
           int                     x;
   
           if ((gx_disable) || (menuvram == NULL)) {
                   return;
           }
           if (calcdrawrect(&dr, menuvram, rct) != SUCCESS) {
                   return;
           }
           p = scrnmng.vram->ptr + (dr.srcpos * 2);
           q = menuvram->ptr + (dr.srcpos * 2);
           r = (BYTE *)GXBeginDraw() + dr.dstpos;
           a = menuvram->alpha + dr.srcpos;
           salign = menuvram->width;
           dalign = dr.yalign - (dr.width * dr.xalign);
           do {
                   x = 0;
                   do {
                           if (a[x]) {
                                   if (a[x] & 2) {
                                           *(UINT16 *)r = *(UINT16 *)(q + x * 2);
                                   }
                                   else {
                                           a[x] = 0;
                                           *(UINT16 *)r = *(UINT16 *)(p + x * 2);
                                   }
                           }
                           r += dr.xalign;
                   } while(++x < dr.width);
                   p += salign * 2;
                   q += salign * 2;
                   r += dalign;
                   a += salign;
           } while(--dr.height);
           GXEndDraw();
 }  }
   
   
   // ----
   
   #if defined(SUPPORT_SOFTKBD)
   BOOL scrnmng_kbdpos(LPARAM *lp) {
   
           UINT    x;
           UINT    y;
   
           x = LOWORD(*lp);
           y = HIWORD(*lp) - scrnmng.kbdposy;
           *lp = (x & 0xffff) | ((y << 16) & 0xffff0000);
           return(SUCCESS);
   }
   
   BOOL scrnmng_ismenu(LPARAM lp) {
   
           if ((LOWORD(lp) < 32) && (HIWORD(lp) >= (scrnmng.height - 32))) {
                   return(TRUE);
           }
           else {
                   return(FALSE);
           }
   }
   #endif
   
Removed from v.1.1  
changed lines
  Added in v.1.9

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