1 /* GTK - The GIMP Toolkit
2 * Copyright (C) 1998-2002 James Henstridge <james@daa.com.au>
3 * Copyright (C) 2006-2007 Async Open Source,
4 * Johan Dahlin <jdahlin@async.com.br>,
5 * Henrique Romano <henrique@async.com.br>
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Library General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 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 * Library General Public License for more details.
16 *
17 * You should have received a copy of the GNU Library General Public
18 * License along with this library; if not, write to the
19 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 * Boston, MA 02111-1307, USA.
21 */
22
23 #include "config.h"
24 #include <errno.h> /* errno */
25 #include <stdlib.h> /* strtol, strtoul */
26 #include <string.h> /* strlen */
27
28 #include "gtkbuilder.h"
29 #include "gtkbuildable.h"
30 #include "gtkbuilderprivate.h"
31 #include "gtkmain.h"
32 #include "gtkintl.h"
33 #include "gtkprivate.h"
34 #include "gtktypebuiltins.h"
35 #include "gtkwindow.h"
36 #include "gtkicontheme.h"
37 #include "gtkstock.h"
38 #include "gtkalias.h"
39
40 static void gtk_builder_class_init (GtkBuilderClass *klass);
41 static void gtk_builder_init (GtkBuilder *builder);
42 static void gtk_builder_finalize (GObject *object);
43 static void gtk_builder_set_property (GObject *object,
44 guint prop_id,
45 const GValue *value,
46 GParamSpec *pspec);
47 static void gtk_builder_get_property (GObject *object,
48 guint prop_id,
49 GValue *value,
50 GParamSpec *pspec);
51 static GType gtk_builder_real_get_type_from_name (GtkBuilder *builder,
52 const gchar *type_name);
53
54 enum {
55 PROP_0,
56 PROP_TRANSLATION_DOMAIN,
57 };
58
59 struct _GtkBuilderPrivate
60 {
61 gchar *domain;
62 GHashTable *objects;
63 GSList *delayed_properties;
64 GSList *signals;
65 gchar *filename;
66 };
67
G_DEFINE_TYPE(GtkBuilder,gtk_builder,G_TYPE_OBJECT)68 G_DEFINE_TYPE (GtkBuilder, gtk_builder, G_TYPE_OBJECT)
69
70 static void
71 gtk_builder_class_init (GtkBuilderClass *klass)
72 {
73 GObjectClass *gobject_class;
74
75 gobject_class = G_OBJECT_CLASS (klass);
76
77 gobject_class->finalize = gtk_builder_finalize;
78 gobject_class->set_property = gtk_builder_set_property;
79 gobject_class->get_property = gtk_builder_get_property;
80
81 klass->get_type_from_name = gtk_builder_real_get_type_from_name;
82
83 /**
84 * GtkBuilder:translation-domain:
85 *
86 * The translation domain used when translating property values that
87 * have been marked as translatable in interface descriptions.
88 * If the translation domain is %NULL, #GtkBuilder uses gettext(),
89 * otherwise g_dgettext().
90 *
91 * Since: 2.12
92 */
93 g_object_class_install_property (gobject_class,
94 PROP_TRANSLATION_DOMAIN,
95 g_param_spec_string ("translation-domain",
96 P_("Translation Domain"),
97 P_("The translation domain used by gettext"),
98 NULL,
99 GTK_PARAM_READWRITE));
100
101 g_type_class_add_private (gobject_class, sizeof (GtkBuilderPrivate));
102 }
103
104 static void
gtk_builder_init(GtkBuilder * builder)105 gtk_builder_init (GtkBuilder *builder)
106 {
107 builder->priv = G_TYPE_INSTANCE_GET_PRIVATE (builder, GTK_TYPE_BUILDER,
108 GtkBuilderPrivate);
109 builder->priv->domain = NULL;
110 builder->priv->objects = g_hash_table_new_full (g_str_hash, g_str_equal,
111 g_free, g_object_unref);
112 }
113
114
115 /*
116 * GObject virtual methods
117 */
118
119 static void
gtk_builder_finalize(GObject * object)120 gtk_builder_finalize (GObject *object)
121 {
122 GtkBuilderPrivate *priv = GTK_BUILDER (object)->priv;
123
124 g_free (priv->domain);
125 g_free (priv->filename);
126
127 g_hash_table_destroy (priv->objects);
128
129 g_slist_foreach (priv->signals, (GFunc) _free_signal_info, NULL);
130 g_slist_free (priv->signals);
131
132 G_OBJECT_CLASS (gtk_builder_parent_class)->finalize (object);
133 }
134
135 static void
gtk_builder_set_property(GObject * object,guint prop_id,const GValue * value,GParamSpec * pspec)136 gtk_builder_set_property (GObject *object,
137 guint prop_id,
138 const GValue *value,
139 GParamSpec *pspec)
140 {
141 GtkBuilder *builder = GTK_BUILDER (object);
142
143 switch (prop_id)
144 {
145 case PROP_TRANSLATION_DOMAIN:
146 gtk_builder_set_translation_domain (builder, g_value_get_string (value));
147 break;
148 default:
149 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
150 break;
151 }
152 }
153
154 static void
gtk_builder_get_property(GObject * object,guint prop_id,GValue * value,GParamSpec * pspec)155 gtk_builder_get_property (GObject *object,
156 guint prop_id,
157 GValue *value,
158 GParamSpec *pspec)
159 {
160 GtkBuilder *builder = GTK_BUILDER (object);
161
162 switch (prop_id)
163 {
164 case PROP_TRANSLATION_DOMAIN:
165 g_value_set_string (value, builder->priv->domain);
166 break;
167 default:
168 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
169 break;
170 }
171 }
172
173
174 /*
175 * Try to map a type name to a _get_type function
176 * and call it, eg:
177 *
178 * GtkWindow -> gtk_window_get_type
179 * GtkHBox -> gtk_hbox_get_type
180 * GtkUIManager -> gtk_ui_manager_get_type
181 *
182 */
183 static GType
_gtk_builder_resolve_type_lazily(const gchar * name)184 _gtk_builder_resolve_type_lazily (const gchar *name)
185 {
186 static GModule *module = NULL;
187 GTypeGetFunc func;
188 GString *symbol_name = g_string_new ("");
189 char c, *symbol;
190 int i;
191 GType gtype = G_TYPE_INVALID;
192
193 if (!module)
194 module = g_module_open (NULL, 0);
195
196 for (i = 0; name[i] != '\0'; i++)
197 {
198 c = name[i];
199 /* skip if uppercase, first or previous is uppercase */
200 if ((c == g_ascii_toupper (c) &&
201 i > 0 && name[i-1] != g_ascii_toupper (name[i-1])) ||
202 (i > 2 && name[i] == g_ascii_toupper (name[i]) &&
203 name[i-1] == g_ascii_toupper (name[i-1]) &&
204 name[i-2] == g_ascii_toupper (name[i-2])))
205 g_string_append_c (symbol_name, '_');
206 g_string_append_c (symbol_name, g_ascii_tolower (c));
207 }
208 g_string_append (symbol_name, "_get_type");
209
210 symbol = g_string_free (symbol_name, FALSE);
211
212 if (g_module_symbol (module, symbol, (gpointer)&func))
213 gtype = func ();
214
215 g_free (symbol);
216
217 return gtype;
218 }
219
220 /*
221 * GtkBuilder virtual methods
222 */
223
224 static GType
gtk_builder_real_get_type_from_name(GtkBuilder * builder,const gchar * type_name)225 gtk_builder_real_get_type_from_name (GtkBuilder *builder,
226 const gchar *type_name)
227 {
228 GType gtype;
229
230 gtype = g_type_from_name (type_name);
231 if (gtype != G_TYPE_INVALID)
232 return gtype;
233
234 return _gtk_builder_resolve_type_lazily (type_name);
235 }
236
237 typedef struct
238 {
239 gchar *object;
240 gchar *name;
241 gchar *value;
242 } DelayedProperty;
243
244 static void
gtk_builder_get_parameters(GtkBuilder * builder,GType object_type,const gchar * object_name,GSList * properties,GArray ** parameters,GArray ** construct_parameters)245 gtk_builder_get_parameters (GtkBuilder *builder,
246 GType object_type,
247 const gchar *object_name,
248 GSList *properties,
249 GArray **parameters,
250 GArray **construct_parameters)
251 {
252 GSList *l;
253 GParamSpec *pspec;
254 GObjectClass *oclass;
255 DelayedProperty *property;
256 GError *error = NULL;
257
258 oclass = g_type_class_ref (object_type);
259 g_assert (oclass != NULL);
260
261 *parameters = g_array_new (FALSE, FALSE, sizeof (GParameter));
262 *construct_parameters = g_array_new (FALSE, FALSE, sizeof (GParameter));
263
264 for (l = properties; l; l = l->next)
265 {
266 PropertyInfo *prop = (PropertyInfo*)l->data;
267 GParameter parameter = { NULL };
268
269 pspec = g_object_class_find_property (G_OBJECT_CLASS (oclass),
270 prop->name);
271 if (!pspec)
272 {
273 g_warning ("Unknown property: %s.%s",
274 g_type_name (object_type), prop->name);
275 continue;
276 }
277
278 parameter.name = prop->name;
279
280 if (G_IS_PARAM_SPEC_OBJECT (pspec) &&
281 (G_PARAM_SPEC_VALUE_TYPE (pspec) != GDK_TYPE_PIXBUF))
282 {
283 GObject *object = gtk_builder_get_object (builder, prop->data);
284
285 if (object)
286 {
287 g_value_init (¶meter.value, G_OBJECT_TYPE (object));
288 g_value_set_object (¶meter.value, object);
289 }
290 else
291 {
292 if (pspec->flags & G_PARAM_CONSTRUCT_ONLY)
293 {
294 g_warning ("Failed to get constuct only property "
295 "%s of %s with value `%s'",
296 prop->name, object_name, prop->data);
297 continue;
298 }
299 /* Delay setting property */
300 property = g_slice_new (DelayedProperty);
301 property->object = g_strdup (object_name);
302 property->name = g_strdup (prop->name);
303 property->value = g_strdup (prop->data);
304 builder->priv->delayed_properties =
305 g_slist_prepend (builder->priv->delayed_properties, property);
306 continue;
307 }
308 }
309 else if (!gtk_builder_value_from_string (builder, pspec,
310 prop->data, ¶meter.value, &error))
311 {
312 g_warning ("Failed to set property %s.%s to %s: %s",
313 g_type_name (object_type), prop->name, prop->data,
314 error->message);
315 g_error_free (error);
316 error = NULL;
317 continue;
318 }
319
320 if (pspec->flags & (G_PARAM_CONSTRUCT | G_PARAM_CONSTRUCT_ONLY))
321 g_array_append_val (*construct_parameters, parameter);
322 else
323 g_array_append_val (*parameters, parameter);
324 }
325
326 g_type_class_unref (oclass);
327 }
328
329 static GObject *
gtk_builder_get_internal_child(GtkBuilder * builder,ObjectInfo * info,const gchar * childname,GError ** error)330 gtk_builder_get_internal_child (GtkBuilder *builder,
331 ObjectInfo *info,
332 const gchar *childname,
333 GError **error)
334 {
335 GObject *obj = NULL;
336
337 while (!obj)
338 {
339 if (!info->parent)
340 break;
341
342 info = (ObjectInfo*)((ChildInfo*)info->parent)->parent;
343 if (!info)
344 break;
345
346 GTK_NOTE (BUILDER,
347 g_print ("Trying to get internal child %s from %s\n",
348 childname,
349 gtk_buildable_get_name (GTK_BUILDABLE (info->object))));
350
351 if (GTK_IS_BUILDABLE (info->object))
352 obj = gtk_buildable_get_internal_child (GTK_BUILDABLE (info->object),
353 builder,
354 childname);
355 };
356
357 if (!obj)
358 {
359 g_set_error (error,
360 GTK_BUILDER_ERROR,
361 GTK_BUILDER_ERROR_INVALID_VALUE,
362 "Unknown internal child: %s", childname);
363 }
364 return obj;
365 }
366
367 GObject *
_gtk_builder_construct(GtkBuilder * builder,ObjectInfo * info,GError ** error)368 _gtk_builder_construct (GtkBuilder *builder,
369 ObjectInfo *info,
370 GError **error)
371 {
372 GArray *parameters, *construct_parameters;
373 GType object_type;
374 GObject *obj;
375 int i;
376 GtkBuildableIface *iface;
377 gboolean custom_set_property;
378 GtkBuildable *buildable;
379
380 g_assert (info->class_name != NULL);
381 object_type = gtk_builder_get_type_from_name (builder, info->class_name);
382 if (object_type == G_TYPE_INVALID)
383 {
384 g_set_error (error,
385 GTK_BUILDER_ERROR,
386 GTK_BUILDER_ERROR_INVALID_VALUE,
387 "Invalid object type `%s'",
388 info->class_name);
389 return NULL;
390 }
391
392 gtk_builder_get_parameters (builder, object_type,
393 info->id,
394 info->properties,
395 ¶meters,
396 &construct_parameters);
397
398 if (info->constructor)
399 {
400 GObject *constructor;
401
402 constructor = gtk_builder_get_object (builder, info->constructor);
403 if (constructor == NULL)
404 {
405 g_set_error (error,
406 GTK_BUILDER_ERROR,
407 GTK_BUILDER_ERROR_INVALID_VALUE,
408 "Unknown object constructor for %s: %s",
409 info->id,
410 info->constructor);
411 g_array_free (parameters, TRUE);
412 g_array_free (construct_parameters, TRUE);
413 return NULL;
414 }
415 obj = gtk_buildable_construct_child (GTK_BUILDABLE (constructor),
416 builder,
417 info->id);
418 g_assert (obj != NULL);
419 if (construct_parameters->len)
420 g_warning ("Can't pass in construct-only parameters to %s", info->id);
421 }
422 else if (info->parent && ((ChildInfo*)info->parent)->internal_child != NULL)
423 {
424 gchar *childname = ((ChildInfo*)info->parent)->internal_child;
425 obj = gtk_builder_get_internal_child (builder, info, childname, error);
426 if (!obj)
427 {
428 g_array_free (parameters, TRUE);
429 g_array_free (construct_parameters, TRUE);
430 return NULL;
431 }
432 if (construct_parameters->len)
433 g_warning ("Can't pass in construct-only parameters to %s", childname);
434 g_object_ref (obj);
435 }
436 else
437 {
438 obj = g_object_newv (object_type,
439 construct_parameters->len,
440 (GParameter *)construct_parameters->data);
441
442 /* No matter what, make sure we have a reference.
443 *
444 * If it's an initially unowned object, sink it.
445 * If it's not initially unowned then we have the reference already.
446 *
447 * In the case that this is a window it will be sunk already and
448 * this is effectively a call to g_object_ref(). That's what
449 * we want.
450 */
451 if (G_IS_INITIALLY_UNOWNED (obj))
452 g_object_ref_sink (obj);
453
454 GTK_NOTE (BUILDER,
455 g_print ("created %s of type %s\n", info->id, info->class_name));
456
457 for (i = 0; i < construct_parameters->len; i++)
458 {
459 GParameter *param = &g_array_index (construct_parameters,
460 GParameter, i);
461 g_value_unset (¶m->value);
462 }
463 }
464 g_array_free (construct_parameters, TRUE);
465
466 custom_set_property = FALSE;
467 buildable = NULL;
468 iface = NULL;
469 if (GTK_IS_BUILDABLE (obj))
470 {
471 buildable = GTK_BUILDABLE (obj);
472 iface = GTK_BUILDABLE_GET_IFACE (obj);
473 if (iface->set_buildable_property)
474 custom_set_property = TRUE;
475 }
476
477 for (i = 0; i < parameters->len; i++)
478 {
479 GParameter *param = &g_array_index (parameters, GParameter, i);
480 if (custom_set_property)
481 iface->set_buildable_property (buildable, builder, param->name, ¶m->value);
482 else
483 g_object_set_property (obj, param->name, ¶m->value);
484
485 #if G_ENABLE_DEBUG
486 if (gtk_debug_flags & GTK_DEBUG_BUILDER)
487 {
488 gchar *str = g_strdup_value_contents ((const GValue*)¶m->value);
489 g_print ("set %s: %s = %s\n", info->id, param->name, str);
490 g_free (str);
491 }
492 #endif
493 g_value_unset (¶m->value);
494 }
495 g_array_free (parameters, TRUE);
496
497 if (GTK_IS_BUILDABLE (obj))
498 gtk_buildable_set_name (buildable, info->id);
499 else
500 g_object_set_data_full (obj,
501 "gtk-builder-name",
502 g_strdup (info->id),
503 g_free);
504
505 /* we already own a reference to obj. put it in the hash table. */
506 g_hash_table_insert (builder->priv->objects, g_strdup (info->id), obj);
507
508 return obj;
509 }
510
511
512 void
_gtk_builder_add(GtkBuilder * builder,ChildInfo * child_info)513 _gtk_builder_add (GtkBuilder *builder,
514 ChildInfo *child_info)
515 {
516 GObject *object;
517 GObject *parent;
518
519 /* Internal children are already added
520 * Also prevent us from being called twice.
521 */
522 if (!child_info ||
523 child_info->internal_child ||
524 child_info->added)
525 return;
526
527 object = child_info->object;
528 if (!object)
529 return;
530
531 if (!child_info->parent)
532 {
533 g_warning ("%s: Not adding, No parent",
534 gtk_buildable_get_name (GTK_BUILDABLE (object)));
535 return;
536 }
537
538 g_assert (object != NULL);
539
540 parent = ((ObjectInfo*)child_info->parent)->object;
541 g_assert (GTK_IS_BUILDABLE (parent));
542
543 GTK_NOTE (BUILDER,
544 g_print ("adding %s to %s\n",
545 gtk_buildable_get_name (GTK_BUILDABLE (object)),
546 gtk_buildable_get_name (GTK_BUILDABLE (parent))));
547
548 gtk_buildable_add_child (GTK_BUILDABLE (parent), builder, object,
549 child_info->type);
550
551 child_info->added = TRUE;
552 }
553
554 void
_gtk_builder_add_signals(GtkBuilder * builder,GSList * signals)555 _gtk_builder_add_signals (GtkBuilder *builder,
556 GSList *signals)
557 {
558 builder->priv->signals = g_slist_concat (builder->priv->signals,
559 g_slist_copy (signals));
560 }
561
562 static void
gtk_builder_apply_delayed_properties(GtkBuilder * builder)563 gtk_builder_apply_delayed_properties (GtkBuilder *builder)
564 {
565 GSList *l, *props;
566 DelayedProperty *property;
567 GObject *object;
568 GType object_type;
569 GObjectClass *oclass;
570 GParamSpec *pspec;
571
572 /* take the list over from the builder->priv.
573 *
574 * g_slist_reverse does not copy the list, so the list now
575 * belongs to us (and we free it at the end of this function).
576 */
577 props = g_slist_reverse (builder->priv->delayed_properties);
578 builder->priv->delayed_properties = NULL;
579
580 for (l = props; l; l = l->next)
581 {
582 property = (DelayedProperty*)l->data;
583 object = g_hash_table_lookup (builder->priv->objects, property->object);
584 g_assert (object != NULL);
585
586 object_type = G_OBJECT_TYPE (object);
587 g_assert (object_type != G_TYPE_INVALID);
588
589 oclass = g_type_class_ref (object_type);
590 g_assert (oclass != NULL);
591
592 pspec = g_object_class_find_property (G_OBJECT_CLASS (oclass),
593 property->name);
594 if (!pspec)
595 g_warning ("Unknown property: %s.%s", g_type_name (object_type),
596 property->name);
597 else
598 {
599 GObject *obj;
600
601 obj = g_hash_table_lookup (builder->priv->objects, property->value);
602 if (!obj)
603 g_warning ("No object called: %s", property->value);
604 else
605 g_object_set (object, property->name, obj, NULL);
606 }
607 g_free (property->value);
608 g_free (property->object);
609 g_free (property->name);
610 g_slice_free (DelayedProperty, property);
611 g_type_class_unref (oclass);
612 }
613 g_slist_free (props);
614 }
615
616 void
_gtk_builder_finish(GtkBuilder * builder)617 _gtk_builder_finish (GtkBuilder *builder)
618 {
619 gtk_builder_apply_delayed_properties (builder);
620 }
621
622 /**
623 * gtk_builder_new:
624 *
625 * Creates a new builder object.
626 *
627 * Return value: a new #GtkBuilder object
628 *
629 * Since: 2.12
630 **/
631 GtkBuilder *
gtk_builder_new(void)632 gtk_builder_new (void)
633 {
634 return g_object_new (GTK_TYPE_BUILDER, NULL);
635 }
636
637 /**
638 * gtk_builder_add_from_file:
639 * @builder: a #GtkBuilder
640 * @filename: the name of the file to parse
641 * @error: (allow-none): return location for an error, or %NULL
642 *
643 * Parses a file containing a <link linkend="BUILDER-UI">GtkBuilder
644 * UI definition</link> and merges it with the current contents of @builder.
645 *
646 * Upon errors 0 will be returned and @error will be assigned a
647 * #GError from the #GTK_BUILDER_ERROR, #G_MARKUP_ERROR or #G_FILE_ERROR
648 * domain.
649 *
650 * Returns: A positive value on success, 0 if an error occurred
651 *
652 * Since: 2.12
653 **/
654 guint
gtk_builder_add_from_file(GtkBuilder * builder,const gchar * filename,GError ** error)655 gtk_builder_add_from_file (GtkBuilder *builder,
656 const gchar *filename,
657 GError **error)
658 {
659 gchar *buffer;
660 gsize length;
661 GError *tmp_error;
662
663 g_return_val_if_fail (GTK_IS_BUILDER (builder), 0);
664 g_return_val_if_fail (filename != NULL, 0);
665 g_return_val_if_fail (error == NULL || *error == NULL, 0);
666
667 tmp_error = NULL;
668
669 if (!g_file_get_contents (filename, &buffer, &length, &tmp_error))
670 {
671 g_propagate_error (error, tmp_error);
672 return 0;
673 }
674
675 g_free (builder->priv->filename);
676 builder->priv->filename = g_strdup (filename);
677
678 _gtk_builder_parser_parse_buffer (builder, filename,
679 buffer, length,
680 NULL,
681 &tmp_error);
682
683 g_free (buffer);
684
685 if (tmp_error != NULL)
686 {
687 g_propagate_error (error, tmp_error);
688 return 0;
689 }
690
691 return 1;
692 }
693
694 /**
695 * gtk_builder_add_objects_from_file:
696 * @builder: a #GtkBuilder
697 * @filename: the name of the file to parse
698 * @object_ids: nul-terminated array of objects to build
699 * @error: (allow-none): return location for an error, or %NULL
700 *
701 * Parses a file containing a <link linkend="BUILDER-UI">GtkBuilder
702 * UI definition</link> building only the requested objects and merges
703 * them with the current contents of @builder.
704 *
705 * Upon errors 0 will be returned and @error will be assigned a
706 * #GError from the #GTK_BUILDER_ERROR, #G_MARKUP_ERROR or #G_FILE_ERROR
707 * domain.
708 *
709 * <note><para>
710 * If you are adding an object that depends on an object that is not
711 * its child (for instance a #GtkTreeView that depends on its
712 * #GtkTreeModel), you have to explicitely list all of them in @object_ids.
713 * </para></note>
714 *
715 * Returns: A positive value on success, 0 if an error occurred
716 *
717 * Since: 2.14
718 **/
719 guint
gtk_builder_add_objects_from_file(GtkBuilder * builder,const gchar * filename,gchar ** object_ids,GError ** error)720 gtk_builder_add_objects_from_file (GtkBuilder *builder,
721 const gchar *filename,
722 gchar **object_ids,
723 GError **error)
724 {
725 gchar *buffer;
726 gsize length;
727 GError *tmp_error;
728
729 g_return_val_if_fail (GTK_IS_BUILDER (builder), 0);
730 g_return_val_if_fail (filename != NULL, 0);
731 g_return_val_if_fail (object_ids != NULL && object_ids[0] != NULL, 0);
732 g_return_val_if_fail (error == NULL || *error == NULL, 0);
733
734 tmp_error = NULL;
735
736 if (!g_file_get_contents (filename, &buffer, &length, &tmp_error))
737 {
738 g_propagate_error (error, tmp_error);
739 return 0;
740 }
741
742 g_free (builder->priv->filename);
743 builder->priv->filename = g_strdup (filename);
744
745 _gtk_builder_parser_parse_buffer (builder, filename,
746 buffer, length,
747 object_ids,
748 &tmp_error);
749
750 g_free (buffer);
751
752 if (tmp_error != NULL)
753 {
754 g_propagate_error (error, tmp_error);
755 return 0;
756 }
757
758 return 1;
759 }
760
761 /**
762 * gtk_builder_add_from_string:
763 * @builder: a #GtkBuilder
764 * @buffer: the string to parse
765 * @length: the length of @buffer (may be -1 if @buffer is nul-terminated)
766 * @error: (allow-none): return location for an error, or %NULL
767 *
768 * Parses a string containing a <link linkend="BUILDER-UI">GtkBuilder
769 * UI definition</link> and merges it with the current contents of @builder.
770 *
771 * Upon errors 0 will be returned and @error will be assigned a
772 * #GError from the #GTK_BUILDER_ERROR or #G_MARKUP_ERROR domain.
773 *
774 * Returns: A positive value on success, 0 if an error occurred
775 *
776 * Since: 2.12
777 **/
778 guint
gtk_builder_add_from_string(GtkBuilder * builder,const gchar * buffer,gsize length,GError ** error)779 gtk_builder_add_from_string (GtkBuilder *builder,
780 const gchar *buffer,
781 gsize length,
782 GError **error)
783 {
784 GError *tmp_error;
785
786 g_return_val_if_fail (GTK_IS_BUILDER (builder), 0);
787 g_return_val_if_fail (buffer != NULL, 0);
788 g_return_val_if_fail (error == NULL || *error == NULL, 0);
789
790 tmp_error = NULL;
791
792 g_free (builder->priv->filename);
793 builder->priv->filename = g_strdup (".");
794
795 _gtk_builder_parser_parse_buffer (builder, "<input>",
796 buffer, length,
797 NULL,
798 &tmp_error);
799 if (tmp_error != NULL)
800 {
801 g_propagate_error (error, tmp_error);
802 return 0;
803 }
804
805 return 1;
806 }
807
808 /**
809 * gtk_builder_add_objects_from_string:
810 * @builder: a #GtkBuilder
811 * @buffer: the string to parse
812 * @length: the length of @buffer (may be -1 if @buffer is nul-terminated)
813 * @object_ids: nul-terminated array of objects to build
814 * @error: (allow-none): return location for an error, or %NULL
815 *
816 * Parses a string containing a <link linkend="BUILDER-UI">GtkBuilder
817 * UI definition</link> building only the requested objects and merges
818 * them with the current contents of @builder.
819 *
820 * Upon errors 0 will be returned and @error will be assigned a
821 * #GError from the #GTK_BUILDER_ERROR or #G_MARKUP_ERROR domain.
822 *
823 * <note><para>
824 * If you are adding an object that depends on an object that is not
825 * its child (for instance a #GtkTreeView that depends on its
826 * #GtkTreeModel), you have to explicitely list all of them in @object_ids.
827 * </para></note>
828 *
829 * Returns: A positive value on success, 0 if an error occurred
830 *
831 * Since: 2.14
832 **/
833 guint
gtk_builder_add_objects_from_string(GtkBuilder * builder,const gchar * buffer,gsize length,gchar ** object_ids,GError ** error)834 gtk_builder_add_objects_from_string (GtkBuilder *builder,
835 const gchar *buffer,
836 gsize length,
837 gchar **object_ids,
838 GError **error)
839 {
840 GError *tmp_error;
841
842 g_return_val_if_fail (GTK_IS_BUILDER (builder), 0);
843 g_return_val_if_fail (buffer != NULL, 0);
844 g_return_val_if_fail (object_ids != NULL && object_ids[0] != NULL, 0);
845 g_return_val_if_fail (error == NULL || *error == NULL, 0);
846
847 tmp_error = NULL;
848
849 g_free (builder->priv->filename);
850 builder->priv->filename = g_strdup (".");
851
852 _gtk_builder_parser_parse_buffer (builder, "<input>",
853 buffer, length,
854 object_ids,
855 &tmp_error);
856
857 if (tmp_error != NULL)
858 {
859 g_propagate_error (error, tmp_error);
860 return 0;
861 }
862
863 return 1;
864 }
865
866 /**
867 * gtk_builder_get_object:
868 * @builder: a #GtkBuilder
869 * @name: name of object to get
870 *
871 * Gets the object named @name. Note that this function does not
872 * increment the reference count of the returned object.
873 *
874 * Return value: (transfer none): the object named @name or %NULL if
875 * it could not be found in the object tree.
876 *
877 * Since: 2.12
878 **/
879 GObject *
gtk_builder_get_object(GtkBuilder * builder,const gchar * name)880 gtk_builder_get_object (GtkBuilder *builder,
881 const gchar *name)
882 {
883 g_return_val_if_fail (GTK_IS_BUILDER (builder), NULL);
884 g_return_val_if_fail (name != NULL, NULL);
885
886 return g_hash_table_lookup (builder->priv->objects, name);
887 }
888
889 static void
object_add_to_list(gchar * object_id,GObject * object,GSList ** list)890 object_add_to_list (gchar *object_id,
891 GObject *object,
892 GSList **list)
893 {
894 *list = g_slist_prepend (*list, object);
895 }
896
897 /**
898 * gtk_builder_get_objects:
899 * @builder: a #GtkBuilder
900 *
901 * Gets all objects that have been constructed by @builder. Note that
902 * this function does not increment the reference counts of the returned
903 * objects.
904 *
905 * Return value: (element-type GObject) (transfer container): a newly-allocated #GSList containing all the objects
906 * constructed by the #GtkBuilder instance. It should be freed by
907 * g_slist_free()
908 *
909 * Since: 2.12
910 **/
911 GSList *
gtk_builder_get_objects(GtkBuilder * builder)912 gtk_builder_get_objects (GtkBuilder *builder)
913 {
914 GSList *objects = NULL;
915
916 g_return_val_if_fail (GTK_IS_BUILDER (builder), NULL);
917
918 g_hash_table_foreach (builder->priv->objects, (GHFunc)object_add_to_list, &objects);
919
920 return g_slist_reverse (objects);
921 }
922
923 /**
924 * gtk_builder_set_translation_domain:
925 * @builder: a #GtkBuilder
926 * @domain: (allow-none): the translation domain or %NULL
927 *
928 * Sets the translation domain of @builder.
929 * See #GtkBuilder:translation-domain.
930 *
931 * Since: 2.12
932 **/
933 void
gtk_builder_set_translation_domain(GtkBuilder * builder,const gchar * domain)934 gtk_builder_set_translation_domain (GtkBuilder *builder,
935 const gchar *domain)
936 {
937 gchar *new_domain;
938
939 g_return_if_fail (GTK_IS_BUILDER (builder));
940
941 new_domain = g_strdup (domain);
942 g_free (builder->priv->domain);
943 builder->priv->domain = new_domain;
944
945 g_object_notify (G_OBJECT (builder), "translation-domain");
946 }
947
948 /**
949 * gtk_builder_get_translation_domain:
950 * @builder: a #GtkBuilder
951 *
952 * Gets the translation domain of @builder.
953 *
954 * Return value: the translation domain. This string is owned
955 * by the builder object and must not be modified or freed.
956 *
957 * Since: 2.12
958 **/
959 const gchar *
gtk_builder_get_translation_domain(GtkBuilder * builder)960 gtk_builder_get_translation_domain (GtkBuilder *builder)
961 {
962 g_return_val_if_fail (GTK_IS_BUILDER (builder), NULL);
963
964 return builder->priv->domain;
965 }
966
967 typedef struct {
968 GModule *module;
969 gpointer data;
970 } connect_args;
971
972 static void
gtk_builder_connect_signals_default(GtkBuilder * builder,GObject * object,const gchar * signal_name,const gchar * handler_name,GObject * connect_object,GConnectFlags flags,gpointer user_data)973 gtk_builder_connect_signals_default (GtkBuilder *builder,
974 GObject *object,
975 const gchar *signal_name,
976 const gchar *handler_name,
977 GObject *connect_object,
978 GConnectFlags flags,
979 gpointer user_data)
980 {
981 GCallback func;
982 connect_args *args = (connect_args*)user_data;
983
984 if (!g_module_symbol (args->module, handler_name, (gpointer)&func))
985 {
986 g_warning ("Could not find signal handler '%s'", handler_name);
987 return;
988 }
989
990 if (connect_object)
991 g_signal_connect_object (object, signal_name, func, connect_object, flags);
992 else
993 g_signal_connect_data (object, signal_name, func, args->data, NULL, flags);
994 }
995
996
997 /**
998 * gtk_builder_connect_signals:
999 * @builder: a #GtkBuilder
1000 * @user_data: a pointer to a structure sent in as user data to all signals
1001 *
1002 * This method is a simpler variation of gtk_builder_connect_signals_full().
1003 * It uses #GModule's introspective features (by opening the module %NULL)
1004 * to look at the application's symbol table. From here it tries to match
1005 * the signal handler names given in the interface description with
1006 * symbols in the application and connects the signals.
1007 *
1008 * Note that this function will not work correctly if #GModule is not
1009 * supported on the platform.
1010 *
1011 * When compiling applications for Windows, you must declare signal callbacks
1012 * with #G_MODULE_EXPORT, or they will not be put in the symbol table.
1013 * On Linux and Unices, this is not necessary; applications should instead
1014 * be compiled with the -Wl,--export-dynamic CFLAGS, and linked against
1015 * gmodule-export-2.0.
1016 *
1017 * Since: 2.12
1018 **/
1019 void
gtk_builder_connect_signals(GtkBuilder * builder,gpointer user_data)1020 gtk_builder_connect_signals (GtkBuilder *builder,
1021 gpointer user_data)
1022 {
1023 connect_args *args;
1024
1025 g_return_if_fail (GTK_IS_BUILDER (builder));
1026
1027 if (!g_module_supported ())
1028 g_error ("gtk_builder_connect_signals() requires working GModule");
1029
1030 args = g_slice_new0 (connect_args);
1031 args->module = g_module_open (NULL, G_MODULE_BIND_LAZY);
1032 args->data = user_data;
1033
1034 gtk_builder_connect_signals_full (builder,
1035 gtk_builder_connect_signals_default,
1036 args);
1037 g_module_close (args->module);
1038
1039 g_slice_free (connect_args, args);
1040 }
1041
1042 /**
1043 * GtkBuilderConnectFunc:
1044 * @builder: a #GtkBuilder
1045 * @object: object to connect a signal to
1046 * @signal_name: name of the signal
1047 * @handler_name: name of the handler
1048 * @connect_object: a #GObject, if non-%NULL, use g_signal_connect_object()
1049 * @flags: #GConnectFlags to use
1050 * @user_data: user data
1051 *
1052 * This is the signature of a function used to connect signals. It is used
1053 * by the gtk_builder_connect_signals() and gtk_builder_connect_signals_full()
1054 * methods. It is mainly intended for interpreted language bindings, but
1055 * could be useful where the programmer wants more control over the signal
1056 * connection process.
1057 *
1058 * Since: 2.12
1059 */
1060
1061 /**
1062 * gtk_builder_connect_signals_full:
1063 * @builder: a #GtkBuilder
1064 * @func: (scope call): the function used to connect the signals
1065 * @user_data: arbitrary data that will be passed to the connection function
1066 *
1067 * This function can be thought of the interpreted language binding
1068 * version of gtk_builder_connect_signals(), except that it does not
1069 * require GModule to function correctly.
1070 *
1071 * Since: 2.12
1072 */
1073 void
gtk_builder_connect_signals_full(GtkBuilder * builder,GtkBuilderConnectFunc func,gpointer user_data)1074 gtk_builder_connect_signals_full (GtkBuilder *builder,
1075 GtkBuilderConnectFunc func,
1076 gpointer user_data)
1077 {
1078 GSList *l;
1079 GObject *object;
1080 GObject *connect_object;
1081
1082 g_return_if_fail (GTK_IS_BUILDER (builder));
1083 g_return_if_fail (func != NULL);
1084
1085 if (!builder->priv->signals)
1086 return;
1087
1088 builder->priv->signals = g_slist_reverse (builder->priv->signals);
1089 for (l = builder->priv->signals; l; l = l->next)
1090 {
1091 SignalInfo *signal = (SignalInfo*)l->data;
1092
1093 g_assert (signal != NULL);
1094 g_assert (signal->name != NULL);
1095
1096 object = g_hash_table_lookup (builder->priv->objects,
1097 signal->object_name);
1098 g_assert (object != NULL);
1099
1100 connect_object = NULL;
1101
1102 if (signal->connect_object_name)
1103 {
1104 connect_object = g_hash_table_lookup (builder->priv->objects,
1105 signal->connect_object_name);
1106 if (!connect_object)
1107 g_warning ("Could not lookup object %s on signal %s of object %s",
1108 signal->connect_object_name, signal->name,
1109 signal->object_name);
1110 }
1111
1112 func (builder, object, signal->name, signal->handler,
1113 connect_object, signal->flags, user_data);
1114 }
1115
1116 g_slist_foreach (builder->priv->signals, (GFunc)_free_signal_info, NULL);
1117 g_slist_free (builder->priv->signals);
1118 builder->priv->signals = NULL;
1119 }
1120
1121 /**
1122 * gtk_builder_value_from_string:
1123 * @builder: a #GtkBuilder
1124 * @pspec: the #GParamSpec for the property
1125 * @string: the string representation of the value
1126 * @value: (out): the #GValue to store the result in
1127 * @error: (allow-none): return location for an error, or %NULL
1128 *
1129 * This function demarshals a value from a string. This function
1130 * calls g_value_init() on the @value argument, so it need not be
1131 * initialised beforehand.
1132 *
1133 * This function can handle char, uchar, boolean, int, uint, long,
1134 * ulong, enum, flags, float, double, string, #GdkColor and
1135 * #GtkAdjustment type values. Support for #GtkWidget type values is
1136 * still to come.
1137 *
1138 * Upon errors %FALSE will be returned and @error will be assigned a
1139 * #GError from the #GTK_BUILDER_ERROR domain.
1140 *
1141 * Returns: %TRUE on success
1142 *
1143 * Since: 2.12
1144 */
1145 gboolean
gtk_builder_value_from_string(GtkBuilder * builder,GParamSpec * pspec,const gchar * string,GValue * value,GError ** error)1146 gtk_builder_value_from_string (GtkBuilder *builder,
1147 GParamSpec *pspec,
1148 const gchar *string,
1149 GValue *value,
1150 GError **error)
1151 {
1152 g_return_val_if_fail (GTK_IS_BUILDER (builder), FALSE);
1153 g_return_val_if_fail (G_IS_PARAM_SPEC (pspec), FALSE);
1154 g_return_val_if_fail (string != NULL, FALSE);
1155 g_return_val_if_fail (value != NULL, FALSE);
1156 g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
1157
1158 /*
1159 * GParamSpecUnichar has the internal type G_TYPE_UINT,
1160 * so we cannot handle this in the switch, do it separately
1161 */
1162 if (G_IS_PARAM_SPEC_UNICHAR (pspec))
1163 {
1164 gunichar c;
1165 g_value_init (value, G_TYPE_UINT);
1166 c = g_utf8_get_char_validated (string, strlen (string));
1167 if (c > 0)
1168 g_value_set_uint (value, c);
1169 return TRUE;
1170 }
1171
1172 return gtk_builder_value_from_string_type (builder,
1173 G_PARAM_SPEC_VALUE_TYPE (pspec),
1174 string, value, error);
1175 }
1176
1177 /**
1178 * gtk_builder_value_from_string_type:
1179 * @builder: a #GtkBuilder
1180 * @type: the #GType of the value
1181 * @string: the string representation of the value
1182 * @value: (out): the #GValue to store the result in
1183 * @error: (allow-none): return location for an error, or %NULL
1184 *
1185 * Like gtk_builder_value_from_string(), this function demarshals
1186 * a value from a string, but takes a #GType instead of #GParamSpec.
1187 * This function calls g_value_init() on the @value argument, so it
1188 * need not be initialised beforehand.
1189 *
1190 * Upon errors %FALSE will be returned and @error will be assigned a
1191 * #GError from the #GTK_BUILDER_ERROR domain.
1192 *
1193 * Returns: %TRUE on success
1194 *
1195 * Since: 2.12
1196 */
1197 gboolean
gtk_builder_value_from_string_type(GtkBuilder * builder,GType type,const gchar * string,GValue * value,GError ** error)1198 gtk_builder_value_from_string_type (GtkBuilder *builder,
1199 GType type,
1200 const gchar *string,
1201 GValue *value,
1202 GError **error)
1203 {
1204 gboolean ret = TRUE;
1205
1206 g_return_val_if_fail (type != G_TYPE_INVALID, FALSE);
1207 g_return_val_if_fail (string != NULL, FALSE);
1208 g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
1209
1210 g_value_init (value, type);
1211
1212 switch (G_TYPE_FUNDAMENTAL (type))
1213 {
1214 case G_TYPE_CHAR:
1215 g_value_set_char (value, string[0]);
1216 break;
1217 case G_TYPE_UCHAR:
1218 g_value_set_uchar (value, (guchar)string[0]);
1219 break;
1220 case G_TYPE_BOOLEAN:
1221 {
1222 gboolean b;
1223
1224 if (!_gtk_builder_boolean_from_string (string, &b, error))
1225 {
1226 ret = FALSE;
1227 break;
1228 }
1229 g_value_set_boolean (value, b);
1230 break;
1231 }
1232 case G_TYPE_INT:
1233 case G_TYPE_LONG:
1234 {
1235 long l;
1236 gchar *endptr;
1237 errno = 0;
1238 l = strtol (string, &endptr, 0);
1239 if (errno || endptr == string)
1240 {
1241 g_set_error (error,
1242 GTK_BUILDER_ERROR,
1243 GTK_BUILDER_ERROR_INVALID_VALUE,
1244 "Could not parse integer `%s'",
1245 string);
1246 ret = FALSE;
1247 break;
1248 }
1249 if (G_VALUE_HOLDS_INT (value))
1250 g_value_set_int (value, l);
1251 else
1252 g_value_set_long (value, l);
1253 break;
1254 }
1255 case G_TYPE_UINT:
1256 case G_TYPE_ULONG:
1257 {
1258 gulong ul;
1259 gchar *endptr;
1260 errno = 0;
1261 ul = strtoul (string, &endptr, 0);
1262 if (errno || endptr == string)
1263 {
1264 g_set_error (error,
1265 GTK_BUILDER_ERROR,
1266 GTK_BUILDER_ERROR_INVALID_VALUE,
1267 "Could not parse unsigned integer `%s'",
1268 string);
1269 ret = FALSE;
1270 break;
1271 }
1272 if (G_VALUE_HOLDS_UINT (value))
1273 g_value_set_uint (value, ul);
1274 else
1275 g_value_set_ulong (value, ul);
1276 break;
1277 }
1278 case G_TYPE_ENUM:
1279 {
1280 gint enum_value;
1281 if (!_gtk_builder_enum_from_string (type, string, &enum_value, error))
1282 {
1283 ret = FALSE;
1284 break;
1285 }
1286 g_value_set_enum (value, enum_value);
1287 break;
1288 }
1289 case G_TYPE_FLAGS:
1290 {
1291 guint flags_value;
1292
1293 if (!_gtk_builder_flags_from_string (type, string, &flags_value, error))
1294 {
1295 ret = FALSE;
1296 break;
1297 }
1298 g_value_set_flags (value, flags_value);
1299 break;
1300 }
1301 case G_TYPE_FLOAT:
1302 case G_TYPE_DOUBLE:
1303 {
1304 gdouble d;
1305 gchar *endptr;
1306 errno = 0;
1307 d = g_ascii_strtod (string, &endptr);
1308 if (errno || endptr == string)
1309 {
1310 g_set_error (error,
1311 GTK_BUILDER_ERROR,
1312 GTK_BUILDER_ERROR_INVALID_VALUE,
1313 "Could not parse double `%s'",
1314 string);
1315 ret = FALSE;
1316 break;
1317 }
1318 if (G_VALUE_HOLDS_FLOAT (value))
1319 g_value_set_float (value, d);
1320 else
1321 g_value_set_double (value, d);
1322 break;
1323 }
1324 case G_TYPE_STRING:
1325 g_value_set_string (value, string);
1326 break;
1327 case G_TYPE_BOXED:
1328 if (G_VALUE_HOLDS (value, GDK_TYPE_COLOR))
1329 {
1330 GdkColor colour = { 0, };
1331
1332 if (gdk_color_parse (string, &colour) &&
1333 gdk_colormap_alloc_color (gtk_widget_get_default_colormap (),
1334 &colour, FALSE, TRUE))
1335 g_value_set_boxed (value, &colour);
1336 else
1337 {
1338 g_set_error (error,
1339 GTK_BUILDER_ERROR,
1340 GTK_BUILDER_ERROR_INVALID_VALUE,
1341 "Could not parse color `%s'",
1342 string);
1343 ret = FALSE;
1344 }
1345 }
1346 else if (G_VALUE_HOLDS (value, G_TYPE_STRV))
1347 {
1348 gchar **vector = g_strsplit (string, "\n", 0);
1349 g_value_take_boxed (value, vector);
1350 }
1351 else
1352 {
1353 g_set_error (error,
1354 GTK_BUILDER_ERROR,
1355 GTK_BUILDER_ERROR_INVALID_VALUE,
1356 "Could not parse '%s' as a %s",
1357 string, G_VALUE_TYPE_NAME (value));
1358 ret = FALSE;
1359 }
1360 break;
1361 case G_TYPE_OBJECT:
1362 if (G_VALUE_HOLDS (value, GDK_TYPE_PIXBUF))
1363 {
1364 gchar *filename;
1365 GError *tmp_error = NULL;
1366 GdkPixbuf *pixbuf;
1367
1368 if (gtk_builder_get_object (builder, string))
1369 {
1370 g_set_error (error,
1371 GTK_BUILDER_ERROR,
1372 GTK_BUILDER_ERROR_INVALID_VALUE,
1373 "Could not load image '%s': "
1374 " '%s' is already used as object id",
1375 string, string);
1376 return FALSE;
1377 }
1378
1379 filename = _gtk_builder_get_absolute_filename (builder, string);
1380 pixbuf = gdk_pixbuf_new_from_file (filename, &tmp_error);
1381
1382 if (pixbuf == NULL)
1383 {
1384 GtkIconTheme *theme;
1385
1386 g_warning ("Could not load image '%s': %s",
1387 string, tmp_error->message);
1388 g_error_free (tmp_error);
1389
1390 /* fall back to a missing image */
1391 theme = gtk_icon_theme_get_default ();
1392 pixbuf = gtk_icon_theme_load_icon (theme,
1393 GTK_STOCK_MISSING_IMAGE,
1394 16,
1395 GTK_ICON_LOOKUP_USE_BUILTIN,
1396 NULL);
1397 }
1398
1399 if (pixbuf)
1400 {
1401 g_value_set_object (value, pixbuf);
1402 g_object_unref (G_OBJECT (pixbuf));
1403 }
1404
1405 g_free (filename);
1406
1407 ret = TRUE;
1408 }
1409 else
1410 ret = FALSE;
1411 break;
1412 default:
1413 ret = FALSE;
1414 break;
1415 }
1416
1417 /* Catch unassigned error for object types as well as any unsupported types.
1418 * While parsing GtkBuilder; object types are deserialized
1419 * without calling gtk_builder_value_from_string_type().
1420 */
1421 if (!ret && error && *error == NULL)
1422 g_set_error (error,
1423 GTK_BUILDER_ERROR,
1424 GTK_BUILDER_ERROR_INVALID_VALUE,
1425 "Unsupported GType `%s'", g_type_name (type));
1426
1427 return ret;
1428 }
1429
1430 gboolean
_gtk_builder_enum_from_string(GType type,const gchar * string,gint * enum_value,GError ** error)1431 _gtk_builder_enum_from_string (GType type,
1432 const gchar *string,
1433 gint *enum_value,
1434 GError **error)
1435 {
1436 GEnumClass *eclass;
1437 GEnumValue *ev;
1438 gchar *endptr;
1439 gint value;
1440 gboolean ret;
1441
1442 g_return_val_if_fail (G_TYPE_IS_ENUM (type), FALSE);
1443 g_return_val_if_fail (string != NULL, FALSE);
1444
1445 ret = TRUE;
1446
1447 value = strtoul (string, &endptr, 0);
1448 if (endptr != string) /* parsed a number */
1449 *enum_value = value;
1450 else
1451 {
1452 eclass = g_type_class_ref (type);
1453 ev = g_enum_get_value_by_name (eclass, string);
1454 if (!ev)
1455 ev = g_enum_get_value_by_nick (eclass, string);
1456
1457 if (ev)
1458 *enum_value = ev->value;
1459 else
1460 {
1461 g_set_error (error,
1462 GTK_BUILDER_ERROR,
1463 GTK_BUILDER_ERROR_INVALID_VALUE,
1464 "Could not parse enum: `%s'",
1465 string);
1466 ret = FALSE;
1467 }
1468
1469 g_type_class_unref (eclass);
1470 }
1471
1472 return ret;
1473 }
1474
1475 gboolean
_gtk_builder_flags_from_string(GType type,const gchar * string,guint * flags_value,GError ** error)1476 _gtk_builder_flags_from_string (GType type,
1477 const gchar *string,
1478 guint *flags_value,
1479 GError **error)
1480 {
1481 GFlagsClass *fclass;
1482 gchar *endptr, *prevptr;
1483 guint i, j, value;
1484 gchar *flagstr;
1485 GFlagsValue *fv;
1486 const gchar *flag;
1487 gunichar ch;
1488 gboolean eos, ret;
1489
1490 g_return_val_if_fail (G_TYPE_IS_FLAGS (type), FALSE);
1491 g_return_val_if_fail (string != 0, FALSE);
1492
1493 ret = TRUE;
1494
1495 value = strtoul (string, &endptr, 0);
1496 if (endptr != string) /* parsed a number */
1497 *flags_value = value;
1498 else
1499 {
1500 fclass = g_type_class_ref (type);
1501
1502 flagstr = g_strdup (string);
1503 for (value = i = j = 0; ; i++)
1504 {
1505
1506 eos = flagstr[i] == '\0';
1507
1508 if (!eos && flagstr[i] != '|')
1509 continue;
1510
1511 flag = &flagstr[j];
1512 endptr = &flagstr[i];
1513
1514 if (!eos)
1515 {
1516 flagstr[i++] = '\0';
1517 j = i;
1518 }
1519
1520 /* trim spaces */
1521 for (;;)
1522 {
1523 ch = g_utf8_get_char (flag);
1524 if (!g_unichar_isspace (ch))
1525 break;
1526 flag = g_utf8_next_char (flag);
1527 }
1528
1529 while (endptr > flag)
1530 {
1531 prevptr = g_utf8_prev_char (endptr);
1532 ch = g_utf8_get_char (prevptr);
1533 if (!g_unichar_isspace (ch))
1534 break;
1535 endptr = prevptr;
1536 }
1537
1538 if (endptr > flag)
1539 {
1540 *endptr = '\0';
1541 fv = g_flags_get_value_by_name (fclass, flag);
1542
1543 if (!fv)
1544 fv = g_flags_get_value_by_nick (fclass, flag);
1545
1546 if (fv)
1547 value |= fv->value;
1548 else
1549 {
1550 g_set_error (error,
1551 GTK_BUILDER_ERROR,
1552 GTK_BUILDER_ERROR_INVALID_VALUE,
1553 "Unknown flag: `%s'",
1554 flag);
1555 ret = FALSE;
1556 break;
1557 }
1558 }
1559
1560 if (eos)
1561 {
1562 *flags_value = value;
1563 break;
1564 }
1565 }
1566
1567 g_free (flagstr);
1568
1569 g_type_class_unref (fclass);
1570 }
1571
1572 return ret;
1573 }
1574
1575 /**
1576 * gtk_builder_get_type_from_name:
1577 * @builder: a #GtkBuilder
1578 * @type_name: type name to lookup
1579 *
1580 * Looks up a type by name, using the virtual function that
1581 * #GtkBuilder has for that purpose. This is mainly used when
1582 * implementing the #GtkBuildable interface on a type.
1583 *
1584 * Returns: the #GType found for @type_name or #G_TYPE_INVALID
1585 * if no type was found
1586 *
1587 * Since: 2.12
1588 */
1589 GType
gtk_builder_get_type_from_name(GtkBuilder * builder,const gchar * type_name)1590 gtk_builder_get_type_from_name (GtkBuilder *builder,
1591 const gchar *type_name)
1592 {
1593 g_return_val_if_fail (GTK_IS_BUILDER (builder), G_TYPE_INVALID);
1594 g_return_val_if_fail (type_name != NULL, G_TYPE_INVALID);
1595
1596 return GTK_BUILDER_GET_CLASS (builder)->get_type_from_name (builder, type_name);
1597 }
1598
1599 GQuark
gtk_builder_error_quark(void)1600 gtk_builder_error_quark (void)
1601 {
1602 return g_quark_from_static_string ("gtk-builder-error-quark");
1603 }
1604
1605 gchar *
_gtk_builder_get_absolute_filename(GtkBuilder * builder,const gchar * string)1606 _gtk_builder_get_absolute_filename (GtkBuilder *builder, const gchar *string)
1607 {
1608 gchar *filename;
1609 gchar *dirname = NULL;
1610
1611 if (g_path_is_absolute (string))
1612 return g_strdup (string);
1613
1614 if (builder->priv->filename &&
1615 strcmp (builder->priv->filename, ".") != 0)
1616 {
1617 dirname = g_path_get_dirname (builder->priv->filename);
1618
1619 if (strcmp (dirname, ".") == 0)
1620 {
1621 g_free (dirname);
1622 dirname = g_get_current_dir ();
1623 }
1624 }
1625 else
1626 dirname = g_get_current_dir ();
1627
1628 filename = g_build_filename (dirname, string, NULL);
1629 g_free (dirname);
1630
1631 return filename;
1632 }
1633
1634 #define __GTK_BUILDER_C__
1635 #include "gtkaliasdef.c"
1636