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

comparison src/event-msw.c @ 384:bbff43aa5eb7 r21-2-7

Import from CVS: tag r21-2-7

author	cvs
date	Mon, 13 Aug 2007 11:08:24 +0200
parents	064ab7fed2e0
children	aabb7f5b1c81

comparison

equal deleted inserted replaced

-:6a50c6a581a5
+:bbff43aa5eb7
 /* 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.
 */
 #include <config.h>
 #include "lisp.h"
 #endif
 #include "device.h"
 #include "events.h"
 #include "frame.h"
+#include "buffer.h"
+#include "faces.h"
 #include "lstream.h"
 #include "process.h"
 #include "redisplay.h"
 #include "sysproc.h"
 #include "syswait.h"
 #include "systime.h"
 #include "sysdep.h"
+#include "objects-msw.h"
 #include "events-mod.h"
 #ifdef HAVE_MSG_SELECT
 #include "sysfile.h"
 #elif defined(__CYGWIN32__)
 extern Lisp_Object
 mswindows_get_toolbar_button_text (struct frame* f, int command_id);
 extern Lisp_Object
 mswindows_handle_toolbar_wm_command (struct frame* f, HWND ctrl, WORD id);
+extern Lisp_Object
+mswindows_handle_gui_wm_command (struct frame* f, HWND ctrl, WORD id);
 static Lisp_Object mswindows_find_frame (HWND hwnd);
 static Lisp_Object mswindows_find_console (HWND hwnd);
 static Lisp_Object mswindows_key_to_emacs_keysym(int mswindows_key, int mods);
 static int mswindows_modifier_state (BYTE* keymap, int has_AltGr);
 #define MAX_WAITABLE (MAXIMUM_WAIT_OBJECTS - 1)
 /* List of mswindows waitable handles. */
 static HANDLE mswindows_waitable_handles[MAX_WAITABLE];
+#ifndef HAVE_MSG_SELECT
 /* 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;
 /* Count of quit chars currently in the queue */
 /* Incremented in WM_[SYS]KEYDOWN handler in the mswindows_wnd_proc()
 Decremented in mswindows_dequeue_dispatch_event() */
 int mswindows_quit_chars_count = 0;
 };
 DEFINE_LSTREAM_IMPLEMENTATION ("ntpipe-output", lstream_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;
 get_ntpipe_output_stream_param (Lstream *stream)
 {
 struct ntpipe_shove_stream* s = NTPIPE_SHOVE_STREAM_DATA(stream);
 return s->user_data;
 }
+#endif
 static int
 ntpipe_shove_writer (Lstream *stream, const unsigned char *data, size_t size)
 {
 struct ntpipe_shove_stream* s = NTPIPE_SHOVE_STREAM_DATA(stream);
 if (message==WM_LBUTTONDOWN || message==WM_MBUTTONDOWN ||
 message==WM_RBUTTONDOWN)
 {
 event->event_type = button_press_event;
 SetCapture (hwnd);
+/* we need this to make sure the main window regains the focus
+from control subwindows */
+if (GetFocus() != hwnd)
+	{
+	  SetFocus (hwnd);
+	  mswindows_enqueue_magic_event (hwnd, WM_SETFOCUS);
+	}
 }
 else
 {
 event->event_type = button_release_event;
 ReleaseCapture ();
 return event;
 }
 /*
 * Remove and return the first emacs event on the dispatch queue that matches
-* the supplied event
+* the supplied event.
-* Timeout event matches if interval_id equals to that of the given event.
+* Timeout event matches if interval_id is equal to that of the given event.
 * Keypress event matches if logical AND between modifiers bitmask of the
-* event in the queue and that of the given event is non-zero
+* event in the queue and that of the given event is non-zero.
-* For all other event types, this function asserts.
+* For all other event types, this function aborts.
 */
 Lisp_Object
-mswindows_cancel_dispatch_event (struct Lisp_Event* match)
+mswindows_cancel_dispatch_event (struct Lisp_Event *match)
 {
 Lisp_Object event;
-Lisp_Object previous_event=Qnil;
+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;
 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_CHAIN_LOOP (event, *head)
 {
-int found = 1;
+struct Lisp_Event *e = XEVENT (event);
-if (XEVENT_TYPE (event) != match->event_type)
+if ((e->event_type == match->event_type) &&
-	found = 0;
+	  ((e->event_type == timeout_event) ?
-if (found && match->event_type == timeout_event
+	   (e->event.timeout.interval_id == match->event.timeout.interval_id) :
-	  && (XEVENT(event)->event.timeout.interval_id !=
+	   /* Must be key_press_event */
-	      match->event.timeout.interval_id))
+	   ((e->event.key.modifiers & match->event.key.modifiers) != 0)))
-	found = 0;
-if (found && match->event_type == key_press_event
-	  && ((XEVENT(event)->event.key.modifiers &
-	      match->event.key.modifiers) == 0))
-	found = 0;
-if (found)
 	{
 	  if (NILP (previous_event))
 	    dequeue_event (head, tail);
 	  else
 	    {
 previous_event = event;
 }
 return Qnil;
 }
+#ifndef HAVE_MSG_SELECT
 /************************************************************************/
 /*                     Waitable handles manipulation                    */
 /************************************************************************/
 static int
 find_waitable_handle (HANDLE h)
 return;
 mswindows_waitable_handles [ix] =
 mswindows_waitable_handles [--mswindows_waitable_count];
 }
+#endif /* HAVE_MSG_SELECT */
 /************************************************************************/
 /*                             Event pump                               */
 /************************************************************************/
 mswindows_drain_windows_queue ()
 {
 MSG msg;
 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 )
+	{
+	  TranslateMessage (&msg);
+	}
 DispatchMessage (&msg);
 mswindows_unmodalize_signal_maybe ();
 }
 }
 	mswindows_enqueue_keypress_event (hwnd, keysym, mods);
 else
 	{
 	  int quit_ch = CONSOLE_QUIT_CHAR (XCONSOLE (mswindows_find_console (hwnd)));
 	  BYTE keymap_orig[256];
-	  MSG msg = { hwnd, message, wParam, lParam, GetMessageTime(), (GetMessagePos()) };
+	  POINT pnt = { LOWORD (GetMessagePos()), HIWORD (GetMessagePos()) };
+	  MSG msg = { hwnd, message, wParam, lParam, GetMessageTime(), 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)
 	  if (!NILP(btext))
 	    {
 	      /* I think this is safe since the text will only go away
 when the toolbar does...*/
-	      tttext->lpszText=XSTRING_DATA (btext);
+	      GET_C_STRING_EXT_DATA_ALLOCA (btext, FORMAT_OS,
+					    tttext->lpszText);
 	    }
 #if 0
 	  tttext->uFlags |= TTF_DI_SETITEM;
 #endif
 	}
 #endif /* HAVE_MENUBARS */
 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;
 #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;
+	default:		/* do nothing */
+	}
+/* menubars always must come last since the hashtables do not
+always exist*/
 #ifdef HAVE_MENUBARS
 if (!NILP (mswindows_handle_wm_command (frame, id)))
 	break;
 #endif
-/* Bite me - a spurious command. This cannot happen. */
+return DefWindowProc (hwnd, message, wParam, lParam);
-error ("XEMACS BUG: Cannot decode command message");
+/* 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)
+	      &&
+	      !NILP (XIMAGE_INSTANCE_WIDGET_FACE (image_instance)))
+	    {
+	      /* 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;
 #ifdef HAVE_DRAGNDROP
 case WM_DROPFILES:	/* implementation ripped-off from event-Xt.c */
 {
 UINT filecount, i, len;
 default:
 assert(0);
 }
 }
+#ifndef HAVE_MSG_SELECT
 static HANDLE
 get_process_input_waitable (struct Lisp_Process *process)
 {
 Lisp_Object instr, outstr, p;
 XSETPROCESS (p, process);
 /* Process handle is removed in the event loop as soon
 as it is signaled, so don't bother here about it */
 HANDLE hev = get_process_input_waitable (process);
 remove_waitable_handle (hev);
 }
+#endif /* HAVE_MSG_SELECT */
 static void
 emacs_mswindows_select_console (struct console *con)
 {
 }
 }
 static void
 emacs_mswindows_quit_p (void)
 {
+MSG msg;
 /* Quit cannot happen in modal loop: all program
 input is dedicated to Windows. */
 if (mswindows_in_modal_loop)
 return;
-/* Drain windows queue. This sets up number of quit
+/* Drain windows queue. This sets up number of quit characters in the queue
-characters in in the queue */
+* (and also processes wm focus change, move, resize, etc messages).
-mswindows_drain_windows_queue ();
+* We don't want to process WM_PAINT messages because this function can be
+* called from almost anywhere and the windows' states may be changing. */
+while (PeekMessage (&msg, NULL, 0, WM_PAINT-1, PM_REMOVE) ||
+	 PeekMessage (&msg, NULL, WM_PAINT+1, WM_USER-1, PM_REMOVE))
+DispatchMessage (&msg);
 if (mswindows_quit_chars_count > 0)
 {
 /* Yes there's a hidden one... Throw it away */
 struct Lisp_Event match_against;

Mercurial > hg > xemacs-beta

comparison src/event-msw.c @ 384:bbff43aa5eb7 r21-2-7