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>
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.
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.
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.
24 #include <ctype.h> /* tolower, toupper */
25 #include <errno.h> /* errno */
26 #include <stdlib.h> /* strtol, strtoul */
27 #include <string.h> /* strlen */
29 #include "gtkbuilder.h"
30 #include "gtkbuildable.h"
31 #include "gtkbuilderprivate.h"
34 #include "gtkprivate.h"
35 #include "gtktypebuiltins.h"
36 #include "gtkwindow.h"
37 #include "gtkicontheme.h"
41 static void gtk_builder_class_init (GtkBuilderClass *klass);
42 static void gtk_builder_init (GtkBuilder *builder);
43 static void gtk_builder_finalize (GObject *object);
44 static void gtk_builder_set_property (GObject *object,
48 static void gtk_builder_get_property (GObject *object,
52 static GType gtk_builder_real_get_type_from_name (GtkBuilder *builder,
53 const gchar *type_name);
54 static gboolean _gtk_builder_enum_from_string (GType type,
62 PROP_TRANSLATION_DOMAIN,
65 struct _GtkBuilderPrivate
69 GHashTable *delayed_properties;
76 G_DEFINE_TYPE (GtkBuilder, gtk_builder, G_TYPE_OBJECT)
79 gtk_builder_class_init (GtkBuilderClass *klass)
81 GObjectClass *gobject_class;
83 gobject_class = G_OBJECT_CLASS (klass);
85 gobject_class->finalize = gtk_builder_finalize;
86 gobject_class->set_property = gtk_builder_set_property;
87 gobject_class->get_property = gtk_builder_get_property;
89 klass->get_type_from_name = gtk_builder_real_get_type_from_name;
92 * GtkBuilder:translation-domain:
94 * The translation domain used when translating property values that
95 * have been marked as translatable in interface descriptions.
96 * If the translation domain is %NULL, #GtkBuilder uses gettext(),
97 * otherwise dgettext().
101 g_object_class_install_property (gobject_class,
102 PROP_TRANSLATION_DOMAIN,
103 g_param_spec_string ("translation-domain",
104 P_("Translation Domain"),
105 P_("The translation domain used by gettext"),
107 GTK_PARAM_READWRITE));
109 g_type_class_add_private (gobject_class, sizeof (GtkBuilderPrivate));
113 gtk_builder_init (GtkBuilder *builder)
115 builder->priv = G_TYPE_INSTANCE_GET_PRIVATE (builder, GTK_TYPE_BUILDER,
117 builder->priv->domain = NULL;
118 builder->priv->objects = g_hash_table_new_full (g_str_hash, g_str_equal,
120 builder->priv->delayed_properties = g_hash_table_new_full (g_str_hash,
127 * GObject virtual methods
131 gtk_builder_finalize (GObject *object)
133 GtkBuilder *builder = GTK_BUILDER (object);
135 g_free (builder->priv->domain);
137 g_free (builder->priv->current_root);
138 g_hash_table_destroy (builder->priv->delayed_properties);
139 builder->priv->delayed_properties = NULL;
140 g_slist_foreach (builder->priv->signals, (GFunc)_free_signal_info, NULL);
141 g_slist_free (builder->priv->signals);
142 g_hash_table_destroy (builder->priv->objects);
143 g_slist_foreach (builder->priv->root_objects, (GFunc)g_object_unref, NULL);
144 g_slist_free (builder->priv->root_objects);
145 g_free (builder->priv->filename);
149 gtk_builder_set_property (GObject *object,
154 GtkBuilder *builder = GTK_BUILDER (object);
158 case PROP_TRANSLATION_DOMAIN:
159 gtk_builder_set_translation_domain (builder, g_value_get_string (value));
162 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
168 gtk_builder_get_property (GObject *object,
173 GtkBuilder *builder = GTK_BUILDER (object);
177 case PROP_TRANSLATION_DOMAIN:
178 g_value_set_string (value, builder->priv->domain);
181 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
188 * Try to map a type name to a _get_type function
191 * GtkWindow -> gtk_window_get_type
192 * GtkHBox -> gtk_hbox_get_type
193 * GtkUIManager -> gtk_ui_manager_get_type
197 _gtk_builder_resolve_type_lazily (const gchar *name)
199 static GModule *module = NULL;
201 GString *symbol_name = g_string_new ("");
204 GType gtype = G_TYPE_INVALID;
207 module = g_module_open (NULL, 0);
209 for (i = 0; name[i] != '\0'; i++)
212 /* skip if uppercase, first or previous is uppercase */
213 if ((c == toupper (c) &&
214 i > 0 && name[i-1] != toupper (name[i-1])) ||
215 (i > 2 && name[i] == toupper (name[i]) &&
216 name[i-1] == toupper (name[i-1]) &&
217 name[i-2] == toupper (name[i-2])))
218 g_string_append_c (symbol_name, '_');
219 g_string_append_c (symbol_name, tolower (c));
221 g_string_append (symbol_name, "_get_type");
223 symbol = g_string_free (symbol_name, FALSE);
225 if (g_module_symbol (module, symbol, (gpointer)&func))
234 * GtkBuilder virtual methods
238 gtk_builder_real_get_type_from_name (GtkBuilder *builder,
239 const gchar *type_name)
243 gtype = g_type_from_name (type_name);
244 if (gtype != G_TYPE_INVALID)
247 return _gtk_builder_resolve_type_lazily (type_name);
258 gtk_builder_get_parameters (GtkBuilder *builder,
260 const gchar *object_name,
263 GArray **construct_parameters)
267 GObjectClass *oclass;
268 DelayedProperty *property;
269 GError *error = NULL;
271 oclass = g_type_class_ref (object_type);
272 g_assert (oclass != NULL);
274 *parameters = g_array_new (FALSE, FALSE, sizeof (GParameter));
275 *construct_parameters = g_array_new (FALSE, FALSE, sizeof (GParameter));
277 for (l = properties; l; l = l->next)
279 PropertyInfo *prop = (PropertyInfo*)l->data;
280 GParameter parameter = { NULL };
282 pspec = g_object_class_find_property (G_OBJECT_CLASS (oclass),
286 g_warning ("Unknown property: %s.%s\n",
287 g_type_name (object_type), prop->name);
291 parameter.name = prop->name;
293 if (G_IS_PARAM_SPEC_OBJECT (pspec) &&
294 (G_PARAM_SPEC_VALUE_TYPE (pspec) != GDK_TYPE_PIXBUF))
296 if (pspec->flags & G_PARAM_CONSTRUCT_ONLY)
299 object = gtk_builder_get_object (builder, prop->data);
302 g_warning ("Failed to get constuct only property "
303 "%s of %s with value `%s'",
304 prop->name, object_name, prop->data);
307 g_value_init (¶meter.value, G_OBJECT_TYPE (object));
308 g_value_set_object (¶meter.value, object);
312 GSList *delayed_properties;
314 delayed_properties = g_hash_table_lookup (builder->priv->delayed_properties,
315 builder->priv->current_root);
316 property = g_slice_new (DelayedProperty);
317 property->object = g_strdup (object_name);
318 property->name = g_strdup (prop->name);
319 property->value = g_strdup (prop->data);
320 delayed_properties = g_slist_prepend (delayed_properties, property);
321 g_hash_table_insert (builder->priv->delayed_properties,
322 g_strdup (builder->priv->current_root),
327 else if (!gtk_builder_value_from_string (builder, pspec,
328 prop->data, ¶meter.value, &error))
330 g_warning ("Failed to set property %s.%s to %s: %s",
331 g_type_name (object_type), prop->name, prop->data,
333 g_error_free (error);
338 if (pspec->flags & G_PARAM_CONSTRUCT_ONLY)
339 g_array_append_val (*construct_parameters, parameter);
341 g_array_append_val (*parameters, parameter);
344 g_type_class_unref (oclass);
348 gtk_builder_get_internal_child (GtkBuilder *builder,
350 const gchar *childname)
359 info = (ObjectInfo*)((ChildInfo*)info->parent)->parent;
364 g_print ("Trying to get internal child %s from %s\n",
366 gtk_buildable_get_name (GTK_BUILDABLE (info->object))));
368 if (GTK_IS_BUILDABLE (info->object))
369 obj = gtk_buildable_get_internal_child (GTK_BUILDABLE (info->object),
375 g_error ("Unknown internal child: %s\n", childname);
381 _gtk_builder_construct (GtkBuilder *builder,
384 GArray *parameters, *construct_parameters;
388 GtkBuildableIface *iface;
389 gboolean custom_set_property;
390 GtkBuildable *buildable;
392 g_assert (info->class_name != NULL);
393 object_type = gtk_builder_get_type_from_name (builder, info->class_name);
394 if (object_type == G_TYPE_INVALID)
395 g_error ("Invalid type: %s", info->class_name);
399 g_free (builder->priv->current_root);
400 builder->priv->current_root = g_strdup (info->id);
403 gtk_builder_get_parameters (builder, object_type,
407 &construct_parameters);
409 if (info->constructor)
411 GObject *constructor;
413 constructor = gtk_builder_get_object (builder, info->constructor);
414 if (constructor == NULL)
415 g_error ("Unknown constructor for %s: %s\n", info->id,
418 obj = gtk_buildable_construct_child (GTK_BUILDABLE (constructor),
421 g_assert (obj != NULL);
422 if (construct_parameters->len)
423 g_warning ("Can't pass in construct-only parameters to %s", info->id);
426 else if (info->parent && ((ChildInfo*)info->parent)->internal_child != NULL)
428 gchar *childname = ((ChildInfo*)info->parent)->internal_child;
429 obj = gtk_builder_get_internal_child (builder, info, childname);
430 if (construct_parameters->len)
431 g_warning ("Can't pass in construct-only parameters to %s", childname);
435 obj = g_object_newv (object_type,
436 construct_parameters->len,
437 (GParameter *)construct_parameters->data);
440 g_print ("created %s of type %s\n", info->id, info->class_name));
442 for (i = 0; i < construct_parameters->len; i++)
444 GParameter *param = &g_array_index (construct_parameters,
446 g_value_unset (¶m->value);
449 g_array_free (construct_parameters, TRUE);
451 custom_set_property = FALSE;
454 if (GTK_IS_BUILDABLE (obj))
456 buildable = GTK_BUILDABLE (obj);
457 iface = GTK_BUILDABLE_GET_IFACE (obj);
458 if (iface->set_buildable_property)
459 custom_set_property = TRUE;
462 for (i = 0; i < parameters->len; i++)
464 GParameter *param = &g_array_index (parameters, GParameter, i);
465 if (custom_set_property)
466 iface->set_buildable_property (buildable, builder, param->name, ¶m->value);
468 g_object_set_property (obj, param->name, ¶m->value);
471 if (gtk_debug_flags & GTK_DEBUG_BUILDER)
473 gchar *str = g_strdup_value_contents ((const GValue*)¶m->value);
474 g_print ("set %s: %s = %s\n", info->id, param->name, str);
478 g_value_unset (¶m->value);
480 g_array_free (parameters, TRUE);
482 if (GTK_IS_BUILDABLE (obj))
483 gtk_buildable_set_name (buildable, info->id);
485 g_object_set_data_full (obj,
491 if (!info->parent && !GTK_IS_WINDOW (obj))
493 if (g_object_is_floating (obj))
494 g_object_ref_sink (obj);
496 builder->priv->root_objects =
497 g_slist_prepend (builder->priv->root_objects, obj);
499 g_hash_table_insert (builder->priv->objects, g_strdup (info->id), obj);
501 builder->priv->signals = g_slist_concat (builder->priv->signals,
502 g_slist_copy (info->signals));
508 _gtk_builder_add (GtkBuilder *builder,
509 ChildInfo *child_info)
514 /* Internal children are already added
515 * Also prevent us from being called twice.
518 child_info->internal_child ||
522 object = child_info->object;
526 if (!child_info->parent)
528 g_warning ("%s: Not adding, No parent\n",
529 gtk_buildable_get_name (GTK_BUILDABLE (object)));
533 g_assert (object != NULL);
535 parent = ((ObjectInfo*)child_info->parent)->object;
536 g_assert (GTK_IS_BUILDABLE (parent));
539 g_print ("adding %s to %s\n",
540 gtk_buildable_get_name (GTK_BUILDABLE (object)),
541 gtk_buildable_get_name (GTK_BUILDABLE (parent))));
543 gtk_buildable_add_child (GTK_BUILDABLE (parent), builder, object,
546 child_info->added = TRUE;
550 apply_delayed_properties (const gchar *window_name,
555 DelayedProperty *property;
558 GObjectClass *oclass;
561 g_assert (props != NULL);
562 props = g_slist_reverse (props);
563 for (l = props; l; l = l->next)
565 property = (DelayedProperty*)l->data;
566 object = g_hash_table_lookup (builder->priv->objects, property->object);
567 g_assert (object != NULL);
569 object_type = G_OBJECT_TYPE (object);
570 g_assert (object_type != G_TYPE_INVALID);
572 oclass = g_type_class_ref (object_type);
573 g_assert (oclass != NULL);
575 pspec = g_object_class_find_property (G_OBJECT_CLASS (oclass),
578 g_warning ("Unknown property: %s.%s\n", g_type_name (object_type),
584 obj = g_hash_table_lookup (builder->priv->objects, property->value);
586 g_warning ("No object called: %s\n", property->value);
588 g_object_set (object, property->name, obj, NULL);
590 g_free (property->value);
591 g_free (property->object);
592 g_free (property->name);
593 g_slice_free (DelayedProperty, property);
594 g_type_class_unref (oclass);
596 g_slist_free (props);
600 _gtk_builder_finish (GtkBuilder *builder)
602 if (builder->priv->delayed_properties)
603 g_hash_table_foreach (builder->priv->delayed_properties,
604 (GHFunc)apply_delayed_properties, builder);
610 * Creates a new builder object.
612 * Return value: a new #GtkBuilder object
617 gtk_builder_new (void)
619 return g_object_new (GTK_TYPE_BUILDER, NULL);
623 * gtk_builder_add_from_file:
624 * @builder: a #GtkBuilder
625 * @filename: the name of the file to parse
626 * @error: return location for an error, or %NULL
628 * Parses a file containing a <link linkend="BUILDER-UI">GtkBuilder
629 * UI definition</link> and merges it with the current contents of @builder.
631 * Returns: A positive value on success, 0 if an error occurred
636 gtk_builder_add_from_file (GtkBuilder *builder,
637 const gchar *filename,
644 g_return_val_if_fail (GTK_IS_BUILDER (builder), 0);
645 g_return_val_if_fail (filename != NULL, 0);
649 if (!g_file_get_contents (filename, &buffer, &length, &tmp_error))
651 g_propagate_error (error, tmp_error);
655 builder->priv->filename = g_strdup (filename);
657 _gtk_builder_parser_parse_buffer (builder, filename,
661 if (tmp_error != NULL)
663 g_propagate_error (error, tmp_error);
673 * gtk_builder_add_from_string:
674 * @builder: a #GtkBuilder
675 * @buffer: the string to parse
676 * @length: the length of @buffer (may be -1 if @buffer is nul-terminated)
677 * @error: return location for an error, or %NULL
679 * Parses a string containing a <link linkend="BUILDER-UI">GtkBuilder
680 * UI definition</link> and merges it with the current contents of @builder.
682 * Returns: A positive value on success, 0 if an error occurred
687 gtk_builder_add_from_string (GtkBuilder *builder,
694 g_return_val_if_fail (GTK_IS_BUILDER (builder), 0);
695 g_return_val_if_fail (buffer != NULL, 0);
699 builder->priv->filename = ".";
701 _gtk_builder_parser_parse_buffer (builder, "<input>",
704 if (tmp_error != NULL)
706 g_propagate_error (error, tmp_error);
714 * gtk_builder_get_object:
715 * @builder: a #GtkBuilder
716 * @name: name of object to get
718 * Gets the object named @name. Note that this function does not
719 * increment the reference count of the returned object.
721 * Return value: the object named @name or %NULL if it could not be
722 * found in the object tree.
727 gtk_builder_get_object (GtkBuilder *builder,
730 g_return_val_if_fail (GTK_IS_BUILDER (builder), NULL);
731 g_return_val_if_fail (name != NULL, NULL);
733 return g_hash_table_lookup (builder->priv->objects, name);
737 object_add_to_list (gchar *object_id,
741 *list = g_slist_prepend (*list, object);
745 * gtk_builder_get_objects:
746 * @builder: a #GtkBuilder
748 * Gets all objects that have been constructed by @builder. Note that
749 * this function does not increment the reference counts of the returned
752 * Return value: a newly-allocated #GSList containing all the objects
753 * constructed by the #GtkBuilder instance. It should be freed by
759 gtk_builder_get_objects (GtkBuilder *builder)
761 GSList *objects = NULL;
763 g_return_val_if_fail (GTK_IS_BUILDER (builder), NULL);
765 g_hash_table_foreach (builder->priv->objects, (GHFunc)object_add_to_list, &objects);
767 return g_slist_reverse (objects);
771 * gtk_builder_set_translation_domain:
772 * @builder: a #GtkBuilder
773 * @domain: the translation domain or %NULL
775 * Sets the translation domain of @builder.
776 * See #GtkBuilder:translation-domain.
781 gtk_builder_set_translation_domain (GtkBuilder *builder,
786 g_return_if_fail (GTK_IS_BUILDER (builder));
788 new_domain = g_strdup (domain);
789 g_free (builder->priv->domain);
790 builder->priv->domain = new_domain;
792 g_object_notify (G_OBJECT (builder), "translation-domain");
796 * gtk_builder_get_translation_domain:
797 * @builder: a #GtkBuilder
799 * Gets the translation domain of @builder.
801 * Return value: the translation domain. This string is owned
802 * by the builder object and must not be modified or freed.
807 gtk_builder_get_translation_domain (GtkBuilder *builder)
809 g_return_val_if_fail (GTK_IS_BUILDER (builder), NULL);
811 return builder->priv->domain;
820 gtk_builder_connect_signals_default (GtkBuilder *builder,
822 const gchar *signal_name,
823 const gchar *handler_name,
824 GObject *connect_object,
829 connect_args *args = (connect_args*)user_data;
831 if (!g_module_symbol (args->module, handler_name, (gpointer)&func))
833 g_warning ("Could not find signal handler '%s'", handler_name);
838 g_signal_connect_object (object, signal_name, func, connect_object, flags);
840 g_signal_connect_data (object, signal_name, func, args->data, NULL, flags);
845 * gtk_builder_connect_signals:
846 * @builder: a #GtkBuilder
847 * @user_data: a pointer to a structure sent in as user data to all signals
849 * This method is a simpler variation of gtk_builder_connect_signals_full().
850 * It uses #GModule's introspective features (by opening the module %NULL)
851 * to look at the application's symbol table. From here it tries to match
852 * the signal handler names given in the interface description with
853 * symbols in the application and connects the signals.
855 * Note that this function will not work correctly if #GModule is not
856 * supported on the platform.
861 gtk_builder_connect_signals (GtkBuilder *builder,
866 g_return_if_fail (GTK_IS_BUILDER (builder));
868 if (!g_module_supported ())
869 g_error ("gtk_builder_connect_signals() requires working GModule");
871 args = g_slice_new0 (connect_args);
872 args->module = g_module_open (NULL, G_MODULE_BIND_LAZY);
873 args->data = user_data;
875 gtk_builder_connect_signals_full (builder,
876 gtk_builder_connect_signals_default,
878 g_module_close (args->module);
880 g_slice_free (connect_args, args);
884 * GtkBuilderConnectFunc:
885 * @builder: a #GtkBuilder
886 * @object: object to connect a signal to
887 * @signal_name: name of the signal
888 * @handler_name: name of the handler
889 * @connect_object: a #GObject, if non-%NULL, use g_signal_connect_object()
890 * @flags: #GConnectFlags to use
891 * @user_data: user data
893 * This is the signature of a function used to connect signals. It is used
894 * by the gtk_builder_connect_signals() and gtk_builder_connect_signals_full()
895 * methods. It is mainly intended for interpreted language bindings, but
896 * could be useful where the programmer wants more control over the signal
897 * connection process.
903 * gtk_builder_connect_signals_full:
904 * @builder: a #GtkBuilder
905 * @func: the function used to connect the signals
906 * @user_data: arbitrary data that will be passed to the connection function
908 * This function can be thought of the interpreted language binding
909 * version of gtk_builder_connect_signals(), except that it does not
910 * require GModule to function correctly.
915 gtk_builder_connect_signals_full (GtkBuilder *builder,
916 GtkBuilderConnectFunc func,
921 GObject *connect_object;
923 g_return_if_fail (GTK_IS_BUILDER (builder));
924 g_return_if_fail (func != NULL);
926 if (!builder->priv->signals)
929 builder->priv->signals = g_slist_reverse (builder->priv->signals);
930 for (l = builder->priv->signals; l; l = l->next)
932 SignalInfo *signal = (SignalInfo*)l->data;
934 g_assert (signal != NULL);
935 g_assert (signal->name != NULL);
937 object = g_hash_table_lookup (builder->priv->objects,
938 signal->object_name);
939 g_assert (object != NULL);
941 connect_object = NULL;
943 if (signal->connect_object_name)
945 connect_object = g_hash_table_lookup (builder->priv->objects,
946 signal->connect_object_name);
948 g_warning ("Could not lookup object %s on signal %s of object %s",
949 signal->connect_object_name, signal->name,
950 signal->object_name);
953 func (builder, object, signal->name, signal->handler,
954 connect_object, signal->flags, user_data);
957 g_slist_foreach (builder->priv->signals, (GFunc)_free_signal_info, NULL);
958 g_slist_free (builder->priv->signals);
959 builder->priv->signals = NULL;
963 * gtk_builder_value_from_string:
964 * @builder: a #GtkBuilder
965 * @pspec: the #GParamSpec for the property
966 * @string: the string representation of the value
967 * @value: the #GValue to store the result in
968 * @error: return location for an error, or %NULL
970 * This function demarshals a value from a string. This function
971 * calls g_value_init() on the @value argument, so it need not be
972 * initialised beforehand.
974 * This function can handle char, uchar, boolean, int, uint, long,
975 * ulong, enum, flags, float, double, string, #GdkColor and
976 * #GtkAdjustment type values. Support for #GtkWidget type values is
979 * Returns: %TRUE on success
984 gtk_builder_value_from_string (GtkBuilder *builder,
991 * GParamSpecUnichar has the internal type G_TYPE_UINT,
992 * so we cannot handle this in the switch, do it separately
994 if (G_IS_PARAM_SPEC_UNICHAR (pspec))
997 g_value_init (value, G_TYPE_UINT);
998 c = g_utf8_get_char_validated (string, strlen (string));
1000 g_value_set_uint (value, c);
1004 return gtk_builder_value_from_string_type (builder,
1005 G_PARAM_SPEC_VALUE_TYPE (pspec),
1006 string, value, error);
1010 * gtk_builder_value_from_string_type:
1011 * @builder: a #GtkBuilder
1012 * @type: the #GType of the value
1013 * @string: the string representation of the value
1014 * @value: the #GValue to store the result in
1015 * @error: return location for an error, or %NULL
1017 * Like gtk_builder_value_from_string(), this function demarshals
1018 * a value from a string, but takes a #GType instead of #GParamSpec.
1019 * This function calls g_value_init() on the @value argument, so it
1020 * need not be initialised beforehand.
1022 * Returns: %TRUE on success
1027 gtk_builder_value_from_string_type (GtkBuilder *builder,
1029 const gchar *string,
1033 gboolean ret = TRUE;
1035 g_return_val_if_fail (type != G_TYPE_INVALID, FALSE);
1036 g_return_val_if_fail (string != NULL, FALSE);
1038 g_value_init (value, type);
1040 switch (G_TYPE_FUNDAMENTAL (type))
1043 g_value_set_char (value, string[0]);
1046 g_value_set_uchar (value, (guchar)string[0]);
1048 case G_TYPE_BOOLEAN:
1052 if (!_gtk_builder_boolean_from_string (string, &b, error))
1057 g_value_set_boolean (value, b);
1066 l = strtol (string, &endptr, 0);
1067 if (errno || endptr == string)
1071 GTK_BUILDER_ERROR_INVALID_VALUE,
1072 "Could not parse integer `%s'",
1077 if (G_VALUE_HOLDS_INT (value))
1078 g_value_set_int (value, l);
1080 g_value_set_long (value, l);
1089 ul = strtoul (string, &endptr, 0);
1090 if (errno || endptr == string)
1094 GTK_BUILDER_ERROR_INVALID_VALUE,
1095 "Could not parse unsigned integer `%s'",
1100 if (G_VALUE_HOLDS_UINT (value))
1101 g_value_set_uint (value, ul);
1103 g_value_set_ulong (value, ul);
1109 if (!_gtk_builder_enum_from_string (type, string, &enum_value, error))
1114 g_value_set_enum (value, enum_value);
1120 if (!_gtk_builder_flags_from_string (type, string, &flags_value, error))
1125 g_value_set_flags (value, flags_value);
1134 d = g_ascii_strtod (string, &endptr);
1135 if (errno || endptr == string)
1139 GTK_BUILDER_ERROR_INVALID_VALUE,
1140 "Could not parse double `%s'",
1145 if (G_VALUE_HOLDS_FLOAT (value))
1146 g_value_set_float (value, d);
1148 g_value_set_double (value, d);
1152 g_value_set_string (value, string);
1155 if (G_VALUE_HOLDS (value, GDK_TYPE_COLOR))
1157 GdkColor colour = { 0, };
1159 if (gdk_color_parse (string, &colour) &&
1160 gdk_colormap_alloc_color (gtk_widget_get_default_colormap (),
1161 &colour, FALSE, TRUE))
1162 g_value_set_boxed (value, &colour);
1167 GTK_BUILDER_ERROR_INVALID_VALUE,
1168 "Could not parse color `%s'",
1173 else if (G_VALUE_HOLDS (value, G_TYPE_STRV))
1175 gchar **vector = g_strsplit (string, "\n", 0);
1176 g_value_take_boxed (value, vector);
1182 if (G_VALUE_HOLDS (value, GDK_TYPE_PIXBUF))
1185 GError *tmp_error = NULL;
1188 if (gtk_builder_get_object (builder, string))
1192 GTK_BUILDER_ERROR_INVALID_VALUE,
1193 "Could not load image '%s': "
1194 " '%s' is already used as object id",
1199 if (g_path_is_absolute (string))
1200 filename = g_strdup (string);
1205 dirname = g_path_get_dirname (builder->priv->filename);
1206 filename = g_build_filename (dirname, string, NULL);
1211 pixbuf = gdk_pixbuf_new_from_file (filename, &tmp_error);
1215 GtkIconTheme *theme;
1217 g_warning ("Could not load image '%s': %s",
1218 string, tmp_error->message);
1219 g_error_free (tmp_error);
1221 /* fall back to a missing image */
1222 theme = gtk_icon_theme_get_default ();
1223 pixbuf = gtk_icon_theme_load_icon (theme,
1224 GTK_STOCK_MISSING_IMAGE,
1226 GTK_ICON_LOOKUP_USE_BUILTIN,
1232 g_value_set_object (value, pixbuf);
1233 g_object_unref (G_OBJECT (pixbuf));
1246 GTK_BUILDER_ERROR_INVALID_VALUE,
1247 "Unsupported GType `%s'",
1248 g_type_name (type));
1257 _gtk_builder_enum_from_string (GType type,
1258 const gchar *string,
1267 g_return_val_if_fail (G_TYPE_IS_ENUM (type), 0);
1268 g_return_val_if_fail (string != NULL, 0);
1270 value = strtoul (string, &endptr, 0);
1271 if (endptr != string) /* parsed a number */
1272 *enum_value = value;
1275 eclass = g_type_class_ref (type);
1276 ev = g_enum_get_value_by_name (eclass, string);
1278 ev = g_enum_get_value_by_nick (eclass, string);
1281 *enum_value = ev->value;
1286 GTK_BUILDER_ERROR_INVALID_VALUE,
1287 "Could not parse enum: `%s'",
1292 g_type_class_unref (eclass);
1299 _gtk_builder_flags_from_string (GType type,
1300 const gchar *string,
1304 GFlagsClass *fclass;
1305 gchar *endptr, *prevptr;
1306 guint i, j, ret, value;
1313 g_return_val_if_fail (G_TYPE_IS_FLAGS (type), 0);
1314 g_return_val_if_fail (string != 0, 0);
1318 value = strtoul (string, &endptr, 0);
1319 if (endptr != string) /* parsed a number */
1320 *flags_value = value;
1323 fclass = g_type_class_ref (type);
1325 flagstr = g_strdup (string);
1326 for (value = i = j = 0; ; i++)
1329 eos = flagstr[i] == '\0';
1331 if (!eos && flagstr[i] != '|')
1335 endptr = &flagstr[i];
1339 flagstr[i++] = '\0';
1346 ch = g_utf8_get_char (flag);
1347 if (!g_unichar_isspace (ch))
1349 flag = g_utf8_next_char (flag);
1352 while (endptr > flag)
1354 prevptr = g_utf8_prev_char (endptr);
1355 ch = g_utf8_get_char (prevptr);
1356 if (!g_unichar_isspace (ch))
1364 fv = g_flags_get_value_by_name (fclass, flag);
1367 fv = g_flags_get_value_by_nick (fclass, flag);
1375 GTK_BUILDER_ERROR_INVALID_VALUE,
1376 "Unknown flag: `%s'",
1385 *flags_value = value;
1392 g_type_class_unref (fclass);
1399 * gtk_builder_get_type_from_name:
1400 * @builder: a #GtkBuilder
1401 * @type_name: type name to lookup
1403 * Looks up a type by name, using the virtual function that
1404 * #GtkBuilder has for that purpose.
1406 * Returns: the #GType found for @type_name or #G_TYPE_INVALID
1407 * if no type was found
1412 gtk_builder_get_type_from_name (GtkBuilder *builder,
1413 const gchar *type_name)
1415 g_return_val_if_fail (GTK_IS_BUILDER (builder), G_TYPE_INVALID);
1416 g_return_val_if_fail (type_name != NULL, G_TYPE_INVALID);
1418 return GTK_BUILDER_GET_CLASS (builder)->get_type_from_name (builder, type_name);
1422 gtk_builder_error_quark (void)
1424 return g_quark_from_static_string ("gtk-builder-error-quark");
1428 #define __GTK_BUILDER_C__
1429 #include "gtkaliasdef.c"