git.chise.org Git - chise/xemacs-chise.git-/blob - src/redisplay-tty.c

   1 /* Communication module for TTY terminals.
   2    Copyright (C) 1994, 1995 Board of Trustees, University of Illinois.
   3    Copyright (C) 1995 Sun Microsystems, Inc.
   4    Copyright (C) 1995, 1996 Ben Wing.
   5    Copyright (C) 1996 Chuck Thompson.
   6
   7 This file is part of XEmacs.
   8
   9 XEmacs is free software; you can redistribute it and/or modify it
  10 under the terms of the GNU General Public License as published by the
  11 Free Software Foundation; either version 2, or (at your option) any
  12 later version.
  13
  14 XEmacs is distributed in the hope that it will be useful, but WITHOUT
  15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  17 for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with XEmacs; see the file COPYING.  If not, write to
  21 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  22 Boston, MA 02111-1307, USA.  */
  23
  24 /* Synched up with: Not completely synched with FSF.  Mostly divergent
  25    from FSF. */
  26
  27 /* This file has been Mule-ized. */
  28
  29 /* Written by Chuck Thompson. */
  30 /* Color support added by Ben Wing. */
  31
  32 #include <config.h>
  33 #include "lisp.h"
  34
  35 #include "buffer.h"
  36 #include "console-tty.h"
  37 #include "events.h"
  38 #include "faces.h"
  39 #include "frame.h"
  40 #include "glyphs.h"
  41 #include "lstream.h"
  42 #include "objects-tty.h"
  43 #include "redisplay.h"
  44 #include "sysdep.h"
  45 #include "window.h"
  46
  47 /* These headers #define all kinds of common words like "columns"...
  48    What a bunch of losers.  If we were to include them, we'd have to
  49    include them last to prevent them from messing up our own header
  50    files (struct slot names, etc.).  But it turns out that there are
  51    other conflicts as well on some systems, so screw it: we'll just
  52    re-declare the routines we use and assume the code in this file is
  53    invoking them correctly. */
  54 /* # include <curses.h> */
  55 /* # include <term.h> */
  56 EXTERN_C int tgetent (const char *, const char *);
  57 EXTERN_C int tgetflag (const char *);
  58 EXTERN_C int tgetnum (const char *);
  59 EXTERN_C char *tgetstr (const char *, char **);
  60 EXTERN_C void tputs (const char *, int, void (*)(int));
  61
  62 #define FORCE_CURSOR_UPDATE(c) send_string_to_tty_console (c, 0, 0)
  63 #define OUTPUTN(c, a, n)                        \
  64   do {                                          \
  65     cmputc_console = c;                         \
  66     FORCE_CURSOR_UPDATE (c);                    \
  67     tputs (a, n, cmputc);                       \
  68   } while (0)
  69 #define OUTPUT1(c, a) OUTPUTN (c, a, 1)
  70 #define OUTPUTN_IF(c, a, n)                     \
  71   do {                                          \
  72     cmputc_console = c;                         \
  73     FORCE_CURSOR_UPDATE (c);                    \
  74     if (a)                                      \
  75       tputs (a, n, cmputc);                     \
  76   } while (0)
  77 #define OUTPUT1_IF(c, a) OUTPUTN_IF (c, a, 1)
  78
  79 static void tty_output_charc_dynarr (struct window *w,
  80                                      struct display_line *dl,
  81                                      Charc_dynarr *buf, int xpos,
  82                                      face_index findex,
  83                                      int cursor);
  84 static void tty_output_bufbyte_string (struct window *w,
  85                                        struct display_line *dl,
  86                                        Bufbyte *str, Bytecount len,
  87                                        int xpos, face_index findex,
  88                                        int cursor);
  89 static void tty_turn_on_face (struct window *w, face_index findex);
  90 static void tty_turn_off_face (struct window *w, face_index findex);
  91 static void tty_turn_on_frame_face (struct frame *f, Lisp_Object face);
  92 static void tty_turn_off_frame_face (struct frame *f, Lisp_Object face);
  93
  94 static void term_get_fkeys (Lisp_Object keymap, char **address);
  95
  96 /*****************************************************************************
  97  tty_text_width
  98
  99  Non-Mule tty's don't have fonts (that we use at least), so everything
 100  is considered to be fixed width -- in other words, we return LEN.
 101  Under Mule, however, a character can still cover more than one
 102  column, so we use charc_string_displayed_columns().
 103  ****************************************************************************/
 104 static int
 105 tty_text_width (struct frame *f, struct face_cachel *cachel,
 106                 const Charc *str, Charcount len)
 107 {
 108   return charc_string_displayed_columns (str, len);
 109 }
 110
 111 /*****************************************************************************
 112  tty_divider_height
 113
 114  Return the width of the horizontal divider.  This is a function
 115  because divider_height is a console method.
 116  ****************************************************************************/
 117 static int
 118 tty_divider_height (void)
 119 {
 120   return 1;
 121 }
 122
 123 /*****************************************************************************
 124  tty_eol_cursor_width
 125
 126  Return the width of the end-of-line cursor.  This is a function
 127  because eol_cursor_width is a console method.
 128  ****************************************************************************/
 129 static int
 130 tty_eol_cursor_width (void)
 131 {
 132   return 1;
 133 }
 134
 135 /*****************************************************************************
 136  tty_frame_output_begin
 137
 138  Perform any necessary initialization prior to an update.
 139  ****************************************************************************/
 140 #ifdef DEBUG_XEMACS
 141 void tty_frame_output_begin (struct frame *f);
 142 void
 143 #else
 144 static void
 145 #endif
 146 tty_frame_output_begin (struct frame *f)
 147 {
 148 #ifndef HAVE_TERMIOS
 149   /* Termcap requires `ospeed' to be a global variable so we have to
 150      always set it for whatever tty console we are actually currently
 151      working with. */
 152   ospeed = DEVICE_TTY_DATA (XDEVICE (FRAME_DEVICE (f)))->ospeed;
 153 #endif
 154 }
 155
 156 /*****************************************************************************
 157  tty_frame_output_end
 158
 159  Perform any necessary flushing of queues when an update has completed.
 160  ****************************************************************************/
 161 #ifdef DEBUG_XEMACS
 162 void tty_frame_output_end (struct frame *f);
 163 void
 164 #else
 165 static void
 166 #endif
 167 tty_frame_output_end (struct frame *f)
 168 {
 169   struct console *c = XCONSOLE (FRAME_CONSOLE (f));
 170
 171   CONSOLE_TTY_CURSOR_X (c) = CONSOLE_TTY_FINAL_CURSOR_X (c);
 172   CONSOLE_TTY_CURSOR_Y (c) = CONSOLE_TTY_FINAL_CURSOR_Y (c);
 173   FORCE_CURSOR_UPDATE (c);
 174   Lstream_flush (XLSTREAM (CONSOLE_TTY_DATA (c)->outstream));
 175 }
 176
 177 static void
 178 tty_set_final_cursor_coords (struct frame *f, int y, int x)
 179 {
 180   struct console *c = XCONSOLE (FRAME_CONSOLE (f));
 181
 182   CONSOLE_TTY_FINAL_CURSOR_X (c) = x;
 183   CONSOLE_TTY_FINAL_CURSOR_Y (c) = y;
 184 }
 185
 186 /*****************************************************************************
 187  tty_output_display_block
 188
 189  Given a display line, a block number for that start line, output all
 190  runes between start and end in the specified display block.
 191  ****************************************************************************/
 192 static void
 193 tty_output_display_block (struct window *w, struct display_line *dl, int block,
 194                           int start, int end, int start_pixpos,
 195                           int cursor_start, int cursor_width,
 196                           int cursor_height)
 197 {
 198   struct frame *f = XFRAME (w->frame);
 199   Charc_dynarr *buf = Dynarr_new (Charc);
 200
 201   struct display_block *db = Dynarr_atp (dl->display_blocks, block);
 202   rune_dynarr *rba = db->runes;
 203   struct rune *rb;
 204
 205   int elt = start;
 206   face_index findex;
 207   int xpos;
 208
 209   rb = Dynarr_atp (rba, elt);
 210
 211   if (!rb)
 212     {
 213       /* Nothing to do so don't do anything. */
 214       return;
 215     }
 216   else
 217     {
 218       findex = rb->findex;
 219       xpos = rb->xpos;
 220     }
 221
 222   if (end < 0)
 223     end = Dynarr_length (rba);
 224
 225   Dynarr_reset (buf);
 226
 227   while (elt < end && Dynarr_atp (rba, elt)->xpos < start_pixpos)
 228     {
 229       elt++;
 230       findex = Dynarr_atp (rba, elt)->findex;
 231       xpos = Dynarr_atp (rba, elt)->xpos;
 232     }
 233
 234   while (elt < end)
 235     {
 236       rb = Dynarr_atp (rba, elt);
 237
 238       if (rb->findex == findex && rb->type == RUNE_CHAR
 239           && (!CHARC_ASCII_EQ (rb->object.cglyph, '\n'))
 240           && (rb->cursor_type != CURSOR_ON
 241               || NILP (w->text_cursor_visible_p)))
 242         {
 243           Dynarr_add (buf, rb->object.cglyph);
 244           elt++;
 245         }
 246       else
 247         {
 248           if (Dynarr_length (buf))
 249             {
 250               tty_output_charc_dynarr (w, dl, buf, xpos, findex, 0);
 251               xpos = rb->xpos;
 252             }
 253           Dynarr_reset (buf);
 254
 255           if (rb->type == RUNE_CHAR)
 256             {
 257               findex = rb->findex;
 258               xpos = rb->xpos;
 259
 260               if (CHARC_ASCII_EQ (rb->object.cglyph, '\n'))
 261                 {
 262                   /* Clear in case a cursor was formerly here. */
 263                   Dynarr_add (buf, ASCII_TO_CHARC (' '));
 264                   tty_output_charc_dynarr (w, dl, buf, rb->xpos,
 265                                            DEFAULT_INDEX, 0);
 266                   Dynarr_reset (buf);
 267
 268                   cmgoto (f, dl->ypos - 1, rb->xpos);
 269
 270                   elt++;
 271                 }
 272               else if (rb->cursor_type == CURSOR_ON)
 273                 {
 274                   /* There is not a distinct eol cursor on tty's. */
 275
 276                   Dynarr_add (buf, rb->object.cglyph);
 277                   tty_output_charc_dynarr (w, dl, buf, xpos, findex, 0);
 278                   Dynarr_reset (buf);
 279
 280                   cmgoto (f, dl->ypos - 1, xpos);
 281
 282                   xpos += rb->width;
 283                   elt++;
 284                 }
 285             }
 286           /* #### RUNE_HLINE is actually a little more complicated than this
 287              but at the moment it is only used to draw a turned off
 288              modeline and this will suffice for that. */
 289           else if (rb->type == RUNE_BLANK || rb->type == RUNE_HLINE)
 290             {
 291               Charc ec_to_add;
 292               int size = rb->width;
 293
 294               if (rb->type == RUNE_BLANK)
 295                 ec_to_add = ASCII_TO_CHARC (' ');
 296               else
 297                 ec_to_add = ASCII_TO_CHARC ('-');
 298
 299               while (size--)
 300                 Dynarr_add (buf, ec_to_add);
 301               tty_output_charc_dynarr (w, dl, buf, rb->xpos, findex, 0);
 302
 303               if (xpos >= cursor_start
 304                   && cursor_start < xpos + Dynarr_length (buf))
 305                 {
 306                   cmgoto (f, dl->ypos - 1, cursor_start);
 307                 }
 308
 309               Dynarr_reset (buf);
 310
 311               elt++;
 312               if (elt < end)
 313                 {
 314                   rb = Dynarr_atp (rba, elt);
 315
 316                   findex = rb->findex;
 317                   xpos = rb->xpos;
 318                 }
 319             }
 320           else if (rb->type == RUNE_DGLYPH)
 321             {
 322               Lisp_Object window;
 323               Lisp_Object instance;
 324
 325               XSETWINDOW (window, w);
 326               instance = glyph_image_instance (rb->object.dglyph.glyph,
 327                                                window, ERROR_ME_NOT, 1);
 328
 329               if (IMAGE_INSTANCEP (instance))
 330                 {
 331                   switch (XIMAGE_INSTANCE_TYPE (instance))
 332                     {
 333                     case IMAGE_MONO_PIXMAP:
 334                     case IMAGE_COLOR_PIXMAP:
 335                     case IMAGE_SUBWINDOW:
 336                     case IMAGE_WIDGET:
 337                       /* just do nothing here */
 338                       break;
 339
 340                     case IMAGE_NOTHING:
 341                       /* nothing is as nothing does */
 342                       break;
 343
 344                     case IMAGE_TEXT:
 345                     case IMAGE_POINTER:
 346                     default:
 347                       ABORT ();
 348                     }
 349                   IMAGE_INSTANCE_OPTIMIZE_OUTPUT
 350                     (XIMAGE_INSTANCE (instance)) = 0;
 351                 }
 352
 353               xpos += rb->width;
 354               elt++;
 355             }
 356           else
 357             ABORT ();
 358         }
 359     }
 360
 361   if (Dynarr_length (buf))
 362     tty_output_charc_dynarr (w, dl, buf, xpos, findex, 0);
 363   Dynarr_free (buf);
 364
 365 }
 366
 367
 368
 369 /*****************************************************************************
 370  tty_output_vertical_divider
 371
 372  Draw a vertical divider down the right side of the given window.
 373  ****************************************************************************/
 374 static void
 375 tty_output_vertical_divider (struct window *w, int clear)
 376 {
 377   /* Divider width can either be 0 or 1 on TTYs */
 378   if (window_divider_width (w))
 379     {
 380       struct frame *f = XFRAME (w->frame);
 381       struct console *c = XCONSOLE (FRAME_CONSOLE (f));
 382       int line;
 383       int y_top = WINDOW_TEXT_TOP (w);
 384       int y_bot = WINDOW_TEXT_BOTTOM (w);
 385       unsigned char divv = '|';
 386
 387       tty_turn_on_face (w, MODELINE_INDEX);
 388       for (line = y_top; line < y_bot; line++)
 389         {
 390           cmgoto (f, line, WINDOW_TEXT_RIGHT (w));
 391           send_string_to_tty_console (c, &divv, 1);
 392           TTY_INC_CURSOR_X (c, 1);
 393         }
 394
 395       /* Draw the divider in the modeline. */
 396       cmgoto (f, y_bot, WINDOW_TEXT_RIGHT (w));
 397       send_string_to_tty_console (c, &divv, 1);
 398       TTY_INC_CURSOR_X (c, 1);
 399       tty_turn_off_face (w, MODELINE_INDEX);
 400     }
 401 }
 402
 403 /****************************************************************************
 404  tty_clear_region
 405
 406  Clear the area in the box defined by the given parameters.
 407  ****************************************************************************/
 408 static void
 409 tty_clear_region (Lisp_Object window, struct device* d, struct frame * f,
 410                   face_index findex, int x, int y,
 411                   int width, int height, Lisp_Object fcolor, Lisp_Object bcolor,
 412                   Lisp_Object background_pixmap)
 413 {
 414   struct console *c = XCONSOLE (FRAME_CONSOLE (f));
 415   int line;
 416   struct window* w = XWINDOW (window);
 417
 418   tty_turn_on_face (w, findex);
 419   for (line = y; line < y + height; line++)
 420     {
 421       int col;
 422
 423       cmgoto (f, line, x);
 424
 425       if (window_is_leftmost (w)
 426           && window_is_rightmost (w)
 427           && TTY_SE (c).clr_to_eol)
 428         {
 429           OUTPUT1 (c, TTY_SE (c).clr_to_eol);
 430         }
 431       else
 432         {
 433           unsigned char sp = ' ';
 434           /* #### Of course, this is all complete and utter crap. */
 435           for (col = x; col < x + width; col++)
 436             send_string_to_tty_console (c, &sp, 1);
 437           TTY_INC_CURSOR_X (c, width);
 438         }
 439     }
 440   tty_turn_off_face (w, findex);
 441   cmgoto (f, y, x);
 442 }
 443
 444 /*****************************************************************************
 445  tty_clear_to_window_end
 446
 447  Clear the area between ypos1 and ypos2.  Each margin area and the
 448  text area is handled separately since they may each have their own
 449  background color.
 450  ****************************************************************************/
 451 static void
 452 tty_clear_to_window_end (struct window *w, int ypos1, int ypos2)
 453 {
 454   struct frame *f = XFRAME (w->frame);
 455   struct console *c = XCONSOLE (FRAME_CONSOLE (f));
 456   int x, width;
 457
 458   x = WINDOW_TEXT_LEFT (w);
 459   width = WINDOW_TEXT_WIDTH (w);
 460
 461   if (window_is_rightmost (w))
 462     {
 463       /* #### Optimize to use clr_to_eol function of tty if available, if
 464          the window is the entire width of the frame. */
 465       /* #### Is this actually an optimization? */
 466       int line;
 467       tty_turn_on_face (w, DEFAULT_INDEX);
 468       for (line = ypos1; line < ypos2; line++)
 469         {
 470           cmgoto (XFRAME (w->frame), line, x);
 471           OUTPUT1 (c, TTY_SE (c).clr_to_eol);
 472         }
 473       tty_turn_off_face (w, DEFAULT_INDEX);
 474     }
 475   else
 476     {
 477       Lisp_Object window;
 478
 479       XSETWINDOW (window, w);
 480       redisplay_clear_region (window, DEFAULT_INDEX, x, ypos1, width, ypos2 - ypos1);
 481     }
 482 }
 483
 484 /****************************************************************************
 485  tty_clear_frame
 486
 487  Clear the entire frame.
 488  ****************************************************************************/
 489 static void
 490 tty_clear_frame (struct frame *f)
 491 {
 492   struct console *c = XCONSOLE (FRAME_CONSOLE (f));
 493
 494   tty_turn_on_frame_face (f, Vdefault_face);
 495   if (TTY_SE (c).clr_frame)
 496     {
 497       OUTPUT1 (c, TTY_SE (c).clr_frame);
 498       CONSOLE_TTY_REAL_CURSOR_X (c) = 0;
 499       CONSOLE_TTY_REAL_CURSOR_Y (c) = 0;
 500 #ifdef NOT_SURE
 501       FRAME_CURSOR_X (f) = 0;
 502       FRAME_CURSOR_Y (f) = 0;
 503 #endif
 504     }
 505   else
 506     {
 507 #ifdef NOT_SURE
 508       internal_cursor_to (f, 0, 0);
 509       clear_to_end (f);
 510 #else
 511       /* #### Not implemented. */
 512       stderr_out ("Not yet.\n");
 513 #endif
 514     }
 515   tty_turn_off_frame_face (f, Vdefault_face);
 516 }
 517
 518 static void
 519 tty_output_bufbyte_string (struct window *w, struct display_line *dl,
 520                            Bufbyte *str, Bytecount len, int xpos,
 521                            face_index findex, int cursor)
 522 {
 523   struct frame *f = XFRAME (w->frame);
 524   struct console *c = XCONSOLE (FRAME_CONSOLE (f));
 525
 526   /* First position the cursor. */
 527   cmgoto (f, dl->ypos - 1, xpos);
 528
 529   /* Enable any face properties. */
 530   tty_turn_on_face (w, findex);
 531
 532   send_string_to_tty_console (c, str, len);
 533   TTY_INC_CURSOR_X (c, bufbyte_string_displayed_columns (str, len));
 534
 535   /* Turn the face properties back off. */
 536   tty_turn_off_face (w, findex);
 537 }
 538
 539 static Bufbyte_dynarr *tty_output_charc_dynarr_dynarr;
 540
 541 /*****************************************************************************
 542  tty_output_charc_dynarr
 543
 544  Given a string and a starting position, output that string in the
 545  given face.  If cursor is true, draw a cursor around the string.
 546  ****************************************************************************/
 547 static void
 548 tty_output_charc_dynarr (struct window *w, struct display_line *dl,
 549                          Charc_dynarr *buf, int xpos, face_index findex,
 550                          int cursor)
 551 {
 552   if (!tty_output_charc_dynarr_dynarr)
 553     tty_output_charc_dynarr_dynarr = Dynarr_new (Bufbyte);
 554   else
 555     Dynarr_reset (tty_output_charc_dynarr_dynarr);
 556
 557   convert_charc_string_into_bufbyte_dynarr (Dynarr_atp (buf, 0),
 558                                             Dynarr_length (buf),
 559                                             tty_output_charc_dynarr_dynarr);
 560
 561   tty_output_bufbyte_string (w, dl,
 562                              Dynarr_atp (tty_output_charc_dynarr_dynarr, 0),
 563                              Dynarr_length (tty_output_charc_dynarr_dynarr),
 564                              xpos, findex, cursor);
 565 }
 566
 567 #if 0
 568
 569 static Bufbyte_dynarr *sidcs_dynarr;
 570
 571 static void
 572 substitute_in_dynamic_color_string (Lisp_Object spec, Lisp_Object string)
 573 {
 574   int i;
 575   Bufbyte *specdata = XSTRING_DATA   (spec);
 576   Bytecount speclen = XSTRING_LENGTH (spec);
 577
 578   if (!sidcs_dynarr)
 579     sidcs_dynarr = Dynarr_new (Bufbyte);
 580   else
 581     Dynarr_reset (sidcs_dynarr);
 582
 583   for (i = 0; i < speclen; i++)
 584     {
 585       if (specdata[i] == '%' && specdata[i+1] == '%')
 586         {
 587           Dynarr_add (sidcs_dynarr, '%');
 588           i++;
 589         }
 590       else if (specdata[i] == '%' && specdata[i+1] == 's')
 591         {
 592           Dynarr_add_many (sidcs_dynarr,
 593                            XSTRING_DATA   (string),
 594                            XSTRING_LENGTH (string));
 595           i++;
 596         }
 597       else
 598         Dynarr_add (sidcs_dynarr, specdata[i]);
 599     }
 600 }
 601
 602 #endif
 603
 604 static void
 605 set_foreground_to (struct console *c, Lisp_Object sym)
 606 {
 607   Lisp_Object result;
 608   Bufbyte *escseq = 0;
 609   Bytecount escseqlen = 0;
 610
 611   result = assq_no_quit (sym, Vtty_color_alist);
 612   if (!NILP (result))
 613     {
 614       Lisp_Object esc_seq = XCAR (XCDR (result));
 615       escseq    = XSTRING_DATA   (esc_seq);
 616       escseqlen = XSTRING_LENGTH (esc_seq);
 617     }
 618 #if 0
 619   else if (STRINGP (Vtty_dynamic_color_fg))
 620     {
 621       substitute_in_dynamic_color_string (Vtty_dynamic_color_fg,
 622                                           Fsymbol_name (sym));
 623       escseq = Dynarr_atp (sidcs_dynarr, 0);
 624       escseqlen = Dynarr_length (sidcs_dynarr);
 625     }
 626 #endif
 627
 628   if (escseq)
 629     {
 630       send_string_to_tty_console (c, escseq, escseqlen);
 631     }
 632 }
 633
 634 static void
 635 set_background_to (struct console *c, Lisp_Object sym)
 636 {
 637   Lisp_Object result;
 638   Bufbyte *escseq = 0;
 639   Bytecount escseqlen = 0;
 640
 641   result = assq_no_quit (sym, Vtty_color_alist);
 642   if (!NILP (result))
 643     {
 644       Lisp_Object esc_seq = XCDR (XCDR (result));
 645       escseq    = XSTRING_DATA   (esc_seq);
 646       escseqlen = XSTRING_LENGTH (esc_seq);
 647     }
 648 #if 0
 649   else if (STRINGP (Vtty_dynamic_color_bg))
 650     {
 651       substitute_in_dynamic_color_string (Vtty_dynamic_color_bg,
 652                                           Fsymbol_name (sym));
 653       escseq = Dynarr_atp (sidcs_dynarr, 0);
 654       escseqlen = Dynarr_length (sidcs_dynarr);
 655     }
 656 #endif
 657
 658   if (escseq)
 659     {
 660       send_string_to_tty_console (c, escseq, escseqlen);
 661     }
 662 }
 663
 664 static void
 665 tty_turn_on_face_1 (struct console *c, int highlight_p,
 666                     int blinking_p, int dim_p, int underline_p,
 667                     int reverse_p, Lisp_Object cinst_fore,
 668                     Lisp_Object cinst_back)
 669 {
 670   if (highlight_p)
 671     {
 672       OUTPUT1_IF (c, TTY_SD (c).turn_on_bold);
 673     }
 674
 675   if (blinking_p)
 676     {
 677       OUTPUT1_IF (c, TTY_SD (c).turn_on_blinking);
 678     }
 679
 680   if (dim_p)
 681     {
 682       OUTPUT1_IF (c, TTY_SD (c).turn_on_dim);
 683     }
 684
 685   if (underline_p)
 686     {
 687       /* #### punt for now if underline mode is glitchy */
 688       if (!TTY_FLAGS (c).underline_width)
 689         {
 690           OUTPUT1_IF (c, TTY_SD (c).begin_underline);
 691         }
 692     }
 693
 694   if (reverse_p)
 695     {
 696       /* #### punt for now if standout mode is glitchy */
 697       if (!TTY_FLAGS (c).standout_width)
 698         {
 699           OUTPUT1_IF (c, TTY_SD (c).begin_standout);
 700         }
 701       else
 702         reverse_p = 0;
 703     }
 704
 705   if (reverse_p)
 706     {
 707       Lisp_Object temp = cinst_fore;
 708       cinst_fore = cinst_back;
 709       cinst_back = temp;
 710     }
 711
 712   if (COLOR_INSTANCEP (cinst_fore)
 713       && !EQ (cinst_fore, Vthe_null_color_instance))
 714     set_foreground_to (c, COLOR_INSTANCE_TTY_SYMBOL
 715                        (XCOLOR_INSTANCE (cinst_fore)));
 716
 717   if (COLOR_INSTANCEP (cinst_back)
 718       && !EQ (cinst_back, Vthe_null_color_instance))
 719     set_background_to (c, COLOR_INSTANCE_TTY_SYMBOL
 720                        (XCOLOR_INSTANCE (cinst_back)));
 721 }
 722
 723 /*****************************************************************************
 724  tty_turn_on_face
 725
 726  Turn on all set properties of the given face.
 727  ****************************************************************************/
 728 static void
 729 tty_turn_on_face (struct window *w, face_index findex)
 730 {
 731   struct frame *f = XFRAME (w->frame);
 732   struct console *c = XCONSOLE (FRAME_CONSOLE (f));
 733
 734   tty_turn_on_face_1 (c,
 735                       WINDOW_FACE_CACHEL_HIGHLIGHT_P (w, findex),
 736                       WINDOW_FACE_CACHEL_BLINKING_P (w, findex),
 737                       WINDOW_FACE_CACHEL_DIM_P (w, findex),
 738                       WINDOW_FACE_CACHEL_UNDERLINE_P (w, findex),
 739                       WINDOW_FACE_CACHEL_REVERSE_P (w, findex),
 740                       WINDOW_FACE_CACHEL_FOREGROUND (w, findex),
 741                       WINDOW_FACE_CACHEL_BACKGROUND (w, findex));
 742 }
 743
 744 /*****************************************************************************
 745  tty_turn_off_face
 746
 747  Turn off all set properties of the given face (revert to default
 748  face).  We assume that tty_turn_on_face has been called for the given
 749  face so that its properties are actually active.
 750  ****************************************************************************/
 751 static void
 752 tty_turn_off_face (struct window *w, face_index findex)
 753 {
 754   struct frame *f = XFRAME (w->frame);
 755   struct console *c = XCONSOLE (FRAME_CONSOLE (f));
 756
 757   if (WINDOW_FACE_CACHEL_REVERSE_P (w, findex))
 758     {
 759       /* #### punt for now if standout mode is glitchy */
 760       if (!TTY_FLAGS (c).standout_width)
 761         {
 762           OUTPUT1_IF (c, TTY_SD (c).end_standout);
 763         }
 764     }
 765
 766   if (WINDOW_FACE_CACHEL_UNDERLINE_P (w, findex))
 767     {
 768       /* #### punt for now if underline mode is glitchy */
 769       if (!TTY_FLAGS (c).underline_width)
 770         {
 771           OUTPUT1_IF (c, TTY_SD (c).end_underline);
 772         }
 773     }
 774
 775   if (WINDOW_FACE_CACHEL_HIGHLIGHT_P (w, findex) ||
 776       WINDOW_FACE_CACHEL_BLINKING_P (w, findex) ||
 777       WINDOW_FACE_CACHEL_DIM_P (w, findex) ||
 778       !EQ (WINDOW_FACE_CACHEL_FOREGROUND (w, findex),
 779            Vthe_null_color_instance) ||
 780       !EQ (WINDOW_FACE_CACHEL_BACKGROUND (w, findex),
 781            Vthe_null_color_instance))
 782     {
 783       OUTPUT1_IF (c, TTY_SD (c).turn_off_attributes);
 784     }
 785 }
 786
 787 /*****************************************************************************
 788  tty_turn_on_frame_face
 789
 790  Turn on all set properties of the given face.
 791  ****************************************************************************/
 792 static void
 793 tty_turn_on_frame_face (struct frame *f, Lisp_Object face)
 794 {
 795   Lisp_Object frame;
 796   struct console *c = XCONSOLE (FRAME_CONSOLE (f));
 797
 798   XSETFRAME (frame, f);
 799   tty_turn_on_face_1 (c,
 800                       FACE_HIGHLIGHT_P (face, frame),
 801                       FACE_BLINKING_P (face, frame),
 802                       FACE_DIM_P (face, frame),
 803                       FACE_UNDERLINE_P (face, frame),
 804                       FACE_REVERSE_P (face, frame),
 805                       FACE_FOREGROUND (face, frame),
 806                       FACE_BACKGROUND (face, frame));
 807 }
 808
 809 /*****************************************************************************
 810  tty_turn_off_frame_face
 811
 812  Turn off all set properties of the given face (revert to default
 813  face).  We assume that tty_turn_on_face has been called for the given
 814  face so that its properties are actually active.
 815  ****************************************************************************/
 816 static void
 817 tty_turn_off_frame_face (struct frame *f, Lisp_Object face)
 818 {
 819   Lisp_Object frame;
 820   struct console *c = XCONSOLE (FRAME_CONSOLE (f));
 821
 822   XSETFRAME (frame, f);
 823
 824   if (FACE_REVERSE_P (face, frame))
 825     {
 826       /* #### punt for now if standout mode is glitchy */
 827       if (!TTY_FLAGS (c).standout_width)
 828         {
 829           OUTPUT1_IF (c, TTY_SD (c).end_standout);
 830         }
 831     }
 832
 833   if (FACE_UNDERLINE_P (face, frame))
 834     {
 835       /* #### punt for now if underline mode is glitchy */
 836       if (!TTY_FLAGS (c).underline_width)
 837         {
 838           OUTPUT1_IF (c, TTY_SD (c).end_underline);
 839         }
 840     }
 841
 842   if (FACE_HIGHLIGHT_P (face, frame) ||
 843       FACE_BLINKING_P (face, frame) ||
 844       FACE_DIM_P (face, frame) ||
 845       !EQ (FACE_FOREGROUND (face, frame), Vthe_null_color_instance) ||
 846       !EQ (FACE_BACKGROUND (face, frame), Vthe_null_color_instance))
 847     {
 848       OUTPUT1_IF (c, TTY_SD (c).turn_off_attributes);
 849     }
 850 }
 851
 852 /*****************************************************************************
 853  set_tty_modes
 854
 855  Sets up various parameters on tty modes.
 856  ****************************************************************************/
 857 void
 858 set_tty_modes (struct console *c)
 859 {
 860   if (!CONSOLE_TTY_P (c))
 861     return;
 862
 863   OUTPUT1_IF (c, TTY_SD (c).init_motion);
 864   OUTPUT1_IF (c, TTY_SD (c).cursor_visible);
 865   OUTPUT1_IF (c, TTY_SD (c).keypad_on);
 866
 867   if (TTY_FLAGS (c).auto_margins)
 868     OUTPUT1_IF (c, TTY_SD (c).disable_auto_margins);
 869 }
 870
 871 /*****************************************************************************
 872  reset_tty_modes
 873
 874  Restore default state of tty.
 875  ****************************************************************************/
 876 void
 877 reset_tty_modes (struct console *c)
 878 {
 879   if (!CONSOLE_TTY_P (c))
 880     return;
 881
 882   OUTPUT1_IF (c, TTY_SD (c).orig_pair);
 883   OUTPUT1_IF (c, TTY_SD (c).keypad_off);
 884   OUTPUT1_IF (c, TTY_SD (c).cursor_normal);
 885   OUTPUT1_IF (c, TTY_SD (c).end_motion);
 886
 887   if (TTY_FLAGS (c).auto_margins)
 888     OUTPUT1_IF (c, TTY_SD (c).enable_auto_margins);
 889
 890   {
 891     Lisp_Object frm = CONSOLE_SELECTED_FRAME (c);
 892
 893     if (!NILP (frm))
 894       tty_frame_output_end (XFRAME (frm));
 895   }
 896 }
 897
 898 /*****************************************************************************
 899  tty_redisplay_shutdown
 900
 901  Clear the frame and position the cursor properly for exiting.
 902  ****************************************************************************/
 903 void
 904 tty_redisplay_shutdown (struct console *c)
 905 {
 906   Lisp_Object dev = CONSOLE_SELECTED_DEVICE (c);
 907
 908   if (!NILP (dev))
 909     {
 910       Lisp_Object frm = DEVICE_SELECTED_FRAME (XDEVICE (dev));
 911
 912       if (!NILP (frm))
 913         {
 914           struct frame *f = XFRAME (frm);
 915
 916           /* Clear the bottom line of the frame. */
 917           redisplay_clear_region (FRAME_SELECTED_WINDOW (f), DEFAULT_INDEX, 0,
 918                             f->height, f->width, 1);
 919
 920           /* And then stick the cursor there. */
 921           tty_set_final_cursor_coords (f, f->height, 0);
 922           tty_frame_output_end (f);
 923         }
 924     }
 925 }
 926
 927
 928 /* #### Everything below here is old shit.  It should either be moved
 929    up or removed. */
 930
 931
 932 #ifdef NOT_YET
 933 /* FLAGS - these don't need to be console local since only one console
 934            can be being updated at a time. */
 935 static int insert_mode_on;              /* nonzero if in insert mode */
 936 static int standout_mode_on;            /* nonzero if in standout mode */
 937 static int underline_mode_on;           /* nonzero if in underline mode */
 938 static int alternate_mode_on;           /* nonzero if in alternate char set */
 939 static int attributes_on;               /* nonzero if any attributes on */
 940
 941 static void
 942 turn_on_insert (struct frame *f)
 943 {
 944   struct console *c = XCONSOLE (FRAME_CONSOLE (f));
 945
 946   if (!insert_mode_on)
 947     OUTPUT1_IF (c, TTY_SE (c).begin_ins_mode);
 948   insert_mode_on = 1;
 949 }
 950
 951 static void
 952 turn_off_insert (struct frame *f)
 953 {
 954   struct console *c = XCONSOLE (FRAME_CONSOLE (f));
 955
 956   if (insert_mode_on)
 957     OUTPUT1 (c, TTY_SE (c).end_ins_mode);
 958   insert_mode_on = 0;
 959 }
 960
 961 static void
 962 internal_cursor_to (struct frame *f, int row, int col)
 963 {
 964   struct console *c = XCONSOLE (FRAME_CONSOLE (f));
 965
 966   if (!TTY_FLAGS (c).insert_mode_motion)
 967     turn_off_insert (f);
 968   if (!TTY_FLAGS (c).standout_motion)
 969     {
 970       turn_off_standout (f);
 971       turn_off_underline (f);
 972       turn_off_alternate (f);
 973     }
 974
 975   cmgoto (f, row, col);
 976 }
 977
 978 static void
 979 clear_to_end (struct frame *f)
 980 {
 981   struct console *c = XCONSOLE (FRAME_CONSOLE (f));
 982
 983   /* assumes cursor is already positioned */
 984   if (TTY_SE (c).clr_from_cursor)
 985     {
 986       OUTPUT1 (c, TTY_SE (c).clr_from_cursor);
 987     }
 988   else
 989     {
 990       int line = FRAME_CURSOR_Y (f);
 991
 992       while (line < FRAME_HEIGHT (f))
 993         {
 994           internal_cursor_to (f, line, 0);
 995           OUTPUT1 (c, TTY_SE (c).clr_to_eol);
 996         }
 997     }
 998 }
 999 #endif /* 0 */
1000 \f
1001 #if 0
1002 /*
1003  *  clear from last visible line on window to window end (presumably
1004  *  the line above window's modeline
1005  */
1006 static void
1007 tty_clear_window_end (struct window *w, int ystart, int yend)
1008 {
1009   struct console *c = XCONSOLE (WINDOW_CONSOLE (w));
1010   int line;
1011
1012   for (line = ystart; line < yend; line++)
1013     {
1014       cmgoto (XFRAME (w->frame), line, 0);
1015       OUTPUT1 (c, TTY_SE (c).clr_to_eol);
1016     }
1017 }
1018
1019 #endif /* 0 */
1020
1021 static int
1022 tty_flash (struct device *d)
1023 {
1024   struct console *c = XCONSOLE (DEVICE_CONSOLE (d));
1025   if (TTY_SD (c).visual_bell)
1026     {
1027       OUTPUT1 (c, TTY_SD (c).visual_bell);
1028       Lstream_flush (XLSTREAM (CONSOLE_TTY_DATA (c)->outstream));
1029       return 1;
1030     }
1031   else
1032     return 0;
1033 }
1034
1035 /*
1036  * tty_ring_bell - sound an audio beep.
1037  */
1038 static void
1039 tty_ring_bell (struct device *d, int volume, int pitch, int duration)
1040 {
1041   struct console *c = XCONSOLE (DEVICE_CONSOLE (d));
1042
1043   if (volume)
1044     {
1045       OUTPUT1 (c, TTY_SD (c).audio_bell);
1046       Lstream_flush (XLSTREAM (CONSOLE_TTY_DATA (c)->outstream));
1047     }
1048 }
1049
1050
1051 int
1052 init_tty_for_redisplay (struct device *d, char *terminal_type)
1053 {
1054   int status;
1055   char entry_buffer[2044];
1056   /* char temp_buffer[2044]; */
1057   char *bufptr;
1058   struct console *c = XCONSOLE (DEVICE_CONSOLE (d));
1059
1060   /* What we should really do is allocate just enough space for
1061      the actual strings that are stored; but this would require
1062      doing this after all the tgetstr()s and adjusting all the
1063      pointers. */
1064   CONSOLE_TTY_DATA (c)->term_entry_buffer = (char *) xmalloc (2044);
1065   bufptr = CONSOLE_TTY_DATA (c)->term_entry_buffer;
1066
1067 #ifdef SIGTTOU
1068   /* SIGTT* don't exist under win32 */
1069   EMACS_BLOCK_SIGNAL (SIGTTOU);
1070 #endif
1071   status = tgetent (entry_buffer, terminal_type);
1072 #ifdef SIGTTOU
1073   EMACS_UNBLOCK_SIGNAL (SIGTTOU);
1074 #endif
1075 #if 0
1076   if (status < 0)
1077     return TTY_UNABLE_OPEN_DATABASE;
1078   else if (status == 0)
1079     return TTY_TYPE_UNDEFINED;
1080 #endif
1081   /* Under Linux at least, <0 is returned for TTY_TYPE_UNDEFINED. --ben */
1082   if (status <= 0)
1083     return TTY_TYPE_UNDEFINED;
1084
1085   /*
1086    * Establish the terminal size.
1087    */
1088   /* First try to get the info from the system.  If that fails, check
1089      the termcap entry. */
1090   get_tty_device_size (d, &CONSOLE_TTY_DATA (c)->width,
1091                        &CONSOLE_TTY_DATA (c)->height);
1092
1093   if (CONSOLE_TTY_DATA (c)->width <= 0)
1094     CONSOLE_TTY_DATA (c)->width = tgetnum ("co");
1095   if (CONSOLE_TTY_DATA (c)->height <= 0)
1096     CONSOLE_TTY_DATA (c)->height = tgetnum ("li");
1097
1098   if (CONSOLE_TTY_DATA (c)->width <= 0 || CONSOLE_TTY_DATA (c)->height <= 0)
1099     return TTY_SIZE_UNSPECIFIED;
1100
1101   /*
1102    * Initialize cursor motion information.
1103    */
1104
1105   /* local cursor movement */
1106   TTY_CM (c).up = tgetstr ("up", &bufptr);
1107   TTY_CM (c).down = tgetstr ("do", &bufptr);
1108   TTY_CM (c).left = tgetstr ("le", &bufptr);
1109   TTY_CM (c).right = tgetstr ("nd", &bufptr);
1110   TTY_CM (c).home = tgetstr ("ho", &bufptr);
1111   TTY_CM (c).low_left = tgetstr ("ll", &bufptr);
1112   TTY_CM (c).car_return = tgetstr ("cr", &bufptr);
1113
1114   /* absolute cursor motion */
1115   TTY_CM (c).abs = tgetstr ("cm", &bufptr);
1116   TTY_CM (c).hor_abs = tgetstr ("ch", &bufptr);
1117   TTY_CM (c).ver_abs = tgetstr ("cv", &bufptr);
1118
1119   /* Verify that the terminal is powerful enough to run Emacs */
1120   if (!TTY_CM (c).abs)
1121     {
1122       if (!TTY_CM (c).up || !TTY_CM (c).down
1123           || !TTY_CM (c).left || !TTY_CM (c).right)
1124         return TTY_TYPE_INSUFFICIENT;
1125     }
1126
1127   /* parameterized local cursor movement */
1128   TTY_CM (c).multi_up = tgetstr ("UP", &bufptr);
1129   TTY_CM (c).multi_down = tgetstr ("DO", &bufptr);
1130   TTY_CM (c).multi_left = tgetstr ("LE", &bufptr);
1131   TTY_CM (c).multi_right = tgetstr ("RI", &bufptr);
1132
1133   /* scrolling */
1134   TTY_CM (c).scroll_forw = tgetstr ("sf", &bufptr);
1135   TTY_CM (c).scroll_back = tgetstr ("sr", &bufptr);
1136   TTY_CM (c).multi_scroll_forw = tgetstr ("SF", &bufptr);
1137   TTY_CM (c).multi_scroll_back = tgetstr ("SR", &bufptr);
1138   TTY_CM (c).set_scroll_region = tgetstr ("cs", &bufptr);
1139
1140
1141   /*
1142    * Initialize screen editing information.
1143    */
1144
1145   /* adding to the screen */
1146   TTY_SE (c).ins_line = tgetstr ("al", &bufptr);
1147   TTY_SE (c).multi_ins_line = tgetstr ("AL", &bufptr);
1148   TTY_SE (c).repeat = tgetstr ("rp", &bufptr);
1149   TTY_SE (c).begin_ins_mode = tgetstr ("im", &bufptr);
1150   TTY_SE (c).end_ins_mode = tgetstr ("ei", &bufptr);
1151   TTY_SE (c).ins_char = tgetstr ("ic", &bufptr);
1152   TTY_SE (c).multi_ins_char = tgetstr ("IC", &bufptr);
1153   TTY_SE (c).insert_pad = tgetstr ("ip", &bufptr);
1154
1155   /* deleting from the screen */
1156   TTY_SE (c).clr_frame = tgetstr ("cl", &bufptr);
1157   TTY_SE (c).clr_from_cursor = tgetstr ("cd", &bufptr);
1158   TTY_SE (c).clr_to_eol = tgetstr ("ce", &bufptr);
1159   TTY_SE (c).del_line = tgetstr ("dl", &bufptr);
1160   TTY_SE (c).multi_del_line = tgetstr ("DL", &bufptr);
1161   TTY_SE (c).del_char = tgetstr ("dc", &bufptr);
1162   TTY_SE (c).multi_del_char = tgetstr ("DC", &bufptr);
1163   TTY_SE (c).begin_del_mode = tgetstr ("dm", &bufptr);
1164   TTY_SE (c).end_del_mode = tgetstr ("ed", &bufptr);
1165   TTY_SE (c).erase_at_cursor = tgetstr ("ec", &bufptr);
1166
1167
1168   /*
1169    * Initialize screen display information.
1170    */
1171   TTY_SD (c).begin_standout = tgetstr ("so", &bufptr);
1172   TTY_SD (c).end_standout = tgetstr ("se", &bufptr);
1173   TTY_SD (c).begin_underline = tgetstr ("us", &bufptr);
1174   TTY_SD (c).end_underline = tgetstr ("ue", &bufptr);
1175   TTY_SD (c).begin_alternate = tgetstr ("as", &bufptr);
1176   TTY_SD (c).end_alternate = tgetstr ("ae", &bufptr);
1177   TTY_SD (c).turn_on_reverse = tgetstr ("mr", &bufptr);
1178   TTY_SD (c).turn_on_blinking = tgetstr ("mb", &bufptr);
1179   TTY_SD (c).turn_on_bold = tgetstr ("md", &bufptr);
1180   TTY_SD (c).turn_on_dim = tgetstr ("mh", &bufptr);
1181   TTY_SD (c).turn_off_attributes = tgetstr ("me", &bufptr);
1182   TTY_SD (c).orig_pair = tgetstr ("op", &bufptr);
1183
1184   TTY_SD (c).visual_bell = tgetstr ("vb", &bufptr);
1185   TTY_SD (c).audio_bell = tgetstr ("bl", &bufptr);
1186   if (!TTY_SD (c).audio_bell)
1187     {
1188       /* If audio_bell doesn't get set, then assume C-g.  This is gross and
1189          ugly but is what Emacs has done from time immortal. */
1190       TTY_SD (c).audio_bell = "\07";
1191     }
1192
1193   TTY_SD (c).cursor_visible = tgetstr ("vs", &bufptr);
1194   TTY_SD (c).cursor_normal = tgetstr ("ve", &bufptr);
1195   TTY_SD (c).init_motion = tgetstr ("ti", &bufptr);
1196   TTY_SD (c).end_motion = tgetstr ("te", &bufptr);
1197   TTY_SD (c).keypad_on = tgetstr ("ks", &bufptr);
1198   TTY_SD (c).keypad_off = tgetstr ("ke", &bufptr);
1199   TTY_SD (c).disable_auto_margins = tgetstr ("RA", &bufptr);
1200   TTY_SD (c).enable_auto_margins = tgetstr ("SA", &bufptr);
1201
1202
1203   /*
1204    * Initialize additional terminal information.
1205    */
1206   TTY_FLAGS (c).must_write_spaces = tgetflag ("in");
1207   TTY_FLAGS (c).insert_mode_motion = tgetflag ("mi");
1208   TTY_FLAGS (c).standout_motion = tgetflag ("ms");
1209   TTY_FLAGS (c).memory_above_frame = tgetflag ("da");
1210   TTY_FLAGS (c).memory_below_frame = tgetflag ("db");
1211   TTY_FLAGS (c).standout_width = tgetnum ("sg");
1212   TTY_FLAGS (c).underline_width = tgetnum ("ug");
1213   TTY_FLAGS (c).auto_margins = tgetflag ("am");
1214
1215   if (TTY_FLAGS (c).standout_width == -1)
1216     TTY_FLAGS (c).standout_width = 0;
1217   if (TTY_FLAGS (c).underline_width == -1)
1218     TTY_FLAGS (c).underline_width = 0;
1219
1220    TTY_FLAGS (c).meta_key =
1221      eight_bit_tty (d) ? tgetflag ("km") || tgetflag ("MT") ? 1 : 2 : 0;
1222
1223
1224   /*
1225    * Setup the costs tables for this tty console.
1226    */
1227   cm_cost_init (c);
1228
1229 #ifdef NOT_YET
1230   /*
1231    * Initialize local flags.
1232    */
1233   insert_mode_on = 0;
1234   standout_mode_on = 0;
1235   underline_mode_on = 0;
1236   alternate_mode_on = 0;
1237   attributes_on = 0;
1238 #endif
1239
1240   /*
1241    * Attempt to initialize the function_key_map to
1242    * some kind of sensible value
1243    */
1244
1245   term_get_fkeys (c->function_key_map, &bufptr);
1246
1247   {
1248     /* check for ANSI set-foreground and set-background strings,
1249        and assume color if so.
1250
1251        #### we should support the other (non-ANSI) ways of specifying
1252        color, too. */
1253     char foobuf[500];
1254     char *fooptr = foobuf;
1255     if ((tgetstr ("AB", &fooptr) && tgetstr ("AF", &fooptr)) ||
1256         (tgetstr ("Sf", &fooptr) && tgetstr ("Sb", &fooptr)) ||
1257         ((tgetnum ("Co") > 0) && (tgetnum ("pa") > 0)))
1258       DEVICE_CLASS (d) = Qcolor;
1259     else
1260       DEVICE_CLASS (d) = Qmono;
1261   }
1262
1263   return TTY_INIT_SUCCESS;
1264 }
1265 \f
1266 struct fkey_table
1267 {
1268   const char *cap;
1269   const char *name;
1270 };
1271
1272   /* Termcap capability names that correspond directly to X keysyms.
1273      Some of these (marked "terminfo") aren't supplied by old-style
1274      (Berkeley) termcap entries.  They're listed in X keysym order;
1275      except we put the keypad keys first, so that if they clash with
1276      other keys (as on the IBM PC keyboard) they get overridden.
1277   */
1278
1279 static struct fkey_table keys[] =
1280 {
1281   {"kh", "home"},       /* termcap */
1282   {"kl", "left"},       /* termcap */
1283   {"ku", "up"},         /* termcap */
1284   {"kr", "right"},      /* termcap */
1285   {"kd", "down"},       /* termcap */
1286   {"%8", "prior"},      /* terminfo */
1287   {"%5", "next"},       /* terminfo */
1288   {"@7", "end"},        /* terminfo */
1289   {"@1", "begin"},      /* terminfo */
1290   {"*6", "select"},     /* terminfo */
1291   {"%9", "print"},      /* terminfo */
1292   {"@4", "execute"},    /* terminfo --- actually the `command' key */
1293   /*
1294    * "insert" --- see below
1295    */
1296   {"&8", "undo"},       /* terminfo */
1297   {"%0", "redo"},       /* terminfo */
1298   {"%7", "menu"},       /* terminfo --- actually the `options' key */
1299   {"@0", "find"},       /* terminfo */
1300   {"@2", "cancel"},     /* terminfo */
1301   {"%1", "help"},       /* terminfo */
1302   /*
1303    * "break" goes here, but can't be reliably intercepted with termcap
1304    */
1305   {"&4", "reset"},      /* terminfo --- actually `restart' */
1306   /*
1307    * "system" and "user" --- no termcaps
1308    */
1309   {"kE", "clearline"},  /* terminfo */
1310   {"kA", "insertline"}, /* terminfo */
1311   {"kL", "deleteline"}, /* terminfo */
1312   {"kI", "insertchar"}, /* terminfo */
1313   {"kD", "delete"},     /* terminfo */
1314   {"kB", "backtab"},    /* terminfo */
1315   /*
1316    * "kp-backtab", "kp-space", "kp-tab" --- no termcaps
1317    */
1318   {"@8", "kp-enter"},   /* terminfo */
1319   /*
1320    * "kp-f1", "kp-f2", "kp-f3" "kp-f4",
1321    * "kp-multiply", "kp-add", "kp-separator",
1322    * "kp-subtract", "kp-decimal", "kp-divide", "kp-0";
1323    * --- no termcaps for any of these.
1324    */
1325   {"K4", "kp-1"},       /* terminfo */
1326   /*
1327    * "kp-2" --- no termcap
1328    */
1329   {"K5", "kp-3"},       /* terminfo */
1330   /*
1331    * "kp-4" --- no termcap
1332    */
1333   {"K2", "kp-5"},       /* terminfo */
1334   /*
1335    * "kp-6" --- no termcap
1336    */
1337   {"K1", "kp-7"},       /* terminfo */
1338   /*
1339    * "kp-8" --- no termcap
1340    */
1341   {"K3", "kp-9"},       /* terminfo */
1342   /*
1343    * "kp-equal" --- no termcap
1344    */
1345   {"k1", "f1"},
1346   {"k2", "f2"},
1347   {"k3", "f3"},
1348   {"k4", "f4"},
1349   {"k5", "f5"},
1350   {"k6", "f6"},
1351   {"k7", "f7"},
1352   {"k8", "f8"},
1353   {"k9", "f9"},
1354 };
1355
1356 static char **term_get_fkeys_arg;
1357
1358 static Lisp_Object term_get_fkeys_1 (Lisp_Object keymap);
1359 static Lisp_Object term_get_fkeys_error (Lisp_Object err, Lisp_Object arg);
1360
1361 /* Find the escape codes sent by the function keys for Vfunction_key_map.
1362    This function scans the termcap function key sequence entries, and
1363    adds entries to Vfunction_key_map for each function key it finds.  */
1364
1365 static void
1366 term_get_fkeys (Lisp_Object keymap, char **address)
1367 {
1368   /* We run the body of the function (term_get_fkeys_1) and ignore all Lisp
1369      errors during the call.  The only errors should be from Fdefine_key
1370      when given a key sequence containing an invalid prefix key.  If the
1371      termcap defines function keys which use a prefix that is already bound
1372      to a command by the default bindings, we should silently ignore that
1373      function key specification, rather than giving the user an error and
1374      refusing to run at all on such a terminal.  */
1375
1376   term_get_fkeys_arg = address;
1377
1378   condition_case_1 (Qerror,
1379                     term_get_fkeys_1, keymap,
1380                     term_get_fkeys_error, Qnil);
1381 }
1382
1383 static Lisp_Object
1384 term_get_fkeys_error (Lisp_Object err, Lisp_Object arg)
1385 {
1386   return arg;
1387 }
1388
1389 static Lisp_Object
1390 term_get_fkeys_1 (Lisp_Object function_key_map)
1391 {
1392   int i;
1393
1394   char **address = term_get_fkeys_arg;
1395
1396   for (i = 0; i < countof (keys); i++)
1397     {
1398       char *sequence = tgetstr (keys[i].cap, address);
1399       if (sequence)
1400         Fdefine_key (function_key_map,
1401                      build_ext_string (sequence, Qbinary),
1402                      vector1 (intern (keys[i].name)));
1403     }
1404
1405   /* The uses of the "k0" capability are inconsistent; sometimes it
1406      describes F10, whereas othertimes it describes F0 and "k;" describes F10.
1407      We will attempt to politely accommodate both systems by testing for
1408      "k;", and if it is present, assuming that "k0" denotes F0, otherwise F10.
1409   */
1410   {
1411     const char *k_semi  = tgetstr ("k;", address);
1412     const char *k0      = tgetstr ("k0", address);
1413
1414     if (k_semi)
1415       Fdefine_key (function_key_map, build_ext_string (k_semi, Qbinary),
1416                    vector1 (intern ("f10")));
1417
1418     if (k0)
1419       Fdefine_key (function_key_map, build_ext_string (k0, Qbinary),
1420                    vector1 (intern (k_semi ? "f0" : "f10")));
1421   }
1422
1423   /* Set up cookies for numbered function keys above f10. */
1424   {
1425     char fcap[3], fkey[4];
1426
1427     fcap[0] = 'F'; fcap[2] = '\0';
1428     for (i = 11; i < 64; i++)
1429       {
1430         if (i <= 19)
1431           fcap[1] = '1' + i - 11;
1432         else if (i <= 45)
1433           fcap[1] = 'A' + i - 20;
1434         else
1435           fcap[1] = 'a' + i - 46;
1436
1437         {
1438           char *sequence = tgetstr (fcap, address);
1439           if (sequence)
1440             {
1441               sprintf (fkey, "f%d", i);
1442               Fdefine_key (function_key_map,
1443                            build_ext_string (sequence, Qbinary),
1444                            vector1 (intern (fkey)));
1445             }
1446         }
1447       }
1448   }
1449
1450   /*
1451    * Various mappings to try and get a better fit.
1452    */
1453 #define CONDITIONAL_REASSIGN(cap1, cap2, keyname) do {          \
1454     if (!tgetstr (cap1, address))                               \
1455       {                                                         \
1456         char *sequence = tgetstr (cap2, address);               \
1457         if (sequence)                                           \
1458           Fdefine_key (function_key_map,                        \
1459                        build_ext_string (sequence, Qbinary),    \
1460                        vector1 (intern (keyname)));             \
1461       }                                                         \
1462   } while (0)
1463
1464   /* if there's no key_next keycap, map key_npage to `next' keysym */
1465   CONDITIONAL_REASSIGN ("%5", "kN", "next");
1466   /* if there's no key_prev keycap, map key_ppage to `previous' keysym */
1467   CONDITIONAL_REASSIGN ("%8", "kP", "prior");
1468   /* if there's no key_dc keycap, map key_ic to `insert' keysym */
1469   CONDITIONAL_REASSIGN ("kD", "kI", "insert");
1470
1471   /* IBM has their own non-standard dialect of terminfo.
1472      If the standard name isn't found, try the IBM name.  */
1473   CONDITIONAL_REASSIGN ("kB", "KO", "backtab");
1474   CONDITIONAL_REASSIGN ("@4", "kJ", "execute"); /* actually "action" */
1475   CONDITIONAL_REASSIGN ("@4", "kc", "execute"); /* actually "command" */
1476   CONDITIONAL_REASSIGN ("%7", "ki", "menu");
1477   CONDITIONAL_REASSIGN ("@7", "kw", "end");
1478   CONDITIONAL_REASSIGN ("F1", "k<", "f11");
1479   CONDITIONAL_REASSIGN ("F2", "k>", "f12");
1480   CONDITIONAL_REASSIGN ("%1", "kq", "help");
1481   CONDITIONAL_REASSIGN ("*6", "kU", "select");
1482 #undef CONDITIONAL_REASSIGN
1483
1484   return Qnil;
1485 }
1486
1487 \f
1488 /************************************************************************/
1489 /*                            initialization                            */
1490 /************************************************************************/
1491
1492 void
1493 console_type_create_redisplay_tty (void)
1494 {
1495   /* redisplay methods */
1496   CONSOLE_HAS_METHOD (tty, text_width);
1497   CONSOLE_HAS_METHOD (tty, output_display_block);
1498   CONSOLE_HAS_METHOD (tty, output_vertical_divider);
1499   CONSOLE_HAS_METHOD (tty, divider_height);
1500   CONSOLE_HAS_METHOD (tty, eol_cursor_width);
1501   CONSOLE_HAS_METHOD (tty, clear_to_window_end);
1502   CONSOLE_HAS_METHOD (tty, clear_region);
1503   CONSOLE_HAS_METHOD (tty, clear_frame);
1504   CONSOLE_HAS_METHOD (tty, frame_output_begin);
1505   CONSOLE_HAS_METHOD (tty, frame_output_end);
1506   CONSOLE_HAS_METHOD (tty, flash);
1507   CONSOLE_HAS_METHOD (tty, ring_bell);
1508   CONSOLE_HAS_METHOD (tty, set_final_cursor_coords);
1509 }