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

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

version 1.2, 2004/03/25 10:41:13 version 1.5, 2004/03/28 19:50:25
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
   
   #if (SUPPORT_SOFTKBD == 1)
   #include        "softkbd1.res"
   #elif (SUPPORT_SOFTKBD == 2)
   #include        "softkbd2.res"
   #else
   #include        "softkbd.res"
   #endif
   
   #if 0
 typedef struct {  typedef struct {
         UINT8   left;          BMPDATA inf;
         UINT8   keys;          BYTE    *ptr;
         UINT8   left1;          int             height;
         UINT8   left2;          int             yalign;
         UINT8   base;  } CMNBMP;
         UINT8   right;  
 } FULLKEY;  static BOOL cmnbmp_4(const BYTE *dat, CMNBMP *ret) {
   
           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 {
                           ret->ptr += (inf.height - 1) * ret->yalign;
                           ret->height = inf.height;
                           ret->yalign *= -1;
                   }
           }
           return(SUCCESS);
   }
   #endif
   
   
 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 = {  static  SOFTKBD softkbd;
                 // 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}},  
   void softkbd_initialize(void) {
                 // 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}};  
   
           BMPFILE *bf;
           BMPDATA inf;
   
 static  UINT8   softkey = SOFTKEY_NC;          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;
                           if (inf.height > 0) {
                                   softkbd.height = inf.height;
                           }
                           else {
                                   softkbd.height = 0 - inf.height;
                           }
                   }
                   else {
                           _MFREE(bf);
                   }
           }
   }
   
 void softkbd_paint(CMNVRAM *vram, CMNPALCNV cnv) {  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, CMNBMP_LEFT | CMNBMP_TOP);  
                 _MFREE(bmp);                  _MFREE(bmp);
         }          }
 }  }
   
 static UINT getsoftkbd(int x, int y) {  BOOL softkbd_getsize(int *width, int *height) {
   
         UINT            posy;  
 const FULLKEY   *fk;  
   
         if ((x >= 0) && (x < 32) && (y >= 8) && (y < 40)) {          if (softkbd.bmp == NULL) {
                 return(SOFTKEY_MENU);                  return(FAILURE);
         }  
         x -= 40;  
         posy = y >> 3;  
         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 (x < (90 - 54)) {                    // function  
                 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);          if (width) {
         if (x < (270 - 247)) {                  // cur                  *width = softkbd.width;
                 if (x < 10) {  
                         return(keytbl.cur0[posy]);  
                 }  
                 else if (x < 20) {  
                         return(keytbl.cur1[posy]);  
                 }  
                 return(SOFTKEY_NC);  
         }          }
         x -= (270 - 247);          if (height) {
         if (x < (310 - 270)) {                  // ten key                  *height = softkbd.height;
                 x = (x * (((1 << 12) / 10) + 1)) >> 12;  
                 return(keytbl.ten[x + posy * 4]);  
         }          }
         return(SOFTKEY_NC);          return(SUCCESS);
   }
   
   BOOL softkbd_paint(CMNVRAM *vram, CMNPALCNV cnv) {
   
           cmddraw_bmp16(vram, softkbd.bmp, cnv, CMNBMP_LEFT | CMNBMP_TOP);
           return(TRUE);
 }  }
   
 BOOL softkbd_down(int x, int y) {  BOOL softkbd_down(int x, int y) {
Line 162  BOOL softkbd_down(int x, int y) { Line 139  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.2  
changed lines
  Added in v.1.5

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