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

Diff for /np2/wince/scrnmng.cpp between versions 1.8 and 1.12

version 1.8, 2004/04/05 09:45:07 version 1.12, 2005/02/11 21:17:23
Line 26  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;
 #endif  #endif
 } SCRNMNG;  } SCRNMNG;
Line 41  static SCRNMNG  scrnmng; Line 43  static SCRNMNG  scrnmng;
 static  SCRNSTAT        scrnstat;  static  SCRNSTAT        scrnstat;
 static  SCRNSURF        scrnsurf;  static  SCRNSURF        scrnsurf;
   
 static  BYTE            gx_disable = 1;  static  UINT8           gx_disable = 1;
 extern  GXKeyList       gx_keylist;  extern  GXKeyList       gx_keylist;
   
 static const TCHAR      errmsg[] = STRLITERAL("Error");  static const TCHAR      errmsg[] = _T("Error");
   
   
 typedef struct {  typedef struct {
Line 56  typedef struct { Line 58  typedef struct {
         int             dstpos;          int             dstpos;
 } DRAWRECT;  } DRAWRECT;
   
   
   // ---- GX DLL¤Č¤«
   
   #if !defined(WIN32_PLATFORM_PSPC) || !defined(SIZE_VGA)
   
   #define GXGETDISPLAYPROPERTIES()        GXGetDisplayProperties()
   #define GXBEGINDRAW()                           GXBeginDraw()
   #define GXENDDRAW()                                     GXEndDraw()
   
   #else // PocketPC2003SE VGA
   
   typedef struct {
           WORD    wFormat;
           WORD    wBPP;
           VOID    *pFramePointer;
           int             cxStride;
           int             cyStride;
           int             cxPixels;
           int             cyPixels;
   } RAWFRAMEBUFFERINFO;
   
   #define GETRAWFRAMEBUFFER       0x00020001
   
   enum {
           RFBIFMT_565             = 1,
           RFBIFMT_555             = 2,
           RFBIFMT_OTHER   = 3
   };
   
   static  RAWFRAMEBUFFERINFO      rfbi;
   
   static GXDisplayProperties GXGETDISPLAYPROPERTIES(void) {
   
           HDC                                     hdc;
           GXDisplayProperties     ret;
   
           hdc = GetDC(NULL);
           ExtEscape(hdc, GETRAWFRAMEBUFFER, 0, NULL, sizeof(rfbi), (char *)&rfbi);
           ReleaseDC(NULL, hdc);
           ret.cxWidth = rfbi.cxPixels;
           ret.cyHeight = rfbi.cyPixels;
           ret.cbxPitch = rfbi.cxStride;
           ret.cbyPitch = rfbi.cyStride;
           ret.cBPP = rfbi.wBPP;
           ret.ffFormat = 0;
           switch(rfbi.wFormat) {
                   case RFBIFMT_565:
                           ret.ffFormat |= kfDirect565;
                           break;
   
                   case RFBIFMT_555:
                           ret.ffFormat |= kfDirect555;
                           break;
           }
           return(ret);
   }
   #define GXBEGINDRAW()           (rfbi.pFramePointer)
   #define GXENDDRAW()
   #endif
   
   
   // ----
   
 static BOOL calcdrawrect(DRAWRECT *dr, VRAMHDL s, const RECT_T *rt) {  static BOOL calcdrawrect(DRAWRECT *dr, VRAMHDL s, const RECT_T *rt) {
   
         int             pos;          int             pos;
Line 96  static void palcnv(CMNPAL *dst, const RG Line 161  static void palcnv(CMNPAL *dst, const RG
         }          }
 }  }
   
 static void bmp16draw(void *bmp, BYTE *dst, int width, int height,  static void bmp16draw(void *bmp, UINT8 *dst, int width, int height,
                                                                                                 int xalign, int yalign) {                                                                                                  int xalign, int yalign) {
   
         CMNVRAM vram;          CMNVRAM vram;
Line 122  void scrnmng_initialize(void) { Line 187  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);
         }          }
         if (GXOpenDisplay(hWnd, GX_FULLSCREEN) == 0) {          if (GXOpenDisplay(hWnd, GX_FULLSCREEN) == 0) {
                 MessageBox(hWnd, STRLITERAL("Couldn't GameX Object"),                  MessageBox(hWnd, _T("Couldn't GAPI Object"),
                                                                                         errmsg, MB_OK | MB_ICONSTOP);                                                                                          errmsg, MB_OK | MB_ICONSTOP);
                 return(FAILURE);                  return(FAILURE);
         }          }
         gx_dp = GXGetDisplayProperties();          gx_dp = GXGETDISPLAYPROPERTIES();
         if (gx_dp.cBPP != 16) {          if (gx_dp.cBPP != 16) {
                 MessageBox(hWnd, STRLITERAL("Only 16bit color support..."),                  MessageBox(hWnd, _T("Only 16bit color support..."),
                                                                                         errmsg, MB_OK | MB_ICONSTOP);                                                                                          errmsg, MB_OK | MB_ICONSTOP);
                 return(FAILURE);                  return(FAILURE);
         }          }
         if (!(gx_dp.ffFormat & kfDirect565)) {          if (!(gx_dp.ffFormat & kfDirect565)) {
                 MessageBox(hWnd, STRLITERAL("Only 16bit(565) support..."),                  MessageBox(hWnd, _T("Only 16bit(565) support..."),
                                                                                         errmsg, MB_OK | MB_ICONSTOP);                                                                                          errmsg, MB_OK | MB_ICONSTOP);
                 return(FAILURE);                  return(FAILURE);
         }          }
Line 152  BOOL scrnmng_create(HWND hWnd, LONG widt Line 220  BOOL scrnmng_create(HWND hWnd, LONG widt
                 scrnmng.rotate = TRUE;                  scrnmng.rotate = TRUE;
         }          }
         else {          else {
                 wsprintf(msg, STRLITERAL("Required %dx%d..."), width, height);                  wsprintf(msg, _T("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);
         }          }
Line 181  BOOL scrnmng_create(HWND hWnd, LONG widt Line 249  BOOL scrnmng_create(HWND hWnd, LONG widt
         scrnmng_clear(TRUE);          scrnmng_clear(TRUE);
 #if defined(SUPPORT_SOFTKBD)  #if defined(SUPPORT_SOFTKBD)
         softkbd_initialize();          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 231  const SCRNSURF *scrnmng_surflock(void) { Line 305  const SCRNSURF *scrnmng_surflock(void) {
                 return(NULL);                  return(NULL);
         }          }
         if (scrnmng.vram == NULL) {          if (scrnmng.vram == NULL) {
                 scrnsurf.ptr = (BYTE *)GXBeginDraw() + scrnmng.start;                  scrnsurf.ptr = (UINT8 *)GXBEGINDRAW() + scrnmng.start;
                 scrnsurf.xalign = scrnmng.xalign;                  scrnsurf.xalign = scrnmng.xalign;
                 scrnsurf.yalign = scrnmng.yalign;                  scrnsurf.yalign = scrnmng.yalign;
         }          }
Line 256  static void draw_onmenu(void) { Line 330  static void draw_onmenu(void) {
   
         RECT_T          rt;          RECT_T          rt;
         DRAWRECT        dr;          DRAWRECT        dr;
 const BYTE              *p;  const UINT8             *p;
         BYTE            *q;          UINT8           *q;
 const BYTE              *a;  const UINT8             *a;
         int                     salign;          int                     salign;
         int                     dalign;          int                     dalign;
         int                     r;          int                     r;
Line 286  const BYTE  *a; Line 360  const BYTE  *a;
                 return;                  return;
         }          }
         p = scrnmng.vram->ptr + (dr.srcpos * 2);          p = scrnmng.vram->ptr + (dr.srcpos * 2);
         q = (BYTE *)GXBeginDraw() + dr.dstpos;          q = (UINT8 *)GXBEGINDRAW() + dr.dstpos;
         a = menuvram->alpha + dr.srcpos;          a = menuvram->alpha + dr.srcpos;
         salign = menuvram->width - dr.width;          salign = menuvram->width - dr.width;
         dalign = dr.yalign - (dr.width * dr.xalign);          dalign = dr.yalign - (dr.width * dr.xalign);
Line 304  const BYTE  *a; Line 378  const BYTE  *a;
                 q += dalign;                  q += dalign;
                 a += salign;                  a += salign;
         } while(--dr.height);          } while(--dr.height);
         GXEndDraw();          GXENDDRAW();
 }  }
   
 void scrnmng_surfunlock(const SCRNSURF *surf) {  void scrnmng_surfunlock(const SCRNSURF *surf) {
Line 318  void scrnmng_surfunlock(const SCRNSURF * Line 392  void scrnmng_surfunlock(const SCRNSURF *
 #if defined(SUPPORT_SOFTKBD)  #if defined(SUPPORT_SOFTKBD)
                         if (scrnmng.allflash) {                          if (scrnmng.allflash) {
                                 scrnmng.allflash = 0;                                  scrnmng.allflash = 0;
                                 vram.ptr = surf->ptr + (surf->yalign * 200);                                  vram.ptr = surf->ptr + (scrnmng.kbdposy * surf->yalign);
                                 vram.width = 320;                                  vram.width = scrnmng.width;
                                 vram.height = 40;                                  vram.height = scrnmng.kbdheight;
                                 vram.xalign = surf->xalign;                                  vram.xalign = surf->xalign;
                                 vram.yalign = surf->yalign;                                  vram.yalign = surf->yalign;
                                 vram.bpp = 16;                                  vram.bpp = 16;
                                 softkbd_paint(&vram, palcnv, TRUE);                                  softkbd_paint(&vram, palcnv, TRUE);
                         }                          }
 #endif  #endif
                         GXEndDraw();                          GXENDDRAW();
                 }                  }
                 else {                  else {
                         if (menuvram) {                          if (menuvram) {
Line 373  BOOL scrnmng_mousepos(LPARAM *lp) { Line 447  BOOL scrnmng_mousepos(LPARAM *lp) {
 void scrnmng_clear(BOOL logo) {  void scrnmng_clear(BOOL logo) {
   
         void    *bmp;          void    *bmp;
         BYTE    *p;          UINT8   *p;
         BYTE    *q;          UINT8   *q;
         int             y;          int             y;
         int             x;          int             x;
         long    yalign;          long    yalign;
Line 386  void scrnmng_clear(BOOL logo) { Line 460  void scrnmng_clear(BOOL logo) {
         if (logo) {          if (logo) {
                 bmp = (void *)bmpdata_solvedata(nekop2_bmp);                  bmp = (void *)bmpdata_solvedata(nekop2_bmp);
         }          }
         p = (BYTE *)GXBeginDraw();          p = (UINT8 *)GXBEGINDRAW();
         q = p;          q = p;
         y = gx_dp.cyHeight;          y = gx_dp.cyHeight;
         yalign = gx_dp.cbyPitch - (gx_dp.cbxPitch * gx_dp.cxWidth);          yalign = gx_dp.cbyPitch - (gx_dp.cbxPitch * gx_dp.cxWidth);
Line 399  void scrnmng_clear(BOOL logo) { Line 473  void scrnmng_clear(BOOL logo) {
                 q += yalign;                  q += yalign;
         } while(--y);          } while(--y);
         bmp16draw(bmp, p + scrnmng.start, scrnmng.width, scrnmng.height,          bmp16draw(bmp, p + scrnmng.start, scrnmng.width, scrnmng.height,
                                                                                                 scrnmng.xalign, scrnmng.yalign);        GXEndDraw();                                                                                                  scrnmng.xalign, scrnmng.yalign);        GXENDDRAW();
         if (bmp) {          if (bmp) {
                 _MFREE(bmp);                  _MFREE(bmp);
         }          }
Line 423  void scrnmng_keybinds(void) { Line 497  void scrnmng_keybinds(void) {
   
 BOOL scrnmng_entermenu(SCRNMENU *smenu) {  BOOL scrnmng_entermenu(SCRNMENU *smenu) {
   
           VRAMHDL vram;
 #if defined(SUPPORT_SOFTKBD)  #if defined(SUPPORT_SOFTKBD)
         CMNVRAM vram;          CMNVRAM kbdvram;
 #endif  #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)
         vram.ptr = scrnmng.vram->ptr + (640 * 200);          kbdvram.ptr = vram->ptr + (vram->yalign * scrnmng.kbdposy);
         vram.width = 320;          kbdvram.width = vram->width;
         vram.height = 40;          kbdvram.height = scrnmng.kbdheight;
         vram.xalign = 2;          kbdvram.xalign = vram->xalign;
         vram.yalign = 640;          kbdvram.yalign = vram->yalign;
         vram.bpp = 16;          kbdvram.bpp = vram->bpp;
         softkbd_paint(&vram, palcnv, TRUE);          softkbd_paint(&kbdvram, palcnv, TRUE);
 #endif  #endif
         smenu->width = scrnmng.width;          smenu->width = scrnmng.width;
         smenu->height = scrnmng.height;          smenu->height = scrnmng.height;
Line 462  void scrnmng_leavemenu(void) { Line 538  void scrnmng_leavemenu(void) {
 void scrnmng_menudraw(const RECT_T *rct) {  void scrnmng_menudraw(const RECT_T *rct) {
   
         DRAWRECT        dr;          DRAWRECT        dr;
 const BYTE              *p;  const UINT8             *p;
 const BYTE              *q;  const UINT8             *q;
         BYTE            *r;          UINT8           *r;
         BYTE            *a;          UINT8           *a;
         int                     salign;          int                     salign;
         int                     dalign;          int                     dalign;
         int                     x;          int                     x;
Line 478  const BYTE  *q; Line 554  const BYTE  *q;
         }          }
         p = scrnmng.vram->ptr + (dr.srcpos * 2);          p = scrnmng.vram->ptr + (dr.srcpos * 2);
         q = menuvram->ptr + (dr.srcpos * 2);          q = menuvram->ptr + (dr.srcpos * 2);
         r = (BYTE *)GXBeginDraw() + dr.dstpos;          r = (UINT8 *)GXBEGINDRAW() + dr.dstpos;
         a = menuvram->alpha + dr.srcpos;          a = menuvram->alpha + dr.srcpos;
         salign = menuvram->width;          salign = menuvram->width;
         dalign = dr.yalign - (dr.width * dr.xalign);          dalign = dr.yalign - (dr.width * dr.xalign);
Line 501  const BYTE  *q; Line 577  const BYTE  *q;
                 r += dalign;                  r += dalign;
                 a += salign;                  a += salign;
         } while(--dr.height);          } while(--dr.height);
         GXEndDraw();          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.8  
changed lines
  Added in v.1.12

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