Pileus Git - ~andy/gtk/blob - gtk/gtkbuilder.c

   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
  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
 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
 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
 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
 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
 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
 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
 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           if (pspec->flags & G_PARAM_CONSTRUCT_ONLY)
 284             {
 285               GObject *object;
 286               object = gtk_builder_get_object (builder, prop->data);
 287               if (!object)
 288                 {
 289                   g_warning ("Failed to get constuct only property "
 290                              "%s of %s with value `%s'",
 291                              prop->name, object_name, prop->data);
 292                   continue;
 293                 }
 294               g_value_init (&parameter.value, G_OBJECT_TYPE (object));
 295               g_value_set_object (&parameter.value, object);
 296             }
 297           else
 298             {
 299               property = g_slice_new (DelayedProperty);
 300               property->object = g_strdup (object_name);
 301               property->name = g_strdup (prop->name);
 302               property->value = g_strdup (prop->data);
 303               builder->priv->delayed_properties =
 304                 g_slist_prepend (builder->priv->delayed_properties, property);
 305
 306               continue;
 307             }
 308         }
 309       else if (!gtk_builder_value_from_string (builder, pspec,
 310                                                prop->data, &parameter.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_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 *
 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 *
 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                               &parameters,
 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 (&param->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, &param->value);
 482       else
 483         g_object_set_property (obj, param->name, &param->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*)&param->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 (&param->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
 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
 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
 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
 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 *
 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
 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
 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
 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
 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 *
 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
 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 *
 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
 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 *
 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
 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
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: 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
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: 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
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: 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
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
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
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
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
1600 gtk_builder_error_quark (void)
1601 {
1602   return g_quark_from_static_string ("gtk-builder-error-quark");
1603 }
1604
1605 gchar *
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"