Changed all the input handling code:

- Make use of MPX's XInput instead of core input protocol.
- Enables multiple focus.
- Enables meta_operations for any devices.

Now you MUST use "--enable-mpx" or metacity will refuse to compile. This will be
corrected soon.

Now you MUST ust my gtk+ patch to compile it. See
http://live.gnome.org/Metacity/MpxHowto.

The code is not good yet. There are a lot of broken layers and bad variable
names. They will be fixed.

Known bugs:
- Focus only works if you click window frames.
- Keyboard shorcuts not working yet.

I know I should have commited this earlier, but it would ONLY work with all
these changes together.


svn path=/branches/multiple_pointer_x/; revision=3302

28 files changed, 3062 insertions, 1221 deletions

diff --git a/README b/README
index 2b82e5cd..f1509b0f 100644
--- a/README
+++ b/README
@@ -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 */
diff --git a/src/core.c b/src/core.c
index 4efe6798..06098584 100644
--- a/src/core.c
+++ b/src/core.c
@@ -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
diff --git a/src/core.h b/src/core.h
index c374429f..4e0b54c8 100644
--- a/src/core.h
+++ b/src/core.h
@@ -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, &timestamp))
     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, &timestamp))
     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,
diff --git a/src/ui.c b/src/ui.c
index b65a4b95..aa1a7ad3 100644
--- a/src/ui.c
+++ b/src/ui.c
@@ -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);
 }
 
diff --git a/src/ui.h b/src/ui.h
index b84ccb98..9621dda7 100644
--- a/src/ui.h
+++ b/src/ui.h
@@ -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);