gobject-2.0

Description:

GObject provides the object system used for Pango and GTK+.

Content:

Namespaces:

  • GLib

    • Interfaces:

    • TypePlugin - The TypePlugin interface is used by the type system in order to handle the lifecycle of dynamically loaded types.

    Classes:

    Structs:

    • EnumValue - A structure which contains a single enum value, its name, and its nickname.
    • FlagsValue - A structure which contains a single flags value, its name, and its nickname.
    • InterfaceInfo - A structure that provides information to the type system which is used specifically for managing interface types.
    • ObjectConstructParam - The GObjectConstructParam struct is an auxiliary structure used to hand ParamSpec/ Value pairs to the constructor of a ObjectClass.
    • Parameter - The GParameter struct is an auxiliary structure used to hand parameter name/value pairs to newv.
    • Signal
    • SignalInvocationHint - The SignalInvocationHint structure is used to pass on additional information to callbacks during a signal emission.
    • SignalQuery - A structure holding in-depth information for a specific signal.
    • Type - A numerical value which represents the unique identifier of a registered type.
    • TypeInfo - This structure is used to provide the type system with the information required to initialize and destruct (finalize) a type's class and its instances.
    • TypeQuery - A structure holding information for a specific type.
    • TypeValueTable - The TypeValueTable provides the functions required by the Value implementation, to serve as a container for values of a type.
    • Value - An opaque structure used to hold different types of values.
    • WeakRef - A structure containing a weak reference to a Object.

    Enums:

    • BindingFlags - Flags to be passed to g_object_bind_property or g_object_bind_property_full.
    • ConnectFlags - The connection flags are used to specify the behaviour of a signal's connection.
    • ParamFlags - Through the ParamFlags flag values, certain aspects of parameters can be configured.
    • SignalFlags - The signal flags are used to specify a signal's behaviour.
    • SignalMatchType - The match types specify what block_matched, unblock_matched and disconnect_matched match signals by.
    • TypeDebugFlags - These flags used to be passed to g_type_init_with_debug_flags which is now deprecated.
    • TypeFlags - Bit masks used to check or determine characteristics of a type.
    • TypeFundamentalFlags - Bit masks used to check or determine specific characteristics of a fundamental type.

    Delegates:

    • public delegate void BaseFinalizeFunc (TypeClass g_class)
      A callback function used by the type system to finalize those portions of a derived types class structure that were setup from the corresponding BaseInitFunc function.
    • public delegate void BaseInitFunc (TypeClass g_class)
      A callback function used by the type system to do base initialization of the class structures of derived types.
    • public delegate bool BindingTransformFunc (Binding binding, Value from_value, ref Value to_value)
      A function to be called to transform from_value to to_value.
    • public delegate void* BoxedCopyFunc (void* boxed)
      This function is provided by the user and should produce a copy of the passed in boxed structure.
    • public delegate void BoxedFreeFunc (void* boxed)
      This function is provided by the user and should free the boxed structure passed.
    • public delegate void Callback ()
    • public delegate void ClassFinalizeFunc (TypeClass g_class, void* class_data)
      A callback function used by the type system to finalize a class.
    • public delegate void ClassInitFunc (TypeClass g_class, void* class_data)
      A callback function used by the type system to initialize the class of a specific type.
    • public delegate void ClosureMarshal (Closure closure, out Value return_value, Value[] param_values, void* invocation_hint, void* marshal_data)
      The type used for marshaller functions.
    • public delegate void ClosureNotify (void* data, Closure closure)
      The type used for the various notification callbacks which can be registered on closures.
    • public delegate void InstanceInitFunc (TypeInstance instance, TypeClass g_class)
      A callback function used by the type system to initialize a new instance of a type.
    • public delegate void InterfaceFinalizeFunc (TypeInterface g_iface, void* iface_data)
      A callback function used by the type system to finalize an interface.
    • public delegate void InterfaceInitFunc (TypeInterface g_iface, void* iface_data)
      A callback function used by the type system to initialize a new interface.
    • public delegate Object ObjectConstructorFunc (Type type, ObjectConstructParam[] construct_properties)
      The type used for callback functions in structure definitions and function signatures.
    • public delegate void ObjectFinalizeFunc (Object object)
      The type of the finalize function of ObjectClass.
    • public delegate void ObjectGetPropertyFunc (Object object, uint property_id, ref Value value, ParamSpec pspec)
      The type of the get_property function of ObjectClass.
    • public delegate void ObjectSetPropertyFunc (Object object, uint property_id, Value value, ParamSpec pspec)
      The type of the set_property function of ObjectClass.
    • public delegate bool SignalAccumulator (SignalInvocationHint ihint, Value return_accu, Value handler_return, void* data)
      The signal accumulator is a special callback function that can be used to collect return values of the various callbacks that are called during a signal emission.
    • public delegate void SignalCMarshaller (Closure closure, Value? return_value, Value[] param_values, void* invocation_hint, void* marshal_data)
      This is the signature of marshaller functions, required to marshall arrays of parameter values to signal emissions into C language callback invocations.
    • public delegate void SignalCVaMarshaller (Closure closure, Value? return_value, TypeInstance instance, va_list args, void* marshal_data, Type[] param_types)
      This is the signature of va_list marshaller functions, an optional marshaller that can be used in some situations to avoid marshalling the signal argument into GValues.
    • public delegate bool SignalEmissionHook (SignalInvocationHint ihint, Value[] param_values)
      A simple function pointer to get invoked when the signal is emitted.
    • public delegate void ToggleNotify (Object object, bool is_last_ref)
      A callback function used for notification when the state of a toggle reference changes.
    • public delegate void TypeClassCacheFunc (void* cache_data, TypeClass g_class)
      A callback function which is called when the reference count of a class drops to zero.
    • public delegate void ValueTransform (Value src_value, ref Value dest_value)
      The type of value transformation functions which can be registered with register_transform_func.
    • public delegate void WeakNotify (Object object)
      A WeakNotify function can be added to an object as a callback that gets triggered when the object is finalized.

    Methods:

  • SignalHandler

    • Methods:

    • public void block (void* instance, ulong handler_id)
      Blocks a handler of an instance so it will not be called during any signal emissions unless it is unblocked again.
    • public uint block_by_func (void* instance, void* func, void* data)
    • public uint block_matched (void* instance, SignalMatchType mask, uint signal_id, Quark detail, Closure? closure, void* func, void* data)
      Blocks all handlers on an instance that match a certain selection criteria.
    • public void disconnect (void* instance, ulong handler_id)
      Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
    • public uint disconnect_by_data (void* instance, void* data)
    • public uint disconnect_by_func (void* instance, void* func, void* data)
    • public uint disconnect_matched (void* instance, SignalMatchType mask, uint signal_id, Quark detail, Closure? closure, void* func, void* data)
      Disconnects all handlers on an instance that match a certain selection criteria.
    • public ulong find (void* instance, SignalMatchType mask, uint signal_id, Quark detail, Closure? closure, void* func, void* data)
      Finds the first signal handler that matches certain selection criteria.
    • public bool is_connected (void* instance, ulong handler_id)
      Returns whether handler_id is the ID of a handler connected to instance.
    • public void unblock (void* instance, ulong handler_id)
      Undoes the effect of a previous block call.
    • public uint unblock_by_func (void* instance, void* func, void* data)
    • public uint unblock_matched (void* instance, SignalMatchType mask, uint signal_id, Quark detail, Closure? closure, void* func, void* data)
      Unblocks all handlers on an instance that match a certain selection criteria.