Merge lp:~apinheiro/unity/a11y-quicklist into lp:unity

[Alejandro Piñeiro]

[Alejandro Piñeiro (apinheiro)]

BTW, this branch is already being tested by the users, as it is included on this branch:

https://launchpad.net/~apinheiro/+archive/unity-extra-a11y

I already received some positive feedback from ubuntu-accessibility mailing list

[Alex Launi (alexlauni)]

+1 this looks good

review: Approve

=== modified file 'plugins/unityshell/src/QuicklistMenuItem.cpp'
--- plugins/unityshell/src/QuicklistMenuItem.cpp	2011-10-11 18:18:13 +0000
+++ plugins/unityshell/src/QuicklistMenuItem.cpp	2011-11-07 19:26:37 +0000
@@ -28,6 +28,8 @@
 
 #include <X11/Xlib.h>
 
+NUX_IMPLEMENT_OBJECT_TYPE(QuicklistMenuItem);
+
 static void
 OnPropertyChanged(gchar*             property,
                   GValue*            value,
@@ -37,8 +39,6 @@
 OnItemActivated(guint              timestamp,
                 QuicklistMenuItem* self);
 
-NUX_IMPLEMENT_OBJECT_TYPE(QuicklistMenuItem);
-
 QuicklistMenuItem::QuicklistMenuItem(DbusmenuMenuitem* item,
                                      NUX_FILE_LINE_DECL) :
   View(NUX_FILE_LINE_PARAM)

=== modified file 'plugins/unityshell/src/QuicklistView.cpp'
--- plugins/unityshell/src/QuicklistView.cpp	2011-10-11 18:18:13 +0000
+++ plugins/unityshell/src/QuicklistView.cpp	2011-11-07 19:26:37 +0000
@@ -181,6 +181,8 @@
         while (IsMenuItemSeperator(_current_item_index))
           _current_item_index--;
 
+        selection_change.emit();
+
         GetNthItems(_current_item_index)->_prelight = true;
         QueueDraw();
       }
@@ -201,6 +203,8 @@
         while (IsMenuItemSeperator(_current_item_index))
           _current_item_index++;
 
+        selection_change.emit();
+
         GetNthItems(_current_item_index)->_prelight = true;
         QueueDraw();
       }
@@ -210,6 +214,7 @@
     case NUX_VK_LEFT:
     case NUX_KP_LEFT:
       _current_item_index = 0;
+      selection_change.emit();
       GetNthItems(_current_item_index)->_prelight = true;
       Hide();
       // inform Launcher we switch back to Launcher key-nav
@@ -221,12 +226,14 @@
       // esc (close quicklist, exit key-nav)
     case NUX_VK_ESCAPE:
       _current_item_index = 0;
+      selection_change.emit();
       GetNthItems(_current_item_index)->_prelight = true;
       Hide();
       // inform UnityScreen we leave key-nav completely
       ubus_server_send_message(ubus_server_get_default(),
                                UBUS_LAUNCHER_END_KEY_NAV,
                                NULL);
+      selection_change.emit();
       break;
 
       // <SPACE>, <RETURN> (activate selected menu-item)
@@ -242,6 +249,7 @@
                                        NULL,
                                        0);
         _current_item_index = 0;
+        selection_change.emit();
         GetNthItems(_current_item_index)->_prelight = true;
         Hide();
       }
@@ -1507,3 +1515,8 @@
   return true;
 }
 
+QuicklistMenuItem*
+QuicklistView::GetSelectedMenuItem()
+{
+  return GetNthItems(_current_item_index);
+}

=== modified file 'plugins/unityshell/src/QuicklistView.h'
--- plugins/unityshell/src/QuicklistView.h	2011-10-11 18:18:13 +0000
+++ plugins/unityshell/src/QuicklistView.h	2011-11-07 19:26:37 +0000
@@ -97,6 +97,10 @@
                                unsigned int keysym,
                                const char* character);
 
+  //Required for a11y
+  QuicklistMenuItem* GetSelectedMenuItem();
+  sigc::signal<void> selection_change;
+
 private:
   void RecvCairoTextChanged(QuicklistMenuItem* item);
   void RecvCairoTextColorChanged(QuicklistMenuItem* item);

=== modified file 'plugins/unityshell/src/unity-launcher-accessible.cpp'
--- plugins/unityshell/src/unity-launcher-accessible.cpp	2011-10-06 04:18:36 +0000
+++ plugins/unityshell/src/unity-launcher-accessible.cpp	2011-11-07 19:26:37 +0000
@@ -36,6 +36,7 @@
 #include "unitya11y.h"
 #include "Launcher.h"
 #include "LauncherModel.h"
+#include "QuicklistView.h"
 
 using unity::launcher::Launcher;
 using unity::launcher::LauncherIcon;

=== added file 'plugins/unityshell/src/unity-quicklist-accessible.cpp'
--- plugins/unityshell/src/unity-quicklist-accessible.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/unity-quicklist-accessible.cpp	2011-11-07 19:26:37 +0000
@@ -0,0 +1,182 @@
+/*
+ * Copyright (C) 2011 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * 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/>.
+ *
+ * Authored by: Alejandro Piñeiro Iglesias <[e-mail]>
+ */
+
+/**
+ * SECTION:unity-quicklist-accessible
+ * @Title: UnityQuicklistAccessible
+ * @short_description: Implementation of the ATK interfaces for #QuicklistView
+ * @see_also: QuicklistView
+ *
+ * #UnityQuicklistAccessible implements the required ATK interfaces for
+ * #QuicklistView.
+ *
+ * IMPLEMENTATION NOTES:
+ *
+ *  The desired accessible object hierarchy is the following one:
+ *    Role:menu
+ *     Role:menu-item
+ *     Role:menu-item.
+ *
+ *  But this quicklist is also a base window, so we can't set a role
+ *  menu, and then keeping it sending window messages.
+ *
+ *  So a new object, with role menu will be added to the hierarchy:
+ *  QuicklistMenu. It also hide the intermediate container objects.
+ *
+ * So we will have:
+ *   Role:window (the quicklist itself)
+ *     Role:menu (a dummy object having the role menu)
+ *       Role:menuitem (From QuicklistView->GetChildren)
+ *       Role:menuitem
+ *
+ */
+
+#include <glib/gi18n.h>
+
+#include "unity-quicklist-accessible.h"
+#include "unity-quicklist-menu-accessible.h"
+
+#include "unitya11y.h"
+#include "Launcher.h" /*without this I get a error with the following include*/
+#include "QuicklistView.h"
+
+/* GObject */
+static void unity_quicklist_accessible_class_init(UnityQuicklistAccessibleClass* klass);
+static void unity_quicklist_accessible_init(UnityQuicklistAccessible* self);
+
+/* AtkObject.h */
+static void         unity_quicklist_accessible_initialize(AtkObject* accessible,
+                                                          gpointer   data);
+static gint         unity_quicklist_accessible_get_n_children(AtkObject* obj);
+static AtkObject*   unity_quicklist_accessible_ref_child(AtkObject* obj,
+                                                         gint i);
+
+G_DEFINE_TYPE(UnityQuicklistAccessible, unity_quicklist_accessible,  NUX_TYPE_BASE_WINDOW_ACCESSIBLE);
+
+
+#define UNITY_QUICKLIST_ACCESSIBLE_GET_PRIVATE(obj)                      \
+  (G_TYPE_INSTANCE_GET_PRIVATE ((obj), UNITY_TYPE_QUICKLIST_ACCESSIBLE,  \
+                                UnityQuicklistAccessiblePrivate))
+
+struct _UnityQuicklistAccessiblePrivate
+{
+  AtkObject* menu_accessible;
+};
+
+
+static void
+unity_quicklist_accessible_class_init(UnityQuicklistAccessibleClass* klass)
+{
+  GObjectClass* gobject_class = G_OBJECT_CLASS(klass);
+  AtkObjectClass* atk_class = ATK_OBJECT_CLASS(klass);
+
+  /* AtkObject */
+  atk_class->initialize = unity_quicklist_accessible_initialize;
+  atk_class->get_n_children = unity_quicklist_accessible_get_n_children;
+  atk_class->ref_child = unity_quicklist_accessible_ref_child;
+
+  g_type_class_add_private(gobject_class, sizeof(UnityQuicklistAccessiblePrivate));
+}
+
+static void
+unity_quicklist_accessible_init(UnityQuicklistAccessible* self)
+{
+  UnityQuicklistAccessiblePrivate* priv =
+    UNITY_QUICKLIST_ACCESSIBLE_GET_PRIVATE(self);
+
+  self->priv = priv;
+  priv->menu_accessible = NULL;
+}
+
+AtkObject*
+unity_quicklist_accessible_new(nux::Object* object)
+{
+  AtkObject* accessible = NULL;
+
+  g_return_val_if_fail(dynamic_cast<QuicklistView*>(object), NULL);
+
+  accessible = ATK_OBJECT(g_object_new(UNITY_TYPE_QUICKLIST_ACCESSIBLE, NULL));
+
+  atk_object_initialize(accessible, object);
+
+  return accessible;
+}
+
+/* AtkObject.h */
+static void
+unity_quicklist_accessible_initialize(AtkObject* accessible,
+                                      gpointer data)
+{
+  nux::Object* nux_object = NULL;
+  QuicklistView* quicklist = NULL;
+
+  ATK_OBJECT_CLASS(unity_quicklist_accessible_parent_class)->initialize(accessible, data);
+
+  nux_object = nux_object_accessible_get_object(NUX_OBJECT_ACCESSIBLE(accessible));
+  quicklist = dynamic_cast<QuicklistView*>(nux_object);
+
+  if (quicklist == NULL) /* status defunct */
+    return;
+
+  atk_object_set_name(accessible, "Quicklist");
+
+}
+
+static gint
+unity_quicklist_accessible_get_n_children(AtkObject* obj)
+{
+  QuicklistView* quicklist = NULL;
+  nux::Object* nux_object = NULL;
+
+  g_return_val_if_fail(UNITY_IS_QUICKLIST_ACCESSIBLE(obj), 0);
+
+  nux_object = nux_object_accessible_get_object(NUX_OBJECT_ACCESSIBLE(obj));
+  quicklist = dynamic_cast<QuicklistView*>(nux_object);
+
+  if (quicklist == NULL)
+    return 0;
+  else
+    return 1;
+}
+
+static AtkObject*
+unity_quicklist_accessible_ref_child(AtkObject* obj,
+                                     gint i)
+{
+  UnityQuicklistAccessible* self = NULL;
+  QuicklistView* quicklist = NULL;
+  nux::Object* nux_object = NULL;
+
+  g_return_val_if_fail(UNITY_IS_QUICKLIST_ACCESSIBLE(obj), NULL);
+  self = UNITY_QUICKLIST_ACCESSIBLE(obj);
+
+  nux_object = nux_object_accessible_get_object(NUX_OBJECT_ACCESSIBLE(obj));
+  quicklist = dynamic_cast<QuicklistView*>(nux_object);
+  if (quicklist == NULL)
+    return NULL;
+
+  if (self->priv->menu_accessible == NULL)
+  {
+    self->priv->menu_accessible = unity_quicklist_menu_accessible_new(quicklist);
+    atk_object_set_parent(self->priv->menu_accessible, ATK_OBJECT(self));
+  }
+
+  g_object_ref(self->priv->menu_accessible);
+
+  return self->priv->menu_accessible;
+}

=== added file 'plugins/unityshell/src/unity-quicklist-accessible.h'
--- plugins/unityshell/src/unity-quicklist-accessible.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/unity-quicklist-accessible.h	2011-11-07 19:26:37 +0000
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2011 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * 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/>.
+ *
+ * Authored by: Alejandro Piñeiro Iglesias <[e-mail]>
+ */
+
+#ifndef UNITY_QUICKLIST_ACCESSIBLE_H
+#define UNITY_QUICKLIST_ACCESSIBLE_H
+
+#include <atk/atk.h>
+
+#include "nux-base-window-accessible.h"
+
+G_BEGIN_DECLS
+
+#define UNITY_TYPE_QUICKLIST_ACCESSIBLE            (unity_quicklist_accessible_get_type ())
+#define UNITY_QUICKLIST_ACCESSIBLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), UNITY_TYPE_QUICKLIST_ACCESSIBLE, UnityQuicklistAccessible))
+#define UNITY_QUICKLIST_ACCESSIBLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), UNITY_TYPE_QUICKLIST_ACCESSIBLE, UnityQuicklistAccessibleClass))
+#define UNITY_IS_QUICKLIST_ACCESSIBLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), UNITY_TYPE_QUICKLIST_ACCESSIBLE))
+#define UNITY_IS_QUICKLIST_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), UNITY_TYPE_QUICKLIST_ACCESSIBLE))
+#define UNITY_QUICKLIST_ACCESSIBLE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), UNITY_TYPE_QUICKLIST_ACCESSIBLE, UnityQuicklistAccessibleClass))
+
+typedef struct _UnityQuicklistAccessible        UnityQuicklistAccessible;
+typedef struct _UnityQuicklistAccessibleClass   UnityQuicklistAccessibleClass;
+typedef struct _UnityQuicklistAccessiblePrivate   UnityQuicklistAccessiblePrivate;
+
+struct _UnityQuicklistAccessible
+{
+  NuxBaseWindowAccessible parent;
+
+  /*< private >*/
+  UnityQuicklistAccessiblePrivate* priv;
+};
+
+struct _UnityQuicklistAccessibleClass
+{
+  NuxViewAccessibleClass parent_class;
+};
+
+GType      unity_quicklist_accessible_get_type(void);
+AtkObject* unity_quicklist_accessible_new(nux::Object* object);
+
+G_END_DECLS
+
+#endif /* __UNITY_QUICKLIST_ACCESSIBLE_H__ */

=== added file 'plugins/unityshell/src/unity-quicklist-menu-accessible.cpp'
--- plugins/unityshell/src/unity-quicklist-menu-accessible.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/unity-quicklist-menu-accessible.cpp	2011-11-07 19:26:37 +0000
@@ -0,0 +1,367 @@
+/*
+ * Copyright (C) 2011 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * 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/>.
+ *
+ * Authored by: Alejandro Piñeiro Iglesias <[e-mail]>
+ */
+
+/**
+ * SECTION:unity-quicklist-accessible
+ * @Title: UnityQuicklistMenuAccessible
+ * @short_description: Implementation of the ATK interfaces for #QuicklistView as a menu
+ * @see_also: QuicklistView
+ *
+ * #UnityQuicklistAccessible implements the required ATK interfaces for
+ * #QuicklistView, exposing himself as a menu.
+ *
+ * Note that this object is a QuicklistAccessible delegated object. If
+ * you call unitya11y->get_accessible with a Quicklist it will return
+ * a QuicklistAccessible. QuicklistMenuAccessible should only be
+ * instantiated by QuicklistAccessible
+ *
+ * IMPLEMENTATION NOTES:
+ *
+ *  The desired accessible object hierarchy is the following one:
+ *    Role:menu
+ *     Role:menu-item
+ *     Role:menu-item.
+ *
+ *  But this quicklist is also a base window, so we can't set a role
+ *  menu, and then keeping it sending window messages.
+ *
+ *  So a new object, with role menu will be added to the hierarchy:
+ *  QuicklistMenu. It also hide the intermediate container objects.
+ *
+ * So we will have:
+ *   Role:window (the quicklist itself)
+ *     Role:menu (a dummy object having the role menu)
+ *       Role:menuitem (From QuicklistView->GetChildren)
+ *       Role:menuitem
+ *
+ */
+
+#include <glib/gi18n.h>
+
+#include "unity-quicklist-menu-accessible.h"
+
+#include "unitya11y.h"
+#include "Launcher.h" /*without this I get a error with the following include*/
+#include "QuicklistView.h"
+
+/* GObject */
+static void unity_quicklist_menu_accessible_class_init(UnityQuicklistMenuAccessibleClass* klass);
+static void unity_quicklist_menu_accessible_init(UnityQuicklistMenuAccessible* self);
+static void unity_quicklist_menu_accessible_finalize(GObject* object);
+
+/* AtkObject.h */
+static void         unity_quicklist_menu_accessible_initialize(AtkObject* accessible,
+                                                               gpointer   data);
+static gint         unity_quicklist_menu_accessible_get_n_children(AtkObject* obj);
+static AtkObject*   unity_quicklist_menu_accessible_ref_child(AtkObject* obj,
+                                                              gint i);
+
+/* AtkSelection */
+static void       atk_selection_interface_init(AtkSelectionIface* iface);
+static AtkObject* unity_quicklist_menu_accessible_ref_selection(AtkSelection* selection,
+                                                                gint i);
+static gint       unity_quicklist_menu_accessible_get_selection_count(AtkSelection* selection);
+static gboolean   unity_quicklist_menu_accessible_is_child_selected(AtkSelection* selection,
+                                                                    gint i);
+/* private */
+static void on_selection_change_cb(UnityQuicklistMenuAccessible* self);
+static void on_parent_activate_change_cb(AtkObject* parent_window,
+                                         UnityQuicklistMenuAccessible* self);
+static void on_parent_change_cb(gchar* property,
+                                GValue* value,
+                                gpointer data);
+
+G_DEFINE_TYPE_WITH_CODE(UnityQuicklistMenuAccessible,
+                        unity_quicklist_menu_accessible,  NUX_TYPE_OBJECT_ACCESSIBLE,
+                        G_IMPLEMENT_INTERFACE(ATK_TYPE_SELECTION, atk_selection_interface_init));
+
+
+#define UNITY_QUICKLIST_MENU_ACCESSIBLE_GET_PRIVATE(obj)                      \
+  (G_TYPE_INSTANCE_GET_PRIVATE ((obj), UNITY_TYPE_QUICKLIST_MENU_ACCESSIBLE,  \
+                                UnityQuicklistMenuAccessiblePrivate))
+
+struct _UnityQuicklistMenuAccessiblePrivate
+{
+  sigc::connection on_selection_change_connection;
+  guint on_parent_change_id;
+  guint on_parent_activate_change_id;
+};
+
+
+static void
+unity_quicklist_menu_accessible_class_init(UnityQuicklistMenuAccessibleClass* klass)
+{
+  GObjectClass* gobject_class = G_OBJECT_CLASS(klass);
+  AtkObjectClass* atk_class = ATK_OBJECT_CLASS(klass);
+
+  gobject_class->finalize = unity_quicklist_menu_accessible_finalize;
+
+  /* AtkObject */
+  atk_class->initialize = unity_quicklist_menu_accessible_initialize;
+  atk_class->get_n_children = unity_quicklist_menu_accessible_get_n_children;
+  atk_class->ref_child = unity_quicklist_menu_accessible_ref_child;
+
+  g_type_class_add_private(gobject_class, sizeof(UnityQuicklistMenuAccessiblePrivate));
+}
+
+static void
+unity_quicklist_menu_accessible_init(UnityQuicklistMenuAccessible* self)
+{
+  UnityQuicklistMenuAccessiblePrivate* priv =
+    UNITY_QUICKLIST_MENU_ACCESSIBLE_GET_PRIVATE(self);
+
+  self->priv = priv;
+}
+
+static void
+unity_quicklist_menu_accessible_finalize(GObject* object)
+{
+  UnityQuicklistMenuAccessible* self = UNITY_QUICKLIST_MENU_ACCESSIBLE(object);
+
+  self->priv->on_selection_change_connection.disconnect();
+
+  if (self->priv->on_parent_change_id != 0)
+    g_signal_handler_disconnect(object, self->priv->on_parent_change_id);
+
+  G_OBJECT_CLASS(unity_quicklist_menu_accessible_parent_class)->finalize(object);
+}
+
+AtkObject*
+unity_quicklist_menu_accessible_new(nux::Object* object)
+{
+  AtkObject* accessible = NULL;
+
+  g_return_val_if_fail(dynamic_cast<QuicklistView*>(object), NULL);
+
+  accessible = ATK_OBJECT(g_object_new(UNITY_TYPE_QUICKLIST_MENU_ACCESSIBLE, NULL));
+
+  atk_object_initialize(accessible, object);
+
+  return accessible;
+}
+
+/* AtkObject.h */
+static void
+unity_quicklist_menu_accessible_initialize(AtkObject* accessible,
+                                           gpointer data)
+{
+  nux::Object* nux_object = NULL;
+  QuicklistView* quicklist = NULL;
+  UnityQuicklistMenuAccessible* self = NULL;
+
+  ATK_OBJECT_CLASS(unity_quicklist_menu_accessible_parent_class)->initialize(accessible, data);
+  self = UNITY_QUICKLIST_MENU_ACCESSIBLE(accessible);
+
+  nux_object = nux_object_accessible_get_object(NUX_OBJECT_ACCESSIBLE(accessible));
+  quicklist = dynamic_cast<QuicklistView*>(nux_object);
+
+  if (quicklist == NULL) /* status defunct */
+    return;
+
+  atk_object_set_role(accessible, ATK_ROLE_MENU);
+  atk_object_set_name(accessible, "QuicklistMenu");
+
+  self->priv->on_selection_change_connection =
+    quicklist->selection_change.connect(sigc::bind(sigc::ptr_fun(on_selection_change_cb), self));
+
+  self->priv->on_parent_change_id =
+    g_signal_connect(accessible, "notify::accessible-parent",
+                     G_CALLBACK(on_parent_change_cb), self);
+}
+
+static gint
+unity_quicklist_menu_accessible_get_n_children(AtkObject* obj)
+{
+  QuicklistView* quicklist = NULL;
+  nux::Object* nux_object = NULL;
+
+  g_return_val_if_fail(UNITY_IS_QUICKLIST_MENU_ACCESSIBLE(obj), 0);
+
+  nux_object = nux_object_accessible_get_object(NUX_OBJECT_ACCESSIBLE(obj));
+  quicklist = dynamic_cast<QuicklistView*>(nux_object);
+
+  if (quicklist == NULL)
+    return 0;
+
+  return quicklist->GetNumItems();
+}
+
+static AtkObject*
+unity_quicklist_menu_accessible_ref_child(AtkObject* obj,
+                                          gint i)
+{
+  QuicklistView* quicklist = NULL;
+  QuicklistMenuItem* child = NULL;
+  AtkObject* child_accessible = NULL;
+  AtkObject* parent = NULL;
+  nux::Object* nux_object = NULL;
+
+  g_return_val_if_fail(UNITY_IS_QUICKLIST_MENU_ACCESSIBLE(obj), NULL);
+
+  nux_object = nux_object_accessible_get_object(NUX_OBJECT_ACCESSIBLE(obj));
+  quicklist = dynamic_cast<QuicklistView*>(nux_object);
+
+  if (quicklist == NULL)
+    return NULL;
+
+  child = quicklist->GetNthItems(i);
+  child_accessible = unity_a11y_get_accessible(child);
+
+  if (child_accessible != NULL)
+  {
+    g_object_ref(child_accessible);
+    parent = atk_object_get_parent(child_accessible);
+    if (parent != obj)
+      atk_object_set_parent(child_accessible, obj);
+  }
+
+  return child_accessible;
+}
+
+/* AtkSelection */
+static void
+atk_selection_interface_init(AtkSelectionIface* iface)
+{
+  iface->ref_selection = unity_quicklist_menu_accessible_ref_selection;
+  iface->get_selection_count = unity_quicklist_menu_accessible_get_selection_count;
+  iface->is_child_selected = unity_quicklist_menu_accessible_is_child_selected;
+
+  /* NOTE: for the moment we don't provide the implementation for the
+     "interactable" methods, it is, the methods that allow to change
+     the selected icon. The QuicklistView doesn't provide that API, and
+     right now  we are focusing on a normal user input.*/
+}
+
+static AtkObject*
+unity_quicklist_menu_accessible_ref_selection(AtkSelection* selection,
+                                              gint i)
+{
+  QuicklistView* quicklist = NULL;
+  QuicklistMenuItem* child = NULL;
+  AtkObject* child_accessible = NULL;
+  nux::Object* nux_object = NULL;
+
+  g_return_val_if_fail(UNITY_IS_QUICKLIST_MENU_ACCESSIBLE(selection), NULL);
+  /* there can be only one item selected */
+  g_return_val_if_fail(i == 0, NULL);
+
+  nux_object = nux_object_accessible_get_object(NUX_OBJECT_ACCESSIBLE(selection));
+  quicklist = dynamic_cast<QuicklistView*>(nux_object);
+
+  if (quicklist == NULL) /*state is defunct */
+    return NULL;
+
+  child = quicklist->GetSelectedMenuItem();
+  child_accessible = unity_a11y_get_accessible(child);
+
+  if (child_accessible != NULL)
+    g_object_ref(child_accessible);
+
+  return child_accessible;
+}
+
+static gint
+unity_quicklist_menu_accessible_get_selection_count(AtkSelection* selection)
+{
+  QuicklistView* quicklist = NULL;
+  nux::Object* nux_object = NULL;
+
+  g_return_val_if_fail(UNITY_IS_QUICKLIST_MENU_ACCESSIBLE(selection), 0);
+
+  /*
+   * Looking at QuicklistView code, there is always one item selected,
+   * anyway we check that there is at least one item
+   */
+  nux_object = nux_object_accessible_get_object(NUX_OBJECT_ACCESSIBLE(selection));
+  quicklist = dynamic_cast<QuicklistView*>(nux_object);
+
+  if (quicklist == NULL) /*state is defunct */
+    return 0;
+
+  if (quicklist->GetNumItems() > 0)
+    return 1;
+  else
+    return 0;
+}
+
+static gboolean
+unity_quicklist_menu_accessible_is_child_selected(AtkSelection* selection,
+                                                  gint i)
+{
+  QuicklistView* quicklist = NULL;
+  QuicklistMenuItem* selected = NULL;
+  QuicklistMenuItem* ith_item = NULL;
+  nux::Object* nux_object = NULL;
+
+  g_return_val_if_fail(UNITY_IS_QUICKLIST_MENU_ACCESSIBLE(selection), FALSE);
+
+  nux_object = nux_object_accessible_get_object(NUX_OBJECT_ACCESSIBLE(selection));
+  quicklist = dynamic_cast<QuicklistView*>(nux_object);
+
+  if (quicklist == NULL) /*state is defunct */
+    return FALSE;
+
+  selected = quicklist->GetSelectedMenuItem();
+  ith_item = quicklist->GetNthItems(i);
+
+  if (selected == ith_item)
+    return TRUE;
+  else
+    return FALSE;
+}
+
+/* private */
+static void
+on_selection_change_cb(UnityQuicklistMenuAccessible* self)
+{
+  g_signal_emit_by_name(ATK_OBJECT(self), "selection-changed");
+}
+
+static void
+on_parent_activate_change_cb(AtkObject* parent_window,
+                             UnityQuicklistMenuAccessible* self)
+{
+  /* We consider that when our parent window is activated, the focus
+     should be on the menu, specifically on one of the menu-item. So
+     we emit a selection-change in order to notify that a selection
+     was made */
+  g_signal_emit_by_name(ATK_OBJECT(self), "selection-changed");
+}
+
+
+static void
+on_parent_change_cb(gchar* property,
+                    GValue* value,
+                    gpointer data)
+{
+  AtkObject* parent = NULL;
+  UnityQuicklistMenuAccessible* self = NULL;
+
+  g_return_if_fail(UNITY_IS_QUICKLIST_MENU_ACCESSIBLE(data));
+  self = UNITY_QUICKLIST_MENU_ACCESSIBLE(data);
+
+  parent = atk_object_get_parent(ATK_OBJECT(self));
+
+  if (parent == NULL)
+    return;
+
+  self->priv->on_parent_activate_change_id =
+    g_signal_connect(parent, "activate",
+                     G_CALLBACK(on_parent_activate_change_cb), self);
+}
+

=== added file 'plugins/unityshell/src/unity-quicklist-menu-accessible.h'
--- plugins/unityshell/src/unity-quicklist-menu-accessible.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/unity-quicklist-menu-accessible.h	2011-11-07 19:26:37 +0000
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2011 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * 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/>.
+ *
+ * Authored by: Alejandro Piñeiro Iglesias <[e-mail]>
+ */
+
+#ifndef UNITY_QUICKLIST_MENU_ACCESSIBLE_H
+#define UNITY_QUICKLIST_MENU_ACCESSIBLE_H
+
+#include <atk/atk.h>
+
+#include "nux-base-window-accessible.h"
+
+G_BEGIN_DECLS
+
+#define UNITY_TYPE_QUICKLIST_MENU_ACCESSIBLE            (unity_quicklist_menu_accessible_get_type ())
+#define UNITY_QUICKLIST_MENU_ACCESSIBLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), UNITY_TYPE_QUICKLIST_MENU_ACCESSIBLE, UnityQuicklistMenuAccessible))
+#define UNITY_QUICKLIST_MENU_ACCESSIBLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), UNITY_TYPE_QUICKLIST_MENU_ACCESSIBLE, UnityQuicklistMenuAccessibleClass))
+#define UNITY_IS_QUICKLIST_MENU_ACCESSIBLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), UNITY_TYPE_QUICKLIST_MENU_ACCESSIBLE))
+#define UNITY_IS_QUICKLIST_MENU_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), UNITY_TYPE_QUICKLIST_MENU_ACCESSIBLE))
+#define UNITY_QUICKLIST_MENU_ACCESSIBLE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), UNITY_TYPE_QUICKLIST_MENU_ACCESSIBLE, UnityQuicklistMenuAccessibleClass))
+
+typedef struct _UnityQuicklistMenuAccessible        UnityQuicklistMenuAccessible;
+typedef struct _UnityQuicklistMenuAccessibleClass   UnityQuicklistMenuAccessibleClass;
+typedef struct _UnityQuicklistMenuAccessiblePrivate   UnityQuicklistMenuAccessiblePrivate;
+
+struct _UnityQuicklistMenuAccessible
+{
+  NuxObjectAccessible parent;
+
+  /*< private >*/
+  UnityQuicklistMenuAccessiblePrivate* priv;
+};
+
+struct _UnityQuicklistMenuAccessibleClass
+{
+  NuxViewAccessibleClass parent_class;
+};
+
+GType      unity_quicklist_menu_accessible_get_type(void);
+AtkObject* unity_quicklist_menu_accessible_new(nux::Object* object);
+
+G_END_DECLS
+
+#endif /* __UNITY_QUICKLIST_MENU_ACCESSIBLE_H__ */

=== added file 'plugins/unityshell/src/unity-quicklist-menu-item-accessible.cpp'
--- plugins/unityshell/src/unity-quicklist-menu-item-accessible.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/unity-quicklist-menu-item-accessible.cpp	2011-11-07 19:26:37 +0000
@@ -0,0 +1,299 @@
+/*
+ * Copyright (C) 2011 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * 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/>.
+ *
+ * Authored by: Alejandro Piñeiro Iglesias <[e-mail]>
+ */
+
+/**
+ * SECTION:unity-quicklist_menu_item-accessible
+ * @Title: UnityQuicklistMenuItemAccessible
+ * @short_description: Implementation of the ATK interfaces for #QuicklistMenuItem
+ * @see_also: QuicklistMenuItem
+ *
+ * #UnityQuicklistMenuItemAccessible implements the required ATK interfaces for
+ * #QuicklistMenuItem, mainly exposing the text as his name, as this
+ * #object is mainly used as a label
+ *
+ */
+
+#include <glib/gi18n.h>
+
+#include "unity-quicklist-menu-item-accessible.h"
+
+#include "unitya11y.h"
+#include "QuicklistMenuItem.h"
+#include "QuicklistMenuItemLabel.h"
+#include "QuicklistMenuItemSeparator.h"
+
+/* GObject */
+static void unity_quicklist_menu_item_accessible_class_init(UnityQuicklistMenuItemAccessibleClass* klass);
+static void unity_quicklist_menu_item_accessible_init(UnityQuicklistMenuItemAccessible* self);
+static void unity_quicklist_menu_item_accessible_dispose(GObject* object);
+
+/* AtkObject.h */
+static void         unity_quicklist_menu_item_accessible_initialize(AtkObject* accessible,
+                                                                    gpointer   data);
+static const gchar* unity_quicklist_menu_item_accessible_get_name(AtkObject* obj);
+static AtkStateSet* unity_quicklist_menu_item_accessible_ref_state_set(AtkObject* obj);
+
+/* private */
+static void on_parent_selection_change_cb(AtkSelection* selection,
+                                          gpointer data);
+
+G_DEFINE_TYPE(UnityQuicklistMenuItemAccessible, unity_quicklist_menu_item_accessible,  NUX_TYPE_VIEW_ACCESSIBLE);
+
+
+#define UNITY_QUICKLIST_MENU_ITEM_ACCESSIBLE_GET_PRIVATE(obj)           \
+  (G_TYPE_INSTANCE_GET_PRIVATE ((obj), UNITY_TYPE_QUICKLIST_MENU_ITEM_ACCESSIBLE, \
+                                UnityQuicklistMenuItemAccessiblePrivate))
+
+struct _UnityQuicklistMenuItemAccessiblePrivate
+{
+  gboolean selected;
+
+  guint on_parent_selection_change_id;
+  guint on_parent_change_id;
+};
+
+
+static void
+unity_quicklist_menu_item_accessible_class_init(UnityQuicklistMenuItemAccessibleClass* klass)
+{
+  GObjectClass* gobject_class = G_OBJECT_CLASS(klass);
+  AtkObjectClass* atk_class = ATK_OBJECT_CLASS(klass);
+
+  gobject_class->dispose = unity_quicklist_menu_item_accessible_dispose;
+
+  /* AtkObject */
+  atk_class->get_name = unity_quicklist_menu_item_accessible_get_name;
+  atk_class->initialize = unity_quicklist_menu_item_accessible_initialize;
+  atk_class->ref_state_set = unity_quicklist_menu_item_accessible_ref_state_set;
+
+  g_type_class_add_private(gobject_class, sizeof(UnityQuicklistMenuItemAccessiblePrivate));
+}
+
+static void
+unity_quicklist_menu_item_accessible_init(UnityQuicklistMenuItemAccessible* self)
+{
+  UnityQuicklistMenuItemAccessiblePrivate* priv =
+    UNITY_QUICKLIST_MENU_ITEM_ACCESSIBLE_GET_PRIVATE(self);
+
+  self->priv = priv;
+}
+
+static void
+unity_quicklist_menu_item_accessible_dispose(GObject* object)
+{
+  UnityQuicklistMenuItemAccessible* self = UNITY_QUICKLIST_MENU_ITEM_ACCESSIBLE(object);
+  AtkObject* parent = NULL;
+
+  parent = atk_object_get_parent(ATK_OBJECT(object));
+
+  if (UNITY_IS_QUICKLIST_MENU_ITEM_ACCESSIBLE(parent))
+  {
+    if (self->priv->on_parent_selection_change_id != 0)
+      g_signal_handler_disconnect(parent, self->priv->on_parent_selection_change_id);
+  }
+
+  if (self->priv->on_parent_change_id != 0)
+    g_signal_handler_disconnect(object, self->priv->on_parent_change_id);
+
+  G_OBJECT_CLASS(unity_quicklist_menu_item_accessible_parent_class)->dispose(object);
+}
+
+AtkObject*
+unity_quicklist_menu_item_accessible_new(nux::Object* object)
+{
+  AtkObject* accessible = NULL;
+
+  g_return_val_if_fail(dynamic_cast<QuicklistMenuItem*>(object), NULL);
+
+  accessible = ATK_OBJECT(g_object_new(UNITY_TYPE_QUICKLIST_MENU_ITEM_ACCESSIBLE, NULL));
+
+  atk_object_initialize(accessible, object);
+
+  return accessible;
+}
+
+/* AtkObject.h */
+static gboolean
+menu_item_is_a_separator(QuicklistMenuItem* menu_item)
+{
+  QuicklistMenuItemSeparator* separator = NULL;
+
+  separator = dynamic_cast<QuicklistMenuItemSeparator*>(menu_item);
+
+  if (separator != NULL)
+    return TRUE;
+  else
+    return FALSE;
+}
+
+static void
+on_parent_change_cb(gchar* property,
+                    GValue* value,
+                    gpointer data)
+{
+  AtkObject* parent = NULL;
+  UnityQuicklistMenuItemAccessible* self = NULL;
+
+  g_return_if_fail(UNITY_IS_QUICKLIST_MENU_ITEM_ACCESSIBLE(data));
+  self = UNITY_QUICKLIST_MENU_ITEM_ACCESSIBLE(data);
+
+  parent = atk_object_get_parent(ATK_OBJECT(self));
+
+  if (parent == NULL)
+    return;
+
+  self->priv->on_parent_selection_change_id =
+    g_signal_connect(parent, "selection-changed",
+                     G_CALLBACK(on_parent_selection_change_cb), self);
+}
+
+static void
+unity_quicklist_menu_item_accessible_initialize(AtkObject* accessible,
+                                                gpointer data)
+{
+  nux::Object* nux_object = NULL;
+  QuicklistMenuItem* menu_item = NULL;
+  UnityQuicklistMenuItemAccessible* self = NULL;
+
+  ATK_OBJECT_CLASS(unity_quicklist_menu_item_accessible_parent_class)->initialize(accessible, data);
+  self = UNITY_QUICKLIST_MENU_ITEM_ACCESSIBLE(accessible);
+
+  nux_object = nux_object_accessible_get_object(NUX_OBJECT_ACCESSIBLE(accessible));
+  menu_item = dynamic_cast<QuicklistMenuItem*>(nux_object);
+
+  if (menu_item == NULL)
+    return;
+
+  if (menu_item_is_a_separator(menu_item))
+    atk_object_set_role(accessible, ATK_ROLE_SEPARATOR);
+  else
+    atk_object_set_role(accessible, ATK_ROLE_MENU_ITEM);
+
+  /* we could do that by redefining ->set_parent */
+  self->priv->on_parent_change_id =
+    g_signal_connect(accessible, "notify::accessible-parent",
+                     G_CALLBACK(on_parent_change_cb), self);
+}
+
+
+
+static const gchar*
+unity_quicklist_menu_item_accessible_get_name(AtkObject* obj)
+{
+  const gchar* name = NULL;
+
+  g_return_val_if_fail(UNITY_IS_QUICKLIST_MENU_ITEM_ACCESSIBLE(obj), NULL);
+
+  name = ATK_OBJECT_CLASS(unity_quicklist_menu_item_accessible_parent_class)->get_name(obj);
+  if (name == NULL)
+  {
+    QuicklistMenuItem* menu_item = NULL;
+
+    menu_item = dynamic_cast<QuicklistMenuItem*>(nux_object_accessible_get_object(NUX_OBJECT_ACCESSIBLE(obj)));
+    if (menu_item != NULL)
+    {
+      name = menu_item->GetLabel();
+    }
+  }
+
+  return name;
+}
+
+static AtkStateSet*
+unity_quicklist_menu_item_accessible_ref_state_set(AtkObject* obj)
+{
+  AtkStateSet* state_set = NULL;
+  UnityQuicklistMenuItemAccessible* self = NULL;
+  nux::Object* nux_object = NULL;
+
+  g_return_val_if_fail(UNITY_IS_QUICKLIST_MENU_ITEM_ACCESSIBLE(obj), NULL);
+  self = UNITY_QUICKLIST_MENU_ITEM_ACCESSIBLE(obj);
+
+  state_set = ATK_OBJECT_CLASS(unity_quicklist_menu_item_accessible_parent_class)->ref_state_set(obj);
+
+  nux_object = nux_object_accessible_get_object(NUX_OBJECT_ACCESSIBLE(obj));
+
+  if (nux_object == NULL) /* defunct */
+    return state_set;
+
+  /* by default */
+  atk_state_set_add_state(state_set, ATK_STATE_FOCUSABLE);
+  atk_state_set_add_state(state_set, ATK_STATE_ENABLED);
+  atk_state_set_add_state(state_set, ATK_STATE_SENSITIVE);
+
+  if (self->priv->selected)
+  {
+    atk_state_set_add_state(state_set, ATK_STATE_FOCUSED);
+    atk_state_set_add_state(state_set, ATK_STATE_SELECTED);
+    atk_state_set_add_state(state_set, ATK_STATE_ACTIVE);
+  }
+  else
+  {
+    /* we clean the states that could come from NuxAreaAccessible */
+    atk_state_set_remove_state(state_set, ATK_STATE_FOCUSED);
+  }
+
+  return state_set;
+}
+
+/* private */
+static void
+check_selected(UnityQuicklistMenuItemAccessible* self)
+{
+  AtkObject* selected_item = NULL;
+  AtkObject* parent = NULL;
+  nux::Object* nux_object = NULL;
+  gboolean found = FALSE;
+
+  nux_object = nux_object_accessible_get_object(NUX_OBJECT_ACCESSIBLE(self));
+  if (nux_object == NULL) /* state is defunct */
+    return;
+
+  parent = atk_object_get_parent(ATK_OBJECT(self));
+  if (parent == NULL)
+    return;
+
+  selected_item = atk_selection_ref_selection(ATK_SELECTION(parent), 0);
+
+  if (ATK_OBJECT(self) == selected_item)
+    found = TRUE;
+
+  if (found != self->priv->selected)
+  {
+    gboolean return_val = FALSE;
+
+    self->priv->selected = found;
+    atk_object_notify_state_change(ATK_OBJECT(self),
+                                   ATK_STATE_SELECTED,
+                                   found);
+    atk_object_notify_state_change(ATK_OBJECT(self),
+                                   ATK_STATE_ACTIVE,
+                                   found);
+
+    g_signal_emit_by_name(self, "focus-event", self->priv->selected, &return_val);
+  }
+}
+
+static void
+on_parent_selection_change_cb(AtkSelection* selection,
+                              gpointer data)
+{
+  g_return_if_fail(UNITY_IS_QUICKLIST_MENU_ITEM_ACCESSIBLE(data));
+
+  check_selected(UNITY_QUICKLIST_MENU_ITEM_ACCESSIBLE(data));
+}

=== added file 'plugins/unityshell/src/unity-quicklist-menu-item-accessible.h'
--- plugins/unityshell/src/unity-quicklist-menu-item-accessible.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/unity-quicklist-menu-item-accessible.h	2011-11-07 19:26:37 +0000
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2011 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * 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/>.
+ *
+ * Authored by: Alejandro Piñeiro Iglesias <[e-mail]>
+ */
+
+#ifndef UNITY_QUICKLIST_MENU_ITEM_ACCESSIBLE_H
+#define UNITY_QUICKLIST_MENU_ITEM_ACCESSIBLE_H
+
+#include <atk/atk.h>
+
+#include "nux-view-accessible.h"
+
+G_BEGIN_DECLS
+
+#define UNITY_TYPE_QUICKLIST_MENU_ITEM_ACCESSIBLE            (unity_quicklist_menu_item_accessible_get_type ())
+#define UNITY_QUICKLIST_MENU_ITEM_ACCESSIBLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), UNITY_TYPE_QUICKLIST_MENU_ITEM_ACCESSIBLE, UnityQuicklistMenuItemAccessible))
+#define UNITY_QUICKLIST_MENU_ITEM_ACCESSIBLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), UNITY_TYPE_QUICKLIST_MENU_ITEM_ACCESSIBLE, UnityQuicklistMenuItemAccessibleClass))
+#define UNITY_IS_QUICKLIST_MENU_ITEM_ACCESSIBLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), UNITY_TYPE_QUICKLIST_MENU_ITEM_ACCESSIBLE))
+#define UNITY_IS_QUICKLIST_MENU_ITEM_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), UNITY_TYPE_QUICKLIST_MENU_ITEM_ACCESSIBLE))
+#define UNITY_QUICKLIST_MENU_ITEM_ACCESSIBLE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), UNITY_TYPE_QUICKLIST_MENU_ITEM_ACCESSIBLE, UnityQuicklistMenuItemAccessibleClass))
+
+typedef struct _UnityQuicklistMenuItemAccessible        UnityQuicklistMenuItemAccessible;
+typedef struct _UnityQuicklistMenuItemAccessibleClass   UnityQuicklistMenuItemAccessibleClass;
+typedef struct _UnityQuicklistMenuItemAccessiblePrivate   UnityQuicklistMenuItemAccessiblePrivate;
+
+struct _UnityQuicklistMenuItemAccessible
+{
+  NuxViewAccessible parent;
+
+  /*< private >*/
+  UnityQuicklistMenuItemAccessiblePrivate* priv;
+};
+
+struct _UnityQuicklistMenuItemAccessibleClass
+{
+  NuxViewAccessibleClass parent_class;
+};
+
+GType      unity_quicklist_menu_item_accessible_get_type(void);
+AtkObject* unity_quicklist_menu_item_accessible_new(nux::Object* object);
+
+G_END_DECLS
+
+#endif /* __UNITY_QUICKLIST_MENU_ITEM_ACCESSIBLE_H__ */

=== modified file 'plugins/unityshell/src/unitya11y.cpp'
--- plugins/unityshell/src/unitya11y.cpp	2011-11-07 19:26:36 +0000
+++ plugins/unityshell/src/unitya11y.cpp	2011-11-07 19:26:37 +0000
@@ -39,6 +39,8 @@
 #include "DashView.h"
 #include "PlacesSimpleTile.h"
 #include "PlacesGroup.h"
+#include "QuicklistView.h"
+#include "QuicklistMenuItem.h"
 #include "unity-launcher-accessible.h"
 #include "unity-launcher-icon-accessible.h"
 #include "unity-panel-view-accessible.h"
@@ -48,6 +50,8 @@
 #include "unity-rvgrid-accessible.h"
 #include "unity-places-simple-tile-accessible.h"
 #include "unity-places-group-accessible.h"
+#include "unity-quicklist-accessible.h"
+#include "unity-quicklist-menu-item-accessible.h"
 
 using namespace unity;
 using namespace unity::dash;
@@ -281,6 +285,12 @@
   if (object->Type().IsDerivedFromType(PlacesGroup::StaticObjectType))
     return unity_places_group_accessible_new(object);
 
+  if (object->Type().IsDerivedFromType(QuicklistView::StaticObjectType))
+    return unity_quicklist_accessible_new(object);
+
+  if (object->Type().IsDerivedFromType(QuicklistMenuItem::StaticObjectType))
+    return unity_quicklist_menu_item_accessible_new(object);
+
   if (object->Type().IsDerivedFromType(nux::StaticCairoText::StaticObjectType))
     return unity_sctext_accessible_new(object);