home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 2 / 2873 / ttykbd.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-02-28  |  11.1 KB  |  354 lines
  1. /*
  2.  *      Wang PC keyboard handler
  3.  */
  4. #define LINT_ARGS   1           /* enable lint type checking */
  5. #include    "def.h"
  6.  
  7. extern    char    MSG_sp_key[];
  8. extern    char    MSG_byte_shift[];
  9. extern    char    MSG_back_char[];
  10. extern    char    MSG_quit[];
  11. extern    char    MSG_forw_del_char[];
  12. extern    char    MSG_toggle_swap[];
  13. extern    char    MSG_forw_char[];
  14. extern    char    MSG_abort[];
  15. extern    char    MSG_ins_self[];
  16. extern    char    MSG_back_del_char[];
  17. extern    char    MSG_refresh[];
  18. extern    char    MSG_forw_line[];
  19. extern    char    MSG_back_line[];
  20. extern    char    MSG_quote[];
  21. extern    char    MSG_recall[];
  22. extern    char    MSG_twiddle[];
  23. extern    char    MSG_forw_page[];
  24. extern    char    MSG_kill_region[];
  25. extern    char    MSG_yank[];
  26. extern    char    MSG_down_window[];
  27. extern    char    MSG_ins_toggle[];
  28. extern    char    MSG_display_buffers[];
  29. extern    char    MSG_quit[];
  30. extern    char    MSG_exit_flush_all[];
  31. extern    char    MSG_set_file_name[];
  32. extern    char    MSG_file_insert[];
  33. extern    char    MSG_buf_size_lock[];
  34. extern    char    MSG_flush_all[];
  35. extern    char    MSG_down_window[];
  36. extern    char    MSG_up_window[];
  37. extern    char    MSG_file_read[];
  38. extern    char    MSG_file_save[];
  39. extern    char    MSG_file_visit[];
  40. extern    char    MSG_file_write[];
  41. extern    char    MSG_swap_dot_and_mark[];
  42. extern    char    MSG_shrink_window[];
  43. extern    char    MSG_display_position[];
  44. extern    char    MSG_start_macro[];
  45. extern    char    MSG_end_macro[];
  46. extern    char    MSG_help[];
  47. extern    char    MSG_only_window[];
  48. extern    char    MSG_split_window[];
  49. extern    char    MSG_use_buffer[];
  50. extern    char    MSG_spawn_cli[];
  51. extern    char    MSG_execute_macro[];
  52. extern    char    MSG_goto_line[];
  53. extern    char    MSG_ins_unit[];
  54. extern    char    MSG_kill_buffer[];
  55. extern    char    MSG_load_bindings[];
  56. extern    char    MSG_forw_window[];
  57. extern    char    MSG_back_window[];
  58. extern    char    MSG_view_file[];
  59. extern    char    MSG_enlarge_window[];
  60. extern    char    MSG_ascii_mode[];
  61. extern    char    MSG_binary_mode[];
  62. extern    char    MSG_buffer_name[];
  63. extern    char    MSG_decimal_mode[];
  64. extern    char    MSG_ebcdic_mode[];
  65. extern    char    MSG_hex_mode[];
  66. extern    char    MSG_back_del_unit[];
  67. extern    char    MSG_octal_mode[];
  68. extern    char    MSG_display_version[];
  69. extern    char    MSG_unit_size1[];
  70. extern    char    MSG_unit_size2[];
  71. extern    char    MSG_unit_size4[];
  72. extern    char    MSG_reposition_window[];
  73. extern    char    MSG_set_mark[];
  74. extern    char    MSG_goto_eob[];
  75. extern    char    MSG_goto_bob[];
  76. extern    char    MSG_next_buff[];
  77. extern    char    MSG_prev_buff[];
  78. extern    char    MSG_query_replace[];
  79. extern    char    MSG_display_bindings[];
  80. extern    char    MSG_auto_save[];
  81. extern    char    MSG_back_unit[];
  82. extern    char    MSG_compare[];
  83. extern    char    MSG_forw_del_unit[];
  84. extern    char    MSG_forw_unit[];
  85. extern    char    MSG_link_windows[];
  86. extern    char    MSG_print[];
  87. extern    char    MSG_back_search[];
  88. extern    char    MSG_forw_search[];
  89. extern    char    MSG_back_page[];
  90. extern    char    MSG_copy_region[];
  91. extern    char    MSG_extended_command[];
  92. extern    char    MSG_up_window[];
  93. extern    char    MSG_search_again[];
  94. extern    char    MSG_bind_to_key[];
  95. extern    char    MSG_file_visit_split[];
  96. extern    char    MSG_yank_buffer[];
  97. extern    char    MSG_save_region[];
  98. extern    char    MSG_use_buffer_split[];
  99. extern    char    MSG_no_f_tb[];
  100.  
  101. #include    "lintfunc.dec"
  102. #define SPECIAL 0x1F            /* Special keys         */
  103.  
  104. typedef    struct  key_name_array 
  105.     {
  106.     int     key_code;
  107.     char    *func_name_str;
  108.     char    *key_name_str;
  109.     }   KEY_NAME_ARRAY; 
  110. #if MSDOS
  111. extern  bool    wang_pc;
  112. extern  bool    ibm_pc;
  113. #endif
  114. /*
  115.  * The keyboard's special characters, those things that are prefixed with
  116.  * a 0x1F, are placed into the keyboard tables as KCTRL || 0x80 || x, for some
  117.  * x, i.e. they have both the control and 0x80 bits set, so they won't conflict
  118.  * with anything else on the keyboard.
  119.  */
  120.  
  121.  
  122. /*
  123.  * Names for the keys with basic keycode
  124.  * between KFIRST and KLAST (inclusive). This is used by
  125.  * the key name routine in "kbd.c".
  126.  */
  127. #if MSDOS
  128. KEY_NAME_ARRAY wang_keys[] =
  129. {
  130.     KCTRL | 0x80, MSG_bind_to_key, "Indent", 
  131. /*  KCTRL | 0x81, NULL, "Page", */
  132.     KCTRL | 0x82, MSG_reposition_window, "Center",
  133. /*  KCTRL | 0x83, NULL, "DecTab", */
  134. /*  KCTRL | 0x84, NULL, "Format", */
  135. /*  KCTRL | 0x85, NULL, "Merge", */
  136. /*  KCTRL | 0x86, NULL, "Note", */
  137.     KCTRL | 0x87, MSG_set_mark, "Stop",
  138.     KCTRL | 0x88, MSG_forw_search, "Search", 
  139.     KCTRL | 0x89, MSG_yank, "Replace",
  140.     KCTRL | 0x8A, MSG_copy_region, "Copy",
  141.     KCTRL | 0x8B, MSG_kill_region, "Move",
  142.     KCTRL | 0x8C, MSG_extended_command, "Command",
  143.     KCTRL | 0x8D, MSG_forw_window, "UpDown",
  144. /*  KCTRL | 0x8E, NULL, "BlankKey", */
  145.     KCTRL | 0x8F, MSG_goto_line, "GoTo",
  146. /*  KCTRL | 0x90, NULL, "Sh-Indent", */
  147. /*  KCTRL | 0x91, NULL, "Sh-Page", */
  148. /*  KCTRL | 0x92, NULL, "Sh-Center", */
  149. /*  KCTRL | 0x93, NULL, "Sh-DecTab", */
  150. /*  KCTRL | 0x94, NULL, "Sh-Format", */
  151. /*  KCTRL | 0x95, NULL, "Sh-Merge", */
  152. /*  KCTRL | 0x96, NULL, "Sh-Note", */
  153. /*  KCTRL | 0x97, NULL, "Sh-Stop", */
  154.     KCTRL | 0x98, MSG_search_again, "Sh-Search",
  155.     KCTRL | 0x99, MSG_query_replace, "Sh-Replace",
  156. /*  KCTRL | 0x9A, NULL, "Sh-Copy", */
  157. /*  KCTRL | 0x9B, NULL, "Sh-Move", */
  158. /*  KCTRL | 0x9C, NULL, "Sh-Command", */
  159.     KCTRL | 0x9D, MSG_split_window, "Sh-UpDown",
  160. /*  KCTRL | 0x9E, NULL, "Sh-BlankKey", */
  161. /*  KCTRL | 0x9F, NULL, "Sh-GoTo", */
  162.     KCTRL | 0xC0, MSG_back_line, "North",
  163.     KCTRL | 0xC1, MSG_forw_char, "East",
  164.     KCTRL | 0xC2, MSG_forw_line, "South",
  165.     KCTRL | 0xC3, MSG_back_char, "West",
  166.     KCTRL | 0xC4, MSG_byte_shift, "Home",
  167. /*  KCTRL | 0xC5, NULL, "Execute", */
  168.     KCTRL | 0xC6, MSG_ins_toggle, "Insert",
  169.     KCTRL | 0xC7, MSG_forw_del_char, "Delete",
  170.     KCTRL | 0xC8, MSG_back_page, "PrevPage",
  171.     KCTRL | 0xC9, MSG_forw_page, "NextPage",
  172. /*  KCTRL | 0xCB, NULL, "Erase", */
  173. /*  KCTRL | 0xCD, NULL, "BackTab", */
  174. /*  KCTRL | 0xD0, NULL, "Sh-North", */
  175.     KCTRL | 0xD1, MSG_forw_unit, "Sh-East",
  176. /*  KCTRL | 0xD2, NULL, "Sh-South", */
  177.     KCTRL | 0xD3, MSG_back_unit, "Sh-West",
  178. /*  KCTRL | 0xD4, NULL, "Sh-Home", */
  179.     KCTRL | 0xD5, MSG_execute_macro, "Sh-Execute",
  180. /*  KCTRL | 0xD6, NULL, "Sh-Insert", */
  181.     KCTRL | 0xD7, MSG_forw_del_unit, "Sh-Delete",
  182.     KCTRL | 0xD8, MSG_goto_bob, "Sh-PrevPage",
  183.     KCTRL | 0xD9, MSG_goto_eob, "Sh-NextPage",
  184. /*  KCTRL | 0xDB, NULL, "Sh-Erase", */
  185. /*  KCTRL | 0xDC, NULL, "Sh-Tab", */
  186. /*  KCTRL | 0xDD, NULL, "Sh-BackTab", */
  187.     KCTRL | 0xE0, MSG_abort, "Cancel",
  188.     KMETA | KCTRL | 0xE0, MSG_abort, "Cancel",
  189.     KCTLX | KCTRL | 0xE0, MSG_abort, "Ctl-X Cancel",
  190.     KCTRL | 0xE1, MSG_display_bindings, "Help",
  191. /*  KCTRL | 0xE2, NULL, "Glossary", */
  192.     KCTRL | 0xE3, MSG_print, "Print",
  193.     KCTRL | 0xF1, MSG_help, "Sh-Help",
  194. /*  KCTRL | 0xF2, NULL, "Sh-Glossary", */
  195. /*  KCTRL | 0xF3, NULL, "Sh-Print", */
  196.     0, NULL, NULL
  197.     };
  198.  
  199. KEY_NAME_ARRAY  ibm_keys[] =
  200.     {
  201.     KCTLX | 0x80 | 0x3B, MSG_display_bindings, "F1",
  202.     KCTLX | 0x80 | 0x3C, MSG_set_mark, "F2",
  203.     KCTLX | 0x80 | 0x3D, MSG_forw_search, "F3",
  204.     KCTLX | 0x80 | 0x3E, MSG_search_again, "F4",
  205.     KCTLX | 0x80 | 0x3F, MSG_query_replace, "F5",
  206.     KCTLX | 0x80 | 0x40, MSG_yank, "F6",
  207.     KCTLX | 0x80 | 0x41, MSG_copy_region, "F7",
  208.     KCTLX | 0x80 | 0x42, MSG_kill_region, "F8",
  209.     KCTLX | 0x80 | 0x43, MSG_goto_line, "F9",
  210.     KCTLX | 0x80 | 0x44, MSG_abort, "F10",
  211.     KCTLX | 0x80 | 0x54, MSG_help, "Sh-F1",
  212.     KCTLX | 0x80 | 0x55, MSG_file_read, "Sh-F2",
  213.     KCTLX | 0x80 | 0x56, MSG_file_save, "Sh-F3",
  214.     KCTLX | 0x80 | 0x57, MSG_file_visit, "Sh-F4",
  215.     KCTLX | 0x80 | 0x58, MSG_file_write, "Sh-F5",
  216.     KCTLX | 0x80 | 0x59, MSG_flush_all, "Sh-F6",
  217.     KCTLX | 0x80 | 0x5A, MSG_set_file_name, "Sh-F7",
  218.     KCTLX | 0x80 | 0x5B, MSG_file_insert, "Sh-F8",
  219.     KCTLX | 0x80 | 0x5C, MSG_exit_flush_all, "Sh-F9",
  220.     KCTLX | 0x80 | 0x5D, MSG_quit, "Sh-F10",
  221.     KCTLX | 0x80 | 0x5E, MSG_display_buffers, "Ctl-F1",
  222.     KCTLX | 0x80 | 0x5F, MSG_use_buffer, "Ctl-F2",
  223.     KCTLX | 0x80 | 0x60, MSG_kill_buffer, "Ctl-F3",
  224.     KCTLX | 0x80 | 0x61, MSG_next_buff, "Ctl-F4",
  225.     KCTLX | 0x80 | 0x62, MSG_prev_buff, "Ctl-F5",
  226.     KCTLX | 0x80 | 0x63, MSG_yank_buffer, "Ctl-F6",
  227.     KCTLX | 0x80 | 0x64, MSG_set_file_name, "Ctl-F7",
  228.     KCTLX | 0x80 | 0x65, MSG_file_insert, "Ctl-F8",
  229.     KCTLX | 0x80 | 0x66, MSG_exit_flush_all, "Ctl-F9",
  230.     KCTLX | 0x80 | 0x67, MSG_quit, "Ctl-F10",
  231.     KCTLX | 0x80 | 0x48, MSG_back_line, "North",
  232.     KCTLX | 0x80 | 0x4D, MSG_forw_char, "East",
  233.     KCTLX | 0x80 | 0x74, MSG_forw_unit, "Ctl-East",
  234.     KCTLX | 0x80 | 0x50, MSG_forw_line, "South",
  235.     KCTLX | 0x80 | 0x4B, MSG_back_char, "West",
  236.     KCTLX | 0x80 | 0x73, MSG_back_unit, "Ctl-West",
  237.     KCTLX | 0x80 | 0x49, MSG_back_page, "PageDown",
  238.     KCTLX | 0x80 | 0x47, MSG_goto_bob, "Home",
  239.     KCTLX | 0x80 | 0x51, MSG_forw_page, "PageUp",
  240.     KCTLX | 0x80 | 0x4F, MSG_goto_eob, "End",
  241.     KCTLX | 0x80 | 0x52, MSG_ins_toggle, "Insert",
  242.     KCTLX | 0x80 | 0x53, MSG_forw_del_char, "Delete",
  243.     KCTLX | 0x80 | 0x76, MSG_forw_window, "Ctl-PageDown",
  244.     KCTLX | 0x80 | 0x84, MSG_back_window, "Ctl-PageUp",
  245.     KCTLX | 0x80 | 0x72, MSG_print, "Ctl-Print",
  246.     KCTLX | 0x80 | 0x0F, MSG_forw_unit, "Sh-Tab",
  247.     0, NULL, NULL
  248.     };
  249. #endif
  250. /*
  251.  * Read in a key, doing the low level mapping
  252.  * of ASCII code to 11 bit code.  This level deals with
  253.  * mapping the special keys into their spots in the C1
  254.  * control area.  The C0 controls go right through, and
  255.  * get remapped by "getkey".
  256.  */
  257. static int  unkey = KRANDOM;    /* jam - for ungetkey */
  258. void ungetkey (k)
  259. {
  260.     unkey = k;
  261. }
  262.  
  263. int     getkbd ()
  264. {
  265.     register int    c;
  266.  
  267.     if (unkey == KRANDOM)       /* jam */
  268.         c = ttgetc ();
  269.     else
  270.         {
  271.         c = unkey;
  272.         unkey = KRANDOM;
  273.         }
  274.     if (c == SPECIAL)
  275.         {
  276.         c = ttgetc ();
  277.         if ((c == 0xCD) || (c == 0xDD))/* Backtab is meta */
  278.             return (METACH);
  279.         return (c | KCTRL);
  280.         }
  281.     if (c == 0)
  282.         {
  283.         c = ttgetc ();
  284.         return (c | 0x80 | KCTLX);
  285.         }
  286.     return (c);
  287. }
  288.  
  289.  
  290. /*
  291.  * Terminal specific keymap initialization.
  292.  * Attach the special keys to the appropriate built
  293.  * in functions.
  294.  * As is the case of all the keymap routines, errors
  295.  * are very fatal.
  296.  */
  297. void ttykeymapinit ()
  298. {
  299. KEY_NAME_ARRAY  *ptr;
  300. int     i;
  301. char    buf[60];
  302. #if MSDOS
  303.     if (wang_pc)
  304.         ptr = wang_keys;
  305.  
  306.     if (ibm_pc)
  307.         ptr = ibm_keys;
  308.  
  309.     if (!wang_pc && !ibm_pc)
  310.         return;
  311.  
  312.     i = 0;
  313.     while (ptr -> key_code != 0)
  314.         {
  315.         if (ptr -> func_name_str != NULL)
  316.             keydup (ptr -> key_code, ptr -> func_name_str);
  317.         ptr++;
  318.         i++;
  319.         }
  320.     sprintf (buf, MSG_sp_key, i);
  321.     writ_echo (buf);
  322. #endif
  323. }
  324. /* 
  325. *   Search key name array for given key code.
  326. *   return pointer to key name.
  327. */
  328. char    *keystrings (key)
  329. int     key;
  330.     {
  331. #if MSDOS
  332.     KEY_NAME_ARRAY  *ptr;
  333.     
  334.     if (wang_pc)
  335.         ptr = wang_keys;
  336.  
  337.     if (ibm_pc)
  338.         ptr = ibm_keys;
  339.  
  340.     if (!wang_pc && !ibm_pc)
  341.         return(NULL);
  342.  
  343.     while (ptr -> key_code != 0)
  344.         {
  345.         if (key == ptr -> key_code)
  346.             {
  347.             return (ptr -> key_name_str);
  348.             }
  349.         ptr++;
  350.         }
  351. #endif
  352.     return (NULL);
  353.     }
  354.