/* GTK - The GIMP Toolkit

 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald

 *

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

 * modify it under the terms of the GNU Lesser 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

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser 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.

 */

/*

 * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS

 * file for a list of people on the GTK+ Team.  See the ChangeLog

 * files for a list of changes.  These files are distributed with

 * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 

 */

#include "config.h"

#include <stdarg.h>

#include <string.h>

#include <stdlib.h>

#include "gtkcontainer.h"

#include "gtkbuildable.h"

#include "gtkbuilderprivate.h"

#include "gtkprivate.h"

#include "gtkmain.h"

#include "gtkmarshalers.h"

#include "gtkwindow.h"

#include "gtkintl.h"

#include "gtktoolbar.h"

#include <gobject/gobjectnotifyqueue.c>

#include <gobject/gvaluecollector.h>

#include "gtkalias.h"

enum {

  ADD,

  REMOVE,

  CHECK_RESIZE,

  SET_FOCUS_CHILD,

  LAST_SIGNAL

};

enum {

  PROP_0,

  PROP_BORDER_WIDTH,

  PROP_RESIZE_MODE,

  PROP_CHILD

};

#define PARAM_SPEC_PARAM_ID(pspec)              ((pspec)->param_id)

#define PARAM_SPEC_SET_PARAM_ID(pspec, id)      ((pspec)->param_id = (id))

/* --- prototypes --- */

static void     gtk_container_base_class_init      (GtkContainerClass *klass);

static void     gtk_container_base_class_finalize  (GtkContainerClass *klass);

static void     gtk_container_class_init           (GtkContainerClass *klass);

static void     gtk_container_init                 (GtkContainer      *container);

static void     gtk_container_destroy              (GtkObject         *object);

static void     gtk_container_set_property         (GObject         *object,

						    guint            prop_id,

						    const GValue    *value,

						    GParamSpec      *pspec);

static void     gtk_container_get_property         (GObject         *object,

						    guint            prop_id,

						    GValue          *value,

						    GParamSpec      *pspec);

static void     gtk_container_add_unimplemented    (GtkContainer      *container,

						    GtkWidget         *widget);

static void     gtk_container_remove_unimplemented (GtkContainer      *container,

						    GtkWidget         *widget);

static void     gtk_container_real_check_resize    (GtkContainer      *container);

static gboolean gtk_container_focus                (GtkWidget         *widget,

						    GtkDirectionType   direction);

static void     gtk_container_real_set_focus_child (GtkContainer      *container,

						    GtkWidget         *widget);

static gboolean gtk_container_focus_move           (GtkContainer      *container,

						    GList             *children,

						    GtkDirectionType   direction);

static void     gtk_container_children_callback    (GtkWidget         *widget,

						    gpointer           client_data);

static void     gtk_container_show_all             (GtkWidget         *widget);

static void     gtk_container_hide_all             (GtkWidget         *widget);

static gint     gtk_container_expose               (GtkWidget         *widget,

						    GdkEventExpose    *event);

static void     gtk_container_map                  (GtkWidget         *widget);

static void     gtk_container_unmap                (GtkWidget         *widget);

static gchar* gtk_container_child_default_composite_name (GtkContainer *container,

							  GtkWidget    *child);

/* GtkBuildable */

static void gtk_container_buildable_init           (GtkBuildableIface *iface);

static void gtk_container_buildable_add_child      (GtkBuildable *buildable,

						    GtkBuilder   *builder,

						    GObject      *child,

						    const gchar  *type);

static gboolean gtk_container_buildable_custom_tag_start (GtkBuildable  *buildable,

							  GtkBuilder    *builder,

							  GObject       *child,

							  const gchar   *tagname,

							  GMarkupParser *parser,

							  gpointer      *data);

static void    gtk_container_buildable_custom_tag_end (GtkBuildable *buildable,

						       GtkBuilder   *builder,

						       GObject      *child,

						       const gchar  *tagname,

						       gpointer     *data);

/* --- variables --- */

static const gchar           vadjustment_key[] = "gtk-vadjustment";

static guint                 vadjustment_key_id = 0;

static const gchar           hadjustment_key[] = "gtk-hadjustment";

static guint                 hadjustment_key_id = 0;

static GSList	            *container_resize_queue = NULL;

static guint                 container_signals[LAST_SIGNAL] = { 0 };

static GtkWidgetClass       *parent_class = NULL;

extern GParamSpecPool       *_gtk_widget_child_property_pool;

extern GObjectNotifyContext *_gtk_widget_child_property_notify_context;

static GtkBuildableIface    *parent_buildable_iface;

/* --- functions --- */

GType

gtk_container_get_type (void)

{

  static GType container_type = 0;

  if (!container_type)

    {

      const GTypeInfo container_info =

      {

	sizeof (GtkContainerClass),

	(GBaseInitFunc) gtk_container_base_class_init,

	(GBaseFinalizeFunc) gtk_container_base_class_finalize,

	(GClassInitFunc) gtk_container_class_init,

	NULL        /* class_finalize */,

	NULL        /* class_data */,

	sizeof (GtkContainer),

	0           /* n_preallocs */,

	(GInstanceInitFunc) gtk_container_init,

	NULL,       /* value_table */

      };

      const GInterfaceInfo buildable_info =

      {

	(GInterfaceInitFunc) gtk_container_buildable_init,

	NULL,

	NULL

      };

      container_type =

	g_type_register_static (GTK_TYPE_WIDGET, I_("GtkContainer"), 

				&container_info, G_TYPE_FLAG_ABSTRACT);

      g_type_add_interface_static (container_type,

				   GTK_TYPE_BUILDABLE,

				   &buildable_info);

    }

  return container_type;

}

static void

gtk_container_base_class_init (GtkContainerClass *class)

{

  /* reset instance specifc class fields that don't get inherited */

  class->set_child_property = NULL;

  class->get_child_property = NULL;

}

static void

gtk_container_base_class_finalize (GtkContainerClass *class)

{

  GList *list, *node;

  list = g_param_spec_pool_list_owned (_gtk_widget_child_property_pool, G_OBJECT_CLASS_TYPE (class));

  for (node = list; node; node = node->next)

    {

      GParamSpec *pspec = node->data;

      g_param_spec_pool_remove (_gtk_widget_child_property_pool, pspec);

      PARAM_SPEC_SET_PARAM_ID (pspec, 0);

      g_param_spec_unref (pspec);

    }

  g_list_free (list);

}

static void

gtk_container_class_init (GtkContainerClass *class)

{

  GObjectClass *gobject_class = G_OBJECT_CLASS (class);

  GtkObjectClass *object_class = GTK_OBJECT_CLASS (class);

  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);

  parent_class = g_type_class_peek_parent (class);

  vadjustment_key_id = g_quark_from_static_string (vadjustment_key);

  hadjustment_key_id = g_quark_from_static_string (hadjustment_key);

  gobject_class->set_property = gtk_container_set_property;

  gobject_class->get_property = gtk_container_get_property;

  object_class->destroy = gtk_container_destroy;

  widget_class->show_all = gtk_container_show_all;

  widget_class->hide_all = gtk_container_hide_all;

  widget_class->expose_event = gtk_container_expose;

  widget_class->map = gtk_container_map;

  widget_class->unmap = gtk_container_unmap;

  widget_class->focus = gtk_container_focus;

  class->add = gtk_container_add_unimplemented;

  class->remove = gtk_container_remove_unimplemented;

  class->check_resize = gtk_container_real_check_resize;

  class->forall = NULL;

  class->set_focus_child = gtk_container_real_set_focus_child;

  class->child_type = NULL;

  class->composite_name = gtk_container_child_default_composite_name;

  g_object_class_install_property (gobject_class,

                                   PROP_RESIZE_MODE,

                                   g_param_spec_enum ("resize-mode",

                                                      P_("Resize mode"),

                                                      P_("Specify how resize events are handled"),

                                                      GTK_TYPE_RESIZE_MODE,

                                                      GTK_RESIZE_PARENT,

                                                      GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

                                   PROP_BORDER_WIDTH,

                                   g_param_spec_uint ("border-width",

                                                      P_("Border width"),

                                                      P_("The width of the empty border outside the containers children"),

						      0,

						      65535,

						      0,

                                                      GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

                                   PROP_CHILD,

                                   g_param_spec_object ("child",

                                                      P_("Child"),

                                                      P_("Can be used to add a new child to the container"),

                                                      GTK_TYPE_WIDGET,

						      GTK_PARAM_WRITABLE));

  container_signals[ADD] =

    g_signal_new (I_("add"),

		  G_OBJECT_CLASS_TYPE (object_class),

		  G_SIGNAL_RUN_FIRST,

		  G_STRUCT_OFFSET (GtkContainerClass, add),

		  NULL, NULL,

		  _gtk_marshal_VOID__OBJECT,

		  G_TYPE_NONE, 1,

		  GTK_TYPE_WIDGET);

  container_signals[REMOVE] =

    g_signal_new (I_("remove"),

		  G_OBJECT_CLASS_TYPE (object_class),

		  G_SIGNAL_RUN_FIRST,

		  G_STRUCT_OFFSET (GtkContainerClass, remove),

		  NULL, NULL,

		  _gtk_marshal_VOID__OBJECT,

		  G_TYPE_NONE, 1,

		  GTK_TYPE_WIDGET);

  container_signals[CHECK_RESIZE] =

    g_signal_new (I_("check-resize"),

		  G_OBJECT_CLASS_TYPE (object_class),

		  G_SIGNAL_RUN_LAST,

		  G_STRUCT_OFFSET (GtkContainerClass, check_resize),

		  NULL, NULL,

		  _gtk_marshal_VOID__VOID,

		  G_TYPE_NONE, 0);

  container_signals[SET_FOCUS_CHILD] =

    g_signal_new (I_("set-focus-child"),

		  G_OBJECT_CLASS_TYPE (object_class),

		  G_SIGNAL_RUN_FIRST,

		  G_STRUCT_OFFSET (GtkContainerClass, set_focus_child),

		  NULL, NULL,

		  _gtk_marshal_VOID__OBJECT,

		  G_TYPE_NONE, 1,

		  GTK_TYPE_WIDGET);

}

static void

gtk_container_buildable_init (GtkBuildableIface *iface)

{

  parent_buildable_iface = g_type_interface_peek_parent (iface);

  iface->add_child = gtk_container_buildable_add_child;

  iface->custom_tag_start = gtk_container_buildable_custom_tag_start;

  iface->custom_tag_end = gtk_container_buildable_custom_tag_end;

}

static void

gtk_container_buildable_add_child (GtkBuildable  *buildable,

				   GtkBuilder    *builder,

				   GObject       *child,

				   const gchar   *type)

{

  if (type)

    {

      GTK_BUILDER_WARN_INVALID_CHILD_TYPE (buildable, type);

    }

  else if (GTK_IS_WIDGET (child) && GTK_WIDGET (child)->parent == NULL)

    {

      gtk_container_add (GTK_CONTAINER (buildable), GTK_WIDGET (child));

    }

  else

    g_warning ("Cannot add an object of type %s to a container of type %s", 

	       g_type_name (G_OBJECT_TYPE (child)), g_type_name (G_OBJECT_TYPE (buildable)));

}

static void

gtk_container_buildable_set_child_property (GtkContainer *container,

					    GtkBuilder   *builder,

					    GtkWidget    *child,

					    gchar        *name,

					    const gchar  *value)

{

  GParamSpec *pspec;

  GValue gvalue = { 0, };

  GError *error = NULL;

  pspec = gtk_container_class_find_child_property

    (G_OBJECT_GET_CLASS (container), name);

  if (!pspec)

    {

      g_warning ("%s does not have a property called %s",

		 g_type_name (G_OBJECT_TYPE (container)), name);

      return;

    }

  if (!gtk_builder_value_from_string (builder, pspec, value, &gvalue, &error))

    {

      g_warning ("Could not read property %s:%s with value %s of type %s: %s",

		 g_type_name (G_OBJECT_TYPE (container)),

		 name,

		 value,

		 g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)),

		 error->message);

      g_error_free (error);

      return;

    }

  gtk_container_child_set_property (container, child, name, &gvalue);

  g_value_unset (&gvalue);

}

typedef struct {

  GtkBuilder   *builder;

  GtkContainer *container;

  GtkWidget    *child;

  gchar        *child_prop_name;

  gchar        *context;

  gboolean     translatable;

} PackingPropertiesData;

static void

attributes_start_element (GMarkupParseContext *context,

			  const gchar         *element_name,

			  const gchar        **names,

			  const gchar        **values,

			  gpointer             user_data,

			  GError             **error)

{

  PackingPropertiesData *parser_data = (PackingPropertiesData*)user_data;

  guint i;

  if (strcmp (element_name, "property") == 0)

    {

      for (i = 0; names[i]; i++)

	if (strcmp (names[i], "name") == 0)

	  parser_data->child_prop_name = g_strdup (values[i]);

	else if (strcmp (names[i], "translatable") == 0)

	  {

	    if (!_gtk_builder_boolean_from_string (values[1],

						   &parser_data->translatable,

						   error))

	      return;

	  }

	else if (strcmp (names[i], "comments") == 0)

	  ; /* for translators */

	else if (strcmp (names[i], "context") == 0)

	  parser_data->context = g_strdup (values[1]);

	else

	  g_warning ("Unsupported attribute for GtkContainer Child "

		     "property: %s\n", names[i]);

    }

  else if (strcmp (element_name, "packing") == 0)

    return;

  else

    g_warning ("Unsupported tag for GtkContainer: %s\n", element_name);

}

static void

attributes_text_element (GMarkupParseContext *context,

			 const gchar         *text,

			 gsize                text_len,

			 gpointer             user_data,

			 GError             **error)

{

  PackingPropertiesData *parser_data = (PackingPropertiesData*)user_data;

  gchar* value;

  if (!parser_data->child_prop_name)

    return;

  if (parser_data->translatable && text_len)

    {

      const gchar* domain;

      domain = gtk_builder_get_translation_domain (parser_data->builder);

      value = _gtk_builder_parser_translate (domain,

					     parser_data->context,

					     text);

    }

  else

    {

      value = g_strdup (text);

    }

  gtk_container_buildable_set_child_property (parser_data->container,

					      parser_data->builder,

					      parser_data->child,

					      parser_data->child_prop_name,

					      value);

  g_free (parser_data->child_prop_name);

  g_free (parser_data->context);

  g_free (value);

  parser_data->child_prop_name = NULL;

  parser_data->context = NULL;

  parser_data->translatable = FALSE;

}

static const GMarkupParser attributes_parser =

  {

    attributes_start_element,

    NULL,

    attributes_text_element,

  };

static gboolean

gtk_container_buildable_custom_tag_start (GtkBuildable  *buildable,

					  GtkBuilder    *builder,

					  GObject       *child,

					  const gchar   *tagname,

					  GMarkupParser *parser,

					  gpointer      *data)

{

  PackingPropertiesData *parser_data;

  if (parent_buildable_iface->custom_tag_start (buildable, builder, child,

						tagname, parser, data))

    return TRUE;

  if (child && strcmp (tagname, "packing") == 0)

    {

      parser_data = g_slice_new0 (PackingPropertiesData);

      parser_data->builder = builder;

      parser_data->container = GTK_CONTAINER (buildable);

      parser_data->child = GTK_WIDGET (child);

      parser_data->child_prop_name = NULL;

      *parser = attributes_parser;

      *data = parser_data;

      return TRUE;

    }

  return FALSE;

}

static void

gtk_container_buildable_custom_tag_end (GtkBuildable *buildable,

					GtkBuilder   *builder,

					GObject      *child,

					const gchar  *tagname,

					gpointer     *data)

{

  if (strcmp (tagname, "packing") == 0)

    {

      g_slice_free (PackingPropertiesData, (gpointer)data);

      return;

    }

  if (parent_buildable_iface->custom_tag_end)

    parent_buildable_iface->custom_tag_end (buildable, builder,

					    child, tagname, data);

}

/**

 * gtk_container_child_type: 

 * @container: a #GtkContainer

 *

 * Returns the type of the children supported by the container.

 *

 * Note that this may return %G_TYPE_NONE to indicate that no more

 * children can be added, e.g. for a #GtkPaned which already has two 

 * children.

 *

 * Return value: a #GType.

 **/

GType

gtk_container_child_type (GtkContainer *container)

{

  GType slot;

  GtkContainerClass *class;

  g_return_val_if_fail (GTK_IS_CONTAINER (container), 0);

  class = GTK_CONTAINER_GET_CLASS (container);

  if (class->child_type)

    slot = class->child_type (container);

  else

    slot = G_TYPE_NONE;

  return slot;

}

/* --- GtkContainer child property mechanism --- */

static inline void

container_get_child_property (GtkContainer *container,

			      GtkWidget    *child,

			      GParamSpec   *pspec,

			      GValue       *value)

{

  GtkContainerClass *class = g_type_class_peek (pspec->owner_type);

  class->get_child_property (container, child, PARAM_SPEC_PARAM_ID (pspec), value, pspec);

}

static inline void

container_set_child_property (GtkContainer       *container,

			      GtkWidget		 *child,

			      GParamSpec         *pspec,

			      const GValue       *value,

			      GObjectNotifyQueue *nqueue)

{

  GValue tmp_value = { 0, };

  GtkContainerClass *class = g_type_class_peek (pspec->owner_type);

  /* provide a copy to work from, convert (if necessary) and validate */

  g_value_init (&tmp_value, G_PARAM_SPEC_VALUE_TYPE (pspec));

  if (!g_value_transform (value, &tmp_value))

    g_warning ("unable to set child property `%s' of type `%s' from value of type `%s'",

	       pspec->name,

	       g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)),

	       G_VALUE_TYPE_NAME (value));

  else if (g_param_value_validate (pspec, &tmp_value) && !(pspec->flags & G_PARAM_LAX_VALIDATION))

    {

      gchar *contents = g_strdup_value_contents (value);

      g_warning ("value \"%s\" of type `%s' is invalid for property `%s' of type `%s'",

		 contents,

		 G_VALUE_TYPE_NAME (value),

		 pspec->name,

		 g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)));

      g_free (contents);

    }

  else

    {

      class->set_child_property (container, child, PARAM_SPEC_PARAM_ID (pspec), &tmp_value, pspec);

      g_object_notify_queue_add (G_OBJECT (child), nqueue, pspec);

    }

  g_value_unset (&tmp_value);

}

/**

 * gtk_container_child_get_valist:

 * @container: a #GtkContainer

 * @child: a widget which is a child of @container

 * @first_property_name: the name of the first property to get

 * @var_args: return location for the first property, followed 

 *     optionally by more name/return location pairs, followed by %NULL

 * 

 * Gets the values of one or more child properties for @child and @container.

 **/

void

gtk_container_child_get_valist (GtkContainer *container,

				GtkWidget    *child,

				const gchar  *first_property_name,

				va_list       var_args)

{

  const gchar *name;

  g_return_if_fail (GTK_IS_CONTAINER (container));

  g_return_if_fail (GTK_IS_WIDGET (child));

  g_return_if_fail (child->parent == GTK_WIDGET (container));

  g_object_ref (container);

  g_object_ref (child);

  name = first_property_name;

  while (name)

    {

      GValue value = { 0, };

      GParamSpec *pspec;

      gchar *error;

      pspec = g_param_spec_pool_lookup (_gtk_widget_child_property_pool,

					name,

					G_OBJECT_TYPE (container),

					TRUE);

      if (!pspec)

	{

	  g_warning ("%s: container class `%s' has no child property named `%s'",

		     G_STRLOC,

		     G_OBJECT_TYPE_NAME (container),

		     name);

	  break;

	}

      if (!(pspec->flags & G_PARAM_READABLE))

	{

	  g_warning ("%s: child property `%s' of container class `%s' is not readable",

		     G_STRLOC,

		     pspec->name,

		     G_OBJECT_TYPE_NAME (container));

	  break;

	}

      g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));

      container_get_child_property (container, child, pspec, &value);

      G_VALUE_LCOPY (&value, var_args, 0, &error);

      if (error)

	{

	  g_warning ("%s: %s", G_STRLOC, error);

	  g_free (error);

	  g_value_unset (&value);

	  break;

	}

      g_value_unset (&value);

      name = va_arg (var_args, gchar*);

    }

  g_object_unref (child);

  g_object_unref (container);

}

/**

 * gtk_container_child_get_property:

 * @container: a #GtkContainer

 * @child: a widget which is a child of @container

 * @property_name: the name of the property to get

 * @value: a location to return the value

 * 

 * Gets the value of a child property for @child and @container.

 **/

void

gtk_container_child_get_property (GtkContainer *container,

				  GtkWidget    *child,

				  const gchar  *property_name,

				  GValue       *value)

{

  GParamSpec *pspec;

  g_return_if_fail (GTK_IS_CONTAINER (container));

  g_return_if_fail (GTK_IS_WIDGET (child));

  g_return_if_fail (child->parent == GTK_WIDGET (container));

  g_return_if_fail (property_name != NULL);

  g_return_if_fail (G_IS_VALUE (value));

  g_object_ref (container);

  g_object_ref (child);

  pspec = g_param_spec_pool_lookup (_gtk_widget_child_property_pool, property_name,

				    G_OBJECT_TYPE (container), TRUE);

  if (!pspec)

    g_warning ("%s: container class `%s' has no child property named `%s'",

	       G_STRLOC,

	       G_OBJECT_TYPE_NAME (container),

	       property_name);

  else if (!(pspec->flags & G_PARAM_READABLE))

    g_warning ("%s: child property `%s' of container class `%s' is not readable",

	       G_STRLOC,

	       pspec->name,

	       G_OBJECT_TYPE_NAME (container));

  else

    {

      GValue *prop_value, tmp_value = { 0, };

      /* auto-conversion of the callers value type

       */

      if (G_VALUE_TYPE (value) == G_PARAM_SPEC_VALUE_TYPE (pspec))

	{

	  g_value_reset (value);

	  prop_value = value;

	}

      else if (!g_value_type_transformable (G_PARAM_SPEC_VALUE_TYPE (pspec), G_VALUE_TYPE (value)))

	{

	  g_warning ("can't retrieve child property `%s' of type `%s' as value of type `%s'",

		     pspec->name,

		     g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)),

		     G_VALUE_TYPE_NAME (value));

	  g_object_unref (child);

	  g_object_unref (container);

	  return;

	}

      else

	{

	  g_value_init (&tmp_value, G_PARAM_SPEC_VALUE_TYPE (pspec));

	  prop_value = &tmp_value;

	}

      container_get_child_property (container, child, pspec, prop_value);

      if (prop_value != value)

	{

	  g_value_transform (prop_value, value);

	  g_value_unset (&tmp_value);

	}

    }

  g_object_unref (child);

  g_object_unref (container);

}

/**

 * gtk_container_child_set_valist:

 * @container: a #GtkContainer

 * @child: a widget which is a child of @container

 * @first_property_name: the name of the first property to set

 * @var_args: a %NULL-terminated list of property names and values, starting

 *           with @first_prop_name

 * 

 * Sets one or more child properties for @child and @container.

 **/

void

gtk_container_child_set_valist (GtkContainer *container,

				GtkWidget    *child,

				const gchar  *first_property_name,

				va_list       var_args)

{

  GObjectNotifyQueue *nqueue;

  const gchar *name;

  g_return_if_fail (GTK_IS_CONTAINER (container));

  g_return_if_fail (GTK_IS_WIDGET (child));

  g_return_if_fail (child->parent == GTK_WIDGET (container));

  g_object_ref (container);

  g_object_ref (child);

  nqueue = g_object_notify_queue_freeze (G_OBJECT (child), _gtk_widget_child_property_notify_context);

  name = first_property_name;

  while (name)

    {

      GValue value = { 0, };

      gchar *error = NULL;

      GParamSpec *pspec = g_param_spec_pool_lookup (_gtk_widget_child_property_pool,

						    name,

						    G_OBJECT_TYPE (container),

						    TRUE);

      if (!pspec)

	{

	  g_warning ("%s: container class `%s' has no child property named `%s'",

		     G_STRLOC,

		     G_OBJECT_TYPE_NAME (container),

		     name);

	  break;

	}

      if (!(pspec->flags & G_PARAM_WRITABLE))

	{

	  g_warning ("%s: child property `%s' of container class `%s' is not writable",

		     G_STRLOC,

		     pspec->name,

		     G_OBJECT_TYPE_NAME (container));

	  break;

	}

      g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));

      G_VALUE_COLLECT (&value, var_args, 0, &error);

      if (error)

	{

	  g_warning ("%s: %s", G_STRLOC, error);

	  g_free (error);

	  /* we purposely leak the value here, it might not be

	   * in a sane state if an error condition occoured

	   */

	  break;

	}

      container_set_child_property (container, child, pspec, &value, nqueue);

      g_value_unset (&value);

      name = va_arg (var_args, gchar*);

    }

  g_object_notify_queue_thaw (G_OBJECT (child), nqueue);

  g_object_unref (container);

  g_object_unref (child);

}

/**

 * gtk_container_child_set_property:

 * @container: a #GtkContainer

 * @child: a widget which is a child of @container

 * @property_name: the name of the property to set

 * @value: the value to set the property to

 * 

 * Sets a child property for @child and @container.

 **/

void

gtk_container_child_set_property (GtkContainer *container,

				  GtkWidget    *child,

				  const gchar  *property_name,

				  const GValue *value)

{

  GObjectNotifyQueue *nqueue;

  GParamSpec *pspec;

  g_return_if_fail (GTK_IS_CONTAINER (container));

  g_return_if_fail (GTK_IS_WIDGET (child));

  g_return_if_fail (child->parent == GTK_WIDGET (container));

  g_return_if_fail (property_name != NULL);

  g_return_if_fail (G_IS_VALUE (value));

  g_object_ref (container);

  g_object_ref (child);

  nqueue = g_object_notify_queue_freeze (G_OBJECT (child), _gtk_widget_child_property_notify_context);

  pspec = g_param_spec_pool_lookup (_gtk_widget_child_property_pool, property_name,

				    G_OBJECT_TYPE (container), TRUE);

  if (!pspec)

    g_warning ("%s: container class `%s' has no child property named `%s'",

	       G_STRLOC,

	       G_OBJECT_TYPE_NAME (container),

	       property_name);

  else if (!(pspec->flags & G_PARAM_WRITABLE))

    g_warning ("%s: child property `%s' of container class `%s' is not writable",

	       G_STRLOC,

	       pspec->name,

	       G_OBJECT_TYPE_NAME (container));

  else

    {

      container_set_child_property (container, child, pspec, value, nqueue);

    }

  g_object_notify_queue_thaw (G_OBJECT (child), nqueue);

  g_object_unref (container);

  g_object_unref (child);

}

/**

 * gtk_container_add_with_properties:

 * @container: a #GtkContainer 

 * @widget: a widget to be placed inside @container 

 * @first_prop_name: the name of the first child property to set 

 * @Varargs: a %NULL-terminated list of property names and values, starting

 *           with @first_prop_name

 * 

 * Adds @widget to @container, setting child properties at the same time.

 * See gtk_container_add() and gtk_container_child_set() for more details.

 **/

void

gtk_container_add_with_properties (GtkContainer *container,

				   GtkWidget    *widget,

				   const gchar  *first_prop_name,

				   ...)

{

  g_return_if_fail (GTK_IS_CONTAINER (container));

  g_return_if_fail (GTK_IS_WIDGET (widget));

  g_return_if_fail (widget->parent == NULL);

  g_object_ref (container);

  g_object_ref (widget);

  gtk_widget_freeze_child_notify (widget);

  g_signal_emit (container, container_signals[ADD], 0, widget);

  if (widget->parent)

    {

      va_list var_args;

      va_start (var_args, first_prop_name);

      gtk_container_child_set_valist (container, widget, first_prop_name, var_args);

      va_end (var_args);