Mercurial > emacs
view src/w32inevt.c @ 109986:d9cfc4f455fc
merge trunk
author | Kenichi Handa <handa@m17n.org> |
---|---|
date | Wed, 25 Aug 2010 15:15:12 +0900 |
parents | f8660b83cdbf |
children | 55c8c3ca3d48 |
line wrap: on
line source
/* Input event support for Emacs on the Microsoft W32 API. Copyright (C) 1992, 1993, 1995, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. This file is part of GNU Emacs. GNU Emacs is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. GNU Emacs is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */ /* Drew Bliss 01-Oct-93 Adapted from ntkbd.c by Tim Fleehart */ #ifdef HAVE_CONFIG_H #include <config.h> #endif #include <stdlib.h> #include <stdio.h> #include <windows.h> #include <setjmp.h> #ifndef MOUSE_MOVED #define MOUSE_MOVED 1 #endif #include "lisp.h" #include "keyboard.h" #include "frame.h" #include "dispextern.h" #include "blockinput.h" #include "termhooks.h" #include "w32heap.h" #include "w32term.h" /* stdin, from ntterm */ extern HANDLE keyboard_handle; /* Info for last mouse motion */ static COORD movement_pos; static DWORD movement_time; /* from keyboard.c */ extern void reinvoke_input_signal (void); /* from w32console.c */ extern int w32_use_full_screen_buffer; /* from w32fns.c */ extern Lisp_Object Vw32_alt_is_meta; extern unsigned int map_keypad_keys (unsigned int, unsigned int); /* from w32term */ extern Lisp_Object Vw32_capslock_is_shiftlock; extern Lisp_Object Vw32_enable_caps_lock; extern Lisp_Object Vw32_enable_num_lock; extern Lisp_Object Vw32_recognize_altgr; extern Lisp_Object Vw32_pass_lwindow_to_system; extern Lisp_Object Vw32_pass_rwindow_to_system; extern Lisp_Object Vw32_phantom_key_code; extern Lisp_Object Vw32_lwindow_modifier; extern Lisp_Object Vw32_rwindow_modifier; extern Lisp_Object Vw32_apps_modifier; extern Lisp_Object Vw32_scroll_lock_modifier; extern unsigned int w32_key_to_modifier (int key); /* Event queue */ #define EVENT_QUEUE_SIZE 50 static INPUT_RECORD event_queue[EVENT_QUEUE_SIZE]; static INPUT_RECORD *queue_ptr = event_queue, *queue_end = event_queue; /* Temporarily store lead byte of DBCS input sequences. */ static char dbcs_lead = 0; static int fill_queue (BOOL block) { BOOL rc; DWORD events_waiting; if (queue_ptr < queue_end) return queue_end-queue_ptr; if (!block) { /* Check to see if there are some events to read before we try because we can't block. */ if (!GetNumberOfConsoleInputEvents (keyboard_handle, &events_waiting)) return -1; if (events_waiting == 0) return 0; } rc = ReadConsoleInput (keyboard_handle, event_queue, EVENT_QUEUE_SIZE, &events_waiting); if (!rc) return -1; queue_ptr = event_queue; queue_end = event_queue + events_waiting; return (int) events_waiting; } /* In a generic, multi-frame world this should take a console handle and return the frame for it Right now, there's only one frame so return it. */ static FRAME_PTR get_frame (void) { return SELECTED_FRAME (); } /* Translate console modifiers to emacs modifiers. German keyboard support (Kai Morgan Zeise 2/18/95). */ int w32_kbd_mods_to_emacs (DWORD mods, WORD key) { int retval = 0; /* If we recognize right-alt and left-ctrl as AltGr, and it has been pressed, first remove those modifiers. */ if (!NILP (Vw32_recognize_altgr) && (mods & (RIGHT_ALT_PRESSED | LEFT_CTRL_PRESSED)) == (RIGHT_ALT_PRESSED | LEFT_CTRL_PRESSED)) mods &= ~ (RIGHT_ALT_PRESSED | LEFT_CTRL_PRESSED); if (mods & (RIGHT_ALT_PRESSED | LEFT_ALT_PRESSED)) retval = ((NILP (Vw32_alt_is_meta)) ? alt_modifier : meta_modifier); if (mods & (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED)) { retval |= ctrl_modifier; if ((mods & (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED)) == (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED)) retval |= meta_modifier; } if (mods & LEFT_WIN_PRESSED) retval |= w32_key_to_modifier (VK_LWIN); if (mods & RIGHT_WIN_PRESSED) retval |= w32_key_to_modifier (VK_RWIN); if (mods & APPS_PRESSED) retval |= w32_key_to_modifier (VK_APPS); if (mods & SCROLLLOCK_ON) retval |= w32_key_to_modifier (VK_SCROLL); /* Just in case someone wanted the original behavior, make it optional by setting w32-capslock-is-shiftlock to t. */ if (NILP (Vw32_capslock_is_shiftlock) /* Keys that should _not_ be affected by CapsLock. */ && ( (key == VK_BACK) || (key == VK_TAB) || (key == VK_CLEAR) || (key == VK_RETURN) || (key == VK_ESCAPE) || ((key >= VK_SPACE) && (key <= VK_HELP)) || ((key >= VK_NUMPAD0) && (key <= VK_F24)) || ((key >= VK_NUMPAD_CLEAR) && (key <= VK_NUMPAD_DELETE)) )) { /* Only consider shift state. */ if ((mods & SHIFT_PRESSED) != 0) retval |= shift_modifier; } else { /* Ignore CapsLock state if not enabled. */ if (NILP (Vw32_enable_caps_lock)) mods &= ~CAPSLOCK_ON; if ((mods & (SHIFT_PRESSED | CAPSLOCK_ON)) != 0) retval |= shift_modifier; } return retval; } #if 0 /* Return nonzero if the virtual key is a dead key. */ static int is_dead_key (int wparam) { unsigned int code = MapVirtualKey (wparam, 2); /* Windows 95 returns 0x8000, NT returns 0x80000000. */ return (code & 0x80008000) ? 1 : 0; } #endif /* The return code indicates key code size. */ int w32_kbd_patch_key (KEY_EVENT_RECORD *event) { unsigned int key_code = event->wVirtualKeyCode; unsigned int mods = event->dwControlKeyState; BYTE keystate[256]; static BYTE ansi_code[4]; static int isdead = 0; if (isdead == 2) { event->uChar.AsciiChar = ansi_code[2]; isdead = 0; return 1; } if (event->uChar.AsciiChar != 0) return 1; memset (keystate, 0, sizeof (keystate)); keystate[key_code] = 0x80; if (mods & SHIFT_PRESSED) keystate[VK_SHIFT] = 0x80; if (mods & CAPSLOCK_ON) keystate[VK_CAPITAL] = 1; /* If we recognize right-alt and left-ctrl as AltGr, set the key states accordingly before invoking ToAscii. */ if (!NILP (Vw32_recognize_altgr) && (mods & LEFT_CTRL_PRESSED) && (mods & RIGHT_ALT_PRESSED)) { keystate[VK_CONTROL] = 0x80; keystate[VK_LCONTROL] = 0x80; keystate[VK_MENU] = 0x80; keystate[VK_RMENU] = 0x80; } #if 0 /* Because of an OS bug, ToAscii corrupts the stack when called to convert a dead key in console mode on NT4. Unfortunately, trying to check for dead keys using MapVirtualKey doesn't work either - these functions apparently use internal information about keyboard layout which doesn't get properly updated in console programs when changing layout (though apparently it gets partly updated, otherwise ToAscii wouldn't crash). */ if (is_dead_key (event->wVirtualKeyCode)) return 0; #endif /* On NT, call ToUnicode instead and then convert to the current locale's default codepage. */ if (os_subtype == OS_NT) { WCHAR buf[128]; isdead = ToUnicode (event->wVirtualKeyCode, event->wVirtualScanCode, keystate, buf, 128, 0); if (isdead > 0) { char cp[20]; int cpId; event->uChar.UnicodeChar = buf[isdead - 1]; GetLocaleInfo (GetThreadLocale (), LOCALE_IDEFAULTANSICODEPAGE, cp, 20); cpId = atoi (cp); isdead = WideCharToMultiByte (cpId, 0, buf, isdead, ansi_code, 4, NULL, NULL); } else isdead = 0; } else { isdead = ToAscii (event->wVirtualKeyCode, event->wVirtualScanCode, keystate, (LPWORD) ansi_code, 0); } if (isdead == 0) return 0; event->uChar.AsciiChar = ansi_code[0]; return isdead; } extern char *lispy_function_keys[]; static int faked_key = 0; /* return code -1 means that event_queue_ptr won't be incremented. In other word, this event makes two key codes. (by himi) */ int key_event (KEY_EVENT_RECORD *event, struct input_event *emacs_ev, int *isdead) { static int mod_key_state = 0; int wParam; *isdead = 0; /* Skip key-up events. */ if (!event->bKeyDown) { switch (event->wVirtualKeyCode) { case VK_LWIN: mod_key_state &= ~LEFT_WIN_PRESSED; break; case VK_RWIN: mod_key_state &= ~RIGHT_WIN_PRESSED; break; case VK_APPS: mod_key_state &= ~APPS_PRESSED; break; } return 0; } /* Ignore keystrokes we fake ourself; see below. */ if (faked_key == event->wVirtualKeyCode) { faked_key = 0; return 0; } /* To make it easier to debug this code, ignore modifier keys! */ switch (event->wVirtualKeyCode) { case VK_LWIN: if (NILP (Vw32_pass_lwindow_to_system)) { /* Prevent system from acting on keyup (which opens the Start menu if no other key was pressed) by simulating a press of Space which we will ignore. */ if ((mod_key_state & LEFT_WIN_PRESSED) == 0) { if (NUMBERP (Vw32_phantom_key_code)) faked_key = XUINT (Vw32_phantom_key_code) & 255; else faked_key = VK_SPACE; keybd_event (faked_key, (BYTE) MapVirtualKey (faked_key, 0), 0, 0); } } mod_key_state |= LEFT_WIN_PRESSED; if (!NILP (Vw32_lwindow_modifier)) return 0; break; case VK_RWIN: if (NILP (Vw32_pass_rwindow_to_system)) { if ((mod_key_state & RIGHT_WIN_PRESSED) == 0) { if (NUMBERP (Vw32_phantom_key_code)) faked_key = XUINT (Vw32_phantom_key_code) & 255; else faked_key = VK_SPACE; keybd_event (faked_key, (BYTE) MapVirtualKey (faked_key, 0), 0, 0); } } mod_key_state |= RIGHT_WIN_PRESSED; if (!NILP (Vw32_rwindow_modifier)) return 0; break; case VK_APPS: mod_key_state |= APPS_PRESSED; if (!NILP (Vw32_apps_modifier)) return 0; break; case VK_CAPITAL: /* Decide whether to treat as modifier or function key. */ if (NILP (Vw32_enable_caps_lock)) goto disable_lock_key; return 0; case VK_NUMLOCK: /* Decide whether to treat as modifier or function key. */ if (NILP (Vw32_enable_num_lock)) goto disable_lock_key; return 0; case VK_SCROLL: /* Decide whether to treat as modifier or function key. */ if (NILP (Vw32_scroll_lock_modifier)) goto disable_lock_key; return 0; disable_lock_key: /* Ensure the appropriate lock key state is off (and the indicator light as well). */ wParam = event->wVirtualKeyCode; if (GetAsyncKeyState (wParam) & 0x8000) { /* Fake another press of the relevant key. Apparently, this really is the only way to turn off the indicator. */ faked_key = wParam; keybd_event ((BYTE) wParam, (BYTE) MapVirtualKey (wParam, 0), KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0); keybd_event ((BYTE) wParam, (BYTE) MapVirtualKey (wParam, 0), KEYEVENTF_EXTENDEDKEY | 0, 0); keybd_event ((BYTE) wParam, (BYTE) MapVirtualKey (wParam, 0), KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0); } break; case VK_MENU: case VK_CONTROL: case VK_SHIFT: return 0; case VK_CANCEL: /* Windows maps Ctrl-Pause (aka Ctrl-Break) into VK_CANCEL, which is confusing for purposes of key binding; convert VK_CANCEL events into VK_PAUSE events. */ event->wVirtualKeyCode = VK_PAUSE; break; case VK_PAUSE: /* Windows maps Ctrl-NumLock into VK_PAUSE, which is confusing for purposes of key binding; convert these back into VK_NUMLOCK events, at least when we want to see NumLock key presses. (Note that there is never any possibility that VK_PAUSE with Ctrl really is C-Pause as per above.) */ if (NILP (Vw32_enable_num_lock) && (event->dwControlKeyState & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED)) != 0) event->wVirtualKeyCode = VK_NUMLOCK; break; } /* Recognize state of Windows and Apps keys. */ event->dwControlKeyState |= mod_key_state; /* Distinguish numeric keypad keys from extended keys. */ event->wVirtualKeyCode = map_keypad_keys (event->wVirtualKeyCode, (event->dwControlKeyState & ENHANCED_KEY)); if (lispy_function_keys[event->wVirtualKeyCode] == 0) { if (!NILP (Vw32_recognize_altgr) && (event->dwControlKeyState & LEFT_CTRL_PRESSED) && (event->dwControlKeyState & RIGHT_ALT_PRESSED)) { /* Don't try to interpret AltGr key chords; ToAscii seems not to process them correctly. */ } /* Handle key chords including any modifiers other than shift directly, in order to preserve as much modifier information as possible. */ else if (event->dwControlKeyState & ( RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED | RIGHT_ALT_PRESSED | LEFT_ALT_PRESSED | (!NILP (Vw32_lwindow_modifier) ? LEFT_WIN_PRESSED : 0) | (!NILP (Vw32_rwindow_modifier) ? RIGHT_WIN_PRESSED : 0) | (!NILP (Vw32_apps_modifier) ? APPS_PRESSED : 0) | (!NILP (Vw32_scroll_lock_modifier) ? SCROLLLOCK_ON : 0))) { /* Don't translate modified alphabetic keystrokes, so the user doesn't need to constantly switch layout to type control or meta keystrokes when the normal layout translates alphabetic characters to non-ascii characters. */ if ('A' <= event->wVirtualKeyCode && event->wVirtualKeyCode <= 'Z') { event->uChar.AsciiChar = event->wVirtualKeyCode; if ((event->dwControlKeyState & SHIFT_PRESSED) == 0) event->uChar.AsciiChar += ('a' - 'A'); } /* Try to handle unrecognized keystrokes by determining the base character (ie. translating the base key plus shift modifier). */ else if (event->uChar.AsciiChar == 0) w32_kbd_patch_key (event); } if (event->uChar.AsciiChar == 0) { emacs_ev->kind = NO_EVENT; return 0; } else if (event->uChar.AsciiChar > 0) { emacs_ev->kind = ASCII_KEYSTROKE_EVENT; emacs_ev->code = event->uChar.AsciiChar; } else if (event->uChar.UnicodeChar > 0) { emacs_ev->kind = MULTIBYTE_CHAR_KEYSTROKE_EVENT; emacs_ev->code = event->uChar.UnicodeChar; } else { /* Fallback for non-Unicode versions of Windows. */ wchar_t code; char dbcs[2]; char cp[20]; int cpId; /* Get the codepage to interpret this key with. */ GetLocaleInfo (GetThreadLocale (), LOCALE_IDEFAULTANSICODEPAGE, cp, 20); cpId = atoi (cp); dbcs[0] = dbcs_lead; dbcs[1] = event->uChar.AsciiChar; if (dbcs_lead) { dbcs_lead = 0; if (!MultiByteToWideChar (cpId, 0, dbcs, 2, &code, 1)) { /* Garbage */ DebPrint (("Invalid DBCS sequence: %d %d\n", dbcs[0], dbcs[1])); emacs_ev->kind = NO_EVENT; } } else if (IsDBCSLeadByteEx (cpId, dbcs[1])) { dbcs_lead = dbcs[1]; emacs_ev->kind = NO_EVENT; } else { if (!MultiByteToWideChar (cpId, 0, &dbcs[1], 1, &code, 1)) { /* Garbage */ DebPrint (("Invalid character: %d\n", dbcs[1])); emacs_ev->kind = NO_EVENT; } } emacs_ev->kind = MULTIBYTE_CHAR_KEYSTROKE_EVENT; emacs_ev->code = code; } } else { emacs_ev->kind = NON_ASCII_KEYSTROKE_EVENT; emacs_ev->code = event->wVirtualKeyCode; } XSETFRAME (emacs_ev->frame_or_window, get_frame ()); emacs_ev->modifiers = w32_kbd_mods_to_emacs (event->dwControlKeyState, event->wVirtualKeyCode); emacs_ev->timestamp = GetTickCount (); return 1; } int w32_console_toggle_lock_key (int vk_code, Lisp_Object new_state) { int cur_state = (GetKeyState (vk_code) & 1); if (NILP (new_state) || (NUMBERP (new_state) && ((XUINT (new_state)) & 1) != cur_state)) { faked_key = vk_code; keybd_event ((BYTE) vk_code, (BYTE) MapVirtualKey (vk_code, 0), KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0); keybd_event ((BYTE) vk_code, (BYTE) MapVirtualKey (vk_code, 0), KEYEVENTF_EXTENDEDKEY | 0, 0); keybd_event ((BYTE) vk_code, (BYTE) MapVirtualKey (vk_code, 0), KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0); cur_state = !cur_state; } return cur_state; } /* Mouse position hook. */ void w32_console_mouse_position (FRAME_PTR *f, int insist, Lisp_Object *bar_window, enum scroll_bar_part *part, Lisp_Object *x, Lisp_Object *y, unsigned long *time) { BLOCK_INPUT; insist = insist; *f = get_frame (); *bar_window = Qnil; *part = 0; SELECTED_FRAME ()->mouse_moved = 0; XSETINT (*x, movement_pos.X); XSETINT (*y, movement_pos.Y); *time = movement_time; UNBLOCK_INPUT; } /* Remember mouse motion and notify emacs. */ static void mouse_moved_to (int x, int y) { /* If we're in the same place, ignore it */ if (x != movement_pos.X || y != movement_pos.Y) { SELECTED_FRAME ()->mouse_moved = 1; movement_pos.X = x; movement_pos.Y = y; movement_time = GetTickCount (); } } /* Consoles return button bits in a strange order: least significant - Leftmost button next - Rightmost button next - Leftmost+1 next - Leftmost+2... Assume emacs likes three button mice, so Left == 0 Middle == 1 Right == 2 Others increase from there. */ #define NUM_TRANSLATED_MOUSE_BUTTONS 3 static int emacs_button_translation[NUM_TRANSLATED_MOUSE_BUTTONS] = { 0, 2, 1 }; static int do_mouse_event (MOUSE_EVENT_RECORD *event, struct input_event *emacs_ev) { static DWORD button_state = 0; DWORD but_change, mask; int i; if (event->dwEventFlags == MOUSE_MOVED) { /* For movement events we just note that the mouse has moved so that emacs will generate drag events. */ mouse_moved_to (event->dwMousePosition.X, event->dwMousePosition.Y); return 0; } /* It looks like the console code sends us a mouse event with dwButtonState == 0 when a window is activated. Ignore this case. */ if (event->dwButtonState == button_state) return 0; emacs_ev->kind = MOUSE_CLICK_EVENT; /* Find out what button has changed state since the last button event. */ but_change = button_state ^ event->dwButtonState; mask = 1; for (i = 0; mask; i++, mask <<= 1) if (but_change & mask) { if (i < NUM_TRANSLATED_MOUSE_BUTTONS) emacs_ev->code = emacs_button_translation[i]; else emacs_ev->code = i; break; } button_state = event->dwButtonState; emacs_ev->timestamp = GetTickCount (); emacs_ev->modifiers = w32_kbd_mods_to_emacs (event->dwControlKeyState, 0) | ((event->dwButtonState & mask) ? down_modifier : up_modifier); XSETFASTINT (emacs_ev->x, event->dwMousePosition.X); XSETFASTINT (emacs_ev->y, event->dwMousePosition.Y); /* for Mule 2.2 (Based on Emacs 19.28 */ #ifdef MULE XSET (emacs_ev->frame_or_window, Lisp_Frame, get_frame ()); #else XSETFRAME (emacs_ev->frame_or_window, get_frame ()); #endif return 1; } static void resize_event (WINDOW_BUFFER_SIZE_RECORD *event) { FRAME_PTR f = get_frame (); change_frame_size (f, event->dwSize.Y, event->dwSize.X, 0, 1, 0); SET_FRAME_GARBAGED (f); } static void maybe_generate_resize_event (void) { CONSOLE_SCREEN_BUFFER_INFO info; FRAME_PTR f = get_frame (); GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &info); /* It is okay to call this unconditionally, since it will do nothing if the size hasn't actually changed. */ change_frame_size (f, 1 + info.srWindow.Bottom - info.srWindow.Top, 1 + info.srWindow.Right - info.srWindow.Left, 0, 0, 0); } int w32_console_read_socket (struct terminal *terminal, int expected, struct input_event *hold_quit) { BOOL no_events = TRUE; int nev, ret = 0, add; int isdead; if (interrupt_input_blocked) { interrupt_input_pending = 1; return -1; } interrupt_input_pending = 0; BLOCK_INPUT; for (;;) { nev = fill_queue (0); if (nev <= 0) { /* If nev == -1, there was some kind of error If nev == 0 then waitp must be zero and no events were available so return. */ UNBLOCK_INPUT; return nev; } while (nev > 0) { struct input_event inev; EVENT_INIT (inev); inev.kind = NO_EVENT; inev.arg = Qnil; switch (queue_ptr->EventType) { case KEY_EVENT: add = key_event (&queue_ptr->Event.KeyEvent, &inev, &isdead); if (add == -1) /* 95.7.25 by himi */ { queue_ptr--; add = 1; } if (add) kbd_buffer_store_event_hold (&inev, hold_quit); break; case MOUSE_EVENT: add = do_mouse_event (&queue_ptr->Event.MouseEvent, &inev); if (add) kbd_buffer_store_event_hold (&inev, hold_quit); break; case WINDOW_BUFFER_SIZE_EVENT: if (w32_use_full_screen_buffer) resize_event (&queue_ptr->Event.WindowBufferSizeEvent); break; case MENU_EVENT: case FOCUS_EVENT: /* Internal event types, ignored. */ break; } queue_ptr++; nev--; } if (ret > 0 || expected == 0) break; } /* We don't get told about changes in the window size (only the buffer size, which we no longer care about), so we have to check it periodically. */ if (!w32_use_full_screen_buffer) maybe_generate_resize_event (); UNBLOCK_INPUT; return ret; } /* arch-tag: 0bcb39b7-d085-4b85-9070-6750e8c03047 (do not change this comment) */