Merge lp:~samuel-thibault/compiz/shortcuts into lp:compiz/0.9.13

[Samuel thibault]

This is a rework of the previous work of Colomban Wendling (https://code.launchpad.net/~banw/compiz/compiz.a11y-shotcuts). This version uses normal XI2 events, which poses much less problems and still allows to ignore grabs. In the end I changed the approach into converting XI2 events right from the xevent loop before handing them to the rest of compiz.

This depends on my branch https://code.launchpad.net/~samuel-thibault/compiz/motion-dup-fix

[lp:~samuel-thibault/compiz/shortcuts]

4137. By Samuel thibault on 2017-11-14

Fix getting events for our own grabs

If a grab was taken by one of our own plugins, we have to ignore the X grab.

4138. By Samuel thibault on 2017-11-14

screen: Fix uninitialized variable

[Marco Trevisan (Treviño) (3v1n0)]

Thanks for your work, it's really appreciated and something I really had in mind since long time...

However, a part few cleanups (and a bit more of C++11 features usage), we've to think as this will deal with Unity, since there we're using XI2 already for some input monitor operations (mostly for edge events and for monitoring the mouse position when menus are opened, plus few other things), and the fact is that we disable such events when we don't need them.

Now, in theory we could move all that to compiz, introducing new actions types, but the problem now is that we can't really deal with all this work now that we're focused in GNOME

Another possibility is just to make unity to save the state on load with XIGetSelectedEvents and resume that state when we disable it, but in general I'd prefer the events not to be selected unless there's anything else that need them.

Another possibility is just make unity to keep them always enabled, and never toggle them.

In any case, it would be cool if you could test it with your changes, and in case propose a fix for it too. As without that change we can't land compiz in ubuntu (and thus upstream) easily as it could be prone to regressions.

[lp:~samuel-thibault/compiz/shortcuts]

4139. By Samuel thibault on 2017-11-16

screen: factorize XI2 to core event translation

4140. By Samuel thibault on 2017-11-24

Factorize XI2 SelectEvents code into privatescreen

[Samuel thibault (samuel-thibault)]

Hello,

I agree that selecting XI2 events only when needed would be ideally ideal, but
the obtained optimization (avoiding to trivially convert from XI2 events to core
events) does not seem to me worth the complexity cost.

Assuming that we avoid that complexity and just make compiz use XI2 whenever
available (Unity requires it anyway), things would be much simpler:

- Unity can use XIGetSelectedEvents() to determine what Compiz configured, and
merge it before XISelectEvents() and resume it, as you suggested.

- Compiz only disables XI2 temporarily within PrivateWindow::reparent(), so it
can also use XIGetSelectedEvents() to restore it as it was, either the original
compiz set or the set as merged by Unity.

That way, both sides are easily careful about what was set by the other side.

What do you think?

Samuel

[Marco Trevisan (Treviño) (3v1n0)]

Ok, that would look reasonable.

Could you possibly do that unity side of work too?
As otherwise this MP might stuck until I've time for that (and it might take a while).

Cheers

[Samuel thibault (samuel-thibault)]

Sure, I'll do the unity side :)
(probably on Tuesday)

[lp:~samuel-thibault/compiz/shortcuts]

4141. By Samuel thibault on 2017-12-12

xi2: save/restore masks instead of disabling/enabling compiz mask

Unity also uses xi2, so we need to restore its mask, and not the mask that
Compiz uses. This changeset completely replaces xi2SelectNoInput with
xi2DisableInput, which returns the mask which was active, so that xi2EnableInput
can reenable that same mask.

[Samuel thibault (samuel-thibault)]

Sorry I got preempted by other issues. I have pushed the compiz side, and will work on the unity side.

[Samuel thibault (samuel-thibault)]

Hello,

I have pushed the unity side on https://code.launchpad.net/~samuel-thibault/unity/shortcuts

Samuel

[lp:~samuel-thibault/compiz/shortcuts]

4142. By Samuel thibault on 2018-06-29

Enable grab ignore on colorfilter plugin too

4143. By Samuel thibault on 2018-09-25

Fix ButtonRelease/XI_ButtonRelease KeyRelease/XI_KeyRelease confusion

4144. By Samuel thibault on 2018-09-25

fix memleak

Unmerged revisions

4144. By Samuel thibault on 2018-09-25

fix memleak

4143. By Samuel thibault on 2018-09-25

Fix ButtonRelease/XI_ButtonRelease KeyRelease/XI_KeyRelease confusion

4142. By Samuel thibault on 2018-06-29

Enable grab ignore on colorfilter plugin too

4141. By Samuel thibault on 2017-12-12

xi2: save/restore masks instead of disabling/enabling compiz mask

Unity also uses xi2, so we need to restore its mask, and not the mask that
Compiz uses. This changeset completely replaces xi2SelectNoInput with
xi2DisableInput, which returns the mask which was active, so that xi2EnableInput
can reenable that same mask.

4140. By Samuel thibault on 2017-11-24

Factorize XI2 SelectEvents code into privatescreen

4139. By Samuel thibault on 2017-11-16

screen: factorize XI2 to core event translation

4138. By Samuel thibault on 2017-11-14

screen: Fix uninitialized variable

4137. By Samuel thibault on 2017-11-14

Fix getting events for our own grabs

If a grab was taken by one of our own plugins, we have to ignore the X grab.

4136. By Samuel thibault on 2017-11-07

Allow plugins to ignore keyboard grabs

by using XInput2 events when available, converting them into core events before handing them to plugins.

Based on the work of Colomban Wendling

=== modified file 'include/core/action.h'
--- include/core/action.h	2014-01-21 19:46:32 +0000
+++ include/core/action.h	2018-09-25 16:05:25 +0000
@@ -193,6 +193,14 @@
 
 	bool active () const;
 
+        /* When enabled, key events will be reported even while a keyboard grab
+         * is ongoing. This allows shortcuts to work while a menu is open, but
+         * also while xlock is running, so this should not be set lightly, and
+         * notably not in a plugin which could commands and thus override xlock.
+         */
+	bool ignoreGrabs () const;
+	void setIgnoreGrabs (bool ignore);
+
 	/* CompAction should be a pure virtual class so
 	 * that we can pass the interface required to for setActionActiveState
 	 * directly rather than using friends

=== modified file 'include/core/screen.h'
--- include/core/screen.h	2017-06-29 17:19:00 +0000
+++ include/core/screen.h	2018-09-25 16:05:25 +0000
@@ -392,6 +392,10 @@
     virtual int outputDeviceForPoint (const CompPoint &point) = 0;
     virtual int outputDeviceForPoint (int x, int y) = 0;
     virtual int xkbEvent () = 0;
+    virtual long xi2CoreMask () = 0;
+    virtual void xi2SelectInput () = 0;
+    virtual XIEventMask * xi2DisableInput (int *num_masks_return) = 0;
+    virtual void xi2EnableInput (XIEventMask *masks, int num_masks) = 0;
     virtual void warpPointer (int dx, int dy) = 0;
     virtual void updateGrab (GrabHandle handle, Cursor cursor) = 0;
     virtual int shapeEvent () = 0;

=== modified file 'include/core/window.h'
--- include/core/window.h	2018-02-23 16:53:18 +0000
+++ include/core/window.h	2018-09-25 16:05:25 +0000
@@ -34,6 +34,7 @@
 #include <X11/Xutil.h>
 #include <X11/Xregion.h>
 #include <X11/extensions/Xdamage.h>
+#include <X11/extensions/XInput2.h>
 #include <X11/extensions/sync.h>
 
 #include <core/action.h>

=== modified file 'plugins/colorfilter/src/colorfilter.cpp'
--- plugins/colorfilter/src/colorfilter.cpp	2017-03-28 16:39:34 +0000
+++ plugins/colorfilter/src/colorfilter.cpp	2018-09-25 16:05:25 +0000
@@ -450,6 +450,12 @@
 				&ColorfilterScreen::damageDecorations, this, _1,
 				_2));
 
+    foreach (CompOption &o, getOptions ())
+    {
+	if (o.isAction ())
+	    o.value ().action ().setIgnoreGrabs (true);
+    }
+
     loadFilters ();
 };
 

=== modified file 'plugins/ezoom/src/ezoom.cpp'
--- plugins/ezoom/src/ezoom.cpp	2017-12-05 14:45:06 +0000
+++ plugins/ezoom/src/ezoom.cpp	2018-09-25 16:05:25 +0000
@@ -2132,6 +2132,12 @@
     optionSetEnsureVisibilityInitiate (boost::bind (
 					&EZoomScreen::ensureVisibilityAction, this,
 					_1, _2, _3));
+
+    foreach (CompOption &o, getOptions ())
+    {
+	if (o.isAction ())
+	    o.value ().action ().setIgnoreGrabs (true);
+    }
 }
 
 EZoomScreen::~EZoomScreen ()

=== modified file 'plugins/neg/src/neg.cpp'
--- plugins/neg/src/neg.cpp	2017-08-24 13:54:22 +0000
+++ plugins/neg/src/neg.cpp	2018-09-25 16:05:25 +0000
@@ -466,6 +466,11 @@
     optionSetActivateAtStartupNotify (boost::bind (&NegScreen::optionChanged, this,
 						   _1, _2));
 
+    foreach (CompOption &o, getOptions ())
+    {
+	if (o.isAction ())
+	    o.value ().action ().setIgnoreGrabs (true);
+    }
 }
 	
 

=== modified file 'plugins/showmouse/src/showmouse.cpp'
--- plugins/showmouse/src/showmouse.cpp	2017-04-20 13:04:22 +0000
+++ plugins/showmouse/src/showmouse.cpp	2018-09-25 16:05:25 +0000
@@ -700,6 +700,12 @@
 						 this,  _1, _2, _3));
 
     optionSetActivateAtStartupNotify (boost::bind (&ShowmouseScreen::startupToggle, this));
+
+    foreach (CompOption &o, getOptions ())
+    {
+	if (o.isAction ())
+	    o.value ().action ().setIgnoreGrabs (true);
+    }
 }
 
 ShowmouseScreen::~ShowmouseScreen ()

=== modified file 'src/action.cpp'
--- src/action.cpp	2014-02-28 20:45:57 +0000
+++ src/action.cpp	2018-09-25 16:05:25 +0000
@@ -483,9 +483,10 @@
 void
 CompAction::copyState (const CompAction &action)
 {
-    priv->initiate  = action.priv->initiate;
-    priv->terminate = action.priv->terminate;
-    priv->state     = action.priv->state;
+    priv->initiate    = action.priv->initiate;
+    priv->terminate   = action.priv->terminate;
+    priv->state       = action.priv->state;
+    priv->ignoreGrabs = action.priv->ignoreGrabs;
 
     memcpy (&priv->priv, &action.priv->priv, sizeof (CompPrivate));
 }
@@ -501,6 +502,7 @@
 	priv->button.button ()    != val.priv->button.button ()	    ||
 	priv->bell                != val.priv->bell		    ||
 	priv->edgeMask            != val.priv->edgeMask		    ||
+	priv->ignoreGrabs         != val.priv->ignoreGrabs	    ||
 	memcmp (&priv->priv, &val.priv->priv, sizeof (CompPrivate)) != 0)
 	return false;
 
@@ -651,6 +653,18 @@
     return priv->active;
 }
 
+bool
+CompAction::ignoreGrabs () const
+{
+    return priv->ignoreGrabs;
+}
+
+void
+CompAction::setIgnoreGrabs (bool ignore)
+{
+    priv->ignoreGrabs = ignore;
+}
+
 void
 PrivateAction::setActive (bool a)
 {
@@ -665,29 +679,31 @@
 }
 
 PrivateAction::PrivateAction () :
-    initiate  (),
-    terminate (),
-    state     (0),
-    type      (0),
-    key       (),
-    button    (),
-    bell      (false),
-    edgeMask  (0),
-    active    (false)
+    initiate    (),
+    terminate   (),
+    state       (0),
+    type        (0),
+    key         (),
+    button      (),
+    bell        (false),
+    edgeMask    (0),
+    active      (false),
+    ignoreGrabs (false)
 {
     memset (&priv, 0, sizeof (CompPrivate));
 }
 
 PrivateAction::PrivateAction (const PrivateAction &a) :
-    initiate  (a.initiate),
-    terminate (a.terminate),
-    state     (a.state),
-    type      (a.type),
-    key       (a.key),
-    button    (a.button),
-    bell      (a.bell),
-    edgeMask  (a.edgeMask),
-    active    (a.active)
+    initiate    (a.initiate),
+    terminate   (a.terminate),
+    state       (a.state),
+    type        (a.type),
+    key         (a.key),
+    button      (a.button),
+    bell        (a.bell),
+    edgeMask    (a.edgeMask),
+    active      (a.active),
+    ignoreGrabs (a.ignoreGrabs)
 {
     memcpy (&priv, &a.priv, sizeof (CompPrivate));
 }

=== modified file 'src/event.cpp'
--- src/event.cpp	2018-03-02 16:56:34 +0000
+++ src/event.cpp	2018-09-25 16:05:25 +0000
@@ -35,6 +35,7 @@
 #include <X11/extensions/shape.h>
 #include <X11/extensions/Xrandr.h>
 #include <X11/extensions/Xfixes.h>
+#include <X11/extensions/XInput2.h>
 
 #include <core/atoms.h>
 #include <core/servergrab.h>
@@ -164,6 +165,25 @@
     return true;
 }
 
+static bool
+shouldTriggerAction (CompScreen *screen, CompAction *action)
+{
+    if (!screen->grabbed ())
+	/* No grab, no problem */
+	return true;
+
+    if (screen->otherGrabExist (NULL))
+	/* Our own grab */
+	return true;
+
+    if (action->ignoreGrabs ())
+	/* Action should ignore grabs anyway */
+	return true;
+
+    /* Not our grab, respect it */
+    return false;
+}
+
 bool
 cps::EventManager::triggerPress (CompAction         *action,
                              CompAction::State   state,
@@ -280,8 +300,11 @@
 	    if (matchEventState (action->button ().modifiers (),
 				 eventState))
 	    {
-		if (eventManager.triggerPress (action, state, arguments))
-		    return true;
+		if (shouldTriggerAction (screen, action))
+		{
+		    if (eventManager.triggerPress (action, state, arguments))
+			return true;
+		}
 	    }
 	}
     }
@@ -312,9 +335,14 @@
 	    {
 		if (matchEventState (action->button ().modifiers (),
 				     eventState))
-		    if (action->initiate () (action, state,
-					     arguments))
-			return true;
+		{
+		    if (shouldTriggerAction (screen, action))
+		    {
+			if (action->initiate () (action, state,
+						 arguments))
+			    return true;
+		    }
+		}
 	    }
 	}
     }
@@ -385,8 +413,11 @@
 	{
 	    if (action->button ().button () == (int) event->button)
 	    {
-	        if (eventManager.triggerRelease (action, state, arguments))
-		    return true;
+		if (shouldTriggerAction (screen, action))
+		{
+		    if (eventManager.triggerRelease (action, state, arguments))
+			return true;
+		}
 	    }
 	}
     }
@@ -477,6 +508,7 @@
 
 	if (isBound (option, CompAction::BindingTypeKey, state, &action) &&
 	    shouldTriggerKeyPressAction (action, event) &&
+	    shouldTriggerAction (screen, action) &&
 	    eventManager.triggerPress (action, state, arguments))
 		return true;
     }
@@ -485,6 +517,7 @@
     {
 	if (isBound (action, CompAction::BindingTypeKey, state) &&
 	    shouldTriggerKeyPressAction (&action, event) &&
+	    shouldTriggerAction (screen, &action) &&
 	    eventManager.triggerPress (&action, state, arguments))
 		return true;
     }
@@ -524,14 +557,16 @@
 	CompAction *action;
 
 	if (isBound (option, CompAction::BindingTypeKey, state, &action) &&
-	    shouldTriggerKeyReleaseAction (action, event))
+	    shouldTriggerKeyReleaseAction (action, event) &&
+	    shouldTriggerAction (screen, action))
 		handled |= eventManager.triggerRelease (action, state, arguments);
     }
 
     foreach (CompAction &action, actions)
     {
 	if (isBound (action, CompAction::BindingTypeKey, state) &&
-	    shouldTriggerKeyReleaseAction (&action, event))
+	    shouldTriggerKeyReleaseAction (&action, event) &&
+	    shouldTriggerAction (screen, &action))
 		handled |= eventManager.triggerRelease (&action, state, arguments);
     }
 
@@ -976,12 +1011,22 @@
 	{
 	    XEvent nev;
 	    XPeekEvent (dpy, &nev);
+	    if (nev.type == GenericEvent)
+		XGetEventData (dpy, &nev.xcookie);
+	    XIDeviceEvent *nevdev = (XIDeviceEvent *) nev.xcookie.data;
 
-	    if (nev.type == KeyPress && nev.xkey.time == event->xkey.time &&
-		nev.xkey.keycode == event->xkey.keycode)
+	    if ((nev.type == KeyPress && nev.xkey.time == event->xkey.time &&
+		 nev.xkey.keycode == event->xkey.keycode) ||
+		(nev.type == GenericEvent &&
+		 nev.xcookie.evtype == XI_KeyPress &&
+		 nevdev->time == event->xkey.time &&
+		 (unsigned int) nevdev->detail == event->xkey.keycode))
 	    {
 		nextKeyPressIsRepeated_ = true;
 	    }
+
+	    if (nev.type == GenericEvent)
+		XFreeEventData (dpy, &nev.xcookie);
 	}
 
 	foreach (CompPlugin *p, CompPlugin::getPlugins ())

=== modified file 'src/privateaction.h'
--- src/privateaction.h	2012-10-02 10:28:01 +0000
+++ src/privateaction.h	2018-09-25 16:05:25 +0000
@@ -71,6 +71,8 @@
 
 	bool active;
 
+	bool ignoreGrabs;
+
 	CompPrivate priv;
 };
 

=== modified file 'src/privatescreen.h'
--- src/privatescreen.h	2017-06-29 17:19:00 +0000
+++ src/privatescreen.h	2018-09-25 16:05:25 +0000
@@ -37,6 +37,8 @@
 #include <time.h>
 #include <boost/shared_ptr.hpp>
 
+#include <X11/extensions/XInput2.h>
+
 #include <glibmm/main.h>
 
 #include "privatetimeoutsource.h"
@@ -667,6 +669,12 @@
 
 	void setAudibleBell (bool audible);
 
+	int xi2OpCode () const;
+	void xi2SelectInput (Window id);
+	XIEventMask * xi2DisableInput (Window id, int *num_masks_return);
+	void xi2EnableInput (Window id, XIEventMask *masks, int num_masks);
+	long xi2CoreMask ();
+
 	bool handleActionEvent (XEvent *event);
 
 	void handleSelectionRequest (XEvent *event);
@@ -768,6 +776,7 @@
     compiz::private_screen::Extension xSync;
     compiz::private_screen::Extension xRandr;
     compiz::private_screen::Extension xShape;
+    compiz::private_screen::Extension xi2;
     compiz::private_screen::ViewPort viewPort;
     compiz::private_screen::StartupSequenceImpl startupSequence;
     compiz::private_screen::EventManager eventManager;
@@ -955,6 +964,11 @@
 
 	int xkbEvent ();
 
+	long xi2CoreMask ();
+	void xi2SelectInput ();
+	XIEventMask * xi2DisableInput (int *num_masks_return);
+	void xi2EnableInput (XIEventMask *masks, int num_masks);
+
 	XWindowAttributes attrib ();
 
 	int screenNum ();

=== modified file 'src/screen.cpp'
--- src/screen.cpp	2017-10-26 17:02:38 +0000
+++ src/screen.cpp	2018-09-25 16:05:25 +0000
@@ -773,20 +773,48 @@
 	return false;
     XNextEvent (dpy, &ev);
 
+    if (ev.type == GenericEvent)
+	XGetEventData (dpy, &ev.xcookie);
+
     /* Skip to the last MotionNotify
      * event in this sequence */
-    if (ev.type == MotionNotify)
+    if (ev.type == MotionNotify ||
+	(ev.type == GenericEvent &&
+	    ev.xcookie.extension == xi2.get () &&
+	    ev.xcookie.evtype == XI_Motion))
     {
 	XEvent peekEvent;
 	while (XPending (dpy))
 	{
 	    XPeekEvent (dpy, &peekEvent);
 
-	    if (peekEvent.type != MotionNotify)
+	    if (peekEvent.type != MotionNotify &&
+		! (peekEvent.type == GenericEvent &&
+		    peekEvent.xcookie.extension == xi2.get () &&
+		    peekEvent.xcookie.evtype == XI_Motion))
 		break;
 
+	    if (peekEvent.type == GenericEvent)
+		XGetEventData (dpy, &peekEvent.xcookie);
+	    XIDeviceEvent *xiDevEv = (XIDeviceEvent *) peekEvent.xcookie.data;
+
+	    if (peekEvent.type == GenericEvent &&
+		    peekEvent.xcookie.extension == xi2.get () &&
+		    peekEvent.xcookie.evtype == XI_Motion &&
+		    xiDevEv->deviceid != xiDevEv->sourceid)
+	    {
+	        // Ignore Master Devices
+		XFreeEventData (dpy, &peekEvent.xcookie);
+		XNextEvent (dpy, &peekEvent);
+		continue;
+	    }
+	    XFreeEventData (dpy, &peekEvent.xcookie);
+
 	    /* Overwrite previous MotionNotify event */
 	    XNextEvent (dpy, &ev);
+
+	    if (ev.type == GenericEvent)
+		XGetEventData (dpy, &ev.xcookie);
 	}
     }
 
@@ -806,6 +834,56 @@
 	return getNextXEvent (ev);
 }
 
+static unsigned int
+translateXI2State (const XIDeviceEvent *event)
+{
+    unsigned int state;
+
+    /* Keyboard Modifiers, bits 0 to 7 */
+    state = event->mods.effective & ((1 << 8) - 1);
+
+    /* We are only interested in the buttons numbered 1 to 5, which correspond
+     * to the core buttons, bits 8 to 12 */
+    int maxbits = MIN (5, event->buttons.mask_len - 1);
+    for (int i = 1; i <= maxbits; i++)
+    {
+	if (! XIMaskIsSet (event->buttons.mask, i))
+	    continue;
+
+	switch (i)
+	{
+	    case 1: state |= Button1Mask; break;
+	    case 2: state |= Button2Mask; break;
+	    case 3: state |= Button3Mask; break;
+	    case 4: state |= Button4Mask; break;
+	    case 5: state |= Button5Mask; break;
+	}
+    }
+
+    /* Keyboard groups, bits 13 to 15 */
+    state |= (event->group.effective & ((1 << 3) - 1)) << 13;
+
+    return state;
+}
+
+template <typename EVENT>
+void fakeEventFromXiEvent(EVENT *fakeEvent, XEvent *event, XIDeviceEvent *xiDevEv)
+{
+	fakeEvent->serial = event->xcookie.serial;
+	fakeEvent->send_event = event->xcookie.send_event;
+	fakeEvent->display = event->xcookie.display;
+	fakeEvent->window = xiDevEv->event;
+	fakeEvent->root = xiDevEv->root;
+	fakeEvent->subwindow = xiDevEv->child;
+	fakeEvent->time = xiDevEv->time;
+	fakeEvent->x = xiDevEv->event_x;
+	fakeEvent->y = xiDevEv->event_y;
+	fakeEvent->x_root = xiDevEv->root_x;
+	fakeEvent->y_root = xiDevEv->root_y;
+	fakeEvent->state = translateXI2State(xiDevEv);
+	fakeEvent->same_screen = True;
+}
+
 void
 PrivateScreen::processEvents ()
 {
@@ -832,6 +910,77 @@
 
     while (getNextEvent (event))
     {
+	if (xi2.isEnabled ()) {
+	    /* Using XI2 events, ignore any duplicate core events */
+	    switch (event.type) {
+	    case KeyPress:
+	    case KeyRelease:
+		XFlush (dpy);
+		continue;
+	    }
+	}
+
+	if (event.type == GenericEvent
+	    && event.xcookie.extension == xi2.get ()) {
+	    /* Convert XI2 events to core events */
+
+	    XIDeviceEvent *xiDevEv = (XIDeviceEvent *) event.xcookie.data;
+
+	    if (xiDevEv->deviceid != xiDevEv->sourceid) {
+		// Ignore Master Devices
+		XFreeEventData (dpy, &event.xcookie);
+		continue;
+	    }
+
+	    switch (event.xcookie.evtype) {
+	    case XI_ButtonPress:
+	    case XI_ButtonRelease:
+	    {
+		XButtonEvent fakeEvent;
+		fakeEventFromXiEvent(&fakeEvent, &event, xiDevEv);
+		fakeEvent.type = event.xcookie.evtype == XI_ButtonPress ?
+				 ButtonPress : ButtonRelease;
+		fakeEvent.button = xiDevEv->detail;
+		XFreeEventData (dpy, &event.xcookie);
+		event.xbutton = fakeEvent;
+		break;
+	    }
+
+	    case XI_KeyPress:
+	    case XI_KeyRelease:
+	    {
+		XKeyEvent fakeEvent;
+		fakeEventFromXiEvent(&fakeEvent, &event, xiDevEv);
+		fakeEvent.type = event.xcookie.evtype == XI_KeyPress ?
+				 KeyPress : KeyRelease;
+		fakeEvent.keycode = xiDevEv->detail;
+		XFreeEventData (dpy, &event.xcookie);
+		event.xkey = fakeEvent;
+		break;
+	    }
+
+	    case XI_Motion:
+	    {
+		/* TODO: mousepoll is probably useless with XI2.  */
+		XMotionEvent fakeEvent;
+		fakeEventFromXiEvent(&fakeEvent, &event, xiDevEv);
+		fakeEvent.type = MotionNotify;
+		fakeEvent.is_hint = NotifyNormal;
+		XFreeEventData (dpy, &event.xcookie);
+		event.xmotion = fakeEvent;
+		break;
+	    }
+
+	    default:
+		/* Ignore other XI2 events */
+		XFreeEventData (dpy, &event.xcookie);
+		XFlush (dpy);
+		continue;
+	    }
+	}
+	else if (event.type == GenericEvent)
+	    XFreeEventData (dpy, &event.xcookie);
+
 	switch (event.type) {
 	case ButtonPress:
 	case ButtonRelease:
@@ -4532,6 +4681,104 @@
     return privateScreen.getXkbEvent ();
 }
 
+int
+PrivateScreen::xi2OpCode () const
+{
+    return xi2.get ();
+}
+
+void
+PrivateScreen::xi2SelectInput (Window id)
+{
+    if (xi2OpCode () == -1)
+	return;
+
+    XIEventMask eventmask;
+    unsigned char mask[XIMaskLen (XI_LASTEVENT)] = { 0 };
+
+    eventmask.deviceid = XIAllDevices;
+    eventmask.mask_len = sizeof (mask);
+    eventmask.mask = mask;
+
+    XISetMask (mask, XI_KeyPress);
+    XISetMask (mask, XI_KeyRelease);
+    XISetMask (mask, XI_ButtonPress);
+    XISetMask (mask, XI_ButtonRelease);
+    XISetMask (mask, XI_Motion);
+
+    XISelectEvents (dpy, id, &eventmask, 1);
+}
+
+void
+CompScreenImpl::xi2SelectInput (void)
+{
+    privateScreen.xi2SelectInput (privateScreen.rootWindow ());
+}
+
+XIEventMask *
+PrivateScreen::xi2DisableInput (Window id, int *num_masks_return)
+{
+    if (xi2OpCode () == -1)
+	return NULL;
+
+    /* First get previous mask to be restored in xi2EnableInput */
+    XIEventMask *prevmask;
+    prevmask = XIGetSelectedEvents (dpy, id, num_masks_return);
+
+    /* Then disable everything */
+    XIEventMask eventmask;
+    unsigned char mask[1] = { 0 };
+
+    eventmask.deviceid = XIAllDevices;
+    eventmask.mask_len = sizeof (mask);
+    eventmask.mask = mask;
+
+    XISelectEvents (dpy, id, &eventmask, 1);
+
+    return prevmask;
+}
+
+XIEventMask *
+CompScreenImpl::xi2DisableInput (int *num_masks_return)
+{
+    return privateScreen.xi2DisableInput (privateScreen.rootWindow (), num_masks_return);
+}
+
+void
+PrivateScreen::xi2EnableInput (Window id, XIEventMask *masks, int num_masks)
+{
+    if (xi2OpCode () == -1)
+	return;
+
+    XISelectEvents (dpy, id, masks, num_masks);
+    XFree (masks);
+}
+
+void
+CompScreenImpl::xi2EnableInput (XIEventMask *mask, int num_masks)
+{
+    return privateScreen.xi2EnableInput (privateScreen.rootWindow (), mask, num_masks);
+}
+
+long
+PrivateScreen::xi2CoreMask (void)
+{
+    if (xi2OpCode () != -1)
+	return 0;
+
+    return KeyPressMask      |
+	   KeyReleaseMask    |
+	   ButtonPressMask   |
+	   ButtonReleaseMask;
+}
+
+long
+CompScreenImpl::xi2CoreMask (void)
+{
+  return privateScreen.xi2CoreMask ();
+}
+
+
 void
 PrivateScreen::identifyEdgeWindow(Window id)
 {
@@ -5087,6 +5334,28 @@
 }
 
 
+namespace
+{
+static Bool XI2QueryExtension(Display *dpy, int *opcode, int *error)
+{
+    int event;
+
+    if (!XQueryExtension (dpy, "XInputExtension", opcode, &event, error))
+	return False;
+
+    /* we want 2.1 for DeviceEvent::sourceid */
+    int major = 2, minor = 1;
+
+    if (XIQueryVersion (dpy, &major, &minor) == BadRequest)
+	return False;
+    compLogMessage ("core", CompLogLevelDebug,
+		    "Got XI2 extension %d.%d", major, minor);
+
+    return True;
+}
+}
+
+
 bool
 PrivateScreen::initDisplay (const char *name, cps::History& history, unsigned int showingDesktopMask)
 {
@@ -5137,6 +5406,10 @@
 			"No XKB extension");
     }
 
+    xi2.init<XI2QueryExtension> (dpy);
+    if (!xi2.isEnabled ())
+	compLogMessage ("core", CompLogLevelWarn, "No XI2 extension");
+
     int  xineramaError;
     int  xineramaEvent;
     xineramaExtension = XineramaQueryExtension (dpy,
@@ -5152,7 +5425,6 @@
 
     Window root_tmp = XRootWindow (dpy, DefaultScreen (dpy));
 
-
     /* Don't select for SubstructureRedirectMask or
      * SubstructureNotifyMask yet since we need to
      * act in complete synchronization here when
@@ -5165,10 +5437,7 @@
 		  PropertyChangeMask       |
 		  LeaveWindowMask          |
 		  EnterWindowMask          |
-		  KeyPressMask             |
-		  KeyReleaseMask           |
-		  ButtonPressMask          |
-		  ButtonReleaseMask        |
+		  xi2CoreMask ()           |
 		  FocusChangeMask          |
 		  ExposureMask);
 
@@ -5190,6 +5459,8 @@
 		      SubstructureNotifyMask);
     }
 
+    xi2SelectInput (root_tmp);
+
     for (int i = 0; i < SCREEN_EDGE_NUM; i++)
     {
 	screenEdge[i].id    = None;
@@ -5635,6 +5906,7 @@
     lastFileWatchHandle (1),
     watchFds (0),
     lastWatchFdHandle (1),
+    grabbed (false),
     grabWindow (None)
 {
     TimeoutHandler *dTimeoutHandler = new TimeoutHandler ();

=== modified file 'src/window.cpp'
--- src/window.cpp	2018-03-02 17:02:22 +0000
+++ src/window.cpp	2018-09-25 16:05:25 +0000
@@ -6950,6 +6950,10 @@
     /* Do not get any events from here on */
     XSelectInput (dpy, screen->root (), NoEventMask);
 
+    XIEventMask *xi2Masks;
+    int num_masks;
+    xi2Masks = screen->xi2DisableInput (&num_masks);
+
     /* If we have some frame extents, we should apply them here and
      * set lastFrameExtents */
     wrapper = XCreateWindow (dpy, serverFrame,
@@ -7046,13 +7050,12 @@
 		  PropertyChangeMask       |
 		  LeaveWindowMask          |
 		  EnterWindowMask          |
-		  KeyPressMask             |
-		  KeyReleaseMask           |
-		  ButtonPressMask          |
-		  ButtonReleaseMask        |
+		  screen->xi2CoreMask ()   |
 		  FocusChangeMask          |
 		  ExposureMask);
 
+    screen->xi2EnableInput (xi2Masks, num_masks);
+
     XUngrabServer (dpy);
     XSync (dpy, false);
 
@@ -7175,13 +7178,12 @@
 		  PropertyChangeMask       |
 		  LeaveWindowMask          |
 		  EnterWindowMask          |
-		  KeyPressMask             |
-		  KeyReleaseMask           |
-		  ButtonPressMask          |
-		  ButtonReleaseMask        |
+		  screen->xi2CoreMask ()   |
 		  FocusChangeMask          |
 		  ExposureMask);
 
+	screen->xi2SelectInput ();
+
 	XUngrabServer (dpy);
 	XSync (dpy, false);