/* GDK - The GIMP Drawing Kit
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
- * Copyright (C) 1998-1999 Tor Lillqvist
+ * Copyright (C) 1998-2002 Tor Lillqvist
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
-#include "config.h"
-
/* Cannot use TrackMouseEvent, as the stupid WM_MOUSELEAVE message
* doesn't tell us where the mouse has gone. Thus we cannot use it to
* generate a correct GdkNotifyType. Pity, as using TrackMouseEvent
*/
/* define USE_TRACKMOUSEEVENT */
+/* Do use SetCapture, it works now. Thanks to jpe@archaeopteryx.com */
+#define USE_SETCAPTURE 1
+
#include <stdio.h>
+#include "gdk.h"
#include "gdkprivate-win32.h"
+#include "gdkinput-win32.h"
+#include "gdkkeysyms.h"
#include <objbase.h>
+
+#if defined (__GNUC__) && defined (HAVE_DIMM_H)
+/* The w32api imm.h clashes a bit with the IE5.5 dimm.h */
+# define IMEMENUITEMINFOA hidden_IMEMENUITEMINFOA
+# define IMEMENUITEMINFOW hidden_IMEMENUITEMINFOW
+#endif
+
#include <imm.h>
+#if defined (__GNUC__) && defined (HAVE_DIMM_H)
+# undef IMEMENUITEMINFOA
+# undef IMEMENUITEMINFOW
+#endif
+
#ifdef HAVE_DIMM_H
#include <dimm.h>
-#else
-#include "surrogate-dimm.h"
#endif
-#include "gdk.h"
-#include "gdkinternals.h"
-#include "gdkinput-win32.h"
-
-#include "gdkkeysyms.h"
-
-#define PING() printf("%s: %d\n",__FILE__,__LINE__),fflush(stdout)
-typedef struct _GdkIOClosure GdkIOClosure;
typedef struct _GdkEventPrivate GdkEventPrivate;
typedef enum
GDK_EVENT_PENDING = 1 << 0
} GdkEventFlags;
-struct _GdkIOClosure
-{
- GdkInputFunction function;
- GdkInputCondition condition;
- GdkDestroyNotify notify;
- gpointer data;
-};
-
struct _GdkEventPrivate
{
GdkEvent event;
static gboolean gdk_event_translate (GdkEvent *event,
MSG *msg,
gboolean *ret_val_flagp,
- gint *ret_valp);
+ gint *ret_valp,
+ gboolean return_exposes);
static gboolean gdk_event_prepare (GSource *source,
gint *timeout);
gdk_event_prepare,
gdk_event_check,
gdk_event_dispatch,
- (GDestroyNotify)g_free
+ NULL
};
GPollFD event_poll_fd;
static gboolean ignore_wm_char = FALSE;
static gboolean is_altgr_key = FALSE;
+#ifdef HAVE_DIMM_H
static IActiveIMMApp *active_imm_app = NULL;
static IActiveIMMMessagePumpOwner *active_imm_msgpump_owner = NULL;
+#endif
typedef BOOL (WINAPI *PFN_TrackMouseEvent) (LPTRACKMOUSEEVENT);
static PFN_TrackMouseEvent track_mouse_event = NULL;
GdkEvent *eventp;
MSG msg;
DWORD pos;
+#ifdef HAVE_DIMM_H
LRESULT lres;
+#endif
gint ret_val;
gboolean ret_val_flag;
msg.pt.y = HIWORD (pos);
event.flags = GDK_EVENT_PENDING;
- if (gdk_event_translate (&event.event, &msg, &ret_val_flag, &ret_val))
+ if (gdk_event_translate (&event.event, &msg, &ret_val_flag, &ret_val, FALSE))
{
event.flags &= ~GDK_EVENT_PENDING;
#if 1
if (event.event.any.type == GDK_CONFIGURE)
{
/* Compress configure events */
- GList *list = gdk_queued_events;
+ GList *list = _gdk_queued_events;
while (list != NULL
&& (((GdkEvent *)list->data)->any.type != GDK_CONFIGURE
else if (event.event.any.type == GDK_EXPOSE)
{
/* Compress expose events */
- GList *list = gdk_queued_events;
+ GList *list = _gdk_queued_events;
while (list != NULL
&& (((GdkEvent *)list->data)->any.type != GDK_EXPOSE
}
}
#endif
- eventp = gdk_event_new ();
+ eventp = _gdk_event_new ();
*((GdkEventPrivate *) eventp) = event;
/* Philippe Colantoni <colanton@aris.ss.uci.edu> suggests this
* GDK_EVENT_FUNC_FROM_WINDOW_PROC env var to get this
* behaviour.
*/
- if (gdk_event_func_from_window_proc && gdk_event_func)
+ if (gdk_event_func_from_window_proc && _gdk_event_func)
{
GDK_THREADS_ENTER ();
- (*gdk_event_func) (eventp, gdk_event_data);
+ (*_gdk_event_func) (eventp, _gdk_event_data);
gdk_event_free (eventp);
GDK_THREADS_LEAVE ();
}
else
{
- gdk_event_queue_append (eventp);
+ _gdk_event_queue_append (eventp);
#if 1
/* Wake up WaitMessage */
PostMessage (NULL, gdk_ping_msg, 0, 0);
return ret_val;
else
{
+#ifndef HAVE_DIMM_H
+ return DefWindowProc (hwnd, message, wparam, lparam);
+#else
if (active_imm_app == NULL
|| (*active_imm_app->lpVtbl->OnDefWindowProc) (active_imm_app, hwnd, message, wparam, lparam, &lres) == S_FALSE)
return DefWindowProc (hwnd, message, wparam, lparam);
else
return lres;
+#endif
}
}
LRESULT CALLBACK
-gdk_window_procedure (HWND hwnd,
- UINT message,
- WPARAM wparam,
- LPARAM lparam)
+_gdk_win32_window_procedure (HWND hwnd,
+ UINT message,
+ WPARAM wparam,
+ LPARAM lparam)
{
LRESULT retval;
- GDK_NOTE (EVENTS, g_print ("gdk_window_procedure: %#lx %s\n",
- (gulong) hwnd, gdk_win32_message_name (message)));
+ GDK_NOTE (MISC, g_print ("_gdk_win32_window_procedure: %p %s\n",
+ hwnd, gdk_win32_message_name (message)));
retval = real_window_procedure (hwnd, message, wparam, lparam);
- GDK_NOTE (EVENTS, g_print ("gdk_window_procedure: %#lx returns %ld\n",
- (gulong) hwnd, retval));
+ GDK_NOTE (MISC, g_print ("_gdk_win32_window_procedure: %p returns %ld\n",
+ hwnd, retval));
return retval;
}
void
-gdk_events_init (void)
+_gdk_events_init (void)
{
GSource *source;
+#ifdef HAVE_DIMM_H
HRESULT hres;
+#endif
#ifdef USE_TRACKMOUSEEVENT
HMODULE user32, imm32;
HINSTANCE commctrl32;
g_source_set_can_recurse (source, TRUE);
g_source_attach (source, NULL);
- g_source_add (GDK_PRIORITY_EVENTS, TRUE, &event_funcs, NULL, NULL, NULL);
-
+#ifdef HAVE_DIMM_H
hres = CoCreateInstance (&CLSID_CActiveIMM,
NULL,
CLSCTX_ALL,
active_imm_msgpump_owner));
(active_imm_msgpump_owner->lpVtbl->Start) (active_imm_msgpump_owner);
}
+#endif
#ifdef USE_TRACKMOUSEEVENT
user32 = GetModuleHandle ("user32.dll");
{
MSG msg;
- return (gdk_event_queue_find_first() ||
+ return (_gdk_event_queue_find_first() ||
PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE));
}
#else
if (PeekMessage (&msg, GDK_WINDOW_HWND (window), WM_PAINT, WM_PAINT, PM_REMOVE))
{
- event = gdk_event_new ();
+ event = _gdk_event_new ();
- if (gdk_event_translate (event, &msg, NULL, NULL))
+ if (gdk_event_translate (event, &msg, NULL, NULL, TRUE))
return event;
else
gdk_event_free (event);
HWND hwnd_confined_to;
HCURSOR hcursor;
GdkCursorPrivate *cursor_private;
- gint return_val;
+ gint return_val = GDK_GRAB_SUCCESS;
g_return_val_if_fail (window != NULL, 0);
g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
hcursor = NULL;
else
hcursor = cursor_private->hcursor;
-
+#if 0
return_val = _gdk_input_grab_pointer (window,
owner_events,
event_mask,
confine_to,
time);
-
+#endif
if (return_val == GDK_GRAB_SUCCESS)
{
if (!GDK_WINDOW_DESTROYED (window))
{
- GDK_NOTE (EVENTS, g_print ("gdk_pointer_grab: %#lx %s %#lx %s\n",
- (gulong) GDK_WINDOW_HWND (window),
+ GDK_NOTE (EVENTS, g_print ("gdk_pointer_grab: %p %s %p %s\n",
+ GDK_WINDOW_HWND (window),
(owner_events ? "TRUE" : "FALSE"),
- (gulong) hcursor,
+ hcursor,
event_mask_string (event_mask)));
p_grab_mask = event_mask;
p_grab_owner_events = (owner_events != 0);
p_grab_automatic = FALSE;
-#if 0 /* Menus don't work if we use mouse capture. Pity, because many other
- * things work better with mouse capture.
- */
+#if USE_SETCAPTURE
SetCapture (GDK_WINDOW_HWND (window));
-# pragma message("Warning: SetCapture call, menus won't work!")
#endif
return_val = GDK_GRAB_SUCCESS;
}
gdk_pointer_ungrab (guint32 time)
{
GDK_NOTE (EVENTS, g_print ("gdk_pointer_ungrab\n"));
-
+#if 0
_gdk_input_ungrab_pointer (time);
-
-#if 1
+#endif
+
+#if USE_SETCAPTURE
if (GetCapture () != NULL)
ReleaseCapture ();
#endif
p_grab_window = NULL;
}
+/*
+ *--------------------------------------------------------------
+ * find_window_for_pointer_event
+ *
+ * Find the window a pointer event (mouse up, down, move) should
+ * be reported to. If the return value != reported_window then
+ * the ref count of reported_window will be decremented and the
+ * ref count of the return value will be incremented.
+ *
+ * Arguments:
+ *
+ * "reported_window" is the gdk window the xevent was reported relative to
+ * "xevent" is the win32 message
+ *
+ * Results:
+ *
+ * Side effects:
+ *
+ *--------------------------------------------------------------
+ */
+
+static GdkWindow*
+find_window_for_pointer_event (GdkWindow* reported_window,
+ MSG* msg)
+{
+ HWND hwnd;
+ POINTS points;
+ POINT pt;
+ GdkWindow* other_window;
+
+ if (p_grab_window == NULL || !p_grab_owner_events)
+ return reported_window;
+
+ points = MAKEPOINTS (msg->lParam);
+ pt.x = points.x;
+ pt.y = points.y;
+ ClientToScreen (msg->hwnd, &pt);
+
+ GDK_NOTE (EVENTS, g_print ("Finding window for grabbed pointer event at (%ld, %ld)\n",
+ pt.x, pt.y));
+
+ hwnd = WindowFromPoint (pt);
+ if (hwnd == NULL)
+ return reported_window;
+ other_window = gdk_win32_handle_table_lookup ((GdkNativeWindow) hwnd);
+ if (other_window == NULL)
+ return reported_window;
+
+ GDK_NOTE (EVENTS, g_print ("Found window %p for point (%ld, %ld)\n",
+ hwnd, pt.x, pt.y));
+
+ gdk_window_unref (reported_window);
+ gdk_window_ref (other_window);
+
+ return other_window;
+}
+
/*
*--------------------------------------------------------------
* gdk_pointer_is_grabbed
gboolean
gdk_pointer_is_grabbed (void)
{
+ GDK_NOTE (EVENTS, g_print ("gdk_pointer_is_grabbed: %s\n",
+ p_grab_window != NULL ? "TRUE" : "FALSE"));
return p_grab_window != NULL;
}
+/**
+ * gdk_pointer_grab_info_libgtk_only:
+ * @grab_window: location to store current grab window
+ * @owner_events: location to store boolean indicating whether
+ * the @owner_events flag to gdk_pointer_grab() was %TRUE.
+ *
+ * Determines information about the current pointer grab.
+ * This is not public API and must not be used by applications.
+ *
+ * Return value: %TRUE if this application currently has the
+ * pointer grabbed.
+ **/
+gboolean
+gdk_pointer_grab_info_libgtk_only (GdkWindow **grab_window,
+ gboolean *owner_events)
+{
+ if (p_grab_window != NULL)
+ {
+ if (grab_window)
+ *grab_window = p_grab_window;
+ if (owner_events)
+ *owner_events = p_grab_owner_events;
+
+ return TRUE;
+ }
+ else
+ return FALSE;
+}
+
/*
*--------------------------------------------------------------
* gdk_keyboard_grab
g_return_val_if_fail (window != NULL, 0);
g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
- GDK_NOTE (EVENTS, g_print ("gdk_keyboard_grab %#lx\n",
- (gulong) GDK_WINDOW_HWND (window)));
+ GDK_NOTE (EVENTS, g_print ("gdk_keyboard_grab %p\n",
+ GDK_WINDOW_HWND (window)));
if (!GDK_WINDOW_DESTROYED (window))
{
k_grab_window = NULL;
}
+/**
+ * gdk_keyboard_grab_info_libgtk_only:
+ * @grab_window: location to store current grab window
+ * @owner_events: location to store boolean indicating whether
+ * the @owner_events flag to gdk_keyboard_grab() was %TRUE.
+ *
+ * Determines information about the current keyboard grab.
+ * This is not public API and must not be used by applications.
+ *
+ * Return value: %TRUE if this application currently has the
+ * keyboard grabbed.
+ **/
+gboolean
+gdk_keyboard_grab_info_libgtk_only (GdkWindow **grab_window,
+ gboolean *owner_events)
+{
+ if (k_grab_window)
+ {
+ if (grab_window)
+ *grab_window = k_grab_window;
+ if (owner_events)
+ *owner_events = k_grab_owner_events;
+
+ return TRUE;
+ }
+ else
+ return FALSE;
+}
+
static GdkFilterReturn
gdk_event_apply_filters (MSG *msg,
GdkEvent *event,
client_filters = g_list_prepend (client_filters, filter);
}
-/* Thanks to Markus G. Kuhn <mkuhn@acm.org> for the ksysym<->Unicode
- * mapping functions, from the xterm sources.
- */
-
static void
build_key_event_state (GdkEvent *event)
{
if (!is_altgr_key)
{
if (GetKeyState (VK_CONTROL) < 0)
- {
- event->key.state |= GDK_CONTROL_MASK;
-#if 0
- if (event->key.keyval < ' ')
- event->key.keyval += '@';
-#endif
- }
-#if 0
- else if (event->key.keyval < ' ')
- {
- event->key.state |= GDK_CONTROL_MASK;
- event->key.keyval += '@';
- }
-#endif
+ event->key.state |= GDK_CONTROL_MASK;
if (GetKeyState (VK_MENU) < 0)
event->key.state |= GDK_MOD1_MASK;
}
+ else
+ {
+ event->key.state |= GDK_MOD2_MASK;
+ event->key.group = 1;
+ }
}
static gint
return state;
}
+static guint
+vk_from_char (guint c)
+{
+ switch (c)
+ {
+ case '\b':
+ return 'H';
+ case '\t':
+ return 'I';
+ default:
+ return (VkKeyScanEx (c, _gdk_input_locale) & 0xFF);
+ }
+}
+
static void
-build_keypress_event (GdkWindowImplWin32 *impl,
- GdkEvent *event,
- MSG *msg)
+build_keypress_event (GdkEvent *event,
+ MSG *msg)
{
HIMC himc;
- gint i, bytecount, ucount, ucleft, len;
- guchar buf[100], *bp;
- wchar_t wbuf[100], *wcp;
+ gint i, bytecount, ucount;
+ guchar buf[100];
+ wchar_t wbuf[100];
event->key.type = GDK_KEY_PRESS;
event->key.time = msg->time;
event->key.state = 0;
+ event->key.group = 0; /* ??? */
+ event->key.keyval = GDK_VoidSymbol;
if (msg->message == WM_IME_COMPOSITION)
{
himc = ImmGetContext (msg->hwnd);
-
bytecount = ImmGetCompositionStringW (himc, GCS_RESULTSTR,
wbuf, sizeof (wbuf));
+ ImmReleaseContext (msg->hwnd, himc);
+
ucount = bytecount / 2;
+ event->key.hardware_keycode = wbuf[0]; /* ??? */
}
else
{
bytecount = MIN ((msg->lParam & 0xFFFF), sizeof (buf));
for (i = 0; i < bytecount; i++)
buf[i] = msg->wParam;
+ event->key.hardware_keycode = vk_from_char (msg->wParam);
+ if (msg->wParam < ' ')
+ {
+ /* For ASCII control chars, the keyval should be the
+ * corresponding ASCII character.
+ */
+ event->key.keyval = msg->wParam + '@';
+ /* This is needed in case of Alt+nnn or Alt+0nnn (on the numpad)
+ * where nnn<32
+ */
+ event->key.state |= GDK_CONTROL_MASK;
+ }
}
else /* WM_IME_CHAR */
{
- event->key.keyval = GDK_VoidSymbol;
+ event->key.hardware_keycode = 0; /* ??? */
if (msg->wParam & 0xFF00)
{
/* Contrary to some versions of the documentation,
}
}
- /* Convert from the window's current code page
- * to Unicode. Then convert to UTF-8.
- * We don't handle the surrogate stuff. Should we?
+ /* Convert from the thread's current code page
+ * to Unicode. (Followed by conversion to UTF-8 below.)
*/
- ucount = MultiByteToWideChar (impl->charset_info.ciACP,
+ ucount = MultiByteToWideChar (_gdk_input_codepage,
0, buf, bytecount,
- wbuf, sizeof (wbuf) / sizeof (wbuf[0]));
-
- }
- if (ucount == 0)
- event->key.keyval = GDK_VoidSymbol;
- else if (msg->message == WM_CHAR || msg->message == WM_SYSCHAR)
- {
- if (msg->wParam < ' ')
- {
- event->key.keyval = msg->wParam + '@';
- /* This is needed in case of Alt+nnn or Alt+0nnn (on the numpad)
- * where nnn<32
- */
- event->key.state |= GDK_CONTROL_MASK;
- }
- else
- event->key.keyval = gdk_unicode_to_keyval (wbuf[0]);
+ wbuf, G_N_ELEMENTS (wbuf));
}
build_key_event_state (event);
/* Build UTF-8 string */
- ucleft = ucount;
- len = 0;
- wcp = wbuf;
- while (ucleft-- > 0)
- {
- wchar_t c = *wcp++;
-
- if (c < 0x80)
- len += 1;
- else if (c < 0x800)
- len += 2;
- else
- len += 3;
- }
-
- event->key.string = g_malloc (len + 1);
- event->key.length = len;
-
- ucleft = ucount;
- wcp = wbuf;
- bp = event->key.string;
- while (ucleft-- > 0)
+ if (ucount > 0)
{
- int first;
- wchar_t c = *wcp++;
-
- if (c < 0x80)
- {
- first = 0;
- len = 1;
- }
- else if (c < 0x800)
+ if (ucount == 1 && wbuf[0] < 0200)
{
- first = 0xc0;
- len = 2;
+ event->key.string = g_malloc (2);
+ event->key.string[0] = wbuf[0];
+ event->key.string[1] = '\0';
+ event->key.length = 1;
}
else
{
- first = 0xe0;
- len = 3;
+ event->key.string = _gdk_ucs2_to_utf8 (wbuf, ucount);
+ event->key.length = strlen (event->key.string);
}
-
-#if 1
- /* Woo-hoo! */
- switch (len)
- {
- case 3: bp[2] = (c & 0x3f) | 0x80; c >>= 6; /* Fall through */
- case 2: bp[1] = (c & 0x3f) | 0x80; c >>= 6; /* Fall through */
- case 1: bp[0] = c | first;
- }
-#else
- for (i = len - 1; i > 0; --i)
- {
- bp[i] = (c & 0x3f) | 0x80;
- c >>= 6;
- }
- bp[0] = c | first;
-#endif
-
- bp += len;
+ if (event->key.keyval == GDK_VoidSymbol)
+ event->key.keyval = gdk_unicode_to_keyval (wbuf[0]);
}
- *bp = 0;
}
static void
-build_keyrelease_event (GdkWindowImplWin32 *impl,
- GdkEvent *event,
- MSG *msg)
+build_keyrelease_event (GdkEvent *event,
+ MSG *msg)
{
guchar buf;
wchar_t wbuf;
event->key.type = GDK_KEY_RELEASE;
event->key.time = msg->time;
event->key.state = 0;
+ event->key.group = 0; /* ??? */
if (msg->message == WM_CHAR || msg->message == WM_SYSCHAR)
- if (msg->wParam < ' ')
- event->key.keyval = msg->wParam + '@';
- else
- {
- buf = msg->wParam;
- MultiByteToWideChar (impl->charset_info.ciACP,
- 0, &buf, 1, &wbuf, 1);
-
- event->key.keyval = gdk_unicode_to_keyval (wbuf);
- }
+ {
+ if (msg->wParam < ' ')
+ {
+ event->key.keyval = msg->wParam + '@';
+ event->key.state |= GDK_CONTROL_MASK;
+ }
+ else
+ {
+ buf = msg->wParam;
+ MultiByteToWideChar (_gdk_input_codepage,
+ 0, &buf, 1, &wbuf, 1);
+
+ event->key.keyval = gdk_unicode_to_keyval (wbuf);
+ }
+ event->key.hardware_keycode = vk_from_char (msg->wParam);
+ }
else
- event->key.keyval = GDK_VoidSymbol;
+ {
+ event->key.keyval = GDK_VoidSymbol;
+ event->key.hardware_keycode = 0; /* ??? */
+ }
build_key_event_state (event);
event->key.string = NULL;
event->key.length = 0;
static void
print_event_state (gint state)
{
- if (state & GDK_SHIFT_MASK)
- g_print ("SHIFT ");
- if (state & GDK_LOCK_MASK)
- g_print ("LOCK ");
- if (state & GDK_CONTROL_MASK)
- g_print ("CONTROL ");
- if (state & GDK_MOD1_MASK)
- g_print ("MOD1 ");
- if (state & GDK_BUTTON1_MASK)
- g_print ("BUTTON1 ");
- if (state & GDK_BUTTON2_MASK)
- g_print ("BUTTON2 ");
- if (state & GDK_BUTTON3_MASK)
- g_print ("BUTTON3 ");
+#define CASE(bit) if (state & GDK_ ## bit ## _MASK) g_print (#bit " ");
+ CASE (SHIFT);
+ CASE (LOCK);
+ CASE (CONTROL);
+ CASE (MOD1);
+ CASE (MOD2);
+ CASE (MOD3);
+ CASE (MOD4);
+ CASE (MOD5);
+ CASE (BUTTON1);
+ CASE (BUTTON2);
+ CASE (BUTTON3);
+ CASE (BUTTON4);
+ CASE (BUTTON5);
+#undef CASE
+}
+
+static void
+print_window_state (GdkWindowState state)
+{
+#define CASE(bit) if (state & GDK_WINDOW_STATE_ ## bit ) g_print (#bit " ");
+ CASE (WITHDRAWN);
+ CASE (ICONIFIED);
+ CASE (MAXIMIZED);
+ CASE (STICKY);
+#undef CASE
}
static void
switch (event->any.type)
{
- case GDK_NOTHING: g_print ("GDK_NOTHING "); break;
- case GDK_DELETE: g_print ("GDK_DELETE "); break;
- case GDK_DESTROY: g_print ("GDK_DESTROY "); break;
- case GDK_EXPOSE: g_print ("GDK_EXPOSE "); break;
- case GDK_MOTION_NOTIFY: g_print ("GDK_MOTION_NOTIFY "); break;
- case GDK_BUTTON_PRESS: g_print ("GDK_BUTTON_PRESS "); break;
- case GDK_2BUTTON_PRESS: g_print ("GDK_2BUTTON_PRESS "); break;
- case GDK_3BUTTON_PRESS: g_print ("GDK_3BUTTON_PRESS "); break;
- case GDK_BUTTON_RELEASE: g_print ("GDK_BUTTON_RELEASE "); break;
- case GDK_KEY_PRESS: g_print ("GDK_KEY_PRESS "); break;
- case GDK_KEY_RELEASE: g_print ("GDK_KEY_RELEASE "); break;
- case GDK_ENTER_NOTIFY: g_print ("GDK_ENTER_NOTIFY "); break;
- case GDK_LEAVE_NOTIFY: g_print ("GDK_LEAVE_NOTIFY "); break;
- case GDK_FOCUS_CHANGE: g_print ("GDK_FOCUS_CHANGE "); break;
- case GDK_CONFIGURE: g_print ("GDK_CONFIGURE "); break;
- case GDK_MAP: g_print ("GDK_MAP "); break;
- case GDK_UNMAP: g_print ("GDK_UNMAP "); break;
- case GDK_PROPERTY_NOTIFY: g_print ("GDK_PROPERTY_NOTIFY "); break;
- case GDK_SELECTION_CLEAR: g_print ("GDK_SELECTION_CLEAR "); break;
- case GDK_SELECTION_REQUEST: g_print ("GDK_SELECTION_REQUEST "); break;
- case GDK_SELECTION_NOTIFY: g_print ("GDK_SELECTION_NOTIFY "); break;
- case GDK_PROXIMITY_IN: g_print ("GDK_PROXIMITY_IN "); break;
- case GDK_PROXIMITY_OUT: g_print ("GDK_PROXIMITY_OUT "); break;
- case GDK_DRAG_ENTER: g_print ("GDK_DRAG_ENTER "); break;
- case GDK_DRAG_LEAVE: g_print ("GDK_DRAG_LEAVE "); break;
- case GDK_DRAG_MOTION: g_print ("GDK_DRAG_MOTION "); break;
- case GDK_DRAG_STATUS: g_print ("GDK_DRAG_STATUS "); break;
- case GDK_DROP_START: g_print ("GDK_DROP_START "); break;
- case GDK_DROP_FINISHED: g_print ("GDK_DROP_FINISHED "); break;
- case GDK_CLIENT_EVENT: g_print ("GDK_CLIENT_EVENT "); break;
- case GDK_VISIBILITY_NOTIFY: g_print ("GDK_VISIBILITY_NOTIFY "); break;
- case GDK_NO_EXPOSE: g_print ("GDK_NO_EXPOSE "); break;
- case GDK_SCROLL: g_print ("GDK_SCROLL "); break;
+#define CASE(x) case x: g_print ( #x " "); break;
+ CASE (GDK_NOTHING);
+ CASE (GDK_DELETE);
+ CASE (GDK_DESTROY);
+ CASE (GDK_EXPOSE);
+ CASE (GDK_MOTION_NOTIFY);
+ CASE (GDK_BUTTON_PRESS);
+ CASE (GDK_2BUTTON_PRESS);
+ CASE (GDK_3BUTTON_PRESS);
+ CASE (GDK_BUTTON_RELEASE);
+ CASE (GDK_KEY_PRESS);
+ CASE (GDK_KEY_RELEASE);
+ CASE (GDK_ENTER_NOTIFY);
+ CASE (GDK_LEAVE_NOTIFY);
+ CASE (GDK_FOCUS_CHANGE);
+ CASE (GDK_CONFIGURE);
+ CASE (GDK_MAP);
+ CASE (GDK_UNMAP);
+ CASE (GDK_PROPERTY_NOTIFY);
+ CASE (GDK_SELECTION_CLEAR);
+ CASE (GDK_SELECTION_REQUEST);
+ CASE (GDK_SELECTION_NOTIFY);
+ CASE (GDK_PROXIMITY_IN);
+ CASE (GDK_PROXIMITY_OUT);
+ CASE (GDK_DRAG_ENTER);
+ CASE (GDK_DRAG_LEAVE);
+ CASE (GDK_DRAG_MOTION);
+ CASE (GDK_DRAG_STATUS);
+ CASE (GDK_DROP_START);
+ CASE (GDK_DROP_FINISHED);
+ CASE (GDK_CLIENT_EVENT);
+ CASE (GDK_VISIBILITY_NOTIFY);
+ CASE (GDK_NO_EXPOSE);
+ CASE (GDK_SCROLL);
+ CASE (GDK_WINDOW_STATE);
+ CASE (GDK_SETTING);
+#undef CASE
}
- g_print ("%#lx ", (gulong) GDK_WINDOW_HWND (event->any.window));
+ g_print ("%p ", GDK_WINDOW_HWND (event->any.window));
switch (event->any.type)
{
else
escaped = g_strescape (event->key.string, NULL);
kvname = gdk_keyval_name (event->key.keyval);
- g_print ("%s %d:\"%s\" ",
+ g_print ("%#.02x %d %s %d:\"%s\" ",
+ event->key.hardware_keycode, event->key.group,
(kvname ? kvname : "??"),
event->key.length,
escaped);
"???")))));
print_event_state (event->scroll.state);
break;
+ case GDK_WINDOW_STATE:
+ print_window_state (event->window_state.changed_mask);
+ print_window_state (event->window_state.new_window_state);
default:
/* Nothing */
break;
g_print ("\n");
}
+static gboolean
+gdk_window_is_child (GdkWindow *parent,
+ GdkWindow *window)
+{
+ if (parent == NULL || window == NULL)
+ return FALSE;
+
+ return (gdk_window_get_parent (window) == parent ||
+ gdk_window_is_child (parent, gdk_window_get_parent (window)));
+}
+
static void
-synthesize_crossing_events (GdkWindow *window,
- MSG *msg)
+synthesize_enter_or_leave_event (GdkWindow *window,
+ MSG *msg,
+ GdkEventType type,
+ GdkNotifyType detail,
+ gint x,
+ gint y)
{
GdkEvent *event;
- /* If we are not using TrackMouseEvent, generate a leave notify
- * event if necessary
- */
- if (track_mouse_event == NULL
- && current_window
- && (GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (current_window)->impl)->event_mask & GDK_LEAVE_NOTIFY_MASK))
+ event = _gdk_event_new ();
+ event->crossing.type = type;
+ event->crossing.window = window;
+ event->crossing.send_event = FALSE;
+ gdk_window_ref (event->crossing.window);
+ event->crossing.subwindow = NULL;
+ event->crossing.time = msg->time;
+ event->crossing.x = x;
+ event->crossing.y = y;
+ event->crossing.x_root = msg->pt.x;
+ event->crossing.y_root = msg->pt.y;
+ event->crossing.mode = GDK_CROSSING_NORMAL;
+ event->crossing.detail = detail;
+ event->crossing.focus = TRUE; /* ??? */
+ event->crossing.state = 0; /* ??? */
+
+ _gdk_event_queue_append (event);
+
+ if (type == GDK_ENTER_NOTIFY
+ && GDK_WINDOW_OBJECT (window)->extension_events != 0)
+ _gdk_input_enter_event (&event->crossing, window);
+
+ GDK_NOTE (EVENTS, print_event (event));
+}
+
+static void
+synthesize_leave_event (GdkWindow *window,
+ MSG *msg,
+ GdkNotifyType detail)
+{
+ POINT pt;
+
+ if (!(GDK_WINDOW_OBJECT (window)->event_mask & GDK_LEAVE_NOTIFY_MASK))
+ return;
+
+ /* Leave events are at (current_x,current_y) in current_window */
+
+ if (current_window != window)
{
- GDK_NOTE (EVENTS, g_print ("synthesizing LEAVE_NOTIFY event\n"));
+ pt.x = current_x;
+ pt.y = current_y;
+ ClientToScreen (GDK_WINDOW_HWND (current_window), &pt);
+ ScreenToClient (GDK_WINDOW_HWND (window), &pt);
+ synthesize_enter_or_leave_event (window, msg, GDK_LEAVE_NOTIFY, detail, pt.x, pt.y);
+ }
+ else
+ synthesize_enter_or_leave_event (window, msg, GDK_LEAVE_NOTIFY, detail, current_x, current_y);
- event = gdk_event_new ();
- event->crossing.type = GDK_LEAVE_NOTIFY;
- event->crossing.window = current_window;
- gdk_drawable_ref (event->crossing.window);
- event->crossing.subwindow = NULL;
- event->crossing.time = msg->time;
- event->crossing.x = current_x;
- event->crossing.y = current_y;
- event->crossing.x_root = current_x_root;
- event->crossing.y_root = current_y_root;
- event->crossing.mode = GDK_CROSSING_NORMAL;
- if (IsChild (GDK_WINDOW_HWND (current_window), GDK_WINDOW_HWND (window)))
- event->crossing.detail = GDK_NOTIFY_INFERIOR;
- else if (IsChild (GDK_WINDOW_HWND (window), GDK_WINDOW_HWND (current_window)))
- event->crossing.detail = GDK_NOTIFY_ANCESTOR;
- else
- event->crossing.detail = GDK_NOTIFY_NONLINEAR;
+}
+
+static void
+synthesize_enter_event (GdkWindow *window,
+ MSG *msg,
+ GdkNotifyType detail)
+{
+ POINT pt;
- event->crossing.focus = TRUE; /* ??? */
- event->crossing.state = 0; /* ??? */
+ if (!(GDK_WINDOW_OBJECT (window)->event_mask & GDK_ENTER_NOTIFY_MASK))
+ return;
- gdk_event_queue_append (event);
- GDK_NOTE (EVENTS, print_event (event));
+ /* Enter events are at LOWORD (msg->lParam), HIWORD
+ * (msg->lParam) in msg->hwnd */
+
+ pt.x = LOWORD (msg->lParam);
+ pt.y = HIWORD (msg->lParam);
+ if (msg->hwnd != GDK_WINDOW_HWND (window))
+ {
+ ClientToScreen (msg->hwnd, &pt);
+ ScreenToClient (GDK_WINDOW_HWND (window), &pt);
}
+ synthesize_enter_or_leave_event (window, msg, GDK_ENTER_NOTIFY, detail, pt.x, pt.y);
+}
+
+static void
+synthesize_enter_events (GdkWindow *from,
+ GdkWindow *to,
+ MSG *msg,
+ GdkNotifyType detail)
+{
+ GdkWindow *prev = gdk_window_get_parent (to);
+
+ if (prev != from)
+ synthesize_enter_events (from, prev, msg, detail);
+ synthesize_enter_event (to, msg, detail);
+}
+
+static void
+synthesize_leave_events (GdkWindow *from,
+ GdkWindow *to,
+ MSG *msg,
+ GdkNotifyType detail)
+{
+ GdkWindow *next = gdk_window_get_parent (from);
+
+ synthesize_leave_event (from, msg, detail);
+ if (next != to)
+ synthesize_leave_events (next, to, msg, detail);
+}
+
+static void
+synthesize_crossing_events (GdkWindow *window,
+ MSG *msg)
+{
+ GdkWindow *intermediate, *tem, *common_ancestor;
- if (GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)->event_mask & GDK_ENTER_NOTIFY_MASK)
+ if (gdk_window_is_child (current_window, window))
{
- GDK_NOTE (EVENTS, g_print ("synthesizing ENTER_NOTIFY event\n"));
+ /* Pointer has moved to an inferior window. */
+ synthesize_leave_event (current_window, msg, GDK_NOTIFY_INFERIOR);
- event = gdk_event_new ();
- event->crossing.type = GDK_ENTER_NOTIFY;
- event->crossing.window = window;
- gdk_drawable_ref (event->crossing.window);
- event->crossing.subwindow = NULL;
- event->crossing.time = msg->time;
- event->crossing.x = LOWORD (msg->lParam);
- event->crossing.y = HIWORD (msg->lParam);
- event->crossing.x_root = (gfloat) msg->pt.x;
- event->crossing.y_root = (gfloat) msg->pt.y;
- event->crossing.mode = GDK_CROSSING_NORMAL;
- if (current_window
- && IsChild (GDK_WINDOW_HWND (current_window), GDK_WINDOW_HWND (window)))
- event->crossing.detail = GDK_NOTIFY_ANCESTOR;
- else if (current_window
- && IsChild (GDK_WINDOW_HWND (window), GDK_WINDOW_HWND (current_window)))
- event->crossing.detail = GDK_NOTIFY_INFERIOR;
- else
- event->crossing.detail = GDK_NOTIFY_NONLINEAR;
+ /* If there are intermediate windows, generate ENTER_NOTIFY
+ * events for them
+ */
+ intermediate = gdk_window_get_parent (window);
+ if (intermediate != current_window)
+ {
+ synthesize_enter_events (current_window, intermediate, msg, GDK_NOTIFY_VIRTUAL);
+ }
- event->crossing.focus = TRUE; /* ??? */
- event->crossing.state = 0; /* ??? */
+ synthesize_enter_event (window, msg, GDK_NOTIFY_ANCESTOR);
+ }
+ else if (gdk_window_is_child (window, current_window))
+ {
+ /* Pointer has moved to an ancestor window. */
+ synthesize_leave_event (current_window, msg, GDK_NOTIFY_ANCESTOR);
- gdk_event_queue_append (event);
+ /* If there are intermediate windows, generate LEAVE_NOTIFY
+ * events for them
+ */
+ intermediate = gdk_window_get_parent (current_window);
+ if (intermediate != window)
+ {
+ synthesize_leave_events (intermediate, window, msg, GDK_NOTIFY_VIRTUAL);
+ }
+ }
+ else if (current_window)
+ {
+ /* Find least common ancestor of current_window and window */
+ tem = current_window;
+ do {
+ common_ancestor = gdk_window_get_parent (tem);
+ tem = common_ancestor;
+ } while (common_ancestor &&
+ !gdk_window_is_child (common_ancestor, window));
+ if (common_ancestor)
+ {
+ synthesize_leave_event (current_window, msg, GDK_NOTIFY_NONLINEAR);
+ intermediate = gdk_window_get_parent (current_window);
+ if (intermediate != common_ancestor)
+ {
+ synthesize_leave_events (intermediate, common_ancestor,
+ msg, GDK_NOTIFY_NONLINEAR_VIRTUAL);
+ }
+ intermediate = gdk_window_get_parent (window);
+ if (intermediate != common_ancestor)
+ {
+ synthesize_enter_events (common_ancestor, intermediate,
+ msg, GDK_NOTIFY_NONLINEAR_VIRTUAL);
+ }
+ synthesize_enter_event (window, msg, GDK_NOTIFY_NONLINEAR);
+ }
+ }
+ else
+ {
+ /* Dunno where we are coming from */
+ synthesize_enter_event (window, msg, GDK_NOTIFY_UNKNOWN);
+ }
- GDK_NOTE (EVENTS, print_event (event));
+ if (current_window)
+ gdk_window_unref (current_window);
+ current_window = window;
+ gdk_window_ref (current_window);
+}
+
+#if 0
+
+static GList *
+get_descendants (GdkWindow *window)
+{
+ GList *list = gdk_window_get_children (window);
+ GList *head = list;
+ GList *tmp = NULL;
- if (GDK_WINDOW_OBJECT (window)->extension_events != 0)
- _gdk_input_enter_event (&event->crossing, window);
+ while (list)
+ {
+ tmp = g_list_concat (tmp, get_descendants ((GdkWindow *) list->data));
+ list = list->next;
}
+
+ return g_list_concat (tmp, head);
+}
+
+#endif
+
+static void
+synthesize_expose_events (GdkWindow *window)
+{
+ RECT r;
+ HDC hdc;
+ GdkDrawableImplWin32 *impl = GDK_DRAWABLE_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl);
+ GList *list = gdk_window_get_children (window);
+ GList *head = list;
+ GdkEvent *event;
+ int k;
- if (current_window)
- gdk_drawable_unref (current_window);
- current_window = window;
- gdk_drawable_ref (current_window);
-#ifdef USE_TRACKMOUSEEVENT
- if (track_mouse_event != NULL)
+ while (list)
{
- TRACKMOUSEEVENT tme;
+ synthesize_expose_events ((GdkWindow *) list->data);
+ list = list->next;
+ }
- tme.cbSize = sizeof (TRACKMOUSEEVENT);
- tme.dwFlags = TME_LEAVE;
- tme.hwndTrack = GDK_WINDOW_HWND (current_window);
- tme.dwHoverTime = HOVER_DEFAULT;
+ g_list_free (head);
+
+ if (!(hdc = GetDC (impl->handle)))
+ WIN32_GDI_FAILED ("GetDC");
+ else
+ {
+ if ((k = GetClipBox (hdc, &r)) == ERROR)
+ WIN32_GDI_FAILED ("GetClipBox");
+ else if (k != NULLREGION)
+ {
+ event = _gdk_event_new ();
+ event->expose.type = GDK_EXPOSE;
+ event->expose.window = window;
+ gdk_window_ref (window);
+ event->expose.area.x = r.left;
+ event->expose.area.y = r.top;
+ event->expose.area.width = r.right - r.left;
+ event->expose.area.height = r.bottom - r.top;
+ event->expose.region = gdk_region_rectangle (&(event->expose.area));
+ event->expose.count = 0;
+
+ _gdk_event_queue_append (event);
+
+ GDK_NOTE (EVENTS_OR_COLORMAP, print_event (event));
+ }
+ if (!ReleaseDC (impl->handle, hdc))
+ WIN32_GDI_FAILED ("ReleaseDC");
+ }
+}
+
+static void
+update_colors (GdkWindow *window,
+ gboolean top)
+{
+ HDC hdc;
+ GdkDrawableImplWin32 *impl = GDK_DRAWABLE_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl);
+ GList *list = gdk_window_get_children (window);
+ GList *head = list;
+
+ GDK_NOTE (COLORMAP, (top ? g_print ("update_colors:") : (void) 0));
+
+ while (list)
+ {
+ update_colors ((GdkWindow *) list->data, FALSE);
+ list = list->next;
+ }
+ g_list_free (head);
+
+ if (((GdkWindowObject *) window)->input_only ||
+ impl->colormap == NULL)
+ return;
+
+ if (!(hdc = GetDC (impl->handle)))
+ WIN32_GDI_FAILED ("GetDC");
+ else
+ {
+ GdkColormapPrivateWin32 *cmapp = GDK_WIN32_COLORMAP_DATA (impl->colormap);
+ HPALETTE holdpal;
+ gint k;
- (*track_mouse_event) (&tme);
+ if ((holdpal = SelectPalette (hdc, cmapp->hpal, TRUE)) == NULL)
+ WIN32_GDI_FAILED ("SelectPalette");
+ else if ((k = RealizePalette (hdc)) == GDI_ERROR)
+ WIN32_GDI_FAILED ("RealizePalette");
+ else
+ {
+ GDK_NOTE (COLORMAP,
+ (k > 0 ?
+ g_print (" %p pal=%p: realized %d colors\n"
+ "update_colors:",
+ impl->handle, cmapp->hpal, k) :
+ (void) 0,
+ g_print (" %p", impl->handle)));
+ if (!UpdateColors (hdc))
+ WIN32_GDI_FAILED ("UpdateColors");
+ SelectPalette (hdc, holdpal, TRUE);
+ RealizePalette (hdc);
+ }
+ if (!ReleaseDC (impl->handle, hdc))
+ WIN32_GDI_FAILED ("ReleaseDC");
}
-#endif
+ GDK_NOTE (COLORMAP, (top ? g_print ("\n") : (void) 0));
}
static void
gboolean (*doesnt_want_it) (gint mask,
MSG *msg))
{
+ gboolean in_propagation = FALSE;
+
if (grab_window != NULL && !grab_owner_events)
{
/* Event source is grabbed with owner_events FALSE */
}
else
{
- GDK_NOTE (EVENTS, g_print ("...sending to grabber %#lx\n",
- (gulong) GDK_WINDOW_HWND (grab_window)));
+ GDK_NOTE (EVENTS, g_print ("...sending to grabber %p\n",
+ GDK_WINDOW_HWND (grab_window)));
gdk_drawable_unref (*window);
*window = grab_window;
gdk_drawable_ref (*window);
}
while (TRUE)
{
- if ((*doesnt_want_it) (GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (*window)->impl)->event_mask, msg))
+ if ((*doesnt_want_it) (GDK_WINDOW_OBJECT (*window)->event_mask, msg))
{
/* Owner doesn't want it, propagate to parent. */
- if (GDK_WINDOW (GDK_WINDOW_OBJECT (*window)->parent) == gdk_parent_root)
+ if (GDK_WINDOW (GDK_WINDOW_OBJECT (*window)->parent) == _gdk_parent_root)
{
/* No parent; check if grabbed */
if (grab_window != NULL)
{
/* Grabbed! */
GDK_NOTE (EVENTS,
- g_print ("...sending to grabber %#lx\n",
- (gulong) GDK_WINDOW_HWND (grab_window)));
+ g_print ("...sending to grabber %p\n",
+ GDK_WINDOW_HWND (grab_window)));
gdk_drawable_unref (*window);
*window = grab_window;
gdk_drawable_ref (*window);
gdk_drawable_unref (*window);
*window = GDK_WINDOW (GDK_WINDOW_OBJECT (*window)->parent);
gdk_drawable_ref (*window);
- GDK_NOTE (EVENTS, g_print ("...propagating to %#lx\n",
- (gulong) GDK_WINDOW_HWND (*window)));
+ GDK_NOTE (EVENTS, g_print ("%s %p",
+ (in_propagation ? "," : " ...propagating to"),
+ GDK_WINDOW_HWND (*window)));
/* The only branch where we actually continue the loop */
+ in_propagation = TRUE;
}
}
else
#endif
}
-static char *
-decode_key_lparam (LPARAM lParam)
-{
- static char buf[100];
- char *p = buf;
+static char *
+decode_key_lparam (LPARAM lParam)
+{
+ static char buf[100];
+ char *p = buf;
+
+ if (HIWORD (lParam) & KF_UP)
+ p += sprintf (p, "KF_UP ");
+ if (HIWORD (lParam) & KF_REPEAT)
+ p += sprintf (p, "KF_REPEAT ");
+ if (HIWORD (lParam) & KF_ALTDOWN)
+ p += sprintf (p, "KF_ALTDOWN ");
+ if (HIWORD (lParam) & KF_EXTENDED)
+ p += sprintf (p, "KF_EXTENDED ");
+ p += sprintf (p, "sc:%d rep:%d", LOBYTE (HIWORD (lParam)), LOWORD (lParam));
+
+ return buf;
+}
+
+static void
+erase_background (GdkWindow *window,
+ HDC hdc)
+{
+ HDC bgdc = NULL;
+ HBRUSH hbr = NULL;
+ HPALETTE holdpal = NULL;
+ RECT rect;
+ COLORREF bg;
+ GdkColormap *colormap;
+ GdkColormapPrivateWin32 *colormap_private;
+ int i, j;
+
+ if (GDK_WINDOW_OBJECT (window)->input_only ||
+ GDK_WINDOW_OBJECT (window)->bg_pixmap == GDK_NO_BG ||
+ GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)->position_info.no_bg)
+ return;
+
+ colormap = gdk_drawable_get_colormap (window);
+
+ if (colormap &&
+ (colormap->visual->type == GDK_VISUAL_PSEUDO_COLOR ||
+ colormap->visual->type == GDK_VISUAL_STATIC_COLOR))
+ {
+ int k;
+
+ colormap_private = GDK_WIN32_COLORMAP_DATA (colormap);
+
+ if (!(holdpal = SelectPalette (hdc, colormap_private->hpal, FALSE)))
+ WIN32_GDI_FAILED ("SelectPalette");
+ else if ((k = RealizePalette (hdc)) == GDI_ERROR)
+ WIN32_GDI_FAILED ("RealizePalette");
+ else if (k > 0)
+ GDK_NOTE (COLORMAP, g_print ("gdk_win32_erase_background: realized %p: %d colors\n",
+ colormap_private->hpal, k));
+ }
+
+ while (window && GDK_WINDOW_OBJECT (window)->bg_pixmap == GDK_PARENT_RELATIVE_BG)
+ {
+ /* If this window should have the same background as the parent,
+ * fetch the parent. (And if the same goes for the parent, fetch
+ * the grandparent, etc.)
+ */
+ window = GDK_WINDOW (GDK_WINDOW_OBJECT (window)->parent);
+ }
+
+ if (GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)->position_info.no_bg)
+ {
+ /* Improves scolling effect, e.g. main buttons of testgtk */
+ return;
+ }
+
+ if (GDK_WINDOW_OBJECT (window)->bg_pixmap == NULL)
+ {
+ bg = _gdk_win32_colormap_color (GDK_DRAWABLE_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)->colormap,
+ GDK_WINDOW_OBJECT (window)->bg_color.pixel);
+
+ GetClipBox (hdc, &rect);
+ GDK_NOTE (EVENTS,
+ g_print ("...%ldx%ld@+%ld+%ld bg %06lx\n",
+ rect.right - rect.left,
+ rect.bottom - rect.top,
+ rect.left, rect.top,
+ (gulong) bg));
+ if (!(hbr = CreateSolidBrush (bg)))
+ WIN32_GDI_FAILED ("CreateSolidBrush");
+ else if (!FillRect (hdc, &rect, hbr))
+ WIN32_GDI_FAILED ("FillRect");
+ if (hbr != NULL)
+ DeleteObject (hbr);
+ }
+ else if (GDK_WINDOW_OBJECT (window)->bg_pixmap != NULL &&
+ GDK_WINDOW_OBJECT (window)->bg_pixmap != GDK_NO_BG)
+ {
+ GdkPixmap *pixmap = GDK_WINDOW_OBJECT (window)->bg_pixmap;
+ GdkPixmapImplWin32 *pixmap_impl = GDK_PIXMAP_IMPL_WIN32 (GDK_PIXMAP_OBJECT (pixmap)->impl);
+
+ GetClipBox (hdc, &rect);
+
+ if (pixmap_impl->width <= 8 && pixmap_impl->height <= 8)
+ {
+ GDK_NOTE (EVENTS, g_print ("...small pixmap, using brush\n"));
+ if (!(hbr = CreatePatternBrush (GDK_PIXMAP_HBITMAP (pixmap))))
+ WIN32_GDI_FAILED ("CreatePatternBrush");
+ else if (!FillRect (hdc, &rect, hbr))
+ WIN32_GDI_FAILED ("FillRect");
+ if (hbr != NULL)
+ DeleteObject (hbr);
+ }
+ else
+ {
+ HGDIOBJ oldbitmap;
+
+ GDK_NOTE (EVENTS,
+ g_print ("...blitting pixmap %p (%dx%d) "
+ "all over the place,\n"
+ "...clip box = %ldx%ld@+%ld+%ld\n",
+ GDK_PIXMAP_HBITMAP (pixmap),
+ pixmap_impl->width, pixmap_impl->height,
+ rect.right - rect.left, rect.bottom - rect.top,
+ rect.left, rect.top));
+
+ if (!(bgdc = CreateCompatibleDC (hdc)))
+ {
+ WIN32_GDI_FAILED ("CreateCompatibleDC");
+ return;
+ }
+ if (!(oldbitmap = SelectObject (bgdc, GDK_PIXMAP_HBITMAP (pixmap))))
+ {
+ WIN32_GDI_FAILED ("SelectObject");
+ DeleteDC (bgdc);
+ return;
+ }
+ i = 0;
+ while (i < rect.right)
+ {
+ j = 0;
+ while (j < rect.bottom)
+ {
+ if (i + pixmap_impl->width >= rect.left
+ && j + pixmap_impl->height >= rect.top)
+ {
+ if (!BitBlt (hdc, i, j,
+ pixmap_impl->width, pixmap_impl->height,
+ bgdc, 0, 0, SRCCOPY))
+ {
+ WIN32_GDI_FAILED ("BitBlt");
+ SelectObject (bgdc, oldbitmap);
+ DeleteDC (bgdc);
+ return;
+ }
+ }
+ j += pixmap_impl->height;
+ }
+ i += pixmap_impl->width;
+ }
+ SelectObject (bgdc, oldbitmap);
+ DeleteDC (bgdc);
+ }
+ }
+ else
+ {
+ GDK_NOTE (EVENTS, g_print ("...BLACK_BRUSH (?)\n"));
+ hbr = GetStockObject (BLACK_BRUSH);
+ GetClipBox (hdc, &rect);
+ if (!FillRect (hdc, &rect, hbr))
+ WIN32_GDI_FAILED ("FillRect");
+ }
+}
+
+static GdkRegion *
+_gdk_win32_hrgn_to_region (HRGN hrgn)
+{
+ RGNDATA *rgndata;
+ RECT *rects;
+ GdkRegion *result;
+ gint nbytes;
+ gint i;
+
+ if ((nbytes = GetRegionData (hrgn, 0, NULL)) == 0)
+ {
+ WIN32_GDI_FAILED ("GetRegionData");
+ return NULL;
+ }
+
+ rgndata = (RGNDATA *) g_malloc (nbytes);
- if (HIWORD (lParam) & KF_UP)
- p += sprintf (p, "KF_UP ");
- if (HIWORD (lParam) & KF_REPEAT)
- p += sprintf (p, "KF_REPEAT ");
- if (HIWORD (lParam) & KF_ALTDOWN)
- p += sprintf (p, "KF_ALTDOWN ");
- if (HIWORD (lParam) & KF_EXTENDED)
- p += sprintf (p, "KF_EXTENDED ");
- p += sprintf (p, "sc%d rep%d", LOBYTE (HIWORD (lParam)), LOWORD (lParam));
+ if (GetRegionData (hrgn, nbytes, rgndata) == 0)
+ {
+ WIN32_GDI_FAILED ("GetRegionData");
+ g_free (rgndata);
+ return NULL;
+ }
- return buf;
+ result = gdk_region_new ();
+ rects = (RECT *) rgndata->Buffer;
+ for (i = 0; i < rgndata->rdh.nCount; i++)
+ {
+ GdkRectangle r;
+
+ r.x = rects[i].left;
+ r.y = rects[i].top;
+ r.width = rects[i].right - r.x;
+ r.height = rects[i].bottom - r.y;
+
+ gdk_region_union_with_rect (result, &r);
+ }
+
+ g_free (rgndata);
+
+ return result;
}
static gboolean
gdk_event_translate (GdkEvent *event,
MSG *msg,
gboolean *ret_val_flagp,
- gint *ret_valp)
+ gint *ret_valp,
+ gboolean return_exposes)
{
DWORD pidActWin;
DWORD pidThis;
PAINTSTRUCT paintstruct;
HDC hdc;
- HDC bgdc;
- HGDIOBJ oldbitmap;
- HBRUSH hbr;
- COLORREF bg;
RECT rect;
POINT pt;
MINMAXINFO *mmi;
HWND hwnd;
HCURSOR hcursor;
+ HRGN hrgn;
+ CHARSETINFO charset_info;
/* Invariant:
- * window_impl == GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)
+ * private == GDK_WINDOW_OBJECT (window)
*/
GdkWindow *window;
- GdkWindowImplWin32 *window_impl;
+ GdkWindowObject *private;
+
#define ASSIGN_WINDOW(rhs) \
(window = rhs, \
- window_impl = (window ? GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl) : NULL))
+ private = (GdkWindowObject *) window)
+
+ GdkWindowImplWin32 *impl;
GdkWindow *orig_window, *new_window;
- GdkColormapPrivateWin32 *colormap_private;
- GdkPixmap *pixmap;
- GdkPixmapImplWin32 *pixmap_impl;
+ gint xoffset, yoffset;
- int button;
- int i, j;
+ static gint update_colors_counter = 0;
+ gint button;
+ gint k;
gchar buf[256];
- gboolean return_val;
-
- return_val = FALSE;
+ gboolean return_val = FALSE;
if (ret_val_flagp)
*ret_val_flagp = FALSE;
orig_window = window;
event->any.window = window;
- event->any.send_event = FALSE;
+
+ /* InSendMessage() does not really mean the same as X11's send_event flag,
+ * but it is close enough, says jpe@archaeopteryx.com.
+ */
+ event->any.send_event = InSendMessage ();
if (window == NULL)
{
* removed it. Repost the same message to our queue so that
* we will get it later when we are prepared.
*/
- GDK_NOTE(MISC, g_print("gdk_event_translate: %#lx %s posted.\n",
- (gulong) msg->hwnd,
+ GDK_NOTE(MISC, g_print("gdk_event_translate: %p %s posted.\n",
+ msg->hwnd,
msg->message == WM_MOVE ?
"WM_MOVE" : "WM_SIZE"));
if (result != GDK_FILTER_CONTINUE)
{
return_val = (result == GDK_FILTER_TRANSLATE) ? TRUE : FALSE;
+ if (ret_val_flagp)
+ *ret_val_flagp = TRUE;
+ if (ret_valp)
+ *ret_valp = return_val;
goto done;
}
}
- if (msg->message == gdk_selection_notify_msg)
- {
- GDK_NOTE (EVENTS, g_print ("gdk_selection_notify_msg: %#lx\n",
- (gulong) msg->hwnd));
-
- event->selection.type = GDK_SELECTION_NOTIFY;
- event->selection.window = window;
- event->selection.selection = msg->wParam;
- event->selection.target = msg->lParam;
- event->selection.property = gdk_selection_property;
- event->selection.time = msg->time;
-
- return_val = !GDK_WINDOW_DESTROYED (window);
-
- goto done;
- }
- else if (msg->message == gdk_selection_request_msg)
- {
- GDK_NOTE (EVENTS, g_print ("gdk_selection_request_msg: %#lx\n",
- (gulong) msg->hwnd));
-
- event->selection.type = GDK_SELECTION_REQUEST;
- event->selection.window = window;
- event->selection.selection = gdk_clipboard_atom;
- event->selection.target = GDK_TARGET_STRING;
- event->selection.property = gdk_selection_property;
- event->selection.requestor = (guint32) msg->hwnd;
- event->selection.time = msg->time;
-
- return_val = !GDK_WINDOW_DESTROYED (window);
-
- goto done;
- }
- else if (msg->message == gdk_selection_clear_msg)
- {
- GDK_NOTE (EVENTS, g_print ("gdk_selection_clear_msg: %#lx\n",
- (gulong) msg->hwnd));
-
- event->selection.type = GDK_SELECTION_CLEAR;
- event->selection.window = window;
- event->selection.selection = msg->wParam;
- event->selection.time = msg->time;
-
- return_val = !GDK_WINDOW_DESTROYED (window);
-
- goto done;
- }
- else if (msg->message == msh_mousewheel_msg)
+ if (msg->message == msh_mousewheel_msg)
{
- GDK_NOTE (EVENTS, g_print ("MSH_MOUSEWHEEL: %#lx %d\n",
- (gulong) msg->hwnd, msg->wParam));
+ GDK_NOTE (EVENTS, g_print ("MSH_MOUSEWHEEL: %p %d\n",
+ msg->hwnd, msg->wParam));
event->scroll.type = GDK_SCROLL;
}
if (GDK_WINDOW_OBJECT (window)->extension_events != 0
- && gdk_input_ignore_core)
+ && _gdk_input_ignore_core)
{
GDK_NOTE (EVENTS, g_print ("...ignored\n"));
goto done;
GDK_SCROLL_UP : GDK_SCROLL_DOWN;
event->scroll.window = window;
event->scroll.time = msg->time;
- event->scroll.x = (gint16) pt.x;
- event->scroll.y = (gint16) pt.y;
+ _gdk_windowing_window_get_offsets (window, &xoffset, &yoffset);
+ event->scroll.x = (gint16) pt.x + xoffset;
+ event->scroll.y = (gint16) pt.y + yoffset;
event->scroll.x_root = (gint16) LOWORD (msg->lParam);
event->scroll.y_root = (gint16) HIWORD (msg->lParam);
event->scroll.state = 0; /* No state information with MSH_MOUSEWHEEL */
- event->scroll.device = gdk_core_pointer;
+ event->scroll.device = _gdk_core_pointer;
return_val = !GDK_WINDOW_DESTROYED (window);
goto done;
while (tmp_list)
{
GdkClientFilter *filter = tmp_list->data;
- if (filter->type == msg->message)
+ /* FIXME: under win32 messages are not really atoms
+ * as the following cast suggest, but the appears to be right
+ * Haven't found a use case though ...
+ */
+ if (filter->type == GDK_POINTER_TO_ATOM (msg->message))
{
GDK_NOTE (EVENTS, g_print ("client filter matched\n"));
event->any.window = window;
switch (result)
{
case GDK_FILTER_REMOVE:
+ *ret_val_flagp = TRUE;
+ *ret_valp = 0;
return_val = FALSE;
break;
break;
case GDK_FILTER_CONTINUE:
+ *ret_val_flagp = TRUE;
+ *ret_valp = 1;
return_val = TRUE;
event->client.type = GDK_CLIENT_EVENT;
event->client.window = window;
- event->client.message_type = msg->message;
+ /* FIXME: check if the cast is correct, see above */
+ event->client.message_type = GDK_POINTER_TO_ATOM (msg->message);
event->client.data_format = 0;
event->client.data.l[0] = msg->wParam;
event->client.data.l[1] = msg->lParam;
switch (msg->message)
{
case WM_INPUTLANGCHANGE:
- GDK_NOTE (EVENTS,
- g_print ("WM_INPUTLANGCHANGE: %#lx charset %lu locale %lx\n",
- (gulong) msg->hwnd, (gulong) msg->wParam, msg->lParam));
- window_impl->input_locale = (HKL) msg->lParam;
+ _gdk_input_locale = (HKL) msg->lParam;
TranslateCharsetInfo ((DWORD FAR *) msg->wParam,
- &window_impl->charset_info,
+ &charset_info,
TCI_SRCCHARSET);
+ _gdk_input_codepage = charset_info.ciACP;
+ _gdk_keymap_serial++;
+ GDK_NOTE (EVENTS,
+ g_print ("WM_INPUTLANGCHANGE: %p charset %lu locale %lx cp%d\n",
+ msg->hwnd, (gulong) msg->wParam, msg->lParam,
+ _gdk_input_codepage));
break;
case WM_SYSKEYUP:
case WM_SYSKEYDOWN:
GDK_NOTE (EVENTS,
- g_print ("WM_SYSKEY%s: %#lx %s %#x %s\n",
+ g_print ("WM_SYSKEY%s: %p %s vk:%.02x %s\n",
(msg->message == WM_SYSKEYUP ? "UP" : "DOWN"),
- (gulong) msg->hwnd,
+ msg->hwnd,
(GetKeyNameText (msg->lParam, buf,
sizeof (buf)) > 0 ?
buf : ""),
msg->wParam,
decode_key_lparam (msg->lParam)));
- /* Let the system handle Alt-Tab and Alt-Enter */
- if (msg->wParam == VK_TAB
- || msg->wParam == VK_RETURN
- || msg->wParam == VK_F4)
- break;
/* If posted without us having keyboard focus, ignore */
if (!(msg->lParam & 0x20000000))
break;
-#if 0
- /* don't generate events for just the Alt key */
- if (msg->wParam == VK_MENU)
+ /* Let the system handle Alt-Tab, Alt-Enter and Alt-F4 */
+ if (msg->wParam == VK_TAB
+ || msg->wParam == VK_RETURN
+ || msg->wParam == VK_F4)
break;
-#endif
+
/* Jump to code in common with WM_KEYUP and WM_KEYDOWN */
goto keyup_or_down;
case WM_KEYUP:
case WM_KEYDOWN:
GDK_NOTE (EVENTS,
- g_print ("WM_KEY%s: %#lx %s %#x %s\n",
+ g_print ("WM_KEY%s: %p %s vk:%.02x %s\n",
(msg->message == WM_KEYUP ? "UP" : "DOWN"),
- (gulong) msg->hwnd,
+ msg->hwnd,
(GetKeyNameText (msg->lParam, buf,
sizeof (buf)) > 0 ?
buf : ""),
keyup_or_down:
event->key.window = window;
+
switch (msg->wParam)
{
case VK_LBUTTON:
event->key.state |= GDK_CONTROL_MASK;
if (msg->wParam != VK_MENU && GetKeyState (VK_MENU) < 0)
event->key.state |= GDK_MOD1_MASK;
+ event->key.hardware_keycode = msg->wParam;
+ event->key.group = 0;
event->key.string = NULL;
event->key.length = 0;
return_val = !GDK_WINDOW_DESTROYED (window);
if (!use_ime_composition)
break;
- GDK_NOTE (EVENTS, g_print ("WM_IME_COMPOSITION: %#lx %#lx\n",
- (gulong) msg->hwnd, msg->lParam));
+ GDK_NOTE (EVENTS, g_print ("WM_IME_COMPOSITION: %p %#lx\n",
+ msg->hwnd, msg->lParam));
if (msg->lParam & GCS_RESULTSTR)
goto wm_char;
break;
case WM_IME_CHAR:
GDK_NOTE (EVENTS,
- g_print ("WM_IME_CHAR: %#lx bytes: %#.04x\n",
- (gulong) msg->hwnd, msg->wParam));
+ g_print ("WM_IME_CHAR: %p bytes: %#.04x\n",
+ msg->hwnd, msg->wParam));
goto wm_char;
case WM_CHAR:
case WM_SYSCHAR:
GDK_NOTE (EVENTS,
- g_print ("WM_%sCHAR: %#lx %#x %s %s\n",
+ g_print ("WM_%sCHAR: %p %#x %s %s\n",
(msg->message == WM_CHAR ? "" : "SYS"),
- (gulong) msg->hwnd, msg->wParam,
+ msg->hwnd, msg->wParam,
decode_key_lparam (msg->lParam),
(ignore_wm_char ? "ignored" : "")));
return_val = !GDK_WINDOW_DESTROYED (window);
if (return_val && (event->key.window == k_grab_window
- || (window_impl->event_mask & GDK_KEY_RELEASE_MASK)))
+ || (private->event_mask & GDK_KEY_RELEASE_MASK)))
{
if (window == k_grab_window
- || (window_impl->event_mask & GDK_KEY_PRESS_MASK))
+ || (private->event_mask & GDK_KEY_PRESS_MASK))
{
/* Append a GDK_KEY_PRESS event to the pushback list
* (from which it will be fetched before the release
* event).
*/
- GdkEvent *event2 = gdk_event_new ();
- build_keypress_event (window_impl, event2, msg);
+ GdkEvent *event2 = _gdk_event_new ();
+ build_keypress_event (event2, msg);
event2->key.window = window;
gdk_drawable_ref (window);
- gdk_event_queue_append (event2);
+ _gdk_event_queue_append (event2);
GDK_NOTE (EVENTS, print_event (event2));
}
/* Return the key release event. */
- build_keyrelease_event (window_impl, event, msg);
+ build_keyrelease_event (event, msg);
}
- else if (return_val
- && (window_impl->event_mask & GDK_KEY_PRESS_MASK))
+ else if (return_val && (private->event_mask & GDK_KEY_PRESS_MASK))
{
/* Return just the key press event. */
- build_keypress_event (window_impl, event, msg);
+ build_keypress_event (event, msg);
}
else
return_val = FALSE;
buttondown0:
GDK_NOTE (EVENTS,
- g_print ("WM_%cBUTTONDOWN: %#lx (%d,%d)\n",
+ g_print ("WM_%cBUTTONDOWN: %p (%d,%d)\n",
" LMR"[button],
- (gulong) msg->hwnd,
+ msg->hwnd,
LOWORD (msg->lParam), HIWORD (msg->lParam)));
if (GDK_WINDOW_OBJECT (window)->extension_events != 0
- && gdk_input_ignore_core)
+ && _gdk_input_ignore_core)
{
GDK_NOTE (EVENTS, g_print ("...ignored\n"));
break;
}
+ ASSIGN_WINDOW (find_window_for_pointer_event (window, msg));
+
if (window != current_window)
synthesize_crossing_events (window, msg);
if (!p_grab_window)
{
/* No explicit active grab, let's start one automatically */
- gint owner_events = window_impl->event_mask
- & (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK);
+ gint owner_events = (private->event_mask & (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK));
GDK_NOTE (EVENTS, g_print ("...automatic grab started\n"));
gdk_pointer_grab (window,
owner_events,
- window_impl->event_mask,
+ private->event_mask,
NULL, NULL, 0);
p_grab_automatic = TRUE;
}
translate_mouse_coords (orig_window, window, msg);
event->button.x = current_x = (gint16) LOWORD (msg->lParam);
event->button.y = current_y = (gint16) HIWORD (msg->lParam);
- event->button.x_root = msg->pt.x;
- event->button.y_root = msg->pt.y;
+ _gdk_windowing_window_get_offsets (window, &xoffset, &yoffset);
+ event->button.x += xoffset; /* XXX translate current_x, y too? */
+ event->button.y += yoffset;
+ event->button.x_root = current_x_root = msg->pt.x;
+ event->button.y_root = current_y_root = msg->pt.y;
event->button.axes = NULL;
event->button.state = build_pointer_event_state (msg);
event->button.button = button;
- event->button.device = gdk_core_pointer;
+ event->button.device = _gdk_core_pointer;
- gdk_event_button_generate (event);
+ _gdk_event_button_generate (event);
return_val = !GDK_WINDOW_DESTROYED (window);
break;
buttonup0:
GDK_NOTE (EVENTS,
- g_print ("WM_%cBUTTONUP: %#lx (%d,%d)\n",
+ g_print ("WM_%cBUTTONUP: %p (%d,%d)\n",
" LMR"[button],
- (gulong) msg->hwnd,
+ msg->hwnd,
LOWORD (msg->lParam), HIWORD (msg->lParam)));
+ ASSIGN_WINDOW (find_window_for_pointer_event (window, msg));
+
if (GDK_WINDOW_OBJECT (window)->extension_events != 0
- && gdk_input_ignore_core)
+ && _gdk_input_ignore_core)
{
GDK_NOTE (EVENTS, g_print ("...ignored\n"));
break;
if (!propagate (&window, msg,
p_grab_window, p_grab_owner_events, p_grab_mask,
doesnt_want_button_release))
- goto maybe_ungrab;
- ASSIGN_WINDOW (window);
-
- event->button.window = window;
- event->button.time = msg->time;
- if (window != orig_window)
- translate_mouse_coords (orig_window, window, msg);
- event->button.x = (gint16) LOWORD (msg->lParam);
- event->button.y = (gint16) HIWORD (msg->lParam);
- event->button.x_root = msg->pt.x;
- event->button.y_root = msg->pt.y;
- event->button.axes = NULL;
- event->button.state = build_pointer_event_state (msg);
- event->button.button = button;
- event->button.device = gdk_core_pointer;
-
- return_val = !GDK_WINDOW_DESTROYED (window);
+ {
+ }
+ else
+ {
+ ASSIGN_WINDOW (window);
+
+ event->button.window = window;
+ event->button.time = msg->time;
+ if (window != orig_window)
+ translate_mouse_coords (orig_window, window, msg);
+ _gdk_windowing_window_get_offsets (window, &xoffset, &yoffset);
+ event->button.x = (gint16) LOWORD (msg->lParam) + xoffset;
+ event->button.y = (gint16) HIWORD (msg->lParam) + yoffset;
+ event->button.x_root = current_x_root = msg->pt.x;
+ event->button.y_root = current_y_root = msg->pt.y;
+ event->button.axes = NULL;
+ event->button.state = build_pointer_event_state (msg);
+ event->button.button = button;
+ event->button.device = _gdk_core_pointer;
+
+ return_val = !GDK_WINDOW_DESTROYED (window);
+ }
- maybe_ungrab:
if (p_grab_window != NULL
&& p_grab_automatic
- && (event->button.state & (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK | GDK_BUTTON3_MASK)) == 0)
+ && (msg->wParam & (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON)) == 0)
gdk_pointer_ungrab (0);
break;
case WM_MOUSEMOVE:
GDK_NOTE (EVENTS,
- g_print ("WM_MOUSEMOVE: %#lx %#x (%d,%d)\n",
- (gulong) msg->hwnd, msg->wParam,
+ g_print ("WM_MOUSEMOVE: %p %#x (%d,%d)\n",
+ msg->hwnd, msg->wParam,
LOWORD (msg->lParam), HIWORD (msg->lParam)));
+ ASSIGN_WINDOW (find_window_for_pointer_event (window, msg));
+
/* If we haven't moved, don't create any event.
* Windows sends WM_MOUSEMOVE messages after button presses
* even if the mouse doesn't move. This disturbs gtk.
synthesize_crossing_events (window, msg);
if (GDK_WINDOW_OBJECT (window)->extension_events != 0
- && gdk_input_ignore_core)
+ && _gdk_input_ignore_core)
{
GDK_NOTE (EVENTS, g_print ("...ignored\n"));
break;
translate_mouse_coords (orig_window, window, msg);
event->motion.x = current_x = (gint16) LOWORD (msg->lParam);
event->motion.y = current_y = (gint16) HIWORD (msg->lParam);
+ _gdk_windowing_window_get_offsets (window, &xoffset, &yoffset);
+ event->motion.x += xoffset;
+ event->motion.y += yoffset;
event->motion.x_root = current_x_root = msg->pt.x;
event->motion.y_root = current_y_root = msg->pt.y;
event->motion.axes = NULL;
event->motion.state = build_pointer_event_state (msg);
event->motion.is_hint = FALSE;
- event->motion.device = gdk_core_pointer;
+ event->motion.device = _gdk_core_pointer;
return_val = !GDK_WINDOW_DESTROYED (window);
break;
case WM_NCMOUSEMOVE:
GDK_NOTE (EVENTS,
- g_print ("WM_NCMOUSEMOVE: %#lx x,y: %d %d\n",
- (gulong) msg->hwnd,
+ g_print ("WM_NCMOUSEMOVE: %p x,y: %d %d\n",
+ msg->hwnd,
LOWORD (msg->lParam), HIWORD (msg->lParam)));
if (track_mouse_event == NULL
&& current_window != NULL
- && (GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (current_window)->impl)->event_mask & GDK_LEAVE_NOTIFY_MASK))
+ && (GDK_WINDOW_OBJECT (current_window)->event_mask & GDK_LEAVE_NOTIFY_MASK))
{
GDK_NOTE (EVENTS, g_print ("...synthesizing LEAVE_NOTIFY event\n"));
event->crossing.window = current_window;
event->crossing.subwindow = NULL;
event->crossing.time = msg->time;
- event->crossing.x = current_x;
- event->crossing.y = current_y;
+ _gdk_windowing_window_get_offsets (current_window, &xoffset, &yoffset);
+ event->crossing.x = current_x + xoffset;
+ event->crossing.y = current_y + yoffset;
event->crossing.x_root = current_x_root;
event->crossing.y_root = current_y_root;
event->crossing.mode = GDK_CROSSING_NORMAL;
break;
case WM_MOUSEWHEEL:
- GDK_NOTE (EVENTS, g_print ("WM_MOUSEWHEEL: %#lx %d\n",
- (gulong) msg->hwnd, HIWORD (msg->wParam)));
+ GDK_NOTE (EVENTS, g_print ("WM_MOUSEWHEEL: %p %d\n",
+ msg->hwnd, HIWORD (msg->wParam)));
event->scroll.type = GDK_SCROLL;
}
if (GDK_WINDOW_OBJECT (window)->extension_events != 0
- && gdk_input_ignore_core)
+ && _gdk_input_ignore_core)
{
GDK_NOTE (EVENTS, g_print ("...ignored\n"));
break;
GDK_SCROLL_UP : GDK_SCROLL_DOWN;
event->scroll.window = window;
event->scroll.time = msg->time;
- event->scroll.x = (gint16) pt.x;
- event->scroll.y = (gint16) pt.y;
+ _gdk_windowing_window_get_offsets (window, &xoffset, &yoffset);
+ event->scroll.x = (gint16) pt.x + xoffset;
+ event->scroll.y = (gint16) pt.y + yoffset;
event->scroll.x_root = (gint16) LOWORD (msg->lParam);
event->scroll.y_root = (gint16) HIWORD (msg->lParam);
event->scroll.state = build_pointer_event_state (msg);
- event->scroll.device = gdk_core_pointer;
+ event->scroll.device = _gdk_core_pointer;
return_val = !GDK_WINDOW_DESTROYED (window);
break;
#ifdef USE_TRACKMOUSEEVENT
case WM_MOUSELEAVE:
- GDK_NOTE (EVENTS, g_print ("WM_MOUSELEAVE: %#lx\n", (gulong) msg->hwnd));
+ GDK_NOTE (EVENTS, g_print ("WM_MOUSELEAVE: %p\n", msg->hwnd));
- if (!(window_impl->event_mask & GDK_LEAVE_NOTIFY_MASK))
+ if (!(private->event_mask & GDK_LEAVE_NOTIFY_MASK))
break;
event->crossing.type = GDK_LEAVE_NOTIFY;
event->crossing.window = window;
event->crossing.subwindow = NULL;
event->crossing.time = msg->time;
- event->crossing.x = current_x;
- event->crossing.y = current_y;
- event->crossing.x_root = current_xroot;
- event->crossing.y_root = current_yroot;
+ _gdk_windowing_window_get_offsets (window, &xoffset, &yoffset);
+ event->crossing.x = current_x + xoffset;
+ event->crossing.y = current_y + yoffset;
+ event->crossing.x_root = current_x_root;
+ event->crossing.y_root = current_y_root;
event->crossing.mode = GDK_CROSSING_NORMAL;
if (current_window
&& IsChild (GDK_WINDOW_HWND (current_window), GDK_WINDOW_HWND (window)))
break;
#endif
+ case WM_QUERYNEWPALETTE:
+ GDK_NOTE (EVENTS_OR_COLORMAP, g_print ("WM_QUERYNEWPALETTE: %p\n",
+ msg->hwnd));
+ if (gdk_visual_get_system ()->type == GDK_VISUAL_PSEUDO_COLOR)
+ {
+ synthesize_expose_events (window);
+ update_colors_counter = 0;
+ }
+ *ret_val_flagp = TRUE;
+ *ret_valp = FALSE;
+ break;
+
+ case WM_PALETTECHANGED:
+ GDK_NOTE (EVENTS_OR_COLORMAP, g_print ("WM_PALETTECHANGED: %p %p\n",
+ msg->hwnd, (HWND) msg->wParam));
+ *ret_val_flagp = TRUE;
+ *ret_valp = FALSE;
+
+ if (gdk_visual_get_system ()->type != GDK_VISUAL_PSEUDO_COLOR)
+ break;
+
+ if (msg->hwnd == (HWND) msg->wParam)
+ break;
+
+ if (++update_colors_counter == 5)
+ {
+ synthesize_expose_events (window);
+ update_colors_counter = 0;
+ break;
+ }
+
+ update_colors (window, TRUE);
+ break;
+
case WM_SETFOCUS:
case WM_KILLFOCUS:
- GDK_NOTE (EVENTS, g_print ("WM_%sFOCUS: %#lx\n",
+ GDK_NOTE (EVENTS, g_print ("WM_%sFOCUS: %p\n",
(msg->message == WM_SETFOCUS ?
"SET" : "KILL"),
- (gulong) msg->hwnd));
+ msg->hwnd));
- if (!(window_impl->event_mask & GDK_FOCUS_CHANGE_MASK))
+ if (!(private->event_mask & GDK_FOCUS_CHANGE_MASK))
break;
event->focus_change.type = GDK_FOCUS_CHANGE;
break;
case WM_ERASEBKGND:
- GDK_NOTE (EVENTS, g_print ("WM_ERASEBKGND: %#lx dc %#x\n",
- (gulong) msg->hwnd, msg->wParam));
+ GDK_NOTE (EVENTS, g_print ("WM_ERASEBKGND: %p dc %#x\n",
+ msg->hwnd, msg->wParam));
if (GDK_WINDOW_DESTROYED (window))
break;
- colormap_private = (GdkColormapPrivateWin32 *) GDK_DRAWABLE_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)->colormap;
- hdc = (HDC) msg->wParam;
- if (colormap_private && colormap_private->xcolormap->rc_palette)
- {
- int k;
-
- if (SelectPalette (hdc, colormap_private->xcolormap->palette,
- FALSE) == NULL)
- WIN32_GDI_FAILED ("SelectPalette");
- if ((k = RealizePalette (hdc)) == GDI_ERROR)
- WIN32_GDI_FAILED ("RealizePalette");
-#if 0
- g_print ("WM_ERASEBKGND: selected %#x, realized %d colors\n",
- colormap_private->xcolormap->palette, k);
-#endif
- }
- *ret_val_flagp = TRUE;
+ erase_background (window, (HDC) msg->wParam);
+ *ret_val_flagp = TRUE; /* always claim as handled */
*ret_valp = 1;
- if (GDK_WINDOW_OBJECT (window)->input_only)
- break;
-
- if (GDK_WINDOW_OBJECT (window)->bg_pixmap == GDK_PARENT_RELATIVE_BG)
- {
- /* If this window should have the same background as the
- * parent, fetch the parent. (And if the same goes for
- * the parent, fetch the grandparent, etc.)
- */
- while (window && GDK_WINDOW_OBJECT (window)->bg_pixmap == GDK_PARENT_RELATIVE_BG)
- {
- gdk_drawable_unref (window);
- ASSIGN_WINDOW (GDK_WINDOW (GDK_WINDOW_OBJECT (window)->parent));
- gdk_drawable_ref (window);
- }
- }
-
- if (GDK_WINDOW_OBJECT (window)->bg_pixmap == NULL)
- {
- bg = gdk_colormap_color (GDK_DRAWABLE_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)->colormap,
- GDK_WINDOW_OBJECT (window)->bg_color.pixel);
-
- GetClipBox (hdc, &rect);
- GDK_NOTE (EVENTS,
- g_print ("...%ldx%ld@+%ld+%ld BG_PIXEL %.06lx\n",
- rect.right - rect.left,
- rect.bottom - rect.top,
- rect.left, rect.top,
- (gulong) bg));
- hbr = CreateSolidBrush (bg);
-#if 0
- g_print ("...CreateSolidBrush (%.08x) = %.08x\n", bg, hbr);
-#endif
- if (!FillRect (hdc, &rect, hbr))
- WIN32_GDI_FAILED ("FillRect");
- DeleteObject (hbr);
- }
- else if (GDK_WINDOW_OBJECT (window)->bg_pixmap != NULL &&
- GDK_WINDOW_OBJECT (window)->bg_pixmap != GDK_NO_BG)
- {
- pixmap = GDK_WINDOW_OBJECT (window)->bg_pixmap;
- pixmap_impl = GDK_PIXMAP_IMPL_WIN32 (pixmap);
- GetClipBox (hdc, &rect);
-
- if (pixmap_impl->width <= 8 && pixmap_impl->height <= 8)
- {
- GDK_NOTE (EVENTS, g_print ("...small pixmap, using brush\n"));
- hbr = CreatePatternBrush (GDK_PIXMAP_HBITMAP (pixmap));
- if (!FillRect (hdc, &rect, hbr))
- WIN32_GDI_FAILED ("FillRect");
- DeleteObject (hbr);
- }
- else
- {
- GDK_NOTE (EVENTS,
- g_print ("...blitting pixmap %#lx (%dx%d) "
- "all over the place,\n"
- "...clip box = %ldx%ld@+%ld+%ld\n",
- (gulong) GDK_PIXMAP_HBITMAP (pixmap),
- pixmap_impl->width, pixmap_impl->height,
- rect.right - rect.left, rect.bottom - rect.top,
- rect.left, rect.top));
-
- if (!(bgdc = CreateCompatibleDC (hdc)))
- {
- WIN32_GDI_FAILED ("CreateCompatibleDC");
- break;
- }
- if (!(oldbitmap = SelectObject (bgdc, GDK_PIXMAP_HBITMAP (pixmap))))
- {
- WIN32_GDI_FAILED ("SelectObject");
- DeleteDC (bgdc);
- break;
- }
- i = 0;
- while (i < rect.right)
- {
- j = 0;
- while (j < rect.bottom)
- {
- if (i + pixmap_impl->width >= rect.left
- && j + pixmap_impl->height >= rect.top)
- {
- if (!BitBlt (hdc, i, j,
- pixmap_impl->width, pixmap_impl->height,
- bgdc, 0, 0, SRCCOPY))
- {
- WIN32_GDI_FAILED ("BitBlt");
- goto loopexit;
- }
- }
- j += pixmap_impl->height;
- }
- i += pixmap_impl->width;
- }
- loopexit:
- SelectObject (bgdc, oldbitmap);
- DeleteDC (bgdc);
- }
- }
- else
- {
- GDK_NOTE (EVENTS, g_print ("...BLACK_BRUSH (?)\n"));
- hbr = GetStockObject (BLACK_BRUSH);
- GetClipBox (hdc, &rect);
- if (!FillRect (hdc, &rect, hbr))
- WIN32_GDI_FAILED ("FillRect");
- }
break;
case WM_PAINT:
- if (!GetUpdateRect(msg->hwnd, NULL, FALSE))
- {
- GDK_NOTE (EVENTS, g_print ("WM_PAINT: %#lx no update rect\n",
- (gulong) msg->hwnd));
- break;
- }
-
- /* HB: don't generate GDK_EXPOSE events for InputOnly
- * windows -> backing store now works!
- */
- if (GDK_WINDOW_OBJECT (window)->input_only)
- break;
+ if (!GetUpdateRect (msg->hwnd, NULL, FALSE))
+ {
+ GDK_NOTE (EVENTS, g_print ("WM_PAINT: %p no update rgn\n",
+ msg->hwnd));
+ break;
+ }
hdc = BeginPaint (msg->hwnd, &paintstruct);
GDK_NOTE (EVENTS,
- g_print ("WM_PAINT: %#lx %ldx%ld@+%ld+%ld %s dc %#lx\n",
- (gulong) msg->hwnd,
+ g_print ("WM_PAINT: %p %ldx%ld@+%ld+%ld %s dc %p\n",
+ msg->hwnd,
paintstruct.rcPaint.right - paintstruct.rcPaint.left,
paintstruct.rcPaint.bottom - paintstruct.rcPaint.top,
paintstruct.rcPaint.left, paintstruct.rcPaint.top,
(paintstruct.fErase ? "erase" : ""),
- (gulong) hdc));
+ hdc));
EndPaint (msg->hwnd, &paintstruct);
- if (!(window_impl->event_mask & GDK_EXPOSURE_MASK))
+ /* HB: don't generate GDK_EXPOSE events for InputOnly
+ * windows -> backing store now works!
+ */
+ if (GDK_WINDOW_OBJECT (window)->input_only)
+ break;
+
+ if (!(private->event_mask & GDK_EXPOSURE_MASK))
+ break;
+
+#if 0 /* we need to process exposes even with GDK_NO_BG
+ * Otherwise The GIMP canvas update is broken ....
+ */
+ if (GDK_WINDOW_OBJECT (window)->bg_pixmap == GDK_NO_BG)
break;
+#endif
if ((paintstruct.rcPaint.right == paintstruct.rcPaint.left)
|| (paintstruct.rcPaint.bottom == paintstruct.rcPaint.top))
break;
- event->expose.type = GDK_EXPOSE;
- event->expose.window = window;
- event->expose.area.x = paintstruct.rcPaint.left;
- event->expose.area.y = paintstruct.rcPaint.top;
- event->expose.area.width = paintstruct.rcPaint.right - paintstruct.rcPaint.left;
- event->expose.area.height = paintstruct.rcPaint.bottom - paintstruct.rcPaint.top;
- event->expose.count = 0;
-
- return_val = !GDK_WINDOW_DESTROYED (window);
- if (return_val)
- {
- GList *list = gdk_queued_events;
- while (list != NULL )
+ if (return_exposes)
+ {
+ hrgn = CreateRectRgn (0, 0, 0, 0);
+ if ((k = GetUpdateRgn (msg->hwnd, hrgn, FALSE)) == ERROR)
+ WIN32_GDI_FAILED ("GetUpdateRgn");
+ else if (k == NULLREGION)
{
- if ((((GdkEvent *)list->data)->any.type == GDK_EXPOSE) &&
- (((GdkEvent *)list->data)->any.window == window) &&
- !(((GdkEventPrivate *)list->data)->flags & GDK_EVENT_PENDING))
- ((GdkEvent *)list->data)->expose.count++;
-
- list = list->next;
+ DeleteObject (hrgn);
+ break;
}
- }
+
+ event->expose.type = GDK_EXPOSE;
+ event->expose.window = window;
+ event->expose.area.x = paintstruct.rcPaint.left;
+ event->expose.area.y = paintstruct.rcPaint.top;
+ event->expose.area.width = paintstruct.rcPaint.right - paintstruct.rcPaint.left;
+ event->expose.area.height = paintstruct.rcPaint.bottom - paintstruct.rcPaint.top;
+ event->expose.region = _gdk_win32_hrgn_to_region (hrgn);
+ event->expose.count = 0;
+
+ DeleteObject (hrgn);
+
+ return_val = !GDK_WINDOW_DESTROYED (window);
+ if (return_val)
+ {
+ GList *list = _gdk_queued_events;
+ while (list != NULL )
+ {
+ if ((((GdkEvent *)list->data)->any.type == GDK_EXPOSE) &&
+ (((GdkEvent *)list->data)->any.window == window) &&
+ !(((GdkEventPrivate *)list->data)->flags & GDK_EVENT_PENDING))
+ ((GdkEvent *)list->data)->expose.count++;
+
+ list = list->next;
+ }
+ }
+ }
+ else
+ {
+ GdkRectangle expose_rect;
+
+ _gdk_windowing_window_get_offsets (window, &xoffset, &yoffset);
+ expose_rect.x = paintstruct.rcPaint.left + xoffset;
+ expose_rect.y = paintstruct.rcPaint.top + yoffset;
+ expose_rect.width = paintstruct.rcPaint.right - paintstruct.rcPaint.left;
+ expose_rect.height = paintstruct.rcPaint.bottom - paintstruct.rcPaint.top;
+
+ _gdk_window_process_expose (window, msg->time, &expose_rect);
+
+ return_val = FALSE;
+ }
break;
+ case WM_GETICON:
+ GDK_NOTE (EVENTS, g_print ("WM_GETICON: %p %s\n",
+ msg->hwnd,
+ (ICON_BIG == msg->wParam ? "big" : "small")));
+ break;
+
case WM_SETCURSOR:
- GDK_NOTE (EVENTS, g_print ("WM_SETCURSOR: %#lx %#x %#x\n",
- (gulong) msg->hwnd,
+ GDK_NOTE (EVENTS, g_print ("WM_SETCURSOR: %p %#x %#x\n",
+ msg->hwnd,
LOWORD (msg->lParam), HIWORD (msg->lParam)));
if (LOWORD (msg->lParam) != HTCLIENT)
if (p_grab_window != NULL && p_grab_cursor != NULL)
hcursor = p_grab_cursor;
else if (!GDK_WINDOW_DESTROYED (window))
- hcursor = window_impl->hcursor;
+ hcursor = GDK_WINDOW_IMPL_WIN32 (private->impl)->hcursor;
else
hcursor = NULL;
if (hcursor != NULL)
{
- GDK_NOTE (EVENTS, g_print ("...SetCursor(%#lx)\n", (gulong) hcursor));
+ GDK_NOTE (EVENTS, g_print ("...SetCursor(%p)\n", hcursor));
SetCursor (hcursor);
*ret_val_flagp = TRUE;
*ret_valp = TRUE;
break;
case WM_SHOWWINDOW:
- GDK_NOTE (EVENTS, g_print ("WM_SHOWWINDOW: %#lx %d\n",
- (gulong) msg->hwnd,
- msg->wParam));
+ GDK_NOTE (EVENTS, g_print ("WM_SHOWWINDOW: %p %d\n",
+ msg->hwnd, msg->wParam));
- if (!(window_impl->event_mask & GDK_STRUCTURE_MASK))
+ if (!(private->event_mask & GDK_STRUCTURE_MASK))
break;
event->any.type = (msg->wParam ? GDK_MAP : GDK_UNMAP);
case WM_SIZE:
GDK_NOTE (EVENTS,
- g_print ("WM_SIZE: %#lx %s %dx%d\n",
- (gulong) msg->hwnd,
+ g_print ("WM_SIZE: %p %s %dx%d\n",
+ msg->hwnd,
(msg->wParam == SIZE_MAXHIDE ? "MAXHIDE" :
(msg->wParam == SIZE_MAXIMIZED ? "MAXIMIZED" :
(msg->wParam == SIZE_MAXSHOW ? "MAXSHOW" :
(msg->wParam == SIZE_RESTORED ? "RESTORED" : "?"))))),
LOWORD (msg->lParam), HIWORD (msg->lParam)));
- if (!(window_impl->event_mask & GDK_STRUCTURE_MASK))
+ if (!(private->event_mask & GDK_STRUCTURE_MASK))
break;
if (msg->wParam == SIZE_MINIMIZED)
event->configure.y = pt.y;
event->configure.width = LOWORD (msg->lParam);
event->configure.height = HIWORD (msg->lParam);
- GDK_WINDOW_OBJECT (window)->x = event->configure.x;
- GDK_WINDOW_OBJECT (window)->y = event->configure.y;
- window_impl->width = event->configure.width;
- window_impl->height = event->configure.height;
+ private->x = event->configure.x;
+ private->y = event->configure.y;
+ GDK_WINDOW_IMPL_WIN32 (private->impl)->width = event->configure.width;
+ GDK_WINDOW_IMPL_WIN32 (private->impl)->height = event->configure.height;
- if (GDK_WINDOW_OBJECT (window)->resize_count > 1)
- GDK_WINDOW_OBJECT (window)->resize_count -= 1;
+ if (private->resize_count > 1)
+ private->resize_count -= 1;
return_val = !GDK_WINDOW_DESTROYED (window);
- if (return_val
- && GDK_WINDOW_OBJECT (window)->extension_events != 0)
+ if (return_val && private->extension_events != 0)
_gdk_input_configure_event (&event->configure, window);
}
break;
+#if 0
+ case WM_SIZING :
+ {
+ LPRECT lpr = (LPRECT) msg->lParam;
+ NONCLIENTMETRICS ncm;
+ ncm.cbSize = sizeof (NONCLIENTMETRICS);
+ SystemParametersInfo (SPI_GETNONCLIENTMETRICS, ncm.cbSize, &ncm, 0);
+
+ g_print ("WM_SIZING borderWidth %d captionHeight %d\n",
+ ncm.iBorderWidth, ncm.iCaptionHeight);
+ event->configure.type = GDK_CONFIGURE;
+ event->configure.window = window;
+
+ event->configure.x = lpr->left + ncm.iBorderWidth;
+ event->configure.y = lpr->top + ncm.iCaptionHeight;
+ event->configure.width = lpr->right - lpr->left - 2 * ncm.iBorderWidth;
+ event->configure.height = lpr->bottom - lpr->top - ncm.iCaptionHeight;
+ private->x = event->configure.x;
+ private->y = event->configure.y;
+ GDK_WINDOW_IMPL_WIN32 (private->impl)->width = event->configure.width;
+ GDK_WINDOW_IMPL_WIN32 (private->impl)->height = event->configure.height;
+
+ if (private->resize_count > 1)
+ private->resize_count -= 1;
+
+ return_val = !GDK_WINDOW_DESTROYED (window);
+ if (return_val && private->extension_events != 0)
+ _gdk_input_configure_event (&event->configure, window);
+ }
+ break;
+#endif
case WM_GETMINMAXINFO:
- GDK_NOTE (EVENTS, g_print ("WM_GETMINMAXINFO: %#lx\n", (gulong) msg->hwnd));
+ GDK_NOTE (EVENTS, g_print ("WM_GETMINMAXINFO: %p\n", msg->hwnd));
+ impl = GDK_WINDOW_IMPL_WIN32 (private->impl);
mmi = (MINMAXINFO*) msg->lParam;
- if (window_impl->hint_flags & GDK_HINT_MIN_SIZE)
+ if (impl->hint_flags & GDK_HINT_MIN_SIZE)
+ {
+ mmi->ptMinTrackSize.x = impl->hint_min_width;
+ mmi->ptMinTrackSize.y = impl->hint_min_height;
+ }
+ if (impl->hint_flags & GDK_HINT_MAX_SIZE)
{
- mmi->ptMinTrackSize.x = window_impl->hint_min_width;
- mmi->ptMinTrackSize.y = window_impl->hint_min_height;
+ mmi->ptMaxTrackSize.x = impl->hint_max_width;
+ mmi->ptMaxTrackSize.y = impl->hint_max_height;
+
+ /* kind of WM functionality, limit maximized size to screen */
+ mmi->ptMaxPosition.x = 0;
+ mmi->ptMaxPosition.y = 0;
+ mmi->ptMaxSize.x = MIN (impl->hint_max_width, gdk_screen_width ());
+ mmi->ptMaxSize.y = MIN (impl->hint_max_height, gdk_screen_height ());
}
- if (window_impl->hint_flags & GDK_HINT_MAX_SIZE)
+ else if (impl->hint_flags & GDK_HINT_MIN_SIZE)
{
- mmi->ptMaxTrackSize.x = window_impl->hint_max_width;
- mmi->ptMaxTrackSize.y = window_impl->hint_max_height;
-
- mmi->ptMaxSize.x = window_impl->hint_max_width;
- mmi->ptMaxSize.y = window_impl->hint_max_height;
+ /* need to initialize */
+ mmi->ptMaxSize.x = gdk_screen_width ();
+ mmi->ptMaxSize.y = gdk_screen_height ();
}
+ /* lovely API inconsistence: return FALSE when handled */
+ if (ret_val_flagp)
+ *ret_val_flagp = !(impl->hint_flags & (GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE));
break;
case WM_MOVE:
- GDK_NOTE (EVENTS, g_print ("WM_MOVE: %#lx (%d,%d)\n",
- (gulong) msg->hwnd,
+ GDK_NOTE (EVENTS, g_print ("WM_MOVE: %p (%d,%d)\n",
+ msg->hwnd,
LOWORD (msg->lParam), HIWORD (msg->lParam)));
- if (!(window_impl->event_mask & GDK_STRUCTURE_MASK))
+ if (!(private->event_mask & GDK_STRUCTURE_MASK))
break;
if (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD
GetClientRect (msg->hwnd, &rect);
event->configure.width = rect.right;
event->configure.height = rect.bottom;
- GDK_WINDOW_OBJECT (window)->x = event->configure.x;
- GDK_WINDOW_OBJECT (window)->y = event->configure.y;
- window_impl->width = event->configure.width;
- window_impl->height = event->configure.height;
+ private->x = event->configure.x;
+ private->y = event->configure.y;
+ GDK_WINDOW_IMPL_WIN32 (private->impl)->width = event->configure.width;
+ GDK_WINDOW_IMPL_WIN32 (private->impl)->height = event->configure.height;
return_val = !GDK_WINDOW_DESTROYED (window);
}
break;
+#if 0 /* Not quite right, otherwise it may be faster/better than
+ * WM_(MOVE|SIZE) remove decoration (frame) sizes ?
+ */
+ case WM_WINDOWPOSCHANGED :
+
+ if (!(private->event_mask & GDK_STRUCTURE_MASK))
+ break;
+
+ if (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD
+ && !IsIconic(msg->hwnd)
+ && IsWindowVisible(msg->hwnd))
+ {
+ LPWINDOWPOS lpwp = (LPWINDOWPOS) (msg->lParam);
+
+ event->configure.type = GDK_CONFIGURE;
+ event->configure.window = window;
+ event->configure.x = lpwp->x;
+ event->configure.y = lpwp->y;
+ event->configure.width = lpwp->cx;
+ event->configure.height = lpwp->cy;
+ private->x = event->configure.x;
+ private->y = event->configure.y;
+ GDK_WINDOW_IMPL_WIN32 (private->impl)->width = event->configure.width;
+ GDK_WINDOW_IMPL_WIN32 (private->impl)->height = event->configure.height;
+
+ return_val = !GDK_WINDOW_DESTROYED (window);
+
+ GDK_NOTE (EVENTS, g_print ("WM_WINDOWPOSCHANGED: %p %ldx%ld@+%ld+%ld\n",
+ msg->hwnd,
+ lpwp->cx, lpwp->cy, lpwp->x, lpwp->y));
+
+ if (ret_val_flagp)
+ *ret_val_flagp = TRUE;
+ if (ret_valp)
+ *ret_valp = 0;
+ }
+ break;
+#endif
case WM_CLOSE:
- GDK_NOTE (EVENTS, g_print ("WM_CLOSE: %#lx\n", (gulong) msg->hwnd));
+ GDK_NOTE (EVENTS, g_print ("WM_CLOSE: %p\n", msg->hwnd));
event->any.type = GDK_DELETE;
event->any.window = window;
flag = FALSE;
GDK_NOTE (EVENTS, flag = TRUE);
if (flag)
- g_print ("WM_%s: %#lx %#x (%s)\n",
+ g_print ("WM_%s: %p %#x (%s)\n",
(msg->message == WM_RENDERFORMAT ? "RENDERFORMAT" :
"RENDERALLFORMATS"),
- (gulong) msg->hwnd,
+ msg->hwnd,
msg->wParam,
(msg->wParam == CF_TEXT ? "CF_TEXT" :
(msg->wParam == CF_DIB ? "CF_DIB" :
GetClipboardFormatName (msg->wParam, buf, sizeof (buf));
event->selection.target = gdk_atom_intern (buf, FALSE);
}
- event->selection.property = gdk_selection_property;
+ event->selection.property = _gdk_selection_property;
event->selection.requestor = (guint32) msg->hwnd;
event->selection.time = msg->time;
return_val = !GDK_WINDOW_DESTROYED (window);
#endif /* No delayed rendering */
case WM_DESTROY:
- GDK_NOTE (EVENTS, g_print ("WM_DESTROY: %#lx\n", (gulong) msg->hwnd));
+ GDK_NOTE (EVENTS, g_print ("WM_DESTROY: %p\n", msg->hwnd));
event->any.type = GDK_DESTROY;
event->any.window = window;
* constants as case labels.
*/
case WT_PACKET:
- GDK_NOTE (EVENTS, g_print ("WT_PACKET: %#lx %d %#lx\n",
- (gulong) msg->hwnd,
- msg->wParam, msg->lParam));
+ GDK_NOTE (EVENTS, g_print ("WT_PACKET: %p %d %#lx\n",
+ msg->hwnd, msg->wParam, msg->lParam));
goto wintab;
case WT_CSRCHANGE:
- GDK_NOTE (EVENTS, g_print ("WT_CSRCHANGE: %#lx %d %#lx\n",
- (gulong) msg->hwnd,
- msg->wParam, msg->lParam));
+ GDK_NOTE (EVENTS, g_print ("WT_CSRCHANGE: %p %d %#lx\n",
+ msg->hwnd, msg->wParam, msg->lParam));
goto wintab;
case WT_PROXIMITY:
- GDK_NOTE (EVENTS, g_print ("WT_PROXIMITY: %#lx %#x %d %d\n",
- (gulong) msg->hwnd, msg->wParam,
+ GDK_NOTE (EVENTS, g_print ("WT_PROXIMITY: %p %#x %d %d\n",
+ msg->hwnd, msg->wParam,
LOWORD (msg->lParam),
HIWORD (msg->lParam)));
/* Fall through */
#endif
default:
- GDK_NOTE (EVENTS, g_print ("%s: %#lx %#x %#lx\n",
+ GDK_NOTE (EVENTS, g_print ("%s: %p %#x %#lx\n",
gdk_win32_message_name (msg->message),
- (gulong) msg->hwnd,
- msg->wParam, msg->lParam));
+ msg->hwnd, msg->wParam, msg->lParam));
}
done:
}
void
-gdk_events_queue (void)
+_gdk_events_queue (void)
{
MSG msg;
+ GdkEvent *event;
+ GList *node;
- while (!gdk_event_queue_find_first ()
+ while (!_gdk_event_queue_find_first ()
&& PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
{
- GDK_NOTE (EVENTS, g_print ("PeekMessage: %#lx %s\n",
- (gulong) msg.hwnd, gdk_win32_message_name (msg.message)));
-
+#ifndef HAVE_DIMM_H
+ TranslateMessage (&msg);
+#else
if (active_imm_msgpump_owner == NULL
|| (active_imm_msgpump_owner->lpVtbl->OnTranslateMessage) (active_imm_msgpump_owner, &msg) != S_OK)
TranslateMessage (&msg);
+#endif
+#if 1 /* It was like this all the time */
DispatchMessage (&msg);
+#else /* but this one is more similar to the X implementation. Any effect ? */
+ event = _gdk_event_new ();
+
+ event->any.type = GDK_NOTHING;
+ event->any.window = NULL;
+ event->any.send_event = InSendMessage ();
+
+ ((GdkEventPrivate *)event)->flags |= GDK_EVENT_PENDING;
+
+ _gdk_event_queue_append (event);
+ node = _gdk_queued_tail;
+
+ if (gdk_event_translate (event, &msg, NULL, NULL, FALSE))
+ {
+ ((GdkEventPrivate *)event)->flags &= ~GDK_EVENT_PENDING;
+ }
+ else
+ {
+ _gdk_event_queue_remove_link (node);
+ g_list_free_1 (node);
+ gdk_event_free (event);
+ DispatchMessage (&msg);
+ }
+
+#endif
}
}
*timeout = -1;
- retval = (gdk_event_queue_find_first () != NULL)
+ retval = (_gdk_event_queue_find_first () != NULL)
|| PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE);
GDK_THREADS_LEAVE ();
GDK_THREADS_ENTER ();
if (event_poll_fd.revents & G_IO_IN)
- retval = (gdk_event_queue_find_first () != NULL)
+ retval = (_gdk_event_queue_find_first () != NULL)
|| PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE);
else
retval = FALSE;
GDK_THREADS_ENTER ();
- gdk_events_queue();
- event = gdk_event_unqueue();
+ _gdk_events_queue();
+ event = _gdk_event_unqueue();
if (event)
{
- if (gdk_event_func)
- (*gdk_event_func) (event, gdk_event_data);
+ if (_gdk_event_func)
+ (*_gdk_event_func) (event, _gdk_event_data);
gdk_event_free (event);
}
void
gdk_flush (void)
{
+#if 0
+ MSG msg;
+
+ /* Process all messages currently available */
+ while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
+ {
+ TranslateMessage (&msg);
+ DispatchMessage (&msg);
+ }
+#endif
+
GdiFlush ();
}
projects / ~andy / gtk / blobdiff