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

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