-/* Input event support for Windows NT port of GNU Emacs.
+/* Input event support for Emacs on the Microsoft W32 API.
Copyright (C) 1992, 1993, 1995 Free Software Foundation, Inc.
This file is part of GNU Emacs.
/* from dispnew.c */
extern int change_frame_size (FRAME_PTR, int, int, int, int);
+/* from w32fns.c */
+extern Lisp_Object Vw32_alt_is_meta;
+
+/* from w32term */
+extern Lisp_Object Vw32_capslock_is_shiftlock;
+extern Lisp_Object Vw32_recognize_altgr;
+
/* Event queue */
#define EVENT_QUEUE_SIZE 50
static INPUT_RECORD event_queue[EVENT_QUEUE_SIZE];
/* Translate console modifiers to emacs modifiers.
German keyboard support (Kai Morgan Zeise 2/18/95). */
-static int
-win32_kbd_mods_to_emacs (DWORD mods)
+int
+w32_kbd_mods_to_emacs (DWORD mods, WORD key)
{
int retval = 0;
- /* If AltGr has been pressed, remove it. */
- if ((mods & (RIGHT_ALT_PRESSED | LEFT_CTRL_PRESSED))
+ /* If we recognize right-alt and left-ctrl as AltGr, and it has been
+ pressed, remove the 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 = meta_modifier;
+ retval = ((NILP (Vw32_alt_is_meta)) ? alt_modifier : meta_modifier);
if (mods & (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED))
{
retval |= meta_modifier;
}
+ /* Just in case someone wanted the original behaviour, make it
+ optional by setting w32-capslock-is-shiftlock to t. */
+ if (NILP (Vw32_capslock_is_shiftlock) &&
+#if 1
+ ( (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))
+ )
+#else
+ /* Perhaps easier to say which keys we *do* always want affected
+ by capslock. Not sure how this affects "alphabetic" keyboard
+ input in non-English languages though - what virtual key codes
+ are returned for accented letters, for instance? */
+ !( (key >= '0' && key <= '9') || (key >= 'A' && key <= 'Z') )
+#endif
+ )
+ {
+ if ( (mods & SHIFT_PRESSED) == SHIFT_PRESSED)
+ retval |= shift_modifier;
+ }
+ else
+ {
if (((mods & (SHIFT_PRESSED | CAPSLOCK_ON)) == SHIFT_PRESSED)
|| ((mods & (SHIFT_PRESSED | CAPSLOCK_ON)) == CAPSLOCK_ON))
retval |= shift_modifier;
+ }
return retval;
}
-/* Patch up NT keyboard events when info is missing that should be there,
- assuming that map_virt_key says that the key is a valid ASCII char. */
-static char win32_number_shift_map[] = {
- ')', '!', '@', '#', '$', '%', '^', '&', '*', '('
-};
-
-#define WIN32_KEY_SHIFTED(mods, no, yes) \
- ((mods & (SHIFT_PRESSED | CAPSLOCK_ON)) ? yes : no)
-
-static void
-win32_kbd_patch_key (KEY_EVENT_RECORD *event)
+/* 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;
- int mapped_punct = 0;
-
- /* map_virt_key says its a valid key, but the uChar.AsciiChar field
- is empty. patch up the uChar.AsciiChar field using wVirtualKeyCode. */
- if (event->uChar.AsciiChar == 0
- && ((key_code >= '0' && key_code <= '9')
- || (key_code >= 'A' && key_code <= 'Z')
- || (key_code >= 0xBA && key_code <= 0xC0)
- || (key_code >= 0xDB && key_code <= 0xDE)
- )) {
- if (key_code >= '0' && key_code <= '9') {
- event->uChar.AsciiChar =
- WIN32_KEY_SHIFTED (mods, key_code,
- win32_number_shift_map[key_code - '0']);
- return;
- }
- switch (key_code) {
- case 0xBA: mapped_punct = WIN32_KEY_SHIFTED (mods, ';', ':'); break;
- case 0xBB: mapped_punct = WIN32_KEY_SHIFTED (mods, '=', '+'); break;
- case 0xBC: mapped_punct = WIN32_KEY_SHIFTED (mods, ',', '<'); break;
- case 0xBD: mapped_punct = WIN32_KEY_SHIFTED (mods, '-', '_'); break;
- case 0xBE: mapped_punct = WIN32_KEY_SHIFTED (mods, '.', '>'); break;
- case 0xBF: mapped_punct = WIN32_KEY_SHIFTED (mods, '/', '?'); break;
- case 0xC0: mapped_punct = WIN32_KEY_SHIFTED (mods, '`', '~'); break;
- case 0xDB: mapped_punct = WIN32_KEY_SHIFTED (mods, '[', '{'); break;
- case 0xDC: mapped_punct = WIN32_KEY_SHIFTED (mods, '\\', '|'); break;
- case 0xDD: mapped_punct = WIN32_KEY_SHIFTED (mods, ']', '}'); break;
- case 0xDE: mapped_punct = WIN32_KEY_SHIFTED (mods, '\'', '"'); break;
- default:
- mapped_punct = 0;
- break;
+ 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 (mapped_punct) {
- event->uChar.AsciiChar = mapped_punct;
- return;
+ if (event->uChar.AsciiChar != 0)
+ return 1;
+
+ memset (keystate, 0, sizeof (keystate));
+ 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;
}
- /* otherwise, it's a letter. */
- event->uChar.AsciiChar = WIN32_KEY_SHIFTED (mods, key_code - 'A' + 'a',
- key_code);
- }
+
+ isdead = ToAscii (event->wVirtualKeyCode, event->wVirtualScanCode,
+ keystate, (LPWORD) ansi_code, 0);
+ if (isdead == 0)
+ return 0;
+ event->uChar.AsciiChar = ansi_code[0];
+ return isdead;
}
/* Map virtual key codes into:
static int map_virt_key[256] =
{
+#ifdef MULE
+ -3,
+#else
-1,
+#endif
-1, /* VK_LBUTTON */
-1, /* VK_RBUTTON */
0x69, /* VK_CANCEL */
-2, /* . */
-2, /* / */
-2, /* ` */
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0xcf */
+ -2, /* 0xc1: on Brazilian keyboards, this is the /(?) key. */
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0xcf */
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0xda */
-2, -2, -2, -2, -2, /* 0xdf */
-2, -2, -2, -2, -2,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1 /* 0xff */
};
-static int
-key_event (KEY_EVENT_RECORD *event, struct input_event *emacs_ev)
+/* 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)
{
int map;
+ int key_flag = 0;
static BOOL map_virt_key_init_done;
+
+ *isdead = 0;
/* Skip key-up events. */
- if (event->bKeyDown == FALSE)
+ if (!event->bKeyDown)
return 0;
if (event->wVirtualKeyCode > 0xff)
the queue. If they're backing up then we don't generally want
to honor them later since that leads to significant slop in
cursor motion when the system is under heavy load. */
-
+
map = map_virt_key[event->wVirtualKeyCode];
if (map == -1)
{
{
/* ASCII */
emacs_ev->kind = ascii_keystroke;
- win32_kbd_patch_key (event);
+ key_flag = w32_kbd_patch_key (event); /* 95.7.25 by himi */
+ if (key_flag == 0)
+ return 0;
+ if (key_flag < 0)
+ *isdead = 1;
XSETINT (emacs_ev->code, event->uChar.AsciiChar);
}
+#ifdef MULE
+ /* for IME */
+ else if (map == -3)
+ {
+ if ((event->dwControlKeyState & NLS_IME_CONVERSION)
+ && !(event->dwControlKeyState & RIGHT_ALT_PRESSED)
+ && !(event->dwControlKeyState & LEFT_ALT_PRESSED)
+ && !(event->dwControlKeyState & RIGHT_CTRL_PRESSED)
+ && !(event->dwControlKeyState & LEFT_CTRL_PRESSED))
+ {
+ emacs_ev->kind = ascii_keystroke;
+ XSETINT (emacs_ev->code, event->uChar.AsciiChar);
+ }
+ else
+ return 0;
+ }
+#endif
else
{
/* non-ASCII */
emacs_ev->kind = non_ascii_keystroke;
+#ifdef HAVE_NTGUI
+ /* use Windows keysym map */
+ XSETINT (emacs_ev->code, event->wVirtualKeyCode);
+#else
/*
* make_lispy_event () now requires non-ascii codes to have
* the full X keysym values (2nd byte is 0xff). add it on.
*/
map |= 0xff00;
XSETINT (emacs_ev->code, map);
+#endif /* HAVE_NTGUI */
}
+/* 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 ());
- emacs_ev->modifiers = win32_kbd_mods_to_emacs (event->dwControlKeyState);
+#endif
+ emacs_ev->modifiers = w32_kbd_mods_to_emacs (event->dwControlKeyState,
+ event->wVirtualKeyCode);
emacs_ev->timestamp = GetTickCount ();
+ if (key_flag == 2) return -1; /* 95.7.25 by himi */
return 1;
}
/* Mouse position hook. */
void
-win32_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)
+w32_console_mouse_position (FRAME_PTR *f,
+#ifndef MULE
+ int insist,
+#endif
+ Lisp_Object *bar_window,
+ enum scroll_bar_part *part,
+ Lisp_Object *x,
+ Lisp_Object *y,
+ unsigned long *time)
{
BLOCK_INPUT;
-
+
+#ifndef MULE
insist = insist;
+#endif
*f = get_frame ();
*bar_window = Qnil;
button_state = event->dwButtonState;
emacs_ev->timestamp = GetTickCount ();
- emacs_ev->modifiers = win32_kbd_mods_to_emacs (event->dwControlKeyState) |
+ 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;
}
}
int
-win32_read_socket (int sd, struct input_event *bufp, int numchars,
- int waitp, int expected)
+w32_console_read_socket (int sd, struct input_event *bufp, int numchars,
+ int expected)
{
BOOL no_events = TRUE;
int nev, ret = 0, add;
-
+ int isdead;
+
if (interrupt_input_blocked)
{
interrupt_input_pending = 1;
for (;;)
{
- nev = fill_queue (waitp != 0);
+ nev = fill_queue (0);
if (nev <= 0)
{
/* If nev == -1, there was some kind of error
switch (queue_ptr->EventType)
{
case KEY_EVENT:
- add = key_event (&queue_ptr->Event.KeyEvent, bufp);
+ add = key_event (&queue_ptr->Event.KeyEvent, bufp, &isdead);
+ if (add == -1) /* 95.7.25 by himi */
+ {
+ queue_ptr--;
+ add = 1;
+ }
bufp += add;
ret += add;
numchars -= add;