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

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

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

     4  *

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

     6  * modify it under the terms of the GNU Lesser General Public

     7  * License as published by the Free Software Foundation; either

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

     9  *

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

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

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

    13  * Lesser General Public License for more details.

    14  *

    15  * You should have received a copy of the GNU Lesser General

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

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

    18  * Boston, MA 02111-1307, USA.

    19  */

    20 #include	"gobject.h"

    21 #include	"gobjectalias.h"

    22 #ifndef __SYMBIAN32__

    23 #include        <glib/gdatasetprivate.h>

    24 #else

    25 #include <gdatasetprivate.h>

    26 #endif /* __SYMBIAN32__ */

    27 /*

    28  * MT safe with regards to reference counting.

    29  */

    30  #ifdef __SYMBIAN32__

    31 #include <glib_global.h>

    32 #include <gobject_wsd.h>

    33 #include <gobject_global.h>

    34 #endif /* __SYMBIAN32__ */

    35 

    36 #include	"gvaluecollector.h"

    37 #include	"gsignal.h"

    38 #include	"gparamspecs.h"

    39 #include	"gvaluetypes.h"

    40 #include	"gobjectnotifyqueue.c"

    41 #include	<string.h>

    42 #ifndef __SYMBIAN32__

    43 #include	<signal.h>

    44 #endif /* __SYMBIAN32__ */

    45 

    46 

    47 #define	PREALLOC_CPARAMS	(8)

    48 

    49 

    50 /* --- macros --- */

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

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

    53 

    54 #define OBJECT_HAS_TOGGLE_REF_FLAG 0x1

    55 #define OBJECT_HAS_TOGGLE_REF(object) \

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

    57 #define OBJECT_FLOATING_FLAG 0x2

    58 

    59 

    60 /* --- signals --- */

    61 enum {

    62   NOTIFY,

    63   LAST_SIGNAL

    64 };

    65 

    66 

    67 /* --- properties --- */

    68 enum {

    69   PROP_NONE

    70 };

    71 

    72 

    73 /* --- prototypes --- */

    74 static void	g_object_base_class_init		(GObjectClass	*class);

    75 static void	g_object_base_class_finalize		(GObjectClass	*class);

    76 static void	g_object_do_class_init			(GObjectClass	*class);

    77 static void	g_object_init				(GObject	*object);

    78 static GObject*	g_object_constructor			(GType                  type,

    79 							 guint                  n_construct_properties,

    80 							 GObjectConstructParam *construct_params);

    81 static void	g_object_real_dispose			(GObject	*object);

    82 static void	g_object_finalize			(GObject	*object);

    83 static void	g_object_do_set_property		(GObject        *object,

    84 							 guint           property_id,

    85 							 const GValue   *value,

    86 							 GParamSpec     *pspec);

    87 static void	g_object_do_get_property		(GObject        *object,

    88 							 guint           property_id,

    89 							 GValue         *value,

    90 							 GParamSpec     *pspec);

    91 static void	g_value_object_init			(GValue		*value);

    92 static void	g_value_object_free_value		(GValue		*value);

    93 static void	g_value_object_copy_value		(const GValue	*src_value,

    94 							 GValue		*dest_value);

    95 static void	g_value_object_transform_value		(const GValue	*src_value,

    96 							 GValue		*dest_value);

    97 static gpointer g_value_object_peek_pointer             (const GValue   *value);

    98 static gchar*	g_value_object_collect_value		(GValue		*value,

    99 							 guint           n_collect_values,

   100 							 GTypeCValue    *collect_values,

   101 							 guint           collect_flags);

   102 static gchar*	g_value_object_lcopy_value		(const GValue	*value,

   103 							 guint           n_collect_values,

   104 							 GTypeCValue    *collect_values,

   105 							 guint           collect_flags);

   106 static void	g_object_dispatch_properties_changed	(GObject	*object,

   107 							 guint		 n_pspecs,

   108 							 GParamSpec    **pspecs);

   109 static inline void         object_get_property		(GObject        *object,

   110 							 GParamSpec     *pspec,

   111 							 GValue         *value);

   112 static inline void	   object_set_property		(GObject        *object,

   113 							 GParamSpec     *pspec,

   114 							 const GValue   *value,

   115 							 GObjectNotifyQueue *nqueue);

   116 #if (EMULATOR)							 

   117 guint               object_floating_flag_handler (GObject        *object,

   118                                                          gint            job);

   119 #else

   120 static guint               object_floating_flag_handler (GObject        *object,

   121                                                          gint            job);

   122 #endif /* EMULATOR */

   123 static void object_interface_check_properties           (gpointer        func_data,

   124 							 gpointer        g_iface);

   125 

   126 

   127 /* --- variables --- */

   128 #if EMULATOR

   129 

   130 PLS(quark_closure_array,gobject,GQuark)

   131 PLS(quark_weak_refs,gobject,GQuark)

   132 PLS(quark_toggle_refs,gobject,GQuark)

   133 PLS(pspec_pool,gobject,GParamSpecPool *)

   134 PLS(property_notify_context,gobject,GObjectNotifyContext)

   135 PLS_ARRAY(gobject_signals,gobject,gulong)

   136 PLS_MACRO(construct_objects_lock,gobject,GStaticMutex)

   137 PLS(construct_objects,gobject,GSList *)

   138 PLS(floating_flag_handler,gobject,function_type)

   139 

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

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

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

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

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

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

   146 #define g__construct_objects_lock_lock (*FUNCTION_NAME_MACRO(construct_objects_lock,gobject)())

   147 #define construct_objects (*FUNCTION_NAME(construct_objects,gobject)())

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

   149 

   150 #else

   151 

   152 static GQuark	            quark_closure_array = 0;

   153 static GQuark	            quark_weak_refs = 0;

   154 static GQuark	            quark_toggle_refs = 0;

   155 static GParamSpecPool      *pspec_pool = NULL;

   156 static GObjectNotifyContext property_notify_context = { 0, };

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

   158 G_LOCK_DEFINE_STATIC (construct_objects_lock);

   159 static GSList *construct_objects = NULL;

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

   161 

   162 #endif /* EMULATOR */

   163 

   164 /* --- functions --- */

   165 #ifdef	G_ENABLE_DEBUG

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

   167 #if EMULATOR

   168 

   169 PLS_MACRO(debug_objects,gobject,GStaticMutex)

   170 PLS(g_trap_object_ref,gobject,volatile GObject *)

   171 PLS(debug_objects_count,gobject,guint)

   172 PLS(debug_objects_ht,gobject,GHashTable	*)

   173 

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

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

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

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

   178 

   179 

   180 #else

   181 

   182 G_LOCK_DEFINE_STATIC     (debug_objects);

   183 static volatile GObject *g_trap_object_ref = NULL;

   184 static guint		 debug_objects_count = 0;

   185 static GHashTable	*debug_objects_ht = NULL;

   186 #endif /* EMULATOR */

   187 static void

   188 debug_objects_foreach (gpointer key,

   189 		       gpointer value,

   190 		       gpointer user_data)

   191 {

   192   GObject *object = value;

   193 

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

   195 	     object,

   196 	     G_OBJECT_TYPE_NAME (object),

   197 	     object->ref_count);

   198 }

   199 static void

   200 debug_objects_atexit (void)

   201 {

   202   IF_DEBUG (OBJECTS)

   203     {

   204       G_LOCK (debug_objects);

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

   206       g_hash_table_foreach (debug_objects_ht, debug_objects_foreach, NULL);

   207       G_UNLOCK (debug_objects);

   208     }

   209 }

   210 #endif	/* G_ENABLE_DEBUG */

   211 

   212 #if EMULATOR

   213 

   214 PLS(initialized ,g_object_type_init,gboolean)

   215 PLS(info  ,g_object_type_init,GTypeInfo)

   216 

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

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

   219 

   220 const GTypeInfo gobject_info = {

   221 	sizeof (GObjectClass),

   222 	(GBaseInitFunc) g_object_base_class_init,

   223 	(GBaseFinalizeFunc) g_object_base_class_finalize,

   224 	(GClassInitFunc) g_object_do_class_init,

   225 	NULL	/* class_destroy */,

   226 	NULL	/* class_data */,

   227 	sizeof (GObject),

   228 	0		/* n_preallocs */,

   229 	(GInstanceInitFunc) g_object_init,

   230 	NULL,	/* value_table */

   231 };

   232 

   233 

   234 #endif /* EMULATOR */

   235 

   236 void

   237 g_object_type_init (void)

   238 {

   239   #if !(EMULATOR)

   240   static gboolean initialized = FALSE;

   241   static GTypeInfo info = {

   242     sizeof (GObjectClass),

   243     (GBaseInitFunc) g_object_base_class_init,

   244     (GBaseFinalizeFunc) g_object_base_class_finalize,

   245     (GClassInitFunc) g_object_do_class_init,

   246     NULL	/* class_destroy */,

   247     NULL	/* class_data */,

   248     sizeof (GObject),

   249     0		/* n_preallocs */,

   250     (GInstanceInitFunc) g_object_init,

   251     NULL,	/* value_table */

   252   };

   253   #endif /* EMULATOR */

   254   static const GTypeFundamentalInfo finfo = {

   255     G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE,

   256   };

   257 

   258   static const GTypeValueTable value_table = {

   259     g_value_object_init,	  /* value_init */

   260     g_value_object_free_value,	  /* value_free */

   261     g_value_object_copy_value,	  /* value_copy */

   262     g_value_object_peek_pointer,  /* value_peek_pointer */

   263     "p",			  /* collect_format */

   264     g_value_object_collect_value, /* collect_value */

   265     "p",			  /* lcopy_format */

   266     g_value_object_lcopy_value,	  /* lcopy_value */

   267   };

   268   GType type;

   269   

   270   g_return_if_fail (initialized == FALSE);

   271   initialized = TRUE;

   272   

   273   /* G_TYPE_OBJECT

   274    */

   275   info.value_table = &value_table;

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

   277   g_assert (type == G_TYPE_OBJECT);

   278   g_value_register_transform_func (G_TYPE_OBJECT, G_TYPE_OBJECT, g_value_object_transform_value);

   279   

   280 #ifdef	G_ENABLE_DEBUG

   281   IF_DEBUG (OBJECTS)

   282     {

   283       debug_objects_ht = g_hash_table_new (g_direct_hash, NULL);

   284       g_atexit (debug_objects_atexit);

   285     }

   286 #endif	/* G_ENABLE_DEBUG */

   287 }

   288 

   289 #if EMULATOR

   290 #undef initialized

   291 #undef info

   292 #endif /* EMULATOR */

   293 

   294 static void

   295 g_object_base_class_init (GObjectClass *class)

   296 {

   297   GObjectClass *pclass = g_type_class_peek_parent (class);

   298 

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

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

   301   class->get_property = NULL;

   302   class->set_property = NULL;

   303 }

   304 

   305 static void

   306 g_object_base_class_finalize (GObjectClass *class)

   307 {

   308   GList *list, *node;

   309   

   310   _g_signals_destroy (G_OBJECT_CLASS_TYPE (class));

   311 

   312   g_slist_free (class->construct_properties);

   313   class->construct_properties = NULL;

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

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

   316     {

   317       GParamSpec *pspec = node->data;

   318       

   319       g_param_spec_pool_remove (pspec_pool, pspec);

   320       PARAM_SPEC_SET_PARAM_ID (pspec, 0);

   321       g_param_spec_unref (pspec);

   322     }

   323   g_list_free (list);

   324 }

   325 

   326 static void

   327 g_object_notify_dispatcher (GObject     *object,

   328 			    guint        n_pspecs,

   329 			    GParamSpec **pspecs)

   330 {

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

   332 }

   333 

   334 static void

   335 g_object_do_class_init (GObjectClass *class)

   336 {

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

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

   339 

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

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

   342   pspec_pool = g_param_spec_pool_new (TRUE);

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

   344   property_notify_context.dispatcher = g_object_notify_dispatcher;

   345   

   346   class->constructor = g_object_constructor;

   347   class->set_property = g_object_do_set_property;

   348   class->get_property = g_object_do_get_property;

   349   class->dispose = g_object_real_dispose;

   350   class->finalize = g_object_finalize;

   351   class->dispatch_properties_changed = g_object_dispatch_properties_changed;

   352   class->notify = NULL;

   353 

   354   gobject_signals[NOTIFY] =

   355     g_signal_new (g_intern_static_string ("notify"),

   356 		  G_TYPE_FROM_CLASS (class),

   357 		  G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE | G_SIGNAL_DETAILED | G_SIGNAL_NO_HOOKS | G_SIGNAL_ACTION,

   358 		  G_STRUCT_OFFSET (GObjectClass, notify),

   359 		  NULL, NULL,

   360 		  g_cclosure_marshal_VOID__PARAM,

   361 		  G_TYPE_NONE,

   362 		  1, G_TYPE_PARAM);

   363 

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

   365    * implement an interface implement all properties for that interface

   366    */

   367   g_type_add_interface_check (NULL, object_interface_check_properties);

   368 }

   369 

   370 static void

   371 install_property_internal (GType       g_type,

   372 			   guint       property_id,

   373 			   GParamSpec *pspec)

   374 {

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

   376     {

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

   378 		 g_type_name (g_type),

   379 		 pspec->name);

   380       return;

   381     }

   382 

   383   g_param_spec_ref (pspec);

   384   g_param_spec_sink (pspec);

   385   PARAM_SPEC_SET_PARAM_ID (pspec, property_id);

   386   g_param_spec_pool_insert (pspec_pool, pspec, g_type);

   387 }

   388 

   389 EXPORT_C void

   390 g_object_class_install_property (GObjectClass *class,

   391 				 guint	       property_id,

   392 				 GParamSpec   *pspec)

   393 {

   394   g_return_if_fail (G_IS_OBJECT_CLASS (class));

   395   g_return_if_fail (G_IS_PARAM_SPEC (pspec));

   396   if (pspec->flags & G_PARAM_WRITABLE)

   397     g_return_if_fail (class->set_property != NULL);

   398   if (pspec->flags & G_PARAM_READABLE)

   399     g_return_if_fail (class->get_property != NULL);

   400   g_return_if_fail (property_id > 0);

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

   402   if (pspec->flags & G_PARAM_CONSTRUCT)

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

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

   405     g_return_if_fail (pspec->flags & G_PARAM_WRITABLE);

   406 

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

   408 

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

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

   411 

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

   413    * of the overidden inherited construct property

   414    */

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

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

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

   418 }

   419 

   420 EXPORT_C void

   421 g_object_interface_install_property (gpointer      g_iface,

   422 				     GParamSpec   *pspec)

   423 {

   424   GTypeInterface *iface_class = g_iface;

   425 	

   426   g_return_if_fail (G_TYPE_IS_INTERFACE (iface_class->g_type));

   427   g_return_if_fail (G_IS_PARAM_SPEC (pspec));

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

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

   430 		    

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

   432 }

   433 

   434 EXPORT_C GParamSpec*

   435 g_object_class_find_property (GObjectClass *class,

   436 			      const gchar  *property_name)

   437 {

   438   GParamSpec *pspec;

   439   GParamSpec *redirect;

   440 	

   441   g_return_val_if_fail (G_IS_OBJECT_CLASS (class), NULL);

   442   g_return_val_if_fail (property_name != NULL, NULL);

   443   

   444   pspec = g_param_spec_pool_lookup (pspec_pool,

   445 				    property_name,

   446 				    G_OBJECT_CLASS_TYPE (class),

   447 				    TRUE);

   448   if (pspec)

   449     {

   450       redirect = g_param_spec_get_redirect_target (pspec);

   451       if (redirect)

   452 	return redirect;

   453       else

   454 	return pspec;

   455     }

   456   else

   457     return NULL;

   458 }

   459 

   460 EXPORT_C GParamSpec*

   461 g_object_interface_find_property (gpointer      g_iface,

   462 				  const gchar  *property_name)

   463 {

   464   GTypeInterface *iface_class = g_iface;

   465 	

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

   467   g_return_val_if_fail (property_name != NULL, NULL);

   468   

   469   return g_param_spec_pool_lookup (pspec_pool,

   470 				   property_name,

   471 				   iface_class->g_type,

   472 				   FALSE);

   473 }

   474 

   475 EXPORT_C void

   476 g_object_class_override_property (GObjectClass *oclass,

   477 				  guint         property_id,

   478 				  const gchar  *name)

   479 {

   480   GParamSpec *overridden = NULL;

   481   GParamSpec *new;

   482   GType parent_type;

   483   

   484   g_return_if_fail (G_IS_OBJECT_CLASS (oclass));

   485   g_return_if_fail (property_id > 0);

   486   g_return_if_fail (name != NULL);

   487 

   488   /* Find the overridden property; first check parent types

   489    */

   490   parent_type = g_type_parent (G_OBJECT_CLASS_TYPE (oclass));

   491   if (parent_type != G_TYPE_NONE)

   492     overridden = g_param_spec_pool_lookup (pspec_pool,

   493 					   name,

   494 					   parent_type,

   495 					   TRUE);

   496   if (!overridden)

   497     {

   498       GType *ifaces;

   499       guint n_ifaces;

   500       

   501       /* Now check interfaces

   502        */

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

   504       while (n_ifaces-- && !overridden)

   505 	{

   506 	  overridden = g_param_spec_pool_lookup (pspec_pool,

   507 						 name,

   508 						 ifaces[n_ifaces],

   509 						 FALSE);

   510 	}

   511       

   512       g_free (ifaces);

   513     }

   514 

   515   if (!overridden)

   516     {

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

   518 		 G_STRFUNC, G_OBJECT_CLASS_NAME (oclass), name);

   519       return;

   520     }

   521 

   522   new = g_param_spec_override (name, overridden);

   523   g_object_class_install_property (oclass, property_id, new);

   524 }

   525 

   526 EXPORT_C GParamSpec** /* free result */

   527 g_object_class_list_properties (GObjectClass *class,

   528 				guint        *n_properties_p)

   529 {

   530   GParamSpec **pspecs;

   531   guint n;

   532 

   533   g_return_val_if_fail (G_IS_OBJECT_CLASS (class), NULL);

   534 

   535   pspecs = g_param_spec_pool_list (pspec_pool,

   536 				   G_OBJECT_CLASS_TYPE (class),

   537 				   &n);

   538   if (n_properties_p)

   539     *n_properties_p = n;

   540 

   541   return pspecs;

   542 }

   543 

   544 EXPORT_C GParamSpec** /* free result */

   545 g_object_interface_list_properties (gpointer      g_iface,

   546 				    guint        *n_properties_p)

   547 {

   548   GTypeInterface *iface_class = g_iface;

   549   GParamSpec **pspecs;

   550   guint n;

   551 

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

   553 

   554   pspecs = g_param_spec_pool_list (pspec_pool,

   555 				   iface_class->g_type,

   556 				   &n);

   557   if (n_properties_p)

   558     *n_properties_p = n;

   559 

   560   return pspecs;

   561 }

   562 

   563 static void

   564 g_object_init (GObject *object)

   565 {

   566   object->ref_count = 1;

   567   g_datalist_init (&object->qdata);

   568   

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

   570   g_object_notify_queue_freeze (object, &property_notify_context);

   571 

   572   /* allow construct-only properties to be set */

   573   G_LOCK (construct_objects_lock);

   574   construct_objects = g_slist_prepend (construct_objects, object);

   575   G_UNLOCK (construct_objects_lock);

   576   

   577 #ifdef	G_ENABLE_DEBUG

   578   IF_DEBUG (OBJECTS)

   579     {

   580       G_LOCK (debug_objects);

   581       debug_objects_count++;

   582       g_hash_table_insert (debug_objects_ht, object, object);

   583       G_UNLOCK (debug_objects);

   584     }

   585 #endif	/* G_ENABLE_DEBUG */

   586 }

   587 

   588 static void

   589 g_object_do_set_property (GObject      *object,

   590 			  guint         property_id,

   591 			  const GValue *value,

   592 			  GParamSpec   *pspec)

   593 {

   594   switch (property_id)

   595     {

   596     default:

   597       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

   598       break;

   599     }

   600 }

   601 

   602 static void

   603 g_object_do_get_property (GObject     *object,

   604 			  guint        property_id,

   605 			  GValue      *value,

   606 			  GParamSpec  *pspec)

   607 {

   608   switch (property_id)

   609     {

   610     default:

   611       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

   612       break;

   613     }

   614 }

   615 

   616 static void

   617 g_object_real_dispose (GObject *object)

   618 {

   619   g_signal_handlers_destroy (object);

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

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

   622 }

   623 

   624 static void

   625 g_object_finalize (GObject *object)

   626 {

   627   g_datalist_clear (&object->qdata);

   628   

   629 #ifdef	G_ENABLE_DEBUG

   630   IF_DEBUG (OBJECTS)

   631     {

   632       G_LOCK (debug_objects);

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

   634       g_hash_table_remove (debug_objects_ht, object);

   635       debug_objects_count--;

   636       G_UNLOCK (debug_objects);

   637     }

   638 #endif	/* G_ENABLE_DEBUG */

   639 }

   640 

   641 

   642 static void

   643 g_object_dispatch_properties_changed (GObject     *object,

   644 				      guint        n_pspecs,

   645 				      GParamSpec **pspecs)

   646 {

   647   guint i;

   648 

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

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

   651 }

   652 

   653 EXPORT_C void

   654 g_object_run_dispose (GObject *object)

   655 {

   656   g_return_if_fail (G_IS_OBJECT (object));

   657   g_return_if_fail (object->ref_count > 0);

   658 

   659   g_object_ref (object);

   660   G_OBJECT_GET_CLASS (object)->dispose (object);

   661   g_object_unref (object);

   662 }

   663 

   664 EXPORT_C void

   665 g_object_freeze_notify (GObject *object)

   666 {

   667   g_return_if_fail (G_IS_OBJECT (object));

   668 

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

   670     return;

   671 

   672   g_object_ref (object);

   673   g_object_notify_queue_freeze (object, &property_notify_context);

   674   g_object_unref (object);

   675 }

   676 

   677 EXPORT_C void

   678 g_object_notify (GObject     *object,

   679 		 const gchar *property_name)

   680 {

   681   GParamSpec *pspec;

   682   

   683   g_return_if_fail (G_IS_OBJECT (object));

   684   g_return_if_fail (property_name != NULL);

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

   686     return;

   687   

   688   g_object_ref (object);

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

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

   691    * because g_object_notify_queue_add() does that

   692    */

   693   pspec = g_param_spec_pool_lookup (pspec_pool,

   694 				    property_name,

   695 				    G_OBJECT_TYPE (object),

   696 				    TRUE);

   697 

   698   if (!pspec)

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

   700 	       G_STRFUNC,

   701 	       G_OBJECT_TYPE_NAME (object),

   702 	       property_name);

   703   else

   704     {

   705       GObjectNotifyQueue *nqueue;

   706       

   707       nqueue = g_object_notify_queue_freeze (object, &property_notify_context);

   708       g_object_notify_queue_add (object, nqueue, pspec);

   709       g_object_notify_queue_thaw (object, nqueue);

   710     }

   711   g_object_unref (object);

   712 }

   713 

   714 EXPORT_C void

   715 g_object_thaw_notify (GObject *object)

   716 {

   717   GObjectNotifyQueue *nqueue;

   718   

   719   g_return_if_fail (G_IS_OBJECT (object));

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

   721     return;

   722   

   723   g_object_ref (object);

   724   nqueue = g_object_notify_queue_from_object (object, &property_notify_context);

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

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

   727 	       G_STRFUNC, G_OBJECT_TYPE_NAME (object), object);

   728   else

   729     g_object_notify_queue_thaw (object, nqueue);

   730   g_object_unref (object);

   731 }

   732 

   733 static inline void

   734 object_get_property (GObject     *object,

   735 		     GParamSpec  *pspec,

   736 		     GValue      *value)

   737 {

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

   739   guint param_id = PARAM_SPEC_PARAM_ID (pspec);

   740   GParamSpec *redirect;

   741 

   742   redirect = g_param_spec_get_redirect_target (pspec);

   743   if (redirect)

   744     pspec = redirect;    

   745   

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

   747 }

   748 

   749 static inline void

   750 object_set_property (GObject             *object,

   751 		     GParamSpec          *pspec,

   752 		     const GValue        *value,

   753 		     GObjectNotifyQueue  *nqueue)

   754 {

   755   GValue tmp_value = { 0, };

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

   757   guint param_id = PARAM_SPEC_PARAM_ID (pspec);

   758   GParamSpec *redirect;

   759 

   760   redirect = g_param_spec_get_redirect_target (pspec);

   761   if (redirect)

   762     pspec = redirect;

   763 

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

   765   g_value_init (&tmp_value, G_PARAM_SPEC_VALUE_TYPE (pspec));

   766   if (!g_value_transform (value, &tmp_value))

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

   768 	       pspec->name,

   769 	       g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)),

   770 	       G_VALUE_TYPE_NAME (value));

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

   772     {

   773       gchar *contents = g_strdup_value_contents (value);

   774 

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

   776 		 contents,

   777 		 G_VALUE_TYPE_NAME (value),

   778 		 pspec->name,

   779 		 g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)));

   780       g_free (contents);

   781     }

   782   else

   783     {

   784       class->set_property (object, param_id, &tmp_value, pspec);

   785       g_object_notify_queue_add (object, nqueue, pspec);

   786     }

   787   g_value_unset (&tmp_value);

   788 }

   789 

   790 static void

   791 object_interface_check_properties (gpointer func_data,

   792 				   gpointer g_iface)

   793 {

   794   GTypeInterface *iface_class = g_iface;

   795   GObjectClass *class = g_type_class_peek (iface_class->g_instance_type);

   796   GType iface_type = iface_class->g_type;

   797   GParamSpec **pspecs;

   798   guint n;

   799 

   800   if (!G_IS_OBJECT_CLASS (class))

   801     return;

   802 

   803   pspecs = g_param_spec_pool_list (pspec_pool, iface_type, &n);

   804 

   805   while (n--)

   806     {

   807       GParamSpec *class_pspec = g_param_spec_pool_lookup (pspec_pool,

   808 							  pspecs[n]->name,

   809 							  G_OBJECT_CLASS_TYPE (class),

   810 							  TRUE);

   811       

   812       if (!class_pspec)

   813 	{

   814 	  g_critical ("Object class %s doesn't implement property "

   815 		      "'%s' from interface '%s'",

   816 		      g_type_name (G_OBJECT_CLASS_TYPE (class)),

   817 		      pspecs[n]->name,

   818 		      g_type_name (iface_type));

   819 

   820 	  continue;

   821 	}

   822 

   823       /* The implementation paramspec must have a less restrictive

   824        * type than the interface parameter spec for set() and a

   825        * more restrictive type for get(). We just require equality,

   826        * rather than doing something more complicated checking

   827        * the READABLE and WRITABLE flags. We also simplify here

   828        * by only checking the value type, not the G_PARAM_SPEC_TYPE.

   829        */

   830       if (class_pspec &&

   831 	  !g_type_is_a (G_PARAM_SPEC_VALUE_TYPE (pspecs[n]),

   832 			G_PARAM_SPEC_VALUE_TYPE (class_pspec)))

   833 	{

   834 	  g_critical ("Property '%s' on class '%s' has type '%s' "

   835 		      "which is different from the type '%s', "

   836 		      "of the property on interface '%s'\n",

   837 		      pspecs[n]->name,

   838 		      g_type_name (G_OBJECT_CLASS_TYPE (class)),

   839 		      g_type_name (G_PARAM_SPEC_VALUE_TYPE (class_pspec)),

   840 		      g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspecs[n])),

   841 		      g_type_name (iface_type));

   842 	}

   843       

   844 #define SUBSET(a,b,mask) (((a) & ~(b) & (mask)) == 0)

   845       

   846       /* CONSTRUCT and CONSTRUCT_ONLY add restrictions.

   847        * READABLE and WRITABLE remove restrictions. The implementation

   848        * paramspec must have less restrictive flags.

   849        */

   850       if (class_pspec &&

   851 	  (!SUBSET (class_pspec->flags,

   852 		    pspecs[n]->flags,

   853 		    G_PARAM_CONSTRUCT | G_PARAM_CONSTRUCT_ONLY) ||

   854 	   !SUBSET (pspecs[n]->flags,

   855 		    class_pspec->flags,

   856 		    G_PARAM_READABLE | G_PARAM_WRITABLE)))

   857 	{

   858 	  g_critical ("Flags for property '%s' on class '%s' "

   859 		      "are not compatible with the property on"

   860 		      "interface '%s'\n",

   861 		      pspecs[n]->name,

   862 		      g_type_name (G_OBJECT_CLASS_TYPE (class)),

   863 		      g_type_name (iface_type));

   864 	}

   865 #undef SUBSET	  

   866     }

   867   

   868   g_free (pspecs);

   869 }

   870 

   871 EXPORT_C gpointer

   872 g_object_new (GType	   object_type,

   873 	      const gchar *first_property_name,

   874 	      ...)

   875 {

   876   GObject *object;

   877   va_list var_args;

   878   

   879   g_return_val_if_fail (G_TYPE_IS_OBJECT (object_type), NULL);

   880   

   881   va_start (var_args, first_property_name);

   882   object = g_object_new_valist (object_type, first_property_name, var_args);

   883   va_end (var_args);

   884   

   885   return object;

   886 }

   887 

   888 static gboolean

   889 object_in_construction (GObject *object)

   890 {

   891   gboolean in_construction;

   892   G_LOCK (construct_objects_lock);

   893   in_construction = g_slist_find (construct_objects, object) != NULL;

   894   G_UNLOCK (construct_objects_lock);

   895   return in_construction;

   896 }

   897 

   898 EXPORT_C gpointer

   899 g_object_newv (GType       object_type,

   900 	       guint       n_parameters,

   901 	       GParameter *parameters)

   902 {

   903   GObjectConstructParam *cparams, *oparams;

   904   GObjectNotifyQueue *nqueue;

   905   GObject *object;

   906   GObjectClass *class, *unref_class = NULL;

   907   GSList *slist;

   908   guint n_total_cparams = 0, n_cparams = 0, n_oparams = 0, n_cvalues;

   909   GValue *cvalues;

   910   GList *clist = NULL;

   911   guint i;

   912 

   913   g_return_val_if_fail (G_TYPE_IS_OBJECT (object_type), NULL);

   914 

   915   class = g_type_class_peek_static (object_type);

   916   if (!class)

   917     class = unref_class = g_type_class_ref (object_type);

   918   for (slist = class->construct_properties; slist; slist = slist->next)

   919     {

   920       clist = g_list_prepend (clist, slist->data);

   921       n_total_cparams += 1;

   922     }

   923 

   924   /* collect parameters, sort into construction and normal ones */

   925   oparams = g_new (GObjectConstructParam, n_parameters);

   926   cparams = g_new (GObjectConstructParam, n_total_cparams);

   927   

   928   for (i = 0; i < n_parameters; i++)

   929     {

   930       GValue *value = &parameters[i].value;

   931       GParamSpec *pspec = g_param_spec_pool_lookup (pspec_pool,

   932 						    parameters[i].name,

   933 						    object_type,

   934 						    TRUE);

   935       if (!pspec)

   936 	{

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

   938 		     G_STRFUNC,

   939 		     g_type_name (object_type),

   940 		     parameters[i].name);

   941 	  continue;

   942 	}

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

   944 	{

   945 	  g_warning ("%s: property `%s' of object class `%s' is not writable",

   946 		     G_STRFUNC,

   947 		     pspec->name,

   948 		     g_type_name (object_type));

   949 	  continue;

   950 	}

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

   952 	{

   953 	  GList *list = g_list_find (clist, pspec);

   954 

   955 	  if (!list)

   956 	    {

   957 	      g_warning ("%s: construct property \"%s\" for object `%s' can't be set twice",

   958                          G_STRFUNC, pspec->name, g_type_name (object_type));

   959 	      continue;

   960 	    }

   961 	  cparams[n_cparams].pspec = pspec;

   962 	  cparams[n_cparams].value = value;

   963 	  n_cparams++;

   964 	  if (!list->prev)

   965 	    clist = list->next;

   966 	  else

   967 	    list->prev->next = list->next;

   968 	  if (list->next)

   969 	    list->next->prev = list->prev;

   970 	  g_list_free_1 (list);

   971 	}

   972       else

   973 	{

   974 	  oparams[n_oparams].pspec = pspec;

   975 	  oparams[n_oparams].value = value;

   976 	  n_oparams++;

   977 	}

   978     }

   979 

   980   /* set remaining construction properties to default values */

   981   n_cvalues = n_total_cparams - n_cparams;

   982   cvalues = g_new (GValue, n_cvalues);

   983   while (clist)

   984     {

   985       GList *tmp = clist->next;

   986       GParamSpec *pspec = clist->data;

   987       GValue *value = cvalues + n_total_cparams - n_cparams - 1;

   988 

   989       value->g_type = 0;

   990       g_value_init (value, G_PARAM_SPEC_VALUE_TYPE (pspec));

   991       g_param_value_set_default (pspec, value);

   992 

   993       cparams[n_cparams].pspec = pspec;

   994       cparams[n_cparams].value = value;

   995       n_cparams++;

   996 

   997       g_list_free_1 (clist);

   998       clist = tmp;

   999     }

  1000 

  1001   /* construct object from construction parameters */

  1002   object = class->constructor (object_type, n_total_cparams, cparams);

  1003   G_LOCK (construct_objects_lock);

  1004   construct_objects = g_slist_remove (construct_objects, object);

  1005   G_UNLOCK (construct_objects_lock);

  1006 

  1007   /* free construction values */

  1008   g_free (cparams);

  1009   while (n_cvalues--)

  1010     g_value_unset (cvalues + n_cvalues);

  1011   g_free (cvalues);

  1012   

  1013   /* release g_object_init() notification queue freeze_count */

  1014   nqueue = g_object_notify_queue_freeze (object, &property_notify_context);

  1015   g_object_notify_queue_thaw (object, nqueue);

  1016   

  1017   /* set remaining properties */

  1018   for (i = 0; i < n_oparams; i++)

  1019     object_set_property (object, oparams[i].pspec, oparams[i].value, nqueue);

  1020   g_free (oparams);

  1021 

  1022   if (unref_class)

  1023     g_type_class_unref (unref_class);

  1024 

  1025   /* release our own freeze count and handle notifications */

  1026   g_object_notify_queue_thaw (object, nqueue);

  1027   

  1028   return object;

  1029 }

  1030 

  1031 EXPORT_C GObject*

  1032 g_object_new_valist (GType	  object_type,

  1033 		     const gchar *first_property_name,

  1034 		     va_list	  var_args)

  1035 {

  1036   GObjectClass *class;

  1037   GParameter *params;

  1038   const gchar *name;

  1039   GObject *object;

  1040   guint n_params = 0, n_alloced_params = 16;

  1041   

  1042   g_return_val_if_fail (G_TYPE_IS_OBJECT (object_type), NULL);

  1043 

  1044   if (!first_property_name)

  1045     return g_object_newv (object_type, 0, NULL);

  1046 

  1047   class = g_type_class_ref (object_type);

  1048   params = g_new (GParameter, n_alloced_params);

  1049   name = first_property_name;

  1050   while (name)

  1051     {

  1052       gchar *error = NULL;

  1053       GParamSpec *pspec = g_param_spec_pool_lookup (pspec_pool,

  1054 						    name,

  1055 						    object_type,

  1056 						    TRUE);

  1057       if (!pspec)

  1058 	{

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

  1060 		     G_STRFUNC,

  1061 		     g_type_name (object_type),

  1062 		     name);

  1063 	  break;

  1064 	}

  1065       if (n_params >= n_alloced_params)

  1066 	{

  1067 	  n_alloced_params += 16;

  1068 	  params = g_renew (GParameter, params, n_alloced_params);

  1069 	}

  1070       params[n_params].name = name;

  1071       params[n_params].value.g_type = 0;

  1072       g_value_init (&params[n_params].value, G_PARAM_SPEC_VALUE_TYPE (pspec));

  1073       G_VALUE_COLLECT (&params[n_params].value, var_args, 0, &error);

  1074       if (error)

  1075 	{

  1076 	  g_warning ("%s: %s", G_STRFUNC, error);

  1077 	  g_free (error);

  1078           g_value_unset (&params[n_params].value);

  1079 	  break;

  1080 	}

  1081       n_params++;

  1082       name = va_arg (var_args, gchar*);

  1083     }

  1084 

  1085   object = g_object_newv (object_type, n_params, params);

  1086 

  1087   while (n_params--)

  1088     g_value_unset (&params[n_params].value);

  1089   g_free (params);

  1090 

  1091   g_type_class_unref (class);

  1092 

  1093   return object;

  1094 }

  1095 

  1096 static GObject*

  1097 g_object_constructor (GType                  type,

  1098 		      guint                  n_construct_properties,

  1099 		      GObjectConstructParam *construct_params)

  1100 {

  1101   GObject *object;

  1102 

  1103   /* create object */

  1104   object = (GObject*) g_type_create_instance (type);

  1105   

  1106   /* set construction parameters */

  1107   if (n_construct_properties)

  1108     {

  1109       GObjectNotifyQueue *nqueue = g_object_notify_queue_freeze (object, &property_notify_context);

  1110       

  1111       /* set construct properties */

  1112       while (n_construct_properties--)

  1113 	{

  1114 	  GValue *value = construct_params->value;

  1115 	  GParamSpec *pspec = construct_params->pspec;

  1116 

  1117 	  construct_params++;

  1118 	  object_set_property (object, pspec, value, nqueue);

  1119 	}

  1120       g_object_notify_queue_thaw (object, nqueue);

  1121       /* the notification queue is still frozen from g_object_init(), so

  1122        * we don't need to handle it here, g_object_newv() takes

  1123        * care of that

  1124        */

  1125     }

  1126 

  1127   return object;

  1128 }

  1129 

  1130 EXPORT_C void

  1131 g_object_set_valist (GObject	 *object,

  1132 		     const gchar *first_property_name,

  1133 		     va_list	  var_args)

  1134 {

  1135   GObjectNotifyQueue *nqueue;