winkbd.c

   1 #include "cfg.h"
   2 #include "kbd.h"
   3
   4 BYTE    keyboard[256];
   5 DWORD   controlStates[256];
   6 DWORD   lastControlState;
   7
   8 HANDLE  hMyConsoleInput;
   9 /* DWORD        idProcess; */
  10
  11 void kbd_init(void) {
  12 /*      GetWindowThreadProcessId(GetForegroundWindow(), &idProcess); */
  13         hMyConsoleInput=GetStdHandle(STD_INPUT_HANDLE);
  14
  15         SetConsoleMode(hMyConsoleInput, ENABLE_WINDOW_INPUT);
  16
  17         memset(keyboard, 0, sizeof(keyboard));
  18         memset(controlStates, 0, sizeof(controlStates));
  19         lastControlState=0;
  20         kbd_update();
  21 }
  22
  23 void kbd_close(void) {
  24 }
  25
  26 #ifdef CLIENT
  27 void sigwinch_handler(int signum);
  28 #endif
  29
  30 int kbd_update(void) {
  31         INPUT_RECORD    ir[50];
  32         DWORD                   rd=0;
  33         int                             chg=0;
  34         if ( WaitForSingleObject(hMyConsoleInput, 0)!=WAIT_TIMEOUT ) {
  35                 if ( ReadConsoleInput(hMyConsoleInput, ir, 50, &rd) ) {
  36                         DWORD   i;
  37                         for(i=0; i<rd; i++) {
  38                                 if ( ir[i].EventType==KEY_EVENT ) {
  39                                         DWORD   vkc=ir[i].Event.KeyEvent.wVirtualKeyCode;
  40                                         if ( ir[i].Event.KeyEvent.bKeyDown ) {
  41                                                 if ( !(keyboard[vkc]&1) )
  42                                                         keyboard[vkc]|=2;
  43                                                 keyboard[vkc]|=1;
  44                                                 lastControlState=controlStates[vkc]=ir[i].Event.KeyEvent.dwControlKeyState;
  45                                         }
  46                                         else {
  47                                                 keyboard[vkc]&=~1;
  48                                                 lastControlState=ir[i].Event.KeyEvent.dwControlKeyState;
  49                                         }
  50                                 }
  51                                 else if ( ir[i].EventType==WINDOW_BUFFER_SIZE_EVENT ) {
  52                                         SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE), ir[i].Event.WindowBufferSizeEvent.dwSize);
  53                                         #ifdef CLIENT
  54                                         sigwinch_handler(0);
  55                                         #endif
  56                                 }
  57                         };
  58                         /* process ext. keys according to lastControlState */
  59                         if ( lastControlState&RIGHT_CTRL_PRESSED ) {
  60                                 if ( !(keyboard[VK_RCONTROL]&1) )
  61                                         keyboard[VK_RCONTROL]|=2;
  62                                 keyboard[VK_RCONTROL]|=1;
  63                         }
  64                         else
  65                                 keyboard[VK_RCONTROL]&=~1;
  66                         if ( lastControlState&LEFT_CTRL_PRESSED ) {
  67                                 if ( !(keyboard[VK_LCONTROL]&1) )
  68                                         keyboard[VK_LCONTROL]|=2;
  69                                 keyboard[VK_LCONTROL]|=1;
  70                         }
  71                         else
  72                                 keyboard[VK_LCONTROL]&=~1;
  73
  74                         if ( lastControlState&RIGHT_ALT_PRESSED ) {
  75                                 if ( !(keyboard[VK_RMENU]&1) )
  76                                         keyboard[VK_RMENU]|=2;
  77                                 keyboard[VK_RMENU]|=1;
  78                         }
  79                         else
  80                                 keyboard[VK_RMENU]&=~1;
  81                         if ( lastControlState&LEFT_ALT_PRESSED ) {
  82                                 if ( !(keyboard[VK_LMENU]&1) )
  83                                         keyboard[VK_LMENU]|=2;
  84                                 keyboard[VK_LMENU]|=1;
  85                         }
  86                         else
  87                                 keyboard[VK_LMENU]&=~1;
  88                 }
  89         };
  90         return chg;
  91 }
  92
  93 SHORT IntToVKey(int k) {
  94         if ( k>255 ) {
  95                 SHORT   vKey;
  96                 switch( k ) {
  97                 case K_ESCAPE: vKey=VK_ESCAPE; break;
  98                 case K_BACKSPACE: vKey=VK_BACK; break;
  99                 case K_TAB: vKey=VK_TAB; break;
 100                 case K_ENTER: vKey=VK_RETURN; break;
 101                 case K_RIGHT_SHIFT: vKey=VK_RSHIFT; break;
 102                 case K_LEFT_SHIFT: vKey=VK_LSHIFT; break;
 103                 case K_RIGHT_CTRL: vKey=VK_RCONTROL; break;
 104                 case K_LEFT_CTRL: vKey=VK_LCONTROL; break;
 105                 case K_LEFT_ALT: vKey=VK_LMENU; break;
 106                 case K_RIGHT_ALT: vKey=VK_RMENU; break;
 107                 case K_NUM_ASTERISK: vKey=VK_MULTIPLY; break;
 108                 case K_CAPS_LOCK: vKey=VK_CAPITAL; break;
 109                 case K_NUM_LOCK: vKey=VK_NUMLOCK; break;
 110                 case K_SCROLL_LOCK: vKey=VK_SCROLL; break;
 111                 case K_PAUSE: vKey=VK_PAUSE; break;
 112                 case K_SYSRQ: vKey=VK_SNAPSHOT; break;
 113                 case K_F1: vKey=VK_F1; break;
 114                 case K_F2: vKey=VK_F2; break;
 115                 case K_F3: vKey=VK_F3; break;
 116                 case K_F4: vKey=VK_F4; break;
 117                 case K_F5: vKey=VK_F5; break;
 118                 case K_F6: vKey=VK_F6; break;
 119                 case K_F7: vKey=VK_F7; break;
 120                 case K_F8: vKey=VK_F8; break;
 121                 case K_F9: vKey=VK_F9; break;
 122                 case K_F10: vKey=VK_F10; break;
 123                 case K_F11: vKey=VK_F11; break;
 124                 case K_F12: vKey=VK_F12; break;
 125                 case K_NUM1: vKey=VK_NUMPAD1; break;
 126                 case K_NUM2: vKey=VK_NUMPAD2; break;
 127                 case K_NUM3: vKey=VK_NUMPAD3; break;
 128                 case K_NUM4: vKey=VK_NUMPAD4; break;
 129                 case K_NUM5: vKey=VK_NUMPAD5; break;
 130                 case K_NUM6: vKey=VK_NUMPAD6; break;
 131                 case K_NUM7: vKey=VK_NUMPAD7; break;
 132                 case K_NUM8: vKey=VK_NUMPAD8; break;
 133                 case K_NUM9: vKey=VK_NUMPAD9; break;
 134                 case K_NUM0: vKey=VK_NUMPAD0; break;
 135                 case K_NUM_MINUS: vKey=VK_SUBTRACT; break;
 136                 case K_NUM_PLUS: vKey=VK_ADD; break;
 137                 case K_NUM_DOT: vKey=VK_DECIMAL; break;
 138                 case K_NUM_ENTER: vKey=VK_RETURN; break;
 139                 case K_NUM_SLASH: vKey=VK_DIVIDE; break;
 140                 case K_LEFT: vKey=VK_LEFT; break;
 141                 case K_RIGHT: vKey=VK_RIGHT; break;
 142                 case K_UP: vKey=VK_UP; break;
 143                 case K_DOWN: vKey=VK_DOWN; break;
 144                 case K_HOME: vKey=VK_HOME; break;
 145                 case K_END: vKey=VK_END; break;
 146                 case K_INSERT: vKey=VK_INSERT; break;
 147                 case K_DELETE: vKey=VK_DELETE; break;
 148                 case K_PGUP: vKey=VK_PRIOR; break;
 149                 case K_PGDOWN: vKey=VK_NEXT; break;
 150                 default: vKey=-1;
 151                 }
 152                 return vKey;
 153         }
 154         else
 155                 return VkKeyScanEx((unsigned char)(k&0xFF), GetKeyboardLayout(0));
 156 }
 157
 158 int kbd_is_pressed(int k) {
 159         /* return GetKeyState(IntToVKey(k))&0x8000; */
 160         SHORT   key=IntToVKey(k);
 161         int             n;
 162         if ( key==-1 )
 163                 return 0;
 164         if (( n=(keyboard[key&0xFF]&1) )&&( k>=32 )&&( k<=127 )) {
 165                 if ( key&0x100 ) {      /* shift must be down */
 166                         if ( !(controlStates[key&0xFF]&SHIFT_PRESSED) )
 167                                 n=0;
 168                 }
 169                 else {          /* shift must be up */
 170                         if ( controlStates[key&0xFF]&SHIFT_PRESSED )
 171                                 n=0;
 172                 }
 173                 if ( key&0x200 ) {      /* ctrl must be down */
 174                         if (!(( controlStates[key&0xFF]&RIGHT_CTRL_PRESSED )||
 175                                         ( controlStates[key&0xFF]&LEFT_CTRL_PRESSED )))
 176                                 n=0;
 177                 }
 178                 else {          /* ctrl must be up */
 179                         if (( controlStates[key&0xFF]&RIGHT_CTRL_PRESSED )||
 180                                 ( controlStates[key&0xFF]&LEFT_CTRL_PRESSED ))
 181                                 n=0;
 182                 }
 183                 if ( key&0x400 ) {      /* alt must be down */
 184                         if (!(( controlStates[key&0xFF]&RIGHT_ALT_PRESSED )||
 185                                 ( controlStates[key&0xFF]&LEFT_ALT_PRESSED )))
 186                                 n=0;
 187                 }
 188                 else {          /* alt must be up */
 189                         if (( controlStates[key&0xFF]&RIGHT_ALT_PRESSED )||
 190                                 ( controlStates[key&0xFF]&LEFT_ALT_PRESSED ))
 191                                 n=0;
 192                 }
 193         };
 194         return n;
 195 }
 196
 197 int kbd_was_pressed(int k) {
 198         /* return GetKeyState(IntToVKey(k))&0x8000; */
 199         SHORT   key=IntToVKey(k);
 200         int             n;
 201         if ( key==-1 )
 202                 return 0;
 203         if (( n=(keyboard[key&0xFF]&2) )&&( k>=32 )&&( k<=127 )) {
 204                 if ( key&0x100 ) {      /* shift must be down */
 205                         if ( !(controlStates[key&0xFF]&SHIFT_PRESSED) )
 206                                 n=0;
 207                 }
 208                 else {          /* shift must be up */
 209                         if ( controlStates[key&0xFF]&SHIFT_PRESSED )
 210                                 n=0;
 211                 }
 212                 if ( key&0x200 ) {      /* ctrl must be down */
 213                         if (!(( controlStates[key&0xFF]&RIGHT_CTRL_PRESSED )||
 214                                         ( controlStates[key&0xFF]&LEFT_CTRL_PRESSED )))
 215                                 n=0;
 216                 }
 217                 else {          /* ctrl must be up */
 218                         if (( controlStates[key&0xFF]&RIGHT_CTRL_PRESSED )||
 219                                 ( controlStates[key&0xFF]&LEFT_CTRL_PRESSED ))
 220                                 n=0;
 221                 }
 222                 if ( key&0x400 ) {      /* alt must be down */
 223                         if (!(( controlStates[key&0xFF]&RIGHT_ALT_PRESSED )||
 224                                 ( controlStates[key&0xFF]&LEFT_ALT_PRESSED )))
 225                                 n=0;
 226                 }
 227                 else {          /* alt must be up */
 228                         if (( controlStates[key&0xFF]&RIGHT_ALT_PRESSED )||
 229                                 ( controlStates[key&0xFF]&LEFT_ALT_PRESSED ))
 230                                 n=0;
 231                 }
 232         };
 233         if ( n )
 234                 keyboard[key&0xFF]&=~2;
 235         return n;
 236 }
 237
 238 void kbd_wait_for_key(void) {
 239         WaitForSingleObject(hMyConsoleInput, INFINITE);
 240 }