Merge lp:~alanbell/compiz/texttracking into lp:compiz/0.9.8

[Alan Bell]

merges in code from
https://github.com/gloob/gloob-Ezoom-fork
https://github.com/gloob/compiz-accessibility-plugin
fixing lp:#727290
it compiles, might have an additional dependency on at-spi stuff, I don't know how to merge it with the debian packaging to make an installable package.

[Sam Spilsbury (smspillaz)]

Looks good, and definitely on the right track, needs some work before we can merge it in, but definitely something we can have for 12.10

The README can probably be cut down or go entirely, it seems to be mostly about how to enable AT-SPI and how to build and install the plugin, which is mostly redundant anyways as the buildsystem will build it for us.

There are a few indentation problems that need to be fixed. Indentation in compiz is a little weird (X11 style). It goes:

4 spaces
8-wide tab
8-wide tab + 4 spaces
8-wide tab + 8 wide tab
8-wide tab + 8-wide tab + 4 spaces

etc

So some areas where this needs to be fixed are:

215 + virtual AccessibilityEntity *
216 + clone () const;
217 +
218 + AtspiAccessible *
219 + getObject ();

215 + virtual AccessibilityEntity *
216 + clone () const;
217 +
218 + AtspiAccessible *
219 + getObject ();

412 + for (int i = 0; i < len; i++) {
413 +

The brace goes on the next line, eg
for (int i = 0; i < len; i++)
{

 + switch (iface) {

ditto

518 + compLogMessage ("Accessibility", CompLogLevelInfo,
519 + "AccessibilityEntity::AccessibilityEntity (%s)\n", object->name);
520 +

I don't think these messages are necessary. Program function can be verified through unit tests (which I'll get on to in a minute)

1269 + if (a11yHandle->active ())
1270 + a11yHandle->unregisterAll ();

That needs to be a tab and not four spaces.

The second big thing I have about this code is that the design feels a little weird.

The inheritance hierarchy looks a bit like this:

AccessibilityEntity
 - AccessibilityComponent
 - AccessibilityText

AccessibleObject (which appears to be a wrapper around AtspiAccessible *)
Accessibility (which appears to be a manager class)

The real gripe I have here are things like this:

434 + case Component:
435 + entity = AccessibilityEntity::Ptr (new AccessibilityComponent (object));
436 + break;
437 +
438 + case Text:
439 + entity = AccessibilityEntity::Ptr (new AccessibilityText (object));
440 + break;
441 +
442 + case Accessible:
443 + case Action:
444 + case Collection:
445 + case Document:
446 + case EditableText:
447 + case Hypertext:
448 + case Hyperlink:
449 + case Image:
450 + case Selection:
451 + case Table:
452 + case Value:
453 + break;
454 +
455 + default:
456 + entity = AccessibilityEntity::Ptr (new AccessibilityEntity (object));

This code feels fragile, because our fallback case is "silently do nothing", and we just waste memory by tracking objects we don't really care about. Moreover, that behaviour is different from cases that we know we don't care about where we return a shared_ptr to NULL and then the client code just assumes that the pointer is valid.

There are other examples like this:

941 + if (object->is (Component))
942 + {
943 +
944 + AccessibilityComponent::Ptr ac =
945 + boost::static_pointer_cast<AccessibilityComponent>
946 + (object->getEntity (Component));

Generally speaking, code where you need to go from some "placeholder" down to something that you think the object is feels to me like reintepret_casting through void * with a note that everything will be okay.

I understand that Atspi is based on GObject and as such, you have to handle the type system at run...

review: Needs Fixing

[Sam Spilsbury (smspillaz)]

Oh yeah, totally forgot! Tests...

Generally speaking, I prefer all code going into compiz to come with unit tests. I don't think getting this particular code under test will be that difficult. The majority of the a11y code looks like its just wrappers for managing objects coming to us from AT-SPI.

Stuff that I think needs to be tested (or needs to be deleted, since it looks unused):

206 + virtual bool
207 + load (AtspiAccessible *);
208 +
209 + virtual bool
210 + contains (AccessibilityEntity *, int, int);
211 +

Actually they can be deleted completely as they are unused. But...

236 + CompRect
237 + getExtents () const;
238 +
239 + CompPoint
240 + getPosition () const;
241 +
242 + CompPoint
243 + getSize () const;

I am like 99% sure the second two are unused.

The relationship between getExtents and this:

1214 + if (optionGetZoomMode () == EzoomOptions::ZoomModePanArea)
1215 + {
1216 + ensureVisibilityArea (rect.x1(),
1217 + rect.y1(),
1218 + rect.x2(),
1219 + rect.y2(),
1220 + optionGetRestrainMargin (),
1221 + NORTHWEST);
1222 + }

Or, a potential getZoomCenterArea () needs to come under test

As well as:

267 + CompRect
268 + getCharacterExtents (int) const;
269 +
270 + CompRect
271 + getRangeExtents (int) const;
272 +
273 + int
274 + getCaretOffset ();

(getRangeExtents can be deleted)

But the relationship between the first and the third needs to be tested. That means breaking the dependency on

654 + AtspiRect *character_rect = atspi_text_get_character_extents
655 + (text, offset, ATSPI_COORD_TYPE_SCREEN, &error);

through an interface by which AtspiRect can be manipulated and atspi_text_get_character_extents be queried.

Then you can use Mock Objects to verify the behaviour of getCharacterExtents and the resulting zoom rect.

Feel free to poke with questions on IRC. I'm on planes for the next two days, but I can be found on freenode (nick: smspillaz)

[lp:~alanbell/compiz/texttracking]

3254. By Alan Bell on 2012-06-23

remove README and fix indentation

3255. By Alan Bell on 2012-06-23

remove message

3256. By Alan Bell on 2012-06-23

indentation issue

[Daniel van Vugt (vanvugt)]

Please review and fix the indentation and style again. For example:

135 + virtual IfaceType
136 + is ();
137 +
138 + virtual AccessibilityEntity *
139 + clone () const;
140 +
141 + AtspiAccessible *
142 + getObject ();

should be more like:

   virtual IfaceType is ();
   virtual AccessibilityEntity *clone () const;
   AtspiAccessible *getObject ();

And the same applies elsewhere.

review: Needs Fixing

[Daniel van Vugt (vanvugt)]

When done, please click Resubmit so we get notified.

[Daniel van Vugt (vanvugt)]

Please also click "Set commit message" when done so the automerger doesn't reject it once approved by us.

[Sam Spilsbury (smspillaz)]

(This will be looked at and I will propose a merge to fix some of the overarching design issues once the gles2 and gsettings work is done)

[Alan Bell (alanbell)]

I will have a go at the indentation issues, but I am a bit out of my depth on the refactoring, this isn't my code, I am just trying to integrate it into the upstream tree, I will try and contact gloob https://github.com/gloob for some help I think.

[Sam Spilsbury (smspillaz)]

Sure, no problem :)

[Alejandro Leiva (gloob)]

Hi guys, thanks for working on this.

As Sam pointed out before there's some methods, classes and structures that I'm not using in the plugin. In fact I'm not happy with the global architecture. A refactor is needed. I'll do.

Alan if you can grant me write access to your branch I won't need to create a new branch and merge and so on.

Cheers.

[Alan Bell (alanbell)]

thanks Alejandro,

I don't think I can give you write access to my branch, but you can probably do
bzr branch lp:~alanbell/compiz/texttracking
bzr push lp:~gloob/compiz/texttracking

and then do a merge request from there

Unmerged revisions

3256. By Alan Bell on 2012-06-23

indentation issue

3255. By Alan Bell on 2012-06-23

remove message

3254. By Alan Bell on 2012-06-23

remove README and fix indentation

3253. By Alan Bell on 2012-06-22

renamed the accessibility plugin folder and fixed an unused variable in ezoom

3252. By Alan Bell on 2012-06-22

merging in text tracking zoom work by Alejandro Leiva
https://github.com/gloob/compiz-accessibility-plugin
https://github.com/gloob/gloob-Ezoom-fork

=== added directory 'plugins/accessibility'
=== added file 'plugins/accessibility/AUTHORS'
--- plugins/accessibility/AUTHORS	1970-01-01 00:00:00 +0000
+++ plugins/accessibility/AUTHORS	2012-06-23 15:04:23 +0000
@@ -0,0 +1,1 @@
+Alejandro Leiva <[e-mail]>
 
=== added file 'plugins/accessibility/CMakeLists.txt'
--- plugins/accessibility/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/accessibility/CMakeLists.txt	2012-06-23 15:04:23 +0000
@@ -0,0 +1,5 @@
+find_package (Compiz REQUIRED)
+
+include (CompizPlugin)
+
+compiz_plugin (accessibility PKGDEPS atspi-2)
 
=== added file 'plugins/accessibility/ChangeLog'
=== added file 'plugins/accessibility/NEWS'
=== added file 'plugins/accessibility/VERSION'
--- plugins/accessibility/VERSION	1970-01-01 00:00:00 +0000
+++ plugins/accessibility/VERSION	2012-06-23 15:04:23 +0000
@@ -0,0 +1,1 @@
+0.9.5.0
 
=== added file 'plugins/accessibility/accessibility.xml.in'
--- plugins/accessibility/accessibility.xml.in	1970-01-01 00:00:00 +0000
+++ plugins/accessibility/accessibility.xml.in	2012-06-23 15:04:23 +0000
@@ -0,0 +1,17 @@
+<?xml version="1.0"?>
+<compiz>
+    <plugin name="accessibility" useBcop="true">
+        <_short>Accessibility</_short>
+        <_long>Activate compatibility with accessibility layer.</_long>
+        <category>Accessibility</category>
+        <deps>
+            <relation type="after">
+                <plugin>opengl</plugin>
+                <plugin>composite</plugin>
+                <plugin>decor</plugin>
+            </relation>	
+        </deps>
+        <options>
+        </options>		
+    </plugin>
+</compiz>
 
=== added file 'plugins/accessibility/compiz-accessibility.pc.in'
--- plugins/accessibility/compiz-accessibility.pc.in	1970-01-01 00:00:00 +0000
+++ plugins/accessibility/compiz-accessibility.pc.in	2012-06-23 15:04:23 +0000
@@ -0,0 +1,12 @@
+prefix=@prefix@
+exec_prefix=@prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: compiz-accessibility
+Description: Accessibility (based in AT-SPI2) plugin for compiz
+Version: @VERSION@
+
+Requires: compiz
+Libs: -L${libdir}/compiz -laccessibility
+Cflags: @COMPIZ_CFLAGS@ -I${includedir}/compiz
 
=== added directory 'plugins/accessibility/include'
=== added directory 'plugins/accessibility/include/accessibility'
=== added file 'plugins/accessibility/include/accessibility/accessibility.h'
--- plugins/accessibility/include/accessibility/accessibility.h	1970-01-01 00:00:00 +0000
+++ plugins/accessibility/include/accessibility/accessibility.h	2012-06-23 15:04:23 +0000
@@ -0,0 +1,217 @@
+/*
+ * Compiz Accessibility PLugin
+ *
+ * Copyright (c) 2011 F123 Consulting & Mais Diferenças
+ *
+ * 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.
+ *
+ * Author: Alejandro Leiva <[e-mail]>
+ *
+ */
+
+#ifndef _ACCESSIBILITY_H
+#define _ACCESSIBILITY_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <atspi/atspi.h>
+#ifdef __cplusplus
+}
+#endif
+
+/*
+ * Class hierarchy that hold and manage differents accessible objects.
+ */
+enum IfaceType
+{
+    Accessible = 0,
+    Action,
+    Collection,
+    Component,
+    Document,
+    EditableText,
+    Hypertext,
+    Hyperlink,
+    Image,
+    Selection,
+    Table,
+    Text,
+    Value,
+};
+
+class AccessibilityEntity
+{
+    public:
+        typedef boost::shared_ptr<AccessibilityEntity> Ptr;
+
+        AccessibilityEntity (AtspiAccessible *);
+        virtual ~AccessibilityEntity ();
+
+        virtual bool
+        load (AtspiAccessible *);
+
+        virtual bool
+        contains (AccessibilityEntity *, int, int);
+
+        virtual IfaceType
+        is ();
+
+	    virtual AccessibilityEntity *
+	    clone () const;
+
+	    AtspiAccessible *
+	    getObject ();
+
+    protected:
+        AtspiAccessible * obj;
+};
+
+class AccessibilityComponent :
+    public AccessibilityEntity
+{
+    public:
+        typedef boost::shared_ptr<AccessibilityComponent> Ptr;
+        
+        AccessibilityComponent (AtspiAccessible *);
+
+	    virtual AccessibilityComponent *
+	    clone () const;
+
+        CompRect
+        getExtents () const;
+        
+        CompPoint
+        getPosition () const;
+
+        CompPoint
+        getSize () const;
+
+        virtual IfaceType
+        is ();
+
+        /* TODO: Implement based in a compiz layer type.
+        CompLayer
+        getLayer ();
+        */
+    protected:
+        AtspiComponent    *component;
+};
+
+class AccessibilityText :
+    public AccessibilityEntity
+{
+    public:
+        typedef boost::shared_ptr<AccessibilityText> Ptr;
+        
+        AccessibilityText (AtspiAccessible *);
+
+	    virtual AccessibilityText *
+	    clone () const;
+
+        CompRect
+        getCharacterExtents (int) const;
+
+        CompRect
+        getRangeExtents (int) const;
+
+        int
+        getCaretOffset ();
+
+        virtual IfaceType
+        is ();
+
+    protected:
+        AtspiText          *text;
+};
+
+class AccessibleObject
+{
+    public:        
+        typedef std::vector <AccessibilityEntity::Ptr> Entities;
+        typedef std::vector <IfaceType> Interfaces;
+
+        AccessibleObject (AtspiAccessible *);
+        
+        AccessibleObject::Entities
+        create (AtspiAccessible *);
+
+        AccessibilityEntity::Ptr
+        get (IfaceType);
+
+        bool
+        is (IfaceType);
+
+        AccessibilityEntity::Ptr
+        getEntity (IfaceType);
+
+    private:
+        AccessibilityEntity::Ptr
+        instantiate (AtspiAccessible *, IfaceType);
+
+        static IfaceType
+        enumFromStr (const char *);
+
+        int
+        getIfaceIndex (IfaceType);
+
+    private:
+        Entities            ents;
+        Interfaces          interfaces;
+        AtspiAccessible *   obj;
+};
+
+class AccessibilityEvent
+{
+    public:
+        AccessibilityEvent (const AtspiEvent *);
+        ~AccessibilityEvent ();
+
+        const char *
+        getType ();
+
+        AccessibleObject *
+        getAccessibleObject ();
+
+    private:
+        const AtspiEvent  *event;
+        AccessibleObject  *object;
+
+};
+
+typedef boost::function<void (AccessibilityEvent *)> AccessibilityEventCallback;
+
+class Accessibility
+{
+    public:
+
+        Accessibility ();
+        ~Accessibility ();
+
+        bool
+        start ();
+
+        bool
+        stop ();
+
+        bool
+        active ();
+
+        bool
+        registerEventHandler (const char *, AccessibilityEventCallback);
+
+        void
+        unregisterAll ();
+
+    friend class AccessibilityScreen;
+};      
+
+#endif // _ACCESSIBILITY_H
 
=== added directory 'plugins/accessibility/src'
=== added file 'plugins/accessibility/src/accessibility.cpp'
--- plugins/accessibility/src/accessibility.cpp	1970-01-01 00:00:00 +0000
+++ plugins/accessibility/src/accessibility.cpp	2012-06-23 15:04:23 +0000
@@ -0,0 +1,651 @@
+/*
+ * Compiz Accessibility PLugin
+ *
+ * Copyright (c) 2011 F123 Consulting & Mais Diferenças
+ *
+ * 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.
+ *
+ * Author: Alejandro Leiva <[e-mail]>
+ *
+ */
+
+#include "private.h"
+
+COMPIZ_PLUGIN_20090315 (accessibility, AccessibilityPluginVTable);
+
+AccessibleObject::AccessibleObject (AtspiAccessible *object)
+{
+    compLogMessage ("Accessibility", CompLogLevelInfo,
+                    "AccessibleObject::AccessibleObject (%s)\n", object->name);
+	
+    obj = object;
+    
+    create (object);
+}
+
+AccessibleObject::Entities
+AccessibleObject::create (AtspiAccessible *object)
+{
+    GArray * ifaces = atspi_accessible_get_interfaces (object);
+
+    int len = (int) ifaces->len;
+
+    for (int i = 0; i < len; i++)
+    {
+
+        char *iface = (char *) g_array_index (ifaces, gchar *, i);
+
+        interfaces.push_back (enumFromStr (iface));
+        // Defer the creation of the AccessibilityEntity structure.
+        // TODO: Create a new method to create it from AccessibleObject.
+        //ents.push_back (instantiate (object, iface));
+    }
+
+    g_array_free (ifaces, TRUE);
+
+    return ents;
+}
+
+AccessibilityEntity::Ptr
+AccessibleObject::instantiate (AtspiAccessible *object, IfaceType iface)
+{
+    AccessibilityEntity::Ptr entity;
+    
+    switch (iface)
+    {
+
+        case Component:
+            entity = AccessibilityEntity::Ptr (new AccessibilityComponent (object));
+            break;
+
+        case Text:
+            entity = AccessibilityEntity::Ptr (new AccessibilityText (object));
+            break;
+
+        case Accessible:
+        case Action:
+        case Collection:
+        case Document:
+        case EditableText:
+        case Hypertext:
+        case Hyperlink:
+        case Image:
+        case Selection:
+        case Table:    
+        case Value:
+            break;
+			
+        default:
+            entity = AccessibilityEntity::Ptr (new AccessibilityEntity (object));
+    }
+
+    return entity;
+}
+
+IfaceType
+AccessibleObject::enumFromStr (const char *str)
+{
+
+    for (int i = 0; i < NUM_IFACES_SUPPORTED; i++)
+        if (!strcmp (IfaceTypeStr[i], str))
+            return (IfaceType) i;
+    
+    return Accessible;
+}
+
+AccessibilityEntity::Ptr
+AccessibleObject::get (IfaceType type)
+{
+    int index = getIfaceIndex (type);
+    compLogMessage ("Accessibility", CompLogLevelInfo, "AccessibleObject::get(%s) = %d\n",
+                    type, index);
+
+    if (index < 0)
+        return AccessibilityEntity::Ptr ();
+
+    return ents[index];
+}
+
+bool
+AccessibleObject::is (IfaceType type)
+{
+    int index = getIfaceIndex (type);
+
+    if (index < 0)
+        return false;
+
+    return true;
+}
+
+int
+AccessibleObject::getIfaceIndex (IfaceType type)
+{
+    for (int i = 0; i < (int) interfaces.size(); i++)
+    {	
+        if (type == interfaces[i])
+            return i;
+    }
+
+    return -1;
+}
+
+AccessibilityEntity::Ptr
+AccessibleObject::getEntity (IfaceType type)
+{
+    return instantiate (obj, type);
+}
+
+
+AccessibilityEntity::AccessibilityEntity (AtspiAccessible *object)
+{	
+    obj = object;
+}
+
+AccessibilityEntity::~AccessibilityEntity () {
+
+}
+
+bool
+AccessibilityEntity::load (AtspiAccessible *object)
+{
+    return true;
+}
+
+bool
+AccessibilityEntity::contains (AccessibilityEntity *entity, int x, int y)
+{
+    return true;
+}
+
+IfaceType
+AccessibilityEntity::is ()
+{
+    return Accessible;
+}
+
+AccessibilityEntity *
+AccessibilityEntity::clone () const
+{
+    return new AccessibilityEntity (obj);
+}
+
+AtspiAccessible *
+AccessibilityEntity::getObject () {
+    return obj;
+}
+
+
+AccessibilityComponent::AccessibilityComponent (AtspiAccessible *obj) :
+    AccessibilityEntity (obj)
+{
+    compLogMessage ("Accessibility", CompLogLevelInfo,
+                    "AccessibilityComponent::AccessibilityComponent (%s)\n", obj->name);
+	
+    component = atspi_accessible_get_component (obj);
+}
+
+AccessibilityComponent *
+AccessibilityComponent::clone () const
+{
+    return new AccessibilityComponent (obj);
+}
+
+CompRect
+AccessibilityComponent::getExtents () const
+{   
+    CompRect rect;
+    GError *error = NULL;
+
+    AtspiRect *component_rect =
+        atspi_component_get_extents (component, ATSPI_COORD_TYPE_SCREEN, &error);   
+    
+    if (!component_rect)
+        g_error_free (error);
+    else
+        rect = CompRect (component_rect->x,
+                         component_rect->y,
+                         component_rect->width,
+                         component_rect->height);
+
+    return rect;
+}
+
+CompPoint
+AccessibilityComponent::getPosition () const
+{
+    CompPoint position;
+    GError *error = NULL;
+
+    AtspiPoint *component_position =
+        atspi_component_get_position (component, ATSPI_COORD_TYPE_SCREEN, &error);
+
+    if (!component_position)
+        g_error_free (error);
+    else
+        position = CompPoint (component_position->x, component_position->y);
+       
+    return position;
+}
+
+CompPoint
+AccessibilityComponent::getSize () const
+{
+    CompPoint size;
+    GError *error = NULL;
+
+    AtspiPoint *component_size = atspi_component_get_size (component, &error);
+
+    if (!component_size)
+        g_error_free (error);
+    else
+        size = CompPoint (component_size->x, component_size->y);
+
+    return size;
+}
+
+IfaceType
+AccessibilityComponent::is ()
+{
+    return Component;
+}
+
+
+AccessibilityText::AccessibilityText (AtspiAccessible *obj) :
+    AccessibilityEntity (obj)
+{
+    compLogMessage ("Accessibility", CompLogLevelInfo,
+                    "AccessibilityText::AccessibilityText (%s)\n", obj->name);
+	
+    text = atspi_accessible_get_text (obj);
+}
+
+AccessibilityText *
+AccessibilityText::clone () const
+{
+    return new AccessibilityText (obj);
+}
+
+CompRect
+AccessibilityText::getCharacterExtents (int offset) const
+{
+    CompRect rect;
+    GError *error = NULL;
+
+    AtspiRect *character_rect = atspi_text_get_character_extents
+        (text, offset, ATSPI_COORD_TYPE_SCREEN, &error);
+
+    if (!character_rect)
+        g_error_free (error);
+    else
+        rect = CompRect (character_rect->x,
+                         character_rect->y,
+                         character_rect->width,
+                         character_rect->height);
+
+    return rect;
+}
+
+CompRect
+AccessibilityText::getRangeExtents (int offset) const
+{
+    CompRect rect;
+    GError *error = NULL;
+
+    AtspiRect *range_rect = atspi_text_get_range_extents
+        (text, 0, 0, ATSPI_COORD_TYPE_SCREEN, &error);
+
+    if (!range_rect)
+        g_error_free (error);
+    else
+        rect = CompRect (range_rect->x,
+                         range_rect->y,
+                         range_rect->width,
+                         range_rect->height);
+
+    return rect;
+}
+
+int
+AccessibilityText::getCaretOffset ()
+{
+    GError *error = NULL;
+    
+    int caret_offset = atspi_text_get_caret_offset (text, &error);
+
+    if (!caret_offset)
+        g_error_free (error);
+
+    return caret_offset;
+}
+
+IfaceType
+AccessibilityText::is ()
+{
+    return Text;
+}
+
+
+Accessibility::Accessibility ()
+{
+    compLogMessage ("Accessibility", CompLogLevelInfo,
+                    "Accessibility constructor called.\n");
+
+}
+
+Accessibility::~Accessibility ()
+{
+    compLogMessage ("Accessibility", CompLogLevelInfo,
+                    "Accessibility destructor called.\n");
+
+}
+
+bool
+Accessibility::start ()
+{
+    return true;
+}
+
+bool
+Accessibility::stop ()
+{
+    return true;
+}
+
+bool
+Accessibility::active ()
+{
+    return true;
+}
+
+bool
+Accessibility::registerEventHandler (const char *event_type, AccessibilityEventCallback cb)
+{
+    ACCESSIBILITY_SCREEN (screen);
+
+    as->registerEventHandler (event_type, cb);
+
+    return true;
+}
+
+void
+Accessibility::unregisterAll ()
+{
+    ACCESSIBILITY_SCREEN (screen);
+
+    as->unregisterAll ();
+}
+
+void
+staticAccessibilityEventCallback (const AtspiEvent *event)
+{
+    if (!event)
+        return;
+    
+    ACCESSIBILITY_SCREEN (screen);
+
+    AccessibilityHandlerList list = as->list;
+
+    std::list<AccessibilityHandler *>::iterator it;
+
+    AccessibilityEvent *e = new AccessibilityEvent (event);
+    
+    for (it = list.begin (); it != list.end (); it++)
+    {
+        const char * target_type = (*it)->event_type;
+        
+        if (strncmp (target_type, event->type, strlen(target_type)) == 0)
+        {
+            compLogMessage ("Accessibility", CompLogLevelInfo,
+                            "Delegating (%s) to -> functor [%d][%s]\n",
+                            event->type, 
+                            (*it)->id, (*it)->event_type);
+        
+            (*it)->cb (e);
+        }
+    }
+
+    delete (e);
+}
+
+void
+staticAccessibilityEventDestroyCallback (void *data)
+{
+    ACCESSIBILITY_SCREEN (screen);
+
+    AccessibilityHandlerList list = as->list;
+
+    std::list<AccessibilityHandler *>::iterator it;
+
+    for (it = list.begin (); it != list.end (); it++)
+    {
+        compLogMessage ("Accessibility", CompLogLevelInfo,
+                        "Delegating destroy to -> functor [%d][%s]\n",
+                        (*it)->id);
+        // TODO: Implement callback mechanism for handles destroy.
+    }
+}
+
+AccessibilityEvent::AccessibilityEvent (const AtspiEvent *event)
+{
+    this->event = event;
+    this->object = new AccessibleObject (event->source);
+}
+
+AccessibilityEvent::~AccessibilityEvent ()
+{
+    delete (event);
+    delete (object);
+}
+
+const char *
+AccessibilityEvent::getType ()
+{
+    return event->type;
+}
+
+AccessibleObject *
+AccessibilityEvent::getAccessibleObject ()
+{
+    return object;
+}
+
+AccessibilityEventHandler
+AccessibilityScreen::registerEventHandler (const char *event_type,
+                                           AccessibilityEventCallback cb)
+{
+
+    AccessibilityHandler *hnd = new AccessibilityHandler ();
+
+    if (!hnd)
+        return 0;
+
+    if (!event_type || !cb)
+        return 0;
+
+    // Create event listeners
+    GError *error = NULL;
+
+    AtspiEventListener *event_listener =
+        atspi_event_listener_new_simple (staticAccessibilityEventCallback,
+                                         staticAccessibilityEventDestroyCallback);
+    
+    if (!atspi_event_listener_register (event_listener, event_type, &error))
+    {
+        compLogMessage ("Accessibility", CompLogLevelInfo,
+                        "Cannot create event listener (%s). [%s]\n",
+                        event_type, 
+                        error->message);
+        
+        g_error_free (error);
+        error = NULL;
+    }
+
+    hnd->event_type     = event_type;
+    hnd->event_listener = event_listener;
+    hnd->cb             = cb;
+    hnd->id             = lastEventHandler++;
+
+    list.push_front (hnd);
+
+    compLogMessage ("Accessibility", CompLogLevelInfo, "Registered new listener (%d): (%s))\n", hnd->id, hnd->event_type);
+    
+    return hnd->id;
+}
+
+void
+AccessibilityScreen::unregisterEventHandler (AccessibilityEventHandler handler)
+{
+    
+    std::list<AccessibilityHandler *>::iterator it;
+    AccessibilityHandler *h;
+
+    if (list.size() < 0)
+        return;
+        
+    for (it = list.begin (); it != list.end (); it++)
+        if ((*it)->id == handler)
+            break;
+
+    if (it == list.end ())
+        return;
+
+    // Unregister event.
+    GError *error = NULL;
+
+    if (!atspi_event_listener_deregister ((*it)->event_listener, (*it)->event_type, &error))
+    {
+        compLogMessage ("Accessibility", CompLogLevelInfo,
+                        "Cannot unregister event listener (%s). [%s]\n",
+                        (*it)->event_type,
+                        error->message);
+        
+        g_error_free (error);
+        error = NULL;
+    }
+
+    // Free and erase from the list.
+    h = (*it);
+    delete (h);
+    
+    list.erase (it);
+}
+
+
+bool
+AccessibilityScreen::unregisterByType (const char * event_type)
+{
+    //TODO
+    return true;
+}
+
+void
+AccessibilityScreen::unregisterAll ()
+{
+    std::list<AccessibilityHandler *>::iterator it;
+
+    if (list.size () < 0)
+        return;
+
+    for (it = list.begin (); it != list.end (); it++)
+    {
+        unregisterEventHandler ((*it)->id);
+    }
+}
+
+void
+AccessibilityScreen::handleAccessibilityEvent (AccessibilityEvent *event)
+{
+
+    AccessibleObject *object = event->getAccessibleObject ();
+
+    if (object->is (Component))
+    {
+        
+        AccessibilityComponent::Ptr ac = 
+            boost::static_pointer_cast<AccessibilityComponent>
+            (object->getEntity (Component));
+
+        CompRect rect = ac->getExtents ();
+
+        compLogMessage ("Accessibility", CompLogLevelInfo, "Object is Component\n");
+        
+        compLogMessage ("Accessibility", CompLogLevelInfo,
+                        "Component Area [%d, %d] [%d, %d]\n",
+                        rect.x1(), rect.y1(), rect.x2(), rect.y2());
+    }
+    else
+    {
+
+        compLogMessage ("Accessibility", CompLogLevelInfo, "Object is NOT Component\n");
+    }
+}
+
+AccessibilityScreen::AccessibilityScreen (CompScreen *screen) :
+    PluginClassHandler <AccessibilityScreen, CompScreen> (screen),
+    screen (screen),
+    lastEventHandler (0)
+{
+    compLogMessage ("Accessibility", CompLogLevelInfo,
+                    "AccessibilityScreen called.\n");
+
+    /* TODO: Check atspi_init() code. There's a memory leak when registryd
+     * isn't running.
+     */
+    int atspi_status = atspi_init ();
+	
+    compLogMessage ("Accessibility", CompLogLevelInfo,
+                    "AccessibilityScreen: AT-SPI init() %d.\n", atspi_status);
+
+    /*
+    registerEventHandler ("object:state-changed:", boost::bind (
+                    &AccessibilityScreen::handleAccessibilityEvent, this, _1));
+    */
+
+    compLogMessage ("Accessibility", CompLogLevelInfo, "Running!\n");
+        
+    /*
+    // Launch main event atspi loop
+    // This is not needed because compiz private screen launches its own
+    // Glib MainLoop
+    */
+    /*
+
+    atspi_event_main();
+    */
+}
+
+AccessibilityScreen::~AccessibilityScreen ()
+{
+
+    unregisterAll ();
+    
+    //atspi_event_quit();
+    int atspi_status = atspi_exit ();
+
+    compLogMessage ("Accessibility", CompLogLevelInfo,
+                    "~AccessibilityScreen called. Exit value: %d\n", atspi_status);
+}
+
+bool
+AccessibilityPluginVTable::init ()
+{
+    if (!CompPlugin::checkPluginABI ("core", CORE_ABIVERSION))
+    {
+        compLogMessage ("Accessibility", CompLogLevelInfo,
+                        "compiz core not in sync.\n");
+        return false;
+    }
+
+    compLogMessage ("Accessibility", CompLogLevelInfo,
+                    "Running Accessibility plugin.\n");
+
+    return true;
+}
 
=== added file 'plugins/accessibility/src/private.h'
--- plugins/accessibility/src/private.h	1970-01-01 00:00:00 +0000
+++ plugins/accessibility/src/private.h	2012-06-23 15:04:23 +0000
@@ -0,0 +1,113 @@
+/*
+ * Compiz Accessibility PLugin
+ *
+ * Copyright (c) 2011 F123 Consulting & Mais Diferenças
+ *
+ * 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.
+ *
+ * Author: Alejandro Leiva <[e-mail]>
+ *
+ */
+
+#include <vector>
+#include <cstring>
+
+#include <boost/shared_ptr.hpp>
+
+#include <core/core.h>
+#include <core/pluginclasshandler.h>
+
+#include <glibmm/main.h>
+
+#include <accessibility/accessibility.h>
+#include "accessibility_options.h"
+
+static const char *IfaceTypeStr[] =
+{
+    "Accessible",
+    "Action",
+    "Collection",
+    "Component",
+    "Document",
+    "EditableText",
+    "Hypertext",
+    "Hyperlink",
+    "Image",
+    "Selection",
+    "Table",
+    "Text",
+    "Value",
+};
+
+#define NUM_IFACES_SUPPORTED 13
+
+typedef int AccessibilityEventHandler;
+
+/* Struct of a handler and list of handlers */
+struct AccessibilityHandler {
+    const char *                event_type;
+    AtspiEventListener *        event_listener;
+    AccessibilityEventCallback  cb;
+    AccessibilityEventHandler   id;
+};
+
+typedef std::list<AccessibilityHandler *> AccessibilityHandlerList;
+
+class AccessibilityScreen :
+    public PluginClassHandler <AccessibilityScreen, CompScreen>,
+    public ScreenInterface,
+    public AccessibilityOptions
+{
+    public:
+
+        AccessibilityScreen (CompScreen *);
+        ~AccessibilityScreen ();
+
+        CompScreen *screen;
+
+        AccessibilityEventHandler
+        registerEventHandler (const char * event_type,
+                              AccessibilityEventCallback cb);
+        
+        void
+        unregisterEventHandler (AccessibilityEventHandler handler);
+
+        bool
+        unregisterByType (const char * event_type);
+
+        void
+        unregisterAll ();
+
+        void
+        handleAccessibilityEvent (AccessibilityEvent *);
+
+    public:
+        
+        AccessibilityHandlerList list;
+        int lastEventHandler;
+
+    protected:
+
+        AtspiEventListener *listener;
+
+};
+
+#define ACCESSIBILITY_SCREEN(s) \
+    AccessibilityScreen *as = AccessibilityScreen::get (s)
+
+class AccessibilityPluginVTable :
+    public CompPlugin::VTableForScreen <AccessibilityScreen>
+{
+    public:
+
+        bool init();
+        
+};
 
=== modified file 'plugins/ezoom/CMakeLists.txt'
--- plugins/ezoom/CMakeLists.txt	2012-05-16 17:40:27 +0000
+++ plugins/ezoom/CMakeLists.txt	2012-06-23 15:04:23 +0000
@@ -2,4 +2,4 @@
 
 include (CompizPlugin)
 
-compiz_plugin (ezoom PLUGINDEPS composite opengl mousepoll)
+compiz_plugin (ezoom PLUGINDEPS composite opengl mousepoll accessibility PKGDEPS atspi-2)
 
=== modified file 'plugins/ezoom/ezoom.xml.in'
--- plugins/ezoom/ezoom.xml.in	2012-05-16 17:40:27 +0000
+++ plugins/ezoom/ezoom.xml.in	2012-06-23 15:04:23 +0000
@@ -6,6 +6,7 @@
 		<plugin>opengl</plugin>
 		<plugin>expo</plugin>
 		<plugin>decor</plugin>
+		<plugin>accessibility</plugin>
 	    </relation>
 	    <relation type="before">
 		<plugin>staticswitcher</plugin>
@@ -14,6 +15,7 @@
 	    <requirement>
 		<plugin>opengl</plugin>
 		<plugin>mousepoll</plugin>
+		<plugin>accessibility</plugin>
 	    </requirement>
 	</deps>
 	<_short>Enhanced Zoom Desktop</_short>
 
=== modified file 'plugins/ezoom/src/ezoom.cpp'
--- plugins/ezoom/src/ezoom.cpp	2012-05-18 06:52:20 +0000
+++ plugins/ezoom/src/ezoom.cpp	2012-06-23 15:04:23 +0000
@@ -604,6 +604,12 @@
     mouse = MousePoller::getCurrentPosition ();
 }
 
+void
+EZoomScreen::enableAccessibility ()
+{
+    ;
+}
+
 /* Sets the zoom (or scale) level.
  * Cleans up if we are suddenly zoomed out.
  */
@@ -1790,6 +1796,62 @@
     screen->handleEvent (event);
 }
 
+void
+EZoomScreen::handleAccessibilityEvent (AccessibilityEvent *event)
+{
+    AccessibleObject *object = event->getAccessibleObject ();
+    
+    compLogMessage ("EZoom", CompLogLevelInfo,
+                    "event->type: %s\n", event->getType());
+
+    if (object->is (Component))
+    {
+        
+        AccessibilityComponent::Ptr ac = 
+            boost::static_pointer_cast<AccessibilityComponent>
+            (object->getEntity (Component));
+
+        CompRect rect = ac->getExtents ();
+
+        compLogMessage ("Ezoom", CompLogLevelInfo,
+                        "ensureVisibilityArea [%d, %d] [%d, %d]\n",
+                        rect.x1(), rect.y1(), rect.x2(), rect.y2());
+
+        if (optionGetZoomMode () == EzoomOptions::ZoomModePanArea)
+        {
+            ensureVisibilityArea (rect.x1(),
+                                  rect.y1(),
+                                  rect.x2(),
+                                  rect.y2(),
+                                  optionGetRestrainMargin (),
+                                  NORTHWEST);
+        }
+    }
+
+    if (object->is (Text))
+    {
+        AccessibilityText::Ptr at = 
+            boost::static_pointer_cast<AccessibilityText>
+            (object->getEntity (Text));
+
+        CompRect rect = at->getCharacterExtents (at->getCaretOffset ());
+
+        compLogMessage ("Ezoom", CompLogLevelInfo,
+                        "TEXT - [%d, %d] [%d, %d]\n",
+                        rect.x1(), rect.y1(), rect.x2(), rect.y2());
+
+        if (optionGetZoomMode () == EzoomOptions::ZoomModePanArea)
+        {
+            ensureVisibilityArea (rect.x1(),
+                                  rect.y1(),
+                                  rect.x2(),
+                                  rect.y2(),
+                                  optionGetRestrainMargin (),
+                                  NORTHWEST);
+        }
+    }
+}
+
 /* TODO: Use this ctor carefully */
 
 EZoomScreen::CursorTexture::CursorTexture () :
@@ -1866,6 +1928,12 @@
     pollHandle.setCallback (boost::bind (
 				&EZoomScreen::updateMouseInterval, this, _1));
 
+    a11yHandle = new Accessibility();
+    a11yHandle->registerEventHandler ("object:state-changed", boost::bind (
+                        &EZoomScreen::handleAccessibilityEvent, this, _1));
+    a11yHandle->registerEventHandler ("object:text-changed", boost::bind (
+                        &EZoomScreen::handleAccessibilityEvent, this, _1));
+
     optionSetZoomInButtonInitiate (boost::bind (&EZoomScreen::zoomIn, this, _1,
 						_2, _3));
     optionSetZoomOutButtonInitiate (boost::bind (&EZoomScreen::zoomOut, this, _1,
@@ -1926,6 +1994,9 @@
     if (pollHandle.active ())
 	pollHandle.stop ();
 
+    if (a11yHandle->active ())
+	a11yHandle->unregisterAll ();
+
     if (zooms.size ())
 	zooms.clear ();
 
 
=== modified file 'plugins/ezoom/src/ezoom.h'
--- plugins/ezoom/src/ezoom.h	2010-10-25 02:23:36 +0000
+++ plugins/ezoom/src/ezoom.h	2012-06-23 15:04:23 +0000
@@ -44,6 +44,7 @@
 #include <composite/composite.h>
 #include <opengl/opengl.h>
 #include <mousepoll/mousepoll.h>
+#include <accessibility/accessibility.h>
 
 
 #include "ezoom_options.h"
@@ -184,6 +185,8 @@
 
 	MousePoller		 pollHandle; // mouse poller object
 
+    Accessibility    *a11yHandle; // Accessibility object
+
      private:
 
 	bool fixesSupported;
@@ -212,6 +215,9 @@
 	void
 	handleEvent (XEvent *);
 
+    void
+    handleAccessibilityEvent (AccessibilityEvent *event);
+
     public:
 
 	int
@@ -250,6 +256,9 @@
 	void
 	enableMousePolling ();
 
+    void
+    enableAccessibility ();
+
 	void
 	setScale (int out, float value);
 
 
=== modified file 'plugins/mousepoll/mousepoll.xml.in'
--- plugins/mousepoll/mousepoll.xml.in	2012-05-16 17:43:36 +0000
+++ plugins/mousepoll/mousepoll.xml.in	2012-06-23 15:04:23 +0000
@@ -16,7 +16,7 @@
 	    <option type="int" name="mouse_poll_interval">
 		<_short>Mouse Poll Interval</_short>
 		<_long>How often to poll the mouse position, in miliseconds. Reduce this to reduce choppy behavior.</_long>
-		<default>40</default>
+		<default>10</default>
 		<min>1</min>
 		<max>500</max>
 	    </option>