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