[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.4

version 1.1, 2004/03/25 08:51:24 version 1.4, 2004/03/25 18:25:24
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 {  #if (SUPPORT_SOFTKBD == 1)
         UINT8   left;  #include        "softkbd1.res"
         UINT8   keys;  #elif (SUPPORT_SOFTKBD == 2)
         UINT8   left1;  #include        "softkbd2.res"
         UINT8   left2;  #else
         UINT8   base;  #include        "softkbd.res"
         UINT8   right;  #endif
 } FULLKEY;  
   
 typedef struct {  typedef struct {
         FULLKEY fk[4];          BYTE    *bmp;
         UINT8   cur0[5];          UINT    width;
         UINT8   cur1[5];          UINT    height;
         UINT8   ten[20];          UINT8   key;
 } KEYTBL;  } SOFTKBD;
   
 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  
                    {0x38, 0x36, 0x3a, 0x3b, 0x3d},  
                    {0x39, 0x37, 0x3a, 0x3c, 0x3d},  
   
                 // 270  
                    {0x3e, 0x3f, 0x40, 0x41,  
                         0x42, 0x43, 0x44, 0x45,  
                         0x46, 0x47, 0x48, 0x49,  
                         0x4a, 0x4b, 0x4c, 0x4d,  
                         0x4e, 0x4f, 0x50, 0x1c}};  
   
   static  SOFTKBD softkbd;
   
 static  UINT8   softkey = SOFTKEY_NC;  
   
 void softkbd_paint(CMNVRAM *vram, CMNPALCNV cnv) {  void softkbd_initialize(void) {
   
           BMPFILE *bf;
           BMPDATA inf;
   
           softkbd.bmp = NULL;
           softkbd.width = 0;
           softkbd.height = 0;
           softkbd.key = SOFTKEY_NC;
           bf = (BMPFILE *)bmpdata_solvedata(np2kbd_bmp);
           if (bf != 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;
                           softkbd.height = inf.height;
                   }
                   else {
                           _MFREE(bf);
                   }
           }
   }
   
   void softkbd_deinitialize(void) {
   
         BYTE    *bmp;          BYTE    *bmp;
   
         bmp = bmpdata_solvedata(np2kbd_bmp);          bmp = softkbd.bmp;
           softkbd.bmp = NULL;
         if (bmp) {          if (bmp) {
                 cmddraw_bmp16(vram, bmp, cnv);  
                 _MFREE(bmp);                  _MFREE(bmp);
         }          }
 }  }
   
 static UINT getsoftkbd(int x, int y) {  BOOL softkbd_getsize(int *width, int *height) {
   
         UINT            posy;          if (softkbd.bmp == 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.width;
         if ((posy >= 5) || (x < 0)) {  
                 return(SOFTKEY_NC);  
         }  
         if (x < (54 - 40)) {                    // stop/copy  
                 if ((x < 10) && (posy < 2)) {  
                         return(0x60 + posy);  
                 }  
                 return(SOFTKEY_NC);  
         }          }
         x -= (54 - 40);          if (height) {
         if (x < (90 - 54)) {                    // function                  *height = softkbd.height;
                 if (x < 15) {  
                         return(0x62 + posy);  
                 }  
                 if ((x >= 17) && (x < 32)) {  
                         return(0x67 + posy);  
                 }  
                 return(SOFTKEY_NC);  
         }  
         x -= (90 - 54);  
         if (x < (247 - 90)) {                   // fullkey  
                 if (posy < 4) {  
                         if (x < 153) {  
                                 fk = keytbl.fk + posy;  
                                 x -= fk->left;  
                                 if (x < -10) {  
                                         return(fk->left1);  
                                 }  
                                 else if (x < 0) {  
                                         return(fk->left2);  
                                 }  
                                 x = (x * (((1 << 12) / 10) + 1)) >> 12;  
                                 if (x < (int)fk->keys) {  
                                         return(fk->base + x);  
                                 }  
                                 return(fk->right);  
                         }  
                 }  
                 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);          return(SUCCESS);
         if (x < (270 - 247)) {                  // cur  }
                 if (x < 10) {  
                         return(keytbl.cur0[posy]);  void softkbd_paint(CMNVRAM *vram, CMNPALCNV cnv) {
                 }  
                 else if (x < 20) {          cmddraw_bmp16(vram, softkbd.bmp, cnv, CMNBMP_LEFT | CMNBMP_TOP);
                         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);  
 }  }
   
 BOOL softkbd_down(int x, int y) {  BOOL softkbd_down(int x, int y) {
Line 162  BOOL softkbd_down(int x, int y) { Line 92  BOOL softkbd_down(int x, int y) {
         }          }
         else if (key != SOFTKEY_NC) {          else if (key != SOFTKEY_NC) {
                 keystat_senddata((UINT8)key);                  keystat_senddata((UINT8)key);
                 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_senddata((REG8)(softkbd.key | 0x80));
                 softkey = SOFTKEY_NC;                  softkbd.key = SOFTKEY_NC;
         }          }
 }  }
   
 #endif  #endif
   
Removed from v.1.1  
changed lines
  Added in v.1.4

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