Merge lp:~ksamak/compiz/ezoom_focus_tracking into lp:compiz/0.9.13

[ksamak]

ezoom: added focus tracking based on at-spi a11y events.

[Andrea Azzarone (azzar1)]

Can you please link a bug to the MP?

[Andrea Azzarone (azzar1)]

Ok this is the first part of the review. I'll continue later.

review: Needs Fixing

[Sam Spilsbury (smspillaz)]

Thanks for all the hard work in implementing this. There's a fair bit of work to be done before this can be integrated. In particular, this cannot be merged whilst it opens a separate display connection - that is a recipe for deadlocks.

review: Needs Fixing (code, style)

[Sam Spilsbury (smspillaz)]

Relevant prior art, if interested: https://code.launchpad.net/~gloob/compiz/texttracking

[ksamak (ksamak)]

well, this plugin would indeed have been helpful.

Sam Spilsbury (smspillaz) wrote 18 hours ago:
I like the fact that this is a separate library, but this absolutely doesn't belong in the mousepoll plugin. The mouse poll plugin is supposed to do one thing and one thing only - update the position of the mouse every N milliseconds. Move all this into either a separate plugin or library.

I originally made a copy of the mousePoll plugin (called focusPoll), but for some unknown reason it... deadlocked, or froze at runtime. I couldn't find why, and no one had time to look at it, so I merged both logics in mousepoll, cause then, with sensibly the same methods, it didn't freeze.

I agree an additional plugin would serve better, so I'd appreciate some input on that problem.
there's a readyish branch on http://git.hypra.fr/hypra/compiz.git named focuspoll. Maybe you would have some insights as to what is blocking here. It might be, as you pointed, the call to open the display.
question: how would you circumvent the problem of the call to XOpenDisplay, if the whole a11ywatcher was a library? Is there a better way to get the screen info? that is without causing all those problems.

I will meditate on these ideas, and weight the pros and cons of the different solutions, and i'll then continue the work.
thank you for all the advice and corrections, including those pending below. I am available to discuss these matters further, or if you have more insight.

review: Needs Fixing

[Sam Spilsbury (smspillaz)]

> Maybe you would have some insights as to what is blocking here. It
> might be, as you pointed, the call to open the display.
> question: how would you circumvent the problem of the call to XOpenDisplay, if
> the whole a11ywatcher was a library? Is there a better way to get the screen
> info? that is without causing all those problems.

Yes, there's a global variable called 'screen' and you can access the current connection from there (screen->dpy()). If your library needs a reference to it, I'd suggest having the caller pass it in.

[ksamak (ksamak)]

I've answered some of the following, and will superseed the merge request with the new version from the branch.
i thank you for your time, advice, and corrections.

[ksamak (ksamak)]

call for help on the matter of binding C callback to c++ member function.
thx

[ksamak (ksamak)]

just a ping, i changed coding style again, on request from 3v1n0.

[Andrea Azzarone (azzar1)]

I reviews part of the code. Fix it before I going on.

review: Needs Fixing

[ksamak (ksamak)]

I fixed the code according to your specifications, i changed the whole coding style of my editor, thanks to the few lines i (finally) found here:
http://wiki.compiz.org/Development/CodingStyle
Sorry again for my misunderstanding tabs and coding style, i'll try my best to respect that from initial coding on, event though i find it less readable.
I thank you for your patience.

review: Needs Resubmitting

[lp:~ksamak/compiz/ezoom_focus_tracking]

4122. By ksamak <ksamak@ksalaptop> on 2017-04-10

added precedence relation to start showmouse before ezoom

4123. By ksamak <ksamak@ksalaptop> on 2017-04-20

coding style

4124. By ksamak <ksamak@ksalaptop> on 2017-04-28

added rebranding of icedove to thunderbird support

[ksamak (ksamak)]

created lp:~ksamak/compiz/correct_mousetheme_targetting_for_ezoom, although i think it wasn't necessary. I'll delete it.
I add the update for the rebranding of icedove into thunderbird.
thank you.

review: Needs Resubmitting

[Samuel thibault (samuel-thibault)]

Hello,

I have gone through the previous review from azzar1, and commented further.

Samuel

[Samuel thibault (samuel-thibault)]

I have commented on the callback issue, to avoid the singleton.

Unmerged revisions

4124. By ksamak <ksamak@ksalaptop> on 2017-04-28

added rebranding of icedove to thunderbird support

4123. By ksamak <ksamak@ksalaptop> on 2017-04-20

coding style

4122. By ksamak <ksamak@ksalaptop> on 2017-04-10

added precedence relation to start showmouse before ezoom

4121. By ksamak <ksamak@ksalaptop> on 2017-04-02

modifications of code according to azzar's request

4120. By ksamak <ksamak@ksalaptop> on 2017-03-14

coding style modifs. changed if format on 3v1n0's request

4119. By ksamak <ksamak@ksalaptop> on 2017-02-25

coding style modifs

4118. By ksamak <ksamak@ksalaptop> on 2017-02-25

coding style modifs

4117. By ksamak <ksamak@ksalaptop> on 2017-02-24

minors code modifs

4116. By ksamak <ksamak@ksalaptop> on 2017-02-24

minors code modifs

4115. By ksamak <ksamak@ksalaptop> on 2017-02-24

corrected segfault, minors code modifs

=== modified file 'debian/compiz-dev.install'
--- debian/compiz-dev.install	2016-07-14 15:21:59 +0000
+++ debian/compiz-dev.install	2017-04-28 09:59:04 +0000
@@ -7,6 +7,7 @@
 debian/tmp/usr/lib/*/pkgconfig/compiz-composite.pc
 debian/tmp/usr/lib/*/pkgconfig/compiz-cube.pc
 debian/tmp/usr/lib/*/pkgconfig/compiz-mousepoll.pc
+debian/tmp/usr/lib/*/pkgconfig/compiz-focuspoll.pc
 debian/tmp/usr/lib/*/pkgconfig/compiz-opengl.pc
 debian/tmp/usr/lib/*/pkgconfig/compiz.pc
 debian/tmp/usr/lib/*/pkgconfig/compiz-scale.pc

=== modified file 'debian/compiz-plugins-default.install'
--- debian/compiz-plugins-default.install	2015-07-24 16:28:37 +0000
+++ debian/compiz-plugins-default.install	2017-04-28 09:59:04 +0000
@@ -26,6 +26,8 @@
 usr/share/compiz/*matecompat.*
 usr/lib/*/compiz/*mousepoll.*
 usr/share/compiz/*mousepoll.*
+usr/lib/*/compiz/*focuspoll.*
+usr/share/compiz/*focuspoll.*
 usr/lib/*/compiz/*move.*
 usr/share/compiz/*move.*
 usr/lib/*/compiz/*opengl.*

=== modified file 'debian/control'
--- debian/control	2016-11-03 18:29:41 +0000
+++ debian/control	2017-04-28 09:59:04 +0000
@@ -14,6 +14,7 @@
                quilt (>= 0.40),
                libcairo2-dev,
                libdbus-glib-1-dev,
+               libatspi2.0-dev,
                libgl1-mesa-dev (>= 6.5.1) [!armhf !armel] | libgl-dev [!armhf !armel],
                libegl1-mesa-dev [armhf armel], libgles2-mesa-dev [armhf armel],
                libboost-dev,

=== modified file 'plugins/ezoom/CMakeLists.txt'
--- plugins/ezoom/CMakeLists.txt	2012-05-16 17:40:27 +0000
+++ plugins/ezoom/CMakeLists.txt	2017-04-28 09:59:04 +0000
@@ -2,4 +2,4 @@
 
 include (CompizPlugin)
 
-compiz_plugin (ezoom PLUGINDEPS composite opengl mousepoll)
+compiz_plugin (ezoom PLUGINDEPS composite opengl mousepoll focuspoll)

=== modified file 'plugins/ezoom/ezoom.xml.in'
--- plugins/ezoom/ezoom.xml.in	2016-07-01 15:37:19 +0000
+++ plugins/ezoom/ezoom.xml.in	2017-04-28 09:59:04 +0000
@@ -7,6 +7,7 @@
 		<plugin>expo</plugin>
 		<plugin>decor</plugin>
 		<plugin>mousepoll</plugin>
+		<plugin>focuspoll</plugin>
 	    </relation>
 	    <relation type="before">
 		<plugin>staticswitcher</plugin>
@@ -15,6 +16,7 @@
 	    <requirement>
 		<plugin>opengl</plugin>
 		<plugin>mousepoll</plugin>
+		<plugin>focuspoll</plugin>
 	    </requirement>
 	</deps>
 	<_short>Enhanced Zoom Desktop</_short>
@@ -425,12 +427,17 @@
 		<_short>Focus Tracking</_short>
 		<option type="bool" name="follow_focus">
 		    <_short>Enable focus tracking</_short>
-		    <_long>Move the zoom area when focus changes.</_long>
+		    <_long>Move the zoom area when focus changes. You may see the focuspoll module options for more</_long>
 		    <default>true</default>
 		</option>
+		<option type="bool" name="follow_window_focus">
+		    <_short>Enable focus tracking when switching windows</_short>
+		    <_long>Move the zoom area to the center of a newly switched window.</_long>
+		    <default>false</default>
+		</option>
 		<option type="bool" name="focus_fit_window">
-		    <_short>Fit zoom level to window on focus change</_short>
-		    <_long>Fit the zoomed area to the window when the zoomed area moves as a result of focus tracking.</_long>
+		    <_short>Fit zoom level to newly switched window</_short>
+		    <_long>Fit the zoomed area to the window when it switches.</_long>
 		    <default>false</default>
 		</option>
 		<option type="float" name="autoscale_min">
@@ -443,16 +450,31 @@
 		</option>
 		<option type="bool" name="always_focus_fit_window">
 		    <_short>Always fit to window on focus track</_short>
-		    <_long>Fit the zoomed area to the window when the zoomed area moves as a result of focus tracking. Even when not initially zoomed in. </_long>
+		    <_long>Fit the zoomed area to the newly switched window, even when not initially zoomed in. </_long>
 		    <default>false</default>
 		</option>
 		<option type="int" name="follow_focus_delay">
-		    <_short>Follow Focus Delay</_short>
-		    <_long>Only attempt to center newly focused windows if the mouse hasn't moved in this amount of seconds. Use this to avoid jumping when using sloppy focus.</_long>
-		    <default>0</default>
+		    <_short>tracking delay between mouse/keyboard modes</_short>
+		    <_long>Only attempt to follow focus if the mouse hasn't moved in this amount of seconds. Use this to avoid jumping everywhere on the screen.</_long>
+		    <default>1</default>
 		    <min>0</min>
 		    <max>15</max>
 		</option>
+		<option type="bool" name="always_center_mouse">
+		    <_short>Keep Mouse centered inside zoom area</_short>
+		    <_long>If activated, the mouse will always be centered when in mouse sync mode, if not, it will move around the zoom area</_long>
+		    <default>true</default>
+		</option>
+		<option type="bool" name="restrain_zoom_to_screen">
+		    <_short>Restrain the zoom area inside the screen</_short>
+		    <_long>if enabled, zoom area will stay inside the screen, if not, zoom area can go over screen borders (it will show empty black space)</_long>
+		    <default>true</default>
+		</option>
+		<option type="bool" name="warp_mouse_to_focus">
+		    <_short>when switching focus back to mouse, warp mouse inside the zoomed area</_short>
+		    <_long>when following a keyboard focus, one can want the mouse to come back into the field of vision before moving it. avoids jumping to another part of the screen when switching mouse/keyboard focus.</_long>
+		    <default>true</default>
+		</option>
 	    </group>
 	    <group>
 		<_short>Animation</_short>
@@ -461,7 +483,7 @@
 		    <_long>Zoom Speed</_long>
 		    <default>25</default>
 		    <min>0.1</min>
-		    <max>100</max>
+		    <max>500</max>
 		    <precision>0.1</precision>
 		</option>
 		<option type="float" name="timestep">
@@ -472,6 +494,11 @@
 		    <max>50</max>
 		    <precision>0.1</precision>
 		</option>
+		<option type="bool" name="instant_pan">
+		    <_short>move the zoom area instantly</_short>
+		    <_long>when enabled, zoom area is warped instantly to focus position. When disabled, zoom area makes a smooth move to the focus position</_long>
+		    <default>false</default>
+		</option>
 	    </group>
 	</options>
     </plugin>

=== modified file 'plugins/ezoom/src/ezoom.cpp'
--- plugins/ezoom/src/ezoom.cpp	2016-07-01 15:37:19 +0000
+++ plugins/ezoom/src/ezoom.cpp	2017-04-28 09:59:04 +0000
@@ -76,7 +76,6 @@
 
 COMPIZ_PLUGIN_20090315 (ezoom, ZoomPluginVTable)
 
-
 /*
  * This toggles paint functions. We don't need to continually run code when we
  * are not doing anything.
@@ -573,18 +572,45 @@
 			int  y,
 			bool instant)
 {
+    setCenter (x, y, instant, false);
+}
+
+void
+EZoomScreen::setCenter (int x,
+			int y,
+			bool instant,
+			bool center)
+{
     int         out = screen->outputDeviceForPoint (x, y);
     CompOutput  *o  = &screen->outputDevs ().at (out);
 
     if (zooms.at (out).locked)
 	return;
 
-    zooms.at (out).xTranslate = (float)
-	((x - o->x1 ()) - o->width ()  / 2) / (o->width ());
-    zooms.at (out).yTranslate = (float)
-	((y - o->y1 ()) - o->height () / 2) / (o->height ());
-
-    if (instant)
+    // this correction allows constant centering of the mouse
+    float zoomCorrection = std::max(1.0f - zooms.at (out).newZoom, 0.1f);
+    if (!center) {
+	zoomCorrection = EZOOM_SCREEN_BORDER_OFFSET;
+    }
+
+    float zoom_x_inside = (float) (x - o->x1 () - o->width () / 2);
+    // We need the zoom correction to center the mouse in zoomarea
+    zoom_x_inside /= o->width () * zoomCorrection;
+    float zoom_y_inside = (float) (y - o->y1 () - o->height () / 2);
+    zoom_y_inside /= o->height () * zoomCorrection;
+
+    if (optionGetRestrainZoomToScreen ()) {
+        if (zoom_x_inside < -0.5f) { zoom_x_inside = -0.5f;}
+        if (zoom_x_inside > 0.5f) { zoom_x_inside = 0.5f;}
+        if (zoom_y_inside < -0.5f) { zoom_y_inside = -0.5f;}
+        if (zoom_y_inside > 0.5f) { zoom_y_inside = 0.5f;}
+    }
+
+    zooms.at (out).xTranslate = zoom_x_inside;
+    zooms.at (out).yTranslate = zoom_y_inside;
+
+
+    if (instant || optionGetInstantPan ())
     {
 	zooms.at (out).realXTranslate = zooms.at (out).xTranslate;
 	zooms.at (out).realYTranslate = zooms.at (out).yTranslate;
@@ -671,11 +697,23 @@
 void
 EZoomScreen::enableMousePolling ()
 {
-    pollHandle.start ();
-    lastChange = time(NULL);
+    pollMouseHandle.start ();
+    lastMouseChange = time (NULL);
     mouse      = MousePoller::getCurrentPosition ();
 }
 
+/* Enables polling of focus position */
+void
+EZoomScreen::enableFocusPolling ()
+{
+    if (!optionGetFollowFocus ())
+    {
+	return;
+    }
+    pollFocusHandle.start ();
+    lastFocusChange = time (NULL);
+}
+
 /* Sets the zoom (or scale) level.
  * Cleans up if we are suddenly zoomed out.
  */
@@ -690,9 +728,12 @@
 	value = 1.0f;
     else
     {
-	if (!pollHandle.active ())
+	if (!pollMouseHandle.active ())
 	    enableMousePolling ();
 
+	if (!pollFocusHandle.active ())
+	    enableFocusPolling ();
+
 	grabbed |= (1 << zooms.at (out).output);
 	cursorZoomActive (out);
     }
@@ -738,7 +779,7 @@
 {
     int out = screen->outputDeviceForPoint (mouse.x (), mouse.y ());
 
-    if (!isInMovement (out))
+    if (!isInMovement (out) || nonMouseFocusTracking)
 	return;
 
     CompOutput *o = &screen->outputDevs ().at (out);
@@ -1026,7 +1067,7 @@
 
     if (zooms.at (out).currentZoom == 1.0f)
     {
-	lastChange = time(NULL);
+	lastMouseChange = time (NULL);
 	mouse = MousePoller::getCurrentPosition ();
     }
 
@@ -1097,20 +1138,57 @@
 void
 EZoomScreen::updateMousePosition (const CompPoint &p)
 {
+    auto localTime = time (NULL);
     mouse.setX (p.x ());
     mouse.setY (p.y ());
 
     int out = screen->outputDeviceForPoint (mouse.x (), mouse.y ());
-    lastChange = time(NULL);
-
-    if (optionGetZoomMode () == EzoomOptions::ZoomModeSyncMouse &&
-	!isInMovement (out))
-	setCenter (mouse.x (), mouse.y (), true);
-
+
+    if (optionGetZoomMode () == EzoomOptions::ZoomModeSyncMouse && !isInMovement (out))
+    {
+	if (optionGetWarpMouseToFocus ()) {
+	    // mouse taking back control of focus
+	    if (lastMouseChange <= lastFocusChange) {
+		nonMouseFocusTracking = false;
+		screen->warpPointer (mouse.x (), mouse.y ());
+		restrainCursor (out);
+	    } else {
+		setCenter (mouse.x (), mouse.y (), true, optionGetAlwaysCenterMouse ());
+	    }
+	    lastMouseChange = localTime;
+	    // respect a timing in case user has merely grazed his mouse
+	} else if (localTime - lastFocusChange > optionGetFollowFocusDelay ()) {
+	    setCenter (mouse.x (), mouse.y (), true, optionGetAlwaysCenterMouse ());
+	    lastMouseChange = localTime;
+	}
+    }
     cursorMoved ();
     cScreen->damageScreen ();
 }
 
+void
+EZoomScreen::updateFocusPosition (const CompRect &rect)
+{
+    auto localTime = time (NULL);
+    int out = screen->outputDeviceForPoint (rect.x (), rect.y ());
+    if (localTime - lastMouseChange > optionGetFollowFocusDelay ()) {
+	int zoom_area_width  = screen->outputDevs ().at (out).width ()  * zooms.at (out).currentZoom;
+	int zoom_area_height = screen->outputDevs ().at (out).height () * zooms.at (out).currentZoom;
+	int pos_x = rect.x ()+ rect.width () / 2;
+	int pos_y = rect.y () + rect.height () / 2;
+	if (rect.width () > zoom_area_width) { // corrects a too big target, aims at top-left corner
+	    pos_x -= (rect.width () - zoom_area_width) / 2;
+	}
+	if (rect.height () > zoom_area_height) {
+	    pos_y -= (rect.height () - zoom_area_height) / 2;
+	}
+	setCenter (pos_x, pos_y, false, true);
+	nonMouseFocusTracking = true;
+	lastFocusChange = localTime;
+    }
+    cScreen->damageScreen ();
+}
+
 /* Timeout handler to poll the mouse. Returns false (and thereby does not
  * get re-added to the queue) when zoom is not active. */
 void
@@ -1122,11 +1200,21 @@
     {
 	cursorMoved ();
 
-	if (pollHandle.active ())
-	    pollHandle.stop ();
+	if (pollMouseHandle.active ())
+	    pollMouseHandle.stop ();
     }
 }
 
+/* Timeout handler to focusPoll. */
+void
+EZoomScreen::updateFocusInterval (const CompRect &rect)
+{
+    updateFocusPosition (rect);
+
+	if (!grabbed && pollFocusHandle.active ())
+	    pollFocusHandle.stop ();
+}
+
 /* Free a cursor */
 void
 EZoomScreen::freeCursor (CursorTexture *cursor)
@@ -1878,8 +1966,8 @@
 
     if (w == NULL						||
 	w->id () == screen->activeWindow ()			||
-	time(NULL) - lastChange < optionGetFollowFocusDelay ()	||
-	!optionGetFollowFocus ())
+	time (NULL) - lastMouseChange < optionGetFollowFocusDelay ()	||
+	!optionGetFollowWindowFocus ())
 	return;
 
     int out = screen->outputDeviceForGeometry (w->geometry ());
@@ -1972,7 +2060,9 @@
     gScreen (GLScreen::get (screen)),
     grabbed (0),
     grabIndex (0),
-    lastChange (0),
+    lastMouseChange (0),
+    lastFocusChange (0),
+    nonMouseFocusTracking (false),
     cursorInfoSelected (false),
     cursorHidden (false)
 {
@@ -2006,8 +2096,10 @@
 	zooms.push_back (za);
     }
 
-    pollHandle.setCallback (boost::bind (
-				&EZoomScreen::updateMouseInterval, this, _1));
+    pollMouseHandle.setCallback (boost::bind(&EZoomScreen::updateMouseInterval,
+					     this, _1));
+    pollFocusHandle.setCallback (boost::bind(&EZoomScreen::updateFocusInterval,
+					     this, _1));
 
     optionSetZoomInButtonInitiate (boost::bind (&EZoomScreen::zoomIn, this, _1,
 						_2, _3));
@@ -2100,8 +2192,10 @@
 
 EZoomScreen::~EZoomScreen ()
 {
-    if (pollHandle.active ())
-	pollHandle.stop ();
+    if (pollMouseHandle.active ())
+	pollMouseHandle.stop ();
+    if (pollFocusHandle.active ())
+	pollFocusHandle.stop ();
 
     if (zooms.size ())
 	zooms.clear ();
@@ -2116,7 +2210,8 @@
     if (CompPlugin::checkPluginABI ("core", CORE_ABIVERSION)		&&
 	CompPlugin::checkPluginABI ("composite", COMPIZ_COMPOSITE_ABI)	&&
 	CompPlugin::checkPluginABI ("opengl", COMPIZ_OPENGL_ABI)	&&
-	CompPlugin::checkPluginABI ("mousepoll", COMPIZ_MOUSEPOLL_ABI))
+	CompPlugin::checkPluginABI ("mousepoll", COMPIZ_MOUSEPOLL_ABI) &&
+	CompPlugin::checkPluginABI ("focuspoll", COMPIZ_FOCUSPOLL_ABI))
 	return true;
 
     return false;

=== modified file 'plugins/ezoom/src/ezoom.h'
--- plugins/ezoom/src/ezoom.h	2016-07-01 15:37:19 +0000
+++ plugins/ezoom/src/ezoom.h	2017-04-28 09:59:04 +0000
@@ -43,12 +43,15 @@
 #include <composite/composite.h>
 #include <opengl/opengl.h>
 #include <mousepoll/mousepoll.h>
+#include <focuspoll/focuspoll.h>
 
 
 #include "ezoom_options.h"
 
 #include <cmath>
 
+#define EZOOM_SCREEN_BORDER_OFFSET 0.92
+
 enum SpecificZoomTarget
 {
     ZoomTarget1 = 0,
@@ -169,16 +172,19 @@
 	CompPoint              mouse; // we get this from mousepoll
 	unsigned long int      grabbed;
 	CompScreen::GrabHandle grabIndex; // for zoomBox
-	time_t                 lastChange;
+	time_t                 lastMouseChange;
+	time_t                 lastFocusChange;
 	CursorTexture          cursor;	// the texture for the faux-cursor
 					// we paint to do fake input
 					// handling
+	bool                   nonMouseFocusTracking;
 	bool                   cursorInfoSelected;
 	bool                   cursorHidden;
 	CompRect               box;
 	CompPoint              clickPos;
 
-	MousePoller            pollHandle; // mouse poller object
+	MousePoller            pollMouseHandle; // mouse poller object
+	FocusPoller            pollFocusHandle; // focus poller object
 
      private:
 
@@ -231,6 +237,11 @@
 	setCenter (int  x,
 		   int  y,
 		   bool instant);
+	void
+	setCenter (int x,
+		   int y,
+		   bool instant,
+		   bool center);
 
 	void
 	setZoomArea (int  x,
@@ -250,6 +261,9 @@
 	enableMousePolling ();
 
 	void
+	enableFocusPolling ();
+
+	void
 	setScale (int   out,
 		  float value);
 
@@ -295,6 +309,12 @@
 	void
 	updateMouseInterval (const CompPoint &p);
 
+	void
+	updateFocusPosition (const CompRect &retc);
+
+	void
+	updateFocusInterval (const CompRect &rect);
+
 	/* Make dtor */
 	void
 	freeCursor (CursorTexture * cursor);

=== added directory 'plugins/focuspoll'
=== added file 'plugins/focuspoll/CMakeLists.txt'
--- plugins/focuspoll/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/focuspoll/CMakeLists.txt	2017-04-28 09:59:04 +0000
@@ -0,0 +1,9 @@
+find_package (Compiz REQUIRED)
+
+include (CompizPlugin)
+include_directories (include/accessibilitywatcher)
+
+pkg_search_module( ATSPI REQUIRED atspi-2 )
+
+compiz_plugin (focuspoll PKGDEPS atspi-2 )
+

=== added file 'plugins/focuspoll/compiz-focuspoll.pc.in'
--- plugins/focuspoll/compiz-focuspoll.pc.in	1970-01-01 00:00:00 +0000
+++ plugins/focuspoll/compiz-focuspoll.pc.in	2017-04-28 09:59:04 +0000
@@ -0,0 +1,12 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: compiz-focuspoll
+Description: Focuspoll plugin for compiz
+Version: @VERSION@
+
+Requires: compiz
+Libs: -L${libdir}/compiz -lfocuspoll
+Cflags: @COMPIZ_CFLAGS@ -I${includedir}/compiz

=== added file 'plugins/focuspoll/focuspoll.xml.in'
--- plugins/focuspoll/focuspoll.xml.in	1970-01-01 00:00:00 +0000
+++ plugins/focuspoll/focuspoll.xml.in	2017-04-28 09:59:04 +0000
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<compiz>
+    <plugin name="focuspoll" useBcop="true">
+	<_short>Focus position polling</_short>
+	<_long>Updates the focus pointer position from the accessibility library AT-SPI through dbus</_long>
+	<category>Utility</category>
+	<options>
+	    <_short>Misc</_short>
+		<option type="bool" name="track_components">
+		    <_short>track movement of components (like a menu, label, or button)</_short>
+		    <_long>if enabled, focuspoll will track the movements of every component able to provide focus.</_long>
+		    <default>true</default>
+		</option>
+		<option type="bool" name="track_caret">
+		    <_short>track movement of the caret (the cursor in text)</_short>
+		    <_long>if enabled, focuspoll will track the movements of the caret.</_long>
+		    <default>true</default>
+		</option>
+		<option type="bool" name="ignore_links">
+		    <_short>ignores link focuses</_short>
+		    <_long>if enabled, focuspoll will not track the focus events of link items</_long>
+		    <default>true</default>
+		</option>
+		<option type="int" name="focus_poll_interval">
+		    <_short>Focus Poll Interval</_short>
+		    <_long>How often to poll DBus for focus changes, in milliseconds. Reduce this to reduce choppy behavior.</_long>
+		    <default>10</default>
+		    <min>1</min>
+		    <max>500</max>
+		</option>
+	</options>
+    </plugin>
+</compiz>
+

=== added directory 'plugins/focuspoll/include'
=== added directory 'plugins/focuspoll/include/accessibilitywatcher'
=== added file 'plugins/focuspoll/include/accessibilitywatcher/accessibilitywatcher.h'
--- plugins/focuspoll/include/accessibilitywatcher/accessibilitywatcher.h	1970-01-01 00:00:00 +0000
+++ plugins/focuspoll/include/accessibilitywatcher/accessibilitywatcher.h	2017-04-28 09:59:04 +0000
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2016 Auboyneau Vincent <[e-mail]>
+ *
+ *   This file is part of compiz.
+ *
+ *   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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef ACCESSIBILITY_WATCHER_H
+#define ACCESSIBILITY_WATCHER_H
+
+#include <deque>
+#include <vector>
+
+#include "focusinfo.h"
+
+#include <atspi/atspi.h>
+
+class AccessibilityWatcher {
+    public:
+	~AccessibilityWatcher();
+	static AccessibilityWatcher* getInstance();
+
+	void init();
+	void quit();
+
+	void setIgnoreLinks(bool);
+	void setScreenLimits(int, int);
+	int getScreenWidth();
+	int getScreenHeight();
+
+	std::deque<FocusInfo> getFocusQueue();
+	void resetFocusQueue();
+	bool returnToPrevMenu();
+
+    private:
+	AccessibilityWatcher();
+	static AccessibilityWatcher* instance;
+
+	bool initialized;
+	int screenWidth;
+	int screenHeight;
+	static bool ignoreLinks;
+	std::deque<FocusInfo> focusList;
+	std::vector<FocusInfo> previouslyActiveMenus;
+
+	AtspiEventListener *focusListener;
+	AtspiEventListener *caretMoveListener;
+	AtspiEventListener *selectedListener;
+	AtspiEventListener *descendantChangedListener;
+
+	void addWatches();
+	void removeWatches();
+
+	static std::string getLabel(AtspiAccessible *accessible);
+	const static gchar* atspiStateGetName (gint state);
+	static std::string getStateSet (AtspiAccessible *accessible);
+
+	static void registerEvent(const AtspiEvent *event, const std::string& type);
+	static bool appSpecificFilter(FocusInfo& focusInfo, const AtspiEvent* event);
+	static bool filterBadEvents(const FocusInfo& event);
+	static void getAlternativeCaret(FocusInfo& focus, const AtspiEvent* event);
+
+	static void onFocus(const AtspiEvent *event, void *data);
+	static void onSelectedChange(const AtspiEvent *event, void *data);
+	static void onCaretMove(const AtspiEvent *event, void *data);
+	static void onDescendantChanged(const AtspiEvent *event, void *data);
+
+};
+
+#endif

=== added file 'plugins/focuspoll/include/accessibilitywatcher/focusinfo.h'
--- plugins/focuspoll/include/accessibilitywatcher/focusinfo.h	1970-01-01 00:00:00 +0000
+++ plugins/focuspoll/include/accessibilitywatcher/focusinfo.h	2017-04-28 09:59:04 +0000
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2016 Auboyneau Vincent <[e-mail]>
+ *
+ *   This file is part of compiz.
+ *
+ *   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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef FOCUS_INFO_H
+#define FOCUS_INFO_H
+
+#include <tuple>
+#include <string>
+#include <sstream>
+
+
+class FocusInfo {
+    public:
+
+	FocusInfo(const std::string& type,
+		  const std::string& name,
+		  const std::string& label,
+		  const std::string& role,
+		  const std::string& application,
+		  int x,
+		  int y,
+		  int width,
+		  int height);
+
+	FocusInfo(const std::string& type,
+		  const std::string& name,
+		  const std::string& label,
+		  const std::string& role,
+		  const std::string& application);
+
+	FocusInfo();
+
+	int x, y, w, h;
+	int xAlt, yAlt, wAlt, hAlt;
+	std::string type;
+	std::string name;
+	std::string label;
+	std::string role;
+	std::string application;
+
+	// AT-SPI events that are interesting to know about the event
+	bool enabled;
+	bool active;
+	bool focusable;
+	bool focused;
+	bool selected;
+	bool showing;
+	bool visible;
+
+	std::string getType();
+	std::string summary();
+	std::tuple<int, int> getPosition();
+	std::tuple<int, int> getSize();
+	std::tuple<int, int, int, int> getBBox();
+
+	bool operator== (const FocusInfo& other) const;
+	bool operator!= (const FocusInfo& other) const;
+};
+
+#endif

=== added directory 'plugins/focuspoll/include/focuspoll'
=== added file 'plugins/focuspoll/include/focuspoll/focuspoll.h'
--- plugins/focuspoll/include/focuspoll/focuspoll.h	1970-01-01 00:00:00 +0000
+++ plugins/focuspoll/include/focuspoll/focuspoll.h	2017-04-28 09:59:04 +0000
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2016 Auboyneau Vincent <[e-mail]>
+ *
+ *   This file is part of compiz.
+ *
+ *   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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _COMPIZ_FOCUSPOLL_H
+#define _COMPIZ_FOCUSPOLL_H
+
+#define COMPIZ_FOCUSPOLL_ABI 1
+
+#include <boost/function.hpp>
+#include <core/rect.h>
+#include <accessibilitywatcher/focusinfo.h>
+
+class FocusPoller
+{
+    public:
+	typedef boost::function<void(const CompRect &)> CallBack;
+
+	FocusPoller ();
+	~FocusPoller ();
+
+	void setCallback (CallBack callback);
+	void start ();
+	void stop ();
+	bool active ();
+
+    private:
+	bool mActive;
+	CallBack mCallback;
+	CompRect focusRect;
+
+	friend class FocuspollScreen;
+};
+
+#endif

=== added directory 'plugins/focuspoll/src'
=== added file 'plugins/focuspoll/src/accessibilitywatcher.cpp'
--- plugins/focuspoll/src/accessibilitywatcher.cpp	1970-01-01 00:00:00 +0000
+++ plugins/focuspoll/src/accessibilitywatcher.cpp	2017-04-28 09:59:04 +0000
@@ -0,0 +1,506 @@
+/*
+ * Copyright (C) 2016 Auboyneau Vincent <[e-mail]>
+ *
+ *   This file is part of compiz.
+ *
+ *   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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <iostream>
+#include <functional>
+
+#include <boost/mem_fn.hpp>
+#include <boost/bind.hpp>
+#include <boost/function.hpp>
+
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "accessibilitywatcher.h"
+
+namespace {
+const int A11YWATCHER_MAX_CARET_WIDTH = 50;
+const int A11YWATCHER_MAX_CARET_HEIGHT = 70;
+}
+
+AccessibilityWatcher* AccessibilityWatcher::instance = NULL;
+bool AccessibilityWatcher::ignoreLinks = false;
+
+AccessibilityWatcher::AccessibilityWatcher() :
+	initialized(false),
+	screenWidth(0),
+	screenHeight(0)
+{
+}
+
+AccessibilityWatcher::~AccessibilityWatcher() {
+    quit();
+};
+
+AccessibilityWatcher *AccessibilityWatcher::getInstance () {
+    if (instance == NULL)
+    {
+	instance = new AccessibilityWatcher();
+    }
+    return instance;
+}
+
+std::string AccessibilityWatcher::getLabel(AtspiAccessible *accessible) {
+    GArray *relations = atspi_accessible_get_relation_set (accessible, NULL);
+    if (relations == NULL)
+    {
+	return "";
+    }
+
+    AtspiRelation *relation;
+    for (unsigned i = 0; i < relations->len; ++i) {
+	relation = g_array_index (relations, AtspiRelation*, i);
+	if (atspi_relation_get_relation_type (relation) == ATSPI_RELATION_LABELLED_BY)
+	{
+	    g_array_free (relations, true);
+	    g_object_unref(relations);
+	    auto res_label = atspi_accessible_get_name(atspi_relation_get_target(relation, 0), NULL);
+	    g_object_unref(relation);
+	    return (res_label == NULL) ? "" : res_label;
+	}
+    }
+    if (relations->len > 0)
+    {
+	g_object_unref(relations);
+    }
+    return "";
+}
+
+void AccessibilityWatcher::setIgnoreLinks(bool val) {
+    ignoreLinks = val;
+}
+
+void AccessibilityWatcher::setScreenLimits(int x, int y) {
+	screenWidth = x;
+	screenHeight = y;
+}
+
+int AccessibilityWatcher::getScreenWidth () {
+    return screenWidth;
+}
+
+int AccessibilityWatcher::getScreenHeight () {
+    return screenHeight;
+}
+
+void AccessibilityWatcher::registerEvent(const AtspiEvent *event, const std::string &type) {
+	// type is registered from filter on calling event
+	FocusInfo res(type,
+			atspi_accessible_get_name (event->source, NULL),
+			getLabel (event->source),
+			atspi_accessible_get_role_name (event->source, NULL),
+			atspi_accessible_get_name(atspi_accessible_get_application (event->source, NULL), NULL));
+
+	if (!res.active)
+	{
+		// prevents skipping events that are not designated as active. we check the parent.
+		auto parent = atspi_accessible_get_parent(event->source, NULL);
+		while (!res.active && parent) {
+			auto stateSet = atspi_accessible_get_state_set (child);
+			if (atspi_state_set_contains(stateSet, ATSPI_STATE_ACTIVE))
+			{
+				res.active = true;
+			}
+			g_object_unref(stateSet);
+			g_object_unref(parent);
+			child = atspi_accessible_get_parent(child, NULL);
+		}
+		g_object_unref(parent);
+	}
+
+    AtspiComponent* component;
+    if (res.type == "active-descendant-changed")
+	{
+        auto accessible = atspi_accessible_get_child_at_index(event->source, event->detail1, NULL);
+        component = atspi_accessible_get_component(accessible);
+		g_object_unref(accessible);
+    } else {
+        component = atspi_accessible_get_component(event->source);
+    }
+
+    if (component)
+	{
+        AtspiRect* size = atspi_component_get_extents(component, ATSPI_COORD_TYPE_SCREEN, NULL);
+        res.x = size->x;
+        res.y = size->y;
+        res.w = size->width;
+        res.h = size->height;
+		g_object_unref(component);
+    }
+    // let's get the caret offset, and then its position for a caret event
+    if (type == "caret")
+	{
+        auto text = atspi_accessible_get_text(event->source);
+        if (!text)
+		{
+            return;
+        }
+        auto offset = atspi_text_get_caret_offset(text, NULL);
+		// if we're at the beginning of text, let the widget pos decide
+        if (event->detail1)
+		{
+            AtspiRect *size = atspi_text_get_character_extents(text, offset, ATSPI_COORD_TYPE_SCREEN, NULL);
+            res.x = size->x;
+            res.y = size->y;
+            res.w = size->width;
+            res.h = size->height;
+        }
+		// correcting a missing offset to a caret move event in firefox
+		if (res.x == 0 && res.y == 0 && offset > 0)
+		{
+            AtspiRect *size = atspi_text_get_character_extents(text, offset-1, ATSPI_COORD_TYPE_SCREEN, NULL);
+            res.x = size->x;
+            res.y = size->y;
+            res.w = size->width;
+            res.h = size->height;
+        }
+		// when result is obviously not a caret size
+        if (strcmp(event->type, "object:text-caret-moved") == 0 && (res.w > A11YWATCHER_MAX_CARET_WIDTH || res.h > A11YWATCHER_MAX_CARET_HEIGHT))
+		{
+            AtspiRect *size = atspi_text_get_character_extents(text, offset, ATSPI_COORD_TYPE_SCREEN, NULL);
+            res.x = size->x;
+            res.y = size->y;
+            res.w = size->width;
+            res.h = size->height;
+            if (type == "caret" && strcmp(event->type, "object:text-caret-moved") == 0 && (res.w > A11YWATCHER_MAX_CARET_WIDTH || res.h > A11YWATCHER_MAX_CARET_HEIGHT))
+			{
+                res.x = 0;
+                res.y = 0;
+            }
+        }
+		g_object_unref(text);
+
+		// still no offset, it's probably a newline and we're at bugzilla #1319273 (with new paragraph obj)
+        if (res.x == 0 && res.y == 0 &&
+				(strcmp(event->type, "object:text-changed:insert") == 0 ||
+				 strcmp(event->type, "object:text-changed:removed") == 0 ||
+				 strcmp(event->type, "object:text-caret-moved") == 0)) {
+            res.x = res.xAlt;
+            res.y = res.yAlt;
+            res.w = res.wAlt;
+            res.h = res.hAlt;
+        }
+    }
+
+    // getting the states on event
+    auto stateSet = atspi_accessible_get_state_set (event->source);
+    if (atspi_state_set_contains(stateSet, ATSPI_STATE_FOCUSED))
+	{
+        res.focused = true;
+        AccessibilityWatcher::getInstance()->previouslyActiveMenus.clear(); // reset potential menu stack
+    }
+    if (atspi_state_set_contains(stateSet, ATSPI_STATE_SELECTED))
+	{ // never works, GTK Bad implem?
+        res.selected = true;
+    }
+    if (res.type == "state-changed:selected" && event->detail1 == 1)
+	{
+        res.selected = true;
+        AccessibilityWatcher::getInstance()->previouslyActiveMenus.push_back(res); // add to stack of menus
+    }
+
+    if (appSpecificFilter(res, event))
+	{
+        return;
+    }
+    if (filterBadEvents(res))
+	{
+        return;
+    }
+    while (AccessibilityWatcher::getInstance()->focusList.size() >= 5) { // don't keep the whole history
+        AccessibilityWatcher::getInstance()->focusList.erase(AccessibilityWatcher::getInstance()->focusList.begin());
+    }
+    AccessibilityWatcher::getInstance()->focusList.push_back(res);
+}
+
+bool AccessibilityWatcher::appSpecificFilter(FocusInfo& focus, const AtspiEvent* event)
+{
+    if (focus.type == "state-changed:selected" && // emulates on-change:selected false behaviour. eg: for menus
+       (focus.role == "menu item" ||
+        focus.role == "menu" ||
+        focus.role == "check menu item" ||
+        focus.role == "radio menu item") &&
+        focus.application != "mate-panel")
+    {
+        if (!focus.selected && AccessibilityWatcher::getInstance()->returnToPrevMenu())
+		{
+            return true;
+        }
+        focus.active = true;
+    }
+    if (focus.application == "soffice" && focus.role == "paragraph")
+	{ // LO-calc: avoid spam event from main edit line
+        auto parent = atspi_accessible_get_parent(event->source, NULL);
+        std::string parentLabel = atspi_accessible_get_name(parent, NULL);
+        if (parentLabel == "Input line" ||
+            parentLabel == "Ligne de saisie") {
+            return true;
+        }
+    }
+    if (focus.application == "Icedove" || focus.application == "Thunderbird")
+	{
+        if (focus.type == "caret")
+		{
+            auto text = atspi_accessible_get_text(event->source); // next if deals with a special newline char, that remained buggy. hypra issue #430
+            auto offset = atspi_text_get_caret_offset(text, NULL);
+            auto string = std::string(atspi_text_get_text_at_offset(text, offset, ATSPI_TEXT_BOUNDARY_CHAR, NULL)->content);
+            auto stringM1 = std::string(atspi_text_get_text_at_offset(text, offset -1, ATSPI_TEXT_BOUNDARY_CHAR, NULL)->content);
+            if (offset == atspi_text_get_character_count(text, NULL) && string == "\0" && (stringM1 == "\n" || int(stringM1.c_str()[0]) == -17))
+			{
+                getAlternativeCaret(focus, event);
+                focus.x = focus.xAlt;
+                focus.y = focus.yAlt + focus.hAlt;
+                focus.w = focus.wAlt;
+                focus.h = focus.hAlt;
+            }
+            if (!(focus.x == 0 && focus.y == 0))
+			{ // prevents compose window loss of tracking in HTML mode (active flag ok, but no focused flag)
+                AccessibilityWatcher::getInstance()->focusList.push_back(focus);
+                return true;
+            }
+            auto component = atspi_accessible_get_component(event->source);
+            if (component)
+			{
+                AtspiRect* size = atspi_component_get_extents(component, ATSPI_COORD_TYPE_SCREEN, NULL);
+                focus.x = size->x;
+                focus.y = size->y;
+                focus.w = 7;
+                focus.h = size->height;
+                AccessibilityWatcher::getInstance()->focusList.push_back(focus);
+                return true;
+            }
+        }
+    }
+    if (focus.application == "Firefox")
+	{
+        if (ignoreLinks && focus.type != "caret" && focus.role == "link")
+		{
+            return true;
+        }
+        if (focus.type == "caret" &&
+           (static_cast<std::string>(event->type) == "object:text-changed:insert:system" ||
+            static_cast<std::string>(event->type) == "object:text-changed:delete:system")) { // prevents status bar focus in firefox
+            return true;
+        }
+        if (focus.type == "focus" && focus.role == "document frame")
+		{ // general page parasite event
+			return true;
+		}
+		if (focus.type == "caret" && !(focus.x == 0 && focus.y == 0))
+		{
+            AccessibilityWatcher::getInstance()->focusList.push_back(focus);
+            return true;
+        }
+        getAlternativeCaret(focus, event);
+        if (focus.type == "caret" && !(focus.xAlt == 0 && focus.yAlt == 0))
+		{
+            focus.x = focus.xAlt;
+            focus.y = focus.yAlt + focus.hAlt;
+            focus.w = focus.wAlt;
+            focus.h = focus.hAlt;
+            AccessibilityWatcher::getInstance()->focusList.push_back(focus);
+            return true;
+        }
+    }
+    if (focus.application == "evince" && focus.type == "state-changed:selected" && focus.role == "icon")
+	{ // LO-calc: avoid spam event from main edit line
+        return true; // ignores the parasite event from evince icon
+    }
+    return false;
+}
+
+bool AccessibilityWatcher::filterBadEvents(const FocusInfo& event) {
+    if (event.type == "caret" && event.x ==0 && event.y == 0)
+	{
+        return true;
+    }
+    if (!event.active)
+	{
+        return true;
+    }
+    if (!event.focused && !event.selected)
+	{
+        return true;
+    }
+    if (AccessibilityWatcher::getInstance()->getScreenWidth() != 0 && AccessibilityWatcher::getInstance()->getScreenHeight() !=0 &&
+        (event.x > AccessibilityWatcher::getInstance()->getScreenWidth() ||
+        event.y > AccessibilityWatcher::getInstance()->getScreenHeight() || // TODO remove when non-singleton
+        event.x < 0 ||
+        event.y < 0 )) {
+        return true;
+    }
+    return false;
+}
+
+/*
+ * this is meant to emulate the missing "selected" argument in menu hierarchy.
+ * no idea whether this is a fail in GTK, or in ATSPI
+ */
+bool AccessibilityWatcher::returnToPrevMenu() {
+        if (previouslyActiveMenus.size() > 1)
+		{
+            previouslyActiveMenus.pop_back();
+            focusList.push_back(previouslyActiveMenus.back());
+            return true;
+        }
+        return false;
+}
+
+/*
+ * Tries to extrapolate a missing caret position from other text characters.
+ * is used as last resort when application doesn't respect at-spi standarts,
+ * or at-spi bugs.
+ */
+void AccessibilityWatcher::getAlternativeCaret(FocusInfo& focus, const AtspiEvent* event) {
+    auto text = atspi_accessible_get_text(event->source);
+    if (!text) { return; }
+    auto offset = atspi_text_get_caret_offset(text, NULL);
+    auto caretChar = std::string(atspi_text_get_string_at_offset(text, offset, ATSPI_TEXT_GRANULARITY_CHAR, NULL)->content);
+    bool hasSeenDeviceControl1 = false;
+
+	// if we're at a newline, sometimes at-spi isn't giving us a caret position. unknown bug in some apps.
+    if (caretChar == "\n" || caretChar == "\0")
+	{
+		// gives the last empty line the right focus.
+        int lines = atspi_text_get_character_count(text, NULL) == offset ? 1 : 0;
+        int charIndex = 1;
+        bool charExtentsFound = false;
+
+        AtspiRect *size = atspi_text_get_character_extents(text, offset, ATSPI_COORD_TYPE_SCREEN, NULL);
+		// try and find the character on upper line to extrapolate position from. no more that 300 char, we risk lag.
+        while (!charExtentsFound && charIndex <= offset && charIndex < 300) {
+            size = atspi_text_get_character_extents(text, offset - charIndex, ATSPI_COORD_TYPE_SCREEN, NULL);
+            caretChar = atspi_text_get_string_at_offset(text, offset - charIndex, ATSPI_TEXT_GRANULARITY_CHAR, NULL)->content;
+			// if we found a caret, check we're at beginning of line (or of text) to extrapolate position
+            if ((size->x != 0 || size->y != 0) && int(caretChar[0]) != -17)
+			{
+                if (offset - charIndex -1 >= 0 && std::string(atspi_text_get_string_at_offset(text, offset - charIndex -1, ATSPI_TEXT_GRANULARITY_CHAR, NULL)->content) == "\n")
+				{
+                    charExtentsFound = true; // first character of upper line has been found
+                }
+				else if (offset - charIndex -1 == 0)
+				{
+                    size = atspi_text_get_character_extents(text, 0, ATSPI_COORD_TYPE_SCREEN, NULL);
+					// first character of upper line has been found
+                    charExtentsFound = true;
+                }
+            }
+			else if (caretChar == "\n" || int(caretChar[0]) == -17)
+			{
+                ++lines;
+            }
+            if (!hasSeenDeviceControl1 && int(caretChar[0]) == -17 )
+			{
+                hasSeenDeviceControl1 = true;
+            }
+            ++charIndex;
+        }
+        if (!hasSeenDeviceControl1)
+		{
+            lines--;
+        }
+        focus.xAlt = size->x;
+        focus.yAlt = size->y + (lines-1) * size->height;
+        focus.wAlt = size->width;
+        focus.hAlt = size->height;
+    }
+}
+
+
+void AccessibilityWatcher::onCaretMove (const AtspiEvent *event, void *data) {
+    registerEvent(event, "caret");
+}
+
+void AccessibilityWatcher::onSelectedChange (const AtspiEvent *event, void *data) {
+    registerEvent(event, "state-changed:selected");
+}
+
+void AccessibilityWatcher::onFocus (const AtspiEvent *event, void *data) {
+    /* We only care about focus/selection gain
+     * there's no detail1 on focus loss in AT-SPI specs */
+    if (!event->detail1) {return;}
+
+    registerEvent(event, "focus");
+}
+
+void AccessibilityWatcher::onDescendantChanged (const AtspiEvent *event, void *data) {
+    registerEvent(event, "active-descendant-changed");
+}
+
+/* Register to events */
+void AccessibilityWatcher::addWatches() {
+
+	//auto callback = boost::bind (&AccessibilityWatcher::onFocus, this, _1, _2);
+	//auto bound_fn = boost::bind<void>( boost::mem_fn(&AccessibilityWatcher::onFocus), this, _1, _2);
+	//auto bound_fn = boost::bind( &AccessibilityWatcher::onFocus, this, _1, _2);
+	//boost::function<void (const AtspiEvent *event, void *data)> callback(functor, this);
+
+
+	//std::function<void (AtspiEvent*, void*)> bound_fn = std::bind(&AccessibilityWatcher::onFocus, this, std::placeholders::_1, std::placeholders::_2);
+	//using sig = void (AtspiEvent*, void*);
+	//using tamere = std::function<sig>;
+	//AtspiEventListenerCB bound_fn = std::bind(&AccessibilityWatcher::onFocus, this, std::placeholders::_1, std::placeholders::_2);
+    //focusListener = atspi_event_listener_new (reinterpret_cast<AtspiEventListenerCB>(bound_fn), NULL, NULL);
+
+    focusListener = atspi_event_listener_new (reinterpret_cast<AtspiEventListenerCB>(onFocus), NULL, NULL);
+    caretMoveListener = atspi_event_listener_new (reinterpret_cast<AtspiEventListenerCB>(onCaretMove), NULL, NULL);
+    selectedListener = atspi_event_listener_new (reinterpret_cast<AtspiEventListenerCB>(onSelectedChange), NULL, NULL);
+    descendantChangedListener = atspi_event_listener_new (reinterpret_cast<AtspiEventListenerCB>(onDescendantChanged), NULL, NULL);
+
+    atspi_event_listener_register (focusListener, "object:state-changed:focused", NULL);
+    atspi_event_listener_register (caretMoveListener, "object:text-caret-moved", NULL);
+    atspi_event_listener_register (caretMoveListener, "object:text-changed:inserted", NULL);
+    atspi_event_listener_register (caretMoveListener, "object:text-changed:removed", NULL);
+    atspi_event_listener_register (selectedListener, "object:state-changed:selected", NULL);
+    atspi_event_listener_register (descendantChangedListener, "object:active-descendant-changed", NULL);
+}
+
+void AccessibilityWatcher::removeWatches() {
+    atspi_event_listener_deregister (focusListener, "object:state-changed:focused", NULL);
+    atspi_event_listener_deregister (caretMoveListener, "object:text-caret-moved", NULL);
+    atspi_event_listener_deregister (caretMoveListener, "object:text-changed:inserted", NULL);
+    atspi_event_listener_deregister (caretMoveListener, "object:text-changed:removed", NULL);
+    atspi_event_listener_deregister (selectedListener, "object:state-changed:selected", NULL);
+    atspi_event_listener_deregister (descendantChangedListener, "object:active-descendant-changed", NULL);
+}
+
+void AccessibilityWatcher::init() {
+    if (initialized) { return; }
+
+    atspi_init ();
+    atspi_set_main_context(g_main_context_default());
+    addWatches();
+
+    initialized = true;
+}
+
+void AccessibilityWatcher::quit() {
+    removeWatches();
+    initialized = false;
+}
+
+std::deque<FocusInfo> AccessibilityWatcher::getFocusQueue() {
+    return focusList;
+}
+
+void AccessibilityWatcher::resetFocusQueue() {
+    focusList.clear();
+}
+

=== added file 'plugins/focuspoll/src/focuspoll.cpp'
--- plugins/focuspoll/src/focuspoll.cpp	1970-01-01 00:00:00 +0000
+++ plugins/focuspoll/src/focuspoll.cpp	2017-04-28 09:59:04 +0000
@@ -0,0 +1,220 @@
+/*
+ * Copyright (C) 2016 Auboyneau Vincent <[e-mail]>
+ *
+ *   This file is part of compiz.
+ *
+ *   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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "private.h"
+#include <iostream>
+
+COMPIZ_PLUGIN_20090315 (focuspoll, FocuspollPluginVTable);
+
+bool
+FocuspollScreen::updatePosition ()
+{
+    if (!a11ywatcher->getFocusQueue().empty()) {
+	int focusX, focusY, focusW, focusH;
+	std::tie(focusX, focusY, focusW, focusH) = a11ywatcher->getFocusQueue().back().getBBox();
+	focusRect = CompRect(focusX, focusY, focusW, focusH);
+	// for (auto poller : pollers) segfaults at focuspoller.stop, reverting TODO
+	for (std::list<FocusPoller *>::iterator it = pollers.begin (); it != pollers.end ();) {
+	    FocusPoller *poller = *it;
+	    ++it;
+
+	    poller->mCallback(focusRect);
+	}
+    }
+    a11ywatcher->resetFocusQueue();
+    return true;
+}
+
+bool
+FocuspollScreen::addTimer (FocusPoller *poller)
+{
+    bool start = pollers.empty ();
+
+    std::list<FocusPoller *>::iterator it =
+	std::find (pollers.begin (), pollers.end (), poller);
+
+    if (it != pollers.end ())
+	return false;
+
+    pollers.insert (it, poller);
+
+    if (start)
+    {
+	//focusHasMoved();
+	timer.start();
+    }
+
+    return true;
+}
+
+void
+FocuspollScreen::removeTimer (FocusPoller *poller)
+{
+    std::list<FocusPoller *>::iterator it =
+	std::find (pollers.begin(), pollers.end (), poller);
+
+    if (it == pollers.end ())
+	return;
+
+    pollers.erase (it);
+
+    if (pollers.empty ()) {
+	timer.stop ();
+    }
+}
+
+void
+FocusPoller::setCallback (FocusPoller::CallBack callback)
+{
+    bool wasActive = mActive;
+
+    if (mActive)
+	stop ();
+
+    mCallback = callback;
+
+    if (wasActive)
+	start ();
+}
+
+void
+FocusPoller::start ()
+{
+    FOCUSPOLL_SCREEN (screen);
+
+    if (!fs)
+    {
+	compLogMessage ("focuspoll", CompLogLevelWarn,
+			"Plugin version mismatch, can't start focus poller.");
+
+	return;
+    }
+
+    if (mCallback.empty ())
+    {
+	compLogMessage ("focuspoll", CompLogLevelWarn,
+			"Can't start focus poller without callback.");
+	return;
+    }
+
+    fs->addTimer (this);
+
+    mActive = true;
+}
+
+void
+FocusPoller::stop ()
+{
+    FOCUSPOLL_SCREEN (screen);
+
+    /* Prevent broken plugins from calling stop () twice */
+
+    if (!mActive)
+	return;
+
+    if (!fs)
+    {
+	compLogMessage ("focuspoll",
+			CompLogLevelWarn,
+			"Plugin version mismatch, can't stop focus poller.");
+	return;
+    }
+
+    mActive = false;
+    fs->removeTimer (this);
+}
+
+bool
+FocusPoller::active ()
+{
+    return mActive;
+}
+
+FocusPoller::FocusPoller () :
+    mActive (false),
+    mCallback (NULL) {
+    }
+
+std::tuple<int, int> FocuspollScreen::getScreenLimits() {
+    int x =0, y = 0;
+    for (auto dev : screen->outputDevs()) {
+	x =  std::max(x, dev.x() + dev.width());
+	y =  std::max(y, dev.y() + dev.height());
+    }
+    return std::make_tuple(x, y);
+}
+
+void
+FocuspollScreen::updateTimer ()
+{
+    float timeout = optionGetFocusPollInterval ();
+    timer.setTimes (timeout, timeout * 1.5);
+}
+
+FocusPoller::~FocusPoller ()
+{
+    if (mActive) {
+	stop();
+    }
+}
+
+void
+FocuspollScreen::setOptions()
+{
+    a11ywatcher->setIgnoreLinks(optionGetIgnoreLinks());
+}
+
+template class PluginClassHandler <FocuspollScreen, CompScreen, COMPIZ_FOCUSPOLL_ABI>;
+
+FocuspollScreen::FocuspollScreen (CompScreen *screen) :
+    PluginClassHandler <FocuspollScreen, CompScreen, COMPIZ_FOCUSPOLL_ABI> (screen)
+{
+    a11ywatcher = AccessibilityWatcher::getInstance();
+    a11ywatcher->init();
+
+    int screenLimitX, screenLimitY;
+    std::tie(screenLimitX, screenLimitY) = getScreenLimits();
+    a11ywatcher->setScreenLimits(screenLimitX, screenLimitY);
+
+    updateTimer ();
+    timer.setCallback (boost::bind (&FocuspollScreen::updatePosition, this));
+    optionSetFocusPollIntervalNotify (boost::bind (&FocuspollScreen::updateTimer, this));
+
+    optionSetIgnoreLinksNotify (boost::bind (&FocuspollScreen::setOptions, this));
+
+}
+
+bool
+FocuspollPluginVTable::init ()
+{
+    if (CompPlugin::checkPluginABI ("core", CORE_ABIVERSION))
+    {
+	CompPrivate p;
+	p.uval = COMPIZ_FOCUSPOLL_ABI;
+	screen->storeValue ("focuspoll_ABI", p);
+	return true;
+    }
+    return false;
+}
+
+void
+FocuspollPluginVTable::fini ()
+{
+    screen->eraseValue ("focuspoll_ABI");
+}

=== added file 'plugins/focuspoll/src/private.h'
--- plugins/focuspoll/src/private.h	1970-01-01 00:00:00 +0000
+++ plugins/focuspoll/src/private.h	2017-04-28 09:59:04 +0000
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2016 Auboyneau Vincent <[e-mail]>
+ *
+ *   This file is part of compiz.
+ *
+ *   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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <tuple>
+#include <core/core.h>
+#include <core/pluginclasshandler.h>
+#include <core/timer.h>
+
+#include <focuspoll/focuspoll.h>
+#include <accessibilitywatcher/accessibilitywatcher.h>
+
+#include "focuspoll_options.h"
+
+typedef enum _FocuspollOptions
+{
+    MP_DISPLAY_OPTION_FOCUS_POLL_INTERVAL,
+    MP_DISPLAY_OPTION_NUM
+} FocuspollDisplayOptions;
+
+class FocuspollScreen;
+extern template class PluginClassHandler <FocuspollScreen, CompScreen, COMPIZ_FOCUSPOLL_ABI>;
+
+class FocuspollScreen :
+    public PluginClassHandler <FocuspollScreen, CompScreen, COMPIZ_FOCUSPOLL_ABI>,
+    public FocuspollOptions
+{
+    public:
+        FocuspollScreen (CompScreen *screen);
+
+        std::list<FocusPoller *> pollers;
+        CompTimer timer;
+        CompTimer settingsTimer;
+        CompRect focusRect;
+
+        bool updatePosition ();
+        bool addTimer (FocusPoller *poller);
+        void removeTimer (FocusPoller *poller);
+        void updateTimer ();
+
+    private:
+        AccessibilityWatcher* a11ywatcher;
+
+	std::tuple<int, int> getScreenLimits();
+	void setOptions();
+
+};
+
+#define FOCUSPOLL_SCREEN(s)						\
+    FocuspollScreen *fs = FocuspollScreen::get (s)
+
+#define NUM_OPTIONS(s) (sizeof ((s)->opt) / sizeof (CompOption))
+
+class FocuspollPluginVTable :
+    public CompPlugin::VTableForScreen<FocuspollScreen, COMPIZ_FOCUSPOLL_ABI>
+{
+    public:
+        bool init ();
+        void fini ();
+};

=== modified file 'plugins/showmouse/showmouse.xml.in'
--- plugins/showmouse/showmouse.xml.in	2016-05-31 17:30:42 +0000
+++ plugins/showmouse/showmouse.xml.in	2017-04-28 09:59:04 +0000
@@ -11,6 +11,9 @@
 				<plugin>cube</plugin>
 				<plugin>decor</plugin>
 			</relation>
+			<relation type="before">
+				<plugin>ezoom</plugin>
+			</relation>
 			<requirement>
 				<plugin>opengl</plugin>
 				<plugin>mousepoll</plugin>