/* GTK - The GIMP Toolkit

 * Copyright (C) 1998-2002 James Henstridge <james@daa.com.au>

 * Copyright (C) 2006-2007 Async Open Source,

 *                         Johan Dahlin <jdahlin@async.com.br>,

 *                         Henrique Romano <henrique@async.com.br>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

#include "config.h"

#include <errno.h> /* errno */

#include <stdlib.h> /* strtol, strtoul */

#include <string.h> /* strlen */

#include "gtkbuilder.h"

#include "gtkbuildable.h"

#include "gtkbuilderprivate.h"

#include "gtkmain.h"

#include "gtkintl.h"

#include "gtkprivate.h"

#include "gtktypebuiltins.h"

#include "gtkwindow.h"

#include "gtkicontheme.h"

#include "gtkstock.h"

#include "gtkalias.h"

static void gtk_builder_class_init     (GtkBuilderClass *klass);

static void gtk_builder_init           (GtkBuilder      *builder);

static void gtk_builder_finalize       (GObject         *object);

static void gtk_builder_set_property   (GObject         *object,

                                        guint            prop_id,

                                        const GValue    *value,

                                        GParamSpec      *pspec);

static void gtk_builder_get_property   (GObject         *object,

                                        guint            prop_id,

                                        GValue          *value,

                                        GParamSpec      *pspec);

static GType gtk_builder_real_get_type_from_name (GtkBuilder  *builder,

                                                  const gchar *type_name);

enum {

  PROP_0,

  PROP_TRANSLATION_DOMAIN,

};

struct _GtkBuilderPrivate

{

  gchar *domain;

  GHashTable *objects;

  GSList *delayed_properties;

  GSList *signals;

  gchar *filename;

};

G_DEFINE_TYPE (GtkBuilder, gtk_builder, G_TYPE_OBJECT)

static void

gtk_builder_class_init (GtkBuilderClass *klass)

{

  GObjectClass *gobject_class;

  gobject_class = G_OBJECT_CLASS (klass);

  gobject_class->finalize = gtk_builder_finalize;

  gobject_class->set_property = gtk_builder_set_property;

  gobject_class->get_property = gtk_builder_get_property;

  klass->get_type_from_name = gtk_builder_real_get_type_from_name;

 /** 

  * GtkBuilder:translation-domain:

  *

  * The translation domain used when translating property values that

  * have been marked as translatable in interface descriptions.

  * If the translation domain is %NULL, #GtkBuilder uses gettext(),

  * otherwise g_dgettext().

  *

  * Since: 2.12

  */

  g_object_class_install_property (gobject_class,

                                   PROP_TRANSLATION_DOMAIN,

                                   g_param_spec_string ("translation-domain",

                                                        P_("Translation Domain"),

                                                        P_("The translation domain used by gettext"),

                                                        NULL,

                                                        GTK_PARAM_READWRITE));

  g_type_class_add_private (gobject_class, sizeof (GtkBuilderPrivate));

}

static void

gtk_builder_init (GtkBuilder *builder)

{

  builder->priv = G_TYPE_INSTANCE_GET_PRIVATE (builder, GTK_TYPE_BUILDER,

                                               GtkBuilderPrivate);

  builder->priv->domain = NULL;

  builder->priv->objects = g_hash_table_new_full (g_str_hash, g_str_equal,

                                                  g_free, g_object_unref);

}

/*

 * GObject virtual methods

 */

static void

gtk_builder_finalize (GObject *object)

{

  GtkBuilderPrivate *priv = GTK_BUILDER (object)->priv;

  g_free (priv->domain);

  g_free (priv->filename);

  g_hash_table_destroy (priv->objects);

  g_slist_foreach (priv->signals, (GFunc) _free_signal_info, NULL);

  g_slist_free (priv->signals);

  G_OBJECT_CLASS (gtk_builder_parent_class)->finalize (object);

}

static void

gtk_builder_set_property (GObject      *object,

                          guint         prop_id,

                          const GValue *value,

                          GParamSpec   *pspec)

{

  GtkBuilder *builder = GTK_BUILDER (object);

  switch (prop_id)

    {

    case PROP_TRANSLATION_DOMAIN:

      gtk_builder_set_translation_domain (builder, g_value_get_string (value));

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

    }

}

static void

gtk_builder_get_property (GObject    *object,

                          guint       prop_id,

                          GValue     *value,

                          GParamSpec *pspec)

{

  GtkBuilder *builder = GTK_BUILDER (object);

  switch (prop_id)

    {

    case PROP_TRANSLATION_DOMAIN:

      g_value_set_string (value, builder->priv->domain);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

    }

}

/*

 * Try to map a type name to a _get_type function

 * and call it, eg:

 *

 * GtkWindow -> gtk_window_get_type

 * GtkHBox -> gtk_hbox_get_type

 * GtkUIManager -> gtk_ui_manager_get_type

 *

 */

static GType

_gtk_builder_resolve_type_lazily (const gchar *name)

{

  static GModule *module = NULL;

  GTypeGetFunc func;

  GString *symbol_name = g_string_new ("");

  char c, *symbol;

  int i;

  GType gtype = G_TYPE_INVALID;

  if (!module)

    module = g_module_open (NULL, 0);

  for (i = 0; name[i] != '\0'; i++)

    {

      c = name[i];

      /* skip if uppercase, first or previous is uppercase */

      if ((c == g_ascii_toupper (c) &&

           i > 0 && name[i-1] != g_ascii_toupper (name[i-1])) ||

          (i > 2 && name[i]   == g_ascii_toupper (name[i]) &&

           name[i-1] == g_ascii_toupper (name[i-1]) &&

           name[i-2] == g_ascii_toupper (name[i-2])))

        g_string_append_c (symbol_name, '_');

      g_string_append_c (symbol_name, g_ascii_tolower (c));

    }

  g_string_append (symbol_name, "_get_type");

  symbol = g_string_free (symbol_name, FALSE);

  if (g_module_symbol (module, symbol, (gpointer)&func))

    gtype = func ();

  g_free (symbol);

  return gtype;

}

/*

 * GtkBuilder virtual methods

 */

static GType

gtk_builder_real_get_type_from_name (GtkBuilder  *builder, 

                                     const gchar *type_name)

{

  GType gtype;

  gtype = g_type_from_name (type_name);

  if (gtype != G_TYPE_INVALID)

    return gtype;

  return _gtk_builder_resolve_type_lazily (type_name);

}

typedef struct

{

  gchar *object;

  gchar *name;

  gchar *value;

} DelayedProperty;

static void

gtk_builder_get_parameters (GtkBuilder  *builder,

                            GType        object_type,

                            const gchar *object_name,

                            GSList      *properties,

                            GArray      **parameters,

                            GArray      **construct_parameters)

{

  GSList *l;

  GParamSpec *pspec;

  GObjectClass *oclass;

  DelayedProperty *property;

  GError *error = NULL;

  oclass = g_type_class_ref (object_type);

  g_assert (oclass != NULL);

  *parameters = g_array_new (FALSE, FALSE, sizeof (GParameter));

  *construct_parameters = g_array_new (FALSE, FALSE, sizeof (GParameter));

  for (l = properties; l; l = l->next)

    {

      PropertyInfo *prop = (PropertyInfo*)l->data;

      GParameter parameter = { NULL };

      pspec = g_object_class_find_property (G_OBJECT_CLASS (oclass),

                                            prop->name);

      if (!pspec)

        {

          g_warning ("Unknown property: %s.%s",

                     g_type_name (object_type), prop->name);

          continue;

        }

      parameter.name = prop->name;

      if (G_IS_PARAM_SPEC_OBJECT (pspec) &&

          (G_PARAM_SPEC_VALUE_TYPE (pspec) != GDK_TYPE_PIXBUF))

        {

          GObject *object = gtk_builder_get_object (builder, prop->data);

          if (object)

            {

              g_value_init (&parameter.value, G_OBJECT_TYPE (object));

              g_value_set_object (&parameter.value, object);

            }

          else 

            {

              if (pspec->flags & G_PARAM_CONSTRUCT_ONLY)

                {

                  g_warning ("Failed to get constuct only property "

                             "%s of %s with value `%s'",

                             prop->name, object_name, prop->data);

                  continue;

                }

              /* Delay setting property */

              property = g_slice_new (DelayedProperty);

              property->object = g_strdup (object_name);

              property->name = g_strdup (prop->name);

              property->value = g_strdup (prop->data);

              builder->priv->delayed_properties =

                g_slist_prepend (builder->priv->delayed_properties, property);

              continue;

            }

        }

      else if (!gtk_builder_value_from_string (builder, pspec,

					       prop->data, &parameter.value, &error))

        {

          g_warning ("Failed to set property %s.%s to %s: %s",

                     g_type_name (object_type), prop->name, prop->data,

		     error->message);

	  g_error_free (error);

	  error = NULL;

          continue;

        }

      if (pspec->flags & (G_PARAM_CONSTRUCT | G_PARAM_CONSTRUCT_ONLY))

        g_array_append_val (*construct_parameters, parameter);

      else

        g_array_append_val (*parameters, parameter);

    }

  g_type_class_unref (oclass);

}

static GObject *

gtk_builder_get_internal_child (GtkBuilder  *builder,

                                ObjectInfo  *info,

                                const gchar *childname,

				GError      **error)

{

  GObject *obj = NULL;

  while (!obj)

    {

      if (!info->parent)

        break;

      info = (ObjectInfo*)((ChildInfo*)info->parent)->parent;

      if (!info)

        break;

      GTK_NOTE (BUILDER,

                g_print ("Trying to get internal child %s from %s\n",

                         childname,

                         gtk_buildable_get_name (GTK_BUILDABLE (info->object))));

      if (GTK_IS_BUILDABLE (info->object))

          obj = gtk_buildable_get_internal_child (GTK_BUILDABLE (info->object),

                                                  builder,

                                                  childname);

    };

  if (!obj)

    {

      g_set_error (error,

		   GTK_BUILDER_ERROR,

		   GTK_BUILDER_ERROR_INVALID_VALUE,

		   "Unknown internal child: %s", childname);

    }

  return obj;

}

GObject *

_gtk_builder_construct (GtkBuilder *builder,

                        ObjectInfo *info,

			GError **error)

{

  GArray *parameters, *construct_parameters;

  GType object_type;

  GObject *obj;

  int i;

  GtkBuildableIface *iface;

  gboolean custom_set_property;

  GtkBuildable *buildable;

  g_assert (info->class_name != NULL);

  object_type = gtk_builder_get_type_from_name (builder, info->class_name);

  if (object_type == G_TYPE_INVALID)

    {

      g_set_error (error,

		   GTK_BUILDER_ERROR,

		   GTK_BUILDER_ERROR_INVALID_VALUE,

		   "Invalid object type `%s'",

		   info->class_name);

      return NULL;

    }

  gtk_builder_get_parameters (builder, object_type,

                              info->id,

                              info->properties,

                              &parameters,

                              &construct_parameters);

  if (info->constructor)

    {

      GObject *constructor;

      constructor = gtk_builder_get_object (builder, info->constructor);

      if (constructor == NULL)

	{

	  g_set_error (error,

		       GTK_BUILDER_ERROR,

		       GTK_BUILDER_ERROR_INVALID_VALUE,

		       "Unknown object constructor for %s: %s",

		       info->id,

		       info->constructor);

	  g_array_free (parameters, TRUE);

	  g_array_free (construct_parameters, TRUE);

	  return NULL;

	}

      obj = gtk_buildable_construct_child (GTK_BUILDABLE (constructor),

                                           builder,

                                           info->id);

      g_assert (obj != NULL);

      if (construct_parameters->len)

        g_warning ("Can't pass in construct-only parameters to %s", info->id);

    }

  else if (info->parent && ((ChildInfo*)info->parent)->internal_child != NULL)

    {

      gchar *childname = ((ChildInfo*)info->parent)->internal_child;

      obj = gtk_builder_get_internal_child (builder, info, childname, error);

      if (!obj)

	{

	  g_array_free (parameters, TRUE);

	  g_array_free (construct_parameters, TRUE);

	  return NULL;

	}

      if (construct_parameters->len)

        g_warning ("Can't pass in construct-only parameters to %s", childname);

      g_object_ref (obj);

    }

  else

    {

      obj = g_object_newv (object_type,

                           construct_parameters->len,

                           (GParameter *)construct_parameters->data);

      /* No matter what, make sure we have a reference.

       *

       * If it's an initially unowned object, sink it.

       * If it's not initially unowned then we have the reference already.

       *

       * In the case that this is a window it will be sunk already and

       * this is effectively a call to g_object_ref().  That's what

       * we want.

       */

      if (G_IS_INITIALLY_UNOWNED (obj))

        g_object_ref_sink (obj);

      GTK_NOTE (BUILDER,

                g_print ("created %s of type %s\n", info->id, info->class_name));

      for (i = 0; i < construct_parameters->len; i++)

        {

          GParameter *param = &g_array_index (construct_parameters,

                                              GParameter, i);

          g_value_unset (&param->value);

        }

    }

  g_array_free (construct_parameters, TRUE);

  custom_set_property = FALSE;

  buildable = NULL;

  iface = NULL;

  if (GTK_IS_BUILDABLE (obj))

    {

      buildable = GTK_BUILDABLE (obj);

      iface = GTK_BUILDABLE_GET_IFACE (obj);

      if (iface->set_buildable_property)

        custom_set_property = TRUE;

    }

  for (i = 0; i < parameters->len; i++)

    {

      GParameter *param = &g_array_index (parameters, GParameter, i);

      if (custom_set_property)

        iface->set_buildable_property (buildable, builder, param->name, &param->value);

      else

        g_object_set_property (obj, param->name, &param->value);

#if G_ENABLE_DEBUG

      if (gtk_debug_flags & GTK_DEBUG_BUILDER)

        {

          gchar *str = g_strdup_value_contents ((const GValue*)&param->value);

          g_print ("set %s: %s = %s\n", info->id, param->name, str);

          g_free (str);

        }

#endif      

      g_value_unset (&param->value);

    }

  g_array_free (parameters, TRUE);

  if (GTK_IS_BUILDABLE (obj))

    gtk_buildable_set_name (buildable, info->id);

  else

    g_object_set_data_full (obj,

                            "gtk-builder-name",

                            g_strdup (info->id),

                            g_free);

  /* we already own a reference to obj.  put it in the hash table. */

  g_hash_table_insert (builder->priv->objects, g_strdup (info->id), obj);

  return obj;

}

void

_gtk_builder_add (GtkBuilder *builder,

                  ChildInfo  *child_info)

{

  GObject *object;

  GObject *parent;

  /* Internal children are already added

   * Also prevent us from being called twice.

   */

  if (!child_info ||

      child_info->internal_child ||

      child_info->added)

    return;

  object = child_info->object;

  if (!object)

    return;

  if (!child_info->parent)

    {

      g_warning ("%s: Not adding, No parent",

                 gtk_buildable_get_name (GTK_BUILDABLE (object)));

      return;

    }

  g_assert (object != NULL);

  parent = ((ObjectInfo*)child_info->parent)->object;

  g_assert (GTK_IS_BUILDABLE (parent));

  GTK_NOTE (BUILDER,

            g_print ("adding %s to %s\n",

                     gtk_buildable_get_name (GTK_BUILDABLE (object)),

                     gtk_buildable_get_name (GTK_BUILDABLE (parent))));

  gtk_buildable_add_child (GTK_BUILDABLE (parent), builder, object,

			   child_info->type);

  child_info->added = TRUE;

}

void

_gtk_builder_add_signals (GtkBuilder *builder,

			  GSList     *signals)

{

  builder->priv->signals = g_slist_concat (builder->priv->signals,

                                           g_slist_copy (signals));

}

static void

gtk_builder_apply_delayed_properties (GtkBuilder *builder)

{

  GSList *l, *props;

  DelayedProperty *property;

  GObject *object;

  GType object_type;

  GObjectClass *oclass;

  GParamSpec *pspec;

  /* take the list over from the builder->priv.

   *

   * g_slist_reverse does not copy the list, so the list now

   * belongs to us (and we free it at the end of this function).

   */

  props = g_slist_reverse (builder->priv->delayed_properties);

  builder->priv->delayed_properties = NULL;

  for (l = props; l; l = l->next)

    {

      property = (DelayedProperty*)l->data;

      object = g_hash_table_lookup (builder->priv->objects, property->object);

      g_assert (object != NULL);

      object_type = G_OBJECT_TYPE (object);

      g_assert (object_type != G_TYPE_INVALID);

      oclass = g_type_class_ref (object_type);

      g_assert (oclass != NULL);

      pspec = g_object_class_find_property (G_OBJECT_CLASS (oclass),

                                            property->name);

      if (!pspec)

        g_warning ("Unknown property: %s.%s", g_type_name (object_type),

                   property->name);

      else

        {

          GObject *obj;

          obj = g_hash_table_lookup (builder->priv->objects, property->value);

          if (!obj)

            g_warning ("No object called: %s", property->value);

          else

            g_object_set (object, property->name, obj, NULL);

        }

      g_free (property->value);

      g_free (property->object);

      g_free (property->name);

      g_slice_free (DelayedProperty, property);

      g_type_class_unref (oclass);

    }

  g_slist_free (props);

}

void

_gtk_builder_finish (GtkBuilder *builder)

{

  gtk_builder_apply_delayed_properties (builder);

}

/**

 * gtk_builder_new:

 *

 * Creates a new builder object.

 *

 * Return value: a new #GtkBuilder object

 *

 * Since: 2.12

 **/

GtkBuilder *

gtk_builder_new (void)

{

  return g_object_new (GTK_TYPE_BUILDER, NULL);

}

/**

 * gtk_builder_add_from_file:

 * @builder: a #GtkBuilder

 * @filename: the name of the file to parse

 * @error: (allow-none): return location for an error, or %NULL

 *

 * Parses a file containing a <link linkend="BUILDER-UI">GtkBuilder 

 * UI definition</link> and merges it with the current contents of @builder. 

 * 

 * Upon errors 0 will be returned and @error will be assigned a

 * #GError from the #GTK_BUILDER_ERROR, #G_MARKUP_ERROR or #G_FILE_ERROR 

 * domain.

 *

 * Returns: A positive value on success, 0 if an error occurred

 *

 * Since: 2.12

 **/

guint

gtk_builder_add_from_file (GtkBuilder   *builder,

                           const gchar  *filename,

                           GError      **error)

{

  gchar *buffer;

  gsize length;

  GError *tmp_error;

  g_return_val_if_fail (GTK_IS_BUILDER (builder), 0);

  g_return_val_if_fail (filename != NULL, 0);

  g_return_val_if_fail (error == NULL || *error == NULL, 0);

  tmp_error = NULL;

  if (!g_file_get_contents (filename, &buffer, &length, &tmp_error))

    {

      g_propagate_error (error, tmp_error);

      return 0;

    }

  g_free (builder->priv->filename);

  builder->priv->filename = g_strdup (filename);

  _gtk_builder_parser_parse_buffer (builder, filename,

                                    buffer, length,

                                    NULL,

                                    &tmp_error);

  g_free (buffer);

  if (tmp_error != NULL)

    {

      g_propagate_error (error, tmp_error);

      return 0;

    }

  return 1;

}

/**

 * gtk_builder_add_objects_from_file:

 * @builder: a #GtkBuilder

 * @filename: the name of the file to parse

 * @object_ids: nul-terminated array of objects to build

 * @error: (allow-none): return location for an error, or %NULL

 *

 * Parses a file containing a <link linkend="BUILDER-UI">GtkBuilder 

 * UI definition</link> building only the requested objects and merges

 * them with the current contents of @builder. 

 *

 * Upon errors 0 will be returned and @error will be assigned a

 * #GError from the #GTK_BUILDER_ERROR, #G_MARKUP_ERROR or #G_FILE_ERROR 

 * domain.

 *

 * <note><para>

 * If you are adding an object that depends on an object that is not 

 * its child (for instance a #GtkTreeView that depends on its

 * #GtkTreeModel), you have to explicitely list all of them in @object_ids. 

 * </para></note>

 *

 * Returns: A positive value on success, 0 if an error occurred

 *

 * Since: 2.14

 **/

guint

gtk_builder_add_objects_from_file (GtkBuilder   *builder,

                                   const gchar  *filename,

                                   gchar       **object_ids,

                                   GError      **error)

{

  gchar *buffer;

  gsize length;

  GError *tmp_error;

  g_return_val_if_fail (GTK_IS_BUILDER (builder), 0);

  g_return_val_if_fail (filename != NULL, 0);

  g_return_val_if_fail (object_ids != NULL && object_ids[0] != NULL, 0);

  g_return_val_if_fail (error == NULL || *error == NULL, 0);

  tmp_error = NULL;

  if (!g_file_get_contents (filename, &buffer, &length, &tmp_error))

    {

      g_propagate_error (error, tmp_error);

      return 0;

    }

  g_free (builder->priv->filename);

  builder->priv->filename = g_strdup (filename);

  _gtk_builder_parser_parse_buffer (builder, filename,

                                    buffer, length,

                                    object_ids,

                                    &tmp_error);

  g_free (buffer);

  if (tmp_error != NULL)

    {

      g_propagate_error (error, tmp_error);

      return 0;

    }

  return 1;

}

/**

 * gtk_builder_add_from_string:

 * @builder: a #GtkBuilder

 * @buffer: the string to parse

 * @length: the length of @buffer (may be -1 if @buffer is nul-terminated)

 * @error: (allow-none): return location for an error, or %NULL

 *

 * Parses a string containing a <link linkend="BUILDER-UI">GtkBuilder 

 * UI definition</link> and merges it with the current contents of @builder. 

 *

 * Upon errors 0 will be returned and @error will be assigned a

 * #GError from the #GTK_BUILDER_ERROR or #G_MARKUP_ERROR domain.

 *

 * Returns: A positive value on success, 0 if an error occurred

 *

 * Since: 2.12

 **/

guint

gtk_builder_add_from_string (GtkBuilder   *builder,

                             const gchar  *buffer,

                             gsize         length,

                             GError      **error)

{

  GError *tmp_error;

  g_return_val_if_fail (GTK_IS_BUILDER (builder), 0);

  g_return_val_if_fail (buffer != NULL, 0);

  g_return_val_if_fail (error == NULL || *error == NULL, 0);

  tmp_error = NULL;

  g_free (builder->priv->filename);

  builder->priv->filename = g_strdup (".");

  _gtk_builder_parser_parse_buffer (builder, "<input>",

                                    buffer, length,

                                    NULL,

                                    &tmp_error);

  if (tmp_error != NULL)

    {

      g_propagate_error (error, tmp_error);

      return 0;

    }

  return 1;

}

/**

 * gtk_builder_add_objects_from_string:

 * @builder: a #GtkBuilder

 * @buffer: the string to parse

 * @length: the length of @buffer (may be -1 if @buffer is nul-terminated)

 * @object_ids: nul-terminated array of objects to build

 * @error: (allow-none): return location for an error, or %NULL

 *

 * Parses a string containing a <link linkend="BUILDER-UI">GtkBuilder 

 * UI definition</link> building only the requested objects and merges

 * them with the current contents of @builder. 

 *

 * Upon errors 0 will be returned and @error will be assigned a

 * #GError from the #GTK_BUILDER_ERROR or #G_MARKUP_ERROR domain.

 * 

 * <note><para>

 * If you are adding an object that depends on an object that is not 

 * its child (for instance a #GtkTreeView that depends on its

 * #GtkTreeModel), you have to explicitely list all of them in @object_ids. 

 * </para></note>

 *

 * Returns: A positive value on success, 0 if an error occurred

 *

 * Since: 2.14

 **/

guint

gtk_builder_add_objects_from_string (GtkBuilder   *builder,

                                     const gchar  *buffer,

                                     gsize         length,

                                     gchar       **object_ids,

                                     GError      **error)

{

  GError *tmp_error;

  g_return_val_if_fail (GTK_IS_BUILDER (builder), 0);

  g_return_val_if_fail (buffer != NULL, 0);

  g_return_val_if_fail (object_ids != NULL && object_ids[0] != NULL, 0);

  g_return_val_if_fail (error == NULL || *error == NULL, 0);

  tmp_error = NULL;

  g_free (builder->priv->filename);

  builder->priv->filename = g_strdup (".");

  _gtk_builder_parser_parse_buffer (builder, "<input>",

                                    buffer, length,

                                    object_ids,

                                    &tmp_error);

  if (tmp_error != NULL)

    {

      g_propagate_error (error, tmp_error);

      return 0;

    }

  return 1;

}

/**

 * gtk_builder_get_object:

 * @builder: a #GtkBuilder

 * @name: name of object to get

 *

 * Gets the object named @name. Note that this function does not

 * increment the reference count of the returned object. 

 *

 * Return value: (transfer none): the object named @name or %NULL if

 *    it could not be found in the object tree.

 *

 * Since: 2.12

 **/

GObject *

gtk_builder_get_object (GtkBuilder  *builder,