* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
/*
* Private function declarations
*/
+#define SYNAPSIS_ICON_WINDOW_CLASS "SynTrackCursorWindowClass"
+
static gboolean gdk_event_translate (MSG *msg,
gint *ret_valp);
static void handle_wm_paint (MSG *msg,
GSourceFunc callback,
gpointer user_data);
-static gboolean is_modally_blocked (GdkWindow *window);
-
/* Private variable declarations
*/
static GList *client_filters; /* Filters for client messages */
extern gint _gdk_input_ignore_core;
-static HCURSOR p_grab_cursor;
+HCURSOR _gdk_win32_grab_cursor;
static GSourceFuncs event_funcs = {
gdk_event_prepare,
GPollFD event_poll_fd;
static GdkWindow *mouse_window = NULL;
+static GdkWindow *mouse_window_ignored_leave = NULL;
static gint current_x, current_y;
static gint current_root_x, current_root_y;
static UINT client_message;
gboolean in)
{
GdkDevice *device;
+ GdkDevice *source_device;
GdkEvent *event;
device = GDK_DEVICE_MANAGER_WIN32 (device_manager)->core_keyboard;
+ source_device = GDK_DEVICE_MANAGER_WIN32 (device_manager)->system_keyboard;
event = gdk_event_new (GDK_FOCUS_CHANGE);
event->focus_change.window = window;
event->focus_change.in = in;
gdk_event_set_device (event, device);
+ gdk_event_set_source_device (event, source_device);
_gdk_win32_append_event (event);
}
{
GdkEvent *event = gdk_event_new (GDK_GRAB_BROKEN);
GdkDevice *device;
+ GdkDevice *source_device;
if (keyboard)
- device = GDK_DEVICE_MANAGER_WIN32 (device_manager)->core_keyboard;
+ {
+ device = GDK_DEVICE_MANAGER_WIN32 (device_manager)->core_keyboard;
+ source_device = GDK_DEVICE_MANAGER_WIN32 (device_manager)->system_keyboard;
+ }
else
- device = GDK_DEVICE_MANAGER_WIN32 (device_manager)->core_pointer;
+ {
+ device = GDK_DEVICE_MANAGER_WIN32 (device_manager)->core_pointer;
+ source_device = GDK_DEVICE_MANAGER_WIN32 (device_manager)->system_pointer;
+ }
event->grab_broken.window = window;
event->grab_broken.send_event = 0;
event->grab_broken.implicit = FALSE;
event->grab_broken.grab_window = grab_window;
gdk_event_set_device (event, device);
+ gdk_event_set_source_device (event, device);
_gdk_win32_append_event (event);
}
#endif
-GdkGrabStatus
-_gdk_windowing_device_grab (GdkDevice *device,
- GdkWindow *window,
- GdkWindow *native_window,
- gboolean owner_events,
- GdkEventMask event_mask,
- GdkWindow *confine_to,
- GdkCursor *cursor,
- guint32 time)
-{
- HCURSOR hcursor;
- GdkWin32Cursor *cursor_private;
- gint return_val;
- GdkWindowImplWin32 *impl = GDK_WINDOW_IMPL_WIN32 (native_window->impl);
-
- g_return_val_if_fail (window != NULL, 0);
- g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
- g_return_val_if_fail (confine_to == NULL || GDK_IS_WINDOW (confine_to), 0);
-
- cursor_private = (GdkWin32Cursor*) cursor;
-
- if (!cursor)
- hcursor = NULL;
- else if ((hcursor = CopyCursor (cursor_private->hcursor)) == NULL)
- WIN32_API_FAILED ("CopyCursor");
-
- return_val = GDK_DEVICE_GET_CLASS (device)->grab (device,
- native_window,
- owner_events,
- event_mask,
- confine_to,
- cursor,
- time);
-
- /* TODO_CSW: grab brokens, confine window, input_grab */
- if (p_grab_cursor != NULL)
- {
- if (GetCursor () == p_grab_cursor)
- SetCursor (NULL);
- DestroyCursor (p_grab_cursor);
- }
-
- p_grab_cursor = hcursor;
-
- if (p_grab_cursor != NULL)
- SetCursor (p_grab_cursor);
- else if (impl->hcursor != NULL)
- SetCursor (impl->hcursor);
- else
- SetCursor (LoadCursor (NULL, IDC_ARROW));
-
- return return_val;
-}
-
static GdkWindow *
find_window_for_mouse_event (GdkWindow* reported_window,
MSG* msg)
(event->any.type == GDK_LEAVE_NOTIFY)) &&
(event->crossing.subwindow != NULL))
g_object_ref (event->crossing.subwindow);
+ if (((event->any.type == GDK_SELECTION_CLEAR) ||
+ (event->any.type == GDK_SELECTION_NOTIFY) ||
+ (event->any.type == GDK_SELECTION_REQUEST)) &&
+ (event->selection.requestor != NULL))
+ g_object_ref (event->selection.requestor);
+ if ((event->any.type == GDK_OWNER_CHANGE) &&
+ (event->owner_change.owner != NULL))
+ g_object_ref (event->owner_change.owner);
event->any.send_event = InSendMessage ();
}
event->crossing.detail = notify_type;
event->crossing.focus = FALSE;
event->crossing.state = mask;
- gdk_event_set_device (event, _gdk_display->core_pointer);
+ gdk_event_set_device (event, device_manager->core_pointer);
+ gdk_event_set_source_device (event, device_manager->system_pointer);
_gdk_win32_append_event (event);
-
- if (type == GDK_ENTER_NOTIFY &&
- window->extension_events != 0)
- _gdk_device_wintab_update_window_coords (window);
}
static GdkWindow *
gboolean grab_owner_events,
gint grab_mask,
gboolean (*doesnt_want_it) (gint mask,
- MSG *msg),
- gboolean check_extended)
+ MSG *msg))
{
if (grab_window != NULL && !grab_owner_events)
{
/* Event source is grabbed with owner_events FALSE */
- /* See if the event should be ignored because an extended input
- * device is used
- */
- if (check_extended &&
- grab_window->extension_events != 0 &&
- _gdk_input_ignore_core)
- {
- GDK_NOTE (EVENTS, g_print (" (ignored for grabber)"));
- return FALSE;
- }
if ((*doesnt_want_it) (grab_mask, msg))
{
GDK_NOTE (EVENTS, g_print (" (grabber doesn't want it)"));
*/
while (TRUE)
{
- if (check_extended &&
- (*window)->extension_events != 0 &&
- _gdk_input_ignore_core)
- {
- GDK_NOTE (EVENTS, g_print (" (ignored)"));
- return FALSE;
- }
if ((*doesnt_want_it) ((*window)->event_mask, msg))
{
/* Owner doesn't want it, propagate to parent. */
{
/* Event source is grabbed with owner_events TRUE */
- if (check_extended &&
- grab_window->extension_events != 0 &&
- _gdk_input_ignore_core)
- {
- GDK_NOTE (EVENTS, g_print (" (ignored for grabber)"));
- return FALSE;
- }
if ((*doesnt_want_it) (grab_mask, msg))
{
/* Grabber doesn't want it either */
void
_gdk_win32_emit_configure_event (GdkWindow *window)
{
+ GdkWindowImplWin32 *window_impl;
RECT client_rect;
POINT point;
HWND hwnd;
+ window_impl = GDK_WINDOW_IMPL_WIN32 (window->impl);
+ if (window_impl->inhibit_configure)
+ return;
+
hwnd = GDK_WINDOW_HWND (window);
GetClientRect (hwnd, &client_rect);
MSG *msg)
{
GdkEvent *event = gdk_event_new (type);
+ GdkDeviceManagerWin32 *device_manager;
+
+ if (_gdk_input_ignore_core)
+ return;
+
+ device_manager = GDK_DEVICE_MANAGER_WIN32 (gdk_display_get_device_manager (_gdk_display));
event->button.window = window;
event->button.time = _gdk_win32_get_next_tick (msg->time);
event->button.axes = NULL;
event->button.state = build_pointer_event_state (msg);
event->button.button = button;
- gdk_event_set_device (event, _gdk_display->core_pointer);
+ gdk_event_set_device (event, device_manager->core_pointer);
+ gdk_event_set_source_device (event, device_manager->system_pointer);
_gdk_win32_append_event (event);
}
BYTE key_state[256];
HIMC himc;
WINDOWPOS *windowpos;
+ gboolean ignore_leave;
GdkEvent *event;
GdkWindow *orig_window, *new_window;
GdkDeviceManager *device_manager;
+ GdkDeviceManagerWin32 *device_manager_win32;
GdkDeviceGrabInfo *keyboard_grab = NULL;
GdkDeviceGrabInfo *pointer_grab = NULL;
}
device_manager = gdk_display_get_device_manager (_gdk_display);
+ device_manager_win32 = GDK_DEVICE_MANAGER_WIN32 (device_manager);
keyboard_grab = _gdk_display_get_last_device_grab (_gdk_display,
- GDK_DEVICE_MANAGER_WIN32 (device_manager)->core_keyboard);
+ device_manager_win32->core_keyboard);
pointer_grab = _gdk_display_get_last_device_grab (_gdk_display,
- GDK_DEVICE_MANAGER_WIN32 (device_manager)->core_pointer);
+ device_manager_win32->core_pointer);
g_object_ref (window);
keyboard_grab->window,
keyboard_grab->owner_events,
GDK_ALL_EVENTS_MASK,
- doesnt_want_key, FALSE))
+ doesnt_want_key))
break;
if (GDK_WINDOW_DESTROYED (window))
event->key.string = NULL;
event->key.length = 0;
event->key.hardware_keycode = msg->wParam;
- gdk_event_set_device (event, GDK_DEVICE_MANAGER_WIN32 (device_manager)->core_keyboard);
+ gdk_event_set_device (event, device_manager_win32->core_keyboard);
+ gdk_event_set_source_device (event, device_manager_win32->system_keyboard);
if (HIWORD (msg->lParam) & KF_EXTENDED)
{
switch (msg->wParam)
keyboard_grab->window,
keyboard_grab->owner_events,
GDK_ALL_EVENTS_MASK,
- doesnt_want_char, FALSE))
+ doesnt_want_char))
break;
if (GDK_WINDOW_DESTROYED (window))
/* Build a key press event */
event = gdk_event_new (GDK_KEY_PRESS);
event->key.window = window;
- gdk_event_set_device (event, GDK_DEVICE_MANAGER_WIN32 (device_manager)->core_keyboard);
+ gdk_event_set_device (event, device_manager_win32->core_keyboard);
+ gdk_event_set_source_device (event, device_manager_win32->system_keyboard);
build_wm_ime_composition_event (event, msg, wbuf[i], key_state);
_gdk_win32_append_event (event);
/* Build a key release event. */
event = gdk_event_new (GDK_KEY_RELEASE);
event->key.window = window;
- gdk_event_set_device (event, GDK_DEVICE_MANAGER_WIN32 (device_manager)->core_keyboard);
+ gdk_event_set_device (event, device_manager_win32->core_keyboard);
+ gdk_event_set_source_device (event, device_manager_win32->system_keyboard);
build_wm_ime_composition_event (event, msg, wbuf[i], key_state);
_gdk_win32_append_event (event);
GET_X_LPARAM (msg->lParam), GET_Y_LPARAM (msg->lParam)));
assign_object (&window, find_window_for_mouse_event (window, msg));
-#if 0
- if (window->extension_events != 0 &&
- _gdk_input_ignore_core)
- {
- GDK_NOTE (EVENTS, g_print (" (ignored)"));
- break;
- }
-#endif
if (pointer_grab != NULL && pointer_grab->implicit)
{
msg->time,
FALSE);
assign_object (&mouse_window, new_window);
+ mouse_window_ignored_leave = NULL;
}
}
msg->time,
FALSE);
assign_object (&mouse_window, new_window);
+ mouse_window_ignored_leave = NULL;
if (new_window != NULL)
track_mouse_event (TME_LEAVE, GDK_WINDOW_HWND (new_window));
}
+ else if (new_window != NULL &&
+ new_window == mouse_window_ignored_leave)
+ {
+ /* If we ignored a leave event for this window and we're now getting
+ input again we need to re-arm the mouse tracking, as that was
+ cancelled by the mouseleave. */
+ mouse_window_ignored_leave = NULL;
+ track_mouse_event (TME_LEAVE, GDK_WINDOW_HWND (new_window));
+ }
assign_object (&window, find_window_for_mouse_event (window, msg));
current_root_x = msg->pt.x + _gdk_offset_x;
current_root_y = msg->pt.y + _gdk_offset_y;
- event = gdk_event_new (GDK_MOTION_NOTIFY);
- event->motion.window = window;
- event->motion.time = _gdk_win32_get_next_tick (msg->time);
- event->motion.x = current_x = (gint16) GET_X_LPARAM (msg->lParam);
- event->motion.y = current_y = (gint16) GET_Y_LPARAM (msg->lParam);
- event->motion.x_root = current_root_x;
- event->motion.y_root = current_root_y;
- event->motion.axes = NULL;
- event->motion.state = build_pointer_event_state (msg);
- event->motion.is_hint = FALSE;
- gdk_event_set_device (event, _gdk_display->core_pointer);
+ if (!_gdk_input_ignore_core)
+ {
+ event = gdk_event_new (GDK_MOTION_NOTIFY);
+ event->motion.window = window;
+ event->motion.time = _gdk_win32_get_next_tick (msg->time);
+ event->motion.x = current_x = (gint16) GET_X_LPARAM (msg->lParam);
+ event->motion.y = current_y = (gint16) GET_Y_LPARAM (msg->lParam);
+ event->motion.x_root = current_root_x;
+ event->motion.y_root = current_root_y;
+ event->motion.axes = NULL;
+ event->motion.state = build_pointer_event_state (msg);
+ event->motion.is_hint = FALSE;
+ gdk_event_set_device (event, device_manager_win32->core_pointer);
+ gdk_event_set_source_device (event, device_manager_win32->system_pointer);
- _gdk_win32_append_event (event);
+ _gdk_win32_append_event (event);
+ }
return_val = TRUE;
break;
new_window = NULL;
hwnd = WindowFromPoint (msg->pt);
+ ignore_leave = FALSE;
if (hwnd != NULL)
{
+ char classname[64];
+
POINT client_pt = msg->pt;
+ /* The synapitics trackpad drivers have this irritating
+ feature where it pops up a window right under the pointer
+ when you scroll. We ignore the leave and enter events for
+ this window */
+ if (GetClassNameA (hwnd, classname, sizeof(classname)) &&
+ strcmp (classname, SYNAPSIS_ICON_WINDOW_CLASS) == 0)
+ ignore_leave = TRUE;
+
ScreenToClient (hwnd, &client_pt);
GetClientRect (hwnd, &rect);
if (PtInRect (&rect, client_pt))
new_window = gdk_win32_handle_table_lookup (hwnd);
}
- synthesize_crossing_events (_gdk_display,
- mouse_window, new_window,
- GDK_CROSSING_NORMAL,
- &msg->pt,
- 0, /* TODO: Set right mask */
- msg->time,
- FALSE);
+ if (!ignore_leave)
+ synthesize_crossing_events (_gdk_display,
+ mouse_window, new_window,
+ GDK_CROSSING_NORMAL,
+ &msg->pt,
+ 0, /* TODO: Set right mask */
+ msg->time,
+ FALSE);
assign_object (&mouse_window, new_window);
+ mouse_window_ignored_leave = ignore_leave ? new_window : NULL;
+
return_val = TRUE;
break;
if ((hwnd = WindowFromPoint (point)) == NULL)
break;
+
+ {
+ char classname[64];
+
+ /* The synapitics trackpad drivers have this irritating
+ feature where it pops up a window right under the pointer
+ when you scroll. We backtrack and to the toplevel and
+ find the innermost child instead. */
+ if (GetClassNameA (hwnd, classname, sizeof(classname)) &&
+ strcmp (classname, SYNAPSIS_ICON_WINDOW_CLASS) == 0)
+ {
+ HWND hwndc;
+
+ /* Find our toplevel window */
+ hwnd = GetAncestor (msg->hwnd, GA_ROOT);
+
+ /* Walk back up to the outermost child at the desired point */
+ do {
+ ScreenToClient (hwnd, &point);
+ hwndc = ChildWindowFromPoint (hwnd, point);
+ ClientToScreen (hwnd, &point);
+ } while (hwndc != hwnd && (hwnd = hwndc, 1));
+ }
+ }
msg->hwnd = hwnd;
if ((new_window = gdk_win32_handle_table_lookup (msg->hwnd)) == NULL)
event->scroll.x_root = (gint16) GET_X_LPARAM (msg->lParam) + _gdk_offset_x;
event->scroll.y_root = (gint16) GET_Y_LPARAM (msg->lParam) + _gdk_offset_y;
event->scroll.state = build_pointer_event_state (msg);
- gdk_event_set_device (event, _gdk_display->core_pointer);
+ gdk_event_set_device (event, device_manager_win32->core_pointer);
+ gdk_event_set_source_device (event, device_manager_win32->system_pointer);
_gdk_win32_append_event (event);
case WM_MOUSEACTIVATE:
{
- GdkWindow *tmp;
-
if (gdk_window_get_window_type (window) == GDK_WINDOW_TEMP
|| !window->accept_focus)
{
return_val = TRUE;
}
- tmp = _gdk_modal_current ();
-
- if (tmp != NULL)
+ if (_gdk_modal_blocked (gdk_window_get_toplevel (window)))
{
- if (gdk_window_get_toplevel (window) != tmp)
- {
- *ret_valp = MA_NOACTIVATEANDEAT;
- return_val = TRUE;
- }
+ *ret_valp = MA_NOACTIVATEANDEAT;
+ return_val = TRUE;
}
}
if (grab_window == NULL && LOWORD (msg->lParam) != HTCLIENT)
break;
- if (grab_window != NULL && p_grab_cursor != NULL)
- hcursor = p_grab_cursor;
+ if (grab_window != NULL && _gdk_win32_grab_cursor != NULL)
+ hcursor = _gdk_win32_grab_cursor;
else if (!GDK_WINDOW_DESTROYED (window))
hcursor = GDK_WINDOW_IMPL_WIN32 (window->impl)->hcursor;
else
gdk_pointer_ungrab (msg->time);
}
- if (keyboard_grab->window == window)
+ if (keyboard_grab != NULL &&
+ keyboard_grab->window == window)
gdk_keyboard_ungrab (msg->time);
}
!IsIconic (msg->hwnd) &&
!GDK_WINDOW_DESTROYED (window))
_gdk_win32_emit_configure_event (window);
-
- if (window->extension_events != 0)
- _gdk_device_wintab_update_window_coords (window);
}
if ((windowpos->flags & SWP_HIDEWINDOW) &&
* but we still need to deal with alt-tab, or with SetActiveWindow() type
* situations.
*/
- if (is_modally_blocked (window) && LOWORD (msg->wParam) == WA_ACTIVE)
+ if (_gdk_modal_blocked (window) && LOWORD (msg->wParam) == WA_ACTIVE)
{
GdkWindow *modal_current = _gdk_modal_current ();
SetActiveWindow (GDK_WINDOW_HWND (modal_current));
break;
}
+ if (LOWORD (msg->wParam) == WA_INACTIVE)
+ gdk_synthesize_window_state (window, GDK_WINDOW_STATE_FOCUSED, 0);
+ else
+ gdk_synthesize_window_state (window, 0, GDK_WINDOW_STATE_FOCUSED);
+
/* Bring any tablet contexts to the top of the overlap order when
* one of our windows is activated.
* NOTE: It doesn't seem to work well if it is done in WM_ACTIVATEAPP
{
gboolean retval;
- GDK_THREADS_ENTER ();
+ gdk_threads_enter ();
*timeout = -1;
- retval = (_gdk_event_queue_find_first (_gdk_display) != NULL ||
- (modal_win32_dialog == NULL &&
- GetQueueStatus (QS_ALLINPUT) != 0));
+ if (_gdk_display->event_pause_count > 0)
+ retval = FALSE;
+ else
+ retval = (_gdk_event_queue_find_first (_gdk_display) != NULL ||
+ (modal_win32_dialog == NULL &&
+ GetQueueStatus (QS_ALLINPUT) != 0));
- GDK_THREADS_LEAVE ();
+ gdk_threads_leave ();
return retval;
}
{
gboolean retval;
- GDK_THREADS_ENTER ();
-
- if (event_poll_fd.revents & G_IO_IN)
- {
- retval = (_gdk_event_queue_find_first (_gdk_display) != NULL ||
- (modal_win32_dialog == NULL &&
- GetQueueStatus (QS_ALLINPUT) != 0));
- }
+ gdk_threads_enter ();
+
+ if (_gdk_display->event_pause_count > 0)
+ retval = FALSE;
+ else if (event_poll_fd.revents & G_IO_IN)
+ retval = (_gdk_event_queue_find_first (_gdk_display) != NULL ||
+ (modal_win32_dialog == NULL &&
+ GetQueueStatus (QS_ALLINPUT) != 0));
else
- {
- retval = FALSE;
- }
+ retval = FALSE;
- GDK_THREADS_LEAVE ();
+ gdk_threads_leave ();
return retval;
}
{
GdkEvent *event;
- GDK_THREADS_ENTER ();
+ gdk_threads_enter ();
_gdk_win32_display_queue_events (_gdk_display);
event = _gdk_event_unqueue (_gdk_display);
}
}
- GDK_THREADS_LEAVE ();
+ gdk_threads_leave ();
return TRUE;
}
{
modal_win32_dialog = window;
}
-
-static gboolean
-is_modally_blocked (GdkWindow *window)
-{
- GdkWindow *modal_current = _gdk_modal_current ();
- return modal_current != NULL ? gdk_window_get_toplevel (window) != modal_current : FALSE;
-}
-
-void
-_gdk_win32_display_sync (GdkDisplay * display)
-{
- MSG msg;
-
- g_return_if_fail (display == _gdk_display);
-
- /* Process all messages currently available */
- while (PeekMessageW (&msg, NULL, 0, 0, PM_REMOVE))
- DispatchMessageW (&msg);
-}
-
projects / ~andy / gtk / blobdiff