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