texinfo/info/infomap.c

   1 /* infomap.c -- Keymaps for Info.
   2    $Id: infomap.c,v 1.1.1.2 1998/03/22 20:42:40 law 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 }