diff options
-rw-r--r-- | README | 8 | ||||
-rw-r--r-- | configure.in | 3 | ||||
-rw-r--r-- | src/Makefile.am | 6 | ||||
-rw-r--r-- | src/common.h | 2 | ||||
-rw-r--r-- | src/constraints.c | 14 | ||||
-rw-r--r-- | src/constraints.h | 3 | ||||
-rw-r--r-- | src/core.c | 132 | ||||
-rw-r--r-- | src/core.h | 105 | ||||
-rw-r--r-- | src/delete.c | 5 | ||||
-rw-r--r-- | src/devices.c | 111 | ||||
-rw-r--r-- | src/devices.h | 26 | ||||
-rw-r--r-- | src/display.c | 1338 | ||||
-rw-r--r-- | src/display.h | 80 | ||||
-rw-r--r-- | src/frame.c | 100 | ||||
-rw-r--r-- | src/frames.c | 192 | ||||
-rw-r--r-- | src/frames.h | 8 | ||||
-rw-r--r-- | src/keybindings.c | 1163 | ||||
-rw-r--r-- | src/keybindings.h | 35 | ||||
-rw-r--r-- | src/place.c | 12 | ||||
-rw-r--r-- | src/screen.c | 173 | ||||
-rw-r--r-- | src/screen.h | 7 | ||||
-rw-r--r-- | src/ui.c | 57 | ||||
-rw-r--r-- | src/ui.h | 12 | ||||
-rw-r--r-- | src/window-props.c | 4 | ||||
-rw-r--r-- | src/window.c | 603 | ||||
-rw-r--r-- | src/window.h | 57 | ||||
-rw-r--r-- | src/workspace.c | 26 | ||||
-rw-r--r-- | src/workspace.h | 1 |
28 files changed, 3062 insertions, 1221 deletions
@@ -1,3 +1,11 @@ ++=================== WARNING ====================+ +| THIS IS AN UNSTABLE BRANCH! | +| CODE IS NOT BEAUTIFUL YET! | +| A LOT OF METACITY FUNCTION LAYERS WERE BROKEN! | +| ALL THIS WILL BE FIXED | ++================================================+ + + Metacity is not a meta-City as in an urban center, but rather Meta-ness as in the state of being meta. i.e. metacity : meta as opacity : opaque. Also it may have something to do with the Meta key diff --git a/configure.in b/configure.in index d3cf72e3..488f3b52 100644 --- a/configure.in +++ b/configure.in @@ -558,5 +558,6 @@ if test $(( $(echo $METACITY_MINOR_VERSION) %2)) == "1"; then echo -n "Use 2.$stable_version.x for stable " echo "(gnome-2-$stable_version branch in CVS)" else - echo "This is the stable branch of metacity" + echo "This is an UNSTABLE branch of metacity" + echo "Code is still ugly. A lot of things will be changed" fi diff --git a/src/Makefile.am b/src/Makefile.am index c800b390..6d37833d 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -23,6 +23,7 @@ metacity_SOURCES= \ core.c \ core.h \ delete.c \ + devices.c \ devices.h \ display.c \ display.h \ @@ -112,8 +113,9 @@ libmetacity_private_la_SOURCES= \ theme-parser.h \ util.c \ util.h \ - common.h \ - devices.h + devices.c \ + devices.h \ + common.h libmetacity_private_la_LDFLAGS = -no-undefined libmetacity_private_la_LIBADD = @METACITY_LIBS@ diff --git a/src/common.h b/src/common.h index 5501c781..3cfb1b50 100644 --- a/src/common.h +++ b/src/common.h @@ -84,6 +84,8 @@ typedef struct _MetaWindowMenu MetaWindowMenu; #ifdef MPX /* This was defined here so I don't need to include devices.h on this file */ typedef struct _MetaDevInfo MetaDevInfo; +/* XXX */ +typedef struct _MetaDisplay MetaDisplay; typedef void (* MetaWindowMenuFunc) (MetaWindowMenu *menu, Display *xdisplay, diff --git a/src/constraints.c b/src/constraints.c index 8cba3bfb..2fc98f18 100644 --- a/src/constraints.c +++ b/src/constraints.c @@ -183,7 +183,8 @@ static void setup_constraint_info (ConstraintInfo *info, MetaMoveResizeFlags flags, int resize_gravity, const MetaRectangle *orig, - MetaRectangle *new); + MetaRectangle *new, + MetaDevInfo *dev); static void place_window_if_needed (MetaWindow *window, ConstraintInfo *info); static void update_onscreen_requirements (MetaWindow *window, @@ -266,7 +267,8 @@ meta_window_constrain (MetaWindow *window, MetaMoveResizeFlags flags, int resize_gravity, const MetaRectangle *orig, - MetaRectangle *new) + MetaRectangle *new, + MetaDevInfo *dev) { ConstraintInfo info; ConstraintPriority priority = PRIORITY_MINIMUM; @@ -289,7 +291,8 @@ meta_window_constrain (MetaWindow *window, flags, resize_gravity, orig, - new); + new, + dev); place_window_if_needed (window, &info); while (!satisfied && priority <= PRIORITY_MAXIMUM) { @@ -331,7 +334,8 @@ setup_constraint_info (ConstraintInfo *info, MetaMoveResizeFlags flags, int resize_gravity, const MetaRectangle *orig, - MetaRectangle *new) + MetaRectangle *new, + MetaDevInfo *dev) { const MetaXineramaScreenInfo *xinerama_info; MetaWorkspace *cur_workspace; @@ -415,7 +419,7 @@ setup_constraint_info (ConstraintInfo *info, "Treating resize request of legacy application %s as a " "fullscreen request\n", window->desc); - meta_window_make_fullscreen_internal (window); + meta_window_make_fullscreen_internal (window, dev); } /* Log all this information for debugging */ diff --git a/src/constraints.h b/src/constraints.h index 8ce332e7..9816809a 100644 --- a/src/constraints.h +++ b/src/constraints.h @@ -43,6 +43,7 @@ void meta_window_constrain (MetaWindow *window, MetaMoveResizeFlags flags, int resize_gravity, const MetaRectangle *orig, - MetaRectangle *new); + MetaRectangle *new, + MetaDevInfo *dev); #endif /* META_CONSTRAINTS_H */ @@ -222,26 +222,28 @@ meta_core_queue_frame_resize (Display *xdisplay, } void -meta_core_user_move (Display *xdisplay, - Window frame_xwindow, - int x, - int y) +meta_core_user_move (Display *xdisplay, + MetaDevInfo *dev, + Window frame_xwindow, + int x, + int y) { MetaWindow *window = get_window (xdisplay, frame_xwindow); - meta_window_move (window, TRUE, x, y); + meta_window_move (window, dev, TRUE, x, y); } void -meta_core_user_resize (Display *xdisplay, - Window frame_xwindow, - int gravity, - int width, - int height) +meta_core_user_resize (Display *xdisplay, + MetaDevInfo *dev, + Window frame_xwindow, + int gravity, + int width, + int height) { MetaWindow *window = get_window (xdisplay, frame_xwindow); - meta_window_resize_with_gravity (window, TRUE, width, height, gravity); + meta_window_resize_with_gravity (window, dev, TRUE, width, height, gravity); } void @@ -254,9 +256,10 @@ meta_core_user_raise (Display *xdisplay, } void -meta_core_user_lower_and_unfocus (Display *xdisplay, - Window frame_xwindow, - guint32 timestamp) +meta_core_user_lower_and_unfocus (Display *xdisplay, + MetaDevInfo *dev, + Window frame_xwindow, + guint32 timestamp) { MetaWindow *window = get_window (xdisplay, frame_xwindow); @@ -292,18 +295,20 @@ meta_core_user_lower_and_unfocus (Display *xdisplay, /* focus the default window, if needed */ if (window->has_focus) meta_workspace_focus_default_window (window->screen->active_workspace, + dev, NULL, timestamp); } void -meta_core_user_focus (Display *xdisplay, - Window frame_xwindow, - guint32 timestamp) +meta_core_user_focus (Display *xdisplay, + MetaDevInfo *dev, + Window frame_xwindow, + guint32 timestamp) { MetaWindow *window = get_window (xdisplay, frame_xwindow); - meta_window_focus (window, timestamp); + meta_window_focus (window, dev, timestamp); } void @@ -317,6 +322,7 @@ meta_core_minimize (Display *xdisplay, void meta_core_maximize (Display *xdisplay, + MetaDevInfo *dev, Window frame_xwindow) { MetaWindow *window = get_window (xdisplay, frame_xwindow); @@ -324,13 +330,14 @@ meta_core_maximize (Display *xdisplay, if (meta_prefs_get_raise_on_click ()) meta_window_raise (window); - meta_window_maximize (window, + meta_window_maximize (window, dev, META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL); } void -meta_core_toggle_maximize (Display *xdisplay, - Window frame_xwindow) +meta_core_toggle_maximize (Display *xdisplay, + MetaDevInfo *dev, + Window frame_xwindow) { MetaWindow *window = get_window (xdisplay, frame_xwindow); @@ -338,23 +345,24 @@ meta_core_toggle_maximize (Display *xdisplay, meta_window_raise (window); if (META_WINDOW_MAXIMIZED (window)) - meta_window_unmaximize (window, + meta_window_unmaximize (window, dev, META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL); else - meta_window_maximize (window, + meta_window_maximize (window, dev, META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL); } void -meta_core_unmaximize (Display *xdisplay, - Window frame_xwindow) +meta_core_unmaximize (Display *xdisplay, + MetaDevInfo *dev, + Window frame_xwindow) { MetaWindow *window = get_window (xdisplay, frame_xwindow); if (meta_prefs_get_raise_on_click ()) meta_window_raise (window); - meta_window_unmaximize (window, + meta_window_unmaximize (window, dev, META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL); } @@ -369,23 +377,25 @@ meta_core_delete (Display *xdisplay, } void -meta_core_unshade (Display *xdisplay, - Window frame_xwindow, - guint32 timestamp) +meta_core_unshade (Display *xdisplay, + MetaDevInfo *dev, + Window frame_xwindow, + guint32 timestamp) { MetaWindow *window = get_window (xdisplay, frame_xwindow); - meta_window_unshade (window, timestamp); + meta_window_unshade (window, dev, timestamp); } void -meta_core_shade (Display *xdisplay, - Window frame_xwindow, - guint32 timestamp) +meta_core_shade (Display *xdisplay, + MetaDevInfo *dev, + Window frame_xwindow, + guint32 timestamp) { MetaWindow *window = get_window (xdisplay, frame_xwindow); - meta_window_shade (window, timestamp); + meta_window_shade (window, dev, timestamp); } void @@ -457,18 +467,19 @@ meta_core_get_active_workspace (Screen *xscreen) } void -meta_core_show_window_menu (Display *xdisplay, - Window frame_xwindow, - int root_x, - int root_y, - int button, - guint32 timestamp) +meta_core_show_window_menu (Display *xdisplay, + MetaDevInfo *dev, + Window frame_xwindow, + int root_x, + int root_y, + int button, + guint32 timestamp) { MetaWindow *window = get_window (xdisplay, frame_xwindow); if (meta_prefs_get_raise_on_click ()) meta_window_raise (window); - meta_window_focus (window, timestamp); + meta_window_focus (window, dev, timestamp); meta_window_show_menu (window, root_x, root_y, button, timestamp); } @@ -607,16 +618,17 @@ meta_core_get_workspace_name_with_index (Display *xdisplay, } gboolean -meta_core_begin_grab_op (Display *xdisplay, - Window frame_xwindow, - MetaGrabOp op, - gboolean pointer_already_grabbed, - gboolean frame_action, - int button, - gulong modmask, - guint32 timestamp, - int root_x, - int root_y) +meta_core_begin_grab_op (Display *xdisplay, + MetaDevInfo *dev, /* XXX use XDevice* ?? */ + Window frame_xwindow, + MetaGrabOp op, + gboolean pointer_already_grabbed, + gboolean frame_action, + int button, + gulong modmask, + guint32 timestamp, + int root_x, + int root_y) { MetaWindow *window = get_window (xdisplay, frame_xwindow); MetaDisplay *display; @@ -627,7 +639,7 @@ meta_core_begin_grab_op (Display *xdisplay, g_assert (screen != NULL); - return meta_display_begin_grab_op (display, screen, window, + return meta_display_begin_grab_op (display, screen, dev, window, op, pointer_already_grabbed, frame_action, button, modmask, @@ -635,14 +647,17 @@ meta_core_begin_grab_op (Display *xdisplay, } void -meta_core_end_grab_op (Display *xdisplay, - guint32 timestamp) +meta_core_end_grab_op (Display *xdisplay, + MetaDevInfo *dev, + guint32 timestamp) { MetaDisplay *display; + + /* XXX we should recive a device_id or an XDevice? */ display = meta_display_for_x_display (xdisplay); - meta_display_end_grab_op (display, timestamp); + meta_display_end_grab_op (display, dev, timestamp); } MetaGrabOp @@ -690,15 +705,16 @@ meta_core_get_grab_button (Display *xdisplay) } void -meta_core_grab_buttons (Display *xdisplay, - Window frame_xwindow) +meta_core_grab_buttons (Display *xdisplay, + Window frame_xwindow, + MetaDevInfo *dev) { MetaDisplay *display; display = meta_display_for_x_display (xdisplay); meta_verbose ("Grabbing buttons on frame 0x%lx\n", frame_xwindow); - meta_display_grab_window_buttons (display, frame_xwindow); + meta_display_grab_window_buttons (display, frame_xwindow, dev); } void @@ -96,42 +96,51 @@ void meta_core_queue_frame_resize (Display *xdisplay, Window frame_xwindow); /* Move as a result of user operation */ -void meta_core_user_move (Display *xdisplay, - Window frame_xwindow, - int x, - int y); -void meta_core_user_resize (Display *xdisplay, - Window frame_xwindow, - int gravity, - int width, - int height); +void meta_core_user_move (Display *xdisplay, + MetaDevInfo *dev, + Window frame_xwindow, + int x, + int y); +void meta_core_user_resize (Display *xdsplay, + MetaDevInfo *dev, + Window frame_xwindow, + int gravity, + int width, + int height); void meta_core_user_raise (Display *xdisplay, Window frame_xwindow); -void meta_core_user_lower_and_unfocus (Display *xdisplay, - Window frame_xwindow, - guint32 timestamp); +void meta_core_user_lower_and_unfocus (Display *xdisplay, + MetaDevInfo *dev, + Window frame_xwindow, + guint32 timestamp); -void meta_core_user_focus (Display *xdisplay, - Window frame_xwindow, - guint32 timestamp); +void meta_core_user_focus (Display *xdisplay, + MetaDevInfo *dev, + Window frame_xwindow, + guint32 timestamp); void meta_core_minimize (Display *xdisplay, Window frame_xwindow); -void meta_core_toggle_maximize (Display *xdisplay, - Window frame_xwindow); -void meta_core_unmaximize (Display *xdisplay, - Window frame_xwindow); -void meta_core_maximize (Display *xdisplay, - Window frame_xwindow); +void meta_core_toggle_maximize (Display *xdisplay, + MetaDevInfo *dev, + Window frame_xwindow); +void meta_core_unmaximize (Display *xdisplay, + MetaDevInfo *dev, + Window frame_xwindow); +void meta_core_maximize (Display *xdisplay, + MetaDevInfo *dev, + Window frame_xwindow); void meta_core_delete (Display *xdisplay, Window frame_xwindow, guint32 timestamp); -void meta_core_unshade (Display *xdisplay, - Window frame_xwindow, - guint32 timestamp); -void meta_core_shade (Display *xdisplay, - Window frame_xwindow, +void meta_core_unshade (Display *xdisplay, + MetaDevInfo *dev, + Window frame_xwindow, + guint32 timestamp); +void meta_core_shade (Display *xdisplay, + MetaDevInfo *dev, + Window frame_xwindow, guint32 timestamp); void meta_core_unstick (Display *xdisplay, Window frame_xwindow); @@ -153,37 +162,41 @@ const char* meta_core_get_workspace_name_with_index (Display *xdisplay, Window xroot, int index); -void meta_core_show_window_menu (Display *xdisplay, - Window frame_xwindow, - int root_x, - int root_y, - int button, - guint32 timestamp); +void meta_core_show_window_menu (Display *xdisplay, + MetaDevInfo *dev, + Window frame_xwindow, + int root_x, + int root_y, + int button, + guint32 timestamp); void meta_core_get_menu_accelerator (MetaMenuOp menu_op, int workspace, unsigned int *keysym, MetaVirtualModifier *modifiers); -gboolean meta_core_begin_grab_op (Display *xdisplay, - 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, - guint32 timestamp); +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); -void meta_core_grab_buttons (Display *xdisplay, - Window frame_xwindow); +void meta_core_grab_buttons (Display *xdisplay, + Window frame_xwindow, + MetaDevInfo *dev); void meta_core_set_screen_cursor (Display *xdisplay, Window frame_on_screen, diff --git a/src/delete.c b/src/delete.c index 30941aee..d88edd71 100644 --- a/src/delete.c +++ b/src/delete.c @@ -504,7 +504,10 @@ meta_window_present_delete_dialog (MetaWindow *window, guint32 timestamp) w->res_class && g_strcasecmp (w->res_class, "metacity-dialog") == 0) { - meta_window_activate (w, timestamp); + /* XXX use the window's current focus!!! */ + meta_window_activate (w, + &window->display->devices->keyboards[0], + timestamp); break; } diff --git a/src/devices.c b/src/devices.c new file mode 100644 index 00000000..d873cfdc --- /dev/null +++ b/src/devices.c @@ -0,0 +1,111 @@ +/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */ + +/* Metacity device functions */ + +/* + * Copyright (C) 2007 Paulo Ricardo Zanoni + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA + * 02111-1307, USA. + */ + +#include <config.h> + +#include "devices.h" +#include "common.h" +#include "util.h" +#include "display.h" + +#include <string.h> + +#ifdef MPX +/* TODO: if these were macros, metacity would be faster! */ + +/* Should we :%s/find/get/g ??? */ + +MetaDevInfo* +meta_devices_find_mouse_by_name (MetaDisplay *display, + gchar *name) +{ + int i; + + for (i = 0; i < display->devices->miceUsed; i++) + if (strcmp(name, display->devices->mice[i].name) == 0) + return &display->devices->mice[i]; + + meta_warning ("Error! Could not find mouse named %s!\n", name); + + return NULL; +} + +MetaDevInfo* +meta_devices_find_mouse_by_id (MetaDisplay *display, + XID id) +{ + int i; + + for (i = 0; i < display->devices->miceUsed; i++) + if (id == display->devices->mice[i].xdev->device_id) + return &display->devices->mice[i]; + meta_warning ("Error! Could not find mouse XID = %d!\n", (int) id); + + return NULL; +} + +MetaDevInfo* +meta_devices_find_keyboard_by_id (MetaDisplay *display, + XID id) +{ + int i; + + for (i = 0; i < display->devices->keybsUsed; i++) + if (id == display->devices->keyboards[i].xdev->device_id) + return &display->devices->keyboards[i]; + + meta_warning ("Error! Could not find keyboard XID = %d\n", (int) id); + + return NULL; +} + +MetaDevInfo* +meta_devices_find_paired_mouse (MetaDisplay *display, XID id) +{ + int i; + + for (i = 0; i < display->devices->keybsUsed; i++) + if (id == display->devices->keyboards[i].xdev->device_id) + return &display->devices->pairedPointers[i]; + + meta_warning("Error! Could not find mouse paired with keyboard XID = %d\n", + (int) id); + + return NULL; +} + +MetaDevInfo* +meta_devices_find_paired_keyboard (MetaDisplay *display, XID id) +{ + int i; + + for (i = 0; i < display->devices->keybsUsed; i++) + if (id == display->devices->pairedPointers[i].xdev->device_id) + return &display->devices->keyboards[i]; + + meta_warning("Error! Could not find keyboard paired with mouse XID = %d\n", + (int) id); + + return NULL; +} +#endif diff --git a/src/devices.h b/src/devices.h index 10be1456..73adff4d 100644 --- a/src/devices.h +++ b/src/devices.h @@ -29,6 +29,7 @@ #include <X11/extensions/XInput.h> #include "common.h" +/* #include "display.h" XXX ? */ /* By default, the MetaDevInfo lists have size 8. Almost no client has more * than 8 mice or keyboards... */ @@ -36,8 +37,12 @@ #define DEFAULT_INPUT_ARRAY_SIZE 8 typedef struct _MetaDevices MetaDevices; + /* typedef struct _MetaDevInfo MetaDevInfo; This guy was declared at common.h */ +/* TODO: create MetaPtrInfo and MetaKbdInfo, so that you can differentiate it + * and force correct type using in function prototypes */ + struct _MetaDevInfo { XDevice *xdev; @@ -51,11 +56,28 @@ struct _MetaDevices int miceSize; MetaDevInfo *keyboards; - int keybsUsed; - int keybsSize; + int keybsUsed; /* XXX :%s/keybsUsed/kbdsUsed/g or something else? */ + int keybsSize; /* I don't like "keybs" */ MetaDevInfo *pairedPointers; }; +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_keyboard_by_id (MetaDisplay *display, + XID id); + +MetaDevInfo* meta_devices_find_paired_mouse (MetaDisplay *display, + XID id); + +MetaDevInfo* meta_devices_find_paired_keyboard (MetaDisplay *display, + XID id); + +#else +#error "This branch will ONLY compile if you enable --enable-mpx!" #endif #endif diff --git a/src/display.c b/src/display.c index 14ef5b0e..94c415ed 100644 --- a/src/display.c +++ b/src/display.c @@ -42,6 +42,7 @@ #include "bell.h" #include "effects.h" #include "compositor.h" +#include "devices.h" #include <X11/Xatom.h> #include <X11/cursorfont.h> #ifdef HAVE_SOLARIS_XINERAMA @@ -528,6 +529,102 @@ meta_display_open (void) display->events = NULL; +#ifdef MPX + { + /* Check to see the available input devices */ + + XDeviceInfo *devsInfo, *devInfo, *auxDevsInfo, *auxDevInfo; + int howManyDevices, i, j; + + XID pDevId; + XDevice *kDev; + XDevice *open; + MetaDevices *d; + + display->devices = g_malloc(sizeof(MetaDevices)); + + d = display->devices; + + /* We should register ourselves as the pairing client here + * XXX XRegisterPairingClient */ + + d->mice = g_malloc(sizeof(XID) * DEFAULT_INPUT_ARRAY_SIZE); + d->keyboards = g_malloc(sizeof(XID) * DEFAULT_INPUT_ARRAY_SIZE); + d->pairedPointers = g_malloc(sizeof(XID) * DEFAULT_INPUT_ARRAY_SIZE); + + d->miceUsed = 0; + d->miceSize = DEFAULT_INPUT_ARRAY_SIZE; + d->keybsUsed = 0; + d->keybsSize = DEFAULT_INPUT_ARRAY_SIZE; + + devsInfo = XListInputDevices(display->xdisplay, &howManyDevices); + for (i = 0; i < howManyDevices; i++) + { + devInfo = &devsInfo[i]; + + if (devInfo->use == IsXExtensionKeyboard) + { + if (d->keybsUsed == d->keybsSize) + { + /* FIXME This is broken! See comment in devices.h! */ + d->keyboards = g_realloc (d->keyboards, + sizeof(XID) * (d->keybsSize + DEFAULT_INPUT_ARRAY_SIZE)); + d->pairedPointers = g_realloc(d->pairedPointers, + sizeof(XID) * (d->keybsSize + DEFAULT_INPUT_ARRAY_SIZE)); + d->keybsSize += DEFAULT_INPUT_ARRAY_SIZE; + } + + meta_warning("opening deivce id %d, name %s\n", + (int)devInfo->id, devInfo->name); /* XXX */ + kDev = XOpenDevice(display->xdisplay, devInfo->id); + d->keyboards[d->keybsUsed].xdev = kDev; + d->keyboards[d->keybsUsed].name = + g_strdup_printf("%s", devInfo->name); + + XGetPairedPointer(display->xdisplay, kDev, &pDevId); + meta_warning("opening paired device id %d\n", + (int)pDevId); /* XXX */ + open = XOpenDevice(display->xdisplay, pDevId); + d->pairedPointers[d->keybsUsed].xdev = open; + + /* Look in the device list for a device with the id pDevId + * and then find its name */ + auxDevsInfo = devsInfo; + for (j = 0; j < howManyDevices; j++) + { + auxDevInfo = &auxDevsInfo[j]; + if (auxDevInfo->id == pDevId) + break; + + } + /* XXX if howManyDevices < 1, auxDevInfo is invalid and we will + * segfault here... */ + d->pairedPointers[d->keybsUsed].name = + g_strdup_printf("%s", auxDevInfo->name); + d->keybsUsed++; + meta_warning(" device name = %s\n", auxDevInfo->name); /* XXX */ + } + else if (devInfo->use == IsXExtensionPointer) + { + if (d->miceUsed == d->miceSize) + { + d->mice = g_realloc(d->mice, + sizeof(XID) * (d->miceSize + DEFAULT_INPUT_ARRAY_SIZE)); + d->miceSize += DEFAULT_INPUT_ARRAY_SIZE; + } + meta_warning("opening device id %d, name %s\n", + (int)devInfo->id, devInfo->name); /* XXX */ + open = XOpenDevice(display->xdisplay, devInfo->id); + d->mice[d->miceUsed].xdev = open; + d->mice[d->miceUsed].name = g_strdup_printf("%s", devInfo->name); + d->miceUsed++; + } + } + XFreeDeviceList(devsInfo); + + } +#endif + /* Get events */ meta_ui_add_event_func (display->xdisplay, event_callback, @@ -744,7 +841,7 @@ meta_display_open (void) } meta_display_grab (display); - + /* Now manage all existing windows */ tmp = display->screens; while (tmp != NULL) @@ -759,38 +856,71 @@ meta_display_open (void) { Window focus; int ret_to; +#ifdef MPX + Time unused; +#endif /* kinda bogus because GetInputFocus has no possible errors */ meta_error_trap_push (display); /* FIXME: This is totally broken; see comment 9 of bug 88194 about this */ - focus = None; - ret_to = RevertToPointerRoot; - XGetInputFocus (display->xdisplay, &focus, &ret_to); +#ifdef MPX + for (i = 0; i < display->devices->miceUsed; i++) + { +#endif + focus = None; + ret_to = RevertToPointerRoot; +#ifdef MPX + XGetDeviceFocus (display->xdisplay, display->devices->mice[i].xdev, + &focus, &ret_to, &unused); +#endif - /* Force a new FocusIn (does this work?) */ + /* Force a new FocusIn (does this work?) */ - /* Use the same timestamp that was passed to meta_screen_new(), - * as it is the most recent timestamp. - */ - if (focus == None || focus == PointerRoot) - /* Just focus the no_focus_window on the first screen */ - meta_display_focus_the_no_focus_window (display, - display->screens->data, - timestamp); - else - { - MetaWindow * window; - window = meta_display_lookup_x_window (display, focus); - if (window) - meta_display_set_input_focus_window (display, window, FALSE, timestamp); - else + /* Use the same timestamp that was passed to meta_screen_new(), + * as it is the most recent timestamp. + */ + if (focus == None || focus == PointerRoot) /* Just focus the no_focus_window on the first screen */ +#ifdef MPX meta_display_focus_the_no_focus_window (display, + &display->devices->mice[i], display->screens->data, timestamp); +#else + meta_display_focus_the_no_focus_window (display, + display->screens->data, + timestamp); +#endif + else + { + MetaWindow * window; + window = meta_display_lookup_x_window (display, focus); + if (window) +#ifdef MPX + meta_display_set_input_focus_window (display, + &display->devices->mice[i], + window, FALSE, timestamp); +#else + meta_display_set_input_focus_window (display, window, + FALSE, timestamp); +#endif + else + /* Just focus the no_focus_window on the first screen */ +#ifdef MPX + meta_display_focus_the_no_focus_window (display, + &display->devices->mice[i], + display->screens->data, + timestamp); +#else + meta_display_focus_the_no_focus_window (display, + display->screens->data, + timestamp); +#endif + } +#ifdef MPX } - +#endif meta_error_trap_pop (display, FALSE); } @@ -798,99 +928,7 @@ meta_display_open (void) if (meta_prefs_get_compositing_manager ()) enable_compositor (display); - -#ifdef MPX - { - /* Check to see the available input devices */ - - XDeviceInfo *devsInfo, *devInfo, *auxDevsInfo, *auxDevInfo; - int howManyDevices, i, j; - - XID pDevId; - XDevice *kDev; - XDevice *open; - MetaDevices *d; - - d = &display->devices; - - /* We should register ourselves as the pairing client here - * XXX XRegisterPairingClient */ - - d->mice = g_malloc(sizeof(XID) * DEFAULT_INPUT_ARRAY_SIZE); - d->keyboards = g_malloc(sizeof(XID) * DEFAULT_INPUT_ARRAY_SIZE); - d->pairedPointers = g_malloc(sizeof(XID) * DEFAULT_INPUT_ARRAY_SIZE); - - d->miceUsed = 0; - d->miceSize = DEFAULT_INPUT_ARRAY_SIZE; - d->keybsUsed = 0; - d->keybsSize = DEFAULT_INPUT_ARRAY_SIZE; - - devsInfo = XListInputDevices(display->xdisplay, &howManyDevices); - for (i = 0; i < howManyDevices; i++) - { - devInfo = &devsInfo[i]; - - if (devInfo->use == IsXExtensionKeyboard) - { - if (d->keybsUsed == d->keybsSize) - { - /* FIXME This is broken! See comment in devices.h! */ - d->keyboards = g_realloc (d->keyboards, - sizeof(XID) * (d->keybsSize + DEFAULT_INPUT_ARRAY_SIZE)); - d->pairedPointers = g_realloc(d->pairedPointers, - sizeof(XID) * (d->keybsSize + DEFAULT_INPUT_ARRAY_SIZE)); - d->keybsSize += DEFAULT_INPUT_ARRAY_SIZE; - } - - meta_warning("opening deivce id %d, name %s\n", - (int)devInfo->id, devInfo->name); /* XXX */ - kDev = XOpenDevice(display->xdisplay, devInfo->id); - d->keyboards[d->keybsUsed].xdev = kDev; - d->keyboards[d->keybsUsed].name = - g_strdup_printf("%s", devInfo->name); - - XGetPairedPointer(display->xdisplay, kDev, &pDevId); - meta_warning("opening device id %d\n", - (int)pDevId); /* XXX */ - open = XOpenDevice(display->xdisplay, pDevId); - d->pairedPointers[d->keybsUsed].xdev = open; - - /* Look in the device list for a device with the id pDevId - * and then find its name */ - auxDevsInfo = devsInfo; - for (j = 0; j < howManyDevices; j++) - { - auxDevInfo = &auxDevsInfo[j]; - if (auxDevInfo->id == pDevId) - break; - - } - d->pairedPointers[d->keybsUsed].name = - g_strdup_printf("%s", auxDevInfo->name); - d->keybsUsed++; - meta_warning(" name = %s\n", auxDevInfo->name); /* XXX */ - } - else if (devInfo->use == IsXExtensionPointer) - { - if (d->miceUsed == d->miceSize) - { - d->mice = g_realloc(d->mice, - sizeof(XID) * (d->miceSize + DEFAULT_INPUT_ARRAY_SIZE)); - d->miceSize += DEFAULT_INPUT_ARRAY_SIZE; - } - meta_warning("opening device id %d, name %s\n", - (int)devInfo->id, devInfo->name); /* XXX */ - open = XOpenDevice(display->xdisplay, devInfo->id); - d->mice[d->miceUsed].xdev = open; - d->mice[d->miceUsed].name = g_strdup_printf("%s", devInfo->name); - d->miceUsed++; - } - } - XFreeDeviceList(devsInfo); - - } -#endif - + /* Done opening new display */ display->display_opening = FALSE; @@ -1191,6 +1229,7 @@ grab_op_is_mouse_only (MetaGrabOp op) static gboolean grab_op_is_mouse (MetaGrabOp op) { +// meta_warning("meta_grab_op = %d\n", op); switch (op) { case META_GRAB_OP_MOVING: @@ -1411,12 +1450,14 @@ window_raise_with_delay_callback (void *data) unsigned int mask; gboolean same_screen; gboolean point_in_window; + Bool shared; meta_error_trap_push (window->display); - same_screen = XQueryPointer (window->display->xdisplay, - window->xwindow, - &root, &child, - &root_x, &root_y, &x, &y, &mask); + same_screen = XQueryDevicePointer (window->display->xdisplay, + /* XXX */ window->display->devices->mice[0].xdev, + window->xwindow, + &root, &child, &root_x, &root_y, + &x, &y, &mask, &shared); meta_error_trap_pop (window->display, TRUE); point_in_window = @@ -1508,6 +1549,9 @@ event_callback (XEvent *event, Window modified; gboolean frame_was_receiver; gboolean filter_out_event; +#ifdef MPX + XDeviceButtonEvent *xdbe; /* Move this somewhere else? */ +#endif display = data; @@ -1523,7 +1567,28 @@ event_callback (XEvent *event, display->xinerama_cache_invalidated = TRUE; modified = event_get_modified_window (display, event); - + +/* XXX */ + if (event->type == display->dev_btn_press_type) + { + XDeviceButtonPressedEvent *xdbe; + xdbe = (XDeviceButtonPressedEvent *)event; + meta_warning("event_callback: XDeviceButtonPress received... XID = %d\n", + xdbe->deviceid); +// return 0; + } +/* XXX */ + +#ifdef MPX + if (event->type == display->dev_btn_press_type) + { + xdbe = (XDeviceButtonPressedEvent *) event; + /* filter out scrollwheel */ + if (xdbe->button == 4 || + xdbe->button == 5) + return FALSE; + } +#else if (event->type == ButtonPress) { /* filter out scrollwheel */ @@ -1531,6 +1596,7 @@ event_callback (XEvent *event, event->xbutton.button == 5) return FALSE; } +#endif else if (event->type == UnmapNotify) { if (meta_ui_window_should_not_cause_focus (display->xdisplay, @@ -1575,7 +1641,7 @@ event_callback (XEvent *event, modified == window->frame->xwindow) { /* Note that if the frame and the client both have an - * XGrabButton (as is normal with our setup), the event + * XDeviceGrabButton (as is normal with our setup), the event * goes to the frame. */ frame_was_receiver = TRUE; @@ -1648,7 +1714,8 @@ event_callback (XEvent *event, } #endif /* HAVE_SHAPE */ - if (window && ((event->type == KeyPress) || (event->type == ButtonPress))) + if (window && ((event->type == display->dev_key_press_type) || + (event->type == display->dev_btn_press_type))) { if (CurrentTime == display->current_time) { @@ -1669,209 +1736,9 @@ event_callback (XEvent *event, switch (event->type) { - case KeyPress: - case KeyRelease: - meta_display_process_key_event (display, window, event); - break; - case ButtonPress: - if ((window && - grab_op_is_mouse (display->grab_op) && - display->grab_button != (int) event->xbutton.button && - display->grab_window == window) || - grab_op_is_keyboard (display->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)) - { - MetaScreen *screen; - meta_topic (META_DEBUG_WINDOW_OPS, - "Syncing to old stack positions.\n"); - screen = - meta_display_screen_for_root (display, event->xany.window); - meta_stack_set_positions (screen->stack, - display->grab_old_window_stacking); - } - meta_display_end_grab_op (display, - event->xbutton.time); - } - else if (window && display->grab_op == META_GRAB_OP_NONE) - { - gboolean begin_move = FALSE; - unsigned int grab_mask; - gboolean unmodified; - - grab_mask = display->window_grab_modifiers; - if (g_getenv ("METACITY_DEBUG_BUTTON_GRABS")) - grab_mask |= ControlMask; - - /* Two possible sources of an unmodified event; one is a - * client that's letting button presses pass through to the - * frame, the other is our focus_window_grab on unmodified - * button 1. So for all such events we focus the window. - */ - unmodified = (event->xbutton.state & grab_mask) == 0; - - if (unmodified || - event->xbutton.button == 1) - { - /* don't focus if frame received, will be lowered in - * frames.c or special-cased if the click was on a - * minimize/close button. - */ - if (!frame_was_receiver) - { - if (meta_prefs_get_raise_on_click ()) - meta_window_raise (window); - else - meta_topic (META_DEBUG_FOCUS, - "Not raising window on click due to don't-raise-on-click option\n"); - - /* Don't focus panels--they must explicitly request focus. - * See bug 160470 - */ - if (window->type != META_WINDOW_DOCK) - { - meta_topic (META_DEBUG_FOCUS, - "Focusing %s due to unmodified button %u press (display.c)\n", - window->desc, event->xbutton.button); - meta_window_focus (window, event->xbutton.time); - } - else - /* However, do allow terminals to lose focus due to new - * window mappings after the user clicks on a panel. - */ - display->allow_terminal_deactivation = TRUE; - } - - /* you can move on alt-click but not on - * the click-to-focus - */ - if (!unmodified) - begin_move = TRUE; - } - else if (!unmodified && event->xbutton.button == 2) - { - if (window->has_resize_func) - { - gboolean north, south; - gboolean west, east; - int root_x, root_y; - MetaGrabOp op; - - meta_window_get_position (window, &root_x, &root_y); - - west = event->xbutton.x_root < (root_x + 1 * window->rect.width / 3); - east = event->xbutton.x_root > (root_x + 2 * window->rect.width / 3); - north = event->xbutton.y_root < (root_y + 1 * window->rect.height / 3); - south = event->xbutton.y_root > (root_y + 2 * window->rect.height / 3); - - if (north && west) - op = META_GRAB_OP_RESIZING_NW; - else if (north && east) - op = META_GRAB_OP_RESIZING_NE; - else if (south && west) - op = META_GRAB_OP_RESIZING_SW; - else if (south && east) - op = META_GRAB_OP_RESIZING_SE; - else if (north) - op = META_GRAB_OP_RESIZING_N; - else if (west) - op = META_GRAB_OP_RESIZING_W; - else if (east) - op = META_GRAB_OP_RESIZING_E; - else if (south) - op = META_GRAB_OP_RESIZING_S; - else /* Middle region is no-op to avoid user triggering wrong action */ - op = META_GRAB_OP_NONE; - - if (op != META_GRAB_OP_NONE) - meta_display_begin_grab_op (display, - window->screen, - window, - op, - TRUE, - FALSE, - event->xbutton.button, - 0, - event->xbutton.time, - event->xbutton.x_root, - event->xbutton.y_root); - } - } - else if (event->xbutton.button == 3) - { - if (meta_prefs_get_raise_on_click ()) - meta_window_raise (window); - meta_window_show_menu (window, - event->xbutton.x_root, - event->xbutton.y_root, - event->xbutton.button, - event->xbutton.time); - } - - if (!frame_was_receiver && unmodified) - { - /* This is from our synchronous grab since - * it has no modifiers and was on the client window - */ - int mode; - - /* When clicking a different app in click-to-focus - * in application-based mode, and the different - * app is not a dock or desktop, eat the focus click. - */ - if (meta_prefs_get_focus_mode () == META_FOCUS_MODE_CLICK && - meta_prefs_get_application_based () && - !window->has_focus && - window->type != META_WINDOW_DOCK && - window->type != META_WINDOW_DESKTOP && - (display->focus_window == NULL || - !meta_window_same_application (window, - display->focus_window))) - mode = AsyncPointer; /* eat focus click */ - else - mode = ReplayPointer; /* give event back */ - - meta_verbose ("Allowing events mode %s time %u\n", - mode == AsyncPointer ? "AsyncPointer" : "ReplayPointer", - (unsigned int)event->xbutton.time); - - XAllowEvents (display->xdisplay, - mode, event->xbutton.time); - } - - if (begin_move && window->has_move_func) - { - meta_display_begin_grab_op (display, - window->screen, - window, - META_GRAB_OP_MOVING, - TRUE, - FALSE, - event->xbutton.button, - 0, - event->xbutton.time, - event->xbutton.x_root, - event->xbutton.y_root); - } - } - break; - case ButtonRelease: - if (display->grab_window == window && - grab_op_is_mouse (display->grab_op)) - meta_window_handle_mouse_grab_op_event (window, event); - break; - case MotionNotify: - if (display->grab_window == window && - grab_op_is_mouse (display->grab_op)) - meta_window_handle_mouse_grab_op_event (window, event); - break; case EnterNotify: +// meta_warning("got a EnterNotify event!!! this should not happen!!!\n"); +#if 0 if (display->grab_window == window && grab_op_is_mouse (display->grab_op)) { @@ -1963,8 +1830,11 @@ event_callback (XEvent *event, if (window->type == META_WINDOW_DOCK) meta_window_raise (window); } +#endif break; case LeaveNotify: +// meta_warning("Recived LeaveNotify! Something is wrong!\n"); +#if 0 if (display->grab_window == window && grab_op_is_mouse (display->grab_op)) meta_window_handle_mouse_grab_op_event (window, event); @@ -1976,60 +1846,7 @@ event_callback (XEvent *event, !window->has_focus) meta_window_lower (window); } - break; - case FocusIn: - case FocusOut: - if (window) - { - meta_window_notify_focus (window, event); - } - else if (meta_display_xwindow_is_a_no_focus_window (display, - event->xany.window)) - { - meta_topic (META_DEBUG_FOCUS, - "Focus %s event received on no_focus_window 0x%lx " - "mode %s detail %s\n", - event->type == FocusIn ? "in" : - event->type == FocusOut ? "out" : - "???", - event->xany.window, - meta_event_mode_to_string (event->xfocus.mode), - meta_event_detail_to_string (event->xfocus.detail)); - } - else if (meta_display_screen_for_root (display, - event->xany.window) != NULL) - { - MetaScreen * screen; - screen = meta_display_screen_for_root (display, event->xany.window); - - meta_topic (META_DEBUG_FOCUS, - "Focus %s event received on root window 0x%lx " - "mode %s detail %s\n", - event->type == FocusIn ? "in" : - event->type == FocusOut ? "out" : - "???", - event->xany.window, - meta_event_mode_to_string (event->xfocus.mode), - meta_event_detail_to_string (event->xfocus.detail)); - - if (event->type == FocusIn && - event->xfocus.detail == NotifyDetailNone) - { - meta_topic (META_DEBUG_FOCUS, - "Focus got set to None, probably due to brain-damage in the X protocol (see bug 125492). Setting the default focus window.\n"); - - meta_workspace_focus_default_window (screen->active_workspace, NULL, meta_display_get_current_time_roundtrip (display)); - } - else if (event->type == FocusIn && - event->xfocus.mode == NotifyNormal && - event->xfocus.detail == NotifyInferior) - { - meta_topic (META_DEBUG_FOCUS, - "Focus got set to root window, probably due to gnome-session logout dialog usage (see bug 153220). Setting the default focus window.\n"); - meta_workspace_focus_default_window (screen->active_workspace, NULL, meta_display_get_current_time_roundtrip (display)); - } - - } +#endif break; case KeymapNotify: break; @@ -2056,7 +1873,7 @@ event_callback (XEvent *event, if (display->grab_op != META_GRAB_OP_NONE && display->grab_window == window) - meta_display_end_grab_op (display, timestamp); + meta_display_end_grab_op (display, NULL, timestamp); if (frame_was_receiver) { @@ -2087,7 +1904,7 @@ event_callback (XEvent *event, if (display->grab_op != META_GRAB_OP_NONE && display->grab_window == window && ((window->frame == NULL) || !window->frame->mapped)) - meta_display_end_grab_op (display, timestamp); + meta_display_end_grab_op (display, NULL, timestamp); /* XXX ? */ if (!frame_was_receiver) { @@ -2126,8 +1943,12 @@ event_callback (XEvent *event, case MapRequest: if (window == NULL) { + /* So, here we are, at the top level of window creating. When we + * create a window we sometimes focus them. But, which device should + * we associate with the focus????????????? */ window = meta_window_new (display, event->xmaprequest.window, - FALSE); + FALSE, + &display->devices->keyboards[0]); } /* if frame was receiver it's some malicious send event or something */ else if (!frame_was_receiver && window) @@ -2364,7 +2185,7 @@ event_callback (XEvent *event, else { meta_screen_unshow_desktop (screen); - meta_workspace_focus_default_window (screen->active_workspace, NULL, timestamp); + meta_workspace_focus_default_window (screen->active_workspace, &display->devices->keyboards[0], NULL, timestamp); /* XXX */ } } else if (event->xclient.message_type == @@ -2451,6 +2272,441 @@ event_callback (XEvent *event, } break; default: +#ifdef MPX +/* XXX correct indentation */ + + if (event->type == display->dev_key_press_type || + event->type == display->dev_key_release_type) + meta_display_process_key_event (display, window, + (XDeviceKeyEvent *)event); + + else if (event->type == display->dev_btn_press_type) + { + meta_warning("recived XDeviceButtonPress event!\n"); + + MetaDevInfo *dev; /* XXX declare here? */ + 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)) + { + 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)) + { + 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_display_end_grab_op (display, + dev, + xdbe->time); + } + else if (window && display->grab_op == META_GRAB_OP_NONE) + { + gboolean begin_move = FALSE; + unsigned int grab_mask; + gboolean unmodified; + + grab_mask = display->window_grab_modifiers; + if (g_getenv ("METACITY_DEBUG_BUTTON_GRABS")) + grab_mask |= ControlMask; + + /* Two possible sources of an unmodified event; one is a + * client that's letting button presses pass through to the + * frame, the other is our focus_window_grab on unmodified + * button 1. So for all such events we focus the window. + */ + unmodified = (xdbe->state & grab_mask) == 0; + + if (unmodified || + xdbe->button == 1) + { + /* don't focus if frame received, will be lowered in + * frames.c or special-cased if the click was on a + * minimize/close button. + */ + if (!frame_was_receiver) + { + if (meta_prefs_get_raise_on_click ()) + meta_window_raise (window); + else + meta_topic (META_DEBUG_FOCUS, + "Not raising window on click due to don't-raise-on-click option\n"); + + /* Don't focus panels--they must explicitly request focus. + * See bug 160470 + */ + if (window->type != META_WINDOW_DOCK) + { + meta_topic (META_DEBUG_FOCUS, + "Focusing %s due to unmodified button %u press (display.c)\n", + window->desc, xdbe->button); + meta_window_focus (window, dev, xdbe->time); + } + else + /* However, do allow terminals to lose focus due to new + * window mappings after the user clicks on a panel. + */ + display->allow_terminal_deactivation = TRUE; + } + + /* you can move on alt-click but not on + * the click-to-focus + */ + if (!unmodified) + begin_move = TRUE; + } + else if (!unmodified && xdbe->button == 2) + { + if (window->has_resize_func) + { + gboolean north, south; + gboolean west, east; + int root_x, root_y; + MetaGrabOp op; + + meta_window_get_position (window, &root_x, &root_y); + + west = xdbe->x_root < (root_x + 1 * window->rect.width / 3); + east = xdbe->x_root > (root_x + 2 * window->rect.width / 3); + north = xdbe->y_root < (root_y + 1 * window->rect.height / 3); + south = xdbe->y_root > (root_y + 2 * window->rect.height / 3); + + if (north && west) + op = META_GRAB_OP_RESIZING_NW; + else if (north && east) + op = META_GRAB_OP_RESIZING_NE; + else if (south && west) + op = META_GRAB_OP_RESIZING_SW; + else if (south && east) + op = META_GRAB_OP_RESIZING_SE; + else if (north) + op = META_GRAB_OP_RESIZING_N; + else if (west) + op = META_GRAB_OP_RESIZING_W; + else if (east) + op = META_GRAB_OP_RESIZING_E; + else if (south) + op = META_GRAB_OP_RESIZING_S; + else /* Middle region is no-op to avoid user triggering wrong action */ + op = META_GRAB_OP_NONE; + + if (op != META_GRAB_OP_NONE) + { + meta_display_begin_grab_op (display, + window->screen, + dev, + window, + op, + TRUE, + FALSE, + xdbe->button, + 0, + xdbe->time, + xdbe->x_root, + xdbe->y_root); + } + } + } + else if (xdbe->button == 3) + { + if (meta_prefs_get_raise_on_click ()) + meta_window_raise (window); + meta_window_show_menu (window, + xdbe->x_root, + xdbe->y_root, + xdbe->button, + xdbe->time); + } + + if (!frame_was_receiver && unmodified) + { + /* This is from our synchronous grab since + * it has no modifiers and was on the client window + */ + int mode; + + /* When clicking a different app in click-to-focus + * in application-based mode, and the different + * app is not a dock or desktop, eat the focus click. + */ + if (meta_prefs_get_focus_mode () == META_FOCUS_MODE_CLICK && + meta_prefs_get_application_based () && + !window->has_focus && + window->type != META_WINDOW_DOCK && + window->type != META_WINDOW_DESKTOP && + (display->focus_window == NULL || + !meta_window_same_application (window, + display->focus_window))) + mode = AsyncPointer; /* eat focus click */ + else + mode = ReplayPointer; /* give event back */ + + meta_verbose ("Allowing events mode %s time %u\n", + mode == AsyncPointer ? "AsyncPointer" : "ReplayPointer", + (unsigned int)xdbe->time); + + XAllowDeviceEvents (display->xdisplay, dev->xdev, + mode, xdbe->time); + } + + if (begin_move && window->has_move_func) + { + + meta_display_begin_grab_op (display, + window->screen, + dev, + window, + META_GRAB_OP_MOVING, + TRUE, + FALSE, + xdbe->button, + 0, + xdbe->time, + xdbe->x_root, + xdbe->y_root); + } + } + } + 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); + } + 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); + } + } + else if (event->type == display->dev_focus_in_type || + event->type == display->dev_focus_out_type) + { + XDeviceFocusChangeEvent *xdfc; + MetaDevInfo *dev; + + xdfc = (XDeviceFocusChangeEvent *)event; + dev = meta_devices_find_keyboard_by_id (display, xdfc->deviceid); + +// meta_warning("recived XDeviceFocusChange\n"); + + if (window) + { + meta_window_notify_focus (window, event); + } + else if (meta_display_xwindow_is_a_no_focus_window (display, + xdfc->window)) + { + meta_topic (META_DEBUG_FOCUS, + "Focus %s event received on no_focus_window 0x%lx " + "mode %s detail %s\n", + event->type == display->dev_focus_in_type ? "in" : + event->type == display->dev_focus_out_type ? "out" : + "???", + xdfc->window, + meta_event_mode_to_string (xdfc->mode), + meta_event_detail_to_string (xdfc->detail)); + } + else if (meta_display_screen_for_root (display, + event->xany.window) != NULL) + { + MetaScreen * screen; + screen = meta_display_screen_for_root (display, event->xany.window); + + meta_topic (META_DEBUG_FOCUS, + "Focus %s event received on root window 0x%lx " + "mode %s detail %s\n", + event->type == display->dev_focus_in_type ? "in" : + event->type == display->dev_focus_out_type ? "out" : + "???", + xdfc->window, + meta_event_mode_to_string (xdfc->mode), + meta_event_detail_to_string (xdfc->detail)); + + if (event->type == display->dev_focus_in_type && + xdfc->detail == NotifyDetailNone) + { + meta_topic (META_DEBUG_FOCUS, + "Focus got set to None, probably due to brain-damage in the X protocol (see bug 125492). Setting the default focus window.\n"); + + meta_workspace_focus_default_window (screen->active_workspace, dev, NULL, meta_display_get_current_time_roundtrip (display)); + } + else if (event->type == display->dev_focus_in_type && + xdfc->mode == NotifyNormal && + xdfc->detail == NotifyInferior) + { + meta_topic (META_DEBUG_FOCUS, + "Focus got set to root window, probably due to gnome-session logout dialog usage (see bug 153220). Setting the default focus window.\n"); + meta_workspace_focus_default_window (screen->active_workspace, dev, NULL, meta_display_get_current_time_roundtrip (display)); + } + + } + } + 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); + +// 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; + } + + /* If the mouse switches screens, active the default window on the new + * screen; this will make keybindings and workspace-launched items + * actually appear on the right screen. + */ + if (display->active_screen != + meta_display_screen_for_root (display, xdce->root)) + { + MetaScreen *new_screen; + new_screen = meta_display_screen_for_root (display, + xdce->root); + meta_workspace_focus_default_window (new_screen->active_workspace, + dev, + NULL, + xdce->time); + } + + /* Check if we've entered a window; do this even if window->has_focus to + * avoid races. + */ + if (window && !serial_is_ignored (display, xdce->serial) && + xdce->mode != NotifyGrab && + xdce->mode != NotifyUngrab && + xdce->detail != NotifyInferior && + meta_display_focus_sentinel_clear (display)) + { + switch (meta_prefs_get_focus_mode ()) + { + case META_FOCUS_MODE_SLOPPY: + case META_FOCUS_MODE_MOUSE: + display->mouse_mode = TRUE; + if (window->type != META_WINDOW_DOCK && + window->type != META_WINDOW_DESKTOP) + { + meta_topic (META_DEBUG_FOCUS, + "Focusing %s due to enter notify with serial %lu " + "at time %lu, and setting display->mouse_mode to " + "TRUE.\n", + window->desc, + xdce->serial, + xdce->time); + + meta_window_focus (window, dev, xdce->time); + + /* stop ignoring stuff */ + reset_ignores (display); + + if (meta_prefs_get_auto_raise ()) + { + meta_display_queue_autoraise_callback (display, window); + } + else + { + meta_topic (META_DEBUG_FOCUS, + "Auto raise is disabled\n"); + } + } + /* In mouse focus mode, we defocus when the mouse *enters* + * the DESKTOP window, instead of defocusing on LeaveNotify. + * This is because having the mouse enter override-redirect + * child windows unfortunately causes LeaveNotify events that + * we can't distinguish from the mouse actually leaving the + * toplevel window as we expect. But, since we filter out + * EnterNotify events on override-redirect windows, this + * alternative mechanism works great. + */ + if (window->type == META_WINDOW_DESKTOP && + meta_prefs_get_focus_mode() == META_FOCUS_MODE_MOUSE && + display->expected_focus_window != NULL) + { + meta_topic (META_DEBUG_FOCUS, + "Unsetting focus from %s due to mouse entering " + "the DESKTOP window\n", + display->expected_focus_window->desc); + meta_display_focus_the_no_focus_window (display, + dev, + window->screen, + xdce->time); + } + break; + case META_FOCUS_MODE_CLICK: + break; + } + + if (window->type == META_WINDOW_DOCK) + meta_window_raise (window); + } + } + else if (event->type == display->dev_leave_notify_type) + { + XDeviceCrossingEvent *xdce; + + 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"); + + + if (display->grab_window == window && + grab_op_is_mouse (display->grab_op)) + meta_window_handle_mouse_grab_op_event (window, event); + else if (window != NULL) + { + if (window->type == META_WINDOW_DOCK && + xdce->mode != NotifyGrab && + xdce->mode != NotifyUngrab && + !window->has_focus) + meta_window_lower (window); + } + } + +#endif + #ifdef HAVE_XKB if (event->type == display->xkb_base_event_type) { @@ -2562,6 +2818,32 @@ event_get_modified_window (MetaDisplay *display, } #endif + 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; + else if (event->type == display->dev_motion_notify_type) + return ((XDeviceMotionEvent *)event)->window; + else if (event->type == display->dev_ptr_motion_hint_type) + { + meta_warning("received dev_ptr_motion_hint_type event!" + " returning NULL for its window!\n"); + return None; + } + else if (event->type == display->dev_enter_notify_type) + return ((XDeviceEnterWindowEvent *)event)->window; + else if (event->type == display->dev_leave_notify_type) + return ((XDeviceLeaveWindowEvent *)event)->window; + else if (event->type == display->dev_focus_in_type) + return ((XDeviceFocusInEvent *)event)->window; + else if (event->type == display->dev_focus_out_type) + return ((XDeviceFocusOutEvent *)event)->window; + + meta_warning("=======================\n" + "event_get_modified_window returning None for event->type == %d\n" + "display = 0x%x\n" + "=======================================================\n", + event->type, (int)display); return None; } } @@ -3241,28 +3523,38 @@ xcursor_for_op (MetaDisplay *display, } void +#ifdef MPX meta_display_set_grab_op_cursor (MetaDisplay *display, MetaScreen *screen, + MetaDevInfo *dev, MetaGrabOp op, gboolean change_pointer, Window grab_xwindow, guint32 timestamp) +#endif { Cursor cursor; cursor = xcursor_for_op (display, op); +#ifndef MPX #define GRAB_MASK (PointerMotionMask | \ ButtonPressMask | ButtonReleaseMask | \ EnterWindowMask | LeaveWindowMask) +#endif if (change_pointer) { meta_error_trap_push_with_return (display); +#ifdef MPX + /* XXX Implement this!!! How?? */ + meta_warning("I'm supposed to cast the analogous Xi function for XChangeActivePointerGrab!\n"); +#else XChangeActivePointerGrab (display->xdisplay, GRAB_MASK, cursor, timestamp); +#endif meta_topic (META_DEBUG_WINDOW_OPS, "Changed pointer with XChangeActivePointerGrab()\n"); @@ -3280,30 +3572,60 @@ meta_display_set_grab_op_cursor (MetaDisplay *display, g_assert (screen != NULL); meta_error_trap_push (display); - if (XGrabPointer (display->xdisplay, - grab_xwindow, - False, - GRAB_MASK, - GrabModeAsync, GrabModeAsync, - screen->xroot, - cursor, - timestamp) == GrabSuccess) +#ifdef MPX + /* XXX: EnterWindowMask, LeaveWindowMask */ + XEventClass evclasses[5]; + + DeviceButtonPress (dev->xdev, display->dev_btn_press_type, + evclasses[0]); /* XXX use 0!! */ +// meta_warning("display->dev_btn_press_type = %d\n", display->dev_btn_press_type); +// if (display->dev_btn_press_type == 0) +// meta_warning("AQUIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII\n"); + DeviceButtonRelease (dev->xdev, display->dev_btn_release_type, + evclasses[1]); + DeviceMotionNotify (dev->xdev, display->dev_motion_notify_type, + evclasses[2]); +// meta_warning("display->dev_motion_notify_type = %d\n", display->dev_motion_notify_type); + DeviceEnterNotify (dev->xdev, display->dev_enter_notify_type, + evclasses[3]); + DeviceLeaveNotify (dev->xdev, display->dev_leave_notify_type, + evclasses[4]); + +// 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 { display->grab_have_pointer = TRUE; - meta_topic (META_DEBUG_WINDOW_OPS, - "XGrabPointer() returned GrabSuccess time %u\n", - timestamp); +#ifdef MPX + meta_topic (META_DEBUG_WINDOW_OPS, + "XExtendedGrabDevice() returned GrabSuccess\n"); +#endif } else { - meta_topic (META_DEBUG_WINDOW_OPS, - "XGrabPointer() failed time %u\n", - timestamp); +#ifdef MPX + meta_topic (META_DEBUG_WINDOW_OPS, + "XExtendedGrabDevice() failed!\n"); +#endif } meta_error_trap_pop (display, TRUE); } +#ifndef MPX #undef GRAB_MASK +#endif if (cursor != None) XFreeCursor (display->xdisplay, cursor); @@ -3312,6 +3634,7 @@ meta_display_set_grab_op_cursor (MetaDisplay *display, gboolean meta_display_begin_grab_op (MetaDisplay *display, MetaScreen *screen, + MetaDevInfo *dev, MetaWindow *window, MetaGrabOp op, gboolean pointer_already_grabbed, @@ -3322,6 +3645,22 @@ meta_display_begin_grab_op (MetaDisplay *display, int root_x, int root_y) { + + meta_warning("meta_display_begin_grab_op called for device named %s\n", + dev->name); + + { + int i; + for (i = 0; i < display->devices->keybsUsed; i++) + if (dev->xdev->device_id == display->devices->keyboards[i].xdev->device_id) + { + meta_warning("ERROR! Trying to grab_op keyboard %s!!\n", dev->name); + meta_warning("ERROR! Trying to grab_op keyboard %s!!\n", dev->name); + meta_warning("ERROR! Trying to grab_op keyboard %s!!\n", dev->name); + sleep(5); + } + } + Window grab_xwindow; if (grab_op_is_mouse (op) && meta_grab_op_is_moving (op)) @@ -3334,7 +3673,8 @@ meta_display_begin_grab_op (MetaDisplay *display, } } - meta_topic (META_DEBUG_WINDOW_OPS, +/* 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); @@ -3350,6 +3690,7 @@ meta_display_begin_grab_op (MetaDisplay *display, if (window && (meta_grab_op_is_moving (op) || meta_grab_op_is_resizing (op))) { + meta_warning("moving or resizing!\n"); if (meta_prefs_get_raise_on_click ()) meta_window_raise (window); else @@ -3375,33 +3716,47 @@ meta_display_begin_grab_op (MetaDisplay *display, if (pointer_already_grabbed) display->grab_have_pointer = TRUE; - - meta_display_set_grab_op_cursor (display, screen, op, FALSE, grab_xwindow, - timestamp); + +#ifdef MPX + meta_display_set_grab_op_cursor (display, screen, dev, op, FALSE, + grab_xwindow, timestamp); +#endif if (!display->grab_have_pointer) { meta_topic (META_DEBUG_WINDOW_OPS, - "XGrabPointer() failed\n"); + "XExtendedGrabDevice() failed\n"); return FALSE; } /* 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; + + keybDev = meta_devices_find_paired_keyboard (display, + dev->xdev->device_id); +#endif + if (window) display->grab_have_keyboard = - meta_window_grab_all_keys (window, timestamp); +#ifdef MPX + meta_window_grab_all_keys (window, keybDev, timestamp); +#endif else display->grab_have_keyboard = - meta_screen_grab_all_keys (screen, timestamp); +#ifdef MPX + meta_screen_grab_all_keys (screen, dev, timestamp); +#endif if (!display->grab_have_keyboard) { - meta_topic (META_DEBUG_WINDOW_OPS, + meta_warning( +/* meta_topic (META_DEBUG_WINDOW_OPS, */ "grabbing all keys failed, ungrabbing pointer\n"); - XUngrabPointer (display->xdisplay, timestamp); + XUngrabDevice (display->xdisplay, dev->xdev, timestamp); display->grab_have_pointer = FALSE; return FALSE; } @@ -3506,8 +3861,9 @@ meta_display_begin_grab_op (MetaDisplay *display, } #endif } - - meta_topic (META_DEBUG_WINDOW_OPS, + +meta_warning( +/* meta_topic (META_DEBUG_WINDOW_OPS, */ "Grab op %u on window %s successful\n", display->grab_op, window ? window->desc : "(null)"); @@ -3588,8 +3944,15 @@ meta_display_begin_grab_op (MetaDisplay *display, void meta_display_end_grab_op (MetaDisplay *display, + MetaDevInfo *dev, guint32 timestamp) { + +// 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); @@ -3653,11 +4016,13 @@ meta_display_end_grab_op (MetaDisplay *display, { if (meta_grab_op_is_moving (display->grab_op)) meta_window_move (display->grab_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, TRUE, display->grab_wireframe_rect.width, display->grab_wireframe_rect.height, @@ -3679,17 +4044,29 @@ meta_display_end_grab_op (MetaDisplay *display, { meta_topic (META_DEBUG_WINDOW_OPS, "Ungrabbing pointer with timestamp %u\n", timestamp); - XUngrabPointer (display->xdisplay, timestamp); + XExtendedUngrabDevice (display->xdisplay, dev->xdev); } if (display->grab_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 + 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, timestamp); + meta_window_ungrab_all_keys (display->grab_window, + pairedKbd, timestamp); else - meta_screen_ungrab_all_keys (display->grab_screen, timestamp); + meta_screen_ungrab_all_keys (display->grab_screen, + pairedKbd, timestamp); } #ifdef HAVE_XSYNC @@ -3736,6 +4113,7 @@ meta_display_check_threshold_reached (MetaDisplay *display, static void meta_change_button_grab (MetaDisplay *display, + MetaDevInfo *dev, Window xwindow, gboolean grab, gboolean sync, @@ -3744,6 +4122,18 @@ meta_change_button_grab (MetaDisplay *display, { unsigned int ignored_mask; +// meta_warning("doodoocaca com dev = %s\n", dev->name); + + int idev; + int found = 0; + for (idev = 0; idev < display->devices->miceUsed; idev++) + { + if (dev->xdev->device_id == display->devices->mice[idev].xdev->device_id) + found = 1; + } + if (! found) + meta_warning("-=-=-=-=-=- ERROR!!!!!!!!!!!!!!!! -=-=-=-=-=-=-=-=-=\n"); + meta_verbose ("%s 0x%lx sync = %d button = %d modmask 0x%x\n", grab ? "Grabbing" : "Ungrabbing", xwindow, @@ -3766,19 +4156,53 @@ meta_change_button_grab (MetaDisplay *display, if (meta_is_debugging ()) meta_error_trap_push_with_return (display); - /* GrabModeSync means freeze until XAllowEvents */ + /* GrabModeSync means freeze until XAllowDeviceEvents */ if (grab) - XGrabButton (display->xdisplay, button, modmask | ignored_mask, + { + XEventClass evclasses[4]; + DeviceButtonPress (dev->xdev, display->dev_btn_press_type, + evclasses[0]); + +// meta_warning("display->dev_btn_press_type = %d\n", display->dev_btn_press_type); + if (display->dev_btn_press_type == 0) + meta_warning("DOOOOOOOOOOODOOOOOOOOOOCAAAAAAACAAAAAAAAA!!\n"); + DeviceButtonRelease (dev->xdev, display->dev_btn_release_type, + evclasses[1]); + DeviceMotionNotify (dev->xdev, display->dev_motion_notify_type, + evclasses[2]); +// meta_warning("display->dev_motion_notify_type = %d\n", display->dev_motion_notify_type); + DevicePointerMotionHint (dev->xdev, display->dev_ptr_motion_hint_type, + evclasses[3]); + +// meta_warning("XGrabDeviceButton() display.c:4158\n"); + + XGrabDeviceButton(display->xdisplay, dev->xdev, button, + modmask | ignored_mask, dev->xdev, + xwindow, False, 4, evclasses, + sync ? GrabModeSync : GrabModeAsync, + GrabModeAsync); + +#if 0 +#warning XGrabButton + XGrabButton (display->xdisplay, button, modmask | ignored_mask, xwindow, False, ButtonPressMask | ButtonReleaseMask | PointerMotionMask | PointerMotionHintMask, sync ? GrabModeSync : GrabModeAsync, GrabModeAsync, False, None); +#endif + } else + XUngrabDeviceButton (display->xdisplay, dev->xdev, + button, modmask | ignored_mask, + dev->xdev, xwindow); +#if 0 +#warning XUngrabButton XUngrabButton (display->xdisplay, button, modmask | ignored_mask, xwindow); +#endif if (meta_is_debugging ()) { @@ -3800,7 +4224,8 @@ meta_change_button_grab (MetaDisplay *display, void meta_display_grab_window_buttons (MetaDisplay *display, - Window xwindow) + Window xwindow, + MetaDevInfo *dev) { /* Grab Alt + button1 for moving window. * Grab Alt + button2 for resizing window. @@ -3820,7 +4245,7 @@ meta_display_grab_window_buttons (MetaDisplay *display, int i; for (i = 1; i < 4; i++) { - meta_change_button_grab (display, xwindow, + meta_change_button_grab (display, dev, xwindow, TRUE, FALSE, i, display->window_grab_modifiers); @@ -3829,7 +4254,7 @@ meta_display_grab_window_buttons (MetaDisplay *display, * otherwise ;-) */ if (debug) - meta_change_button_grab (display, xwindow, + meta_change_button_grab (display, dev, xwindow, TRUE, FALSE, i, ControlMask); @@ -3841,7 +4266,7 @@ meta_display_grab_window_buttons (MetaDisplay *display, * Shift+Alt+Button1 for some reason; so at least part of the * order still matters, which sucks (please FIXME). */ - meta_change_button_grab (display, xwindow, + meta_change_button_grab (display, dev, xwindow, TRUE, FALSE, 1, display->window_grab_modifiers | ShiftMask); @@ -3850,7 +4275,8 @@ meta_display_grab_window_buttons (MetaDisplay *display, void meta_display_ungrab_window_buttons (MetaDisplay *display, - Window xwindow) + Window xwindow, + MetaDevInfo *dev) { gboolean debug; int i; @@ -3862,12 +4288,12 @@ meta_display_ungrab_window_buttons (MetaDisplay *display, i = 1; while (i < 4) { - meta_change_button_grab (display, xwindow, + meta_change_button_grab (display, dev, xwindow, FALSE, FALSE, i, display->window_grab_modifiers); if (debug) - meta_change_button_grab (display, xwindow, + meta_change_button_grab (display, dev, xwindow, FALSE, FALSE, i, ControlMask); ++i; @@ -3878,7 +4304,8 @@ meta_display_ungrab_window_buttons (MetaDisplay *display, #define MAX_FOCUS_BUTTON 4 void meta_display_grab_focus_window_button (MetaDisplay *display, - MetaWindow *window) + MetaWindow *window, + MetaDevInfo *dev) { /* Grab button 1 for activating unfocused windows */ meta_verbose ("Grabbing unfocused window buttons for %s\n", window->desc); @@ -3913,7 +4340,7 @@ meta_display_grab_focus_window_button (MetaDisplay *display, int i = 1; while (i < MAX_FOCUS_BUTTON) { - meta_change_button_grab (display, + meta_change_button_grab (display, dev, window->xwindow, TRUE, TRUE, i, 0); @@ -3927,7 +4354,8 @@ meta_display_grab_focus_window_button (MetaDisplay *display, void meta_display_ungrab_focus_window_button (MetaDisplay *display, - MetaWindow *window) + MetaWindow *window, + MetaDevInfo *dev) { meta_verbose ("Ungrabbing unfocused window buttons for %s\n", window->desc); @@ -3938,7 +4366,7 @@ meta_display_ungrab_focus_window_button (MetaDisplay *display, int i = 1; while (i < MAX_FOCUS_BUTTON) { - meta_change_button_grab (display, window->xwindow, + meta_change_button_grab (display, dev, window->xwindow, FALSE, FALSE, i, 0); ++i; @@ -4892,8 +5320,15 @@ prefs_changed_callback (MetaPreference pref, while (tmp != NULL) { MetaWindow *w = tmp->data; - meta_display_ungrab_window_buttons (display, w->xwindow); - meta_display_ungrab_focus_window_button (display, w); + /* XXX */ + int idev; + for (idev = 0; idev < display->devices->keybsUsed; idev++) + { + meta_display_ungrab_window_buttons (display, w->xwindow, + &display->devices->keyboards[idev]); + meta_display_ungrab_focus_window_button (display, w, + &display->devices->keyboards[idev]); + } tmp = tmp->next; } @@ -4906,8 +5341,17 @@ prefs_changed_callback (MetaPreference pref, while (tmp != NULL) { MetaWindow *w = tmp->data; - meta_display_grab_focus_window_button (display, w); - meta_display_grab_window_buttons (display, w->xwindow); + int idev; + for (idev = 0; idev < display->devices->keybsUsed; idev++) + { + meta_display_grab_focus_window_button (display, w, + &display->devices->keyboards[idev]); + } + for (idev = 0; idev < display->devices->miceUsed; idev++) + { + meta_display_grab_window_buttons (display, w->xwindow, + &display->devices->mice[idev]); + } tmp = tmp->next; } @@ -5058,19 +5502,31 @@ timestamp_too_old (MetaDisplay *display, } void -meta_display_set_input_focus_window (MetaDisplay *display, +#ifdef MPX +meta_display_set_input_focus_window (MetaDisplay *display, + MetaDevInfo *dev, MetaWindow *window, gboolean focus_frame, guint32 timestamp) + +#else +meta_display_set_input_focus_window (MetaDisplay *display, + MetaWindow *window, + gboolean focus_frame, + guint32 timestamp) +#endif { if (timestamp_too_old (display, window, ×tamp)) return; meta_error_trap_push (display); - XSetInputFocus (display->xdisplay, - focus_frame ? window->frame->xwindow : window->xwindow, - RevertToPointerRoot, - timestamp); +#ifdef MPX + XSetDeviceFocus (display->xdisplay, + dev->xdev, + focus_frame ? window->frame->xwindow : window->xwindow, + RevertToPointerRoot, + timestamp); +#endif meta_error_trap_pop (display, FALSE); display->expected_focus_window = window; @@ -5082,17 +5538,27 @@ meta_display_set_input_focus_window (MetaDisplay *display, } void -meta_display_focus_the_no_focus_window (MetaDisplay *display, +#ifdef MPX +meta_display_focus_the_no_focus_window (MetaDisplay *display, + MetaDevInfo *dev, MetaScreen *screen, guint32 timestamp) +#else +meta_display_focus_the_no_focus_window (MetaDisplay *display, + MetaScreen *screen, + guint32 timestamp) +#endif { if (timestamp_too_old (display, NULL, ×tamp)) return; - XSetInputFocus (display->xdisplay, - screen->no_focus_window, - RevertToPointerRoot, - timestamp); +#ifdef MPX + XSetDeviceFocus (display->xdisplay, + dev->xdev, + screen->no_focus_window, + RevertToPointerRoot, + timestamp); +#endif display->expected_focus_window = NULL; display->last_focus_time = timestamp; display->active_screen = screen; diff --git a/src/display.h b/src/display.h index 5216afef..02c286da 100644 --- a/src/display.h +++ b/src/display.h @@ -52,7 +52,7 @@ #define meta_XFree(p) do { if ((p)) XFree ((p)); } while (0) typedef struct MetaCompositor MetaCompositor; -typedef struct _MetaDisplay MetaDisplay; +/* typedef struct _MetaDisplay MetaDisplay; XXX */ typedef struct _MetaFrame MetaFrame; typedef struct _MetaKeyBinding MetaKeyBinding; typedef struct _MetaScreen MetaScreen; @@ -192,7 +192,7 @@ struct _MetaDisplay /* This is the actual window from focus events, * not the one we last set */ - MetaWindow *focus_window; + MetaWindow *focus_window; /* XXX Make this per-device */ /* window we are expecting a FocusIn event for or the current focus * window if we are not expecting any FocusIn/FocusOut events; not @@ -201,9 +201,9 @@ struct _MetaDisplay * time is sent to meta_display_set_input_focus_window, though that * would be a programming error). See bug 154598 for more info. */ - MetaWindow *expected_focus_window; + MetaWindow *expected_focus_window; /* XXX Make this per-device */ - /* last timestamp passed to XSetInputFocus */ + /* last timestamp passed to XSetDeviceFocus */ guint32 last_focus_time; /* last user interaction time in any app */ @@ -268,6 +268,7 @@ struct _MetaDisplay int grab_latest_motion_y; gulong grab_mask; guint grab_have_pointer : 1; + guint grab_grabbed_pointer : 1; guint grab_have_keyboard : 1; guint grab_wireframe_active : 1; guint grab_was_cancelled : 1; /* Only used in wireframe mode */ @@ -378,7 +379,17 @@ struct _MetaDisplay #endif #ifdef MPX - MetaDevices devices; + int dev_btn_press_type; + int dev_btn_release_type; + int dev_motion_notify_type; + int dev_ptr_motion_hint_type; + int dev_focus_in_type; + int dev_focus_out_type; + int dev_key_press_type; + int dev_key_release_type; + int dev_enter_notify_type; + int dev_leave_notify_type; + MetaDevices *devices; #endif }; @@ -449,7 +460,15 @@ GSList* meta_displays_list (void); Cursor meta_display_create_x_cursor (MetaDisplay *display, MetaCursor cursor); - +#ifdef MPX +void meta_display_set_grab_op_cursor (MetaDisplay *display, + MetaScreen *screen, + MetaDevInfo *dev, + MetaGrabOp op, + gboolean change_pointer, + Window grab_xwindow, + guint32 timestamp); +#else void meta_display_set_grab_op_cursor (MetaDisplay *display, MetaScreen *screen, MetaGrabOp op, @@ -457,6 +476,22 @@ void meta_display_set_grab_op_cursor (MetaDisplay *display, Window grab_xwindow, guint32 timestamp); +#endif + +#ifdef MPX +gboolean meta_display_begin_grab_op (MetaDisplay *display, + MetaScreen *screen, + MetaDevInfo *dev, + MetaWindow *window, + MetaGrabOp op, + gboolean pointer_already_grabbed, + gboolean frame_action, + int button, + gulong modmask, + guint32 timestamp, + int root_x, + int root_y); +#else gboolean meta_display_begin_grab_op (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, @@ -468,21 +503,27 @@ gboolean meta_display_begin_grab_op (MetaDisplay *display, guint32 timestamp, int root_x, int root_y); +#endif void meta_display_end_grab_op (MetaDisplay *display, + MetaDevInfo *dev, guint32 timestamp); void meta_display_check_threshold_reached (MetaDisplay *display, int x, int y); void meta_display_grab_window_buttons (MetaDisplay *display, - Window xwindow); + Window xwindow, + MetaDevInfo *dev); void meta_display_ungrab_window_buttons (MetaDisplay *display, - Window xwindow); + Window xwindow, + MetaDevInfo *dev); void meta_display_grab_focus_window_button (MetaDisplay *display, - MetaWindow *window); + MetaWindow *window, + MetaDevInfo *dev); void meta_display_ungrab_focus_window_button (MetaDisplay *display, - MetaWindow *window); + MetaWindow *window, + MetaDevInfo *dev); /* Next two functions are defined in edge-resistance.c */ void meta_display_compute_resistance_and_snapping_edges (MetaDisplay *display); @@ -567,18 +608,33 @@ gboolean meta_display_focus_sentinel_clear (MetaDisplay *display); * whether a window should be allowed to be focused should depend * on user_time events (see bug 167358, comment 15 in particular) */ -void meta_display_set_input_focus_window (MetaDisplay *display, +#ifdef MPX +void meta_display_set_input_focus_window (MetaDisplay *display, + MetaDevInfo *dev, MetaWindow *window, gboolean focus_frame, guint32 timestamp); +#else +void meta_display_set_input_focus_window (MetaDisplay *display, + MetaWindow *window, + gboolean focus_frame, + guint32 timestamp); +#endif /* meta_display_focus_the_no_focus_window is called when the * designated no_focus_window should be focused, but is otherwise the * same as meta_display_set_input_focus_window */ -void meta_display_focus_the_no_focus_window (MetaDisplay *display, +#ifdef MPX +void meta_display_focus_the_no_focus_window (MetaDisplay *display, + MetaDevInfo *dev, MetaScreen *screen, guint32 timestamp); +#else +void meta_display_focus_the_no_focus_window (MetaDisplay *display, + MetaScreen *screen, + guint32 timestamp); +#endif void meta_display_queue_autoraise_callback (MetaDisplay *display, MetaWindow *window); diff --git a/src/frame.c b/src/frame.c index f4f81892..03b96e15 100644 --- a/src/frame.c +++ b/src/frame.c @@ -33,15 +33,17 @@ #include <X11/extensions/Xrender.h> #endif +#ifdef MPX #define EVENT_MASK (SubstructureRedirectMask | \ StructureNotifyMask | SubstructureNotifyMask | \ ExposureMask | \ - ButtonPressMask | ButtonReleaseMask | \ - PointerMotionMask | PointerMotionHintMask | \ - EnterWindowMask | LeaveWindowMask | \ - FocusChangeMask | \ +/* PointerMotionMask | PointerMotionHintMask |*/ \ +/* EnterWindowMask | LeaveWindowMask | */ \ +/* FocusChangeMask | */ \ ColormapChangeMask) +#endif + void meta_window_ensure_frame (MetaWindow *window) { @@ -97,9 +99,11 @@ meta_window_ensure_frame (MetaWindow *window) visual = window->xvisual; else visual = NULL; - + +#ifdef MPX frame->xwindow = meta_ui_create_frame_window (window->screen->ui, window->display->xdisplay, + window->display->devices, visual, frame->rect.x, frame->rect.y, @@ -107,10 +111,89 @@ meta_window_ensure_frame (MetaWindow *window) frame->rect.height, frame->window->screen->number); +#endif + meta_verbose ("Frame for %s is 0x%lx\n", frame->window->desc, frame->xwindow); attrs.event_mask = EVENT_MASK; XChangeWindowAttributes (window->display->xdisplay, frame->xwindow, CWEventMask, &attrs); +#ifdef MPX + meta_warning("vo pega os eventos...\n"); + + XEventClass *evclasses; + int nclasses = 0; + int idev; + + evclasses = g_new(XEventClass, + window->display->devices->miceUsed * 6 + + window->display->devices->keybsUsed * 2); +// meta_warning("window->display->devices->miceUsed = %d\n", +// window->display->devices->miceUsed); + for (idev = 0; idev < window->display->devices->miceUsed; idev++) + { +// meta_warning("nclasses == %d\n", nclasses); + DeviceButtonPress (window->display->devices->mice[idev].xdev, + window->display->dev_btn_press_type, + evclasses[nclasses]); + nclasses++; + meta_warning("window->display->dev_btn_press_type = %d\n", window->display->dev_btn_press_type); +// meta_warning("nclasses == %d\n", nclasses); + DeviceButtonRelease (window->display->devices->mice[idev].xdev, + window->display->dev_btn_release_type, + evclasses[nclasses]); + nclasses++; + meta_warning("window->display->dev_btn_release_type = %d\n", window->display->dev_btn_release_type); +// meta_warning("nclasses == %d\n", nclasses); + DeviceMotionNotify (window->display->devices->mice[idev].xdev, + window->display->dev_motion_notify_type, + evclasses[nclasses]); + nclasses++; + meta_warning("window->display->dev_motion_notify_type = %d\n", window->display->dev_motion_notify_type); +// meta_warning("nclasses == %d\n", nclasses); + DevicePointerMotionHint (window->display->devices->mice[idev].xdev, + window->display->dev_ptr_motion_hint_type, + evclasses[nclasses]); + nclasses++; + meta_warning("window->display->dev_ptr_motion_hint_type = %d\n", window->display->dev_ptr_motion_hint_type); +// meta_warning("nclasses == %d\n", nclasses); + DeviceEnterNotify (window->display->devices->mice[idev].xdev, + window->display->dev_enter_notify_type, + evclasses[nclasses]); + nclasses++; + meta_warning("window->display->dev_enter_notify_type = %d\n", window->display->dev_enter_notify_type); +// meta_warning("nclasses == %d\n", nclasses); + DeviceLeaveNotify (window->display->devices->mice[idev].xdev, + window->display->dev_leave_notify_type, + evclasses[nclasses]); + nclasses++; + meta_warning("window->display->dev_leave_notify_type = %d\n", window->display->dev_leave_notify_type); +// meta_warning("nclasses == %d\n", nclasses); + + } + /* XXX Should these be called with the keybs as arguments? */ + for (idev = 0; idev < window->display->devices->miceUsed; idev++) + { + DeviceFocusIn (window->display->devices->keyboards[idev].xdev, + window->display->dev_focus_in_type, + evclasses[nclasses]); + nclasses++; + meta_warning("window->display->dev_focus_in_type = %d\n", window->display->dev_focus_in_type); +// meta_warning("nclasses == %d\n", nclasses); + DeviceFocusOut (window->display->devices->keyboards[idev].xdev, + window->display->dev_focus_out_type, + evclasses[nclasses]); + nclasses++; + meta_warning("window->display->dev_focus_out_type = %d\n", window->display->dev_focus_out_type); + + } + +// 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); + + /* g_free(evclasses); XXX */ +#endif meta_display_register_x_window (window->display, &frame->xwindow, window); @@ -158,7 +241,8 @@ meta_window_ensure_frame (MetaWindow *window) window->title); /* Move keybindings to frame instead of window */ - meta_window_grab_keys (window); + for (idev = 0; idev < window->display->devices->keybsUsed; idev++) + meta_window_grab_keys (window, &window->display->devices->keyboards[idev]); /* Shape mask */ meta_ui_apply_frame_shape (frame->window->screen->ui, @@ -175,6 +259,7 @@ void meta_window_destroy_frame (MetaWindow *window) { MetaFrame *frame; + int idev; if (window->frame == NULL) return; @@ -218,7 +303,8 @@ meta_window_destroy_frame (MetaWindow *window) window->frame = NULL; /* Move keybindings to window instead of frame */ - meta_window_grab_keys (window); + for (idev = 0; idev < window->display->devices->keybsUsed; idev++) + meta_window_grab_keys (window, &window->display->devices->keyboards[idev]); g_free (frame); diff --git a/src/frames.c b/src/frames.c index c14e73ba..b5d2f959 100644 --- a/src/frames.c +++ b/src/frames.c @@ -25,6 +25,7 @@ #include <config.h> #include <math.h> +#include <string.h> #include "boxes.h" #include "frames.h" #include "util.h" @@ -35,6 +36,7 @@ #include "prefs.h" #include "errors.h" #include "ui.h" +#include "devices.h" #ifdef HAVE_SHAPE #include <X11/extensions/shape.h> @@ -42,6 +44,14 @@ #define DEFAULT_INNER_BUTTON_BORDER 3 +/* XXX */ +struct _tipInfo { + MetaFrames *frames; + MetaDevInfo *dev; +}; + +typedef struct _tipInfo meta_tip_info; + static void meta_frames_class_init (MetaFramesClass *klass); static void meta_frames_init (MetaFrames *frames); static void meta_frames_destroy (GtkObject *object); @@ -563,9 +573,10 @@ meta_frames_new (int screen_number) } void -meta_frames_manage_window (MetaFrames *frames, - Window xwindow, - GdkWindow *window) +meta_frames_manage_window (MetaFrames *frames, + Window xwindow, + GdkWindow *window, + MetaDevices *devices) { MetaUIFrame *frame; @@ -593,7 +604,10 @@ meta_frames_manage_window (MetaFrames *frames, * and meta_ui_create_frame_window() return to meta_window_ensure_frame(). */ - meta_core_grab_buttons (gdk_display, frame->xwindow); + int idev; + for (idev = 0; idev < devices->miceUsed; idev++) + meta_core_grab_buttons (gdk_display, frame->xwindow, + &devices->mice[idev]); g_hash_table_replace (frames->frames, &frame->xwindow, frame); } @@ -1047,7 +1061,7 @@ meta_frames_repaint_frame (MetaFrames *frames, } static void -show_tip_now (MetaFrames *frames) +show_tip_now (meta_tip_info *tip_info) { const char *tiptext; MetaUIFrame *frame; @@ -1055,17 +1069,34 @@ show_tip_now (MetaFrames *frames) Window root, child; guint mask; MetaFrameControl control; + Bool shared; + + MetaFrames *frames = tip_info->frames; + MetaDevInfo *dev = tip_info->dev; frame = frames->last_motion_frame; if (frame == NULL) return; + XQueryDevicePointer (gdk_display, + dev->xdev, + frame->xwindow, + &root, &child, + &root_x, &root_y, + &x, &y, + &mask, + &shared); + + +#if 0 +#warning XQueryPointer XQueryPointer (gdk_display, frame->xwindow, &root, &child, &root_x, &root_y, &x, &y, &mask); +#endif control = get_control (frames, frame, x, y); @@ -1161,24 +1192,31 @@ show_tip_now (MetaFrames *frames) static gboolean tip_timeout_func (gpointer data) { - MetaFrames *frames; + meta_tip_info *tip_info; - frames = data; + tip_info = data; - show_tip_now (frames); + show_tip_now (tip_info); return FALSE; } #define TIP_DELAY 450 static void -queue_tip (MetaFrames *frames) +queue_tip (MetaFrames *frames, MetaDevInfo *dev) { + meta_tip_info *tip_info; + + tip_info = g_new(meta_tip_info, 1); + + tip_info->frames = frames; + tip_info->dev = dev; + clear_tip (frames); frames->tooltip_timeout = g_timeout_add (TIP_DELAY, tip_timeout_func, - frames); + tip_info); } static void @@ -1214,7 +1252,14 @@ meta_frame_titlebar_event (MetaUIFrame *frame, int action) { MetaFrameFlags flags; + MetaDevInfo *dev; + meta_warning("meta_frame_titlebar_event(): device->name = %s\n", + event->device->name); + + dev = meta_devices_find_mouse_by_name(meta_display_for_x_display(gdk_display), + event->device->name); + switch (action) { case META_ACTION_TITLEBAR_TOGGLE_SHADE: @@ -1227,10 +1272,12 @@ meta_frame_titlebar_event (MetaUIFrame *frame, { if (flags & META_FRAME_SHADED) meta_core_unshade (gdk_display, + dev, frame->xwindow, event->time); else meta_core_shade (gdk_display, + dev, frame->xwindow, event->time); } @@ -1245,7 +1292,7 @@ meta_frame_titlebar_event (MetaUIFrame *frame, if (flags & META_FRAME_ALLOWS_MAXIMIZE) { - meta_core_toggle_maximize (gdk_display, frame->xwindow); + meta_core_toggle_maximize (gdk_display, dev, frame->xwindow); } } break; @@ -1269,12 +1316,14 @@ meta_frame_titlebar_event (MetaUIFrame *frame, case META_ACTION_TITLEBAR_LOWER: meta_core_user_lower_and_unfocus (gdk_display, + dev, frame->xwindow, event->time); break; case META_ACTION_TITLEBAR_MENU: meta_core_show_window_menu (gdk_display, + dev, frame->xwindow, event->x_root, event->y_root, @@ -1320,10 +1369,24 @@ static gboolean meta_frames_button_press_event (GtkWidget *widget, GdkEventButton *event) { + + meta_warning("meta_frames_button_press_event(): device = %s\n", + event->device->name); + MetaUIFrame *frame; MetaFrames *frames; MetaFrameControl control; - + MetaDisplay *display; + MetaDevInfo *dev; + MetaDevInfo *pairedKeyb; + + display = meta_display_for_x_display (gdk_display); /* did I put this here? XXX if I did, remove and put inside find_by_id! */ + + dev = meta_devices_find_mouse_by_name (display, + event->device->name); + pairedKeyb = meta_devices_find_paired_keyboard (display, + dev->xdev->device_id); + frames = META_FRAMES (widget); /* Remember that the display may have already done something with this event. @@ -1347,6 +1410,7 @@ meta_frames_button_press_event (GtkWidget *widget, "Focusing window with frame 0x%lx due to button 1 press\n", frame->xwindow); meta_core_user_focus (gdk_display, + pairedKeyb, frame->xwindow, event->time); } @@ -1424,7 +1488,11 @@ meta_frames_button_press_event (GtkWidget *widget, break; } + +/* if (dev == NULL) + meta_warning("could not find the mouse!! bad ugly error!\n"); */ meta_core_begin_grab_op (gdk_display, + dev, frame->xwindow, op, TRUE, @@ -1457,6 +1525,7 @@ meta_frames_button_press_event (GtkWidget *widget, dx += rect->width; meta_core_show_window_menu (gdk_display, + dev, frame->xwindow, rect->x + dx, rect->y + rect->height + dy, @@ -1516,13 +1585,16 @@ meta_frames_button_press_event (GtkWidget *widget, if (!titlebar_is_onscreen) meta_core_show_window_menu (gdk_display, + dev, frame->xwindow, event->x_root, event->y_root, event->button, event->time); - else + else { + meta_warning("chamando meta_core_begin_grab_op de onde eu quero\n"); meta_core_begin_grab_op (gdk_display, + dev, frame->xwindow, op, TRUE, @@ -1532,6 +1604,7 @@ meta_frames_button_press_event (GtkWidget *widget, event->time, event->x_root, event->y_root); + } } else if (control == META_FRAME_CONTROL_TITLE && event->button == 1) @@ -1545,6 +1618,7 @@ meta_frames_button_press_event (GtkWidget *widget, if (flags & META_FRAME_ALLOWS_MOVE) { meta_core_begin_grab_op (gdk_display, + dev, frame->xwindow, META_GRAB_OP_MOVING, TRUE, @@ -1571,6 +1645,12 @@ meta_frames_button_press_event (GtkWidget *widget, void meta_frames_notify_menu_hide (MetaFrames *frames) { + /* Begin XXX */ + MetaDisplay *display; + + display = meta_display_for_x_display (gdk_display); + /* End XXX */ + if (meta_core_get_grab_op (gdk_display) == META_GRAB_OP_CLICKING_MENU) { @@ -1588,7 +1668,9 @@ meta_frames_notify_menu_hide (MetaFrames *frames) { redraw_control (frames, frame, META_FRAME_CONTROL_MENU); - meta_core_end_grab_op (gdk_display, CurrentTime); + meta_core_end_grab_op (gdk_display, + &display->devices->mice[0], + CurrentTime); } } } @@ -1601,7 +1683,21 @@ meta_frames_button_release_event (GtkWidget *widget, MetaUIFrame *frame; MetaFrames *frames; MetaGrabOp op; - + MetaDisplay *display; + 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); frame = meta_frames_lookup_window (frames, GDK_WINDOW_XID (event->window)); @@ -1632,74 +1728,78 @@ meta_frames_button_release_event (GtkWidget *widget, if (control == META_FRAME_CONTROL_MINIMIZE) meta_core_minimize (gdk_display, frame->xwindow); - meta_core_end_grab_op (gdk_display, event->time); + meta_core_end_grab_op (gdk_display, dev, event->time); break; case META_GRAB_OP_CLICKING_MAXIMIZE: if (control == META_FRAME_CONTROL_MAXIMIZE) - meta_core_maximize (gdk_display, frame->xwindow); + /* Should we use the mouse or the keyboard? */ + meta_core_maximize (gdk_display, + meta_devices_find_paired_keyboard(display, + dev->xdev->device_id), + frame->xwindow); - meta_core_end_grab_op (gdk_display, event->time); + meta_core_end_grab_op (gdk_display, dev, event->time); break; case META_GRAB_OP_CLICKING_UNMAXIMIZE: if (control == META_FRAME_CONTROL_UNMAXIMIZE) - meta_core_unmaximize (gdk_display, frame->xwindow); + meta_core_unmaximize (gdk_display, dev, frame->xwindow); - meta_core_end_grab_op (gdk_display, event->time); + meta_core_end_grab_op (gdk_display, dev, event->time); break; case META_GRAB_OP_CLICKING_DELETE: if (control == META_FRAME_CONTROL_DELETE) meta_core_delete (gdk_display, frame->xwindow, event->time); - meta_core_end_grab_op (gdk_display, event->time); + meta_core_end_grab_op (gdk_display, dev, event->time); break; case META_GRAB_OP_CLICKING_MENU: - meta_core_end_grab_op (gdk_display, event->time); + meta_core_end_grab_op (gdk_display, dev, event->time); break; case META_GRAB_OP_CLICKING_SHADE: if (control == META_FRAME_CONTROL_SHADE) - meta_core_shade (gdk_display, frame->xwindow, event->time); + meta_core_shade (gdk_display, dev, frame->xwindow, event->time); - meta_core_end_grab_op (gdk_display, event->time); + meta_core_end_grab_op (gdk_display, dev, event->time); break; case META_GRAB_OP_CLICKING_UNSHADE: if (control == META_FRAME_CONTROL_UNSHADE) - meta_core_unshade (gdk_display, frame->xwindow, event->time); + meta_core_unshade (gdk_display, dev, frame->xwindow, event->time); - meta_core_end_grab_op (gdk_display, event->time); + meta_core_end_grab_op (gdk_display, dev, event->time); break; case META_GRAB_OP_CLICKING_ABOVE: if (control == META_FRAME_CONTROL_ABOVE) meta_core_make_above (gdk_display, frame->xwindow); - meta_core_end_grab_op (gdk_display, event->time); + meta_core_end_grab_op (gdk_display, dev, event->time); break; case META_GRAB_OP_CLICKING_UNABOVE: if (control == META_FRAME_CONTROL_UNABOVE) meta_core_unmake_above (gdk_display, frame->xwindow); - meta_core_end_grab_op (gdk_display, event->time); + meta_core_end_grab_op (gdk_display, dev, event->time); break; case META_GRAB_OP_CLICKING_STICK: if (control == META_FRAME_CONTROL_STICK) meta_core_stick (gdk_display, frame->xwindow); - meta_core_end_grab_op (gdk_display, event->time); + meta_core_end_grab_op (gdk_display, dev, event->time); break; case META_GRAB_OP_CLICKING_UNSTICK: if (control == META_FRAME_CONTROL_UNSTICK) meta_core_unstick (gdk_display, frame->xwindow); - meta_core_end_grab_op (gdk_display, event->time); + meta_core_end_grab_op (gdk_display, dev, event->time); break; default: @@ -1832,6 +1932,10 @@ meta_frames_motion_notify_event (GtkWidget *widget, MetaUIFrame *frame; MetaFrames *frames; MetaGrabOp grab_op; + MetaDevInfo *dev; + + dev = meta_devices_find_mouse_by_name(meta_display_for_x_display(gdk_display), + event->device->name); frames = META_FRAMES (widget); @@ -1860,9 +1964,20 @@ meta_frames_motion_notify_event (GtkWidget *widget, case META_GRAB_OP_CLICKING_UNSTICK: { MetaFrameControl control; + + int x, y, root_x, root_y; + Window root, child; + guint mask; + Bool shared; + + XQueryDevicePointer (gdk_display, dev->xdev, frame->xwindow, + &root, &child, &root_x, &root_y, &x, &y, + &mask, &shared); +#if 0 int x, y; - +#warning gdk_window_get_pointer gdk_window_get_pointer (frame->window, &x, &y, NULL); +#endif /* Control is set to none unless it matches * the current grab @@ -1901,16 +2016,27 @@ meta_frames_motion_notify_event (GtkWidget *widget, case META_GRAB_OP_NONE: { MetaFrameControl control; + + int x, y, root_x, root_y; + Window root, child; + guint mask; + Bool shared; + + XQueryDevicePointer (gdk_display, dev->xdev, frame->xwindow, + &root, &child, &root_x, &root_y, &x, &y, + &mask, &shared); +#if 0 int x, y; - +#warning gdk_window_get_pointer gdk_window_get_pointer (frame->window, &x, &y, NULL); +#endif control = get_control (frames, frame, x, y); /* Update prelit control and cursor */ meta_frames_update_prelit_control (frames, frame, control); - queue_tip (frames); + queue_tip (frames, dev); } break; diff --git a/src/frames.h b/src/frames.h index c4ad8bfb..8ed401bf 100644 --- a/src/frames.h +++ b/src/frames.h @@ -28,6 +28,7 @@ #include <gdk/gdkx.h> #include "common.h" #include "theme.h" +#include "devices.h" typedef enum { @@ -114,9 +115,10 @@ GType meta_frames_get_type (void) G_GNUC_CONST; MetaFrames *meta_frames_new (int screen_number); -void meta_frames_manage_window (MetaFrames *frames, - Window xwindow, - GdkWindow *window); +void meta_frames_manage_window (MetaFrames *frames, + Window xwindow, + GdkWindow *window, + MetaDevices *devices); void meta_frames_unmanage_window (MetaFrames *frames, Window xwindow); void meta_frames_set_title (MetaFrames *frames, diff --git a/src/keybindings.c b/src/keybindings.c index cd04c4f1..ecc8b9b6 100644 --- a/src/keybindings.c +++ b/src/keybindings.c @@ -33,6 +33,7 @@ #include "place.h" #include "prefs.h" #include "effects.h" +#include "devices.h" #include <X11/keysym.h> #include <string.h> @@ -45,230 +46,273 @@ static gboolean all_bindings_disabled = FALSE; -typedef void (* MetaKeyHandlerFunc) (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding); +typedef void (* MetaKeyHandlerFunc) (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding); static void handle_activate_workspace (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_activate_menu (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_tab_forward (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_tab_backward (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_cycle_forward (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_cycle_backward (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_toggle_fullscreen (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_toggle_desktop (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_panel_keybinding (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_toggle_above (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_toggle_maximize (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_maximize (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_unmaximize (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_toggle_shade (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_close_window (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_minimize_window (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_begin_move (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_begin_resize (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_toggle_sticky (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_move_to_workspace (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_move_to_workspace_flip (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_workspace_switch (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_raise_or_lower (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_raise (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_lower (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_run_command (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_maximize_vert (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_maximize_horiz (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_move_to_side_n (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_move_to_side_w (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_move_to_side_s (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_move_to_side_e (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); -static void handle_move_to_corner_nw (MetaDisplay *display, +static void handle_move_to_corner_nw (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); -static void handle_move_to_corner_ne (MetaDisplay *display, +static void handle_move_to_corner_ne (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); -static void handle_move_to_corner_sw (MetaDisplay *display, +static void handle_move_to_corner_sw (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); -static void handle_move_to_corner_se (MetaDisplay *display, +static void handle_move_to_corner_se (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_spew_mark (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); static void handle_run_terminal (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, MetaKeyBinding *binding); /* debug */ static gboolean process_mouse_move_resize_grab (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, KeySym keysym); static gboolean process_keyboard_move_grab (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, KeySym keysym); static gboolean process_keyboard_resize_grab (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, KeySym keysym); static gboolean process_tab_grab (MetaDisplay *display, MetaScreen *screen, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, KeySym keysym); static gboolean process_workspace_switch_grab (MetaDisplay *display, MetaScreen *screen, - XEvent *event, + //XEvent *event, + XDeviceKeyEvent *xdke, KeySym keysym); static void regrab_screen_bindings (MetaDisplay *display); @@ -495,6 +539,7 @@ reload_keymap (MetaDisplay *display) if (display->keymap) meta_XFree (display->keymap); + /* XXX USE XI!!!!! (when it implements these functions...) */ display->keymap = XGetKeyboardMapping (display->xdisplay, display->min_keycode, display->max_keycode - @@ -509,6 +554,7 @@ reload_modmap (MetaDisplay *display) int map_size; int i; + /* XXX USE XI!!!!! (when it implements these functions...) */ if (display->modmap) XFreeModifiermap (display->modmap); @@ -830,6 +876,7 @@ static void regrab_screen_bindings (MetaDisplay *display) { GSList *tmp; + int idev; meta_error_trap_push (display); /* for efficiency push outer trap */ @@ -837,9 +884,11 @@ regrab_screen_bindings (MetaDisplay *display) while (tmp != NULL) { MetaScreen *screen = tmp->data; - - meta_screen_ungrab_keys (screen); - meta_screen_grab_keys (screen); + for (idev = 0; idev < display->devices->keybsUsed; idev++) + { + meta_screen_ungrab_keys (screen, &display->devices->keyboards[idev]); + meta_screen_grab_keys (screen, &display->devices->keyboards[idev]); + } tmp = tmp->next; } @@ -852,6 +901,7 @@ regrab_window_bindings (MetaDisplay *display) { GSList *windows; GSList *tmp; + int idev; windows = meta_display_list_windows (display); @@ -861,8 +911,11 @@ regrab_window_bindings (MetaDisplay *display) { MetaWindow *w = tmp->data; - meta_window_ungrab_keys (w); - meta_window_grab_keys (w); + for (idev = 0; idev < display->devices->keybsUsed; idev++) + { + meta_window_ungrab_keys (w, &display->devices->keyboards[idev]); + meta_window_grab_keys (w, &display->devices->keyboards[idev]); + } tmp = tmp->next; } @@ -899,6 +952,7 @@ void meta_display_process_mapping_event (MetaDisplay *display, XEvent *event) { + /* XXX Is this Xi'able? */ if (event->xmapping.request == MappingModifier) { meta_topic (META_DEBUG_KEYBINDINGS, @@ -1028,6 +1082,7 @@ keysym_name (int keysym) /* Grab/ungrab, ignoring all annoying modifiers like NumLock etc. */ static void meta_change_keygrab (MetaDisplay *display, + MetaDevInfo *dev, Window xwindow, gboolean grab, int keysym, @@ -1065,15 +1120,20 @@ meta_change_keygrab (MetaDisplay *display, if (meta_is_debugging ()) meta_error_trap_push_with_return (display); if (grab) - XGrabKey (display->xdisplay, keycode, - modmask | ignored_mask, - xwindow, - True, - GrabModeAsync, GrabModeSync); + XGrabDeviceKey (display->xdisplay, + dev->xdev, + keycode, + modmask | ignored_mask, + dev->xdev, + xwindow, + True, + 0, + NULL, + GrabModeAsync, GrabModeSync); else - XUngrabKey (display->xdisplay, keycode, - modmask | ignored_mask, - xwindow); + XUngrabDeviceKey (display->xdisplay, dev->xdev, keycode, + modmask | ignored_mask, + dev->xdev, xwindow); if (meta_is_debugging ()) { @@ -1100,16 +1160,18 @@ meta_change_keygrab (MetaDisplay *display, static void meta_grab_key (MetaDisplay *display, + MetaDevInfo *dev, Window xwindow, int keysym, unsigned int keycode, int modmask) { - meta_change_keygrab (display, xwindow, TRUE, keysym, keycode, modmask); + meta_change_keygrab (display, dev, xwindow, TRUE, keysym, keycode, modmask); } static void -grab_keys (MetaKeyBinding *bindings, +grab_keys (MetaDevInfo *dev, + MetaKeyBinding *bindings, int n_bindings, MetaDisplay *display, Window xwindow) @@ -1125,7 +1187,7 @@ grab_keys (MetaKeyBinding *bindings, { if (bindings[i].keycode != 0) { - meta_grab_key (display, xwindow, + meta_grab_key (display, dev, xwindow, bindings[i].keysym, bindings[i].keycode, bindings[i].mask); @@ -1139,6 +1201,7 @@ grab_keys (MetaKeyBinding *bindings, static void ungrab_all_keys (MetaDisplay *display, + MetaDevInfo *dev, Window xwindow) { if (meta_is_debugging ()) @@ -1146,8 +1209,8 @@ ungrab_all_keys (MetaDisplay *display, else meta_error_trap_push (display); - XUngrabKey (display->xdisplay, AnyKey, AnyModifier, - xwindow); + XUngrabDeviceKey (display->xdisplay, dev->xdev, AnyKey, AnyModifier, + dev->xdev, xwindow); if (meta_is_debugging ()) { @@ -1164,7 +1227,7 @@ ungrab_all_keys (MetaDisplay *display, } void -meta_screen_grab_keys (MetaScreen *screen) +meta_screen_grab_keys (MetaScreen *screen, MetaDevInfo *dev) { if (screen->all_keys_grabbed) return; @@ -1172,7 +1235,8 @@ meta_screen_grab_keys (MetaScreen *screen) if (screen->keys_grabbed) return; - grab_keys (screen->display->screen_bindings, + grab_keys (dev, + screen->display->screen_bindings, screen->display->n_screen_bindings, screen->display, screen->xroot); @@ -1180,17 +1244,17 @@ meta_screen_grab_keys (MetaScreen *screen) } void -meta_screen_ungrab_keys (MetaScreen *screen) +meta_screen_ungrab_keys (MetaScreen *screen, MetaDevInfo *dev) { if (screen->keys_grabbed) { - ungrab_all_keys (screen->display, screen->xroot); + ungrab_all_keys (screen->display, dev, screen->xroot); screen->keys_grabbed = FALSE; } } void -meta_window_grab_keys (MetaWindow *window) +meta_window_grab_keys (MetaWindow *window, MetaDevInfo *dev) { if (window->all_keys_grabbed) return; @@ -1198,7 +1262,7 @@ meta_window_grab_keys (MetaWindow *window) if (window->type == META_WINDOW_DOCK) { if (window->keys_grabbed) - ungrab_all_keys (window->display, window->xwindow); + ungrab_all_keys (window->display, dev, window->xwindow); window->keys_grabbed = FALSE; return; } @@ -1206,7 +1270,7 @@ meta_window_grab_keys (MetaWindow *window) if (window->keys_grabbed) { if (window->frame && !window->grab_on_frame) - ungrab_all_keys (window->display, window->xwindow); + ungrab_all_keys (window->display, dev, window->xwindow); else if (window->frame == NULL && window->grab_on_frame) ; /* continue to regrab on client window */ @@ -1214,7 +1278,8 @@ meta_window_grab_keys (MetaWindow *window) return; /* already all good */ } - grab_keys (window->display->window_bindings, + grab_keys (dev, + window->display->window_bindings, window->display->n_window_bindings, window->display, window->frame ? window->frame->xwindow : window->xwindow); @@ -1224,16 +1289,16 @@ meta_window_grab_keys (MetaWindow *window) } void -meta_window_ungrab_keys (MetaWindow *window) +meta_window_ungrab_keys (MetaWindow *window, MetaDevInfo *dev) { if (window->keys_grabbed) { if (window->grab_on_frame && window->frame != NULL) - ungrab_all_keys (window->display, + ungrab_all_keys (window->display, dev, window->frame->xwindow); else if (!window->grab_on_frame) - ungrab_all_keys (window->display, + ungrab_all_keys (window->display, dev, window->xwindow); window->keys_grabbed = FALSE; @@ -1263,9 +1328,16 @@ grab_status_to_string (int status) #endif /* WITH_VERBOSE_MODE */ static gboolean +#ifdef MPX +grab_keyboard (MetaDisplay *display, + MetaDevInfo *dev, + Window xwindow, + guint32 timestamp) +#else grab_keyboard (MetaDisplay *display, Window xwindow, guint32 timestamp) +#endif { int result; int grab_status; @@ -1275,16 +1347,27 @@ grab_keyboard (MetaDisplay *display, */ meta_error_trap_push_with_return (display); - grab_status = XGrabKeyboard (display->xdisplay, - xwindow, True, - GrabModeAsync, GrabModeAsync, - timestamp); +#ifdef MPX + /* XXX No event classes?? */ +#warning grabbing stuff with no evclasses + grab_status = XGrabDevice (display->xdisplay, + dev->xdev, + xwindow, + True, + 0, + NULL, + GrabModeAsync, + GrabModeAsync, + timestamp); +// meta_warning("grabbed device %s with no evclasses! keybindings.c:1362\n", +// dev->name); +#endif if (grab_status != GrabSuccess) { meta_error_trap_pop_with_return (display, TRUE); meta_topic (META_DEBUG_KEYBINDINGS, - "XGrabKeyboard() returned failure status %s time %u\n", + "XGrabDevice() returned failure status %s time %u\n", grab_status_to_string (grab_status), timestamp); return FALSE; @@ -1295,7 +1378,7 @@ grab_keyboard (MetaDisplay *display, if (result != Success) { meta_topic (META_DEBUG_KEYBINDINGS, - "XGrabKeyboard() resulted in an error\n"); + "XGrabDevice() resulted in an error\n"); return FALSE; } } @@ -1306,19 +1389,26 @@ grab_keyboard (MetaDisplay *display, } static void -ungrab_keyboard (MetaDisplay *display, guint32 timestamp) +ungrab_keyboard (MetaDisplay *display, + MetaDevInfo *dev, + guint32 timestamp) { meta_error_trap_push (display); meta_topic (META_DEBUG_KEYBINDINGS, "Ungrabbing keyboard with timestamp %u\n", timestamp); - XUngrabKeyboard (display->xdisplay, timestamp); + XUngrabDevice (display->xdisplay, dev->xdev, timestamp); meta_error_trap_pop (display, FALSE); } 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; @@ -1326,37 +1416,45 @@ meta_screen_grab_all_keys (MetaScreen *screen, guint32 timestamp) return FALSE; if (screen->keys_grabbed) - meta_screen_ungrab_keys (screen); + meta_screen_ungrab_keys (screen, dev); meta_topic (META_DEBUG_KEYBINDINGS, "Grabbing all keys on RootWindow\n"); - retval = grab_keyboard (screen->display, screen->xroot, timestamp); + retval = grab_keyboard (screen->display, dev, screen->xroot, timestamp); if (retval) screen->all_keys_grabbed = TRUE; else - meta_screen_grab_keys (screen); + meta_screen_grab_keys (screen, dev); return retval; } void -meta_screen_ungrab_all_keys (MetaScreen *screen, guint32 timestamp) +meta_screen_ungrab_all_keys (MetaScreen *screen, + MetaDevInfo *dev, + guint32 timestamp) { if (screen->all_keys_grabbed) { - ungrab_keyboard (screen->display, timestamp); + ungrab_keyboard (screen->display, dev, timestamp); screen->all_keys_grabbed = FALSE; screen->keys_grabbed = FALSE; /* Re-establish our standard bindings */ - meta_screen_grab_keys (screen); + meta_screen_grab_keys (screen, dev); } } 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; @@ -1365,7 +1463,7 @@ meta_window_grab_all_keys (MetaWindow *window, return FALSE; if (window->keys_grabbed) - meta_window_ungrab_keys (window); + meta_window_ungrab_keys (window, dev); /* Make sure the window is focused, otherwise the grab * won't do a lot of good. @@ -1373,13 +1471,17 @@ meta_window_grab_all_keys (MetaWindow *window, meta_topic (META_DEBUG_FOCUS, "Focusing %s because we're grabbing all its keys\n", window->desc); - meta_window_focus (window, timestamp); + meta_window_focus (window, dev, timestamp); grabwindow = window->frame ? window->frame->xwindow : window->xwindow; 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; @@ -1391,18 +1493,22 @@ meta_window_grab_all_keys (MetaWindow *window, } void -meta_window_ungrab_all_keys (MetaWindow *window, guint32 timestamp) +meta_window_ungrab_all_keys (MetaWindow *window, + MetaDevInfo *dev, + guint32 timestamp) { + + if (window->all_keys_grabbed) { - ungrab_keyboard (window->display, timestamp); + ungrab_keyboard (window->display, dev, timestamp); window->grab_on_frame = FALSE; window->all_keys_grabbed = FALSE; window->keys_grabbed = FALSE; /* Re-establish our standard bindings */ - meta_window_grab_keys (window); + meta_window_grab_keys (window, dev); } } @@ -1531,25 +1637,43 @@ keycode_is_primary_modifier (MetaDisplay *display, static gboolean primary_modifier_still_pressed (MetaDisplay *display, + MetaDevInfo *ptrDev, unsigned int entire_binding_mask) { unsigned int primary_modifier; int x, y, root_x, root_y; Window root, child; guint mask; - MetaScreen *random_screen; - Window random_xwindow; + MetaScreen *random_screen; + Window random_xwindow; + Bool shared; +// MetaDevInfo *pairedPointer; primary_modifier = get_primary_modifier (display, entire_binding_mask); random_screen = display->screens->data; random_xwindow = random_screen->no_focus_window; + +// pairedPointer = meta_devices_find_paired_mouse(display, dev->xdev->device_id); + + XQueryDevicePointer (display->xdisplay, + ptrDev->xdev, + random_xwindow, /* some random window */ + &root, &child, + &root_x, &root_y, + &x, &y, + &mask, &shared); + + +#if 0 +#warning XQueryPointer XQueryPointer (display->xdisplay, random_xwindow, /* some random window */ &root, &child, &root_x, &root_y, &x, &y, &mask); +#endif meta_topic (META_DEBUG_KEYBINDINGS, "Primary modifier 0x%x full grab mask 0x%x current state 0x%x\n", @@ -1587,29 +1711,28 @@ process_event (MetaKeyBinding *bindings, MetaDisplay *display, MetaScreen *screen, MetaWindow *window, - XEvent *event, + XDeviceKeyEvent *xdke, KeySym keysym) { int i; - /* we used to have release-based bindings but no longer. */ - if (event->type == KeyRelease) + if (xdke->type == display->dev_key_release_type) return; i = 0; while (i < n_bindings) { - if (bindings[i].keycode == event->xkey.keycode && - ((event->xkey.state & ~(display->ignored_modifier_mask)) == + if (bindings[i].keycode == xdke->keycode && + ((xdke->state & ~(display->ignored_modifier_mask)) == bindings[i].mask) && - event->type == KeyPress) + xdke->type == display->dev_key_press_type) { const MetaKeyHandler *handler; meta_topic (META_DEBUG_KEYBINDINGS, "Binding keycode 0x%x mask 0x%x matches event 0x%x state 0x%x\n", bindings[i].keycode, bindings[i].mask, - event->xkey.keycode, event->xkey.state); + xdke->keycode, xdke->state); if (bindings[i].handler) handler = bindings[i].handler; @@ -1632,7 +1755,7 @@ process_event (MetaKeyBinding *bindings, */ display->allow_terminal_deactivation = TRUE; - (* handler->func) (display, screen, window, event, + (* handler->func) (display, screen, window, xdke, &bindings[i]); return; } @@ -1645,48 +1768,53 @@ process_event (MetaKeyBinding *bindings, } void -meta_display_process_key_event (MetaDisplay *display, - MetaWindow *window, - XEvent *event) +meta_display_process_key_event (MetaDisplay *display, + MetaWindow *window, + XDeviceKeyEvent *xdke) { KeySym keysym; gboolean handled; gboolean all_keys_grabbed; const char *str; MetaScreen *screen; + MetaDevInfo *dev; + + meta_warning("meta_display_process_key_event\n"); - XAllowEvents (display->xdisplay, + dev = meta_devices_find_keyboard_by_id (display, xdke->deviceid); + + XAllowDeviceEvents (display->xdisplay, dev->xdev, all_bindings_disabled ? ReplayKeyboard : AsyncKeyboard, - event->xkey.time); + xdke->time); if (all_bindings_disabled) return; /* if key event was on root window, we have a shortcut */ - screen = meta_display_screen_for_root (display, event->xkey.window); + screen = meta_display_screen_for_root (display, xdke->window); /* else round-trip to server */ if (screen == NULL) screen = meta_display_screen_for_xwindow (display, - event->xany.window); + xdke->window); if (screen == NULL) return; /* event window is destroyed */ /* ignore key events on popup menus and such. */ if (window == NULL && - meta_ui_window_is_widget (screen->ui, event->xany.window)) + meta_ui_window_is_widget (screen->ui, xdke->window)) return; /* window may be NULL */ - keysym = XKeycodeToKeysym (display->xdisplay, event->xkey.keycode, 0); + keysym = XKeycodeToKeysym (display->xdisplay, xdke->keycode, 0); str = XKeysymToString (keysym); meta_topic (META_DEBUG_KEYBINDINGS, "Processing key %s event, keysym: %s state: 0x%x window: %s\n", - event->type == KeyPress ? "press" : "release", - str ? str : "none", event->xkey.state, + xdke->type == display->dev_key_press_type ? "press" : "release", + str ? str : "none", xdke->state, window ? window->desc : "(no window)"); all_keys_grabbed = window ? window->all_keys_grabbed : screen->all_keys_grabbed; @@ -1696,13 +1824,13 @@ meta_display_process_key_event (MetaDisplay *display, process_event (display->screen_bindings, display->n_screen_bindings, screen_handlers, - display, screen, NULL, event, keysym); + display, screen, NULL, xdke, keysym); if (window) process_event (display->window_bindings, display->n_window_bindings, window_handlers, - display, screen, window, event, keysym); + display, screen, window, xdke, keysym); return; } @@ -1735,7 +1863,7 @@ meta_display_process_key_event (MetaDisplay *display, "Processing event for mouse-only move/resize\n"); g_assert (window != NULL); handled = process_mouse_move_resize_grab (display, screen, - window, event, keysym); + window, xdke, keysym); break; case META_GRAB_OP_KEYBOARD_MOVING: @@ -1743,7 +1871,7 @@ meta_display_process_key_event (MetaDisplay *display, "Processing event for keyboard move\n"); g_assert (window != NULL); handled = process_keyboard_move_grab (display, screen, - window, event, keysym); + window, xdke, keysym); break; case META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN: @@ -1759,7 +1887,7 @@ meta_display_process_key_event (MetaDisplay *display, "Processing event for keyboard resize\n"); g_assert (window != NULL); handled = process_keyboard_resize_grab (display, screen, - window, event, keysym); + window, xdke, keysym); break; case META_GRAB_OP_KEYBOARD_TABBING_NORMAL: @@ -1770,13 +1898,13 @@ meta_display_process_key_event (MetaDisplay *display, case META_GRAB_OP_KEYBOARD_ESCAPING_GROUP: meta_topic (META_DEBUG_KEYBINDINGS, "Processing event for keyboard tabbing/cycling\n"); - handled = process_tab_grab (display, screen, event, keysym); + handled = process_tab_grab (display, screen, xdke, keysym); break; case META_GRAB_OP_KEYBOARD_WORKSPACE_SWITCHING: meta_topic (META_DEBUG_KEYBINDINGS, "Processing event for keyboard workspace switching\n"); - handled = process_workspace_switch_grab (display, screen, event, keysym); + handled = process_workspace_switch_grab (display, screen, xdke, keysym); break; default: @@ -1790,21 +1918,27 @@ meta_display_process_key_event (MetaDisplay *display, meta_topic (META_DEBUG_KEYBINDINGS, "Ending grab op %u on key event sym %s\n", display->grab_op, XKeysymToString (keysym)); - meta_display_end_grab_op (display, event->xkey.time); + meta_display_end_grab_op (display, + dev, + xdke->time); } } static gboolean -process_mouse_move_resize_grab (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - KeySym keysym) +process_mouse_move_resize_grab (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + KeySym keysym) { + MetaDevInfo *dev; + /* don't care about releases, but eat them, don't end grab */ - if (event->type == KeyRelease) + if (xdke->type == display->dev_key_release_type) return TRUE; + dev = meta_devices_find_keyboard_by_id (display, xdke->deviceid); + if (keysym == XK_Escape) { /* End move or resize and restore to original state. If the @@ -1816,10 +1950,12 @@ process_mouse_move_resize_grab (MetaDisplay *display, */ if (window->shaken_loose) meta_window_maximize (window, + dev, META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL); else if (!display->grab_wireframe_active) meta_window_move_resize (display->grab_window, + dev, TRUE, display->grab_initial_window_pos.x, display->grab_initial_window_pos.y, @@ -1839,25 +1975,29 @@ process_mouse_move_resize_grab (MetaDisplay *display, } static gboolean -process_keyboard_move_grab (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - KeySym keysym) +process_keyboard_move_grab (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + KeySym keysym) { gboolean handled; int x, y; int incr; gboolean smart_snap; + MetaDevInfo *dev; handled = FALSE; /* don't care about releases, but eat them, don't end grab */ - if (event->type == KeyRelease) + if (xdke->type == display->dev_key_release_type) return TRUE; + dev = meta_devices_find_keyboard_by_id (display, xdke->deviceid); + + /* don't end grab on modifier key presses */ - if (is_modifier (display, event->xkey.keycode)) + if (is_modifier (display, xdke->keycode)) return TRUE; if (display->grab_wireframe_active) @@ -1870,14 +2010,14 @@ process_keyboard_move_grab (MetaDisplay *display, meta_window_get_position (window, &x, &y); } - smart_snap = (event->xkey.state & ShiftMask) != 0; + smart_snap = (xdke->state & ShiftMask) != 0; #define SMALL_INCREMENT 1 #define NORMAL_INCREMENT 10 if (smart_snap) incr = 1; - else if (event->xkey.state & ControlMask) + else if (xdke->state & ControlMask) incr = SMALL_INCREMENT; else incr = NORMAL_INCREMENT; @@ -1893,10 +2033,12 @@ process_keyboard_move_grab (MetaDisplay *display, */ if (window->shaken_loose) meta_window_maximize (window, + dev, META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL); else if (!display->grab_wireframe_active) meta_window_move_resize (display->grab_window, + dev, TRUE, display->grab_initial_window_pos.x, display->grab_initial_window_pos.y, @@ -1976,7 +2118,7 @@ process_keyboard_move_grab (MetaDisplay *display, } else { - meta_window_move (window, TRUE, x, y); + meta_window_move (window, dev, TRUE, x, y); } meta_window_update_keyboard_move (window); @@ -1986,11 +2128,11 @@ process_keyboard_move_grab (MetaDisplay *display, } static gboolean -process_keyboard_resize_grab_op_change (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - KeySym keysym) +process_keyboard_resize_grab_op_change (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + KeySym keysym) { gboolean handled; @@ -2108,11 +2250,11 @@ process_keyboard_resize_grab_op_change (MetaDisplay *display, } static gboolean -process_keyboard_resize_grab (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - KeySym keysym) +process_keyboard_resize_grab (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + KeySym keysym) { gboolean handled; int height_inc; @@ -2120,15 +2262,17 @@ process_keyboard_resize_grab (MetaDisplay *display, int width, height; gboolean smart_snap; int gravity; + MetaDevInfo *dev; handled = FALSE; - /* don't care about releases, but eat them, don't end grab */ - if (event->type == KeyRelease) + if (xdke->type == display->dev_key_release_type) return TRUE; + dev = meta_devices_find_keyboard_by_id (display, xdke->deviceid); + /* don't end grab on modifier key presses */ - if (is_modifier (display, event->xkey.keycode)) + if (is_modifier (display, xdke->keycode)) return TRUE; if (keysym == XK_Escape) @@ -2141,6 +2285,7 @@ process_keyboard_resize_grab (MetaDisplay *display, */ if (!display->grab_wireframe_active) meta_window_move_resize (display->grab_window, + dev, TRUE, display->grab_initial_window_pos.x, display->grab_initial_window_pos.y, @@ -2153,7 +2298,7 @@ process_keyboard_resize_grab (MetaDisplay *display, } if (process_keyboard_resize_grab_op_change (display, screen, window, - event, keysym)) + xdke, keysym)) return TRUE; if (display->grab_wireframe_active) @@ -2169,7 +2314,7 @@ process_keyboard_resize_grab (MetaDisplay *display, gravity = meta_resize_gravity_from_grab_op (display->grab_op); - smart_snap = (event->xkey.state & ShiftMask) != 0; + smart_snap = (xdke->state & ShiftMask) != 0; #define SMALL_INCREMENT 1 #define NORMAL_INCREMENT 10 @@ -2179,7 +2324,7 @@ process_keyboard_resize_grab (MetaDisplay *display, height_inc = 1; width_inc = 1; } - else if (event->xkey.state & ControlMask) + else if (xdke->state & ControlMask) { width_inc = SMALL_INCREMENT; height_inc = SMALL_INCREMENT; @@ -2366,7 +2511,8 @@ process_keyboard_resize_grab (MetaDisplay *display, * are actually different from what we had before. */ if (window->rect.width != width || window->rect.height != height) - meta_window_resize_with_gravity (window, + meta_window_resize_with_gravity (window, + dev, TRUE, width, height, @@ -2382,6 +2528,7 @@ static gboolean end_keyboard_grab (MetaDisplay *display, unsigned int keycode) { +#warning change end_keyboard_grab prototype? I think no... #ifdef HAVE_XKB if (display->xkb_base_event_type > 0) { @@ -2406,10 +2553,10 @@ end_keyboard_grab (MetaDisplay *display, } static gboolean -process_tab_grab (MetaDisplay *display, - MetaScreen *screen, - XEvent *event, - KeySym keysym) +process_tab_grab (MetaDisplay *display, + MetaScreen *screen, + XDeviceKeyEvent *xdke, + KeySym keysym) { MetaKeyBindingAction action; gboolean popup_not_showing; @@ -2417,14 +2564,25 @@ process_tab_grab (MetaDisplay *display, gboolean key_used; 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) return FALSE; g_return_val_if_fail (screen->tab_popup != NULL, FALSE); - if (event->type == KeyRelease && - end_keyboard_grab (display, event->xkey.keycode)) + if (xdke->type == display->dev_key_release_type && + end_keyboard_grab (display, xdke->keycode)) { /* We're done, move to the new window. */ Window target_xwindow; @@ -2449,11 +2607,11 @@ process_tab_grab (MetaDisplay *display, "selection and turning mouse_mode off\n", target_window->desc); display->mouse_mode = FALSE; - meta_window_activate (target_window, event->xkey.time); + meta_window_activate (target_window, dev, xdke->time); meta_topic (META_DEBUG_KEYBINDINGS, "Ending grab early so we can focus the target window\n"); - meta_display_end_grab_op (display, event->xkey.time); + meta_display_end_grab_op (display, dev, xdke->time); return TRUE; /* we already ended the grab */ } @@ -2462,18 +2620,18 @@ process_tab_grab (MetaDisplay *display, } /* don't care about other releases, but eat them, don't end grab */ - if (event->type == KeyRelease) + if (xdke->type == display->dev_key_release_type) return TRUE; /* don't end grab on modifier key presses */ - if (is_modifier (display, event->xkey.keycode)) + if (is_modifier (display, xdke->keycode)) return TRUE; prev_xwindow = (Window) meta_ui_tab_popup_get_selected (screen->tab_popup); prev_window = meta_display_lookup_x_window (display, prev_xwindow); action = display_get_keybinding_action (display, keysym, - event->xkey.keycode, + xdke->keycode, display->grab_mask); /* Cancel when alt-Escape is pressed during using alt-Tab, and vice @@ -2583,7 +2741,7 @@ process_tab_grab (MetaDisplay *display, meta_topic (META_DEBUG_KEYBINDINGS, "Key pressed, moving tab focus in popup\n"); - if (event->xkey.state & ShiftMask) + if (xdke->state & ShiftMask) backward = !backward; if (backward) @@ -2643,11 +2801,11 @@ process_tab_grab (MetaDisplay *display, } static void -handle_activate_workspace (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *event_window, - XEvent *event, - MetaKeyBinding *binding) +handle_activate_workspace (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *event_window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { int which; MetaWorkspace *workspace; @@ -2667,7 +2825,7 @@ handle_activate_workspace (MetaDisplay *display, if (workspace) { - meta_workspace_activate (workspace, event->xkey.time); + meta_workspace_activate (workspace, xdke->time); } else { @@ -2796,11 +2954,11 @@ meta_spawn_command_line_async_on_screen (const gchar *command_line, static void -handle_run_command (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_run_command (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { int which; const char *command; @@ -2820,7 +2978,7 @@ handle_run_command (MetaDisplay *display, s = g_strdup_printf (_("No command %d has been defined.\n"), which + 1); - error_on_command (which, NULL, s, screen->number, event->xkey.time); + error_on_command (which, NULL, s, screen->number, xdke->time); g_free (s); return; @@ -2829,7 +2987,7 @@ handle_run_command (MetaDisplay *display, err = NULL; if (!meta_spawn_command_line_async_on_screen (command, screen, &err)) { - error_on_command (which, command, err->message, screen->number, event->xkey.time); + error_on_command (which, command, err->message, screen->number, xdke->time); g_error_free (err); } @@ -2837,34 +2995,40 @@ handle_run_command (MetaDisplay *display, static void -handle_maximize_vert (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_maximize_vert (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { + MetaDevInfo *dev; + + dev = meta_devices_find_keyboard_by_id (display, xdke->deviceid); if (window && window->has_resize_func) { if (window->maximized_vertically) - meta_window_unmaximize (window, META_MAXIMIZE_VERTICAL); + meta_window_unmaximize (window, dev, META_MAXIMIZE_VERTICAL); else - meta_window_maximize (window, META_MAXIMIZE_VERTICAL); + meta_window_maximize (window, dev, META_MAXIMIZE_VERTICAL); } } static void -handle_maximize_horiz (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_maximize_horiz (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { + MetaDevInfo *dev; + + dev = meta_devices_find_keyboard_by_id (display, xdke->deviceid); if (window && window->has_resize_func) { if (window->maximized_horizontally) - meta_window_unmaximize (window, META_MAXIMIZE_HORIZONTAL); + meta_window_unmaximize (window, dev, META_MAXIMIZE_HORIZONTAL); else - meta_window_maximize (window, META_MAXIMIZE_HORIZONTAL); + meta_window_maximize (window, dev, META_MAXIMIZE_HORIZONTAL); } } @@ -2878,6 +3042,7 @@ static void handle_move_to_corner_backend (MetaDisplay *display, MetaScreen *screen, MetaWindow *window, + MetaDevInfo *dev, gboolean xchange, gboolean ychange, gboolean to_right, @@ -2913,132 +3078,162 @@ handle_move_to_corner_backend (MetaDisplay *display, } meta_window_move_resize (window, - FALSE, - new_x, - new_y, - window->rect.width, - window->rect.height); + dev, + FALSE, + new_x, + new_y, + window->rect.width, + window->rect.height); } static void -handle_move_to_corner_nw (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_move_to_corner_nw (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { if (window) { - handle_move_to_corner_backend (display, screen, window, TRUE, TRUE, FALSE, FALSE); + handle_move_to_corner_backend (display, screen, window, + meta_devices_find_keyboard_by_id(display, xdke->deviceid), + TRUE, TRUE, FALSE, FALSE); } } static void -handle_move_to_corner_ne (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_move_to_corner_ne (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { if (window) { - handle_move_to_corner_backend (display, screen, window, TRUE, TRUE, TRUE, FALSE); + handle_move_to_corner_backend (display, screen, window, + meta_devices_find_keyboard_by_id(display, xdke->deviceid), + TRUE, TRUE, TRUE, FALSE); } } static void -handle_move_to_corner_sw (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_move_to_corner_sw (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { if (window) { - handle_move_to_corner_backend (display, screen, window, TRUE, TRUE, FALSE, TRUE); + handle_move_to_corner_backend (display, screen, window, + meta_devices_find_keyboard_by_id(display, xdke->deviceid), + TRUE, TRUE, FALSE, TRUE); } } static void -handle_move_to_corner_se (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_move_to_corner_se (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { if (window) { - handle_move_to_corner_backend (display, screen, window, TRUE, TRUE, TRUE, TRUE); + handle_move_to_corner_backend (display, screen, window, + meta_devices_find_keyboard_by_id(display, xdke->deviceid), + TRUE, TRUE, TRUE, TRUE); } } static void -handle_move_to_side_n (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_move_to_side_n (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { if (window) { - handle_move_to_corner_backend (display, screen, window, FALSE, TRUE, FALSE, FALSE); + handle_move_to_corner_backend (display, screen, window, + meta_devices_find_keyboard_by_id(display, xdke->deviceid), + FALSE, TRUE, FALSE, FALSE); } } static void -handle_move_to_side_s (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_move_to_side_s (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { if (window) { - handle_move_to_corner_backend (display, screen, window, FALSE, TRUE, FALSE, TRUE); + handle_move_to_corner_backend (display, screen, window, + meta_devices_find_keyboard_by_id(display, xdke->deviceid), + FALSE, TRUE, FALSE, TRUE); } } static void -handle_move_to_side_e (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_move_to_side_e (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { if (window) { - handle_move_to_corner_backend (display, screen, window, TRUE, FALSE, TRUE, FALSE); + handle_move_to_corner_backend (display, screen, window, + meta_devices_find_keyboard_by_id(display, xdke->deviceid), + TRUE, FALSE, TRUE, FALSE); } } static void -handle_move_to_side_w (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_move_to_side_w (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { if (window) { - handle_move_to_corner_backend (display, screen, window, TRUE, FALSE, FALSE, FALSE); + handle_move_to_corner_backend (display, screen, window, + meta_devices_find_keyboard_by_id(display, xdke->deviceid), + TRUE, FALSE, FALSE, FALSE); } } static gboolean -process_workspace_switch_grab (MetaDisplay *display, - MetaScreen *screen, - XEvent *event, - KeySym keysym) +process_workspace_switch_grab (MetaDisplay *display, + MetaScreen *screen, + XDeviceKeyEvent *xdke, + 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); + g_return_val_if_fail (screen->tab_popup != NULL, FALSE); - if (event->type == KeyRelease && - end_keyboard_grab (display, event->xkey.keycode)) + if (xdke->type == display->dev_key_release_type && + end_keyboard_grab (display, xdke->keycode)) { /* We're done, move to the new workspace. */ MetaWorkspace *target_workspace; @@ -3053,14 +3248,15 @@ process_workspace_switch_grab (MetaDisplay *display, { meta_topic (META_DEBUG_KEYBINDINGS, "Ending grab so we can focus on the target workspace\n"); - meta_display_end_grab_op (display, event->xkey.time); + meta_display_end_grab_op (display, dev, xdke->time); meta_topic (META_DEBUG_KEYBINDINGS, "Focusing default window on target workspace\n"); - meta_workspace_focus_default_window (target_workspace, + meta_workspace_focus_default_window (target_workspace, + dev, NULL, - event->xkey.time); + xdke->time); return TRUE; /* we already ended the grab */ } @@ -3072,11 +3268,11 @@ process_workspace_switch_grab (MetaDisplay *display, } /* don't care about other releases, but eat them, don't end grab */ - if (event->type == KeyRelease) + if (xdke->type == display->dev_key_release_type) return TRUE; /* don't end grab on modifier key presses */ - if (is_modifier (display, event->xkey.keycode)) + if (is_modifier (display, xdke->keycode)) return TRUE; /* select the next workspace in the tabpopup */ @@ -3090,7 +3286,7 @@ process_workspace_switch_grab (MetaDisplay *display, action = display_get_keybinding_action (display, keysym, - event->xkey.keycode, + xdke->keycode, display->grab_mask); switch (action) @@ -3130,7 +3326,7 @@ process_workspace_switch_grab (MetaDisplay *display, meta_topic (META_DEBUG_KEYBINDINGS, "Activating target workspace\n"); - meta_workspace_activate (target_workspace, event->xkey.time); + meta_workspace_activate (target_workspace, xdke->time); return TRUE; /* we already ended the grab */ } @@ -3141,34 +3337,38 @@ process_workspace_switch_grab (MetaDisplay *display, "Ending workspace tabbing & focusing default window; uninteresting key pressed\n"); workspace = (MetaWorkspace *) meta_ui_tab_popup_get_selected (screen->tab_popup); - meta_workspace_focus_default_window (workspace, NULL, event->xkey.time); + meta_workspace_focus_default_window (workspace, dev, NULL, xdke->time); return FALSE; } static void -handle_toggle_desktop (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_toggle_desktop (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { + MetaDevInfo *dev; + + dev = meta_devices_find_keyboard_by_id (display, xdke->deviceid); if (screen->active_workspace->showing_desktop) { meta_screen_unshow_desktop (screen); - meta_workspace_focus_default_window (screen->active_workspace, + meta_workspace_focus_default_window (screen->active_workspace, + dev, NULL, - event->xkey.time); + xdke->time); } else - meta_screen_show_desktop (screen, event->xkey.time); + meta_screen_show_desktop (screen, xdke->time); } static void -handle_panel_keybinding (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_panel_keybinding (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { MetaKeyBindingAction action; Atom action_atom; @@ -3194,17 +3394,23 @@ handle_panel_keybinding (MetaDisplay *display, ev.message_type = display->atom_gnome_panel_action; ev.format = 32; ev.data.l[0] = action_atom; - ev.data.l[1] = event->xkey.time; + ev.data.l[1] = xdke->time; meta_topic (META_DEBUG_KEYBINDINGS, "Sending panel message with timestamp %lu, and turning mouse_mode " - "off due to keybinding press\n", event->xkey.time); + "off due to keybinding press\n", xdke->time); display->mouse_mode = FALSE; meta_error_trap_push (display); /* Release the grab for the panel before sending the event */ - XUngrabKeyboard (display->xdisplay, event->xkey.time); + XUngrabDevice (display->xdisplay, + (meta_devices_find_keyboard_by_id (display, xdke->deviceid))->xdev, /* XXX */ + xdke->time); +#if 0 +#warning XUngrabKeyboard + XUngrabKeyboard (display->xdisplay, xdke->time); +#endif XSendEvent (display->xdisplay, screen->xroot, @@ -3216,11 +3422,11 @@ handle_panel_keybinding (MetaDisplay *display, } static void -handle_activate_menu (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *event_window, - XEvent *event, - MetaKeyBinding *binding) +handle_activate_menu (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *event_window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { if (display->focus_window) { @@ -3235,7 +3441,7 @@ handle_activate_menu (MetaDisplay *display, meta_window_show_menu (display->focus_window, x, y, 0, - event->xkey.time); + xdke->time); } } @@ -3276,16 +3482,22 @@ cycle_op_from_tab_type (MetaTabList type) } static void -do_choose_window (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *event_window, - XEvent *event, - MetaKeyBinding *binding, - gboolean backward, - gboolean show_popup) +do_choose_window (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *event_window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding, + gboolean backward, + gboolean show_popup) { MetaTabList type; MetaWindow *initial_selection; + + MetaDevInfo *kbdDev; + MetaDevInfo *pairedPtr; + + kbdDev = meta_devices_find_keyboard_by_id (display, xdke->deviceid); + pairedPtr = meta_devices_find_paired_mouse (display, xdke->deviceid); type = GPOINTER_TO_INT (binding->handler->data); @@ -3293,7 +3505,7 @@ do_choose_window (MetaDisplay *display, "Tab list = %u show_popup = %d\n", type, show_popup); /* reverse direction if shift is down */ - if (event->xkey.state & ShiftMask) + if (xdke->state & ShiftMask) backward = !backward; initial_selection = meta_display_get_tab_next (display, @@ -3325,10 +3537,11 @@ do_choose_window (MetaDisplay *display, "switch/cycle windows with no modifiers\n", initial_selection->desc); display->mouse_mode = FALSE; - meta_window_activate (initial_selection, event->xkey.time); + meta_window_activate (initial_selection, kbdDev, xdke->time); } else if (meta_display_begin_grab_op (display, screen, + pairedPtr, NULL, show_popup ? tab_op_from_tab_type (type) : @@ -3337,10 +3550,10 @@ do_choose_window (MetaDisplay *display, FALSE, 0, binding->mask, - event->xkey.time, + xdke->time, 0, 0)) { - if (!primary_modifier_still_pressed (display, + if (!primary_modifier_still_pressed (display, pairedPtr, binding->mask)) { /* This handles a race where modifier might be released @@ -3352,9 +3565,9 @@ do_choose_window (MetaDisplay *display, "mouse_mode due to switch/cycle windows where " "modifier was released prior to grab\n", initial_selection->desc); - meta_display_end_grab_op (display, event->xkey.time); + meta_display_end_grab_op (display, pairedPtr, xdke->time); display->mouse_mode = FALSE; - meta_window_activate (initial_selection, event->xkey.time); + meta_window_activate (initial_selection, kbdDev, xdke->time); } else { @@ -3377,71 +3590,75 @@ do_choose_window (MetaDisplay *display, } static void -handle_tab_forward (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *event_window, - XEvent *event, - MetaKeyBinding *binding) +handle_tab_forward (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *event_window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { do_choose_window (display, screen, - event_window, event, binding, FALSE, TRUE); + event_window, xdke, binding, FALSE, TRUE); } static void -handle_tab_backward (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *event_window, - XEvent *event, - MetaKeyBinding *binding) +handle_tab_backward (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *event_window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { do_choose_window (display, screen, - event_window, event, binding, TRUE, TRUE); + event_window, xdke, binding, TRUE, TRUE); } static void -handle_cycle_forward (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *event_window, - XEvent *event, - MetaKeyBinding *binding) +handle_cycle_forward (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *event_window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { do_choose_window (display, screen, - event_window, event, binding, FALSE, FALSE); + event_window, xdke, binding, FALSE, FALSE); } static void -handle_cycle_backward (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *event_window, - XEvent *event, - MetaKeyBinding *binding) +handle_cycle_backward (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *event_window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { do_choose_window (display, screen, - event_window, event, binding, TRUE, FALSE); + event_window, xdke, binding, TRUE, FALSE); } static void -handle_toggle_fullscreen (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_toggle_fullscreen (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { + MetaDevInfo *dev; + + dev = meta_devices_find_keyboard_by_id (display, xdke->deviceid); + if (window) { if (window->fullscreen) - meta_window_unmake_fullscreen (window); + meta_window_unmake_fullscreen (window, dev); else if (window->has_fullscreen_func) - meta_window_make_fullscreen (window); + meta_window_make_fullscreen (window, dev); } } static void -handle_toggle_above (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_toggle_above (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { if (window) { @@ -3453,91 +3670,105 @@ handle_toggle_above (MetaDisplay *display, } static void -handle_toggle_maximize (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_toggle_maximize (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { + MetaDevInfo *dev; + + dev = meta_devices_find_keyboard_by_id (display, xdke->deviceid); + if (window) { if (META_WINDOW_MAXIMIZED (window)) - meta_window_unmaximize (window, + meta_window_unmaximize (window, dev, META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL); else if (window->has_maximize_func) - meta_window_maximize (window, + meta_window_maximize (window, dev, META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL); } } static void -handle_maximize (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_maximize (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { if (window) { if (window->has_maximize_func) meta_window_maximize (window, + meta_devices_find_keyboard_by_id (display, + xdke->deviceid), + META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL); } } static void -handle_unmaximize (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_unmaximize (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { + MetaDevInfo *dev; + + dev = meta_devices_find_keyboard_by_id (display, xdke->deviceid); + if (window) { if (window->maximized_vertically || window->maximized_horizontally) - meta_window_unmaximize (window, + meta_window_unmaximize (window, dev, META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL); } } static void -handle_toggle_shade (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_toggle_shade (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { + MetaDevInfo *dev; + + dev = meta_devices_find_keyboard_by_id (display, xdke->deviceid); if (window) { if (window->shaded) - meta_window_unshade (window, event->xkey.time); + meta_window_unshade (window, dev, xdke->time); else if (window->has_shade_func) - meta_window_shade (window, event->xkey.time); + meta_window_shade (window, dev, xdke->time); } } static void -handle_close_window (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_close_window (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { if (window) if (window->has_close_func) - meta_window_delete (window, event->xkey.time); + meta_window_delete (window, xdke->time); } static void -handle_minimize_window (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_minimize_window (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { if (window) if (window->has_minimize_func) @@ -3545,43 +3776,69 @@ handle_minimize_window (MetaDisplay *display, } static void -handle_begin_move (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_begin_move (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { + /* XXX Shouldnt we grab the mouse? (not the keyboard) */ +#if 0 + int idev; + MetaDevInfo *dev; + for (idev = 0; idev < display->devices->keybsUsed; idev++) + if (((XDeviceKeyEvent*)event)->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 (window && window->has_move_func) { meta_window_begin_grab_op (window, + dev, META_GRAB_OP_KEYBOARD_MOVING, FALSE, - event->xkey.time); + xdke->time); } } static void -handle_begin_resize (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_begin_resize (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { + /* XXX Shouldnt we grab the mouse? (not the keyboard) */ +#if 0 + int idev; + MetaDevInfo *dev; + for (idev = 0; idev < display->devices->keybsUsed; idev++) + if (((XDeviceKeyEvent*)event)->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 (window && window->has_resize_func) { meta_window_begin_grab_op (window, + dev, META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN, FALSE, - event->xkey.time); + xdke->time); } } static void -handle_toggle_sticky (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_toggle_sticky (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { if (window) { @@ -3593,12 +3850,12 @@ handle_toggle_sticky (MetaDisplay *display, } static void -do_handle_move_to_workspace (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding, - gboolean flip) +do_handle_move_to_workspace (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding, + gboolean flip) { int which; MetaWorkspace *workspace; @@ -3631,7 +3888,7 @@ do_handle_move_to_workspace (MetaDisplay *display, workspace->screen->display->mouse_mode = FALSE; meta_workspace_activate_with_focus (workspace, window, - event->xkey.time); + xdke->time); } } else @@ -3641,40 +3898,40 @@ do_handle_move_to_workspace (MetaDisplay *display, } static void -handle_move_to_workspace (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_move_to_workspace (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { do_handle_move_to_workspace (display, screen, window, - event, + xdke, binding, FALSE); } static void -handle_move_to_workspace_flip (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_move_to_workspace_flip (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { do_handle_move_to_workspace (display, screen, window, - event, + xdke, binding, TRUE); } static void -handle_raise_or_lower (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_raise_or_lower (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { /* Get window at pointer */ @@ -3719,11 +3976,11 @@ handle_raise_or_lower (MetaDisplay *display, } static void -handle_raise (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_raise (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { if (window) { @@ -3732,11 +3989,11 @@ handle_raise (MetaDisplay *display, } static void -handle_lower (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_lower (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { if (window) { @@ -3745,14 +4002,21 @@ handle_lower (MetaDisplay *display, } static void -handle_workspace_switch (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_workspace_switch (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { int motion; unsigned int grab_mask; + + MetaDevInfo *kbdDev; + MetaDevInfo *pairedPtr; + + kbdDev = meta_devices_find_keyboard_by_id (display, xdke->deviceid); + pairedPtr = meta_devices_find_paired_mouse (display, xdke->deviceid); + motion = GPOINTER_TO_INT (binding->handler->data); @@ -3762,17 +4026,18 @@ handle_workspace_switch (MetaDisplay *display, "Starting tab between workspaces, showing popup\n"); /* FIXME should we use binding->mask ? */ - grab_mask = event->xkey.state & ~(display->ignored_modifier_mask); + grab_mask = xdke->state & ~(display->ignored_modifier_mask); if (meta_display_begin_grab_op (display, screen, + pairedPtr, NULL, META_GRAB_OP_KEYBOARD_WORKSPACE_SWITCHING, FALSE, FALSE, 0, grab_mask, - event->xkey.time, + xdke->time, 0, 0)) { MetaWorkspace *next; @@ -3781,7 +4046,7 @@ handle_workspace_switch (MetaDisplay *display, next = meta_workspace_get_neighbor (screen->active_workspace, motion); g_assert (next); - grabbed_before_release = primary_modifier_still_pressed (display, grab_mask); + grabbed_before_release = primary_modifier_still_pressed (display, pairedPtr, grab_mask); meta_topic (META_DEBUG_KEYBINDINGS, "Activating target workspace\n"); @@ -3793,10 +4058,10 @@ handle_workspace_switch (MetaDisplay *display, * release event. Must end grab before we can switch * spaces. */ - meta_display_end_grab_op (display, event->xkey.time); + meta_display_end_grab_op (display, pairedPtr, xdke->time); } - meta_workspace_activate (next, event->xkey.time); + meta_workspace_activate (next, xdke->time); if (grabbed_before_release) { @@ -3809,11 +4074,11 @@ handle_workspace_switch (MetaDisplay *display, } static void -handle_spew_mark (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_spew_mark (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { meta_verbose ("-- MARK MARK MARK MARK --\n"); } @@ -3827,15 +4092,15 @@ meta_set_keybindings_disabled (gboolean setting) } static void -handle_run_terminal (MetaDisplay *display, - MetaScreen *screen, - MetaWindow *window, - XEvent *event, - MetaKeyBinding *binding) +handle_run_terminal (MetaDisplay *display, + MetaScreen *screen, + MetaWindow *window, + XDeviceKeyEvent *xdke, + MetaKeyBinding *binding) { const char *command; GError *err; - + command = meta_prefs_get_terminal_command (); if (command == NULL) @@ -3847,7 +4112,7 @@ handle_run_terminal (MetaDisplay *display, "keybinding press\n"); s = g_strdup_printf (_("No terminal command has been defined.\n")); - error_on_terminal_command (NULL, s, screen->number, event->xkey.time); + error_on_terminal_command (NULL, s, screen->number, xdke->time); g_free (s); return; @@ -3857,7 +4122,7 @@ handle_run_terminal (MetaDisplay *display, if (!meta_spawn_command_line_async_on_screen (command, screen, &err)) { error_on_terminal_command (command, err->message, screen->number, - event->xkey.time); + xdke->time); g_error_free (err); } diff --git a/src/keybindings.h b/src/keybindings.h index 0f5e4d58..82db0d4d 100644 --- a/src/keybindings.h +++ b/src/keybindings.h @@ -26,24 +26,43 @@ #include "display.h" #include "window.h" +#include "devices.h" void meta_display_init_keys (MetaDisplay *display); void meta_display_shutdown_keys (MetaDisplay *display); -void meta_screen_grab_keys (MetaScreen *screen); -void meta_screen_ungrab_keys (MetaScreen *screen); +void meta_screen_grab_keys (MetaScreen *screen, + MetaDevInfo *dev); +void meta_screen_ungrab_keys (MetaScreen *screen, + MetaDevInfo *dev); +#ifdef MPX gboolean meta_screen_grab_all_keys (MetaScreen *screen, + MetaDevInfo *dev, guint32 timestamp); -void meta_screen_ungrab_all_keys (MetaScreen *screen, +#else +gboolean meta_screen_grab_all_keys (MetaScreen *screen, + guint32 timestamp); +#endif +void meta_screen_ungrab_all_keys (MetaScreen *screen, + MetaDevInfo *dev, guint32 timestamp); -void meta_window_grab_keys (MetaWindow *window); -void meta_window_ungrab_keys (MetaWindow *window); +void meta_window_grab_keys (MetaWindow *window, + MetaDevInfo *dev); +void meta_window_ungrab_keys (MetaWindow *window, + MetaDevInfo *dev); +#ifdef MPX gboolean meta_window_grab_all_keys (MetaWindow *window, + MetaDevInfo *dev, guint32 timestamp); +#else +gboolean meta_window_grab_all_keys (MetaWindow *window, + guint32 timestamp); +#endif void meta_window_ungrab_all_keys (MetaWindow *window, + MetaDevInfo *dev, guint32 timestamp); -void meta_display_process_key_event (MetaDisplay *display, - MetaWindow *window, - XEvent *event); +void meta_display_process_key_event (MetaDisplay *display, + MetaWindow *window, + XDeviceKeyEvent *xdke); void meta_set_keybindings_disabled (gboolean setting); void meta_display_process_mapping_event (MetaDisplay *display, XEvent *event); diff --git a/src/place.c b/src/place.c index 20972a33..2439de4d 100644 --- a/src/place.c +++ b/src/place.c @@ -135,7 +135,9 @@ find_next_cascade (MetaWindow *window, * of NW corner of window frame. */ - current = meta_screen_get_current_xinerama (window->screen); + /* XXX */ + current = meta_screen_get_current_xinerama (window->screen, + &window->display->devices->mice[0]); meta_window_get_work_area_for_xinerama (window, current->number, &work_area); cascade_x = MAX (0, work_area.x); @@ -790,7 +792,9 @@ meta_window_place (MetaWindow *window, int w, h; /* Warning, this function is a round trip! */ - xi = meta_screen_get_current_xinerama (window->screen); + /* Warning, this is an XXX! */ + xi = meta_screen_get_current_xinerama (window->screen, + &window->display->devices->mice[0]); w = xi->rect.width; h = xi->rect.height; @@ -835,7 +839,9 @@ meta_window_place (MetaWindow *window, } /* Warning, this is a round trip! */ - xi = meta_screen_get_current_xinerama (window->screen); + /* Warning, this is an XXX! */ + xi = meta_screen_get_current_xinerama (window->screen, + &window->display->devices->mice[0]); /* "Origin" placement algorithm */ x = xi->rect.x; diff --git a/src/screen.c b/src/screen.c index 362397ca..8afe50ec 100644 --- a/src/screen.c +++ b/src/screen.c @@ -500,8 +500,8 @@ meta_screen_new (MetaDisplay *display, SubstructureRedirectMask | SubstructureNotifyMask | ColormapChangeMask | PropertyChangeMask | LeaveWindowMask | EnterWindowMask | - KeyPressMask | KeyReleaseMask | - FocusChangeMask | StructureNotifyMask | +/* KeyPressMask | KeyReleaseMask | */ +/* FocusChangeMask | */StructureNotifyMask | #ifdef HAVE_COMPOSITE_EXTENSIONS ExposureMask | #endif @@ -515,7 +515,44 @@ meta_screen_new (MetaDisplay *display, return NULL; } - + + XEventClass *evclasses; + int nclasses = 0; + int idev; + + evclasses = g_new(XEventClass, display->devices->keybsUsed * 4); + + for (idev = 0; idev < display->devices->keybsUsed; idev++) + { + DeviceKeyPress (display->devices->keyboards[idev].xdev, + display->dev_key_press_type, + evclasses[nclasses]); + nclasses++; + if (display->dev_key_press_type == 0) + { + meta_warning("MAPUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUULULULULU\n"); + meta_warning("MAPUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUULULULULU\n"); + meta_warning("MAPUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUULULULULU\n"); + meta_warning("MAPUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUULULULULU\n"); + sleep (5); + } + DeviceKeyRelease (display->devices->keyboards[idev].xdev, + display->dev_key_release_type, + evclasses[nclasses]); + nclasses++; + DeviceFocusIn (display->devices->keyboards[idev].xdev, + display->dev_focus_in_type, + evclasses[nclasses]); + nclasses++; + DeviceFocusOut (display->devices->keyboards[idev].xdev, + display->dev_focus_out_type, + evclasses[nclasses]); + nclasses++; + } + + XSelectExtensionEvent (xdisplay, xroot, evclasses, nclasses); + /* g_free evclasses XXX */ + screen = g_new (MetaScreen, 1); screen->closing = 0; @@ -624,7 +661,9 @@ meta_screen_new (MetaDisplay *display, screen->all_keys_grabbed = FALSE; screen->keys_grabbed = FALSE; - meta_screen_grab_keys (screen); + + for (idev = 0; idev < display->devices->keybsUsed; idev++) + meta_screen_grab_keys (screen, &display->devices->keyboards[idev]); screen->ui = meta_ui_new (screen->display->xdisplay, screen->xscreen); @@ -670,6 +709,8 @@ meta_screen_free (MetaScreen *screen, MetaDisplay *display; XGCValues gc_values = { 0 }; + int idev; + display = screen->display; screen->closing += 1; @@ -686,7 +727,8 @@ meta_screen_free (MetaScreen *screen, meta_prefs_remove_listener (prefs_changed_callback, screen); - meta_screen_ungrab_keys (screen); + for (idev = 0; idev < display->devices->keybsUsed; idev++) + meta_screen_ungrab_keys (screen, &display->devices->keyboards[idev]); #ifdef HAVE_STARTUP_NOTIFICATION g_slist_foreach (screen->startup_sequences, @@ -807,9 +849,11 @@ meta_screen_manage_all_windows (MetaScreen *screen) for (list = windows; list != NULL; list = list->next) { WindowInfo *info = list->data; - + /* FIXME: we just don't know what keyboard we should associate with each + * window... That is a really really big problem... */ meta_window_new_with_attrs (screen->display, info->xwindow, TRUE, - &info->attrs); + &info->attrs, + &screen->display->devices->keyboards[0]); } meta_stack_thaw (screen->stack); @@ -1388,7 +1432,8 @@ meta_screen_ensure_workspace_popup (MetaScreen *screen) } MetaWindow* -meta_screen_get_mouse_window (MetaScreen *screen, +meta_screen_get_mouse_window (MetaDevInfo *dev, + MetaScreen *screen, MetaWindow *not_this_one) { MetaWindow *window; @@ -1396,12 +1441,28 @@ meta_screen_get_mouse_window (MetaScreen *screen, int root_x_return, root_y_return; int win_x_return, win_y_return; unsigned int mask_return; + Bool shared; if (not_this_one) meta_topic (META_DEBUG_FOCUS, "Focusing mouse window excluding %s\n", not_this_one->desc); meta_error_trap_push (screen->display); + + XQueryDevicePointer (screen->display->xdisplay, + dev->xdev, + screen->xroot, + &root_return, + &child_return, + &root_x_return, + &root_y_return, + &win_x_return, + &win_y_return, + &mask_return, + &shared); + +#if 0 +#warning XQueryPointer XQueryPointer (screen->display->xdisplay, screen->xroot, &root_return, @@ -1411,6 +1472,7 @@ meta_screen_get_mouse_window (MetaScreen *screen, &win_x_return, &win_y_return, &mask_return); +#endif meta_error_trap_pop (screen->display, TRUE); window = meta_stack_get_default_focus_window_at_point (screen->stack, @@ -1526,8 +1588,9 @@ meta_screen_get_natural_xinerama_list (MetaScreen *screen, { visited[i] = FALSE; } - - current = meta_screen_get_current_xinerama (screen); + /* XXX XXX XXX XXX TODO FIXME PORN */ + current = meta_screen_get_current_xinerama (screen, + &screen->display->devices->mice[0]); xinerama_queue = g_queue_new (); g_queue_push_tail (xinerama_queue, (gpointer) current); visited[current->number] = TRUE; @@ -1594,7 +1657,7 @@ meta_screen_get_natural_xinerama_list (MetaScreen *screen, } const MetaXineramaScreenInfo* -meta_screen_get_current_xinerama (MetaScreen *screen) +meta_screen_get_current_xinerama (MetaScreen *screen, MetaDevInfo *dev) { if (screen->n_xinerama_infos == 1) return &screen->xinerama_infos[0]; @@ -1609,10 +1672,27 @@ meta_screen_get_current_xinerama (MetaScreen *screen) unsigned int mask_return; int i; MetaRectangle pointer_position; + Bool shared; screen->display->xinerama_cache_invalidated = FALSE; pointer_position.width = pointer_position.height = 1; + + XQueryDevicePointer (screen->display->xdisplay, + dev->xdev, + screen->xroot, + &root_return, + &child_return, + &pointer_position.x, + &pointer_position.y, + &win_x_return, + &win_y_return, + &mask_return, + &shared); + + +#if 0 +#warning XQueryPointer XQueryPointer (screen->display->xdisplay, screen->xroot, &root_return, @@ -1622,6 +1702,7 @@ meta_screen_get_current_xinerama (MetaScreen *screen) &win_x_return, &win_y_return, &mask_return); +#endif screen->last_xinerama_index = 0; for (i = 0; i < screen->n_xinerama_infos; i++) @@ -1825,8 +1906,17 @@ meta_create_offscreen_window (Display *xdisplay, Window parent, long valuemask) { + + Window xwin; + XSetWindowAttributes attrs; + XEventClass *evclasses; + int nclasses = 0; + int idev; + + MetaDisplay *display = meta_display_for_x_display (xdisplay); + /* we want to be override redirect because sometimes we * create a window on a screen we aren't managing. * (but on a display we are managing at least one screen for) @@ -1834,7 +1924,56 @@ meta_create_offscreen_window (Display *xdisplay, attrs.override_redirect = True; attrs.event_mask = valuemask; - return XCreateWindow (xdisplay, + evclasses = g_new(XEventClass, display->devices->keybsUsed * 4); + + for (idev = 0; idev < display->devices->keybsUsed; idev++) + { + if (valuemask & KeyPressMask) + { + DeviceKeyPress (display->devices->keyboards[idev].xdev, + display->dev_key_press_type, + evclasses[nclasses]); + nclasses++; + if (display->dev_key_press_type == 0) + { + meta_warning("UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUULULULULU\n"); + meta_warning("UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUULULULULU\n"); + meta_warning("UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUULULULULU\n"); + meta_warning("UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUULULULULU\n"); + sleep (5); + } + + } + if (valuemask & KeyReleaseMask) + { + DeviceKeyRelease (display->devices->keyboards[idev].xdev, + display->dev_key_release_type, + evclasses[nclasses]); + nclasses++; + } + if (valuemask & FocusChangeMask) + { + DeviceFocusIn (display->devices->keyboards[idev].xdev, + display->dev_focus_in_type, + evclasses[nclasses]); + nclasses++; + DeviceFocusOut (display->devices->keyboards[idev].xdev, + display->dev_focus_out_type, + evclasses[nclasses]); + nclasses++; + } + } + + if (valuemask & KeyPressMask) + attrs.event_mask |= ~KeyPressMask; + + if (valuemask & KeyReleaseMask) + attrs.event_mask |= ~KeyReleaseMask; + + if (valuemask & FocusChangeMask) + attrs.event_mask |= ~FocusChangeMask; + + xwin = XCreateWindow (xdisplay, parent, -100, -100, 1, 1, 0, @@ -1843,6 +1982,11 @@ meta_create_offscreen_window (Display *xdisplay, (Visual *)CopyFromParent, CWOverrideRedirect | CWEventMask, &attrs); + + XSelectExtensionEvent (xdisplay, xwin, evclasses, nclasses); + /* g_free evclasses XXX */ + + return xwin; } static void @@ -2308,6 +2452,7 @@ meta_screen_show_desktop (MetaScreen *screen, guint32 timestamp) { GList *windows; + int idev; if (screen->active_workspace->showing_desktop) return; @@ -2327,7 +2472,9 @@ meta_screen_show_desktop (MetaScreen *screen, if (w->screen == screen && w->type == META_WINDOW_DESKTOP) { - meta_window_focus (w, timestamp); + /* XXX make a mru for each device!!!!!!!! FIXME TODO*/ + for (idev = 0; idev < w->display->devices->miceUsed; idev++) + meta_window_focus (w, &w->display->devices->mice[idev], timestamp); break; } diff --git a/src/screen.h b/src/screen.h index e3a0340d..c6cc7f45 100644 --- a/src/screen.h +++ b/src/screen.h @@ -149,10 +149,11 @@ void meta_screen_ensure_tab_popup (MetaScreen *scree MetaTabShowType show_type); void meta_screen_ensure_workspace_popup (MetaScreen *screen); -MetaWindow* meta_screen_get_mouse_window (MetaScreen *screen, - MetaWindow *not_this_one); +MetaWindow* meta_screen_get_mouse_window (MetaDevInfo *dev, + MetaScreen *screen, + MetaWindow *not_this_one); -const MetaXineramaScreenInfo* meta_screen_get_current_xinerama (MetaScreen *screen); +const MetaXineramaScreenInfo* meta_screen_get_current_xinerama (MetaScreen *screen, MetaDevInfo *dev); const MetaXineramaScreenInfo* meta_screen_get_xinerama_for_rect (MetaScreen *screen, MetaRectangle *rect); const MetaXineramaScreenInfo* meta_screen_get_xinerama_for_window (MetaScreen *screen, @@ -153,6 +153,18 @@ meta_ui_get_frame_geometry (MetaUI *ui, } Window +#ifdef MPX +meta_ui_create_frame_window (MetaUI *ui, + Display *xdisplay, + MetaDevices *devices, + Visual *xvisual, + gint x, + gint y, + gint width, + gint height, + gint screen_no) + +#else meta_ui_create_frame_window (MetaUI *ui, Display *xdisplay, Visual *xvisual, @@ -161,6 +173,7 @@ meta_ui_create_frame_window (MetaUI *ui, gint width, gint height, gint screen_no) +#endif { GdkDisplay *display = gdk_x11_lookup_xdisplay (xdisplay); GdkScreen *screen = gdk_display_get_screen (display, screen_no); @@ -169,7 +182,7 @@ meta_ui_create_frame_window (MetaUI *ui, GdkWindow *window; GdkVisual *visual; GdkColormap *cmap = gdk_screen_get_default_colormap (screen); - + /* Default depth/visual handles clients with weird visuals; they can * always be children of the root depth/visual obviously, but * e.g. DRI games can't be children of a parent that has the same @@ -215,8 +228,48 @@ meta_ui_create_frame_window (MetaUI *ui, gdk_window_resize (window, width, height); - meta_frames_manage_window (ui->frames, GDK_WINDOW_XID (window), window); + meta_frames_manage_window (ui->frames, GDK_WINDOW_XID (window), + window, devices); + +#ifdef MPX + GList *devslist, *j; + int i; + + devslist = gdk_devices_list(); + /* We're gonna need to know which mouse clicked the window... */ + for (i = 0; i < devices->miceUsed; i++) + { + for (j = devslist; j != NULL; j = j->next) + { +// meta_warning("devices->mice[i].name = %s | j->data->name = %s\n", +// devices->mice[i].name, ((GdkDevice*)(j->data))->name); + if (strcmp( ((GdkDevice*)(j->data))->name, + devices->mice[i].name) == 0) + { + meta_warning("selecting mouse name %s (%s) for gdk events.\n", + devices->mice[i].name, ((GdkDevice*)(j->data))->name); + gdk_device_set_mode(((GdkDevice*)(j->data)), GDK_MODE_RAW); + break; + } + } + if (j == NULL) + meta_warning("WARNING!! " + "Device %s has not been selected for gdk events!\n", + devices->mice[i].name); + } + + gdk_input_set_extension_events (window, + GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | + GDK_BUTTON_RELEASE_MASK | + GDK_POINTER_MOTION_MASK | + GDK_POINTER_MOTION_HINT_MASK | + GDK_ENTER_NOTIFY_MASK | + GDK_LEAVE_NOTIFY_MASK | + GDK_FOCUS_CHANGE_MASK, + GDK_EXTENSION_EVENTS_ALL); + +#endif return GDK_WINDOW_XID (window); } @@ -75,14 +75,26 @@ void meta_ui_get_frame_geometry (MetaUI *ui, Window frame_xwindow, int *top_height, int *bottom_height, int *left_width, int *right_width); +#ifdef MPX Window meta_ui_create_frame_window (MetaUI *ui, Display *xdisplay, + MetaDevices *devices, Visual *xvisual, gint x, gint y, gint width, gint height, gint screen_no); +#else +Window meta_ui_create_frame_window (MetaUI *ui, + Display *xdisplay, + Visual *xvisual, + gint x, + gint y, + gint width, + gint height, + gint screen_no); +#endif void meta_ui_destroy_frame_window (MetaUI *ui, Window xwindow); void meta_ui_move_resize_frame (MetaUI *ui, diff --git a/src/window-props.c b/src/window-props.c index 3602395a..70da4ab6 100644 --- a/src/window-props.c +++ b/src/window-props.c @@ -805,7 +805,9 @@ reload_net_startup_id (MetaWindow *window, if (window->initial_workspace_set) workspace = meta_screen_get_workspace_by_index (window->screen, window->initial_workspace); - meta_window_activate_with_workspace (window, timestamp, workspace); + meta_window_activate_with_workspace (window, + /* XXX */ &window->display->devices->keyboards[0], + timestamp, workspace); } } diff --git a/src/window.c b/src/window.c index 3cd013e3..807b10ac 100644 --- a/src/window.c +++ b/src/window.c @@ -45,6 +45,7 @@ #include "constraints.h" #include "compositor.h" #include "effects.h" +#include "devices.h" #include <X11/Xatom.h> #include <string.h> @@ -81,6 +82,7 @@ static void meta_window_hide (MetaWindow *window); static void meta_window_save_rect (MetaWindow *window); static void meta_window_move_resize_internal (MetaWindow *window, + MetaDevInfo *dev, MetaMoveResizeFlags flags, int resize_gravity, int root_x_nw, @@ -92,11 +94,13 @@ static void ensure_mru_position_after (MetaWindow *window, MetaWindow *after_this_one); -static void meta_window_move_resize_now (MetaWindow *window); +static void meta_window_move_resize_now (MetaWindow *window, + MetaDevInfo *dev); static void meta_window_unqueue (MetaWindow *window, guint queuebits); static void update_move (MetaWindow *window, + MetaDevInfo *dev, gboolean snap, int x, int y); @@ -115,11 +119,20 @@ static gboolean queue_calc_showing_func (MetaWindow *window, void *data); static void meta_window_apply_session_info (MetaWindow *window, - const MetaWindowSessionInfo *info); + const MetaWindowSessionInfo *info, + MetaDevInfo *dev); static void unmaximize_window_before_freeing (MetaWindow *window); static void unminimize_window_and_all_transient_parents (MetaWindow *window); +static void meta_window_add_focused_device (MetaWindow *window, + MetaDevInfo *kbdDev); +static void meta_window_remove_focused_device (MetaWindow *window, + MetaDevInfo *kbdDev); +static gboolean meta_window_focused_by_dev (MetaWindow *window, + MetaDevInfo *kbdDev); + + /* Idle handlers for the three queues. The "data" parameter in each case * will be a GINT_TO_POINTER of the index into the queue arrays to use. * @@ -130,6 +143,8 @@ static gboolean idle_calc_showing (gpointer data); static gboolean idle_move_resize (gpointer data); static gboolean idle_update_icon (gpointer data); +/* XXX: declare window_activate!!! */ + #ifdef WITH_VERBOSE_MODE static const char* wm_state_to_string (int state) @@ -197,7 +212,8 @@ maybe_leave_show_desktop_mode (MetaWindow *window) MetaWindow* meta_window_new (MetaDisplay *display, Window xwindow, - gboolean must_be_viewable) + gboolean must_be_viewable, + MetaDevInfo *dev) { XWindowAttributes attrs; MetaWindow *window; @@ -221,7 +237,7 @@ meta_window_new (MetaDisplay *display, return NULL; } window = meta_window_new_with_attrs (display, xwindow, - must_be_viewable, &attrs); + must_be_viewable, &attrs, dev); meta_error_trap_pop (display, FALSE); @@ -234,7 +250,8 @@ MetaWindow* meta_window_new_with_attrs (MetaDisplay *display, Window xwindow, gboolean must_be_viewable, - XWindowAttributes *attrs) + XWindowAttributes *attrs, + MetaDevInfo *dev) { MetaWindow *window; GSList *tmp; @@ -244,7 +261,7 @@ meta_window_new_with_attrs (MetaDisplay *display, MetaMoveResizeFlags flags; #define N_INITIAL_PROPS 18 Atom initial_props[N_INITIAL_PROPS]; - int i; + int i, idev; gboolean has_shape; g_assert (attrs != NULL); @@ -585,6 +602,10 @@ meta_window_new_with_attrs (MetaDisplay *display, initial_props[i++] = XA_WM_TRANSIENT_FOR; initial_props[i++] = display->atom_net_wm_user_time_window; g_assert (N_INITIAL_PROPS == i); + + window->focused_devices = g_new (MetaDevInfo*, DEFAULT_INPUT_ARRAY_SIZE); + window->focused_devices_used = 0; + window->focused_devices_size = DEFAULT_INPUT_ARRAY_SIZE; meta_window_reload_properties (window, initial_props, N_INITIAL_PROPS); @@ -621,9 +642,18 @@ meta_window_new_with_attrs (MetaDisplay *display, if (window->decorated) meta_window_ensure_frame (window); - meta_window_grab_keys (window); - meta_display_grab_window_buttons (window->display, window->xwindow); - meta_display_grab_focus_window_button (window->display, window); + for (idev = 0; idev < display->devices->keybsUsed; idev++) + { + meta_window_grab_keys (window, &display->devices->keyboards[idev]); + } + + for (idev = 0; idev < display->devices->miceUsed; idev++) + { + meta_display_grab_window_buttons (window->display, window->xwindow, + &display->devices->mice[idev]); + meta_display_grab_focus_window_button (window->display, window, + &display->devices->mice[idev]); + } if (window->type == META_WINDOW_DESKTOP || window->type == META_WINDOW_DOCK) @@ -727,6 +757,7 @@ meta_window_new_with_attrs (MetaDisplay *display, flags = META_IS_CONFIGURE_REQUEST | META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION; meta_window_move_resize_internal (window, + dev, flags, window->size_hints.win_gravity, window->size_hints.x, @@ -742,7 +773,7 @@ meta_window_new_with_attrs (MetaDisplay *display, if (info) { - meta_window_apply_session_info (window, info); + meta_window_apply_session_info (window, info, dev); meta_window_release_saved_state (info); } } @@ -787,7 +818,8 @@ meta_window_new_with_attrs (MetaDisplay *display, /* This function should only be called from the end of meta_window_new_with_attrs () */ static void meta_window_apply_session_info (MetaWindow *window, - const MetaWindowSessionInfo *info) + const MetaWindowSessionInfo *info, + MetaDevInfo *dev) { if (info->stack_position_set) { @@ -816,7 +848,7 @@ meta_window_apply_session_info (MetaWindow *window, if (window->has_maximize_func && info->maximized) { - meta_window_maximize (window, + meta_window_maximize (window, dev, META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL); @@ -917,6 +949,7 @@ meta_window_apply_session_info (MetaWindow *window, flags = META_DO_GRAVITY_ADJUST | META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION; meta_window_move_resize_internal (window, + dev, flags, window->size_hints.win_gravity, x, y, w, h); @@ -928,6 +961,7 @@ meta_window_free (MetaWindow *window, guint32 timestamp) { GList *tmp; + int idev; meta_verbose ("Unmanaging 0x%lx\n", window->xwindow); @@ -978,19 +1012,24 @@ meta_window_free (MetaWindow *window, meta_topic (META_DEBUG_FOCUS, "Focusing default window since we're unmanaging %s\n", window->desc); - meta_workspace_focus_default_window (window->screen->active_workspace, - window, - timestamp); + for (idev = 0; idev < window->focused_devices_used; idev++) + meta_workspace_focus_default_window (window->screen->active_workspace, + window->focused_devices[idev], + window, + timestamp); } else if (window->display->expected_focus_window == window) { + /* XXX Read display.h:206 */ meta_topic (META_DEBUG_FOCUS, "Focusing default window since expected focus window freed %s\n", window->desc); window->display->expected_focus_window = NULL; - meta_workspace_focus_default_window (window->screen->active_workspace, - window, - timestamp); + for (idev = 0; idev < window->display->devices->keybsUsed; idev++) + meta_workspace_focus_default_window (window->screen->active_workspace, + &window->display->devices->keyboards[idev], + window, + timestamp); } else { @@ -1011,7 +1050,7 @@ meta_window_free (MetaWindow *window, } if (window->display->grab_window == window) - meta_display_end_grab_op (window->display, timestamp); + meta_display_end_grab_op (window->display, NULL, timestamp); g_assert (window->display->grab_window != window); @@ -1092,10 +1131,15 @@ meta_window_free (MetaWindow *window, meta_error_trap_pop (window->display, FALSE); } - meta_window_ungrab_keys (window); - meta_display_ungrab_window_buttons (window->display, window->xwindow); - meta_display_ungrab_focus_window_button (window->display, window); - + for (idev = 0; idev < window->display->devices->keybsUsed; idev++) + { + meta_window_ungrab_keys (window, + &window->display->devices->keyboards[idev]); + meta_display_ungrab_window_buttons (window->display, window->xwindow, + &window->display->devices->keyboards[idev]); + meta_display_ungrab_focus_window_button (window->display, window, + &window->display->devices->keyboards[idev]); + } meta_display_unregister_x_window (window->display, window->xwindow); @@ -1372,6 +1416,8 @@ static void finish_minimize (const MetaEffect *effect, gpointer data) { + int idev; + MetaWindow *window = data; /* FIXME: It really sucks to put timestamp pinging here; it'd * probably make more sense in implement_showing() so that it's at @@ -1384,9 +1430,11 @@ finish_minimize (const MetaEffect *effect, meta_window_hide (window); if (window->has_focus) { - meta_workspace_focus_default_window (window->screen->active_workspace, - window, - timestamp); + for (idev = 0; idev < window->focused_devices_used; idev++) + meta_workspace_focus_default_window (window->screen->active_workspace, + window->focused_devices[idev], + window, + timestamp); } } @@ -2006,8 +2054,10 @@ meta_window_show (MetaWindow *window) "window %s which isn't being focused. Unfocusing the " "ancestor.\n", focus_window->desc, window->desc); - + /* XXX we should make the keyboard that triggered the event (or paired + * with the pointer that triggered the event) recive the focus!!! */ meta_display_focus_the_no_focus_window (window->display, + /* XXX */ &window->display->devices->mice[0], window->screen, timestamp); } @@ -2030,7 +2080,8 @@ meta_window_show (MetaWindow *window) * show the window. */ window->calc_placement = TRUE; - meta_window_move_resize_now (window); + meta_window_move_resize_now (window, + /* XXX */ &window->display->devices->keyboards[0]); window->calc_placement = FALSE; /* don't ever do the initial position constraint thing again. @@ -2179,7 +2230,9 @@ meta_window_show (MetaWindow *window) window->showing_for_first_time = FALSE; if (takes_focus_on_map) { - meta_window_focus (window, timestamp); + /* XXX we should make the keyboard that triggered the event (or paired + * with the pointer that triggered the event) recive the focus!!! */ + meta_window_focus (window, &window->display->devices->mice[0], timestamp); /* XXX XXX XXX XXX */ } else { @@ -2403,6 +2456,7 @@ meta_window_maximize_internal (MetaWindow *window, void meta_window_maximize (MetaWindow *window, + MetaDevInfo *dev, MetaMaximizeFlags directions) { /* At least one of the two directions ought to be set */ @@ -2424,7 +2478,7 @@ meta_window_maximize (MetaWindow *window, */ guint32 timestamp = meta_display_get_current_time_roundtrip (window->display); - meta_window_unshade (window, timestamp); + meta_window_unshade (window, dev, timestamp); } /* if the window hasn't been placed yet, we'll maximize it then @@ -2474,6 +2528,7 @@ unmaximize_window_before_freeing (MetaWindow *window) * therefore move_resize the window to saved_rect here * before closing it. */ meta_window_move_resize (window, + /* XXX */ &window->display->devices->keyboards[0], FALSE, window->saved_rect.x, window->saved_rect.y, @@ -2484,6 +2539,7 @@ unmaximize_window_before_freeing (MetaWindow *window) void meta_window_unmaximize (MetaWindow *window, + MetaDevInfo *dev, MetaMaximizeFlags directions) { /* At least one of the two directions ought to be set */ @@ -2544,6 +2600,7 @@ meta_window_unmaximize (MetaWindow *window, } meta_window_move_resize (window, + dev, FALSE, target_rect.x, target_rect.y, @@ -2579,7 +2636,7 @@ meta_window_unmake_above (MetaWindow *window) } void -meta_window_make_fullscreen_internal (MetaWindow *window) +meta_window_make_fullscreen_internal (MetaWindow *window, MetaDevInfo *dev) { if (!window->fullscreen) { @@ -2593,7 +2650,7 @@ meta_window_make_fullscreen_internal (MetaWindow *window) */ guint32 timestamp = meta_display_get_current_time_roundtrip (window->display); - meta_window_unshade (window, timestamp); + meta_window_unshade (window, dev, timestamp); } meta_window_save_rect (window); @@ -2612,11 +2669,12 @@ meta_window_make_fullscreen_internal (MetaWindow *window) } void -meta_window_make_fullscreen (MetaWindow *window) +meta_window_make_fullscreen (MetaWindow *window, + MetaDevInfo *dev) { if (!window->fullscreen) { - meta_window_make_fullscreen_internal (window); + meta_window_make_fullscreen_internal (window, dev); /* move_resize with new constraints */ meta_window_queue(window, META_QUEUE_MOVE_RESIZE); @@ -2624,7 +2682,8 @@ meta_window_make_fullscreen (MetaWindow *window) } void -meta_window_unmake_fullscreen (MetaWindow *window) +meta_window_unmake_fullscreen (MetaWindow *window, + MetaDevInfo *dev) { if (window->fullscreen) { @@ -2642,6 +2701,7 @@ meta_window_unmake_fullscreen (MetaWindow *window) ensure_size_hints_satisfied (&target_rect, &window->size_hints); meta_window_move_resize (window, + dev, FALSE, target_rect.x, target_rect.y, @@ -2657,6 +2717,7 @@ meta_window_unmake_fullscreen (MetaWindow *window) void meta_window_shade (MetaWindow *window, + MetaDevInfo *dev, guint32 timestamp) { meta_topic (META_DEBUG_WINDOW_OPS, @@ -2697,7 +2758,7 @@ meta_window_shade (MetaWindow *window, meta_topic (META_DEBUG_FOCUS, "Re-focusing window %s after shading it\n", window->desc); - meta_window_focus (window, timestamp); + meta_window_focus (window, dev, timestamp); set_net_wm_state (window); } @@ -2705,6 +2766,7 @@ meta_window_shade (MetaWindow *window, void meta_window_unshade (MetaWindow *window, + MetaDevInfo *dev, guint32 timestamp) { meta_topic (META_DEBUG_WINDOW_OPS, @@ -2718,7 +2780,7 @@ meta_window_unshade (MetaWindow *window, meta_topic (META_DEBUG_FOCUS, "Focusing window %s after unshading it\n", window->desc); - meta_window_focus (window, timestamp); + meta_window_focus (window, dev, timestamp); set_net_wm_state (window); } @@ -2743,7 +2805,8 @@ static void window_activate (MetaWindow *window, guint32 timestamp, MetaClientType source_indication, - MetaWorkspace *workspace) + MetaWorkspace *workspace, + MetaDevInfo *dev) { gboolean can_ignore_outdated_timestamps; meta_topic (META_DEBUG_FOCUS, @@ -2791,7 +2854,7 @@ window_activate (MetaWindow *window, meta_window_change_workspace (window, workspace); if (window->shaded) - meta_window_unshade (window, timestamp); + meta_window_unshade (window, dev, timestamp); unminimize_window_and_all_transient_parents (window); @@ -2802,7 +2865,7 @@ window_activate (MetaWindow *window, meta_topic (META_DEBUG_FOCUS, "Focusing window %s due to activation\n", window->desc); - meta_window_focus (window, timestamp); + meta_window_focus (window, dev, timestamp); } /* This function exists since most of the functionality in window_activate @@ -2811,17 +2874,19 @@ window_activate (MetaWindow *window, */ void meta_window_activate (MetaWindow *window, + MetaDevInfo *dev, guint32 timestamp) { /* We're not really a pager, but the behavior we want is the same as if * we were such. If we change the pager behavior later, we could revisit * this and just add extra flags to window_activate. */ - window_activate (window, timestamp, META_CLIENT_TYPE_PAGER, NULL); + window_activate (window, timestamp, META_CLIENT_TYPE_PAGER, NULL, dev); } void meta_window_activate_with_workspace (MetaWindow *window, + MetaDevInfo *dev, guint32 timestamp, MetaWorkspace *workspace) { @@ -2829,7 +2894,7 @@ meta_window_activate_with_workspace (MetaWindow *window, * we were such. If we change the pager behavior later, we could revisit * this and just add extra flags to window_activate. */ - window_activate (window, timestamp, META_CLIENT_TYPE_APPLICATION, workspace); + window_activate (window, timestamp, META_CLIENT_TYPE_APPLICATION, workspace, dev); } /* Manually fix all the weirdness explained in the big comment at the @@ -3010,6 +3075,7 @@ send_sync_request (MetaWindow *window) static void meta_window_move_resize_internal (MetaWindow *window, + MetaDevInfo *dev, MetaMoveResizeFlags flags, int gravity, int root_x_nw, @@ -3142,7 +3208,8 @@ meta_window_move_resize_internal (MetaWindow *window, flags, gravity, &old_rect, - &new_rect); + &new_rect, + dev); w = new_rect.width; h = new_rect.height; @@ -3468,6 +3535,7 @@ meta_window_move_resize_internal (MetaWindow *window, void meta_window_resize (MetaWindow *window, + MetaDevInfo *dev, gboolean user_op, int w, int h) @@ -3479,6 +3547,7 @@ meta_window_resize (MetaWindow *window, flags = (user_op ? META_IS_USER_ACTION : 0) | META_IS_RESIZE_ACTION; meta_window_move_resize_internal (window, + dev, flags, NorthWestGravity, x, y, w, h); @@ -3486,6 +3555,7 @@ meta_window_resize (MetaWindow *window, void meta_window_move (MetaWindow *window, + MetaDevInfo *dev, gboolean user_op, int root_x_nw, int root_y_nw) @@ -3493,6 +3563,7 @@ meta_window_move (MetaWindow *window, MetaMoveResizeFlags flags = (user_op ? META_IS_USER_ACTION : 0) | META_IS_MOVE_ACTION; meta_window_move_resize_internal (window, + dev, flags, NorthWestGravity, root_x_nw, root_y_nw, @@ -3502,6 +3573,7 @@ meta_window_move (MetaWindow *window, void meta_window_move_resize (MetaWindow *window, + MetaDevInfo *dev, gboolean user_op, int root_x_nw, int root_y_nw, @@ -3512,6 +3584,7 @@ meta_window_move_resize (MetaWindow *window, (user_op ? META_IS_USER_ACTION : 0) | META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION; meta_window_move_resize_internal (window, + dev, flags, NorthWestGravity, root_x_nw, root_y_nw, @@ -3519,7 +3592,8 @@ meta_window_move_resize (MetaWindow *window, } void -meta_window_resize_with_gravity (MetaWindow *window, +meta_window_resize_with_gravity (MetaWindow *window, + MetaDevInfo *dev, gboolean user_op, int w, int h, @@ -3532,19 +3606,21 @@ meta_window_resize_with_gravity (MetaWindow *window, flags = (user_op ? META_IS_USER_ACTION : 0) | META_IS_RESIZE_ACTION; meta_window_move_resize_internal (window, + dev, flags, gravity, x, y, w, h); } static void -meta_window_move_resize_now (MetaWindow *window) +meta_window_move_resize_now (MetaWindow *window, + MetaDevInfo *dev) { /* If constraints have changed then we want to snap back to wherever * the user had the window. We use user_rect for this reason. See * also bug 426519 comment 3. */ - meta_window_move_resize (window, FALSE, + meta_window_move_resize (window, dev, FALSE, window->user_rect.x, window->user_rect.y, window->user_rect.width, @@ -3579,7 +3655,8 @@ idle_move_resize (gpointer data) window = tmp->data; /* As a side effect, sets window->move_resize_queued = FALSE */ - meta_window_move_resize_now (window); + meta_window_move_resize_now (window, + /* XXX */ &window->display->devices->keyboards[0]); tmp = tmp->next; } @@ -3904,6 +3981,7 @@ get_modal_transient (MetaWindow *window) /* XXX META_EFFECT_FOCUS */ void meta_window_focus (MetaWindow *window, + MetaDevInfo *dev, guint32 timestamp) { MetaWindow *modal_transient; @@ -3960,6 +4038,7 @@ meta_window_focus (MetaWindow *window, meta_topic (META_DEBUG_FOCUS, "Focusing frame of %s\n", window->desc); meta_display_set_input_focus_window (window->display, + dev, window, TRUE, timestamp); @@ -3973,6 +4052,7 @@ meta_window_focus (MetaWindow *window, "Setting input focus on %s since input = true\n", window->desc); meta_display_set_input_focus_window (window->display, + dev, window, FALSE, timestamp); @@ -4319,13 +4399,14 @@ meta_window_send_icccm_message (MetaWindow *window, } void -meta_window_move_resize_request (MetaWindow *window, - guint value_mask, - int gravity, - int new_x, - int new_y, - int new_width, - int new_height) +meta_window_move_resize_request (MetaWindow *window, + MetaDevInfo *dev, + guint value_mask, + int gravity, + int new_x, + int new_y, + int new_width, + int new_height) { int x, y, width, height; gboolean allow_position_change; @@ -4462,7 +4543,8 @@ meta_window_move_resize_request (MetaWindow *window, flags |= META_IS_RESIZE_ACTION; if (flags & (META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION)) - meta_window_move_resize_internal (window, + meta_window_move_resize_internal (window, + dev, flags, gravity, x, @@ -4497,6 +4579,7 @@ meta_window_configure_request (MetaWindow *window, window->border_width = event->xconfigurerequest.border_width; meta_window_move_resize_request(window, + /* XXX */ &window->display->devices->keyboards[0], event->xconfigurerequest.value_mask, window->size_hints.win_gravity, event->xconfigurerequest.x, @@ -4698,10 +4781,17 @@ meta_window_client_message (MetaWindow *window, shade = (action == _NET_WM_STATE_ADD || (action == _NET_WM_STATE_TOGGLE && !window->shaded)); + /* Stupid protocol has no device indication; of course, + * shading sucks anyway so who really cares that we're forced + * to guess which device is it? */ if (shade && window->has_shade_func) - meta_window_shade (window, timestamp); + meta_window_shade (window, + &window->display->devices->keyboards[0], + timestamp); else - meta_window_unshade (window, timestamp); + meta_window_unshade (window, + &window->display->devices->keyboards[0], + timestamp); } if (first == display->atom_net_wm_state_fullscreen || @@ -4712,9 +4802,11 @@ meta_window_client_message (MetaWindow *window, make_fullscreen = (action == _NET_WM_STATE_ADD || (action == _NET_WM_STATE_TOGGLE && !window->fullscreen)); if (make_fullscreen && window->has_fullscreen_func) - meta_window_make_fullscreen (window); + meta_window_make_fullscreen (window, + &window->display->devices->keyboards[0]); else - meta_window_unmake_fullscreen (window); + meta_window_unmake_fullscreen (window, + &window->display->devices->keyboards[0]); } if (first == display->atom_net_wm_state_maximized_horz || @@ -4729,13 +4821,17 @@ meta_window_client_message (MetaWindow *window, { if (meta_prefs_get_raise_on_click ()) meta_window_raise (window); - meta_window_maximize (window, META_MAXIMIZE_HORIZONTAL); + meta_window_maximize (window, + &window->display->devices->keyboards[0], + META_MAXIMIZE_HORIZONTAL); } else { if (meta_prefs_get_raise_on_click ()) meta_window_raise (window); - meta_window_unmaximize (window, META_MAXIMIZE_HORIZONTAL); + meta_window_unmaximize (window, + &window->display->devices->keyboards[0], + META_MAXIMIZE_HORIZONTAL); } } @@ -4751,13 +4847,17 @@ meta_window_client_message (MetaWindow *window, { if (meta_prefs_get_raise_on_click ()) meta_window_raise (window); - meta_window_maximize (window, META_MAXIMIZE_VERTICAL); + meta_window_maximize (window, + &window->display->devices->keyboards[0], + META_MAXIMIZE_VERTICAL); } else { if (meta_prefs_get_raise_on_click ()) meta_window_raise (window); - meta_window_unmaximize (window, META_MAXIMIZE_VERTICAL); + meta_window_unmaximize (window, + &window->display->devices->keyboards[0], + META_MAXIMIZE_VERTICAL); } } @@ -4915,7 +5015,8 @@ meta_window_client_message (MetaWindow *window, ((window->has_move_func && op == META_GRAB_OP_KEYBOARD_MOVING) || (window->has_resize_func && op == META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN))) { - meta_window_begin_grab_op (window, op, frame_action, timestamp); + /* XXX XXX XXX XXX */ + meta_window_begin_grab_op (window, NULL, op, frame_action, timestamp); } else if (op != META_GRAB_OP_NONE && ((window->has_move_func && op == META_GRAB_OP_MOVING) || @@ -4931,18 +5032,31 @@ meta_window_client_message (MetaWindow *window, int x, y, query_root_x, query_root_y; Window root, child; guint mask; + Bool shared; /* The race conditions in this _NET_WM_MOVERESIZE thing * are mind-boggling */ mask = 0; meta_error_trap_push (window->display); + + XQueryDevicePointer (window->display->xdisplay, + /* XXX */ window->display->devices->mice[0].xdev, + window->xwindow, + &root, &child, + &query_root_x, &query_root_y, + &x, &y, + &mask, &shared); + +#if 0 +#warning XQueryPointer here! XQueryPointer (window->display->xdisplay, window->xwindow, &root, &child, &query_root_x, &query_root_y, &x, &y, &mask); +#endif meta_error_trap_pop (window->display, TRUE); if (mask & Button1Mask) @@ -4961,6 +5075,7 @@ meta_window_client_message (MetaWindow *window, "Beginning move/resize with button = %d\n", button); meta_display_begin_grab_op (window->display, window->screen, + /* XXX */ &window->display->devices->mice[0], window, op, FALSE, @@ -4988,6 +5103,7 @@ meta_window_client_message (MetaWindow *window, gravity = window->size_hints.win_gravity; meta_window_move_resize_request(window, + &window->display->devices->keyboards[0], value_mask, gravity, event->xclient.data.l[1], // x @@ -5019,7 +5135,8 @@ meta_window_client_message (MetaWindow *window, timestamp = meta_display_get_current_time (display); } - window_activate (window, timestamp, source_indication, NULL); + window_activate (window, timestamp, source_indication, NULL, + &window->display->devices->keyboards[0]); /* XXX */ return TRUE; } @@ -5030,6 +5147,8 @@ gboolean meta_window_notify_focus (MetaWindow *window, XEvent *event) { + + meta_warning("METAWINDOWNOTIFYFOCUSMETAWINDOWNOTIFYFOCUSMETAWINDOWNOTIFY\n"); /* note the event can be on either the window or the frame, * we focus the frame for shaded windows */ @@ -5044,27 +5163,39 @@ meta_window_notify_focus (MetaWindow *window, * the focus window tracking. * * The problem is that keybindings for windows are done with - * XGrabKey, which means focus_window disappears and the front of + * XGrabDeviceKey, which means focus_window disappears and the front of * the MRU list gets confused from what the user expects once a * keybinding is used. - */ + */ +/* XXX This function can receive UnmapNotify, DeviceFocusIn or DeviceFocusOut! + * Remove all its "xany" !!! */ + XDeviceFocusChangeEvent *xdfce; + MetaDevInfo *dev; + + if (event->type != UnmapNotify) + { + xdfce = (XDeviceFocusChangeEvent *)event; + dev = meta_devices_find_keyboard_by_id(window->display, xdfce->deviceid); + } +#ifndef MPX /* uber XXX */ meta_topic (META_DEBUG_FOCUS, "Focus %s event received on %s 0x%lx (%s) " "mode %s detail %s\n", - event->type == FocusIn ? "in" : - event->type == FocusOut ? "out" : + event->type == window->display->dev_focus_in_type ? "in" : + event->type == window->display->dev_focus_out_type ? "out" : event->type == UnmapNotify ? "unmap" : "???", - window->desc, event->xany.window, - event->xany.window == window->xwindow ? + window->desc, xdfce->window, + xdfce->window == window->xwindow ? "client window" : - (window->frame && event->xany.window == window->frame->xwindow) ? + (window->frame && xdfce->window == window->frame->xwindow) ? "frame window" : "unknown window", event->type != UnmapNotify ? - meta_event_mode_to_string (event->xfocus.mode) : "n/a", + meta_event_mode_to_string (xdfce->mode) : "n/a", event->type != UnmapNotify ? - meta_event_detail_to_string (event->xfocus.detail) : "n/a"); + meta_event_detail_to_string (xdfce->detail) : "n/a"); +#endif /* FIXME our pointer tracking is broken; see how * gtk+/gdk/x11/gdkevents-x11.c or XFree86/xc/programs/xterm/misc.c @@ -5084,27 +5215,28 @@ meta_window_notify_focus (MetaWindow *window, * * http://bugzilla.gnome.org/show_bug.cgi?id=90382 */ - - if ((event->type == FocusIn || - event->type == FocusOut) && - (event->xfocus.mode == NotifyGrab || - event->xfocus.mode == NotifyUngrab || + if ((event->type == window->display->dev_focus_in_type || + event->type == window->display->dev_focus_out_type) && + (xdfce->mode == NotifyGrab || + xdfce->mode == NotifyUngrab || /* From WindowMaker, ignore all funky pointer root events */ - event->xfocus.detail > NotifyNonlinearVirtual)) + xdfce->detail > NotifyNonlinearVirtual)) { meta_topic (META_DEBUG_FOCUS, "Ignoring focus event generated by a grab or other weirdness\n"); return TRUE; } - - if (event->type == FocusIn) + + if (event->type == window->display->dev_focus_in_type) { - if (window != window->display->focus_window) +// if (window != window->display->focus_window) + if (! meta_window_focused_by_dev(window, dev)) { meta_topic (META_DEBUG_FOCUS, "* Focus --> %s\n", window->desc); - window->display->focus_window = window; - window->has_focus = TRUE; + window->display->focus_window = window; /* XXX devices.h:195 */ +// window->has_focus = TRUE; + meta_window_add_focused_device (window, dev); /* Move to the front of the focusing workspace's MRU list. * We should only be "removing" it from the MRU list if it's @@ -5149,14 +5281,17 @@ meta_window_notify_focus (MetaWindow *window, * causing the client to get funky enter/leave events. */ if (meta_prefs_get_focus_mode () == META_FOCUS_MODE_CLICK) - meta_display_ungrab_focus_window_button (window->display, window); + meta_display_ungrab_focus_window_button (window->display, + window, + meta_devices_find_paired_mouse(window->display, + dev->xdev->device_id)); } } - else if (event->type == FocusOut || + else if (event->type == window->display->dev_focus_out_type || event->type == UnmapNotify) { - if (event->type == FocusOut && - event->xfocus.detail == NotifyInferior) + if (event->type == window->display->dev_focus_out_type && + xdfce->detail == NotifyInferior) { /* This event means the client moved focus to a subwindow */ meta_topic (META_DEBUG_FOCUS, @@ -5165,7 +5300,8 @@ meta_window_notify_focus (MetaWindow *window, return TRUE; } - if (window == window->display->focus_window) +// if (window == window->display->focus_window) /* XXX */ + if (meta_window_focused_by_dev(window, dev)) { meta_topic (META_DEBUG_FOCUS, "%s is now the previous focus window due to being focused out or unmapped\n", @@ -5174,8 +5310,9 @@ meta_window_notify_focus (MetaWindow *window, meta_topic (META_DEBUG_FOCUS, "* Focus --> NULL (was %s)\n", window->desc); - window->display->focus_window = NULL; - window->has_focus = FALSE; + window->display->focus_window = NULL; /* XXX */ +// window->has_focus = FALSE; + meta_window_remove_focused_device (window, dev); if (window->frame) meta_frame_queue_draw (window->frame); @@ -5189,7 +5326,10 @@ meta_window_notify_focus (MetaWindow *window, /* Re-grab for click to focus, if necessary */ if (meta_prefs_get_focus_mode () == META_FOCUS_MODE_CLICK) - meta_display_grab_focus_window_button (window->display, window); + meta_display_grab_focus_window_button (window->display, + window, + meta_devices_find_paired_mouse(window->display, + dev->xdev->device_id)); } } @@ -5984,7 +6124,10 @@ recalc_window_type (MetaWindow *window) /* update stacking constraints */ meta_window_update_layer (window); - meta_window_grab_keys (window); + int idev; + for (idev = 0; idev < window->display->devices->keybsUsed; idev++) + meta_window_grab_keys (window, + &window->display->devices->keyboards[idev]); } } @@ -6337,7 +6480,7 @@ menu_callback (MetaWindowMenu *menu, guint32 timestamp, MetaMenuOp op, int workspace_index, - MetaDevInfo *device, + MetaDevInfo *device, /* change to 'dev' ? */ gpointer data) #else @@ -6376,22 +6519,24 @@ menu_callback (MetaWindowMenu *menu, case META_MENU_OP_UNMAXIMIZE: meta_window_unmaximize (window, + device, META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL); break; case META_MENU_OP_MAXIMIZE: meta_window_maximize (window, + device, META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL); break; case META_MENU_OP_UNSHADE: - meta_window_unshade (window, timestamp); + meta_window_unshade (window, device, timestamp); break; case META_MENU_OP_SHADE: - meta_window_shade (window, timestamp); + meta_window_shade (window, device, timestamp); break; case META_MENU_OP_MOVE_LEFT: @@ -6437,6 +6582,7 @@ menu_callback (MetaWindowMenu *menu, case META_MENU_OP_MOVE: meta_window_begin_grab_op (window, + device, META_GRAB_OP_KEYBOARD_MOVING, TRUE, timestamp); @@ -6444,13 +6590,14 @@ menu_callback (MetaWindowMenu *menu, case META_MENU_OP_RESIZE: meta_window_begin_grab_op (window, + device, META_GRAB_OP_KEYBOARD_RESIZING_UNKNOWN, TRUE, timestamp); break; case META_MENU_OP_RECOVER: - meta_window_shove_titlebar_onscreen (window); + meta_window_shove_titlebar_onscreen (window, device); break; #ifdef MPX @@ -6613,7 +6760,7 @@ meta_window_show_menu (MetaWindow *window, window->xwindow, ops, insensitive, - &window->display->devices, + window->display->devices, meta_window_get_net_wm_desktop (window), meta_screen_get_n_workspaces (window->screen), menu_callback, @@ -6639,7 +6786,8 @@ meta_window_show_menu (MetaWindow *window, } void -meta_window_shove_titlebar_onscreen (MetaWindow *window) +meta_window_shove_titlebar_onscreen (MetaWindow *window, + MetaDevInfo *dev) { MetaRectangle outer_rect; GList *onscreen_region; @@ -6677,6 +6825,7 @@ meta_window_shove_titlebar_onscreen (MetaWindow *window) newx = outer_rect.x + window->frame->child_x; newy = outer_rect.y + window->frame->child_y; meta_window_move_resize (window, + dev, FALSE, newx, newy, @@ -6826,6 +6975,7 @@ 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); @@ -6835,6 +6985,7 @@ update_move_timeout (gpointer data) static void update_move (MetaWindow *window, + MetaDevInfo *dev, gboolean snap, int x, int y) @@ -6903,7 +7054,7 @@ update_move (MetaWindow *window, display->grab_anchor_root_x = x; display->grab_anchor_root_y = y; - meta_window_unmaximize (window, + meta_window_unmaximize (window, dev, META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL); @@ -6947,7 +7098,7 @@ update_move (MetaWindow *window, window->user_rect.x = window->saved_rect.x; window->user_rect.y = window->saved_rect.y; - meta_window_unmaximize (window, + meta_window_unmaximize (window, dev, META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL); } @@ -6957,7 +7108,7 @@ update_move (MetaWindow *window, display->grab_anchor_root_y = y; window->shaken_loose = FALSE; - meta_window_maximize (window, + meta_window_maximize (window, dev, META_MAXIMIZE_HORIZONTAL | META_MAXIMIZE_VERTICAL); @@ -7001,7 +7152,7 @@ update_move (MetaWindow *window, display->grab_wireframe_rect.width, display->grab_wireframe_rect.height); else - meta_window_move (window, TRUE, new_x, new_y); + meta_window_move (window, dev, TRUE, new_x, new_y); } static gboolean @@ -7235,7 +7386,9 @@ update_resize (MetaWindow *window, * are actually different from what we had before. */ if (old.width != new_w || old.height != new_h) - meta_window_resize_with_gravity (window, TRUE, new_w, new_h, gravity); + meta_window_resize_with_gravity (window, + /* XXX Really not this */ &window->display->devices->keyboards[0], + TRUE, new_w, new_h, gravity); } /* Store the latest resize time, if we actually resized. */ @@ -7273,18 +7426,32 @@ check_use_this_motion_notify (MetaWindow *window, { EventScannerData esd; XEvent useless; +#ifdef MPX + XDeviceMotionEvent *xdme; + + xdme = (XDeviceMotionEvent *) event; +#endif /* This code is copied from Owen's GDK code. */ if (window->display->grab_motion_notify_time != 0) { /* == is really the right test, but I'm all for paranoia */ +#ifdef MPX + if (window->display->grab_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", - (unsigned int)event->xmotion.time, +#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; return TRUE; @@ -7372,7 +7539,100 @@ meta_window_handle_mouse_grab_op_event (MetaWindow *window, } } #endif /* HAVE_XSYNC */ - + +#ifdef MPX + 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, + xdbe->x_root, + xdbe->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 (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)) + { + if (xdbe->root == window->screen->xroot) + update_resize (window, + xdbe->state & ShiftMask, + xdbe->x_root, + xdbe->y_root, + TRUE); + if (window->display->compositor) + meta_compositor_set_updates (window->display->compositor, window, TRUE); + } + } + + meta_display_end_grab_op (window->display, dev, xdbe->time); + } + else if (event->type == window->display->dev_motion_notify_type) + { + MetaDevInfo *dev, *pairedKeyb; + XDeviceMotionEvent *xdme; /* XXX declare this somewhere else? */ + xdme = (XDeviceMotionEvent *) event; + + dev = meta_devices_find_mouse_by_id (window->display, xdme->deviceid); + pairedKeyb = meta_devices_find_paired_keyboard (window->display, + xdme->deviceid); + +// 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, + xdme->x_root, + xdme->y_root); + if (meta_grab_op_is_moving (window->display->grab_op)) + { + if (xdme->root == window->screen->xroot) + { + if (check_use_this_motion_notify (window, + event)) + update_move (window, + pairedKeyb, + xdme->state & ShiftMask, + xdme->x_root, + xdme->y_root); + } + } + else if (meta_grab_op_is_resizing (window->display->grab_op)) + { + if (xdme->root == window->screen->xroot) + { + if (check_use_this_motion_notify (window, + event)) + update_resize (window, + xdme->state & ShiftMask, + xdme->x_root, + xdme->y_root, + FALSE); + } + } + } + +#else switch (event->type) { case ButtonRelease: @@ -7407,7 +7667,6 @@ meta_window_handle_mouse_grab_op_event (MetaWindow *window, meta_display_end_grab_op (window->display, event->xbutton.time); break; - case MotionNotify: meta_display_check_threshold_reached (window->display, event->xmotion.x_root, @@ -7442,6 +7701,7 @@ meta_window_handle_mouse_grab_op_event (MetaWindow *window, default: break; } +#endif } void @@ -7750,6 +8010,7 @@ warp_grab_pointer (MetaWindow *window, int *x, int *y) { +/* XXX XXX XXX XXX XXX XXX */ MetaRectangle rect; MetaDisplay *display; @@ -7863,10 +8124,11 @@ warp_grab_pointer (MetaWindow *window, } void -meta_window_begin_grab_op (MetaWindow *window, - MetaGrabOp op, - gboolean frame_action, - guint32 timestamp) +meta_window_begin_grab_op (MetaWindow *window, + MetaDevInfo *dev, + MetaGrabOp op, + gboolean frame_action, + guint32 timestamp) { int x, y; @@ -7875,6 +8137,7 @@ meta_window_begin_grab_op (MetaWindow *window, meta_display_begin_grab_op (window->display, window->screen, + dev, window, op, FALSE, @@ -7897,10 +8160,12 @@ meta_window_update_keyboard_resize (MetaWindow *window, if (update_cursor) { + meta_warning("meta_window_update_keyboard_resize()\n"); guint32 timestamp; /* FIXME: Using CurrentTime is really bad mojo */ timestamp = CurrentTime; meta_display_set_grab_op_cursor (window->display, + NULL, NULL, window->display->grab_op, TRUE, @@ -8104,3 +8369,117 @@ meta_window_unset_demands_attention (MetaWindow *window) window->wm_state_demands_attention = FALSE; set_net_wm_state (window); } + +/* XXX declare these prototypes somewhere! */ + +void +meta_window_add_focused_device (MetaWindow *window, MetaDevInfo *kbdDev) +{ + + meta_warning("Trying to add device named %s to window...\n", kbdDev->name); + int i; + + if (window->focused_devices_used == window->focused_devices_size) + { + window->focused_devices = g_renew(MetaDevInfo*, + window->focused_devices, + window->focused_devices_size + + DEFAULT_INPUT_ARRAY_SIZE); + window->focused_devices_size += DEFAULT_INPUT_ARRAY_SIZE; + } + + /* REMOVE THIS AFTER TESTING */ + { + if (window->has_focus && (window->focused_devices_used == 0)) + meta_warning("window->has_focus && (window->focused_devices_used == 0"); + 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); + + + } + /* XXX I could compare: window->focused_devices[i] with kbdDev, it access + * less memmory, but I don't like the idea of comparing pointers */ + for (i = 0; i < window->focused_devices_used; i++) + if (window->focused_devices[i]->xdev->device_id == kbdDev->xdev->device_id) + { + meta_warning("This device already focuses the window!\n"); + return; + } + + window->has_focus = TRUE; + + 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("DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD\n"); +} + +void +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); + + /* REMOVE THIS AFTER TESTING */ + { + if (window->has_focus && (window->focused_devices_used == 0)) + meta_warning("window->has_focus && (window->focused_devices_used == 0"); + 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); + } + + if (window->focused_devices_used == 0 || (!window->has_focus)) + { + meta_warning("unfocusing a non-focused window!\n"); + return; + } + + /* XXX find a better algorithm than O(N) */ + for (i = 0; i < window->focused_devices_used; i++) + { + if (window->focused_devices[i]->xdev->device_id ==kbdDev->xdev->device_id) + { + for (j = i; j < (window->focused_devices_used - 1); j++) + window->focused_devices[j] = window->focused_devices[j+1]; + break; + } + } + + if (i == window->focused_devices_used) + { + meta_warning("trying to unfocus the window with a device that already" + " doesn't focus it!\n"); + return; + } + + window->focused_devices_used--; + + 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("BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n"); +} + +gboolean +meta_window_focused_by_dev (MetaWindow *window, MetaDevInfo *kbdDev) +{ + int i; + + for (i = 0; i < window->focused_devices_used; i++) + if (window->focused_devices[i]->xdev->device_id == kbdDev->xdev->device_id) + return TRUE; + + return FALSE; + +} diff --git a/src/window.h b/src/window.h index 2d2386e0..45afaa9c 100644 --- a/src/window.h +++ b/src/window.h @@ -354,6 +354,10 @@ struct _MetaWindow /* maintained by group.c */ MetaGroup *group; + + MetaDevInfo **focused_devices; /* Should it be XID? */ + int focused_devices_used; + int focused_devices_size; }; /* These differ from window->has_foo_func in that they consider @@ -372,11 +376,13 @@ struct _MetaWindow MetaWindow* meta_window_new (MetaDisplay *display, Window xwindow, - gboolean must_be_viewable); + gboolean must_be_viewable, + MetaDevInfo *dev); MetaWindow* meta_window_new_with_attrs (MetaDisplay *display, Window xwindow, gboolean must_be_viewable, - XWindowAttributes *attrs); + XWindowAttributes *attrs, + MetaDevInfo *dev); void meta_window_free (MetaWindow *window, guint32 timestamp); void meta_window_calc_showing (MetaWindow *window); @@ -385,17 +391,21 @@ void meta_window_queue (MetaWindow *window, void meta_window_minimize (MetaWindow *window); void meta_window_unminimize (MetaWindow *window); void meta_window_maximize (MetaWindow *window, + MetaDevInfo *dev, MetaMaximizeFlags directions); void meta_window_maximize_internal (MetaWindow *window, MetaMaximizeFlags directions, MetaRectangle *saved_rect); void meta_window_unmaximize (MetaWindow *window, + MetaDevInfo *dev, MetaMaximizeFlags directions); void meta_window_make_above (MetaWindow *window); void meta_window_unmake_above (MetaWindow *window); void meta_window_shade (MetaWindow *window, + MetaDevInfo *dev, guint32 timestamp); void meta_window_unshade (MetaWindow *window, + MetaDevInfo *dev, guint32 timestamp); void meta_window_change_workspace (MetaWindow *window, MetaWorkspace *workspace); @@ -403,30 +413,39 @@ void meta_window_stick (MetaWindow *window); void meta_window_unstick (MetaWindow *window); void meta_window_activate (MetaWindow *window, + MetaDevInfo *dev, guint32 current_time); void meta_window_activate_with_workspace (MetaWindow *window, + MetaDevInfo *dev, guint32 current_time, MetaWorkspace *workspace); -void meta_window_make_fullscreen_internal (MetaWindow *window); -void meta_window_make_fullscreen (MetaWindow *window); -void meta_window_unmake_fullscreen (MetaWindow *window); +void meta_window_make_fullscreen_internal (MetaWindow *window, + MetaDevInfo *dev); +void meta_window_make_fullscreen (MetaWindow *window, + MetaDevInfo *dev); +void meta_window_unmake_fullscreen (MetaWindow *window, + MetaDevInfo *dev); /* args to move are window pos, not frame pos */ void meta_window_move (MetaWindow *window, + MetaDevInfo *dev, gboolean user_op, int root_x_nw, int root_y_nw); void meta_window_resize (MetaWindow *window, + MetaDevInfo *dev, gboolean user_op, int w, int h); void meta_window_move_resize (MetaWindow *window, + MetaDevInfo *dev, gboolean user_op, int root_x_nw, int root_y_nw, int w, int h); void meta_window_resize_with_gravity (MetaWindow *window, + MetaDevInfo *dev, gboolean user_op, int w, int h, @@ -489,6 +508,7 @@ void meta_window_delete (MetaWindow *window, guint32 timestamp); void meta_window_kill (MetaWindow *window); void meta_window_focus (MetaWindow *window, + MetaDevInfo *dev, guint32 timestamp); void meta_window_raise (MetaWindow *window); void meta_window_lower (MetaWindow *window); @@ -501,13 +521,14 @@ void meta_window_send_icccm_message (MetaWindow *window, guint32 timestamp); -void meta_window_move_resize_request(MetaWindow *window, - guint value_mask, - int gravity, - int x, - int y, - int width, - int height); +void meta_window_move_resize_request (MetaWindow *window, + MetaDevInfo *dev, + guint value_mask, + int gravity, + int x, + int y, + int width, + int height); gboolean meta_window_configure_request (MetaWindow *window, XEvent *event); gboolean meta_window_property_notify (MetaWindow *window, @@ -528,7 +549,8 @@ void meta_window_show_menu (MetaWindow *window, guint32 timestamp); gboolean meta_window_titlebar_is_onscreen (MetaWindow *window); -void meta_window_shove_titlebar_onscreen (MetaWindow *window); +void meta_window_shove_titlebar_onscreen (MetaWindow *window, + MetaDevInfo *dev); void meta_window_set_gravity (MetaWindow *window, int gravity); @@ -577,10 +599,11 @@ void meta_window_foreach_ancestor (MetaWindow *window, MetaWindow* meta_window_find_root_ancestor (MetaWindow *window); -void meta_window_begin_grab_op (MetaWindow *window, - MetaGrabOp op, - gboolean frame_action, - guint32 timestamp); +void meta_window_begin_grab_op (MetaWindow *window, + MetaDevInfo *dev, + MetaGrabOp op, + gboolean frame_action, + guint32 timestamp); void meta_window_update_keyboard_resize (MetaWindow *window, gboolean update_cursor); diff --git a/src/workspace.c b/src/workspace.c index 41bb8048..0708c145 100644 --- a/src/workspace.c +++ b/src/workspace.c @@ -333,7 +333,9 @@ meta_workspace_activate_with_focus (MetaWorkspace *workspace, if (focus_this) { - meta_window_focus (focus_this, timestamp); + meta_window_focus (focus_this, + &focus_this->display->devices->keyboards[0], /* XXX */ + timestamp); meta_window_raise (focus_this); } else if (move_window) @@ -343,7 +345,9 @@ meta_workspace_activate_with_focus (MetaWorkspace *workspace, else { meta_topic (META_DEBUG_FOCUS, "Focusing default window on new workspace\n"); - meta_workspace_focus_default_window (workspace, NULL, timestamp); + meta_workspace_focus_default_window (workspace, + /* XXX */ &focus_this->display->devices->keyboards[0], + NULL, timestamp); } } @@ -780,6 +784,7 @@ meta_workspace_get_name (MetaWorkspace *workspace) void meta_workspace_focus_default_window (MetaWorkspace *workspace, + MetaDevInfo *dev, MetaWindow *not_this_one, guint32 timestamp) { @@ -796,7 +801,8 @@ meta_workspace_focus_default_window (MetaWorkspace *workspace, else { MetaWindow * window; - window = meta_screen_get_mouse_window (workspace->screen, not_this_one); + window = meta_screen_get_mouse_window (dev, workspace->screen, + not_this_one); if (window && window->type != META_WINDOW_DOCK && window->type != META_WINDOW_DESKTOP) @@ -818,7 +824,9 @@ meta_workspace_focus_default_window (MetaWorkspace *workspace, { meta_topic (META_DEBUG_FOCUS, "Focusing mouse window %s\n", window->desc); - meta_window_focus (window, timestamp); + meta_window_focus (window, + &window->display->devices->keyboards[0], + timestamp); } if (workspace->screen->display->autoraise_window != window && @@ -836,6 +844,7 @@ meta_workspace_focus_default_window (MetaWorkspace *workspace, "Setting focus to no_focus_window, since no valid " "window to focus found.\n"); meta_display_focus_the_no_focus_window (workspace->screen->display, + /* XXX */ &workspace->screen->display->devices->keyboards[0], workspace->screen, timestamp); } @@ -883,7 +892,9 @@ focus_ancestor_or_mru_window (MetaWorkspace *workspace, "Focusing %s, ancestor of %s\n", ancestor->desc, not_this_one->desc); - meta_window_focus (ancestor, timestamp); + meta_window_focus (ancestor, + /* XXX */ &ancestor->display->devices->keyboards[0], + timestamp); /* Also raise the window if in click-to-focus */ if (meta_prefs_get_focus_mode () == META_FOCUS_MODE_CLICK) @@ -929,7 +940,9 @@ focus_ancestor_or_mru_window (MetaWorkspace *workspace, meta_topic (META_DEBUG_FOCUS, "Focusing workspace MRU window %s\n", window->desc); - meta_window_focus (window, timestamp); + meta_window_focus (window, + /* XXX */ &window->display->devices->keyboards[0], + timestamp); /* Also raise the window if in click-to-focus */ if (meta_prefs_get_focus_mode () == META_FOCUS_MODE_CLICK) @@ -939,6 +952,7 @@ focus_ancestor_or_mru_window (MetaWorkspace *workspace, { meta_topic (META_DEBUG_FOCUS, "No MRU window to focus found; focusing no_focus_window.\n"); meta_display_focus_the_no_focus_window (workspace->screen->display, + /* XXX */ &workspace->screen->display->devices->keyboards[0], workspace->screen, timestamp); } diff --git a/src/workspace.h b/src/workspace.h index 61aa8e71..14814f6c 100644 --- a/src/workspace.h +++ b/src/workspace.h @@ -90,6 +90,7 @@ void meta_workspace_get_work_area_all_xineramas (MetaWorkspace *workspace, MetaRectangle *area); void meta_workspace_focus_default_window (MetaWorkspace *workspace, + MetaDevInfo *dev, MetaWindow *not_this_one, guint32 timestamp); |