summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorPaulo Zanoni <przanoni@src.gnome.org>2007-08-27 04:43:33 +0000
committerPaulo Zanoni <przanoni@src.gnome.org>2007-08-27 04:43:33 +0000
commitaafaf298f7d8132aca02b3bfcf2340574fc7bfbf (patch)
treeb197ffe1e0af89f2beacf2f07d87c82494298b8c
parentb41c8538b6e644bbc3a9fc01d7e008dd2bc3e2f9 (diff)
downloadmetacity-multiple_pointer_x.tar.gz
Another very big commit...multiple_pointer_x
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
Diffstat
-rw-r--r--src/common.h3
-rw-r--r--src/constraints.c3
-rw-r--r--src/core.c43
-rw-r--r--src/core.h37
-rw-r--r--src/devices.c74
-rw-r--r--src/devices.h52
-rw-r--r--src/display.c684
-rw-r--r--src/display.h11
-rw-r--r--src/edge-resistance.c107
-rw-r--r--src/edge-resistance.h2
-rw-r--r--src/frame.c16
-rw-r--r--src/frame.h3
-rw-r--r--src/frames.c63
-rw-r--r--src/keybindings.c269
-rw-r--r--src/screen.c18
-rw-r--r--src/screen.h6
-rw-r--r--src/window.c630
-rw-r--r--src/window.h42
-rw-r--r--src/workspace.c15
-rw-r--r--src/workspace.h2
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 <X11/extensions/sync.h>
+#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 <config.h>
#include <math.h>
-#include <string.h>
+#include <string.h> /* 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 (&current_time, &window->display->grab_last_moveresize_time);
+ elapsed = time_diff (&current_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);
View Lorry Controller Status