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