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

Diff for /np2/keystat.c between versions 1.4 and 1.8

version 1.4, 2004/02/19 11:32:11 version 1.8, 2004/03/30 07:12:02
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
   #include        "dosio.h"
 #include        "textfile.h"  #include        "textfile.h"
 #include        "pccore.h"  #include        "pccore.h"
 #include        "iocore.h"  #include        "iocore.h"
Line 19  typedef struct { Line 20  typedef struct {
   
   
                 NKEYTBL         nkeytbl;                  NKEYTBL         nkeytbl;
                   KEYCTRL         keyctrl;
 static  KEYSTAT         keystat;  static  KEYSTAT         keystat;
   
   
 void keystat_initialize(void) {  void keystat_initialize(void) {
   
           char    path[MAX_PATH];
   
         ZeroMemory(&keystat, sizeof(keystat));          ZeroMemory(&keystat, sizeof(keystat));
         FillMemory(keystat.ref, sizeof(keystat.ref), NKEYREF_NC);          FillMemory(keystat.ref, sizeof(keystat.ref), NKEYREF_NC);
         keystat_tblreset();          keystat_tblreset();
           getbiospath(path, "key.txt", sizeof(path));
           keystat_tblload(path);
 }  }
   
 void keystat_tblreset(void) {  void keystat_tblreset(void) {
Line 38  void keystat_tblreset(void) { Line 44  void keystat_tblreset(void) {
                 nkeytbl.key[i].keys = 1;                  nkeytbl.key[i].keys = 1;
                 nkeytbl.key[i].key[0] = (UINT8)i;                  nkeytbl.key[i].key[0] = (UINT8)i;
         }          }
           for (i=0; i<0x10; i++) {
                   nkeytbl.key[i+0x80].keys = 1;
                   nkeytbl.key[i+0x80].key[0] = (UINT8)(i + 0xf0);
           }
   }
   
   void keystat_tblset(REG8 ref, const UINT8 *key, UINT cnt) {
   
           NKEYM   *nkey;
   
           if ((ref >= NKEY_USER) && (ref < (NKEY_USER + NKEY_USERKEYS))) {
                   nkey = (NKEYM *)(nkeytbl.user + (ref - NKEY_USER));
                   cnt = min(cnt, 15);
           }
           else if (ref < NKEY_SYSTEM) {
                   nkey = (NKEYM *)(nkeytbl.key + ref);
                   cnt = min(cnt, 3);
           }
           else {
                   return;
           }
           nkey->keys = (UINT8)cnt;
           if (cnt) {
                   CopyMemory(nkey->key, key, cnt);
           }
 }  }
   
   
 // ---- config...  // ---- config...
   
 static REG8 searchkeynum(const char *str) {  static const char str_userkey1[] = "userkey1";
   static const char str_userkey2[] = "userkey2";
   
   static REG8 searchkeynum(const char *str, BOOL user) {
   
 const KEYNAME   *n;  const KEYNAME   *n;
 const KEYNAME   *nterm;  const KEYNAME   *nterm;
Line 56  const KEYNAME *nterm; Line 90  const KEYNAME *nterm;
                 }                  }
                 n++;                  n++;
         }          }
           if (user) {
                   if (!milstr_cmp(str_userkey1, str)) {
                           return(NKEY_USER + 0);
                   }
                   if (!milstr_cmp(str_userkey2, str)) {
                           return(NKEY_USER + 1);
                   }
           }
         return(0xff);          return(0xff);
 }  }
   
 void keystat_tblload(const char *filename) {  void keystat_tblload(const char *filename) {
   
         TEXTFILEH       tfh;          TEXTFILEH       tfh;
         char            work[128];          char            work[256];
         char            *p;          char            *p;
         char            *q;          char            *q;
         char            *r;          char            *r;
         REG8            key;          UINT8           ref;
           UINT8           key[15];
           UINT            cnt;
   
         tfh = textfile_open(filename, 0x800);          tfh = textfile_open(filename, 0x800);
         if (tfh == NULL) {          if (tfh == NULL) {
Line 82  void keystat_tblload(const char *filenam Line 126  void keystat_tblload(const char *filenam
                         continue;                          continue;
                 }                  }
                 *q++ = '\0';                  *q++ = '\0';
                 r = (char *)milstr_chr(p, ' ');                  r = milstr_chr(p, ' ');
                 if (r != NULL) {                  if (r != NULL) {
                         *r = '\0';                          *r = '\0';
                 }                  }
                 key = searchkeynum(p);                  ref = searchkeynum(p, TRUE);
                   if (ref == 0xff) {
                 while(q) {                          continue;
                   }
                   cnt = 0;
                   while((q) && (cnt < 16)) {
                         p = milstr_nextword(q);                          p = milstr_nextword(q);
                         q = milstr_chr(p, ' ');                          q = milstr_chr(p, ' ');
                         if (q != NULL) {                          if (q != NULL) {
                                 *q++ = '\0';                                  *q++ = '\0';
                         }                          }
                         key = searchkeynum(p);                          key[cnt] = searchkeynum(p, FALSE);
                           if (key[cnt] != 0xff) {
                                   cnt++;
                           }
                 }                  }
                   keystat_tblset(ref, key, cnt);
         }          }
         textfile_close(tfh);          textfile_close(tfh);
   
Line 107  kstbl_err: Line 157  kstbl_err:
   
 // ----  // ----
   
   void keystat_ctrl(REG8 dat) {
   
           if (!keyctrl.reqparam) {
                   keyctrl.mode = dat;
                   switch(dat) {
   #if defined(SUPPORT_PC9801_119)
                           case 0x95:
   #endif
                           case 0x9c:
                           case 0x9d:
                                   keyctrl.reqparam = 1;
                                   keyboard_ctrl(0xfa);
                                   break;
   
   #if defined(SUPPORT_PC9801_119)
                           case 0x96:
                                   keyboard_ctrl(0xfa);
                                   keyboard_ctrl(0xa0);
                                   keyboard_ctrl(0x83);
                                   break;
   #endif
   
                           case 0x9f:
                                   keyboard_ctrl(0xfa);
                                   keyboard_ctrl(0xa0);
                                   keyboard_ctrl(0x80);
                                   break;
   
                           default:
                                   keyboard_ctrl(0xfc);
                                   break;
                   }
           }
           else {
                   switch(keyctrl.mode) {
   #if defined(SUPPORT_PC9801_119)
                           case 0x95:
                                   keyctrl.kbdtype = dat;
                                   break;
   #endif
                           case 0x9d:
                                   break;
   
                           case 0x9e:
                                   break;
                   }
                   keyctrl.reqparam = 0;
           }
   }
   
   
   // ----
   
 void keystat_down(const UINT8 *key, REG8 keys, REG8 ref) {  void keystat_down(const UINT8 *key, REG8 keys, REG8 ref) {
   
           UINT8   keydata;
         UINT8   keycode;          UINT8   keycode;
         UINT8   shift;  
         REG8    data;          REG8    data;
   
         while(keys--) {          while(keys--) {
                 keycode = *key++;                  keydata = *key++;
                 keycode = (keycode & 0x7f);                  keycode = (keydata & 0x7f);
                 if (keycode < 0x70) {                  if (keycode < 0x70) {
                         if ((keystat.ref[keycode] == NKEYREF_NC) ||                          if ((keystat.ref[keycode] == NKEYREF_NC) ||
                                 (!(kbexflag[keycode] & KBEX_NONREP))) {                                  (!(kbexflag[keycode] & KBEX_NONREP))) {
Line 124  void keystat_down(const UINT8 *key, REG8 Line 227  void keystat_down(const UINT8 *key, REG8
                         keystat.ref[keycode] = ref;                          keystat.ref[keycode] = ref;
                 }                  }
                 else {                  else {
   #if defined(SUPPORT_PC9801_119)
                           if ((keyctrl.kbdtype != 0x03) && (keycode >= 0x75)) {
                                   continue;
                           }
   #else
                           if (keycode >= 0x75) {
                                   continue;
                           }
   #endif
                         if ((np2cfg.XSHIFT) &&                          if ((np2cfg.XSHIFT) &&
                                 (((keycode == 0x70) && (np2cfg.XSHIFT & 1)) ||                                  (((keycode == 0x70) && (np2cfg.XSHIFT & 1)) ||
                                 ((keycode == 0x74) && (np2cfg.XSHIFT & 2)) ||                                  ((keycode == 0x74) && (np2cfg.XSHIFT & 2)) ||
                                 ((keycode == 0x73) && (np2cfg.XSHIFT & 4)))) {                                  ((keycode == 0x73) && (np2cfg.XSHIFT & 4)))) {
                                 keycode |= 8;                                  keydata |= 0x80;
                         }                          }
                         shift = keycode & 0x07;                          if (!(keydata & 0x80)) {                        // シフト
                         if (!(keycode & 8)) {                   // シフト                                  if (keystat.ref[keycode] == NKEYREF_NC) {
                                 if ((keystat.ref[0x70 + shift] == NKEYREF_NC) &&                                          keystat.ref[keycode] = ref;
                                         (keystat.ref[0x78 + shift] == NKEYREF_NC)) {                                          keyboard_send(keycode);
                                         keyboard_send((REG8)(0x70 + shift));  
                                 }  
                                 if (keystat.ref[0x70 + shift] > ref) {  
                                         keystat.ref[0x70 + shift] = ref;  
                                 }                                  }
                         }                          }
                         else {                                                          // シフトメカニカル処理                          else {                                                          // シフトメカニカル処理
                                 if (keystat.ref[0x78 + shift] == NKEYREF_NC) {                                  if (keystat.ref[keycode] == NKEYREF_NC) {
                                         keystat.ref[0x78 + shift] = ref;                                          keystat.ref[keycode] = ref;
                                         data = (REG8)(0x70 + shift);                                          data = keycode;
                                 }                                  }
                                 else {                                  else {
                                         keystat.ref[0x78 + shift] = NKEYREF_NC;                                          keystat.ref[keycode] = NKEYREF_NC;
                                         data = (REG8)(0xf0 + shift);                                          data = (REG8)(keycode + 0x80);
                                 }  
                                 if (keystat.ref[0x70 + shift] == NKEYREF_NC) {  
                                         keyboard_send(data);  
                                 }                                  }
                                   keyboard_send(data);
                         }                          }
                 }                  }
         }          }
Line 159  void keystat_down(const UINT8 *key, REG8 Line 265  void keystat_down(const UINT8 *key, REG8
   
 void keystat_up(const UINT8 *key, REG8 keys, REG8 ref) {  void keystat_up(const UINT8 *key, REG8 keys, REG8 ref) {
   
           UINT8   keydata;
         UINT8   keycode;          UINT8   keycode;
         UINT8   shift;  
   
         while(keys--) {          while(keys--) {
                 keycode = *key++;                  keydata = *key++;
                 keycode = (keycode & 0x7f);                  keycode = (keydata & 0x7f);
                 if (keycode < 0x70) {                  if (keycode < 0x70) {
                         if (keystat.ref[keycode] == ref) {                          if (keystat.ref[keycode] == ref) {
                                 keystat.ref[keycode] = NKEYREF_NC;                                  keystat.ref[keycode] = NKEYREF_NC;
Line 172  void keystat_up(const UINT8 *key, REG8 k Line 278  void keystat_up(const UINT8 *key, REG8 k
                         }                          }
                 }                  }
                 else {                  else {
   #if defined(SUPPORT_PC9801_119)
                           if ((keyctrl.kbdtype != 0x03) && (keycode >= 0x75)) {
                                   continue;
                           }
   #else
                           if (keycode >= 0x75) {
                                   continue;
                           }
   #endif
                         if ((np2cfg.XSHIFT) &&                          if ((np2cfg.XSHIFT) &&
                                 (((keycode == 0x70) && (np2cfg.XSHIFT & 1)) ||                                  (((keycode == 0x70) && (np2cfg.XSHIFT & 1)) ||
                                 ((keycode == 0x74) && (np2cfg.XSHIFT & 2)) ||                                  ((keycode == 0x74) && (np2cfg.XSHIFT & 2)) ||
                                 ((keycode == 0x73) && (np2cfg.XSHIFT & 4)))) {                                  ((keycode == 0x73) && (np2cfg.XSHIFT & 4)))) {
                                 keycode |= 8;                                  keydata |= 0x80;
                         }                          }
                         shift = keycode & 0x07;                          if (!(keydata & 0x80)) {                        // シフト
                         if (!(keycode & 8)) {                   // シフト                                  if (keystat.ref[keycode] != NKEYREF_NC) {
                                 if (keystat.ref[0x70 + shift] == ref) {                                          keystat.ref[keycode] = NKEYREF_NC;
                                         keystat.ref[0x70 + shift] = NKEYREF_NC;                                          keyboard_send((REG8)(keycode + 0x80));
                                         if (keystat.ref[0x78 + shift] == NKEYREF_NC) {  
                                                 keyboard_send((REG8)(shift + 0xf0));  
                                         }  
                                 }                                  }
                         }                          }
                 }                  }
Line 195  void keystat_resendstat(void) { Line 307  void keystat_resendstat(void) {
   
         REG8    i;          REG8    i;
   
         for (i=0; i<0x70; i++) {          for (i=0; i<0x80; i++) {
                 if (keystat.ref[i] != NKEYREF_NC) {                  if (keystat.ref[i] != NKEYREF_NC) {
                         keyboard_send(i);                          keyboard_send(i);
                 }                  }
         }          }
         for (i=0; i<8; i++) {  
                 if ((keystat.ref[0x70 + i] != NKEYREF_NC) ||  
                         (keystat.ref[0x78 + i] != NKEYREF_NC)) {  
                         keyboard_send((REG8)(i + 0x70));  
                 }  
         }  
 }  }
   
   
Line 213  void keystat_resendstat(void) { Line 319  void keystat_resendstat(void) {
   
 void keystat_keydown(REG8 ref) {  void keystat_keydown(REG8 ref) {
   
         UINT8           keycode;          UINT8   shift;
         UINT8           shift;  const NKEYM     *nkey;
 const NKEYM3    *nkey3;  
 const NKEYM15   *nkey15;          if ((ref >= NKEY_USER) && (ref < (NKEY_USER + NKEY_USERKEYS))) {
                   nkey = (NKEYM *)(nkeytbl.user + (ref - NKEY_USER));
         keycode = ref & 0x7f;                  keystat_down(nkey->key, nkey->keys, NKEYREF_USER);
         if (np2cfg.KEY_MODE) {          }
                 shift = kbexflag[keycode];          else if (ref < NKEY_SYSTEM) {
                 if (shift & KBEX_JOYKEY) {                  if (np2cfg.KEY_MODE) {
                         keystat.extkey |= (1 << (shift & 7));                          shift = kbexflag[ref];
                         return;                          if (shift & KBEX_JOYKEY) {
                 }                                  keystat.extkey |= (1 << (shift & 7));
         }                                  return;
         if ((keycode != NKEY_USER1) && (keycode != NKEY_USER2)) {                          }
                 nkey3 = nkeytbl.key + keycode;                  }
                 keystat_down(nkey3->key, nkey3->keys, keycode);                  nkey = (NKEYM *)(nkeytbl.key + ref);
         }                  keystat_down(nkey->key, nkey->keys, ref);
         else {  
 #if 0  
                 nkey15 = nkeytbl.user + (keycode - NKEY_USER1);  
 #else  
                 nkey15 = (NKEYM15 *)(np2cfg.userkey + (keycode - NKEY_USER1));  
 #endif  
                 keystat_down(nkey15->key, nkey15->keys, NKEYREF_USER);  
         }          }
 }  }
   
 void keystat_keyup(REG8 ref) {  void keystat_keyup(REG8 ref) {
   
         UINT8           keycode;          UINT8   shift;
         UINT8           shift;  const NKEYM     *nkey;
 const NKEYM3    *nkey3;  
 const NKEYM15   *nkey15;          if ((ref >= NKEY_USER) && (ref < (NKEY_USER + NKEY_USERKEYS))) {
                   nkey = (NKEYM *)(nkeytbl.user + (ref - NKEY_USER));
         keycode = ref & 0x7f;                  keystat_up(nkey->key, nkey->keys, NKEYREF_USER);
         if (np2cfg.KEY_MODE) {          }
                 shift = kbexflag[keycode];          else if (ref < NKEY_SYSTEM) {
                 if (shift & KBEX_JOYKEY) {                  if (np2cfg.KEY_MODE) {
                         keystat.extkey &= ~(1 << (shift & 7));                          shift = kbexflag[ref];
                         return;                          if (shift & KBEX_JOYKEY) {
                 }                                  keystat.extkey &= ~(1 << (shift & 7));
         }                                  return;
         if ((keycode != NKEY_USER1) && (keycode != NKEY_USER2)) {                          }
                 nkey3 = nkeytbl.key + keycode;                  }
                 keystat_up(nkey3->key, nkey3->keys, keycode);                  nkey = (NKEYM *)(nkeytbl.key + ref);
         }                  keystat_up(nkey->key, nkey->keys, ref);
         else {  
 #if 0  
                 nkey15 = nkeytbl.user + (keycode - NKEY_USER1);  
 #else  
                 nkey15 = (NKEYM15 *)(np2cfg.userkey + (keycode - NKEY_USER1));  
 #endif  
                 keystat_up(nkey15->key, nkey15->keys, NKEYREF_USER);  
         }          }
 }  }
   
Line 273  void keystat_releaseref(REG8 ref) { Line 365  void keystat_releaseref(REG8 ref) {
   
         REG8    i;          REG8    i;
   
         for (i=0; i<0x70; i++) {          for (i=0; i<0x80; i++) {
                 if (keystat.ref[i] == ref) {                  if (keystat.ref[i] == ref) {
                         keystat.ref[i] = NKEYREF_NC;                          keystat.ref[i] = NKEYREF_NC;
                         keyboard_send((REG8)(i + 0x80));                          keyboard_send((REG8)(i + 0x80));
                 }                  }
         }          }
         for (i=0; i<0x10; i++) {  
                 if (keystat.ref[0x70 + i] == ref) {  
                         keystat.ref[0x70 + i] = NKEYREF_NC;  
                         if (keystat.ref[0x78 ^ i] == NKEYREF_NC) {  
                                 keyboard_send((REG8)((i & 7) + 0xe0));  
                         }  
                 }  
         }  
 }  }
   
 void keystat_resetjoykey(void) {  void keystat_resetjoykey(void) {
Line 305  void keystat_resetjoykey(void) { Line 389  void keystat_resetjoykey(void) {
 void keystat_releasekey(REG8 key) {  void keystat_releasekey(REG8 key) {
   
         key &= 0x7f;          key &= 0x7f;
         if (key < 0x70) {          if (keystat.ref[key] != NKEYREF_NC) {
                 if (keystat.ref[key] != NKEYREF_NC) {                  keystat.ref[key] = NKEYREF_NC;
                         keystat.ref[key] = NKEYREF_NC;                  keyboard_send((REG8)(key + 0x80));
                         keyboard_send((REG8)(key + 0x80));  
                 }  
         }  
         else {  
                 key &= 0x07;  
                 if ((keystat.ref[0x70 + key] != NKEYREF_NC) ||  
                         (keystat.ref[0x78 + key] != NKEYREF_NC)) {  
                         keystat.ref[0x70 + key] = NKEYREF_NC;  
                         keystat.ref[0x78 + key] = NKEYREF_NC;  
                         keyboard_send((REG8)(key + 0xf0));  
                 }  
         }          }
 }  }
   
Line 326  void keystat_allrelease(void) { Line 399  void keystat_allrelease(void) {
   
         REG8    i;          REG8    i;
   
         for (i=0; i<0x78; i++) {          for (i=0; i<0x80; i++) {
                 keystat_releasekey(i);                  keystat_releasekey(i);
         }          }
 }  }
Line 406  REG8 keystat_getmouse(SINT16 *x, SINT16  Line 479  REG8 keystat_getmouse(SINT16 *x, SINT16 
   
 // ----  // ----
   
 void keystat_senddata(REG8 data) {  // キーコード変更
   
         UINT8   keycode;  static REG8 cnvnewcode(REG8 oldcode) {
   
           switch(oldcode) {
                   case 0x71:                              // 通常caps
                           return(0x81);
   
                   case 0x72:                              // 通常カナ
                           return(0x82);
   
                   case 0x79:                              // メカニカルロックcaps
                           return(0x71);
   
                   case 0x7a:                              // メカニカルロックcaps
                           return(0x72);
   
         keycode = data & 0x7f;                  case 0x76:
         if ((keycode == 0x71) || (keycode == 0x72) ||                          return(0x90);           // NKEY_USER + 0
                 (keycode == 0x79) || (keycode == 0x7a)) {  
                 keycode ^= 8;                  case 0x77:
                           return(0x91);           // NKEY_USER + 1
   
                   default:
                           return(oldcode);
         }          }
   }
   
   void keystat_senddata(REG8 data) {
   
           REG8    keycode;
   
           keycode = cnvnewcode((REG8)(data & 0x7f));
         if (!(data & 0x80)) {          if (!(data & 0x80)) {
                 keystat_keydown(keycode);                  keystat_keydown(keycode);
         }          }
Line 423  void keystat_senddata(REG8 data) { Line 520  void keystat_senddata(REG8 data) {
         }          }
 }  }
   
   void keystat_forcerelease(REG8 data) {
   
           REG8    keycode;
   
           keycode = cnvnewcode((REG8)(data & 0x7f));
           keystat_releasekey(keycode);
   }
   
Removed from v.1.4  
changed lines
  Added in v.1.8

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