src/w32console.c

   1 /* Terminal hooks for GNU Emacs on the Microsoft W32 API.
   2    Copyright (C) 1992, 1999, 2001, 2002, 2003, 2004,
   3                  2005, 2006, 2007  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, or (at your option)
  10 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; see the file COPYING.  If not, write to
  19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  20 Boston, MA 02110-1301, USA.
  21
  22    Tim Fleehart (apollo@online.com)             1-17-92
  23    Geoff Voelker (voelker@cs.washington.edu)    9-12-93
  24 */
  25
  26
  27 #include <config.h>
  28
  29 #include <stdlib.h>
  30 #include <stdio.h>
  31 #include <windows.h>
  32 #include <string.h>
  33
  34 #include "lisp.h"
  35 #include "charset.h"
  36 #include "coding.h"
  37 #include "disptab.h"
  38 /* Disable features in frame.h that require a Window System.  */
  39 #undef HAVE_WINDOW_SYSTEM
  40 #include "frame.h"
  41 #include "termhooks.h"
  42 #include "termchar.h"
  43 #include "dispextern.h"
  44 #include "w32inevt.h"
  45
  46 /* from window.c */
  47 extern Lisp_Object Frecenter ();
  48
  49 /* from keyboard.c */
  50 extern int detect_input_pending ();
  51
  52 /* from sysdep.c */
  53 extern int read_input_pending ();
  54
  55 static void w32con_move_cursor (struct frame *f, int row, int col);
  56 static void w32con_clear_to_end (struct frame *f);
  57 static void w32con_clear_frame (struct frame *f);
  58 static void w32con_clear_end_of_line (struct frame *f, int);
  59 static void w32con_ins_del_lines (struct frame *f, int vpos, int n);
  60 static void w32con_insert_glyphs (struct frame *f, struct glyph *start, int len);
  61 static void w32con_write_glyphs (struct frame *f, struct glyph *string, int len);
  62 static void w32con_delete_glyphs (struct frame *f, int n);
  63 static void w32con_reset_terminal_modes (struct terminal *t);
  64 static void w32con_set_terminal_modes (struct terminal *t);
  65 static void w32con_set_terminal_window (struct frame *f, int size);
  66 static void w32con_update_begin (struct frame * f);
  67 static void w32con_update_end (struct frame * f);
  68 static WORD w32_face_attributes (struct frame *f, int face_id);
  69
  70 static COORD    cursor_coords;
  71 static HANDLE   prev_screen, cur_screen;
  72 static WORD     char_attr_normal;
  73 static DWORD   prev_console_mode;
  74
  75 #ifndef USE_SEPARATE_SCREEN
  76 static CONSOLE_CURSOR_INFO prev_console_cursor;
  77 #endif
  78
  79 /* Determine whether to make frame dimensions match the screen buffer,
  80    or the current window size.  The former is desirable when running
  81    over telnet, while the latter is more useful when working directly at
  82    the console with a large scroll-back buffer.  */
  83 int w32_use_full_screen_buffer;
  84 HANDLE  keyboard_handle;
  85
  86
  87 /* Setting this as the ctrl handler prevents emacs from being killed when
  88    someone hits ^C in a 'suspended' session (child shell).
  89    Also ignore Ctrl-Break signals.  */
  90
  91 BOOL
  92 ctrl_c_handler (unsigned long type)
  93 {
  94   /* Only ignore "interrupt" events when running interactively.  */
  95   return (!noninteractive
  96           && (type == CTRL_C_EVENT || type == CTRL_BREAK_EVENT));
  97 }
  98
  99
 100 /* Move the cursor to (ROW, COL) on FRAME.  */
 101 static void
 102 w32con_move_cursor (struct frame *f, int row, int col)
 103 {
 104   cursor_coords.X = col;
 105   cursor_coords.Y = row;
 106
 107   /* TODO: for multi-tty support, cur_screen should be replaced with a
 108      reference to the terminal for this frame.  */
 109   SetConsoleCursorPosition (cur_screen, cursor_coords);
 110 }
 111
 112 /* Clear from cursor to end of screen.  */
 113 static void
 114 w32con_clear_to_end (struct frame *f)
 115 {
 116   w32con_clear_end_of_line (f, FRAME_COLS (f) - 1);
 117   w32con_ins_del_lines (f, cursor_coords.Y, FRAME_LINES (f) - cursor_coords.Y - 1);
 118 }
 119
 120 /* Clear the frame.  */
 121 static void
 122 w32con_clear_frame (struct frame *f)
 123 {
 124   COORD      dest;
 125   int        n;
 126   DWORD      r;
 127   CONSOLE_SCREEN_BUFFER_INFO info;
 128
 129   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &info);
 130
 131   /* Remember that the screen buffer might be wider than the window.  */
 132   n = FRAME_LINES (f) * info.dwSize.X;
 133   dest.X = dest.Y = 0;
 134
 135   FillConsoleOutputAttribute (cur_screen, char_attr_normal, n, dest, &r);
 136   FillConsoleOutputCharacter (cur_screen, ' ', n, dest, &r);
 137
 138   w32con_move_cursor (f, 0, 0);
 139 }
 140
 141
 142 static struct glyph glyph_base[256];
 143 static BOOL  ceol_initialized = FALSE;
 144
 145 /* Clear from Cursor to end (what's "standout marker"?).  */
 146 static void
 147 w32con_clear_end_of_line (struct frame *f, int end)
 148 {
 149   if (!ceol_initialized)
 150     {
 151       int i;
 152       for (i = 0; i < 256; i++)
 153         {
 154           memcpy (&glyph_base[i], &space_glyph, sizeof (struct glyph));
 155         }
 156       ceol_initialized = TRUE;
 157     }
 158   w32con_write_glyphs (f, glyph_base, end - cursor_coords.X);   /* fencepost ?  */
 159 }
 160
 161 /* Insert n lines at vpos. if n is negative delete -n lines.  */
 162 static void
 163 w32con_ins_del_lines (struct frame *f, int vpos, int n)
 164 {
 165   int        i, nb;
 166   SMALL_RECT scroll;
 167   COORD      dest;
 168   CHAR_INFO  fill;
 169
 170   if (n < 0)
 171     {
 172       scroll.Top = vpos - n;
 173       scroll.Bottom = FRAME_LINES (f);
 174       dest.Y = vpos;
 175     }
 176   else
 177     {
 178       scroll.Top = vpos;
 179       scroll.Bottom = FRAME_LINES (f) - n;
 180       dest.Y = vpos + n;
 181     }
 182   scroll.Left = 0;
 183   scroll.Right = FRAME_COLS (f);
 184
 185   dest.X = 0;
 186
 187   fill.Char.AsciiChar = 0x20;
 188   fill.Attributes = char_attr_normal;
 189
 190   ScrollConsoleScreenBuffer (cur_screen, &scroll, NULL, 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;
 239   COORD      dest;
 240   CHAR_INFO  fill;
 241
 242   scroll.Top = cursor_coords.Y;
 243   scroll.Bottom = cursor_coords.Y;
 244
 245   if (direction == LEFT)
 246     {
 247       scroll.Left = cursor_coords.X + dist;
 248       scroll.Right = FRAME_COLS (f) - 1;
 249     }
 250   else
 251     {
 252       scroll.Left = cursor_coords.X;
 253       scroll.Right = FRAME_COLS (f) - dist - 1;
 254     }
 255
 256   dest.X = cursor_coords.X;
 257   dest.Y = cursor_coords.Y;
 258
 259   fill.Char.AsciiChar = 0x20;
 260   fill.Attributes = char_attr_normal;
 261
 262   ScrollConsoleScreenBuffer (cur_screen, &scroll, NULL, dest, &fill);
 263 }
 264
 265
 266 /* If start is zero insert blanks instead of a string at start ?. */
 267 static void
 268 w32con_insert_glyphs (struct frame *f, register struct glyph *start, register int len)
 269 {
 270   scroll_line (f, len, RIGHT);
 271
 272   /* Move len chars to the right starting at cursor_coords, fill with blanks */
 273   if (start)
 274     {
 275       /* Print the first len characters of start, cursor_coords.X adjusted
 276          by write_glyphs.  */
 277
 278       w32con_write_glyphs (f, start, len);
 279     }
 280   else
 281     {
 282       w32con_clear_end_of_line (f, cursor_coords.X + len);
 283     }
 284 }
 285
 286 extern unsigned char *encode_terminal_code P_ ((struct glyph *, int,
 287                                                 struct coding_system *));
 288
 289 static void
 290 w32con_write_glyphs (struct frame *f, register struct glyph *string,
 291                      register int len)
 292 {
 293   int produced, consumed;
 294   DWORD r;
 295   WORD char_attr;
 296   unsigned char *conversion_buffer;
 297   struct coding_system *coding;
 298
 299   if (len <= 0)
 300     return;
 301
 302   /* If terminal_coding does any conversion, use it, otherwise use
 303      safe_terminal_coding.  We can't use CODING_REQUIRE_ENCODING here
 304      because it always return 1 if the member src_multibyte is 1.  */
 305   coding = (FRAME_TERMINAL_CODING (f)->common_flags & CODING_REQUIRE_ENCODING_MASK
 306             ? FRAME_TERMINAL_CODING (f) : &safe_terminal_coding);
 307   /* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
 308      the tail.  */
 309   coding->mode &= ~CODING_MODE_LAST_BLOCK;
 310
 311   while (len > 0)
 312     {
 313       /* Identify a run of glyphs with the same face.  */
 314       int face_id = string->face_id;
 315       int n;
 316
 317       for (n = 1; n < len; ++n)
 318         if (string[n].face_id != face_id)
 319           break;
 320
 321       /* Turn appearance modes of the face of the run on.  */
 322       char_attr = w32_face_attributes (f, face_id);
 323
 324       if (n == len)
 325         /* This is the last run.  */
 326         coding->mode |= CODING_MODE_LAST_BLOCK;
 327       conversion_buffer = encode_terminal_code (string, n, coding);
 328       if (coding->produced > 0)
 329         {
 330           /* Set the attribute for these characters.  */
 331           if (!FillConsoleOutputAttribute (cur_screen, char_attr,
 332                                            coding->produced, cursor_coords,
 333                                            &r))
 334             {
 335               printf ("Failed writing console attributes: %d\n",
 336                       GetLastError ());
 337               fflush (stdout);
 338             }
 339
 340           /* Write the characters.  */
 341           if (!WriteConsoleOutputCharacter (cur_screen, conversion_buffer,
 342                                             coding->produced, cursor_coords,
 343                                             &r))
 344             {
 345               printf ("Failed writing console characters: %d\n",
 346                       GetLastError ());
 347               fflush (stdout);
 348             }
 349
 350           cursor_coords.X += coding->produced;
 351           w32con_move_cursor (f, cursor_coords.Y, cursor_coords.X);
 352         }
 353       len -= n;
 354       string += n;
 355     }
 356 }
 357
 358
 359 static void
 360 w32con_delete_glyphs (struct frame *f, int n)
 361 {
 362   /* delete chars means scroll chars from cursor_coords.X + n to
 363      cursor_coords.X, anything beyond the edge of the screen should
 364      come out empty...  */
 365
 366   scroll_line (f, n, LEFT);
 367 }
 368
 369 static unsigned int sound_type = 0xFFFFFFFF;
 370 #define MB_EMACS_SILENT (0xFFFFFFFF - 1)
 371
 372 void
 373 w32_sys_ring_bell (struct frame *f)
 374 {
 375   if (sound_type == 0xFFFFFFFF)
 376     {
 377       Beep (666, 100);
 378     }
 379   else if (sound_type == MB_EMACS_SILENT)
 380     {
 381       /* Do nothing.  */
 382     }
 383   else
 384     MessageBeep (sound_type);
 385 }
 386
 387 DEFUN ("set-message-beep", Fset_message_beep, Sset_message_beep, 1, 1, 0,
 388        doc: /* Set the sound generated when the bell is rung.
 389 SOUND is 'asterisk, 'exclamation, 'hand, 'question, 'ok, or 'silent
 390 to use the corresponding system sound for the bell.  The 'silent sound
 391 prevents Emacs from making any sound at all.
 392 SOUND is nil to use the normal beep.  */)
 393      (sound)
 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 #ifdef USE_SEPARATE_SCREEN
 422   SetConsoleActiveScreenBuffer (prev_screen);
 423 #else
 424   SetConsoleCursorInfo (prev_screen, &prev_console_cursor);
 425 #endif
 426   SetConsoleMode (keyboard_handle, prev_console_mode);
 427 }
 428
 429 static void
 430 w32con_set_terminal_modes (struct terminal *t)
 431 {
 432   CONSOLE_CURSOR_INFO cci;
 433
 434   /* make cursor big and visible (100 on Win95 makes it disappear)  */
 435   cci.dwSize = 99;
 436   cci.bVisible = TRUE;
 437   (void) SetConsoleCursorInfo (cur_screen, &cci);
 438
 439   SetConsoleActiveScreenBuffer (cur_screen);
 440
 441   SetConsoleMode (keyboard_handle, ENABLE_MOUSE_INPUT | ENABLE_WINDOW_INPUT);
 442
 443   /* Initialize input mode: interrupt_input off, no flow control, allow
 444      8 bit character input, standard quit char.  */
 445   Fset_input_mode (Qnil, Qnil, make_number (2), Qnil);
 446 }
 447
 448 /* hmmm... perhaps these let us bracket screen changes so that we can flush
 449    clumps rather than one-character-at-a-time...
 450
 451    we'll start with not moving the cursor while an update is in progress.  */
 452 static void
 453 w32con_update_begin (struct frame * f)
 454 {
 455 }
 456
 457 static void
 458 w32con_update_end (struct frame * f)
 459 {
 460   SetConsoleCursorPosition (cur_screen, cursor_coords);
 461 }
 462
 463 static void
 464 w32con_set_terminal_window (struct frame *f, int size)
 465 {
 466 }
 467
 468 /***********************************************************************
 469                                 Faces
 470  ***********************************************************************/
 471
 472
 473 /* Turn appearances of face FACE_ID on tty frame F on.  */
 474
 475 static WORD
 476 w32_face_attributes (f, face_id)
 477      struct frame *f;
 478      int face_id;
 479 {
 480   WORD char_attr;
 481   struct face *face = FACE_FROM_ID (f, face_id);
 482
 483   xassert (face != NULL);
 484
 485   char_attr = char_attr_normal;
 486
 487   if (face->foreground != FACE_TTY_DEFAULT_FG_COLOR
 488       && face->foreground != FACE_TTY_DEFAULT_COLOR)
 489     char_attr = (char_attr & 0xfff0) + (face->foreground % 16);
 490
 491   if (face->background != FACE_TTY_DEFAULT_BG_COLOR
 492       && face->background != FACE_TTY_DEFAULT_COLOR)
 493     char_attr = (char_attr & 0xff0f) + ((face->background % 16) << 4);
 494
 495
 496   /* NTEMACS_TODO: Faces defined during startup get both foreground
 497      and background of 0. Need a better way around this - for now detect
 498      the problem and invert one of the faces to make the text readable. */
 499   if (((char_attr & 0x00f0) >> 4) == (char_attr & 0x000f))
 500     char_attr ^= 0x0007;
 501
 502   if (face->tty_reverse_p)
 503     char_attr = (char_attr & 0xff00) + ((char_attr & 0x000f) << 4)
 504       + ((char_attr & 0x00f0) >> 4);
 505
 506   return char_attr;
 507 }
 508
 509
 510 /* Emulation of some X window features from xfns.c and xfaces.c.  */
 511
 512 extern char unspecified_fg[], unspecified_bg[];
 513
 514
 515 /* Given a color index, return its standard name.  */
 516 Lisp_Object
 517 vga_stdcolor_name (int idx)
 518 {
 519   /* Standard VGA colors, in the order of their standard numbering
 520      in the default VGA palette.  */
 521   static char *vga_colors[16] = {
 522     "black", "blue", "green", "cyan", "red", "magenta", "brown",
 523     "lightgray", "darkgray", "lightblue", "lightgreen", "lightcyan",
 524     "lightred", "lightmagenta", "yellow", "white"
 525   };
 526
 527   extern Lisp_Object Qunspecified;
 528
 529   if (idx >= 0 && idx < sizeof (vga_colors) / sizeof (vga_colors[0]))
 530     return build_string (vga_colors[idx]);
 531   else
 532     return Qunspecified;        /* meaning the default */
 533 }
 534
 535 typedef int (*term_hook) ();
 536
 537 void
 538 initialize_w32_display (struct terminal *term)
 539 {
 540   CONSOLE_SCREEN_BUFFER_INFO    info;
 541
 542   term->rif = 0; /* No window based redisplay on the console.  */
 543   term->cursor_to_hook          = w32con_move_cursor;
 544   term->raw_cursor_to_hook              = w32con_move_cursor;
 545   term->clear_to_end_hook               = w32con_clear_to_end;
 546   term->clear_frame_hook                = w32con_clear_frame;
 547   term->clear_end_of_line_hook  = w32con_clear_end_of_line;
 548   term->ins_del_lines_hook              = w32con_ins_del_lines;
 549   term->insert_glyphs_hook              = w32con_insert_glyphs;
 550   term->write_glyphs_hook               = w32con_write_glyphs;
 551   term->delete_glyphs_hook              = w32con_delete_glyphs;
 552   term->ring_bell_hook          = w32_sys_ring_bell;
 553   term->reset_terminal_modes_hook       = w32con_reset_terminal_modes;
 554   term->set_terminal_modes_hook = w32con_set_terminal_modes;
 555   term->set_terminal_window_hook        = w32con_set_terminal_window;
 556   term->update_begin_hook               = w32con_update_begin;
 557   term->update_end_hook         = w32con_update_end;
 558
 559   term->read_socket_hook = w32_console_read_socket;
 560   term->mouse_position_hook = w32_console_mouse_position;
 561
 562   /* The following are not used on the console.  */
 563   term->frame_rehighlight_hook = 0;
 564   term->frame_raise_lower_hook = 0;
 565   term->set_vertical_scroll_bar_hook = 0;
 566   term->condemn_scroll_bars_hook = 0;
 567   term->redeem_scroll_bar_hook = 0;
 568   term->judge_scroll_bars_hook = 0;
 569   term->frame_up_to_date_hook = 0;
 570
 571   /* Initialize interrupt_handle.  */
 572   init_crit ();
 573
 574   /* Remember original console settings.  */
 575   keyboard_handle = GetStdHandle (STD_INPUT_HANDLE);
 576   GetConsoleMode (keyboard_handle, &prev_console_mode);
 577
 578   prev_screen = GetStdHandle (STD_OUTPUT_HANDLE);
 579
 580 #ifdef USE_SEPARATE_SCREEN
 581   cur_screen = CreateConsoleScreenBuffer (GENERIC_READ | GENERIC_WRITE,
 582                                           0, NULL,
 583                                           CONSOLE_TEXTMODE_BUFFER,
 584                                           NULL);
 585
 586   if (cur_screen == INVALID_HANDLE_VALUE)
 587     {
 588       printf ("CreateConsoleScreenBuffer failed in ResetTerm\n");
 589       printf ("LastError = 0x%lx\n", GetLastError ());
 590       fflush (stdout);
 591       exit (0);
 592     }
 593 #else
 594   cur_screen = prev_screen;
 595   GetConsoleCursorInfo (prev_screen, &prev_console_cursor);
 596 #endif
 597
 598   /* Respect setting of LINES and COLUMNS environment variables.  */
 599   {
 600     char * lines = getenv("LINES");
 601     char * columns = getenv("COLUMNS");
 602
 603     if (lines != NULL && columns != NULL)
 604       {
 605         SMALL_RECT new_win_dims;
 606         COORD new_size;
 607
 608         new_size.X = atoi (columns);
 609         new_size.Y = atoi (lines);
 610
 611         GetConsoleScreenBufferInfo (cur_screen, &info);
 612
 613         /* Shrink the window first, so the buffer dimensions can be
 614            reduced if necessary.  */
 615         new_win_dims.Top = 0;
 616         new_win_dims.Left = 0;
 617         new_win_dims.Bottom = min (new_size.Y, info.dwSize.Y) - 1;
 618         new_win_dims.Right = min (new_size.X, info.dwSize.X) - 1;
 619         SetConsoleWindowInfo (cur_screen, TRUE, &new_win_dims);
 620
 621         SetConsoleScreenBufferSize (cur_screen, new_size);
 622
 623         /* Set the window size to match the buffer dimension.  */
 624         new_win_dims.Top = 0;
 625         new_win_dims.Left = 0;
 626         new_win_dims.Bottom = new_size.Y - 1;
 627         new_win_dims.Right = new_size.X - 1;
 628         SetConsoleWindowInfo (cur_screen, TRUE, &new_win_dims);
 629       }
 630   }
 631
 632   GetConsoleScreenBufferInfo (cur_screen, &info);
 633
 634   char_attr_normal = info.wAttributes;
 635
 636   /* Determine if the info returned by GetConsoleScreenBufferInfo
 637      is realistic.  Old MS Telnet servers used to only fill out
 638      the dwSize portion, even modern one fill the whole struct with
 639      garbage when using non-MS telnet clients.  */
 640   if ((w32_use_full_screen_buffer
 641        && (info.dwSize.Y < 20 || info.dwSize.Y > 100
 642            || info.dwSize.X < 40 || info.dwSize.X > 200))
 643       || (!w32_use_full_screen_buffer
 644           && (info.srWindow.Bottom - info.srWindow.Top < 20
 645               || info.srWindow.Bottom - info.srWindow.Top > 100
 646               || info.srWindow.Right - info.srWindow.Left < 40
 647               || info.srWindow.Right - info.srWindow.Left > 100)))
 648     {
 649       FRAME_LINES (SELECTED_FRAME ()) = 25;
 650       SET_FRAME_COLS (SELECTED_FRAME (), 80);
 651     }
 652
 653   else if (w32_use_full_screen_buffer)
 654     {
 655       FRAME_LINES (SELECTED_FRAME ()) = info.dwSize.Y;  /* lines per page */
 656       SET_FRAME_COLS (SELECTED_FRAME (), info.dwSize.X);  /* characters per line */
 657     }
 658   else
 659     {
 660       /* Lines per page.  Use buffer coords instead of buffer size.  */
 661       FRAME_LINES (SELECTED_FRAME ()) = 1 + info.srWindow.Bottom -
 662         info.srWindow.Top;
 663       /* Characters per line.  Use buffer coords instead of buffer size.  */
 664       SET_FRAME_COLS (SELECTED_FRAME (), 1 + info.srWindow.Right -
 665                        info.srWindow.Left);
 666     }
 667
 668   /* Setup w32_display_info structure for this frame. */
 669
 670   w32_initialize_display_info (build_string ("Console"));
 671
 672 }
 673
 674
 675 DEFUN ("set-screen-color", Fset_screen_color, Sset_screen_color, 2, 2, 0,
 676        doc: /* Set screen colors.  */)
 677     (foreground, background)
 678     Lisp_Object foreground;
 679     Lisp_Object background;
 680 {
 681   char_attr_normal = XFASTINT (foreground) + (XFASTINT (background) << 4);
 682
 683   Frecenter (Qnil);
 684   return Qt;
 685 }
 686
 687 DEFUN ("set-cursor-size", Fset_cursor_size, Sset_cursor_size, 1, 1, 0,
 688        doc: /* Set cursor size.  */)
 689     (size)
 690     Lisp_Object size;
 691 {
 692   CONSOLE_CURSOR_INFO cci;
 693   cci.dwSize = XFASTINT (size);
 694   cci.bVisible = TRUE;
 695   (void) SetConsoleCursorInfo (cur_screen, &cci);
 696
 697   return Qt;
 698 }
 699
 700 void
 701 syms_of_ntterm ()
 702 {
 703   DEFVAR_BOOL ("w32-use-full-screen-buffer",
 704                &w32_use_full_screen_buffer,
 705                doc: /* Non-nil means make terminal frames use the full screen buffer dimensions.
 706 This is desirable when running Emacs over telnet.
 707 A value of nil means use the current console window dimensions; this
 708 may be preferrable when working directly at the console with a large
 709 scroll-back buffer.  */);
 710   w32_use_full_screen_buffer = 0;
 711
 712   defsubr (&Sset_screen_color);
 713   defsubr (&Sset_cursor_size);
 714   defsubr (&Sset_message_beep);
 715 }
 716
 717 /* arch-tag: a390a07f-f661-42bc-aeb4-e6d8bf860337
 718    (do not change this comment) */