src/w32inevt.c

   1 /* Input event support for Emacs on the Microsoft W32 API.
   2    Copyright (C) 1992, 1993, 1995, 2001, 2002, 2003, 2004, 2005, 2006,
   3                  2007, 2008  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    Drew Bliss                   01-Oct-93
  22      Adapted from ntkbd.c by Tim Fleehart
  23 */
  24
  25
  26 #ifdef HAVE_CONFIG_H
  27 #include <config.h>
  28 #endif
  29
  30 #include <stdlib.h>
  31 #include <stdio.h>
  32 #include <windows.h>
  33
  34 #ifndef MOUSE_MOVED
  35 #define MOUSE_MOVED   1
  36 #endif
  37
  38 #include "lisp.h"
  39 #include "keyboard.h"
  40 #include "frame.h"
  41 #include "dispextern.h"
  42 #include "blockinput.h"
  43 #include "termhooks.h"
  44 #include "w32heap.h"
  45 #include "w32term.h"
  46
  47 /* stdin, from ntterm */
  48 extern HANDLE keyboard_handle;
  49
  50 /* Info for last mouse motion */
  51 static COORD movement_pos;
  52 static DWORD movement_time;
  53
  54 /* from keyboard.c */
  55 extern void reinvoke_input_signal (void);
  56
  57 /* from w32console.c */
  58 extern int w32_use_full_screen_buffer;
  59
  60 /* from w32fns.c */
  61 extern Lisp_Object Vw32_alt_is_meta;
  62 extern unsigned int map_keypad_keys (unsigned int, unsigned int);
  63
  64 /* from w32term */
  65 extern Lisp_Object Vw32_capslock_is_shiftlock;
  66 extern Lisp_Object Vw32_enable_caps_lock;
  67 extern Lisp_Object Vw32_enable_num_lock;
  68 extern Lisp_Object Vw32_recognize_altgr;
  69 extern Lisp_Object Vw32_pass_lwindow_to_system;
  70 extern Lisp_Object Vw32_pass_rwindow_to_system;
  71 extern Lisp_Object Vw32_phantom_key_code;
  72 extern Lisp_Object Vw32_lwindow_modifier;
  73 extern Lisp_Object Vw32_rwindow_modifier;
  74 extern Lisp_Object Vw32_apps_modifier;
  75 extern Lisp_Object Vw32_scroll_lock_modifier;
  76 extern unsigned int w32_key_to_modifier (int key);
  77
  78 /* Event queue */
  79 #define EVENT_QUEUE_SIZE 50
  80 static INPUT_RECORD event_queue[EVENT_QUEUE_SIZE];
  81 static INPUT_RECORD *queue_ptr = event_queue, *queue_end = event_queue;
  82
  83 static int
  84 fill_queue (BOOL block)
  85 {
  86   BOOL rc;
  87   DWORD events_waiting;
  88
  89   if (queue_ptr < queue_end)
  90     return queue_end-queue_ptr;
  91
  92   if (!block)
  93     {
  94       /* Check to see if there are some events to read before we try
  95          because we can't block.  */
  96       if (!GetNumberOfConsoleInputEvents (keyboard_handle, &events_waiting))
  97         return -1;
  98       if (events_waiting == 0)
  99         return 0;
 100     }
 101
 102   rc = ReadConsoleInput (keyboard_handle, event_queue, EVENT_QUEUE_SIZE,
 103                          &events_waiting);
 104   if (!rc)
 105     return -1;
 106   queue_ptr = event_queue;
 107   queue_end = event_queue + events_waiting;
 108   return (int) events_waiting;
 109 }
 110
 111 /* In a generic, multi-frame world this should take a console handle
 112    and return the frame for it
 113
 114    Right now, there's only one frame so return it.  */
 115 static FRAME_PTR
 116 get_frame (void)
 117 {
 118   return SELECTED_FRAME ();
 119 }
 120
 121 /* Translate console modifiers to emacs modifiers.
 122    German keyboard support (Kai Morgan Zeise 2/18/95).  */
 123 int
 124 w32_kbd_mods_to_emacs (DWORD mods, WORD key)
 125 {
 126   int retval = 0;
 127
 128   /* If we recognize right-alt and left-ctrl as AltGr, and it has been
 129      pressed, first remove those modifiers.  */
 130   if (!NILP (Vw32_recognize_altgr)
 131       && (mods & (RIGHT_ALT_PRESSED | LEFT_CTRL_PRESSED))
 132       == (RIGHT_ALT_PRESSED | LEFT_CTRL_PRESSED))
 133     mods &= ~ (RIGHT_ALT_PRESSED | LEFT_CTRL_PRESSED);
 134
 135   if (mods & (RIGHT_ALT_PRESSED | LEFT_ALT_PRESSED))
 136     retval = ((NILP (Vw32_alt_is_meta)) ? alt_modifier : meta_modifier);
 137
 138   if (mods & (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED))
 139     {
 140       retval |= ctrl_modifier;
 141       if ((mods & (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED))
 142           == (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED))
 143         retval |= meta_modifier;
 144     }
 145
 146   if (mods & LEFT_WIN_PRESSED)
 147     retval |= w32_key_to_modifier (VK_LWIN);
 148   if (mods & RIGHT_WIN_PRESSED)
 149     retval |= w32_key_to_modifier (VK_RWIN);
 150   if (mods & APPS_PRESSED)
 151     retval |= w32_key_to_modifier (VK_APPS);
 152   if (mods & SCROLLLOCK_ON)
 153     retval |= w32_key_to_modifier (VK_SCROLL);
 154
 155   /* Just in case someone wanted the original behavior, make it
 156      optional by setting w32-capslock-is-shiftlock to t.  */
 157   if (NILP (Vw32_capslock_is_shiftlock)
 158       /* Keys that should _not_ be affected by CapsLock.  */
 159       && (    (key == VK_BACK)
 160            || (key == VK_TAB)
 161            || (key == VK_CLEAR)
 162            || (key == VK_RETURN)
 163            || (key == VK_ESCAPE)
 164            || ((key >= VK_SPACE) && (key <= VK_HELP))
 165            || ((key >= VK_NUMPAD0) && (key <= VK_F24))
 166            || ((key >= VK_NUMPAD_CLEAR) && (key <= VK_NUMPAD_DELETE))
 167          ))
 168     {
 169       /* Only consider shift state.  */
 170       if ((mods & SHIFT_PRESSED) != 0)
 171         retval |= shift_modifier;
 172     }
 173   else
 174     {
 175       /* Ignore CapsLock state if not enabled.  */
 176       if (NILP (Vw32_enable_caps_lock))
 177         mods &= ~CAPSLOCK_ON;
 178       if ((mods & (SHIFT_PRESSED | CAPSLOCK_ON)) != 0)
 179         retval |= shift_modifier;
 180     }
 181
 182   return retval;
 183 }
 184
 185 #if 0
 186 /* Return nonzero if the virtual key is a dead key.  */
 187 static int
 188 is_dead_key (int wparam)
 189 {
 190   unsigned int code = MapVirtualKey (wparam, 2);
 191
 192   /* Windows 95 returns 0x8000, NT returns 0x80000000.  */
 193   return (code & 0x80008000) ? 1 : 0;
 194 }
 195 #endif
 196
 197 /* The return code indicates key code size. */
 198 int
 199 w32_kbd_patch_key (KEY_EVENT_RECORD *event)
 200 {
 201   unsigned int key_code = event->wVirtualKeyCode;
 202   unsigned int mods = event->dwControlKeyState;
 203   BYTE keystate[256];
 204   static BYTE ansi_code[4];
 205   static int isdead = 0;
 206
 207   if (isdead == 2)
 208     {
 209       event->uChar.AsciiChar = ansi_code[2];
 210       isdead = 0;
 211       return 1;
 212     }
 213   if (event->uChar.AsciiChar != 0)
 214     return 1;
 215
 216   memset (keystate, 0, sizeof (keystate));
 217   keystate[key_code] = 0x80;
 218   if (mods & SHIFT_PRESSED)
 219     keystate[VK_SHIFT] = 0x80;
 220   if (mods & CAPSLOCK_ON)
 221     keystate[VK_CAPITAL] = 1;
 222   /* If we recognize right-alt and left-ctrl as AltGr, set the key
 223      states accordingly before invoking ToAscii.  */
 224   if (!NILP (Vw32_recognize_altgr)
 225       && (mods & LEFT_CTRL_PRESSED) && (mods & RIGHT_ALT_PRESSED))
 226     {
 227       keystate[VK_CONTROL] = 0x80;
 228       keystate[VK_LCONTROL] = 0x80;
 229       keystate[VK_MENU] = 0x80;
 230       keystate[VK_RMENU] = 0x80;
 231     }
 232
 233 #if 0
 234   /* Because of an OS bug, ToAscii corrupts the stack when called to
 235      convert a dead key in console mode on NT4.  Unfortunately, trying
 236      to check for dead keys using MapVirtualKey doesn't work either -
 237      these functions apparently use internal information about keyboard
 238      layout which doesn't get properly updated in console programs when
 239      changing layout (though apparently it gets partly updated,
 240      otherwise ToAscii wouldn't crash).  */
 241   if (is_dead_key (event->wVirtualKeyCode))
 242     return 0;
 243 #endif
 244
 245   /* On NT, call ToUnicode instead and then convert to the current
 246      locale's default codepage.  */
 247   if (os_subtype == OS_NT)
 248     {
 249       WCHAR buf[128];
 250
 251       isdead = ToUnicode (event->wVirtualKeyCode, event->wVirtualScanCode,
 252                           keystate, buf, 128, 0);
 253       if (isdead > 0)
 254         {
 255           char cp[20];
 256           int cpId;
 257
 258           GetLocaleInfo (GetThreadLocale (),
 259                          LOCALE_IDEFAULTANSICODEPAGE, cp, 20);
 260           cpId = atoi (cp);
 261           isdead = WideCharToMultiByte (cpId, 0, buf, isdead,
 262                                         ansi_code, 4, NULL, NULL);
 263         }
 264       else
 265         isdead = 0;
 266     }
 267   else
 268     {
 269       isdead = ToAscii (event->wVirtualKeyCode, event->wVirtualScanCode,
 270                         keystate, (LPWORD) ansi_code, 0);
 271     }
 272
 273   if (isdead == 0)
 274     return 0;
 275   event->uChar.AsciiChar = ansi_code[0];
 276   return isdead;
 277 }
 278
 279
 280 extern char *lispy_function_keys[];
 281
 282 static int faked_key = 0;
 283
 284 /* return code -1 means that event_queue_ptr won't be incremented.
 285    In other word, this event makes two key codes.   (by himi)       */
 286 int
 287 key_event (KEY_EVENT_RECORD *event, struct input_event *emacs_ev, int *isdead)
 288 {
 289   static int mod_key_state = 0;
 290   int wParam;
 291
 292   *isdead = 0;
 293
 294   /* Skip key-up events.  */
 295   if (!event->bKeyDown)
 296     {
 297       switch (event->wVirtualKeyCode)
 298         {
 299         case VK_LWIN:
 300           mod_key_state &= ~LEFT_WIN_PRESSED;
 301           break;
 302         case VK_RWIN:
 303           mod_key_state &= ~RIGHT_WIN_PRESSED;
 304           break;
 305         case VK_APPS:
 306           mod_key_state &= ~APPS_PRESSED;
 307           break;
 308         }
 309       return 0;
 310     }
 311
 312   /* Ignore keystrokes we fake ourself; see below.  */
 313   if (faked_key == event->wVirtualKeyCode)
 314     {
 315       faked_key = 0;
 316       return 0;
 317     }
 318
 319   /* To make it easier to debug this code, ignore modifier keys!  */
 320   switch (event->wVirtualKeyCode)
 321     {
 322     case VK_LWIN:
 323       if (NILP (Vw32_pass_lwindow_to_system))
 324         {
 325           /* Prevent system from acting on keyup (which opens the Start
 326              menu if no other key was pressed) by simulating a press of
 327              Space which we will ignore.  */
 328           if ((mod_key_state & LEFT_WIN_PRESSED) == 0)
 329             {
 330               if (NUMBERP (Vw32_phantom_key_code))
 331                 faked_key = XUINT (Vw32_phantom_key_code) & 255;
 332               else
 333                 faked_key = VK_SPACE;
 334               keybd_event (faked_key, (BYTE) MapVirtualKey (faked_key, 0), 0, 0);
 335             }
 336         }
 337       mod_key_state |= LEFT_WIN_PRESSED;
 338       if (!NILP (Vw32_lwindow_modifier))
 339         return 0;
 340       break;
 341     case VK_RWIN:
 342       if (NILP (Vw32_pass_rwindow_to_system))
 343         {
 344           if ((mod_key_state & RIGHT_WIN_PRESSED) == 0)
 345             {
 346               if (NUMBERP (Vw32_phantom_key_code))
 347                 faked_key = XUINT (Vw32_phantom_key_code) & 255;
 348               else
 349                 faked_key = VK_SPACE;
 350               keybd_event (faked_key, (BYTE) MapVirtualKey (faked_key, 0), 0, 0);
 351             }
 352         }
 353       mod_key_state |= RIGHT_WIN_PRESSED;
 354       if (!NILP (Vw32_rwindow_modifier))
 355         return 0;
 356       break;
 357     case VK_APPS:
 358       mod_key_state |= APPS_PRESSED;
 359       if (!NILP (Vw32_apps_modifier))
 360         return 0;
 361       break;
 362     case VK_CAPITAL:
 363       /* Decide whether to treat as modifier or function key.  */
 364       if (NILP (Vw32_enable_caps_lock))
 365         goto disable_lock_key;
 366       return 0;
 367     case VK_NUMLOCK:
 368       /* Decide whether to treat as modifier or function key.  */
 369       if (NILP (Vw32_enable_num_lock))
 370         goto disable_lock_key;
 371       return 0;
 372     case VK_SCROLL:
 373       /* Decide whether to treat as modifier or function key.  */
 374       if (NILP (Vw32_scroll_lock_modifier))
 375         goto disable_lock_key;
 376       return 0;
 377     disable_lock_key:
 378       /* Ensure the appropriate lock key state is off (and the
 379          indicator light as well).  */
 380       wParam = event->wVirtualKeyCode;
 381       if (GetAsyncKeyState (wParam) & 0x8000)
 382         {
 383           /* Fake another press of the relevant key.  Apparently, this
 384              really is the only way to turn off the indicator.  */
 385           faked_key = wParam;
 386           keybd_event ((BYTE) wParam, (BYTE) MapVirtualKey (wParam, 0),
 387                        KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0);
 388           keybd_event ((BYTE) wParam, (BYTE) MapVirtualKey (wParam, 0),
 389                        KEYEVENTF_EXTENDEDKEY | 0, 0);
 390           keybd_event ((BYTE) wParam, (BYTE) MapVirtualKey (wParam, 0),
 391                        KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0);
 392         }
 393       break;
 394     case VK_MENU:
 395     case VK_CONTROL:
 396     case VK_SHIFT:
 397       return 0;
 398     case VK_CANCEL:
 399       /* Windows maps Ctrl-Pause (aka Ctrl-Break) into VK_CANCEL,
 400          which is confusing for purposes of key binding; convert
 401          VK_CANCEL events into VK_PAUSE events.  */
 402       event->wVirtualKeyCode = VK_PAUSE;
 403       break;
 404     case VK_PAUSE:
 405       /* Windows maps Ctrl-NumLock into VK_PAUSE, which is confusing
 406          for purposes of key binding; convert these back into
 407          VK_NUMLOCK events, at least when we want to see NumLock key
 408          presses.  (Note that there is never any possibility that
 409          VK_PAUSE with Ctrl really is C-Pause as per above.)  */
 410       if (NILP (Vw32_enable_num_lock)
 411           && (event->dwControlKeyState
 412               & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED)) != 0)
 413         event->wVirtualKeyCode = VK_NUMLOCK;
 414       break;
 415     }
 416
 417   /* Recognize state of Windows and Apps keys.  */
 418   event->dwControlKeyState |= mod_key_state;
 419
 420   /* Distinguish numeric keypad keys from extended keys.  */
 421   event->wVirtualKeyCode =
 422     map_keypad_keys (event->wVirtualKeyCode,
 423                      (event->dwControlKeyState & ENHANCED_KEY));
 424
 425   if (lispy_function_keys[event->wVirtualKeyCode] == 0)
 426     {
 427       emacs_ev->kind = ASCII_KEYSTROKE_EVENT;
 428
 429       if (!NILP (Vw32_recognize_altgr)
 430           && (event->dwControlKeyState & LEFT_CTRL_PRESSED)
 431           && (event->dwControlKeyState & RIGHT_ALT_PRESSED))
 432         {
 433           /* Don't try to interpret AltGr key chords; ToAscii seems not
 434              to process them correctly.  */
 435         }
 436       /* Handle key chords including any modifiers other than shift
 437          directly, in order to preserve as much modifier information as
 438          possible.  */
 439       else if (event->dwControlKeyState
 440                & (  RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED
 441                   | RIGHT_ALT_PRESSED | LEFT_ALT_PRESSED
 442                   | (!NILP (Vw32_lwindow_modifier) ? LEFT_WIN_PRESSED : 0)
 443                   | (!NILP (Vw32_rwindow_modifier) ? RIGHT_WIN_PRESSED : 0)
 444                   | (!NILP (Vw32_apps_modifier) ? APPS_PRESSED : 0)
 445                   | (!NILP (Vw32_scroll_lock_modifier) ? SCROLLLOCK_ON : 0)))
 446         {
 447           /* Don't translate modified alphabetic keystrokes, so the user
 448              doesn't need to constantly switch layout to type control or
 449              meta keystrokes when the normal layout translates
 450              alphabetic characters to non-ascii characters.  */
 451           if ('A' <= event->wVirtualKeyCode && event->wVirtualKeyCode <= 'Z')
 452             {
 453               event->uChar.AsciiChar = event->wVirtualKeyCode;
 454               if ((event->dwControlKeyState & SHIFT_PRESSED) == 0)
 455                 event->uChar.AsciiChar += ('a' - 'A');
 456             }
 457           /* Try to handle unrecognized keystrokes by determining the
 458              base character (ie. translating the base key plus shift
 459              modifier).  */
 460           else if (event->uChar.AsciiChar == 0)
 461             w32_kbd_patch_key (event);
 462         }
 463       if (event->uChar.AsciiChar == 0)
 464         return 0;
 465       emacs_ev->code = event->uChar.AsciiChar;
 466     }
 467   else
 468     {
 469       emacs_ev->kind = NON_ASCII_KEYSTROKE_EVENT;
 470       emacs_ev->code = event->wVirtualKeyCode;
 471     }
 472
 473   XSETFRAME (emacs_ev->frame_or_window, get_frame ());
 474   emacs_ev->modifiers = w32_kbd_mods_to_emacs (event->dwControlKeyState,
 475                                                event->wVirtualKeyCode);
 476   emacs_ev->timestamp = GetTickCount ();
 477   return 1;
 478 }
 479
 480 int
 481 w32_console_toggle_lock_key (int vk_code, Lisp_Object new_state)
 482 {
 483   int cur_state = (GetKeyState (vk_code) & 1);
 484
 485   if (NILP (new_state)
 486       || (NUMBERP (new_state)
 487           && ((XUINT (new_state)) & 1) != cur_state))
 488     {
 489       faked_key = vk_code;
 490
 491       keybd_event ((BYTE) vk_code,
 492                    (BYTE) MapVirtualKey (vk_code, 0),
 493                    KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0);
 494       keybd_event ((BYTE) vk_code,
 495                    (BYTE) MapVirtualKey (vk_code, 0),
 496                    KEYEVENTF_EXTENDEDKEY | 0, 0);
 497       keybd_event ((BYTE) vk_code,
 498                    (BYTE) MapVirtualKey (vk_code, 0),
 499                    KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0);
 500       cur_state = !cur_state;
 501     }
 502
 503   return cur_state;
 504 }
 505
 506 /* Mouse position hook.  */
 507 void
 508 w32_console_mouse_position (FRAME_PTR *f,
 509                             int insist,
 510                             Lisp_Object *bar_window,
 511                             enum scroll_bar_part *part,
 512                             Lisp_Object *x,
 513                             Lisp_Object *y,
 514                             unsigned long *time)
 515 {
 516   BLOCK_INPUT;
 517
 518   insist = insist;
 519
 520   *f = get_frame ();
 521   *bar_window = Qnil;
 522   *part = 0;
 523   SELECTED_FRAME ()->mouse_moved = 0;
 524
 525   XSETINT(*x, movement_pos.X);
 526   XSETINT(*y, movement_pos.Y);
 527   *time = movement_time;
 528
 529   UNBLOCK_INPUT;
 530 }
 531
 532 /* Remember mouse motion and notify emacs.  */
 533 static void
 534 mouse_moved_to (int x, int y)
 535 {
 536   /* If we're in the same place, ignore it */
 537   if (x != movement_pos.X || y != movement_pos.Y)
 538     {
 539       SELECTED_FRAME ()->mouse_moved = 1;
 540       movement_pos.X = x;
 541       movement_pos.Y = y;
 542       movement_time = GetTickCount ();
 543     }
 544 }
 545
 546 /* Consoles return button bits in a strange order:
 547      least significant - Leftmost button
 548      next - Rightmost button
 549      next - Leftmost+1
 550      next - Leftmost+2...
 551
 552    Assume emacs likes three button mice, so
 553      Left == 0
 554      Middle == 1
 555      Right == 2
 556    Others increase from there.  */
 557
 558 #define NUM_TRANSLATED_MOUSE_BUTTONS 3
 559 static int emacs_button_translation[NUM_TRANSLATED_MOUSE_BUTTONS] =
 560 {
 561   0, 2, 1
 562 };
 563
 564 static int
 565 do_mouse_event (MOUSE_EVENT_RECORD *event,
 566                 struct input_event *emacs_ev)
 567 {
 568   static DWORD button_state = 0;
 569   DWORD but_change, mask;
 570   int i;
 571
 572   if (event->dwEventFlags == MOUSE_MOVED)
 573     {
 574       /* For movement events we just note that the mouse has moved
 575          so that emacs will generate drag events.  */
 576       mouse_moved_to (event->dwMousePosition.X, event->dwMousePosition.Y);
 577       return 0;
 578     }
 579
 580   /* It looks like the console code sends us a mouse event with
 581      dwButtonState == 0 when a window is activated.  Ignore this case.  */
 582   if (event->dwButtonState == button_state)
 583     return 0;
 584
 585   emacs_ev->kind = MOUSE_CLICK_EVENT;
 586
 587   /* Find out what button has changed state since the last button event.  */
 588   but_change = button_state ^ event->dwButtonState;
 589   mask = 1;
 590   for (i = 0; mask; i++, mask <<= 1)
 591     if (but_change & mask)
 592       {
 593         if (i < NUM_TRANSLATED_MOUSE_BUTTONS)
 594           emacs_ev->code = emacs_button_translation[i];
 595         else
 596           emacs_ev->code = i;
 597         break;
 598       }
 599
 600   button_state = event->dwButtonState;
 601   emacs_ev->timestamp = GetTickCount ();
 602   emacs_ev->modifiers = w32_kbd_mods_to_emacs (event->dwControlKeyState, 0) |
 603     ((event->dwButtonState & mask) ? down_modifier : up_modifier);
 604
 605   XSETFASTINT (emacs_ev->x, event->dwMousePosition.X);
 606   XSETFASTINT (emacs_ev->y, event->dwMousePosition.Y);
 607 /* for Mule 2.2 (Based on Emacs 19.28 */
 608 #ifdef MULE
 609   XSET (emacs_ev->frame_or_window, Lisp_Frame, get_frame ());
 610 #else
 611   XSETFRAME (emacs_ev->frame_or_window, get_frame ());
 612 #endif
 613
 614   return 1;
 615 }
 616
 617 static void
 618 resize_event (WINDOW_BUFFER_SIZE_RECORD *event)
 619 {
 620   FRAME_PTR f = get_frame ();
 621
 622   change_frame_size (f, event->dwSize.Y, event->dwSize.X, 0, 1, 0);
 623   SET_FRAME_GARBAGED (f);
 624 }
 625
 626 static void
 627 maybe_generate_resize_event ()
 628 {
 629   CONSOLE_SCREEN_BUFFER_INFO info;
 630   FRAME_PTR f = get_frame ();
 631
 632   GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &info);
 633
 634   /* It is okay to call this unconditionally, since it will do nothing
 635      if the size hasn't actually changed.  */
 636   change_frame_size (f,
 637                      1 + info.srWindow.Bottom - info.srWindow.Top,
 638                      1 + info.srWindow.Right - info.srWindow.Left,
 639                      0, 0, 0);
 640 }
 641
 642 int
 643 w32_console_read_socket (struct terminal *terminal,
 644                          int expected,
 645                          struct input_event *hold_quit)
 646 {
 647   BOOL no_events = TRUE;
 648   int nev, ret = 0, add;
 649   int isdead;
 650
 651   if (interrupt_input_blocked)
 652     {
 653       interrupt_input_pending = 1;
 654       return -1;
 655     }
 656
 657   interrupt_input_pending = 0;
 658   BLOCK_INPUT;
 659
 660   for (;;)
 661     {
 662       nev = fill_queue (0);
 663       if (nev <= 0)
 664         {
 665           /* If nev == -1, there was some kind of error
 666              If nev == 0 then waitp must be zero and no events were available
 667              so return.  */
 668           UNBLOCK_INPUT;
 669           return nev;
 670         }
 671
 672       while (nev > 0)
 673         {
 674           struct input_event inev;
 675
 676           EVENT_INIT (inev);
 677           inev.kind = NO_EVENT;
 678           inev.arg = Qnil;
 679
 680           switch (queue_ptr->EventType)
 681             {
 682             case KEY_EVENT:
 683               add = key_event (&queue_ptr->Event.KeyEvent, &inev, &isdead);
 684               if (add == -1) /* 95.7.25 by himi */
 685                 {
 686                   queue_ptr--;
 687                   add = 1;
 688                 }
 689               if (add)
 690                 kbd_buffer_store_event_hold (&inev, hold_quit);
 691               break;
 692
 693             case MOUSE_EVENT:
 694               add = do_mouse_event (&queue_ptr->Event.MouseEvent, &inev);
 695               if (add)
 696                 kbd_buffer_store_event_hold (&inev, hold_quit);
 697               break;
 698
 699             case WINDOW_BUFFER_SIZE_EVENT:
 700               if (w32_use_full_screen_buffer)
 701                 resize_event (&queue_ptr->Event.WindowBufferSizeEvent);
 702               break;
 703
 704             case MENU_EVENT:
 705             case FOCUS_EVENT:
 706               /* Internal event types, ignored. */
 707               break;
 708             }
 709
 710           queue_ptr++;
 711           nev--;
 712         }
 713
 714       if (ret > 0 || expected == 0)
 715         break;
 716     }
 717
 718   /* We don't get told about changes in the window size (only the buffer
 719      size, which we no longer care about), so we have to check it
 720      periodically.  */
 721   if (!w32_use_full_screen_buffer)
 722     maybe_generate_resize_event ();
 723
 724   UNBLOCK_INPUT;
 725   return ret;
 726 }
 727
 728 /* arch-tag: 0bcb39b7-d085-4b85-9070-6750e8c03047
 729    (do not change this comment) */