typedef GClosureMarshal GSignalCMarshaller; This is the signature of marshaller functions, required to marshall arrays of parameter values to signal emissions into C language callback invocations. It is merely an alias to GClosureMarshal since the GClosure mechanism takes over responsibility of actual function invocation for the signal system.
typedef gchar** GStrv; A C representable type name for G_TYPE_STRV. See Also GParamSpecBoxed, g_param_spec_boxed()
typedef gchar* gchararray; A C representable type name for G_TYPE_STRING.
Flags to be passed to g_object_bind_property() or g_object_bind_property_full(). This enumeration can be extended at later date. G_BINDING_DEFAULT The default binding; if the source property changes, the target property is updated with its value. G_BINDING_BIDIRECTIONAL Bidirectional binding; if either the property of the source or the property of the target changes, the other is updated. G_BINDING_SYNC_CREATE Synchronize the values of the source and target properties when creating the binding; the direction of the synchronization is always from the source to the target. G_BINDING_INVERT_BOOLEAN If the two properties being bound are booleans, setting one to TRUE will result in the other being set to FALSE and vice versa. This flag will only work for boolean properties, and cannot be used when passing custom transformation functions to g_object_bind_property_full(). Since 2.26
The connection flags are used to specify the behaviour of a signal's connection. G_CONNECT_AFTER whether the handler should be called before or after the default handler of the signal. G_CONNECT_SWAPPED whether the instance and data should be swapped when calling the handler.
Through the GParamFlags flag values, certain aspects of parameters can be configured. G_PARAM_READABLE the parameter is readable G_PARAM_WRITABLE the parameter is writable G_PARAM_CONSTRUCT the parameter will be set upon object construction G_PARAM_CONSTRUCT_ONLY the parameter will only be set upon object construction G_PARAM_LAX_VALIDATION upon parameter conversion (see g_param_value_convert()) strict validation is not required G_PARAM_STATIC_NAME the string used as name when constructing the parameter is guaranteed to remain valid and unmodified for the lifetime of the parameter. Since 2.8 G_PARAM_PRIVATE internal G_PARAM_STATIC_NICK the string used as nick when constructing the parameter is guaranteed to remain valid and unmmodified for the lifetime of the parameter. Since 2.8 G_PARAM_STATIC_BLURB the string used as blurb when constructing the parameter is guaranteed to remain valid and unmodified for the lifetime of the parameter. Since 2.8 G_PARAM_DEPRECATED the parameter is deprecated and will be removed in a future version. A warning will be generated if it is used while running with G_ENABLE_DIAGNOSTIC=1.
The signal flags are used to specify a signal's behaviour, the overall signal description outlines how especially the RUN flags control the stages of a signal emission. G_SIGNAL_RUN_FIRST Invoke the object method handler in the first emission stage. G_SIGNAL_RUN_LAST Invoke the object method handler in the third emission stage. G_SIGNAL_RUN_CLEANUP Invoke the object method handler in the last emission stage. G_SIGNAL_NO_RECURSE Signals being emitted for an object while currently being in emission for this very object will not be emitted recursively, but instead cause the first emission to be restarted. G_SIGNAL_DETAILED This signal supports "::detail" appendices to the signal name upon handler connections and emissions. G_SIGNAL_ACTION Action signals are signals that may freely be emitted on alive objects from user code via g_signal_emit() and friends, without the need of being embedded into extra code that performs pre or post emission adjustments on the object. They can also be thought of as object methods which can be called generically by third-party code. G_SIGNAL_NO_HOOKS No emissions hooks are supported for this signal.
The match types specify what g_signal_handlers_block_matched(), g_signal_handlers_unblock_matched() and g_signal_handlers_disconnect_matched() match signals by. G_SIGNAL_MATCH_ID The signal id must be equal. G_SIGNAL_MATCH_DETAIL The signal detail be equal. G_SIGNAL_MATCH_CLOSURE The closure must be the same. G_SIGNAL_MATCH_FUNC The C closure callback must be the same. G_SIGNAL_MATCH_DATA The closure data must be the same. G_SIGNAL_MATCH_UNBLOCKED Only unblocked signals may matched.
The GTypeDebugFlags enumeration values can be passed to g_type_init_with_debug_flags() to trigger debugging messages during runtime. Note that the messages can also be triggered by setting the GOBJECT_DEBUG environment variable to a ':'-separated list of "objects" and "signals". G_TYPE_DEBUG_NONE Print no messages. G_TYPE_DEBUG_OBJECTS Print messages about object bookkeeping. G_TYPE_DEBUG_SIGNALS Print messages about signal emissions. G_TYPE_DEBUG_MASK Mask covering all debug flags.
Bit masks used to check or determine characteristics of a type. G_TYPE_FLAG_ABSTRACT Indicates an abstract type. No instances can be created for an abstract type. G_TYPE_FLAG_VALUE_ABSTRACT Indicates an abstract value type, i.e. a type that introduces a value table, but can't be used for g_value_init().
Bit masks used to check or determine specific characteristics of a fundamental type. G_TYPE_FLAG_CLASSED Indicates a classed type. G_TYPE_FLAG_INSTANTIATABLE Indicates an instantiable type (implies classed). G_TYPE_FLAG_DERIVABLE Indicates a flat derivable type. G_TYPE_FLAG_DEEP_DERIVABLE Indicates a deep derivable type (implies derivable).
Main Gtk struct. GBinding is an opaque structure whose members cannot be accessed directly. Since 2.26
A GCClosure is a specialization of GClosure for C function callbacks. GClosure closure; the GClosure gpointer callback; the callback function
Main Gtk struct. A GClosure represents a callback supplied by the programmer. volatile guint in_marshal : 1; Indicates whether the closure is currently being invoked with g_closure_invoke() volatile guint is_invalid : 1; Indicates whether the closure has been invalidated by g_closure_invalidate()
The class of an enumeration type holds information about its possible values. GTypeClass g_type_class; the parent class gint minimum; the smallest possible value. gint maximum; the largest possible value. guint n_values; the number of possible values. GEnumValue *values; an array of GEnumValue structs describing the individual values.
Main Gtk struct. A structure which contains a single enum value, its name, and its nickname. gint value; the enum value const gchar *value_name; the name of the value const gchar *value_nick; the nickname of the value
The class of a flags type holds information about its possible values. GTypeClass g_type_class; the parent class guint mask; a mask covering all possible values. guint n_values; the number of possible values. GFlagsValue *values; an array of GFlagsValue structs describing the individual values.
A structure which contains a single flags value, its name, and its nickname. guint value; the flags value const gchar *value_name; the name of the value const gchar *value_nick; the nickname of the value
All the fields in the GInitiallyUnowned structure are private to the GInitiallyUnowned implementation and should never be accessed directly.
The class structure for the GInitiallyUnowned type.
A structure that provides information to the type system which is used specifically for managing interface types. GInterfaceInitFunc interface_init; location of the interface initialization function GInterfaceFinalizeFunc interface_finalize; location of the interface finalization function gpointer interface_data; user-supplied data passed to the interface init/finalize functions
Main Gtk struct. All the fields in the GObject structure are private to the GObject implementation and should never be accessed directly.
The class structure for the GObject type. Example4.Implementing singletons using a constructor static MySingleton *the_singleton = NULL; static GObject* my_singleton_constructor (GType type,
The GObjectConstructParam struct is an auxiliary structure used to hand GParamSpec/GValue pairs to the constructor of a GObjectClass. GParamSpec *pspec; the GParamSpec of the construct parameter GValue *value; the value to set the parameter to
Main Gtk struct. All other fields of the GParamSpec struct are private and should not be used directly. GTypeInstance g_type_instance; private GTypeInstance portion gchar *name; name of this parameter GParamFlags flags; GParamFlags flags for this parameter GType value_type; the GValue type for this parameter GType owner_type; GType type that uses (introduces) this parameter
A GParamSpec derived structure that contains the meta data for boolean properties. GParamSpec parent_instance; private GParamSpec portion gboolean default_value; default value for the property specified
A GParamSpec derived structure that contains the meta data for boxed properties. GParamSpec parent_instance; private GParamSpec portion
A GParamSpec derived structure that contains the meta data for character properties. GParamSpec parent_instance; private GParamSpec portion gint8 minimum; minimum value for the property specified gint8 maximum; maximum value for the property specified gint8 default_value; default value for the property specified
The class structure for the GParamSpec type. Normally, GParamSpec classes are filled by g_param_type_register_static(). GTypeClass g_type_class; the parent class GType value_type; the GValue type for this parameter finalize () The instance finalization function (optional), should chain up to the finalize method of the parent class. value_set_default () Resets a value to the default value for this type (recommended, the default is g_value_reset()), see g_param_value_set_default(). value_validate () Ensures that the contents of value comply with the specifications set out by this type (optional), see g_param_value_set_validate(). values_cmp () Compares value1 with value2 according to this type (recommended, the default is memcmp()), see g_param_values_cmp().
A GParamSpec derived structure that contains the meta data for double properties. GParamSpec parent_instance; private GParamSpec portion gdouble minimum; minimum value for the property specified gdouble maximum; maximum value for the property specified gdouble default_value; default value for the property specified gdouble epsilon; values closer than epsilon will be considered identical by g_param_values_cmp(); the default value is 1e-90.
A GParamSpec derived structure that contains the meta data for enum properties. GParamSpec parent_instance; private GParamSpec portion GEnumClass *enum_class; the GEnumClass for the enum gint default_value; default value for the property specified
A GParamSpec derived structure that contains the meta data for flags properties. GParamSpec parent_instance; private GParamSpec portion GFlagsClass *flags_class; the GFlagsClass for the flags guint default_value; default value for the property specified
A GParamSpec derived structure that contains the meta data for float properties. GParamSpec parent_instance; private GParamSpec portion gfloat minimum; minimum value for the property specified gfloat maximum; maximum value for the property specified gfloat default_value; default value for the property specified gfloat epsilon; values closer than epsilon will be considered identical by g_param_values_cmp(); the default value is 1e-30.
A GParamSpec derived structure that contains the meta data for GType properties. GParamSpec parent_instance; private GParamSpec portion GType is_a_type; a GType whose subtypes can occur as values Since 2.10
A GParamSpec derived structure that contains the meta data for integer properties. GParamSpec parent_instance; private GParamSpec portion gint minimum; minimum value for the property specified gint maximum; maximum value for the property specified gint default_value; default value for the property specified
A GParamSpec derived structure that contains the meta data for 64bit integer properties. GParamSpec parent_instance; private GParamSpec portion gint64 minimum; minimum value for the property specified gint64 maximum; maximum value for the property specified gint64 default_value; default value for the property specified
A GParamSpec derived structure that contains the meta data for long integer properties. GParamSpec parent_instance; private GParamSpec portion glong minimum; minimum value for the property specified glong maximum; maximum value for the property specified glong default_value; default value for the property specified
A GParamSpec derived structure that contains the meta data for object properties. GParamSpec parent_instance; private GParamSpec portion
This is a type of GParamSpec type that simply redirects operations to another paramspec. All operations other than getting or setting the value are redirected, including accessing the nick and blurb, validating a value, and so forth. See g_param_spec_get_redirect_target() for retrieving the overidden property. GParamSpecOverride is used in implementing g_object_class_override_property(), and will not be directly useful unless you are implementing a new base type similar to GObject. Since 2.4
A GParamSpec derived structure that contains the meta data for G_TYPE_PARAM properties. GParamSpec parent_instance; private GParamSpec portion
A GParamSpec derived structure that contains the meta data for pointer properties. GParamSpec parent_instance; private GParamSpec portion
A GParamSpecPool maintains a collection of GParamSpecs which can be quickly accessed by owner and name. The implementation of the GObject property system uses such a pool to store the GParamSpecs of the properties all object types.
A GParamSpec derived structure that contains the meta data for string properties. GParamSpec parent_instance; private GParamSpec portion gchar *default_value; default value for the property specified gchar *cset_first; a string containing the allowed values for the first byte gchar *cset_nth; a string containing the allowed values for the subsequent bytes gchar substitutor; the replacement byte for bytes which don't match cset_first or cset_nth. guint null_fold_if_empty : 1; replace empty string by NULL guint ensure_non_null : 1; replace NULL strings by an empty string
This structure is used to provide the type system with the information required to initialize and destruct (finalize) a parameter's class and instances thereof. The initialized structure is passed to the g_param_type_register_static() The type system will perform a deep copy of this structure, so its memory does not need to be persistent across invocation of g_param_type_register_static(). guint16 instance_size; Size of the instance (object) structure. guint16 n_preallocs; Prior to GLib 2.10, it specified the number of pre-allocated (cached) instances to reserve memory for (0 indicates no caching). Since GLib 2.10, it is ignored, since instances are allocated with the slice allocator now. instance_init () Location of the instance initialization function (optional). GType value_type; The GType of values conforming to this GParamSpec finalize () The instance finalization function (optional). value_set_default () Resets a value to the default value for pspec (recommended, the default is g_value_reset()), see g_param_value_set_default(). value_validate () Ensures that the contents of value comply with the specifications set out by pspec (optional), see g_param_value_set_validate(). values_cmp () Compares value1 with value2 according to pspec (recommended, the default is memcmp()), see g_param_values_cmp().
A GParamSpec derived structure that contains the meta data for unsigned character properties. GParamSpec parent_instance; private GParamSpec portion guint8 minimum; minimum value for the property specified guint8 maximum; maximum value for the property specified guint8 default_value; default value for the property specified
A GParamSpec derived structure that contains the meta data for unsigned integer properties. GParamSpec parent_instance; private GParamSpec portion guint minimum; minimum value for the property specified guint maximum; maximum value for the property specified guint default_value; default value for the property specified
A GParamSpec derived structure that contains the meta data for unsigned 64bit integer properties. GParamSpec parent_instance; private GParamSpec portion guint64 minimum; minimum value for the property specified guint64 maximum; maximum value for the property specified guint64 default_value; default value for the property specified
A GParamSpec derived structure that contains the meta data for unsigned long integer properties. GParamSpec parent_instance; private GParamSpec portion gulong minimum; minimum value for the property specified gulong maximum; maximum value for the property specified gulong default_value; default value for the property specified
A GParamSpec derived structure that contains the meta data for unichar (unsigned integer) properties. GParamSpec parent_instance; private GParamSpec portion gunichar default_value; default value for the property specified
A GParamSpec derived structure that contains the meta data for GValueArray properties. GParamSpec parent_instance; private GParamSpec portion GParamSpec *element_spec; a GParamSpec describing the elements contained in arrays of this property, may be NULL guint fixed_n_elements; if greater than 0, arrays of this property will always have this many elements
A GParamSpec derived structure that contains the meta data for GVariant properties. GParamSpec parent_instance; private GParamSpec portion GVariantType *type; a GVariantType, or NULL GVariant *default_value; a GVariant, or NULL Since 2.26
The GParameter struct is an auxiliary structure used to hand parameter name/value pairs to g_object_newv(). const gchar *name; the parameter name GValue value; the parameter value
The GSignalInvocationHint structure is used to pass on additional information to callbacks during a signal emission. guint signal_id; The signal id of the signal invoking the callback GQuark detail; The detail passed on for this emission GSignalFlags run_type; The stage the signal emission is currently in, this field will contain one of G_SIGNAL_RUN_FIRST, G_SIGNAL_RUN_LAST or G_SIGNAL_RUN_CLEANUP.
A structure holding in-depth information for a specific signal. It is filled in by the g_signal_query() function. guint signal_id; The signal id of the signal being queried, or 0 if the signal to be queried was unknown. const gchar *signal_name; The signal name. GType itype; The interface/instance type that this signal can be emitted for. GSignalFlags signal_flags; The signal flags as passed in to g_signal_new(). GType return_type; The return type for user callbacks. guint n_params; The number of parameters that user callbacks take. const GType *param_types; The individual parameter types for user callbacks, note that the effective callback signature is: @return_type callback (gpointer data1, [param_types param_names,] gpointer data2);
An opaque structure used as the base of all classes.
A structure that provides information to the type system which is used specifically for managing fundamental types. GTypeFundamentalFlags type_flags; GTypeFundamentalFlags describing the characteristics of the fundamental type
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. The initialized structure is passed to the g_type_register_static() function (or is copied into the provided GTypeInfo structure in the g_type_plugin_complete_type_info()). The type system will perform a deep copy of this structure, so its memory does not need to be persistent across invocation of g_type_register_static(). guint16 class_size; Size of the class structure (required for interface, classed and instantiatable types). GBaseInitFunc base_init; Location of the base initialization function (optional). GBaseFinalizeFunc base_finalize; Location of the base finalization function (optional). GClassInitFunc class_init; Location of the class initialization function for classed and instantiatable types. Location of the default vtable inititalization function for interface types. (optional) This function is used both to fill in virtual functions in the class or default vtable, and to do type-specific setup such as registering signals and object properties. GClassFinalizeFunc class_finalize; Location of the class finalization function for classed and instantiatable types. Location fo the default vtable finalization function for interface types. (optional) gconstpointer class_data; User-supplied data passed to the class init/finalize functions. guint16 instance_size; Size of the instance (object) structure (required for instantiatable types only). guint16 n_preallocs; Prior to GLib 2.10, it specified the number of pre-allocated (cached) instances to reserve memory for (0 indicates no caching). Since GLib 2.10, it is ignored, since instances are allocated with the slice allocator now. GInstanceInitFunc instance_init; Location of the instance initialization function (optional, for instantiatable types only). const GTypeValueTable *value_table; A GTypeValueTable function table for generic handling of GValues of this type (usually only useful for fundamental types).
An opaque structure used as the base of all type instances.
An opaque structure used as the base of all interface types.
Main Gtk struct. The members of the GTypeModule structure should not be accessed directly, except for the name field. gchar *name; the name of the module
In order to implement dynamic loading of types based on GTypeModule, the load and unload functions in GTypeModuleClass must be implemented. GObjectClass parent_class; the parent class load () loads the module and registers one or more types using g_type_module_register_type(). unload () unloads the module
Main Gtk struct. The GTypePlugin typedef is used as a placeholder for objects that implement the GTypePlugin interface.
The GTypePlugin interface is used by the type system in order to handle the lifecycle of dynamically loaded types. GTypePluginUse use_plugin; Increases the use count of the plugin. GTypePluginUnuse unuse_plugin; Decreases the use count of the plugin. GTypePluginCompleteTypeInfo complete_type_info; Fills in the GTypeInfo and GTypeValueTable structs for the type. The structs are initialized with memset(s, 0, sizeof (s)) before calling this function. GTypePluginCompleteInterfaceInfo complete_interface_info; Fills in missing parts of the GInterfaceInfo for the interface. The structs is initialized with memset(s, 0, sizeof (s)) before calling this function.
A structure holding information for a specific type. It is filled in by the g_type_query() function. GType type; the GType value of the type. const gchar *type_name; the name of the type. guint class_size; the size of the class structure. guint instance_size; the size of the instance structure.
The GTypeValueTable provides the functions required by the GValue implementation, to serve as a container for values of a type. value_init () Default initialize values contents by poking values directly into the value->data array. The data array of the GValue passed into this function was zero-filled with memset(), so no care has to be taken to free any old contents. E.g. for the implementation of a string value that may never be NULL, the implementation might look like: value_free () Free any old contents that might be left in the data array of the passed in value. No resources may remain allocated through the GValue contents after this function returns. E.g. for our above string type: value_copy () dest_value is a GValue with zero-filled data section and src_value is a properly setup GValue of same or derived type. The purpose of this function is to copy the contents of src_value into dest_value in a way, that even after src_value has been freed, the contents of dest_value remain valid. String type example: value_peek_pointer () If the value contents fit into a pointer, such as objects or strings, return this pointer, so the caller can peek at the current contents. To extend on our above string example: gchar *collect_format; A string format describing how to collect the contents of this value bit-by-bit. Each character in the format represents an argument to be collected, and the characters themselves indicate the type of the argument. Currently supported arguments are: 'i' - Integers. passed as collect_values[].v_int. 'l' - Longs. passed as collect_values[].v_long. 'd' - Doubles. passed as collect_values[].v_double. 'p' - Pointers. passed as collect_values[].v_pointer. It should be noted that for variable argument list construction, ANSI C promotes every type smaller than an integer to an int, and floats to doubles. So for collection of short int or char, 'i' needs to be used, and for collection of floats 'd'. collect_value () The collect_value() function is responsible for converting the values collected from a variable argument list into contents suitable for storage in a GValue. This function should setup value similar to value_init(); e.g. for a string value that does not allow NULL pointers, it needs to either spew an error, or do an implicit conversion by storing an empty string. The value passed in to this function has a zero-filled data array, so just like for value_init() it is guaranteed to not contain any old contents that might need freeing. n_collect_values is exactly the string length of collect_format, and collect_values is an array of unions GTypeCValue with length n_collect_values, containing the collected values according to collect_format. collect_flags is an argument provided as a hint by the caller. It may contain the flag G_VALUE_NOCOPY_CONTENTS indicating, that the collected value contents may be considered "static" for the duration of the value lifetime. Thus an extra copy of the contents stored in collect_values is not required for assignment to value. For our above string example, we continue with: It should be noted, that it is generally a bad idea to follow the G_VALUE_NOCOPY_CONTENTS hint for reference counted types. Due to reentrancy requirements and reference count assertions performed by the GSignal code, reference counts should always be incremented for reference counted contents stored in the value->data array. To deviate from our string example for a moment, and taking a look at an exemplary implementation for collect_value() of GObject: The reference count for valid objects is always incremented, regardless of collect_flags. For invalid objects, the example returns a newly allocated string without altering value. Upon success, collect_value() needs to return NULL. If, however, an error condition occurred, collect_value() may spew an error by returning a newly allocated non-NULL string, giving a suitable description of the error condition. The calling code makes no assumptions about the value contents being valid upon error returns, value is simply thrown away without further freeing. As such, it is a good idea to not allocate GValue contents, prior to returning an error, however, collect_values() is not obliged to return a correctly setup value for error returns, simply because any non-NULL return is considered a fatal condition so further program behaviour is undefined. gchar *lcopy_format; Format description of the arguments to collect for lcopy_value, analogous to collect_format. Usually, lcopy_format string consists only of 'p's to provide lcopy_value() with pointers to storage locations. lcopy_value () This function is responsible for storing the value contents into arguments passed through a variable argument list which got collected into collect_values according to lcopy_format. n_collect_values equals the string length of lcopy_format, and collect_flags may contain G_VALUE_NOCOPY_CONTENTS. In contrast to collect_value(), lcopy_value() is obliged to always properly support G_VALUE_NOCOPY_CONTENTS. Similar to collect_value() the function may prematurely abort by returning a newly allocated string describing an error condition. To complete the string example: And an illustrative version of lcopy_value() for reference-counted types:
Main Gtk struct. A GValueArray contains an array of GValue elements. guint n_values; number of values contained in the array GValue *values; array of values