xemacs-beta: src/event-msw.c comparison

comparison src/event-msw.c @ 771:943eaba38521

[xemacs-hg @ 2002-03-13 08:51:24 by ben] The big ben-mule-21-5 check-in! Various files were added and deleted. See CHANGES-ben-mule. There are still some test suite failures. No crashes, though. Many of the failures have to do with problems in the test suite itself rather than in the actual code. I'll be addressing these in the next day or so -- none of the test suite failures are at all critical. Meanwhile I'll be trying to address the biggest issues -- i.e. build or run failures, which will almost certainly happen on various platforms. All comments should be sent to ben@xemacs.org -- use a Cc: if necessary when sending to mailing lists. There will be pre- and post- tags, something like pre-ben-mule-21-5-merge-in, and post-ben-mule-21-5-merge-in.

author	ben
date	Wed, 13 Mar 2002 08:54:06 +0000
parents	46d76bae9921
children	026c5bf9c134

comparison

equal deleted inserted replaced

-:336a418893b5
+:943eaba38521
 /* 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, 2000, 2001 Ben Wing.
+Copyright (C) 1996, 2000, 2001, 2002 Ben Wing.
 Copyright (C) 1997 Jonathan Harris.
 This file is part of XEmacs.
 XEmacs is free software; you can redistribute it and/or modify it
 along with XEmacs; see the file COPYING.  If not, write to
 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */
 /* Synched up with: Not in FSF. */
+/* This file essentially Mule-ized (except perhaps some Unicode splitting).
+5-2000. */
 /* Authorship:
 Ultimately based on FSF.
 Rewritten by Ben Wing.
 Rewritten for mswindows by Jonathan Harris, November 1997 for 21.0.
 Subprocess and modal loop support by Kirill M. Katsnelson.
 */
+#define NEED_MSWINDOWS_SHLOBJ /* for IShellLink */
 #include <config.h>
 #include "lisp.h"
 #include "console-msw.h"
 #include "frame.h"
 #include "lstream.h"
 #include "objects-msw.h"
 #include "process.h"
 #include "redisplay.h"
-#include "select.h"
 #include "sysdep.h"
 #include "window.h"
 #include "sysfile.h"
 #include "sysproc.h"
 #include "systime.h"
 #include "syswait.h"
 #ifdef HAVE_MSG_SELECT
 #include "console-tty.h"
-#elif defined(CYGWIN)
+#elif defined (CYGWIN)
 typedef unsigned int SOCKET;
-#endif
-#if !(defined(CYGWIN) || defined(MINGW))
-# include <shlobj.h>	/* For IShellLink */
 #endif
 #ifdef HAVE_MENUBARS
 #define ADJR_MENUFLAG TRUE
 #else
 #define BUTTON_2_TIMER_ID 1
 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, DWORD fwKeys,
+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,
 shared_data_block[MAX_SLURP_STREAMS]={{0}};
 struct ntpipe_slurp_stream
 {
 LPARAM user_data;	/* Any user data stored in the stream object	 */
-struct ntpipe_slurp_stream_shared_data* thread_data;
+struct ntpipe_slurp_stream_shared_data *thread_data;
 };
-DEFINE_LSTREAM_IMPLEMENTATION ("ntpipe-input", lstream_ntpipe_slurp,
+DEFINE_LSTREAM_IMPLEMENTATION ("ntpipe-input", ntpipe_slurp);
-			       sizeof (struct ntpipe_slurp_stream));
 /* This function is thread-safe, and is called from either thread
 context. It serializes freeing shared data structure */
 static void
-slurper_free_shared_data_maybe (struct ntpipe_slurp_stream_shared_data* s)
+slurper_free_shared_data_maybe (struct ntpipe_slurp_stream_shared_data *s)
 {
 if (InterlockedDecrement (&s->lock_count) == 0)
 {
 /* Destroy events */
 CloseHandle (s->hev_thread);
 CloseHandle (s->hpipe);
 s->inuse_p = 0;
 }
 }
-static struct ntpipe_slurp_stream_shared_data*
+static struct ntpipe_slurp_stream_shared_data *
 slurper_allocate_shared_data (void)
 {
 int i=0;
-for (i=0; i<MAX_SLURP_STREAMS; i++)
+for (i = 0; i < MAX_SLURP_STREAMS; i++)
 {
 if (!shared_data_block[i].inuse_p)
 	{
-	  shared_data_block[i].inuse_p=1;
+	  shared_data_block[i].inuse_p = 1;
 	  return &shared_data_block[i];
 	}
 }
-return (struct ntpipe_slurp_stream_shared_data*)0;
+return (struct ntpipe_slurp_stream_shared_data *)0;
 }
 static DWORD WINAPI
 slurp_thread (LPVOID vparam)
 {
 struct ntpipe_slurp_stream_shared_data *s =
-(struct ntpipe_slurp_stream_shared_data*)vparam;
+(struct ntpipe_slurp_stream_shared_data *)vparam;
 for (;;)
 {
 /* Read one byte from the pipe */
 DWORD actually_read;
 static Lisp_Object
 make_ntpipe_input_stream (HANDLE hpipe, LPARAM param)
 {
 Lisp_Object obj;
 Lstream *lstr = Lstream_new (lstream_ntpipe_slurp, "r");
-struct ntpipe_slurp_stream* s = NTPIPE_SLURP_STREAM_DATA (lstr);
+struct ntpipe_slurp_stream *s = NTPIPE_SLURP_STREAM_DATA (lstr);
 DWORD thread_id_unused;
 HANDLE hthread;
 /* We deal only with pipes, for we're using PeekNamedPipe api */
 assert (GetFileType (hpipe) == FILE_TYPE_PIPE);
 s->thread_data->error_p = FALSE;
 s->thread_data->hpipe = hpipe;
 s->user_data = param;
 /* hev_thread is a manual-reset event, initially signaled */
-s->thread_data->hev_thread = CreateEvent (NULL, TRUE, TRUE, NULL);
+s->thread_data->hev_thread = qxeCreateEvent (NULL, TRUE, TRUE, NULL);
 /* hev_caller is a manual-reset event, initially nonsignaled */
-s->thread_data->hev_caller = CreateEvent (NULL, TRUE, FALSE, NULL);
+s->thread_data->hev_caller = qxeCreateEvent (NULL, TRUE, FALSE, NULL);
 /* hev_unsleep is a manual-reset event, initially nonsignaled */
-s->thread_data->hev_unsleep = CreateEvent (NULL, TRUE, FALSE, NULL);
+s->thread_data->hev_unsleep = qxeCreateEvent (NULL, TRUE, FALSE, NULL);
 /* Now let it go */
 ResumeThread (hthread);
 CloseHandle (hthread);
 }
 static LPARAM
 get_ntpipe_input_stream_param (Lstream *stream)
 {
-struct ntpipe_slurp_stream* s = NTPIPE_SLURP_STREAM_DATA(stream);
+struct ntpipe_slurp_stream *s = NTPIPE_SLURP_STREAM_DATA(stream);
 return s->user_data;
 }
 static HANDLE
 get_ntpipe_input_stream_waitable (Lstream *stream)
 {
-struct ntpipe_slurp_stream* s = NTPIPE_SLURP_STREAM_DATA(stream);
+struct ntpipe_slurp_stream *s = NTPIPE_SLURP_STREAM_DATA(stream);
 return s->thread_data->hev_caller;
 }
 static Bytecount
 ntpipe_slurp_reader (Lstream *stream, unsigned char *data,
 		     Bytecount size)
 {
 /* This function must be called from the main thread only */
-struct ntpipe_slurp_stream_shared_data* s =
+struct ntpipe_slurp_stream_shared_data *s =
 NTPIPE_SLURP_STREAM_DATA(stream)->thread_data;
 if (!s->die_p)
 {
 DWORD wait_result;
 /* Disallow pipe read delay for the thread: we need a character
 ASAP */
 SetEvent (s->hev_unsleep);
 /* Check if we have a character ready. Give it a short delay,
-	 for the thread to awake from pipe delay, just ion case*/
+	 for the thread to awake from pipe delay, just ion case */
 wait_result = WaitForSingleObject (s->hev_caller, 2);
 /* Revert to the normal sleep behavior. */
 ResetEvent (s->hev_unsleep);
 static int
 ntpipe_slurp_closer (Lstream *stream)
 {
 /* This function must be called from the main thread only */
-struct ntpipe_slurp_stream_shared_data* s =
+struct ntpipe_slurp_stream_shared_data *s =
 NTPIPE_SLURP_STREAM_DATA(stream)->thread_data;
 /* Force thread to stop */
 InterlockedIncrement (&s->die_p);
 LONG   idle_p;	/* Non-zero if thread is waiting for job	 */
 BOOL   error_p : 1;   /* Read error other than EOF/broken pipe	 */
 BOOL   blocking_p : 1;/* Last write attempt would cause blocking	 */
 };
-DEFINE_LSTREAM_IMPLEMENTATION ("ntpipe-output", lstream_ntpipe_shove,
+DEFINE_LSTREAM_IMPLEMENTATION ("ntpipe-output", ntpipe_shove);
-			       sizeof (struct ntpipe_shove_stream));
 #ifndef HAVE_MSG_SELECT
 static DWORD WINAPI
 shove_thread (LPVOID vparam)
 {
-struct ntpipe_shove_stream *s = (struct ntpipe_shove_stream*) vparam;
+struct ntpipe_shove_stream *s = (struct ntpipe_shove_stream *) vparam;
 for (;;)
 {
 DWORD bytes_written;
 /* Block on event and wait for a job */
 InterlockedIncrement (&s->idle_p);
 WaitForSingleObject (s->hev_thread, INFINITE);
+if (s->die_p)
+	break;
 /* Write passed buffer if any */
 if (s->size > 0)
 	{
 if (!WriteFile (s->hpipe, s->buffer, s->size, &bytes_written, NULL)
 static Lisp_Object
 make_ntpipe_output_stream (HANDLE hpipe, LPARAM param)
 {
 Lisp_Object obj;
 Lstream *lstr = Lstream_new (lstream_ntpipe_shove, "w");
-struct ntpipe_shove_stream* s = NTPIPE_SHOVE_STREAM_DATA (lstr);
+struct ntpipe_shove_stream *s = NTPIPE_SHOVE_STREAM_DATA (lstr);
 DWORD thread_id_unused;
 s->die_p = 0;
 s->error_p = FALSE;
 s->hpipe = hpipe;
 Lstream_delete (lstr);
 return Qnil;
 }
 /* hev_thread is an auto-reset event, initially nonsignaled */
-s->hev_thread = CreateEvent (NULL, FALSE, FALSE, NULL);
+s->hev_thread = qxeCreateEvent (NULL, FALSE, FALSE, NULL);
 /* Now let it go */
 ResumeThread (s->hthread);
 lstr->flags |= LSTREAM_FL_CLOSE_AT_DISKSAVE;
 }
 static LPARAM
 get_ntpipe_output_stream_param (Lstream *stream)
 {
-struct ntpipe_shove_stream* s = NTPIPE_SHOVE_STREAM_DATA(stream);
+struct ntpipe_shove_stream *s = NTPIPE_SHOVE_STREAM_DATA(stream);
 return s->user_data;
 }
 #endif
 static Bytecount
 ntpipe_shove_writer (Lstream *stream, const unsigned char *data,
 		     Bytecount size)
 {
-struct ntpipe_shove_stream* s = NTPIPE_SHOVE_STREAM_DATA(stream);
+struct ntpipe_shove_stream *s = NTPIPE_SHOVE_STREAM_DATA(stream);
 if (s->error_p)
 return -1;
 s->blocking_p = !s->idle_p;
 /* 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 */
+if (xSwitchToThread) /* not in Win9x */
 (void) xSwitchToThread ();
 return size;
 }
 static int
 ntpipe_shove_was_blocked_p (Lstream *stream)
 {
-struct ntpipe_shove_stream* s = NTPIPE_SHOVE_STREAM_DATA(stream);
+struct ntpipe_shove_stream *s = NTPIPE_SHOVE_STREAM_DATA(stream);
 return s->blocking_p;
 }
 static int
 ntpipe_shove_closer (Lstream *stream)
 {
-struct ntpipe_shove_stream* s = NTPIPE_SHOVE_STREAM_DATA(stream);
+struct ntpipe_shove_stream *s = NTPIPE_SHOVE_STREAM_DATA(stream);
 /* Force thread stop */
 InterlockedIncrement (&s->die_p);
+/* Close pipe handle, possibly breaking it */
+CloseHandle (s->hpipe);
 /* 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 */
 unsigned int blocking_p :1;	/* Last write attempt would block	     */
 };
 #define WINSOCK_STREAM_DATA(stream) LSTREAM_TYPE_DATA (stream, winsock)
-DEFINE_LSTREAM_IMPLEMENTATION ("winsock", lstream_winsock,
+DEFINE_LSTREAM_IMPLEMENTATION ("winsock", winsock);
-			       sizeof (struct winsock_stream));
 static void
 winsock_initiate_read (struct winsock_stream *str)
 {
 ResetEvent (str->ov.hEvent);
 if (str->error_p)
 return -1;
 /* Return as much of buffer as we have */
 size = min (size, (Bytecount) (str->bufsize - str->charbpos));
-memcpy (data, (void*)((BYTE*)str->buffer + str->charbpos), size);
+memcpy (data, (void *) ((BYTE *) str->buffer + str->charbpos), size);
 str->charbpos += size;
 /* Read more if buffer is exhausted */
 if (str->bufsize == str->charbpos)
 winsock_initiate_read (str);
 xzero (*str);
 str->s = s;
 str->user_data = param;
-str->ov.hEvent = CreateEvent (NULL, TRUE, FALSE, NULL);
+str->ov.hEvent = qxeCreateEvent (NULL, TRUE, FALSE, NULL);
 if (lstr->flags & LSTREAM_FL_READ)
 {
 str->buffer = xmalloc (WINSOCK_READ_BUFFER_SIZE);
 winsock_initiate_read (str);
 /************************************************************************/
 /*                     Dispatch queue management                        */
 /************************************************************************/
 static int
-mswindows_user_event_p (Lisp_Event* sevt)
+mswindows_user_event_p (Lisp_Event *sevt)
 {
 return (sevt->event_type == key_press_event
 	  || sevt->event_type == button_press_event
 	  || sevt->event_type == button_release_event
 	  || sevt->event_type == misc_user_event);
 		 &mswindows_s_dispatch_event_queue,
 		 user_p ? &mswindows_u_dispatch_event_queue_tail :
 		 &mswindows_s_dispatch_event_queue_tail);
 /* Avoid blocking on WaitMessage */
-PostMessage (NULL, XM_BUMPQUEUE, 0, 0);
+qxePostMessage (NULL, XM_BUMPQUEUE, 0, 0);
 }
 /*
 * Add a misc-user event to the dispatch queue.
 *
 void
 mswindows_enqueue_misc_user_event (Lisp_Object channel, Lisp_Object function,
 				   Lisp_Object object)
 {
 Lisp_Object event = Fmake_event (Qnil, Qnil);
-Lisp_Event* e = XEVENT (event);
+Lisp_Event *e = XEVENT (event);
 e->event_type = misc_user_event;
 e->channel = channel;
 e->timestamp = GetTickCount ();
 e->event.misc.function = function;
 void
 mswindows_enqueue_magic_event (HWND hwnd, UINT msg)
 {
 Lisp_Object emacs_event = Fmake_event (Qnil, Qnil);
-Lisp_Event* event = XEVENT (emacs_event);
+Lisp_Event *event = XEVENT (emacs_event);
 event->channel = hwnd ? mswindows_find_frame (hwnd) : Qnil;
 event->timestamp = GetMessageTime();
 event->event_type = magic_event;
 EVENT_MSWINDOWS_MAGIC_TYPE (event) = msg;
 mswindows_enqueue_dispatch_event (emacs_event);
 }
 static void
-mswindows_enqueue_process_event (Lisp_Process* p)
+mswindows_enqueue_process_event (Lisp_Process *p)
 {
 Lisp_Object emacs_event = Fmake_event (Qnil, Qnil);
-Lisp_Event* event = XEVENT (emacs_event);
+Lisp_Event *event = XEVENT (emacs_event);
 Lisp_Object process;
 XSETPROCESS (process, p);
 event->event_type = process_event;
 event->timestamp  = GetTickCount ();
 /* 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);
+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 =
 }
 mswindows_enqueue_dispatch_event (emacs_event);
 }
-static void
+static Lisp_Object
 mswindows_enqueue_keypress_event (HWND hwnd, Lisp_Object keysym, int mods)
 {
 Lisp_Object emacs_event = Fmake_event (Qnil, Qnil);
-Lisp_Event* event = XEVENT(emacs_event);
+Lisp_Event *event = XEVENT(emacs_event);
 event->channel = mswindows_find_console(hwnd);
 event->timestamp = GetMessageTime();
 event->event_type = key_press_event;
 event->event.key.keysym = keysym;
 event->event.key.modifiers = mods;
 mswindows_enqueue_dispatch_event (emacs_event);
+return emacs_event;
 }
 /*
 * Remove and return the first emacs event on the dispatch queue.
 * Give a preference to user events over non-user ones.
 */
 static Lisp_Object
 mswindows_dequeue_dispatch_event (void)
 {
 Lisp_Object event;
-Lisp_Event* sevt;
+Lisp_Event *sevt;
 assert (!NILP(mswindows_u_dispatch_event_queue) ||
 	  !NILP(mswindows_s_dispatch_event_queue));
 event = dequeue_event (
 mswindows_cancel_dispatch_event (Lisp_Event *match)
 {
 Lisp_Object event;
 Lisp_Object previous_event = Qnil;
 int user_p = mswindows_user_event_p (match);
-Lisp_Object* head = user_p ? &mswindows_u_dispatch_event_queue :
+Lisp_Object *head = user_p ? &mswindows_u_dispatch_event_queue :
 &mswindows_s_dispatch_event_queue;
-Lisp_Object* tail = user_p ? &mswindows_u_dispatch_event_queue_tail :
+Lisp_Object *tail = user_p ? &mswindows_u_dispatch_event_queue_tail :
 &mswindows_s_dispatch_event_queue_tail;
 assert (match->event_type == timeout_event
 	  || match->event_type == key_press_event);
 /************************************************************************/
 /*                             Event pump                               */
 /************************************************************************/
+int
+mswindows_window_is_xemacs (HWND hwnd)
+{
+/* 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 */
+Extbyte class_name_buf[sizeof (XEMACS_CLASS) + 2];
+/* Use GetClassNameA because XEMACS_CLASS is not in Unicode format. */
+if (!GetClassNameA (hwnd, class_name_buf, sizeof (class_name_buf) - 1))
+return 0;
+return !ascii_strcasecmp (class_name_buf, XEMACS_CLASS);
+}
 static Lisp_Object
 mswindows_modal_loop_error_handler (Lisp_Object cons_sig_data,
 				    Lisp_Object u_n_u_s_e_d)
 {
 MSG msg;
 /* 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))
+while (qxePeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
 {
-char class_name_buf [sizeof (XEMACS_CLASS) + 2] = "";
+#ifdef HAVE_DIALOGS
 /* Don't translate messages destined for a dialog box, this
 	 makes keyboard traversal work. I think?? */
 if (mswindows_is_dialog_msg (&msg))
 	{
 	  mswindows_unmodalize_signal_maybe ();
 	  continue;
 	}
+#endif /* HAVE_DIALOGS */
 /* 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 (!mswindows_window_is_xemacs (msg.hwnd))
-	 if the name is longer than XEMACS_CLASS */
+	TranslateMessage (&msg);
-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;
+	  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 */
 	    }
 	  /* Don't dispatch. WM_PAINT is always the last message in the
 	     queue so it's OK to just return. */
 	  return;
 	}
-DispatchMessage (&msg);
+qxeDispatchMessage (&msg);
 mswindows_unmodalize_signal_maybe ();
 }
 }
 /*
 /* We'll deadlock if go waiting */
 if (mswindows_pending_timers_count == 0)
 invalid_operation ("Deadlock due to an attempt to call next-event in a wrong context", Qunbound);
 /* Fetch and dispatch any pending timers */
-if (GetMessage (&msg, NULL, WM_TIMER, WM_TIMER) > 0)
+if (qxeGetMessage (&msg, NULL, WM_TIMER, WM_TIMER) > 0)
-	DispatchMessage (&msg);
+	qxeDispatchMessage (&msg);
 }
 }
 /*
 * This drains the event queue and fills up two internal queues until
 		     user events ahead of process events. */
 		  if (FD_ISSET (i, &temp_mask) && FD_ISSET (i, &tty_only_mask))
 		    {
 		      struct console *c = tty_find_console_from_fd (i);
 		      Lisp_Object emacs_event = Fmake_event (Qnil, Qnil);
-		      Lisp_Event* event = XEVENT (emacs_event);
+		      Lisp_Event *event = XEVENT (emacs_event);
 		      assert (c);
-		      if (read_event_from_tty_or_stream_desc (event, c, i))
+		      if (read_event_from_tty_or_stream_desc (event, c))
 			{
 			  mswindows_enqueue_dispatch_event (emacs_event);
 			  return;
 			}
 		    }
 			}
 		    }
 		}
 	    }
 	}
-else if (active==-1)
+else if (active == -1)
 	{
 	  if (errno != EINTR)
 	    {
 	      /* something bad happened */
 	      assert(0);
 	}
 else
 	/* Look for any event */
 	what_events = QS_ALLINPUT;
+/*
+	 #### YUCK YUCK YUCK!!!!
+	 When running under a debugger, every time I hit F12 (which for me
+	 is mapped to right-brace) I hit a breakpoint inside of Windows!
+	 NTDLL! DbgBreakPoint@0 address 0x77f9eea9
+	 KERNEL32! BaseAttachComplete@4 + 41 bytes
+	 KERNEL32! BaseAttachCompleteThunk@0 + 19 bytes
+	 USER32! MsgWaitForMultipleObjectsEx@20 + 224 bytes
+	 USER32! MsgWaitForMultipleObjects@20 + 30 bytes
+	 Microsoft says:
+	 (Knowledge Base Q130667, PRB: F12 Causes Hard-Coded Breakpoint
+	 Exception When Debugging)
+	 CAUSE
+	 When the F12 key is pressed and the application in focus is being
+	 debugged, Windows NT calls a function similar to DebugBreak(),
+	 which executes a hard coded breakpoint instruction. The integrated
+	 debugger then traps the exception generated by this instruction.
+	 This behavior is intentional and occurs with other debuggers such
+	 as WinDbg from the Windows 32-bit SDK.
+	 RESOLUTION
+	 While there is no way to disable this functionality, it doesn't
+	 affect the application that's being debugged other than to pause
+	 debugging and change focus. You can continue debugging by pressing
+	 the F5 key.
+	 This can be annoying if you have an application that heavily uses
+	 the F12 key, so you may want to temporarily assign another key to
+	 handle the F12 key functionality in your program when debugging.
+	 STATUS
+	 This behavior is by design.
+	 However, elsewhere I found this:
+	 UserDebuggerHotKey
+	 HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\AeDebug
+	 Data type Range Default value
+	 REG_DWORD  0x0 - 0xFF  0x0
+	 Description
+	 Specifies the key that, when pressed, establishes a breakpoint in
+	 code being debugged.
+	 The debugger interrupts code processing at the breakpoint so the
+	 programmer can examine a suspected problem.
+	 The key specified in this value only sets a breakpoint. It does
+	 not invoke the debugger (the debugger must be running before the
+	 key is pressed) and it does not switch the debugger to single-step
+	 mode.
+	 The value of this entry is a keyboard scan code. The default
+	 value, 0x0, represents the F12 key on a 101-key keyboard or the -
+	 (hyphen, VK_SUBTRACT) key on an 82-key keyboard.
+	 */
+__try
+{
 active = MsgWaitForMultipleObjects (mswindows_waitable_count,
 					  mswindows_waitable_handles,
 					  FALSE, badly_p ? INFINITE : 0,
 					  what_events);
+}
+__except (GetExceptionCode () == EXCEPTION_BREAKPOINT ?
+	    EXCEPTION_CONTINUE_EXECUTION :
+	    EXCEPTION_CONTINUE_SEARCH)
+{
+}
 /* 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 &&
 return (HDDEDATA)FALSE;
 case XTYP_WILDCONNECT:
 {
 	/* We only support one {service,topic} pair */
-	HSZPAIR pairs[2] = {
+	HSZPAIR pairs[2] =
+	{
 	  { mswindows_dde_service, mswindows_dde_topic_system }, { 0, 0 } };
-	if (!(hszItem  || DdeCmpStringHandles (hszItem, mswindows_dde_service)) &&
+	if (!(hszItem
-	    !(hszTopic || DdeCmpStringHandles (hszTopic, mswindows_dde_topic_system)))
+	      || DdeCmpStringHandles (hszItem, mswindows_dde_service)) &&
+	    !(hszTopic
+	      || DdeCmpStringHandles (hszTopic, mswindows_dde_topic_system)))
 	  return (DdeCreateDataHandle (mswindows_dde_mlid, (LPBYTE)pairs,
 				       sizeof (pairs), 0L, 0, uFmt, 0));
 }
 return (HDDEDATA)NULL;
 	return (HDDEDATA) DDE_FBUSY;
 if (!DdeCmpStringHandles (hszTopic, mswindows_dde_topic_system))
 	{
 	  DWORD len = DdeGetData (hdata, NULL, 0, 0);
-	  LPBYTE cmd = (LPBYTE) alloca (len+1);
+	  LPBYTE extcmd = (LPBYTE) alloca (len+1);
-	  char *end;
+	  Intbyte *cmd;
-	  char *filename;
+	  Intbyte *end;
 	  struct gcpro gcpro1, gcpro2;
 	  Lisp_Object l_dndlist = Qnil;
 	  Lisp_Object emacs_event = Fmake_event (Qnil, Qnil);
 	  Lisp_Object frmcons, devcons, concons;
 	  Lisp_Event *event = XEVENT (emacs_event);
-	  DdeGetData (hdata, cmd, len, 0);
+	  DdeGetData (hdata, extcmd, len, 0);
-	  cmd[len] = '\0';
 	  DdeFreeDataHandle (hdata);
+	  TO_INTERNAL_FORMAT (DATA, (extcmd, len),
+			      C_STRING_ALLOCA, cmd,
+			      Qmswindows_tstr);
 	  /* Check syntax & that it's an [Open("foo")] command, which we
 	   * treat like a file drop */
 	  /* #### Ought to be generalised and accept some other commands */
 	  if (*cmd == '[')
 	    cmd++;
-	  if (strnicmp (cmd, MSWINDOWS_DDE_ITEM_OPEN,
+	  if (qxestrncasecmp_c (cmd, MSWINDOWS_DDE_ITEM_OPEN,
-			strlen (MSWINDOWS_DDE_ITEM_OPEN)))
+				strlen (MSWINDOWS_DDE_ITEM_OPEN)))
 	    return DDE_FNOTPROCESSED;
 	  cmd += strlen (MSWINDOWS_DDE_ITEM_OPEN);
-	  while (*cmd==' ')
+	  while (*cmd == ' ')
 	    cmd++;
-	  if (*cmd!='(' || *(cmd+1)!='\"')
+	  if (*cmd != '(' || *(cmd + 1) != '\"')
 	    return DDE_FNOTPROCESSED;
-	  end = (cmd+=2);
+	  end = (cmd += 2);
-	  while (*end && *end!='\"')
+	  while (*end && *end != '\"')
 	    end++;
 	  if (!*end)
 	    return DDE_FNOTPROCESSED;
 	  *end = '\0';
-	  if (*(++end)!=')')
+	  if (*++end != ')')
 	    return DDE_FNOTPROCESSED;
-	  if (*(++end)==']')
+	  if (*++end == ']')
 	    end++;
 	  if (*end)
 	    return DDE_FNOTPROCESSED;
-#ifdef CYGWIN
+	  {
-	  filename = alloca (cygwin_win32_to_posix_path_list_buf_size (cmd) + 5);
+	    /* The drag-n-drop code in dragdrop.el expects pseudo-URL's,
-	  strcpy (filename, "file:");
+	       consisting of just file: followed by the filename.  This
-	  cygwin_win32_to_posix_path_list (cmd, filename+5);
+	       should maybe work, but both Netscape and IE complain
-#else
+	       whenever they're not given the full file spec, like
-	  dostounix_filename (cmd);
-	  filename = alloca (strlen (cmd)+6);
+	       file:///C|/foo/bar/  or equivalently
-	  strcpy (filename, "file:");
+	       file:///C:/foo/bar/  (less portably)
-	  strcat (filename, cmd);
-#endif
+	       they don't allow relative paths at all!  this is way bogus. */
+	    cmd = urlify_filename (cmd);
+	    l_dndlist = build_intstring (cmd);
+	    xfree (cmd);
+	  }
 	  GCPRO2 (emacs_event, l_dndlist);
-	  l_dndlist = make_string (filename, strlen (filename));
 	  /* Find a mswindows frame */
 	  event->channel = Qnil;
 	  FRAME_LOOP_NO_BREAK (frmcons, devcons, concons)
 	    {
 #ifdef DEBUG_XEMACS
 if (debug_mswindows_events)
 debug_output_mswin_message (hwnd, message_, wParam, lParam);
 #endif /* DEBUG_XEMACS */
-assert (!GetWindowLong (hwnd, GWL_USERDATA));
+assert (!qxeGetWindowLong (hwnd, GWL_USERDATA));
 switch (message_)
 {
 case WM_DESTROYCLIPBOARD:
-/* We own the clipboard and someone else wants it.  Delete our
+mswindows_handle_destroyclipboard ();
-	 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)));
+msframe = FRAME_MSWINDOWS_DATA (XFRAME (mswindows_find_frame (hwnd)));
 if (msframe->sizing && !mswindows_dynamic_frame_resize)
 	goto defproc;
 return 1;
 case WM_CLOSE:
 * calling TranslateMessage() unless AltGr is *really* down. */
 {
 	BYTE keymap_trans[256];
 	BYTE keymap_orig[256];
 	BYTE keymap_sticky[256];
+	/* WARNING: XEmacs code paths are far more subtle than you
+	   think.  In particular, QUIT checking will query and remove
+	   events, including keyboard events, from the queue. (QUIT is
+	   definitely invoked from TO_INTERNAL_FORMAT().) If we do
+	   this recursively anywhere in the following code, it will
+	   mess certain things up -- in particular, the OS-provided
+	   sticky modifier code available as part of the accessibility
+	   package.
+	   (Academic question: If QUIT checking is supposed to be
+	   triggered only every 1/4 second, why is it getting
+	   consistently triggered here?  I saw the problem
+	   consistently.  Answer: It appears that, currently,
+	   sometimes the code to pump messages is wrapped with
+	   begin_dont_check_for_quit() and sometimes it isn't. (####
+	   FIX THIS SHIT!) cmdloop.c, for example, has it, but not
+	   everywhere.  The current games with avoiding QUIT mean that
+	   the 1/4-second timer consistently fires while
+	   dont_check_for_quit is set [which causes the quit check to
+	   get deferred but the flag is still on], and so the next
+	   time it's unset and we call QUIT is *right here*.
+	   In my stderr-proc ws I majorly cleaned up the whole shit by
+	   just wrapping all the entry points in dont_check_for_quit.
+	   This fixed the remaining bugs with C-g getting interpreted
+	   wrong.)
+	   #### We should probably wrap this whole function in
+	   begin_dont_check_for_quit(); but then we should set this
+	   back to 0 when handling a menu callback, which gets invoked
+	   from within this function, specifically from
+	   DefWindowProc(). (We already do the latter in my new
+	   stderr-proc ws, because in that ws next_event_internal()
+	   calls begin_dont_check_for_quit(). */
+	int count = begin_dont_check_for_quit ();
 	int has_AltGr = mswindows_current_layout_has_AltGr ();
 	int mods = 0, mods_with_shift = 0;
 	int extendedp = lParam & 0x1000000;
 	Lisp_Object keysym;
 	int sticky_changed;
 	      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;
+	    /* No need to gcpro because the event is already on a
+queue when we retrieve it. */
+	    Lisp_Object lastev = Qnil;
 	    msg.hwnd = hwnd;
 	    msg.message = message_;
 	    msg.wParam = wParam;
 	    msg.lParam = lParam;
 	    SetKeyboardState (keymap_trans);
 	    /* Maybe generate some WM_[SYS]CHARs in the queue */
 	    TranslateMessage (&msg);
-	    while (PeekMessage (&tranmsg, hwnd, WM_CHAR, WM_CHAR, PM_REMOVE)
+	    while (qxePeekMessage (&tranmsg, hwnd, WM_CHAR, WM_CHAR, PM_REMOVE)
-		   || PeekMessage (&tranmsg, hwnd, WM_SYSCHAR, WM_SYSCHAR,
+		   || qxePeekMessage (&tranmsg, hwnd, WM_SYSCHAR, WM_SYSCHAR,
-				   PM_REMOVE))
+				      PM_REMOVE))
 	      {
 		int mods_with_quit = mods;
-		Emchar ch = (Emchar) tranmsg.wParam;
+		int length;
+		Extbyte extchar[4];
+		Intbyte *intchar;
+		Emchar ch;
+		if (XEUNICODE_P)
+		  {
+		    length = unicode_char_to_text (tranmsg.wParam, extchar);
+		    TO_INTERNAL_FORMAT (DATA, (extchar, length),
+					C_STRING_ALLOCA, (intchar),
+					Qmswindows_unicode);
+		    ch = charptr_emchar (intchar);
+		  }
+		else
+		  {
+		    length = ansi_char_to_text (tranmsg.wParam, extchar);
+		    intchar = (convert_multibyte_to_internal_malloc
+			       (extchar, length,
+				mswindows_locale_to_code_page
+				/* See intl-win32.c for an explanation of
+				   the following */
+				((LCID) GetKeyboardLayout (0) & 0xFFFF),
+				NULL));
+		    ch = charptr_emchar (intchar);
+		    xfree (intchar);
+		  }
 #ifdef DEBUG_XEMACS
 		if (debug_mswindows_events)
 		  {
 		    stderr_out ("-> ");
 #endif /* DEBUG_XEMACS */
 		/* 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 */
-		/* !!#### Fix this in my mule ws -- replace current_buffer
-		   with 0 */
 		if (((quit_ch < ' ' && (mods & XEMACS_MOD_CONTROL)
-		      && DOWNCASE (current_buffer, quit_ch + 'a' - 1) ==
+		      && DOWNCASE (0, quit_ch + 'a' - 1) ==
-		      DOWNCASE (current_buffer, ch))
+		      DOWNCASE (0, ch))
 		     || (quit_ch >= ' ' && !(mods & XEMACS_MOD_CONTROL)
-			 && DOWNCASE (current_buffer, quit_ch) ==
+			 && DOWNCASE (0, quit_ch) ==
-			 DOWNCASE (current_buffer, ch)))
+			 DOWNCASE (0, ch)))
 		    && ((mods_with_shift &
 			 ~(XEMACS_MOD_CONTROL | XEMACS_MOD_SHIFT))
 			== 0))
 		  {
 		    mods_with_quit |= FAKE_MOD_QUIT;
 			 mswindows_char_is_accelerator (frame, ch))
 		  {
 		    got_accelerator = 1;
 		    break;
 		  }
-		mswindows_enqueue_keypress_event (hwnd, make_char (ch),
+		lastev = mswindows_enqueue_keypress_event (hwnd,
-						  mods_with_quit);
+							   make_char (ch),
+							   mods_with_quit);
 	      } /* while */
+#ifdef MULE
+	    /* Also figure out what the character would be in other
+	       possible keyboard layouts, in this order:
+	       -- current language environment
+	       -- user default language environment
+	       -- system default language environment
+	       -- same three, but checking the underlying virtual key,
+	          and only paying attention if it's alphabetic
+	       -- US ASCII
+	       See events.h, struct key_data, for why we do this.
+	       */
+	    if (!NILP (lastev))
+	      {
+		int i;
+		int scan = (lParam >> 16) && 0xFF;
+		for (i = 0; i < KEYCHAR_LAST; i++)
+		  {
+		    int vk_only = 0;
+		    LCID lcid;
+		    int virtual_key;
+		    switch (i)
+		      {
+		      case KEYCHAR_UNDERLYING_VIRTUAL_KEY_CURRENT_LANGENV:
+			vk_only = 1;
+		      case KEYCHAR_CURRENT_LANGENV:
+			lcid = mswindows_current_locale ();
+			break;
+		      case KEYCHAR_UNDERLYING_VIRTUAL_KEY_DEFAULT_USER:
+			vk_only = 1;
+		      case KEYCHAR_DEFAULT_USER:
+			lcid = GetUserDefaultLCID ();
+			break;
+		      case KEYCHAR_UNDERLYING_VIRTUAL_KEY_DEFAULT_SYSTEM:
+			vk_only = 1;
+		      case KEYCHAR_DEFAULT_SYSTEM:
+			lcid = GetSystemDefaultLCID ();
+			break;
+		      case KEYCHAR_QWERTY:
+			lcid = MAKELANGID (LANG_ENGLISH, SUBLANG_ENGLISH_US);
+			break;
+		      default: abort (); lcid = 0;
+		      }
+		    /* VERY CONFUSING!  See intl-win32.c. */
+		    lcid = lcid & 0xFFFF;
+		    virtual_key = MapVirtualKeyEx (scan, 1, (HKL) lcid);
+		    if (!vk_only)
+		      {
+			if (XEUNICODE_P)
+			  {
+			    Extbyte received_keys[32];
+			    int tounret =
+			      ToUnicodeEx
+				(virtual_key, scan, keymap_trans,
+				 (LPWSTR) received_keys,
+				 sizeof (received_keys) / XETCHAR_SIZE,
+				 0, /* #### what about this flag? "if
+				       bit 0 is set, a menu is
+				       active???" */
+				 (HKL) lcid);
+			    if (tounret > 0)
+			      {
+				Intbyte *intchar;
+				TO_INTERNAL_FORMAT
+				  (DATA,
+				   (received_keys + (tounret - 1) * 2, 2),
+				   C_STRING_ALLOCA, intchar,
+				   Qmswindows_unicode);
+				XEVENT (lastev)->event.key.alt_keychars[i] =
+				  charptr_emchar (intchar);
+			      }
+			  }
+			else
+			  {
+			    WORD received_keys[32];
+			    int tounret =
+			      ToAsciiEx (virtual_key, scan, keymap_trans,
+					 received_keys,
+					 0, /* #### what about this
+					       flag? "if bit 0 is set, a
+					       menu is active???" */
+					 (HKL) lcid);
+			    if (tounret > 0)
+			      {
+				/* #### I cannot find proper
+				   documentation on what format the
+				   return value is in.  I'm assuming
+				   it's like WM_IME_CHAR: DBCS chars
+				   have the lead byte in bits 8-15 of
+				   the short. */
+				Intbyte *intchar;
+				Extbyte mbstuff[2];
+				Bytecount mblength = 0;
+				WORD thechar = received_keys[tounret - 1];
+				mbstuff[mblength++] =
+				  (Extbyte) (thechar & 0xFF);
+				if (thechar > 0xFF)
+				  mbstuff[mblength++] =
+				    (Extbyte) ((thechar >> 8) & 0xFF);
+				intchar = convert_multibyte_to_internal_malloc
+				  (mbstuff, mblength,
+				   mswindows_locale_to_code_page (lcid),
+				   NULL);
+				XEVENT (lastev)->event.key.alt_keychars[i] =
+				  charptr_emchar (intchar);
+				xfree (intchar);
+			      }
+			  }
+		      }
+		    else
+		      {
+			Emchar altch;
+			if (virtual_key >= 'A' && virtual_key <= 'Z')
+			  altch =
+			    virtual_key + (mods_with_shift & XEMACS_MOD_SHIFT ?
+					   'a' - 'A' : 0);
+			else
+			  altch = 0;
+			XEVENT (lastev)->event.key.alt_keychars[i] = altch;
+		      }
+		  }
+	      }
+#endif /* MULE */
 	    /* 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);
+		unbind_to (count);
 		goto defproc;
 	      }
 	    SetKeyboardState (keymap_orig);
 	  } /* else */
+	if (key_needs_default_processing_p (wParam))
+	  {
+	    unbind_to (count);
+	    goto defproc;
+	  }
+	else
+	  {
+	    unbind_to (count);
+	    break;
+	  }
 }
-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,
 					    wParam &~ MK_MBUTTON,
 					    GetMessageTime());
 break;
 case WM_LBUTTONUP:
-msframe  = FRAME_MSWINDOWS_DATA (XFRAME (mswindows_find_frame (hwnd)));
+msframe = FRAME_MSWINDOWS_DATA (XFRAME (mswindows_find_frame (hwnd)));
-msframe->last_click_time =  GetMessageTime();
+msframe->last_click_time = GetMessageTime();
 KillTimer (hwnd, BUTTON_2_TIMER_ID);
 msframe->button2_need_lbutton = 0;
 if (msframe->ignore_next_lbutton_up)
 	{
 						GetMessageTime());
 	}
 break;
 case WM_RBUTTONUP:
-msframe  = FRAME_MSWINDOWS_DATA (XFRAME (mswindows_find_frame (hwnd)));
+msframe = FRAME_MSWINDOWS_DATA (XFRAME (mswindows_find_frame (hwnd)));
-msframe->last_click_time =  GetMessageTime();
+msframe->last_click_time = GetMessageTime();
 KillTimer (hwnd, BUTTON_2_TIMER_ID);
 msframe->button2_need_rbutton = 0;
 if (msframe->ignore_next_rbutton_up)
 	{
 						GetMessageTime());
 	}
 break;
 case WM_LBUTTONDOWN:
-msframe  = FRAME_MSWINDOWS_DATA (XFRAME (mswindows_find_frame (hwnd)));
+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;
 	  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();
+msframe->last_click_time = GetMessageTime();
 break;
 case WM_RBUTTONDOWN:
-msframe  = FRAME_MSWINDOWS_DATA (XFRAME (mswindows_find_frame (hwnd)));
+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;
 	  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();
+msframe->last_click_time = GetMessageTime();
 break;
 case WM_TIMER:
 if (wParam == BUTTON_2_TIMER_ID)
 	{
-	  msframe  = FRAME_MSWINDOWS_DATA (XFRAME (mswindows_find_frame (hwnd)));
+	  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;
 	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)));
+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)))
 	    {
 	      KillTimer (hwnd, BUTTON_2_TIMER_ID);
-	      SendMessage (hwnd, WM_TIMER, BUTTON_2_TIMER_ID, 0);
+	      qxeSendMessage (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->channel = mswindows_find_frame (hwnd);
-	  event->timestamp = GetMessageTime();
+	  event->timestamp = GetMessageTime ();
 	  event->event_type = pointer_motion_event;
-	  event->event.motion.x = MAKEPOINTS(lParam).x;
+	  event->event.motion.x = MAKEPOINTS (lParam).x;
-	  event->event.motion.y = MAKEPOINTS(lParam).y;
+	  event->event.motion.y = MAKEPOINTS (lParam).y;
 	  event->event.motion.modifiers =
 	    mswindows_modifier_state (NULL, wParam, 0);
 	  mswindows_enqueue_dispatch_event (emacs_event);
 	}
 	LPNMHDR nmhdr = (LPNMHDR) lParam;
 	if ((int) nmhdr->code == TTN_NEEDTEXT)
 	  {
 #ifdef HAVE_TOOLBARS
-	    LPTOOLTIPTEXT tttext = (LPTOOLTIPTEXT) lParam;
+	    LPTOOLTIPTEXTW tttextw = (LPTOOLTIPTEXTW) lParam;
 	    Lisp_Object btext;
+	    Extbyte *btextext = 0;
 	    /* find out which toolbar */
 	    frame = XFRAME (mswindows_find_frame (hwnd));
 	    btext = mswindows_get_toolbar_button_text (frame, nmhdr->idFrom);
-	    tttext->lpszText = NULL;
+	    tttextw->hinst = NULL;
-	    tttext->hinst = NULL;
+	    if (!NILP (btext))
-	    if (!NILP(btext))
+	      LISP_STRING_TO_TSTR (btext, btextext);
+	    if (btextext)
 	      {
-		/* I think this is safe since the text will only go away
+		/* WARNING: We can't just write a '\0' into the 79th
-		   when the toolbar does...*/
+"character" because tttextw->szText is in WCHAR's but we
-		LISP_STRING_TO_EXTERNAL (btext, tttext->lpszText, Qnative);
+may be copying an ANSI string into it.  Easiest to just
+zero the whole thing. */
+		xzero (*tttextw->szText);
+		xetcsncpy ((Extbyte *) tttextw->szText, btextext, 79);
 	      }
+	    else
+	      tttextw->lpszText = NULL;
 #endif
 	  }
 	/* handle tree view callbacks */
 	else if ((int) nmhdr->code == TVN_SELCHANGED)
 	  {
 	  }
 	/* handle tab control callbacks */
 	else if ((int) nmhdr->code == TCN_SELCHANGE)
 	  {
 	    TC_ITEM item;
-	    int idx = SendMessage (nmhdr->hwndFrom, TCM_GETCURSEL, 0, 0);
+	    int idx = qxeSendMessage (nmhdr->hwndFrom, TCM_GETCURSEL, 0, 0);
 	    frame = XFRAME (mswindows_find_frame (hwnd));
 	    item.mask = TCIF_PARAM;
-	    SendMessage (nmhdr->hwndFrom, TCM_GETITEM, (WPARAM)idx,
+	    qxeSendMessage (nmhdr->hwndFrom, TCM_GETITEM, (WPARAM) idx,
-			 (LPARAM)&item);
+			    (LPARAM) &item);
 	    mswindows_handle_gui_wm_command (frame, 0, item.lParam);
 	  }
 }
 break;
 	  {
 	    FRAME_VISIBLE_P (frame) = 0;
 	    FRAME_ICONIFIED_P (frame) = 0;
 	  }
-	return DefWindowProc (hwnd, message_, wParam, lParam);
+	goto defproc;
 }
 case WM_SHOWWINDOW:
 /*
 The WM_SHOWWINDOW message is sent to a window when the window
 }
 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)
+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);
+	  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)
+	  if (wParam == SIZE_MINIMIZED)
 	    {
 	      /* Iconified */
 	      mswindows_enqueue_magic_event (hwnd, XM_UNMAPFRAME);
 	    }
 	  else
 	      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);
+	      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,
+		  mswindows_size_frame_internal (frame,
-						  FRAME_MSWINDOWS_TARGET_RECT
+						 FRAME_MSWINDOWS_TARGET_RECT
-						  (frame));
+						 (frame));
-		  /* Reset so we do not get here again. The SetWindowPos call in
+		  /* Reset so we do not get here again. The SetWindowPos
-		   * mswindows_size_frame_internal can cause recursion here. */
+		   * 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;
 		    }
 	    && wpl.showCmd != SW_SHOWMAXIMIZED
 	    && !(wp->flags & SWP_NOSIZE))
 	  {
 	    RECT ncsize = { 0, 0, 0, 0 };
 	    int pixwidth, pixheight;
-	    AdjustWindowRectEx (&ncsize, GetWindowLong (hwnd, GWL_STYLE),
+	    AdjustWindowRectEx (&ncsize, qxeGetWindowLong (hwnd, GWL_STYLE),
 				GetMenu(hwnd) != NULL,
-				GetWindowLong (hwnd, GWL_EXSTYLE));
+				qxeGetWindowLong (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);
 	   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 = 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 = FRAME_MSWINDOWS_DATA (XFRAME (mswindows_find_frame (hwnd)));
 msframe->sizing = 0;
 /* Queue noop event */
 mswindows_enqueue_magic_event (NULL, XM_BUMPQUEUE);
 return 0;
 	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 */
+	if (UNBOUNDP (mswindows_pump_outstanding_events()))	/* Can GC */
 	  {
 	    /* Error during event pumping - cancel scroll */
-	    SendMessage (hwndScrollBar, WM_CANCELMODE, 0, 0);
+	    qxeSendMessage (hwndScrollBar, WM_CANCELMODE, 0, 0);
 	  }
 	UNGCPRO;
 	break;
 }
 }
 #endif
 #ifdef HAVE_MENUBARS
 case WM_INITMENU:
-if (UNBOUNDP (mswindows_handle_wm_initmenu (
+if (UNBOUNDP (mswindows_handle_wm_initmenu
-						  (HMENU) wParam,
+		    ((HMENU) wParam,
-						  XFRAME (mswindows_find_frame (hwnd)))))
+		     XFRAME (mswindows_find_frame (hwnd)))))
-	SendMessage (hwnd, WM_CANCELMODE, 0, 0);
+	qxeSendMessage (hwnd, WM_CANCELMODE, 0, 0);
 break;
 case WM_INITMENUPOPUP:
 if (!HIWORD(lParam))
 	{
-	  if (UNBOUNDP (mswindows_handle_wm_initmenupopup (
+	  if (UNBOUNDP (mswindows_handle_wm_initmenupopup
-							   (HMENU) wParam,
+			((HMENU) wParam,
-							   XFRAME (mswindows_find_frame (hwnd)))))
+			 XFRAME (mswindows_find_frame (hwnd)))))
-	    SendMessage (hwnd, WM_CANCELMODE, 0, 0);
+	    qxeSendMessage (hwnd, WM_CANCELMODE, 0, 0);
 	}
 break;
 #endif /* HAVE_MENUBARS */
 #ifdef HAVE_TOOLBARS
 	if (!NILP (mswindows_handle_toolbar_wm_command (frame, cid, id)))
 	  break;
 #endif
-	/* widgets in a buffer only eval a callback for suitable events.*/
+	/* 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*/
+	   always exist */
 #ifdef HAVE_MENUBARS
 	if (!NILP (mswindows_handle_wm_command (frame, id)))
 	  break;
 #endif
-	return DefWindowProc (hwnd, message_, wParam, lParam);
+	goto defproc;
-	/* Bite me - a spurious command. This used to not be able to
+	/* Bite me - a spurious command.  This used to not be able to
-	   happen but with the introduction of widgets its now
+	   happen but with the introduction of widgets it's now
-	   possible. */
+	   possible. #### Andy, fix the god-damn widget code!  It has
+	   more bugs than a termite's nest! */
 }
 break;
 case WM_CTLCOLORBTN:
 case WM_CTLCOLORLISTBOX:
 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;
+	HWND crtlwnd = (HWND) lParam;
-	LONG ii = GetWindowLong (crtlwnd, GWL_USERDATA);
+	LONG ii = qxeGetWindowLong (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;
+		HDC hdc = (HDC) wParam;
 		if (last_widget_brushed != ii)
 		  {
 		    if (widget_brush)
 		      DeleteObject (widget_brush);
 		    widget_brush = CreateSolidBrush
 goto defproc;
 #ifdef HAVE_DRAGNDROP
 case WM_DROPFILES:	/* implementation ripped-off from event-Xt.c */
 {
-	UINT filecount, i, len;
+	UINT filecount, i;
 	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);
+	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->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);
+	filecount = qxeDragQueryFile ((HDROP) wParam, 0xffffffff, NULL, 0);
-	for (i=0; i<filecount; i++)
+	for (i = 0; i < filecount; i++)
 	  {
-	    len = DragQueryFile ((HDROP) wParam, i, NULL, 0);
+	    Intbyte *fname;
+	    Extbyte *fname_ext;
+	    Bytecount fnamelen;
+	    Charcount len = qxeDragQueryFile ((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);
+	    fname_ext = (Extbyte *) alloca ((len + 1) * XETCHAR_SIZE);
-	    DragQueryFile ((HANDLE) wParam, i, fname, len+1);
+	    qxeDragQueryFile ((HDROP) wParam, i, fname_ext, len + 1);
+	    TO_INTERNAL_FORMAT (DATA, (fname_ext, len * XETCHAR_SIZE),
+				ALLOCA, (fname, fnamelen),
+				Qmswindows_tstr);
 	    /* May be a shell link aka "shortcut" - replace fname if so */
-#if !(defined(CYGWIN) || defined(MINGW))
+#if !defined (NO_CYGWIN_COM_SUPPORT)
-	    /* cygwin doesn't define this COM stuff */
+	    if (!qxestrcasecmp_c (fname + fnamelen - 4, ".LNK"))
-	    if (!stricmp (fname + strlen (fname) - 4, ".LNK"))
 	      {
-		IShellLink* psl;
+		/* ####
-		if (CoCreateInstance (&CLSID_ShellLink, NULL,
+		   Note the following in the docs:
-				      CLSCTX_INPROC_SERVER, &IID_IShellLink, &psl) == S_OK)
+		   Note: The IShellLink interface has an ANSI version
+		   (IShellLinkA) and a Unicode version (IShellLinkW). The
+		   version that will be used depends on whether you compile
+		   for ANSI or Unicode. However, Microsoft� Windows 95 and
+		   Microsoft� Windows 98 only support IShellLinkA.
+		   We haven't yet implemented COM support in the
+		   Unicode-splitting library.  I don't quite understand how
+		   COM works yet, but it looks like what's happening is
+		   that the ShellLink class implements both the IShellLinkA
+		   and IShellLinkW interfaces.  To make this work at
+		   run-time, we have to do something like this:
+		   -- define a new interface qxeIShellLink that uses
+		   Extbyte * instead of LPSTR or LPWSTR. (not totally
+		   necessary since Extbyte * == LPSTR).
+		   -- define a new class qxeShellLink that implements
+		   qxeIShellLink.  the methods on this class need to create
+		   a shadow ShellLink object to do all the real work, and
+		   call the corresponding function from either the
+		   IShellLinkA or IShellLinkW interfaces on this object,
+		   depending on whether XEUNICODE_P is defined.
+		   -- with appropriate preprocessor magic, of course, we
+		   could make things appear transparent; but we've decided
+		   not to do preprocessor magic for the moment.
+		   */
+		/* #### Not Unicode-split for the moment; we have to do it
+ourselves. */
+		if (XEUNICODE_P)
 		  {
-		    IPersistFile* ppf;
+		    IShellLinkW *psl;
-		    if (psl->lpVtbl->QueryInterface (psl, &IID_IPersistFile,
+		    if (CoCreateInstance (
-						     &ppf) == S_OK)
+					  XECOMID (CLSID_ShellLink),
+					  NULL,
+					  CLSCTX_INPROC_SERVER,
+					  XECOMID (IID_IShellLinkW),
+					  (void **) &psl) == S_OK)
 		      {
-			OLECHAR wsz[PATH_MAX];
+			IPersistFile *ppf;
-			WIN32_FIND_DATA wfd;
-			LPSTR resolved = (char *) xmalloc (PATH_MAX+1);
+			if (XECOMCALL2 (psl, QueryInterface,
+					XECOMID (IID_IPersistFile),
-			MultiByteToWideChar (CP_ACP,0, fname, -1, wsz, PATH_MAX);
+					(void **) &ppf) ==
+			    S_OK)
-			if ((ppf->lpVtbl->Load (ppf, wsz, STGM_READ) == S_OK) &&
-			    (psl->lpVtbl->GetPath (psl, resolved, PATH_MAX,
-						   &wfd, 0)==S_OK))
 			  {
-			    xfree (fname);
+			    Extbyte *fname_unicode;
-			    fname = resolved;
+			    WIN32_FIND_DATAW wfd;
-			    len = strlen (fname);
+			    LPWSTR resolved =
+			      alloca_array (WCHAR, PATH_MAX + 1);
+			    TO_EXTERNAL_FORMAT (DATA, (fname, fnamelen),
+						C_STRING_ALLOCA,
+						fname_unicode,
+						Qmswindows_unicode);
+			    if (XECOMCALL2 (ppf, Load,
+					    (LPWSTR) fname_unicode,
+					    STGM_READ) == S_OK &&
+				/* #### YUCK!  Docs read
+cchMaxPath
+Maximum number of bytes to copy to the buffer pointed to by the
+	pszFile parameter.
+But "cch" means "count of characters", not bytes.  I'll assume the doc
+writers messed up and the programmer was correct.  Also, this approach
+is safe even if it's actually the other way around. */
+#ifdef CYGWIN_HEADERS /* Another Cygwin prototype error */
+				XECOMCALL4 (psl, GetPath, (LPSTR) resolved,
+					    PATH_MAX, &wfd, 0)
+#else
+				XECOMCALL4 (psl, GetPath, resolved,
+					    PATH_MAX, &wfd, 0)
+#endif
+				== S_OK)
+			      TO_INTERNAL_FORMAT (C_STRING, resolved,
+						  ALLOCA, (fname, fnamelen),
+						  Qmswindows_tstr);
+			    XECOMCALL0 (ppf, Release);
 			  }
-			ppf->lpVtbl->Release (ppf);
+			XECOMCALL0 (psl, Release);
 		      }
+		  }
-		    psl->lpVtbl->Release (psl);
+		else
+		  {
+		    IShellLinkA *psl;
+		    if (CoCreateInstance (
+					  XECOMID (CLSID_ShellLink),
+					  NULL,
+					  CLSCTX_INPROC_SERVER,
+					  XECOMID (IID_IShellLinkA),
+					  (void **) &psl) == S_OK)
+		      {
+			IPersistFile *ppf;
+			if (XECOMCALL2 (psl, QueryInterface,
+					XECOMID (IID_IPersistFile),
+					(void **) &ppf) ==
+			    S_OK)
+			  {
+			    Extbyte *fname_unicode;
+			    WIN32_FIND_DATAA wfd;
+			    LPSTR resolved =
+			      alloca_array (CHAR, PATH_MAX + 1);
+			    /* Always Unicode.  Not obvious from the
+IPersistFile documentation, but look under
+"Shell Link" for example code. */
+			    TO_EXTERNAL_FORMAT (DATA, (fname, fnamelen),
+						C_STRING_ALLOCA,
+						fname_unicode,
+						Qmswindows_unicode);
+			    if (XECOMCALL2 (ppf, Load,
+					    (LPWSTR) fname_unicode,
+					    STGM_READ) == S_OK
+				&& XECOMCALL4 (psl, GetPath, resolved,
+					       PATH_MAX, &wfd, 0) == S_OK)
+			      TO_INTERNAL_FORMAT (C_STRING, resolved,
+						  ALLOCA, (fname, fnamelen),
+						  Qmswindows_tstr);
+			    XECOMCALL0 (ppf, Release);
+			  }
+			XECOMCALL0 (psl, Release);
+		      }
 		  }
 	      }
-#endif
+#endif /* !defined (NO_CYGWIN_COM_SUPPORT) */
+	    {
-#ifdef CYGWIN
+	      fname = urlify_filename (fname);
-	    filename = xmalloc (cygwin_win32_to_posix_path_list_buf_size (fname) + 5);
+	      l_item = build_intstring (fname);
-	    strcpy (filename, "file:");
+	      xfree (fname);
-	    cygwin_win32_to_posix_path_list (fname, filename+5);
+	      l_dndlist = Fcons (l_item, l_dndlist);
-#else
+	    }
-	    filename = (char *)xmalloc (len+6);
-	    strcat (strcpy (filename, "file:"), fname);
-	    dostounix_filename (filename+5);
-#endif
-	    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
+#endif /* HAVE_DRAGNDROP */
+#ifdef MULE
+case WM_IME_CHAR:
+case WM_IME_STARTCOMPOSITION:
+mswindows_start_ime_composition (XFRAME (mswindows_find_frame (hwnd)));
+goto defproc;
+case WM_IME_COMPOSITION:
+if (lParam & GCS_RESULTSTR)
+{
+HIMC imc = ImmGetContext (hwnd);
+	 Extbyte *result;
+Bytecount len;
+	 Intbyte *resultint, *endptr;
+	 Bytecount lenint;
+	 int speccount;
+if (!imc)
+break;
+	 /* See WM_KEYDOWN above. */
+	 speccount = begin_dont_check_for_quit ();
+	 /* Sizes always in bytes, even for unicode.
+ImmGetCompositionStringW is supported even on Windows 9x, and
+allows us to handle multiple languages. */
+len = ImmGetCompositionStringW (imc, GCS_RESULTSTR, NULL, 0);
+	 result = alloca_array (Extbyte, len);
+ImmGetCompositionStringW (imc, GCS_RESULTSTR, (WCHAR *) result, len);
+ImmReleaseContext (hwnd, imc);
+	 TO_INTERNAL_FORMAT (DATA, (result, len),
+			     ALLOCA, (resultint, lenint),
+			     Qmswindows_tstr);
+	 endptr = resultint + lenint;
+	 while (resultint < endptr)
+	   {
+	     Emchar ch = charptr_emchar (resultint);
+	      if (ch == ' ')
+		mswindows_enqueue_keypress_event (hwnd, QKspace, 0);
+	      else
+		mswindows_enqueue_keypress_event (hwnd, make_char (ch), 0);
+	     INC_CHARPTR (resultint);
+	   }
+	 unbind_to (speccount);
+}
+goto defproc;
+#endif /* MULE */
 defproc:
 default:
-return DefWindowProc (hwnd, message_, wParam, lParam);
+return qxeDefWindowProc (hwnd, message_, wParam, lParam);
 }
 return (0);
 }
 {
 /* This simple caching mechanism saves 10% of CPU
 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 = (HKL) -1;
+HKL current_hkl = GetKeyboardLayout (0);
-if (xGetKeyboardLayout) /* not in NT 3.5 */
-current_hkl = xGetKeyboardLayout (0);
 if (current_hkl != last_hkl)
 {
 int c;
 last_hkl_has_AltGr = 0;
 /* In this loop, we query whether a character requires
 /* Returns the state of the modifier keys in the format expected by the
 * Lisp_Event key_data, button_data and motion_data modifiers member */
 static int
-mswindows_modifier_state (BYTE* keymap, DWORD fwKeys, int has_AltGr)
+mswindows_modifier_state (BYTE *keymap, DWORD fwKeys, int has_AltGr)
 {
 int mods = 0;
 int keys_is_real = 0;
 BYTE keymap2[256];
 }
 else
 {
 switch (mswindows_key)
 	{
+#if 0
+	VK_LBUTTON:
+	VK_RBUTTON:
+	VK_CANCEL:
+	VK_MBUTTON:
+	VK_XBUTTON1:
+	VK_XBUTTON2:
+#endif /* 0 */
 	case VK_BACK:		return QKbackspace;
 	case VK_TAB:		return QKtab;
+	  /* #### Officially 0A (and 0B too) are "reserved". */
 	case '\n':		return QKlinefeed;
 	case VK_CLEAR:		return KEYSYM ("clear");
 	case VK_RETURN:		return QKreturn;
+#if 0
+	VK_SHIFT: "shift"
+	VK_CONTROL: "control"
+	VK_MENU: "alt"
+#endif /* 0 */
 	case VK_PAUSE:		return KEYSYM ("pause");
+#if 0
+	VK_CAPITAL: "caps-lock"
+	VK_KANA: IME Kana mode
+	VK_HANGUEL: IME Hanguel mode (maintained for compatibility; use VK_HANGUL)
+	VK_HANGUL: IME Hangul mode
+	VK_JUNJA: IME Junja mode
+	VK_FINAL: IME final mode
+	VK_HANJA: IME Hanja mode
+	VK_KANJI: IME Kanji mode
+#endif /* 0 */
 	case VK_ESCAPE:		return QKescape;
+#if 0
+	VK_CONVERT: IME convert
+	VK_NONCONVERT: IME nonconvert
+	VK_ACCEPT: IME accept
+	VK_MODECHANGE: IME mode change request
+#endif /* 0 */
 	case VK_SPACE:		return QKspace;
 	case VK_PRIOR:		return KEYSYM ("kp-prior");
 	case VK_NEXT:		return KEYSYM ("kp-next");
 	case VK_END:		return KEYSYM ("kp-end");
 	case VK_HOME:		return KEYSYM ("kp-home");
 	case VK_EXECUTE:	return KEYSYM ("execute");
 	case VK_SNAPSHOT:	return KEYSYM ("print");
 	case VK_INSERT:		return KEYSYM ("kp-insert");
 	case VK_DELETE:		return KEYSYM ("kp-delete");
 	case VK_HELP:		return KEYSYM ("help");
+#if 0
+	  '0' through '9': numeric keys
+	  'A' through 'Z': alphabetic keys
+	  VK_LWIN: "lwin"
+	  VK_RWIN: "rwin"
+	  VK_APPS: "apps"
+	  VK_SLEEP: "sleep"
+#endif /* 0 */
 	case VK_NUMPAD0:	return KEYSYM ("kp-0");
 	case VK_NUMPAD1:	return KEYSYM ("kp-1");
 	case VK_NUMPAD2:	return KEYSYM ("kp-2");
 	case VK_NUMPAD3:	return KEYSYM ("kp-3");
 	case VK_NUMPAD4:	return KEYSYM ("kp-4");
 	case VK_F20:		return KEYSYM ("f20");
 	case VK_F21:		return KEYSYM ("f21");
 	case VK_F22:		return KEYSYM ("f22");
 	case VK_F23:		return KEYSYM ("f23");
 	case VK_F24:		return KEYSYM ("f24");
+#if 0
+	VK_NUMLOCK: 90 NUM LOCK key
+	VK_SCROLL: 91 SCROLL LOCK key
+	  92~96 OEM specific;
+	VK_LSHIFT:
+	VK_RSHIFT:
+	VK_LCONTROL:
+	VK_RCONTROL:
+	VK_LMENU:
+	VK_RMENU:
+#ifdef VK_BROWSER_BACK /* Windows 2000 only */
+	VK_BROWSER_BACK: Browser Back key
+	VK_BROWSER_FORWARD: Browser Forward key
+	VK_BROWSER_REFRESH: Browser Refresh key
+	VK_BROWSER_STOP: Browser Stop key
+	VK_BROWSER_SEARCH: Browser Search key
+	VK_BROWSER_FAVORITES: Browser Favorites key
+	VK_BROWSER_HOME: Browser Start and Home key
+	VK_VOLUME_MUTE: Volume Mute key
+	VK_VOLUME_DOWN: Volume Down key
+	VK_VOLUME_UP: Volume Up key
+	VK_MEDIA_NEXT_TRACK: Next Track key
+	VK_MEDIA_PREV_TRACK: Previous Track key
+	VK_MEDIA_STOP: Stop Media key
+	VK_MEDIA_PLAY_PAUSE: Play/Pause Media key
+	VK_LAUNCH_MAIL: Start Mail key
+	VK_LAUNCH_MEDIA_SELECT: Select Media key
+	VK_LAUNCH_APP1: Start Application 1 key
+	VK_LAUNCH_APP2: Start Application 2 key
+	  B8-B9 Reserved;
+	VK_OEM_1: For the US standard keyboard, the ';:' key
+	VK_OEM_PLUS: For any country/region, the '+' key
+	VK_OEM_COMMA: For any country/region, the ',' key
+	VK_OEM_MINUS: For any country/region, the '-' key
+	VK_OEM_PERIOD: For any country/region, the '.' key
+	VK_OEM_2: For the US standard keyboard, the '/?' key
+	VK_OEM_3: For the US standard keyboard, the '`~' key
+	  C1~D7 Reserved;
+	  D8~DA Unassigned;
+	VK_OEM_4: For the US standard keyboard, the '[{' key
+	VK_OEM_5: For the US standard keyboard, the '\|' key
+	VK_OEM_6: For the US standard keyboard, the ']}' key
+	VK_OEM_7: For the US standard keyboard, the 'single-quote/double-quote' key
+	VK_OEM_8:
+	  E0 Reserved;
+	  E1 OEM specific;
+	VK_OEM_102: Either the angle bracket key or the backslash key on the RT 102-key keyboard
+	  E3~E4 OEM specific;
+#endif /* VK_BROWSER_BACK */
+	VK_PROCESSKEY: E5 Windows 95/98, Windows NT 4.0, Windows 2000: IME PROCESS key
+	  E6 OEM specific;
+	VK_PACKET: Used to pass Unicode characters as if they were keystrokes. The VK_PACKET key is the low word of a 32-bit Virtual Key value used for non-keyboard input methods. For more information, see Remark in KEYBDINPUT, SendInput, WM_KEYDOWN, and WM_KEYUP
+	  E8 Unassigned;
+	  E9~F5 OEM specific;
+	VK_ATTN: Attn key
+	VK_CRSEL: CrSel key
+	VK_EXSEL: ExSel key
+	VK_EREOF: Erase EOF key
+	VK_PLAY: Play key
+	VK_ZOOM: Zoom key
+	VK_NONAME: Reserved for future use
+	VK_PA1: PA1 key
+	VK_OEM_CLEAR: Clear key
+#endif /* 0 */
 	}
 }
 return Qnil;
 }
 * Find the frame that matches the supplied mswindows window handle
 */
 Lisp_Object
 mswindows_find_frame (HWND hwnd)
 {
-LONG l = GetWindowLong (hwnd, XWL_FRAMEOBJ);
+LONG l = qxeGetWindowLong (hwnd, XWL_FRAMEOBJ);
 Lisp_Object f;
 if (l == 0)
 {
 /* We are in progress of frame creation. Return the frame
 	 being created, as it still not remembered in the window
 * Handle a magic event off the dispatch queue.
 */
 static void
 emacs_mswindows_handle_magic_event (Lisp_Event *emacs_event)
 {
-switch (EVENT_MSWINDOWS_MAGIC_TYPE(emacs_event))
+switch (EVENT_MSWINDOWS_MAGIC_TYPE (emacs_event))
 {
 case XM_BUMPQUEUE:
 break;
 case WM_PAINT:
 case WM_SETFOCUS:
 case WM_KILLFOCUS:
 {
 	Lisp_Object frame = EVENT_CHANNEL (emacs_event);
 	struct frame *f = XFRAME (frame);
-	int in_p = (EVENT_MSWINDOWS_MAGIC_TYPE(emacs_event) == WM_SETFOCUS);
+	int in_p = (EVENT_MSWINDOWS_MAGIC_TYPE (emacs_event) == WM_SETFOCUS);
 	Lisp_Object conser;
 	struct gcpro gcpro1;
 	/* On focus change, clear all memory of sticky modifiers
 	   to avoid non-intuitive behavior. */
 case XM_MAPFRAME:
 case XM_UNMAPFRAME:
 {
 	Lisp_Object frame = EVENT_CHANNEL (emacs_event);
-	va_run_hook_with_args (EVENT_MSWINDOWS_MAGIC_TYPE(emacs_event)
+	va_run_hook_with_args (EVENT_MSWINDOWS_MAGIC_TYPE (emacs_event)
 			       == XM_MAPFRAME ?
 			       Qmap_frame_hook : Qunmap_frame_hook,
 			       1, frame);
 }
 break;
 Vquit_flag = critical_p ? Qcritical : Qt;
 }
 }
 USID
-emacs_mswindows_create_stream_pair (void* inhandle, void* outhandle,
+emacs_mswindows_create_stream_pair (void *inhandle, void *outhandle,
-				    Lisp_Object* instream,
+				    Lisp_Object *instream,
-				    Lisp_Object* outstream,
+				    Lisp_Object *outstream,
 				    int flags)
 {
 /* Handles for streams */
 HANDLE hin, hout;
 /* fds. These just stored along with the streams, and are closed in
 	    : get_ntpipe_input_stream_param (XLSTREAM (instream)));
 int out = (NILP(outstream) ? -1
 	     : filedesc_stream_fd (XLSTREAM (outstream)));
 if (in >= 0)
-close (in);
+retry_close (in);
 if (out != in && out >= 0)
-close (out);
+retry_close (out);
 #endif
 return (NILP (instream)
 	  ? USID_DONTHASH
 #if defined(HAVE_SOCKETS) && !defined(HAVE_MSG_SELECT)
 #if 0 /* #### */
 Lisp_Object instr, outstr;
 get_process_streams (p, &instr, &outstr);
 /* if it still has fds, then it hasn't been killed yet. */
-assert (NILP(instr));
+assert (NILP (instr));
-assert (NILP(outstr));
+assert (NILP (outstr));
 /* #### More checks here */
 #endif
 }
 #endif
 mswindows_event_stream->quit_p_cb		= emacs_mswindows_quit_p;
 mswindows_event_stream->select_console_cb 	= emacs_mswindows_select_console;
 mswindows_event_stream->unselect_console_cb	= emacs_mswindows_unselect_console;
 #ifdef HAVE_MSG_SELECT
 mswindows_event_stream->select_process_cb 	=
-(void (*)(Lisp_Process*))event_stream_unixoid_select_process;
+(void (*)(Lisp_Process *)) event_stream_unixoid_select_process;
 mswindows_event_stream->unselect_process_cb	=
-(void (*)(Lisp_Process*))event_stream_unixoid_unselect_process;
+(void (*)(Lisp_Process *)) event_stream_unixoid_unselect_process;
 mswindows_event_stream->create_stream_pair_cb = event_stream_unixoid_create_stream_pair;
 mswindows_event_stream->delete_stream_pair_cb = event_stream_unixoid_delete_stream_pair;
 #else
 mswindows_event_stream->select_process_cb 	= emacs_mswindows_select_process;
 mswindows_event_stream->unselect_process_cb	= emacs_mswindows_unselect_process;
 void
 init_event_mswindows_late (void)
 {
 #ifdef HAVE_MSG_SELECT
-windows_fd = open("/dev/windows", O_RDONLY | O_NONBLOCK, 0);
+windows_fd = retry_open ("/dev/windows", O_RDONLY | O_NONBLOCK, 0);
 assert (windows_fd>=0);
 FD_SET (windows_fd, &input_wait_mask);
 FD_ZERO(&zero_mask);
 #endif

Mercurial > hg > xemacs-beta

comparison src/event-msw.c @ 771:943eaba38521