1/* gtkaccessiblevaluestatic.c: GtkAccessibleValue static implementations
2 *
3 * Copyright 2020 GNOME Foundation
4 *
5 * SPDX-License-Identifier: LGPL-2.1-or-later
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
19 */
20
21#include "config.h"
22
23#include "gtkaccessiblevalueprivate.h"
24#include "gtkbuilderprivate.h"
25#include "gtkenums.h"
26#include "gtktypebuiltins.h"
27
28/* {{{ Undefined value */
29
30static void
31gtk_undefined_accessible_value_print (const GtkAccessibleValue *value,
32 GString *buffer)
33{
34 g_string_append (string: buffer, val: "undefined");
35}
36
37static const GtkAccessibleValueClass GTK_UNDEFINED_ACCESSIBLE_VALUE = {
38 .type = GTK_ACCESSIBLE_VALUE_TYPE_UNDEFINED,
39 .type_name = "GtkUndefinedAccessibleValue",
40 .instance_size = sizeof (GtkAccessibleValue),
41 .print = gtk_undefined_accessible_value_print,
42};
43
44static GtkAccessibleValue undefined_value =
45 GTK_ACCESSIBLE_VALUE_INIT (&GTK_UNDEFINED_ACCESSIBLE_VALUE);
46
47GtkAccessibleValue *
48gtk_undefined_accessible_value_new (void)
49{
50 return gtk_accessible_value_ref (self: &undefined_value);
51}
52
53int
54gtk_undefined_accessible_value_get (const GtkAccessibleValue *value)
55{
56 g_return_val_if_fail (value != NULL, GTK_ACCESSIBLE_VALUE_UNDEFINED);
57 g_return_val_if_fail (value->value_class == &GTK_UNDEFINED_ACCESSIBLE_VALUE,
58 GTK_ACCESSIBLE_VALUE_UNDEFINED);
59
60 return GTK_ACCESSIBLE_VALUE_UNDEFINED;
61}
62
63/* }}} */
64
65/* {{{ Boolean values */
66
67typedef struct
68{
69 GtkAccessibleValue parent;
70
71 gboolean value;
72} GtkBooleanAccessibleValue;
73
74static gboolean
75gtk_boolean_accessible_value_equal (const GtkAccessibleValue *value_a,
76 const GtkAccessibleValue *value_b)
77{
78 const GtkBooleanAccessibleValue *bool_a = (GtkBooleanAccessibleValue *) value_a;
79 const GtkBooleanAccessibleValue *bool_b = (GtkBooleanAccessibleValue *) value_b;
80
81 return bool_a->value == bool_b->value;
82}
83
84static void
85gtk_boolean_accessible_value_print (const GtkAccessibleValue *value,
86 GString *buffer)
87{
88 const GtkBooleanAccessibleValue *self = (GtkBooleanAccessibleValue *) value;
89
90 g_string_append_printf (string: buffer, format: "%s", self->value ? "true" : "false");
91}
92
93static const GtkAccessibleValueClass GTK_BOOLEAN_ACCESSIBLE_VALUE = {
94 .type = GTK_ACCESSIBLE_VALUE_TYPE_BOOLEAN,
95 .type_name = "GtkBooleanAccessibleValue",
96 .instance_size = sizeof (GtkBooleanAccessibleValue),
97 .equal = gtk_boolean_accessible_value_equal,
98 .print = gtk_boolean_accessible_value_print,
99};
100
101static GtkBooleanAccessibleValue boolean_values[] = {
102 { GTK_ACCESSIBLE_VALUE_INIT (&GTK_BOOLEAN_ACCESSIBLE_VALUE), FALSE },
103 { GTK_ACCESSIBLE_VALUE_INIT (&GTK_BOOLEAN_ACCESSIBLE_VALUE), TRUE },
104};
105
106GtkAccessibleValue *
107gtk_boolean_accessible_value_new (gboolean state)
108{
109 if (state)
110 return gtk_accessible_value_ref (self: (GtkAccessibleValue *) &boolean_values[1]);
111
112 return gtk_accessible_value_ref (self: (GtkAccessibleValue *) &boolean_values[0]);
113}
114
115gboolean
116gtk_boolean_accessible_value_get (const GtkAccessibleValue *value)
117{
118 GtkBooleanAccessibleValue *self = (GtkBooleanAccessibleValue *) value;
119
120 g_return_val_if_fail (value != NULL, FALSE);
121 g_return_val_if_fail (value->value_class == &GTK_BOOLEAN_ACCESSIBLE_VALUE, FALSE);
122
123 return self->value;
124}
125
126/* }}} */
127
128/* {{{ Tri-state values */
129
130typedef struct {
131 GtkAccessibleValue parent;
132
133 GtkAccessibleTristate value;
134} GtkTristateAccessibleValue;
135
136static gboolean
137gtk_tristate_accessible_value_equal (const GtkAccessibleValue *value_a,
138 const GtkAccessibleValue *value_b)
139{
140 const GtkTristateAccessibleValue *self_a = (GtkTristateAccessibleValue *) value_a;
141 const GtkTristateAccessibleValue *self_b = (GtkTristateAccessibleValue *) value_b;
142
143 return self_a->value == self_b->value;
144}
145
146static void
147gtk_tristate_accessible_value_print (const GtkAccessibleValue *value,
148 GString *buffer)
149{
150 const GtkTristateAccessibleValue *self = (GtkTristateAccessibleValue *) value;
151
152 switch (self->value)
153 {
154 case GTK_ACCESSIBLE_TRISTATE_FALSE:
155 g_string_append (string: buffer, val: "false");
156 break;
157
158 case GTK_ACCESSIBLE_TRISTATE_TRUE:
159 g_string_append (string: buffer, val: "true");
160 break;
161
162 case GTK_ACCESSIBLE_TRISTATE_MIXED:
163 g_string_append (string: buffer, val: "mixed");
164 break;
165
166 default:
167 g_assert_not_reached ();
168 break;
169 }
170}
171
172static const GtkAccessibleValueClass GTK_TRISTATE_ACCESSIBLE_VALUE = {
173 .type = GTK_ACCESSIBLE_VALUE_TYPE_TRISTATE,
174 .type_name = "GtkTristateAccessibleValue",
175 .instance_size = sizeof (GtkTristateAccessibleValue),
176 .equal = gtk_tristate_accessible_value_equal,
177 .print = gtk_tristate_accessible_value_print,
178};
179
180static GtkTristateAccessibleValue tristate_values[] = {
181 [GTK_ACCESSIBLE_TRISTATE_FALSE] = {
182 GTK_ACCESSIBLE_VALUE_INIT (&GTK_TRISTATE_ACCESSIBLE_VALUE), .value: GTK_ACCESSIBLE_TRISTATE_FALSE
183 },
184 [GTK_ACCESSIBLE_TRISTATE_TRUE] = {
185 GTK_ACCESSIBLE_VALUE_INIT (&GTK_TRISTATE_ACCESSIBLE_VALUE), .value: GTK_ACCESSIBLE_TRISTATE_TRUE
186 },
187 [GTK_ACCESSIBLE_TRISTATE_MIXED] = {
188 GTK_ACCESSIBLE_VALUE_INIT (&GTK_TRISTATE_ACCESSIBLE_VALUE), .value: GTK_ACCESSIBLE_TRISTATE_MIXED
189 },
190};
191
192GtkAccessibleValue *
193gtk_tristate_accessible_value_new (GtkAccessibleTristate value)
194{
195 g_return_val_if_fail (value >= GTK_ACCESSIBLE_TRISTATE_FALSE &&
196 value <= GTK_ACCESSIBLE_TRISTATE_MIXED, NULL);
197
198 return gtk_accessible_value_ref (self: (GtkAccessibleValue *) &tristate_values[value]);
199}
200
201GtkAccessibleTristate
202gtk_tristate_accessible_value_get (const GtkAccessibleValue *value)
203{
204 g_return_val_if_fail (value != NULL, GTK_ACCESSIBLE_TRISTATE_FALSE);
205 g_return_val_if_fail (value->value_class == &GTK_TRISTATE_ACCESSIBLE_VALUE,
206 GTK_ACCESSIBLE_TRISTATE_FALSE);
207
208 GtkTristateAccessibleValue *self = (GtkTristateAccessibleValue *) value;
209
210 return self->value;
211}
212
213/* }}} */
214
215/* {{{ Enumeration values */
216
217typedef struct {
218 GtkAccessibleValue parent;
219
220 int value;
221 const char *token;
222} GtkTokenAccessibleValue;
223
224static gboolean
225gtk_token_accessible_value_equal (const GtkAccessibleValue *value_a,
226 const GtkAccessibleValue *value_b)
227{
228 const GtkTokenAccessibleValue *self_a = (GtkTokenAccessibleValue *) value_a;
229 const GtkTokenAccessibleValue *self_b = (GtkTokenAccessibleValue *) value_b;
230
231 return self_a->value == self_b->value;
232}
233
234static void
235gtk_token_accessible_value_print (const GtkAccessibleValue *value,
236 GString *buffer)
237{
238 const GtkTokenAccessibleValue *self = (GtkTokenAccessibleValue *) value;
239
240 g_string_append (string: buffer, val: self->token);
241}
242
243static const GtkAccessibleValueClass GTK_INVALID_ACCESSIBLE_VALUE = {
244 .type = GTK_ACCESSIBLE_VALUE_TYPE_TOKEN,
245 .type_name = "GtkInvalidAccessibleValue",
246 .instance_size = sizeof (GtkTokenAccessibleValue),
247 .equal = gtk_token_accessible_value_equal,
248 .print = gtk_token_accessible_value_print,
249};
250
251static GtkTokenAccessibleValue invalid_values[] = {
252 [GTK_ACCESSIBLE_INVALID_FALSE] = {
253 GTK_ACCESSIBLE_VALUE_INIT (&GTK_INVALID_ACCESSIBLE_VALUE), .value: GTK_ACCESSIBLE_INVALID_FALSE, .token: "false"
254 },
255 [GTK_ACCESSIBLE_INVALID_TRUE] = {
256 GTK_ACCESSIBLE_VALUE_INIT (&GTK_INVALID_ACCESSIBLE_VALUE), .value: GTK_ACCESSIBLE_INVALID_TRUE, .token: "true"
257 },
258 [GTK_ACCESSIBLE_INVALID_GRAMMAR] = {
259 GTK_ACCESSIBLE_VALUE_INIT (&GTK_INVALID_ACCESSIBLE_VALUE), .value: GTK_ACCESSIBLE_INVALID_GRAMMAR, .token: "grammar"
260 },
261 [GTK_ACCESSIBLE_INVALID_SPELLING] = {
262 GTK_ACCESSIBLE_VALUE_INIT (&GTK_INVALID_ACCESSIBLE_VALUE), .value: GTK_ACCESSIBLE_INVALID_SPELLING, .token: "spelling"
263 },
264};
265
266GtkAccessibleValue *
267gtk_invalid_accessible_value_new (GtkAccessibleInvalidState state)
268{
269 g_return_val_if_fail (state >= GTK_ACCESSIBLE_INVALID_FALSE &&
270 state <= GTK_ACCESSIBLE_INVALID_SPELLING,
271 NULL);
272
273 return gtk_accessible_value_ref (self: (GtkAccessibleValue *) &invalid_values[state]);
274}
275
276GtkAccessibleInvalidState
277gtk_invalid_accessible_value_get (const GtkAccessibleValue *value)
278{
279 GtkTokenAccessibleValue *self = (GtkTokenAccessibleValue *) value;
280
281 g_return_val_if_fail (value != NULL, GTK_ACCESSIBLE_INVALID_FALSE);
282 g_return_val_if_fail (value->value_class == &GTK_INVALID_ACCESSIBLE_VALUE,
283 GTK_ACCESSIBLE_INVALID_FALSE);
284
285 return self->value;
286}
287
288GtkAccessibleValue *
289gtk_invalid_accessible_value_parse (const char *str,
290 gsize len,
291 GError **error)
292{
293 int value;
294
295 if (_gtk_builder_enum_from_string (type: GTK_TYPE_ACCESSIBLE_INVALID_STATE, string: str, enum_value: &value, error))
296 return gtk_invalid_accessible_value_new (state: value);
297
298 return NULL;
299}
300
301void
302gtk_invalid_accessible_value_init_value (GValue *value)
303{
304 g_value_init (value, g_type: GTK_TYPE_ACCESSIBLE_INVALID_STATE);
305}
306
307static const GtkAccessibleValueClass GTK_AUTOCOMPLETE_ACCESSIBLE_VALUE = {
308 .type = GTK_ACCESSIBLE_VALUE_TYPE_TOKEN,
309 .type_name = "GtkAutocompleteAccessibleValue",
310 .instance_size = sizeof (GtkTokenAccessibleValue),
311 .equal = gtk_token_accessible_value_equal,
312 .print = gtk_token_accessible_value_print,
313};
314
315static GtkTokenAccessibleValue autocomplete_values[] = {
316 [GTK_ACCESSIBLE_AUTOCOMPLETE_NONE] = {
317 GTK_ACCESSIBLE_VALUE_INIT (&GTK_AUTOCOMPLETE_ACCESSIBLE_VALUE), .value: GTK_ACCESSIBLE_AUTOCOMPLETE_NONE, .token: "none"
318 },
319 [GTK_ACCESSIBLE_AUTOCOMPLETE_INLINE] = {
320 GTK_ACCESSIBLE_VALUE_INIT (&GTK_AUTOCOMPLETE_ACCESSIBLE_VALUE), .value: GTK_ACCESSIBLE_AUTOCOMPLETE_INLINE, .token: "inline"
321 },
322 [GTK_ACCESSIBLE_AUTOCOMPLETE_LIST] = {
323 GTK_ACCESSIBLE_VALUE_INIT (&GTK_AUTOCOMPLETE_ACCESSIBLE_VALUE), .value: GTK_ACCESSIBLE_AUTOCOMPLETE_LIST, .token: "list"
324 },
325 [GTK_ACCESSIBLE_AUTOCOMPLETE_BOTH] = {
326 GTK_ACCESSIBLE_VALUE_INIT (&GTK_AUTOCOMPLETE_ACCESSIBLE_VALUE), .value: GTK_ACCESSIBLE_AUTOCOMPLETE_BOTH, .token: "both"
327 },
328};
329
330GtkAccessibleValue *
331gtk_autocomplete_accessible_value_new (GtkAccessibleAutocomplete value)
332{
333 g_return_val_if_fail (value >= GTK_ACCESSIBLE_AUTOCOMPLETE_NONE &&
334 value <= GTK_ACCESSIBLE_AUTOCOMPLETE_BOTH,
335 NULL);
336
337 return gtk_accessible_value_ref (self: (GtkAccessibleValue *) &autocomplete_values[value]);
338}
339
340GtkAccessibleAutocomplete
341gtk_autocomplete_accessible_value_get (const GtkAccessibleValue *value)
342{
343 GtkTokenAccessibleValue *self = (GtkTokenAccessibleValue *) value;
344
345 g_return_val_if_fail (value != NULL, GTK_ACCESSIBLE_AUTOCOMPLETE_NONE);
346 g_return_val_if_fail (value->value_class == &GTK_AUTOCOMPLETE_ACCESSIBLE_VALUE,
347 GTK_ACCESSIBLE_AUTOCOMPLETE_NONE);
348
349 return self->value;
350}
351
352GtkAccessibleValue *
353gtk_autocomplete_accessible_value_parse (const char *str,
354 gsize len,
355 GError **error)
356{
357 int value;
358
359 if (_gtk_builder_enum_from_string (type: GTK_TYPE_ACCESSIBLE_AUTOCOMPLETE, string: str, enum_value: &value, error))
360 return gtk_autocomplete_accessible_value_new (value);
361
362 return NULL;
363}
364
365void
366gtk_autocomplete_accessible_value_init_value (GValue *value)
367{
368 g_value_init (value, g_type: GTK_TYPE_ACCESSIBLE_AUTOCOMPLETE);
369}
370
371static const GtkAccessibleValueClass GTK_ORIENTATION_ACCESSIBLE_VALUE = {
372 .type = GTK_ACCESSIBLE_VALUE_TYPE_TOKEN,
373 .type_name = "GtkOrientationAccessibleValue",
374 .instance_size = sizeof (GtkTokenAccessibleValue),
375 .equal = gtk_token_accessible_value_equal,
376 .print = gtk_token_accessible_value_print,
377};
378
379static GtkTokenAccessibleValue orientation_values[] = {
380 [GTK_ORIENTATION_HORIZONTAL] = {
381 GTK_ACCESSIBLE_VALUE_INIT (&GTK_ORIENTATION_ACCESSIBLE_VALUE), .value: GTK_ORIENTATION_HORIZONTAL, .token: "horizontal"
382 },
383 [GTK_ORIENTATION_VERTICAL] = {
384 GTK_ACCESSIBLE_VALUE_INIT (&GTK_ORIENTATION_ACCESSIBLE_VALUE), .value: GTK_ORIENTATION_VERTICAL, .token: "vertical"
385 },
386};
387
388GtkAccessibleValue *
389gtk_orientation_accessible_value_new (GtkOrientation value)
390{
391 g_return_val_if_fail (value >= GTK_ORIENTATION_HORIZONTAL &&
392 value <= GTK_ORIENTATION_VERTICAL,
393 NULL);
394
395 return gtk_accessible_value_ref (self: (GtkAccessibleValue *) &orientation_values[value]);
396}
397
398GtkOrientation
399gtk_orientation_accessible_value_get (const GtkAccessibleValue *value)
400{
401 GtkTokenAccessibleValue *self = (GtkTokenAccessibleValue *) value;
402
403 g_return_val_if_fail (value != NULL, GTK_ACCESSIBLE_VALUE_UNDEFINED);
404 g_return_val_if_fail (value->value_class == &GTK_ORIENTATION_ACCESSIBLE_VALUE,
405 GTK_ACCESSIBLE_VALUE_UNDEFINED);
406
407 return self->value;
408}
409
410GtkAccessibleValue *
411gtk_orientation_accessible_value_parse (const char *str,
412 gsize len,
413 GError **error)
414{
415 int value;
416
417 if (_gtk_builder_enum_from_string (type: GTK_TYPE_ORIENTATION, string: str, enum_value: &value, error))
418 return gtk_orientation_accessible_value_new (value);
419
420 return NULL;
421}
422
423void
424gtk_orientation_accessible_value_init_value (GValue *value)
425{
426 g_value_init (value, g_type: GTK_TYPE_ORIENTATION);
427}
428
429static const GtkAccessibleValueClass GTK_SORT_ACCESSIBLE_VALUE = {
430 .type = GTK_ACCESSIBLE_VALUE_TYPE_TOKEN,
431 .type_name = "GtkSortAccessibleValue",
432 .instance_size = sizeof (GtkTokenAccessibleValue),
433 .equal = gtk_token_accessible_value_equal,
434 .print = gtk_token_accessible_value_print,
435};
436
437static GtkTokenAccessibleValue sort_values[] = {
438 [GTK_ACCESSIBLE_SORT_NONE] = {
439 GTK_ACCESSIBLE_VALUE_INIT (&GTK_SORT_ACCESSIBLE_VALUE), .value: GTK_ACCESSIBLE_SORT_NONE, .token: "none"
440 },
441 [GTK_ACCESSIBLE_SORT_ASCENDING] = {
442 GTK_ACCESSIBLE_VALUE_INIT (&GTK_SORT_ACCESSIBLE_VALUE), .value: GTK_ACCESSIBLE_SORT_ASCENDING, .token: "ascending"
443 },
444 [GTK_ACCESSIBLE_SORT_DESCENDING] = {
445 GTK_ACCESSIBLE_VALUE_INIT (&GTK_SORT_ACCESSIBLE_VALUE), .value: GTK_ACCESSIBLE_SORT_DESCENDING, .token: "descending"
446 },
447 [GTK_ACCESSIBLE_SORT_OTHER] = {
448 GTK_ACCESSIBLE_VALUE_INIT (&GTK_SORT_ACCESSIBLE_VALUE), .value: GTK_ACCESSIBLE_SORT_OTHER, .token: "other"
449 },
450};
451
452GtkAccessibleValue *
453gtk_sort_accessible_value_new (GtkAccessibleSort value)
454{
455 g_return_val_if_fail (value >= GTK_ACCESSIBLE_SORT_NONE &&
456 value <= GTK_ACCESSIBLE_SORT_OTHER,
457 NULL);
458
459 return gtk_accessible_value_ref (self: (GtkAccessibleValue *) &sort_values[value]);
460}
461
462GtkAccessibleSort
463gtk_sort_accessible_value_get (const GtkAccessibleValue *value)
464{
465 GtkTokenAccessibleValue *self = (GtkTokenAccessibleValue *) value;
466
467 g_return_val_if_fail (value != NULL, GTK_ACCESSIBLE_SORT_NONE);
468 g_return_val_if_fail (value->value_class == &GTK_SORT_ACCESSIBLE_VALUE,
469 GTK_ACCESSIBLE_SORT_NONE);
470
471 return self->value;
472}
473
474GtkAccessibleValue *
475gtk_sort_accessible_value_parse (const char *str,
476 gsize len,
477 GError **error)
478{
479 int value;
480
481 if (_gtk_builder_enum_from_string (type: GTK_TYPE_ACCESSIBLE_SORT, string: str, enum_value: &value, error))
482 return gtk_sort_accessible_value_new (value);
483
484 return NULL;
485}
486
487void
488gtk_sort_accessible_value_init_value (GValue *value)
489{
490 g_value_init (value, g_type: GTK_TYPE_ACCESSIBLE_SORT);
491}
492
493/* }}} */
494

source code of gtk/gtk/gtkaccessiblevaluestatic.c