home *** CD-ROM | disk | FTP | other *** search
/ Media Share 9 / MEDIASHARE_09.ISO / comm / ykh121.zip / YKHSRC.ZIP / KEYIO.C < prev    next >
C/C++ Source or Header  |  1992-12-02  |  14KB  |  465 lines
  1. #pragma inline
  2.  
  3. #include <stdio.h>
  4. #include <dos.h>
  5. #include <bios.h>
  6. #include "jislib.h"
  7.  
  8. #define ESC         0x1B          /* ASCII ESCape character */
  9. #define ESCAPE      0x11B         /* Keyboard ESCape scan code */
  10. #define DEL         0x7F          /* ASCII DELete character */
  11. #define BKSP        0xE08         /* Keyboard BacKSPace scan code */
  12.  
  13. #define F1          0x3C00        /* Keyboard Function key 1 scan code */
  14. #define F2          0xE02F        /* Keyboard Function key 2 scan code */
  15. #define F3          0x372A        /* Keyboard Function key 3 scan code */
  16. #define F4          0x4A2D        /* Keyboard Function key 4 scan code */
  17.  
  18. #define EXITO       0x6700
  19.  
  20. #define FUN4        0x3E00
  21. #define F5          0x3F00        /* Keyboard Function key 5 scan code */
  22. #define F6          0x4000        /* Keyboard Function key 6 scan code */
  23. #define F7          0x4100        /* Keyboard Function key 7 scan code */
  24. #define F8          0x4200        /* Keyboard Function key 8 scan code */
  25. #define F9          0x4300        /* Keyboard Function key 9 scan code */
  26. #define F10         0x4400        /* Keyboard Function key 10 scan code */
  27. #define UP          0x48e0        /* Keyboard Up Arrow scan code */
  28. #define DOWN        0x50e0        /* Keyboard Down Arrow scan code */
  29. #define LEFT        0x4Be0        /* Keyboard Left Arrow scan code */
  30. #define RIGHT       0x4De0        /* Keyboard Right Arrow scan code */
  31.  
  32. #define HOME        0x47e0
  33. #define INSERT      0x52e0
  34. #define DELETE      0x53e0
  35. #define END         0x4Fe0
  36. #define PAGEUP      0x49e0
  37. #define PAGEDN      0x51e0
  38.  
  39. #define K1          0x4F31        /* Keyboard Numeric 1 scan code */
  40. #define K2          0x5032        /* Keyboard Numeric 2 scan code */
  41. #define K3          0x5133        /* Keyboard Numeric 3 scan code */
  42. #define K4          0x4B34        /* Keyboard Numeric 4 scan code */
  43. #define K5          0x4C35        /* Keyboard Numeric 5 scan code */
  44. #define K6          0x4D36        /* Keyboard Numeric 6 scan code */
  45. #define K7          0x4737        /* Keyboard Numeric 7 scan code */
  46. #define K8          0x4838        /* Keyboard Numeric 8 scan code */
  47. #define K9          0x4939        /* Keyboard Numeric 9 scan code */
  48. #define K0          0x5230        /* Keyboard Numeric 0 scan code */
  49. #define KDASH       0xFFFF        /*0x372A       Keyboard Numeric Asteric scan code */
  50. #define KCOMA       0x4E2B        /*0x4A2D       Keyboard Numeric Dash(minus) scan code */
  51. #define KENTR       0xE00D        /* Keyboard Numeric + (plus) scan code */
  52. #define KDOT        0x532E        /* Keyboard Numeric Period scan code */
  53.  
  54. #define CSI         155
  55.  
  56. /*****************************************************************************/
  57. /* function prototypes                                                       */
  58.  
  59. int          Keyinit( void );     /* Initialize the keyboard system */
  60. int          ConChk( void );      /* Check the keyboard for keystrokes */
  61. unsigned int GetKey( void );      /* Retrieve a scan code from keyboard */
  62. int          DoKey( void );       /* Transmit a key sequence */
  63.  
  64. void TransKey( unsigned ); /* Translate a keystroke to a sequence */
  65. int TransNumKey(unsigned); /* Translate Numeric Keypad keystroke */
  66. int TransApplKey(unsigned);/* Translate Application Keypad keystroke */
  67. void SendBksp( void );     /* Transmit the backspace character */
  68. void   SetKeyPad( int );          /* Set the keypad to APPLICATION, NUMERIC */
  69. void   SetCursorKey( int );       /* Set the cursor key mode */
  70.  
  71. /*****************************************************************************/
  72. /* Global variables                                                          */
  73.  
  74. unsigned char backspace;          /* Backspace/Delete translation flag */
  75. unsigned char keyclick;           /* Keyclick mode on/off */
  76. unsigned char applkeypad;         /* Current state of keypad */
  77.  
  78. unsigned paused=0;
  79.  
  80. /*****************************************************************************/
  81. /* External variables                                                        */
  82.  
  83. extern unsigned inputmode;
  84.  
  85. /*****************************************************************************/
  86. /* Local Static data                                                         */
  87.  
  88. static char cursorkey = '[';      /* Sequence character in cursor key */
  89. static union REGS regs;           /* Registers for int86 call */
  90.  
  91. /*****************************************************************************/
  92.  
  93.  
  94.  
  95. int key_control() {return 1;}
  96.  
  97. int key_init() {
  98. asm mov ax,00500H;
  99. asm mov cx,0FFFFH;
  100. asm int 16H;
  101.  
  102. asm mov cx,16;
  103. key_looper:
  104. asm mov ax,01000H;
  105. asm int 16H;
  106. asm cmp ax,0FFFFH;
  107. asm loopne key_looper
  108. asm jne key_not;
  109.  
  110. backspace = 0;
  111. keyclick = 0;
  112. applkeypad = 0;
  113. ctrlbrk(key_control);
  114. kb_open();
  115. return 0;
  116.  
  117. key_not:
  118. return 1;
  119. }
  120.  
  121. void key_close()
  122. {
  123. kb_close();
  124. }
  125.  
  126.  
  127. /*  C O N C H K  --  Check if any key strokes are waiting, check hot keys */
  128.  
  129. ConChk()
  130. {
  131. asm mov ah,11h;
  132. asm int 16h;
  133. asm mov ax,1;
  134. asm jnz ConChk_1
  135. asm xor ax,ax;
  136.  
  137. ConChk_1:;
  138. }
  139.  
  140.  
  141. /*  G E T K E Y  --  Return a keyboard scan code */
  142.  
  143. unsigned int GetKey()
  144. {
  145. unsigned int scancode;
  146. unsigned int keyflags;
  147.  
  148. asm mov ah,10h;
  149. asm int 16h;
  150. asm mov scancode,ax;
  151. asm mov ah,12h;
  152. asm int 16h;
  153. asm mov keyflags,ax;
  154.  
  155. switch (scancode)
  156.   {
  157.   case 0x4e2b: if (keyflags&3)       /* SHIFT+KEYPAD_PLUS = KEYPAD_MINUS */
  158.                  scancode=0xffff;
  159.                break;
  160.   case 0x4400: scancode=0x2c1a;      /* F10 = CTRL+Z */
  161.                break;
  162.   case 0x1f13: paused=1;             /* CTRL+S pauses */
  163.                break;
  164.   case 0x1011: paused=0;             /* CTRL+Q unpauses */
  165.                break;
  166.   case 0x3b00: if (paused^=1)        /* F1 toggles pause */
  167.                  scancode=0x1f13;
  168.                  else
  169.                  scancode=0x1011;
  170.                break;
  171.   }
  172. return(scancode);
  173. }
  174.  
  175.  
  176.  
  177. /*  D O K E Y  --  Retrieve and interpret a keystroke */
  178.  
  179. DoKey()
  180. {
  181. unsigned i,j;
  182. unsigned scancode;
  183.  
  184. switch(scancode=GetKey())
  185.   {
  186.   case FUN4 : return -4;
  187.   case F5   : return -5;
  188.   case F6   : return -6;
  189.   case F7   : return -7;
  190.   case F8   : return -8;
  191.   case F9   : return -9;
  192.   case EXITO: return -10;
  193.   }
  194. DoInput(scancode);
  195. return 0;
  196. }
  197.  
  198.  
  199.  
  200.  
  201.  
  202.  
  203. /* T R A N S K E Y  -- translate a scancode into a keystroke sequence */
  204.  
  205. void TransKey( unsigned key ) {
  206.  
  207.  
  208.     switch(key) {                 /* Evaluate this keyboard scan code */
  209.        case BKSP:                 /* Backspace pressed */
  210.             SendBksp();
  211.             break;
  212.        case F1:                   /* Function key 1 pressed */
  213.            com_send( ESC );
  214.            com_send( 'O' );
  215.            com_send( 'P' );
  216.            break;
  217.        case F2:                   /* Function key 2 pressed */
  218.            com_send( ESC );
  219.            com_send( 'O' );
  220.            com_send( 'Q' );
  221.            break;
  222.        case F3:                   /* Function key 3 pressed */
  223.            com_send( ESC );
  224.            com_send( 'O' );
  225.            com_send( 'R' );
  226.            break;
  227.        case F4:                   /* Function key 4 pressed */
  228.            com_send( ESC );
  229.            com_send( 'O' );
  230.            com_send( 'S' );
  231.            break;
  232.        case UP:                   /* Up Arrow pressed */
  233.            com_send(ESC);
  234.            com_send(cursorkey);
  235.            com_send('A');
  236.            break;
  237.        case DOWN:                 /* Down Arrow pressed */
  238.            com_send(ESC);
  239.            com_send(cursorkey);
  240.            com_send('B');
  241.            break;
  242.        case RIGHT:                /* Right Arrow pressed */
  243.            com_send(ESC);
  244.            com_send(cursorkey);
  245.            com_send('C');
  246.            break;
  247.        case LEFT:                 /* Left Arrow pressed */
  248.            com_send(ESC);
  249.            com_send(cursorkey);
  250.            com_send('D');
  251.            break;
  252.  
  253.        case HOME:  /* Home */
  254.            com_send(ESC);
  255.            com_send('[');
  256.            com_send('1');
  257.            com_send('~');
  258.            break;
  259.        case INSERT:  /* Insert */
  260.            com_send(ESC);
  261.            com_send('[');
  262.            com_send('2');
  263.            com_send('~');
  264.            break;
  265.        case DELETE:  /* Delete */
  266.            com_send(ESC);
  267.            com_send('[');
  268.            com_send('3');
  269.            com_send('~');
  270.            break;
  271.        case END: /* End */
  272.            com_send(ESC);
  273.            com_send('[');
  274.            com_send('4');
  275.            com_send('~');
  276.            break;
  277.        case PAGEUP:  /* Page Up */
  278.            com_send(ESC);
  279.            com_send('[');
  280.            com_send('5');
  281.            com_send('~');
  282.            break;
  283.        case PAGEDN:  /* Page Dn */
  284.            com_send(ESC);
  285.            com_send('[');
  286.            com_send('6');
  287.            com_send('~');
  288.            break;
  289.        default:                   /* No translation yet, check numeric pad */
  290.            if ( (TransNumKey(key) == 0 ) && (TransApplKey(key) == 0) )
  291.               com_send( (char)key );  /* Still no translation, transmit char */
  292.            break;
  293.     }
  294. }
  295.  
  296. /* T R A N S N U M K E Y  --  Try and translate key from the Numeric Keypad */
  297.  
  298. static TransNumKey(register unsigned key) {
  299.  
  300.    if (applkeypad != 0)           /* If keypad is not in NUMERIC mode */
  301.       return(0);                    /* then no translation here possible */
  302.  
  303.    switch ( key ) {
  304.       case K7:                    /* Numeric 7 pressed */
  305.          com_send('7');
  306.          return(1);
  307.       case K8:                    /* Numeric 8 pressed */
  308.          com_send('8');
  309.          return(1);
  310.       case K9:                    /* Numeric 9 pressed */
  311.          com_send('9');
  312.          return(1);
  313.       case KDASH:                 /* Numeric Minus pressed */
  314.          com_send('-');
  315.          return(1);
  316.       case K4:                    /* Numeric 4 pressed */
  317.          com_send('4');
  318.          return(1);
  319.       case K5:                    /* Numeric 5 pressed */
  320.          com_send('5');
  321.          return(1);
  322.       case K6:                    /* Numeric 6 pressed */
  323.          com_send('6');
  324.          return(1);
  325.       case KCOMA:                 /* Numeric Comma pressed */
  326.          com_send(',');
  327.          return(1);
  328.       case K1:                    /* Numeric 1 pressed */
  329.          com_send('1');
  330.          return(1);
  331.       case K2:                    /* Numeric 2 pressed */
  332.          com_send('2');
  333.          return(1);
  334.       case K3:                    /* Numeric 3 pressed */
  335.          com_send('3');
  336.          return(1);
  337.       case K0:                    /* Numeric 0 pressed */
  338.          com_send('0');
  339.          return(1);
  340.       case KDOT:                  /* Numeric Period pressed */
  341.          com_send('.');
  342.          return(1);
  343.       case KENTR:                 /* Numeric Enter pressed */
  344.          com_send(13);
  345.          return(1);
  346.       default:;
  347.    }
  348.    return(0);                     /* No translation */
  349. }
  350.  
  351. /* T R A N S A P P L K E Y  --  Try and translate key from Application Keypad*/
  352.  
  353. static TransApplKey(register unsigned key) {
  354.  
  355.    if (applkeypad != 1)           /* If keypad is not APPLICATION mode */
  356.       return(0);                    /* then no translation here possible */
  357.  
  358.    switch ( key )  {
  359.        case K7:                   /* Application key 7 pressed*/
  360.            com_send(ESC);
  361.            com_send('O');
  362.            com_send('w');
  363.            return(1);
  364.        case K8:                   /* Application key 8 pressed */
  365.            com_send(ESC);
  366.            com_send('O');
  367.            com_send('x');
  368.            return(1);
  369.        case K9:                   /* Application key 9 pressed */
  370.            com_send(ESC);
  371.            com_send('O');
  372.            com_send('y');
  373.            return(1);
  374.        case KDASH:                /* Application key minus pressed */
  375.            com_send(ESC);
  376.            com_send('O');
  377.            com_send('m');
  378.            return(1);
  379.        case K4:                   /* Application key 4 pressed */
  380.            com_send(ESC);
  381.            com_send('O');
  382.            com_send('t');
  383.            return(1);
  384.        case K5:                   /* Application key 5 pressed */
  385.            com_send(ESC);
  386.            com_send('O');
  387.            com_send('u');
  388.            return(1);
  389.        case K6:                   /* Application key 6 pressed */
  390.            com_send(ESC);
  391.            com_send('O');
  392.            com_send('v');
  393.            return(1);
  394.        case KCOMA:                /* Application key Comma pressed */
  395.            com_send(ESC);
  396.            com_send('O');
  397.            com_send('l');
  398.            return(1);
  399.        case K1:                   /* Application key 1 pressed */
  400.            com_send(ESC);
  401.            com_send('O');
  402.            com_send('q');
  403.            return(1);
  404.        case K2:                   /* Application key 2 pressed */
  405.            com_send(ESC);
  406.            com_send('O');
  407.            com_send('r');
  408.            return(1);
  409.        case K3:                   /* Application key 3 pressed */
  410.            com_send(ESC);
  411.            com_send('O');
  412.            com_send('s');
  413.            return(1);
  414.        case K0:                   /* Application key 0 pressed */
  415.            com_send(ESC);
  416.            com_send('O');
  417.            com_send('p');
  418.            return(1);
  419.        case KDOT:                 /* Application key Dot pressed */
  420.            com_send(ESC);
  421.            com_send('O');
  422.            com_send('n');
  423.            return(1);
  424.        case KENTR:                /* Application key Enter pressed */
  425.            com_send(ESC);
  426.            com_send('O');
  427.            com_send('M');
  428.            return(1);
  429.        default:;
  430.    }
  431.    return(0);                     /* No translation */
  432. }
  433.  
  434.  
  435.  
  436. /* S E N D B K S P -- Send a backspace out */
  437.  
  438. static void SendBksp() {
  439.    if (backspace)                 /* If backspace flag is on then */
  440.       com_send(8);                       /* transmit a backspace */
  441.    else
  442.       com_send(DEL);                  /* Else transmit a delete */
  443. }
  444.  
  445. /* S E T K E Y P A D -- Set the keypad translation */
  446.  
  447. void SetKeyPad( int mode ) {
  448.  
  449.    if (mode)                      /* If a mode set is requested */
  450.       applkeypad = 1;               /* set the keypad to APPLICATION */
  451.    else                           /* Else */
  452.       applkeypad = 0;               /* set the keypad to NUMERIC mode*/
  453. }
  454.  
  455. /* S E T C U R S O R K E Y -- Set the cursior key mode */
  456.  
  457. void SetCursorKey( mode ) {       /* This establishes the second character */
  458.                                   /* of the cursor keys escape sequence */
  459.    if (mode)                      /* If cursor key mode is requested */
  460.       cursorkey = 'O';              /* then set cursor key to 'O' */
  461.    else                           /* Else */
  462.       cursorkey = '[';              /* use a bracket for escape sequences */
  463. }
  464.  
  465.