From aafaf298f7d8132aca02b3bfcf2340574fc7bfbf Mon Sep 17 00:00:00 2001 From: Paulo Zanoni Date: Mon, 27 Aug 2007 04:43:33 +0000 Subject: Another very big commit... Now it is possible to do "multiple operations" at the same time: dragging/resizing windows with multiple mice, for example. Some bugs corrected. Some other still need to be corrected... svn path=/branches/multiple_pointer_x/; revision=3310 --- src/common.h | 3 +- src/constraints.c | 3 +- src/core.c | 43 ++-- src/core.h | 37 +-- src/devices.c | 74 ++++++ src/devices.h | 52 ++-- src/display.c | 684 ++++++++++++++++++++++++++++---------------------- src/display.h | 11 +- src/edge-resistance.c | 107 ++++---- src/edge-resistance.h | 2 + src/frame.c | 16 +- src/frame.h | 3 +- src/frames.c | 63 +++-- src/keybindings.c | 269 ++++++++++---------- src/screen.c | 18 +- src/screen.h | 6 +- src/window.c | 630 ++++++++++++++++++++++------------------------ src/window.h | 42 +++- src/workspace.c | 15 +- src/workspace.h | 2 + 20 files changed, 1145 insertions(+), 935 deletions(-) diff --git a/src/common.h b/src/common.h index 6845214f..eafe9b3d 100644 --- a/src/common.h +++ b/src/common.h @@ -115,7 +115,8 @@ typedef void (* MetaWindowMenuFunc) (MetaWindowMenu *menu, /* There is now one operation per device pair! Remember! */ typedef enum { - META_GRAB_OP_NONE, + META_GRAB_OP_NONE, /* This should never be zero! When there is no operation, + * dev->grab_op == NULL! */ /* Mouse ops */ META_GRAB_OP_MOVING, diff --git a/src/constraints.c b/src/constraints.c index 2fc98f18..c631e237 100644 --- a/src/constraints.c +++ b/src/constraints.c @@ -1181,7 +1181,8 @@ constrain_titlebar_visible (MetaWindow *window, * clicking on the frame to start the move. */ unconstrained_user_action = - info->is_user_action && !window->display->grab_frame_action; + info->is_user_action /* && !window->display->grab_frame_action*/; + /* FIXME!!!!!!!!!! This breaks stuff!! ^^^^^^^^^^^^^^^^^^^^^^^ */ /* Exit early if we know the constraint won't apply--note that this constraint * is only meant for normal windows (e.g. we don't want docks to be shoved diff --git a/src/core.c b/src/core.c index 06098584..4f81ea22 100644 --- a/src/core.c +++ b/src/core.c @@ -661,47 +661,54 @@ meta_core_end_grab_op (Display *xdisplay, } MetaGrabOp -meta_core_get_grab_op (Display *xdisplay) +meta_core_get_grab_op (Display *xdisplay, XID ptr_id) { MetaDisplay *display; + MetaDevInfo *ptr_dev; display = meta_display_for_x_display (xdisplay); + ptr_dev = meta_devices_find_mouse_by_id (display, ptr_id); - return display->grab_op; + if (ptr_dev->grab_op == NULL) + return META_GRAB_OP_NONE; + else + return ptr_dev->grab_op->op; } Window -meta_core_get_grab_frame (Display *xdisplay) +meta_core_get_grab_frame (Display *xdisplay, XID ptr_id) { MetaDisplay *display; + MetaDevInfo *ptr_dev; display = meta_display_for_x_display (xdisplay); + ptr_dev = meta_devices_find_mouse_by_id (display, ptr_id); g_assert (display != NULL); - g_assert (display->grab_op == META_GRAB_OP_NONE || - display->grab_screen != NULL); - g_assert (display->grab_op == META_GRAB_OP_NONE || - display->grab_screen->display->xdisplay == xdisplay); - - if (display->grab_op != META_GRAB_OP_NONE && - display->grab_window && - display->grab_window->frame) - return display->grab_window->frame->xwindow; - else - return None; -} + if (ptr_dev->grab_op != NULL) + { + g_assert (ptr_dev->grab_op->screen != NULL); + g_assert (ptr_dev->grab_op->screen->display->xdisplay == xdisplay); + + if (ptr_dev->grab_op->window && ptr_dev->grab_op->window->frame) + return ptr_dev->grab_op->window->frame->xwindow; + } + return None; +} int -meta_core_get_grab_button (Display *xdisplay) +meta_core_get_grab_button (Display *xdisplay, XID ptr_id) { MetaDisplay *display; + MetaDevInfo *ptr_dev; display = meta_display_for_x_display (xdisplay); + ptr_dev = meta_devices_find_mouse_by_id (display, ptr_id); - if (display->grab_op == META_GRAB_OP_NONE) + if (ptr_dev->grab_op == NULL) return -1; - return display->grab_button; + return ptr_dev->grab_op->button; } void diff --git a/src/core.h b/src/core.h index 4e0b54c8..e4769383 100644 --- a/src/core.h +++ b/src/core.h @@ -175,23 +175,26 @@ void meta_core_get_menu_accelerator (MetaMenuOp menu_op, unsigned int *keysym, MetaVirtualModifier *modifiers); -gboolean meta_core_begin_grab_op (Display *xdisplay, - MetaDevInfo *dev, - Window frame_xwindow, - MetaGrabOp op, - gboolean pointer_already_grabbed, - gboolean frame_action, - int button, - gulong modmask, - guint32 timestamp, - int root_x, - int root_y); -void meta_core_end_grab_op (Display *xdisplay, - MetaDevInfo *xdev, - guint32 timestamp); -MetaGrabOp meta_core_get_grab_op (Display *xdisplay); -Window meta_core_get_grab_frame (Display *xdisplay); -int meta_core_get_grab_button (Display *xdisplay); +gboolean meta_core_begin_grab_op (Display *xdisplay, + MetaDevInfo *dev, + Window frame_xwindow, + MetaGrabOp op, + gboolean pointer_already_grabbed, + gboolean frame_action, + int button, + gulong modmask, + guint32 timestamp, + int root_x, + int root_y); +void meta_core_end_grab_op (Display *xdisplay, + MetaDevInfo *xdev, + guint32 timestamp); +MetaGrabOp meta_core_get_grab_op (Display *xdisplay, + XID ptr_id); +Window meta_core_get_grab_frame (Display *xdisplay, + XID ptr_id); +int meta_core_get_grab_button (Display *xdisplay, + XID ptr_id); void meta_core_grab_buttons (Display *xdisplay, diff --git a/src/devices.c b/src/devices.c index 54a4eff9..494b254e 100644 --- a/src/devices.c +++ b/src/devices.c @@ -117,4 +117,78 @@ meta_devices_find_paired_keyboard (MetaDisplay *display, XID id) return &display->devices->keyboards[0]; } + +/* This is used to manage lists of devices... + * XXX We should decide a definitive way to do this... + * I don't like this one... */ + +/* XXX We need performance!! Change these into macros?? */ + +void +meta_devices_list_create (MetaDevList *list) +{ + list->devices = g_new (MetaDevInfo*, DEFAULT_INPUT_ARRAY_SIZE); + list->used = 0; + list->size = DEFAULT_INPUT_ARRAY_SIZE; +} + +void +meta_devices_list_destroy (MetaDevList *list) +{ + g_free (list->devices); +} + +gboolean +meta_devices_list_add (MetaDevList *list, MetaDevInfo *dev) +{ + int i; + + for (i = 0; i < list->used; i++) + if (list->devices[i]->xdev->device_id == dev->xdev->device_id) + return FALSE; + + if (list->used == list->size) + { + list->devices = g_renew(MetaDevInfo*, + list->devices, + list->size + DEFAULT_INPUT_ARRAY_SIZE); + list->size += DEFAULT_INPUT_ARRAY_SIZE; + } + + + list->devices[list->used] = dev; + list->used++; + + return TRUE; +} + +gboolean +meta_devices_list_remove (MetaDevList *list, MetaDevInfo *dev) +{ + int i, j; + + for (i = 0; i < list->used; i++) + if (list->devices[i]->xdev->device_id == dev->xdev->device_id) + { + for (j = i; j < (list->used -1); j++) + list->devices[j] = list->devices[j+1]; + list->used--; + return TRUE; + } + + return FALSE; +} + +gboolean +meta_devices_list_is_member (MetaDevList *list, MetaDevInfo *dev) +{ + int i; + + for (i = 0; i < list->used; i++) + if (list->devices[i]->xdev->device_id == dev->xdev->device_id) + return TRUE; + + return FALSE; +} + #endif diff --git a/src/devices.h b/src/devices.h index 9dce947b..46acbc3b 100644 --- a/src/devices.h +++ b/src/devices.h @@ -31,6 +31,10 @@ #include "common.h" #include "boxes.h" +#ifdef HAVE_XSYNC +#include +#endif + /* By default, the MetaDevInfo lists have size 4. Almost no client has more * than 4 mice or keyboards... */ #define DEFAULT_INPUT_ARRAY_SIZE 4 @@ -41,11 +45,11 @@ typedef struct _MetaDevices MetaDevices; typedef struct _MetaGrabOpInfo MetaGrabOpInfo; +typedef struct _MetaDevList MetaDevList; + /* TODO: create MetaPtrInfo and MetaKbdInfo, so that you can differentiate it * and force correct type using in function prototypes */ -#if 0 ---> To be used soon!! (next commit) struct _MetaGrabOpInfo { /* current window operation */ @@ -69,7 +73,7 @@ struct _MetaGrabOpInfo MetaRectangle wireframe_rect; MetaRectangle wireframe_last_xor_rect; MetaRectangle initial_window_pos; - int initial_x, grab_initial_y; /* These are only relevant for */ + int initial_x, initial_y; /* These are only relevant for */ gboolean threshold_movement_reached; /* raise_on_click == FALSE. */ MetaResizePopup *resize_popup; GTimeVal last_moveresize_time; @@ -79,8 +83,12 @@ struct _MetaGrabOpInfo GList* old_window_stacking; MetaEdgeResistanceData *edge_resistance_data; unsigned int last_user_action_was_snap; -}; + int resize_timeout_id; +#ifdef HAVE_XSYNC + /* alarm monitoring client's _NET_WM_SYNC_REQUEST_COUNTER */ + XSyncAlarm sync_request_alarm; #endif +}; struct _MetaDevInfo { @@ -102,20 +110,36 @@ struct _MetaDevices /* TODO: consider creating a structure to store the pairs!! */ }; -MetaDevInfo* meta_devices_find_mouse_by_name (MetaDisplay *display, - gchar *name); +struct _MetaDevList +{ + MetaDevInfo **devices; + int used; + int size; +}; + +MetaDevInfo* meta_devices_find_mouse_by_name (MetaDisplay *display, + gchar *name); + +MetaDevInfo* meta_devices_find_mouse_by_id (MetaDisplay *display, + XID id); -MetaDevInfo* meta_devices_find_mouse_by_id (MetaDisplay *display, - XID id); +MetaDevInfo* meta_devices_find_keyboard_by_id (MetaDisplay *display, + XID id); -MetaDevInfo* meta_devices_find_keyboard_by_id (MetaDisplay *display, - XID id); +MetaDevInfo* meta_devices_find_paired_mouse (MetaDisplay *display, + XID id); -MetaDevInfo* meta_devices_find_paired_mouse (MetaDisplay *display, - XID id); +MetaDevInfo* meta_devices_find_paired_keyboard (MetaDisplay *display, + XID id); +void meta_devices_list_create (MetaDevList *list); +void meta_devices_list_destroy (MetaDevList *list); +gboolean meta_devices_list_add (MetaDevList *list, + MetaDevInfo *dev); +gboolean meta_devices_list_remove (MetaDevList *list, + MetaDevInfo *dev); +gboolean meta_devices_list_is_member (MetaDevList *list, + MetaDevInfo *dev); -MetaDevInfo* meta_devices_find_paired_keyboard (MetaDisplay *display, - XID id); #else #error "This branch will ONLY compile if you enable --enable-mpx!" diff --git a/src/display.c b/src/display.c index ef7b5d7d..da9d60f4 100644 --- a/src/display.c +++ b/src/display.c @@ -376,14 +376,14 @@ meta_display_open (void) display->autoraise_window = NULL; display->focus_window = NULL; display->expected_focus_window = NULL; - display->grab_old_window_stacking = NULL; +// display->grab_old_window_stacking = NULL; display->mouse_mode = TRUE; /* Only relevant for mouse or sloppy focus */ display->allow_terminal_deactivation = TRUE; /* Only relevant for when a terminal has the focus */ #ifdef HAVE_XSYNC - display->grab_sync_request_alarm = None; +// display->grab_sync_request_alarm = None; #endif /* FIXME copy the checks from GDK probably */ @@ -629,20 +629,20 @@ meta_display_open (void) display->current_time = CurrentTime; display->sentinel_counter = 0; - display->grab_resize_timeout_id = 0; - display->grab_have_keyboard = FALSE; +// display->grab_resize_timeout_id = 0; +// display->grab_have_keyboard = FALSE; #ifdef HAVE_XKB display->last_bell_time = 0; #endif - display->grab_op = META_GRAB_OP_NONE; - display->grab_wireframe_active = FALSE; - display->grab_window = NULL; - display->grab_screen = NULL; - display->grab_resize_popup = NULL; +// display->grab_op = META_GRAB_OP_NONE; +// display->grab_wireframe_active = FALSE; +// display->grab_window = NULL; +// display->grab_screen = NULL; +// display->grab_resize_popup = NULL; - display->grab_edge_resistance_data = NULL; +// display->grab_edge_resistance_data = NULL; #ifdef HAVE_XSYNC { @@ -995,6 +995,7 @@ void meta_display_close (MetaDisplay *display, guint32 timestamp) { + int idev; GSList *tmp; if (display->error_traps > 0) @@ -1006,8 +1007,17 @@ meta_display_close (MetaDisplay *display, meta_display_remove_autoraise_callback (display); - if (display->grab_old_window_stacking) - g_list_free (display->grab_old_window_stacking); + + for (idev = 0; idev < display->devices->miceUsed; idev++) + { + if (display->devices->mice[idev].grab_op) + { + if (display->devices->mice[idev].grab_op->old_window_stacking) + g_list_free + (display->devices->mice[idev].grab_op->old_window_stacking); + g_free (display->devices->mice[idev].grab_op); + } + } /* Stop caring about events */ meta_ui_remove_event_func (display->xdisplay, @@ -1558,13 +1568,12 @@ event_callback (XEvent *event, { XDeviceButtonPressedEvent *xdbe; xdbe = (XDeviceButtonPressedEvent *)event; - meta_warning("event_callback: XDeviceButtonPress received... XID = %d\n", - (int)xdbe->deviceid); +// meta_warning("event_callback: XDeviceButtonPress received... XID = %d\n", +// (int)xdbe->deviceid); // return 0; } /* XXX */ -#ifdef MPX if (event->type == display->dev_btn_press_type) { xdbe = (XDeviceButtonPressedEvent *) event; @@ -1573,15 +1582,6 @@ event_callback (XEvent *event, xdbe->button == 5) return FALSE; } -#else - if (event->type == ButtonPress) - { - /* filter out scrollwheel */ - if (event->xbutton.button == 4 || - event->xbutton.button == 5) - return FALSE; - } -#endif else if (event->type == UnmapNotify) { if (meta_ui_window_should_not_cause_focus (display->xdisplay, @@ -1593,16 +1593,29 @@ event_callback (XEvent *event, event->xany.serial); } } +#ifdef MPX + else if (event->type == display->dev_leave_notify_type && + ((XDeviceCrossingEvent*)event)->mode == NotifyUngrab && + modified == display->ungrab_should_not_cause_focus_window) + { + add_ignored_serial (display, ((XDeviceCrossingEvent*)event)->serial); + meta_topic (META_DEBUG_FOCUS, + "Adding LeaveNotify serial %lu to ignored focus serials\n", + ((XDeviceCrossingEvent*)event)->serial); + } + +#else else if (event->type == LeaveNotify && event->xcrossing.mode == NotifyUngrab && modified == display->ungrab_should_not_cause_focus_window) { + /* XXX! Use MPX! */ add_ignored_serial (display, event->xany.serial); meta_topic (META_DEBUG_FOCUS, "Adding LeaveNotify serial %lu to ignored focus serials\n", event->xany.serial); } - +#endif if (modified != None) window = meta_display_lookup_x_window (display, modified); else @@ -1636,15 +1649,20 @@ event_callback (XEvent *event, #ifdef HAVE_XSYNC if (META_DISPLAY_HAS_XSYNC (display) && - event->type == (display->xsync_event_base + XSyncAlarmNotify) && - ((XSyncAlarmNotifyEvent*)event)->alarm == display->grab_sync_request_alarm) + event->type == (display->xsync_event_base + XSyncAlarmNotify)) { - filter_out_event = TRUE; /* GTK doesn't want to see this really */ - - if (display->grab_op != META_GRAB_OP_NONE && - display->grab_window != NULL && - grab_op_is_mouse (display->grab_op)) - meta_window_handle_mouse_grab_op_event (display->grab_window, event); + int idev; + + for (idev = 0; idev < display->devices->miceUsed; idev++) + if (display->devices->mice[idev].grab_op) + if (((XSyncAlarmNotifyEvent*)event)->alarm == + display->devices->mice[idev].grab_op->sync_request_alarm) + { + filter_out_event = TRUE; /* GTK doesn't want to see this really */ + if (display->devices->mice[idev].grab_op->window != NULL && + grab_op_is_mouse(display->devices->mice[idev].grab_op->op)) + meta_window_handle_mouse_grab_op_event (display->devices->mice[idev].grab_op->window, event); + } } #endif /* HAVE_XSYNC */ @@ -1849,6 +1867,7 @@ event_callback (XEvent *event, case DestroyNotify: if (window) { + int idev; /* FIXME: It sucks that DestroyNotify events don't come with * a timestamp; could we do something better here? Maybe X * will change one day? @@ -1856,9 +1875,12 @@ event_callback (XEvent *event, guint32 timestamp; timestamp = meta_display_get_current_time_roundtrip (display); - if (display->grab_op != META_GRAB_OP_NONE && - display->grab_window == window) - meta_display_end_grab_op (display, NULL, timestamp); + for (idev = 0; idev < display->devices->miceUsed; idev++) + if (display->devices->mice[idev].grab_op) + if (display->devices->mice[idev].grab_op->window == window) + meta_display_end_grab_op (display, + &display->devices->mice[idev], + timestamp); if (frame_was_receiver) { @@ -1879,6 +1901,8 @@ event_callback (XEvent *event, case UnmapNotify: if (window) { + int idev; + /* FIXME: It sucks that UnmapNotify events don't come with * a timestamp; could we do something better here? Maybe X * will change one day? @@ -1886,11 +1910,14 @@ event_callback (XEvent *event, guint32 timestamp; timestamp = meta_display_get_current_time_roundtrip (display); - if (display->grab_op != META_GRAB_OP_NONE && - display->grab_window == window && - ((window->frame == NULL) || !window->frame->mapped)) - meta_display_end_grab_op (display, NULL, timestamp); /* XXX ? */ - + for (idev = 0; idev < display->devices->miceUsed; idev++) + if (display->devices->mice[idev].grab_op) + if (display->devices->mice[idev].grab_op->window == window && + ((window->frame == NULL) || !window->frame->mapped)) + meta_display_end_grab_op (display, + &display->devices->mice[idev], + timestamp); + if (!frame_was_receiver) { if (window->unmaps_pending == 0) @@ -2137,7 +2164,9 @@ event_callback (XEvent *event, } if (workspace) - meta_workspace_activate (workspace, time); + meta_workspace_activate (workspace, + /* XXX */ &display->devices->keyboards[0], + time); else meta_verbose ("Don't know about workspace %d\n", space); } @@ -2273,34 +2302,39 @@ event_callback (XEvent *event, xdbe = (XDeviceButtonEvent *) event; dev = meta_devices_find_mouse_by_id (display, xdbe->deviceid); - if ((window && - grab_op_is_mouse (display->grab_op) && - display->grab_button != (int) xdbe->button && - display->grab_window == window) || - grab_op_is_keyboard (display->grab_op)) + if (dev->grab_op) { - meta_topic (META_DEBUG_WINDOW_OPS, - "Ending grab op %u on window %s due to button press\n", - display->grab_op, - (display->grab_window ? - display->grab_window->desc : - "none")); - if (GRAB_OP_IS_WINDOW_SWITCH (display->grab_op)) + if ((window && + grab_op_is_mouse (dev->grab_op->op) && + dev->grab_op->button != (int) xdbe->button && + dev->grab_op->window == window) || + grab_op_is_keyboard (dev->grab_op->op)) { - MetaScreen *screen; - meta_topic (META_DEBUG_WINDOW_OPS, - "Syncing to old stack positions.\n"); - screen = - meta_display_screen_for_root (display, xdbe->window); - meta_stack_set_positions (screen->stack, - display->grab_old_window_stacking); - } + meta_topic (META_DEBUG_WINDOW_OPS, + "Ending grab op %u on device %s window %s due to" + " button press\n", + dev->grab_op->op, + dev->name, + (dev->grab_op->window ? + dev->grab_op->window->desc : + "none")); + if (GRAB_OP_IS_WINDOW_SWITCH (dev->grab_op->op)) + { + MetaScreen *screen; + meta_topic (META_DEBUG_WINDOW_OPS, + "Syncing to old stack positions.\n"); + screen = + meta_display_screen_for_root (display, xdbe->window); + meta_stack_set_positions (screen->stack, + dev->grab_op->old_window_stacking); + } - meta_display_end_grab_op (display, - dev, - xdbe->time); + meta_display_end_grab_op (display, + dev, + xdbe->time); + } } - else if (window && display->grab_op == META_GRAB_OP_NONE) + else if (window && dev->grab_op == NULL) { gboolean begin_move = FALSE; unsigned int grab_mask; @@ -2469,20 +2503,33 @@ event_callback (XEvent *event, } else if (event->type == display->dev_btn_release_type) { - meta_warning("recived XDeviceButtonRelease (where is the button press?)\n"); - if (display->grab_window == window && - grab_op_is_mouse (display->grab_op)) - meta_window_handle_mouse_grab_op_event (window, event); +// meta_warning("recived XDeviceButtonRelease (where is the button press?)\n"); + + MetaDevInfo *ptr_dev; + + ptr_dev = meta_devices_find_mouse_by_id (display, + ((XDeviceButtonReleasedEvent*)event)->deviceid); + if (ptr_dev->grab_op) + if (ptr_dev->grab_op->window == window && + grab_op_is_mouse (ptr_dev->grab_op->op)) + meta_window_handle_mouse_grab_op_event (window, event); } else if (event->type == display->dev_motion_notify_type) { // meta_warning("recived XDeviceMotionNotify! display->grab_op = %d, display->grab_window = 0x%x, window = 0x%x\n", display->grab_op, (int)display->grab_window, (int)window); - if (display->grab_window == window && - grab_op_is_mouse (display->grab_op)) - { -// meta_warning("chamando meta_window_handle_mouse_grab_op_event\n"); - meta_window_handle_mouse_grab_op_event (window, event); - } + + MetaDevInfo *ptr_dev; + + ptr_dev = meta_devices_find_mouse_by_id (display, + ((XDeviceMotionEvent*)event)->deviceid); + + if (ptr_dev->grab_op) + if (ptr_dev->grab_op->window == window && + grab_op_is_mouse (ptr_dev->grab_op->op)) + { +// meta_warning("calling meta_window_handle_mouse_grab_op_event\n"); + meta_window_handle_mouse_grab_op_event (window, event); + } } else if (event->type == display->dev_focus_in_type || event->type == display->dev_focus_out_type) @@ -2550,28 +2597,20 @@ event_callback (XEvent *event, else if (event->type == display->dev_enter_notify_type) { XDeviceCrossingEvent *xdce; - - xdce = (XDeviceCrossingEvent *)event; -#if 0 - int idev; MetaDevInfo *dev; - /* XXX make a meta_devices_get_pointer_by_id */ - for (idev = 0; idev < display->devices->miceUsed; idev++) - if (xdce->deviceid == display->devices->mice[idev].xdev->device_id) - dev = &display->devices->mice[idev]; -#endif - MetaDevInfo *dev; - dev = meta_devices_find_mouse_by_id (display, xdce->deviceid); + xdce = (XDeviceCrossingEvent *)event; + dev = meta_devices_find_mouse_by_id (display, xdce->deviceid); -// meta_warning("got a DeviceEnterNotify event!!! woohoo!!!\n"); - if (display->grab_window == window && - grab_op_is_mouse (display->grab_op)) - { - /* Wtf???? This does nothing! */ - meta_window_handle_mouse_grab_op_event (window, event); - break; - } + //meta_warning("got a DeviceEnterNotify event!!! woohoo!!!\n"); + if (dev->grab_op) + if (dev->grab_op->window == window && + grab_op_is_mouse (dev->grab_op->op)) + { + /* XXX Wtf???? This does nothing! FIXME */ + meta_window_handle_mouse_grab_op_event (window, event); + break; + } /* If the mouse switches screens, active the default window on the new * screen; this will make keybindings and workspace-launched items @@ -2663,23 +2702,20 @@ event_callback (XEvent *event, else if (event->type == display->dev_leave_notify_type) { XDeviceCrossingEvent *xdce; + MetaDevInfo *ptr_dev; xdce = (XDeviceCrossingEvent *)event; -// int idev; -// MetaDevInfo *dev; - - /* XXX make a meta_devices_get_pointer_by_id */ -// for (idev = 0; idev < display->devices->miceUsed; idev++) -// if (xdce->deviceid == display->devices->mice[idev].xdev->device_id) -// dev = &display->devices->mice[idev]; - // meta_warning("got a DeviceLeaveNotify event!!! woohoo!!!\n"); + ptr_dev = meta_devices_find_mouse_by_id (display, xdce->deviceid); - if (display->grab_window == window && - grab_op_is_mouse (display->grab_op)) - meta_window_handle_mouse_grab_op_event (window, event); + if (ptr_dev->grab_op) + { + if (ptr_dev->grab_op->window == window && + grab_op_is_mouse (ptr_dev->grab_op->op)) + meta_window_handle_mouse_grab_op_event (window, event); + } else if (window != NULL) { if (window->type == META_WINDOW_DOCK && @@ -2805,9 +2841,9 @@ event_get_modified_window (MetaDisplay *display, if (event->type == display->dev_key_press_type) return ((XDeviceKeyPressedEvent *)event)->window; - if (event->type == display->dev_key_release_type) + else if (event->type == display->dev_key_release_type) return ((XDeviceKeyReleasedEvent *)event)->window; - if (event->type == display->dev_btn_press_type) + else if (event->type == display->dev_btn_press_type) return ((XDeviceButtonPressedEvent *)event)->window; else if (event->type == display->dev_btn_release_type) return ((XDeviceButtonReleasedEvent *)event)->window; @@ -2889,6 +2925,30 @@ event_get_time (MetaDisplay *display, case CirculateRequest: case MappingNotify: default: + if (event->type == display->dev_key_press_type) + return ((XDeviceKeyPressedEvent *)event)->time; + else if (event->type == display->dev_key_release_type) + return ((XDeviceKeyReleasedEvent *)event)->time; + else if (event->type == display->dev_btn_press_type) + return ((XDeviceButtonPressedEvent *)event)->time; + else if (event->type == display->dev_btn_release_type) + return ((XDeviceButtonReleasedEvent *)event)->time; + else if (event->type == display->dev_motion_notify_type) + return ((XDeviceMotionEvent *)event)->time; + else if (event->type == display->dev_ptr_motion_hint_type) + { + meta_warning("received dev_ptr_motion_hint_type event!" + " returning NULL for its time!\n"); + return None; + } + else if (event->type == display->dev_enter_notify_type) + return ((XDeviceEnterWindowEvent *)event)->time; + else if (event->type == display->dev_leave_notify_type) + return ((XDeviceLeaveWindowEvent *)event)->time; + else if (event->type == display->dev_focus_in_type) + return ((XDeviceFocusInEvent *)event)->time; + else if (event->type == display->dev_focus_out_type) + return ((XDeviceFocusOutEvent *)event)->time; return CurrentTime; } } @@ -3552,8 +3612,8 @@ meta_display_set_grab_op_cursor (MetaDisplay *display, { meta_topic (META_DEBUG_WINDOW_OPS, "Error trapped from XChangeActivePointerGrab()\n"); - if (display->grab_have_pointer) - display->grab_have_pointer = FALSE; + if (dev->grab_op->have_pointer) + dev->grab_op->have_pointer = FALSE; } } else @@ -3561,7 +3621,6 @@ meta_display_set_grab_op_cursor (MetaDisplay *display, g_assert (screen != NULL); meta_error_trap_push (display); -#ifdef MPX /* XXX: EnterWindowMask, LeaveWindowMask */ XEventClass evclasses[5]; @@ -3583,31 +3642,26 @@ meta_display_set_grab_op_cursor (MetaDisplay *display, // meta_warning("going to XExtendedGrabDevice now for device named %s\n", // dev->name); - if (XExtendedGrabDevice (display->xdisplay, /* dpy */ - dev->xdev, /* dev */ - grab_xwindow, /* grab_win */ - GrabModeAsync, /* device_mode */ - False, /* ownerEvents */ - screen->xroot, /* confineTo */ - cursor, /* cursor */ - 5, /* event_count */ - evclasses, /* event_list */ - 0, /* generic_event_count */ - NULL) == GrabSuccess ) /* generic_events */ -#endif + if (XExtendedGrabDevice (display->xdisplay, /* dpy */ + dev->xdev, /* dev */ + grab_xwindow, /* grab_win */ + GrabModeAsync, /* device_mode */ + False, /* ownerEvents */ + screen->xroot, /* confineTo */ + cursor, /* cursor */ + 5, /* event_count */ + evclasses, /* event_list */ + 0, /* generic_event_count */ + NULL) == GrabSuccess ) /* generic_events */ { - display->grab_have_pointer = TRUE; -#ifdef MPX + dev->grab_op->have_pointer = TRUE; meta_topic (META_DEBUG_WINDOW_OPS, "XExtendedGrabDevice() returned GrabSuccess\n"); -#endif } else { -#ifdef MPX meta_topic (META_DEBUG_WINDOW_OPS, "XExtendedGrabDevice() failed!\n"); -#endif } meta_error_trap_pop (display, TRUE); } @@ -3635,10 +3689,11 @@ meta_display_begin_grab_op (MetaDisplay *display, int root_y) { - meta_warning("meta_display_begin_grab_op called for device named %s\n", - dev->name); +// meta_warning("meta_display_begin_grab_op called for device named %s\n", +// dev->name); { + /* XXX Debug-only code!!! Don't release this! */ int i; for (i = 0; i < display->devices->keybsUsed; i++) if (dev->xdev->device_id == display->devices->keyboards[i].xdev->device_id) @@ -3663,30 +3718,35 @@ meta_display_begin_grab_op (MetaDisplay *display, } /* meta_topic (META_DEBUG_WINDOW_OPS, */ - meta_warning( - "Doing grab op %u on window %s button %d pointer already grabbed: %d pointer pos %d,%d\n", - op, window ? window->desc : "none", button, pointer_already_grabbed, - root_x, root_y); + meta_warning("Doing grab op %u on device %s window %s button %d pointer" + " already grabbed: %d pointer pos %d,%d\n", + op, dev->name, window ? window->desc : "none", + button, pointer_already_grabbed, + root_x, root_y); - if (display->grab_op != META_GRAB_OP_NONE) + if (dev->grab_op != NULL) { - meta_warning ("Attempt to perform window operation %u on window %s when operation %u on %s already in effect\n", - op, window ? window->desc : "none", display->grab_op, - display->grab_window ? display->grab_window->desc : "none"); + meta_warning ("Attempt to perform window operation %u on device %s" + " window %s when operation %u on %s already in effect\n", + op, dev->name, window ? window->desc : "none", + dev->grab_op->op, + dev->grab_op->window ? dev->grab_op->window->desc : "none"); return FALSE; } + dev->grab_op = g_new0 (MetaGrabOpInfo, 1); + if (window && (meta_grab_op_is_moving (op) || meta_grab_op_is_resizing (op))) { - meta_warning("moving or resizing!\n"); +// meta_warning("moving or resizing!\n"); if (meta_prefs_get_raise_on_click ()) meta_window_raise (window); else { - display->grab_initial_x = root_x; - display->grab_initial_y = root_y; - display->grab_threshold_movement_reached = FALSE; + dev->grab_op->initial_x = root_x; + dev->grab_op->initial_y = root_y; + dev->grab_op->threshold_movement_reached = FALSE; } } @@ -3701,17 +3761,15 @@ meta_display_begin_grab_op (MetaDisplay *display, else grab_xwindow = screen->xroot; - display->grab_have_pointer = FALSE; - if (pointer_already_grabbed) - display->grab_have_pointer = TRUE; + dev->grab_op->have_pointer = TRUE; + else + dev->grab_op->have_pointer = FALSE; -#ifdef MPX meta_display_set_grab_op_cursor (display, screen, dev, op, FALSE, grab_xwindow, timestamp); -#endif - if (!display->grab_have_pointer) + if (!dev->grab_op->have_pointer) { meta_topic (META_DEBUG_WINDOW_OPS, "XExtendedGrabDevice() failed\n"); @@ -3721,84 +3779,83 @@ meta_display_begin_grab_op (MetaDisplay *display, /* Grab keys for keyboard ops and mouse move/resizes; see #126497 */ if (grab_op_is_keyboard (op) || grab_op_is_mouse_only (op)) { -#ifdef MPX - MetaDevInfo *keybDev; + MetaDevInfo *paired_kbd; - keybDev = meta_devices_find_paired_keyboard (display, - dev->xdev->device_id); -#endif + paired_kbd = meta_devices_find_paired_keyboard (display, + dev->xdev->device_id); if (window) - display->grab_have_keyboard = -#ifdef MPX - meta_window_grab_all_keys (window, keybDev, timestamp); -#endif - + dev->grab_op->have_keyboard = meta_window_grab_all_keys (window, + paired_kbd, + timestamp); else - display->grab_have_keyboard = -#ifdef MPX - meta_screen_grab_all_keys (screen, dev, timestamp); -#endif - - if (!display->grab_have_keyboard) + dev->grab_op->have_keyboard = meta_screen_grab_all_keys (screen, + paired_kbd, + timestamp); + /* XXX: make paired_kbd = dev->grab_op here??? */ + if (!dev->grab_op->have_keyboard) { - meta_warning( -/* meta_topic (META_DEBUG_WINDOW_OPS, */ - "grabbing all keys failed, ungrabbing pointer\n"); - XUngrabDevice (display->xdisplay, dev->xdev, timestamp); - display->grab_have_pointer = FALSE; - return FALSE; + meta_warning ( +/* meta_topic (META_DEBUG_WINDOW_OPS, */ + "grabbing all keys failed, ungrabbing pointer\n"); + XExtendedUngrabDevice (display->xdisplay, dev->xdev); + dev->grab_op->have_pointer = FALSE; + g_free(dev->grab_op); + dev->grab_op = NULL; + return FALSE; } + else + paired_kbd->grab_op = dev->grab_op; } - display->grab_op = op; - display->grab_window = window; - display->grab_screen = screen; - display->grab_xwindow = grab_xwindow; - display->grab_button = button; - display->grab_mask = modmask; - display->grab_anchor_root_x = root_x; - display->grab_anchor_root_y = root_y; - display->grab_latest_motion_x = root_x; - display->grab_latest_motion_y = root_y; - display->grab_last_moveresize_time.tv_sec = 0; - display->grab_last_moveresize_time.tv_usec = 0; - display->grab_motion_notify_time = 0; - display->grab_old_window_stacking = NULL; + dev->grab_op->op = op; + dev->grab_op->window = window; + dev->grab_op->screen = screen; + dev->grab_op->xwindow = grab_xwindow; + dev->grab_op->button = button; + dev->grab_op->mask = modmask; + dev->grab_op->anchor_root_x = root_x; + dev->grab_op->anchor_root_y = root_y; + dev->grab_op->latest_motion_x = root_x; + dev->grab_op->latest_motion_y = root_y; + dev->grab_op->last_moveresize_time.tv_sec = 0; + dev->grab_op->last_moveresize_time.tv_usec = 0; + dev->grab_op->motion_notify_time = 0; + dev->grab_op->old_window_stacking = NULL; #ifdef HAVE_XSYNC - display->grab_sync_request_alarm = None; - display->grab_last_user_action_was_snap = FALSE; + dev->grab_op->sync_request_alarm = None; + dev->grab_op->last_user_action_was_snap = FALSE; #endif - display->grab_was_cancelled = FALSE; - display->grab_frame_action = frame_action; + dev->grab_op->was_cancelled = FALSE; + dev->grab_op->frame_action = frame_action; - if (display->grab_resize_timeout_id) + if (dev->grab_op->resize_timeout_id) { - g_source_remove (display->grab_resize_timeout_id); - display->grab_resize_timeout_id = 0; + g_source_remove (dev->grab_op->resize_timeout_id); + dev->grab_op->resize_timeout_id = 0; } - if (display->grab_window) + if (dev->grab_op->window) { - meta_window_get_client_root_coords (display->grab_window, - &display->grab_initial_window_pos); - display->grab_anchor_window_pos = display->grab_initial_window_pos; + meta_window_get_client_root_coords (dev->grab_op->window, + &dev->grab_op->initial_window_pos); + dev->grab_op->anchor_window_pos = dev->grab_op->initial_window_pos; - display->grab_wireframe_active = + dev->grab_op->wireframe_active = (meta_prefs_get_reduced_resources () && !meta_prefs_get_gnome_accessibility ()) && - (meta_grab_op_is_resizing (display->grab_op) || - meta_grab_op_is_moving (display->grab_op)); + (meta_grab_op_is_resizing (dev->grab_op->op) || + meta_grab_op_is_moving (dev->grab_op->op)); - if (display->grab_wireframe_active) + if (dev->grab_op->wireframe_active) { - meta_window_calc_showing (display->grab_window); - meta_window_begin_wireframe (window); + meta_window_calc_showing (dev->grab_op->window); + meta_window_begin_wireframe (window, dev); } #ifdef HAVE_XSYNC - if (!display->grab_wireframe_active && - meta_grab_op_is_resizing (display->grab_op) && - display->grab_window->sync_request_counter != None) + if (!dev->grab_op->wireframe_active && + meta_grab_op_is_resizing (dev->grab_op->op) && + dev->grab_op->window->sync_request_counter != None) { XSyncAlarmAttributes values; XSyncValue init; @@ -3812,17 +3869,17 @@ meta_display_begin_grab_op (MetaDisplay *display, XSyncIntToValue (&init, 0); XSyncSetCounter (display->xdisplay, - display->grab_window->sync_request_counter, init); + dev->grab_op->window->sync_request_counter, init); - display->grab_window->sync_request_serial = 0; - display->grab_window->sync_request_time.tv_sec = 0; - display->grab_window->sync_request_time.tv_usec = 0; + dev->grab_op->window->sync_request_serial = 0; + dev->grab_op->window->sync_request_time.tv_sec = 0; + dev->grab_op->window->sync_request_time.tv_usec = 0; - values.trigger.counter = display->grab_window->sync_request_counter; + values.trigger.counter = dev->grab_op->window->sync_request_counter; values.trigger.value_type = XSyncAbsolute; values.trigger.test_type = XSyncPositiveTransition; XSyncIntToValue (&values.trigger.wait_value, - display->grab_window->sync_request_serial + 1); + dev->grab_op->window->sync_request_serial + 1); /* After triggering, increment test_value by this. * (NOT wait_value above) @@ -3832,21 +3889,21 @@ meta_display_begin_grab_op (MetaDisplay *display, /* we want events (on by default anyway) */ values.events = True; - display->grab_sync_request_alarm = XSyncCreateAlarm (display->xdisplay, - XSyncCACounter | - XSyncCAValueType | - XSyncCAValue | - XSyncCATestType | - XSyncCADelta | - XSyncCAEvents, - &values); + dev->grab_op->sync_request_alarm = XSyncCreateAlarm(display->xdisplay, + XSyncCACounter | + XSyncCAValueType | + XSyncCAValue | + XSyncCATestType | + XSyncCADelta | + XSyncCAEvents, + &values); if (meta_error_trap_pop_with_return (display, FALSE) != Success) - display->grab_sync_request_alarm = None; + dev->grab_op->sync_request_alarm = None; meta_topic (META_DEBUG_RESIZING, "Created update alarm 0x%lx\n", - display->grab_sync_request_alarm); + dev->grab_op->sync_request_alarm); } #endif } @@ -3854,30 +3911,33 @@ meta_display_begin_grab_op (MetaDisplay *display, meta_warning( /* meta_topic (META_DEBUG_WINDOW_OPS, */ "Grab op %u on window %s successful\n", - display->grab_op, window ? window->desc : "(null)"); + dev->grab_op->op, window ? window->desc : "(null)"); - g_assert (display->grab_window != NULL || display->grab_screen != NULL); - g_assert (display->grab_op != META_GRAB_OP_NONE); + g_assert (dev->grab_op->window != NULL || dev->grab_op->screen != NULL); +/* g_assert (display->grab_op != META_GRAB_OP_NONE); XXX */ +/* g_assert (display->grab_op != META_GRAB_OP_UNUSED); XXX */ + /* XXX No need to assert dev->grab_op, because we would have already + * segfaulted if it didn't exist... */ /* If this is a move or resize, cache the window edges for * resistance/snapping */ - if (meta_grab_op_is_resizing (display->grab_op) || - meta_grab_op_is_moving (display->grab_op)) + if (meta_grab_op_is_resizing (dev->grab_op->op) || + meta_grab_op_is_moving (dev->grab_op->op)) { meta_topic (META_DEBUG_WINDOW_OPS, "Computing edges to resist-movement or snap-to for %s.\n", window->desc); - meta_display_compute_resistance_and_snapping_edges (display); + meta_display_compute_resistance_and_snapping_edges (dev); } /* Save the old stacking */ - if (GRAB_OP_IS_WINDOW_SWITCH (display->grab_op)) + if (GRAB_OP_IS_WINDOW_SWITCH (dev->grab_op->op)) { meta_topic (META_DEBUG_WINDOW_OPS, "Saving old stack positions; old pointer was %p.\n", - display->grab_old_window_stacking); - display->grab_old_window_stacking = + dev->grab_op->old_window_stacking); + dev->grab_op->old_window_stacking = meta_stack_get_positions (screen->stack); } @@ -3923,9 +3983,9 @@ meta_warning( break; } - if (display->grab_window) + if (dev->grab_op->window) { - meta_window_refresh_resize_popup (display->grab_window); + meta_window_refresh_resize_popup (dev->grab_op->window, dev); } return TRUE; @@ -3937,24 +3997,34 @@ meta_display_end_grab_op (MetaDisplay *display, guint32 timestamp) { -// meta_warning("meta_display_end_grab_op called for device named %s\n", -// dev->name); + meta_warning("meta_display_end_grab_op called for device named %s\n", + dev->name); MetaDevInfo *pairedKbd; meta_topic (META_DEBUG_WINDOW_OPS, - "Ending grab op %u at time %u\n", display->grab_op, timestamp); + "Ending grab op %u device %s at time %u\n", + dev->grab_op->op, dev->name, timestamp); - if (display->grab_op == META_GRAB_OP_NONE) + if (dev->grab_op == NULL) return; - if (display->grab_window != NULL) - display->grab_window->shaken_loose = FALSE; + { + /* debugging only!!!!!! */ + if (dev->grab_op->op == META_GRAB_OP_NONE) + { + meta_warning("found META_GRAB_OP_NONE!!!!!!!\n"); + sleep (60); + } + } + + if (dev->grab_op->window != NULL) + dev->grab_op->window->shaken_loose = FALSE; - if (display->grab_window != NULL && + if (dev->grab_op->window != NULL && !meta_prefs_get_raise_on_click () && - (meta_grab_op_is_moving (display->grab_op) || - meta_grab_op_is_resizing (display->grab_op))) + (meta_grab_op_is_moving (dev->grab_op->op) || + meta_grab_op_is_resizing (dev->grab_op->op))) { /* Only raise the window in orthogonal raise * ('do-not-raise-on-click') mode if the user didn't try to move @@ -3962,142 +4032,146 @@ meta_display_end_grab_op (MetaDisplay *display, * For raise on click mode, the window was raised at the * beginning of the grab_op. */ - if (!display->grab_threshold_movement_reached) - meta_window_raise (display->grab_window); + if (!dev->grab_op->threshold_movement_reached) + meta_window_raise (dev->grab_op->window); } - if (GRAB_OP_IS_WINDOW_SWITCH (display->grab_op) || - display->grab_op == META_GRAB_OP_KEYBOARD_WORKSPACE_SWITCHING) + if (GRAB_OP_IS_WINDOW_SWITCH (dev->grab_op->op) || + dev->grab_op->op == META_GRAB_OP_KEYBOARD_WORKSPACE_SWITCHING) { - meta_ui_tab_popup_free (display->grab_screen->tab_popup); - display->grab_screen->tab_popup = NULL; + meta_ui_tab_popup_free (dev->grab_op->screen->tab_popup); + dev->grab_op->screen->tab_popup = NULL; /* If the ungrab here causes an EnterNotify, ignore it for * sloppy focus */ - display->ungrab_should_not_cause_focus_window = display->grab_xwindow; + display->ungrab_should_not_cause_focus_window = dev->grab_op->xwindow; } /* If this was a move or resize clear out the edge cache */ - if (meta_grab_op_is_resizing (display->grab_op) || - meta_grab_op_is_moving (display->grab_op)) + if (meta_grab_op_is_resizing (dev->grab_op->op) || + meta_grab_op_is_moving (dev->grab_op->op)) { meta_topic (META_DEBUG_WINDOW_OPS, "Clearing out the edges for resistance/snapping"); - meta_display_cleanup_edges (display); + meta_display_cleanup_edges (dev); } - if (display->grab_old_window_stacking != NULL) + if (dev->grab_op->old_window_stacking != NULL) { meta_topic (META_DEBUG_WINDOW_OPS, "Clearing out the old stack position, which was %p.\n", - display->grab_old_window_stacking); - g_list_free (display->grab_old_window_stacking); - display->grab_old_window_stacking = NULL; + dev->grab_op->old_window_stacking); + g_list_free (dev->grab_op->old_window_stacking); + dev->grab_op->old_window_stacking = NULL; } - if (display->grab_wireframe_active) + if (dev->grab_op->wireframe_active) { - display->grab_wireframe_active = FALSE; - meta_window_end_wireframe (display->grab_window); + dev->grab_op->wireframe_active = FALSE; + meta_window_end_wireframe (dev->grab_op->window, dev); - if (!display->grab_was_cancelled) + if (!dev->grab_op->was_cancelled) { - if (meta_grab_op_is_moving (display->grab_op)) - meta_window_move (display->grab_window, + if (meta_grab_op_is_moving (dev->grab_op->op)) + meta_window_move (dev->grab_op->window, dev, TRUE, - display->grab_wireframe_rect.x, - display->grab_wireframe_rect.y); - if (meta_grab_op_is_resizing (display->grab_op)) - meta_window_resize_with_gravity (display->grab_window, + dev->grab_op->wireframe_rect.x, + dev->grab_op->wireframe_rect.y); + if (meta_grab_op_is_resizing (dev->grab_op->op)) + meta_window_resize_with_gravity (dev->grab_op->window, dev, TRUE, - display->grab_wireframe_rect.width, - display->grab_wireframe_rect.height, - meta_resize_gravity_from_grab_op (display->grab_op)); + dev->grab_op->wireframe_rect.width, + dev->grab_op->wireframe_rect.height, + meta_resize_gravity_from_grab_op (dev->grab_op->op)); } - meta_window_calc_showing (display->grab_window); + meta_window_calc_showing (dev->grab_op->window); } if (display->compositor && - display->grab_window && - grab_op_is_mouse (display->grab_op) && - meta_grab_op_is_moving (display->grab_op)) + dev->grab_op->window && + grab_op_is_mouse (dev->grab_op->op) && + meta_grab_op_is_moving (dev->grab_op->op)) { meta_compositor_end_move (display->compositor, - display->grab_window); + dev->grab_op->window); } - if (display->grab_have_pointer) + if (dev->grab_op->have_pointer) { meta_topic (META_DEBUG_WINDOW_OPS, - "Ungrabbing pointer with timestamp %u\n", timestamp); + "Ungrabbing pointer %s with timestamp %u\n", + dev->name, timestamp); XExtendedUngrabDevice (display->xdisplay, dev->xdev); } - if (display->grab_have_keyboard) + if (dev->grab_op->have_keyboard) { -#if 0 - int idev; - for (idev = 0; idev < display->devices->keybsUsed; idev++) - if (&display->devices->pairedPointers[idev] == dev) - pairedKbd = &display->devices->keyboards[idev]; - if (pairedKbd == NULL) - meta_warning("we have a pointer with no associated keyboard!!\n"); /* XXX */ -#endif + /* XXX: there can be more than one keyboard paired with the same mouse! */ pairedKbd = meta_devices_find_paired_keyboard (display, dev->xdev->device_id); meta_topic (META_DEBUG_WINDOW_OPS, "Ungrabbing all keys timestamp %u\n", timestamp); - if (display->grab_window) - meta_window_ungrab_all_keys (display->grab_window, + if (dev->grab_op->window) + meta_window_ungrab_all_keys (dev->grab_op->window, pairedKbd, timestamp); else - meta_screen_ungrab_all_keys (display->grab_screen, + meta_screen_ungrab_all_keys (dev->grab_op->screen, pairedKbd, timestamp); + + pairedKbd->grab_op = NULL; } #ifdef HAVE_XSYNC - if (display->grab_sync_request_alarm != None) + if (dev->grab_op->sync_request_alarm != None) { XSyncDestroyAlarm (display->xdisplay, - display->grab_sync_request_alarm); - display->grab_sync_request_alarm = None; + dev->grab_op->sync_request_alarm); + dev->grab_op->sync_request_alarm = None; } #endif /* HAVE_XSYNC */ - display->grab_window = NULL; - display->grab_screen = NULL; - display->grab_xwindow = None; - display->grab_op = META_GRAB_OP_NONE; + dev->grab_op->window = NULL; + dev->grab_op->screen = NULL; + dev->grab_op->xwindow = None; +/* dev->grab_op->op = META_GRAB_OP_NONE; */ - if (display->grab_resize_popup) + if (dev->grab_op->resize_popup) { - meta_ui_resize_popup_free (display->grab_resize_popup); - display->grab_resize_popup = NULL; + meta_ui_resize_popup_free (dev->grab_op->resize_popup); + dev->grab_op->resize_popup = NULL; } - if (display->grab_resize_timeout_id) + if (dev->grab_op->resize_timeout_id) { - g_source_remove (display->grab_resize_timeout_id); - display->grab_resize_timeout_id = 0; + g_source_remove (dev->grab_op->resize_timeout_id); + dev->grab_op->resize_timeout_id = 0; } + + g_free (dev->grab_op); + dev->grab_op = NULL; } void meta_display_check_threshold_reached (MetaDisplay *display, + MetaDevInfo *ptr_dev, int x, int y) { /* Don't bother doing the check again if we've already reached the threshold */ - if (meta_prefs_get_raise_on_click () || - display->grab_threshold_movement_reached) - return; - if (ABS (display->grab_initial_x - x) >= 8 || - ABS (display->grab_initial_y - y) >= 8) - display->grab_threshold_movement_reached = TRUE; + if (ptr_dev->grab_op) + { + if (meta_prefs_get_raise_on_click () || + ptr_dev->grab_op->threshold_movement_reached) + return; + + if (ABS (ptr_dev->grab_op->initial_x - x) >= 8 || + ABS (ptr_dev->grab_op->initial_y - y) >= 8) + ptr_dev->grab_op->threshold_movement_reached = TRUE; + } } static void diff --git a/src/display.h b/src/display.h index 075bdd6e..a3ee66ce 100644 --- a/src/display.h +++ b/src/display.h @@ -254,7 +254,7 @@ struct _MetaDisplay /* Alt+click button grabs */ unsigned int window_grab_modifiers; -//#if 0 +#if 0 /* current window operation */ MetaGrabOp grab_op; MetaScreen *grab_screen; @@ -286,7 +286,7 @@ struct _MetaDisplay GList* grab_old_window_stacking; MetaEdgeResistanceData *grab_edge_resistance_data; unsigned int grab_last_user_action_was_snap; -//#endif +#endif /* we use property updates as sentinels for certain window focus events * to avoid some race conditions on EnterNotify events @@ -297,11 +297,13 @@ struct _MetaDisplay int xkb_base_event_type; guint32 last_bell_time; #endif +#if 0 #ifdef HAVE_XSYNC /* alarm monitoring client's _NET_WM_SYNC_REQUEST_COUNTER */ XSyncAlarm grab_sync_request_alarm; #endif int grab_resize_timeout_id; +#endif /* Keybindings stuff */ MetaKeyBinding *screen_bindings; @@ -510,6 +512,7 @@ void meta_display_end_grab_op (MetaDisplay *display, guint32 timestamp); void meta_display_check_threshold_reached (MetaDisplay *display, + MetaDevInfo *ptr_dev, int x, int y); void meta_display_grab_window_buttons (MetaDisplay *display, @@ -527,8 +530,8 @@ void meta_display_ungrab_focus_window_button (MetaDisplay *display, MetaDevInfo *dev); /* Next two functions are defined in edge-resistance.c */ -void meta_display_compute_resistance_and_snapping_edges (MetaDisplay *display); -void meta_display_cleanup_edges (MetaDisplay *display); +void meta_display_compute_resistance_and_snapping_edges (MetaDevInfo *dev); +void meta_display_cleanup_edges (MetaDevInfo *dev); /* make a request to ensure the event serial has changed */ void meta_display_increment_event_serial (MetaDisplay *display); diff --git a/src/edge-resistance.c b/src/edge-resistance.c index d5c60112..d72728e0 100644 --- a/src/edge-resistance.c +++ b/src/edge-resistance.c @@ -29,13 +29,13 @@ /* A simple macro for whether a given window's edges are potentially * relevant for resistance/snapping during a move/resize operation */ -#define WINDOW_EDGES_RELEVANT(window, display) \ - meta_window_should_be_showing (window) && \ - window->screen == display->grab_screen && \ - window != display->grab_window && \ - window->type != META_WINDOW_DESKTOP && \ - window->type != META_WINDOW_MENU && \ - window->type != META_WINDOW_SPLASHSCREEN +#define WINDOW_EDGES_RELEVANT(c_window, dev) \ + meta_window_should_be_showing (c_window) && \ + c_window->screen == dev->grab_op->screen && \ + c_window != dev->grab_op->window && \ + c_window->type != META_WINDOW_DESKTOP && \ + c_window->type != META_WINDOW_MENU && \ + c_window->type != META_WINDOW_SPLASHSCREEN struct ResistanceDataForAnEdge { @@ -46,6 +46,7 @@ struct ResistanceDataForAnEdge GSourceFunc timeout_func; MetaWindow *window; int keyboard_buildup; + MetaDevInfo *dev; /* XXX This is a hack! Remove it from here! XXX */ }; typedef struct ResistanceDataForAnEdge ResistanceDataForAnEdge; @@ -312,16 +313,23 @@ static gboolean edge_resistance_timeout (gpointer data) { ResistanceDataForAnEdge *resistance_data = data; + ResizeMoveTimeoutData *rmtd; + + rmtd = g_new (ResizeMoveTimeoutData, 1); + + rmtd->window = resistance_data->window; + rmtd->dev = resistance_data->dev; resistance_data->timeout_over = TRUE; resistance_data->timeout_id = 0; - (*resistance_data->timeout_func)(resistance_data->window); + (*resistance_data->timeout_func)(rmtd); return FALSE; } static int apply_edge_resistance (MetaWindow *window, + MetaDevInfo *dev, int old_pos, int new_pos, const MetaRectangle *old_rect, @@ -433,6 +441,7 @@ apply_edge_resistance (MetaWindow *window, if (!resistance_data->timeout_setup && timeout_length_ms != 0) { + resistance_data->dev = dev; resistance_data->timeout_id = g_timeout_add (timeout_length_ms, edge_resistance_timeout, @@ -535,7 +544,8 @@ apply_edge_snapping (int old_pos, * function will cause a crash. */ static gboolean -apply_edge_resistance_to_each_side (MetaDisplay *display, +/* Do we really need the display here?? FIXME */ +apply_edge_resistance_to_each_side (MetaDevInfo *dev, MetaWindow *window, const MetaRectangle *old_outer, MetaRectangle *new_outer, @@ -549,8 +559,9 @@ apply_edge_resistance_to_each_side (MetaDisplay *display, gboolean modified; int new_left, new_right, new_top, new_bottom; - g_assert (display->grab_edge_resistance_data != NULL); - edge_data = display->grab_edge_resistance_data; + g_assert (dev->grab_op); + g_assert (dev->grab_op->edge_resistance_data != NULL); + edge_data = dev->grab_op->edge_resistance_data; if (auto_snap) { @@ -597,6 +608,7 @@ apply_edge_resistance_to_each_side (MetaDisplay *display, { /* Now, apply the normal horizontal edge resistance */ new_left = apply_edge_resistance (window, + dev, BOX_LEFT (*old_outer), BOX_LEFT (*new_outer), old_outer, @@ -607,6 +619,7 @@ apply_edge_resistance_to_each_side (MetaDisplay *display, TRUE, keyboard_op); new_right = apply_edge_resistance (window, + dev, BOX_RIGHT (*old_outer), BOX_RIGHT (*new_outer), old_outer, @@ -626,6 +639,7 @@ apply_edge_resistance_to_each_side (MetaDisplay *display, if (!is_resize || window->size_hints.height_inc == 1) { new_top = apply_edge_resistance (window, + dev, BOX_TOP (*old_outer), BOX_TOP (*new_outer), old_outer, @@ -636,6 +650,7 @@ apply_edge_resistance_to_each_side (MetaDisplay *display, FALSE, keyboard_op); new_bottom = apply_edge_resistance (window, + dev, BOX_BOTTOM (*old_outer), BOX_BOTTOM (*new_outer), old_outer, @@ -664,10 +679,10 @@ apply_edge_resistance_to_each_side (MetaDisplay *display, } void -meta_display_cleanup_edges (MetaDisplay *display) +meta_display_cleanup_edges (MetaDevInfo *dev) { guint i,j; - MetaEdgeResistanceData *edge_data = display->grab_edge_resistance_data; + MetaEdgeResistanceData *edge_data = dev->grab_op->edge_resistance_data; GHashTable *edges_to_be_freed; g_assert (edge_data != NULL); @@ -744,8 +759,8 @@ meta_display_cleanup_edges (MetaDisplay *display) edge_data->bottom_data.timeout_id != 0) g_source_remove (edge_data->bottom_data.timeout_id); - g_free (display->grab_edge_resistance_data); - display->grab_edge_resistance_data = NULL; + g_free (dev->grab_op->edge_resistance_data); + dev->grab_op->edge_resistance_data = NULL; } static int @@ -758,7 +773,7 @@ stupid_sort_requiring_extra_pointer_dereference (gconstpointer a, } static void -cache_edges (MetaDisplay *display, +cache_edges (MetaDevInfo *dev, GList *window_edges, GList *xinerama_edges, GList *screen_edges) @@ -842,9 +857,9 @@ cache_edges (MetaDisplay *display, /* * 2nd: Allocate the edges */ - g_assert (display->grab_edge_resistance_data == NULL); - display->grab_edge_resistance_data = g_new (MetaEdgeResistanceData, 1); - edge_data = display->grab_edge_resistance_data; + g_assert (dev->grab_op->edge_resistance_data == NULL); + dev->grab_op->edge_resistance_data = g_new (MetaEdgeResistanceData, 1); + edge_data = dev->grab_op->edge_resistance_data; edge_data->left_edges = g_array_sized_new (FALSE, FALSE, sizeof(MetaEdge*), @@ -911,20 +926,20 @@ cache_edges (MetaDisplay *display, * avoided this sort by sticking them into the array with some simple * merging of the lists). */ - g_array_sort (display->grab_edge_resistance_data->left_edges, + g_array_sort (dev->grab_op->edge_resistance_data->left_edges, stupid_sort_requiring_extra_pointer_dereference); - g_array_sort (display->grab_edge_resistance_data->right_edges, + g_array_sort (dev->grab_op->edge_resistance_data->right_edges, stupid_sort_requiring_extra_pointer_dereference); - g_array_sort (display->grab_edge_resistance_data->top_edges, + g_array_sort (dev->grab_op->edge_resistance_data->top_edges, stupid_sort_requiring_extra_pointer_dereference); - g_array_sort (display->grab_edge_resistance_data->bottom_edges, + g_array_sort (dev->grab_op->edge_resistance_data->bottom_edges, stupid_sort_requiring_extra_pointer_dereference); } static void -initialize_grab_edge_resistance_data (MetaDisplay *display) +initialize_grab_edge_resistance_data (MetaDevInfo *dev) { - MetaEdgeResistanceData *edge_data = display->grab_edge_resistance_data; + MetaEdgeResistanceData *edge_data = dev->grab_op->edge_resistance_data; edge_data->left_data.timeout_setup = FALSE; edge_data->right_data.timeout_setup = FALSE; @@ -938,7 +953,7 @@ initialize_grab_edge_resistance_data (MetaDisplay *display) } void -meta_display_compute_resistance_and_snapping_edges (MetaDisplay *display) +meta_display_compute_resistance_and_snapping_edges (MetaDevInfo *dev) { GList *stacked_windows; GList *cur_window_iter; @@ -955,8 +970,8 @@ meta_display_compute_resistance_and_snapping_edges (MetaDisplay *display) * 1st: Get the list of relevant windows, from bottom to top */ stacked_windows = - meta_stack_list_windows (display->grab_screen->stack, - display->grab_screen->active_workspace); + meta_stack_list_windows (dev->grab_op->screen->stack, + dev->grab_op->screen->active_workspace); /* * 2nd: we need to separate that stacked list into a list of windows that @@ -970,7 +985,7 @@ meta_display_compute_resistance_and_snapping_edges (MetaDisplay *display) while (cur_window_iter != NULL) { MetaWindow *cur_window = cur_window_iter->data; - if (WINDOW_EDGES_RELEVANT (cur_window, display)) + if (WINDOW_EDGES_RELEVANT (cur_window, dev)) { MetaRectangle *new_rect; new_rect = g_new (MetaRectangle, 1); @@ -1005,7 +1020,7 @@ meta_display_compute_resistance_and_snapping_edges (MetaDisplay *display) * resistance (note that dock edges are considered screen edges * which are handled separately */ - if (WINDOW_EDGES_RELEVANT (cur_window, display) && + if (WINDOW_EDGES_RELEVANT (cur_window, dev) && cur_window->type != META_WINDOW_DOCK) { GList *new_edges; @@ -1017,7 +1032,7 @@ meta_display_compute_resistance_and_snapping_edges (MetaDisplay *display) * by other windows or DOCKS, but that's handled below). */ meta_rectangle_intersect (&cur_rect, - &display->grab_screen->rect, + &dev->grab_op->screen->rect, &reduced); new_edges = NULL; @@ -1111,16 +1126,16 @@ meta_display_compute_resistance_and_snapping_edges (MetaDisplay *display) * xinerama edges in an array for quick access. Free the edges since * they've been cached elsewhere. */ - cache_edges (display, + cache_edges (dev, edges, - display->grab_screen->active_workspace->xinerama_edges, - display->grab_screen->active_workspace->screen_edges); + dev->grab_op->screen->active_workspace->xinerama_edges, + dev->grab_op->screen->active_workspace->screen_edges); g_list_free (edges); /* * 6th: Initialize the resistance timeouts and buildups */ - initialize_grab_edge_resistance_data (display); + initialize_grab_edge_resistance_data (dev); } /* Note that old_[xy] and new_[xy] are with respect to inner positions of @@ -1128,6 +1143,7 @@ meta_display_compute_resistance_and_snapping_edges (MetaDisplay *display) */ void meta_window_edge_resistance_for_move (MetaWindow *window, + MetaDevInfo *dev, int old_x, int old_y, int *new_x, @@ -1139,11 +1155,11 @@ meta_window_edge_resistance_for_move (MetaWindow *window, MetaRectangle old_outer, proposed_outer, new_outer; gboolean is_resize; - if (window == window->display->grab_window && - window->display->grab_wireframe_active) + if (window == dev->grab_op->window && + dev->grab_op->wireframe_active) { meta_window_get_xor_rect (window, - &window->display->grab_wireframe_rect, + &dev->grab_op->wireframe_rect, &old_outer); } else @@ -1155,9 +1171,9 @@ meta_window_edge_resistance_for_move (MetaWindow *window, proposed_outer.y += (*new_y - old_y); new_outer = proposed_outer; - window->display->grab_last_user_action_was_snap = snap; + dev->grab_op->last_user_action_was_snap = snap; is_resize = FALSE; - if (apply_edge_resistance_to_each_side (window->display, + if (apply_edge_resistance_to_each_side (dev, window, &old_outer, &new_outer, @@ -1221,6 +1237,7 @@ meta_window_edge_resistance_for_move (MetaWindow *window, */ void meta_window_edge_resistance_for_resize (MetaWindow *window, + MetaDevInfo *dev, int old_width, int old_height, int *new_width, @@ -1234,11 +1251,11 @@ meta_window_edge_resistance_for_resize (MetaWindow *window, int proposed_outer_width, proposed_outer_height; gboolean is_resize; - if (window == window->display->grab_window && - window->display->grab_wireframe_active) + if (window == dev->grab_op->window && + dev->grab_op->wireframe_active) { meta_window_get_xor_rect (window, - &window->display->grab_wireframe_rect, + &dev->grab_op->wireframe_rect, &old_outer); } else @@ -1253,9 +1270,9 @@ meta_window_edge_resistance_for_resize (MetaWindow *window, proposed_outer_width, proposed_outer_height); - window->display->grab_last_user_action_was_snap = snap; + dev->grab_op->last_user_action_was_snap = snap; is_resize = TRUE; - if (apply_edge_resistance_to_each_side (window->display, + if (apply_edge_resistance_to_each_side (dev, window, &old_outer, &new_outer, diff --git a/src/edge-resistance.h b/src/edge-resistance.h index 6d0dbe0b..08ab0e0a 100644 --- a/src/edge-resistance.h +++ b/src/edge-resistance.h @@ -27,6 +27,7 @@ #include "window.h" void meta_window_edge_resistance_for_move (MetaWindow *window, + MetaDevInfo *dev, int old_x, int old_y, int *new_x, @@ -35,6 +36,7 @@ void meta_window_edge_resistance_for_move (MetaWindow *window, gboolean snap, gboolean is_keyboard_op); void meta_window_edge_resistance_for_resize (MetaWindow *window, + MetaDevInfo *dev, int old_width, int old_height, int *new_width, diff --git a/src/frame.c b/src/frame.c index 8fb7d012..b4eb7d2b 100644 --- a/src/frame.c +++ b/src/frame.c @@ -118,7 +118,7 @@ meta_window_ensure_frame (MetaWindow *window) XChangeWindowAttributes (window->display->xdisplay, frame->xwindow, CWEventMask, &attrs); #ifdef MPX - meta_warning("vo pega os eventos...\n"); + meta_warning("i'll get the events...\n"); XEventClass *evclasses; int nclasses = 0; @@ -190,7 +190,7 @@ meta_window_ensure_frame (MetaWindow *window) // meta_warning("nclasses == %d\n", nclasses); XSelectExtensionEvent(window->display->xdisplay, frame->xwindow, evclasses, nclasses); - meta_warning("selected the events! stored them in display 0x%x\n", window->display); + meta_warning("selected the events! stored them in display 0x%x\n", (int)window->display); /* g_free(evclasses); XXX */ #endif @@ -413,10 +413,11 @@ update_shape (MetaFrame *frame) } void -meta_frame_sync_to_window (MetaFrame *frame, - int resize_gravity, - gboolean need_move, - gboolean need_resize) +meta_frame_sync_to_window (MetaFrame *frame, + int resize_gravity, + gboolean need_move, + gboolean need_resize, + MetaWindow *grab_window) { if (!(need_move || need_resize)) { @@ -466,8 +467,7 @@ meta_frame_sync_to_window (MetaFrame *frame, /* If we're interactively resizing the frame, repaint * it immediately so we don't start to lag. */ - if (frame->window->display->grab_window == - frame->window) + if (grab_window == frame->window) meta_ui_repaint_frame (frame->window->screen->ui, frame->xwindow); } diff --git a/src/frame.h b/src/frame.h index 859e25af..df24f200 100644 --- a/src/frame.h +++ b/src/frame.h @@ -75,7 +75,8 @@ void meta_frame_calc_geometry (MetaFrame *frame, void meta_frame_sync_to_window (MetaFrame *frame, int gravity, gboolean need_move, - gboolean need_resize); + gboolean need_resize, + MetaWindow *grab_window); void meta_frame_set_screen_cursor (MetaFrame *frame, MetaCursor cursor); diff --git a/src/frames.c b/src/frames.c index b5d2f959..a8b545b7 100644 --- a/src/frames.c +++ b/src/frames.c @@ -25,7 +25,7 @@ #include #include -#include +#include /* I used to use strcmp here! Now I don't anymore! Remove?*/ #include "boxes.h" #include "frames.h" #include "util.h" @@ -1370,8 +1370,8 @@ meta_frames_button_press_event (GtkWidget *widget, GdkEventButton *event) { - meta_warning("meta_frames_button_press_event(): device = %s\n", - event->device->name); +// meta_warning("meta_frames_button_press_event(): device = %s\n", +// event->device->name); MetaUIFrame *frame; MetaFrames *frames; @@ -1429,7 +1429,7 @@ meta_frames_button_press_event (GtkWidget *widget, return meta_frame_double_click_event (frame, event); } - if (meta_core_get_grab_op (gdk_display) != + if (meta_core_get_grab_op (gdk_display, dev->xdev->device_id) != META_GRAB_OP_NONE) return FALSE; /* already up to something */ @@ -1511,6 +1511,9 @@ meta_frames_button_press_event (GtkWidget *widget, MetaFrameGeometry fgeom; GdkRectangle *rect; int dx, dy; + + meta_warning("META_GRAB_OP_CLICKING_MENU for device %s\n", + dev->name); meta_frames_calc_geometry (frames, frame, &fgeom); @@ -1592,7 +1595,6 @@ meta_frames_button_press_event (GtkWidget *widget, event->button, event->time); else { - meta_warning("chamando meta_core_begin_grab_op de onde eu quero\n"); meta_core_begin_grab_op (gdk_display, dev, frame->xwindow, @@ -1647,16 +1649,23 @@ meta_frames_notify_menu_hide (MetaFrames *frames) { /* Begin XXX */ MetaDisplay *display; + int idev; + MetaDevInfo *dev; display = meta_display_for_x_display (gdk_display); + + /* gotta find who clicked the menu... */ + for (idev = 0; idev < display->devices->miceUsed; idev++) + if (meta_core_get_grab_op (gdk_display, display->devices->mice[idev].xdev->device_id) == META_GRAB_OP_CLICKING_MENU) + dev = &display->devices->mice[idev]; /* End XXX */ - if (meta_core_get_grab_op (gdk_display) == + if (meta_core_get_grab_op (gdk_display, dev->xdev->device_id) == /* XXX already done this! */ META_GRAB_OP_CLICKING_MENU) { Window grab_frame; - grab_frame = meta_core_get_grab_frame (gdk_display); + grab_frame = meta_core_get_grab_frame (gdk_display, dev->xdev->device_id); if (grab_frame != None) { @@ -1669,7 +1678,7 @@ meta_frames_notify_menu_hide (MetaFrames *frames) redraw_control (frames, frame, META_FRAME_CONTROL_MENU); meta_core_end_grab_op (gdk_display, - &display->devices->mice[0], + dev, CurrentTime); } } @@ -1687,15 +1696,6 @@ meta_frames_button_release_event (GtkWidget *widget, MetaDevInfo *dev; display = meta_display_for_x_display (gdk_display); -#if 0 - int idev; - for (idev = 0; idev < display->devices->miceUsed; idev++) - if (strcmp(event->device->name, display->devices->mice[idev].name) == 0) - metaDev = &display->devices->mice[idev]; - /* XXX */ - if (metaDev == NULL) - meta_warning("metaDev == null!! problema t meta_frames_button_release\n"); -#endif dev = meta_devices_find_mouse_by_name (display, event->device->name); frames = META_FRAMES (widget); @@ -1706,7 +1706,7 @@ meta_frames_button_release_event (GtkWidget *widget, clear_tip (frames); - op = meta_core_get_grab_op (gdk_display); + op = meta_core_get_grab_op (gdk_display, dev->xdev->device_id); if (op == META_GRAB_OP_NONE) return FALSE; @@ -1715,8 +1715,8 @@ meta_frames_button_release_event (GtkWidget *widget, * involving frame controls). Window ops that don't require a * frame are handled in the Xlib part of the code, display.c/window.c */ - if (frame->xwindow == meta_core_get_grab_frame (gdk_display) && - ((int) event->button) == meta_core_get_grab_button (gdk_display)) + if (frame->xwindow == meta_core_get_grab_frame (gdk_display, dev->xdev->device_id) && + ((int) event->button) == meta_core_get_grab_button (gdk_display, dev->xdev->device_id)) { MetaFrameControl control; @@ -1947,7 +1947,7 @@ meta_frames_motion_notify_event (GtkWidget *widget, frames->last_motion_frame = frame; - grab_op = meta_core_get_grab_op (gdk_display); + grab_op = meta_core_get_grab_op (gdk_display, dev->xdev->device_id); switch (grab_op) { @@ -2365,10 +2365,23 @@ meta_frames_paint_to_drawable (MetaFrames *frames, for (i = 0; i < META_BUTTON_TYPE_LAST; i++) button_states[i] = META_BUTTON_STATE_NORMAL; - grab_frame = meta_core_get_grab_frame (gdk_display); - grab_op = meta_core_get_grab_op (gdk_display); - if (grab_frame != frame->xwindow) - grab_op = META_GRAB_OP_NONE; +// grab_frame = meta_core_get_grab_frame (gdk_display); +// grab_op = meta_core_get_grab_op (gdk_display); + + /* Check if we have any operation on this frame */ + int idev = 0; + MetaDisplay *display; + + grab_op = META_GRAB_OP_NONE; + display = meta_display_for_x_display (gdk_display); + for (idev = 0; idev < display->devices->miceUsed; idev++) + if (display->devices->mice[idev].grab_op) + if (meta_core_get_grab_frame(display->xdisplay, display->devices->mice[idev].xdev->device_id) == frame->xwindow) + grab_op = display->devices->mice[idev].grab_op->op; + /* XXX: if there is more than one operation on this screen, we won't know! */ + +// if (grab_frame != frame->xwindow) +// grab_op = META_GRAB_OP_NONE; /* Set prelight state */ switch (frame->prelit_control) diff --git a/src/keybindings.c b/src/keybindings.c index ecc8b9b6..d3aa9df0 100644 --- a/src/keybindings.c +++ b/src/keybindings.c @@ -1229,10 +1229,10 @@ ungrab_all_keys (MetaDisplay *display, void meta_screen_grab_keys (MetaScreen *screen, MetaDevInfo *dev) { - if (screen->all_keys_grabbed) + if (meta_devices_list_is_member (&screen->all_keys_grabbed, dev)) return; - if (screen->keys_grabbed) + if (meta_devices_list_is_member (&screen->keys_grabbed, dev)) return; grab_keys (dev, @@ -1240,34 +1240,34 @@ meta_screen_grab_keys (MetaScreen *screen, MetaDevInfo *dev) screen->display->n_screen_bindings, screen->display, screen->xroot); - screen->keys_grabbed = TRUE; + meta_devices_list_add (&screen->keys_grabbed, dev); } void meta_screen_ungrab_keys (MetaScreen *screen, MetaDevInfo *dev) { - if (screen->keys_grabbed) + if (meta_devices_list_is_member (&screen->keys_grabbed, dev)) { ungrab_all_keys (screen->display, dev, screen->xroot); - screen->keys_grabbed = FALSE; + meta_devices_list_remove (&screen->keys_grabbed, dev); } } void meta_window_grab_keys (MetaWindow *window, MetaDevInfo *dev) { - if (window->all_keys_grabbed) + if (meta_devices_list_is_member(&window->all_keys_grabbed, dev)) return; if (window->type == META_WINDOW_DOCK) { - if (window->keys_grabbed) + if (meta_devices_list_is_member(&window->keys_grabbed, dev)) ungrab_all_keys (window->display, dev, window->xwindow); - window->keys_grabbed = FALSE; + meta_devices_list_remove (&window->keys_grabbed, dev); return; } - if (window->keys_grabbed) + if (meta_devices_list_is_member (&window->keys_grabbed, dev)) { if (window->frame && !window->grab_on_frame) ungrab_all_keys (window->display, dev, window->xwindow); @@ -1284,14 +1284,14 @@ meta_window_grab_keys (MetaWindow *window, MetaDevInfo *dev) window->display, window->frame ? window->frame->xwindow : window->xwindow); - window->keys_grabbed = TRUE; + meta_devices_list_add (&window->keys_grabbed, dev); window->grab_on_frame = window->frame != NULL; } void meta_window_ungrab_keys (MetaWindow *window, MetaDevInfo *dev) { - if (window->keys_grabbed) + if (meta_devices_list_is_member (&window->keys_grabbed, dev)) { if (window->grab_on_frame && window->frame != NULL) @@ -1301,7 +1301,7 @@ meta_window_ungrab_keys (MetaWindow *window, MetaDevInfo *dev) ungrab_all_keys (window->display, dev, window->xwindow); - window->keys_grabbed = FALSE; + meta_devices_list_remove (&window->keys_grabbed, dev); } } @@ -1349,7 +1349,6 @@ grab_keyboard (MetaDisplay *display, #ifdef MPX /* XXX No event classes?? */ -#warning grabbing stuff with no evclasses grab_status = XGrabDevice (display->xdisplay, dev->xdev, xwindow, @@ -1403,26 +1402,22 @@ ungrab_keyboard (MetaDisplay *display, } gboolean -#ifdef MPX meta_screen_grab_all_keys (MetaScreen *screen, MetaDevInfo *dev, guint32 timestamp) -#else -meta_screen_grab_all_keys (MetaScreen *screen, guint32 timestamp) -#endif { gboolean retval; - if (screen->all_keys_grabbed) + if (meta_devices_list_is_member(&screen->all_keys_grabbed, dev)) return FALSE; - if (screen->keys_grabbed) + if (meta_devices_list_is_member(&screen->keys_grabbed, dev)) meta_screen_ungrab_keys (screen, dev); meta_topic (META_DEBUG_KEYBINDINGS, - "Grabbing all keys on RootWindow\n"); + "Grabbing all keys on RootWindow for device %s\n", dev->name); retval = grab_keyboard (screen->display, dev, screen->xroot, timestamp); if (retval) - screen->all_keys_grabbed = TRUE; + meta_devices_list_add (&screen->all_keys_grabbed, dev); else meta_screen_grab_keys (screen, dev); @@ -1434,12 +1429,12 @@ meta_screen_ungrab_all_keys (MetaScreen *screen, MetaDevInfo *dev, guint32 timestamp) { - if (screen->all_keys_grabbed) + if (meta_devices_list_is_member (&screen->all_keys_grabbed, dev)) { ungrab_keyboard (screen->display, dev, timestamp); - screen->all_keys_grabbed = FALSE; - screen->keys_grabbed = FALSE; + meta_devices_list_remove (&screen->all_keys_grabbed, dev); + meta_devices_list_remove (&screen->keys_grabbed, dev); /* Re-establish our standard bindings */ meta_screen_grab_keys (screen, dev); @@ -1447,22 +1442,17 @@ meta_screen_ungrab_all_keys (MetaScreen *screen, } gboolean -#ifdef MPX meta_window_grab_all_keys (MetaWindow *window, MetaDevInfo *dev, guint32 timestamp) -#else -meta_window_grab_all_keys (MetaWindow *window, - guint32 timestamp) -#endif { Window grabwindow; gboolean retval; - if (window->all_keys_grabbed) + if (meta_devices_list_is_member (&window->all_keys_grabbed, dev)) return FALSE; - if (window->keys_grabbed) + if (meta_devices_list_is_member (&window->keys_grabbed, dev)) meta_window_ungrab_keys (window, dev); /* Make sure the window is focused, otherwise the grab @@ -1477,15 +1467,11 @@ meta_window_grab_all_keys (MetaWindow *window, meta_topic (META_DEBUG_KEYBINDINGS, "Grabbing all keys on window %s\n", window->desc); -#ifdef MPX retval = grab_keyboard (window->display, dev, grabwindow, timestamp); -#else - retval = grab_keyboard (window->display, grabwindow, timestamp); -#endif if (retval) { - window->keys_grabbed = FALSE; - window->all_keys_grabbed = TRUE; + meta_devices_list_remove (&window->keys_grabbed, dev); + meta_devices_list_add (&window->all_keys_grabbed, dev); window->grab_on_frame = window->frame != NULL; } @@ -1499,13 +1485,13 @@ meta_window_ungrab_all_keys (MetaWindow *window, { - if (window->all_keys_grabbed) + if (meta_devices_list_is_member (&window->all_keys_grabbed, dev)) { ungrab_keyboard (window->display, dev, timestamp); window->grab_on_frame = FALSE; - window->all_keys_grabbed = FALSE; - window->keys_grabbed = FALSE; + meta_devices_list_remove (&window->all_keys_grabbed, dev); + meta_devices_list_remove (&window->keys_grabbed, dev); /* Re-establish our standard bindings */ meta_window_grab_keys (window, dev); @@ -1817,7 +1803,9 @@ meta_display_process_key_event (MetaDisplay *display, str ? str : "none", xdke->state, window ? window->desc : "(no window)"); - all_keys_grabbed = window ? window->all_keys_grabbed : screen->all_keys_grabbed; + all_keys_grabbed = window ? + meta_devices_list_is_member(&window->all_keys_grabbed, dev): + meta_devices_list_is_member(&screen->all_keys_grabbed, dev); if (!all_keys_grabbed) { /* Do the normal keybindings */ @@ -1835,7 +1823,7 @@ meta_display_process_key_event (MetaDisplay *display, return; } - if (display->grab_op == META_GRAB_OP_NONE) + if (dev->grab_op == NULL) return; /* If we get here we have a global grab, because @@ -1845,10 +1833,10 @@ meta_display_process_key_event (MetaDisplay *display, handled = FALSE; - if (window ? (window == display->grab_window) : - (screen == display->grab_screen)) + if (window ? (window == dev->grab_op->window) : + (screen == dev->grab_op->screen)) { - switch (display->grab_op) + switch (dev->grab_op->op) { case META_GRAB_OP_MOVING: case META_GRAB_OP_RESIZING_SE: @@ -1916,8 +1904,8 @@ meta_display_process_key_event (MetaDisplay *display, if (!handled) { meta_topic (META_DEBUG_KEYBINDINGS, - "Ending grab op %u on key event sym %s\n", - display->grab_op, XKeysymToString (keysym)); + "Ending grab op %u on device %s key event sym %s\n", + dev->grab_op->op, dev->name, XKeysymToString (keysym)); meta_display_end_grab_op (display, dev, xdke->time); @@ -1953,16 +1941,16 @@ process_mouse_move_resize_grab (MetaDisplay *display, dev, META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL); - else if (!display->grab_wireframe_active) - meta_window_move_resize (display->grab_window, + else if (!dev->grab_op->wireframe_active) + meta_window_move_resize (dev->grab_op->window, dev, TRUE, - display->grab_initial_window_pos.x, - display->grab_initial_window_pos.y, - display->grab_initial_window_pos.width, - display->grab_initial_window_pos.height); + dev->grab_op->initial_window_pos.x, + dev->grab_op->initial_window_pos.y, + dev->grab_op->initial_window_pos.width, + dev->grab_op->initial_window_pos.height); else - display->grab_was_cancelled = TRUE; + dev->grab_op->was_cancelled = TRUE; /* End grab, since this was an "unhandled" keypress */ return FALSE; @@ -2000,10 +1988,10 @@ process_keyboard_move_grab (MetaDisplay *display, if (is_modifier (display, xdke->keycode)) return TRUE; - if (display->grab_wireframe_active) + if (dev->grab_op->wireframe_active) { - x = display->grab_wireframe_rect.x; - y = display->grab_wireframe_rect.y; + x = dev->grab_op->wireframe_rect.x; + y = dev->grab_op->wireframe_rect.y; } else { @@ -2036,16 +2024,16 @@ process_keyboard_move_grab (MetaDisplay *display, dev, META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL); - else if (!display->grab_wireframe_active) - meta_window_move_resize (display->grab_window, + else if (!dev->grab_op->wireframe_active) + meta_window_move_resize (dev->grab_op->window, dev, TRUE, - display->grab_initial_window_pos.x, - display->grab_initial_window_pos.y, - display->grab_initial_window_pos.width, - display->grab_initial_window_pos.height); + dev->grab_op->initial_window_pos.x, + dev->grab_op->initial_window_pos.y, + dev->grab_op->initial_window_pos.width, + dev->grab_op->initial_window_pos.height); else - display->grab_was_cancelled = TRUE; + dev->grab_op->was_cancelled = TRUE; } /* When moving by increments, we still snap to edges if the move @@ -2096,12 +2084,13 @@ process_keyboard_move_grab (MetaDisplay *display, "Computed new window location %d,%d due to keypress\n", x, y); - if (display->grab_wireframe_active) - old_rect = display->grab_wireframe_rect; + if (dev->grab_op->wireframe_active) + old_rect = dev->grab_op->wireframe_rect; else meta_window_get_client_root_coords (window, &old_rect); - meta_window_edge_resistance_for_move (window, + meta_window_edge_resistance_for_move (window, + dev, old_rect.x, old_rect.y, &x, @@ -2110,18 +2099,18 @@ process_keyboard_move_grab (MetaDisplay *display, smart_snap, TRUE); - if (display->grab_wireframe_active) + if (dev->grab_op->wireframe_active) { - meta_window_update_wireframe (window, x, y, - display->grab_wireframe_rect.width, - display->grab_wireframe_rect.height); + meta_window_update_wireframe (window, dev, x, y, + dev->grab_op->wireframe_rect.width, + dev->grab_op->wireframe_rect.height); } else { meta_window_move (window, dev, TRUE, x, y); } - meta_window_update_keyboard_move (window); + meta_window_update_keyboard_move (dev, window); } return handled; @@ -2135,31 +2124,37 @@ process_keyboard_resize_grab_op_change (MetaDisplay *display, KeySym keysym) { gboolean handled; + MetaDevInfo *dev; + + dev = meta_devices_find_keyboard_by_id (display, xdke->deviceid); + + if (!dev->grab_op) + return FALSE; handled = FALSE; - switch (display->grab_op) + switch (dev->grab_op->op) { case META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN: switch (keysym) { case XK_Up: case XK_KP_Up: - display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_N; + dev->grab_op->op = META_GRAB_OP_KEYBOARD_RESIZING_N; handled = TRUE; break; case XK_Down: case XK_KP_Down: - display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_S; + dev->grab_op->op = META_GRAB_OP_KEYBOARD_RESIZING_S; handled = TRUE; break; case XK_Left: case XK_KP_Left: - display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_W; + dev->grab_op->op = META_GRAB_OP_KEYBOARD_RESIZING_W; handled = TRUE; break; case XK_Right: case XK_KP_Right: - display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_E; + dev->grab_op->op = META_GRAB_OP_KEYBOARD_RESIZING_E; handled = TRUE; break; } @@ -2170,12 +2165,12 @@ process_keyboard_resize_grab_op_change (MetaDisplay *display, { case XK_Left: case XK_KP_Left: - display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_W; + dev->grab_op->op = META_GRAB_OP_KEYBOARD_RESIZING_W; handled = TRUE; break; case XK_Right: case XK_KP_Right: - display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_E; + dev->grab_op->op = META_GRAB_OP_KEYBOARD_RESIZING_E; handled = TRUE; break; } @@ -2186,12 +2181,12 @@ process_keyboard_resize_grab_op_change (MetaDisplay *display, { case XK_Left: case XK_KP_Left: - display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_W; + dev->grab_op->op = META_GRAB_OP_KEYBOARD_RESIZING_W; handled = TRUE; break; case XK_Right: case XK_KP_Right: - display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_E; + dev->grab_op->op = META_GRAB_OP_KEYBOARD_RESIZING_E; handled = TRUE; break; } @@ -2202,12 +2197,12 @@ process_keyboard_resize_grab_op_change (MetaDisplay *display, { case XK_Up: case XK_KP_Up: - display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_N; + dev->grab_op->op = META_GRAB_OP_KEYBOARD_RESIZING_N; handled = TRUE; break; case XK_Down: case XK_KP_Down: - display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_S; + dev->grab_op->op = META_GRAB_OP_KEYBOARD_RESIZING_S; handled = TRUE; break; } @@ -2218,12 +2213,12 @@ process_keyboard_resize_grab_op_change (MetaDisplay *display, { case XK_Up: case XK_KP_Up: - display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_N; + dev->grab_op->op = META_GRAB_OP_KEYBOARD_RESIZING_N; handled = TRUE; break; case XK_Down: case XK_KP_Down: - display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_S; + dev->grab_op->op = META_GRAB_OP_KEYBOARD_RESIZING_S; handled = TRUE; break; } @@ -2242,7 +2237,7 @@ process_keyboard_resize_grab_op_change (MetaDisplay *display, if (handled) { - meta_window_update_keyboard_resize (window, TRUE); + meta_window_update_keyboard_resize (dev, window, TRUE); return TRUE; } @@ -2283,16 +2278,16 @@ process_keyboard_resize_grab (MetaDisplay *display, * we need to avoid moveresizing to the position of the * wireframe. */ - if (!display->grab_wireframe_active) - meta_window_move_resize (display->grab_window, + if (!dev->grab_op->wireframe_active) + meta_window_move_resize (dev->grab_op->window, dev, TRUE, - display->grab_initial_window_pos.x, - display->grab_initial_window_pos.y, - display->grab_initial_window_pos.width, - display->grab_initial_window_pos.height); + dev->grab_op->initial_window_pos.x, + dev->grab_op->initial_window_pos.y, + dev->grab_op->initial_window_pos.width, + dev->grab_op->initial_window_pos.height); else - display->grab_was_cancelled = TRUE; + dev->grab_op->was_cancelled = TRUE; return FALSE; } @@ -2301,10 +2296,10 @@ process_keyboard_resize_grab (MetaDisplay *display, xdke, keysym)) return TRUE; - if (display->grab_wireframe_active) + if (dev->grab_op->wireframe_active) { - width = display->grab_wireframe_rect.width; - height = display->grab_wireframe_rect.height; + width = dev->grab_op->wireframe_rect.width; + height = dev->grab_op->wireframe_rect.height; } else { @@ -2312,7 +2307,7 @@ process_keyboard_resize_grab (MetaDisplay *display, height = window->rect.height; } - gravity = meta_resize_gravity_from_grab_op (display->grab_op); + gravity = meta_resize_gravity_from_grab_op (dev->grab_op->op); smart_snap = (xdke->state & ShiftMask) != 0; @@ -2475,13 +2470,14 @@ process_keyboard_resize_grab (MetaDisplay *display, "%dx%d, gravity %s\n", width, height, meta_gravity_to_string (gravity)); - if (display->grab_wireframe_active) - old_rect = display->grab_wireframe_rect; + if (dev->grab_op->wireframe_active) + old_rect = dev->grab_op->wireframe_rect; else old_rect = window->rect; /* Don't actually care about x,y */ /* Do any edge resistance/snapping */ meta_window_edge_resistance_for_resize (window, + dev, old_rect.width, old_rect.height, &width, @@ -2491,15 +2487,15 @@ process_keyboard_resize_grab (MetaDisplay *display, smart_snap, TRUE); - if (display->grab_wireframe_active) + if (dev->grab_op->wireframe_active) { MetaRectangle new_position; - meta_rectangle_resize_with_gravity (&display->grab_wireframe_rect, + meta_rectangle_resize_with_gravity (&dev->grab_op->wireframe_rect, &new_position, gravity, width, height); - meta_window_update_wireframe (window, + meta_window_update_wireframe (window, dev, new_position.x, new_position.y, new_position.width, @@ -2518,7 +2514,7 @@ process_keyboard_resize_grab (MetaDisplay *display, height, gravity); } - meta_window_update_keyboard_resize (window, FALSE); + meta_window_update_keyboard_resize (dev, window, FALSE); } return handled; @@ -2526,16 +2522,16 @@ process_keyboard_resize_grab (MetaDisplay *display, static gboolean end_keyboard_grab (MetaDisplay *display, + MetaDevInfo *dev, unsigned int keycode) { -#warning change end_keyboard_grab prototype? I think no... #ifdef HAVE_XKB if (display->xkb_base_event_type > 0) { unsigned int primary_modifier; XkbStateRec state; - primary_modifier = get_primary_modifier (display, display->grab_mask); + primary_modifier = get_primary_modifier (display, dev->grab_op->mask); XkbGetState (display->xdisplay, XkbUseCoreKbd, &state); @@ -2545,7 +2541,7 @@ end_keyboard_grab (MetaDisplay *display, else #endif { - if (keycode_is_primary_modifier (display, keycode, display->grab_mask)) + if (keycode_is_primary_modifier (display, keycode, dev->grab_op->mask)) return TRUE; } @@ -2565,24 +2561,16 @@ process_tab_grab (MetaDisplay *display, Window prev_xwindow; MetaWindow *prev_window; MetaDevInfo *dev; -#if 0 - int idev; - - xdke = (XDeviceKeyEvent *)event; - - for (idev = 0; idev < display->devices->keybsUsed; idev++) - if (display->devices->keyboards[idev].xdev->device_id == xdke->deviceid) - dev = &display->devices->keyboards[idev]; -#endif + dev = meta_devices_find_keyboard_by_id (display, xdke->deviceid); - if (screen != display->grab_screen) + if (screen != dev->grab_op->screen) return FALSE; g_return_val_if_fail (screen->tab_popup != NULL, FALSE); if (xdke->type == display->dev_key_release_type && - end_keyboard_grab (display, xdke->keycode)) + end_keyboard_grab (display, dev, xdke->keycode)) { /* We're done, move to the new window. */ Window target_xwindow; @@ -2632,7 +2620,7 @@ process_tab_grab (MetaDisplay *display, action = display_get_keybinding_action (display, keysym, xdke->keycode, - display->grab_mask); + dev->grab_op->mask); /* Cancel when alt-Escape is pressed during using alt-Tab, and vice * versa. @@ -2646,7 +2634,7 @@ process_tab_grab (MetaDisplay *display, /* CYCLE_* are traditionally Escape-based actions, * and should cancel traditionally Tab-based ones. */ - switch (display->grab_op) + switch (dev->grab_op->op) { case META_GRAB_OP_KEYBOARD_ESCAPING_NORMAL: case META_GRAB_OP_KEYBOARD_ESCAPING_DOCK: @@ -2663,7 +2651,7 @@ process_tab_grab (MetaDisplay *display, /* SWITCH_* are traditionally Tab-based actions, * and should cancel traditionally Escape-based ones. */ - switch (display->grab_op) + switch (dev->grab_op->op) { case META_GRAB_OP_KEYBOARD_TABBING_NORMAL: case META_GRAB_OP_KEYBOARD_TABBING_DOCK: @@ -2674,7 +2662,7 @@ process_tab_grab (MetaDisplay *display, * we'd previously raised and unminimized. */ meta_stack_set_positions (screen->stack, - screen->display->grab_old_window_stacking); + dev->grab_op->old_window_stacking); if (prev_window && prev_window->tab_unminimized) { meta_window_minimize (prev_window); @@ -2687,7 +2675,7 @@ process_tab_grab (MetaDisplay *display, case META_KEYBINDING_ACTION_CYCLE_GROUP_BACKWARD: case META_KEYBINDING_ACTION_SWITCH_GROUP: case META_KEYBINDING_ACTION_SWITCH_GROUP_BACKWARD: - switch (display->grab_op) + switch (dev->grab_op->op) { case META_GRAB_OP_KEYBOARD_ESCAPING_GROUP: case META_GRAB_OP_KEYBOARD_TABBING_GROUP: @@ -2758,7 +2746,7 @@ process_tab_grab (MetaDisplay *display, MetaWindow *target_window; meta_stack_set_positions (screen->stack, - display->grab_old_window_stacking); + dev->grab_op->old_window_stacking); target_xwindow = (Window) meta_ui_tab_popup_get_selected (screen->tab_popup); @@ -2788,7 +2776,7 @@ process_tab_grab (MetaDisplay *display, meta_topic (META_DEBUG_KEYBINDINGS, "Syncing to old stack positions.\n"); meta_stack_set_positions (screen->stack, - screen->display->grab_old_window_stacking); + dev->grab_op->old_window_stacking); if (prev_window && prev_window->tab_unminimized) { @@ -2809,6 +2797,7 @@ handle_activate_workspace (MetaDisplay *display, { int which; MetaWorkspace *workspace; + MetaDevInfo *dev; which = GPOINTER_TO_INT (binding->handler->data); @@ -2825,7 +2814,8 @@ handle_activate_workspace (MetaDisplay *display, if (workspace) { - meta_workspace_activate (workspace, xdke->time); + dev = meta_devices_find_keyboard_by_id (display, xdke->deviceid); + meta_workspace_activate (workspace, dev, xdke->time); } else { @@ -3213,27 +3203,19 @@ process_workspace_switch_grab (MetaDisplay *display, KeySym keysym) { MetaWorkspace *workspace; -#if 0 - XDeviceKeyEvent *xdke; - MetaDevInfo *dev; - int idev; - - if (screen != display->grab_screen) - return FALSE; - - xdke = (XDeviceKeyEvent *)event; - for (idev = 0; idev < display->devices->keybsUsed; idev++) - if (xdke->deviceid == display->devices->keyboards[idev].xdev->device_id) - dev = &display->devices->keyboards[idev]; -#endif MetaDevInfo *dev; dev = meta_devices_find_keyboard_by_id (display, xdke->deviceid); + if (!dev->grab_op) + return FALSE; + if (screen != dev->grab_op->screen) + return FALSE; + g_return_val_if_fail (screen->tab_popup != NULL, FALSE); if (xdke->type == display->dev_key_release_type && - end_keyboard_grab (display, xdke->keycode)) + end_keyboard_grab (display, dev, xdke->keycode)) { /* We're done, move to the new workspace. */ MetaWorkspace *target_workspace; @@ -3287,7 +3269,7 @@ process_workspace_switch_grab (MetaDisplay *display, action = display_get_keybinding_action (display, keysym, xdke->keycode, - display->grab_mask); + dev->grab_op->mask); switch (action) { @@ -3326,7 +3308,7 @@ process_workspace_switch_grab (MetaDisplay *display, meta_topic (META_DEBUG_KEYBINDINGS, "Activating target workspace\n"); - meta_workspace_activate (target_workspace, xdke->time); + meta_workspace_activate (target_workspace, dev, xdke->time); return TRUE; /* we already ended the grab */ } @@ -3859,6 +3841,7 @@ do_handle_move_to_workspace (MetaDisplay *display, { int which; MetaWorkspace *workspace; + MetaDevInfo *dev; which = GPOINTER_TO_INT (binding->handler->data); @@ -3886,7 +3869,9 @@ do_handle_move_to_workspace (MetaDisplay *display, "Resetting mouse_mode to FALSE due to " "do_handle_move_to_workspace() call with flip set.\n"); workspace->screen->display->mouse_mode = FALSE; + dev = meta_devices_find_keyboard_by_id (display, xdke->deviceid); meta_workspace_activate_with_focus (workspace, + dev, window, xdke->time); } @@ -4061,7 +4046,7 @@ handle_workspace_switch (MetaDisplay *display, meta_display_end_grab_op (display, pairedPtr, xdke->time); } - meta_workspace_activate (next, xdke->time); + meta_workspace_activate (next, kbdDev, xdke->time); if (grabbed_before_release) { diff --git a/src/screen.c b/src/screen.c index adb65008..9a239fcc 100644 --- a/src/screen.c +++ b/src/screen.c @@ -655,13 +655,17 @@ meta_screen_new (MetaDisplay *display, /* Screens must have at least one workspace at all times, * so create that required workspace. */ - meta_workspace_activate (meta_workspace_new (screen), timestamp); + meta_workspace_activate (meta_workspace_new (screen), + &display->devices->keyboards[0], /* XXX */ + timestamp); update_num_workspaces (screen, timestamp); set_workspace_names (screen); - screen->all_keys_grabbed = FALSE; - screen->keys_grabbed = FALSE; +// screen->all_keys_grabbed = FALSE; +// screen->keys_grabbed = FALSE; + meta_devices_list_create (&screen->all_keys_grabbed); + meta_devices_list_create (&screen->keys_grabbed); for (idev = 0; idev < display->devices->keybsUsed; idev++) meta_screen_grab_keys (screen, &display->devices->keyboards[idev]); @@ -694,7 +698,9 @@ meta_screen_new (MetaDisplay *display, current_workspace); if (space != NULL) - meta_workspace_activate (space, timestamp); + meta_workspace_activate (space, + &display->devices->keyboards[0], /* XXX */ + timestamp); } meta_verbose ("Added screen %d ('%s') root 0x%lx\n", @@ -1198,7 +1204,9 @@ update_num_workspaces (MetaScreen *screen, } if (need_change_space) - meta_workspace_activate (last_remaining, timestamp); + meta_workspace_activate (last_remaining, + &screen->display->devices->keyboards[0], /* XXX */ + timestamp); /* Should now be safe to free the workspaces */ tmp = extras; diff --git a/src/screen.h b/src/screen.h index c6cc7f45..33d4b32c 100644 --- a/src/screen.h +++ b/src/screen.h @@ -110,8 +110,10 @@ struct _MetaScreen MetaScreenCorner starting_corner; guint vertical_workspaces : 1; - guint keys_grabbed : 1; - guint all_keys_grabbed : 1; +// guint keys_grabbed : 1; +// guint all_keys_grabbed : 1; + MetaDevList keys_grabbed; + MetaDevList all_keys_grabbed; int closing; diff --git a/src/window.c b/src/window.c index 807b10ac..a080becc 100644 --- a/src/window.c +++ b/src/window.c @@ -106,6 +106,7 @@ static void update_move (MetaWindow *window, int y); static gboolean update_move_timeout (gpointer data); static void update_resize (MetaWindow *window, + MetaDevInfo *dev, gboolean snap, int x, int y, @@ -493,9 +494,11 @@ meta_window_new_with_attrs (MetaDisplay *display, window->denied_focus_and_not_transient = FALSE; window->unmanaging = FALSE; window->is_in_queues = 0; - window->keys_grabbed = FALSE; +// window->keys_grabbed = FALSE; + meta_devices_list_create (&window->keys_grabbed); window->grab_on_frame = FALSE; - window->all_keys_grabbed = FALSE; +// window->all_keys_grabbed = FALSE; + meta_devices_list_create (&window->all_keys_grabbed); window->withdrawn = FALSE; window->initial_workspace_set = FALSE; window->initial_timestamp_set = FALSE; @@ -1025,9 +1028,9 @@ meta_window_free (MetaWindow *window, "Focusing default window since expected focus window freed %s\n", window->desc); window->display->expected_focus_window = NULL; - for (idev = 0; idev < window->display->devices->keybsUsed; idev++) + for (idev = 0; idev < window->focused_devices_used; idev++) meta_workspace_focus_default_window (window->screen->active_workspace, - &window->display->devices->keyboards[idev], + window->focused_devices[idev], window, timestamp); } @@ -1048,11 +1051,15 @@ meta_window_free (MetaWindow *window, window->desc); invalidate_work_areas (window); } - - if (window->display->grab_window == window) - meta_display_end_grab_op (window->display, NULL, timestamp); + + for (idev = 0; idev < window->display->devices->miceUsed; idev++) + if (window->display->devices->mice[idev].grab_op) + if (window->display->devices->mice[idev].grab_op->window == window) + meta_display_end_grab_op (window->display, + &window->display->devices->mice[idev], + timestamp); - g_assert (window->display->grab_window != window); +// g_assert (window->display->grab_window != window); if (window->display->focus_window == window) window->display->focus_window = NULL; @@ -1132,6 +1139,7 @@ meta_window_free (MetaWindow *window, } for (idev = 0; idev < window->display->devices->keybsUsed; idev++) +#warning UNGRAB STUFF HERE!!! { meta_window_ungrab_keys (window, &window->display->devices->keyboards[idev]); @@ -2593,10 +2601,10 @@ meta_window_unmaximize (MetaWindow *window, * the workspace, since that's where it was when the grab op * started. So we need to update the grab state. */ - if (meta_grab_op_is_moving (window->display->grab_op) && - window->display->grab_window == window) + if (meta_grab_op_is_moving (dev->grab_op->op) && + dev->grab_op->window == window) { - window->display->grab_anchor_window_pos = target_rect; + dev->grab_op->anchor_window_pos = target_rect; } meta_window_move_resize (window, @@ -2607,9 +2615,9 @@ meta_window_unmaximize (MetaWindow *window, target_rect.width, target_rect.height); - if (window->display->grab_wireframe_active) + if (dev->grab_op->wireframe_active) { - window->display->grab_wireframe_rect = target_rect; + dev->grab_op->wireframe_rect = target_rect; } recalc_window_features (window); @@ -3432,7 +3440,8 @@ meta_window_move_resize_internal (MetaWindow *window, if (configure_frame_first && window->frame) meta_frame_sync_to_window (window->frame, gravity, - need_move_frame, need_resize_frame); + need_move_frame, need_resize_frame, + (dev->grab_op) ? dev->grab_op->window : NULL); values.border_width = 0; values.x = client_move_x; @@ -3466,7 +3475,7 @@ meta_window_move_resize_internal (MetaWindow *window, #ifdef HAVE_XSYNC if (window->sync_request_counter != None && - window->display->grab_sync_request_alarm != None && + dev->grab_op->sync_request_alarm != None && window->sync_request_time.tv_usec == 0 && window->sync_request_time.tv_sec == 0) { @@ -3489,7 +3498,8 @@ meta_window_move_resize_internal (MetaWindow *window, if (!configure_frame_first && window->frame) meta_frame_sync_to_window (window->frame, gravity, - need_move_frame, need_resize_frame); + need_move_frame, need_resize_frame, + dev->grab_op->window); /* Put gravity back to be nice to lesser window managers */ if (use_static_gravity) @@ -3521,10 +3531,13 @@ meta_window_move_resize_internal (MetaWindow *window, meta_topic (META_DEBUG_GEOMETRY, "Size/position not modified\n"); } - if (window->display->grab_wireframe_active) - meta_window_update_wireframe (window, root_x_nw, root_y_nw, w, h); + if (dev->grab_op) + { + if (dev->grab_op->wireframe_active) + meta_window_update_wireframe (window, dev, root_x_nw, root_y_nw, w, h); + } else - meta_window_refresh_resize_popup (window); + meta_window_refresh_resize_popup (window, dev); /* Invariants leaving this function are: * a) window->rect and frame->rect reflect the actual @@ -3554,6 +3567,7 @@ meta_window_resize (MetaWindow *window, } void +/* XXX: consider changing the header! its all inside dev->! */ meta_window_move (MetaWindow *window, MetaDevInfo *dev, gboolean user_op, @@ -3572,6 +3586,7 @@ meta_window_move (MetaWindow *window, } void +/* XXX: consider changing prototype! */ meta_window_move_resize (MetaWindow *window, MetaDevInfo *dev, gboolean user_op, @@ -3834,94 +3849,98 @@ meta_window_get_xor_rect (MetaWindow *window, */ static void meta_window_get_wireframe_geometry (MetaWindow *window, + MetaDevInfo *dev, int *width, int *height) { - - if (!window->display->grab_wireframe_active) + /* Do I need to check if dev->grab_op ?? */ + if (!dev->grab_op->wireframe_active) return; if ((width == NULL) || (height == NULL)) return; - if ((window->display->grab_window->size_hints.width_inc <= 1) || - (window->display->grab_window->size_hints.height_inc <= 1)) + if ((dev->grab_op->window->size_hints.width_inc <= 1) || + (dev->grab_op->window->size_hints.height_inc <= 1)) { *width = -1; *height = -1; return; } - *width = window->display->grab_wireframe_rect.width - - window->display->grab_window->size_hints.base_width; - *width /= window->display->grab_window->size_hints.width_inc; + *width = dev->grab_op->wireframe_rect.width - + dev->grab_op->window->size_hints.base_width; + *width /= dev->grab_op->window->size_hints.width_inc; - *height = window->display->grab_wireframe_rect.height - - window->display->grab_window->size_hints.base_height; - *height /= window->display->grab_window->size_hints.height_inc; + *height = dev->grab_op->wireframe_rect.height - + dev->grab_op->window->size_hints.base_height; + *height /= dev->grab_op->window->size_hints.height_inc; } /* XXX META_EFFECT_ALT_TAB, well, this and others */ void -meta_window_begin_wireframe (MetaWindow *window) +meta_window_begin_wireframe (MetaWindow *window, MetaDevInfo *dev) { MetaRectangle new_xor; int display_width, display_height; meta_window_get_client_root_coords (window, - &window->display->grab_wireframe_rect); + &dev->grab_op->wireframe_rect); - meta_window_get_xor_rect (window, &window->display->grab_wireframe_rect, + meta_window_get_xor_rect (window, &dev->grab_op->wireframe_rect, &new_xor); - meta_window_get_wireframe_geometry (window, &display_width, &display_height); + meta_window_get_wireframe_geometry (window, dev, + &display_width, &display_height); meta_effects_begin_wireframe (window->screen, &new_xor, display_width, display_height); - window->display->grab_wireframe_last_xor_rect = new_xor; - window->display->grab_wireframe_last_display_width = display_width; - window->display->grab_wireframe_last_display_height = display_height; + dev->grab_op->wireframe_last_xor_rect = new_xor; + dev->grab_op->wireframe_last_display_width = display_width; + dev->grab_op->wireframe_last_display_height = display_height; } void -meta_window_update_wireframe (MetaWindow *window, - int x, - int y, - int width, - int height) +meta_window_update_wireframe (MetaWindow *window, + MetaDevInfo *dev, + int x, + int y, + int width, + int height) { MetaRectangle new_xor; int display_width, display_height; - window->display->grab_wireframe_rect.x = x; - window->display->grab_wireframe_rect.y = y; - window->display->grab_wireframe_rect.width = width; - window->display->grab_wireframe_rect.height = height; + dev->grab_op->wireframe_rect.x = x; + dev->grab_op->wireframe_rect.y = y; + dev->grab_op->wireframe_rect.width = width; + dev->grab_op->wireframe_rect.height = height; - meta_window_get_xor_rect (window, &window->display->grab_wireframe_rect, + meta_window_get_xor_rect (window, &dev->grab_op->wireframe_rect, &new_xor); - meta_window_get_wireframe_geometry (window, &display_width, &display_height); + meta_window_get_wireframe_geometry (window, dev, + &display_width, &display_height); meta_effects_update_wireframe (window->screen, - &window->display->grab_wireframe_last_xor_rect, - window->display->grab_wireframe_last_display_width, - window->display->grab_wireframe_last_display_height, + &dev->grab_op->wireframe_last_xor_rect, + dev->grab_op->wireframe_last_display_width, + dev->grab_op->wireframe_last_display_height, &new_xor, display_width, display_height); - window->display->grab_wireframe_last_xor_rect = new_xor; - window->display->grab_wireframe_last_display_width = display_width; - window->display->grab_wireframe_last_display_height = display_height; + dev->grab_op->wireframe_last_xor_rect = new_xor; + dev->grab_op->wireframe_last_display_width = display_width; + dev->grab_op->wireframe_last_display_height = display_height; } void -meta_window_end_wireframe (MetaWindow *window) +meta_window_end_wireframe (MetaWindow *window, MetaDevInfo *dev) { - meta_effects_end_wireframe (window->display->grab_window->screen, - &window->display->grab_wireframe_last_xor_rect, - window->display->grab_wireframe_last_display_width, - window->display->grab_wireframe_last_display_height); + meta_effects_end_wireframe (dev->grab_op->window->screen, + &dev->grab_op->wireframe_last_xor_rect, + dev->grab_op->wireframe_last_display_width, + dev->grab_op->wireframe_last_display_height); } const char* @@ -3990,13 +4009,16 @@ meta_window_focus (MetaWindow *window, "Setting input focus to window %s, input: %d take_focus: %d\n", window->desc, window->input, window->take_focus); - if (window->display->grab_window && - window->display->grab_window->all_keys_grabbed) + if (dev->grab_op) { - meta_topic (META_DEBUG_FOCUS, - "Current focus window %s has global keygrab, not focusing window %s after all\n", - window->display->grab_window->desc, window->desc); - return; + if (dev->grab_op->window && + meta_devices_list_is_member(&dev->grab_op->window->all_keys_grabbed, dev)) + { + meta_topic (META_DEBUG_FOCUS, + "Current focus window %s has global keygrab, not focusing window %s after all\n", + dev->grab_op->window->desc, window->desc); + return; + } } modal_transient = get_modal_transient (window); @@ -4422,26 +4444,26 @@ meta_window_move_resize_request (MetaWindow *window, * app asked for the current size/position instead of the new one. */ in_grab_op = FALSE; - if (window->display->grab_op != META_GRAB_OP_NONE && - window == window->display->grab_window) - { - switch (window->display->grab_op) - { - case META_GRAB_OP_MOVING: - case META_GRAB_OP_RESIZING_SE: - case META_GRAB_OP_RESIZING_S: - case META_GRAB_OP_RESIZING_SW: - case META_GRAB_OP_RESIZING_N: - case META_GRAB_OP_RESIZING_NE: - case META_GRAB_OP_RESIZING_NW: - case META_GRAB_OP_RESIZING_W: - case META_GRAB_OP_RESIZING_E: - in_grab_op = TRUE; - break; - default: - break; - } - } + if (dev->grab_op != NULL) + if (window == dev->grab_op->window) + { + switch (dev->grab_op->op) + { + case META_GRAB_OP_MOVING: + case META_GRAB_OP_RESIZING_SE: + case META_GRAB_OP_RESIZING_S: + case META_GRAB_OP_RESIZING_SW: + case META_GRAB_OP_RESIZING_N: + case META_GRAB_OP_RESIZING_NE: + case META_GRAB_OP_RESIZING_NW: + case META_GRAB_OP_RESIZING_W: + case META_GRAB_OP_RESIZING_E: + in_grab_op = TRUE; + break; + default: + break; + } + } /* it's essential to use only the explicitly-set fields, * and otherwise use our current up-to-date position. @@ -5148,7 +5170,7 @@ meta_window_notify_focus (MetaWindow *window, XEvent *event) { - meta_warning("METAWINDOWNOTIFYFOCUSMETAWINDOWNOTIFYFOCUSMETAWINDOWNOTIFY\n"); +// meta_warning("METAWINDOWNOTIFYFOCUSMETAWINDOWNOTIFYFOCUSMETAWINDOWNOTIFY\n"); /* note the event can be on either the window or the frame, * we focus the frame for shaded windows */ @@ -6896,8 +6918,9 @@ time_diff (const GTimeVal *first, } static gboolean -check_moveresize_frequency (MetaWindow *window, - gdouble *remaining) +check_moveresize_frequency (MetaWindow *window, + MetaDevInfo *dev, + gdouble *remaining) { GTimeVal current_time; @@ -6905,7 +6928,7 @@ check_moveresize_frequency (MetaWindow *window, #ifdef HAVE_XSYNC if (!window->disable_sync && - window->display->grab_sync_request_alarm != None) + dev->grab_op->sync_request_alarm != None) { if (window->sync_request_time.tv_sec != 0 || window->sync_request_time.tv_usec != 0) @@ -6947,7 +6970,7 @@ check_moveresize_frequency (MetaWindow *window, const double ms_between_resizes = 1000.0 / max_resizes_per_second; double elapsed; - elapsed = time_diff (¤t_time, &window->display->grab_last_moveresize_time); + elapsed = time_diff (¤t_time, &dev->grab_op->last_moveresize_time); if (elapsed >= 0.0 && elapsed < ms_between_resizes) { @@ -6972,18 +6995,22 @@ check_moveresize_frequency (MetaWindow *window, static gboolean update_move_timeout (gpointer data) { - MetaWindow *window = data; - update_move (window, - /* XXX */ &window->display->devices->keyboards[0], - window->display->grab_last_user_action_was_snap, - window->display->grab_latest_motion_x, - window->display->grab_latest_motion_y); + ResizeMoveTimeoutData *rmtd = data; + + update_move (rmtd->window, + rmtd->dev, + rmtd->dev->grab_op->last_user_action_was_snap, + rmtd->dev->grab_op->latest_motion_x, + rmtd->dev->grab_op->latest_motion_y); + + g_free (rmtd); return FALSE; } static void +/* Change prototype? All except window is inside dev-> */ update_move (MetaWindow *window, MetaDevInfo *dev, gboolean snap, @@ -6996,21 +7023,21 @@ update_move (MetaWindow *window, int shake_threshold; MetaDisplay *display = window->display; - display->grab_latest_motion_x = x; - display->grab_latest_motion_y = y; + dev->grab_op->latest_motion_x = x; + dev->grab_op->latest_motion_y = y; - dx = x - display->grab_anchor_root_x; - dy = y - display->grab_anchor_root_y; + dx = x - dev->grab_op->anchor_root_x; + dy = y - dev->grab_op->anchor_root_y; - new_x = display->grab_anchor_window_pos.x + dx; - new_y = display->grab_anchor_window_pos.y + dy; + new_x = dev->grab_op->anchor_window_pos.x + dx; + new_y = dev->grab_op->anchor_window_pos.y + dy; meta_verbose ("x,y = %d,%d anchor ptr %d,%d anchor pos %d,%d dx,dy %d,%d\n", x, y, - display->grab_anchor_root_x, - display->grab_anchor_root_y, - display->grab_anchor_window_pos.x, - display->grab_anchor_window_pos.y, + dev->grab_op->anchor_root_x, + dev->grab_op->anchor_root_y, + dev->grab_op->anchor_window_pos.x, + dev->grab_op->anchor_window_pos.y, dx, dy); /* Don't bother doing anything if no move has been specified. (This @@ -7037,22 +7064,22 @@ update_move (MetaWindow *window, /* move the unmaximized window to the cursor */ prop = - ((double)(x - display->grab_initial_window_pos.x)) / - ((double)display->grab_initial_window_pos.width); + ((double)(x - dev->grab_op->initial_window_pos.x)) / + ((double)dev->grab_op->initial_window_pos.width); - display->grab_initial_window_pos.x = + dev->grab_op->initial_window_pos.x = x - window->saved_rect.width * prop; - display->grab_initial_window_pos.y = y; + dev->grab_op->initial_window_pos.y = y; if (window->frame) { - display->grab_initial_window_pos.y += window->frame->child_y / 2; + dev->grab_op->initial_window_pos.y += window->frame->child_y / 2; } - window->saved_rect.x = display->grab_initial_window_pos.x; - window->saved_rect.y = display->grab_initial_window_pos.y; - display->grab_anchor_root_x = x; - display->grab_anchor_root_y = y; + window->saved_rect.x = dev->grab_op->initial_window_pos.x; + window->saved_rect.y = dev->grab_op->initial_window_pos.y; + dev->grab_op->anchor_root_x = x; + dev->grab_op->anchor_root_y = y; meta_window_unmaximize (window, dev, META_MAXIMIZE_HORIZONTAL | @@ -7103,9 +7130,9 @@ update_move (MetaWindow *window, META_MAXIMIZE_VERTICAL); } - display->grab_initial_window_pos = work_area; - display->grab_anchor_root_x = x; - display->grab_anchor_root_y = y; + dev->grab_op->initial_window_pos = work_area; + dev->grab_op->anchor_root_x = x; + dev->grab_op->anchor_root_y = y; window->shaken_loose = FALSE; meta_window_maximize (window, dev, @@ -7117,8 +7144,8 @@ update_move (MetaWindow *window, } } - if (display->grab_wireframe_active) - old = display->grab_wireframe_rect; + if (dev->grab_op->wireframe_active) + old = dev->grab_op->wireframe_rect; else meta_window_get_client_root_coords (window, &old); @@ -7129,7 +7156,8 @@ update_move (MetaWindow *window, new_y = old.y; /* Do any edge resistance/snapping */ - meta_window_edge_resistance_for_move (window, + meta_window_edge_resistance_for_move (window, + dev, old.x, old.y, &new_x, @@ -7140,17 +7168,17 @@ update_move (MetaWindow *window, if (display->compositor) { - int root_x = new_x - display->grab_anchor_window_pos.x + display->grab_anchor_root_x; - int root_y = new_y - display->grab_anchor_window_pos.y + display->grab_anchor_root_y; + int root_x = new_x - dev->grab_op->anchor_window_pos.x + dev->grab_op->anchor_root_x; + int root_y = new_y - dev->grab_op->anchor_window_pos.y + dev->grab_op->anchor_root_y; meta_compositor_update_move (display->compositor, window, root_x, root_y); } - if (display->grab_wireframe_active) - meta_window_update_wireframe (window, new_x, new_y, - display->grab_wireframe_rect.width, - display->grab_wireframe_rect.height); + if (dev->grab_op->wireframe_active) + meta_window_update_wireframe (window, dev, new_x, new_y, + dev->grab_op->wireframe_rect.width, + dev->grab_op->wireframe_rect.height); else meta_window_move (window, dev, TRUE, new_x, new_y); } @@ -7158,18 +7186,21 @@ update_move (MetaWindow *window, static gboolean update_resize_timeout (gpointer data) { - MetaWindow *window = data; + ResizeMoveTimeoutData *rmtd = data; - update_resize (window, - window->display->grab_last_user_action_was_snap, - window->display->grab_latest_motion_x, - window->display->grab_latest_motion_y, + update_resize (rmtd->window, + rmtd->dev, + rmtd->dev->grab_op->last_user_action_was_snap, + rmtd->dev->grab_op->latest_motion_x, + rmtd->dev->grab_op->latest_motion_y, TRUE); return FALSE; } static void +/* Change prototupe? window + dev */ update_resize (MetaWindow *window, + MetaDevInfo *dev, gboolean snap, int x, int y, gboolean force) @@ -7181,14 +7212,14 @@ update_resize (MetaWindow *window, int new_x, new_y; double remaining; - window->display->grab_latest_motion_x = x; - window->display->grab_latest_motion_y = y; + dev->grab_op->latest_motion_x = x; + dev->grab_op->latest_motion_y = y; - dx = x - window->display->grab_anchor_root_x; - dy = y - window->display->grab_anchor_root_y; + dx = x - dev->grab_op->anchor_root_x; + dy = y - dev->grab_op->anchor_root_y; - new_w = window->display->grab_anchor_window_pos.width; - new_h = window->display->grab_anchor_window_pos.height; + new_w = dev->grab_op->anchor_window_pos.width; + new_h = dev->grab_op->anchor_window_pos.height; /* Don't bother doing anything if no move has been specified. (This * happens often, even in keyboard resizing, due to the warping of the @@ -7198,50 +7229,50 @@ update_resize (MetaWindow *window, return; /* FIXME this is only used in wireframe mode */ - new_x = window->display->grab_anchor_window_pos.x; - new_y = window->display->grab_anchor_window_pos.y; + new_x = dev->grab_op->anchor_window_pos.x; + new_y = dev->grab_op->anchor_window_pos.y; - if (window->display->grab_op == META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN) + if (dev->grab_op->op == META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN) { if ((dx > 0) && (dy > 0)) { - window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_SE; - meta_window_update_keyboard_resize (window, TRUE); + dev->grab_op->op = META_GRAB_OP_KEYBOARD_RESIZING_SE; + meta_window_update_keyboard_resize (dev, window, TRUE); } else if ((dx < 0) && (dy > 0)) { - window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_SW; - meta_window_update_keyboard_resize (window, TRUE); + dev->grab_op->op = META_GRAB_OP_KEYBOARD_RESIZING_SW; + meta_window_update_keyboard_resize (dev, window, TRUE); } else if ((dx > 0) && (dy < 0)) { - window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_NE; - meta_window_update_keyboard_resize (window, TRUE); + dev->grab_op->op = META_GRAB_OP_KEYBOARD_RESIZING_NE; + meta_window_update_keyboard_resize (dev, window, TRUE); } else if ((dx < 0) && (dy < 0)) { - window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_NW; - meta_window_update_keyboard_resize (window, TRUE); + dev->grab_op->op = META_GRAB_OP_KEYBOARD_RESIZING_NW; + meta_window_update_keyboard_resize (dev, window, TRUE); } else if (dx < 0) { - window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_W; - meta_window_update_keyboard_resize (window, TRUE); + dev->grab_op->op = META_GRAB_OP_KEYBOARD_RESIZING_W; + meta_window_update_keyboard_resize (dev, window, TRUE); } else if (dx > 0) { - window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_E; - meta_window_update_keyboard_resize (window, TRUE); + dev->grab_op->op = META_GRAB_OP_KEYBOARD_RESIZING_E; + meta_window_update_keyboard_resize (dev, window, TRUE); } else if (dy > 0) { - window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_S; - meta_window_update_keyboard_resize (window, TRUE); + dev->grab_op->op = META_GRAB_OP_KEYBOARD_RESIZING_S; + meta_window_update_keyboard_resize (dev, window, TRUE); } else if (dy < 0) { - window->display->grab_op = META_GRAB_OP_KEYBOARD_RESIZING_N; - meta_window_update_keyboard_resize (window, TRUE); + dev->grab_op->op = META_GRAB_OP_KEYBOARD_RESIZING_N; + meta_window_update_keyboard_resize (dev, window, TRUE); } } @@ -7250,7 +7281,7 @@ update_resize (MetaWindow *window, * meta_rectangle_resize_with_gravity(). If we were to use that, we * could just increment new_w and new_h by dx and dy in all cases. */ - switch (window->display->grab_op) + switch (dev->grab_op->op) { case META_GRAB_OP_RESIZING_SE: case META_GRAB_OP_RESIZING_NE: @@ -7275,7 +7306,7 @@ update_resize (MetaWindow *window, break; } - switch (window->display->grab_op) + switch (dev->grab_op->op) { case META_GRAB_OP_RESIZING_SE: case META_GRAB_OP_RESIZING_S: @@ -7299,17 +7330,21 @@ update_resize (MetaWindow *window, break; } - if (!check_moveresize_frequency (window, &remaining) && !force) + if (!check_moveresize_frequency (window, dev, &remaining) && !force) { /* we are ignoring an event here, so we schedule a * compensation event when we would otherwise not ignore * an event. Otherwise we can become stuck if the user never * generates another event. */ - if (!window->display->grab_resize_timeout_id) + if (!dev->grab_op->resize_timeout_id) { - window->display->grab_resize_timeout_id = - g_timeout_add ((int)remaining, update_resize_timeout, window); + ResizeMoveTimeoutData *rmtd; + rmtd = g_new (ResizeMoveTimeoutData, 1); + rmtd->window = window; + rmtd->dev = dev; + dev->grab_op->resize_timeout_id = + g_timeout_add ((int)remaining, update_resize_timeout, rmtd); } return; @@ -7320,14 +7355,14 @@ update_resize (MetaWindow *window, meta_compositor_set_updates (window->display->compositor, window, TRUE); /* Remove any scheduled compensation events */ - if (window->display->grab_resize_timeout_id) + if (dev->grab_op->resize_timeout_id) { - g_source_remove (window->display->grab_resize_timeout_id); - window->display->grab_resize_timeout_id = 0; + g_source_remove (dev->grab_op->resize_timeout_id); + dev->grab_op->resize_timeout_id = 0; } - if (window->display->grab_wireframe_active) - old = window->display->grab_wireframe_rect; + if (dev->grab_op->wireframe_active) + old = dev->grab_op->wireframe_rect; else old = window->rect; /* Don't actually care about x,y */ @@ -7335,7 +7370,7 @@ update_resize (MetaWindow *window, * aspect ratio windows don't interact nicely with the above stuff. So, * to avoid some nasty flicker, we enforce that. */ - switch (window->display->grab_op) + switch (dev->grab_op->op) { case META_GRAB_OP_RESIZING_S: case META_GRAB_OP_RESIZING_N: @@ -7352,11 +7387,12 @@ update_resize (MetaWindow *window, } /* compute gravity of client during operation */ - gravity = meta_resize_gravity_from_grab_op (window->display->grab_op); + gravity = meta_resize_gravity_from_grab_op (dev->grab_op->op); g_assert (gravity >= 0); /* Do any edge resistance/snapping */ meta_window_edge_resistance_for_resize (window, + dev, old.width, old.height, &new_w, @@ -7366,7 +7402,7 @@ update_resize (MetaWindow *window, snap, FALSE); - if (window->display->grab_wireframe_active) + if (dev->grab_op->wireframe_active) { if ((new_x + new_w <= new_x) || (new_y + new_h <= new_y)) return; @@ -7378,7 +7414,7 @@ update_resize (MetaWindow *window, * confuses broken clients that have problems with opaque * resize, they probably don't track their visibility. */ - meta_window_update_wireframe (window, new_x, new_y, new_w, new_h); + meta_window_update_wireframe (window, dev, new_x, new_y, new_w, new_h); } else { @@ -7387,13 +7423,13 @@ update_resize (MetaWindow *window, */ if (old.width != new_w || old.height != new_h) meta_window_resize_with_gravity (window, - /* XXX Really not this */ &window->display->devices->keyboards[0], + /* XXX Really not this */ dev, TRUE, new_w, new_h, gravity); } /* Store the latest resize time, if we actually resized. */ if (window->rect.width != old.width || window->rect.height != old.height) - g_get_current_time (&window->display->grab_last_moveresize_time); + g_get_current_time (&dev->grab_op->last_moveresize_time); } typedef struct @@ -7426,38 +7462,33 @@ check_use_this_motion_notify (MetaWindow *window, { EventScannerData esd; XEvent useless; -#ifdef MPX XDeviceMotionEvent *xdme; + MetaDevInfo *dev; xdme = (XDeviceMotionEvent *) event; -#endif + dev = meta_devices_find_mouse_by_id (window->display, xdme->deviceid); /* This code is copied from Owen's GDK code. */ - if (window->display->grab_motion_notify_time != 0) + if (dev->grab_op->motion_notify_time != 0) { /* == is really the right test, but I'm all for paranoia */ -#ifdef MPX - if (window->display->grab_motion_notify_time <= + if (dev->grab_op->motion_notify_time <= xdme->time) -#else - if (window->display->grab_motion_notify_time <= - event->xmotion.time) -#endif { meta_topic (META_DEBUG_RESIZING, "Arrived at event with time %u (waiting for %u), using it\n", -#ifdef MPX (unsigned int)xdme->time, -#else - (unsigned int)event->xmotion.time, -#endif - window->display->grab_motion_notify_time); - window->display->grab_motion_notify_time = 0; + dev->grab_op->motion_notify_time); + dev->grab_op->motion_notify_time = 0; return TRUE; } else - return FALSE; /* haven't reached the saved timestamp yet */ + { + meta_warning("not using this motion notify event!!! name = %s\n", + dev->name); + return FALSE; /* haven't reached the saved timestamp yet */ + } } esd.current_event = event; @@ -7482,7 +7513,9 @@ check_use_this_motion_notify (MetaWindow *window, /* Save this timestamp, and ignore all motion notify * until we get to the one with this stamp. */ - window->display->grab_motion_notify_time = esd.last_time; + dev->grab_op->motion_notify_time = esd.last_time; + meta_warning("not using this motion notify event... name = %s\n", + dev->name); return FALSE; } } @@ -7494,10 +7527,22 @@ meta_window_handle_mouse_grab_op_event (MetaWindow *window, #ifdef HAVE_XSYNC if (event->type == (window->display->xsync_event_base + XSyncAlarmNotify)) { + int idev; + MetaDevInfo *ptr_dev; + + /* XXX: Again, we're going to do what has already been done in + * event_callback. Consider changing this... */ + for (idev = 0; idev < window->display->devices->miceUsed; idev++) + if (window->display->devices->mice[idev].grab_op) + if (((XSyncAlarmNotifyEvent*)event)->alarm == + window->display->devices->mice[idev].grab_op->sync_request_alarm) + ptr_dev = &window->display->devices->mice[idev]; + + meta_topic (META_DEBUG_RESIZING, "Alarm event received last motion x = %d y = %d\n", - window->display->grab_latest_motion_x, - window->display->grab_latest_motion_y); + ptr_dev->grab_op->latest_motion_x, + ptr_dev->grab_op->latest_motion_y); /* If sync was previously disabled, turn it back on and hope * the application has come to its senses (maybe it was just @@ -7508,7 +7553,7 @@ meta_window_handle_mouse_grab_op_event (MetaWindow *window, window->sync_request_time.tv_usec = 0; /* This means we are ready for another configure. */ - switch (window->display->grab_op) + switch (ptr_dev->grab_op->op) { case META_GRAB_OP_RESIZING_E: case META_GRAB_OP_RESIZING_W: @@ -7528,9 +7573,10 @@ meta_window_handle_mouse_grab_op_event (MetaWindow *window, case META_GRAB_OP_KEYBOARD_RESIZING_NW: /* no pointer round trip here, to keep in sync */ update_resize (window, - window->display->grab_last_user_action_was_snap, - window->display->grab_latest_motion_x, - window->display->grab_latest_motion_y, + ptr_dev, + ptr_dev->grab_op->last_user_action_was_snap, + ptr_dev->grab_op->latest_motion_x, + ptr_dev->grab_op->latest_motion_y, TRUE); break; @@ -7544,22 +7590,13 @@ meta_window_handle_mouse_grab_op_event (MetaWindow *window, if (event->type == window->display->dev_btn_release_type) { XDeviceButtonEvent *xdbe; /* XXX declare this somewhere else? */ -#if 0 - MetaDevInfo *dev; - int idev; - - xdbe = (XDeviceButtonReleasedEvent *) event; - for (idev = 0; idev < window->display->devices->keybsUsed; idev++) - if (xdbe->deviceid == window->display->devices->keyboards[idev].xdev->device_id) - dev = &window->display->devices->keyboards[idev]; -#endif - MetaDevInfo *dev; xdbe = (XDeviceButtonReleasedEvent *) event; dev = meta_devices_find_mouse_by_id (window->display, xdbe->deviceid); meta_display_check_threshold_reached (window->display, + dev, xdbe->x_root, xdbe->y_root); /* If the user was snap moving then ignore the button release @@ -7567,18 +7604,19 @@ meta_window_handle_mouse_grab_op_event (MetaWindow *window, * mouse button and they almost certainly do not want a * non-snapped movement to occur from the button release. */ - if (!window->display->grab_last_user_action_was_snap) + if (!dev->grab_op->last_user_action_was_snap) { - if (meta_grab_op_is_moving (window->display->grab_op)) + if (meta_grab_op_is_moving (dev->grab_op->op)) { if (xdbe->root == window->screen->xroot) update_move (window, dev, xdbe->state & ShiftMask, xdbe->x_root, xdbe->y_root); } - else if (meta_grab_op_is_resizing (window->display->grab_op)) + else if (meta_grab_op_is_resizing (dev->grab_op->op)) { if (xdbe->root == window->screen->xroot) update_resize (window, + dev, xdbe->state & ShiftMask, xdbe->x_root, xdbe->y_root, @@ -7602,9 +7640,10 @@ meta_window_handle_mouse_grab_op_event (MetaWindow *window, // meta_warning("xdme->x_root = %d, xdme->y_root = %d, xdme->x = %d, xdme->y = %d\n", xdme->x_root, xdme->y_root, xdme->x, xdme->y); meta_display_check_threshold_reached (window->display, + dev, xdme->x_root, xdme->y_root); - if (meta_grab_op_is_moving (window->display->grab_op)) + if (meta_grab_op_is_moving (dev->grab_op->op)) { if (xdme->root == window->screen->xroot) { @@ -7617,13 +7656,14 @@ meta_window_handle_mouse_grab_op_event (MetaWindow *window, xdme->y_root); } } - else if (meta_grab_op_is_resizing (window->display->grab_op)) + else if (meta_grab_op_is_resizing (dev->grab_op->op)) { if (xdme->root == window->screen->xroot) { if (check_use_this_motion_notify (window, event)) update_resize (window, + dev, xdme->state & ShiftMask, xdme->x_root, xdme->y_root, @@ -7631,76 +7671,6 @@ meta_window_handle_mouse_grab_op_event (MetaWindow *window, } } } - -#else - switch (event->type) - { - case ButtonRelease: - meta_display_check_threshold_reached (window->display, - event->xbutton.x_root, - event->xbutton.y_root); - /* If the user was snap moving then ignore the button release - * because they may have let go of shift before releasing the - * mouse button and they almost certainly do not want a - * non-snapped movement to occur from the button release. - */ - if (!window->display->grab_last_user_action_was_snap) - { - if (meta_grab_op_is_moving (window->display->grab_op)) - { - if (event->xbutton.root == window->screen->xroot) - update_move (window, event->xbutton.state & ShiftMask, - event->xbutton.x_root, event->xbutton.y_root); - } - else if (meta_grab_op_is_resizing (window->display->grab_op)) - { - if (event->xbutton.root == window->screen->xroot) - update_resize (window, - event->xbutton.state & ShiftMask, - event->xbutton.x_root, - event->xbutton.y_root, - TRUE); - if (window->display->compositor) - meta_compositor_set_updates (window->display->compositor, window, TRUE); - } - } - - meta_display_end_grab_op (window->display, event->xbutton.time); - break; - case MotionNotify: - meta_display_check_threshold_reached (window->display, - event->xmotion.x_root, - event->xmotion.y_root); - if (meta_grab_op_is_moving (window->display->grab_op)) - { - if (event->xmotion.root == window->screen->xroot) - { - if (check_use_this_motion_notify (window, - event)) - update_move (window, - event->xmotion.state & ShiftMask, - event->xmotion.x_root, - event->xmotion.y_root); - } - } - else if (meta_grab_op_is_resizing (window->display->grab_op)) - { - if (event->xmotion.root == window->screen->xroot) - { - if (check_use_this_motion_notify (window, - event)) - update_resize (window, - event->xmotion.state & ShiftMask, - event->xmotion.x_root, - event->xmotion.y_root, - FALSE); - } - } - break; - - default: - break; - } #endif } @@ -7817,25 +7787,26 @@ meta_window_same_application (MetaWindow *window, } void -meta_window_refresh_resize_popup (MetaWindow *window) +/* XXX change prototype? window == dev->grab_op->window! */ +meta_window_refresh_resize_popup (MetaWindow *window, MetaDevInfo *dev) { - if (window->display->grab_op == META_GRAB_OP_NONE) + if (dev->grab_op == NULL) return; - if (window->display->grab_window != window) + if (dev->grab_op->window != window) return; /* We shouldn't ever get called when the wireframe is active * because that's handled by a different code path in effects.c */ - if (window->display->grab_wireframe_active) + if (dev->grab_op->wireframe_active) { meta_topic (META_DEBUG_WINDOW_OPS, "refresh_resize_popup called when wireframe active\n"); return; } - switch (window->display->grab_op) + switch (dev->grab_op->op) { case META_GRAB_OP_RESIZING_SE: case META_GRAB_OP_RESIZING_S: @@ -7861,32 +7832,32 @@ meta_window_refresh_resize_popup (MetaWindow *window) return; } - if (window->display->grab_resize_popup == NULL) + if (dev->grab_op->resize_popup == NULL) { if (window->size_hints.width_inc > 1 || window->size_hints.height_inc > 1) - window->display->grab_resize_popup = + dev->grab_op->resize_popup = meta_ui_resize_popup_new (window->display->xdisplay, window->screen->number); } - if (window->display->grab_resize_popup != NULL) + if (dev->grab_op->resize_popup != NULL) { MetaRectangle rect; - if (window->display->grab_wireframe_active) - rect = window->display->grab_wireframe_rect; + if (dev->grab_op->wireframe_active) + rect = dev->grab_op->wireframe_rect; else meta_window_get_client_root_coords (window, &rect); - meta_ui_resize_popup_set (window->display->grab_resize_popup, + meta_ui_resize_popup_set (dev->grab_op->resize_popup, rect, window->size_hints.base_width, window->size_hints.base_height, window->size_hints.width_inc, window->size_hints.height_inc); - meta_ui_resize_popup_set_showing (window->display->grab_resize_popup, + meta_ui_resize_popup_set_showing (dev->grab_op->resize_popup, TRUE); } } @@ -8006,11 +7977,11 @@ meta_window_is_ancestor_of_transient (MetaWindow *window, */ static gboolean warp_grab_pointer (MetaWindow *window, + MetaDevInfo *dev, MetaGrabOp grab_op, int *x, int *y) { -/* XXX XXX XXX XXX XXX XXX */ MetaRectangle rect; MetaDisplay *display; @@ -8019,9 +7990,9 @@ warp_grab_pointer (MetaWindow *window, /* We may not have done begin_grab_op yet, i.e. may not be in a grab */ - if (window == display->grab_window && display->grab_wireframe_active) + if (window == dev->grab_op->window && dev->grab_op->wireframe_active) { - meta_window_get_xor_rect (window, &display->grab_wireframe_rect, &rect); + meta_window_get_xor_rect (window, &dev->grab_op->wireframe_rect, &rect); } else { @@ -8097,21 +8068,22 @@ warp_grab_pointer (MetaWindow *window, * events generated by the XWarpPointer() call below don't cause complete * funkiness. See bug 124582 and bug 122670. */ - display->grab_anchor_root_x = *x; - display->grab_anchor_root_y = *y; - display->grab_latest_motion_x = *x; - display->grab_latest_motion_y = *y; - if (display->grab_wireframe_active) - display->grab_anchor_window_pos = display->grab_wireframe_rect; + dev->grab_op->anchor_root_x = *x; + dev->grab_op->anchor_root_y = *y; + dev->grab_op->latest_motion_x = *x; + dev->grab_op->latest_motion_y = *y; + if (dev->grab_op->wireframe_active) + dev->grab_op->anchor_window_pos = dev->grab_op->wireframe_rect; else meta_window_get_client_root_coords (window, - &display->grab_anchor_window_pos); + &dev->grab_op->anchor_window_pos); - XWarpPointer (display->xdisplay, - None, - window->screen->xroot, - 0, 0, 0, 0, - *x, *y); + XWarpDevicePointer (display->xdisplay, + dev->xdev, + None, + window->screen->xroot, + 0, 0, 0, 0, + *x, *y); if (meta_error_trap_pop_with_return (display, FALSE) != Success) { @@ -8132,7 +8104,7 @@ meta_window_begin_grab_op (MetaWindow *window, { int x, y; - warp_grab_pointer (window, + warp_grab_pointer (window, dev, op, &x, &y); meta_display_begin_grab_op (window->display, @@ -8149,13 +8121,15 @@ meta_window_begin_grab_op (MetaWindow *window, } void -meta_window_update_keyboard_resize (MetaWindow *window, - gboolean update_cursor) +/* Change args order? */ +meta_window_update_keyboard_resize (MetaDevInfo *dev, + MetaWindow *window, + gboolean update_cursor) { int x, y; - warp_grab_pointer (window, - window->display->grab_op, + warp_grab_pointer (window, dev, + dev->grab_op->op, &x, &y); if (update_cursor) @@ -8167,20 +8141,20 @@ meta_window_update_keyboard_resize (MetaWindow *window, meta_display_set_grab_op_cursor (window->display, NULL, NULL, - window->display->grab_op, + dev->grab_op->op, TRUE, - window->display->grab_xwindow, + dev->grab_op->xwindow, timestamp); } } void -meta_window_update_keyboard_move (MetaWindow *window) +meta_window_update_keyboard_move (MetaDevInfo *dev, MetaWindow *window) { int x, y; - warp_grab_pointer (window, - window->display->grab_op, + warp_grab_pointer (window, dev, + dev->grab_op->op, &x, &y); } @@ -8376,7 +8350,7 @@ void meta_window_add_focused_device (MetaWindow *window, MetaDevInfo *kbdDev) { - meta_warning("Trying to add device named %s to window...\n", kbdDev->name); +// meta_warning("Trying to add device named %s to window...\n", kbdDev->name); int i; if (window->focused_devices_used == window->focused_devices_size) @@ -8395,8 +8369,8 @@ meta_window_add_focused_device (MetaWindow *window, MetaDevInfo *kbdDev) if ((!window->has_focus) && (window->focused_devices_used > 0)) meta_warning("(!window->has_focus()) && (window->focused_devices_used > 0"); - for (i = 0; i < window->focused_devices_used; i++) - meta_warning("Window focused by %s\n", window->focused_devices[i]->name); +// for (i = 0; i < window->focused_devices_used; i++) +// meta_warning("Window focused by %s\n", window->focused_devices[i]->name); } @@ -8414,9 +8388,9 @@ meta_window_add_focused_device (MetaWindow *window, MetaDevInfo *kbdDev) window->focused_devices[window->focused_devices_used] = kbdDev; window->focused_devices_used++; - meta_warning("window->focused_devices_used = %d\n", window->focused_devices_used); +// meta_warning("window->focused_devices_used = %d\n", window->focused_devices_used); - meta_warning("DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD\n"); +// meta_warning("DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD\n"); } void @@ -8424,7 +8398,7 @@ meta_window_remove_focused_device (MetaWindow *window, MetaDevInfo *kbdDev) { int i, j; - meta_warning("Trying to remove device named %s from window...\n", kbdDev->name); +// meta_warning("Trying to remove device named %s from window...\n", kbdDev->name); /* REMOVE THIS AFTER TESTING */ { @@ -8433,8 +8407,8 @@ meta_window_remove_focused_device (MetaWindow *window, MetaDevInfo *kbdDev) if ((!window->has_focus) && (window->focused_devices_used > 0)) meta_warning("(!window->has_focus()) && (window->focused_devices_used > 0"); - for (i = 0; i < window->focused_devices_used; i++) - meta_warning("Window focused by %s\n", window->focused_devices[i]->name); +// for (i = 0; i < window->focused_devices_used; i++) +// meta_warning("Window focused by %s\n", window->focused_devices[i]->name); } if (window->focused_devices_used == 0 || (!window->has_focus)) @@ -8466,9 +8440,9 @@ meta_window_remove_focused_device (MetaWindow *window, MetaDevInfo *kbdDev) if (window->focused_devices_used == 0) window->has_focus = FALSE; - meta_warning("window->focused_devices_used = %d\n@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n", window->focused_devices_used); +// meta_warning("window->focused_devices_used = %d\n@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n", window->focused_devices_used); - meta_warning("BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n"); +// meta_warning("BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n"); } gboolean diff --git a/src/window.h b/src/window.h index 45afaa9c..d5a8c22f 100644 --- a/src/window.h +++ b/src/window.h @@ -249,9 +249,11 @@ struct _MetaWindow guint is_in_queues : NUMBER_OF_QUEUES; /* Used by keybindings.c */ - guint keys_grabbed : 1; /* normal keybindings grabbed */ +// guint keys_grabbed : 1; /* normal keybindings grabbed */ guint grab_on_frame : 1; /* grabs are on the frame */ - guint all_keys_grabbed : 1; /* AnyKey grabbed */ +// guint all_keys_grabbed : 1; /* AnyKey grabbed */ + MetaDevList keys_grabbed; + MetaDevList all_keys_grabbed; /* Set if the reason for unmanaging the window is that * it was withdrawn @@ -360,6 +362,15 @@ struct _MetaWindow int focused_devices_size; }; +/* XXX Should put this here? Should do otherway? */ +typedef struct _ResizeMoveTimeoutData ResizeMoveTimeoutData; + +struct _ResizeMoveTimeoutData +{ + MetaWindow *window; + MetaDevInfo *dev; +}; + /* These differ from window->has_foo_func in that they consider * the dynamic window state such as "maximized", not just the * window's type @@ -496,13 +507,16 @@ void meta_window_get_outer_rect (const MetaWindow *window, void meta_window_get_xor_rect (MetaWindow *window, const MetaRectangle *grab_wireframe_rect, MetaRectangle *xor_rect); -void meta_window_begin_wireframe (MetaWindow *window); -void meta_window_update_wireframe (MetaWindow *window, - int x, - int y, - int width, - int height); -void meta_window_end_wireframe (MetaWindow *window); +void meta_window_begin_wireframe (MetaWindow *window, + MetaDevInfo *dev); +void meta_window_update_wireframe (MetaWindow *window, + MetaDevInfo *dev, + int x, + int y, + int width, + int height); +void meta_window_end_wireframe (MetaWindow *window, + MetaDevInfo *dev); void meta_window_delete (MetaWindow *window, guint32 timestamp); @@ -584,7 +598,7 @@ gboolean meta_window_same_application (MetaWindow *window, #define META_WINDOW_IN_GROUP_TAB_CHAIN(w, g) \ (((w)->input || (w)->take_focus) && (!g || meta_window_get_group(w)==g)) -void meta_window_refresh_resize_popup (MetaWindow *window); +void meta_window_refresh_resize_popup (MetaWindow *window, MetaDevInfo *dev); void meta_window_free_delete_dialog (MetaWindow *window); @@ -605,9 +619,11 @@ void meta_window_begin_grab_op (MetaWindow *window, gboolean frame_action, guint32 timestamp); -void meta_window_update_keyboard_resize (MetaWindow *window, - gboolean update_cursor); -void meta_window_update_keyboard_move (MetaWindow *window); +void meta_window_update_keyboard_resize (MetaDevInfo *dev, + MetaWindow *window, + gboolean update_cursor); +void meta_window_update_keyboard_move (MetaDevInfo *dev, + MetaWindow *window); void meta_window_update_layer (MetaWindow *window); diff --git a/src/workspace.c b/src/workspace.c index 0708c145..904bb4ea 100644 --- a/src/workspace.c +++ b/src/workspace.c @@ -272,6 +272,7 @@ meta_workspace_queue_calc_showing (MetaWorkspace *workspace) void meta_workspace_activate_with_focus (MetaWorkspace *workspace, + MetaDevInfo *kbd_dev, MetaWindow *focus_this, guint32 timestamp) { @@ -302,9 +303,9 @@ meta_workspace_activate_with_focus (MetaWorkspace *workspace, return; move_window = NULL; - if (workspace->screen->display->grab_op == META_GRAB_OP_MOVING || - workspace->screen->display->grab_op == META_GRAB_OP_KEYBOARD_MOVING) - move_window = workspace->screen->display->grab_window; + if (kbd_dev->grab_op->op == META_GRAB_OP_MOVING || + kbd_dev->grab_op->op == META_GRAB_OP_KEYBOARD_MOVING) + move_window = kbd_dev->grab_op->window; if (move_window != NULL) { @@ -333,8 +334,9 @@ meta_workspace_activate_with_focus (MetaWorkspace *workspace, if (focus_this) { + meta_warning("this should be a kbd: %s\n", kbd_dev->name); meta_window_focus (focus_this, - &focus_this->display->devices->keyboards[0], /* XXX */ + kbd_dev, timestamp); meta_window_raise (focus_this); } @@ -346,16 +348,17 @@ meta_workspace_activate_with_focus (MetaWorkspace *workspace, { meta_topic (META_DEBUG_FOCUS, "Focusing default window on new workspace\n"); meta_workspace_focus_default_window (workspace, - /* XXX */ &focus_this->display->devices->keyboards[0], + kbd_dev, NULL, timestamp); } } void meta_workspace_activate (MetaWorkspace *workspace, + MetaDevInfo *dev, guint32 timestamp) { - meta_workspace_activate_with_focus (workspace, NULL, timestamp); + meta_workspace_activate_with_focus (workspace, dev, NULL, timestamp); } int diff --git a/src/workspace.h b/src/workspace.h index 14814f6c..d83a3b25 100644 --- a/src/workspace.h +++ b/src/workspace.h @@ -68,9 +68,11 @@ void meta_workspace_remove_window (MetaWorkspace *workspace, void meta_workspace_relocate_windows (MetaWorkspace *workspace, MetaWorkspace *new_home); void meta_workspace_activate_with_focus (MetaWorkspace *workspace, + MetaDevInfo *kbd_dev, MetaWindow *focus_this, guint32 timestamp); void meta_workspace_activate (MetaWorkspace *workspace, + MetaDevInfo *dev, guint32 timestamp); int meta_workspace_index (MetaWorkspace *workspace); GList* meta_workspace_list_windows (MetaWorkspace *workspace); -- cgit v1.2.1