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