Debian Codegraph @

gtk/a11y/gtkmenuitemaccessible.c

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