GNOME.org
 

[gtk+/a11y] Convert Gail(Sub)MenuItem to GtkAccessible classes

commit bdc5de12323aa55ea7c8b62a35a88f5e88209f4e
Author: Matthias Clasen <mclasen redhat com>
Date:   Fri Jul 1 16:59:46 2011 -0400

    Convert Gail(Sub)MenuItem to GtkAccessible classes
    
    This is along the same lines as the previous commit,
    with the same caveat.

 gtk/a11y/Makefile.am                               |    8 +-
 gtk/a11y/gail.c                                    |    3 -
 gtk/a11y/gailcontainer.h                           |    5 +-
 gtk/a11y/gailmenuitem.c                            |  806 --------------------
 gtk/a11y/gailmenuitem.h                            |   60 --
 gtk/a11y/gailsubmenuitem.h                         |   54 --
 gtk/a11y/gtkcheckmenuitemaccessible.c              |    2 +-
 gtk/a11y/gtkcheckmenuitemaccessible.h              |    6 +-
 gtk/a11y/gtkchecksubmenuitemaccessible.c           |    2 +-
 gtk/a11y/gtkchecksubmenuitemaccessible.h           |    6 +-
 gtk/a11y/gtkexpanderaccessible.c                   |    3 -
 gtk/a11y/gtkmenuitemaccessible.c                   |  605 +++++++++++++++
 gtk/a11y/gtkmenuitemaccessible.h                   |   53 ++
 ...ailsubmenuitem.c => gtksubmenuitemaccessible.c} |  172 ++---
 gtk/a11y/gtksubmenuitemaccessible.h                |   51 ++
 gtk/gtkmenuitem.c                                  |   20 +
 16 files changed, 796 insertions(+), 1060 deletions(-)
---
diff --git a/gtk/a11y/Makefile.am b/gtk/a11y/Makefile.am
index f310305..922c077 100644
--- a/gtk/a11y/Makefile.am
+++ b/gtk/a11y/Makefile.am
@@ -25,7 +25,7 @@ gail_c_sources =			\
 	gailmisc.c			\
 	gailmenu.c			\
 	gailmenushell.c			\
-	gailmenuitem.c			\
+	gtkmenuitemaccessible.c		\
 	gtknotebookaccessible.c		\
 	gtknotebookpageaccessible.c	\
 	gtkpanedaccessible.c		\
@@ -40,7 +40,7 @@ gail_c_sources =			\
 	gtkscrollbaraccessible.c	\
 	gtkscrolledwindowaccessible.c	\
 	gtkspinbuttonaccessible.c	\
-	gailsubmenuitem.c		\
+	gtksubmenuitemaccessible.c	\
 	gtkstatusbaraccessible.c	\
 	gailtextcell.c			\
 	gailtextutil.c			\
@@ -77,7 +77,7 @@ gail_private_h_sources =		\
 	gailmisc.h			\
 	gailmenu.h			\
 	gailmenushell.h			\
-	gailmenuitem.h			\
+	gtkmenuitemaccessible.h		\
 	gtknotebookaccessible.h		\
 	gtknotebookpageaccessible.h	\
 	gtkpanedaccessible.h		\
@@ -92,7 +92,7 @@ gail_private_h_sources =		\
 	gtkscrollbaraccessible.h	\
 	gtkscrolledwindowaccessible.h	\
 	gtkspinbuttonaccessible.h	\
-	gailsubmenuitem.h		\
+	gtksubmenuitemaccessible.h	\
 	gtkstatusbaraccessible.h	\
 	gailtextcell.h			\
 	gailtextutil.h			\
diff --git a/gtk/a11y/gail.c b/gtk/a11y/gail.c
index bcb867b..cb8cfc4 100644
--- a/gtk/a11y/gail.c
+++ b/gtk/a11y/gail.c
@@ -31,7 +31,6 @@
 #include "gailimagecell.h"
 #include "gailmenu.h"
 #include "gailmenushell.h"
-#include "gailmenuitem.h"
 #include "gailrenderercell.h"
 #include "gailtextcell.h"
 #include "gailtoplevel.h"
@@ -86,7 +85,6 @@ static GQuark quark_focus_object = 0;
 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_WIDGET, GailWidget, gail_widget, GTK_TYPE_WIDGET)
 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_CONTAINER, GailContainer, gail_container, GTK_TYPE_CONTAINER)
 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_BUTTON, GailButton, gail_button, GTK_TYPE_BUTTON)
-GAIL_IMPLEMENT_FACTORY_WITH_FUNC (GAIL_TYPE_MENU_ITEM, GailMenuItem, gail_menu_item, gail_menu_item_new)
 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_MENU_SHELL, GailMenuShell, gail_menu_shell, GTK_TYPE_MENU_SHELL)
 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_MENU, GailMenu, gail_menu, GTK_TYPE_MENU)
 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_WINDOW, GailWindow, gail_window, GTK_TYPE_BIN)
@@ -837,7 +835,6 @@ gail_accessibility_module_init (void)
   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_WIDGET, gail_widget);
   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_CONTAINER, gail_container);
   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_BUTTON, gail_button);
-  GAIL_WIDGET_SET_FACTORY (GTK_TYPE_MENU_ITEM, gail_menu_item);
   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_MENU_BAR, gail_menu_shell);
   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_MENU, gail_menu);
   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_WINDOW, gail_window);
diff --git a/gtk/a11y/gailcontainer.h b/gtk/a11y/gailcontainer.h
index 0124199..d5094f6 100644
--- a/gtk/a11y/gailcontainer.h
+++ b/gtk/a11y/gailcontainer.h
@@ -38,10 +38,7 @@ struct _GailContainer
 {
   GailWidget parent;
 
-  /*
-   * Cached list of children
-   */
-  GList      *children;
+  GList *children;
 };
 
 GType gail_container_get_type (void);
diff --git a/gtk/a11y/gtkcheckmenuitemaccessible.c b/gtk/a11y/gtkcheckmenuitemaccessible.c
index 7eb9b0f..7348275 100644
--- a/gtk/a11y/gtkcheckmenuitemaccessible.c
+++ b/gtk/a11y/gtkcheckmenuitemaccessible.c
@@ -23,7 +23,7 @@
 #include "gtkcheckmenuitemaccessible.h"
 
 
-G_DEFINE_TYPE (GtkCheckMenuItemAccessible, gtk_check_menu_item_accessible, GAIL_TYPE_MENU_ITEM)
+G_DEFINE_TYPE (GtkCheckMenuItemAccessible, gtk_check_menu_item_accessible, GTK_TYPE_MENU_ITEM_ACCESSIBLE)
 
 static void
 toggled_cb (GtkWidget *widget)
diff --git a/gtk/a11y/gtkcheckmenuitemaccessible.h b/gtk/a11y/gtkcheckmenuitemaccessible.h
index 8749030..2adc424 100644
--- a/gtk/a11y/gtkcheckmenuitemaccessible.h
+++ b/gtk/a11y/gtkcheckmenuitemaccessible.h
@@ -20,7 +20,7 @@
 #ifndef __GTK_CHECK_MENU_ITEM_ACCESSIBLE_H__
 #define __GTK_CHECK_MENU_ITEM_ACCESSIBLE_H__
 
-#include "gailmenuitem.h"
+#include "gtkmenuitemaccessible.h"
 
 G_BEGIN_DECLS
 
@@ -36,12 +36,12 @@ typedef struct _GtkCheckMenuItemAccessibleClass GtkCheckMenuItemAccessibleClass;
 
 struct _GtkCheckMenuItemAccessible
 {
-  GailMenuItem parent;
+  GtkMenuItemAccessible parent;
 };
 
 struct _GtkCheckMenuItemAccessibleClass
 {
-  GailMenuItemClass parent_class;
+  GtkMenuItemAccessibleClass parent_class;
 };
 
 GType gtk_check_menu_item_accessible_get_type (void);
diff --git a/gtk/a11y/gtkchecksubmenuitemaccessible.c b/gtk/a11y/gtkchecksubmenuitemaccessible.c
index fe6681b..eb55c58 100644
--- a/gtk/a11y/gtkchecksubmenuitemaccessible.c
+++ b/gtk/a11y/gtkchecksubmenuitemaccessible.c
@@ -24,7 +24,7 @@
 #include "gtkchecksubmenuitemaccessible.h"
 
 
-G_DEFINE_TYPE (GtkCheckSubmenuItemAccessible, gtk_check_submenu_item_accessible, GAIL_TYPE_SUB_MENU_ITEM)
+G_DEFINE_TYPE (GtkCheckSubmenuItemAccessible, gtk_check_submenu_item_accessible, GTK_TYPE_SUBMENU_ITEM_ACCESSIBLE)
 
 static void
 toggled_cb (GtkWidget *widget)
diff --git a/gtk/a11y/gtkchecksubmenuitemaccessible.h b/gtk/a11y/gtkchecksubmenuitemaccessible.h
index 91065fc..bc4e8c3 100644
--- a/gtk/a11y/gtkchecksubmenuitemaccessible.h
+++ b/gtk/a11y/gtkchecksubmenuitemaccessible.h
@@ -20,7 +20,7 @@
 #ifndef __GTK_CHECK_SUBMENU_ITEM_ACCESSIBLE_H__
 #define __GTK_CHECK_SUBMENU_ITEM_ACCESSIBLE_H__
 
-#include "gailsubmenuitem.h"
+#include "gtksubmenuitemaccessible.h"
 
 G_BEGIN_DECLS
 
@@ -36,12 +36,12 @@ typedef struct _GtkCheckSubmenuItemAccessibleClass GtkCheckSubmenuItemAccessible
 
 struct _GtkCheckSubmenuItemAccessible
 {
-  GailSubMenuItem parent;
+  GtkSubmenuItemAccessible parent;
 };
 
 struct _GtkCheckSubmenuItemAccessibleClass
 {
-  GailSubMenuItemClass parent_class;
+  GtkSubmenuItemAccessibleClass parent_class;
 };
 
 GType gtk_check_submenu_item_accessible_get_type (void);
diff --git a/gtk/a11y/gtkexpanderaccessible.c b/gtk/a11y/gtkexpanderaccessible.c
index 105dfac..ab599f9 100644
--- a/gtk/a11y/gtkexpanderaccessible.c
+++ b/gtk/a11y/gtkexpanderaccessible.c
@@ -243,7 +243,6 @@ static const gchar *
 gtk_expander_accessible_get_keybinding (AtkAction *action,
                                         gint       i)
 {
-  GtkExpanderAccessible *expander;
   gchar *return_value = NULL;
   GtkWidget *widget;
   GtkWidget *label;
@@ -255,8 +254,6 @@ gtk_expander_accessible_get_keybinding (AtkAction *action,
   if (i != 0)
     return NULL;
 
-  expander = GTK_EXPANDER_ACCESSIBLE (action);
-
   label = gtk_expander_get_label_widget (GTK_EXPANDER (widget));
   if (GTK_IS_LABEL (label))
     {
diff --git a/gtk/a11y/gtkmenuitemaccessible.c b/gtk/a11y/gtkmenuitemaccessible.c
new file mode 100644
index 0000000..3f8d908
--- /dev/null
+++ b/gtk/a11y/gtkmenuitemaccessible.c
@@ -0,0 +1,605 @@
+/* GAIL - The GNOME Accessibility Implementation Library
+ * Copyright 2001, 2002, 2003 Sun Microsystems Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <string.h>
+#include <gtk/gtk.h>
+#include "gtkmenuitemaccessible.h"
+#include "gtksubmenuitemaccessible.h"
+
+#define KEYBINDING_SEPARATOR ";"
+
+static void menu_item_select   (GtkMenuItem *item);
+static void menu_item_deselect (GtkMenuItem *item);
+
+static GtkWidget *get_label_from_container   (GtkWidget *container);
+static gchar     *get_text_from_label_widget (GtkWidget *widget);
+
+
+static void atk_action_interface_init (AtkActionIface *iface);
+
+G_DEFINE_TYPE_WITH_CODE (GtkMenuItemAccessible, gtk_menu_item_accessible, GAIL_TYPE_CONTAINER,
+                         G_IMPLEMENT_INTERFACE (ATK_TYPE_ACTION, atk_action_interface_init))
+
+static void
+gtk_menu_item_accessible_initialize (AtkObject *obj,
+                                     gpointer   data)
+{
+  GtkWidget *widget;
+  GtkWidget *parent;
+
+  ATK_OBJECT_CLASS (gtk_menu_item_accessible_parent_class)->initialize (obj, data);
+
+  g_signal_connect (data, "select", G_CALLBACK (menu_item_select), NULL);
+  g_signal_connect (data, "deselect", G_CALLBACK (menu_item_deselect), NULL);
+
+  widget = GTK_WIDGET (data);
+  parent = gtk_widget_get_parent (widget);
+  if (GTK_IS_MENU (parent))
+    {
+      GtkWidget *parent_widget;
+
+      parent_widget =  gtk_menu_get_attach_widget (GTK_MENU (parent));
+
+      if (!GTK_IS_MENU_ITEM (parent_widget))
+        parent_widget = gtk_widget_get_parent (widget);
+      if (parent_widget)
+        atk_object_set_parent (obj, gtk_widget_get_accessible (parent_widget));
+    }
+
+  g_object_set_data (G_OBJECT (obj), "atk-component-layer", GINT_TO_POINTER (ATK_LAYER_POPUP));
+
+  if (GTK_IS_TEAROFF_MENU_ITEM (data))
+    obj->role = ATK_ROLE_TEAR_OFF_MENU_ITEM;
+  else if (GTK_IS_SEPARATOR_MENU_ITEM (data))
+    obj->role = ATK_ROLE_SEPARATOR;
+  else
+    obj->role = ATK_ROLE_MENU_ITEM;
+}
+
+static gint
+gtk_menu_item_accessible_get_n_children (AtkObject *obj)
+{
+  GtkWidget *widget;
+  GtkWidget *submenu;
+  gint count = 0;
+
+  widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
+  if (widget == NULL)
+    return count;
+
+  submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (widget));
+  if (submenu)
+    {
+      GList *children;
+
+      children = gtk_container_get_children (GTK_CONTAINER (submenu));
+      count = g_list_length (children);
+      g_list_free (children);
+    }
+  return count;
+}
+
+static AtkObject *
+gtk_menu_item_accessible_ref_child (AtkObject *obj,
+                                    gint       i)
+{
+  AtkObject  *accessible;
+  GtkWidget *widget;
+  GtkWidget *submenu;
+
+  widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
+  if (widget == NULL)
+    return NULL;
+
+  accessible = NULL;
+  submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (widget));
+  if (submenu)
+    {
+      GList *children;
+      GList *tmp_list;
+
+      children = gtk_container_get_children (GTK_CONTAINER (submenu));
+      tmp_list = g_list_nth (children, i);
+      if (tmp_list)
+        {
+          accessible = gtk_widget_get_accessible (GTK_WIDGET (tmp_list->data));
+          g_object_ref (accessible);
+        }
+      g_list_free (children);
+    }
+
+  return accessible;
+}
+
+static AtkStateSet *
+gtk_menu_item_accessible_ref_state_set (AtkObject *obj)
+{
+  AtkObject *menu_item;
+  AtkStateSet *state_set, *parent_state_set;
+
+  state_set = ATK_OBJECT_CLASS (gtk_menu_item_accessible_parent_class)->ref_state_set (obj);
+
+  menu_item = atk_object_get_parent (obj);
+
+  if (menu_item)
+    {
+      if (!GTK_IS_MENU_ITEM (gtk_accessible_get_widget (GTK_ACCESSIBLE (menu_item))))
+        return state_set;
+
+      parent_state_set = atk_object_ref_state_set (menu_item);
+      if (!atk_state_set_contains_state (parent_state_set, ATK_STATE_SELECTED))
+        {
+          atk_state_set_remove_state (state_set, ATK_STATE_FOCUSED);
+          atk_state_set_remove_state (state_set, ATK_STATE_SHOWING);
+        }
+    }
+
+  return state_set;
+}
+
+static const gchar *
+gtk_menu_item_accessible_get_name (AtkObject *obj)
+{
+  const gchar *name;
+  GtkWidget *widget;
+  GtkWidget *label;
+  GtkMenuItemAccessible *accessible;
+
+  widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
+  if (widget == NULL)
+    return NULL;
+
+  name = ATK_OBJECT_CLASS (gtk_menu_item_accessible_parent_class)->get_name (obj);
+  if (name)
+    return name;
+
+  accessible = GTK_MENU_ITEM_ACCESSIBLE (obj);
+  label = get_label_from_container (widget);
+
+  g_free (accessible->text);
+  accessible->text = get_text_from_label_widget (label);
+
+  return accessible->text;
+}
+
+static void
+gtk_menu_item_accessible_finalize (GObject *object)
+{
+  GtkMenuItemAccessible *accessible = GTK_MENU_ITEM_ACCESSIBLE (object);
+
+  g_free (accessible->text);
+
+  G_OBJECT_CLASS (gtk_menu_item_accessible_parent_class)->finalize (object);
+}
+
+static void
+gtk_menu_item_accessible_notify_gtk (GObject    *obj,
+                                     GParamSpec *pspec)
+{
+  AtkObject* atk_obj;
+
+  atk_obj = gtk_widget_get_accessible (GTK_WIDGET (obj));
+
+  if (strcmp (pspec->name, "label") == 0)
+    {
+      if (atk_obj->name == NULL)
+        g_object_notify (G_OBJECT (atk_obj), "accessible-name");
+      g_signal_emit_by_name (atk_obj, "visible_data_changed");
+    }
+  else
+    GAIL_WIDGET_CLASS (gtk_menu_item_accessible_parent_class)->notify_gtk (obj, pspec);
+}
+
+static void
+gtk_menu_item_accessible_class_init (GtkMenuItemAccessibleClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+  AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
+  GailWidgetClass *widget_class = (GailWidgetClass*)klass;
+
+  widget_class->notify_gtk = gtk_menu_item_accessible_notify_gtk;
+
+  gobject_class->finalize = gtk_menu_item_accessible_finalize;
+
+  class->get_n_children = gtk_menu_item_accessible_get_n_children;
+  class->ref_child = gtk_menu_item_accessible_ref_child;
+  class->ref_state_set = gtk_menu_item_accessible_ref_state_set;
+  class->initialize = gtk_menu_item_accessible_initialize;
+  class->get_name = gtk_menu_item_accessible_get_name;
+}
+
+static void
+gtk_menu_item_accessible_init (GtkMenuItemAccessible *menu_item)
+{
+}
+
+static GtkWidget *
+get_label_from_container (GtkWidget *container)
+{
+  GtkWidget *label;
+  GList *children, *tmp_list;
+
+  if (!GTK_IS_CONTAINER (container))
+    return NULL;
+
+  children = gtk_container_get_children (GTK_CONTAINER (container));
+  label = NULL;
+
+  for (tmp_list = children; tmp_list != NULL; tmp_list = tmp_list->next)
+    {
+      if (GTK_IS_LABEL (tmp_list->data))
+        {
+          label = tmp_list->data;
+          break;
+        }
+      else if (GTK_IS_CELL_VIEW (tmp_list->data))
+        {
+          label = tmp_list->data;
+          break;
+        }
+      else if (GTK_IS_BOX (tmp_list->data))
+        {
+          label = get_label_from_container (GTK_WIDGET (tmp_list->data));
+          if (label)
+            break;
+        }
+    }
+  g_list_free (children);
+
+  return label;
+}
+
+static gchar *
+get_text_from_label_widget (GtkWidget *label)
+{
+  if (GTK_IS_LABEL (label))
+    return g_strdup (gtk_label_get_text (GTK_LABEL (label)));
+  else if (GTK_IS_CELL_VIEW (label))
+    {
+      GList *cells, *l;
+      GtkTreeModel *model;
+      GtkTreeIter iter;
+      GtkTreePath *path;
+      GtkCellArea *area;
+      gchar *text;
+
+      model = gtk_cell_view_get_model (GTK_CELL_VIEW (label));
+      path = gtk_cell_view_get_displayed_row (GTK_CELL_VIEW (label));
+      gtk_tree_model_get_iter (model, &iter, path);
+      gtk_tree_path_free (path);
+
+      area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (label));
+      gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
+      cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (label));
+
+      text = NULL;
+      for (l = cells; l; l = l->next)
+        {
+          GtkCellRenderer *cell = l->data;
+
+          if (GTK_IS_CELL_RENDERER_TEXT (cell))
+            {
+              g_object_get (cell, "text", &text, NULL);
+              break;
+            }
+        }
+
+      g_list_free (cells);
+
+      return text;
+    }
+
+  return NULL;
+}
+
+static void
+ensure_menus_unposted (GtkMenuItemAccessible *menu_item)
+{
+  AtkObject *parent;
+  GtkWidget *widget;
+
+  parent = atk_object_get_parent (ATK_OBJECT (menu_item));
+  while (parent)
+    {
+      widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (parent));
+      if (GTK_IS_MENU (widget))
+        {
+          if (gtk_widget_get_mapped (widget))
+            gtk_menu_shell_cancel (GTK_MENU_SHELL (widget));
+
+          return;
+        }
+      parent = atk_object_get_parent (parent);
+    }
+}
+
+static gboolean
+gtk_menu_item_accessible_do_action (AtkAction *action,
+                                    gint       i)
+{
+  GtkWidget *item, *item_parent;
+  gboolean item_mapped;
+
+  item = gtk_accessible_get_widget (GTK_ACCESSIBLE (action));
+  if (item == NULL)
+    return FALSE;
+
+  if (i != 0)
+    return FALSE;
+
+  if (!gtk_widget_get_sensitive (item) || !gtk_widget_get_visible (item))
+    return FALSE;
+
+  item_parent = gtk_widget_get_parent (item);
+  if (!GTK_IS_MENU_SHELL (item_parent))
+    return FALSE;
+
+  gtk_menu_shell_select_item (GTK_MENU_SHELL (item_parent), item);
+  item_mapped = gtk_widget_get_mapped (item);
+
+  /* This is what is called when <Return> is pressed for a menu item.
+   * The last argument means 'force hide'.
+   */
+  g_signal_emit_by_name (item_parent, "activate_current", 1);
+  if (!item_mapped)
+    ensure_menus_unposted (GTK_MENU_ITEM_ACCESSIBLE (action));
+
+  return TRUE;
+}
+
+static gint
+gtk_menu_item_accessible_get_n_actions (AtkAction *action)
+{
+  return 1;
+}
+
+static const gchar *
+gtk_menu_item_accessible_action_get_name (AtkAction *action,
+                                          gint       i)
+{
+  if (i != 0)
+    return NULL;
+
+  return "click";
+}
+
+static gboolean
+find_accel_by_widget (GtkAccelKey *key,
+                      GClosure    *closure,
+                      gpointer     data)
+{
+  /* We assume that closure->data points to the widget
+   * pending gtk_widget_get_accel_closures being made public
+   */
+  return data == (gpointer) closure->data;
+}
+
+static gboolean
+find_accel_by_closure (GtkAccelKey *key,
+                       GClosure    *closure,
+                       gpointer     data)
+{
+  return data == (gpointer) closure;
+}
+
+/* This function returns a string of the form A;B;C where A is
+ * the keybinding for the widget; B is the keybinding to traverse
+ * from the menubar and C is the accelerator. The items in the
+ * keybinding to traverse from the menubar are separated by ":".
+ */
+static const gchar *
+gtk_menu_item_accessible_get_keybinding (AtkAction *action,
+                                         gint       i)
+{
+  gchar *keybinding = NULL;
+  gchar *item_keybinding = NULL;
+  gchar *full_keybinding = NULL;
+  gchar *accelerator = NULL;
+  GtkWidget *item;
+  GtkWidget *temp_item;
+  GtkWidget *child;
+  GtkWidget *parent;
+
+  item = gtk_accessible_get_widget (GTK_ACCESSIBLE (action));
+  if (item == NULL)
+    return NULL;
+
+  if (i != 0)
+    return NULL;
+
+  temp_item = item;
+  while (TRUE)
+    {
+      GdkModifierType mnemonic_modifier = 0;
+      guint key_val;
+      gchar *key, *temp_keybinding;
+
+      child = gtk_bin_get_child (GTK_BIN (temp_item));
+      if (child == NULL)
+        return NULL;
+
+      parent = gtk_widget_get_parent (temp_item);
+      if (!parent)
+        /* parent can be NULL when activating a window from the panel */
+        return NULL;
+
+      if (GTK_IS_MENU_BAR (parent))
+        {
+          GtkWidget *toplevel;
+
+          toplevel = gtk_widget_get_toplevel (parent);
+          if (toplevel && GTK_IS_WINDOW (toplevel))
+            mnemonic_modifier =
+              gtk_window_get_mnemonic_modifier (GTK_WINDOW (toplevel));
+        }
+
+      if (GTK_IS_LABEL (child))
+        {
+          key_val = gtk_label_get_mnemonic_keyval (GTK_LABEL (child));
+          if (key_val != GDK_KEY_VoidSymbol)
+            {
+              key = gtk_accelerator_name (key_val, mnemonic_modifier);
+              if (full_keybinding)
+                temp_keybinding = g_strconcat (key, ":", full_keybinding, NULL);
+              else
+                temp_keybinding = g_strdup (key);
+
+              if (temp_item == item)
+                item_keybinding = g_strdup (key);
+
+              g_free (key);
+              g_free (full_keybinding);
+              full_keybinding = temp_keybinding;
+            }
+          else
+            {
+              /* No keybinding */
+              g_free (full_keybinding);
+              full_keybinding = NULL;
+              break;
+            }
+        }
+
+      /* We have reached the menu bar so we are finished */
+      if (GTK_IS_MENU_BAR (parent))
+        break;
+
+      g_return_val_if_fail (GTK_IS_MENU (parent), NULL);
+      temp_item = gtk_menu_get_attach_widget (GTK_MENU (parent));
+      if (!GTK_IS_MENU_ITEM (temp_item))
+        {
+          /* Menu is attached to something other than a menu item;
+           * probably an option menu
+           */
+          g_free (full_keybinding);
+          full_keybinding = NULL;
+          break;
+        }
+    }
+
+  parent = gtk_widget_get_parent (item);
+  if (GTK_IS_MENU (parent))
+    {
+      GtkAccelGroup *group;
+      GtkAccelKey *key;
+
+      group = gtk_menu_get_accel_group (GTK_MENU (parent));
+      if (group)
+        key = gtk_accel_group_find (group, find_accel_by_widget, item);
+      else
+        {
+          key = NULL;
+          child = gtk_bin_get_child (GTK_BIN (item));
+          if (GTK_IS_ACCEL_LABEL (child))
+            {
+              GtkAccelLabel *accel_label;
+              GClosure      *accel_closure;
+
+              accel_label = GTK_ACCEL_LABEL (child);
+              g_object_get (accel_label, "accel-closure", &accel_closure, NULL);
+              if (accel_closure)
+                {
+                  key = gtk_accel_group_find (gtk_accel_group_from_accel_closure (accel_closure),
+                                              find_accel_by_closure,
+                                              accel_closure);
+                  g_closure_unref (accel_closure);
+                }
+            }
+        }
+
+     if (key)
+       accelerator = gtk_accelerator_name (key->accel_key, key->accel_mods);
+   }
+
+  /* Concatenate the bindings */
+  if (item_keybinding || full_keybinding || accelerator)
+    {
+      gchar *temp;
+      if (item_keybinding)
+        {
+          keybinding = g_strconcat (item_keybinding, KEYBINDING_SEPARATOR, NULL);
+          g_free (item_keybinding);
+        }
+      else
+        keybinding = g_strdup (KEYBINDING_SEPARATOR);
+
+      if (full_keybinding)
+        {
+          temp = g_strconcat (keybinding, full_keybinding,
+                              KEYBINDING_SEPARATOR, NULL);
+          g_free (full_keybinding);
+        }
+      else
+        temp = g_strconcat (keybinding, KEYBINDING_SEPARATOR, NULL);
+
+      g_free (keybinding);
+      keybinding = temp;
+      if (accelerator)
+        {
+          temp = g_strconcat (keybinding, accelerator, NULL);
+          g_free (accelerator);
+          g_free (keybinding);
+          keybinding = temp;
+      }
+    }
+
+  return keybinding;
+}
+
+static void
+atk_action_interface_init (AtkActionIface *iface)
+{
+  iface->do_action = gtk_menu_item_accessible_do_action;
+  iface->get_n_actions = gtk_menu_item_accessible_get_n_actions;
+  iface->get_name = gtk_menu_item_accessible_action_get_name;
+  iface->get_keybinding = gtk_menu_item_accessible_get_keybinding;
+}
+
+static void
+menu_item_selection (GtkMenuItem  *item,
+                     gboolean      selected)
+{
+  AtkObject *obj, *parent;
+  gint i;
+
+  obj = gtk_widget_get_accessible (GTK_WIDGET (item));
+  atk_object_notify_state_change (obj, ATK_STATE_SELECTED, selected);
+
+  for (i = 0; i < atk_object_get_n_accessible_children (obj); i++)
+    {
+      AtkObject *child;
+      child = atk_object_ref_accessible_child (obj, i);
+      atk_object_notify_state_change (child, ATK_STATE_SHOWING, selected);
+      g_object_unref (child);
+    }
+  parent = atk_object_get_parent (obj);
+  g_signal_emit_by_name (parent, "selection_changed");
+}
+
+static void
+menu_item_select (GtkMenuItem *item)
+{
+  menu_item_selection (item, TRUE);
+}
+
+static void
+menu_item_deselect (GtkMenuItem *item)
+{
+  menu_item_selection (item, FALSE);
+}
diff --git a/gtk/a11y/gtkmenuitemaccessible.h b/gtk/a11y/gtkmenuitemaccessible.h
new file mode 100644
index 0000000..88470da
--- /dev/null
+++ b/gtk/a11y/gtkmenuitemaccessible.h
@@ -0,0 +1,53 @@
+/* GAIL - The GNOME Accessibility Implementation Library
+ * Copyright 2001 Sun Microsystems Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __GTK_MENU_ITEM_ACCESSIBLE_H__
+#define __GTK_MENU_ITEM_ACCESSIBLE_H__
+
+#include "gailcontainer.h"
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_MENU_ITEM_ACCESSIBLE                     (gtk_menu_item_accessible_get_type ())
+#define GTK_MENU_ITEM_ACCESSIBLE(obj)                     (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_MENU_ITEM_ACCESSIBLE, GtkMenuItemAccessible))
+#define GTK_MENU_ITEM_ACCESSIBLE_CLASS(klass)             (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_MENU_ITEM_ACCESSIBLE, GtkMenuItemAccessibleClass))
+#define GTK_IS_MENU_ITEM_ACCESSIBLE(obj)                  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_MENU_ITEM_ACCESSIBLE))
+#define GTK_IS_MENU_ITEM_ACCESSIBLE_CLASS(klass)          (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_MENU_ITEM_ACCESSIBLE))
+#define GTK_MENU_ITEM_ACCESSIBLE_GET_CLASS(obj)           (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_MENU_ITEM_ACCESSIBLE, GtkMenuItemAccessibleClass))
+
+typedef struct _GtkMenuItemAccessible      GtkMenuItemAccessible;
+typedef struct _GtkMenuItemAccessibleClass GtkMenuItemAccessibleClass;
+
+struct _GtkMenuItemAccessible
+{
+  GailContainer parent;
+
+  gchar *text;
+};
+
+struct _GtkMenuItemAccessibleClass
+{
+  GailContainerClass parent_class;
+};
+
+GType gtk_menu_item_accessible_get_type (void);
+
+G_END_DECLS
+
+#endif /* __GTK_MENU_ITEM_ACCESSIBLE_H__ */
diff --git a/gtk/a11y/gailsubmenuitem.c b/gtk/a11y/gtksubmenuitemaccessible.c
similarity index 56%
rename from gtk/a11y/gailsubmenuitem.c
rename to gtk/a11y/gtksubmenuitemaccessible.c
index a571f98..cf879eb 100644
--- a/gtk/a11y/gailsubmenuitem.c
+++ b/gtk/a11y/gtksubmenuitemaccessible.c
@@ -20,104 +20,51 @@
 #include "config.h"
 
 #include <gtk/gtk.h>
-#include "gailsubmenuitem.h"
-
-static void         gail_sub_menu_item_class_init       (GailSubMenuItemClass *klass);
-static void         gail_sub_menu_item_init             (GailSubMenuItem *item);
-static void         gail_sub_menu_item_real_initialize  (AtkObject      *obj,
-                                                         gpointer       data);
-
-static void         atk_selection_interface_init        (AtkSelectionIface  *iface);
-static gboolean     gail_sub_menu_item_add_selection    (AtkSelection   *selection,
-                                                         gint           i);
-static gboolean     gail_sub_menu_item_clear_selection  (AtkSelection   *selection);
-static AtkObject*   gail_sub_menu_item_ref_selection    (AtkSelection   *selection,
-                                                         gint           i);
-static gint         gail_sub_menu_item_get_selection_count
-                                                        (AtkSelection   *selection);
-static gboolean     gail_sub_menu_item_is_child_selected
-                                                        (AtkSelection   *selection,
-                                                         gint           i);
-static gboolean     gail_sub_menu_item_remove_selection (AtkSelection   *selection,
-                                                         gint           i);
-static gint         menu_item_add_gtk                   (GtkContainer   *container,
-                                                         GtkWidget      *widget);
-static gint         menu_item_remove_gtk                (GtkContainer   *container,
-                                                         GtkWidget      *widget);
-
-G_DEFINE_TYPE_WITH_CODE (GailSubMenuItem, gail_sub_menu_item, GAIL_TYPE_MENU_ITEM,
-                         G_IMPLEMENT_INTERFACE (ATK_TYPE_SELECTION, atk_selection_interface_init))
+#include "gtksubmenuitemaccessible.h"
 
-static void
-gail_sub_menu_item_class_init (GailSubMenuItemClass *klass)
-{
-  AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
+static gint menu_item_add_gtk    (GtkContainer   *container,
+                                  GtkWidget      *widget);
+static gint menu_item_remove_gtk (GtkContainer   *container,
+                                  GtkWidget      *widget);
 
-  class->initialize = gail_sub_menu_item_real_initialize;
-}
+static void atk_selection_interface_init (AtkSelectionIface *iface);
 
-static void
-gail_sub_menu_item_init (GailSubMenuItem *item)
-{
-}
+G_DEFINE_TYPE_WITH_CODE (GtkSubmenuItemAccessible, gtk_submenu_item_accessible, GTK_TYPE_MENU_ITEM_ACCESSIBLE,
+                         G_IMPLEMENT_INTERFACE (ATK_TYPE_SELECTION, atk_selection_interface_init))
 
 static void
-gail_sub_menu_item_real_initialize (AtkObject *obj,
-                                   gpointer   data)
+gtk_submenu_item_accessible_initialize (AtkObject *obj,
+                                        gpointer   data)
 {
   GtkWidget *submenu;
 
-  ATK_OBJECT_CLASS (gail_sub_menu_item_parent_class)->initialize (obj, data);
+  ATK_OBJECT_CLASS (gtk_submenu_item_accessible_parent_class)->initialize (obj, data);
 
   submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (data));
   g_return_if_fail (submenu);
 
-  g_signal_connect (submenu,
-                    "add",
-                    G_CALLBACK (menu_item_add_gtk),
-                    NULL);
-  g_signal_connect (submenu,
-                    "remove",
-                    G_CALLBACK (menu_item_remove_gtk),
-                    NULL);
+  g_signal_connect (submenu, "add", G_CALLBACK (menu_item_add_gtk), NULL);
+  g_signal_connect (submenu, "remove", G_CALLBACK (menu_item_remove_gtk), NULL);
 
   obj->role = ATK_ROLE_MENU;
 }
 
-AtkObject*
-gail_sub_menu_item_new (GtkWidget *widget)
+static void
+gtk_submenu_item_accessible_class_init (GtkSubmenuItemAccessibleClass *klass)
 {
-  GObject *object;
-  AtkObject *accessible;
-
-  g_return_val_if_fail (GTK_IS_MENU_ITEM (widget), NULL);
-
-  object = g_object_new (GAIL_TYPE_SUB_MENU_ITEM, NULL);
-
-  accessible = ATK_OBJECT (object);
-  atk_object_initialize (accessible, widget);
+  AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
 
-  return accessible;
+  class->initialize = gtk_submenu_item_accessible_initialize;
 }
 
 static void
-atk_selection_interface_init (AtkSelectionIface *iface)
+gtk_submenu_item_accessible_init (GtkSubmenuItemAccessible *item)
 {
-  iface->add_selection = gail_sub_menu_item_add_selection;
-  iface->clear_selection = gail_sub_menu_item_clear_selection;
-  iface->ref_selection = gail_sub_menu_item_ref_selection;
-  iface->get_selection_count = gail_sub_menu_item_get_selection_count;
-  iface->is_child_selected = gail_sub_menu_item_is_child_selected;
-  iface->remove_selection = gail_sub_menu_item_remove_selection;
-  /*
-   * select_all_selection does not make sense for a submenu of a menu item
-   * so no implementation is provided.
-   */
 }
 
 static gboolean
-gail_sub_menu_item_add_selection (AtkSelection *selection,
-                                  gint          i)
+gtk_submenu_item_accessible_add_selection (AtkSelection *selection,
+                                           gint          i)
 {
   GtkMenuShell *shell;
   GList *kids;
@@ -128,7 +75,6 @@ gail_sub_menu_item_add_selection (AtkSelection *selection,
 
   widget =  gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
   if (widget == NULL)
-    /* State is defunct */
     return FALSE;
 
   submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (widget));
@@ -150,7 +96,7 @@ gail_sub_menu_item_add_selection (AtkSelection *selection,
 }
 
 static gboolean
-gail_sub_menu_item_clear_selection (AtkSelection   *selection)
+gtk_submenu_item_accessible_clear_selection (AtkSelection *selection)
 {
   GtkMenuShell *shell;
   GtkWidget *widget;
@@ -158,7 +104,6 @@ gail_sub_menu_item_clear_selection (AtkSelection   *selection)
 
   widget =  gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
   if (widget == NULL)
-    /* State is defunct */
     return FALSE;
 
   submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (widget));
@@ -169,9 +114,9 @@ gail_sub_menu_item_clear_selection (AtkSelection   *selection)
   return TRUE;
 }
 
-static AtkObject*
-gail_sub_menu_item_ref_selection (AtkSelection   *selection,
-                                  gint           i)
+static AtkObject *
+gtk_submenu_item_accessible_ref_selection (AtkSelection *selection,
+                                           gint          i)
 {
   GtkMenuShell *shell;
   AtkObject *obj;
@@ -184,7 +129,6 @@ gail_sub_menu_item_ref_selection (AtkSelection   *selection,
 
   widget =  gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
   if (widget == NULL)
-    /* State is defunct */
     return NULL;
 
   submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (widget));
@@ -198,14 +142,12 @@ gail_sub_menu_item_ref_selection (AtkSelection   *selection,
       g_object_ref (obj);
       return obj;
     }
-  else
-    {
-      return NULL;
-    }
+
+  return NULL;
 }
 
 static gint
-gail_sub_menu_item_get_selection_count (AtkSelection   *selection)
+gtk_submenu_item_accessible_get_selection_count (AtkSelection *selection)
 {
   GtkMenuShell *shell;
   GtkWidget *widget;
@@ -213,25 +155,21 @@ gail_sub_menu_item_get_selection_count (AtkSelection   *selection)
 
   widget =  gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
   if (widget == NULL)
-    /* State is defunct */
     return 0;
 
   submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (widget));
-  g_return_val_if_fail (GTK_IS_MENU_SHELL (submenu), FALSE);
+  g_return_val_if_fail (GTK_IS_MENU_SHELL (submenu), 0);
   shell = GTK_MENU_SHELL (submenu);
 
-  /*
-   * Identifies the currently selected menu item
-   */
-  if (gtk_menu_shell_get_selected_item (shell) == NULL)
-    return 0;
-  else
+  if (gtk_menu_shell_get_selected_item (shell) != NULL)
     return 1;
+
+  return 0;
 }
 
 static gboolean
-gail_sub_menu_item_is_child_selected (AtkSelection   *selection,
-                                       gint           i)
+gtk_submenu_item_accessible_is_child_selected (AtkSelection *selection,
+                                               gint          i)
 {
   GtkMenuShell *shell;
   gint j;
@@ -242,7 +180,6 @@ gail_sub_menu_item_is_child_selected (AtkSelection   *selection,
 
   widget =  gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
   if (widget == NULL)
-    /* State is defunct */
     return FALSE;
 
   submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (widget));
@@ -257,12 +194,12 @@ gail_sub_menu_item_is_child_selected (AtkSelection   *selection,
   j = g_list_index (kids, item);
   g_list_free (kids);
 
-  return (j==i);
+  return j==i;
 }
 
 static gboolean
-gail_sub_menu_item_remove_selection (AtkSelection   *selection,
-                                  gint           i)
+gtk_submenu_item_accessible_remove_selection (AtkSelection *selection,
+                                              gint          i)
 {
   GtkMenuShell *shell;
   GtkWidget *widget;
@@ -274,7 +211,6 @@ gail_sub_menu_item_remove_selection (AtkSelection   *selection,
 
   widget =  gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
   if (widget == NULL)
-    /* State is defunct */
     return FALSE;
 
   submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (widget));
@@ -283,19 +219,25 @@ gail_sub_menu_item_remove_selection (AtkSelection   *selection,
 
   item = gtk_menu_shell_get_selected_item (shell);
   if (item && gtk_menu_item_get_submenu (GTK_MENU_ITEM (item)))
-    {
-    /*
-     * Menu item contains a menu and it is the selected menu item
-     * so deselect it.
-     */
-      gtk_menu_shell_deselect (shell);
-    }
+    gtk_menu_shell_deselect (shell);
+
   return TRUE;
 }
 
+static void
+atk_selection_interface_init (AtkSelectionIface *iface)
+{
+  iface->add_selection = gtk_submenu_item_accessible_add_selection;
+  iface->clear_selection = gtk_submenu_item_accessible_clear_selection;
+  iface->ref_selection = gtk_submenu_item_accessible_ref_selection;
+  iface->get_selection_count = gtk_submenu_item_accessible_get_selection_count;
+  iface->is_child_selected = gtk_submenu_item_accessible_is_child_selected;
+  iface->remove_selection = gtk_submenu_item_accessible_remove_selection;
+}
+
 static gint
 menu_item_add_gtk (GtkContainer *container,
-                   GtkWidget	*widget)
+                   GtkWidget    *widget)
 {
   GtkWidget *parent_widget;
   AtkObject *atk_parent;
@@ -311,9 +253,8 @@ menu_item_add_gtk (GtkContainer *container,
       atk_parent = gtk_widget_get_accessible (parent_widget);
       atk_child = gtk_widget_get_accessible (widget);
 
+      g_object_notify (G_OBJECT (atk_child), "accessible-parent");
       gail_container = GAIL_CONTAINER (atk_parent);
-      g_object_notify (G_OBJECT (atk_child), "accessible_parent");
-
       g_list_free (gail_container->children);
       gail_container->children = gtk_container_get_children (container);
       index = g_list_index (gail_container->children, widget);
@@ -325,13 +266,12 @@ menu_item_add_gtk (GtkContainer *container,
 
 static gint
 menu_item_remove_gtk (GtkContainer *container,
-                      GtkWidget	   *widget)
+                      GtkWidget    *widget)
 {
   GtkWidget *parent_widget;
   AtkObject *atk_parent;
   AtkObject *atk_child;
   GailContainer *gail_container;
-  AtkPropertyValues values = { NULL };
   gint index;
   gint list_length;
 
@@ -343,13 +283,9 @@ menu_item_remove_gtk (GtkContainer *container,
       atk_parent = gtk_widget_get_accessible (parent_widget);
       atk_child = gtk_widget_get_accessible (widget);
 
-      gail_container = GAIL_CONTAINER (atk_parent);
-      g_value_init (&values.old_value, G_TYPE_POINTER);
-      g_value_set_pointer (&values.old_value, atk_parent);
-      values.property_name = "accessible-parent";
-      g_signal_emit_by_name (atk_child,
-                             "property_change::accessible-parent", &values, NULL);
+      g_object_notify (G_OBJECT (atk_child), "accessible-parent");
 
+      gail_container = GAIL_CONTAINER (atk_parent);
       index = g_list_index (gail_container->children, widget);
       list_length = g_list_length (gail_container->children);
       g_list_free (gail_container->children);
diff --git a/gtk/a11y/gtksubmenuitemaccessible.h b/gtk/a11y/gtksubmenuitemaccessible.h
new file mode 100644
index 0000000..4f7fbba
--- /dev/null
+++ b/gtk/a11y/gtksubmenuitemaccessible.h
@@ -0,0 +1,51 @@
+/* GAIL - The GNOME Accessibility Implementation Library
+ * Copyright 2002 Sun Microsystems Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __GTK_SUBMENU_ITEM_ACCESSIBLE_H__
+#define __GTK_SUBMENU_ITEM_ACCESSIBLE_H__
+
+#include "gtkmenuitemaccessible.h"
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_SUBMENU_ITEM_ACCESSIBLE                     (gtk_submenu_item_accessible_get_type ())
+#define GTK_SUBMENU_ITEM_ACCESSIBLE(obj)                     (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SUBMENU_ITEM_ACCESSIBLE, GtkSubmenuItemAccessible))
+#define GTK_SUBMENU_ITEM_ACCESSIBLE_CLASS(klass)             (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SUBMENU_ITEM_ACCESSIBLE, GtkSubmenuItemAccessibleClass))
+#define GTK_IS_SUBMENU_ITEM_ACCESSIBLE(obj)                  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SUBMENU_ITEM_ACCESSIBLE))
+#define GTK_IS_SUBMENU_ITEM_ACCESSIBLE_CLASS(klass)          (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SUBMENU_ITEM_ACCESSIBLE))
+#define GTK_SUBMENU_ITEM_ACCESSIBLE_GET_CLASS(obj)           (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SUBMENU_ITEM_ACCESSIBLE, GtkSubmenuItemAccessibleClass))
+
+typedef struct _GtkSubmenuItemAccessible      GtkSubmenuItemAccessible;
+typedef struct _GtkSubmenuItemAccessibleClass GtkSubmenuItemAccessibleClass;
+
+struct _GtkSubmenuItemAccessible
+{
+  GtkMenuItemAccessible parent;
+};
+
+struct _GtkSubmenuItemAccessibleClass
+{
+  GtkMenuItemAccessibleClass parent_class;
+};
+
+GType gtk_submenu_item_accessible_get_type (void);
+
+G_END_DECLS
+
+#endif /* __GTK_SUBMENU_ITEM_ACCESSIBLE_H__ */
diff --git a/gtk/gtkmenuitem.c b/gtk/gtkmenuitem.c
index 1537e84..0d96574 100644
--- a/gtk/gtkmenuitem.c
+++ b/gtk/gtkmenuitem.c
@@ -43,6 +43,8 @@
 #include "gtkwidgetprivate.h"
 #include "gtkintl.h"
 #include "gtktypebuiltins.h"
+#include "a11y/gtkmenuitemaccessible.h"
+#include "a11y/gtksubmenuitemaccessible.h"
 
 
 /**
@@ -207,6 +209,23 @@ G_DEFINE_TYPE_WITH_CODE (GtkMenuItem, gtk_menu_item, GTK_TYPE_BIN,
                          G_IMPLEMENT_INTERFACE (GTK_TYPE_ACTIVATABLE,
                                                 gtk_menu_item_activatable_interface_init))
 
+static AtkObject *
+gtk_menu_item_get_accessible (GtkWidget *widget)
+{
+  GObject *object;
+  AtkObject *accessible;
+
+  /* FIXME this is not really right, submenus can come and go */
+  if (gtk_menu_item_get_submenu (GTK_MENU_ITEM (widget)))
+    object = g_object_new (GTK_TYPE_SUBMENU_ITEM_ACCESSIBLE, NULL);
+  else
+    object = g_object_new (GTK_TYPE_MENU_ITEM_ACCESSIBLE, NULL);
+
+  accessible = ATK_OBJECT (object);
+  atk_object_initialize (accessible, widget);
+
+  return accessible;
+}
 
 static void
 gtk_menu_item_class_init (GtkMenuItemClass *klass)
@@ -235,6 +254,7 @@ gtk_menu_item_class_init (GtkMenuItemClass *klass)
   widget_class->get_preferred_width = gtk_menu_item_get_preferred_width;
   widget_class->get_preferred_height = gtk_menu_item_get_preferred_height;
   widget_class->get_preferred_height_for_width = gtk_menu_item_get_preferred_height_for_width;
+  widget_class->get_accessible = gtk_menu_item_get_accessible;
 
   container_class->forall = gtk_menu_item_forall;
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]