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

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