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 | |
30 | static void |
31 | gtk_undefined_accessible_value_print (const GtkAccessibleValue *value, |
32 | GString *buffer) |
33 | { |
34 | g_string_append (string: buffer, val: "undefined" ); |
35 | } |
36 | |
37 | static 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 | |
44 | static GtkAccessibleValue undefined_value = |
45 | GTK_ACCESSIBLE_VALUE_INIT (>K_UNDEFINED_ACCESSIBLE_VALUE); |
46 | |
47 | GtkAccessibleValue * |
48 | gtk_undefined_accessible_value_new (void) |
49 | { |
50 | return gtk_accessible_value_ref (self: &undefined_value); |
51 | } |
52 | |
53 | int |
54 | gtk_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 == >K_UNDEFINED_ACCESSIBLE_VALUE, |
58 | GTK_ACCESSIBLE_VALUE_UNDEFINED); |
59 | |
60 | return GTK_ACCESSIBLE_VALUE_UNDEFINED; |
61 | } |
62 | |
63 | /* }}} */ |
64 | |
65 | /* {{{ Boolean values */ |
66 | |
67 | typedef struct |
68 | { |
69 | GtkAccessibleValue parent; |
70 | |
71 | gboolean value; |
72 | } GtkBooleanAccessibleValue; |
73 | |
74 | static gboolean |
75 | gtk_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 | |
84 | static void |
85 | gtk_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 | |
93 | static 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 | |
101 | static GtkBooleanAccessibleValue boolean_values[] = { |
102 | { GTK_ACCESSIBLE_VALUE_INIT (>K_BOOLEAN_ACCESSIBLE_VALUE), FALSE }, |
103 | { GTK_ACCESSIBLE_VALUE_INIT (>K_BOOLEAN_ACCESSIBLE_VALUE), TRUE }, |
104 | }; |
105 | |
106 | GtkAccessibleValue * |
107 | gtk_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 | |
115 | gboolean |
116 | gtk_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 == >K_BOOLEAN_ACCESSIBLE_VALUE, FALSE); |
122 | |
123 | return self->value; |
124 | } |
125 | |
126 | /* }}} */ |
127 | |
128 | /* {{{ Tri-state values */ |
129 | |
130 | typedef struct { |
131 | GtkAccessibleValue parent; |
132 | |
133 | GtkAccessibleTristate value; |
134 | } GtkTristateAccessibleValue; |
135 | |
136 | static gboolean |
137 | gtk_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 | |
146 | static void |
147 | gtk_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 | |
172 | static 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 | |
180 | static GtkTristateAccessibleValue tristate_values[] = { |
181 | [GTK_ACCESSIBLE_TRISTATE_FALSE] = { |
182 | GTK_ACCESSIBLE_VALUE_INIT (>K_TRISTATE_ACCESSIBLE_VALUE), .value: GTK_ACCESSIBLE_TRISTATE_FALSE |
183 | }, |
184 | [GTK_ACCESSIBLE_TRISTATE_TRUE] = { |
185 | GTK_ACCESSIBLE_VALUE_INIT (>K_TRISTATE_ACCESSIBLE_VALUE), .value: GTK_ACCESSIBLE_TRISTATE_TRUE |
186 | }, |
187 | [GTK_ACCESSIBLE_TRISTATE_MIXED] = { |
188 | GTK_ACCESSIBLE_VALUE_INIT (>K_TRISTATE_ACCESSIBLE_VALUE), .value: GTK_ACCESSIBLE_TRISTATE_MIXED |
189 | }, |
190 | }; |
191 | |
192 | GtkAccessibleValue * |
193 | gtk_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 | |
201 | GtkAccessibleTristate |
202 | gtk_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 == >K_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 | |
217 | typedef struct { |
218 | GtkAccessibleValue parent; |
219 | |
220 | int value; |
221 | const char *token; |
222 | } GtkTokenAccessibleValue; |
223 | |
224 | static gboolean |
225 | gtk_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 | |
234 | static void |
235 | gtk_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 | |
243 | static 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 | |
251 | static GtkTokenAccessibleValue invalid_values[] = { |
252 | [GTK_ACCESSIBLE_INVALID_FALSE] = { |
253 | GTK_ACCESSIBLE_VALUE_INIT (>K_INVALID_ACCESSIBLE_VALUE), .value: GTK_ACCESSIBLE_INVALID_FALSE, .token: "false" |
254 | }, |
255 | [GTK_ACCESSIBLE_INVALID_TRUE] = { |
256 | GTK_ACCESSIBLE_VALUE_INIT (>K_INVALID_ACCESSIBLE_VALUE), .value: GTK_ACCESSIBLE_INVALID_TRUE, .token: "true" |
257 | }, |
258 | [GTK_ACCESSIBLE_INVALID_GRAMMAR] = { |
259 | GTK_ACCESSIBLE_VALUE_INIT (>K_INVALID_ACCESSIBLE_VALUE), .value: GTK_ACCESSIBLE_INVALID_GRAMMAR, .token: "grammar" |
260 | }, |
261 | [GTK_ACCESSIBLE_INVALID_SPELLING] = { |
262 | GTK_ACCESSIBLE_VALUE_INIT (>K_INVALID_ACCESSIBLE_VALUE), .value: GTK_ACCESSIBLE_INVALID_SPELLING, .token: "spelling" |
263 | }, |
264 | }; |
265 | |
266 | GtkAccessibleValue * |
267 | gtk_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 | |
276 | GtkAccessibleInvalidState |
277 | gtk_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 == >K_INVALID_ACCESSIBLE_VALUE, |
283 | GTK_ACCESSIBLE_INVALID_FALSE); |
284 | |
285 | return self->value; |
286 | } |
287 | |
288 | GtkAccessibleValue * |
289 | gtk_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 | |
301 | void |
302 | gtk_invalid_accessible_value_init_value (GValue *value) |
303 | { |
304 | g_value_init (value, g_type: GTK_TYPE_ACCESSIBLE_INVALID_STATE); |
305 | } |
306 | |
307 | static 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 | |
315 | static GtkTokenAccessibleValue autocomplete_values[] = { |
316 | [GTK_ACCESSIBLE_AUTOCOMPLETE_NONE] = { |
317 | GTK_ACCESSIBLE_VALUE_INIT (>K_AUTOCOMPLETE_ACCESSIBLE_VALUE), .value: GTK_ACCESSIBLE_AUTOCOMPLETE_NONE, .token: "none" |
318 | }, |
319 | [GTK_ACCESSIBLE_AUTOCOMPLETE_INLINE] = { |
320 | GTK_ACCESSIBLE_VALUE_INIT (>K_AUTOCOMPLETE_ACCESSIBLE_VALUE), .value: GTK_ACCESSIBLE_AUTOCOMPLETE_INLINE, .token: "inline" |
321 | }, |
322 | [GTK_ACCESSIBLE_AUTOCOMPLETE_LIST] = { |
323 | GTK_ACCESSIBLE_VALUE_INIT (>K_AUTOCOMPLETE_ACCESSIBLE_VALUE), .value: GTK_ACCESSIBLE_AUTOCOMPLETE_LIST, .token: "list" |
324 | }, |
325 | [GTK_ACCESSIBLE_AUTOCOMPLETE_BOTH] = { |
326 | GTK_ACCESSIBLE_VALUE_INIT (>K_AUTOCOMPLETE_ACCESSIBLE_VALUE), .value: GTK_ACCESSIBLE_AUTOCOMPLETE_BOTH, .token: "both" |
327 | }, |
328 | }; |
329 | |
330 | GtkAccessibleValue * |
331 | gtk_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 | |
340 | GtkAccessibleAutocomplete |
341 | gtk_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 == >K_AUTOCOMPLETE_ACCESSIBLE_VALUE, |
347 | GTK_ACCESSIBLE_AUTOCOMPLETE_NONE); |
348 | |
349 | return self->value; |
350 | } |
351 | |
352 | GtkAccessibleValue * |
353 | gtk_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 | |
365 | void |
366 | gtk_autocomplete_accessible_value_init_value (GValue *value) |
367 | { |
368 | g_value_init (value, g_type: GTK_TYPE_ACCESSIBLE_AUTOCOMPLETE); |
369 | } |
370 | |
371 | static 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 | |
379 | static GtkTokenAccessibleValue orientation_values[] = { |
380 | [GTK_ORIENTATION_HORIZONTAL] = { |
381 | GTK_ACCESSIBLE_VALUE_INIT (>K_ORIENTATION_ACCESSIBLE_VALUE), .value: GTK_ORIENTATION_HORIZONTAL, .token: "horizontal" |
382 | }, |
383 | [GTK_ORIENTATION_VERTICAL] = { |
384 | GTK_ACCESSIBLE_VALUE_INIT (>K_ORIENTATION_ACCESSIBLE_VALUE), .value: GTK_ORIENTATION_VERTICAL, .token: "vertical" |
385 | }, |
386 | }; |
387 | |
388 | GtkAccessibleValue * |
389 | gtk_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 | |
398 | GtkOrientation |
399 | gtk_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 == >K_ORIENTATION_ACCESSIBLE_VALUE, |
405 | GTK_ACCESSIBLE_VALUE_UNDEFINED); |
406 | |
407 | return self->value; |
408 | } |
409 | |
410 | GtkAccessibleValue * |
411 | gtk_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 | |
423 | void |
424 | gtk_orientation_accessible_value_init_value (GValue *value) |
425 | { |
426 | g_value_init (value, g_type: GTK_TYPE_ORIENTATION); |
427 | } |
428 | |
429 | static 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 | |
437 | static GtkTokenAccessibleValue sort_values[] = { |
438 | [GTK_ACCESSIBLE_SORT_NONE] = { |
439 | GTK_ACCESSIBLE_VALUE_INIT (>K_SORT_ACCESSIBLE_VALUE), .value: GTK_ACCESSIBLE_SORT_NONE, .token: "none" |
440 | }, |
441 | [GTK_ACCESSIBLE_SORT_ASCENDING] = { |
442 | GTK_ACCESSIBLE_VALUE_INIT (>K_SORT_ACCESSIBLE_VALUE), .value: GTK_ACCESSIBLE_SORT_ASCENDING, .token: "ascending" |
443 | }, |
444 | [GTK_ACCESSIBLE_SORT_DESCENDING] = { |
445 | GTK_ACCESSIBLE_VALUE_INIT (>K_SORT_ACCESSIBLE_VALUE), .value: GTK_ACCESSIBLE_SORT_DESCENDING, .token: "descending" |
446 | }, |
447 | [GTK_ACCESSIBLE_SORT_OTHER] = { |
448 | GTK_ACCESSIBLE_VALUE_INIT (>K_SORT_ACCESSIBLE_VALUE), .value: GTK_ACCESSIBLE_SORT_OTHER, .token: "other" |
449 | }, |
450 | }; |
451 | |
452 | GtkAccessibleValue * |
453 | gtk_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 | |
462 | GtkAccessibleSort |
463 | gtk_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 == >K_SORT_ACCESSIBLE_VALUE, |
469 | GTK_ACCESSIBLE_SORT_NONE); |
470 | |
471 | return self->value; |
472 | } |
473 | |
474 | GtkAccessibleValue * |
475 | gtk_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 | |
487 | void |
488 | gtk_sort_accessible_value_init_value (GValue *value) |
489 | { |
490 | g_value_init (value, g_type: GTK_TYPE_ACCESSIBLE_SORT); |
491 | } |
492 | |
493 | /* }}} */ |
494 | |