/* GObject - GLib Type, Object, Parameter and Signal Library

 * Copyright (C) 1998-1999, 2000-2001 Tim Janik and Red Hat, Inc.

 * Portions copyright (c) 2006-2009 Nokia Corporation.  All rights reserved.

 *

 * 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.

 */

/*

 * MT safe with regards to reference counting.

 */

#include "config.h"

#include <string.h>

#include <signal.h>

#include "gdatasetprivate.h"

#include "gobject.h"

#include "gvaluecollector.h"

#include "gsignal.h"

#include "gparamspecs.h"

#include "gvaluetypes.h"

#include "gobjectalias.h"

 #ifdef __SYMBIAN32__

#include <glib_global.h>

#include "gobject_wsd.h"

#include <gobject_global.h>

#endif /* __SYMBIAN32__ */

/* This should be included after gobjectalias.h (or pltcheck.sh will fail) */

#include "gobjectnotifyqueue.c"

/**

 * SECTION:objects

 * @short_description: The base object type

 * @see_also: #GParamSpecObject, g_param_spec_object()

 * @title: The Base Object Type

 *

 * GObject is the fundamental type providing the common attributes and

 * methods for all object types in GTK+, Pango and other libraries

 * based on GObject.  The GObject class provides methods for object

 * construction and destruction, property access methods, and signal

 * support.  Signals are described in detail in <xref

 * linkend="gobject-Signals"/>.

 *

 * <para id="floating-ref">

 * #GInitiallyUnowned is derived from #GObject. The only difference between

 * the two is that the initial reference of a #GInitiallyUnowned is flagged

 * as a <firstterm>floating</firstterm> reference.

 * This means that it is not specifically claimed to be "owned" by

 * any code portion. The main motivation for providing floating references is

 * C convenience. In particular, it allows code to be written as:

 * |[

 * container = create_container();

 * container_add_child (container, create_child());

 * ]|

 * If <function>container_add_child()</function> will g_object_ref_sink() the

 * passed in child, no reference of the newly created child is leaked.

 * Without floating references, <function>container_add_child()</function>

 * can only g_object_ref() the new child, so to implement this code without

 * reference leaks, it would have to be written as:

 * |[

 * Child *child;

 * container = create_container();

 * child = create_child();

 * container_add_child (container, child);

 * g_object_unref (child);

 * ]|

 * The floating reference can be converted into

 * an ordinary reference by calling g_object_ref_sink().

 * For already sunken objects (objects that don't have a floating reference

 * anymore), g_object_ref_sink() is equivalent to g_object_ref() and returns

 * a new reference.

 * Since floating references are useful almost exclusively for C convenience,

 * language bindings that provide automated reference and memory ownership

 * maintenance (such as smart pointers or garbage collection) therefore don't

 * need to expose floating references in their API.

 * </para>

 *

 * Some object implementations may need to save an objects floating state

 * across certain code portions (an example is #GtkMenu), to achive this, the

 * following sequence can be used:

 *

 * |[

 * // save floating state

 * gboolean was_floating = g_object_is_floating (object);

 * g_object_ref_sink (object);

 * // protected code portion

 * ...;

 * // restore floating state

 * if (was_floating)

 *   g_object_force_floating (object);

 * g_obejct_unref (object); // release previously acquired reference

 * ]|

 */

/* --- macros --- */

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

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

#define OBJECT_HAS_TOGGLE_REF_FLAG 0x1

#define OBJECT_HAS_TOGGLE_REF(object) \

    ((G_DATALIST_GET_FLAGS (&(object)->qdata) & OBJECT_HAS_TOGGLE_REF_FLAG) != 0)

#define OBJECT_FLOATING_FLAG 0x2

/* --- signals --- */

enum {

  NOTIFY,

  LAST_SIGNAL

};

/* --- properties --- */

enum {

  PROP_NONE

};

/* --- prototypes --- */

static void	g_object_base_class_init		(GObjectClass	*class);

static void	g_object_base_class_finalize		(GObjectClass	*class);

static void	g_object_do_class_init			(GObjectClass	*class);

static void	g_object_init				(GObject	*object);

static GObject*	g_object_constructor			(GType                  type,

							 guint                  n_construct_properties,

							 GObjectConstructParam *construct_params);

static void	g_object_real_dispose			(GObject	*object);

static void	g_object_finalize			(GObject	*object);

static void	g_object_do_set_property		(GObject        *object,

							 guint           property_id,

							 const GValue   *value,

							 GParamSpec     *pspec);

static void	g_object_do_get_property		(GObject        *object,

							 guint           property_id,

							 GValue         *value,

							 GParamSpec     *pspec);

static void	g_value_object_init			(GValue		*value);

static void	g_value_object_free_value		(GValue		*value);

static void	g_value_object_copy_value		(const GValue	*src_value,

							 GValue		*dest_value);

static void	g_value_object_transform_value		(const GValue	*src_value,

							 GValue		*dest_value);

static gpointer g_value_object_peek_pointer             (const GValue   *value);

static gchar*	g_value_object_collect_value		(GValue		*value,

							 guint           n_collect_values,

							 GTypeCValue    *collect_values,

							 guint           collect_flags);

static gchar*	g_value_object_lcopy_value		(const GValue	*value,

							 guint           n_collect_values,

							 GTypeCValue    *collect_values,

							 guint           collect_flags);

static void	g_object_dispatch_properties_changed	(GObject	*object,

							 guint		 n_pspecs,

							 GParamSpec    **pspecs);

static inline void         object_get_property		(GObject        *object,

							 GParamSpec     *pspec,

							 GValue         *value);

static inline void	   object_set_property		(GObject        *object,

							 GParamSpec     *pspec,

							 const GValue   *value,

							 GObjectNotifyQueue *nqueue);

#if (EMULATOR)							 

guint               object_floating_flag_handler (GObject        *object,

                                                         gint            job);

#else

static guint               object_floating_flag_handler (GObject        *object,

                                                         gint            job);

#endif /* EMULATOR */

static void object_interface_check_properties           (gpointer        func_data,

							 gpointer        g_iface);

/* --- variables --- */

#if EMULATOR

PLS(quark_closure_array,gobject,GQuark)

PLS(quark_weak_refs,gobject,GQuark)

PLS(quark_toggle_refs,gobject,GQuark)

PLS(pspec_pool,gobject,GParamSpecPool *)

PLS(property_notify_context,gobject,GObjectNotifyContext)

PLS_ARRAY(gobject_signals,gobject,gulong)

PLS_MACRO(construction_mutex,gobject,GStaticMutex)

PLS(construction_objects,gobject,GSList *)

PLS(floating_flag_handler,gobject,function_type)

#define quark_closure_array (*FUNCTION_NAME(quark_closure_array,gobject)())

#define quark_weak_refs (*FUNCTION_NAME(quark_weak_refs,gobject)())

#define quark_toggle_refs (*FUNCTION_NAME(quark_toggle_refs,gobject)())

#define pspec_pool (*FUNCTION_NAME(pspec_pool,gobject)())

#define property_notify_context (*FUNCTION_NAME(property_notify_context,gobject)())

#define gobject_signals (FUNCTION_NAME(gobject_signals,gobject)())

#define g__construction_mutex_lock (*FUNCTION_NAME_MACRO(construction_mutex,gobject)())

#define construction_objects (*FUNCTION_NAME(construction_objects,gobject)())

#define floating_flag_handler (*FUNCTION_NAME(floating_flag_handler,gobject)())

#else

static GQuark	            quark_closure_array = 0;

static GQuark	            quark_weak_refs = 0;

static GQuark	            quark_toggle_refs = 0;

static GParamSpecPool      *pspec_pool = NULL;

static GObjectNotifyContext property_notify_context = { 0, };

static gulong	            gobject_signals[LAST_SIGNAL] = { 0, };

static guint (*floating_flag_handler) (GObject*, gint) = object_floating_flag_handler;

G_LOCK_DEFINE_STATIC (construction_mutex);

static GSList *construction_objects = NULL;

#endif /* EMULATOR */

/* --- functions --- */

#ifdef	G_ENABLE_DEBUG

#define	IF_DEBUG(debug_type)	if (_g_type_debug_flags & G_TYPE_DEBUG_ ## debug_type)

#if EMULATOR

PLS_MACRO(debug_objects,gobject,GStaticMutex)

PLS(g_trap_object_ref,gobject,volatile GObject *)

PLS(debug_objects_count,gobject,guint)

PLS(debug_objects_ht,gobject,GHashTable	*)

#define g__debug_objects_lock (*FUNCTION_NAME_MACRO(debug_objects,gobject)())

#define g_trap_object_ref (*FUNCTION_NAME(g_trap_object_ref,gobject)())

#define debug_objects_count (*FUNCTION_NAME(debug_objects_count,gobject)())

#define debug_objects_ht (*FUNCTION_NAME(debug_objects_ht,gobject)())

#else

G_LOCK_DEFINE_STATIC     (debug_objects);

static volatile GObject *g_trap_object_ref = NULL;

static guint		 debug_objects_count = 0;

static GHashTable	*debug_objects_ht = NULL;

#endif /* EMULATOR */

static void

debug_objects_foreach (gpointer key,

		       gpointer value,

		       gpointer user_data)

{

  GObject *object = value;

  g_message ("[%p] stale %s\tref_count=%u",

	     object,

	     G_OBJECT_TYPE_NAME (object),

	     object->ref_count);

}

static void

debug_objects_atexit (void)

{

  IF_DEBUG (OBJECTS)

    {

      G_LOCK (debug_objects);

      g_message ("stale GObjects: %u", debug_objects_count);

      g_hash_table_foreach (debug_objects_ht, debug_objects_foreach, NULL);

      G_UNLOCK (debug_objects);

    }

}

#endif	/* G_ENABLE_DEBUG */

#if EMULATOR

PLS(initialized ,g_object_type_init,gboolean)

PLS(info  ,g_object_type_init,GTypeInfo)

#define initialized  (*FUNCTION_NAME(initialized ,g_object_type_init)())

#define info  (*FUNCTION_NAME(info ,g_object_type_init)())

const GTypeInfo gobject_info = {

	sizeof (GObjectClass),

	(GBaseInitFunc) g_object_base_class_init,

	(GBaseFinalizeFunc) g_object_base_class_finalize,

	(GClassInitFunc) g_object_do_class_init,

	NULL	/* class_destroy */,

	NULL	/* class_data */,

	sizeof (GObject),

	0		/* n_preallocs */,

	(GInstanceInitFunc) g_object_init,

	NULL,	/* value_table */

};

#endif /* EMULATOR */

void

g_object_type_init (void)

{

  #if !(EMULATOR)

  static gboolean initialized = FALSE;

  #endif /* EMULATOR */

  static const GTypeFundamentalInfo finfo = {

    G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE,

  };

  #if !(EMULATOR)

  static GTypeInfo info = {

    sizeof (GObjectClass),

    (GBaseInitFunc) g_object_base_class_init,

    (GBaseFinalizeFunc) g_object_base_class_finalize,

    (GClassInitFunc) g_object_do_class_init,

    NULL	/* class_destroy */,

    NULL	/* class_data */,

    sizeof (GObject),

    0		/* n_preallocs */,

    (GInstanceInitFunc) g_object_init,

    NULL,	/* value_table */

  };

  #endif /* EMULATOR */

  static const GTypeValueTable value_table = {

    g_value_object_init,	  /* value_init */

    g_value_object_free_value,	  /* value_free */

    g_value_object_copy_value,	  /* value_copy */

    g_value_object_peek_pointer,  /* value_peek_pointer */

    "p",			  /* collect_format */

    g_value_object_collect_value, /* collect_value */

    "p",			  /* lcopy_format */

    g_value_object_lcopy_value,	  /* lcopy_value */

  };

  GType type;

  g_return_if_fail (initialized == FALSE);

  initialized = TRUE;

  /* G_TYPE_OBJECT

   */

  info.value_table = &value_table;

  type = g_type_register_fundamental (G_TYPE_OBJECT, g_intern_static_string ("GObject"), &info, &finfo, 0);

  g_assert (type == G_TYPE_OBJECT);

  g_value_register_transform_func (G_TYPE_OBJECT, G_TYPE_OBJECT, g_value_object_transform_value);

#ifdef	G_ENABLE_DEBUG

  IF_DEBUG (OBJECTS)

    {

      debug_objects_ht = g_hash_table_new (g_direct_hash, NULL);

      g_atexit (debug_objects_atexit);

    }

#endif	/* G_ENABLE_DEBUG */

}

#if EMULATOR

#undef initialized

#undef info

#endif /* EMULATOR */

static void

g_object_base_class_init (GObjectClass *class)

{

  GObjectClass *pclass = g_type_class_peek_parent (class);

  /* reset instance specific fields and methods that don't get inherited */

  class->construct_properties = pclass ? g_slist_copy (pclass->construct_properties) : NULL;

  class->get_property = NULL;

  class->set_property = NULL;

}

static void

g_object_base_class_finalize (GObjectClass *class)

{

  GList *list, *node;

  _g_signals_destroy (G_OBJECT_CLASS_TYPE (class));

  g_slist_free (class->construct_properties);

  class->construct_properties = NULL;

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

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

    {

      GParamSpec *pspec = node->data;

      g_param_spec_pool_remove (pspec_pool, pspec);

      PARAM_SPEC_SET_PARAM_ID (pspec, 0);

      g_param_spec_unref (pspec);

    }

  g_list_free (list);

}

static void

g_object_notify_dispatcher (GObject     *object,

			    guint        n_pspecs,

			    GParamSpec **pspecs)

{

  G_OBJECT_GET_CLASS (object)->dispatch_properties_changed (object, n_pspecs, pspecs);

}

static void

g_object_do_class_init (GObjectClass *class)

{

  /* read the comment about typedef struct CArray; on why not to change this quark */

  quark_closure_array = g_quark_from_static_string ("GObject-closure-array");

  quark_weak_refs = g_quark_from_static_string ("GObject-weak-references");

  quark_toggle_refs = g_quark_from_static_string ("GObject-toggle-references");

  pspec_pool = g_param_spec_pool_new (TRUE);

  property_notify_context.quark_notify_queue = g_quark_from_static_string ("GObject-notify-queue");

  property_notify_context.dispatcher = g_object_notify_dispatcher;

  class->constructor = g_object_constructor;

  class->set_property = g_object_do_set_property;

  class->get_property = g_object_do_get_property;

  class->dispose = g_object_real_dispose;

  class->finalize = g_object_finalize;

  class->dispatch_properties_changed = g_object_dispatch_properties_changed;

  class->notify = NULL;

  /**

   * GObject::notify:

   * @gobject: the object which received the signal.

   * @pspec: the #GParamSpec of the property which changed.

   *

   * The notify signal is emitted on an object when one of its

   * properties has been changed. Note that getting this signal

   * doesn't guarantee that the value of the property has actually

   * changed, it may also be emitted when the setter for the property

   * is called to reinstate the previous value.

   *

   * This signal is typically used to obtain change notification for a

   * single property, by specifying the property name as a detail in the

   * g_signal_connect() call, like this:

   * |[

   * g_signal_connect (text_view->buffer, "notify::paste-target-list",

   *                   G_CALLBACK (gtk_text_view_target_list_notify),

   *                   text_view)

   * ]|

   * It is important to note that you must use

   * <link linkend="canonical-parameter-name">canonical</link> parameter names as

   * detail strings for the notify signal.

   */

  gobject_signals[NOTIFY] =

    g_signal_new (g_intern_static_string ("notify"),

		  G_TYPE_FROM_CLASS (class),

		  G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE | G_SIGNAL_DETAILED | G_SIGNAL_NO_HOOKS | G_SIGNAL_ACTION,

		  G_STRUCT_OFFSET (GObjectClass, notify),

		  NULL, NULL,

		  g_cclosure_marshal_VOID__PARAM,

		  G_TYPE_NONE,

		  1, G_TYPE_PARAM);

  /* Install a check function that we'll use to verify that classes that

   * implement an interface implement all properties for that interface

   */

  g_type_add_interface_check (NULL, object_interface_check_properties);

}

static void

install_property_internal (GType       g_type,

			   guint       property_id,

			   GParamSpec *pspec)

{

  if (g_param_spec_pool_lookup (pspec_pool, pspec->name, g_type, FALSE))

    {

      g_warning ("When installing property: type `%s' already has a property named `%s'",

		 g_type_name (g_type),

		 pspec->name);

      return;

    }

  g_param_spec_ref (pspec);

  g_param_spec_sink (pspec);

  PARAM_SPEC_SET_PARAM_ID (pspec, property_id);

  g_param_spec_pool_insert (pspec_pool, pspec, g_type);

}

/**

 * g_object_class_install_property:

 * @oclass: a #GObjectClass

 * @property_id: the id for the new property

 * @pspec: the #GParamSpec for the new property

 *

 * Installs a new property. This is usually done in the class initializer.

 *

 * Note that it is possible to redefine a property in a derived class,

 * by installing a property with the same name. This can be useful at times,

 * e.g. to change the range of allowed values or the default value.

 */

EXPORT_C void

g_object_class_install_property (GObjectClass *class,

				 guint	       property_id,

				 GParamSpec   *pspec)

{

  g_return_if_fail (G_IS_OBJECT_CLASS (class));

  g_return_if_fail (G_IS_PARAM_SPEC (pspec));

  if (pspec->flags & G_PARAM_WRITABLE)

    g_return_if_fail (class->set_property != NULL);

  if (pspec->flags & G_PARAM_READABLE)

    g_return_if_fail (class->get_property != NULL);

  g_return_if_fail (property_id > 0);

  g_return_if_fail (PARAM_SPEC_PARAM_ID (pspec) == 0);	/* paranoid */

  if (pspec->flags & G_PARAM_CONSTRUCT)

    g_return_if_fail ((pspec->flags & G_PARAM_CONSTRUCT_ONLY) == 0);

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

    g_return_if_fail (pspec->flags & G_PARAM_WRITABLE);

  install_property_internal (G_OBJECT_CLASS_TYPE (class), property_id, pspec);

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

    class->construct_properties = g_slist_prepend (class->construct_properties, pspec);

  /* for property overrides of construct poperties, we have to get rid

   * of the overidden inherited construct property

   */

  pspec = g_param_spec_pool_lookup (pspec_pool, pspec->name, g_type_parent (G_OBJECT_CLASS_TYPE (class)), TRUE);

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

    class->construct_properties = g_slist_remove (class->construct_properties, pspec);

}

/**

 * g_object_interface_install_property:

 * @g_iface: any interface vtable for the interface, or the default

 *  vtable for the interface.

 * @pspec: the #GParamSpec for the new property

 *

 * Add a property to an interface; this is only useful for interfaces

 * that are added to GObject-derived types. Adding a property to an

 * interface forces all objects classes with that interface to have a

 * compatible property. The compatible property could be a newly

 * created #GParamSpec, but normally

 * g_object_class_override_property() will be used so that the object

 * class only needs to provide an implementation and inherits the

 * property description, default value, bounds, and so forth from the

 * interface property.

 *

 * This function is meant to be called from the interface's default

 * vtable initialization function (the @class_init member of

 * #GTypeInfo.) It must not be called after after @class_init has

 * been called for any object types implementing this interface.

 *

 * Since: 2.4

 */

EXPORT_C void

g_object_interface_install_property (gpointer      g_iface,

				     GParamSpec   *pspec)

{

  GTypeInterface *iface_class = g_iface;

  g_return_if_fail (G_TYPE_IS_INTERFACE (iface_class->g_type));

  g_return_if_fail (G_IS_PARAM_SPEC (pspec));

  g_return_if_fail (!G_IS_PARAM_SPEC_OVERRIDE (pspec)); /* paranoid */

  g_return_if_fail (PARAM_SPEC_PARAM_ID (pspec) == 0);	/* paranoid */

  install_property_internal (iface_class->g_type, 0, pspec);

}

/**

 * g_object_class_find_property:

 * @oclass: a #GObjectClass

 * @property_name: the name of the property to look up

 *

 * Looks up the #GParamSpec for a property of a class.

 *

 * Returns: the #GParamSpec for the property, or %NULL if the class

 *          doesn't have a property of that name

 */

EXPORT_C GParamSpec*

g_object_class_find_property (GObjectClass *class,

			      const gchar  *property_name)

{

  GParamSpec *pspec;

  GParamSpec *redirect;

  g_return_val_if_fail (G_IS_OBJECT_CLASS (class), NULL);

  g_return_val_if_fail (property_name != NULL, NULL);

  pspec = g_param_spec_pool_lookup (pspec_pool,

				    property_name,

				    G_OBJECT_CLASS_TYPE (class),

				    TRUE);

  if (pspec)

    {

      redirect = g_param_spec_get_redirect_target (pspec);

      if (redirect)

	return redirect;

      else

	return pspec;

    }

  else

    return NULL;

}

/**

 * g_object_interface_find_property:

 * @g_iface: any interface vtable for the interface, or the default

 *  vtable for the interface

 * @property_name: name of a property to lookup.

 *

 * Find the #GParamSpec with the given name for an

 * interface. Generally, the interface vtable passed in as @g_iface

 * will be the default vtable from g_type_default_interface_ref(), or,

 * if you know the interface has already been loaded,

 * g_type_default_interface_peek().

 *

 * Since: 2.4

 *

 * Returns: the #GParamSpec for the property of the interface with the

 *          name @property_name, or %NULL if no such property exists.

 */

EXPORT_C GParamSpec*

g_object_interface_find_property (gpointer      g_iface,

				  const gchar  *property_name)

{

  GTypeInterface *iface_class = g_iface;

  g_return_val_if_fail (G_TYPE_IS_INTERFACE (iface_class->g_type), NULL);

  g_return_val_if_fail (property_name != NULL, NULL);

  return g_param_spec_pool_lookup (pspec_pool,

				   property_name,

				   iface_class->g_type,

				   FALSE);

}

/**

 * g_object_class_override_property:

 * @oclass: a #GObjectClass

 * @property_id: the new property ID

 * @name: the name of a property registered in a parent class or

 *  in an interface of this class.

 *

 * Registers @property_id as referring to a property with the

 * name @name in a parent class or in an interface implemented

 * by @oclass. This allows this class to <firstterm>override</firstterm>

 * a property implementation in a parent class or to provide

 * the implementation of a property from an interface.

 *

 * <note>

 * Internally, overriding is implemented by creating a property of type

 * #GParamSpecOverride; generally operations that query the properties of

 * the object class, such as g_object_class_find_property() or

 * g_object_class_list_properties() will return the overridden

 * property. However, in one case, the @construct_properties argument of

 * the @constructor virtual function, the #GParamSpecOverride is passed

 * instead, so that the @param_id field of the #GParamSpec will be

 * correct.  For virtually all uses, this makes no difference. If you

 * need to get the overridden property, you can call

 * g_param_spec_get_redirect_target().

 * </note>

 *

 * Since: 2.4

 */

EXPORT_C void

g_object_class_override_property (GObjectClass *oclass,

				  guint         property_id,

				  const gchar  *name)

{

  GParamSpec *overridden = NULL;

  GParamSpec *new;

  GType parent_type;

  g_return_if_fail (G_IS_OBJECT_CLASS (oclass));

  g_return_if_fail (property_id > 0);

  g_return_if_fail (name != NULL);

  /* Find the overridden property; first check parent types

   */

  parent_type = g_type_parent (G_OBJECT_CLASS_TYPE (oclass));

  if (parent_type != G_TYPE_NONE)

    overridden = g_param_spec_pool_lookup (pspec_pool,

					   name,

					   parent_type,

					   TRUE);

  if (!overridden)

    {

      GType *ifaces;

      guint n_ifaces;

      /* Now check interfaces

       */

      ifaces = g_type_interfaces (G_OBJECT_CLASS_TYPE (oclass), &n_ifaces);

      while (n_ifaces-- && !overridden)

	{

	  overridden = g_param_spec_pool_lookup (pspec_pool,

						 name,

						 ifaces[n_ifaces],

						 FALSE);

	}

      g_free (ifaces);

    }

  if (!overridden)

    {

      g_warning ("%s: Can't find property to override for '%s::%s'",

		 G_STRFUNC, G_OBJECT_CLASS_NAME (oclass), name);

      return;

    }

  new = g_param_spec_override (name, overridden);

  g_object_class_install_property (oclass, property_id, new);

}

/**

 * g_object_class_list_properties:

 * @oclass: a #GObjectClass

 * @n_properties: return location for the length of the returned array

 *

 * Get an array of #GParamSpec* for all properties of a class.

 *

 * Returns: an array of #GParamSpec* which should be freed after use

 */

EXPORT_C GParamSpec** /* free result */

g_object_class_list_properties (GObjectClass *class,

				guint        *n_properties_p)

{

  GParamSpec **pspecs;

  guint n;

  g_return_val_if_fail (G_IS_OBJECT_CLASS (class), NULL);

  pspecs = g_param_spec_pool_list (pspec_pool,

				   G_OBJECT_CLASS_TYPE (class),

				   &n);

  if (n_properties_p)

    *n_properties_p = n;

  return pspecs;

}

/**

 * g_object_interface_list_properties:

 * @g_iface: any interface vtable for the interface, or the default

 *  vtable for the interface

 * @n_properties_p: location to store number of properties returned.

 *

 * Lists the properties of an interface.Generally, the interface

 * vtable passed in as @g_iface will be the default vtable from

 * g_type_default_interface_ref(), or, if you know the interface has

 * already been loaded, g_type_default_interface_peek().

 *

 * Since: 2.4

 *

 * Returns: a pointer to an array of pointers to #GParamSpec

 *          structures. The paramspecs are owned by GLib, but the

 *          array should be freed with g_free() when you are done with

 *          it.

 */

EXPORT_C GParamSpec** /* free result */

g_object_interface_list_properties (gpointer      g_iface,

				    guint        *n_properties_p)

{

  GTypeInterface *iface_class = g_iface;

  GParamSpec **pspecs;

  guint n;

  g_return_val_if_fail (G_TYPE_IS_INTERFACE (iface_class->g_type), NULL);

  pspecs = g_param_spec_pool_list (pspec_pool,

				   iface_class->g_type,

				   &n);

  if (n_properties_p)

    *n_properties_p = n;

  return pspecs;

}

static void

g_object_init (GObject *object)

{

  object->ref_count = 1;

  g_datalist_init (&object->qdata);

  /* freeze object's notification queue, g_object_newv() preserves pairedness */

  g_object_notify_queue_freeze (object, &property_notify_context);

  /* enter construction list for notify_queue_thaw() and to allow construct-only properties */

  G_LOCK (construction_mutex);

  construction_objects = g_slist_prepend (construction_objects, object);

  G_UNLOCK (construction_mutex);

#ifdef	G_ENABLE_DEBUG

  IF_DEBUG (OBJECTS)

    {

      G_LOCK (debug_objects);

      debug_objects_count++;

      g_hash_table_insert (debug_objects_ht, object, object);

      G_UNLOCK (debug_objects);

    }

#endif	/* G_ENABLE_DEBUG */

}

static void

g_object_do_set_property (GObject      *object,

			  guint         property_id,

			  const GValue *value,

			  GParamSpec   *pspec)

{

  switch (property_id)

    {

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

      break;

    }

}

static void

g_object_do_get_property (GObject     *object,

			  guint        property_id,

			  GValue      *value,

			  GParamSpec  *pspec)

{

  switch (property_id)

    {

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

      break;

    }

}

static void

g_object_real_dispose (GObject *object)

{

  g_signal_handlers_destroy (object);

  g_datalist_id_set_data (&object->qdata, quark_closure_array, NULL);

  g_datalist_id_set_data (&object->qdata, quark_weak_refs, NULL);

}

static void

g_object_finalize (GObject *object)

{

  g_datalist_clear (&object->qdata);

#ifdef	G_ENABLE_DEBUG

  IF_DEBUG (OBJECTS)

    {

      G_LOCK (debug_objects);

      g_assert (g_hash_table_lookup (debug_objects_ht, object) == object);

      g_hash_table_remove (debug_objects_ht, object);

      debug_objects_count--;

      G_UNLOCK (debug_objects);

    }

#endif	/* G_ENABLE_DEBUG */

}

static void

g_object_dispatch_properties_changed (GObject     *object,

				      guint        n_pspecs,

				      GParamSpec **pspecs)

{

  guint i;

  for (i = 0; i < n_pspecs; i++)

    g_signal_emit (object, gobject_signals[NOTIFY], g_quark_from_string (pspecs[i]->name), pspecs[i]);

}

/**

 * g_object_run_dispose:

 * @object: a #GObject

 *

 * Releases all references to other objects. This can be used to break

 * reference cycles.

 *

 * This functions should only be called from object system implementations.

 */

EXPORT_C void

g_object_run_dispose (GObject *object)

{

  g_return_if_fail (G_IS_OBJECT (object));

  g_return_if_fail (object->ref_count > 0);

  g_object_ref (object);

  G_OBJECT_GET_CLASS (object)->dispose (object);

  g_object_unref (object);

}

/**

 * g_object_freeze_notify:

 * @object: a #GObject

 *

 * Increases the freeze count on @object. If the freeze count is

 * non-zero, the emission of "notify" signals on @object is

 * stopped. The signals are queued until the freeze count is decreased

 * to zero.

 *

 * This is necessary for accessors that modify multiple properties to prevent

 * premature notification while the object is still being modified.

 */

EXPORT_C void

g_object_freeze_notify (GObject *object)

{

  g_return_if_fail (G_IS_OBJECT (object));

  if (g_atomic_int_get (&object->ref_count) == 0)

    return;

  g_object_ref (object);

  g_object_notify_queue_freeze (object, &property_notify_context);

  g_object_unref (object);

}

/**

 * g_object_notify:

 * @object: a #GObject

 * @property_name: the name of a property installed on the class of @object.

 *

 * Emits a "notify" signal for the property @property_name on @object.

 */

EXPORT_C void

g_object_notify (GObject     *object,

		 const gchar *property_name)

{

  GParamSpec *pspec;

  g_return_if_fail (G_IS_OBJECT (object));

  g_return_if_fail (property_name != NULL);

  if (g_atomic_int_get (&object->ref_count) == 0)

    return;

  g_object_ref (object);

  /* We don't need to get the redirect target

   * (by, e.g. calling g_object_class_find_property())

   * because g_object_notify_queue_add() does that

   */

  pspec = g_param_spec_pool_lookup (pspec_pool,

				    property_name,

				    G_OBJECT_TYPE (object),

				    TRUE);

  if (!pspec)

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

	       G_STRFUNC,

	       G_OBJECT_TYPE_NAME (object),

	       property_name);

  else

    {

      GObjectNotifyQueue *nqueue;

      nqueue = g_object_notify_queue_freeze (object, &property_notify_context);

      g_object_notify_queue_add (object, nqueue, pspec);

      g_object_notify_queue_thaw (object, nqueue);

    }

  g_object_unref (object);

}

/**

 * g_object_thaw_notify:

 * @object: a #GObject

 *

 * Reverts the effect of a previous call to

 * g_object_freeze_notify(). The freeze count is decreased on @object

 * and when it reaches zero, all queued "notify" signals are emitted.

 *

 * It is an error to call this function when the freeze count is zero.

 */

EXPORT_C void

g_object_thaw_notify (GObject *object)

{

  GObjectNotifyQueue *nqueue;

  g_return_if_fail (G_IS_OBJECT (object));

  if (g_atomic_int_get (&object->ref_count) == 0)

    return;

  g_object_ref (object);

  nqueue = g_object_notify_queue_from_object (object, &property_notify_context);

  if (!nqueue || !nqueue->freeze_count)

    g_warning ("%s: property-changed notification for %s(%p) is not frozen",

	       G_STRFUNC, G_OBJECT_TYPE_NAME (object), object);

  else

    g_object_notify_queue_thaw (object, nqueue);

  g_object_unref (object);

}

static inline void

object_get_property (GObject     *object,

		     GParamSpec  *pspec,

		     GValue      *value)

{

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

  guint param_id = PARAM_SPEC_PARAM_ID (pspec);

  GParamSpec *redirect;

  redirect = g_param_spec_get_redirect_target (pspec);

  if (redirect)

    pspec = redirect;    

  class->get_property (object, param_id, value, pspec);

}

static inline void

object_set_property (GObject             *object,

		     GParamSpec          *pspec,

		     const GValue        *value,