GObjectClass

The class structure for the GObject type.

// Example of implementing a singleton using a constructor.
static MySingleton *the_singleton = NULL;

static GObject*
my_singleton_constructor (GType                  type,
                          guint                  n_construct_params,
                          GObjectConstructParam *construct_params)
{
  GObject *object;

  if (!the_singleton)
    {
      object = G_OBJECT_CLASS (parent_class)->constructor (type,
                                                           n_construct_params,
                                                           construct_params);
      the_singleton = MY_SINGLETON (object);
    }
  else
    object = g_object_ref (G_OBJECT (the_singleton));

  return object;
}

Members

Variables

constructProperties
GSList* constructProperties;
constructed
void function(ObjectC* object) constructed;

the @constructed function is called by gobject.object.ObjectG.new_ as the final step of the object creation process. At the point of the call, all construction properties have been set on the object. The purpose of this call is to allow for object initialisation steps that can only be performed after construction properties have been set. @constructed implementors should chain up to the @constructed call of their parent class to allow it to complete its initialisation.

constructor
ObjectC* function(GType type, uint nConstructProperties, GObjectConstructParam* constructProperties) constructor;

the @constructor function is called by g_object_new () to complete the object initialization after all the construction properties are set. The first thing a @constructor implementation must do is chain up to the @constructor of the parent class. Overriding @constructor should be rarely needed, e.g. to handle construct properties, or to implement singletons.

dispatchPropertiesChanged
void function(ObjectC* object, uint nPspecs, GParamSpec** pspecs) dispatchPropertiesChanged;

emits property change notification for a bunch of properties. Overriding @dispatch_properties_changed should be rarely needed.

dispose
void function(ObjectC* object) dispose;

the @dispose function is supposed to drop all references to other objects, but keep the instance otherwise intact, so that client method invocations still work. It may be run multiple times (due to reference loops). Before returning, @dispose should chain up to the @dispose method of the parent class.

finalize
void function(ObjectC* object) finalize;

instance finalization function, should finish the finalization of the instance begun in @dispose and chain up to the @finalize method of the parent class.

flags
size_t flags;
gTypeClass
GTypeClass gTypeClass;

the parent class

getProperty
void function(ObjectC* object, uint propertyId, GValue* value, GParamSpec* pspec) getProperty;

the generic getter for all properties of this type. Should be overridden for every type with properties.

nConstructProperties
size_t nConstructProperties;
nPspecs
size_t nPspecs;
notify
void function(ObjectC* object, GParamSpec* pspec) notify;

the class closure for the notify signal

pdummy
void*[3] pdummy;
pspecs
void* pspecs;
setProperty
void function(ObjectC* object, uint propertyId, const(GValue)* value, GParamSpec* pspec) setProperty;

the generic setter for all properties of this type. Should be overridden for every type with properties. If implementations of @set_property don't emit property change notification explicitly, this will be done implicitly by the type system. However, if the notify signal is emitted explicitly, the type system will not emit it a second time.