[BACK]Return to softkbd.c CVS log [TXT] [DIR] Up to [RetroPC.NET] / np2 / generic

Diff for /np2/generic/softkbd.c between versions 1.5 and 1.12

version 1.5, 2004/03/28 19:50:25 version 1.12, 2004/07/29 15:15:35
Line 6 Line 6
 #include        "softkbd.h"  #include        "softkbd.h"
 #include        "keystat.h"  #include        "keystat.h"
   
   
 #define SOFTKEY_MENU    0xfe  #define SOFTKEY_MENU    0xfe
 #define SOFTKEY_NC              0xff  #define SOFTKEY_NC              0xff
   
   
   typedef struct {
           UINT8   key;
           UINT8   key2;
           UINT8   led;
           UINT8   flag;
           void    *ptr;
           CMNBMP  bmp;
           CMNPAL  pal[16];
   } SOFTKBD;
   
   static  SOFTKBD softkbd;
   
 #if (SUPPORT_SOFTKBD == 1)  #if (SUPPORT_SOFTKBD == 1)
   #if defined(SIZE_QVGA)
 #include        "softkbd1.res"  #include        "softkbd1.res"
 #elif (SUPPORT_SOFTKBD == 2)  #else
 #include        "softkbd2.res"  #include        "softkbd2.res"
   #endif
   #elif (SUPPORT_SOFTKBD == 2)
   #error not support (SUPPORT_SOFTKBD == 2)
 #else  #else
   #if !defined(SUPPORT_PC9801_119)
 #include        "softkbd.res"  #include        "softkbd.res"
   #else
   #include        "softkbd3.res"
   #endif
 #endif  #endif
   
 #if 0  
 typedef struct {  static void loadbmp(const char *filename) {
         BMPDATA inf;  
         BYTE    *ptr;          void    *ptr;
         int             height;  
         int             yalign;          softkbd.ptr = NULL;
 } CMNBMP;          ptr = (void *)bmpdata_solvedata(np2kbd_bmp);
           if (ptr != NULL) {
 static BOOL cmnbmp_4(const BYTE *dat, CMNBMP *ret) {                  if (cmndraw_bmp4inf(&softkbd.bmp, ptr) == SUCCESS) {
                           softkbd.ptr = ptr;
         BMPDATA         inf;  
 const BMPFILE   *bf;  
   
         bf = (BMPFILE *)dat;  
         if ((bf == NULL) ||  
                 (bf->bfType[0] != 'B') || (bf->bfType[1] != 'M') ||  
                 (bmpdata_getinfo((BMPINFO *)(bf + 1), &inf) != SUCCESS) ||  
                 (inf.bpp == 4)) {  
                 return(FAILURE);  
         }  
         if (ret) {  
                 ret->inf = inf;  
                 ret->ptr = ((BYTE *)bf) + (LOADINTELDWORD(bf->bfOffBits));  
                 ret->yalign = bmpdata_getalign((BMPINFO *)(bf + 1));  
                 if (inf.height < 0) {  
                         ret->height = inf.height * -1;  
                 }                  }
                 else {                  else {
                         ret->ptr += (inf.height - 1) * ret->yalign;                          _MFREE(ptr);
                         ret->height = inf.height;  
                         ret->yalign *= -1;  
                 }                  }
         }          }
         return(SUCCESS);          softkbd.flag |= SOFTKEY_FLAGREDRAW;
           (void)filename;
 }  }
 #endif  
   
   
 typedef struct {  
         BYTE    *bmp;  
         UINT    width;  
         UINT    height;  
         UINT8   key;  
 } SOFTKBD;  
   
 static  SOFTKBD softkbd;  
   
   
   
 // ----  
   
 void softkbd_initialize(void) {  void softkbd_initialize(void) {
   
         BMPFILE *bf;  
         BMPDATA inf;  
   
         softkbd.bmp = NULL;  
         softkbd.width = 0;  
         softkbd.height = 0;  
         softkbd.key = SOFTKEY_NC;          softkbd.key = SOFTKEY_NC;
         bf = (BMPFILE *)bmpdata_solvedata(np2kbd_bmp);          softkbd.led = 0;
         if (bf != NULL) {          loadbmp(NULL);
                 if ((bf->bfType[0] == 'B') && (bf->bfType[1] == 'M') &&  
                         (bmpdata_getinfo((BMPINFO *)(bf + 1), &inf) == SUCCESS) &&  
                         (inf.bpp == 4)) {  
                         softkbd.bmp = (BYTE *)bf;  
                         softkbd.width = inf.width;  
                         if (inf.height > 0) {  
                                 softkbd.height = inf.height;  
                         }  
                         else {  
                                 softkbd.height = 0 - inf.height;  
                         }  
                 }  
                 else {  
                         _MFREE(bf);  
                 }  
         }  
 }  }
   
 void softkbd_deinitialize(void) {  void softkbd_deinitialize(void) {
   
         BYTE    *bmp;          void    *ptr;
   
         bmp = softkbd.bmp;          ptr = softkbd.ptr;
         softkbd.bmp = NULL;          softkbd.ptr = NULL;
         if (bmp) {          if (ptr) {
                 _MFREE(bmp);                  _MFREE(ptr);
         }          }
 }  }
   
 BOOL softkbd_getsize(int *width, int *height) {  BOOL softkbd_getsize(int *width, int *height) {
   
         if (softkbd.bmp == NULL) {          if (softkbd.ptr == NULL) {
                 return(FAILURE);                  return(FAILURE);
         }          }
         if (width) {          if (width) {
                 *width = softkbd.width;                  *width = softkbd.bmp.width;
         }          }
         if (height) {          if (height) {
                 *height = softkbd.height;                  *height = softkbd.bmp.height;
         }          }
         return(SUCCESS);          return(SUCCESS);
 }  }
   
 BOOL softkbd_paint(CMNVRAM *vram, CMNPALCNV cnv) {  REG8 softkbd_process(void) {
   
           return(softkbd.flag);
   }
   
   BOOL softkbd_paint(CMNVRAM *vram, CMNPALCNV cnv, BOOL redraw) {
   
           UINT8   flag;
           BOOL    ret;
   
         cmddraw_bmp16(vram, softkbd.bmp, cnv, CMNBMP_LEFT | CMNBMP_TOP);          flag = softkbd.flag;
         return(TRUE);          softkbd.flag = 0;
           if (redraw) {
                   flag = SOFTKEY_FLAGREDRAW | SOFTKEY_FLAGDRAW;
           }
           ret = FALSE;
           if ((flag & SOFTKEY_FLAGREDRAW) && (vram) && (cnv)) {
                   (*cnv)(softkbd.pal, softkbd.bmp.paltbl, softkbd.bmp.pals, vram->bpp);
                   cmndraw_bmp16(vram, softkbd.ptr, cnv, CMNBMP_LEFT | CMNBMP_TOP);
                   ret = TRUE;
           }
           if (flag & SOFTKEY_FLAGDRAW) {
                   TRACEOUT(("softkbd_paint"));
                   ledpaint(vram);
                   ret = TRUE;
           }
           return(ret);
 }  }
   
 BOOL softkbd_down(int x, int y) {  BOOL softkbd_down(int x, int y) {
Line 138  BOOL softkbd_down(int x, int y) { Line 129  BOOL softkbd_down(int x, int y) {
                 return(TRUE);                  return(TRUE);
         }          }
         else if (key != SOFTKEY_NC) {          else if (key != SOFTKEY_NC) {
                 keystat_senddata((UINT8)key);                  keystat_down(&key, 1, NKEYREF_SOFTKBD);
                 softkbd.key = key;                  softkbd.key = key;
         }          }
         return(FALSE);          return(FALSE);
Line 147  BOOL softkbd_down(int x, int y) { Line 138  BOOL softkbd_down(int x, int y) {
 void softkbd_up(void) {  void softkbd_up(void) {
   
         if (softkbd.key != SOFTKEY_NC) {          if (softkbd.key != SOFTKEY_NC) {
                 keystat_senddata((REG8)(softkbd.key | 0x80));                  keystat_up(&softkbd.key, 1, NKEYREF_SOFTKBD);
                 softkbd.key = SOFTKEY_NC;                  softkbd.key = SOFTKEY_NC;
         }          }
 }  }
   
   void softkbd_led(REG8 led) {
   
           TRACEOUT(("softkbd_led(%x)", led));
           if (softkbd.led != led) {
                   softkbd.led = led;
                   softkbd.flag |= SOFTKEY_FLAGDRAW;
           }
   }
 #endif  #endif
   
Removed from v.1.5  
changed lines
  Added in v.1.12

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