Debian Codegraph @

gtk/a11y/gtkspinbuttonaccessible.c

raw
1 /* GTK+ - accessibility implementations
2 * Copyright 2001, 2002, 2003 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, see <http://www.gnu.org/licenses/>.
16 */
17
18 #include "config.h"
19
20 #include <string.h>
21 #include <gtk/gtk.h>
22 #include "gtkspinbuttonaccessible.h"
23
24 struct _GtkSpinButtonAccessiblePrivate
25 {
26 GtkAdjustment *adjustment;
27 };
28
29 static void atk_value_interface_init (AtkValueIface *iface);
30
31 G_DEFINE_TYPE_WITH_CODE (GtkSpinButtonAccessible, gtk_spin_button_accessible, GTK_TYPE_ENTRY_ACCESSIBLE,
32 G_ADD_PRIVATE (GtkSpinButtonAccessible)
33 G_IMPLEMENT_INTERFACE (ATK_TYPE_VALUE, atk_value_interface_init))
34
35 static void
36 gtk_spin_button_accessible_value_changed (GtkAdjustment *adjustment,
37 gpointer data)
38 {
39 g_object_notify (G_OBJECT (data), "accessible-value");
40 }
41
42 static void
43 gtk_spin_button_accessible_widget_set (GtkAccessible *accessible)
44 {
45 GtkSpinButtonAccessiblePrivate *priv = GTK_SPIN_BUTTON_ACCESSIBLE (accessible)->priv;
46 GtkWidget *spin;
47 GtkAdjustment *adj;
48
49 spin = gtk_accessible_get_widget (accessible);
50 adj = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spin));
51 if (adj)
52 {
53 priv->adjustment = adj;
54 g_object_ref (priv->adjustment);
55 g_signal_connect (priv->adjustment, "value-changed",
56 G_CALLBACK (gtk_spin_button_accessible_value_changed),
57 accessible);
58 }
59 }
60
61 static void
62 gtk_spin_button_accessible_widget_unset (GtkAccessible *accessible)
63 {
64 GtkSpinButtonAccessiblePrivate *priv = GTK_SPIN_BUTTON_ACCESSIBLE (accessible)->priv;
65
66 if (priv->adjustment)
67 {
68 g_signal_handlers_disconnect_by_func (priv->adjustment,
69 G_CALLBACK (gtk_spin_button_accessible_value_changed),
70 accessible);
71 g_object_unref (priv->adjustment);
72 priv->adjustment = NULL;
73 }
74 }
75
76 static void
77 gtk_spin_button_accessible_initialize (AtkObject *obj,
78 gpointer data)
79 {
80 ATK_OBJECT_CLASS (gtk_spin_button_accessible_parent_class)->initialize (obj, data);
81 obj->role = ATK_ROLE_SPIN_BUTTON;
82 }
83
84 static void
85 gtk_spin_button_accessible_notify_gtk (GObject *obj,
86 GParamSpec *pspec)
87 {
88 GtkWidget *widget = GTK_WIDGET (obj);
89 AtkObject *spin;
90
91 if (strcmp (pspec->name, "adjustment") == 0)
92 {
93 spin = gtk_widget_get_accessible (widget);
94 gtk_spin_button_accessible_widget_unset (GTK_ACCESSIBLE (spin));
95 gtk_spin_button_accessible_widget_set (GTK_ACCESSIBLE (spin));
96
97 }
98 else
99 GTK_WIDGET_ACCESSIBLE_CLASS (gtk_spin_button_accessible_parent_class)->notify_gtk (obj, pspec);
100 }
101
102 static void
103 gtk_spin_button_accessible_class_init (GtkSpinButtonAccessibleClass *klass)
104 {
105 AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
106 GtkAccessibleClass *accessible_class = (GtkAccessibleClass*)klass;
107 GtkWidgetAccessibleClass *widget_class = (GtkWidgetAccessibleClass*)klass;
108
109 class->initialize = gtk_spin_button_accessible_initialize;
110
111 accessible_class->widget_set = gtk_spin_button_accessible_widget_set;
112 accessible_class->widget_unset = gtk_spin_button_accessible_widget_unset;
113
114 widget_class->notify_gtk = gtk_spin_button_accessible_notify_gtk;
115 }
116
117 static void
118 gtk_spin_button_accessible_init (GtkSpinButtonAccessible *button)
119 {
120 button->priv = gtk_spin_button_accessible_get_instance_private (button);
121 }
122
123 static void
124 gtk_spin_button_accessible_get_current_value (AtkValue *obj,
125 GValue *value)
126 {
127 GtkWidget *widget;
128 GtkAdjustment *adjustment;
129
130 widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
131 adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget));
132 if (adjustment == NULL)
133 return;
134
135 memset (value, 0, sizeof (GValue));
136 g_value_init (value, G_TYPE_DOUBLE);
137 g_value_set_double (value, gtk_adjustment_get_value (adjustment));
138 }
139
140 static void
141 gtk_spin_button_accessible_get_maximum_value (AtkValue *obj,
142 GValue *value)
143 {
144 GtkWidget *widget;
145 GtkAdjustment *adjustment;
146
147 widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
148 adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget));
149 if (adjustment == NULL)
150 return;
151
152 memset (value, 0, sizeof (GValue));
153 g_value_init (value, G_TYPE_DOUBLE);
154 g_value_set_double (value, gtk_adjustment_get_upper (adjustment));
155 }
156
157 static void
158 gtk_spin_button_accessible_get_minimum_value (AtkValue *obj,
159 GValue *value)
160 {
161 GtkWidget *widget;
162 GtkAdjustment *adjustment;
163
164 widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
165 adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget));
166 if (adjustment == NULL)
167 return;
168
169 memset (value, 0, sizeof (GValue));
170 g_value_init (value, G_TYPE_DOUBLE);
171 g_value_set_double (value, gtk_adjustment_get_lower (adjustment));
172 }
173
174 static void
175 gtk_spin_button_accessible_get_minimum_increment (AtkValue *obj,
176 GValue *value)
177 {
178 GtkWidget *widget;
179 GtkAdjustment *adjustment;
180
181 widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
182 adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget));
183 if (adjustment == NULL)
184 return;
185
186 memset (value, 0, sizeof (GValue));
187 g_value_init (value, G_TYPE_DOUBLE);
188 g_value_set_double (value, gtk_adjustment_get_minimum_increment (adjustment));
189 }
190
191 static gboolean
192 gtk_spin_button_accessible_set_current_value (AtkValue *obj,
193 const GValue *value)
194 {
195 GtkWidget *widget;
196 GtkAdjustment *adjustment;
197
198 widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
199 adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget));
200 if (adjustment == NULL)
201 return FALSE;
202
203 gtk_adjustment_set_value (adjustment, g_value_get_double (value));
204
205 return TRUE;
206 }
207
208 static void
209 gtk_spin_button_accessible_get_value_and_text (AtkValue *obj,
210 gdouble *value,
211 gchar **text)
212 {
213 GtkWidget *widget;
214 GtkAdjustment *adjustment;
215
216 widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
217 adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget));
218 if (adjustment == NULL)
219 return;
220
221 *value = gtk_adjustment_get_value (adjustment);
222 *text = NULL;
223 }
224
225 static AtkRange *
226 gtk_spin_button_accessible_get_range (AtkValue *obj)
227 {
228 GtkWidget *widget;
229 GtkAdjustment *adjustment;
230
231 widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
232 adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget));
233 if (adjustment == NULL)
234 return NULL;
235
236 return atk_range_new (gtk_adjustment_get_lower (adjustment),
237 gtk_adjustment_get_upper (adjustment),
238 NULL);
239 }
240
241 static void
242 gtk_spin_button_accessible_set_value (AtkValue *obj,
243 const gdouble value)
244 {
245 GtkWidget *widget;
246 GtkAdjustment *adjustment;
247
248 widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
249 adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget));
250 if (adjustment == NULL)
251 return;
252
253 gtk_adjustment_set_value (adjustment, value);
254 }
255
256 static gdouble
257 gtk_spin_button_accessible_get_increment (AtkValue *obj)
258 {
259 GtkWidget *widget;
260 GtkAdjustment *adjustment;
261
262 widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
263 adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget));
264 if (adjustment == NULL)
265 return 0;
266
267 return gtk_adjustment_get_minimum_increment (adjustment);
268 }
269
270 static void
271 atk_value_interface_init (AtkValueIface *iface)
272 {
273 iface->get_current_value = gtk_spin_button_accessible_get_current_value;
274 iface->get_maximum_value = gtk_spin_button_accessible_get_maximum_value;
275 iface->get_minimum_value = gtk_spin_button_accessible_get_minimum_value;
276 iface->get_minimum_increment = gtk_spin_button_accessible_get_minimum_increment;
277 iface->set_current_value = gtk_spin_button_accessible_set_current_value;
278
279 iface->get_value_and_text = gtk_spin_button_accessible_get_value_and_text;
280 iface->get_range = gtk_spin_button_accessible_get_range;
281 iface->set_value = gtk_spin_button_accessible_set_value;
282 iface->get_increment = gtk_spin_button_accessible_get_increment;
283 }