home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 13 / AACD13.ISO / AACD / Online / Twiny / Windows / Source / keyboard.cpp < prev    next >
C/C++ Source or Header  |  2000-08-14  |  7KB  |  265 lines
  1. // this file has been taken from WinUAE's sources and slightly modified
  2. // to fulfil my needs
  3. #include <windows.h>
  4.  
  5. #include "inputevent.h"
  6. #include "keyboard.h"
  7.  
  8. extern void SendEvent( char Class, short Code, short Qual, short MX, short MY );
  9.  
  10. static char keystate[ AK_RCTRL + 1 ];
  11.  
  12.  
  13. static int getcapslock( void )
  14. {
  15.     BYTE keyState[256];
  16.  
  17.     GetKeyboardState( keyState );
  18.  
  19.     return( keyState[ VK_CAPITAL ] & 1 );
  20. }
  21.  
  22. inline int getrwin( void )
  23. {
  24.     return(( GetAsyncKeyState( VK_RWIN ) & 0x8000 ) ? TRUE : FALSE );
  25. }
  26.  
  27. inline int getlwin( void )
  28. {
  29.     return(( GetAsyncKeyState( VK_LWIN ) & 0x8000 ) ? TRUE : FALSE );
  30. }
  31.  
  32. static char getascii( UINT vk, UINT scancode )
  33. {
  34.     BYTE    keyState[256];
  35.     char    buffer[2];
  36.     int        result;
  37.  
  38.     GetKeyboardState( keyState );
  39.  
  40.     result = ToAscii( vk, scancode, keyState, (LPWORD)buffer, 0 );
  41.  
  42.     if( result == 1 )
  43.         result = buffer[0];
  44.  
  45.     return( result );
  46. }
  47.  
  48. /* there's a problem remaining with the semantics of the '#' key on U.S. keyboards */
  49. static int scancode2amiga( int keycode, int scancode )
  50. {
  51.     switch( keycode & 0xff ) {
  52.  
  53.         case VK_INSERT:            return AK_LAMI;
  54.         case VK_HOME:            return AK_RAMI;
  55.      
  56.         case VK_MENU:            return(( scancode & KF_EXTENDED ) ? AK_RALT : AK_LALT );
  57.      
  58.         case VK_APPS:            return AK_RALT;
  59.  
  60.         case VK_SCROLL:            return( -2 );
  61.         case VK_PRIOR:            return( -3 );
  62.         case VK_F12:            return( -5 );
  63.         case VK_CAPITAL:        return( -4 );
  64.  
  65.         case VK_DECIMAL:        return AK_NPDEL;
  66.         case VK_DIVIDE:            return AK_NPDIV;
  67.         case VK_MULTIPLY:        return AK_NPMUL;
  68.         case VK_SUBTRACT:        return AK_NPSUB;
  69.         case VK_ADD:            return AK_NPADD;
  70.         case VK_NUMPAD0:        return AK_NP0;
  71.         case VK_NUMPAD1:        return AK_NP1;
  72.         case VK_NUMPAD2:        return AK_NP2;
  73.         case VK_NUMPAD3:        return AK_NP3;
  74.         case VK_NUMPAD4:        return AK_NP4;
  75.         case VK_NUMPAD5:        return AK_NP5;
  76.         case VK_NUMPAD6:        return AK_NP6;
  77.         case VK_NUMPAD7:        return AK_NP7;
  78.         case VK_NUMPAD8:        return AK_NP8;
  79.         case VK_NUMPAD9:        return AK_NP9;
  80.         case VK_UP:                return AK_UP;
  81.         case VK_DOWN:            return AK_DN;
  82.         case VK_LEFT:            return AK_LF;
  83.         case VK_RIGHT:            return AK_RT;
  84.         case VK_CONTROL:        return(( scancode & KF_EXTENDED ) ? AK_RCTRL : AK_CTRL );
  85.         case VK_RETURN:            return(( scancode & KF_EXTENDED ) ? AK_ENT : AK_RET );    
  86.         case VK_F1:                return AK_F1;
  87.         case VK_F2:                return AK_F2;
  88.         case VK_F3:                return AK_F3;
  89.         case VK_F4:                return AK_F4;
  90.         case VK_F5:                return AK_F5;
  91.         case VK_F6:                return AK_F6;
  92.         case VK_F7:                return AK_F7;
  93.         case VK_F8:                return AK_F8;
  94.         case VK_F9:                return AK_F9;
  95.         case VK_F10:            return AK_F10;
  96.         case VK_HELP:
  97.         case VK_PAUSE:
  98.         case VK_NEXT:            return AK_HELP;
  99.     }
  100.  
  101.     switch( scancode ) {
  102.         case 0x01:    return AK_ESC;
  103.         case 0x29:    return AK_BACKQUOTE;
  104.         case 0x02:    return AK_1;
  105.         case 0x03:    return AK_2;
  106.         case 0x04:    return AK_3;
  107.         case 0x05:    return AK_4;
  108.         case 0x06:    return AK_5;
  109.         case 0x07:    return AK_6;
  110.         case 0x08:    return AK_7;
  111.         case 0x09:    return AK_8;
  112.         case 0x0a:    return AK_9;
  113.         case 0x0b:    return AK_0;
  114.         case 0x0c:    return AK_MINUS;
  115.         case 0x0d:    return AK_EQUAL;
  116.         case 0x57:  return AK_BACKSLASH; /* This is F11 */ 
  117.         case 0x0e:    return AK_BS;
  118.         case 0x0f:    return AK_TAB;
  119.         case 0x10:    return AK_Q;
  120.         case 0x11:    return AK_W;
  121.         case 0x12:    return AK_E;
  122.         case 0x13:    return AK_R;
  123.         case 0x14:    return AK_T;
  124.         case 0x15:    return AK_Y;
  125.         case 0x16:    return AK_U;
  126.         case 0x17:    return AK_I;
  127.         case 0x18:    return AK_O;
  128.         case 0x19:    return AK_P;
  129.         case 0x1a:    return AK_LBRACKET;
  130.         case 0x1b:    return AK_RBRACKET;
  131.         case 0x3a:    return AK_CAPSLOCK;
  132.         case 0x1e:    return AK_A;
  133.         case 0x1f:    return AK_S;
  134.         case 0x20:    return AK_D;
  135.         case 0x21:    return AK_F;
  136.         case 0x22:    return AK_G;
  137.         case 0x23:    return AK_H;
  138.         case 0x24:    return AK_J;
  139.         case 0x25:    return AK_K;
  140.         case 0x26:    return AK_L;
  141.         case 0x27:    return AK_SEMICOLON;
  142.         case 0x28:    return AK_QUOTE;
  143.         case 0x2b: /* This scancode is \ on US keyboards, but # on German ones - figure out which! */
  144.             switch( getascii( keycode & 0xFF, scancode )) {
  145.                 
  146.                 case '\\':
  147.                     return AK_BACKSLASH;
  148.  
  149.                 default:
  150.                     return AK_NUMBERSIGN;
  151.             }
  152.         case 0x2a:    return AK_LSH;
  153.         case 0x56:    return AK_LTGT;
  154.         case 0x2c:    return AK_Z;
  155.         case 0x2d:    return AK_X;
  156.         case 0x2e:    return AK_C;
  157.         case 0x2f:    return AK_V;
  158.         case 0x30:    return AK_B;
  159.         case 0x31:    return AK_N;
  160.         case 0x32:    return AK_M;
  161.         case 0x33:    return AK_COMMA;
  162.         case 0x34:    return AK_PERIOD;
  163.         case 0x35:    return AK_SLASH;
  164.         case 0x36:    return AK_RSH;
  165.         case 0x38:    return AK_LALT;
  166.         case 0x39:    return AK_SPC;
  167.         case 0x153:    return AK_DEL;
  168.         case 0x51:    return AK_HELP;
  169. //        case 0x52:    return AK_LAMI;
  170. //        case 0x47:    return AK_RAMI;
  171.         case 0x4b:    return AK_LF;
  172.         case 0x50:    return AK_DN;
  173.         case 0x4d:    return AK_RT;
  174.         case 0x48:    return AK_UP;
  175.         case 0x4e:    return AK_NPADD;
  176.         case 0x4a:    return AK_NPSUB;
  177.         case 0x37:    return AK_NPMUL;
  178.     }
  179.  
  180.     return( -1 );
  181. }
  182.  
  183. int my_kbd_handler( int keycode, int scancode, int newstate, int repeat )
  184. {
  185.     int akey = scancode2amiga( keycode, scancode );
  186.  
  187.     switch( akey ) {
  188.  
  189.         case -3:
  190.             if( !newstate )
  191.                 SendEvent( IECLASS_RAWMOUSE, IECODE_MBUTTON, 0, 0, 0 );
  192.             return( FALSE );
  193.  
  194.  
  195.         case -4:
  196.             if( newstate ) {
  197.                 akey     = AK_CAPSLOCK;
  198.                 newstate = getcapslock();
  199.             }
  200.             break;
  201.  
  202.         case -5:
  203.             return( TRUE );
  204.  
  205.         default:
  206.             if( newstate && ( akey >= -17 ) && ( akey <= -10 ))
  207.                 akey = -10 - akey;
  208.             break;
  209.     }
  210.  
  211.     if( akey >= 0 ) {
  212.         unsigned short qual = 0;
  213.  
  214.         if( newstate && keystate[ akey ] )
  215.             qual |= IEQUALIFIER_REPEAT;
  216.  
  217.         keystate[ akey ] = newstate;
  218.  
  219.         if( !newstate )
  220.             akey |= IECODE_UP_PREFIX;
  221.  
  222.         while( repeat-- > 0 )
  223.             SendEvent( IECLASS_RAWKEY, akey, qual, 0, 0 );
  224.     }
  225.  
  226.     return( FALSE );
  227. }
  228.  
  229. unsigned short GetQualifiers( void )
  230. {
  231.     unsigned short qual = 0;
  232.  
  233.     if( keystate[ AK_CAPSLOCK ] )
  234.         qual |= IEQUALIFIER_CAPSLOCK;
  235.  
  236.     if( keystate[ AK_LSH ] )
  237.         qual |= IEQUALIFIER_LSHIFT;
  238.  
  239.     if( keystate[ AK_RSH ] )
  240.         qual |= IEQUALIFIER_RSHIFT;
  241.  
  242.     if( keystate[ AK_LALT ] )
  243.         qual |= IEQUALIFIER_LALT;
  244.  
  245.     if( keystate[ AK_RALT ] )
  246.         qual |= IEQUALIFIER_RALT;
  247.  
  248.     if( keystate[ AK_LAMI ] || getlwin() )
  249.         qual |= IEQUALIFIER_LCOMMAND;
  250.  
  251.     if( keystate[ AK_RAMI ] || getrwin() )
  252.         qual |= IEQUALIFIER_RCOMMAND;
  253.  
  254.     if( keystate[ AK_CTRL ] || keystate[ AK_RCTRL ] )
  255.         qual |= IEQUALIFIER_CONTROL;
  256.  
  257.     return( qual );
  258. }
  259.  
  260. void InitKeyboard( void )
  261. {
  262.     memset( keystate, 0, sizeof( keystate ));
  263.  
  264.     keystate[ AK_CAPSLOCK ] = getcapslock();
  265. }