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

   1 /* GTK+ - accessibility implementations
   2  * Copyright 2011, F123 Consulting & Mais Diferenças
   3  * Copyright 2001, 2002, 2003 Sun Microsystems Inc.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library. If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include "config.h"
  20
  21 #include <gtk/gtk.h>
  22
  23 #include "gtkwidgetaccessibleprivate.h"
  24 #include "gtkwindowaccessible.h"
  25 #include "gtktoplevelaccessible.h"
  26
  27 /* atkcomponent.h */
  28
  29 static void                  gtk_window_accessible_get_extents      (AtkComponent         *component,
  30                                                            gint                 *x,
  31                                                            gint                 *y,
  32                                                            gint                 *width,
  33                                                            gint                 *height,
  34                                                            AtkCoordType         coord_type);
  35 static void                  gtk_window_accessible_get_size         (AtkComponent         *component,
  36                                                            gint                 *width,
  37                                                            gint                 *height);
  38
  39 static void atk_component_interface_init (AtkComponentIface *iface);
  40 static void atk_window_interface_init (AtkWindowIface *iface);
  41
  42 G_DEFINE_TYPE_WITH_CODE (GtkWindowAccessible,
  43                          gtk_window_accessible,
  44                          GTK_TYPE_CONTAINER_ACCESSIBLE,
  45                          G_IMPLEMENT_INTERFACE (ATK_TYPE_COMPONENT,
  46                                                 atk_component_interface_init)
  47                          G_IMPLEMENT_INTERFACE (ATK_TYPE_WINDOW,
  48                                                 atk_window_interface_init));
  49
  50
  51 static void
  52 gtk_window_accessible_focus_event (AtkObject *obj,
  53                                    gboolean   focus_in)
  54 {
  55   atk_object_notify_state_change (obj, ATK_STATE_ACTIVE, focus_in);
  56 }
  57
  58 static void
  59 gtk_window_accessible_notify_gtk (GObject    *obj,
  60                                   GParamSpec *pspec)
  61 {
  62   GtkWidget *widget = GTK_WIDGET (obj);
  63   AtkObject* atk_obj = gtk_widget_get_accessible (widget);
  64
  65   if (g_strcmp0 (pspec->name, "title") == 0)
  66     {
  67       g_object_notify (G_OBJECT (atk_obj), "accessible-name");
  68       g_signal_emit_by_name (atk_obj, "visible-data-changed");
  69     }
  70   else
  71     GTK_WIDGET_ACCESSIBLE_CLASS (gtk_window_accessible_parent_class)->notify_gtk (obj, pspec);
  72 }
  73
  74 static gboolean
  75 window_state_event_cb (GtkWidget           *widget,
  76                        GdkEventWindowState *event)
  77 {
  78   AtkObject* obj;
  79
  80   obj = gtk_widget_get_accessible (widget);
  81   atk_object_notify_state_change (obj, ATK_STATE_ICONIFIED,
  82                                   (event->new_window_state & GDK_WINDOW_STATE_ICONIFIED) != 0);
  83
  84   return FALSE;
  85 }
  86
  87 static void
  88 gtk_window_accessible_initialize (AtkObject *obj,
  89                                   gpointer   data)
  90 {
  91   GtkWidget *widget = GTK_WIDGET (data);
  92   const gchar *name;
  93
  94   ATK_OBJECT_CLASS (gtk_window_accessible_parent_class)->initialize (obj, data);
  95
  96   g_signal_connect (data, "window-state-event", G_CALLBACK (window_state_event_cb), NULL);
  97   _gtk_widget_accessible_set_layer (GTK_WIDGET_ACCESSIBLE (obj), ATK_LAYER_WINDOW);
  98
  99   name = gtk_widget_get_name (widget);
 100
 101   if (!g_strcmp0 (name, "gtk-tooltip"))
 102     obj->role = ATK_ROLE_TOOL_TIP;
 103   else if (gtk_window_get_window_type (GTK_WINDOW (widget)) == GTK_WINDOW_POPUP)
 104     obj->role = ATK_ROLE_WINDOW;
 105   else
 106     obj->role = ATK_ROLE_FRAME;
 107
 108   /* Notify that tooltip is showing */
 109   if (obj->role == ATK_ROLE_TOOL_TIP && gtk_widget_get_mapped (widget))
 110     atk_object_notify_state_change (obj, ATK_STATE_SHOWING, 1);
 111 }
 112
 113 static GtkWidget *
 114 find_label_child (GtkContainer *container)
 115 {
 116   GList *children, *tmp_list;
 117   GtkWidget *child;
 118
 119   children = gtk_container_get_children (container);
 120
 121   child = NULL;
 122   for (tmp_list = children; tmp_list != NULL; tmp_list = tmp_list->next)
 123     {
 124       if (GTK_IS_LABEL (tmp_list->data))
 125         {
 126           child = GTK_WIDGET (tmp_list->data);
 127           break;
 128         }
 129       else if (GTK_IS_CONTAINER (tmp_list->data))
 130         {
 131           child = find_label_child (GTK_CONTAINER (tmp_list->data));
 132           if (child)
 133             break;
 134         }
 135    }
 136   g_list_free (children);
 137   return child;
 138 }
 139
 140 static const gchar *
 141 gtk_window_accessible_get_name (AtkObject *accessible)
 142 {
 143   const gchar* name;
 144   GtkWidget* widget;
 145
 146   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible));
 147   if (widget == NULL)
 148     return NULL;
 149
 150   name = ATK_OBJECT_CLASS (gtk_window_accessible_parent_class)->get_name (accessible);
 151   if (name != NULL)
 152     return name;
 153
 154   if (GTK_IS_WINDOW (widget))
 155     {
 156       GtkWindow *window = GTK_WINDOW (widget);
 157
 158       name = gtk_window_get_title (window);
 159       if (name == NULL && accessible->role == ATK_ROLE_TOOL_TIP)
 160         {
 161           GtkWidget *child;
 162
 163           child = find_label_child (GTK_CONTAINER (window));
 164           if (GTK_IS_LABEL (child))
 165             name = gtk_label_get_text (GTK_LABEL (child));
 166         }
 167     }
 168   return name;
 169 }
 170
 171 static gint
 172 gtk_window_accessible_get_index_in_parent (AtkObject *accessible)
 173 {
 174   GtkWidget* widget;
 175   AtkObject* atk_obj;
 176   gint index = -1;
 177
 178   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible));
 179   if (widget == NULL)
 180     return -1;
 181
 182   index = ATK_OBJECT_CLASS (gtk_window_accessible_parent_class)->get_index_in_parent (accessible);
 183   if (index != -1)
 184     return index;
 185
 186   atk_obj = atk_get_root ();
 187
 188   if (GTK_IS_WINDOW (widget))
 189     {
 190       GtkWindow *window = GTK_WINDOW (widget);
 191       if (GTK_IS_TOPLEVEL_ACCESSIBLE (atk_obj))
 192         {
 193           GtkToplevelAccessible *toplevel = GTK_TOPLEVEL_ACCESSIBLE (atk_obj);
 194           index = g_list_index (gtk_toplevel_accessible_get_children (toplevel), window);
 195         }
 196       else
 197         {
 198           gint i, sibling_count;
 199
 200           sibling_count = atk_object_get_n_accessible_children (atk_obj);
 201           for (i = 0; i < sibling_count && index == -1; ++i)
 202             {
 203               AtkObject *child = atk_object_ref_accessible_child (atk_obj, i);
 204               if (accessible == child)
 205                 index = i;
 206               g_object_unref (G_OBJECT (child));
 207             }
 208         }
 209     }
 210   return index;
 211 }
 212
 213 static AtkRelationSet *
 214 gtk_window_accessible_ref_relation_set (AtkObject *obj)
 215 {
 216   GtkWidget *widget;
 217   AtkRelationSet *relation_set;
 218   AtkObject *array[1];
 219   AtkRelation* relation;
 220   GtkWidget *current_widget;
 221
 222   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
 223   if (widget == NULL)
 224     return NULL;
 225
 226   relation_set = ATK_OBJECT_CLASS (gtk_window_accessible_parent_class)->ref_relation_set (obj);
 227
 228   if (atk_object_get_role (obj) == ATK_ROLE_TOOL_TIP)
 229     {
 230       relation = atk_relation_set_get_relation_by_type (relation_set, ATK_RELATION_POPUP_FOR);
 231       if (relation)
 232         atk_relation_set_remove (relation_set, relation);
 233
 234       if (0) /* FIXME need a way to go from tooltip window to widget */
 235         {
 236           array[0] = gtk_widget_get_accessible (current_widget);
 237           relation = atk_relation_new (array, 1, ATK_RELATION_POPUP_FOR);
 238           atk_relation_set_add (relation_set, relation);
 239           g_object_unref (relation);
 240         }
 241     }
 242   return relation_set;
 243 }
 244
 245 static AtkStateSet *
 246 gtk_window_accessible_ref_state_set (AtkObject *accessible)
 247 {
 248   AtkStateSet *state_set;
 249   GtkWidget *widget;
 250   GtkWindow *window;
 251   GdkWindow *gdk_window;
 252   GdkWindowState state;
 253
 254   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible));
 255   if (widget == NULL)
 256     return NULL;
 257
 258   state_set = ATK_OBJECT_CLASS (gtk_window_accessible_parent_class)->ref_state_set (accessible);
 259
 260   window = GTK_WINDOW (widget);
 261
 262   if (gtk_window_has_toplevel_focus (window) && gtk_window_is_active (window))
 263     atk_state_set_add_state (state_set, ATK_STATE_ACTIVE);
 264
 265   gdk_window = gtk_widget_get_window (widget);
 266   if (gdk_window)
 267     {
 268       state = gdk_window_get_state (gdk_window);
 269       if (state & GDK_WINDOW_STATE_ICONIFIED)
 270         atk_state_set_add_state (state_set, ATK_STATE_ICONIFIED);
 271     }
 272   if (gtk_window_get_modal (window))
 273     atk_state_set_add_state (state_set, ATK_STATE_MODAL);
 274
 275   if (gtk_window_get_resizable (window))
 276     atk_state_set_add_state (state_set, ATK_STATE_RESIZABLE);
 277
 278   return state_set;
 279 }
 280
 281 static void
 282 gtk_window_accessible_class_init (GtkWindowAccessibleClass *klass)
 283 {
 284   GtkWidgetAccessibleClass *widget_class = (GtkWidgetAccessibleClass*)klass;
 285   AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
 286
 287   widget_class->notify_gtk = gtk_window_accessible_notify_gtk;
 288
 289   class->get_name = gtk_window_accessible_get_name;
 290   class->get_index_in_parent = gtk_window_accessible_get_index_in_parent;
 291   class->ref_relation_set = gtk_window_accessible_ref_relation_set;
 292   class->ref_state_set = gtk_window_accessible_ref_state_set;
 293   class->initialize = gtk_window_accessible_initialize;
 294   class->focus_event = gtk_window_accessible_focus_event;
 295 }
 296
 297 static void
 298 gtk_window_accessible_init (GtkWindowAccessible *accessible)
 299 {
 300 }
 301
 302 static void
 303 gtk_window_accessible_get_extents (AtkComponent  *component,
 304                                    gint          *x,
 305                                    gint          *y,
 306                                    gint          *width,
 307                                    gint          *height,
 308                                    AtkCoordType   coord_type)
 309 {
 310   GtkWidget *widget;
 311   GdkWindow *window;
 312   GdkRectangle rect;
 313   gint x_toplevel, y_toplevel;
 314
 315   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (component));
 316   if (widget == NULL)
 317     return;
 318
 319   if (!gtk_widget_is_toplevel (widget))
 320     {
 321       AtkComponentIface *parent_iface;
 322
 323       parent_iface = (AtkComponentIface *) g_type_interface_peek_parent (ATK_COMPONENT_GET_IFACE (component));
 324       parent_iface->get_extents (component, x, y, width, height, coord_type);
 325       return;
 326     }
 327
 328   window = gtk_widget_get_window (widget);
 329   if (window == NULL)
 330     return;
 331
 332   gdk_window_get_frame_extents (window, &rect);
 333
 334   *width = rect.width;
 335   *height = rect.height;
 336   if (!gtk_widget_is_drawable (widget))
 337     {
 338       *x = G_MININT;
 339       *y = G_MININT;
 340       return;
 341     }
 342
 343   *x = rect.x;
 344   *y = rect.y;
 345   if (coord_type == ATK_XY_WINDOW)
 346     {
 347       gdk_window_get_origin (window, &x_toplevel, &y_toplevel);
 348       *x -= x_toplevel;
 349       *y -= y_toplevel;
 350     }
 351 }
 352
 353 static void
 354 gtk_window_accessible_get_size (AtkComponent *component,
 355                                 gint         *width,
 356                                 gint         *height)
 357 {
 358   GtkWidget *widget;
 359   GdkWindow *window;
 360   GdkRectangle rect;
 361
 362   widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (component));
 363   if (widget == NULL)
 364     return;
 365
 366   if (!gtk_widget_is_toplevel (widget))
 367     {
 368       AtkComponentIface *parent_iface;
 369
 370       parent_iface = (AtkComponentIface *) g_type_interface_peek_parent (ATK_COMPONENT_GET_IFACE (component));
 371       parent_iface->get_size (component, width, height);
 372       return;
 373     }
 374
 375   window = gtk_widget_get_window (widget);
 376   if (window == NULL)
 377     return;
 378
 379   gdk_window_get_frame_extents (window, &rect);
 380
 381   *width = rect.width;
 382   *height = rect.height;
 383 }
 384
 385 static void
 386 atk_component_interface_init (AtkComponentIface *iface)
 387 {
 388   iface->get_extents = gtk_window_accessible_get_extents;
 389   iface->get_size = gtk_window_accessible_get_size;
 390 }
 391
 392 static void
 393 atk_window_interface_init (AtkWindowIface *iface)
 394 {
 395   /* At this moment AtkWindow is just about signals */
 396 }