Pileus Git - ~andy/gtk/blob - modules/other/gail/gail.c

   1 /* GAIL - The GNOME Accessibility Implementation Library
   2  * Copyright 2001 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, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include "config.h"
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24
  25 #include <gtk/gtk.h>
  26 #include "gail.h"
  27 #include "gailfactory.h"
  28
  29 #define GNOME_ACCESSIBILITY_ENV "GNOME_ACCESSIBILITY"
  30 #define NO_GAIL_ENV "NO_GAIL"
  31
  32 static gboolean gail_focus_watcher      (GSignalInvocationHint *ihint,
  33                                          guint                  n_param_values,
  34                                          const GValue          *param_values,
  35                                          gpointer               data);
  36 static gboolean gail_select_watcher     (GSignalInvocationHint *ihint,
  37                                          guint                  n_param_values,
  38                                          const GValue          *param_values,
  39                                          gpointer               data);
  40 static gboolean gail_deselect_watcher   (GSignalInvocationHint *ihint,
  41                                          guint                  n_param_values,
  42                                          const GValue          *param_values,
  43                                          gpointer               data);
  44 static gboolean gail_switch_page_watcher(GSignalInvocationHint *ihint,
  45                                          guint                  n_param_values,
  46                                          const GValue          *param_values,
  47                                          gpointer               data);
  48 static AtkObject* gail_get_accessible_for_widget (GtkWidget    *widget,
  49                                                   gboolean     *transient);
  50 static void     gail_finish_select       (GtkWidget            *widget);
  51 static void     gail_map_cb              (GtkWidget            *widget);
  52 static void     gail_map_submenu_cb      (GtkWidget            *widget);
  53 static gint     gail_focus_idle_handler  (gpointer             data);
  54 static void     gail_focus_notify        (GtkWidget            *widget);
  55 static void     gail_focus_notify_when_idle (GtkWidget            *widget);
  56
  57 static void     gail_focus_tracker_init (void);
  58 static void     gail_focus_object_destroyed (gpointer data);
  59 static void     gail_focus_tracker (AtkObject *object);
  60 static void     gail_set_focus_widget (GtkWidget *focus_widget,
  61                                        GtkWidget *widget);
  62 static void     gail_set_focus_object (AtkObject *focus_obj,
  63                                        AtkObject *obj);
  64
  65 GtkWidget* focus_widget = NULL;
  66 static GtkWidget* next_focus_widget = NULL;
  67 static gboolean was_deselect = FALSE;
  68 static GtkWidget* subsequent_focus_widget = NULL;
  69 static GtkWidget* focus_before_menu = NULL;
  70 static guint focus_notify_handler = 0;
  71 static guint focus_tracker_id = 0;
  72 static GQuark quark_focus_object = 0;
  73
  74 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_WIDGET, GailWidget, gail_widget, GTK_TYPE_WIDGET)
  75 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_CONTAINER, GailContainer, gail_container, GTK_TYPE_CONTAINER)
  76 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_BUTTON, GailButton, gail_button, GTK_TYPE_BUTTON)
  77 GAIL_IMPLEMENT_FACTORY_WITH_FUNC (GAIL_TYPE_MENU_ITEM, GailMenuItem, gail_menu_item, gail_menu_item_new)
  78 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_TOGGLE_BUTTON, GailToggleButton, gail_toggle_button, GTK_TYPE_TOGGLE_BUTTON)
  79 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_IMAGE, GailImage, gail_image, GTK_TYPE_IMAGE)
  80 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_TEXT_VIEW, GailTextView, gail_text_view, GTK_TYPE_TEXT_VIEW)
  81 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_COMBO_BOX, GailComboBox, gail_combo_box, GTK_TYPE_COMBO_BOX)
  82 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_ENTRY, GailEntry, gail_entry, GTK_TYPE_ENTRY)
  83 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_MENU_SHELL, GailMenuShell, gail_menu_shell, GTK_TYPE_MENU_SHELL)
  84 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_MENU, GailMenu, gail_menu, GTK_TYPE_MENU)
  85 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_WINDOW, GailWindow, gail_window, GTK_TYPE_BIN)
  86 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_RANGE, GailRange, gail_range, GTK_TYPE_RANGE)
  87 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_SCALE, GailScale, gail_scale, GTK_TYPE_SCALE)
  88 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_SCALE_BUTTON, GailScaleButton, gail_scale_button, GTK_TYPE_SCALE_BUTTON)
  89 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_LABEL, GailLabel, gail_label, GTK_TYPE_LABEL)
  90 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_STATUSBAR, GailStatusbar, gail_statusbar, GTK_TYPE_STATUSBAR)
  91 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_NOTEBOOK, GailNotebook, gail_notebook, GTK_TYPE_NOTEBOOK)
  92 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_CALENDAR, GailCalendar, gail_calendar, GTK_TYPE_CALENDAR)
  93 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_PROGRESS_BAR, GailProgressBar, gail_progress_bar, GTK_TYPE_PROGRESS_BAR)
  94 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_SPIN_BUTTON, GailSpinButton, gail_spin_button, GTK_TYPE_SPIN_BUTTON)
  95 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_TREE_VIEW, GailTreeView, gail_tree_view, GTK_TYPE_TREE_VIEW)
  96 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_FRAME, GailFrame, gail_frame, GTK_TYPE_FRAME)
  97 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_RADIO_BUTTON, GailRadioButton, gail_radio_button, GTK_TYPE_RADIO_BUTTON)
  98 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_ARROW, GailArrow, gail_arrow, GTK_TYPE_ARROW)
  99 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_SEPARATOR, GailSeparator, gail_separator, GTK_TYPE_SEPARATOR)
 100 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_BOX, GailBox, gail_box, GTK_TYPE_BOX)
 101 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_SCROLLED_WINDOW, GailScrolledWindow, gail_scrolled_window, GTK_TYPE_SCROLLED_WINDOW)
 102 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_PANED, GailPaned, gail_paned, GTK_TYPE_PANED)
 103 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_SCROLLBAR, GailScrollbar, gail_scrollbar, GTK_TYPE_SCROLLBAR)
 104 GAIL_IMPLEMENT_FACTORY_WITH_FUNC (GAIL_TYPE_CHECK_MENU_ITEM, GailCheckMenuItem, gail_check_menu_item, gail_check_menu_item_new)
 105 GAIL_IMPLEMENT_FACTORY_WITH_FUNC (GAIL_TYPE_RADIO_MENU_ITEM, GailRadioMenuItem, gail_radio_menu_item, gail_radio_menu_item_new)
 106 GAIL_IMPLEMENT_FACTORY (GAIL_TYPE_EXPANDER, GailExpander, gail_expander, GTK_TYPE_EXPANDER)
 107 GAIL_IMPLEMENT_FACTORY_WITH_FUNC_DUMMY (GAIL_TYPE_RENDERER_CELL, GailRendererCell, gail_renderer_cell, GTK_TYPE_CELL_RENDERER, gail_renderer_cell_new)
 108 GAIL_IMPLEMENT_FACTORY_WITH_FUNC_DUMMY (GAIL_TYPE_BOOLEAN_CELL, GailBooleanCell, gail_boolean_cell, GTK_TYPE_CELL_RENDERER_TOGGLE, gail_boolean_cell_new)
 109 GAIL_IMPLEMENT_FACTORY_WITH_FUNC_DUMMY (GAIL_TYPE_IMAGE_CELL, GailImageCell, gail_image_cell, GTK_TYPE_CELL_RENDERER_PIXBUF, gail_image_cell_new)
 110 GAIL_IMPLEMENT_FACTORY_WITH_FUNC_DUMMY (GAIL_TYPE_TEXT_CELL, GailTextCell, gail_text_cell, GTK_TYPE_CELL_RENDERER_TEXT, gail_text_cell_new)
 111
 112 static AtkObject*
 113 gail_get_accessible_for_widget (GtkWidget *widget,
 114                                 gboolean  *transient)
 115 {
 116   AtkObject *obj = NULL;
 117   GType gnome_canvas;
 118
 119   gnome_canvas = g_type_from_name ("GnomeCanvas");
 120
 121   *transient = FALSE;
 122   if (!widget)
 123     return NULL;
 124
 125   if (GTK_IS_ENTRY (widget))
 126     ;
 127   else if (GTK_IS_NOTEBOOK (widget))
 128     {
 129       GtkNotebook *notebook;
 130       gint page_num = -1;
 131
 132       notebook = GTK_NOTEBOOK (widget);
 133       page_num = gtk_notebook_get_current_page (notebook);
 134       if (page_num != -1)
 135         {
 136           obj = gtk_widget_get_accessible (widget);
 137           obj = atk_object_ref_accessible_child (obj, page_num);
 138           g_object_unref (obj);
 139         }
 140     }
 141   else if (G_TYPE_CHECK_INSTANCE_TYPE ((widget), gnome_canvas))
 142     {
 143       GObject *focused_item;
 144       GValue value = {0, };
 145
 146       g_value_init (&value, G_TYPE_OBJECT);
 147       g_object_get_property (G_OBJECT (widget), "focused_item", &value);
 148       focused_item = g_value_get_object (&value);
 149
 150       if (focused_item)
 151         {
 152           AtkObject *tmp;
 153
 154           obj = atk_gobject_accessible_for_object (G_OBJECT (focused_item));
 155           tmp = g_object_get_qdata (G_OBJECT (obj), quark_focus_object);
 156           if (tmp != NULL)
 157             obj = tmp;
 158         }
 159     }
 160   else if (GTK_IS_TOGGLE_BUTTON (widget))
 161     {
 162       GtkWidget *other_widget = gtk_widget_get_parent (widget);
 163       if (GTK_IS_COMBO_BOX (other_widget))
 164         {
 165           gail_set_focus_widget (other_widget, widget);
 166           widget = other_widget;
 167         }
 168     }
 169   if (obj == NULL)
 170     {
 171       AtkObject *focus_object;
 172
 173       obj = gtk_widget_get_accessible (widget);
 174       focus_object = g_object_get_qdata (G_OBJECT (obj), quark_focus_object);
 175       /*
 176        * We check whether the object for this focus_object has been deleted.
 177        * This can happen when navigating to an empty directory in nautilus.
 178        * See bug #141907.
 179        */
 180       if (ATK_IS_GOBJECT_ACCESSIBLE (focus_object))
 181         {
 182           if (!atk_gobject_accessible_get_object (ATK_GOBJECT_ACCESSIBLE (focus_object)))
 183             focus_object = NULL;
 184         }
 185       if (focus_object)
 186         obj = focus_object;
 187     }
 188
 189   return obj;
 190 }
 191
 192 static gboolean
 193 gail_focus_watcher (GSignalInvocationHint *ihint,
 194                     guint                  n_param_values,
 195                     const GValue          *param_values,
 196                     gpointer               data)
 197 {
 198   GObject *object;
 199   GtkWidget *widget;
 200   GdkEvent *event;
 201
 202   object = g_value_get_object (param_values + 0);
 203   g_return_val_if_fail (GTK_IS_WIDGET(object), FALSE);
 204
 205   event = g_value_get_boxed (param_values + 1);
 206   widget = GTK_WIDGET (object);
 207
 208   if (event->type == GDK_FOCUS_CHANGE)
 209     {
 210       if (event->focus_change.in)
 211         {
 212           if (GTK_IS_WINDOW (widget))
 213             {
 214               GtkWidget *focus_widget;
 215               GtkWindow *window;
 216               GtkWindowType type;
 217
 218               window = GTK_WINDOW (widget);
 219               focus_widget = gtk_window_get_focus (window);
 220               g_object_get (window, "type", &type, NULL);
 221
 222               if (focus_widget)
 223                 {
 224                   /*
 225                    * If we already have a potential focus widget set this
 226                    * windows's focus widget to focus_before_menu so that
 227                    * it will be reported when menu item is unset.
 228                    */
 229                   if (next_focus_widget)
 230                     {
 231                       if (GTK_IS_MENU_ITEM (next_focus_widget) &&
 232                           !focus_before_menu)
 233                         {
 234                           void *vp_focus_before_menu = &focus_before_menu;
 235                           focus_before_menu = focus_widget;
 236                           g_object_add_weak_pointer (G_OBJECT (focus_before_menu), vp_focus_before_menu);
 237                         }
 238
 239                       return TRUE;
 240                     }
 241                   widget = focus_widget;
 242                 }
 243               else if (type == GTK_WINDOW_POPUP)
 244                 {
 245                   if (GTK_IS_BIN (widget))
 246                     {
 247                       GtkWidget *child = gtk_bin_get_child (GTK_BIN (widget));
 248
 249                       if (GTK_IS_WIDGET (child) && gtk_widget_has_grab (child))
 250                         {
 251                           if (GTK_IS_MENU_SHELL (child))
 252                             {
 253                               if (GTK_MENU_SHELL (child)->active_menu_item)
 254                                 {
 255                                   /*
 256                                    * We have a menu which has a menu item selected
 257                                    * so we do not report focus on the menu.
 258                                    */
 259                                   return TRUE;
 260                                 }
 261                             }
 262                           widget = child;
 263                         }
 264                     }
 265                   else /* popup window has no children; this edge case occurs in some custom code (OOo for instance) */
 266                     {
 267                       return TRUE;
 268                     }
 269                 }
 270               else /* Widget is a non-popup toplevel with no focus children;
 271                       don't emit for this case either, as it's useless */
 272                 {
 273                   return TRUE;
 274                 }
 275             }
 276         }
 277       else
 278         {
 279           if (next_focus_widget)
 280             {
 281                GtkWidget *toplevel;
 282
 283                toplevel = gtk_widget_get_toplevel (next_focus_widget);
 284                if (toplevel == widget)
 285                  next_focus_widget = NULL;
 286             }
 287           /* focus out */
 288           widget = NULL;
 289         }
 290     }
 291   else
 292     {
 293       if (event->type == GDK_MOTION_NOTIFY && gtk_widget_has_focus (widget))
 294         {
 295           if (widget == focus_widget)
 296             {
 297               return TRUE;
 298             }
 299         }
 300       else
 301         {
 302           return TRUE;
 303         }
 304     }
 305   /*
 306    * If the focus widget is a GtkSocket without a plug
 307    * then ignore the focus notification as the embedded
 308    * plug will report a focus notification.
 309    */
 310   if (GTK_IS_SOCKET (widget) &&
 311       GTK_SOCKET (widget)->plug_widget == NULL)
 312     return TRUE;
 313   /*
 314    * The widget may not yet be visible on the screen so we wait until it is.
 315    */
 316   gail_focus_notify_when_idle (widget);
 317   return TRUE;
 318 }
 319
 320 static gboolean
 321 gail_select_watcher (GSignalInvocationHint *ihint,
 322                      guint                  n_param_values,
 323                      const GValue          *param_values,
 324                      gpointer               data)
 325 {
 326   GObject *object;
 327   GtkWidget *widget;
 328
 329   object = g_value_get_object (param_values + 0);
 330   g_return_val_if_fail (GTK_IS_WIDGET(object), FALSE);
 331
 332   widget = GTK_WIDGET (object);
 333
 334   if (!gtk_widget_get_mapped (widget))
 335     {
 336       g_signal_connect (widget, "map",
 337                         G_CALLBACK (gail_map_cb),
 338                         NULL);
 339     }
 340   else
 341     gail_finish_select (widget);
 342
 343   return TRUE;
 344 }
 345
 346 static void
 347 gail_finish_select (GtkWidget *widget)
 348 {
 349   if (GTK_IS_MENU_ITEM (widget))
 350     {
 351       GtkMenuItem* menu_item;
 352
 353       menu_item = GTK_MENU_ITEM (widget);
 354       if (menu_item->submenu &&
 355           !gtk_widget_get_mapped (menu_item->submenu))
 356         {
 357           /*
 358            * If the submenu is not visble, wait until it is before
 359            * reporting focus on the menu item.
 360            */
 361           gulong handler_id;
 362
 363           handler_id = g_signal_handler_find (menu_item->submenu,
 364                                               G_SIGNAL_MATCH_FUNC,
 365                                               g_signal_lookup ("map",
 366                                                                GTK_TYPE_WINDOW),
 367                                               0,
 368                                               NULL,
 369                                               (gpointer) gail_map_submenu_cb,
 370                                               NULL);
 371           if (!handler_id)
 372             g_signal_connect (menu_item->submenu, "map",
 373                               G_CALLBACK (gail_map_submenu_cb),
 374                               NULL);
 375             return;
 376
 377         }
 378       /*
 379        * If we are waiting to report focus on a menubar or a menu item
 380        * because of a previous deselect, cancel it.
 381        */
 382       if (was_deselect &&
 383           focus_notify_handler &&
 384           next_focus_widget &&
 385           (GTK_IS_MENU_BAR (next_focus_widget) ||
 386            GTK_IS_MENU_ITEM (next_focus_widget)))
 387         {
 388           void *vp_next_focus_widget = &next_focus_widget;
 389           g_source_remove (focus_notify_handler);
 390           g_object_remove_weak_pointer (G_OBJECT (next_focus_widget), vp_next_focus_widget);
 391           next_focus_widget = NULL;
 392           focus_notify_handler = 0;
 393           was_deselect = FALSE;
 394         }
 395     }
 396   /*
 397    * If previously focused widget is not a GtkMenuItem or a GtkMenu,
 398    * keep track of it so we can return to it after menubar is deactivated
 399    */
 400   if (focus_widget &&
 401       !GTK_IS_MENU_ITEM (focus_widget) &&
 402       !GTK_IS_MENU (focus_widget))
 403     {
 404       void *vp_focus_before_menu = &focus_before_menu;
 405       focus_before_menu = focus_widget;
 406       g_object_add_weak_pointer (G_OBJECT (focus_before_menu), vp_focus_before_menu);
 407
 408     }
 409   gail_focus_notify_when_idle (widget);
 410
 411   return;
 412 }
 413
 414 static void
 415 gail_map_cb (GtkWidget *widget)
 416 {
 417   gail_finish_select (widget);
 418 }
 419
 420 static void
 421 gail_map_submenu_cb (GtkWidget *widget)
 422 {
 423   if (GTK_IS_MENU (widget))
 424     {
 425       if (GTK_MENU (widget)->parent_menu_item)
 426         gail_finish_select (GTK_MENU (widget)->parent_menu_item);
 427     }
 428 }
 429
 430
 431 static gboolean
 432 gail_deselect_watcher (GSignalInvocationHint *ihint,
 433                        guint                  n_param_values,
 434                        const GValue          *param_values,
 435                        gpointer               data)
 436 {
 437   GObject *object;
 438   GtkWidget *widget;
 439   GtkWidget *menu_shell;
 440
 441   object = g_value_get_object (param_values + 0);
 442   g_return_val_if_fail (GTK_IS_WIDGET(object), FALSE);
 443
 444   widget = GTK_WIDGET (object);
 445
 446   if (!GTK_IS_MENU_ITEM (widget))
 447     return TRUE;
 448
 449   if (subsequent_focus_widget == widget)
 450     subsequent_focus_widget = NULL;
 451
 452   menu_shell = gtk_widget_get_parent (widget);
 453   if (GTK_IS_MENU_SHELL (menu_shell))
 454     {
 455       GtkWidget *parent_menu_shell;
 456
 457       parent_menu_shell = GTK_MENU_SHELL (menu_shell)->parent_menu_shell;
 458       if (parent_menu_shell)
 459         {
 460           GtkWidget *active_menu_item;
 461
 462           active_menu_item = GTK_MENU_SHELL (parent_menu_shell)->active_menu_item;
 463           if (active_menu_item)
 464             {
 465               gail_focus_notify_when_idle (active_menu_item);
 466             }
 467         }
 468       else
 469         {
 470           if (!GTK_IS_MENU_BAR (menu_shell))
 471             {
 472               gail_focus_notify_when_idle (menu_shell);
 473             }
 474         }
 475     }
 476   was_deselect = TRUE;
 477   return TRUE;
 478 }
 479
 480 static gboolean
 481 gail_switch_page_watcher (GSignalInvocationHint *ihint,
 482                           guint                  n_param_values,
 483                           const GValue          *param_values,
 484                           gpointer               data)
 485 {
 486   GObject *object;
 487   GtkWidget *widget;
 488
 489   object = g_value_get_object (param_values + 0);
 490   g_return_val_if_fail (GTK_IS_WIDGET(object), FALSE);
 491
 492   widget = GTK_WIDGET (object);
 493
 494   if (!GTK_IS_NOTEBOOK (widget))
 495     return TRUE;
 496
 497   if (gtk_notebook_get_current_page (GTK_NOTEBOOK (widget)) == -1)
 498     return TRUE;
 499
 500   gail_focus_notify_when_idle (widget);
 501   return TRUE;
 502 }
 503
 504 static gboolean
 505 gail_focus_idle_handler (gpointer data)
 506 {
 507   focus_notify_handler = 0;
 508   /*
 509    * The widget which was to receive focus may have been removed
 510    */
 511   if (!next_focus_widget)
 512     {
 513       if (next_focus_widget != data)
 514         return FALSE;
 515     }
 516   else
 517     {
 518       void *vp_next_focus_widget = &next_focus_widget;
 519       g_object_remove_weak_pointer (G_OBJECT (next_focus_widget), vp_next_focus_widget);
 520       next_focus_widget = NULL;
 521     }
 522
 523   gail_focus_notify (data);
 524
 525   return FALSE;
 526 }
 527
 528 static void
 529 gail_focus_notify (GtkWidget *widget)
 530 {
 531   AtkObject *atk_obj;
 532   gboolean transient;
 533
 534   if (widget != focus_widget)
 535     {
 536       if (focus_widget)
 537         {
 538           void *vp_focus_widget = &focus_widget;
 539           g_object_remove_weak_pointer (G_OBJECT (focus_widget), vp_focus_widget);
 540         }
 541       focus_widget = widget;
 542       if (focus_widget)
 543         {
 544           void *vp_focus_widget = &focus_widget;
 545           g_object_add_weak_pointer (G_OBJECT (focus_widget), vp_focus_widget);
 546           /*
 547            * The UI may not have been updated yet; e.g. in gtkhtml2
 548            * html_view_layout() is called in a idle handler
 549            */
 550           if (focus_widget == focus_before_menu)
 551             {
 552               void *vp_focus_before_menu = &focus_before_menu;
 553               g_object_remove_weak_pointer (G_OBJECT (focus_before_menu), vp_focus_before_menu);
 554               focus_before_menu = NULL;
 555             }
 556         }
 557       gail_focus_notify_when_idle (focus_widget);
 558     }
 559   else
 560     {
 561       if (focus_widget)
 562         atk_obj  = gail_get_accessible_for_widget (focus_widget, &transient);
 563       else
 564         atk_obj = NULL;
 565       /*
 566        * Do not report focus on redundant object
 567        */
 568       if (atk_obj &&
 569           (atk_object_get_role(atk_obj) != ATK_ROLE_REDUNDANT_OBJECT))
 570           atk_focus_tracker_notify (atk_obj);
 571       if (atk_obj && transient)
 572         g_object_unref (atk_obj);
 573       if (subsequent_focus_widget)
 574         {
 575           GtkWidget *tmp_widget = subsequent_focus_widget;
 576           subsequent_focus_widget = NULL;
 577           gail_focus_notify_when_idle (tmp_widget);
 578         }
 579     }
 580 }
 581
 582 static void
 583 gail_focus_notify_when_idle (GtkWidget *widget)
 584 {
 585   if (focus_notify_handler)
 586     {
 587       if (widget)
 588         {
 589           /*
 590            * Ignore focus request when menu item is going to be focused.
 591            * See bug #124232.
 592            */
 593           if (GTK_IS_MENU_ITEM (next_focus_widget) && !GTK_IS_MENU_ITEM (widget))
 594             return;
 595
 596           if (next_focus_widget)
 597             {
 598               if (GTK_IS_MENU_ITEM (next_focus_widget) && GTK_IS_MENU_ITEM (widget))
 599                 {
 600                   if (gtk_menu_item_get_submenu (GTK_MENU_ITEM (next_focus_widget)) == gtk_widget_get_parent (widget))
 601                     {
 602                       if (subsequent_focus_widget)
 603                         g_assert_not_reached ();
 604                       subsequent_focus_widget = widget;
 605                       return;
 606                     }
 607                 }
 608             }
 609           g_source_remove (focus_notify_handler);
 610           if (next_focus_widget)
 611             {
 612               void *vp_next_focus_widget = &next_focus_widget;
 613               g_object_remove_weak_pointer (G_OBJECT (next_focus_widget), vp_next_focus_widget);
 614               next_focus_widget = NULL;
 615             }
 616         }
 617       else
 618         /*
 619          * Ignore if focus is being set to NULL and we are waiting to set focus
 620          */
 621         return;
 622     }
 623
 624   if (widget)
 625     {
 626       void *vp_next_focus_widget = &next_focus_widget;
 627       next_focus_widget = widget;
 628       g_object_add_weak_pointer (G_OBJECT (next_focus_widget), vp_next_focus_widget);
 629     }
 630   else
 631     {
 632       /*
 633        * We are about to report focus as NULL so remove the weak pointer
 634        * for the widget we were waiting to report focus on.
 635        */
 636       if (next_focus_widget)
 637         {
 638           void *vp_next_focus_widget = &next_focus_widget;
 639           g_object_remove_weak_pointer (G_OBJECT (next_focus_widget), vp_next_focus_widget);
 640           next_focus_widget = NULL;
 641         }
 642     }
 643
 644   focus_notify_handler = gdk_threads_add_idle (gail_focus_idle_handler, widget);
 645 }
 646
 647 static gboolean
 648 gail_deactivate_watcher (GSignalInvocationHint *ihint,
 649                          guint                  n_param_values,
 650                          const GValue          *param_values,
 651                          gpointer               data)
 652 {
 653   GObject *object;
 654   GtkWidget *widget;
 655   GtkMenuShell *shell;
 656   GtkWidget *focus = NULL;
 657
 658   object = g_value_get_object (param_values + 0);
 659   g_return_val_if_fail (GTK_IS_WIDGET(object), FALSE);
 660   widget = GTK_WIDGET (object);
 661
 662   g_return_val_if_fail (GTK_IS_MENU_SHELL(widget), TRUE);
 663   shell = GTK_MENU_SHELL(widget);
 664   if (!shell->parent_menu_shell)
 665     focus = focus_before_menu;
 666
 667   /*
 668    * If we are waiting to report focus on a menubar or a menu item
 669    * because of a previous deselect, cancel it.
 670    */
 671   if (was_deselect &&
 672       focus_notify_handler &&
 673       next_focus_widget &&
 674       (GTK_IS_MENU_BAR (next_focus_widget) ||
 675        GTK_IS_MENU_ITEM (next_focus_widget)))
 676     {
 677       void *vp_next_focus_widget = &next_focus_widget;
 678       g_source_remove (focus_notify_handler);
 679       g_object_remove_weak_pointer (G_OBJECT (next_focus_widget), vp_next_focus_widget);
 680       next_focus_widget = NULL;
 681       focus_notify_handler = 0;
 682       was_deselect = FALSE;
 683     }
 684   gail_focus_notify_when_idle (focus);
 685
 686   return TRUE;
 687 }
 688
 689 static void
 690 gail_focus_tracker_init (void)
 691 {
 692   static gboolean  emission_hooks_added = FALSE;
 693
 694   if (!emission_hooks_added)
 695     {
 696       /*
 697        * We cannot be sure that the classes exist so we make sure that they do.
 698        */
 699       g_type_class_ref (GTK_TYPE_WIDGET);
 700       g_type_class_ref (GTK_TYPE_MENU_SHELL);
 701       g_type_class_ref (GTK_TYPE_NOTEBOOK);
 702
 703       /*
 704        * We listen for event_after signal and then check that the
 705        * event was a focus in event so we get called after the event.
 706        */
 707       g_signal_add_emission_hook (
 708              g_signal_lookup ("event-after", GTK_TYPE_WIDGET), 0,
 709              gail_focus_watcher, NULL, (GDestroyNotify) NULL);
 710       /*
 711        * A "select" signal is emitted when arrow key is used to
 712        * move to a list item in the popup window of a GtkCombo or
 713        * a menu item in a menu.
 714        */
 715       g_signal_add_emission_hook (
 716              g_signal_lookup ("select", GTK_TYPE_MENU_ITEM), 0,
 717              gail_select_watcher, NULL, (GDestroyNotify) NULL);
 718
 719       /*
 720        * A "deselect" signal is emitted when arrow key is used to
 721        * move from a menu item in a menu to the parent menu.
 722        */
 723       g_signal_add_emission_hook (
 724              g_signal_lookup ("deselect", GTK_TYPE_MENU_ITEM), 0,
 725              gail_deselect_watcher, NULL, (GDestroyNotify) NULL);
 726
 727       /*
 728        * We listen for deactivate signals on menushells to determine
 729        * when the "focus" has left the menus.
 730        */
 731       g_signal_add_emission_hook (
 732              g_signal_lookup ("deactivate", GTK_TYPE_MENU_SHELL), 0,
 733              gail_deactivate_watcher, NULL, (GDestroyNotify) NULL);
 734
 735       /*
 736        * We listen for "switch-page" signal on a GtkNotebook to notify
 737        * when page has changed because of clicking on a notebook tab.
 738        */
 739       g_signal_add_emission_hook (
 740              g_signal_lookup ("switch-page", GTK_TYPE_NOTEBOOK), 0,
 741              gail_switch_page_watcher, NULL, (GDestroyNotify) NULL);
 742       emission_hooks_added = TRUE;
 743     }
 744 }
 745
 746 static void
 747 gail_focus_object_destroyed (gpointer data)
 748 {
 749   GObject *obj;
 750
 751   obj = G_OBJECT (data);
 752   g_object_set_qdata (obj, quark_focus_object, NULL);
 753   g_object_unref (obj);
 754 }
 755
 756 static void
 757 gail_focus_tracker (AtkObject *focus_object)
 758 {
 759   /*
 760    * Do not report focus on redundant object
 761    */
 762   if (focus_object &&
 763       (atk_object_get_role(focus_object) != ATK_ROLE_REDUNDANT_OBJECT))
 764     {
 765       AtkObject *old_focus_object;
 766
 767       if (!GTK_IS_ACCESSIBLE (focus_object))
 768         {
 769           AtkObject *parent;
 770
 771           parent = focus_object;
 772           while (1)
 773             {
 774               parent = atk_object_get_parent (parent);
 775               if (parent == NULL)
 776                 break;
 777               if (GTK_IS_ACCESSIBLE (parent))
 778                 break;
 779             }
 780
 781           if (parent)
 782             {
 783               gail_set_focus_object (focus_object, parent);
 784             }
 785         }
 786       else
 787         {
 788           old_focus_object = g_object_get_qdata (G_OBJECT (focus_object), quark_focus_object);
 789           if (old_focus_object)
 790             {
 791               g_object_weak_unref (G_OBJECT (old_focus_object),
 792                                    (GWeakNotify) gail_focus_object_destroyed,
 793                                    focus_object);
 794               g_object_set_qdata (G_OBJECT (focus_object), quark_focus_object, NULL);
 795               g_object_unref (G_OBJECT (focus_object));
 796             }
 797         }
 798     }
 799 }
 800
 801 static void
 802 gail_set_focus_widget (GtkWidget *focus_widget,
 803                        GtkWidget *widget)
 804 {
 805   AtkObject *focus_obj;
 806   AtkObject *obj;
 807
 808   focus_obj = gtk_widget_get_accessible (focus_widget);
 809   obj = gtk_widget_get_accessible (widget);
 810   gail_set_focus_object (focus_obj, obj);
 811 }
 812
 813 static void
 814 gail_set_focus_object (AtkObject *focus_obj,
 815                        AtkObject *obj)
 816 {
 817   AtkObject *old_focus_obj;
 818
 819   old_focus_obj = g_object_get_qdata (G_OBJECT (obj), quark_focus_object);
 820   if (old_focus_obj != obj)
 821     {
 822       if (old_focus_obj)
 823         g_object_weak_unref (G_OBJECT (old_focus_obj),
 824                              (GWeakNotify) gail_focus_object_destroyed,
 825                              obj);
 826       else
 827         /*
 828          * We call g_object_ref as if obj is destroyed
 829          * while the weak reference exists then destroying the
 830          * focus_obj would cause gail_focus_object_destroyed to be
 831          * called when obj is not a valid GObject.
 832          */
 833         g_object_ref (obj);
 834
 835       g_object_weak_ref (G_OBJECT (focus_obj),
 836                          (GWeakNotify) gail_focus_object_destroyed,
 837                          obj);
 838       g_object_set_qdata (G_OBJECT (obj), quark_focus_object, focus_obj);
 839     }
 840 }
 841
 842 /*
 843  *   These exported symbols are hooked by gnome-program
 844  * to provide automatic module initialization and shutdown.
 845  */
 846 extern void gnome_accessibility_module_init     (void);
 847 extern void gnome_accessibility_module_shutdown (void);
 848
 849 static int gail_initialized = FALSE;
 850
 851 static void
 852 gail_accessibility_module_init (void)
 853 {
 854   const char *env_a_t_support;
 855   gboolean a_t_support = FALSE;
 856
 857   if (gail_initialized)
 858     {
 859       return;
 860     }
 861   gail_initialized = TRUE;
 862   quark_focus_object = g_quark_from_static_string ("gail-focus-object");
 863
 864   env_a_t_support = g_getenv (GNOME_ACCESSIBILITY_ENV);
 865
 866   if (env_a_t_support)
 867     a_t_support = atoi (env_a_t_support);
 868   if (a_t_support)
 869     fprintf (stderr, "GTK Accessibility Module initialized\n");
 870
 871   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_WIDGET, gail_widget);
 872   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_CONTAINER, gail_container);
 873   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_BUTTON, gail_button);
 874   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_MENU_ITEM, gail_menu_item);
 875   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_TOGGLE_BUTTON, gail_toggle_button);
 876   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_IMAGE, gail_image);
 877   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_TEXT_VIEW, gail_text_view);
 878   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_COMBO_BOX, gail_combo_box);
 879   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_ENTRY, gail_entry);
 880   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_MENU_BAR, gail_menu_shell);
 881   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_MENU, gail_menu);
 882   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_WINDOW, gail_window);
 883   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_RANGE, gail_range);
 884   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_SCALE, gail_scale);
 885   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_SCALE_BUTTON, gail_scale_button);
 886   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_LABEL, gail_label);
 887   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_STATUSBAR, gail_statusbar);
 888   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_NOTEBOOK, gail_notebook);
 889   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_CALENDAR, gail_calendar);
 890   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_PROGRESS_BAR, gail_progress_bar);
 891   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_SPIN_BUTTON, gail_spin_button);
 892   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_TREE_VIEW, gail_tree_view);
 893   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_FRAME, gail_frame);
 894   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_CELL_RENDERER_TEXT, gail_text_cell);
 895   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_CELL_RENDERER_TOGGLE, gail_boolean_cell);
 896   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_CELL_RENDERER_PIXBUF, gail_image_cell);
 897   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_CELL_RENDERER, gail_renderer_cell);
 898   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_RADIO_BUTTON, gail_radio_button);
 899   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_ARROW, gail_arrow);
 900   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_SEPARATOR, gail_separator);
 901   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_BOX, gail_box);
 902   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_SCROLLED_WINDOW, gail_scrolled_window);
 903   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_PANED, gail_paned);
 904   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_SCROLLBAR, gail_scrollbar);
 905   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_CHECK_MENU_ITEM, gail_check_menu_item);
 906   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_RADIO_MENU_ITEM, gail_radio_menu_item);
 907   GAIL_WIDGET_SET_FACTORY (GTK_TYPE_EXPANDER, gail_expander);
 908
 909   atk_focus_tracker_init (gail_focus_tracker_init);
 910   focus_tracker_id = atk_add_focus_tracker (gail_focus_tracker);
 911
 912   /* Initialize the GailUtility class */
 913   g_type_class_unref (g_type_class_ref (GAIL_TYPE_UTIL));
 914   g_type_class_unref (g_type_class_ref (GAIL_TYPE_MISC));
 915 }
 916
 917 /**
 918  * gnome_accessibility_module_init:
 919  * @void:
 920  *
 921  *   This method is invoked by name from libgnome's
 922  * gnome-program.c to activate accessibility support.
 923  **/
 924 void
 925 gnome_accessibility_module_init (void)
 926 {
 927   gail_accessibility_module_init ();
 928 }
 929
 930 /**
 931  * gnome_accessibility_module_shutdown:
 932  * @void:
 933  *
 934  *   This method is invoked by name from libgnome's
 935  * gnome-program.c to de-activate accessibility support.
 936  **/
 937 void
 938 gnome_accessibility_module_shutdown (void)
 939 {
 940   if (!gail_initialized)
 941     {
 942       return;
 943     }
 944   gail_initialized = FALSE;
 945   atk_remove_focus_tracker (focus_tracker_id);
 946
 947   fprintf (stderr, "GTK Accessibility Module shutdown\n");
 948
 949   /* FIXME: de-register the factory types so we can unload ? */
 950 }
 951
 952 int
 953 gtk_module_init (gint *argc, char** argv[])
 954 {
 955   const char* env_no_gail;
 956   gboolean no_gail = FALSE;
 957
 958   env_no_gail = g_getenv (NO_GAIL_ENV);
 959   if (env_no_gail)
 960       no_gail = atoi (env_no_gail);
 961
 962   if (no_gail)
 963       return 0;
 964
 965   gail_accessibility_module_init ();
 966
 967   return 0;
 968 }
 969
 970 const char *
 971 g_module_check_init (GModule *module)
 972 {
 973   g_module_make_resident (module);
 974
 975   return NULL;
 976 }
 977