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