unused/bios/key.c

   1 /*
   2 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
   3 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
   4 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
   5 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
   6 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
   7 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
   8 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
   9 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  10 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
  11 COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  12 */
  13
  14 //#define PASS_KEYS_TO_BIOS     1                       //if set, bios gets keys
  15
  16 #pragma off (unreferenced)
  17 static char rcsid[] = "$Id: key.c,v 1.1.1.1 2001-01-19 03:30:14 bradleyb Exp $";
  18 #pragma on (unreferenced)
  19
  20 #include <stdlib.h>
  21 #include <stdio.h>
  22 #include <conio.h>
  23 #include <dos.h>
  24 #include <i86.h>
  25
  26 //#define WATCOM_10
  27
  28 #include "error.h"
  29 #include "key.h"
  30 #include "timer.h"
  31 #include "dpmi.h"
  32
  33 #define KEY_BUFFER_SIZE 16
  34
  35 //-------- Variable accessed by outside functions ---------
  36 unsigned char                           keyd_buffer_type;               // 0=No buffer, 1=buffer ASCII, 2=buffer scans
  37 unsigned char                           keyd_repeat;
  38 unsigned char                           keyd_editor_mode;
  39 volatile unsigned char  keyd_last_pressed;
  40 volatile unsigned char  keyd_last_released;
  41 volatile unsigned char  keyd_pressed[256];
  42 volatile int                            keyd_time_when_last_pressed;
  43
  44 typedef struct keyboard {
  45         unsigned short          keybuffer[KEY_BUFFER_SIZE];
  46         fix                                     time_pressed[KEY_BUFFER_SIZE];
  47         fix                                     TimeKeyWentDown[256];
  48         fix                                     TimeKeyHeldDown[256];
  49         unsigned int            NumDowns[256];
  50         unsigned int            NumUps[256];
  51         unsigned int            keyhead, keytail;
  52         unsigned char           E0Flag;
  53         unsigned char           E1Flag;
  54         int                                     in_key_handler;
  55         void (__interrupt __far *prev_int_9)();
  56 } keyboard;
  57
  58 static volatile keyboard key_data;
  59
  60 static unsigned char Installed=0;
  61
  62 unsigned char ascii_table[128] =
  63 { 255, 255, '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '-', '=',255,255,
  64   'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p', '[', ']', 255, 255,
  65   'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', ';', 39, '`',
  66   255, '\\', 'z', 'x', 'c', 'v', 'b', 'n', 'm', ',', '.', '/', 255,'*',
  67   255, ' ', 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,255,255,
  68   255, 255, 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
  69   255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
  70   255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
  71   255,255,255,255,255,255,255,255 };
  72
  73 unsigned char shifted_ascii_table[128] =
  74 { 255, 255, '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '_', '+',255,255,
  75   'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', '{', '}', 255, 255,
  76   'A', 'S', 'D', 'F', 'G', 'H', 'J', 'K', 'L', ':', '"', '~',
  77   255, '|', 'Z', 'X', 'C', 'V', 'B', 'N', 'M', '<', '>', '?', 255,255,
  78   255, ' ', 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,255,255,
  79   255, 255, 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
  80   255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
  81   255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
  82   255,255,255,255,255,255,255,255 };
  83
  84
  85 extern char key_to_ascii(int keycode )
  86 {
  87         int shifted;
  88
  89         shifted = keycode & KEY_SHIFTED;
  90         keycode &= 0xFF;
  91
  92         if ( keycode>=127 )
  93                 return 255;
  94
  95         if (shifted)
  96                 return shifted_ascii_table[keycode];
  97         else
  98                 return ascii_table[keycode];
  99 }
 100
 101
 102 void key_putkey (unsigned short keycode)
 103  {
 104   // this function simulates a key stroke entered
 105   char temp;
 106
 107
 108   temp = key_data.keytail+1;
 109   if ( temp >= KEY_BUFFER_SIZE ) temp=0;
 110   if (temp!=key_data.keyhead)
 111     {
 112                 key_data.keybuffer[key_data.keytail] = keycode;
 113                 key_data.keytail = temp;
 114     }
 115  }
 116
 117
 118 void key_clear_bios_buffer_all()
 119 {
 120         // Clear keyboard buffer...
 121         *(ushort *)0x41a=*(ushort *)0x41c;
 122         // Clear the status bits...
 123 //      *(ubyte *)0x417 = 0;
 124 //      *(ubyte *)0x418 = 0;
 125 }
 126
 127 void key_clear_bios_buffer()
 128 {
 129         // Clear keyboard buffer...
 130         *(ushort *)0x41a=*(ushort *)0x41c;
 131 }
 132
 133 void key_flush()
 134 {
 135         int i;
 136         fix CurTime;
 137
 138         _disable();
 139
 140         // Clear the BIOS buffer
 141         key_clear_bios_buffer();
 142
 143         key_data.keyhead = key_data.keytail = 0;
 144
 145         //Clear the keyboard buffer
 146         for (i=0; i<KEY_BUFFER_SIZE; i++ )      {
 147                 key_data.keybuffer[i] = 0;
 148                 key_data.time_pressed[i] = 0;
 149         }
 150
 151         //Clear the keyboard array
 152
 153         CurTime =timer_get_fixed_secondsX();
 154
 155         for (i=0; i<256; i++ )  {
 156                 keyd_pressed[i] = 0;
 157                 key_data.TimeKeyWentDown[i] = CurTime;
 158                 key_data.TimeKeyHeldDown[i] = 0;
 159                 key_data.NumDowns[i]=0;
 160                 key_data.NumUps[i]=0;
 161         }
 162         _enable();
 163 }
 164
 165 int add_one( int n )
 166 {
 167         n++;
 168         if ( n >= KEY_BUFFER_SIZE ) n=0;
 169         return n;
 170 }
 171
 172 // Returns 1 if character waiting... 0 otherwise
 173 int key_checkch()
 174 {
 175         int is_one_waiting = 0;
 176
 177         _disable();
 178
 179         key_clear_bios_buffer();
 180
 181         if (key_data.keytail!=key_data.keyhead)
 182                 is_one_waiting = 1;
 183         _enable();
 184         return is_one_waiting;
 185 }
 186
 187 int key_inkey()
 188 {
 189         int key = 0;
 190
 191         _disable();
 192
 193         key_clear_bios_buffer();
 194
 195         if (key_data.keytail!=key_data.keyhead) {
 196                 key = key_data.keybuffer[key_data.keyhead];
 197                 key_data.keyhead = add_one(key_data.keyhead);
 198         }
 199         _enable();
 200         return key;
 201 }
 202
 203 int key_inkey_time(fix * time)
 204 {
 205         int key = 0;
 206
 207         _disable();
 208
 209         key_clear_bios_buffer();
 210
 211         if (key_data.keytail!=key_data.keyhead) {
 212                 key = key_data.keybuffer[key_data.keyhead];
 213                 *time = key_data.time_pressed[key_data.keyhead];
 214                 key_data.keyhead = add_one(key_data.keyhead);
 215         }
 216         _enable();
 217         return key;
 218 }
 219
 220
 221
 222 int key_peekkey()
 223 {
 224         int key = 0;
 225
 226         _disable();
 227
 228         key_clear_bios_buffer();
 229
 230         if (key_data.keytail!=key_data.keyhead) {
 231                 key = key_data.keybuffer[key_data.keyhead];
 232         }
 233         _enable();
 234         return key;
 235 }
 236
 237 // If not installed, uses BIOS and returns getch();
 238 //      Else returns pending key (or waits for one if none waiting).
 239 int key_getch()
 240 {
 241         int dummy=0;
 242
 243         if (!Installed)
 244                 return getch();
 245
 246         while (!key_checkch())
 247                 dummy++;
 248         return key_inkey();
 249 }
 250
 251 unsigned int key_get_shift_status()
 252 {
 253         unsigned int shift_status = 0;
 254
 255         _disable();
 256
 257         key_clear_bios_buffer();
 258
 259         if ( keyd_pressed[KEY_LSHIFT] || keyd_pressed[KEY_RSHIFT] )
 260                 shift_status |= KEY_SHIFTED;
 261
 262         if ( keyd_pressed[KEY_LALT] || keyd_pressed[KEY_RALT] )
 263                 shift_status |= KEY_ALTED;
 264
 265         if ( keyd_pressed[KEY_LCTRL] || keyd_pressed[KEY_RCTRL] )
 266                 shift_status |= KEY_CTRLED;
 267
 268 #ifndef NDEBUG
 269         if (keyd_pressed[KEY_DELETE])
 270                 shift_status |=KEY_DEBUGGED;
 271 #endif
 272
 273         _enable();
 274
 275         return shift_status;
 276 }
 277
 278 // Returns the number of seconds this key has been down since last call.
 279 fix key_down_time(int scancode) {
 280         fix time_down, time;
 281
 282         if ((scancode<0)|| (scancode>255)) return 0;
 283
 284 #ifndef NDEBUG
 285         if (keyd_editor_mode && key_get_shift_status() )
 286                 return 0;
 287 #endif
 288
 289         _disable();
 290
 291         if ( !keyd_pressed[scancode] )  {
 292                 time_down = key_data.TimeKeyHeldDown[scancode];
 293                 key_data.TimeKeyHeldDown[scancode] = 0;
 294         } else  {
 295                 time = timer_get_fixed_secondsX();
 296                 time_down =  time - key_data.TimeKeyWentDown[scancode];
 297                 key_data.TimeKeyWentDown[scancode] = time;
 298         }
 299         _enable();
 300
 301         return time_down;
 302 }
 303
 304 // Returns number of times key has went from up to down since last call.
 305 unsigned int key_down_count(int scancode)       {
 306         int n;
 307
 308         if ((scancode<0)|| (scancode>255)) return 0;
 309
 310         _disable();
 311         n = key_data.NumDowns[scancode];
 312         key_data.NumDowns[scancode] = 0;
 313         _enable();
 314
 315         return n;
 316 }
 317
 318
 319 // Returns number of times key has went from down to up since last call.
 320 unsigned int key_up_count(int scancode) {
 321         int n;
 322
 323         if ((scancode<0)|| (scancode>255)) return 0;
 324
 325         _disable();
 326         n = key_data.NumUps[scancode];
 327         key_data.NumUps[scancode] = 0;
 328         _enable();
 329
 330         return n;
 331 }
 332
 333 // Use intrinsic forms so that we stay in the locked interrup code.
 334
 335 void Int5();
 336 #pragma aux Int5 = "int 5";
 337
 338 #pragma off (check_stack)
 339 void __interrupt __far key_handler()
 340 {
 341         unsigned char scancode, breakbit, temp;
 342         unsigned short keycode;
 343
 344 #ifndef WATCOM_10
 345 #ifndef NDEBUG
 346         ubyte * MONO = (ubyte *)(0x0b0000+24*80*2);
 347         if (  ((MONO[0]=='D') && (MONO[2]=='B') && (MONO[4]=='G') && (MONO[6]=='>')) ||
 348                         ((MONO[14]=='<') && (MONO[16]=='i') && (MONO[18]=='>') && (MONO[20]==' ') && (MONO[22]=='-')) ||
 349                         ((MONO[0]==200 ) && (MONO[2]==27) && (MONO[4]==17) )
 350                 )
 351                 _chain_intr( key_data.prev_int_9 );
 352 #endif
 353 #endif
 354
 355         // Read in scancode
 356         scancode = inp( 0x60 );
 357
 358         switch( scancode )      {
 359         case 0xE0:
 360                 key_data.E0Flag = 0x80;
 361                 break;
 362         default:
 363                 // Parse scancode and break bit
 364                 if (key_data.E1Flag > 0 )       {               // Special code for Pause, which is E1 1D 45 E1 9D C5
 365                         key_data.E1Flag--;
 366                         if ( scancode == 0x1D ) {
 367                                 scancode        = KEY_PAUSE;
 368                                 breakbit        = 0;
 369                         } else if ( scancode == 0x9d ) {
 370                                 scancode        = KEY_PAUSE;
 371                                 breakbit        = 1;
 372                         } else {
 373                                 break;          // skip this keycode
 374                         }
 375                 } else if ( scancode==0xE1 )    {
 376                         key_data.E1Flag = 2;
 377                         break;
 378                 } else {
 379                         breakbit        = scancode & 0x80;              // Get make/break bit
 380                         scancode &= 0x7f;                                               // Strip make/break bit off of scancode
 381                         scancode |= key_data.E0Flag;                                    // Add in extended key code
 382                 }
 383                 key_data.E0Flag = 0;                                                            // Clear extended key code
 384
 385                 if (breakbit)   {
 386                         // Key going up
 387                         keyd_last_released = scancode;
 388                         keyd_pressed[scancode] = 0;
 389                         key_data.NumUps[scancode]++;
 390                         temp = 0;
 391                         temp |= keyd_pressed[KEY_LSHIFT] || keyd_pressed[KEY_RSHIFT];
 392                         temp |= keyd_pressed[KEY_LALT] || keyd_pressed[KEY_RALT];
 393                         temp |= keyd_pressed[KEY_LCTRL] || keyd_pressed[KEY_RCTRL];
 394 #ifndef NDEBUG
 395                         temp |= keyd_pressed[KEY_DELETE];
 396                         if ( !(keyd_editor_mode && temp) )
 397 #endif          // NOTICE LINK TO ABOVE IF!!!!
 398                                 key_data.TimeKeyHeldDown[scancode] += timer_get_fixed_secondsX() - key_data.TimeKeyWentDown[scancode];
 399                 } else {
 400                         // Key going down
 401                         keyd_last_pressed = scancode;
 402                         keyd_time_when_last_pressed = timer_get_fixed_secondsX();
 403                         if (!keyd_pressed[scancode])    {
 404                                 // First time down
 405                                 key_data.TimeKeyWentDown[scancode] = timer_get_fixed_secondsX();
 406                                 keyd_pressed[scancode] = 1;
 407                                 key_data.NumDowns[scancode]++;
 408 #ifndef NDEBUG
 409                                 if ( (keyd_pressed[KEY_LSHIFT]) && (scancode == KEY_BACKSP) )   {
 410                                         keyd_pressed[KEY_LSHIFT] = 0;
 411                                         Int5();
 412                                 }
 413 #endif
 414                         } else if (!keyd_repeat) {
 415                                 // Don't buffer repeating key if repeat mode is off
 416                                 scancode = 0xAA;
 417                         }
 418
 419                         if ( scancode!=0xAA ) {
 420                                 keycode = scancode;
 421
 422                                 if ( keyd_pressed[KEY_LSHIFT] || keyd_pressed[KEY_RSHIFT] )
 423                                         keycode |= KEY_SHIFTED;
 424
 425                                 if ( keyd_pressed[KEY_LALT] || keyd_pressed[KEY_RALT] )
 426                                         keycode |= KEY_ALTED;
 427
 428                                 if ( keyd_pressed[KEY_LCTRL] || keyd_pressed[KEY_RCTRL] )
 429                                         keycode |= KEY_CTRLED;
 430
 431 #ifndef NDEBUG
 432                                 if ( keyd_pressed[KEY_DELETE] )
 433                                         keycode |= KEY_DEBUGGED;
 434 #endif
 435
 436                                 temp = key_data.keytail+1;
 437                                 if ( temp >= KEY_BUFFER_SIZE ) temp=0;
 438
 439                                 if (temp!=key_data.keyhead)     {
 440                                         key_data.keybuffer[key_data.keytail] = keycode;
 441                                         key_data.time_pressed[key_data.keytail] = keyd_time_when_last_pressed;
 442                                         key_data.keytail = temp;
 443                                 }
 444                         }
 445                 }
 446         }
 447
 448 #ifndef NDEBUG
 449 #ifdef PASS_KEYS_TO_BIOS
 450         _chain_intr( key_data.prev_int_9 );
 451 #endif
 452 #endif
 453
 454         temp = inp(0x61);               // Get current port 61h state
 455         temp |= 0x80;                   // Turn on bit 7 to signal clear keybrd
 456         outp( 0x61, temp );     // Send to port
 457         temp &= 0x7f;                   // Turn off bit 7 to signal break
 458         outp( 0x61, temp );     // Send to port
 459         outp( 0x20, 0x20 );     // Reset interrupt controller
 460 }
 461
 462 #pragma on (check_stack)
 463
 464 void key_handler_end()  {               // Dummy function to help calculate size of keyboard handler function
 465 }
 466
 467 ubyte Status1,Status2;
 468
 469 void key_init()
 470 {
 471         // Initialize queue
 472
 473         Status1= *(ubyte*)0x417;
 474         Status2= *(ubyte*)0x418;
 475
 476         keyd_time_when_last_pressed = timer_get_fixed_seconds();
 477         keyd_buffer_type = 1;
 478         keyd_repeat = 1;
 479         key_data.in_key_handler = 0;
 480         key_data.E0Flag = 0;
 481         key_data.E1Flag = 0;
 482
 483         // Clear the keyboard array
 484         key_flush();
 485
 486         if (Installed) return;
 487         Installed = 1;
 488
 489         //--------------- lock everything for the virtal memory ----------------------------------
 490         if (!dpmi_lock_region ((void near *)key_handler, (char *)key_handler_end - (char near *)key_handler))   {
 491                 Error( "Can't lock keyboard handler!\n" );
 492         }
 493         if (!dpmi_lock_region (&key_data, sizeof(keyboard)))    {
 494                 Error( "Can't lock keyboard handler's data!\n" );
 495         }
 496         if (!dpmi_lock_region (&keyd_buffer_type, sizeof(char)))        {
 497                 Error( "Can't lock keyboard handler's data!\n" );
 498         }
 499         if (!dpmi_lock_region (&keyd_repeat, sizeof(char)))     {
 500                 Error( "Can't lock keyboard handler's data!\n" );
 501         }
 502         if (!dpmi_lock_region (&keyd_editor_mode, sizeof(char)))        {
 503                 Error( "Can't lock keyboard handler's data!\n" );
 504         }
 505         if (!dpmi_lock_region (&keyd_last_pressed, sizeof(char)))       {
 506                 Error( "Can't lock keyboard handler's data!\n" );
 507         }
 508         if (!dpmi_lock_region (&keyd_last_released, sizeof(char)))      {
 509                 Error( "Can't lock keyboard handler's data!\n" );
 510         }
 511         if (!dpmi_lock_region (&keyd_pressed, sizeof(char)*256))        {
 512                 Error( "Can't lock keyboard handler's data!\n" );
 513         }
 514         if (!dpmi_lock_region (&keyd_time_when_last_pressed, sizeof(int)))      {
 515                 Error( "Can't lock keyboard handler's data!\n" );
 516         }
 517
 518         key_data.prev_int_9 = _dos_getvect( 9 );
 519         _dos_setvect( 9, key_handler );
 520
 521         atexit( key_close );
 522 }
 523
 524 void key_close()
 525 {
 526         if (!Installed) return;
 527         Installed = 0;
 528
 529         _dos_setvect( 9, key_data.prev_int_9 );
 530
 531         _disable();
 532         key_clear_bios_buffer_all();
 533         _enable();
 534
 535         *(ubyte*)0x417=Status1;
 536         *(ubyte*)0x418=Status2;
 537 }