src/w32console.c

   1 /* Terminal hooks for GNU Emacs on the Microsoft W32 API.
   2    Copyright (C) 1992, 1999, 2001-2012  Free Software Foundation, Inc.
   3
   4 This file is part of GNU Emacs.
   5
   6 GNU Emacs 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 3 of the License, or
   9 (at your option) any later version.
  10
  11 GNU Emacs 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 GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 /*
  20    Tim Fleehart (apollo@online.com)             1-17-92
  21    Geoff Voelker (voelker@cs.washington.edu)    9-12-93
  22 */
  23
  24
  25 #include <config.h>
  26
  27 #include <stdio.h>
  28 #include <windows.h>
  29 #include <setjmp.h>
  30
  31 #include "lisp.h"
  32 #include "character.h"
  33 #include "coding.h"
  34 #include "disptab.h"
  35 #include "frame.h"
  36 #include "window.h"
  37 #include "termhooks.h"
  38 #include "termchar.h"
  39 #include "dispextern.h"
  40 #include "w32inevt.h"
  41
  42 /* from window.c */
  43 extern Lisp_Object Frecenter (Lisp_Object);
  44
  45 static void w32con_move_cursor (struct frame *f, int row, int col);
  46 static void w32con_clear_to_end (struct frame *f);
  47 static void w32con_clear_frame (struct frame *f);
  48 static void w32con_clear_end_of_line (struct frame *f, int);
  49 static void w32con_ins_del_lines (struct frame *f, int vpos, int n);
  50 static void w32con_insert_glyphs (struct frame *f, struct glyph *start, int len);
  51 static void w32con_write_glyphs (struct frame *f, struct glyph *string, int len);
  52 static void w32con_delete_glyphs (struct frame *f, int n);
  53 static void w32con_reset_terminal_modes (struct terminal *t);
  54 static void w32con_set_terminal_modes (struct terminal *t);
  55 static void w32con_set_terminal_window (struct frame *f, int size);
  56 static void w32con_update_begin (struct frame * f);
  57 static void w32con_update_end (struct frame * f);
  58 static WORD w32_face_attributes (struct frame *f, int face_id);
  59
  60 static COORD    cursor_coords;
  61 static HANDLE   prev_screen, cur_screen;
  62 static WORD     char_attr_normal;
  63 static DWORD    prev_console_mode;
  64
  65 #ifndef USE_SEPARATE_SCREEN
  66 static CONSOLE_CURSOR_INFO prev_console_cursor;
  67 #endif
  68
  69 HANDLE  keyboard_handle;
  70
  71
  72 /* Setting this as the ctrl handler prevents emacs from being killed when
  73    someone hits ^C in a 'suspended' session (child shell).
  74    Also ignore Ctrl-Break signals.  */
  75
  76 BOOL
  77 ctrl_c_handler (unsigned long type)
  78 {
  79   /* Only ignore "interrupt" events when running interactively.  */
  80   return (!noninteractive
  81           && (type == CTRL_C_EVENT || type == CTRL_BREAK_EVENT));
  82 }
  83
  84
  85 /* Move the cursor to (ROW, COL) on FRAME.  */
  86 static void
  87 w32con_move_cursor (struct frame *f, int row, int col)
  88 {
  89   cursor_coords.X = col;
  90   cursor_coords.Y = row;
  91
  92   /* TODO: for multi-tty support, cur_screen should be replaced with a
  93      reference to the terminal for this frame.  */
  94   SetConsoleCursorPosition (cur_screen, cursor_coords);
  95 }
  96
  97 /* Clear from cursor to end of screen.  */
  98 static void
  99 w32con_clear_to_end (struct frame *f)
 100 {
 101   w32con_clear_end_of_line (f, FRAME_COLS (f) - 1);
 102   w32con_ins_del_lines (f, cursor_coords.Y, FRAME_LINES (f) - cursor_coords.Y - 1);
 103 }
 104
 105 /* Clear the frame.  */
 106 static void
 107 w32con_clear_frame (struct frame *f)
 108 {
 109   COORD      dest;
 110   int        n;
 111   DWORD      r;
 112   CONSOLE_SCREEN_BUFFER_INFO info;
 113
 114   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &info);
 115
 116   /* Remember that the screen buffer might be wider than the window.  */
 117   n = FRAME_LINES (f) * info.dwSize.X;
 118   dest.X = dest.Y = 0;
 119
 120   FillConsoleOutputAttribute (cur_screen, char_attr_normal, n, dest, &r);
 121   FillConsoleOutputCharacter (cur_screen, ' ', n, dest, &r);
 122
 123   w32con_move_cursor (f, 0, 0);
 124 }
 125
 126
 127 static struct glyph glyph_base[256];
 128 static BOOL  ceol_initialized = FALSE;
 129
 130 /* Clear from Cursor to end (what's "standout marker"?).  */
 131 static void
 132 w32con_clear_end_of_line (struct frame *f, int end)
 133 {
 134   if (!ceol_initialized)
 135     {
 136       int i;
 137       for (i = 0; i < 256; i++)
 138         {
 139           memcpy (&glyph_base[i], &space_glyph, sizeof (struct glyph));
 140         }
 141       ceol_initialized = TRUE;
 142     }
 143   w32con_write_glyphs (f, glyph_base, end - cursor_coords.X);   /* fencepost ?  */
 144 }
 145
 146 /* Insert n lines at vpos. if n is negative delete -n lines.  */
 147 static void
 148 w32con_ins_del_lines (struct frame *f, int vpos, int n)
 149 {
 150   int        i, nb;
 151   SMALL_RECT scroll;
 152   SMALL_RECT clip;
 153   COORD      dest;
 154   CHAR_INFO  fill;
 155
 156   if (n < 0)
 157     {
 158       scroll.Top = vpos - n;
 159       scroll.Bottom = FRAME_LINES (f);
 160       dest.Y = vpos;
 161     }
 162   else
 163     {
 164       scroll.Top = vpos;
 165       scroll.Bottom = FRAME_LINES (f) - n;
 166       dest.Y = vpos + n;
 167     }
 168   clip.Top = clip.Left = scroll.Left = 0;
 169   clip.Right = scroll.Right = FRAME_COLS (f);
 170   clip.Bottom = FRAME_LINES (f);
 171
 172   dest.X = 0;
 173
 174   fill.Char.AsciiChar = 0x20;
 175   fill.Attributes = char_attr_normal;
 176
 177   ScrollConsoleScreenBuffer (cur_screen, &scroll, &clip, dest, &fill);
 178
 179   /* Here we have to deal with a w32 console flake: If the scroll
 180      region looks like abc and we scroll c to a and fill with d we get
 181      cbd... if we scroll block c one line at a time to a, we get cdd...
 182      Emacs expects cdd consistently... So we have to deal with that
 183      here... (this also occurs scrolling the same way in the other
 184      direction.  */
 185
 186   if (n > 0)
 187     {
 188       if (scroll.Bottom < dest.Y)
 189         {
 190           for (i = scroll.Bottom; i < dest.Y; i++)
 191             {
 192               w32con_move_cursor (f, i, 0);
 193               w32con_clear_end_of_line (f, FRAME_COLS (f));
 194             }
 195         }
 196     }
 197   else
 198     {
 199       nb = dest.Y + (scroll.Bottom - scroll.Top) + 1;
 200
 201       if (nb < scroll.Top)
 202         {
 203           for (i = nb; i < scroll.Top; i++)
 204             {
 205               w32con_move_cursor (f, i, 0);
 206               w32con_clear_end_of_line (f, FRAME_COLS (f));
 207             }
 208         }
 209     }
 210
 211   cursor_coords.X = 0;
 212   cursor_coords.Y = vpos;
 213 }
 214
 215 #undef  LEFT
 216 #undef  RIGHT
 217 #define LEFT    1
 218 #define RIGHT   0
 219
 220 static void
 221 scroll_line (struct frame *f, int dist, int direction)
 222 {
 223   /* The idea here is to implement a horizontal scroll in one line to
 224      implement delete and half of insert.  */
 225   SMALL_RECT scroll, clip;
 226   COORD      dest;
 227   CHAR_INFO  fill;
 228
 229   clip.Top = scroll.Top = clip.Bottom = scroll.Bottom = cursor_coords.Y;
 230   clip.Left = 0;
 231   clip.Right = FRAME_COLS (f);
 232
 233   if (direction == LEFT)
 234     {
 235       scroll.Left = cursor_coords.X + dist;
 236       scroll.Right = FRAME_COLS (f) - 1;
 237     }
 238   else
 239     {
 240       scroll.Left = cursor_coords.X;
 241       scroll.Right = FRAME_COLS (f) - dist - 1;
 242     }
 243
 244   dest.X = cursor_coords.X;
 245   dest.Y = cursor_coords.Y;
 246
 247   fill.Char.AsciiChar = 0x20;
 248   fill.Attributes = char_attr_normal;
 249
 250   ScrollConsoleScreenBuffer (cur_screen, &scroll, &clip, dest, &fill);
 251 }
 252
 253
 254 /* If start is zero insert blanks instead of a string at start ?. */
 255 static void
 256 w32con_insert_glyphs (struct frame *f, register struct glyph *start,
 257                       register int len)
 258 {
 259   scroll_line (f, len, RIGHT);
 260
 261   /* Move len chars to the right starting at cursor_coords, fill with blanks */
 262   if (start)
 263     {
 264       /* Print the first len characters of start, cursor_coords.X adjusted
 265          by write_glyphs.  */
 266
 267       w32con_write_glyphs (f, start, len);
 268     }
 269   else
 270     {
 271       w32con_clear_end_of_line (f, cursor_coords.X + len);
 272     }
 273 }
 274
 275 static void
 276 w32con_write_glyphs (struct frame *f, register struct glyph *string,
 277                      register int len)
 278 {
 279   DWORD r;
 280   WORD char_attr;
 281   unsigned char *conversion_buffer;
 282   struct coding_system *coding;
 283
 284   if (len <= 0)
 285     return;
 286
 287   /* If terminal_coding does any conversion, use it, otherwise use
 288      safe_terminal_coding.  We can't use CODING_REQUIRE_ENCODING here
 289      because it always return 1 if the member src_multibyte is 1.  */
 290   coding = (FRAME_TERMINAL_CODING (f)->common_flags & CODING_REQUIRE_ENCODING_MASK
 291             ? FRAME_TERMINAL_CODING (f) : &safe_terminal_coding);
 292   /* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
 293      the tail.  */
 294   coding->mode &= ~CODING_MODE_LAST_BLOCK;
 295
 296   while (len > 0)
 297     {
 298       /* Identify a run of glyphs with the same face.  */
 299       int face_id = string->face_id;
 300       int n;
 301
 302       for (n = 1; n < len; ++n)
 303         if (string[n].face_id != face_id)
 304           break;
 305
 306       /* Turn appearance modes of the face of the run on.  */
 307       char_attr = w32_face_attributes (f, face_id);
 308
 309       if (n == len)
 310         /* This is the last run.  */
 311         coding->mode |= CODING_MODE_LAST_BLOCK;
 312       conversion_buffer = encode_terminal_code (string, n, coding);
 313       if (coding->produced > 0)
 314         {
 315           /* Set the attribute for these characters.  */
 316           if (!FillConsoleOutputAttribute (cur_screen, char_attr,
 317                                            coding->produced, cursor_coords,
 318                                            &r))
 319             {
 320               printf ("Failed writing console attributes: %d\n",
 321                       GetLastError ());
 322               fflush (stdout);
 323             }
 324
 325           /* Write the characters.  */
 326           if (!WriteConsoleOutputCharacter (cur_screen, conversion_buffer,
 327                                             coding->produced, cursor_coords,
 328                                             &r))
 329             {
 330               printf ("Failed writing console characters: %d\n",
 331                       GetLastError ());
 332               fflush (stdout);
 333             }
 334
 335           cursor_coords.X += coding->produced;
 336           w32con_move_cursor (f, cursor_coords.Y, cursor_coords.X);
 337         }
 338       len -= n;
 339       string += n;
 340     }
 341 }
 342
 343 /* Used for mouse highlight.  */
 344 static void
 345 w32con_write_glyphs_with_face (struct frame *f, register int x, register int y,
 346                                register struct glyph *string, register int len,
 347                                register int face_id)
 348 {
 349   unsigned char *conversion_buffer;
 350   struct coding_system *coding;
 351
 352   if (len <= 0)
 353     return;
 354
 355   /* If terminal_coding does any conversion, use it, otherwise use
 356      safe_terminal_coding.  We can't use CODING_REQUIRE_ENCODING here
 357      because it always return 1 if the member src_multibyte is 1.  */
 358   coding = (FRAME_TERMINAL_CODING (f)->common_flags & CODING_REQUIRE_ENCODING_MASK
 359             ? FRAME_TERMINAL_CODING (f) : &safe_terminal_coding);
 360   /* We are going to write the entire block of glyphs in one go, as
 361      they all have the same face.  So this _is_ the last block.  */
 362   coding->mode |= CODING_MODE_LAST_BLOCK;
 363
 364   conversion_buffer = encode_terminal_code (string, len, coding);
 365   if (coding->produced > 0)
 366     {
 367       DWORD filled, written;
 368       /* Compute the character attributes corresponding to the face.  */
 369       DWORD char_attr = w32_face_attributes (f, face_id);
 370       COORD start_coords;
 371
 372       start_coords.X = x;
 373       start_coords.Y = y;
 374       /* Set the attribute for these characters.  */
 375       if (!FillConsoleOutputAttribute (cur_screen, char_attr,
 376                                        coding->produced, start_coords,
 377                                        &filled))
 378         DebPrint (("Failed writing console attributes: %d\n", GetLastError ()));
 379       else
 380         {
 381           /* Write the characters.  */
 382           if (!WriteConsoleOutputCharacter (cur_screen, conversion_buffer,
 383                                             filled, start_coords, &written))
 384             DebPrint (("Failed writing console characters: %d\n",
 385                        GetLastError ()));
 386         }
 387     }
 388 }
 389
 390 /* Implementation of draw_row_with_mouse_face for W32 console.  */
 391 void
 392 tty_draw_row_with_mouse_face (struct window *w, struct glyph_row *row,
 393                               int start_hpos, int end_hpos,
 394                               enum draw_glyphs_face draw)
 395 {
 396   int nglyphs = end_hpos - start_hpos;
 397   struct frame *f = XFRAME (WINDOW_FRAME (w));
 398   struct tty_display_info *tty = FRAME_TTY (f);
 399   int face_id = tty->mouse_highlight.mouse_face_face_id;
 400   int pos_x, pos_y;
 401
 402   if (end_hpos >= row->used[TEXT_AREA])
 403     nglyphs = row->used[TEXT_AREA] - start_hpos;
 404
 405   pos_y = row->y + WINDOW_TOP_EDGE_Y (w);
 406   pos_x = row->used[LEFT_MARGIN_AREA] + start_hpos + WINDOW_LEFT_EDGE_X (w);
 407
 408   if (draw == DRAW_MOUSE_FACE)
 409     w32con_write_glyphs_with_face (f, pos_x, pos_y,
 410                                    row->glyphs[TEXT_AREA] + start_hpos,
 411                                    nglyphs, face_id);
 412   else if (draw == DRAW_NORMAL_TEXT)
 413     {
 414       COORD save_coords = cursor_coords;
 415
 416       w32con_move_cursor (f, pos_y, pos_x);
 417       write_glyphs (f, row->glyphs[TEXT_AREA] + start_hpos, nglyphs);
 418       w32con_move_cursor (f, save_coords.Y, save_coords.X);
 419     }
 420 }
 421
 422 static void
 423 w32con_delete_glyphs (struct frame *f, int n)
 424 {
 425   /* delete chars means scroll chars from cursor_coords.X + n to
 426      cursor_coords.X, anything beyond the edge of the screen should
 427      come out empty...  */
 428
 429   scroll_line (f, n, LEFT);
 430 }
 431
 432 static unsigned int sound_type = 0xFFFFFFFF;
 433 #define MB_EMACS_SILENT (0xFFFFFFFF - 1)
 434
 435 void
 436 w32_sys_ring_bell (struct frame *f)
 437 {
 438   if (sound_type == 0xFFFFFFFF)
 439     {
 440       Beep (666, 100);
 441     }
 442   else if (sound_type == MB_EMACS_SILENT)
 443     {
 444       /* Do nothing.  */
 445     }
 446   else
 447     MessageBeep (sound_type);
 448 }
 449
 450 DEFUN ("set-message-beep", Fset_message_beep, Sset_message_beep, 1, 1, 0,
 451        doc: /* Set the sound generated when the bell is rung.
 452 SOUND is 'asterisk, 'exclamation, 'hand, 'question, 'ok, or 'silent
 453 to use the corresponding system sound for the bell.  The 'silent sound
 454 prevents Emacs from making any sound at all.
 455 SOUND is nil to use the normal beep.  */)
 456   (Lisp_Object sound)
 457 {
 458   CHECK_SYMBOL (sound);
 459
 460   if (NILP (sound))
 461       sound_type = 0xFFFFFFFF;
 462   else if (EQ (sound, intern ("asterisk")))
 463       sound_type = MB_ICONASTERISK;
 464   else if (EQ (sound, intern ("exclamation")))
 465       sound_type = MB_ICONEXCLAMATION;
 466   else if (EQ (sound, intern ("hand")))
 467       sound_type = MB_ICONHAND;
 468   else if (EQ (sound, intern ("question")))
 469       sound_type = MB_ICONQUESTION;
 470   else if (EQ (sound, intern ("ok")))
 471       sound_type = MB_OK;
 472   else if (EQ (sound, intern ("silent")))
 473       sound_type = MB_EMACS_SILENT;
 474   else
 475       sound_type = 0xFFFFFFFF;
 476
 477   return sound;
 478 }
 479
 480 static void
 481 w32con_reset_terminal_modes (struct terminal *t)
 482 {
 483   COORD dest;
 484   CONSOLE_SCREEN_BUFFER_INFO info;
 485   int n;
 486   DWORD r;
 487
 488   /* Clear the complete screen buffer.  This is required because Emacs
 489      sets the cursor position to the top of the buffer, but there might
 490      be other output below the bottom of the Emacs frame if the screen buffer
 491      is larger than the window size.  */
 492   GetConsoleScreenBufferInfo (cur_screen, &info);
 493   dest.X = 0;
 494   dest.Y = 0;
 495   n = info.dwSize.X * info.dwSize.Y;
 496
 497   FillConsoleOutputAttribute (cur_screen, char_attr_normal, n, dest, &r);
 498   FillConsoleOutputCharacter (cur_screen, ' ', n, dest, &r);
 499   /* Now that the screen is clear, put the cursor at the top.  */
 500   SetConsoleCursorPosition (cur_screen, dest);
 501
 502 #ifdef USE_SEPARATE_SCREEN
 503   SetConsoleActiveScreenBuffer (prev_screen);
 504 #else
 505   SetConsoleCursorInfo (prev_screen, &prev_console_cursor);
 506 #endif
 507
 508   SetConsoleMode (keyboard_handle, prev_console_mode);
 509 }
 510
 511 static void
 512 w32con_set_terminal_modes (struct terminal *t)
 513 {
 514   CONSOLE_CURSOR_INFO cci;
 515
 516   /* make cursor big and visible (100 on Win95 makes it disappear)  */
 517   cci.dwSize = 99;
 518   cci.bVisible = TRUE;
 519   (void) SetConsoleCursorInfo (cur_screen, &cci);
 520
 521   SetConsoleActiveScreenBuffer (cur_screen);
 522
 523   SetConsoleMode (keyboard_handle, ENABLE_MOUSE_INPUT | ENABLE_WINDOW_INPUT);
 524
 525   /* Initialize input mode: interrupt_input off, no flow control, allow
 526      8 bit character input, standard quit char.  */
 527   Fset_input_mode (Qnil, Qnil, make_number (2), Qnil);
 528 }
 529
 530 /* hmmm... perhaps these let us bracket screen changes so that we can flush
 531    clumps rather than one-character-at-a-time...
 532
 533    we'll start with not moving the cursor while an update is in progress.  */
 534 static void
 535 w32con_update_begin (struct frame * f)
 536 {
 537 }
 538
 539 static void
 540 w32con_update_end (struct frame * f)
 541 {
 542   SetConsoleCursorPosition (cur_screen, cursor_coords);
 543 }
 544
 545 static void
 546 w32con_set_terminal_window (struct frame *f, int size)
 547 {
 548 }
 549
 550 /***********************************************************************
 551                         stubs from termcap.c
 552  ***********************************************************************/
 553
 554 void
 555 sys_tputs (char *str, int nlines, int (*outfun) (int))
 556 {
 557 }
 558
 559 char *
 560 sys_tgetstr (char *cap, char **area)
 561 {
 562   return NULL;
 563 }
 564
 565
 566 /***********************************************************************
 567                         stubs from cm.c
 568  ***********************************************************************/
 569
 570 struct tty_display_info *current_tty = NULL;
 571 int cost = 0;
 572
 573 int
 574 evalcost (int c)
 575 {
 576   return c;
 577 }
 578
 579 int
 580 cmputc (int c)
 581 {
 582   return c;
 583 }
 584
 585 void
 586 cmcheckmagic (struct tty_display_info *tty)
 587 {
 588 }
 589
 590 void
 591 cmcostinit (struct tty_display_info *tty)
 592 {
 593 }
 594
 595 void
 596 cmgoto (struct tty_display_info *tty, int row, int col)
 597 {
 598 }
 599
 600 void
 601 Wcm_clear (struct tty_display_info *tty)
 602 {
 603 }
 604
 605
 606 /***********************************************************************
 607                                 Faces
 608  ***********************************************************************/
 609
 610
 611 /* Turn appearances of face FACE_ID on tty frame F on.  */
 612
 613 static WORD
 614 w32_face_attributes (struct frame *f, int face_id)
 615 {
 616   WORD char_attr;
 617   struct face *face = FACE_FROM_ID (f, face_id);
 618
 619   eassert (face != NULL);
 620
 621   char_attr = char_attr_normal;
 622
 623   /* Reverse the default color if requested. If background and
 624      foreground are specified, then they have been reversed already.  */
 625   if (face->tty_reverse_p)
 626     char_attr = (char_attr & 0xff00) + ((char_attr & 0x000f) << 4)
 627       + ((char_attr & 0x00f0) >> 4);
 628
 629   /* Before the terminal is properly initialized, all colors map to 0.
 630      Don't try to resolve them.  */
 631   if (NILP (Vtty_defined_color_alist))
 632     return char_attr;
 633
 634   /* Colors should be in the range 0...15 unless they are one of
 635      FACE_TTY_DEFAULT_COLOR, FACE_TTY_DEFAULT_FG_COLOR or
 636      FACE_TTY_DEFAULT_BG_COLOR.  Other out of range colors are
 637      invalid, so it is better to use the default color if they ever
 638      get through to here.  */
 639   if (face->foreground >= 0 && face->foreground < 16)
 640     char_attr = (char_attr & 0xfff0) + face->foreground;
 641
 642   if (face->background >= 0 && face->background < 16)
 643     char_attr = (char_attr & 0xff0f) + (face->background << 4);
 644
 645   return char_attr;
 646 }
 647
 648 void
 649 initialize_w32_display (struct terminal *term)
 650 {
 651   CONSOLE_SCREEN_BUFFER_INFO    info;
 652   Mouse_HLInfo *hlinfo;
 653
 654   term->rif = 0; /* No window based redisplay on the console.  */
 655   term->cursor_to_hook          = w32con_move_cursor;
 656   term->raw_cursor_to_hook      = w32con_move_cursor;
 657   term->clear_to_end_hook       = w32con_clear_to_end;
 658   term->clear_frame_hook        = w32con_clear_frame;
 659   term->clear_end_of_line_hook  = w32con_clear_end_of_line;
 660   term->ins_del_lines_hook      = w32con_ins_del_lines;
 661   term->insert_glyphs_hook      = w32con_insert_glyphs;
 662   term->write_glyphs_hook       = w32con_write_glyphs;
 663   term->delete_glyphs_hook      = w32con_delete_glyphs;
 664   term->ring_bell_hook          = w32_sys_ring_bell;
 665   term->reset_terminal_modes_hook = w32con_reset_terminal_modes;
 666   term->set_terminal_modes_hook = w32con_set_terminal_modes;
 667   term->set_terminal_window_hook = w32con_set_terminal_window;
 668   term->update_begin_hook       = w32con_update_begin;
 669   term->update_end_hook         = w32con_update_end;
 670
 671   term->read_socket_hook = w32_console_read_socket;
 672   term->mouse_position_hook = w32_console_mouse_position;
 673
 674   /* The following are not used on the console.  */
 675   term->frame_rehighlight_hook = 0;
 676   term->frame_raise_lower_hook = 0;
 677   term->set_vertical_scroll_bar_hook = 0;
 678   term->condemn_scroll_bars_hook = 0;
 679   term->redeem_scroll_bar_hook = 0;
 680   term->judge_scroll_bars_hook = 0;
 681   term->frame_up_to_date_hook = 0;
 682
 683   /* Initialize the mouse-highlight data.  */
 684   hlinfo = &term->display_info.tty->mouse_highlight;
 685   hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
 686   hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
 687   hlinfo->mouse_face_face_id = DEFAULT_FACE_ID;
 688   hlinfo->mouse_face_mouse_frame = NULL;
 689   hlinfo->mouse_face_window = Qnil;
 690   hlinfo->mouse_face_hidden = 0;
 691
 692   /* Initialize interrupt_handle.  */
 693   init_crit ();
 694
 695   /* Remember original console settings.  */
 696   keyboard_handle = GetStdHandle (STD_INPUT_HANDLE);
 697   GetConsoleMode (keyboard_handle, &prev_console_mode);
 698
 699   prev_screen = GetStdHandle (STD_OUTPUT_HANDLE);
 700
 701 #ifdef USE_SEPARATE_SCREEN
 702   cur_screen = CreateConsoleScreenBuffer (GENERIC_READ | GENERIC_WRITE,
 703                                           0, NULL,
 704                                           CONSOLE_TEXTMODE_BUFFER,
 705                                           NULL);
 706
 707   if (cur_screen == INVALID_HANDLE_VALUE)
 708     {
 709       printf ("CreateConsoleScreenBuffer failed in ResetTerm\n");
 710       printf ("LastError = 0x%lx\n", GetLastError ());
 711       fflush (stdout);
 712       exit (0);
 713     }
 714 #else
 715   cur_screen = prev_screen;
 716   GetConsoleCursorInfo (prev_screen, &prev_console_cursor);
 717 #endif
 718
 719   /* Respect setting of LINES and COLUMNS environment variables.  */
 720   {
 721     char * lines = getenv ("LINES");
 722     char * columns = getenv ("COLUMNS");
 723
 724     if (lines != NULL && columns != NULL)
 725       {
 726         SMALL_RECT new_win_dims;
 727         COORD new_size;
 728
 729         new_size.X = atoi (columns);
 730         new_size.Y = atoi (lines);
 731
 732         GetConsoleScreenBufferInfo (cur_screen, &info);
 733
 734         /* Shrink the window first, so the buffer dimensions can be
 735            reduced if necessary.  */
 736         new_win_dims.Top = 0;
 737         new_win_dims.Left = 0;
 738         new_win_dims.Bottom = min (new_size.Y, info.dwSize.Y) - 1;
 739         new_win_dims.Right = min (new_size.X, info.dwSize.X) - 1;
 740         SetConsoleWindowInfo (cur_screen, TRUE, &new_win_dims);
 741
 742         SetConsoleScreenBufferSize (cur_screen, new_size);
 743
 744         /* Set the window size to match the buffer dimension.  */
 745         new_win_dims.Top = 0;
 746         new_win_dims.Left = 0;
 747         new_win_dims.Bottom = new_size.Y - 1;
 748         new_win_dims.Right = new_size.X - 1;
 749         SetConsoleWindowInfo (cur_screen, TRUE, &new_win_dims);
 750       }
 751   }
 752
 753   GetConsoleScreenBufferInfo (cur_screen, &info);
 754
 755   char_attr_normal = info.wAttributes;
 756
 757   /* Determine if the info returned by GetConsoleScreenBufferInfo
 758      is realistic.  Old MS Telnet servers used to only fill out
 759      the dwSize portion, even modern one fill the whole struct with
 760      garbage when using non-MS telnet clients.  */
 761   if ((w32_use_full_screen_buffer
 762        && (info.dwSize.Y < 20 || info.dwSize.Y > 100
 763            || info.dwSize.X < 40 || info.dwSize.X > 200))
 764       || (!w32_use_full_screen_buffer
 765           && (info.srWindow.Bottom - info.srWindow.Top < 20
 766               || info.srWindow.Bottom - info.srWindow.Top > 100
 767               || info.srWindow.Right - info.srWindow.Left < 40
 768               || info.srWindow.Right - info.srWindow.Left > 100)))
 769     {
 770       FRAME_LINES (SELECTED_FRAME ()) = 25;
 771       SET_FRAME_COLS (SELECTED_FRAME (), 80);
 772     }
 773
 774   else if (w32_use_full_screen_buffer)
 775     {
 776       FRAME_LINES (SELECTED_FRAME ()) = info.dwSize.Y;  /* lines per page */
 777       SET_FRAME_COLS (SELECTED_FRAME (), info.dwSize.X);  /* characters per line */
 778     }
 779   else
 780     {
 781       /* Lines per page.  Use buffer coords instead of buffer size.  */
 782       FRAME_LINES (SELECTED_FRAME ()) = 1 + info.srWindow.Bottom -
 783         info.srWindow.Top;
 784       /* Characters per line.  Use buffer coords instead of buffer size.  */
 785       SET_FRAME_COLS (SELECTED_FRAME (), 1 + info.srWindow.Right -
 786                        info.srWindow.Left);
 787     }
 788
 789   /* Setup w32_display_info structure for this frame. */
 790
 791   w32_initialize_display_info (build_string ("Console"));
 792
 793 }
 794
 795
 796 DEFUN ("set-screen-color", Fset_screen_color, Sset_screen_color, 2, 2, 0,
 797        doc: /* Set screen foreground and background colors.
 798
 799 Arguments should be indices between 0 and 15, see w32console.el.  */)
 800   (Lisp_Object foreground, Lisp_Object background)
 801 {
 802   char_attr_normal = XFASTINT (foreground) + (XFASTINT (background) << 4);
 803
 804   Frecenter (Qnil);
 805   return Qt;
 806 }
 807
 808 DEFUN ("get-screen-color", Fget_screen_color, Sget_screen_color, 0, 0, 0,
 809        doc: /* Get color indices of the current screen foreground and background.
 810
 811 The colors are returned as a list of 2 indices (FOREGROUND BACKGROUND).
 812 See w32console.el and `tty-defined-color-alist' for mapping of indices
 813 to colors.  */)
 814   (void)
 815 {
 816   return Fcons (make_number (char_attr_normal & 0x000f),
 817                 Fcons (make_number ((char_attr_normal >> 4) & 0x000f), Qnil));
 818 }
 819
 820 DEFUN ("set-cursor-size", Fset_cursor_size, Sset_cursor_size, 1, 1, 0,
 821        doc: /* Set cursor size.  */)
 822   (Lisp_Object size)
 823 {
 824   CONSOLE_CURSOR_INFO cci;
 825   cci.dwSize = XFASTINT (size);
 826   cci.bVisible = TRUE;
 827   (void) SetConsoleCursorInfo (cur_screen, &cci);
 828
 829   return Qt;
 830 }
 831
 832 void
 833 syms_of_ntterm (void)
 834 {
 835   DEFVAR_BOOL ("w32-use-full-screen-buffer",
 836                w32_use_full_screen_buffer,
 837                doc: /* Non-nil means make terminal frames use the full screen buffer dimensions.
 838 This is desirable when running Emacs over telnet.
 839 A value of nil means use the current console window dimensions; this
 840 may be preferable when working directly at the console with a large
 841 scroll-back buffer.  */);
 842   w32_use_full_screen_buffer = 0;
 843
 844   defsubr (&Sset_screen_color);
 845   defsubr (&Sget_screen_color);
 846   defsubr (&Sset_cursor_size);
 847   defsubr (&Sset_message_beep);
 848 }