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

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

version 1.1, 2004/03/25 08:51:24 version 1.12, 2004/07/29 15:15:35
Line 5 Line 5
 #include        "bmpdata.h"  #include        "bmpdata.h"
 #include        "softkbd.h"  #include        "softkbd.h"
 #include        "keystat.h"  #include        "keystat.h"
 #include        "softkbd.res"  
   
 #define SOFTKEY_MENU    0xfe  #define SOFTKEY_MENU    0xfe
 #define SOFTKEY_NC              0xff  #define SOFTKEY_NC              0xff
   
 typedef struct {  
         UINT8   left;  
         UINT8   keys;  
         UINT8   left1;  
         UINT8   left2;  
         UINT8   base;  
         UINT8   right;  
 } FULLKEY;  
   
 typedef struct {  typedef struct {
         FULLKEY fk[4];          UINT8   key;
         UINT8   cur0[5];          UINT8   key2;
         UINT8   cur1[5];          UINT8   led;
         UINT8   ten[20];          UINT8   flag;
 } KEYTBL;          void    *ptr;
           CMNBMP  bmp;
           CMNPAL  pal[16];
   } SOFTKBD;
   
   static  SOFTKBD softkbd;
   
   #if (SUPPORT_SOFTKBD == 1)
   #if defined(SIZE_QVGA)
   #include        "softkbd1.res"
   #else
   #include        "softkbd2.res"
   #endif
   #elif (SUPPORT_SOFTKBD == 2)
   #error not support (SUPPORT_SOFTKBD == 2)
   #else
   #if !defined(SUPPORT_PC9801_119)
   #include        "softkbd.res"
   #else
   #include        "softkbd3.res"
   #endif
   #endif
   
 static const KEYTBL keytbl = {  
                 // fullkey 90  
                    {{12, 13, 0x00, 0x00, 0x01, 0x0e},  
                         {16, 12, 0x0f, 0x0f, 0x10, 0x1c},  
                         {20, 12, 0x74, 0x71, 0x1d, 0x1c},  
                         {24, 11, 0x70, 0x70, 0x29, 0x70}},  
   
                 // 247  static void loadbmp(const char *filename) {
                    {0x38, 0x36, 0x3a, 0x3b, 0x3d},  
                    {0x39, 0x37, 0x3a, 0x3c, 0x3d},  
   
                 // 270          void    *ptr;
                    {0x3e, 0x3f, 0x40, 0x41,  
                         0x42, 0x43, 0x44, 0x45,  
                         0x46, 0x47, 0x48, 0x49,  
                         0x4a, 0x4b, 0x4c, 0x4d,  
                         0x4e, 0x4f, 0x50, 0x1c}};  
   
           softkbd.ptr = NULL;
           ptr = (void *)bmpdata_solvedata(np2kbd_bmp);
           if (ptr != NULL) {
                   if (cmndraw_bmp4inf(&softkbd.bmp, ptr) == SUCCESS) {
                           softkbd.ptr = ptr;
                   }
                   else {
                           _MFREE(ptr);
                   }
           }
           softkbd.flag |= SOFTKEY_FLAGREDRAW;
           (void)filename;
   }
   
 static  UINT8   softkey = SOFTKEY_NC;  void softkbd_initialize(void) {
   
           softkbd.key = SOFTKEY_NC;
           softkbd.led = 0;
           loadbmp(NULL);
   }
   
 void softkbd_paint(CMNVRAM *vram, CMNPALCNV cnv) {  void softkbd_deinitialize(void) {
   
         BYTE    *bmp;          void    *ptr;
   
         bmp = bmpdata_solvedata(np2kbd_bmp);          ptr = softkbd.ptr;
         if (bmp) {          softkbd.ptr = NULL;
                 cmddraw_bmp16(vram, bmp, cnv);          if (ptr) {
                 _MFREE(bmp);                  _MFREE(ptr);
         }          }
 }  }
   
 static UINT getsoftkbd(int x, int y) {  BOOL softkbd_getsize(int *width, int *height) {
   
         UINT            posy;          if (softkbd.ptr == NULL) {
 const FULLKEY   *fk;                  return(FAILURE);
   
         if ((x >= 0) && (x < 32) && (y >= 8) && (y < 40)) {  
                 return(SOFTKEY_MENU);  
         }          }
         x -= 40;          if (width) {
         posy = y >> 3;                  *width = softkbd.bmp.width;
         if ((posy >= 5) || (x < 0)) {  
                 return(SOFTKEY_NC);  
         }          }
         if (x < (54 - 40)) {                    // stop/copy          if (height) {
                 if ((x < 10) && (posy < 2)) {                  *height = softkbd.bmp.height;
                         return(0x60 + posy);  
                 }  
                 return(SOFTKEY_NC);  
         }          }
         x -= (54 - 40);          return(SUCCESS);
         if (x < (90 - 54)) {                    // function  }
                 if (x < 15) {  
                         return(0x62 + posy);  REG8 softkbd_process(void) {
                 }  
                 if ((x >= 17) && (x < 32)) {          return(softkbd.flag);
                         return(0x67 + posy);  }
                 }  
                 return(SOFTKEY_NC);  BOOL softkbd_paint(CMNVRAM *vram, CMNPALCNV cnv, BOOL redraw) {
         }  
         x -= (90 - 54);          UINT8   flag;
         if (x < (247 - 90)) {                   // fullkey          BOOL    ret;
                 if (posy < 4) {  
                         if (x < 153) {          flag = softkbd.flag;
                                 fk = keytbl.fk + posy;          softkbd.flag = 0;
                                 x -= fk->left;          if (redraw) {
                                 if (x < -10) {                  flag = SOFTKEY_FLAGREDRAW | SOFTKEY_FLAGDRAW;
                                         return(fk->left1);          }
                                 }          ret = FALSE;
                                 else if (x < 0) {          if ((flag & SOFTKEY_FLAGREDRAW) && (vram) && (cnv)) {
                                         return(fk->left2);                  (*cnv)(softkbd.pal, softkbd.bmp.paltbl, softkbd.bmp.pals, vram->bpp);
                                 }                  cmndraw_bmp16(vram, softkbd.ptr, cnv, CMNBMP_LEFT | CMNBMP_TOP);
                                 x = (x * (((1 << 12) / 10) + 1)) >> 12;                  ret = TRUE;
                                 if (x < (int)fk->keys) {          }
                                         return(fk->base + x);          if (flag & SOFTKEY_FLAGDRAW) {
                                 }                  TRACEOUT(("softkbd_paint"));
                                 return(fk->right);                  ledpaint(vram);
                         }                  ret = TRUE;
                 }  
                 else {  
                         x -= 19;  
                         if (x < 0) {  
                                 return(SOFTKEY_NC);  
                         }  
                         x -= 10;  
                         if (x < 0) {  
                                 return(0x72);  
                         }  
                         x -= 10;  
                         if (x < 0) {  
                                 return(0x73);  
                         }  
                         x -= 15;  
                         if (x < 0) {  
                                 return(0x51);  
                         }  
                         x -= 66;  
                         if (x < 0) {  
                                 return(0x34);  
                         }  
                         if (x < 15) {  
                                 return(0x35);  
                         }  
                 }  
                 return(SOFTKEY_NC);  
         }  
         x -= (247 - 90);  
         if (x < (270 - 247)) {                  // cur  
                 if (x < 10) {  
                         return(keytbl.cur0[posy]);  
                 }  
                 else if (x < 20) {  
                         return(keytbl.cur1[posy]);  
                 }  
                 return(SOFTKEY_NC);  
         }  
         x -= (270 - 247);  
         if (x < (310 - 270)) {                  // ten key  
                 x = (x * (((1 << 12) / 10) + 1)) >> 12;  
                 return(keytbl.ten[x + posy * 4]);  
         }          }
         return(SOFTKEY_NC);          return(ret);
 }  }
   
 BOOL softkbd_down(int x, int y) {  BOOL softkbd_down(int x, int y) {
Line 161  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);
                 softkey = key;                  softkbd.key = key;
         }          }
         return(FALSE);          return(FALSE);
 }  }
   
 void softkbd_up(void) {  void softkbd_up(void) {
   
         if (softkey != SOFTKEY_NC) {          if (softkbd.key != SOFTKEY_NC) {
                 keystat_senddata((REG8)(softkey | 0x80));                  keystat_up(&softkbd.key, 1, NKEYREF_SOFTKBD);
                 softkey = 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.1  
changed lines
  Added in v.1.12

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