--- a/src/event-msw.c	Mon Aug 13 11:33:40 2007 +0200
+++ b/src/event-msw.c	Mon Aug 13 11:35:02 2007 +0200
@@ -1,7 +1,7 @@
-/* The  mswindows event_stream interface.
+/* The mswindows event_stream interface.
    Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
    Copyright (C) 1995 Sun Microsystems, Inc.
-   Copyright (C) 1996 Ben Wing.
+   Copyright (C) 1996, 2000 Ben Wing.
    Copyright (C) 1997 Jonathan Harris.
 
 This file is part of XEmacs.
@@ -41,6 +41,7 @@
 #endif
 
 #ifdef HAVE_MENUBARS
+# include "menubar.h"
 # include "menubar-msw.h"
 #endif
 
@@ -57,6 +58,7 @@
 #include "process.h"
 #include "redisplay.h"
 #include "select.h"
+#include "window.h"
 #include "sysproc.h"
 #include "syswait.h"
 #include "systime.h"
@@ -67,14 +69,14 @@
 #ifdef HAVE_MSG_SELECT
 #include "sysfile.h"
 #include "console-tty.h"
-#elif defined(__CYGWIN32__)
+#elif defined(CYGWIN)
 typedef unsigned int SOCKET;
 #endif
 #include <io.h>
 #include <errno.h>
 
-#if defined (__CYGWIN32__) && (CYGWIN_VERSION_DLL_MAJOR < 20)
-typedef NMHDR *LPNMHDR;
+#if !(defined(CYGWIN) || defined(MINGW))
+# include <shlobj.h>	/* For IShellLink */
 #endif
 
 #ifdef HAVE_MENUBARS
@@ -94,10 +96,13 @@
 static Lisp_Object mswindows_find_console (HWND hwnd);
 static Lisp_Object mswindows_key_to_emacs_keysym (int mswindows_key, int mods,
 						  int extendedp);
-static int mswindows_modifier_state (BYTE* keymap, int has_AltGr);
+static int mswindows_modifier_state (BYTE* keymap, DWORD fwKeys,
+				     int has_AltGr);
 static void mswindows_set_chord_timer (HWND hwnd);
 static int mswindows_button2_near_enough (POINTS p1, POINTS p2);
 static int mswindows_current_layout_has_AltGr (void);
+static int mswindows_handle_sticky_modifiers (WPARAM wParam, LPARAM lParam,
+					      int downp, int keyp);
 
 static struct event_stream *mswindows_event_stream;
 
@@ -128,6 +133,7 @@
 /* Number of wait handles */
 static int mswindows_waitable_count=0;
 #endif /* HAVE_MSG_SELECT */
+
 /* Brush for painting widgets */
 static HBRUSH widget_brush = 0;
 static LONG	last_widget_brushed = 0;
@@ -139,12 +145,16 @@
 
 /* These are Lisp integers; see DEFVARS in this file for description. */
 int mswindows_dynamic_frame_resize;
-int mswindows_meta_activates_menu;
+int mswindows_alt_by_itself_activates_menu;
 int mswindows_num_mouse_buttons;
 int mswindows_mouse_button_max_skew_x;
 int mswindows_mouse_button_max_skew_y;
 int mswindows_mouse_button_tolerance;
 
+#ifdef DEBUG_XEMACS
+int debug_mswindows_events;
+#endif
+
 /* This is the event signaled by the event pump.
    See mswindows_pump_outstanding_events for comments */
 static Lisp_Object mswindows_error_caught_in_modal_loop;
@@ -152,6 +162,8 @@
 
 /* Count of wound timers */
 static int mswindows_pending_timers_count;
+
+static DWORD mswindows_last_mouse_button_state;
 
 /************************************************************************/
 /*                Pipe instream - reads process output                  */
@@ -178,11 +190,11 @@
 struct ntpipe_slurp_stream_shared_data
 {
   HANDLE hev_thread;	/* Our thread blocks on this, signaled by caller */
-			/* This is a manual-reset object. 		 */
+  /* This is a manual-reset object. 		 */
   HANDLE hev_caller;	/* Caller blocks on this, and we signal it	 */
-			/* This is a manual-reset object. 		 */
+  /* This is a manual-reset object. 		 */
   HANDLE hev_unsleep;	/* Pipe read delay is canceled if this is set	 */
-			/* This is a manual-reset object. 		 */
+  /* This is a manual-reset object. 		 */
   HANDLE hpipe;		/* Pipe read end handle.			 */
   LONG   die_p;		/* Thread must exit ASAP if non-zero		 */
   BOOL   eof_p   : 1;	/* Set when thread saw EOF			 */
@@ -221,7 +233,7 @@
 }
 
 static struct ntpipe_slurp_stream_shared_data*
-slurper_allocate_shared_data()
+slurper_allocate_shared_data (void)
 {
   int i=0;
   for (i=0; i<MAX_SLURP_STREAMS; i++)
@@ -462,13 +474,13 @@
 #define NTPIPE_SHOVE_STREAM_DATA(stream) \
   LSTREAM_TYPE_DATA (stream, ntpipe_shove)
 
-#define MAX_SHOVE_BUFFER_SIZE 128
+#define MAX_SHOVE_BUFFER_SIZE 512
 
 struct ntpipe_shove_stream
 {
   LPARAM user_data;	/* Any user data stored in the stream object	 */
   HANDLE hev_thread;	/* Our thread blocks on this, signaled by caller */
-			/* This is an auto-reset object. 		 */
+  /* This is an auto-reset object. 		 */
   HANDLE hpipe;		/* Pipe write end handle.			 */
   HANDLE hthread;	/* Reader thread handle.			 */
   char	 buffer[MAX_SHOVE_BUFFER_SIZE];	/* Buffer being written		 */
@@ -496,15 +508,18 @@
       InterlockedIncrement (&s->idle_p);
       WaitForSingleObject (s->hev_thread, INFINITE);
 
-      if (s->die_p)
-	break;
-
-      /* Write passed buffer */
-      if (!WriteFile (s->hpipe, s->buffer, s->size, &bytes_written, NULL)
-	  || bytes_written != s->size)
+      /* Write passed buffer if any */
+      if (s->size > 0)
 	{
-	  s->error_p = TRUE;
-	  InterlockedIncrement (&s->die_p);
+         if (!WriteFile (s->hpipe, s->buffer, s->size, &bytes_written, NULL)
+             || bytes_written != s->size)
+           {
+             s->error_p = TRUE;
+             InterlockedIncrement (&s->die_p);
+           }
+         /* Set size to zero so we won't write it again if the closer sets
+            die_p and kicks us */
+         s->size = 0;
 	}
 
       if (s->die_p)
@@ -537,6 +552,15 @@
       return Qnil;
     }
 
+  /* Set the priority of the thread higher so we don't end up waiting
+     on it to send things. */
+  if (!SetThreadPriority (s->hthread, THREAD_PRIORITY_HIGHEST))
+    {
+      CloseHandle (s->hthread);
+      Lstream_delete (lstr);
+      return Qnil;
+    }
+
   /* hev_thread is an auto-reset event, initially nonsignaled */
   s->hev_thread = CreateEvent (NULL, FALSE, FALSE, NULL);
 
@@ -577,6 +601,10 @@
   /* Start output */
   InterlockedDecrement (&s->idle_p);
   SetEvent (s->hev_thread);
+  /* Give it a chance to run -- this dramatically improves performance
+     of things like crypt. */
+  if (xSwitchToThread) /* not in Win9x or NT 3.51 */
+    (void) xSwitchToThread ();
   return size;
 }
 
@@ -595,14 +623,18 @@
   /* Force thread stop */
   InterlockedIncrement (&s->die_p);
 
-  /* Close pipe handle, possibly breaking it */
-  CloseHandle (s->hpipe);
-
-  /* Thread will end upon unblocking */
+  /* Thread will end upon unblocking.  If it's already unblocked this will
+     do nothing, but the thread won't look at die_p until it's written any
+     pending output. */
   SetEvent (s->hev_thread);
 
   /* Wait while thread terminates */
   WaitForSingleObject (s->hthread, INFINITE);
+
+  /* Close pipe handle, possibly breaking it */
+  CloseHandle (s->hpipe);
+
+  /* Close the thread handle */
   CloseHandle (s->hthread);
 
   /* Destroy the event */
@@ -632,8 +664,8 @@
   SOCKET s;			/* Socket handle (which is a Win32 handle)   */
   OVERLAPPED ov;		/* Overlapped I/O structure		     */
   void* buffer;			/* Buffer. Allocated for input stream only   */
-  unsigned int bufsize;		/* Number of bytes last read		     */
-  unsigned int bufpos;		/* Position in buffer for next fetch	     */
+  unsigned long bufsize;	/* Number of bytes last read		     */
+  unsigned long bufpos;		/* Position in buffer for next fetch	     */
   unsigned int error_p :1;	/* I/O Error seen			     */
   unsigned int eof_p :1;	/* EOF Error seen			     */
   unsigned int pending_p :1;	/* There is a pending I/O operation	     */
@@ -712,7 +744,7 @@
 }
 
 static ssize_t
-winsock_writer (Lstream *stream, CONST unsigned char *data, size_t size)
+winsock_writer (Lstream *stream, const unsigned char *data, size_t size)
 {
   struct winsock_stream *str = WINSOCK_STREAM_DATA (stream);
 
@@ -785,7 +817,7 @@
 }
 
 static Lisp_Object
-make_winsock_stream_1 (SOCKET s, LPARAM param, CONST char *mode)
+make_winsock_stream_1 (SOCKET s, LPARAM param, const char *mode)
 {
   Lisp_Object obj;
   Lstream *lstr = Lstream_new (lstream_winsock, mode);
@@ -864,15 +896,15 @@
 /*
  * Add an emacs event to the proper dispatch queue
  */
-static void
+void
 mswindows_enqueue_dispatch_event (Lisp_Object event)
 {
   int user_p = mswindows_user_event_p (XEVENT(event));
   enqueue_event (event,
 		 user_p ? &mswindows_u_dispatch_event_queue :
-		 	&mswindows_s_dispatch_event_queue,
+		 &mswindows_s_dispatch_event_queue,
 		 user_p ? &mswindows_u_dispatch_event_queue_tail :
-		 	&mswindows_s_dispatch_event_queue_tail);
+		 &mswindows_s_dispatch_event_queue_tail);
 
   /* Avoid blocking on WaitMessage */
   PostMessage (NULL, XM_BUMPQUEUE, 0, 0);
@@ -930,27 +962,30 @@
 }
 
 static void
-mswindows_enqueue_mouse_button_event (HWND hwnd, UINT msg, POINTS where, DWORD when)
+mswindows_enqueue_mouse_button_event (HWND hwnd, UINT msg, POINTS where,
+				      int mods, DWORD when)
 {
+  int downp = (msg == WM_LBUTTONDOWN || msg == WM_MBUTTONDOWN ||
+	       msg == WM_RBUTTONDOWN);
 
   /* We always use last message time, because mouse button
      events may get delayed, and XEmacs double click
      recognition will fail */
 
   Lisp_Object emacs_event = Fmake_event (Qnil, Qnil);
-  Lisp_Event* event = XEVENT(emacs_event);
-
-  event->channel = mswindows_find_frame(hwnd);
+  Lisp_Event* event = XEVENT (emacs_event);
+
+  mswindows_handle_sticky_modifiers (0, 0, downp, 0);
+  event->channel = mswindows_find_frame (hwnd);
   event->timestamp = when;
   event->event.button.button =
     (msg==WM_LBUTTONDOWN || msg==WM_LBUTTONUP) ? 1 :
     ((msg==WM_RBUTTONDOWN || msg==WM_RBUTTONUP) ? 3 : 2);
   event->event.button.x = where.x;
   event->event.button.y = where.y;
-  event->event.button.modifiers = mswindows_modifier_state (NULL, 0);
-
-  if (msg==WM_LBUTTONDOWN || msg==WM_MBUTTONDOWN ||
-      msg==WM_RBUTTONDOWN)
+  event->event.button.modifiers = mswindows_modifier_state (NULL, mods, 0);
+
+  if (downp)
     {
       event->event_type = button_press_event;
       SetCapture (hwnd);
@@ -990,7 +1025,7 @@
  * Give a preference to user events over non-user ones.
  */
 static Lisp_Object
-mswindows_dequeue_dispatch_event ()
+mswindows_dequeue_dispatch_event (void)
 {
   Lisp_Object event;
   Lisp_Event* sevt;
@@ -999,10 +1034,10 @@
 	  !NILP(mswindows_s_dispatch_event_queue));
 
   event = dequeue_event (
-		 NILP(mswindows_u_dispatch_event_queue) ?
+			 NILP(mswindows_u_dispatch_event_queue) ?
 			 &mswindows_s_dispatch_event_queue :
 			 &mswindows_u_dispatch_event_queue,
-		 NILP(mswindows_u_dispatch_event_queue) ?
+			 NILP(mswindows_u_dispatch_event_queue) ?
 			 &mswindows_s_dispatch_event_queue_tail :
 			 &mswindows_u_dispatch_event_queue_tail);
 
@@ -1033,9 +1068,9 @@
   Lisp_Object previous_event = Qnil;
   int user_p = mswindows_user_event_p (match);
   Lisp_Object* head = user_p ? &mswindows_u_dispatch_event_queue :
-    			       &mswindows_s_dispatch_event_queue;
+    &mswindows_s_dispatch_event_queue;
   Lisp_Object* tail = user_p ? &mswindows_u_dispatch_event_queue_tail :
-    			       &mswindows_s_dispatch_event_queue_tail;
+    &mswindows_s_dispatch_event_queue_tail;
 
   assert (match->event_type == timeout_event
 	  || match->event_type == key_press_event);
@@ -1220,7 +1255,7 @@
   GCPRO1 (result);
 
   if (NILP(mswindows_error_caught_in_modal_loop))
-      result = mswindows_protect_modal_loop (mswindows_unsafe_pump_events, Qnil);
+    result = mswindows_protect_modal_loop (mswindows_unsafe_pump_events, Qnil);
   UNGCPRO;
   return result;
 }
@@ -1230,27 +1265,59 @@
  * QUITP, and are interesting in keyboard messages only.
  */
 static void
-mswindows_drain_windows_queue (int keyboard_only_till_quit_char_p)
+mswindows_drain_windows_queue (void)
 {
   MSG msg;
 
-  /* Minimize the hassle of misordered events by not fetching
-     past quit char if called from QUITP; */
-  while (!(keyboard_only_till_quit_char_p &&
-	   mswindows_quit_chars_count > 0) &&
-	 PeekMessage (&msg, NULL,
-		      keyboard_only_till_quit_char_p ? WM_KEYFIRST : 0,
-		      keyboard_only_till_quit_char_p ? WM_KEYLAST : 0,
-		      PM_REMOVE))
+  /* should call mswindows_need_event_in_modal_loop() if in modal loop */
+  assert (!mswindows_in_modal_loop);
+
+  while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
     {
-      /* We have to translate messages that are not sent to the main
-         window. This is so that key presses work ok in things like
-         edit fields. However, we *musn't* translate message for the
-         main window as this is handled in the wnd proc. */
-      if (GetWindowLong (msg.hwnd, GWL_STYLE) & WS_CHILD)
+      char class_name_buf [sizeof (XEMACS_CLASS) + 2] = "";
+
+      if (mswindows_is_dialog_msg (&msg))
+	{
+	  mswindows_unmodalize_signal_maybe ();
+	  continue;
+	}
+
+      /* We have to translate messages that are not sent to an XEmacs
+         frame. This is so that key presses work ok in things like
+         edit fields. However, we *musn't* translate message for XEmacs
+         frames as this is handled in the wnd proc.
+         We also have to avoid generating paint magic events for windows
+	 that aren't XEmacs frames */
+      /* GetClassName will truncate a longer class name. By adding one
+	 extra character, we are forcing textual comparison to fail
+	 if the name is longer than XEMACS_CLASS */
+
+      GetClassName (msg.hwnd, class_name_buf, sizeof (class_name_buf) - 1);
+      if (stricmp (class_name_buf, XEMACS_CLASS) != 0)
 	{
+	  /* Not an XEmacs frame */
 	  TranslateMessage (&msg);
 	}
+      else if (msg.message == WM_PAINT)
+	{
+	  struct mswindows_frame* msframe;
+
+	  /* hdc will be NULL unless this is a subwindow - in which case we
+	     shouldn't have received a paint message for it here. */
+	  assert (msg.wParam == 0);
+
+	  /* Queue a magic event for handling when safe */
+	  msframe =
+	    FRAME_MSWINDOWS_DATA (XFRAME (mswindows_find_frame (msg.hwnd)));
+	  if (!msframe->paint_pending)
+	    {
+	      msframe->paint_pending = 1;
+	      mswindows_enqueue_magic_event (msg.hwnd, WM_PAINT);
+	    }
+	  /* Don't dispatch. WM_PAINT is always the last message in the
+	     queue so it's OK to just return. */
+	  return;
+	}
       DispatchMessage (&msg);
       mswindows_unmodalize_signal_maybe ();
     }
@@ -1314,14 +1381,6 @@
       return;
     }
 
-#if 0
-  /* Have to drain Windows message queue first, otherwise, we may miss
-     quit char when called from quit_p */
-  /* #### This is, ehm, not quite true -- this function is not
-     called from quit_p. --kkm */
-  mswindows_drain_windows_queue ();
-#endif
-
   while (NILP (mswindows_u_dispatch_event_queue)
 	 && NILP (mswindows_s_dispatch_event_queue))
     {
@@ -1351,50 +1410,53 @@
 	{
 	  if (FD_ISSET (windows_fd, &temp_mask))
 	    {
-	      mswindows_drain_windows_queue (0);
+	      mswindows_drain_windows_queue ();
 	    }
-#ifdef HAVE_TTY
-	  /* Look for a TTY event */
-	  for (i = 0; i < MAXDESC-1; i++)
+	  else
 	    {
-	      /* To avoid race conditions (among other things, an infinite
-		 loop when called from Fdiscard_input()), we must return
-		 user events ahead of process events. */
-	      if (FD_ISSET (i, &temp_mask) && FD_ISSET (i, &tty_only_mask))
+#ifdef HAVE_TTY
+	      /* Look for a TTY event */
+	      for (i = 0; i < MAXDESC-1; i++)
 		{
-		  struct console *c = tty_find_console_from_fd (i);
-		  Lisp_Object emacs_event = Fmake_event (Qnil, Qnil);
-		  Lisp_Event* event = XEVENT (emacs_event);
-
-		  assert (c);
-		  if (read_event_from_tty_or_stream_desc (event, c, i))
+		  /* To avoid race conditions (among other things, an infinite
+		     loop when called from Fdiscard_input()), we must return
+		     user events ahead of process events. */
+		  if (FD_ISSET (i, &temp_mask) && FD_ISSET (i, &tty_only_mask))
 		    {
-		      mswindows_enqueue_dispatch_event (emacs_event);
-		      return;
+		      struct console *c = tty_find_console_from_fd (i);
+		      Lisp_Object emacs_event = Fmake_event (Qnil, Qnil);
+		      Lisp_Event* event = XEVENT (emacs_event);
+
+		      assert (c);
+		      if (read_event_from_tty_or_stream_desc (event, c, i))
+			{
+			  mswindows_enqueue_dispatch_event (emacs_event);
+			  return;
+			}
 		    }
 		}
-	    }
 #endif
-	  /* Look for a process event */
-	  for (i = 0; i < MAXDESC-1; i++)
-	    {
-	      if (FD_ISSET (i, &temp_mask))
+	      /* Look for a process event */
+	      for (i = 0; i < MAXDESC-1; i++)
 		{
-		  if (FD_ISSET (i, &process_only_mask))
+		  if (FD_ISSET (i, &temp_mask))
 		    {
-		      Lisp_Process *p =
-			get_process_from_usid (FD_TO_USID(i));
-
-		      mswindows_enqueue_process_event (p);
-		    }
-		  else
-		    {
-		      /* We might get here when a fake event came
-                         through a signal. Return a dummy event, so
-                         that a cycle of the command loop will
-                         occur. */
-		      drain_signal_event_pipe ();
-		      mswindows_enqueue_magic_event (NULL, XM_BUMPQUEUE);
+		      if (FD_ISSET (i, &process_only_mask))
+			{
+			  Lisp_Process *p =
+			    get_process_from_usid (FD_TO_USID(i));
+
+			  mswindows_enqueue_process_event (p);
+			}
+		      else
+			{
+			  /* We might get here when a fake event came
+			     through a signal. Return a dummy event, so
+			     that a cycle of the command loop will
+			     occur. */
+			  drain_signal_event_pipe ();
+			  mswindows_enqueue_magic_event (NULL, XM_BUMPQUEUE);
+			}
 		    }
 		}
 	    }
@@ -1413,53 +1475,65 @@
 	}
 #else
       /* Now try getting a message or process event */
-    active = MsgWaitForMultipleObjects (mswindows_waitable_count,
-					mswindows_waitable_handles,
-					FALSE, badly_p ? INFINITE : 0,
-					QS_ALLINPUT);
-
-    /* This will assert if handle being waited for becomes abandoned.
-       Not the case currently tho */
-    assert ((!badly_p && active == WAIT_TIMEOUT) ||
-	    (active >= WAIT_OBJECT_0 &&
-	     active <= WAIT_OBJECT_0 + mswindows_waitable_count));
-
-    if (active == WAIT_TIMEOUT)
-      {
-	/* No luck trying - just return what we've already got */
-	return;
-      }
-    else if (active == WAIT_OBJECT_0 + mswindows_waitable_count)
-      {
-	/* Got your message, thanks */
-	mswindows_drain_windows_queue (0);
-      }
-    else
-      {
-	int ix = active - WAIT_OBJECT_0;
-	/* First, try to find which process' output has signaled */
-	Lisp_Process *p =
-	  get_process_from_usid (HANDLE_TO_USID (mswindows_waitable_handles[ix]));
-	if (p != NULL)
-	  {
-	    /* Found a signaled process input handle */
-	    mswindows_enqueue_process_event (p);
-	  }
-	else
-	  {
-	    /* None. This means that the process handle itself has signaled.
-	       Remove the handle from the wait vector, and make status_notify
-	       note the exited process */
-	    mswindows_waitable_handles [ix] =
-	      mswindows_waitable_handles [--mswindows_waitable_count];
-	    kick_status_notify ();
-	    /* Have to return something: there may be no accompanying
-	       process event */
-	    mswindows_enqueue_magic_event (NULL, XM_BUMPQUEUE);
-	  }
-      }
+      active = MsgWaitForMultipleObjects (mswindows_waitable_count,
+					  mswindows_waitable_handles,
+					  FALSE, badly_p ? INFINITE : 0,
+					  QS_ALLINPUT);
+
+      /* This will assert if handle being waited for becomes abandoned.
+	 Not the case currently tho */
+      assert ((!badly_p && active == WAIT_TIMEOUT) ||
+	      (active >= WAIT_OBJECT_0 &&
+	       active <= WAIT_OBJECT_0 + mswindows_waitable_count));
+
+      if (active == WAIT_TIMEOUT)
+	{
+	  /* No luck trying - just return what we've already got */
+	  return;
+	}
+      else if (active == WAIT_OBJECT_0 + mswindows_waitable_count)
+	{
+	  /* Got your message, thanks */
+	  mswindows_drain_windows_queue ();
+	}
+      else
+	{
+	  int ix = active - WAIT_OBJECT_0;
+	  /* First, try to find which process' output has signaled */
+	  Lisp_Process *p =
+	    get_process_from_usid (HANDLE_TO_USID (mswindows_waitable_handles[ix]));
+	  if (p != NULL)
+	    {
+	      /* Found a signaled process input handle */
+	      mswindows_enqueue_process_event (p);
+	    }
+	  else
+	    {
+	      /* None. This means that the process handle itself has signaled.
+		 Remove the handle from the wait vector, and make status_notify
+		 note the exited process */
+	      mswindows_waitable_handles [ix] =
+		mswindows_waitable_handles [--mswindows_waitable_count];
+	      kick_status_notify ();
+	      /* We need to return a process event here so that
+		 (1) accept-process-output will return when called on this
+		 process, and (2) status notifications will happen in
+		 accept-process-output, sleep-for, and sit-for. */
+	      /* #### horrible kludge till my real process fixes go in.
+	       */
+	      if (!NILP (Vprocess_list))
+		{
+		  Lisp_Object vaffanculo = XCAR (Vprocess_list);
+		  mswindows_enqueue_process_event (XPROCESS (vaffanculo));
+		}
+	      else /* trash me soon. */
+		/* Have to return something: there may be no accompanying
+		   process event */
+		mswindows_enqueue_magic_event (NULL, XM_BUMPQUEUE);
+	    }
+	}
 #endif
-  } /* while */
+    } /* while */
 }
 
 /************************************************************************/
@@ -1514,7 +1588,7 @@
 	  { mswindows_dde_service, mswindows_dde_topic_system }, { 0, 0 } };
 
 	if (!(hszItem  || DdeCmpStringHandles (hszItem, mswindows_dde_service)) &&
-	    !(hszTopic || DdeCmpStringHandles (hszTopic, mswindows_dde_topic_system)));
+	    !(hszTopic || DdeCmpStringHandles (hszTopic, mswindows_dde_topic_system)))
 	  return (DdeCreateDataHandle (mswindows_dde_mlid, (LPBYTE)pairs,
 				       sizeof (pairs), 0L, 0, uFmt, 0));
       }
@@ -1524,7 +1598,7 @@
       if (!DdeCmpStringHandles (hszTopic, mswindows_dde_topic_system))
 	{
 	  DWORD len = DdeGetData (hdata, NULL, 0, 0);
-	  char *cmd = alloca (len+1);
+	  LPBYTE cmd = (LPBYTE) alloca (len+1);
 	  char *end;
 	  char *filename;
 	  struct gcpro gcpro1, gcpro2;
@@ -1563,7 +1637,7 @@
 	  if (*end)
 	    return DDE_FNOTPROCESSED;
 
-#ifdef __CYGWIN32__
+#ifdef CYGWIN
 	  filename = alloca (cygwin32_win32_to_posix_path_list_buf_size (cmd) + 5);
 	  strcpy (filename, "file:");
 	  cygwin32_win32_to_posix_path_list (cmd, filename+5);
@@ -1609,23 +1683,336 @@
 #endif
 
 /*
- * Returns 1 if a key is a real modifier or special key, which 
+ * Helper to do repainting - repaints can happen both from the windows
+ * procedure and from magic events
+ */
+static void
+mswindows_handle_paint (struct frame *frame)
+{
+  HWND hwnd = FRAME_MSWINDOWS_HANDLE (frame);
+
+  /* According to the docs we need to check GetUpdateRect() before
+     actually doing a WM_PAINT */
+  if (GetUpdateRect (hwnd, NULL, FALSE))
+    {
+      PAINTSTRUCT paintStruct;
+      int x, y, width, height;
+
+      BeginPaint (hwnd, &paintStruct);
+      x = paintStruct.rcPaint.left;
+      y = paintStruct.rcPaint.top;
+      width = paintStruct.rcPaint.right - paintStruct.rcPaint.left;
+      height = paintStruct.rcPaint.bottom - paintStruct.rcPaint.top;
+      /* Normally we want to ignore expose events when child
+	 windows are unmapped, however once we are in the guts of
+	 WM_PAINT we need to make sure that we don't register
+	 unmaps then because they will not actually occur. */
+      /* #### commenting out the next line seems to fix some problems
+	 but not all.  only andy currently understands this stuff and
+	 he needs to review it more carefully. --ben */
+      if (!check_for_ignored_expose (frame, x, y, width, height))
+	{
+	  hold_ignored_expose_registration = 1;
+	  mswindows_redraw_exposed_area (frame, x, y, width, height);
+	  hold_ignored_expose_registration = 0;
+	}
+      EndPaint (hwnd, &paintStruct);
+    }
+}
+
+/*
+ * Returns 1 if a key is a real modifier or special key, which
  * is better handled by DefWindowProc
  */
 static int
 key_needs_default_processing_p (UINT vkey)
 {
-  if (mswindows_meta_activates_menu && vkey == VK_MENU)
+  if (mswindows_alt_by_itself_activates_menu && vkey == VK_MENU
+      /* if we let ALT activate the menu like this, then sticky ALT-modified
+	 keystrokes become impossible. */
+      && !modifier_keys_are_sticky)
     return 1;
 
   return 0;
 }
 
+/* key-handling code is always ugly.  It just ends up working out
+   that way.
+
+   #### Most of the sticky-modifier code below is copied from similar
+   code in event-Xt.c.  They should somehow or other be merged.
+
+   Here are some pointers:
+
+   -- DOWN_MASK indicates which modifiers should be treated as "down"
+      when the corresponding upstroke happens.  It gets reset for
+      a particular modifier when that modifier goes up, and reset
+      for all modifiers when a non-modifier key is pressed.  Example:
+
+      I press Control-A-Shift and then release Control-A-Shift.
+      I want the Shift key to be sticky but not the Control key.
+
+   -- If a modifier key is sticky, I can unstick it by pressing
+      the modifier key again. */
+
+static WPARAM last_downkey;
+static int need_to_add_mask, down_mask;
+
+#define XEMSW_LCONTROL (1<<0)
+#define XEMSW_RCONTROL (1<<1)
+#define XEMSW_LSHIFT (1<<2)
+#define XEMSW_RSHIFT (1<<3)
+#define XEMSW_LMENU (1<<4)
+#define XEMSW_RMENU (1<<5)
+
+static int
+mswindows_handle_sticky_modifiers (WPARAM wParam, LPARAM lParam,
+				   int downp, int keyp)
+{
+  int mods = 0;
+
+  if (!modifier_keys_are_sticky) /* Optimize for non-sticky modifiers */
+    return 0;
+
+  if (! (keyp &&
+	 (wParam == VK_CONTROL || wParam == VK_LCONTROL ||
+	  wParam == VK_RCONTROL ||
+	  wParam == VK_MENU || wParam == VK_LMENU ||
+	  wParam == VK_RMENU ||
+	  wParam == VK_SHIFT || wParam == VK_LSHIFT ||
+	  wParam == VK_RSHIFT)))
+    { /* Not a modifier key */
+      if (downp && keyp && !last_downkey)
+	last_downkey = wParam;
+      /* If I hold press-and-release the Control key and then press
+	 and hold down the right arrow, I want it to auto-repeat
+	 Control-Right.  On the other hand, if I do the same but
+	 manually press the Right arrow a bunch of times, I want
+	 to see one Control-Right and then a bunch of Rights.
+	 This means that we need to distinguish between an
+	 auto-repeated key and a key pressed and released a bunch
+	 of times. */
+      else if ((downp && !keyp) ||
+	       (downp && keyp && last_downkey &&
+		(wParam != last_downkey ||
+		 /* the "previous key state" bit indicates autorepeat */
+		 ! (lParam & (1 << 30)))))
+	{
+	  need_to_add_mask = 0;
+	  last_downkey = 0;
+	}
+      if (downp)
+	down_mask = 0;
+
+      mods = need_to_add_mask;
+    }
+  else                          /* Modifier key pressed */
+    {
+      /* If a non-modifier key was pressed in the middle of a bunch
+	 of modifiers, then it unsticks all the modifiers that were
+	 previously pressed.  We cannot unstick the modifiers until
+	 now because we want to check for auto-repeat of the
+	 non-modifier key. */
+
+      if (last_downkey)
+	{
+	  last_downkey = 0;
+	  need_to_add_mask = 0;
+	}
+
+#define FROB(mask)				\
+do {						\
+  if (downp && keyp)				\
+    {						\
+      /* If modifier key is already sticky,	\
+         then unstick it.  Note that we do	\
+         not test down_mask to deal with the	\
+	 unlikely but possible case that the	\
+	 modifier key auto-repeats. */		\
+      if (need_to_add_mask & mask)		\
+	{					\
+	  need_to_add_mask &= ~mask;		\
+	  down_mask &= ~mask;			\
+	}					\
+      else					\
+	down_mask |= mask;			\
+    }						\
+  else						\
+    {						\
+      if (down_mask & mask)			\
+	{					\
+	  down_mask &= ~mask;			\
+	  need_to_add_mask |= mask;		\
+	}					\
+    }						\
+} while (0)
+
+      if ((wParam == VK_CONTROL && (lParam & 0x1000000))
+	  || wParam == VK_RCONTROL)
+	FROB (XEMSW_RCONTROL);
+      if ((wParam == VK_CONTROL && !(lParam & 0x1000000))
+	  || wParam == VK_LCONTROL)
+	FROB (XEMSW_LCONTROL);
+
+      if ((wParam == VK_SHIFT && (lParam & 0x1000000))
+	  || wParam == VK_RSHIFT)
+	FROB (XEMSW_RSHIFT);
+      if ((wParam == VK_SHIFT && !(lParam & 0x1000000))
+	  || wParam == VK_LSHIFT)
+	FROB (XEMSW_LSHIFT);
+
+      if ((wParam == VK_MENU && (lParam & 0x1000000))
+	  || wParam == VK_RMENU)
+	FROB (XEMSW_RMENU);
+      if ((wParam == VK_MENU && !(lParam & 0x1000000))
+	  || wParam == VK_LMENU)
+	FROB (XEMSW_LMENU);
+    }
+#undef FROB
+
+  if (mods && downp)
+    {
+      BYTE keymap[256];
+
+      GetKeyboardState (keymap);
+
+      if (mods & XEMSW_LCONTROL)
+	{
+	  keymap [VK_CONTROL] |= 0x80;
+	  keymap [VK_LCONTROL] |= 0x80;
+	}
+      if (mods & XEMSW_RCONTROL)
+	{
+	  keymap [VK_CONTROL] |= 0x80;
+	  keymap [VK_RCONTROL] |= 0x80;
+	}
+
+      if (mods & XEMSW_LSHIFT)
+	{
+	  keymap [VK_SHIFT] |= 0x80;
+	  keymap [VK_LSHIFT] |= 0x80;
+	}
+      if (mods & XEMSW_RSHIFT)
+	{
+	  keymap [VK_SHIFT] |= 0x80;
+	  keymap [VK_RSHIFT] |= 0x80;
+	}
+
+      if (mods & XEMSW_LMENU)
+	{
+	  keymap [VK_MENU] |= 0x80;
+	  keymap [VK_LMENU] |= 0x80;
+	}
+      if (mods & XEMSW_RMENU)
+	{
+	  keymap [VK_MENU] |= 0x80;
+	  keymap [VK_RMENU] |= 0x80;
+	}
+
+      SetKeyboardState (keymap);
+      return 1;
+    }
+
+  return 0;
+}
+
+static void
+clear_sticky_modifiers (void)
+{
+  need_to_add_mask = 0;
+  last_downkey     = 0;
+  down_mask        = 0;
+}
+
+#ifdef DEBUG_XEMACS
+
+#if 0
+
+static void
+output_modifier_keyboard_state (void)
+{
+  BYTE keymap[256];
+
+  GetKeyboardState (keymap);
+
+  stderr_out ("GetKeyboardState VK_MENU %d %d VK_LMENU %d %d VK_RMENU %d %d\n",
+	      keymap[VK_MENU] & 0x80 ? 1 : 0,
+	      keymap[VK_MENU] & 0x1 ? 1 : 0,
+	      keymap[VK_LMENU] & 0x80 ? 1 : 0,
+	      keymap[VK_LMENU] & 0x1 ? 1 : 0,
+	      keymap[VK_RMENU] & 0x80 ? 1 : 0,
+	      keymap[VK_RMENU] & 0x1 ? 1 : 0);
+  stderr_out ("GetKeyboardState VK_CONTROL %d %d VK_LCONTROL %d %d VK_RCONTROL %d %d\n",
+	      keymap[VK_CONTROL] & 0x80 ? 1 : 0,
+	      keymap[VK_CONTROL] & 0x1 ? 1 : 0,
+	      keymap[VK_LCONTROL] & 0x80 ? 1 : 0,
+	      keymap[VK_LCONTROL] & 0x1 ? 1 : 0,
+	      keymap[VK_RCONTROL] & 0x80 ? 1 : 0,
+	      keymap[VK_RCONTROL] & 0x1 ? 1 : 0);
+  stderr_out ("GetKeyboardState VK_SHIFT %d %d VK_LSHIFT %d %d VK_RSHIFT %d %d\n",
+	      keymap[VK_SHIFT] & 0x80 ? 1 : 0,
+	      keymap[VK_SHIFT] & 0x1 ? 1 : 0,
+	      keymap[VK_LSHIFT] & 0x80 ? 1 : 0,
+	      keymap[VK_LSHIFT] & 0x1 ? 1 : 0,
+	      keymap[VK_RSHIFT] & 0x80 ? 1 : 0,
+	      keymap[VK_RSHIFT] & 0x1 ? 1 : 0);
+}
+
+#endif
+
+/* try to debug the stuck-alt-key problem.
+
+ #### this happens only inconsistently, and may only happen when using
+ StickyKeys in the Win2000 accessibility section of the control panel,
+ which is extremely broken for other reasons.  */
+
+static void
+output_alt_keyboard_state (void)
+{
+  BYTE keymap[256];
+  SHORT keystate[3];
+  // SHORT asyncstate[3];
+
+  GetKeyboardState (keymap);
+  keystate[0] = GetKeyState (VK_MENU);
+  keystate[1] = GetKeyState (VK_LMENU);
+  keystate[2] = GetKeyState (VK_RMENU);
+  /* Doing this interferes with key processing. */
+/*   asyncstate[0] = GetAsyncKeyState (VK_MENU); */
+/*   asyncstate[1] = GetAsyncKeyState (VK_LMENU); */
+/*   asyncstate[2] = GetAsyncKeyState (VK_RMENU); */
+
+  stderr_out ("GetKeyboardState VK_MENU %d %d VK_LMENU %d %d VK_RMENU %d %d\n",
+	      keymap[VK_MENU] & 0x80 ? 1 : 0,
+	      keymap[VK_MENU] & 0x1 ? 1 : 0,
+	      keymap[VK_LMENU] & 0x80 ? 1 : 0,
+	      keymap[VK_LMENU] & 0x1 ? 1 : 0,
+	      keymap[VK_RMENU] & 0x80 ? 1 : 0,
+	      keymap[VK_RMENU] & 0x1 ? 1 : 0);
+  stderr_out ("GetKeyState VK_MENU %d %d VK_LMENU %d %d VK_RMENU %d %d\n",
+	      keystate[0] & 0x8000 ? 1 : 0,
+	      keystate[0] & 0x1 ? 1 : 0,
+	      keystate[1] & 0x8000 ? 1 : 0,
+	      keystate[1] & 0x1 ? 1 : 0,
+	      keystate[2] & 0x8000 ? 1 : 0,
+	      keystate[2] & 0x1 ? 1 : 0);
+/*   stderr_out ("GetAsyncKeyState VK_MENU %d %d VK_LMENU %d %d VK_RMENU %d %d\n", */
+/* 	      asyncstate[0] & 0x8000 ? 1 : 0, */
+/* 	      asyncstate[0] & 0x1 ? 1 : 0, */
+/* 	      asyncstate[1] & 0x8000 ? 1 : 0, */
+/* 	      asyncstate[1] & 0x1 ? 1 : 0, */
+/* 	      asyncstate[2] & 0x8000 ? 1 : 0, */
+/* 	      asyncstate[2] & 0x1 ? 1 : 0); */
+}
+
+#endif /* DEBUG_XEMACS */
+
+
 /*
  * The windows procedure for the window class XEMACS_CLASS
  */
 LRESULT WINAPI
-mswindows_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
+mswindows_wnd_proc (HWND hwnd, UINT message_, WPARAM wParam, LPARAM lParam)
 {
   /* Note: Remember to initialize emacs_event and event before use.
      This code calls code that can GC. You must GCPRO before calling such code. */
@@ -1636,765 +2023,948 @@
   struct frame *frame;
   struct mswindows_frame* msframe;
 
-  switch (message)
-  {
-  case WM_DESTROYCLIPBOARD:
-    /* We own the clipboard and someone else wants it.  Delete our
-       cached copy of the clipboard contents so we'll ask for it from
-       Windows again when someone does a paste. */
-    handle_selection_clear(QCLIPBOARD);
-    break;
-
-  case WM_ERASEBKGND:
-    /* Erase background only during non-dynamic sizing */
-    msframe  = FRAME_MSWINDOWS_DATA (XFRAME (mswindows_find_frame (hwnd)));
-    if (msframe->sizing && !mswindows_dynamic_frame_resize)
-      goto defproc;
-    return 1;
-
-  case WM_CLOSE:
-    fobj = mswindows_find_frame (hwnd);
-    mswindows_enqueue_misc_user_event (fobj, Qeval, list3 (Qdelete_frame, fobj, Qt));
-    break;
-
-  case WM_KEYUP:
-  case WM_SYSKEYUP:
-    /* See Win95 comment under WM_KEYDOWN */
+  /* Not perfect but avoids crashes. There is potential for wierd
+     behavior here. */
+  if (gc_in_progress)
+    goto defproc;
+
+  assert (!GetWindowLong (hwnd, GWL_USERDATA));
+  switch (message_)
     {
-      BYTE keymap[256];
-
-      if (wParam == VK_CONTROL)
-        {
-	  GetKeyboardState (keymap);
-	  keymap [(lParam & 0x1000000) ? VK_RCONTROL : VK_LCONTROL] &= ~0x80;
-	  SetKeyboardState (keymap);
-	}
-      else if (wParam == VK_MENU)
-	{
-	  GetKeyboardState (keymap);
-	  keymap [(lParam & 0x1000000) ? VK_RMENU : VK_LMENU] &= ~0x80;
-	  SetKeyboardState (keymap);
-	}
-    };
-    if (key_needs_default_processing_p (wParam))
-      goto defproc;
-    else
+    case WM_DESTROYCLIPBOARD:
+      /* We own the clipboard and someone else wants it.  Delete our
+	 cached copy of the clipboard contents so we'll ask for it from
+	 Windows again when someone does a paste, and destroy any memory
+         objects we hold on the clipboard that are not in the list of types
+         that Windows will delete itself. */
+      mswindows_destroy_selection (QCLIPBOARD);
+      handle_selection_clear (QCLIPBOARD);
+      break;
+
+    case WM_ERASEBKGND:
+      /* Erase background only during non-dynamic sizing */
+      msframe  = FRAME_MSWINDOWS_DATA (XFRAME (mswindows_find_frame (hwnd)));
+      if (msframe->sizing && !mswindows_dynamic_frame_resize)
+	goto defproc;
+      return 1;
+
+    case WM_CLOSE:
+      fobj = mswindows_find_frame (hwnd);
+      mswindows_enqueue_misc_user_event (fobj, Qeval, list3 (Qdelete_frame, fobj, Qt));
       break;
 
-  case WM_KEYDOWN:
-  case WM_SYSKEYDOWN:
-    /* In some locales the right-hand Alt key is labelled AltGr. This key
-     * should produce alternative charcaters when combined with another key.
-     * eg on a German keyboard pressing AltGr+q should produce '@'.
-     * AltGr generates exactly the same keystrokes as LCtrl+RAlt. But if
-     * TranslateMessage() is called with *any* combination of Ctrl+Alt down,
-     * it translates as if AltGr were down.
-     * We get round this by removing all modifiers from the keymap before
-     * calling TranslateMessage() unless AltGr is *really* down. */
-    {
-      BYTE keymap[256];
-      int has_AltGr = mswindows_current_layout_has_AltGr ();
-      int mods;
-      int extendedp = lParam & 0x1000000;
-      Lisp_Object keysym;
-
-      GetKeyboardState (keymap);
-      mods = mswindows_modifier_state (keymap, has_AltGr);
-
-      /* Handle non-printables */
-      if (!NILP (keysym = mswindows_key_to_emacs_keysym (wParam, mods,
-							 extendedp)))
-	mswindows_enqueue_keypress_event (hwnd, keysym, mods);
-      else	/* Normal keys & modifiers */
-	{
-	  int quit_ch = CONSOLE_QUIT_CHAR (XCONSOLE (mswindows_find_console (hwnd)));
-	  BYTE keymap_orig[256];
-	  POINT pnt = { LOWORD (GetMessagePos()), HIWORD (GetMessagePos()) };
-	  MSG msg;
-
-	  msg.hwnd = hwnd;
-	  msg.message = message;
-	  msg.wParam = wParam;
-	  msg.lParam = lParam;
-	  msg.time = GetMessageTime();
-	  msg.pt = pnt;
-
-	  /* GetKeyboardState() does not work as documented on Win95. We have
-	   * to loosely track Left and Right modifiers on behalf of the OS,
-	   * without screwing up Windows NT which tracks them properly. */
-	  if (wParam == VK_CONTROL)
-	    keymap [extendedp ? VK_RCONTROL : VK_LCONTROL] |= 0x80;
-	  else if (wParam == VK_MENU)
-	    keymap [extendedp ? VK_RMENU : VK_LMENU] |= 0x80;
-
-	  memcpy (keymap_orig, keymap, 256);
-
-	  /* Remove shift modifier from an ascii character */
-	  mods &= ~MOD_SHIFT;
-
-	  /* Clear control and alt modifiers unless AltGr is pressed */
-	  keymap [VK_RCONTROL] = 0;
-	  keymap [VK_LMENU] = 0;
-	  if (!has_AltGr || !(keymap [VK_LCONTROL] & 0x80)
-	      || !(keymap [VK_RMENU] & 0x80))
-	    {
-	      keymap [VK_LCONTROL] = 0;
-	      keymap [VK_CONTROL] = 0;
-	      keymap [VK_RMENU] = 0;
-	      keymap [VK_MENU] = 0;
-	    }
+    case WM_KEYUP:
+    case WM_SYSKEYUP:
+
+      /* See Win95 comment under WM_KEYDOWN */
+      {
+	BYTE keymap[256];
+	int should_set_keymap = 0;
+
+#ifdef DEBUG_XEMACS
+	if (debug_mswindows_events)
+	  {
+	    stderr_out ("%s wparam=%d lparam=%d\n",
+			message_ == WM_KEYUP ? "WM_KEYUP" : "WM_SYSKEYUP",
+			wParam, (int)lParam);
+	    output_alt_keyboard_state ();
+	  }
+#endif /* DEBUG_XEMACS */
+
+	mswindows_handle_sticky_modifiers (wParam, lParam, 0, 1);
+	if (wParam == VK_CONTROL)
+	  {
+	    GetKeyboardState (keymap);
+	    keymap [(lParam & 0x1000000) ? VK_RCONTROL : VK_LCONTROL] &= ~0x80;
+	    should_set_keymap = 1;
+	  }
+	else if (wParam == VK_MENU)
+	  {
+	    GetKeyboardState (keymap);
+	    keymap [(lParam & 0x1000000) ? VK_RMENU : VK_LMENU] &= ~0x80;
+	    should_set_keymap = 1;
+	  }
+
+	if (should_set_keymap)
+	  //	    && (message_ != WM_SYSKEYUP
+	  //	|| NILP (Vmenu_accelerator_enabled)))
 	  SetKeyboardState (keymap);
 
-	  /* Maybe generate some WM_[SYS]CHARs in the queue */
-	  TranslateMessage (&msg);
-
-	  while (PeekMessage (&msg, hwnd, WM_CHAR, WM_CHAR, PM_REMOVE)
-		 || PeekMessage (&msg, hwnd, WM_SYSCHAR, WM_SYSCHAR, PM_REMOVE))
-	    {
-	      int mods1 = mods;
-	      WPARAM ch = msg.wParam;
-
-	      /* If a quit char with no modifiers other than control and
-		 shift, then mark it with a fake modifier, which is removed
-		 upon dequeueing the event */
-	      /* #### This might also not withstand localization, if
-		 quit character is not a latin-1 symbol */
-	      if (((quit_ch < ' ' && (mods & MOD_CONTROL) && quit_ch + 'a' - 1 == ch)
-		   || (quit_ch >= ' ' && !(mods & MOD_CONTROL) && quit_ch == ch))
-		  && ((mods  & ~(MOD_CONTROL | MOD_SHIFT)) == 0))
-		{
-		  mods1 |= FAKE_MOD_QUIT;
-		  ++mswindows_quit_chars_count;
-		}
-
-	      mswindows_enqueue_keypress_event (hwnd, make_char(ch), mods1);
-	    } /* while */
-	  SetKeyboardState (keymap_orig);
-	} /* else */
-    }
-    if (key_needs_default_processing_p (wParam))
-      goto defproc;
-    else
-      break;
-
-  case WM_MBUTTONDOWN:
-  case WM_MBUTTONUP:
-    /* Real middle mouse button has nothing to do with emulated one:
-       if one wants to exercise fingers playing chords on the mouse,
-       he is allowed to do that! */
-    mswindows_enqueue_mouse_button_event (hwnd, message,
-					  MAKEPOINTS (lParam), GetMessageTime());
-    break;
-
-  case WM_LBUTTONUP:
-    msframe  = FRAME_MSWINDOWS_DATA (XFRAME (mswindows_find_frame (hwnd)));
-    msframe->last_click_time =  GetMessageTime();
-
-    KillTimer (hwnd, BUTTON_2_TIMER_ID);
-    msframe->button2_need_lbutton = 0;
-    if (msframe->ignore_next_lbutton_up)
-      {
-	msframe->ignore_next_lbutton_up = 0;
       }
-    else if (msframe->button2_is_down)
+
+      if (key_needs_default_processing_p (wParam))
+	goto defproc;
+      else
+	break;
+
+    case WM_KEYDOWN:
+    case WM_SYSKEYDOWN:
+
+      /* In some locales the right-hand Alt key is labelled AltGr. This key
+       * should produce alternative characters when combined with another key.
+       * eg on a German keyboard pressing AltGr+q should produce '@'.
+       * AltGr generates exactly the same keystrokes as LCtrl+RAlt. But if
+       * TranslateMessage() is called with *any* combination of Ctrl+Alt down,
+       * it translates as if AltGr were down.
+       * We get round this by removing all modifiers from the keymap before
+       * calling TranslateMessage() unless AltGr is *really* down. */
       {
-	msframe->button2_is_down = 0;
-	msframe->ignore_next_rbutton_up = 1;
-	mswindows_enqueue_mouse_button_event (hwnd, WM_MBUTTONUP,
-					      MAKEPOINTS (lParam), GetMessageTime());
-      }
-    else
-      {
-	if (msframe->button2_need_rbutton)
+	BYTE keymap_trans[256];
+	BYTE keymap_orig[256];
+	BYTE keymap_sticky[256];
+	int has_AltGr = mswindows_current_layout_has_AltGr ();
+	int mods = 0;
+	int extendedp = lParam & 0x1000000;
+	Lisp_Object keysym;
+	int sticky_changed;
+
+#ifdef DEBUG_XEMACS
+	if (debug_mswindows_events)
 	  {
-	    msframe->button2_need_rbutton = 0;
-	    mswindows_enqueue_mouse_button_event (hwnd, WM_LBUTTONDOWN,
-						  MAKEPOINTS (lParam), GetMessageTime());
+	    stderr_out ("%s wparam=%d lparam=%d\n",
+			message_ == WM_KEYDOWN ? "WM_KEYDOWN" : "WM_SYSKEYDOWN",
+			wParam, (int)lParam);
+	    output_alt_keyboard_state ();
 	  }
-	mswindows_enqueue_mouse_button_event (hwnd, WM_LBUTTONUP,
-					      MAKEPOINTS (lParam), GetMessageTime());
-      }
-    break;
-
-  case WM_RBUTTONUP:
-    msframe  = FRAME_MSWINDOWS_DATA (XFRAME (mswindows_find_frame (hwnd)));
-    msframe->last_click_time =  GetMessageTime();
-
-    KillTimer (hwnd, BUTTON_2_TIMER_ID);
-    msframe->button2_need_rbutton = 0;
-    if (msframe->ignore_next_rbutton_up)
-      {
-	msframe->ignore_next_rbutton_up = 0;
-      }
-    else if (msframe->button2_is_down)
-      {
-	msframe->button2_is_down = 0;
-	msframe->ignore_next_lbutton_up = 1;
-	mswindows_enqueue_mouse_button_event (hwnd, WM_MBUTTONUP,
-					      MAKEPOINTS (lParam), GetMessageTime());
-      }
-    else
-      {
-	if (msframe->button2_need_lbutton)
+#endif /* DEBUG_XEMACS */
+
+	GetKeyboardState (keymap_orig);
+	frame = XFRAME (mswindows_find_frame (hwnd));
+	if ((sticky_changed =
+	     mswindows_handle_sticky_modifiers (wParam, lParam, 1, 1)))
 	  {
-	    msframe->button2_need_lbutton = 0;
-	    mswindows_enqueue_mouse_button_event (hwnd, WM_RBUTTONDOWN,
-						  MAKEPOINTS (lParam), GetMessageTime());
-	  }
-	mswindows_enqueue_mouse_button_event (hwnd, WM_RBUTTONUP,
-					      MAKEPOINTS (lParam), GetMessageTime());
-      }
-    break;
-
-  case WM_LBUTTONDOWN:
-    msframe  = FRAME_MSWINDOWS_DATA (XFRAME (mswindows_find_frame (hwnd)));
-
-    if (msframe->button2_need_lbutton)
-      {
-	KillTimer (hwnd, BUTTON_2_TIMER_ID);
-	msframe->button2_need_lbutton = 0;
-	msframe->button2_need_rbutton = 0;
-	if (mswindows_button2_near_enough (msframe->last_click_point, MAKEPOINTS (lParam)))
-	  {
-	    mswindows_enqueue_mouse_button_event (hwnd, WM_MBUTTONDOWN,
-						  MAKEPOINTS (lParam), GetMessageTime());
-	    msframe->button2_is_down = 1;
+	    GetKeyboardState (keymap_sticky);
+	    if (keymap_sticky[VK_MENU] & 0x80)
+	      {
+		message_ = WM_SYSKEYDOWN;
+		/* We have to set the "context bit" so that the
+		   TranslateMessage() call below that generates the
+		   SYSCHAR message does its thing; see the documentation
+		   on WM_SYSKEYDOWN */
+		lParam |= 1 << 29;
+	      }
 	  }
 	else
+	  memcpy (keymap_sticky, keymap_orig, 256);
+
+	mods = mswindows_modifier_state (keymap_sticky, (DWORD) -1, has_AltGr);
+
+	/* Handle non-printables */
+	if (!NILP (keysym = mswindows_key_to_emacs_keysym (wParam, mods,
+							   extendedp)))
 	  {
-	    mswindows_enqueue_mouse_button_event (hwnd, WM_RBUTTONDOWN,
-			msframe->last_click_point, msframe->last_click_time);
-	    mswindows_enqueue_mouse_button_event (hwnd, WM_LBUTTONDOWN,
-						  MAKEPOINTS (lParam), GetMessageTime());
+	    mswindows_enqueue_keypress_event (hwnd, keysym, mods);
+	    if (sticky_changed)
+	      SetKeyboardState (keymap_orig);
 	  }
-      }
-    else
-      {
-	mswindows_set_chord_timer (hwnd);
-	msframe->button2_need_rbutton = 1;
-	msframe->last_click_point = MAKEPOINTS (lParam);
-      }
-    msframe->last_click_time =  GetMessageTime();
-    break;
-
-  case WM_RBUTTONDOWN:
-    msframe  = FRAME_MSWINDOWS_DATA (XFRAME (mswindows_find_frame (hwnd)));
-
-    if (msframe->button2_need_rbutton)
-      {
-	KillTimer (hwnd, BUTTON_2_TIMER_ID);
-	msframe->button2_need_lbutton = 0;
-	msframe->button2_need_rbutton = 0;
-	if (mswindows_button2_near_enough (msframe->last_click_point, MAKEPOINTS (lParam)))
+	else	/* Normal keys & modifiers */
 	  {
-	    mswindows_enqueue_mouse_button_event (hwnd, WM_MBUTTONDOWN,
-						  MAKEPOINTS (lParam), GetMessageTime());
-	    msframe->button2_is_down = 1;
-	  }
-	else
-	  {
-	    mswindows_enqueue_mouse_button_event (hwnd, WM_LBUTTONDOWN,
-				msframe->last_click_point, msframe->last_click_time);
-	    mswindows_enqueue_mouse_button_event (hwnd, WM_RBUTTONDOWN,
-						  MAKEPOINTS (lParam), GetMessageTime());
-	  }
+	    Emchar quit_ch =
+	      CONSOLE_QUIT_CHAR (XCONSOLE (mswindows_find_console (hwnd)));
+	    POINT pnt = { LOWORD (GetMessagePos()), HIWORD (GetMessagePos()) };
+	    MSG msg, tranmsg;
+	    int potential_accelerator = 0;
+	    int got_accelerator = 0;
+
+	    msg.hwnd = hwnd;
+	    msg.message = message_;
+	    msg.wParam = wParam;
+	    msg.lParam = lParam;
+	    msg.time = GetMessageTime();
+	    msg.pt = pnt;
+
+	    /* GetKeyboardState() does not work as documented on Win95. We have
+	     * to loosely track Left and Right modifiers on behalf of the OS,
+	     * without screwing up Windows NT which tracks them properly. */
+	    if (wParam == VK_CONTROL)
+	      {
+		keymap_orig[extendedp ? VK_RCONTROL : VK_LCONTROL] |= 0x80;
+		keymap_sticky[extendedp ? VK_RCONTROL : VK_LCONTROL] |= 0x80;
+	      }
+	    else if (wParam == VK_MENU)
+	      {
+		keymap_orig[extendedp ? VK_RMENU : VK_LMENU] |= 0x80;
+		keymap_sticky[extendedp ? VK_RMENU : VK_LMENU] |= 0x80;
+	      }
+
+	    if (!NILP (Vmenu_accelerator_enabled) &&
+		!(mods & XEMACS_MOD_SHIFT) && message_ == WM_SYSKEYDOWN)
+	      potential_accelerator = 1;
+
+	    /* Remove shift modifier from an ascii character */
+	    mods &= ~XEMACS_MOD_SHIFT;
+
+	    memcpy (keymap_trans, keymap_sticky, 256);
+
+	    /* Clear control and alt modifiers unless AltGr is pressed */
+	    keymap_trans[VK_RCONTROL] = 0;
+	    keymap_trans[VK_LMENU] = 0;
+	    if (!has_AltGr || !(keymap_trans[VK_LCONTROL] & 0x80)
+		|| !(keymap_trans[VK_RMENU] & 0x80))
+	      {
+		keymap_trans[VK_LCONTROL] = 0;
+		keymap_trans[VK_CONTROL] = 0;
+		keymap_trans[VK_RMENU] = 0;
+		keymap_trans[VK_MENU] = 0;
+	      }
+	    SetKeyboardState (keymap_trans);
+
+	    /* Maybe generate some WM_[SYS]CHARs in the queue */
+	    TranslateMessage (&msg);
+
+	    while (PeekMessage (&tranmsg, hwnd, WM_CHAR, WM_CHAR, PM_REMOVE)
+		   || PeekMessage (&tranmsg, hwnd, WM_SYSCHAR, WM_SYSCHAR,
+				   PM_REMOVE))
+	      {
+		int mods1 = mods;
+		WPARAM ch = tranmsg.wParam;
+
+		/* If a quit char with no modifiers other than control and
+		   shift, then mark it with a fake modifier, which is removed
+		   upon dequeueing the event */
+		/* #### This might also not withstand localization, if
+		   quit character is not a latin-1 symbol */
+		if (((quit_ch < ' ' && (mods & XEMACS_MOD_CONTROL)
+		      && quit_ch + 'a' - 1 == ch)
+		     || (quit_ch >= ' ' && !(mods & XEMACS_MOD_CONTROL)
+			 && quit_ch == ch))
+		    && ((mods  & ~(XEMACS_MOD_CONTROL | XEMACS_MOD_SHIFT))
+			== 0))
+		  {
+		    mods1 |= FAKE_MOD_QUIT;
+		    ++mswindows_quit_chars_count;
+		  }
+		else if (potential_accelerator && !got_accelerator &&
+			 mswindows_char_is_accelerator (frame, ch))
+		  {
+		    got_accelerator = 1;
+		    break;
+		  }
+		mswindows_enqueue_keypress_event (hwnd, make_char (ch), mods1);
+	      } /* while */
+
+	    /* This generates WM_SYSCHAR messages, which are interpreted
+	       by DefWindowProc as the menu selections. */
+	    if (got_accelerator)
+	      {
+		SetKeyboardState (keymap_sticky);
+		TranslateMessage (&msg);
+		SetKeyboardState (keymap_orig);
+		goto defproc;
+	      }
+
+	    SetKeyboardState (keymap_orig);
+	  } /* else */
       }
-    else
-      {
-	mswindows_set_chord_timer (hwnd);
-	msframe->button2_need_lbutton = 1;
-	msframe->last_click_point = MAKEPOINTS (lParam);
-      }
-    msframe->last_click_time =  GetMessageTime();
-    break;
-
-  case WM_TIMER:
-    if (wParam == BUTTON_2_TIMER_ID)
-      {
-	msframe  = FRAME_MSWINDOWS_DATA (XFRAME (mswindows_find_frame (hwnd)));
-	KillTimer (hwnd, BUTTON_2_TIMER_ID);
-
-	if (msframe->button2_need_lbutton)
-	  {
-	    msframe->button2_need_lbutton = 0;
-	    mswindows_enqueue_mouse_button_event (hwnd, WM_RBUTTONDOWN,
-				msframe->last_click_point, msframe->last_click_time);
-	  }
-	else if (msframe->button2_need_rbutton)
-	  {
-	    msframe->button2_need_rbutton = 0;
-	    mswindows_enqueue_mouse_button_event (hwnd, WM_LBUTTONDOWN,
-				msframe->last_click_point, msframe->last_click_time);
-	  }
-      }
-    else
-      assert ("Spurious timer fired" == 0);
-    break;
-
-  case WM_MOUSEMOVE:
-    /* Optimization: don't report mouse movement while size is changing */
-    msframe  = FRAME_MSWINDOWS_DATA (XFRAME (mswindows_find_frame (hwnd)));
-    if (!msframe->sizing)
-    {
-      /* When waiting for the second mouse button to finish
-	 button2 emulation, and have moved too far, just pretend
-	 as if timer has expired. This improves drag-select feedback */
-      if ((msframe->button2_need_lbutton || msframe->button2_need_rbutton)
-	  && !mswindows_button2_near_enough (msframe->last_click_point,
-					     MAKEPOINTS (lParam)))
+
+      if (key_needs_default_processing_p (wParam))
+	goto defproc;
+      else
+	break;
+
+    case WM_MBUTTONDOWN:
+    case WM_MBUTTONUP:
+      /* Real middle mouse button has nothing to do with emulated one:
+	 if one wants to exercise fingers playing chords on the mouse,
+	 he is allowed to do that! */
+      mswindows_enqueue_mouse_button_event (hwnd, message_,
+					    MAKEPOINTS (lParam),
+					    wParam &~ MK_MBUTTON,
+					    GetMessageTime());
+      break;
+
+    case WM_LBUTTONUP:
+      msframe  = FRAME_MSWINDOWS_DATA (XFRAME (mswindows_find_frame (hwnd)));
+      msframe->last_click_time =  GetMessageTime();
+
+      KillTimer (hwnd, BUTTON_2_TIMER_ID);
+      msframe->button2_need_lbutton = 0;
+      if (msframe->ignore_next_lbutton_up)
+	{
+	  msframe->ignore_next_lbutton_up = 0;
+	}
+      else if (msframe->button2_is_down)
+	{
+	  msframe->button2_is_down = 0;
+	  msframe->ignore_next_rbutton_up = 1;
+	  mswindows_enqueue_mouse_button_event (hwnd, WM_MBUTTONUP,
+						MAKEPOINTS (lParam),
+						wParam
+						&~ (MK_LBUTTON | MK_MBUTTON
+						    | MK_RBUTTON),
+						GetMessageTime());
+	}
+      else
+	{
+	  if (msframe->button2_need_rbutton)
+	    {
+	      msframe->button2_need_rbutton = 0;
+	      mswindows_enqueue_mouse_button_event (hwnd, WM_LBUTTONDOWN,
+						    MAKEPOINTS (lParam),
+						    wParam &~ MK_LBUTTON,
+						    GetMessageTime());
+	    }
+	  mswindows_enqueue_mouse_button_event (hwnd, WM_LBUTTONUP,
+						MAKEPOINTS (lParam),
+						wParam &~ MK_LBUTTON,
+						GetMessageTime());
+	}
+      break;
+
+    case WM_RBUTTONUP:
+      msframe  = FRAME_MSWINDOWS_DATA (XFRAME (mswindows_find_frame (hwnd)));
+      msframe->last_click_time =  GetMessageTime();
+
+      KillTimer (hwnd, BUTTON_2_TIMER_ID);
+      msframe->button2_need_rbutton = 0;
+      if (msframe->ignore_next_rbutton_up)
+	{
+	  msframe->ignore_next_rbutton_up = 0;
+	}
+      else if (msframe->button2_is_down)
+	{
+	  msframe->button2_is_down = 0;
+	  msframe->ignore_next_lbutton_up = 1;
+	  mswindows_enqueue_mouse_button_event (hwnd, WM_MBUTTONUP,
+						MAKEPOINTS (lParam),
+						wParam
+						&~ (MK_LBUTTON | MK_MBUTTON
+						    | MK_RBUTTON),
+						GetMessageTime());
+	}
+      else
+	{
+	  if (msframe->button2_need_lbutton)
+	    {
+	      msframe->button2_need_lbutton = 0;
+	      mswindows_enqueue_mouse_button_event (hwnd, WM_RBUTTONDOWN,
+						    MAKEPOINTS (lParam),
+						    wParam &~ MK_RBUTTON,
+						    GetMessageTime());
+	    }
+	  mswindows_enqueue_mouse_button_event (hwnd, WM_RBUTTONUP,
+						MAKEPOINTS (lParam),
+						wParam &~ MK_RBUTTON,
+						GetMessageTime());
+	}
+      break;
+
+    case WM_LBUTTONDOWN:
+      msframe  = FRAME_MSWINDOWS_DATA (XFRAME (mswindows_find_frame (hwnd)));
+
+      if (msframe->button2_need_lbutton)
 	{
 	  KillTimer (hwnd, BUTTON_2_TIMER_ID);
-	  SendMessage (hwnd, WM_TIMER, BUTTON_2_TIMER_ID, 0);
-	}
-
-      emacs_event = Fmake_event (Qnil, Qnil);
-      event = XEVENT(emacs_event);
-
-      event->channel = mswindows_find_frame(hwnd);
-      event->timestamp = GetMessageTime();
-      event->event_type = pointer_motion_event;
-      event->event.motion.x = MAKEPOINTS(lParam).x;
-      event->event.motion.y = MAKEPOINTS(lParam).y;
-      event->event.motion.modifiers = mswindows_modifier_state (NULL, 0);
-
-      mswindows_enqueue_dispatch_event (emacs_event);
-    }
-    break;
-
-  case WM_CANCELMODE:
-    ReleaseCapture ();
-    /* Queue a `cancel-mode-internal' misc user event, so mouse
-       selection would be canceled if any */
-    mswindows_enqueue_misc_user_event (mswindows_find_frame (hwnd),
-				       Qcancel_mode_internal, Qnil);
-    break;
-
-  case WM_NOTIFY:
-    {
-      LPNMHDR nmhdr = (LPNMHDR)lParam;
-
-      if (nmhdr->code ==  TTN_NEEDTEXT)
-	{
-#ifdef HAVE_TOOLBARS
-	  LPTOOLTIPTEXT tttext = (LPTOOLTIPTEXT)lParam;
-	  Lisp_Object btext;
-
-	  /* find out which toolbar */
-	  frame = XFRAME (mswindows_find_frame (hwnd));
-	  btext = mswindows_get_toolbar_button_text ( frame,
-						      nmhdr->idFrom );
-
-	  tttext->lpszText = NULL;
-	  tttext->hinst = NULL;
-
-	  if (!NILP(btext))
+	  msframe->button2_need_lbutton = 0;
+	  msframe->button2_need_rbutton = 0;
+	  if (mswindows_button2_near_enough (msframe->last_click_point,
+					     MAKEPOINTS (lParam)))
 	    {
-	      /* I think this is safe since the text will only go away
-                 when the toolbar does...*/
-	      TO_EXTERNAL_FORMAT (LISP_STRING, btext,
-				  C_STRING_ALLOCA, tttext->lpszText,
-				  Qnative);
+	      mswindows_enqueue_mouse_button_event (hwnd, WM_MBUTTONDOWN,
+						    MAKEPOINTS (lParam),
+						    wParam
+						    &~ (MK_LBUTTON | MK_MBUTTON
+							| MK_RBUTTON),
+						    GetMessageTime());
+	      msframe->button2_is_down = 1;
 	    }
-#endif
-	}
-      /* handle tree view callbacks */
-      else if (nmhdr->code == TVN_SELCHANGED)
-	{
-	  NM_TREEVIEW* ptree = (NM_TREEVIEW*)lParam;
-	  frame = XFRAME (mswindows_find_frame (hwnd));
-	  mswindows_handle_gui_wm_command (frame, 0, ptree->itemNew.lParam);
-	}
-      /* handle tab control callbacks */
-      else if (nmhdr->code == TCN_SELCHANGE)
-	{
-	  TC_ITEM item;
-	  int idx = SendMessage (nmhdr->hwndFrom, TCM_GETCURSEL, 0, 0);
-	  frame = XFRAME (mswindows_find_frame (hwnd));
-
-	  item.mask = TCIF_PARAM;
-	  SendMessage (nmhdr->hwndFrom, TCM_GETITEM, (WPARAM)idx,
-		       (LPARAM)&item);
-
-	  mswindows_handle_gui_wm_command (frame, 0, item.lParam);
-	}
-    }
-    break;
-
-  case WM_PAINT:
-    {
-      /* According to the docs we need to check GetUpdateRect() before
-         actually doing a WM_PAINT */
-      if (GetUpdateRect (hwnd, NULL, FALSE))
-	{
-	  PAINTSTRUCT paintStruct;
-	  int x, y, width, height;
-
-	  frame = XFRAME (mswindows_find_frame (hwnd));
-
-	  BeginPaint (hwnd, &paintStruct);
-	  x = paintStruct.rcPaint.left;
-	  y = paintStruct.rcPaint.top;
-	  width = paintStruct.rcPaint.right - paintStruct.rcPaint.left;
-	  height = paintStruct.rcPaint.bottom - paintStruct.rcPaint.top;
-	  /* Normally we want to ignore expose events when child
-	     windows are unmapped, however once we are in the guts of
-	     WM_PAINT we need to make sure that we don't register
-	     unmaps then because they will not actually occur. */
-	  if (!check_for_ignored_expose (frame, x, y, width, height))
+	  else
 	    {
-	      hold_ignored_expose_registration = 1;
-	      mswindows_redraw_exposed_area (frame, x, y, width, height);
-	      hold_ignored_expose_registration = 0;
+	      mswindows_enqueue_mouse_button_event (hwnd, WM_RBUTTONDOWN,
+						    msframe->last_click_point,
+						    msframe->last_click_mods
+						    &~ MK_RBUTTON,
+						    msframe->last_click_time);
+	      mswindows_enqueue_mouse_button_event (hwnd, WM_LBUTTONDOWN,
+						    MAKEPOINTS (lParam),
+						    wParam &~ MK_LBUTTON,
+						    GetMessageTime());
 	    }
-
-	  EndPaint (hwnd, &paintStruct);
 	}
       else
-	goto defproc;
-    }
-    break;
-
-  case WM_SIZE:
-    /* We only care about this message if our size has really changed */
-    if (wParam==SIZE_RESTORED || wParam==SIZE_MAXIMIZED || wParam==SIZE_MINIMIZED)
-    {
-      RECT rect;
-      int columns, rows;
-
-      fobj = mswindows_find_frame (hwnd);
-      frame = XFRAME (fobj);
-      msframe  = FRAME_MSWINDOWS_DATA (frame);
-
-      /* We cannot handle frame map and unmap hooks right in
-	 this routine, because these may throw. We queue
-	 magic events to run these hooks instead - kkm */
-
-      if (wParam==SIZE_MINIMIZED)
+	{
+	  mswindows_set_chord_timer (hwnd);
+	  msframe->button2_need_rbutton = 1;
+	  msframe->last_click_point = MAKEPOINTS (lParam);
+	  msframe->last_click_mods = wParam;
+	}
+      msframe->last_click_time =  GetMessageTime();
+      break;
+
+    case WM_RBUTTONDOWN:
+      msframe  = FRAME_MSWINDOWS_DATA (XFRAME (mswindows_find_frame (hwnd)));
+
+      if (msframe->button2_need_rbutton)
 	{
-	  /* Iconified */
-	  FRAME_VISIBLE_P (frame) = 0;
-	  mswindows_enqueue_magic_event (hwnd, XM_UNMAPFRAME);
+	  KillTimer (hwnd, BUTTON_2_TIMER_ID);
+	  msframe->button2_need_lbutton = 0;
+	  msframe->button2_need_rbutton = 0;
+	  if (mswindows_button2_near_enough (msframe->last_click_point,
+					     MAKEPOINTS (lParam)))
+	    {
+	      mswindows_enqueue_mouse_button_event (hwnd, WM_MBUTTONDOWN,
+						    MAKEPOINTS (lParam),
+						    wParam
+						    &~ (MK_LBUTTON | MK_MBUTTON
+							| MK_RBUTTON),
+						    GetMessageTime());
+	      msframe->button2_is_down = 1;
+	    }
+	  else
+	    {
+	      mswindows_enqueue_mouse_button_event (hwnd, WM_LBUTTONDOWN,
+						    msframe->last_click_point,
+						    msframe->last_click_mods
+						    &~ MK_LBUTTON,
+						    msframe->last_click_time);
+	      mswindows_enqueue_mouse_button_event (hwnd, WM_RBUTTONDOWN,
+						    MAKEPOINTS (lParam),
+						    wParam &~ MK_RBUTTON,
+						    GetMessageTime());
+	    }
 	}
       else
 	{
-	  GetClientRect(hwnd, &rect);
-	  FRAME_PIXWIDTH(frame) = rect.right;
-	  FRAME_PIXHEIGHT(frame) = rect.bottom;
-
-	  pixel_to_real_char_size (frame, rect.right, rect.bottom,
-				   &FRAME_MSWINDOWS_CHARWIDTH (frame),
-				   &FRAME_MSWINDOWS_CHARHEIGHT (frame));
-
-	  pixel_to_char_size (frame, rect.right, rect.bottom, &columns, &rows);
-	  change_frame_size (frame, rows, columns, 1);
-
-	  /* If we are inside frame creation, we have to apply geometric
-	     properties now. */
-	  if (FRAME_MSWINDOWS_TARGET_RECT (frame))
+	  mswindows_set_chord_timer (hwnd);
+	  msframe->button2_need_lbutton = 1;
+	  msframe->last_click_point = MAKEPOINTS (lParam);
+	  msframe->last_click_mods = wParam;
+	}
+      msframe->last_click_time =  GetMessageTime();
+      break;
+
+    case WM_TIMER:
+      if (wParam == BUTTON_2_TIMER_ID)
+	{
+	  msframe  = FRAME_MSWINDOWS_DATA (XFRAME (mswindows_find_frame (hwnd)));
+	  KillTimer (hwnd, BUTTON_2_TIMER_ID);
+
+	  if (msframe->button2_need_lbutton)
+	    {
+	      msframe->button2_need_lbutton = 0;
+	      mswindows_enqueue_mouse_button_event (hwnd, WM_RBUTTONDOWN,
+						    msframe->last_click_point,
+						    msframe->last_click_mods
+						    &~ MK_RBUTTON,
+						    msframe->last_click_time);
+	    }
+	  else if (msframe->button2_need_rbutton)
+	    {
+	      msframe->button2_need_rbutton = 0;
+	      mswindows_enqueue_mouse_button_event (hwnd, WM_LBUTTONDOWN,
+						    msframe->last_click_point,
+						    msframe->last_click_mods
+						    &~ MK_LBUTTON,
+						    msframe->last_click_time);
+	    }
+	}
+      else
+	assert ("Spurious timer fired" == 0);
+      break;
+
+    case WM_MOUSEMOVE:
+      /* Optimization: don't report mouse movement while size is changing */
+      msframe  = FRAME_MSWINDOWS_DATA (XFRAME (mswindows_find_frame (hwnd)));
+      if (!msframe->sizing)
+	{
+	  /* When waiting for the second mouse button to finish
+	     button2 emulation, and have moved too far, just pretend
+	     as if timer has expired. This improves drag-select feedback */
+	  if ((msframe->button2_need_lbutton || msframe->button2_need_rbutton)
+	      && !mswindows_button2_near_enough (msframe->last_click_point,
+						 MAKEPOINTS (lParam)))
 	    {
-	      /* Yes, we have to size again */
-	      mswindows_size_frame_internal ( frame,
-					      FRAME_MSWINDOWS_TARGET_RECT
-					      (frame));
-	      /* Reset so we do not get here again. The SetWindowPos call in
-	       * mswindows_size_frame_internal can cause recursion here. */
-	      if (FRAME_MSWINDOWS_TARGET_RECT (frame))
-		{
-		  xfree (FRAME_MSWINDOWS_TARGET_RECT (frame));
-		  FRAME_MSWINDOWS_TARGET_RECT (frame) = 0;
-		}
+	      KillTimer (hwnd, BUTTON_2_TIMER_ID);
+	      SendMessage (hwnd, WM_TIMER, BUTTON_2_TIMER_ID, 0);
+	    }
+
+	  emacs_event = Fmake_event (Qnil, Qnil);
+	  event = XEVENT(emacs_event);
+
+	  event->channel = mswindows_find_frame(hwnd);
+	  event->timestamp = GetMessageTime();
+	  event->event_type = pointer_motion_event;
+	  event->event.motion.x = MAKEPOINTS(lParam).x;
+	  event->event.motion.y = MAKEPOINTS(lParam).y;
+	  event->event.motion.modifiers =
+	    mswindows_modifier_state (NULL, wParam, 0);
+
+	  mswindows_enqueue_dispatch_event (emacs_event);
+	}
+      break;
+
+    case WM_CANCELMODE:
+      ReleaseCapture ();
+      /* Queue a `cancel-mode-internal' misc user event, so mouse
+	 selection would be canceled if any */
+      mswindows_enqueue_misc_user_event (mswindows_find_frame (hwnd),
+					 Qcancel_mode_internal, Qnil);
+      break;
+
+    case WM_NOTIFY:
+      {
+	LPNMHDR nmhdr = (LPNMHDR)lParam;
+
+	if (nmhdr->code ==  TTN_NEEDTEXT)
+	  {
+#ifdef HAVE_TOOLBARS
+	    LPTOOLTIPTEXT tttext = (LPTOOLTIPTEXT)lParam;
+	    Lisp_Object btext;
+
+	    /* find out which toolbar */
+	    frame = XFRAME (mswindows_find_frame (hwnd));
+	    btext = mswindows_get_toolbar_button_text ( frame,
+							nmhdr->idFrom );
+
+	    tttext->lpszText = NULL;
+	    tttext->hinst = NULL;
+
+	    if (!NILP(btext))
+	      {
+		/* I think this is safe since the text will only go away
+		   when the toolbar does...*/
+		LISP_STRING_TO_EXTERNAL (btext, tttext->lpszText, Qnative);
+	      }
+#endif
+	  }
+	/* handle tree view callbacks */
+	else if (nmhdr->code == TVN_SELCHANGED)
+	  {
+	    NM_TREEVIEW* ptree = (NM_TREEVIEW*)lParam;
+	    frame = XFRAME (mswindows_find_frame (hwnd));
+	    mswindows_handle_gui_wm_command (frame, 0, ptree->itemNew.lParam);
+	  }
+	/* handle tab control callbacks */
+	else if (nmhdr->code == TCN_SELCHANGE)
+	  {
+	    TC_ITEM item;
+	    int idx = SendMessage (nmhdr->hwndFrom, TCM_GETCURSEL, 0, 0);
+	    frame = XFRAME (mswindows_find_frame (hwnd));
+
+	    item.mask = TCIF_PARAM;
+	    SendMessage (nmhdr->hwndFrom, TCM_GETITEM, (WPARAM)idx,
+			 (LPARAM)&item);
+
+	    mswindows_handle_gui_wm_command (frame, 0, item.lParam);
+	  }
+      }
+      break;
+
+    case WM_PAINT:
+      /* hdc will be NULL unless this is a subwindow - in which case we
+	 shouldn't have received a paint message for it here. */
+      assert (wParam == 0);
+
+      /* Can't queue a magic event because windows goes modal and sends paint
+	 messages directly to the windows procedure when doing solid drags
+	 and the message queue doesn't get processed. */
+      mswindows_handle_paint (XFRAME (mswindows_find_frame (hwnd)));
+      break;
+
+    case WM_SIZE:
+      /* We only care about this message if our size has really changed */
+      if (wParam==SIZE_RESTORED || wParam==SIZE_MAXIMIZED || wParam==SIZE_MINIMIZED)
+	{
+	  RECT rect;
+	  int columns, rows;
+
+	  fobj = mswindows_find_frame (hwnd);
+	  frame = XFRAME (fobj);
+	  msframe  = FRAME_MSWINDOWS_DATA (frame);
+
+	  /* We cannot handle frame map and unmap hooks right in
+	     this routine, because these may throw. We queue
+	     magic events to run these hooks instead - kkm */
+
+	  if (wParam==SIZE_MINIMIZED)
+	    {
+	      /* Iconified */
+	      FRAME_VISIBLE_P (frame) = 0;
+	      mswindows_enqueue_magic_event (hwnd, XM_UNMAPFRAME);
 	    }
 	  else
 	    {
-	      if (!msframe->sizing && !FRAME_VISIBLE_P (frame))
-		mswindows_enqueue_magic_event (hwnd, XM_MAPFRAME);
-	      FRAME_VISIBLE_P (frame) = 1;
-
-	      if (!msframe->sizing || mswindows_dynamic_frame_resize)
-		redisplay ();
+	      GetClientRect(hwnd, &rect);
+	      FRAME_PIXWIDTH(frame) = rect.right;
+	      FRAME_PIXHEIGHT(frame) = rect.bottom;
+
+	      pixel_to_real_char_size (frame, rect.right, rect.bottom,
+				       &FRAME_MSWINDOWS_CHARWIDTH (frame),
+				       &FRAME_MSWINDOWS_CHARHEIGHT (frame));
+
+	      pixel_to_char_size (frame, rect.right, rect.bottom, &columns, &rows);
+	      change_frame_size (frame, rows, columns, 1);
+
+	      /* If we are inside frame creation, we have to apply geometric
+		 properties now. */
+	      if (FRAME_MSWINDOWS_TARGET_RECT (frame))
+		{
+		  /* Yes, we have to size again */
+		  mswindows_size_frame_internal ( frame,
+						  FRAME_MSWINDOWS_TARGET_RECT
+						  (frame));
+		  /* Reset so we do not get here again. The SetWindowPos call in
+		   * mswindows_size_frame_internal can cause recursion here. */
+		  if (FRAME_MSWINDOWS_TARGET_RECT (frame))
+		    {
+		      xfree (FRAME_MSWINDOWS_TARGET_RECT (frame));
+		      FRAME_MSWINDOWS_TARGET_RECT (frame) = 0;
+		    }
+		}
+	      else
+		{
+		  if (!msframe->sizing && !FRAME_VISIBLE_P (frame))
+		    mswindows_enqueue_magic_event (hwnd, XM_MAPFRAME);
+		  FRAME_VISIBLE_P (frame) = 1;
+
+		  if (!msframe->sizing || mswindows_dynamic_frame_resize)
+		    redisplay ();
+		}
 	    }
 	}
-    }
-    break;
-
-  /* Misc magic events which only require that the frame be identified */
-  case WM_SETFOCUS:
-  case WM_KILLFOCUS:
-    mswindows_enqueue_magic_event (hwnd, message);
-    break;
-
-  case WM_WINDOWPOSCHANGING:
-    {
-      WINDOWPOS *wp = (LPWINDOWPOS) lParam;
-      WINDOWPLACEMENT wpl = { sizeof(WINDOWPLACEMENT) };
-      GetWindowPlacement(hwnd, &wpl);
-
-      /* Only interested if size is changing and we're not being iconified */
-      if (wpl.showCmd != SW_SHOWMINIMIZED
-	  && wpl.showCmd != SW_SHOWMAXIMIZED
-	  && !(wp->flags & SWP_NOSIZE))
+      break;
+
+    case WM_DISPLAYCHANGE:
+      {
+	struct device *d;
+	DWORD message_tick = GetMessageTime ();
+
+	fobj = mswindows_find_frame (hwnd);
+	frame = XFRAME (fobj);
+	d = XDEVICE (FRAME_DEVICE (frame));
+
+	/* Do this only once per message. XEmacs can receive this message
+	   through as many frames as it currently has open. Message time
+	   will be the same for all these messages. Despite extreme
+	   efficiency, the code below has about one in 4 billion
+	   probability that the HDC is not recreated, provided that
+	   XEmacs is running sufficiently longer than 52 days. */
+	if (DEVICE_MSWINDOWS_UPDATE_TICK(d) != message_tick)
+	  {
+	    DEVICE_MSWINDOWS_UPDATE_TICK(d) = message_tick;
+	    DeleteDC (DEVICE_MSWINDOWS_HCDC(d));
+	    DEVICE_MSWINDOWS_HCDC(d) = CreateCompatibleDC (NULL);
+	  }
+      }
+      break;
+
+      /* Misc magic events which only require that the frame be identified */
+    case WM_SETFOCUS:
+    case WM_KILLFOCUS:
+      mswindows_enqueue_magic_event (hwnd, message_);
+      break;
+
+    case WM_WINDOWPOSCHANGING:
       {
-	RECT ncsize = { 0, 0, 0, 0 };
-	int pixwidth, pixheight;
- 	AdjustWindowRectEx (&ncsize, GetWindowLong (hwnd, GWL_STYLE),
- 			    GetMenu(hwnd) != NULL,
-			    GetWindowLong (hwnd, GWL_EXSTYLE));
-
-	round_size_to_real_char (XFRAME (mswindows_find_frame (hwnd)),
-				 wp->cx - (ncsize.right - ncsize.left),
-				 wp->cy - (ncsize.bottom - ncsize.top),
-				 &pixwidth, &pixheight);
-
-	/* Convert client sizes to window sizes */
-	pixwidth += (ncsize.right - ncsize.left);
-	pixheight += (ncsize.bottom - ncsize.top);
-
-	if (wpl.showCmd != SW_SHOWMAXIMIZED)
+	WINDOWPOS *wp = (LPWINDOWPOS) lParam;
+	WINDOWPLACEMENT wpl = { sizeof(WINDOWPLACEMENT) };
+	GetWindowPlacement(hwnd, &wpl);
+
+	/* Only interested if size is changing and we're not being iconified */
+	if (wpl.showCmd != SW_SHOWMINIMIZED
+	    && wpl.showCmd != SW_SHOWMAXIMIZED
+	    && !(wp->flags & SWP_NOSIZE))
 	  {
-	    /* Adjust so that the bottom or right doesn't move if it's
-	     * the top or left that's being changed */
-	    RECT rect;
-	    GetWindowRect (hwnd, &rect);
-
-	    if (rect.left != wp->x)
-	      wp->x += wp->cx - pixwidth;
-	    if (rect.top != wp->y)
-	      wp->y += wp->cy - pixheight;
+	    RECT ncsize = { 0, 0, 0, 0 };
+	    int pixwidth, pixheight;
+	    AdjustWindowRectEx (&ncsize, GetWindowLong (hwnd, GWL_STYLE),
+				GetMenu(hwnd) != NULL,
+				GetWindowLong (hwnd, GWL_EXSTYLE));
+
+	    round_size_to_real_char (XFRAME (mswindows_find_frame (hwnd)),
+				     wp->cx - (ncsize.right - ncsize.left),
+				     wp->cy - (ncsize.bottom - ncsize.top),
+				     &pixwidth, &pixheight);
+
+	    /* Convert client sizes to window sizes */
+	    pixwidth += (ncsize.right - ncsize.left);
+	    pixheight += (ncsize.bottom - ncsize.top);
+
+	    if (wpl.showCmd != SW_SHOWMAXIMIZED)
+	      {
+		/* Adjust so that the bottom or right doesn't move if it's
+		 * the top or left that's being changed */
+		RECT rect;
+		GetWindowRect (hwnd, &rect);
+
+		if (rect.left != wp->x)
+		  wp->x += wp->cx - pixwidth;
+		if (rect.top != wp->y)
+		  wp->y += wp->cy - pixheight;
+	      }
+
+	    wp->cx = pixwidth;
+	    wp->cy = pixheight;
 	  }
-
-	wp->cx = pixwidth;
-	wp->cy = pixheight;
+	/* DefWindowProc sends useful WM_GETMINMAXINFO message, and adjusts
+	   window position if the user tries to track window too small */
       }
-      /* DefWindowProc sends useful WM_GETMINMAXINFO message, and adjusts
-	 window position if the user tries to track window too small */
-    }
-    goto defproc;
-
-  case WM_ENTERSIZEMOVE:
-    msframe  = FRAME_MSWINDOWS_DATA (XFRAME (mswindows_find_frame (hwnd)));
-    msframe->sizing = 1;
-    return 0;
-
-  case WM_EXITSIZEMOVE:
-    msframe  = FRAME_MSWINDOWS_DATA (XFRAME (mswindows_find_frame (hwnd)));
-    msframe->sizing = 0;
-    /* Queue noop event */
-    mswindows_enqueue_magic_event (NULL, XM_BUMPQUEUE);
-    return 0;
+      goto defproc;
+
+    case WM_ENTERSIZEMOVE:
+      msframe  = FRAME_MSWINDOWS_DATA (XFRAME (mswindows_find_frame (hwnd)));
+      msframe->sizing = 1;
+      return 0;
+
+    case WM_EXITSIZEMOVE:
+      msframe  = FRAME_MSWINDOWS_DATA (XFRAME (mswindows_find_frame (hwnd)));
+      msframe->sizing = 0;
+      /* Queue noop event */
+      mswindows_enqueue_magic_event (NULL, XM_BUMPQUEUE);
+      return 0;
 
 #ifdef HAVE_SCROLLBARS
-  case WM_VSCROLL:
-  case WM_HSCROLL:
-    {
-      /* Direction of scroll is determined by scrollbar instance. */
-      int code = (int) LOWORD(wParam);
-      int pos = (short int) HIWORD(wParam);
-      HWND hwndScrollBar = (HWND) lParam;
-      struct gcpro gcpro1, gcpro2;
-
-      mswindows_handle_scrollbar_event (hwndScrollBar, code,  pos);
-      GCPRO2 (emacs_event, fobj);
-      if (UNBOUNDP(mswindows_pump_outstanding_events()))	/* Can GC */
-	{
-	  /* Error during event pumping - cancel scroll */
-	  SendMessage (hwndScrollBar, WM_CANCELMODE, 0, 0);
-	}
-      UNGCPRO;
-      break;
-    }
-
-  case WM_MOUSEWHEEL:
-    {
-      int keys = LOWORD (wParam); /* Modifier key flags */
-      int delta = (short) HIWORD (wParam); /* Wheel rotation amount */
-      struct gcpro gcpro1, gcpro2;
-
-      if (mswindows_handle_mousewheel_event (mswindows_find_frame (hwnd), keys,  delta))
-	{
-	  GCPRO2 (emacs_event, fobj);
-	  mswindows_pump_outstanding_events ();	/* Can GC */
-	  UNGCPRO;
-	}
-      else
-	goto defproc;
-      break;
-    }
+    case WM_VSCROLL:
+    case WM_HSCROLL:
+      {
+	/* Direction of scroll is determined by scrollbar instance. */
+	int code = (int) LOWORD(wParam);
+	int pos = (short int) HIWORD(wParam);
+	HWND hwndScrollBar = (HWND) lParam;
+	struct gcpro gcpro1, gcpro2;
+
+	mswindows_handle_scrollbar_event (hwndScrollBar, code,  pos);
+	GCPRO2 (emacs_event, fobj);
+	if (UNBOUNDP(mswindows_pump_outstanding_events()))	/* Can GC */
+	  {
+	    /* Error during event pumping - cancel scroll */
+	    SendMessage (hwndScrollBar, WM_CANCELMODE, 0, 0);
+	  }
+	UNGCPRO;
+	break;
+      }
+
+    case WM_MOUSEWHEEL:
+      {
+	int keys = LOWORD (wParam); /* Modifier key flags */
+	int delta = (short) HIWORD (wParam); /* Wheel rotation amount */
+	struct gcpro gcpro1, gcpro2;
+
+	if (mswindows_handle_mousewheel_event (mswindows_find_frame (hwnd), keys,  delta))
+	  {
+	    GCPRO2 (emacs_event, fobj);
+	    mswindows_pump_outstanding_events ();	/* Can GC */
+	    UNGCPRO;
+	  }
+	else
+	  goto defproc;
+	break;
+      }
 #endif
 
 #ifdef HAVE_MENUBARS
-  case WM_INITMENU:
-    if (UNBOUNDP (mswindows_handle_wm_initmenu (
-			(HMENU) wParam,
-			XFRAME (mswindows_find_frame (hwnd)))))
-      SendMessage (hwnd, WM_CANCELMODE, 0, 0);
-    break;
-
-  case WM_INITMENUPOPUP:
-    if (!HIWORD(lParam))
-      {
-	if (UNBOUNDP (mswindows_handle_wm_initmenupopup (
-			(HMENU) wParam,
-			 XFRAME (mswindows_find_frame (hwnd)))))
-	  SendMessage (hwnd, WM_CANCELMODE, 0, 0);
-      }
-    break;
+    case WM_INITMENU:
+      if (UNBOUNDP (mswindows_handle_wm_initmenu (
+						  (HMENU) wParam,
+						  XFRAME (mswindows_find_frame (hwnd)))))
+	SendMessage (hwnd, WM_CANCELMODE, 0, 0);
+      break;
+
+    case WM_INITMENUPOPUP:
+      if (!HIWORD(lParam))
+	{
+	  if (UNBOUNDP (mswindows_handle_wm_initmenupopup (
+							   (HMENU) wParam,
+							   XFRAME (mswindows_find_frame (hwnd)))))
+	    SendMessage (hwnd, WM_CANCELMODE, 0, 0);
+	}
+      break;
 
 #endif /* HAVE_MENUBARS */
 
-  case WM_COMMAND:
-    {
-      WORD id = LOWORD (wParam);
-      WORD nid = HIWORD (wParam);
-      HWND cid = (HWND)lParam;
-      frame = XFRAME (mswindows_find_frame (hwnd));
+    case WM_COMMAND:
+      {
+	WORD id = LOWORD (wParam);
+	WORD nid = HIWORD (wParam);
+	HWND cid = (HWND)lParam;
+	frame = XFRAME (mswindows_find_frame (hwnd));
 
 #ifdef HAVE_TOOLBARS
-      if (!NILP (mswindows_handle_toolbar_wm_command (frame, cid, id)))
-	break;
+	if (!NILP (mswindows_handle_toolbar_wm_command (frame, cid, id)))
+	  break;
 #endif
-      /* widgets in a buffer only eval a callback for suitable events.*/
-      switch (nid)
-	{
-	case BN_CLICKED:
-	case EN_CHANGE:
-	case CBN_EDITCHANGE:
-	case CBN_SELCHANGE:
-	  if (!NILP (mswindows_handle_gui_wm_command (frame, cid, id)))
-	    return 0;
-	}
-      /* menubars always must come last since the hashtables do not
-         always exist*/
+	/* widgets in a buffer only eval a callback for suitable events.*/
+	switch (nid)
+	  {
+	  case BN_CLICKED:
+	  case EN_CHANGE:
+	  case CBN_EDITCHANGE:
+	  case CBN_SELCHANGE:
+	    if (!NILP (mswindows_handle_gui_wm_command (frame, cid, id)))
+	      return 0;
+	  }
+	/* menubars always must come last since the hashtables do not
+	   always exist*/
 #ifdef HAVE_MENUBARS
-      if (!NILP (mswindows_handle_wm_command (frame, id)))
-	break;
+	if (!NILP (mswindows_handle_wm_command (frame, id)))
+	  break;
 #endif
 
-      return DefWindowProc (hwnd, message, wParam, lParam);
-      /* Bite me - a spurious command. This used to not be able to
-         happen but with the introduction of widgets its now
-         possible. */
-    }
-  break;
-
-  case WM_CTLCOLORBTN:
-  case WM_CTLCOLORLISTBOX:
-  case WM_CTLCOLOREDIT:
-  case WM_CTLCOLORSTATIC:
-  case WM_CTLCOLORSCROLLBAR:
-    {
-      /* if we get an opportunity to paint a widget then do so if
-         there is an appropriate face */
-      HWND crtlwnd = (HWND)lParam;
-      LONG ii = GetWindowLong (crtlwnd, GWL_USERDATA);
-      if (ii)
-	{
-	  Lisp_Object image_instance;
-	  VOID_TO_LISP (image_instance, ii);
-	  if (IMAGE_INSTANCEP (image_instance)
-	      &&
-	      IMAGE_INSTANCE_TYPE_P (image_instance, IMAGE_WIDGET))
-	    {
-	      /* set colors for the buttons */
-	      HDC hdc = (HDC)wParam;
-	      if (last_widget_brushed != ii)
-		{
-		  if (widget_brush)
-		    DeleteObject (widget_brush);
-		  widget_brush = CreateSolidBrush
-		    (COLOR_INSTANCE_MSWINDOWS_COLOR
-		     (XCOLOR_INSTANCE
-		      (FACE_BACKGROUND
-		       (XIMAGE_INSTANCE_WIDGET_FACE (image_instance),
-			XIMAGE_INSTANCE_SUBWINDOW_FRAME (image_instance)))));
-		}
-	      last_widget_brushed = ii;
-	      SetTextColor
-		(hdc,
-		 COLOR_INSTANCE_MSWINDOWS_COLOR
-		 (XCOLOR_INSTANCE
-		  (FACE_FOREGROUND
-		   (XIMAGE_INSTANCE_WIDGET_FACE (image_instance),
-		    XIMAGE_INSTANCE_SUBWINDOW_FRAME (image_instance)))));
-	      SetBkMode (hdc, OPAQUE);
-	      SetBkColor
-		(hdc,
-		 COLOR_INSTANCE_MSWINDOWS_COLOR
-		 (XCOLOR_INSTANCE
-		  (FACE_BACKGROUND
-		   (XIMAGE_INSTANCE_WIDGET_FACE (image_instance),
-		    XIMAGE_INSTANCE_SUBWINDOW_FRAME (image_instance)))));
-	      return (LRESULT)widget_brush;
-	    }
-	}
-    }
-    goto defproc;
+	return DefWindowProc (hwnd, message_, wParam, lParam);
+	/* Bite me - a spurious command. This used to not be able to
+	   happen but with the introduction of widgets its now
+	   possible. */
+      }
+      break;
+
+    case WM_CTLCOLORBTN:
+    case WM_CTLCOLORLISTBOX:
+    case WM_CTLCOLOREDIT:
+    case WM_CTLCOLORSTATIC:
+    case WM_CTLCOLORSCROLLBAR:
+      {
+	/* if we get an opportunity to paint a widget then do so if
+	   there is an appropriate face */
+	HWND crtlwnd = (HWND)lParam;
+	LONG ii = GetWindowLong (crtlwnd, GWL_USERDATA);
+	if (ii)
+	  {
+	    Lisp_Object image_instance;
+	    VOID_TO_LISP (image_instance, ii);
+	    if (IMAGE_INSTANCEP (image_instance)
+		&&
+		IMAGE_INSTANCE_TYPE_P (image_instance, IMAGE_WIDGET))
+	      {
+		/* set colors for the buttons */
+		HDC hdc = (HDC)wParam;
+		if (last_widget_brushed != ii)
+		  {
+		    if (widget_brush)
+		      DeleteObject (widget_brush);
+		    widget_brush = CreateSolidBrush
+		      (COLOR_INSTANCE_MSWINDOWS_COLOR
+		       (XCOLOR_INSTANCE
+			(FACE_BACKGROUND
+			 (XIMAGE_INSTANCE_WIDGET_FACE (image_instance),
+			  XIMAGE_INSTANCE_FRAME (image_instance)))));
+		  }
+		last_widget_brushed = ii;
+		SetTextColor
+		  (hdc,
+		   COLOR_INSTANCE_MSWINDOWS_COLOR
+		   (XCOLOR_INSTANCE
+		    (FACE_FOREGROUND
+		     (XIMAGE_INSTANCE_WIDGET_FACE (image_instance),
+		      XIMAGE_INSTANCE_FRAME (image_instance)))));
+		SetBkMode (hdc, OPAQUE);
+		SetBkColor
+		  (hdc,
+		   COLOR_INSTANCE_MSWINDOWS_COLOR
+		   (XCOLOR_INSTANCE
+		    (FACE_BACKGROUND
+		     (XIMAGE_INSTANCE_WIDGET_FACE (image_instance),
+		      XIMAGE_INSTANCE_FRAME (image_instance)))));
+		return (LRESULT)widget_brush;
+	      }
+	  }
+      }
+      goto defproc;
 
 #ifdef HAVE_DRAGNDROP
-  case WM_DROPFILES:	/* implementation ripped-off from event-Xt.c */
-    {
-      UINT filecount, i, len;
-      POINT point;
-      char* filename;
-#ifdef __CYGWIN32__
-      char* fname;
+    case WM_DROPFILES:	/* implementation ripped-off from event-Xt.c */
+      {
+	UINT filecount, i, len;
+	POINT point;
+	char* filename;
+	char* fname;
+
+	Lisp_Object l_dndlist = Qnil, l_item = Qnil;
+	struct gcpro gcpro1, gcpro2, gcpro3;
+
+	emacs_event = Fmake_event (Qnil, Qnil);
+	event = XEVENT(emacs_event);
+
+	GCPRO3 (emacs_event, l_dndlist, l_item);
+
+	if (!DragQueryPoint ((HDROP) wParam, &point))
+	  point.x = point.y = -1;		/* outside client area */
+
+	event->event_type = misc_user_event;
+	event->channel = mswindows_find_frame(hwnd);
+	event->timestamp = GetMessageTime();
+	event->event.misc.button = 1;		/* #### Should try harder */
+	event->event.misc.modifiers = mswindows_modifier_state (NULL,
+								(DWORD) -1, 0);
+	event->event.misc.x = point.x;
+	event->event.misc.y = point.y;
+	event->event.misc.function = Qdragdrop_drop_dispatch;
+
+	filecount = DragQueryFile ((HDROP) wParam, 0xffffffff, NULL, 0);
+	for (i=0; i<filecount; i++)
+	  {
+	    len = DragQueryFile ((HDROP) wParam, i, NULL, 0);
+	    /* The URLs that we make here aren't correct according to section
+	     * 3.10 of rfc1738 because they're missing the //<host>/ part and
+	     * because they may contain reserved characters. But that's OK -
+	     * they just need to be good enough to keep dragdrop.el happy. */
+	    fname = (char *)xmalloc (len+1);
+	    DragQueryFile ((HANDLE) wParam, i, fname, len+1);
+
+	    /* May be a shell link aka "shortcut" - replace fname if so */
+#if !(defined(CYGWIN) || defined(MINGW))
+	    /* cygwin doesn't define this COM stuff */
+	    if (!stricmp (fname + strlen (fname) - 4, ".LNK"))
+	      {
+		IShellLink* psl;
+
+		if (CoCreateInstance (&CLSID_ShellLink, NULL,
+				      CLSCTX_INPROC_SERVER, &IID_IShellLink, &psl) == S_OK)
+		  {
+		    IPersistFile* ppf;
+
+		    if (psl->lpVtbl->QueryInterface (psl, &IID_IPersistFile,
+						     &ppf) == S_OK)
+		      {
+			WORD wsz[MAX_PATH];
+			WIN32_FIND_DATA wfd;
+			LPSTR resolved = (char *) xmalloc (MAX_PATH+1);
+
+			MultiByteToWideChar (CP_ACP,0, fname, -1, wsz, MAX_PATH);
+
+			if ((ppf->lpVtbl->Load (ppf, wsz, STGM_READ) == S_OK) &&
+			    (psl->lpVtbl->GetPath (psl, resolved, MAX_PATH,
+						   &wfd, 0)==S_OK))
+			  {
+			    xfree (fname);
+			    fname = resolved;
+			    len = strlen (fname);
+			  }
+
+			ppf->lpVtbl->Release (ppf);
+		      }
+
+		    psl->lpVtbl->Release (psl);
+		  }
+	      }
 #endif
-      Lisp_Object l_dndlist = Qnil, l_item = Qnil;
-      struct gcpro gcpro1, gcpro2, gcpro3;
-
-      emacs_event = Fmake_event (Qnil, Qnil);
-      event = XEVENT(emacs_event);
-
-      GCPRO3 (emacs_event, l_dndlist, l_item);
-
-      if (!DragQueryPoint ((HANDLE) wParam, &point))
-	point.x = point.y = -1;		/* outside client area */
-
-      event->event_type = misc_user_event;
-      event->channel = mswindows_find_frame(hwnd);
-      event->timestamp = GetMessageTime();
-      event->event.misc.button = 1;		/* #### Should try harder */
-      event->event.misc.modifiers = mswindows_modifier_state (NULL, 0);
-      event->event.misc.x = point.x;
-      event->event.misc.y = point.y;
-      event->event.misc.function = Qdragdrop_drop_dispatch;
-
-      filecount = DragQueryFile ((HANDLE) wParam, 0xffffffff, NULL, 0);
-      for (i=0; i<filecount; i++)
-	{
-	  len = DragQueryFile ((HANDLE) wParam, i, NULL, 0);
-	  /* The URLs that we make here aren't correct according to section
-	   * 3.10 of rfc1738 because they're missing the //<host>/ part and
-	   * because they may contain reserved characters. But that's OK. */
-#ifdef __CYGWIN32__
-	  fname = (char *)xmalloc (len+1);
-	  DragQueryFile ((HANDLE) wParam, i, fname, len+1);
-	  filename = xmalloc (cygwin32_win32_to_posix_path_list_buf_size (fname) + 5);
-	  strcpy (filename, "file:");
-	  cygwin32_win32_to_posix_path_list (fname, filename+5);
-	  xfree (fname);
+
+#ifdef CYGWIN
+	    filename = xmalloc (cygwin32_win32_to_posix_path_list_buf_size (fname) + 5);
+	    strcpy (filename, "file:");
+	    cygwin32_win32_to_posix_path_list (fname, filename+5);
 #else
-	  filename = (char *)xmalloc (len+6);
-	  strcpy (filename, "file:");
-	  DragQueryFile ((HANDLE) wParam, i, filename+5, len+1);
-	  dostounix_filename (filename+5);
+	    filename = (char *)xmalloc (len+6);
+	    strcat (strcpy (filename, "file:"), fname);
+	    dostounix_filename (filename+5);
 #endif
-	  l_item = make_string (filename, strlen (filename));
-	  l_dndlist = Fcons (l_item, l_dndlist);
-	  xfree (filename);
-	}
-      DragFinish ((HANDLE) wParam);
-
-      event->event.misc.object = Fcons (Qdragdrop_URL, l_dndlist);
-      mswindows_enqueue_dispatch_event (emacs_event);
-      UNGCPRO;
+	    xfree (fname);
+	    l_item = make_string (filename, strlen (filename));
+	    l_dndlist = Fcons (l_item, l_dndlist);
+	    xfree (filename);
+	  }
+	DragFinish ((HDROP) wParam);
+
+	event->event.misc.object = Fcons (Qdragdrop_URL, l_dndlist);
+	mswindows_enqueue_dispatch_event (emacs_event);
+	UNGCPRO;
+      }
+      break;
+#endif
+
+    defproc:
+    default:
+      return DefWindowProc (hwnd, message_, wParam, lParam);
     }
-  break;
-#endif
-
-  defproc:
-  default:
-    return DefWindowProc (hwnd, message, wParam, lParam);
-  }
   return (0);
 }
 
@@ -2440,8 +3010,10 @@
      time when a key typed at autorepeat rate of 30 cps! */
   static HKL last_hkl = 0;
   static int last_hkl_has_AltGr;
-
-  HKL current_hkl = GetKeyboardLayout (0);
+  HKL current_hkl = (HKL) -1;
+
+  if (xGetKeyboardLayout) /* not in NT 3.5 */
+    current_hkl = xGetKeyboardLayout (0);
   if (current_hkl != last_hkl)
     {
       TCHAR c;
@@ -2460,29 +3032,46 @@
 
 /* Returns the state of the modifier keys in the format expected by the
  * Lisp_Event key_data, button_data and motion_data modifiers member */
-int mswindows_modifier_state (BYTE* keymap, int has_AltGr)
+static int
+mswindows_modifier_state (BYTE* keymap, DWORD fwKeys, int has_AltGr)
 {
   int mods = 0;
+  int keys_is_real = 0;
+  BYTE keymap2[256];
+
+  if (fwKeys == (DWORD) -1)
+    fwKeys = mswindows_last_mouse_button_state;
+  else
+    {
+      keys_is_real = 1;
+      mswindows_last_mouse_button_state = fwKeys;
+    }
 
   if (keymap == NULL)
     {
-      keymap = (BYTE*) alloca(256);
+      keymap = keymap2;
       GetKeyboardState (keymap);
       has_AltGr = mswindows_current_layout_has_AltGr ();
     }
 
+  /* #### should look at fwKeys for MK_CONTROL.  I don't understand how
+     AltGr works. */
   if (has_AltGr && (keymap [VK_LCONTROL] & 0x80) && (keymap [VK_RMENU] & 0x80))
     {
-      mods |= (keymap [VK_LMENU] & 0x80) ? MOD_META : 0;
-      mods |= (keymap [VK_RCONTROL] & 0x80) ? MOD_CONTROL : 0;
+      mods |= (keymap [VK_LMENU] & 0x80) ? XEMACS_MOD_META : 0;
+      mods |= (keymap [VK_RCONTROL] & 0x80) ? XEMACS_MOD_CONTROL : 0;
     }
   else
     {
-      mods |= (keymap [VK_MENU] & 0x80) ? MOD_META : 0;
-      mods |= (keymap [VK_CONTROL] & 0x80) ? MOD_CONTROL : 0;
+      mods |= (keymap [VK_MENU] & 0x80) ? XEMACS_MOD_META : 0;
+      mods |= (keymap [VK_CONTROL] & 0x80) ? XEMACS_MOD_CONTROL : 0;
     }
 
-  mods |= (keymap [VK_SHIFT] & 0x80) ? MOD_SHIFT : 0;
+  mods |= (keys_is_real ? fwKeys & MK_SHIFT : (keymap [VK_SHIFT] & 0x80))
+    ? XEMACS_MOD_SHIFT : 0;
+  mods |= fwKeys & MK_LBUTTON ? XEMACS_MOD_BUTTON1 : 0;
+  mods |= fwKeys & MK_MBUTTON ? XEMACS_MOD_BUTTON2 : 0;
+  mods |= fwKeys & MK_RBUTTON ? XEMACS_MOD_BUTTON3 : 0;
 
   return mods;
 }
@@ -2491,7 +3080,6 @@
  * Translate a mswindows virtual key to a keysym.
  * Only returns non-Qnil for keys that don't generate WM_CHAR messages
  * or whose ASCII codes (like space) xemacs doesn't like.
- * Virtual key values are defined in winresrc.h
  */
 Lisp_Object mswindows_key_to_emacs_keysym (int mswindows_key, int mods,
 					   int extendedp)
@@ -2500,6 +3088,7 @@
     {
       switch (mswindows_key)
         {
+	case VK_CANCEL:		return KEYSYM ("pause");
 	case VK_RETURN:		return KEYSYM ("kp-enter");
 	case VK_PRIOR:		return KEYSYM ("prior");
 	case VK_NEXT:		return KEYSYM ("next");
@@ -2511,6 +3100,11 @@
 	case VK_DOWN:		return KEYSYM ("down");
 	case VK_INSERT:		return KEYSYM ("insert");
 	case VK_DELETE:		return QKdelete;
+#if 0	/* FSF Emacs allows these to return configurable syms/mods */
+	case VK_LWIN		return KEYSYM ("");
+	case VK_RWIN		return KEYSYM ("");
+#endif
+	case VK_APPS:		return KEYSYM ("menu");
 	}
     }
   else
@@ -2522,6 +3116,7 @@
 	case '\n':		return QKlinefeed;
 	case VK_CLEAR:		return KEYSYM ("clear");
 	case VK_RETURN:		return QKreturn;
+	case VK_PAUSE:		return KEYSYM ("pause");
 	case VK_ESCAPE:		return QKescape;
 	case VK_SPACE:		return QKspace;
 	case VK_PRIOR:		return KEYSYM ("kp-prior");
@@ -2539,11 +3134,6 @@
 	case VK_INSERT:		return KEYSYM ("kp-insert");
 	case VK_DELETE:		return KEYSYM ("kp-delete");
 	case VK_HELP:		return KEYSYM ("help");
-#if 0	/* FSF Emacs allows these to return configurable syms/mods */
-	case VK_LWIN		return KEYSYM ("");
-	case VK_RWIN		return KEYSYM ("");
-#endif
-	case VK_APPS:		return KEYSYM ("menu");
 	case VK_NUMPAD0:	return KEYSYM ("kp-0");
 	case VK_NUMPAD1:	return KEYSYM ("kp-1");
 	case VK_NUMPAD2:	return KEYSYM ("kp-2");
@@ -2702,6 +3292,14 @@
     case XM_BUMPQUEUE:
       break;
 
+    case WM_PAINT:
+      {
+	struct frame *f = XFRAME (EVENT_CHANNEL (emacs_event));
+	mswindows_handle_paint (f);
+	(FRAME_MSWINDOWS_DATA (f))->paint_pending = 0;
+      }
+      break;
+
     case WM_SETFOCUS:
     case WM_KILLFOCUS:
       {
@@ -2709,18 +3307,19 @@
 	struct frame *f = XFRAME (frame);
 	int in_p = (EVENT_MSWINDOWS_MAGIC_TYPE(emacs_event) == WM_SETFOCUS);
 	Lisp_Object conser;
-
-	/* struct gcpro gcpro1; */
-
-	/* Clear sticky modifiers here (if we had any) */
+	struct gcpro gcpro1;
+
+	/* On focus change, clear all memory of sticky modifiers
+	   to avoid non-intuitive behavior. */
+	clear_sticky_modifiers ();
 
 	conser = Fcons (frame, Fcons (FRAME_DEVICE (f), in_p ? Qt : Qnil));
-	/* GCPRO1 (conser); XXX Not necessary? */
+	GCPRO1 (conser);
 	emacs_handle_focus_change_preliminary (conser);
 	/* Under X the stuff up to here is done in the X event handler.
 	   I Don't know why */
 	emacs_handle_focus_change_final (conser);
-	/* UNGCPRO; */
+	UNGCPRO;
 
       }
       break;
@@ -2760,7 +3359,7 @@
 	  ? get_winsock_stream_waitable (XLSTREAM (instr))
 	  : get_ntpipe_input_stream_waitable (XLSTREAM (instr)));
 #else
-    return get_ntpipe_input_stream_waitable (XLSTREAM (instr));
+  return get_ntpipe_input_stream_waitable (XLSTREAM (instr));
 #endif
 }
 
@@ -2831,7 +3430,7 @@
 
   /* Drain windows queue. This sets up number of quit characters in
      the queue */
-  mswindows_drain_windows_queue (1);
+  mswindows_drain_windows_queue ();
 
   if (mswindows_quit_chars_count > 0)
     {
@@ -2847,8 +3446,8 @@
 	{
 	  emacs_event = mswindows_cancel_dispatch_event (&match_against);
 	  assert (!NILP (emacs_event));
-	  
-	  if (XEVENT(emacs_event)->event.key.modifiers & MOD_SHIFT)
+
+	  if (XEVENT(emacs_event)->event.key.modifiers & XEMACS_MOD_SHIFT)
 	    critical_p = 1;
 
 	  Fdeallocate_event(emacs_event);
@@ -2932,7 +3531,7 @@
 
 USID
 emacs_mswindows_delete_stream_pair (Lisp_Object instream,
-					 Lisp_Object outstream)
+				    Lisp_Object outstream)
 {
   /* Oh nothing special here for Win32 at all */
 #if defined (HAVE_UNIX_PROCESSES)
@@ -2961,6 +3560,12 @@
 	  : HANDLE_TO_USID (get_ntpipe_input_stream_waitable (XLSTREAM (instream))));
 }
 
+static int
+emacs_mswindows_current_event_timestamp (struct console *c)
+{
+  return GetTickCount ();
+}
+
 #ifndef HAVE_X_WINDOWS
 /* This is called from GC when a process object is about to be freed.
    If we've still got pointers to it in this file, we're gonna lose hard.
@@ -2994,6 +3599,7 @@
   mswindows_event_stream = xnew (struct event_stream);
 
   mswindows_event_stream->event_pending_p 	= emacs_mswindows_event_pending_p;
+  mswindows_event_stream->force_event_pending = 0;
   mswindows_event_stream->next_event_cb		= emacs_mswindows_next_event;
   mswindows_event_stream->handle_magic_event_cb = emacs_mswindows_handle_magic_event;
   mswindows_event_stream->add_timeout_cb 	= emacs_mswindows_add_timeout;
@@ -3014,6 +3620,8 @@
   mswindows_event_stream->create_stream_pair_cb = emacs_mswindows_create_stream_pair;
   mswindows_event_stream->delete_stream_pair_cb = emacs_mswindows_delete_stream_pair;
 #endif
+  mswindows_event_stream->current_event_timestamp_cb =
+    emacs_mswindows_current_event_timestamp;
 }
 
 void
@@ -3034,13 +3642,30 @@
   mswindows_error_caught_in_modal_loop = Qnil;
   staticpro (&mswindows_error_caught_in_modal_loop);
 
-  DEFVAR_BOOL ("mswindows-meta-activates-menu", &mswindows_meta_activates_menu /*
-*Controls whether pressing and releasing the Meta (Alt) key should
-activate the menubar.
+
+#ifdef DEBUG_XEMACS
+  DEFVAR_INT ("debug-mswindows-events", &debug_mswindows_events /*
+If non-zero, display debug information about Windows events that XEmacs sees.
+Information is displayed in a console window.  Currently defined values are:
+
+1 == non-verbose output
+2 == verbose output
+
+#### Unfortunately, not yet implemented.
+*/ );
+  debug_mswindows_events = 0;
+#endif
+
+  DEFVAR_BOOL ("mswindows-alt-by-itself-activates-menu",
+	       &mswindows_alt_by_itself_activates_menu /*
+*Controls whether pressing and releasing the Alt key activates the menubar.
+This applies only if no intervening key was pressed.  See also
+`menu-accelerator-enabled', which is probably the behavior you actually want.
 Default is t.
 */ );
 
-  DEFVAR_BOOL ("mswindows-dynamic-frame-resize", &mswindows_dynamic_frame_resize /*
+  DEFVAR_BOOL ("mswindows-dynamic-frame-resize",
+	       &mswindows_dynamic_frame_resize /*
 *Controls redrawing frame contents during mouse-drag or keyboard resize
 operation. When non-nil, the frame is redrawn while being resized. When
 nil, frame is not redrawn, and exposed areas are filled with default
@@ -3050,8 +3675,8 @@
 Default is t on fast machines, nil on slow.
 */ );
 
-/* The description copied verbatim from nt-emacs. (C) Geoff Voelker */
-  DEFVAR_INT ("mswindows-mouse-button-tolerance", &mswindows_mouse_button_tolerance /*
+  DEFVAR_INT ("mswindows-mouse-button-tolerance",
+	      &mswindows_mouse_button_tolerance /*
 *Analogue of double click interval for faking middle mouse events.
 The value is the minimum time in milliseconds that must elapse between
 left/right button down events before they are considered distinct events.
@@ -3060,12 +3685,12 @@
 If negative or zero, currently set system default is used instead.
 */ );
 
-/* The description copied verbatim from nt-emacs. (C) Geoff Voelker */
   DEFVAR_INT ("mswindows-num-mouse-buttons", &mswindows_num_mouse_buttons /*
 Number of physical mouse buttons.
 */ );
 
-  DEFVAR_INT ("mswindows-mouse-button-max-skew-x", &mswindows_mouse_button_max_skew_x /*
+  DEFVAR_INT ("mswindows-mouse-button-max-skew-x",
+	      &mswindows_mouse_button_max_skew_x /*
 *Maximum horizontal distance in pixels between points in which left and
 right button clicks occurred for them to be translated into single
 middle button event. Clicks must occur in time not longer than defined
@@ -3073,7 +3698,8 @@
 If negative or zero, currently set system default is used instead.
 */ );
 
-  DEFVAR_INT ("mswindows-mouse-button-max-skew-y", &mswindows_mouse_button_max_skew_y /*
+  DEFVAR_INT ("mswindows-mouse-button-max-skew-y",
+	      &mswindows_mouse_button_max_skew_y /*
 *Maximum vertical distance in pixels between points in which left and
 right button clicks occurred for them to be translated into single
 middle button event. Clicks must occur in time not longer than defined
@@ -3084,7 +3710,7 @@
   mswindows_mouse_button_max_skew_x = 0;
   mswindows_mouse_button_max_skew_y = 0;
   mswindows_mouse_button_tolerance = 0;
-  mswindows_meta_activates_menu = 1;
+  mswindows_alt_by_itself_activates_menu = 1;
 }
 
 void