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