Pileus Git - ~andy/gtk/blob - gtk/a11y/gtkmenuitemaccessible.c

   1 /* GTK+ - accessibility implementations
   2  * Copyright 2001, 2002, 2003 Sun Microsystems Inc.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library. If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include <string.h>
  19 #include <gtk/gtk.h>
  20 #include "gtkmenuitemaccessible.h"
  21 #include "gtkwidgetaccessibleprivate.h"
  22 #include "gtk/gtkmenuitemprivate.h"
  23
  24 struct _GtkMenuItemAccessiblePrivate
  25 {
  26   gchar *text;
  27   gboolean selected;
  28 };
  29
  30 #define KEYBINDING_SEPARATOR ";"
  31
  32 static void menu_item_select   (GtkMenuItem *item);
  33 static void menu_item_deselect (GtkMenuItem *item);
  34
  35 static GtkWidget *get_label_from_container   (GtkWidget *container);
  36 static gchar     *get_text_from_label_widget (GtkWidget *widget);
  37
  38 static gint menu_item_add_gtk    (GtkContainer   *container,
  39                                   GtkWidget      *widget);
  40 static gint menu_item_remove_gtk (GtkContainer   *container,
  41                                   GtkWidget      *widget);
  42
  43 static void atk_action_interface_init    (AtkActionIface *iface);
  44 static void atk_selection_interface_init (AtkSelectionIface *iface);
  45
  46 G_DEFINE_TYPE_WITH_CODE (GtkMenuItemAccessible, gtk_menu_item_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
  47                          G_IMPLEMENT_INTERFACE (ATK_TYPE_ACTION, atk_action_interface_init);
  48                          G_IMPLEMENT_INTERFACE (ATK_TYPE_SELECTION, atk_selection_interface_init))
  49
  50 static void
  51 gtk_menu_item_accessible_initialize (AtkObject *obj,
  52                                      gpointer   data)
  53 {
  54   GtkWidget *widget;
  55   GtkWidget *parent;
  56   GtkWidget *menu;
  57
  58   ATK_OBJECT_CLASS (gtk_menu_item_accessible_parent_class)->initialize (obj, data);
  59
  60   g_signal_connect (data, "select", G_CALLBACK (menu_item_select), NULL);
  61   g_signal_connect (data, "deselect", G_CALLBACK (menu_item_deselect), NULL);
  62
  63   widget = GTK_WIDGET (data);
  64   parent = gtk_widget_get_parent (widget);
  65   if (GTK_IS_MENU (parent))
  66     {
  67       GtkWidget *parent_widget;
  68
  69       parent_widget =  gtk_menu_get_attach_widget (GTK_MENU (parent));
  70
  71       if (!GTK_IS_MENU_ITEM (parent_widget))
  72         parent_widget = gtk_widget_get_parent (widget);
  73       if (parent_widget)
  74         atk_object_set_parent (obj, gtk_widget_get_accessible (parent_widget));
  75     }
  76
  77   _gtk_widget_accessible_set_layer (GTK_WIDGET_ACCESSIBLE (obj), ATK_LAYER_POPUP);
  78
  79   obj->role = ATK_ROLE_MENU_ITEM;
  80
  81   menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (data));
  82   if (menu)
  83     {
  84       g_signal_connect (menu, "add", G_CALLBACK (menu_item_add_gtk), NULL);
  85       g_signal_connect (menu, "remove", G_CALLBACK (menu_item_remove_gtk), NULL);
  86     }
  87 }
  88
  89 static gint
  90 gtk_menu_item_accessible_get_n_children (AtkObject *obj)
  91 {
  92   GtkWidget *widget;
  93   GtkWidget *submenu;
  94   gint count = 0;
  95
  96   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
  97   if (widget == NULL)
  98     return count;
  99
 100   submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (widget));
 101   if (submenu)
 102     {
 103       GList *children;
 104
 105       children = gtk_container_get_children (GTK_CONTAINER (submenu));
 106       count = g_list_length (children);
 107       g_list_free (children);
 108     }
 109   return count;
 110 }
 111
 112 static AtkObject *
 113 gtk_menu_item_accessible_ref_child (AtkObject *obj,
 114                                     gint       i)
 115 {
 116   AtkObject  *accessible;
 117   GtkWidget *widget;
 118   GtkWidget *submenu;
 119
 120   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
 121   if (widget == NULL)
 122     return NULL;
 123
 124   accessible = NULL;
 125   submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (widget));
 126   if (submenu)
 127     {
 128       GList *children;
 129       GList *tmp_list;
 130
 131       children = gtk_container_get_children (GTK_CONTAINER (submenu));
 132       tmp_list = g_list_nth (children, i);
 133       if (tmp_list)
 134         {
 135           accessible = gtk_widget_get_accessible (GTK_WIDGET (tmp_list->data));
 136           g_object_ref (accessible);
 137         }
 138       g_list_free (children);
 139     }
 140
 141   return accessible;
 142 }
 143
 144 static AtkStateSet *
 145 gtk_menu_item_accessible_ref_state_set (AtkObject *obj)
 146 {
 147   AtkObject *menu_item;
 148   AtkStateSet *state_set, *parent_state_set;
 149
 150   state_set = ATK_OBJECT_CLASS (gtk_menu_item_accessible_parent_class)->ref_state_set (obj);
 151
 152   atk_state_set_add_state (state_set, ATK_STATE_SELECTABLE);
 153   if (GTK_MENU_ITEM_ACCESSIBLE (obj)->priv->selected)
 154     atk_state_set_add_state (state_set, ATK_STATE_SELECTED);
 155
 156   menu_item = atk_object_get_parent (obj);
 157
 158   if (menu_item)
 159     {
 160       if (!GTK_IS_MENU_ITEM (gtk_accessible_get_widget (GTK_ACCESSIBLE (menu_item))))
 161         return state_set;
 162
 163       parent_state_set = atk_object_ref_state_set (menu_item);
 164       if (!atk_state_set_contains_state (parent_state_set, ATK_STATE_SELECTED))
 165         {
 166           atk_state_set_remove_state (state_set, ATK_STATE_FOCUSED);
 167           atk_state_set_remove_state (state_set, ATK_STATE_SHOWING);
 168         }
 169       g_object_unref (parent_state_set);
 170     }
 171
 172   return state_set;
 173 }
 174
 175 static AtkRole
 176 gtk_menu_item_accessible_get_role (AtkObject *obj)
 177 {
 178   GtkWidget *widget;
 179
 180   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
 181   if (widget != NULL &&
 182       gtk_menu_item_get_submenu (GTK_MENU_ITEM (widget)))
 183     return ATK_ROLE_MENU;
 184
 185   return ATK_OBJECT_CLASS (gtk_menu_item_accessible_parent_class)->get_role (obj);
 186 }
 187
 188 static const gchar *
 189 gtk_menu_item_accessible_get_name (AtkObject *obj)
 190 {
 191   const gchar *name;
 192   GtkWidget *widget;
 193   GtkWidget *label;
 194   GtkMenuItemAccessible *accessible;
 195
 196   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
 197   if (widget == NULL)
 198     return NULL;
 199
 200   name = ATK_OBJECT_CLASS (gtk_menu_item_accessible_parent_class)->get_name (obj);
 201   if (name)
 202     return name;
 203
 204   accessible = GTK_MENU_ITEM_ACCESSIBLE (obj);
 205   label = get_label_from_container (widget);
 206
 207   g_free (accessible->priv->text);
 208   accessible->priv->text = get_text_from_label_widget (label);
 209
 210   return accessible->priv->text;
 211 }
 212
 213 static void
 214 gtk_menu_item_accessible_finalize (GObject *object)
 215 {
 216   GtkMenuItemAccessible *accessible = GTK_MENU_ITEM_ACCESSIBLE (object);
 217
 218   g_free (accessible->priv->text);
 219
 220   G_OBJECT_CLASS (gtk_menu_item_accessible_parent_class)->finalize (object);
 221 }
 222
 223 static void
 224 gtk_menu_item_accessible_notify_gtk (GObject    *obj,
 225                                      GParamSpec *pspec)
 226 {
 227   AtkObject* atk_obj;
 228
 229   atk_obj = gtk_widget_get_accessible (GTK_WIDGET (obj));
 230
 231   if (strcmp (pspec->name, "label") == 0)
 232     {
 233       if (atk_obj->name == NULL)
 234         g_object_notify (G_OBJECT (atk_obj), "accessible-name");
 235       g_signal_emit_by_name (atk_obj, "visible-data-changed");
 236     }
 237   else
 238     GTK_WIDGET_ACCESSIBLE_CLASS (gtk_menu_item_accessible_parent_class)->notify_gtk (obj, pspec);
 239 }
 240
 241 static void
 242 gtk_menu_item_accessible_class_init (GtkMenuItemAccessibleClass *klass)
 243 {
 244   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 245   AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
 246   GtkWidgetAccessibleClass *widget_class = (GtkWidgetAccessibleClass*)klass;
 247
 248   widget_class->notify_gtk = gtk_menu_item_accessible_notify_gtk;
 249
 250   gobject_class->finalize = gtk_menu_item_accessible_finalize;
 251
 252   class->get_n_children = gtk_menu_item_accessible_get_n_children;
 253   class->ref_child = gtk_menu_item_accessible_ref_child;
 254   class->ref_state_set = gtk_menu_item_accessible_ref_state_set;
 255   class->initialize = gtk_menu_item_accessible_initialize;
 256   class->get_name = gtk_menu_item_accessible_get_name;
 257   class->get_role = gtk_menu_item_accessible_get_role;
 258
 259   g_type_class_add_private (klass, sizeof (GtkMenuItemAccessiblePrivate));
 260 }
 261
 262 static void
 263 gtk_menu_item_accessible_init (GtkMenuItemAccessible *menu_item)
 264 {
 265   menu_item->priv = G_TYPE_INSTANCE_GET_PRIVATE (menu_item,
 266                                                  GTK_TYPE_MENU_ITEM_ACCESSIBLE,
 267                                                  GtkMenuItemAccessiblePrivate);
 268 }
 269
 270 static GtkWidget *
 271 get_label_from_container (GtkWidget *container)
 272 {
 273   GtkWidget *label;
 274   GList *children, *tmp_list;
 275
 276   if (!GTK_IS_CONTAINER (container))
 277     return NULL;
 278
 279   children = gtk_container_get_children (GTK_CONTAINER (container));
 280   label = NULL;
 281
 282   for (tmp_list = children; tmp_list != NULL; tmp_list = tmp_list->next)
 283     {
 284       if (GTK_IS_LABEL (tmp_list->data))
 285         {
 286           label = tmp_list->data;
 287           break;
 288         }
 289       else if (GTK_IS_CELL_VIEW (tmp_list->data))
 290         {
 291           label = tmp_list->data;
 292           break;
 293         }
 294       else if (GTK_IS_BOX (tmp_list->data))
 295         {
 296           label = get_label_from_container (GTK_WIDGET (tmp_list->data));
 297           if (label)
 298             break;
 299         }
 300     }
 301   g_list_free (children);
 302
 303   return label;
 304 }
 305
 306 static gchar *
 307 get_text_from_label_widget (GtkWidget *label)
 308 {
 309   if (GTK_IS_LABEL (label))
 310     return g_strdup (gtk_label_get_text (GTK_LABEL (label)));
 311   else if (GTK_IS_CELL_VIEW (label))
 312     {
 313       GList *cells, *l;
 314       GtkTreeModel *model;
 315       GtkTreeIter iter;
 316       GtkTreePath *path;
 317       GtkCellArea *area;
 318       gchar *text;
 319
 320       model = gtk_cell_view_get_model (GTK_CELL_VIEW (label));
 321       path = gtk_cell_view_get_displayed_row (GTK_CELL_VIEW (label));
 322       gtk_tree_model_get_iter (model, &iter, path);
 323       gtk_tree_path_free (path);
 324
 325       area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (label));
 326       gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
 327       cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (label));
 328
 329       text = NULL;
 330       for (l = cells; l; l = l->next)
 331         {
 332           GtkCellRenderer *cell = l->data;
 333
 334           if (GTK_IS_CELL_RENDERER_TEXT (cell))
 335             {
 336               g_object_get (cell, "text", &text, NULL);
 337               break;
 338             }
 339         }
 340
 341       g_list_free (cells);
 342
 343       return text;
 344     }
 345
 346   return NULL;
 347 }
 348
 349 static void
 350 ensure_menus_unposted (GtkMenuItemAccessible *menu_item)
 351 {
 352   AtkObject *parent;
 353   GtkWidget *widget;
 354
 355   parent = atk_object_get_parent (ATK_OBJECT (menu_item));
 356   while (parent)
 357     {
 358       widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (parent));
 359       if (GTK_IS_MENU (widget))
 360         {
 361           if (gtk_widget_get_mapped (widget))
 362             gtk_menu_shell_cancel (GTK_MENU_SHELL (widget));
 363
 364           return;
 365         }
 366       parent = atk_object_get_parent (parent);
 367     }
 368 }
 369
 370 static gboolean
 371 gtk_menu_item_accessible_do_action (AtkAction *action,
 372                                     gint       i)
 373 {
 374   GtkWidget *item, *item_parent;
 375   gboolean item_mapped;
 376
 377   item = gtk_accessible_get_widget (GTK_ACCESSIBLE (action));
 378   if (item == NULL)
 379     return FALSE;
 380
 381   if (i != 0)
 382     return FALSE;
 383
 384   if (!gtk_widget_get_sensitive (item) || !gtk_widget_get_visible (item))
 385     return FALSE;
 386
 387   item_parent = gtk_widget_get_parent (item);
 388   if (!GTK_IS_MENU_SHELL (item_parent))
 389     return FALSE;
 390
 391   gtk_menu_shell_select_item (GTK_MENU_SHELL (item_parent), item);
 392   item_mapped = gtk_widget_get_mapped (item);
 393
 394   /* This is what is called when <Return> is pressed for a menu item.
 395    * The last argument means 'force hide'.
 396    */
 397   g_signal_emit_by_name (item_parent, "activate-current", 1);
 398   if (!item_mapped)
 399     ensure_menus_unposted (GTK_MENU_ITEM_ACCESSIBLE (action));
 400
 401   return TRUE;
 402 }
 403
 404 static gint
 405 gtk_menu_item_accessible_get_n_actions (AtkAction *action)
 406 {
 407   GtkWidget *item;
 408
 409   item = gtk_accessible_get_widget (GTK_ACCESSIBLE (action));
 410   if (item == NULL)
 411     return 0;
 412
 413   if (!_gtk_menu_item_is_selectable (item))
 414     return 0;
 415
 416   return 1;
 417 }
 418
 419 static const gchar *
 420 gtk_menu_item_accessible_action_get_name (AtkAction *action,
 421                                           gint       i)
 422 {
 423   if (i != 0 || gtk_menu_item_accessible_get_n_actions (action) == 0)
 424     return NULL;
 425
 426   return "click";
 427 }
 428
 429 static gboolean
 430 find_accel_by_widget (GtkAccelKey *key,
 431                       GClosure    *closure,
 432                       gpointer     data)
 433 {
 434   /* We assume that closure->data points to the widget
 435    * pending gtk_widget_get_accel_closures being made public
 436    */
 437   return data == (gpointer) closure->data;
 438 }
 439
 440 static gboolean
 441 find_accel_by_closure (GtkAccelKey *key,
 442                        GClosure    *closure,
 443                        gpointer     data)
 444 {
 445   return data == (gpointer) closure;
 446 }
 447
 448 /* This function returns a string of the form A;B;C where A is
 449  * the keybinding for the widget; B is the keybinding to traverse
 450  * from the menubar and C is the accelerator. The items in the
 451  * keybinding to traverse from the menubar are separated by ":".
 452  */
 453 static const gchar *
 454 gtk_menu_item_accessible_get_keybinding (AtkAction *action,
 455                                          gint       i)
 456 {
 457   gchar *keybinding = NULL;
 458   gchar *item_keybinding = NULL;
 459   gchar *full_keybinding = NULL;
 460   gchar *accelerator = NULL;
 461   GtkWidget *item;
 462   GtkWidget *temp_item;
 463   GtkWidget *child;
 464   GtkWidget *parent;
 465
 466   item = gtk_accessible_get_widget (GTK_ACCESSIBLE (action));
 467   if (item == NULL)
 468     return NULL;
 469
 470   if (i != 0)
 471     return NULL;
 472
 473   temp_item = item;
 474   while (TRUE)
 475     {
 476       GdkModifierType mnemonic_modifier = 0;
 477       guint key_val;
 478       gchar *key, *temp_keybinding;
 479
 480       child = gtk_bin_get_child (GTK_BIN (temp_item));
 481       if (child == NULL)
 482         return NULL;
 483
 484       parent = gtk_widget_get_parent (temp_item);
 485       if (!parent)
 486         /* parent can be NULL when activating a window from the panel */
 487         return NULL;
 488
 489       if (GTK_IS_MENU_BAR (parent))
 490         {
 491           GtkWidget *toplevel;
 492
 493           toplevel = gtk_widget_get_toplevel (parent);
 494           if (toplevel && GTK_IS_WINDOW (toplevel))
 495             mnemonic_modifier =
 496               gtk_window_get_mnemonic_modifier (GTK_WINDOW (toplevel));
 497         }
 498
 499       if (GTK_IS_LABEL (child))
 500         {
 501           key_val = gtk_label_get_mnemonic_keyval (GTK_LABEL (child));
 502           if (key_val != GDK_KEY_VoidSymbol)
 503             {
 504               key = gtk_accelerator_name (key_val, mnemonic_modifier);
 505               if (full_keybinding)
 506                 temp_keybinding = g_strconcat (key, ":", full_keybinding, NULL);
 507               else
 508                 temp_keybinding = g_strdup (key);
 509
 510               if (temp_item == item)
 511                 item_keybinding = g_strdup (key);
 512
 513               g_free (key);
 514               g_free (full_keybinding);
 515               full_keybinding = temp_keybinding;
 516             }
 517           else
 518             {
 519               /* No keybinding */
 520               g_free (full_keybinding);
 521               full_keybinding = NULL;
 522               break;
 523             }
 524         }
 525
 526       /* We have reached the menu bar so we are finished */
 527       if (GTK_IS_MENU_BAR (parent))
 528         break;
 529
 530       g_return_val_if_fail (GTK_IS_MENU (parent), NULL);
 531       temp_item = gtk_menu_get_attach_widget (GTK_MENU (parent));
 532       if (!GTK_IS_MENU_ITEM (temp_item))
 533         {
 534           /* Menu is attached to something other than a menu item;
 535            * probably an option menu
 536            */
 537           g_free (full_keybinding);
 538           full_keybinding = NULL;
 539           break;
 540         }
 541     }
 542
 543   parent = gtk_widget_get_parent (item);
 544   if (GTK_IS_MENU (parent))
 545     {
 546       GtkAccelGroup *group;
 547       GtkAccelKey *key;
 548
 549       group = gtk_menu_get_accel_group (GTK_MENU (parent));
 550       if (group)
 551         key = gtk_accel_group_find (group, find_accel_by_widget, item);
 552       else
 553         {
 554           key = NULL;
 555           child = gtk_bin_get_child (GTK_BIN (item));
 556           if (GTK_IS_ACCEL_LABEL (child))
 557             {
 558               GtkAccelLabel *accel_label;
 559               GClosure      *accel_closure;
 560
 561               accel_label = GTK_ACCEL_LABEL (child);
 562               g_object_get (accel_label, "accel-closure", &accel_closure, NULL);
 563               if (accel_closure)
 564                 {
 565                   key = gtk_accel_group_find (gtk_accel_group_from_accel_closure (accel_closure),
 566                                               find_accel_by_closure,
 567                                               accel_closure);
 568                   g_closure_unref (accel_closure);
 569                 }
 570             }
 571         }
 572
 573      if (key)
 574        accelerator = gtk_accelerator_name (key->accel_key, key->accel_mods);
 575    }
 576
 577   /* Concatenate the bindings */
 578   if (item_keybinding || full_keybinding || accelerator)
 579     {
 580       gchar *temp;
 581       if (item_keybinding)
 582         {
 583           keybinding = g_strconcat (item_keybinding, KEYBINDING_SEPARATOR, NULL);
 584           g_free (item_keybinding);
 585         }
 586       else
 587         keybinding = g_strdup (KEYBINDING_SEPARATOR);
 588
 589       if (full_keybinding)
 590         {
 591           temp = g_strconcat (keybinding, full_keybinding,
 592                               KEYBINDING_SEPARATOR, NULL);
 593           g_free (full_keybinding);
 594         }
 595       else
 596         temp = g_strconcat (keybinding, KEYBINDING_SEPARATOR, NULL);
 597
 598       g_free (keybinding);
 599       keybinding = temp;
 600       if (accelerator)
 601         {
 602           temp = g_strconcat (keybinding, accelerator, NULL);
 603           g_free (accelerator);
 604           g_free (keybinding);
 605           keybinding = temp;
 606       }
 607     }
 608
 609   return keybinding;
 610 }
 611
 612 static void
 613 atk_action_interface_init (AtkActionIface *iface)
 614 {
 615   iface->do_action = gtk_menu_item_accessible_do_action;
 616   iface->get_n_actions = gtk_menu_item_accessible_get_n_actions;
 617   iface->get_name = gtk_menu_item_accessible_action_get_name;
 618   iface->get_keybinding = gtk_menu_item_accessible_get_keybinding;
 619 }
 620
 621 static void
 622 menu_item_selection (GtkMenuItem  *item,
 623                      gboolean      selected)
 624 {
 625   AtkObject *obj, *parent;
 626   gint i;
 627
 628   obj = gtk_widget_get_accessible (GTK_WIDGET (item));
 629   GTK_MENU_ITEM_ACCESSIBLE (obj)->priv->selected = selected;
 630   atk_object_notify_state_change (obj, ATK_STATE_SELECTED, selected);
 631
 632   for (i = 0; i < atk_object_get_n_accessible_children (obj); i++)
 633     {
 634       AtkObject *child;
 635       child = atk_object_ref_accessible_child (obj, i);
 636       atk_object_notify_state_change (child, ATK_STATE_SHOWING, selected);
 637       g_object_unref (child);
 638     }
 639   parent = atk_object_get_parent (obj);
 640   g_signal_emit_by_name (parent, "selection-changed");
 641 }
 642
 643 static gboolean
 644 gtk_menu_item_accessible_add_selection (AtkSelection *selection,
 645                                            gint          i)
 646 {
 647   GtkMenuShell *shell;
 648   GList *kids;
 649   guint length;
 650   GtkWidget *widget;
 651   GtkWidget *menu;
 652   GtkWidget *child;
 653
 654   widget =  gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
 655   if (widget == NULL)
 656     return FALSE;
 657
 658   menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (widget));
 659   if (menu == NULL)
 660     return FALSE;
 661
 662   shell = GTK_MENU_SHELL (menu);
 663   kids = gtk_container_get_children (GTK_CONTAINER (shell));
 664   length = g_list_length (kids);
 665   if (i < 0 || i > length)
 666     {
 667       g_list_free (kids);
 668       return FALSE;
 669     }
 670
 671   child = g_list_nth_data (kids, i);
 672   g_list_free (kids);
 673   g_return_val_if_fail (GTK_IS_MENU_ITEM (child), FALSE);
 674   gtk_menu_shell_select_item (shell, GTK_WIDGET (child));
 675   return TRUE;
 676 }
 677
 678 static gboolean
 679 gtk_menu_item_accessible_clear_selection (AtkSelection *selection)
 680 {
 681   GtkWidget *widget;
 682   GtkWidget *menu;
 683
 684   widget =  gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
 685   if (widget == NULL)
 686     return FALSE;
 687
 688   menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (widget));
 689   if (menu == NULL)
 690     return FALSE;
 691
 692   gtk_menu_shell_deselect (GTK_MENU_SHELL (menu));
 693
 694   return TRUE;
 695 }
 696
 697 static AtkObject *
 698 gtk_menu_item_accessible_ref_selection (AtkSelection *selection,
 699                                            gint          i)
 700 {
 701   GtkMenuShell *shell;
 702   AtkObject *obj;
 703   GtkWidget *widget;
 704   GtkWidget *menu;
 705   GtkWidget *item;
 706
 707   if (i != 0)
 708     return NULL;
 709
 710   widget =  gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
 711   if (widget == NULL)
 712     return NULL;
 713
 714   menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (widget));
 715   if (menu == NULL)
 716     return NULL;
 717
 718   shell = GTK_MENU_SHELL (menu);
 719
 720   item = gtk_menu_shell_get_selected_item (shell);
 721   if (item != NULL)
 722     {
 723       obj = gtk_widget_get_accessible (item);
 724       g_object_ref (obj);
 725       return obj;
 726     }
 727
 728   return NULL;
 729 }
 730
 731 static gint
 732 gtk_menu_item_accessible_get_selection_count (AtkSelection *selection)
 733 {
 734   GtkMenuShell *shell;
 735   GtkWidget *widget;
 736   GtkWidget *menu;
 737
 738   widget =  gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
 739   if (widget == NULL)
 740     return 0;
 741
 742   menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (widget));
 743   if (menu == NULL)
 744     return 0;
 745
 746   shell = GTK_MENU_SHELL (menu);
 747
 748   if (gtk_menu_shell_get_selected_item (shell) != NULL)
 749     return 1;
 750
 751   return 0;
 752 }
 753
 754 static gboolean
 755 gtk_menu_item_accessible_is_child_selected (AtkSelection *selection,
 756                                                gint          i)
 757 {
 758   GtkMenuShell *shell;
 759   gint j;
 760   GtkWidget *widget;
 761   GtkWidget *menu;
 762   GtkWidget *item;
 763   GList *kids;
 764
 765   widget =  gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
 766   if (widget == NULL)
 767     return FALSE;
 768
 769   menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (widget));
 770   if (menu == NULL)
 771     return FALSE;
 772
 773   shell = GTK_MENU_SHELL (menu);
 774
 775   item = gtk_menu_shell_get_selected_item (shell);
 776   if (item == NULL)
 777     return FALSE;
 778
 779   kids = gtk_container_get_children (GTK_CONTAINER (shell));
 780   j = g_list_index (kids, item);
 781   g_list_free (kids);
 782
 783   return j==i;
 784 }
 785
 786 static gboolean
 787 gtk_menu_item_accessible_remove_selection (AtkSelection *selection,
 788                                               gint          i)
 789 {
 790   GtkMenuShell *shell;
 791   GtkWidget *widget;
 792   GtkWidget *menu;
 793   GtkWidget *item;
 794
 795   if (i != 0)
 796     return FALSE;
 797
 798   widget =  gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
 799   if (widget == NULL)
 800     return FALSE;
 801
 802   menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (widget));
 803   if (menu == NULL)
 804     return FALSE;
 805
 806   shell = GTK_MENU_SHELL (menu);
 807
 808   item = gtk_menu_shell_get_selected_item (shell);
 809   if (item && gtk_menu_item_get_submenu (GTK_MENU_ITEM (item)))
 810     gtk_menu_shell_deselect (shell);
 811
 812   return TRUE;
 813 }
 814
 815 static void
 816 atk_selection_interface_init (AtkSelectionIface *iface)
 817 {
 818   iface->add_selection = gtk_menu_item_accessible_add_selection;
 819   iface->clear_selection = gtk_menu_item_accessible_clear_selection;
 820   iface->ref_selection = gtk_menu_item_accessible_ref_selection;
 821   iface->get_selection_count = gtk_menu_item_accessible_get_selection_count;
 822   iface->is_child_selected = gtk_menu_item_accessible_is_child_selected;
 823   iface->remove_selection = gtk_menu_item_accessible_remove_selection;
 824 }
 825
 826 static gint
 827 menu_item_add_gtk (GtkContainer *container,
 828                    GtkWidget    *widget)
 829 {
 830   GtkWidget *parent_widget;
 831
 832   g_return_val_if_fail (GTK_IS_MENU (container), 1);
 833
 834   parent_widget = gtk_menu_get_attach_widget (GTK_MENU (container));
 835   if (GTK_IS_MENU_ITEM (parent_widget))
 836     {
 837       GTK_CONTAINER_ACCESSIBLE_CLASS (gtk_menu_item_accessible_parent_class)->add_gtk (container, widget, gtk_widget_get_accessible (parent_widget));
 838
 839     }
 840   return 1;
 841 }
 842
 843 static gint
 844 menu_item_remove_gtk (GtkContainer *container,
 845                       GtkWidget    *widget)
 846 {
 847   GtkWidget *parent_widget;
 848
 849   g_return_val_if_fail (GTK_IS_MENU (container), 1);
 850
 851   parent_widget = gtk_menu_get_attach_widget (GTK_MENU (container));
 852   if (GTK_IS_MENU_ITEM (parent_widget))
 853     {
 854       GTK_CONTAINER_ACCESSIBLE_CLASS (gtk_menu_item_accessible_parent_class)->remove_gtk (container, widget, gtk_widget_get_accessible (parent_widget));
 855     }
 856   return 1;
 857 }
 858 static void
 859 menu_item_select (GtkMenuItem *item)
 860 {
 861   menu_item_selection (item, TRUE);
 862 }
 863
 864 static void
 865 menu_item_deselect (GtkMenuItem *item)
 866 {
 867   menu_item_selection (item, FALSE);
 868 }