[BACK]Return to mackbd.cpp CVS log [TXT] [DIR] Up to [RetroPC.NET] / np2 / macosx

Diff for /np2/macosx/mackbd.cpp between versions 1.1 and 1.11

version 1.1, 2003/10/16 17:59:39 version 1.11, 2003/11/13 18:58:04
Line 6 Line 6
 #include        "pccore.h"  #include        "pccore.h"
 #include        "iocore.h"  #include        "iocore.h"
   
   #if defined(NP2GCC)
   #include        "mousemng.h"
   #include        "menu.h"
   #include        "sysmng.h"
   #endif
   
 #define         NC              0xff  #define         NC              0xff
   
Line 24  static const BYTE keymac[128] = { Line 29  static const BYTE keymac[128] = {
                                 0x24,0x26,0x28,0x30,0x32,0x2e,0x2f,0x31,                                  0x24,0x26,0x28,0x30,0x32,0x2e,0x2f,0x31,
                         //       TAB, SPC,    ,  BS,    , ESC,    , apl         ; 0x30                          //       TAB, SPC,    ,  BS,    , ESC,    , apl         ; 0x30
                                 0x0f,0x34,  NC,0x0e,  NC,0x00,  NC,  NC,                                  0x0f,0x34,  NC,0x0e,  NC,0x00,  NC,  NC,
                         //       sft, ctl, alt, cps,    ,    ,    ,             ; 0x38                          //       sft, cps, alt, ctl,    ,    ,    ,             ; 0x38
                                   NC,  NC,  NC,  NC,  NC,  NC,  NC,  NC,                                  0x70,0x79,0x73,0x74,  NC,  NC,  NC,  NC,                // for CW
                         //          , [.],    , [*],    ,    , [+],             ; 0x40                          //          , [.],    , [*],    ,    , [+],             ; 0x40
                                   NC,0x50,  NC,0x45,  NC,  NC,0x49,  NC,                                    NC,0x50,  NC,0x45,  NC,  NC,0x49,  NC,
                         //          ,    ,    ,    , ret,    , [-], clr         ; 0x48                          //          ,    ,    ,    , ret,    , [-], clr         ; 0x48
Line 37  static const BYTE keymac[128] = { Line 42  static const BYTE keymac[128] = {
                         //        F5,  F6,  F7,  F3,  F8,  F9,    , F11         ; 0x60                          //        F5,  F6,  F7,  F3,  F8,  F9,    , F11         ; 0x60
                                 0x66,0x67,0x68,0x64,0x69,0x6a,  NC,0x72,                                  0x66,0x67,0x68,0x64,0x69,0x6a,  NC,0x72,
                         //          , F13,    , F14,    , F10,    , F12         ; 0x68                          //          , F13,    , F14,    , F10,    , F12         ; 0x68
                                   NC,  NC,  NC,  NC,  NC,0x6b,  NC,0x80,                                    NC,  NC,  NC,  NC,  NC,0x6b,  NC,  NC,
                         //          , F15, hlp, hom,  ru, del,  F4, end         ; 0x70                          //          , F15, hlp, hom,  ru, del,  F4, end         ; 0x70
                                   NC,  NC,0x3f,0x3e,0x37,0x39,0x65,0x3f,                                    NC,  NC,0x3f,0x3e,0x37,0x39,0x65,0x3f,
                         //        F2,  rd,  F1,  ¢«,  ¢ª,  ¢­,  ¢¬,             ; 0x78                          //        F2,  rd,  F1,  ¢«,  ¢ª,  ¢­,  ¢¬,             ; 0x78
                                 0x63,0x36,0x62,0x3b,0x3c,0x3d,0x3a,  NC};                                  0x63,0x36,0x62,0x3b,0x3c,0x3d,0x3a,  NC};
   
   
 // ÎӸ饭¡¼²¡²¼  // ÎӸ饭¡¼²¡²¼
 static const BYTE keymac2[128] = {  static const BYTE keymac2[128] = {
                         //        £Á,  £Ó,  £Ä,  £Æ,  £È,  £Ç,  £Ú,  £Ø         ; 0x00                          //        £Á,  £Ó,  £Ä,  £Æ,  £È,  £Ç,  £Ú,  £Ø         ; 0x00
Line 60  static const BYTE keymac2[128] = { Line 64  static const BYTE keymac2[128] = {
                                   NC,  NC,  NC,  NC,  NC,  NC,  NC,  NC,                                    NC,  NC,  NC,  NC,  NC,  NC,  NC,  NC,
                         //       TAB, SPC,    ,  BS,    , ESC,    , apl         ; 0x30                          //       TAB, SPC,    ,  BS,    , ESC,    , apl         ; 0x30
                                   NC,  NC,  NC,  NC,  NC,  NC,  NC,  NC,                                    NC,  NC,  NC,  NC,  NC,  NC,  NC,  NC,
                         //       sft, ctl, alt, cps,    ,    ,    ,             ; 0x38                          //       sft, cps, alt, ctl,    ,    ,    ,             ; 0x38
                                   NC,  NC,  NC,  NC,  NC,  NC,  NC,  NC,                                    NC,  NC,  NC,  NC,  NC,  NC,  NC,  NC,
                         //          , [.],    , [*],    ,    , [+],             ; 0x40                          //          , [.],    , [*],    ,    , [+],             ; 0x40
                                   NC,  NC,  NC,  NC,  NC,  NC,  NC,  NC,                                    NC,  NC,  NC,  NC,  NC,  NC,  NC,  NC,
Line 80  static const BYTE keymac2[128] = { Line 84  static const BYTE keymac2[128] = {
                                   NC,  NC,  NC,  NC,  NC,  NC,  NC,  NC};                                    NC,  NC,  NC,  NC,  NC,  NC,  NC,  NC};
   
   
 enum {  static  BYTE    keymap[16];
         kMac_base               = 0x01,  
   
         kMac_kana               = 0x37,  
         kMac_shift              = 0x38,  
         kMac_caps               = 0x39,  
         kMac_alt                = 0x3a,  
         kMac_ctrl               = 0x3b  
 };  
   
 #define kMac_Basebit(a)         (1 << ((a) & 15))  
   
 static  UINT16  shiftback = 0;  
 static  UINT32  shiftchktick = 0;  static  UINT32  shiftchktick = 0;
   
 typedef struct {  void mackbd_initialize(void) {
         UINT16  bit;  
         BYTE    code;  
 } KEYSEA;  
   
 static const KEYSEA keysea[] = {  
                                         {kMac_Basebit(kMac_shift),      0x70},  
                                         {kMac_Basebit(kMac_caps),       0x79},  
 //                                      {kMac_Basebit(kMac_kana),       0x72},  
                                         {kMac_Basebit(kMac_alt),        0x73},  
                                         {kMac_Basebit(kMac_ctrl),       0x74}};  
   
   
 void mackbd_init(void) {  
   
         shiftback = 0;          shiftchktick = GETTICK();
         shiftchktick = 0;          ZeroMemory(&keymap, sizeof(keymap));
 }  }
   
   #if 0
 void mackbd_callback(void) {  void mackbd_callback(void) {
   
         UINT32  tick;          UINT32  tick;
         BYTE    mackeymap[16];          BYTE    key[16];
         UINT16  tmp;          UINT    i;
         UINT16  keyxor;          BYTE    update;
         int             i;          UINT    j;
           BYTE    keycode;
   
         tick = GETTICK();          tick = GETTICK();
         if (shiftchktick != tick) {          if (shiftchktick == tick) {
                 shiftchktick = tick;                  return;
           }
           shiftchktick = tick;
 #if TARGET_API_MAC_CARBON  #if TARGET_API_MAC_CARBON
                 GetKeys((long *)mackeymap);          GetKeys((long *)key);
 #else  #else
                 GetKeys((unsigned long *)mackeymap);          GetKeys((unsigned long *)key);
 #endif  #endif
                 tmp = (mackeymap[7] << 8) + mackeymap[6];          for (i=0; i<16; i++) {
                 keyxor = shiftback ^ tmp;                  update = keymap[i] ^ key[i];
                 shiftback = tmp;                  if (update) {
                 for (i=0; i<(sizeof(keysea) / sizeof(KEYSEA)); i++) {                          keymap[i] = key[i];
                         if (keyxor & keysea[i].bit) {                          for (j=0; j<8; j++) {
                                 if (shiftback & keysea[i].bit) {                                  if (update & (1 << j)) {
                                         keystat_senddata(keysea[i].code);                                          keycode = keymac[i * 8 + j];
                                 }                                          if (keycode != NC) {
                                 else {                                                  if (key[i] & (1 << j)) {
                                         keystat_senddata(keysea[i].code | 0x80);                                                          keystat_senddata(keycode);
                                                   }
                                                   else {
                                                           keystat_senddata(keycode + 0x80);
                                                   }
                                           }
                                 }                                  }
                         }                          }
                 }                  }
         }          }
 }  }
   #endif
   
 BOOL mackbd_down(int cmd, int keycode) {  static const BYTE f12keys[] = {
                           0x61, 0x60, 0x4d, 0x4f};
   
         BYTE    data;  
   
         if (keycode >= 0x80) {  static BYTE getf12key(void) {
                 return(FALSE);  
         }          UINT    key;
         if (!cmd) {  
                 data = keymac[keycode];          key = np2oscfg.F12COPY - 1;
           if (key < (sizeof(f12keys)/sizeof(BYTE))) {
                   return(f12keys[key]);
         }          }
         else {          else {
                 data = keymac2[keycode];                  return(NC);
         }          }
         if (data != NC) {  }
                 if (data == 0x80) {  
                         if (np2oscfg.F12COPY == 1) {  void mackbd_keydown(int keycode) {
                                 data = 0x61;  
                         }          if (keycode == 0x6f) {
                         else {                  if (np2oscfg.F12COPY) {
                                 data = 0x60;                          keystat_senddata(getf12key());
                         }          }
   #if defined(NP2GCC)
           else {
               mousemng_toggle(MOUSEPROC_SYSTEM);
               menu_setmouse(np2oscfg.MOUSE_SW ^ 1);
               sysmng_update(SYS_UPDATECFG);
                 }                  }
                 keystat_senddata(data);  #endif
                 return(TRUE);      }
       else {
           BYTE    data;
           data = keymac[keycode];
           if (data != NC) {
               keystat_senddata(data);
           }
         }          }
         return(FALSE);  
 }  }
   
 void mackbd_up(int keycode) {  void mackbd_keyup(int keycode) {
   
         BYTE    data, data2;          if (keycode == 0x6f) {
                   if (np2oscfg.F12COPY) {
         if (keycode >= 0x80) {                          keystat_senddata(getf12key() | 0x80);
                 return;  
         }  
         data = keymac[keycode];  
         if (data != NC) {  
                 if (data == 0x80) {  
                         if (np2oscfg.F12COPY == 1) {  
                                 data = 0x61;  
                         }  
                         else {  
                                 data = 0x60;  
                         }  
                 }                  }
                 keystat_senddata(data | 0x80);      }
         }      else {
         data2 = keymac2[keycode];          BYTE    data;
         if (data2 != NC) {          data = keymac[keycode];
                 keystat_senddata(data2 | 0x80);          if (data != NC) {
               keystat_senddata(data | 0x80);
           }
         }          }
 }  }
   
   void mackbd_resetf12(void) {
   
           UINT    i;
   
           for (i=0; i<(sizeof(f12keys)/sizeof(BYTE)); i++) {
                   keystat_forcerelease(f12keys[i]);
           }
   }
Removed from v.1.1  
changed lines
  Added in v.1.11

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