home *** CD-ROM | disk | FTP | other *** search
/ Dream 52 / Amiga_Dream_52.iso / OS2 / gnuinfo.zip / info / infomap.c < prev    next >
C/C++ Source or Header  |  1997-07-31  |  12KB  |  369 lines
  1. /* infomap.c -- Keymaps for Info.
  2.    $Id: infomap.c,v 1.7 1997/07/31 20:37:32 karl Exp $
  3.  
  4.    Copyright (C) 1993, 97 Free Software Foundation, Inc.
  5.  
  6.    This program is free software; you can redistribute it and/or modify
  7.    it under the terms of the GNU General Public License as published by
  8.    the Free Software Foundation; either version 2, or (at your option)
  9.    any later version.
  10.  
  11.    This program is distributed in the hope that it will be useful,
  12.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.    GNU General Public License for more details.
  15.  
  16.    You should have received a copy of the GNU General Public License
  17.    along with this program; if not, write to the Free Software
  18.    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19.  
  20.    Written by Brian Fox (bfox@ai.mit.edu). */
  21.  
  22. #include "info.h"
  23. #include "infomap.h"
  24. #include "funs.h"
  25. #include "terminal.h"
  26.  
  27. /* Return a new keymap which has all the uppercase letters mapped to run
  28.    the function info_do_lowercase_version (). */
  29. Keymap
  30. keymap_make_keymap ()
  31. {
  32.   register int i;
  33.   Keymap keymap;
  34.  
  35.   keymap = (Keymap)xmalloc (256 * sizeof (KEYMAP_ENTRY));
  36.  
  37.   for (i = 0; i < 256; i++)
  38.     {
  39.       keymap[i].type = ISFUNC;
  40.       keymap[i].function = (VFunction *)NULL;
  41.     }
  42.  
  43.   for (i = 'A'; i < ('Z' + 1); i++)
  44.     {
  45.       keymap[i].type = ISFUNC;
  46.       keymap[i].function = info_do_lowercase_version;
  47.     }
  48.  
  49.   return (keymap);
  50. }
  51.  
  52. /* Return a new keymap which is a copy of MAP. */
  53. Keymap
  54. keymap_copy_keymap (map)
  55.      Keymap map;
  56. {
  57.   register int i;
  58.   Keymap keymap;
  59.  
  60.   keymap = keymap_make_keymap ();
  61.  
  62.   for (i = 0; i < 256; i++)
  63.     {
  64.       keymap[i].type = map[i].type;
  65.       keymap[i].function = map[i].function;
  66.     }
  67.   return (keymap);
  68. }
  69.  
  70. /* Free the keymap and it's descendents. */
  71. void
  72. keymap_discard_keymap (map)
  73.      Keymap (map);
  74. {
  75.   register int i;
  76.  
  77.   if (!map)
  78.     return;
  79.  
  80.   for (i = 0; i < 256; i++)
  81.     {
  82.       switch (map[i].type)
  83.         {
  84.         case ISFUNC:
  85.           break;
  86.  
  87.         case ISKMAP:
  88.           keymap_discard_keymap ((Keymap)map[i].function);
  89.           break;
  90.  
  91.         }
  92.     }
  93. }
  94.  
  95. /* Conditionally bind key sequence. */
  96. int
  97. keymap_bind_keyseq (map, keyseq, keyentry)
  98.      Keymap map;
  99.      const unsigned char *keyseq;
  100.      KEYMAP_ENTRY *keyentry;
  101. {
  102.   register Keymap m = map;
  103.   register const unsigned char *s = keyseq;
  104.   register int c;
  105.  
  106.   if (s == NULL || *s == '\0') return 0;
  107.  
  108.   while ((c = *s++) != '\0')
  109.     {
  110.       switch (m[c].type)
  111.         {
  112.         case ISFUNC:
  113.           if (!(m[c].function == NULL ||
  114.                 (m != map && m[c].function == info_do_lowercase_version)))
  115.             return 0;
  116.  
  117.           if (*s != '\0')
  118.             {
  119.               m[c].type = ISKMAP;
  120.               m[c].function = (VFunction *)keymap_make_keymap ();
  121.             }
  122.           break;
  123.  
  124.         case ISKMAP:
  125.           if (*s == '\0')
  126.             return 0;
  127.           break;
  128.         }
  129.       if (*s != '\0')
  130.         {
  131.           m = (Keymap)m[c].function;
  132.         }
  133.       else
  134.         {
  135.           m[c] = *keyentry;
  136.         }
  137.     }
  138.  
  139.   return 1;
  140. }
  141.  
  142. /* Initialize the standard info keymaps. */
  143.  
  144. Keymap info_keymap = (Keymap)NULL;
  145. Keymap echo_area_keymap = (Keymap)NULL;
  146.  
  147. void
  148. initialize_info_keymaps ()
  149. {
  150.   register int i;
  151.   Keymap map;
  152.  
  153.   if (!info_keymap)
  154.     {
  155.       info_keymap = keymap_make_keymap ();
  156.       info_keymap[ESC].type = ISKMAP;
  157.       info_keymap[ESC].function = (VFunction *)keymap_make_keymap ();
  158.       info_keymap[Control ('x')].type = ISKMAP;
  159.       info_keymap[Control ('x')].function = (VFunction *)keymap_make_keymap ();
  160.       echo_area_keymap = keymap_make_keymap ();
  161.       echo_area_keymap[ESC].type = ISKMAP;
  162.       echo_area_keymap[ESC].function = (VFunction *)keymap_make_keymap ();
  163.       echo_area_keymap[Control ('x')].type = ISKMAP;
  164.       echo_area_keymap[Control ('x')].function =
  165.         (VFunction *)keymap_make_keymap ();
  166.     }
  167.  
  168.   /* Bind numeric arg functions for both echo area and info window maps. */
  169.   for (i = '0'; i < '9' + 1; i++)
  170.     {
  171.       ((Keymap) info_keymap[ESC].function)[i].function =
  172.         ((Keymap) echo_area_keymap[ESC].function)[i].function =
  173.           info_add_digit_to_numeric_arg;
  174.     }
  175.   ((Keymap) info_keymap[ESC].function)['-'].function =
  176.     ((Keymap) echo_area_keymap[ESC].function)['-'].function =
  177.       info_add_digit_to_numeric_arg;
  178.  
  179.   /* Bind the echo area routines. */
  180.   map = echo_area_keymap;
  181.  
  182.   /* Bind the echo area insert routines. */
  183.   for (i = 0; i < 160; i++)
  184.     if (isprint (i))
  185.       map[i].function = ea_insert;
  186.  
  187.   map[Control ('a')].function = ea_beg_of_line;
  188.   map[Control ('b')].function = ea_backward;
  189.   map[Control ('d')].function = ea_delete;
  190.   map[Control ('e')].function = ea_end_of_line;
  191.   map[Control ('f')].function = ea_forward;
  192.   map[Control ('g')].function = ea_abort;
  193.   map[Control ('h')].function = ea_rubout;
  194.   map[Control ('k')].function = ea_kill_line;
  195.   map[Control ('l')].function = info_redraw_display;
  196.   map[Control ('q')].function = ea_quoted_insert;
  197.   map[Control ('t')].function = ea_transpose_chars;
  198.   map[Control ('u')].function = info_universal_argument;
  199.   map[Control ('y')].function = ea_yank;
  200.  
  201.   map[LFD].function = ea_newline;
  202.   map[RET].function = ea_newline;
  203.   map[SPC].function = ea_complete;
  204.   map[TAB].function = ea_complete;
  205.   map['?'].function = ea_possible_completions;
  206.   map[DEL].function = ea_rubout;
  207.  
  208.   /* Bind the echo area ESC keymap. */
  209.   map = (Keymap)echo_area_keymap[ESC].function;
  210.  
  211.   map[Control ('g')].function = ea_abort;
  212.   map[Control ('v')].function = ea_scroll_completions_window;
  213.   map['b'].function = ea_backward_word;
  214.   map['d'].function = ea_kill_word;
  215.   map['f'].function = ea_forward_word;
  216. #if defined (NAMED_FUNCTIONS)
  217.   /* map['x'].function = info_execute_command; */
  218. #endif /* NAMED_FUNCTIONS */
  219.   map['y'].function = ea_yank_pop;
  220.   map['?'].function = ea_possible_completions;
  221.   map[TAB].function = ea_tab_insert;
  222.   map[DEL].function = ea_backward_kill_word;
  223.  
  224.   /* Bind the echo area Control-x keymap. */
  225.   map = (Keymap)echo_area_keymap[Control ('x')].function;
  226.  
  227.   map['o'].function = info_next_window;
  228.   map[DEL].function = ea_backward_kill_line;
  229.  
  230.   /* Arrow key bindings for echo area keymaps.  It seems that some
  231.      terminals do not match their termcap entries, so it's best to just
  232.      define everything with both of the usual prefixes.  */
  233.   map = echo_area_keymap;
  234.   keymap_bind_keyseq (map, term_ku, &map[Control ('p')]); /* up */
  235.   keymap_bind_keyseq (map, "\033OA", &map[Control ('p')]);
  236.   keymap_bind_keyseq (map, "\033[A", &map[Control ('p')]);
  237.   keymap_bind_keyseq (map, term_kd, &map[Control ('n')]); /* down */
  238.   keymap_bind_keyseq (map, "\033OB", &map[Control ('n')]);
  239.   keymap_bind_keyseq (map, "\033[B", &map[Control ('n')]);
  240.   keymap_bind_keyseq (map, term_kr, &map[Control ('f')]); /* right */
  241.   keymap_bind_keyseq (map, "\033OC", &map[Control ('f')]);
  242.   keymap_bind_keyseq (map, "\033[C", &map[Control ('f')]);
  243.   keymap_bind_keyseq (map, term_kl, &map[Control ('b')]); /* left */
  244.   keymap_bind_keyseq (map, "\033OD", &map[Control ('b')]);
  245.   keymap_bind_keyseq (map, "\033[D", &map[Control ('b')]);
  246.  
  247.   map = (Keymap)echo_area_keymap[ESC].function;
  248.   keymap_bind_keyseq (map, term_kl, &map['b']); /* left */
  249.   keymap_bind_keyseq (map, "\033OA", &map['b']);
  250.   keymap_bind_keyseq (map, "\033[A", &map['b']);
  251.   keymap_bind_keyseq (map, term_kr, &map['f']); /* right */
  252.   keymap_bind_keyseq (map, "\033OB", &map['f']);
  253.   keymap_bind_keyseq (map, "\033[B", &map['f']);
  254.  
  255.   /* Bind commands for Info window keymaps. */
  256.   map = info_keymap;
  257.   map[TAB].function = info_move_to_next_xref;
  258.   map[LFD].function = info_select_reference_this_line;
  259.   map[RET].function = info_select_reference_this_line;
  260.   map[SPC].function = info_scroll_forward;
  261.   map[Control ('a')].function = info_beginning_of_line;
  262.   map[Control ('b')].function = info_backward_char;
  263.   map[Control ('e')].function = info_end_of_line;
  264.   map[Control ('f')].function = info_forward_char;
  265.   map[Control ('g')].function = info_abort_key;
  266.   map[Control ('h')].function = info_get_help_window;
  267.   map[Control ('l')].function = info_redraw_display;
  268.   map[Control ('n')].function = info_next_line;
  269.   map[Control ('p')].function = info_prev_line;
  270.   map[Control ('r')].function = isearch_backward;
  271.   map[Control ('s')].function = isearch_forward;
  272.   map[Control ('u')].function = info_universal_argument;
  273.   map[Control ('v')].function = info_scroll_forward;
  274.   map[','].function = info_next_index_match;
  275.  
  276.   for (i = '1'; i < '9' + 1; i++)
  277.     map[i].function = info_menu_digit;
  278.   map['0'].function = info_last_menu_item;
  279.  
  280.   map['<'].function = info_first_node;
  281.   map['>'].function = info_last_node;
  282.   map['?'].function = info_get_help_window;
  283.   map['['].function = info_global_prev_node;
  284.   map[']'].function = info_global_next_node;
  285.  
  286.   map['b'].function = info_beginning_of_node;
  287.   map['d'].function = info_dir_node;
  288.   map['e'].function = info_end_of_node;
  289.   map['f'].function = info_xref_item;
  290.   map['g'].function = info_goto_node;
  291.   map['h'].function = info_get_info_help_node;
  292.   map['i'].function = info_index_search;
  293.   map['l'].function = info_history_node;
  294.   map['m'].function = info_menu_item;
  295.   map['n'].function = info_next_node;
  296.   map['p'].function = info_prev_node;
  297.   map['q'].function = info_quit;
  298.   map['r'].function = info_xref_item;
  299.   map['s'].function = info_search;
  300.   map['t'].function = info_top_node;
  301.   map['u'].function = info_up_node;
  302.   map[DEL].function = info_scroll_backward;
  303.  
  304.   /* Bind members in the ESC map for Info windows. */
  305.   map = (Keymap)info_keymap[ESC].function;
  306.   map[Control ('f')].function = info_show_footnotes;
  307.   map[Control ('g')].function = info_abort_key;
  308.   map[TAB].function = info_move_to_prev_xref;
  309.   map[Control ('v')].function = info_scroll_other_window;
  310.   map['<'].function = info_beginning_of_node;
  311.   map['>'].function = info_end_of_node;
  312.   map['b'].function = info_backward_word;
  313.   map['f'].function = info_forward_word;
  314.   map['r'].function = info_move_to_window_line;
  315.   map['v'].function = info_scroll_backward;
  316. #if defined (NAMED_FUNCTIONS)
  317.   map['x'].function = info_execute_command;
  318. #endif /* NAMED_FUNCTIONS */
  319.  
  320.   /* Bind members in the Control-X map for Info windows. */
  321.   map = (Keymap)info_keymap[Control ('x')].function;
  322.  
  323.   map[Control ('b')].function = list_visited_nodes;
  324.   map[Control ('c')].function = info_quit;
  325.   map[Control ('f')].function = info_view_file;
  326.   map[Control ('g')].function = info_abort_key;
  327.   map[Control ('v')].function = info_view_file;
  328.   map['0'].function = info_delete_window;
  329.   map['1'].function = info_keep_one_window;
  330.   map['2'].function = info_split_window;
  331.   map['^'].function = info_grow_window;
  332.   map['b'].function = select_visited_node;
  333.   map['k'].function = info_kill_node;
  334.   map['o'].function = info_next_window;
  335.   map['t'].function = info_tile_windows;
  336.   map['w'].function = info_toggle_wrap;
  337.  
  338.   /* Arrow key bindings for Info windows keymap. */
  339.   map = info_keymap;
  340.   keymap_bind_keyseq (map, term_kN, &map[Control ('v')]); /* pagedown */
  341.   keymap_bind_keyseq (map, term_ku, &map[Control ('p')]); /* up */
  342.   keymap_bind_keyseq (map, "\033OA", &map[Control ('p')]);
  343.   keymap_bind_keyseq (map, "\033[A", &map[Control ('p')]);
  344.   keymap_bind_keyseq (map, term_kd, &map[Control ('n')]); /* down */
  345.   keymap_bind_keyseq (map, "\033OB", &map[Control ('n')]);
  346.   keymap_bind_keyseq (map, "\033[B", &map[Control ('n')]);
  347.   keymap_bind_keyseq (map, term_kr, &map[Control ('f')]); /* right */
  348.   keymap_bind_keyseq (map, "\033OC", &map[Control ('f')]);
  349.   keymap_bind_keyseq (map, "\033[C", &map[Control ('f')]);
  350.   keymap_bind_keyseq (map, term_kl, &map[Control ('b')]); /* left */
  351.   keymap_bind_keyseq (map, "\033OD", &map[Control ('b')]);
  352.   keymap_bind_keyseq (map, "\033[D", &map[Control ('b')]);
  353.  
  354.   map = (Keymap)info_keymap[ESC].function;
  355.   keymap_bind_keyseq (map, term_kl, &map['b']); /* left */
  356.   keymap_bind_keyseq (map, "\033OA", &map['b']);
  357.   keymap_bind_keyseq (map, "\033[A", &map['b']);
  358.   keymap_bind_keyseq (map, term_kr, &map['f']); /* right */
  359.   keymap_bind_keyseq (map, "\033OB", &map['f']);
  360.   keymap_bind_keyseq (map, "\033[B", &map['f']);
  361.   keymap_bind_keyseq (map, term_kN, &map[Control ('v')]); /* pagedown */
  362.  
  363.   /* The alternative to this definition of a `main map' key in the
  364.      `ESC map' section, is something like:
  365.     keymap_bind_keyseq (map, term_kP, &((KeyMap)map[ESC].function).map['v']);
  366.   */
  367.   keymap_bind_keyseq (info_keymap/*sic*/, term_kP, &map['v']); /* pageup */
  368. }
  369.