Make the location bar generate accessibility extension API events...

chrome/browser/gtk/accessibility_event_router_gtk.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/gtk/accessibility_event_router_gtk.h"
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/message_loop.h"
 #include "base/stl_util-inl.h"
@@ skipping 99 matching lines @@
     return TRUE;
   }
   // The text hasn't changed yet, so defer calling
   // DispatchAccessibilityNotification.
   reinterpret_cast<AccessibilityEventRouterGtk*>(user_data)->
       PostDispatchAccessibilityNotification(
           widget, NotificationType::ACCESSIBILITY_TEXT_CHANGED);
   return TRUE;
 }
 
+gboolean OnTextBufferChanged(GSignalInvocationHint *ihint,
+                             guint n_param_values,
+                             const GValue* param_values,
+                             gpointer user_data) {
+  // The text hasn't changed yet, so defer calling
+  // DispatchAccessibilityNotification.
+  reinterpret_cast<AccessibilityEventRouterGtk*>(user_data)->
+      PostDispatchAccessibilityNotification(
+          NULL, NotificationType::ACCESSIBILITY_TEXT_CHANGED);
+  return TRUE;
+}
+
+gboolean OnTextViewChanged(GSignalInvocationHint *ihint,
+                           guint n_param_values,
+                           const GValue* param_values,
+                           gpointer user_data) {
+  GtkWidget* widget = GTK_WIDGET(g_value_get_object(param_values));
+  if (!GTK_IS_TEXT_VIEW(widget)) {
+    return TRUE;
+  }
+  // The text hasn't changed yet, so defer calling
+  // DispatchAccessibilityNotification.
+  reinterpret_cast<AccessibilityEventRouterGtk*>(user_data)->
+      PostDispatchAccessibilityNotification(
+          widget, NotificationType::ACCESSIBILITY_TEXT_CHANGED);
+  return TRUE;
+}
+
 gboolean OnMenuMoveCurrent(GSignalInvocationHint *ihint,
                            guint n_param_values,
                            const GValue* param_values,
                            gpointer user_data) {
   // Get the widget (the GtkMenu).
   GtkWidget* widget = GTK_WIDGET(g_value_get_object(param_values));
 
   // Moving may move us into or out of a submenu, so after the menu
   // item moves, |widget| may not be valid anymore. To be safe, then,
   // find the topmost ancestor of this menu and post the notification
   // dispatch on that menu. Then the dispatcher will recurse into submenus
   // as necessary to figure out which item is focused.
   while (GTK_MENU_SHELL(widget)->parent_menu_shell)
     widget = GTK_MENU_SHELL(widget)->parent_menu_shell;
 
   // The menu item hasn't moved yet, so we want to defer calling
   // DispatchAccessibilityNotification until after it does.
   reinterpret_cast<AccessibilityEventRouterGtk*>(user_data)->
       PostDispatchAccessibilityNotification(
           widget, NotificationType::ACCESSIBILITY_CONTROL_FOCUSED);
   return TRUE;
 }
 
 }  // anonymous namespace
 
 AccessibilityEventRouterGtk::AccessibilityEventRouterGtk()
     : listening_(false),
       most_recent_profile_(NULL),
+      most_recent_widget_(NULL),
       method_factory_(this) {
   // We don't want our event listeners to be installed if accessibility is
   // disabled. Install listeners so we can install and uninstall them as
   // needed, then install them now if it's currently enabled.
   ExtensionAccessibilityEventRouter *extension_event_router =
       ExtensionAccessibilityEventRouter::GetInstance();
   extension_event_router->AddOnEnabledListener(
       NewCallback(this,
                   &AccessibilityEventRouterGtk::InstallEventListeners));
   extension_event_router->AddOnDisabledListener(
@@ skipping 25 matching lines @@
 
 void AccessibilityEventRouterGtk::InstallEventListeners() {
   // Create and destroy each type of widget we need signals for,
   // to ensure their modules are loaded, otherwise g_signal_lookup
   // might fail.
   g_object_unref(g_object_ref_sink(gtk_combo_box_new()));
   g_object_unref(g_object_ref_sink(gtk_entry_new()));
   g_object_unref(g_object_ref_sink(gtk_notebook_new()));
   g_object_unref(g_object_ref_sink(gtk_toggle_button_new()));
   g_object_unref(g_object_ref_sink(gtk_tree_view_new()));
+  g_object_unref(g_object_ref_sink(gtk_text_view_new()));
+  g_object_unref(g_object_ref_sink(gtk_text_buffer_new(NULL)));
 
   // Add signal emission hooks for the events we're interested in.
   InstallEventListener("clicked", GTK_TYPE_BUTTON, OnButtonClicked);
   InstallEventListener("changed", GTK_TYPE_COMBO_BOX, OnComboBoxChanged);
   InstallEventListener("cursor-changed", GTK_TYPE_TREE_VIEW,
                        OnTreeViewCursorChanged);
   InstallEventListener("changed", GTK_TYPE_ENTRY, OnEntryChanged);
   InstallEventListener("insert-text", GTK_TYPE_ENTRY, OnEntryChanged);
   InstallEventListener("delete-text", GTK_TYPE_ENTRY, OnEntryChanged);
   InstallEventListener("move-cursor", GTK_TYPE_ENTRY, OnEntryChanged);
   InstallEventListener("focus-in-event", GTK_TYPE_WIDGET, OnWidgetFocused);
   InstallEventListener("switch-page", GTK_TYPE_NOTEBOOK, OnPageSwitched);
   InstallEventListener("toggled", GTK_TYPE_TOGGLE_BUTTON, OnButtonToggled);
   InstallEventListener("move-current", GTK_TYPE_MENU, OnMenuMoveCurrent);
+  InstallEventListener("changed", GTK_TYPE_TEXT_BUFFER, OnTextBufferChanged);
+  InstallEventListener("move-cursor", GTK_TYPE_TEXT_VIEW, OnTextViewChanged);
 
   listening_ = true;
 }
 
 void AccessibilityEventRouterGtk::RemoveEventListeners() {
   for (size_t i = 0; i < installed_hooks_.size(); i++) {
     g_signal_remove_emission_hook(
         installed_hooks_[i].signal_id,
         installed_hooks_[i].hook_id);
   }
@@ skipping 73 matching lines @@
   listening_ = false;
 }
 
 void AccessibilityEventRouterGtk::DispatchAccessibilityNotification(
     GtkWidget* widget, NotificationType type) {
   if (!listening_)
     return;
 
   Profile* profile = NULL;
   bool is_accessible;
+
+  // Special case: when we get ACCESSIBILITY_TEXT_CHANGED, we don't get
+  // a pointer to the widget, so we try to retrieve it from the most recent
+  // widget.
+  if (widget == NULL &&
+      type == NotificationType::ACCESSIBILITY_TEXT_CHANGED &&
+      most_recent_widget_ &&
+      GTK_IS_TEXT_VIEW(most_recent_widget_)) {
+    widget = most_recent_widget_;
+  }
+
+  if (!widget)
+    return;
+
+  most_recent_widget_ = widget;
   FindWidget(widget, &profile, &is_accessible);
   if (profile)
     most_recent_profile_ = profile;
 
   // Special case: a GtkMenu isn't associated with any particular
   // toplevel window, so menu events get routed to the profile of
   // the most recent event that was associated with a window.
   if (GTK_IS_MENU_SHELL(widget) && most_recent_profile_) {
     SendMenuItemNotification(widget, type, most_recent_profile_);
     return;
@@ skipping 14 matching lines @@
     SendComboBoxNotification(widget, type, profile);
   } else if (parent && GTK_IS_COMBO_BOX(parent)) {
     SendComboBoxNotification(parent, type, profile);
   } else if (GTK_IS_RADIO_BUTTON(widget)) {
     SendRadioButtonNotification(widget, type, profile);
   } else if (GTK_IS_TOGGLE_BUTTON(widget)) {
     SendCheckboxNotification(widget, type, profile);
   } else if (GTK_IS_BUTTON(widget)) {
     SendButtonNotification(widget, type, profile);
   } else if (GTK_IS_ENTRY(widget)) {
-    SendTextBoxNotification(widget, type, profile);
+    SendEntryNotification(widget, type, profile);
+  } else if (GTK_IS_TEXT_VIEW(widget)) {
+    SendTextViewNotification(widget, type, profile);
   } else if (GTK_IS_NOTEBOOK(widget)) {
     SendTabNotification(widget, type, profile);
   } else if (GTK_IS_TREE_VIEW(widget)) {
     SendListBoxNotification(widget, type, profile);
   } else {
     // If we have no idea what this control is, return and skip the
     // temporary pause in event listening.
     return;
   }
 
@@ skipping 58 matching lines @@
 
 void AccessibilityEventRouterGtk::SendButtonNotification(
     GtkWidget* widget, NotificationType type, Profile* profile) {
   std::string button_name = GetWidgetName(widget);
   if (button_name.empty() && gtk_button_get_label(GTK_BUTTON(widget)))
     button_name = gtk_button_get_label(GTK_BUTTON(widget));
   AccessibilityButtonInfo info(profile, button_name);
   SendAccessibilityNotification(type, &info);
 }
 
-void AccessibilityEventRouterGtk::SendTextBoxNotification(
+void AccessibilityEventRouterGtk::SendEntryNotification(
     GtkWidget* widget, NotificationType type, Profile* profile) {
   std::string name = GetWidgetName(widget);
   std::string value = gtk_entry_get_text(GTK_ENTRY(widget));
   gint start_pos;
   gint end_pos;
   gtk_editable_get_selection_bounds(GTK_EDITABLE(widget), &start_pos, &end_pos);
   AccessibilityTextBoxInfo info(profile, name, false);
   info.SetValue(value, start_pos, end_pos);
   SendAccessibilityNotification(type, &info);
 }
 
+void AccessibilityEventRouterGtk::SendTextViewNotification(
+    GtkWidget* widget, NotificationType type, Profile* profile) {
+  std::string name = GetWidgetName(widget);
+  GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget));
+  GtkTextIter start, end;
+  gtk_text_buffer_get_bounds(buffer, &start, &end);
+  gchar* text = gtk_text_buffer_get_text(buffer, &start, &end, false);
+  std::string value = text;
+  g_free(text);
+  GtkTextIter sel_start, sel_end;
+  gtk_text_buffer_get_selection_bounds(buffer, &sel_start, &sel_end);
+  int start_pos = gtk_text_iter_get_offset(&sel_start);
+  int end_pos = gtk_text_iter_get_offset(&sel_end);
+  AccessibilityTextBoxInfo info(profile, name, false);
+  info.SetValue(value, start_pos, end_pos);
+  SendAccessibilityNotification(type, &info);
+}
+
 void AccessibilityEventRouterGtk::SendTabNotification(
     GtkWidget* widget, NotificationType type, Profile* profile) {
   int index = gtk_notebook_get_current_page(GTK_NOTEBOOK(widget));
   int page_count = gtk_notebook_get_n_pages(GTK_NOTEBOOK(widget));
   GtkWidget* page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(widget), index);
   GtkWidget* label = gtk_notebook_get_tab_label(GTK_NOTEBOOK(widget), page);
   std::string name = GetWidgetName(widget);
   if (name.empty() && gtk_label_get_text(GTK_LABEL(label))) {
     name = gtk_label_get_text(GTK_LABEL(label));
   }
@@ skipping 124 matching lines @@
       name = gtk_label_get_label(GTK_LABEL(child));
       break;
     }
   }
 #endif
 
   // Send the event.
   AccessibilityMenuItemInfo info(profile, name, submenu != NULL, index, count);
   SendAccessibilityNotification(type, &info);
 }