emacs: src/w32fns.c comparison

comparison src/w32fns.c @ 23681:af0276da2059

(Vw32_pass_optional_keys_to_system): Variable removed. (Vw32_pass_lwindow_to_system): (Vw32_pass_rwindow_to_system): (Vw32_lwindow_modifier): (Vw32_rwindow_modifier): (Vw32_apps_modifier): (Vw32_enable_num_lock): (Vw32_enable_caps_lock): (Vw32_scroll_lock_modifier): New variables. (modifier_set): Return toggle state for Scroll Lock. (w32_key_to_modifier): New function. Returns chosen modifier bit for given key. (w32_get_modifiers): Returns modifier flags for non-keyboard input events. (construct_console_modifiers): Renamed from construct_modifiers; recognize Windows and Apps keys as modifiers. (w32_get_key_modifiers): New function. Returns modifier flags for keyboard input events. (map_keypad_keys): Make non-static. Use second arg as extended flag. (w32_grabbed_keys): New variable. (HOTKEY, HOTKEY_ID, HOTKEY_VK_CODE, HOTKEY_MODIFIERS): New macros. (register_hot_keys): (unregister_hot_keys): (lookup_vk_code): (w32_parse_hot_key): (Fw32_register_hot_key): (Fw32_unregister_hot_key): (Fw32_registered_hot_keys): (Fw32_reconstruct_hot_key): New functions to support hotkeys. (post_character_message): New function. (w32_msg_pump): Handle new messages for using hotkeys and changing keyboard layout/language. (w32_wnd_proc): Major rework of keyboard input handling: optionally recognize Windows keys and Apps key as modifiers; optionally treat NumLock, CapsLock and ScrollLock as function keys; let system translate keystrokes to characters to avoid system bugs relating to dead-key handling; preserve shift distinction for control characters; forward keyboard layout/language changes to lisp; detect and convert hot-key events to normal keystrokes. (syms_of_w32fns): Register new functions and variables. (w32_last_error): New function for use in debugging.

author	Geoff Voelker <voelker@cs.washington.edu>
date	Tue, 10 Nov 1998 20:54:46 +0000
parents	54b22e0a1f7b
children	119fd94ae526

comparison

equal deleted inserted replaced

-:02e5da32da56
+:af0276da2059
 extern void abort ();
 extern void free_frame_menubar ();
 extern struct scroll_bar *x_window_to_scroll_bar ();
 extern int quit_char;
+extern char *lispy_function_keys[];
 /* The colormap for converting color names to RGB values */
 Lisp_Object Vw32_color_map;
 /* Non nil if alt key presses are passed on to Windows.  */
 Lisp_Object Vw32_pass_alt_to_system;
 /* Non nil if alt key is translated to meta_modifier, nil if it is translated
 to alt_modifier.  */
 Lisp_Object Vw32_alt_is_meta;
-/* Non nil if left window, right window, and application key events
+/* Non nil if left window key events are passed on to Windows (this only
-are passed on to Windows.  */
+affects whether "tapping" the key opens the Start menu).  */
-Lisp_Object Vw32_pass_optional_keys_to_system;
+Lisp_Object Vw32_pass_lwindow_to_system;
+/* Non nil if right window key events are passed on to Windows (this
+only affects whether "tapping" the key opens the Start menu).  */
+Lisp_Object Vw32_pass_rwindow_to_system;
+/* Modifier associated with the left "Windows" key, or nil to act as a
+normal key.  */
+Lisp_Object Vw32_lwindow_modifier;
+/* Modifier associated with the right "Windows" key, or nil to act as a
+normal key.  */
+Lisp_Object Vw32_rwindow_modifier;
+/* Modifier associated with the "Apps" key, or nil to act as a normal
+key.  */
+Lisp_Object Vw32_apps_modifier;
+/* Value is nil if Num Lock acts as a function key.  */
+Lisp_Object Vw32_enable_num_lock;
+/* Value is nil if Caps Lock acts as a function key.  */
+Lisp_Object Vw32_enable_caps_lock;
+/* Modifier associated with Scroll Lock, or nil to act as a normal key.  */
+Lisp_Object Vw32_scroll_lock_modifier;
 /* Switch to control whether we inhibit requests for italicised fonts (which
 are synthesized, look ugly, and are trashed by cursor movement under NT). */
 Lisp_Object Vw32_enable_italics;
 extern Lisp_Object last_mouse_scroll_bar;
 extern int last_mouse_scroll_bar_pos;
 /* From w32term.c. */
 extern Lisp_Object Vw32_num_mouse_buttons;
+extern Lisp_Object Vw32_recognize_altgr;
 /* Error if we are not connected to MS-Windows.  */
 void
 check_w32 ()
 /* Do this to discard the default setting specified by our parent. */
 ShowWindow (hwnd, SW_HIDE);
 }
 }
-/* Convert between the modifier bits W32 uses and the modifier bits
-Emacs uses.  */
-unsigned int
-w32_get_modifiers ()
-{
-return (((GetKeyState (VK_SHIFT)&0x8000)   ? shift_modifier  : 0) |
-	  ((GetKeyState (VK_CONTROL)&0x8000) ? ctrl_modifier   : 0) |
-((GetKeyState (VK_MENU)&0x8000)    ?
-	   ((NILP (Vw32_alt_is_meta)) ? alt_modifier : meta_modifier) : 0));
-}
 void
 my_post_msg (wmsg, hwnd, msg, wParam, lParam)
 W32Msg * wmsg;
 HWND hwnd;
 UINT msg;
 }
 static int
 modifier_set (int vkey)
 {
-if (vkey == VK_CAPITAL)
+if (vkey == VK_CAPITAL || vkey == VK_SCROLL)
 return (GetKeyState (vkey) & 0x1);
 if (!modifiers_recorded)
 return (GetKeyState (vkey) & 0x8000);
 switch (vkey)
 return modifiers[EMACS_RCONTROL];
 case VK_LMENU:
 return modifiers[EMACS_LMENU];
 case VK_RMENU:
 return modifiers[EMACS_RMENU];
+}
+return (GetKeyState (vkey) & 0x8000);
+}
+/* Convert between the modifier bits W32 uses and the modifier bits
+Emacs uses.  */
+unsigned int
+w32_key_to_modifier (int key)
+{
+Lisp_Object key_mapping;
+switch (key)
+{
+case VK_LWIN:
+key_mapping = Vw32_lwindow_modifier;
+break;
+case VK_RWIN:
+key_mapping = Vw32_rwindow_modifier;
+break;
+case VK_APPS:
+key_mapping = Vw32_apps_modifier;
+break;
+case VK_SCROLL:
+key_mapping = Vw32_scroll_lock_modifier;
+break;
 default:
-break;
+key_mapping = Qnil;
 }
-return (GetKeyState (vkey) & 0x8000);
+if (EQ (key_mapping, intern ("hyper")))
+return hyper_modifier;
+if (EQ (key_mapping, intern ("super")))
+return super_modifier;
+if (EQ (key_mapping, intern ("meta")))
+return meta_modifier;
+if (EQ (key_mapping, intern ("alt")))
+return alt_modifier;
+if (EQ (key_mapping, intern ("ctrl")))
+return ctrl_modifier;
+if (EQ (key_mapping, intern ("control"))) /* synonym for ctrl */
+return ctrl_modifier;
+if (EQ (key_mapping, intern ("shift")))
+return shift_modifier;
+/* Don't generate any modifier if not explicitly requested.  */
+return 0;
+}
+unsigned int
+w32_get_modifiers ()
+{
+return ((modifier_set (VK_SHIFT)   ? shift_modifier : 0) |
+	  (modifier_set (VK_CONTROL) ? ctrl_modifier  : 0) |
+	  (modifier_set (VK_LWIN)    ? w32_key_to_modifier (VK_LWIN) : 0) |
+	  (modifier_set (VK_RWIN)    ? w32_key_to_modifier (VK_RWIN) : 0) |
+	  (modifier_set (VK_APPS)    ? w32_key_to_modifier (VK_APPS) : 0) |
+	  (modifier_set (VK_SCROLL)  ? w32_key_to_modifier (VK_SCROLL) : 0) |
+(modifier_set (VK_MENU)    ?
+	   ((NILP (Vw32_alt_is_meta)) ? alt_modifier : meta_modifier) : 0));
 }
 /* We map the VK_* modifiers into console modifier constants
 so that we can use the same routines to handle both console
 and window input.  */
 static int
-construct_modifiers (unsigned int wparam, unsigned int lparam)
+construct_console_modifiers ()
 {
 int mods;
-if (wparam != VK_CONTROL && wparam != VK_MENU)
-mods = GetLastError ();
 mods = 0;
 mods |= (modifier_set (VK_SHIFT)) ? SHIFT_PRESSED : 0;
 mods |= (modifier_set (VK_CAPITAL)) ? CAPSLOCK_ON : 0;
+mods |= (modifier_set (VK_SCROLL)) ? SCROLLLOCK_ON : 0;
+mods |= (modifier_set (VK_NUMLOCK)) ? NUMLOCK_ON : 0;
 mods |= (modifier_set (VK_LCONTROL)) ? LEFT_CTRL_PRESSED : 0;
 mods |= (modifier_set (VK_RCONTROL)) ? RIGHT_CTRL_PRESSED : 0;
 mods |= (modifier_set (VK_LMENU)) ? LEFT_ALT_PRESSED : 0;
 mods |= (modifier_set (VK_RMENU)) ? RIGHT_ALT_PRESSED : 0;
+mods |= (modifier_set (VK_LWIN)) ? LEFT_WIN_PRESSED : 0;
+mods |= (modifier_set (VK_RWIN)) ? RIGHT_WIN_PRESSED : 0;
+mods |= (modifier_set (VK_APPS)) ? APPS_PRESSED : 0;
 return mods;
 }
-static unsigned int
+static int
-map_keypad_keys (unsigned int wparam, unsigned int lparam)
+w32_get_key_modifiers (unsigned int wparam, unsigned int lparam)
 {
-unsigned int extended = (lparam & 0x1000000L);
+int mods;
-if (wparam < VK_CLEAR || wparam > VK_DELETE)
+/* Convert to emacs modifiers.  */
-return wparam;
+mods = w32_kbd_mods_to_emacs (construct_console_modifiers (), wparam);
-if (wparam == VK_RETURN)
+return mods;
+}
+unsigned int
+map_keypad_keys (unsigned int virt_key, unsigned int extended)
+{
+if (virt_key < VK_CLEAR || virt_key > VK_DELETE)
+return virt_key;
+if (virt_key == VK_RETURN)
 return (extended ? VK_NUMPAD_ENTER : VK_RETURN);
-if (wparam >= VK_PRIOR && wparam <= VK_DOWN)
+if (virt_key >= VK_PRIOR && virt_key <= VK_DOWN)
-return (!extended ? (VK_NUMPAD_PRIOR + (wparam - VK_PRIOR)) : wparam);
+return (!extended ? (VK_NUMPAD_PRIOR + (virt_key - VK_PRIOR)) : virt_key);
-if (wparam == VK_INSERT || wparam == VK_DELETE)
+if (virt_key == VK_INSERT || virt_key == VK_DELETE)
-return (!extended ? (VK_NUMPAD_INSERT + (wparam - VK_INSERT)) : wparam);
+return (!extended ? (VK_NUMPAD_INSERT + (virt_key - VK_INSERT)) : virt_key);
-if (wparam == VK_CLEAR)
+if (virt_key == VK_CLEAR)
-return (!extended ? VK_NUMPAD_CLEAR : wparam);
+return (!extended ? VK_NUMPAD_CLEAR : virt_key);
-return wparam;
+return virt_key;
+}
+/* List of special key combinations which w32 would normally capture,
+but emacs should grab instead.  Not directly visible to lisp, to
+simplify synchronization.  Each item is an integer encoding a virtual
+key code and modifier combination to capture.  */
+Lisp_Object w32_grabbed_keys;
+#define HOTKEY(vk,mods)       make_number (((vk) & 255) | ((mods) << 8))
+#define HOTKEY_ID(k)          (XFASTINT (k) & 0xbfff)
+#define HOTKEY_VK_CODE(k)     (XFASTINT (k) & 255)
+#define HOTKEY_MODIFIERS(k)   (XFASTINT (k) >> 8)
+/* Register hot-keys for reserved key combinations when Emacs has
+keyboard focus, since this is the only way Emacs can receive key
+combinations like Alt-Tab which are used by the system.  */
+static void
+register_hot_keys (hwnd)
+HWND hwnd;
+{
+Lisp_Object keylist;
+/* Use GC_CONSP, since we are called asynchronously.  */
+for (keylist = w32_grabbed_keys; GC_CONSP (keylist); keylist = XCDR (keylist))
+{
+Lisp_Object key = XCAR (keylist);
+/* Deleted entries get set to nil.  */
+if (!INTEGERP (key))
+	continue;
+RegisterHotKey (hwnd, HOTKEY_ID (key),
+		      HOTKEY_MODIFIERS (key), HOTKEY_VK_CODE (key));
+}
+}
+static void
+unregister_hot_keys (hwnd)
+HWND hwnd;
+{
+Lisp_Object keylist;
+/* Use GC_CONSP, since we are called asynchronously.  */
+for (keylist = w32_grabbed_keys; GC_CONSP (keylist); keylist = XCDR (keylist))
+{
+Lisp_Object key = XCAR (keylist);
+if (!INTEGERP (key))
+	continue;
+UnregisterHotKey (hwnd, HOTKEY_ID (key));
+}
+}
+static void
+post_character_message (hwnd, msg, wParam, lParam, modifiers)
+HWND hwnd;
+UINT msg;
+WPARAM wParam;
+LPARAM lParam;
+DWORD  modifiers;
+{
+W32Msg wmsg;
+wmsg.dwModifiers = modifiers;
+/* Detect quit_char and set quit-flag directly.  Note that we
+still need to post a message to ensure the main thread will be
+woken up if blocked in sys_select(), but we do NOT want to post
+the quit_char message itself (because it will usually be as if
+the user had typed quit_char twice).  Instead, we post a dummy
+message that has no particular effect. */
+{
+int c = wParam;
+if (isalpha (c) && wmsg.dwModifiers == ctrl_modifier)
+c = make_ctrl_char (c) & 0377;
+if (c == quit_char)
+{
+	Vquit_flag = Qt;
+	/* The choice of message is somewhat arbitrary, as long as
+	   the main thread handler just ignores it. */
+	msg = WM_NULL;
+	/* Interrupt any blocking system calls.  */
+	signal_quit ();
+}
+}
+my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
 }
 /* Main message dispatch loop. */
 static void
 w32_msg_pump (deferred_msg * msg_buf)
 {
 MSG msg;
+int result;
+HWND focus_window;
 msh_mousewheel = RegisterWindowMessage (MSH_MOUSEWHEEL);
 while (GetMessage (&msg, NULL, 0, 0))
 {
 	      break;
 	    case WM_EMACS_SETLOCALE:
 	      SetThreadLocale (msg.wParam);
 	      /* Reply is not expected.  */
 	      break;
+	    case WM_EMACS_SETKEYBOARDLAYOUT:
+	      result = (int) ActivateKeyboardLayout ((HKL) msg.wParam, 0);
+	      if (!PostThreadMessage (dwMainThreadId, WM_EMACS_DONE,
+				      result, 0))
+		abort ();
+	      break;
+	    case WM_EMACS_REGISTER_HOT_KEY:
+	      focus_window = GetFocus ();
+	      if (focus_window != NULL)
+		RegisterHotKey (focus_window,
+				HOTKEY_ID (msg.wParam),
+				HOTKEY_MODIFIERS (msg.wParam),
+				HOTKEY_VK_CODE (msg.wParam));
+	      /* Reply is not expected.  */
+	      break;
+	    case WM_EMACS_UNREGISTER_HOT_KEY:
+	      focus_window = GetFocus ();
+	      if (focus_window != NULL)
+		UnregisterHotKey (focus_window, HOTKEY_ID (msg.wParam));
+	      /* Mark item as erased.  */
+	      XCAR ((Lisp_Object) msg.lParam) = Qnil;
+	      if (!PostThreadMessage (dwMainThreadId, WM_EMACS_DONE, 0, 0))
+		abort ();
+	      break;
 	    default:
-	      /* No need to be so draconian!  */
-	      /* abort (); */
 	      DebPrint (("msg %x not expected by w32_msg_pump\n", msg.message));
 	    }
 	}
 else
 	{
 return 0;
 }
 /* Main window procedure */
-extern char *lispy_function_keys[];
 LRESULT CALLBACK
 w32_wnd_proc (hwnd, msg, wParam, lParam)
 HWND hwnd;
 UINT msg;
 	my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
 	return (0);
 }
+case WM_INPUTLANGCHANGE:
+/* Inform lisp thread of keyboard layout changes.  */
+my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
+/* Clear dead keys in the keyboard state; for simplicity only
+preserve modifier key states.  */
+{
+	int i;
+	BYTE keystate[256];
+	GetKeyboardState (keystate);
+	for (i = 0; i < 256; i++)
+	  if (1
+	      && i != VK_SHIFT
+	      && i != VK_LSHIFT
+	      && i != VK_RSHIFT
+	      && i != VK_CAPITAL
+	      && i != VK_NUMLOCK
+	      && i != VK_SCROLL
+	      && i != VK_CONTROL
+	      && i != VK_LCONTROL
+	      && i != VK_RCONTROL
+	      && i != VK_MENU
+	      && i != VK_LMENU
+	      && i != VK_RMENU
+	      && i != VK_LWIN
+	      && i != VK_RWIN)
+	    keystate[i] = 0;
+	SetKeyboardState (keystate);
+}
+goto dflt;
+case WM_HOTKEY:
+/* Synchronize hot keys with normal input.  */
+PostMessage (hwnd, WM_KEYDOWN, HIWORD (lParam), 0);
+return (0);
 case WM_KEYUP:
 case WM_SYSKEYUP:
 record_keyup (wParam, lParam);
 goto dflt;
 case WM_KEYDOWN:
 case WM_SYSKEYDOWN:
+/* Ignore keystrokes we fake ourself; see below.  */
+if (dpyinfo->faked_key == wParam)
+	{
+	  dpyinfo->faked_key = 0;
+	  return 0;
+	}
 /* Synchronize modifiers with current keystroke.  */
 sync_modifiers ();
 record_keydown (wParam, lParam);
+wParam = map_keypad_keys (wParam, (lParam & 0x1000000L) != 0);
-wParam = map_keypad_keys (wParam, lParam);
 windows_translate = 0;
-switch (wParam) {
-case VK_LWIN:
+switch (wParam)
-case VK_RWIN:
+	{
-case VK_APPS:
+	case VK_LWIN:
-	/* More support for these keys will likely be necessary.  */
+	  if (NILP (Vw32_pass_lwindow_to_system))
-	if (!NILP (Vw32_pass_optional_keys_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 (GetAsyncKeyState (wParam) & 1)
+		{
+		  dpyinfo->faked_key = VK_SPACE;
+		  keybd_event (VK_SPACE,
+			       (BYTE) MapVirtualKey (VK_SPACE, 0), 0, 0);
+		}
+	    }
+	  if (!NILP (Vw32_lwindow_modifier))
+	    return 0;
+	  break;
+	case VK_RWIN:
+	  if (NILP (Vw32_pass_rwindow_to_system))
+	    {
+	      if (GetAsyncKeyState (wParam) & 1)
+		{
+		  dpyinfo->faked_key = VK_SPACE;
+		  keybd_event (VK_SPACE,
+			       (BYTE) MapVirtualKey (VK_SPACE, 0), 0, 0);
+		}
+	    }
+	  if (!NILP (Vw32_rwindow_modifier))
+	    return 0;
+	  break;
+	case VK_APPS:
+	  if (!NILP (Vw32_apps_modifier))
+	    return 0;
+	  break;
+	case VK_MENU:
+	  if (NILP (Vw32_pass_alt_to_system))
+	    return 0;
 	  windows_translate = 1;
-	break;
+	  break;
-case VK_MENU:
+	case VK_CAPITAL:
-	if (NILP (Vw32_pass_alt_to_system))
+	  /* Decide whether to treat as modifier or function key.  */
+	  if (NILP (Vw32_enable_caps_lock))
+	    goto disable_lock_key;
 	  return 0;
-	windows_translate = 1;
+	case VK_NUMLOCK:
-	break;
+	  /* Decide whether to treat as modifier or function key.  */
-case VK_CONTROL:
+	  if (NILP (Vw32_enable_num_lock))
-case VK_CAPITAL:
+	    goto disable_lock_key;
-case VK_SHIFT:
+	  return 0;
-case VK_NUMLOCK:
+	case VK_SCROLL:
-case VK_SCROLL:
+	  /* Decide whether to treat as modifier or function key.  */
-	windows_translate = 1;
+	  if (NILP (Vw32_scroll_lock_modifier))
-	break;
+	    goto disable_lock_key;
-default:
+	  return 0;
-	/* If not defined as a function key, change it to a WM_CHAR message. */
+	disable_lock_key:
-	if (lispy_function_keys[wParam] == 0)
+	  /* Ensure the appropriate lock key state is off (and the
-	  msg = WM_CHAR;
+indicator light as well).  */
-	break;
+	  if (GetAsyncKeyState (wParam) & 0x8000)
-}
+	    {
+	      /* Fake another press of the relevant key.  Apparently,
+this really is the only way to turn off the indicator.  */
+	      dpyinfo->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_CONTROL:
+	case VK_SHIFT:
+	case VK_PROCESSKEY:  /* Generated by IME.  */
+	  windows_translate = 1;
+	  break;
+	default:
+	  /* If not defined as a function key, change it to a WM_CHAR message. */
+	  if (lispy_function_keys[wParam] == 0)
+	    {
+	      if (!NILP (Vw32_recognize_altgr)
+		  && modifier_set (VK_LCONTROL) && modifier_set (VK_RMENU))
+		{
+		  /* Always let TranslateMessage handle AltGr key chords;
+		     for some reason, ToAscii doesn't always process AltGr
+		     chords correctly.  */
+		  windows_translate = 1;
+		}
+	      else if (modifier_set (VK_CONTROL) || modifier_set (VK_MENU))
+		{
+		  /* Handle key chords including any modifiers other than shift
+		     directly, in order to preserve as much modifier information as
+		     possible.  */
+		  if ('A' <= wParam && wParam <= 'Z')
+		    {
+		      /* 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 (!modifier_set (VK_SHIFT))
+			wParam += ('a' - 'A');
+		      msg = WM_CHAR;
+		    }
+		  else
+		    {
+		      /* Try to handle other keystrokes by determining the
+			 base character (ie. translating the base key plus
+			 shift modifier).  */
+		      int add;
+		      int isdead = 0;
+		      KEY_EVENT_RECORD key;
+		      key.bKeyDown = TRUE;
+		      key.wRepeatCount = 1;
+		      key.wVirtualKeyCode = wParam;
+		      key.wVirtualScanCode = (lParam & 0xFF0000) >> 16;
+		      key.uChar.AsciiChar = 0;
+		      key.dwControlKeyState = construct_console_modifiers ();
+		      add = w32_kbd_patch_key (&key);
+		      /* 0 means an unrecognised keycode, negative means
+			 dead key.  Ignore both.  */
+		      while (--add >= 0)
+			{
+			  /* Forward asciified character sequence.  */
+			  post_character_message
+			    (hwnd, WM_CHAR, key.uChar.AsciiChar, lParam,
+			     w32_get_key_modifiers (wParam, lParam));
+			  w32_kbd_patch_key (&key);
+			}
+		      return 0;
+		    }
+		}
+	      else
+		{
+		  /* Let TranslateMessage handle everything else.  */
+		  windows_translate = 1;
+		}
+	    }
+	}
 if (windows_translate)
 	{
 	  MSG windows_msg = { hwnd, msg, wParam, lParam, 0, {0,0} };
 /* Fall through */
 case WM_SYSCHAR:
 case WM_CHAR:
-wmsg.dwModifiers = construct_modifiers (wParam, lParam);
+post_character_message (hwnd, msg, wParam, lParam,
+			      w32_get_key_modifiers (wParam, lParam));
-#if 1
-/* Detect quit_char and set quit-flag directly.  Note that we
-	 still need to post a message to ensure the main thread will be
-	 woken up if blocked in sys_select(), but we do NOT want to post
-	 the quit_char message itself (because it will usually be as if
-	 the user had typed quit_char twice).  Instead, we post a dummy
-	 message that has no particular effect. */
-{
-	int c = wParam;
-	if (isalpha (c) && (wmsg.dwModifiers == LEFT_CTRL_PRESSED
-			    || wmsg.dwModifiers == RIGHT_CTRL_PRESSED))
-	  c = make_ctrl_char (c) & 0377;
-	if (c == quit_char)
-	  {
-	    Vquit_flag = Qt;
-	    /* The choice of message is somewhat arbitrary, as long as
-	       the main thread handler just ignores it. */
-	    msg = WM_NULL;
-	    /* Interrupt any blocking system calls.  */
-	    signal_quit ();
-	  }
-}
-#endif
-my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
 break;
 /* Simulate middle mouse button events when left and right buttons
 	 are used together, but only if user has two button mouse. */
 case WM_LBUTTONDOWN:
 if (LOWORD (lParam) == HTCLIENT )
 	return MA_ACTIVATEANDEAT;
 goto dflt;
 #endif
+case WM_ACTIVATEAPP:
+dpyinfo->faked_key = 0;
+reset_modifiers ();
 case WM_ACTIVATE:
-case WM_ACTIVATEAPP:
 case WM_WINDOWPOSCHANGED:
 case WM_SHOWWINDOW:
 /* Inform lisp thread that a frame might have just been obscured
 	 or exposed, so should recheck visibility of all frames.  */
 my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
 goto dflt;
 case WM_SETFOCUS:
-reset_modifiers ();
+register_hot_keys (hwnd);
+goto command;
 case WM_KILLFOCUS:
+unregister_hot_keys (hwnd);
 case WM_MOVE:
 case WM_SIZE:
 case WM_COMMAND:
+command:
 wmsg.dwModifiers = w32_get_modifiers ();
 my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
 goto dflt;
 case WM_CLOSE:
 PostMessage (FRAME_W32_WINDOW (f), WM_SYSCOMMAND, XINT (command), 0);
 return Qnil;
 }
+/* Lookup virtual keycode from string representing the name of a
+non-ascii keystroke into the corresponding virtual key, using
+lispy_function_keys.  */
+static int
+lookup_vk_code (char *key)
+{
+int i;
+for (i = 0; i < 256; i++)
+if (lispy_function_keys[i] != 0
+	&& strcmp (lispy_function_keys[i], key) == 0)
+return i;
+return -1;
+}
+/* Convert a one-element vector style key sequence to a hot key
+definition.  */
+static int
+w32_parse_hot_key (key)
+Lisp_Object key;
+{
+/* Copied from Fdefine_key and store_in_keymap.  */
+register Lisp_Object c;
+int vk_code;
+int lisp_modifiers;
+int w32_modifiers;
+struct gcpro gcpro1;
+CHECK_VECTOR (key, 0);
+if (XFASTINT (Flength (key)) != 1)
+return Qnil;
+GCPRO1 (key);
+c = Faref (key, make_number (0));
+if (CONSP (c) && lucid_event_type_list_p (c))
+c = Fevent_convert_list (c);
+UNGCPRO;
+if (! INTEGERP (c) && ! SYMBOLP (c))
+error ("Key definition is invalid");
+/* Work out the base key and the modifiers.  */
+if (SYMBOLP (c))
+{
+c = parse_modifiers (c);
+lisp_modifiers = Fcar (Fcdr (c));
+c = Fcar (c);
+if (!SYMBOLP (c))
+	abort ();
+vk_code = lookup_vk_code (XSYMBOL (c)->name->data);
+}
+else if (INTEGERP (c))
+{
+lisp_modifiers = XINT (c) & ~CHARACTERBITS;
+/* Many ascii characters are their own virtual key code.  */
+vk_code = XINT (c) & CHARACTERBITS;
+}
+if (vk_code < 0 || vk_code > 255)
+return Qnil;
+if ((lisp_modifiers & meta_modifier) != 0
+&& !NILP (Vw32_alt_is_meta))
+lisp_modifiers |= alt_modifier;
+/* Convert lisp modifiers to Windows hot-key form.  */
+w32_modifiers  = (lisp_modifiers & hyper_modifier)    ? MOD_WIN : 0;
+w32_modifiers |= (lisp_modifiers & alt_modifier)      ? MOD_ALT : 0;
+w32_modifiers |= (lisp_modifiers & ctrl_modifier)     ? MOD_CONTROL : 0;
+w32_modifiers |= (lisp_modifiers & shift_modifier)    ? MOD_SHIFT : 0;
+return HOTKEY (vk_code, w32_modifiers);
+}
+DEFUN ("w32-register-hot-key", Fw32_register_hot_key, Sw32_register_hot_key, 1, 1, 0,
+"Register KEY as a hot-key combination.\n\
+Certain key combinations like Alt-Tab are reserved for system use on\n\
+Windows, and therefore are normally intercepted by the system.  However,\n\
+most of these key combinations can be received by registering them as\n\
+hot-keys, overriding their special meaning.\n\
+\n\
+KEY must be a one element key definition in vector form that would be\n\
+acceptable to `define-key' (e.g. [A-tab] for Alt-Tab).  The meta\n\
+modifier is interpreted as Alt if `w32-alt-is-meta' is t, and hyper\n\
+is always interpreted as the Windows modifier keys.\n\
+\n\
+The return value is the hotkey-id if registered, otherwise nil.")
+(key)
+Lisp_Object key;
+{
+key = w32_parse_hot_key (key);
+if (NILP (Fmemq (key, w32_grabbed_keys)))
+{
+/* Reuse an empty slot if possible.  */
+Lisp_Object item = Fmemq (Qnil, w32_grabbed_keys);
+/* Safe to add new key to list, even if we have focus.  */
+if (NILP (item))
+	w32_grabbed_keys = Fcons (key, w32_grabbed_keys);
+else
+	XCAR (item) = key;
+/* Notify input thread about new hot-key definition, so that it
+	 takes effect without needing to switch focus.  */
+PostThreadMessage (dwWindowsThreadId, WM_EMACS_REGISTER_HOT_KEY,
+			 (WPARAM) key, 0);
+}
+return key;
+}
+DEFUN ("w32-unregister-hot-key", Fw32_unregister_hot_key, Sw32_unregister_hot_key, 1, 1, 0,
+"Unregister HOTKEY as a hot-key combination.")
+(key)
+Lisp_Object key;
+{
+Lisp_Object item;
+if (!INTEGERP (key))
+key = w32_parse_hot_key (key);
+item = Fmemq (key, w32_grabbed_keys);
+if (!NILP (item))
+{
+/* Notify input thread about hot-key definition being removed, so
+	 that it takes effect without needing focus switch.  */
+if (PostThreadMessage (dwWindowsThreadId, WM_EMACS_UNREGISTER_HOT_KEY,
+			     (WPARAM) XINT (XCAR (item)), (LPARAM) item))
+	{
+	  MSG msg;
+	  GetMessage (&msg, NULL, WM_EMACS_DONE, WM_EMACS_DONE);
+	}
+return Qt;
+}
+return Qnil;
+}
+DEFUN ("w32-registered-hot-keys", Fw32_registered_hot_keys, Sw32_registered_hot_keys, 0, 0, 0,
+"Return list of registered hot-key IDs.")
+()
+{
+return Fcopy_sequence (w32_grabbed_keys);
+}
+DEFUN ("w32-reconstruct-hot-key", Fw32_reconstruct_hot_key, Sw32_reconstruct_hot_key, 1, 1, 0,
+"Convert hot-key ID to a lisp key combination.")
+(hotkeyid)
+Lisp_Object hotkeyid;
+{
+int vk_code, w32_modifiers;
+Lisp_Object key;
+CHECK_NUMBER (hotkeyid, 0);
+vk_code = HOTKEY_VK_CODE (hotkeyid);
+w32_modifiers = HOTKEY_MODIFIERS (hotkeyid);
+if (lispy_function_keys[vk_code])
+key = intern (lispy_function_keys[vk_code]);
+else
+key = make_number (vk_code);
+key = Fcons (key, Qnil);
+if (w32_modifiers & MOD_SHIFT)
+key = Fcons (intern ("shift"), key);
+if (w32_modifiers & MOD_CONTROL)
+key = Fcons (intern ("control"), key);
+if (w32_modifiers & MOD_ALT)
+key = Fcons (intern (NILP (Vw32_alt_is_meta) ? "alt" : "meta"), key);
+if (w32_modifiers & MOD_WIN)
+key = Fcons (intern ("hyper"), key);
+return key;
+}
 syms_of_w32fns ()
 {
 /* This is zero if not using MS-Windows.  */
 w32_in_use = 0;
 Fput (Qundefined_color, Qerror_conditions,
 	Fcons (Qundefined_color, Fcons (Qerror, Qnil)));
 Fput (Qundefined_color, Qerror_message,
 	build_string ("Undefined color"));
+staticpro (&w32_grabbed_keys);
+w32_grabbed_keys = Qnil;
 DEFVAR_LISP ("w32-color-map", &Vw32_color_map,
-	       "A array of color name mappings for windows.");
+	       "An array of color name mappings for windows.");
 Vw32_color_map = Qnil;
 DEFVAR_LISP ("w32-pass-alt-to-system", &Vw32_pass_alt_to_system,
 	       "Non-nil if alt key presses are passed on to Windows.\n\
 When non-nil, for example, alt pressed and released and then space will\n\
 DEFVAR_LISP ("w32-alt-is-meta", &Vw32_alt_is_meta,
 	       "Non-nil if the alt key is to be considered the same as the meta key.\n\
 When nil, Emacs will translate the alt key to the Alt modifier, and not Meta.");
 Vw32_alt_is_meta = Qt;
-DEFVAR_LISP ("w32-pass-optional-keys-to-system",
+DEFVAR_LISP ("w32-pass-lwindow-to-system",
-	       &Vw32_pass_optional_keys_to_system,
+	       &Vw32_pass_lwindow_to_system,
-	       "Non-nil if the 'optional' keys (left window, right window,\n\
+	       "Non-nil if the left \"Windows\" key is passed on to Windows.\n\
-and application keys) are passed on to Windows.");
+When non-nil, the Start menu is opened by tapping the key.");
-Vw32_pass_optional_keys_to_system = Qnil;
+Vw32_pass_lwindow_to_system = Qt;
+DEFVAR_LISP ("w32-pass-rwindow-to-system",
+	       &Vw32_pass_rwindow_to_system,
+	       "Non-nil if the right \"Windows\" key is passed on to Windows.\n\
+When non-nil, the Start menu is opened by tapping the key.");
+Vw32_pass_rwindow_to_system = Qt;
+DEFVAR_LISP ("w32-enable-num-lock",
+	       &Vw32_enable_num_lock,
+	       "Non-nil if Num Lock should act normally.\n\
+Set to nil to see Num Lock as the key `kp-numlock'.");
+Vw32_enable_num_lock = Qt;
+DEFVAR_LISP ("w32-enable-caps-lock",
+	       &Vw32_enable_caps_lock,
+	       "Non-nil if Caps Lock should act normally.\n\
+Set to nil to see Caps Lock as the key `capslock'.");
+Vw32_enable_caps_lock = Qt;
+DEFVAR_LISP ("w32-scroll-lock-modifier",
+	       &Vw32_scroll_lock_modifier,
+	       "Modifier to use for the Scroll Lock on state.\n\
+The value can be hyper, super, meta, alt, control or shift for the\n\
+respective modifier, or nil to see Scroll Lock as the key `scroll'.\n\
+Any other value will cause the key to be ignored.");
+Vw32_scroll_lock_modifier = Qt;
+DEFVAR_LISP ("w32-lwindow-modifier",
+	       &Vw32_lwindow_modifier,
+	       "Modifier to use for the left \"Windows\" key.\n\
+The value can be hyper, super, meta, alt, control or shift for the\n\
+respective modifier, or nil to appear as the key `lwindow'.\n\
+Any other value will cause the key to be ignored.");
+Vw32_lwindow_modifier = Qnil;
+DEFVAR_LISP ("w32-rwindow-modifier",
+	       &Vw32_rwindow_modifier,
+	       "Modifier to use for the right \"Windows\" key.\n\
+The value can be hyper, super, meta, alt, control or shift for the\n\
+respective modifier, or nil to appear as the key `rwindow'.\n\
+Any other value will cause the key to be ignored.");
+Vw32_rwindow_modifier = Qnil;
+DEFVAR_LISP ("w32-apps-modifier",
+	       &Vw32_apps_modifier,
+	       "Modifier to use for the \"Apps\" key.\n\
+The value can be hyper, super, meta, alt, control or shift for the\n\
+respective modifier, or nil to appear as the key `apps'.\n\
+Any other value will cause the key to be ignored.");
+Vw32_apps_modifier = Qnil;
 DEFVAR_LISP ("w32-enable-italics", &Vw32_enable_italics,
 	       "Non-nil enables selection of artificially italicized fonts.");
 Vw32_enable_italics = Qnil;
 defsubr (&Sw32_select_font);
 defsubr (&Sw32_define_rgb_color);
 defsubr (&Sw32_default_color_map);
 defsubr (&Sw32_load_color_file);
 defsubr (&Sw32_send_sys_command);
+defsubr (&Sw32_register_hot_key);
+defsubr (&Sw32_unregister_hot_key);
+defsubr (&Sw32_registered_hot_keys);
+defsubr (&Sw32_reconstruct_hot_key);
 /* Setting callback functions for fontset handler.  */
 get_font_info_func = w32_get_font_info;
 list_fonts_func = w32_list_fonts;
 load_font_func = w32_load_font;
 }
 #undef abort
 void
+/* For convenience when debugging.  */
+int
+w32_last_error()
+{
+return GetLastError ();
+}
 w32_abort()
 {
 int button;
 button = MessageBox (NULL,
 		       "A fatal error has occurred!\n\n"

Mercurial > emacs

comparison src/w32fns.c @ 23681:af0276da2059