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

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

 * Portions copyright (c) 2006 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.

 */

#include	"gobject.h"

#include	"gobjectalias.h"

#ifndef __SYMBIAN32__

#include        <glib/gdatasetprivate.h>

#else

#include <gdatasetprivate.h>

#endif /* __SYMBIAN32__ */

/*

 * MT safe with regards to reference counting.

 */

 #ifdef __SYMBIAN32__

#include <glib_global.h>

#include <gobject_wsd.h>

#include <gobject_global.h>

#endif /* __SYMBIAN32__ */

#include	"gvaluecollector.h"

#include	"gsignal.h"

#include	"gparamspecs.h"

#include	"gvaluetypes.h"

#include	"gobjectnotifyqueue.c"

#include	<string.h>

#ifndef __SYMBIAN32__

#include	<signal.h>

#endif /* __SYMBIAN32__ */

#define	PREALLOC_CPARAMS	(8)

/* --- 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(construct_objects_lock,gobject,GStaticMutex)

PLS(construct_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__construct_objects_lock_lock (*FUNCTION_NAME_MACRO(construct_objects_lock,gobject)())

#define construct_objects (*FUNCTION_NAME(construct_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, };

G_LOCK_DEFINE_STATIC (construct_objects_lock);

static GSList *construct_objects = NULL;

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

#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;

  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 GTypeFundamentalInfo finfo = {

    G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE,

  };

  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_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);

}

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);

}

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);

}

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;

}

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);

}

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);

}

EXPORT_C GParamSpec** /* free result */

g_object_class_list_properties (GObjectClass *class,

				guint        *n_properties_p)

{