### Class

# GObject InitiallyUnowned

#### Description [src]

    class GObject.InitiallyUnowned : GObject.Object
    {
      /* No available fields */
    }

A type for objects that have an initially floating reference.

All the fields in the `GInitiallyUnowned` structure are private to the implementation and should never be accessed directly.

#### Hierarchy

#### Ancestors

- GObject

#### Instance methods

##### Methods inherited from GObject (43)

Please see GObject for a full list of methods.

#### Signals

##### Signals inherited from GObject (1)

###### GObject::notify

The notify signal is emitted on an object when one of its properties has its value set through g_object_set_property(), g_object_set(), et al.

#### Class structure

    struct GObjectInitiallyUnownedClass {
      GTypeClass g_type_class;
      GObject* (* constructor) (
        GType type,
        guint n_construct_properties,
        GObjectConstructParam* construct_properties
      );
      void (* set_property) (
        GObject* object,
        guint property_id,
        const GValue* value,
        GParamSpec* pspec
      );
      void (* get_property) (
        GObject* object,
        guint property_id,
        GValue* value,
        GParamSpec* pspec
      );
      void (* dispose) (
        GObject* object
      );
      void (* finalize) (
        GObject* object
      );
      void (* dispatch_properties_changed) (
        GObject* object,
        guint n_pspecs,
        GParamSpec** pspecs
      );
      void (* notify) (
        GObject* object,
        GParamSpec* pspec
      );
      void (* constructed) (
        GObject* object
      );

    }

The class structure for the GInitiallyUnowned type.

###### Class members

`g_type_class: GTypeClass`

  The parent class.

`constructor: GObject* (* constructor) ( GType type, guint n_construct_properties, GObjectConstructParam* construct_properties )`

  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.

`set_property: void (* set_property) ( GObject* object, guint property_id, const GValue* value, GParamSpec* pspec )`

  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.

`get_property: void (* get_property) ( GObject* object, guint property_id, GValue* value, GParamSpec* pspec )`

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

`dispose: void (* dispose) ( GObject* object )`

  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 (* finalize) ( GObject* object )`

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

`dispatch_properties_changed: void (* dispatch_properties_changed) ( GObject* object, guint n_pspecs, GParamSpec** pspecs )`

  Emits property change notification for a bunch of properties. Overriding `dispatch_properties_changed` should be rarely needed.

`notify: void (* notify) ( GObject* object, GParamSpec* pspec )`

  The class closure for the notify signal.

`constructed: void (* constructed) ( GObject* object )`

  The `constructed` function is called by `g_object_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.