Struct _GObjectClass

#[repr(C)]
pub struct _GObjectClass {

    pub g_type_class: GTypeClass,
    pub construct_properties: *mut GSList,
    pub constructor: Option<unsafe extern "C" fn(type_: GType, n_construct_properties: guint, construct_properties: *mut GObjectConstructParam) -> *mut GObject>,
    pub set_property: Option<unsafe extern "C" fn(object: *mut GObject, property_id: guint, value: *const GValue, pspec: *mut GParamSpec)>,
    pub get_property: Option<unsafe extern "C" fn(object: *mut GObject, property_id: guint, value: *mut GValue, pspec: *mut GParamSpec)>,
    pub dispose: Option<unsafe extern "C" fn(object: *mut GObject)>,
    pub finalize: Option<unsafe extern "C" fn(object: *mut GObject)>,
    pub dispatch_properties_changed: Option<unsafe extern "C" fn(object: *mut GObject, n_pspecs: guint, pspecs: *mut *mut GParamSpec)>,
    pub notify: Option<unsafe extern "C" fn(object: *mut GObject, pspec: *mut GParamSpec)>,
    pub constructed: Option<unsafe extern "C" fn(object: *mut GObject)>,
    pub flags: gsize,
    pub n_construct_properties: gsize,
    pub pspecs: gpointer,
    pub n_pspecs: gsize,
    pub pdummy: [gpointer; 3],
}

GObjectClass: @g_type_class: the parent class @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. @set_property: 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: the generic getter for all properties of this type. Should be overridden for every type with properties. @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: 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: emits property change notification for a bunch of properties. Overriding @dispatch_properties_changed should be rarely needed. @notify: the class closure for the notify signal @constructed: 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.

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; } ]|

Fields

g_type_class: GTypeClass

construct_properties: *mut GSList

constructor: Option<unsafe extern "C" fn(type_: GType, n_construct_properties: guint, construct_properties: *mut GObjectConstructParam) -> *mut GObject>

set_property: Option<unsafe extern "C" fn(object: *mut GObject, property_id: guint, value: *const GValue, pspec: *mut GParamSpec)>

get_property: Option<unsafe extern "C" fn(object: *mut GObject, property_id: guint, value: *mut GValue, pspec: *mut GParamSpec)>

dispose: Option<unsafe extern "C" fn(object: *mut GObject)>

finalize: Option<unsafe extern "C" fn(object: *mut GObject)>

dispatch_properties_changed: Option<unsafe extern "C" fn(object: *mut GObject, n_pspecs: guint, pspecs: *mut *mut GParamSpec)>

notify: Option<unsafe extern "C" fn(object: *mut GObject, pspec: *mut GParamSpec)>

constructed: Option<unsafe extern "C" fn(object: *mut GObject)>

flags: gsize

n_construct_properties: gsize

pspecs: gpointer

n_pspecs: gsize

pdummy: [gpointer; 3]

Trait Implementations

impl Clone for _GObjectClass

fn clone(&self) -> _GObjectClass

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for _GObjectClass

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for _GObjectClass

fn eq(&self, other: &_GObjectClass) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for _GObjectClass

impl Eq for _GObjectClass

impl StructuralPartialEq for _GObjectClass