Debian Codegraph @

gtk/a11y/gtkwindowaccessible.c

raw
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 #include "gtkwindowprivate.h"
27
28 /* atkcomponent.h */
29
30 static void gtk_window_accessible_get_extents (AtkComponent *component,
31 gint *x,
32 gint *y,
33 gint *width,
34 gint *height,
35 AtkCoordType coord_type);
36 static void gtk_window_accessible_get_size (AtkComponent *component,
37 gint *width,
38 gint *height);
39
40 static void atk_component_interface_init (AtkComponentIface *iface);
41 static void atk_window_interface_init (AtkWindowIface *iface);
42
43 G_DEFINE_TYPE_WITH_CODE (GtkWindowAccessible,
44 gtk_window_accessible,
45 GTK_TYPE_CONTAINER_ACCESSIBLE,
46 G_IMPLEMENT_INTERFACE (ATK_TYPE_COMPONENT,
47 atk_component_interface_init)
48 G_IMPLEMENT_INTERFACE (ATK_TYPE_WINDOW,
49 atk_window_interface_init));
50
51
52 static void
53 gtk_window_accessible_focus_event (AtkObject *obj,
54 gboolean focus_in)
55 {
56 atk_object_notify_state_change (obj, ATK_STATE_ACTIVE, focus_in);
57 }
58
59 static void
60 gtk_window_accessible_notify_gtk (GObject *obj,
61 GParamSpec *pspec)
62 {
63 GtkWidget *widget = GTK_WIDGET (obj);
64 AtkObject* atk_obj = gtk_widget_get_accessible (widget);
65
66 if (g_strcmp0 (pspec->name, "title") == 0)
67 {
68 g_object_notify (G_OBJECT (atk_obj), "accessible-name");
69 g_signal_emit_by_name (atk_obj, "visible-data-changed");
70 }
71 else
72 GTK_WIDGET_ACCESSIBLE_CLASS (gtk_window_accessible_parent_class)->notify_gtk (obj, pspec);
73 }
74
75 static gboolean
76 window_state_event_cb (GtkWidget *widget,
77 GdkEventWindowState *event)
78 {
79 AtkObject* obj;
80
81 obj = gtk_widget_get_accessible (widget);
82 atk_object_notify_state_change (obj, ATK_STATE_ICONIFIED,
83 (event->new_window_state & GDK_WINDOW_STATE_ICONIFIED) != 0);
84
85 return FALSE;
86 }
87
88 static void
89 gtk_window_accessible_initialize (AtkObject *obj,
90 gpointer data)
91 {
92 GtkWidget *widget = GTK_WIDGET (data);
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 if (gtk_window_get_window_type (GTK_WINDOW (widget)) == GTK_WINDOW_POPUP)
100 obj->role = ATK_ROLE_WINDOW;
101 else
102 obj->role = ATK_ROLE_FRAME;
103 }
104
105 static GtkWidget *
106 find_label_child (GtkContainer *container)
107 {
108 GList *children, *tmp_list;
109 GtkWidget *child;
110
111 children = gtk_container_get_children (container);
112
113 child = NULL;
114 for (tmp_list = children; tmp_list != NULL; tmp_list = tmp_list->next)
115 {
116 if (GTK_IS_LABEL (tmp_list->data))
117 {
118 child = GTK_WIDGET (tmp_list->data);
119 break;
120 }
121 else if (GTK_IS_CONTAINER (tmp_list->data))
122 {
123 child = find_label_child (GTK_CONTAINER (tmp_list->data));
124 if (child)
125 break;
126 }
127 }
128 g_list_free (children);
129 return child;
130 }
131
132 static const gchar *
133 gtk_window_accessible_get_name (AtkObject *accessible)
134 {
135 const gchar* name;
136 GtkWidget* widget;
137
138 widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible));
139 if (widget == NULL)
140 return NULL;
141
142 name = ATK_OBJECT_CLASS (gtk_window_accessible_parent_class)->get_name (accessible);
143 if (name != NULL)
144 return name;
145
146 if (GTK_IS_WINDOW (widget))
147 {
148 GtkWindow *window = GTK_WINDOW (widget);
149
150 name = gtk_window_get_title (window);
151 if (name == NULL && accessible->role == ATK_ROLE_TOOL_TIP)
152 {
153 GtkWidget *child;
154
155 child = find_label_child (GTK_CONTAINER (window));
156 if (GTK_IS_LABEL (child))
157 name = gtk_label_get_text (GTK_LABEL (child));
158 }
159 }
160 return name;
161 }
162
163 static gint
164 gtk_window_accessible_get_index_in_parent (AtkObject *accessible)
165 {
166 GtkWidget* widget;
167 AtkObject* atk_obj;
168 gint index = -1;
169
170 widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible));
171 if (widget == NULL)
172 return -1;
173
174 index = ATK_OBJECT_CLASS (gtk_window_accessible_parent_class)->get_index_in_parent (accessible);
175 if (index != -1)
176 return index;
177
178 atk_obj = atk_get_root ();
179
180 if (GTK_IS_WINDOW (widget))
181 {
182 GtkWindow *window = GTK_WINDOW (widget);
183 if (GTK_IS_TOPLEVEL_ACCESSIBLE (atk_obj))
184 {
185 GtkToplevelAccessible *toplevel = GTK_TOPLEVEL_ACCESSIBLE (atk_obj);
186 index = g_list_index (gtk_toplevel_accessible_get_children (toplevel), window);
187 }
188 else
189 {
190 gint i, sibling_count;
191
192 sibling_count = atk_object_get_n_accessible_children (atk_obj);
193 for (i = 0; i < sibling_count && index == -1; ++i)
194 {
195 AtkObject *child = atk_object_ref_accessible_child (atk_obj, i);
196 if (accessible == child)
197 index = i;
198 g_object_unref (G_OBJECT (child));
199 }
200 }
201 }
202 return index;
203 }
204
205 static AtkRelationSet *
206 gtk_window_accessible_ref_relation_set (AtkObject *obj)
207 {
208 GtkWidget *widget;
209 AtkRelationSet *relation_set;
210 AtkObject *array[1];
211 AtkRelation* relation;
212 GtkWidget *current_widget;
213
214 widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
215 if (widget == NULL)
216 return NULL;
217
218 relation_set = ATK_OBJECT_CLASS (gtk_window_accessible_parent_class)->ref_relation_set (obj);
219
220 if (atk_object_get_role (obj) == ATK_ROLE_TOOL_TIP)
221 {
222 relation = atk_relation_set_get_relation_by_type (relation_set, ATK_RELATION_POPUP_FOR);
223 if (relation)
224 atk_relation_set_remove (relation_set, relation);
225
226 if (0) /* FIXME need a way to go from tooltip window to widget */
227 {
228 array[0] = gtk_widget_get_accessible (current_widget);
229 relation = atk_relation_new (array, 1, ATK_RELATION_POPUP_FOR);
230 atk_relation_set_add (relation_set, relation);
231 g_object_unref (relation);
232 }
233 }
234 return relation_set;
235 }
236
237 static AtkStateSet *
238 gtk_window_accessible_ref_state_set (AtkObject *accessible)
239 {
240 AtkStateSet *state_set;
241 GtkWidget *widget;
242 GtkWindow *window;
243 GdkWindow *gdk_window;
244 GdkWindowState state;
245
246 widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible));
247 if (widget == NULL)
248 return NULL;
249
250 state_set = ATK_OBJECT_CLASS (gtk_window_accessible_parent_class)->ref_state_set (accessible);
251
252 window = GTK_WINDOW (widget);
253
254 if (gtk_window_has_toplevel_focus (window) && gtk_window_is_active (window))
255 atk_state_set_add_state (state_set, ATK_STATE_ACTIVE);
256
257 gdk_window = gtk_widget_get_window (widget);
258 if (gdk_window)
259 {
260 state = gdk_window_get_state (gdk_window);
261 if (state & GDK_WINDOW_STATE_ICONIFIED)
262 atk_state_set_add_state (state_set, ATK_STATE_ICONIFIED);
263 }
264 if (gtk_window_get_modal (window))
265 atk_state_set_add_state (state_set, ATK_STATE_MODAL);
266
267 if (gtk_window_get_resizable (window))
268 atk_state_set_add_state (state_set, ATK_STATE_RESIZABLE);
269
270 return state_set;
271 }
272
273 static void
274 count_widget (GtkWidget *widget,
275 gint *count)
276 {
277 (*count)++;
278 }
279
280 static void
281 prepend_widget (GtkWidget *widget,
282 GList **list)
283 {
284 *list = g_list_prepend (*list, widget);
285 }
286
287 static gint
288 gtk_window_accessible_get_n_children (AtkObject *object)
289 {
290 GtkWidget *window;
291 gint count = 0;
292
293 window = gtk_accessible_get_widget (GTK_ACCESSIBLE (object));
294 gtk_container_forall (GTK_CONTAINER (window),
295 (GtkCallback) count_widget, &count);
296 return count;
297 }
298
299 static AtkObject *
300 gtk_window_accessible_ref_child (AtkObject *object,
301 gint i)
302 {
303 GtkWidget *window, *ref_child;
304 GList *children = NULL;
305
306 window = gtk_accessible_get_widget (GTK_ACCESSIBLE (object));
307 gtk_container_forall (GTK_CONTAINER (window),
308 (GtkCallback) prepend_widget, &children);
309 ref_child = g_list_nth_data (children, i);
310 g_list_free (children);
311
312 if (!ref_child)
313 return NULL;
314
315 return g_object_ref (gtk_widget_get_accessible (ref_child));
316 }
317
318 static AtkAttributeSet *
319 gtk_widget_accessible_get_attributes (AtkObject *obj)
320 {
321 GtkWidget *window;
322 GdkWindowTypeHint hint;
323 AtkAttributeSet *attributes;
324 AtkAttribute *attr;
325 GEnumClass *class;
326 GEnumValue *value;
327
328 attributes = ATK_OBJECT_CLASS (gtk_window_accessible_parent_class)->get_attributes (obj);
329
330 attr = g_new (AtkAttribute, 1);
331 attr->name = g_strdup ("window-type");
332
333 window = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
334 hint = gtk_window_get_type_hint (GTK_WINDOW (window));
335
336 class = g_type_class_ref (GDK_TYPE_WINDOW_TYPE_HINT);
337 for (value = class->values; value->value_name; value++)
338 {
339 if (hint == value->value)
340 {
341 attr->value = g_strdup (value->value_nick);
342 break;
343 }
344 }
345 g_type_class_unref (class);
346
347 attributes = g_slist_append (attributes, attr);
348
349 return attributes;
350 }
351
352 static void
353 gtk_window_accessible_class_init (GtkWindowAccessibleClass *klass)
354 {
355 GtkWidgetAccessibleClass *widget_class = (GtkWidgetAccessibleClass*)klass;
356 AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
357
358 widget_class->notify_gtk = gtk_window_accessible_notify_gtk;
359
360 class->get_name = gtk_window_accessible_get_name;
361 class->get_index_in_parent = gtk_window_accessible_get_index_in_parent;
362 class->ref_relation_set = gtk_window_accessible_ref_relation_set;
363 class->ref_state_set = gtk_window_accessible_ref_state_set;
364 class->initialize = gtk_window_accessible_initialize;
365 class->focus_event = gtk_window_accessible_focus_event;
366 class->get_n_children = gtk_window_accessible_get_n_children;
367 class->ref_child = gtk_window_accessible_ref_child;
368 class->get_attributes = gtk_widget_accessible_get_attributes;
369 }
370
371 static void
372 gtk_window_accessible_init (GtkWindowAccessible *accessible)
373 {
374 }
375
376 static void
377 gtk_window_accessible_get_extents (AtkComponent *component,
378 gint *x,
379 gint *y,
380 gint *width,
381 gint *height,
382 AtkCoordType coord_type)
383 {
384 GtkWidget *widget;
385 GdkWindow *window;
386 GdkRectangle rect;
387 gint x_toplevel, y_toplevel;
388
389 widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (component));
390 if (widget == NULL)
391 return;
392
393 if (!gtk_widget_is_toplevel (widget))
394 {
395 AtkComponentIface *parent_iface;
396
397 parent_iface = (AtkComponentIface *) g_type_interface_peek_parent (ATK_COMPONENT_GET_IFACE (component));
398 parent_iface->get_extents (component, x, y, width, height, coord_type);
399 return;
400 }
401
402 window = gtk_widget_get_window (widget);
403 if (window == NULL)
404 return;
405
406 gdk_window_get_frame_extents (window, &rect);
407
408 *width = rect.width;
409 *height = rect.height;
410 if (!gtk_widget_is_drawable (widget))
411 {
412 *x = G_MININT;
413 *y = G_MININT;
414 return;
415 }
416
417 *x = rect.x;
418 *y = rect.y;
419 if (coord_type == ATK_XY_WINDOW)
420 {
421 gdk_window_get_origin (window, &x_toplevel, &y_toplevel);
422 *x -= x_toplevel;
423 *y -= y_toplevel;
424 }
425 }
426
427 static void
428 gtk_window_accessible_get_size (AtkComponent *component,
429 gint *width,
430 gint *height)
431 {
432 GtkWidget *widget;
433 GdkWindow *window;
434 GdkRectangle rect;
435
436 widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (component));
437 if (widget == NULL)
438 return;
439
440 if (!gtk_widget_is_toplevel (widget))
441 {
442 AtkComponentIface *parent_iface;
443
444 parent_iface = (AtkComponentIface *) g_type_interface_peek_parent (ATK_COMPONENT_GET_IFACE (component));
445 parent_iface->get_size (component, width, height);
446 return;
447 }
448
449 window = gtk_widget_get_window (widget);
450 if (window == NULL)
451 return;
452
453 gdk_window_get_frame_extents (window, &rect);
454
455 *width = rect.width;
456 *height = rect.height;
457 }
458
459 static void
460 atk_component_interface_init (AtkComponentIface *iface)
461 {
462 iface->get_extents = gtk_window_accessible_get_extents;
463 iface->get_size = gtk_window_accessible_get_size;
464 }
465
466 static void
467 atk_window_interface_init (AtkWindowIface *iface)
468 {
469 /* At this moment AtkWindow is just about signals */
470 }