src/w32console.c

   1 /* Terminal hooks for GNU Emacs on the Microsoft W32 API.
   2    Copyright (C) 1992, 1999 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 2, or (at your option)
   9 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; see the file COPYING.  If not, write to
  18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.
  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 <stdlib.h>
  29 #include <stdio.h>
  30 #include <windows.h>
  31 #include <string.h>
  32
  33 #include "lisp.h"
  34 #include "charset.h"
  35 #include "coding.h"
  36 #include "disptab.h"
  37 #include "termhooks.h"
  38 #include "dispextern.h"
  39 /* Disable features in frame.h that require a Window System.  */
  40 #undef HAVE_WINDOW_SYSTEM
  41 #include "frame.h"
  42 #include "w32inevt.h"
  43
  44 #define min(a, b) ((a) < (b) ? (a) : (b))
  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 extern struct frame * updating_frame;
  56 extern int meta_key;
  57
  58 static void move_cursor (int row, int col);
  59 static void clear_to_end (void);
  60 static void clear_frame (void);
  61 static void clear_end_of_line (int);
  62 static void ins_del_lines (int vpos, int n);
  63 static void change_line_highlight (int, int, int, int);
  64 static void reassert_line_highlight (int, int);
  65 static void insert_glyphs (struct glyph *start, int len);
  66 static void write_glyphs (struct glyph *string, int len);
  67 static void delete_glyphs (int n);
  68 void w32_sys_ring_bell (void);
  69 static void reset_terminal_modes (void);
  70 static void set_terminal_modes (void);
  71 static void set_terminal_window (int size);
  72 static void update_begin (struct frame * f);
  73 static void update_end (struct frame * f);
  74 static WORD w32_face_attributes (struct frame *f, int face_id);
  75 static int hl_mode (int new_highlight);
  76
  77 static COORD    cursor_coords;
  78 static HANDLE   prev_screen, cur_screen;
  79 static WORD     char_attr_normal;
  80 static DWORD   prev_console_mode;
  81
  82 #ifndef USE_SEPARATE_SCREEN
  83 static CONSOLE_CURSOR_INFO prev_console_cursor;
  84 #endif
  85
  86 /* Determine whether to make frame dimensions match the screen buffer,
  87    or the current window size.  The former is desirable when running
  88    over telnet, while the latter is more useful when working directly at
  89    the console with a large scroll-back buffer.  */
  90 int w32_use_full_screen_buffer;
  91 HANDLE  keyboard_handle;
  92
  93
  94 /* Setting this as the ctrl handler prevents emacs from being killed when
  95    someone hits ^C in a 'suspended' session (child shell).
  96    Also ignore Ctrl-Break signals.  */
  97
  98 BOOL
  99 ctrl_c_handler (unsigned long type)
 100 {
 101   /* Only ignore "interrupt" events when running interactively.  */
 102   return (!noninteractive
 103           && (type == CTRL_C_EVENT || type == CTRL_BREAK_EVENT));
 104 }
 105
 106 /* If we're updating a frame, use it as the current frame
 107    Otherwise, use the selected frame.  */
 108 #define PICK_FRAME() (updating_frame ? updating_frame : SELECTED_FRAME ())
 109
 110 /* Move the cursor to (row, col).  */
 111 void
 112 move_cursor (int row, int col)
 113 {
 114   cursor_coords.X = col;
 115   cursor_coords.Y = row;
 116
 117   if (updating_frame == (struct frame *) NULL)
 118     {
 119       SetConsoleCursorPosition (cur_screen, cursor_coords);
 120     }
 121 }
 122
 123 /* Clear from cursor to end of screen.  */
 124 void
 125 clear_to_end (void)
 126 {
 127   struct frame * f = PICK_FRAME ();
 128
 129   clear_end_of_line (FRAME_WIDTH (f) - 1);
 130   ins_del_lines (cursor_coords.Y, FRAME_HEIGHT (f) - cursor_coords.Y - 1);
 131 }
 132
 133 /* Clear the frame.  */
 134 void
 135 clear_frame (void)
 136 {
 137   struct frame *  f = PICK_FRAME ();
 138   COORD      dest;
 139   int        n;
 140   DWORD      r;
 141   CONSOLE_SCREEN_BUFFER_INFO info;
 142
 143   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &info);
 144
 145   hl_mode (0);
 146
 147   /* Remember that the screen buffer might be wider than the window.  */
 148   n = FRAME_HEIGHT (f) * info.dwSize.X;
 149   dest.X = dest.Y = 0;
 150
 151   FillConsoleOutputAttribute (cur_screen, char_attr_normal, n, dest, &r);
 152   FillConsoleOutputCharacter (cur_screen, ' ', n, dest, &r);
 153
 154   move_cursor (0, 0);
 155 }
 156
 157
 158 static struct glyph glyph_base[256];
 159 static BOOL  ceol_initialized = FALSE;
 160
 161 /* Clear from Cursor to end (what's "standout marker"?).  */
 162 void
 163 clear_end_of_line (int end)
 164 {
 165   if (!ceol_initialized)
 166     {
 167       int i;
 168       for (i = 0; i < 256; i++)
 169         {
 170           memcpy (&glyph_base[i], &space_glyph, sizeof (struct glyph));
 171         }
 172       ceol_initialized = TRUE;
 173     }
 174   write_glyphs (glyph_base, end - cursor_coords.X);     /* fencepost ?  */
 175 }
 176
 177 /* Insert n lines at vpos. if n is negative delete -n lines.  */
 178 void
 179 ins_del_lines (int vpos, int n)
 180 {
 181   int        i, nb, save_highlight;
 182   SMALL_RECT scroll;
 183   COORD      dest;
 184   CHAR_INFO  fill;
 185   struct frame *  f = PICK_FRAME ();
 186
 187   if (n < 0)
 188     {
 189       scroll.Top = vpos - n;
 190       scroll.Bottom = FRAME_HEIGHT (f);
 191       dest.Y = vpos;
 192     }
 193   else
 194     {
 195       scroll.Top = vpos;
 196       scroll.Bottom = FRAME_HEIGHT (f) - n;
 197       dest.Y = vpos + n;
 198     }
 199   scroll.Left = 0;
 200   scroll.Right = FRAME_WIDTH (f);
 201
 202   dest.X = 0;
 203
 204   save_highlight = hl_mode (0);
 205
 206   fill.Char.AsciiChar = 0x20;
 207   fill.Attributes = char_attr_normal;
 208
 209   ScrollConsoleScreenBuffer (cur_screen, &scroll, NULL, dest, &fill);
 210
 211   /* Here we have to deal with a w32 console flake: If the scroll
 212      region looks like abc and we scroll c to a and fill with d we get
 213      cbd... if we scroll block c one line at a time to a, we get cdd...
 214      Emacs expects cdd consistently... So we have to deal with that
 215      here... (this also occurs scrolling the same way in the other
 216      direction.  */
 217
 218   if (n > 0)
 219     {
 220       if (scroll.Bottom < dest.Y)
 221         {
 222           for (i = scroll.Bottom; i < dest.Y; i++)
 223             {
 224               move_cursor (i, 0);
 225               clear_end_of_line (FRAME_WIDTH (f));
 226             }
 227         }
 228     }
 229   else
 230     {
 231       nb = dest.Y + (scroll.Bottom - scroll.Top) + 1;
 232
 233       if (nb < scroll.Top)
 234         {
 235           for (i = nb; i < scroll.Top; i++)
 236             {
 237               move_cursor (i, 0);
 238               clear_end_of_line (FRAME_WIDTH (f));
 239             }
 240         }
 241     }
 242
 243   cursor_coords.X = 0;
 244   cursor_coords.Y = vpos;
 245
 246   hl_mode (save_highlight);
 247 }
 248
 249 /* Changes attribute to use when drawing characters to control.  */
 250 static int
 251 hl_mode (int new_highlight)
 252 {
 253   static int highlight = 0;
 254   int old_highlight;
 255
 256   old_highlight = highlight;
 257   highlight = (new_highlight != 0);
 258
 259   return old_highlight;
 260 }
 261
 262 /* Call this when about to modify line at position VPOS and change whether it
 263    is highlighted.  */
 264 void
 265 change_line_highlight (int new_highlight, int vpos, int y,
 266                        int first_unused_hpos)
 267 {
 268   hl_mode (new_highlight);
 269   move_cursor (vpos, 0);
 270   clear_end_of_line (first_unused_hpos);
 271 }
 272
 273 /* External interface to control of standout mode. Call this when about to
 274  * modify line at position VPOS and not change whether it is highlighted.  */
 275 void
 276 reassert_line_highlight (int highlight, int vpos)
 277 {
 278   hl_mode (highlight);
 279   vpos;                         /* pedantic compiler silencer */
 280 }
 281
 282 #undef  LEFT
 283 #undef  RIGHT
 284 #define LEFT    1
 285 #define RIGHT   0
 286
 287 void
 288 scroll_line (int dist, int direction)
 289 {
 290   /* The idea here is to implement a horizontal scroll in one line to
 291      implement delete and half of insert.  */
 292   SMALL_RECT scroll;
 293   COORD      dest;
 294   CHAR_INFO  fill;
 295   struct frame *  f = PICK_FRAME ();
 296
 297   scroll.Top = cursor_coords.Y;
 298   scroll.Bottom = cursor_coords.Y;
 299
 300   if (direction == LEFT)
 301     {
 302       scroll.Left = cursor_coords.X + dist;
 303       scroll.Right = FRAME_WIDTH (f) - 1;
 304     }
 305   else
 306     {
 307       scroll.Left = cursor_coords.X;
 308       scroll.Right = FRAME_WIDTH (f) - dist - 1;
 309     }
 310
 311   dest.X = cursor_coords.X;
 312   dest.Y = cursor_coords.Y;
 313
 314   fill.Char.AsciiChar = 0x20;
 315   fill.Attributes = char_attr_normal;
 316
 317   ScrollConsoleScreenBuffer (cur_screen, &scroll, NULL, dest, &fill);
 318 }
 319
 320
 321 /* If start is zero insert blanks instead of a string at start ?. */
 322 void
 323 insert_glyphs (register struct glyph *start, register int len)
 324 {
 325   scroll_line (len, RIGHT);
 326
 327   /* Move len chars to the right starting at cursor_coords, fill with blanks */
 328   if (start)
 329     {
 330       /* Print the first len characters of start, cursor_coords.X adjusted
 331          by write_glyphs.  */
 332
 333       write_glyphs (start, len);
 334     }
 335   else
 336     {
 337       clear_end_of_line (cursor_coords.X + len);
 338     }
 339 }
 340
 341 void
 342 write_glyphs (register struct glyph *string, register int len)
 343 {
 344   int produced, consumed;
 345   DWORD r;
 346   struct frame * f = PICK_FRAME ();
 347   WORD char_attr;
 348   unsigned char conversion_buffer[1024];
 349   int conversion_buffer_size = sizeof conversion_buffer;
 350
 351   if (len <= 0)
 352     return;
 353
 354   /* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
 355      the tail.  */
 356   terminal_coding.mode &= ~CODING_MODE_LAST_BLOCK;
 357
 358   while (len > 0)
 359     {
 360       /* Identify a run of glyphs with the same face.  */
 361       int face_id = string->face_id;
 362       int n;
 363
 364       for (n = 1; n < len; ++n)
 365         if (string[n].face_id != face_id)
 366           break;
 367
 368       /* Turn appearance modes of the face of the run on.  */
 369       char_attr = w32_face_attributes (f, face_id);
 370
 371       while (n > 0)
 372         {
 373           /* We use a fixed size (1024 bytes) of conversion buffer.
 374              Usually it is sufficient, but if not, we just repeat the
 375              loop.  */
 376           produced = encode_terminal_code (string, conversion_buffer,
 377                                            n, conversion_buffer_size,
 378                                            &consumed);
 379           if (produced > 0)
 380             {
 381               /* Set the attribute for these characters.  */
 382               if (!FillConsoleOutputAttribute (cur_screen, char_attr,
 383                                                produced, cursor_coords, &r))
 384                 {
 385                   printf ("Failed writing console attributes: %d\n",
 386                           GetLastError ());
 387                   fflush (stdout);
 388                 }
 389
 390               /* Write the characters.  */
 391               if (!WriteConsoleOutputCharacter (cur_screen, conversion_buffer,
 392                                                 produced, cursor_coords, &r))
 393                 {
 394                   printf ("Failed writing console characters: %d\n",
 395                           GetLastError ());
 396                   fflush (stdout);
 397                 }
 398
 399               cursor_coords.X += produced;
 400               move_cursor (cursor_coords.Y, cursor_coords.X);
 401             }
 402           len -= consumed;
 403           n -= consumed;
 404           string += consumed;
 405         }
 406     }
 407
 408   /* We may have to output some codes to terminate the writing.  */
 409   if (CODING_REQUIRE_FLUSHING (&terminal_coding))
 410     {
 411       terminal_coding.mode |= CODING_MODE_LAST_BLOCK;
 412       encode_coding (&terminal_coding, "", conversion_buffer,
 413                      0, conversion_buffer_size);
 414       if (terminal_coding.produced > 0)
 415         {
 416           if (!FillConsoleOutputAttribute (cur_screen, char_attr_normal,
 417                                            terminal_coding.produced,
 418                                            cursor_coords, &r))
 419             {
 420               printf ("Failed writing console attributes: %d\n",
 421                       GetLastError ());
 422               fflush (stdout);
 423             }
 424
 425           /* Write the characters.  */
 426           if (!WriteConsoleOutputCharacter (cur_screen, conversion_buffer,
 427                                             produced, cursor_coords, &r))
 428             {
 429               printf ("Failed writing console characters: %d\n",
 430                       GetLastError ());
 431               fflush (stdout);
 432             }
 433         }
 434     }
 435 }
 436
 437
 438 void
 439 delete_glyphs (int n)
 440 {
 441   /* delete chars means scroll chars from cursor_coords.X + n to
 442      cursor_coords.X, anything beyond the edge of the screen should
 443      come out empty...  */
 444
 445   scroll_line (n, LEFT);
 446 }
 447
 448 static unsigned int sound_type = 0xFFFFFFFF;
 449 #define MB_EMACS_SILENT (0xFFFFFFFF - 1)
 450
 451 void
 452 w32_sys_ring_bell (void)
 453 {
 454   if (sound_type == 0xFFFFFFFF)
 455     {
 456       Beep (666, 100);
 457     }
 458   else if (sound_type == MB_EMACS_SILENT)
 459     {
 460       /* Do nothing.  */
 461     }
 462   else
 463     MessageBeep (sound_type);
 464 }
 465
 466 DEFUN ("set-message-beep", Fset_message_beep, Sset_message_beep, 1, 1, 0,
 467        "Set the sound generated when the bell is rung.\n\
 468 SOUND is 'asterisk, 'exclamation, 'hand, 'question, 'ok, or 'silent\n\
 469 to use the corresponding system sound for the bell.  The 'silent sound\n\
 470 prevents Emacs from making any sound at all.\n\
 471 SOUND is nil to use the normal beep.")
 472      (sound)
 473      Lisp_Object sound;
 474 {
 475   CHECK_SYMBOL (sound, 0);
 476
 477   if (NILP (sound))
 478       sound_type = 0xFFFFFFFF;
 479   else if (EQ (sound, intern ("asterisk")))
 480       sound_type = MB_ICONASTERISK;
 481   else if (EQ (sound, intern ("exclamation")))
 482       sound_type = MB_ICONEXCLAMATION;
 483   else if (EQ (sound, intern ("hand")))
 484       sound_type = MB_ICONHAND;
 485   else if (EQ (sound, intern ("question")))
 486       sound_type = MB_ICONQUESTION;
 487   else if (EQ (sound, intern ("ok")))
 488       sound_type = MB_OK;
 489   else if (EQ (sound, intern ("silent")))
 490       sound_type = MB_EMACS_SILENT;
 491   else
 492       sound_type = 0xFFFFFFFF;
 493
 494   return sound;
 495 }
 496
 497 void
 498 reset_terminal_modes (void)
 499 {
 500   hl_mode (0);
 501
 502 #ifdef USE_SEPARATE_SCREEN
 503   SetConsoleActiveScreenBuffer (prev_screen);
 504 #else
 505   SetConsoleCursorInfo (prev_screen, &prev_console_cursor);
 506 #endif
 507   SetConsoleMode (keyboard_handle, prev_console_mode);
 508 }
 509
 510 void
 511 set_terminal_modes (void)
 512 {
 513   CONSOLE_CURSOR_INFO cci;
 514
 515   hl_mode (0);
 516
 517   /* make cursor big and visible (100 on Win95 makes it disappear)  */
 518   cci.dwSize = 99;
 519   cci.bVisible = TRUE;
 520   (void) SetConsoleCursorInfo (cur_screen, &cci);
 521
 522   SetConsoleActiveScreenBuffer (cur_screen);
 523
 524   SetConsoleMode (keyboard_handle, ENABLE_MOUSE_INPUT | ENABLE_WINDOW_INPUT);
 525
 526   /* Initialize input mode: interrupt_input off, no flow control, allow
 527      8 bit character input, standard quit char.  */
 528   Fset_input_mode (Qnil, Qnil, make_number (2), Qnil);
 529 }
 530
 531 /* hmmm... perhaps these let us bracket screen changes so that we can flush
 532    clumps rather than one-character-at-a-time...
 533
 534    we'll start with not moving the cursor while an update is in progress.  */
 535 void
 536 update_begin (struct frame * f)
 537 {
 538   hl_mode (0);
 539 }
 540
 541 void
 542 update_end (struct frame * f)
 543 {
 544   hl_mode (0);
 545   SetConsoleCursorPosition (cur_screen, cursor_coords);
 546 }
 547
 548 void
 549 set_terminal_window (int size)
 550 {
 551 }
 552
 553 /***********************************************************************
 554                                 Faces
 555  ***********************************************************************/
 556
 557
 558 /* Turn appearances of face FACE_ID on tty frame F on.  */
 559
 560 static WORD
 561 w32_face_attributes (f, face_id)
 562      struct frame *f;
 563      int face_id;
 564 {
 565   WORD char_attr;
 566   int highlight_on_p;
 567   struct face *face = FACE_FROM_ID (f, face_id);
 568
 569   highlight_on_p = hl_mode (0);
 570   hl_mode (highlight_on_p);
 571
 572   xassert (face != NULL);
 573
 574   char_attr = char_attr_normal;
 575
 576   if (face->foreground != FACE_TTY_DEFAULT_FG_COLOR
 577       && face->foreground != FACE_TTY_DEFAULT_COLOR)
 578     char_attr = (char_attr & 0xfff0) + (face->foreground % 16);
 579
 580   if (face->background != FACE_TTY_DEFAULT_BG_COLOR
 581       && face->background != FACE_TTY_DEFAULT_COLOR)
 582     char_attr = (char_attr & 0xff0f) + ((face->background % 16) << 4);
 583
 584
 585   /* NTEMACS_TODO: Faces defined during startup get both foreground
 586      and background of 0. Need a better way around this - for now detect
 587      the problem and invert one of the faces to make the text readable. */
 588   if (((char_attr & 0x00f0) >> 4) == (char_attr & 0x000f))
 589     char_attr ^= 0x0007;
 590
 591   if (face->tty_reverse_p || highlight_on_p)
 592     char_attr = (char_attr & 0xff00) + ((char_attr & 0x000f) << 4)
 593       + ((char_attr & 0x00f0) >> 4);
 594
 595   return char_attr;
 596 }
 597
 598
 599 /* Emulation of some X window features from xfns.c and xfaces.c.  */
 600
 601 extern char unspecified_fg[], unspecified_bg[];
 602
 603
 604 /* Given a color index, return its standard name.  */
 605 Lisp_Object
 606 vga_stdcolor_name (int idx)
 607 {
 608   /* Standard VGA colors, in the order of their standard numbering
 609      in the default VGA palette.  */
 610   static char *vga_colors[16] = {
 611     "black", "blue", "green", "cyan", "red", "magenta", "brown",
 612     "lightgray", "darkgray", "lightblue", "lightgreen", "lightcyan",
 613     "lightred", "lightmagenta", "yellow", "white"
 614   };
 615
 616   extern Lisp_Object Qunspecified;
 617
 618   if (idx >= 0 && idx < sizeof (vga_colors) / sizeof (vga_colors[0]))
 619     return build_string (vga_colors[idx]);
 620   else
 621     return Qunspecified;        /* meaning the default */
 622 }
 623
 624 typedef int (*term_hook) ();
 625
 626 void
 627 initialize_w32_display (void)
 628 {
 629   CONSOLE_SCREEN_BUFFER_INFO    info;
 630
 631   cursor_to_hook                = move_cursor;
 632   raw_cursor_to_hook            = move_cursor;
 633   clear_to_end_hook             = clear_to_end;
 634   clear_frame_hook              = clear_frame;
 635   clear_end_of_line_hook        = clear_end_of_line;
 636   ins_del_lines_hook            = ins_del_lines;
 637   change_line_highlight_hook    = change_line_highlight;
 638   reassert_line_highlight_hook  = reassert_line_highlight;
 639   insert_glyphs_hook            = insert_glyphs;
 640   write_glyphs_hook             = write_glyphs;
 641   delete_glyphs_hook            = delete_glyphs;
 642   ring_bell_hook                = w32_sys_ring_bell;
 643   reset_terminal_modes_hook     = reset_terminal_modes;
 644   set_terminal_modes_hook       = set_terminal_modes;
 645   set_terminal_window_hook      = set_terminal_window;
 646   update_begin_hook             = update_begin;
 647   update_end_hook               = update_end;
 648
 649   read_socket_hook = w32_console_read_socket;
 650   mouse_position_hook = w32_console_mouse_position;
 651   estimate_mode_line_height_hook = 0;
 652
 653   /* Initialize interrupt_handle.  */
 654   init_crit ();
 655
 656   /* Remember original console settings.  */
 657   keyboard_handle = GetStdHandle (STD_INPUT_HANDLE);
 658   GetConsoleMode (keyboard_handle, &prev_console_mode);
 659
 660   prev_screen = GetStdHandle (STD_OUTPUT_HANDLE);
 661
 662 #ifdef USE_SEPARATE_SCREEN
 663   cur_screen = CreateConsoleScreenBuffer (GENERIC_READ | GENERIC_WRITE,
 664                                           0, NULL,
 665                                           CONSOLE_TEXTMODE_BUFFER,
 666                                           NULL);
 667
 668   if (cur_screen == INVALID_HANDLE_VALUE)
 669     {
 670       printf ("CreateConsoleScreenBuffer failed in ResetTerm\n");
 671       printf ("LastError = 0x%lx\n", GetLastError ());
 672       fflush (stdout);
 673       exit (0);
 674     }
 675 #else
 676   cur_screen = prev_screen;
 677   GetConsoleCursorInfo (prev_screen, &prev_console_cursor);
 678 #endif
 679
 680   /* Respect setting of LINES and COLUMNS environment variables.  */
 681   {
 682     char * lines = getenv("LINES");
 683     char * columns = getenv("COLUMNS");
 684
 685     if (lines != NULL && columns != NULL)
 686       {
 687         SMALL_RECT new_win_dims;
 688         COORD new_size;
 689
 690         new_size.X = atoi (columns);
 691         new_size.Y = atoi (lines);
 692
 693         GetConsoleScreenBufferInfo (cur_screen, &info);
 694
 695         /* Shrink the window first, so the buffer dimensions can be
 696            reduced if necessary.  */
 697         new_win_dims.Top = 0;
 698         new_win_dims.Left = 0;
 699         new_win_dims.Bottom = min (new_size.Y, info.dwSize.Y) - 1;
 700         new_win_dims.Right = min (new_size.X, info.dwSize.X) - 1;
 701         SetConsoleWindowInfo (cur_screen, TRUE, &new_win_dims);
 702
 703         SetConsoleScreenBufferSize (cur_screen, new_size);
 704
 705         /* Set the window size to match the buffer dimension.  */
 706         new_win_dims.Top = 0;
 707         new_win_dims.Left = 0;
 708         new_win_dims.Bottom = new_size.Y - 1;
 709         new_win_dims.Right = new_size.X - 1;
 710         SetConsoleWindowInfo (cur_screen, TRUE, &new_win_dims);
 711       }
 712   }
 713
 714   GetConsoleScreenBufferInfo (cur_screen, &info);
 715
 716   meta_key = 1;
 717   char_attr_normal = info.wAttributes;
 718   hl_mode (0);
 719
 720   if (w32_use_full_screen_buffer)
 721     {
 722       FRAME_HEIGHT (SELECTED_FRAME ()) = info.dwSize.Y; /* lines per page */
 723       SET_FRAME_WIDTH (SELECTED_FRAME (), info.dwSize.X);  /* characters per line */
 724     }
 725   else
 726     {
 727       /* Lines per page.  Use buffer coords instead of buffer size.  */
 728       FRAME_HEIGHT (SELECTED_FRAME ()) = 1 + info.srWindow.Bottom -
 729         info.srWindow.Top;
 730       /* Characters per line.  Use buffer coords instead of buffer size.  */
 731       SET_FRAME_WIDTH (SELECTED_FRAME (), 1 + info.srWindow.Right -
 732                        info.srWindow.Left);
 733     }
 734
 735   /* Setup w32_display_info structure for this frame. */
 736
 737   w32_initialize_display_info (build_string ("Console"));
 738
 739 }
 740
 741 DEFUN ("set-screen-color", Fset_screen_color, Sset_screen_color, 2, 2, 0,
 742        "Set screen colors.")
 743     (foreground, background)
 744     Lisp_Object foreground;
 745     Lisp_Object background;
 746 {
 747   char_attr_normal = XFASTINT (foreground) + (XFASTINT (background) << 4);
 748
 749   Frecenter (Qnil);
 750   return Qt;
 751 }
 752
 753 DEFUN ("set-cursor-size", Fset_cursor_size, Sset_cursor_size, 1, 1, 0,
 754        "Set cursor size.")
 755     (size)
 756     Lisp_Object size;
 757 {
 758   CONSOLE_CURSOR_INFO cci;
 759   cci.dwSize = XFASTINT (size);
 760   cci.bVisible = TRUE;
 761   (void) SetConsoleCursorInfo (cur_screen, &cci);
 762
 763   return Qt;
 764 }
 765
 766 #ifndef HAVE_NTGUI
 767 void
 768 pixel_to_glyph_coords (struct frame * f, int pix_x, int pix_y, int *x, int *y,
 769                       void *bounds, int noclip)
 770 {
 771   *x = pix_x;
 772   *y = pix_y;
 773 }
 774
 775 void
 776 glyph_to_pixel_coords (struct window * f, int x, int y, int *pix_x, int *pix_y)
 777 {
 778   *pix_x = x;
 779   *pix_y = y;
 780 }
 781 #endif /* !HAVE_NTGUI */
 782
 783 void
 784 syms_of_ntterm ()
 785 {
 786   DEFVAR_BOOL ("w32-use-full-screen-buffer",
 787                &w32_use_full_screen_buffer,
 788   "Non-nil means make terminal frames use the full screen buffer dimensions.\n\
 789 This is desirable when running Emacs over telnet, and is the default.\n\
 790 A value of nil means use the current console window dimensions; this\n\
 791 may be preferrable when working directly at the console with a large\n\
 792 scroll-back buffer.");
 793   w32_use_full_screen_buffer = 1;
 794
 795   defsubr (&Sset_screen_color);
 796   defsubr (&Sset_cursor_size);
 797   defsubr (&Sset_message_beep);
 798 }