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; }
/* return code -1 means that event_queue_ptr won't be incremented. In other word, this event makes two key codes. (by himi) */ static 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, -1); } if (event->uChar.AsciiChar == 0) { emacs_ev->kind = NO_EVENT; return 0; } else if (event->uChar.AsciiChar > 0) { /* Pure ASCII characters < 128. */ emacs_ev->kind = ASCII_KEYSTROKE_EVENT; emacs_ev->code = event->uChar.AsciiChar; } else if (event->uChar.UnicodeChar > 0 && w32_console_unicode_input) { /* Unicode codepoint; only valid if we are using Unicode console input mode. */ emacs_ev->kind = MULTIBYTE_CHAR_KEYSTROKE_EVENT; emacs_ev->code = event->uChar.UnicodeChar; } else { /* Fallback handling of non-ASCII characters for non-Unicode versions of Windows, and for non-Unicode input on NT family of Windows. Only characters in the current console codepage are supported by this fallback. */ wchar_t code; char dbcs[2]; int cpId; /* Get the current console input codepage to interpret this key with. Note that the system defaults for the OEM codepage could have been changed by calling SetConsoleCP or w32-set-console-codepage, so using GetLocaleInfo to get LOCALE_IDEFAULTCODEPAGE is not TRT here. */ cpId = GetConsoleCP (); 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 { /* Function keys and other non-character keys. */ 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; }