src/w32console.c

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