| boxed_free |
Free the boxed structure boxed which is of type boxed_type. |
| boxed_type_register_static |
This function creates a new G_TYPE_BOXED derived type id for a new boxed type with name name. |
| clear_object |
Clears a reference to a GObject. since: 2.28 |
| clear_signal_handler |
Disconnects a handler from instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to. The handler_id_ptr is then set to zero, which is never a valid handler ID value (see g_signal_connect()). since: 2.62 |
| enum_complete_type_info |
This function is meant to be called from the complete_type_infofunction of a GTypePlugin implementation, as in the following example:. |
| enum_get_value |
Returns the GEnumValue for a value. |
| enum_get_value_by_name |
Looks up a GEnumValue by name. |
| enum_get_value_by_nick |
Looks up a GEnumValue by nickname. |
| enum_register_static |
Registers a new static enumeration type with the name name. |
| enum_to_string |
Pretty-prints value in the form of the enum’s name. since: 2.54 |
| flags_complete_type_info |
This function is meant to be called from the complete_type_info()function of a GTypePlugin implementation, see the example forg_enum_complete_type_info() above. |
| flags_get_first_value |
Returns the first GFlagsValue which is set in value. |
| flags_get_value_by_name |
Looks up a GFlagsValue by name. |
| flags_get_value_by_nick |
Looks up a GFlagsValue by nickname. |
| flags_register_static |
Registers a new static flags type with the name name. |
| flags_to_string |
Pretty-prints value in the form of the flag names separated by | and sorted. Any extra bits will be shown at the end as a hexadecimal number. since: 2.54 |
| gtype_get_type |
|
| param_spec_boolean |
Creates a new GParamSpecBoolean instance specifying a G_TYPE_BOOLEANproperty. In many cases, it may be more appropriate to use an enum with g_param_spec_enum(), both to improve code clarity by using explicitly named values, and to allow for more values to be added in future without breakingAPI. |
| param_spec_boxed |
Creates a new GParamSpecBoxed instance specifying a G_TYPE_BOXEDderived property. |
| param_spec_char |
Creates a new GParamSpecChar instance specifying a G_TYPE_CHAR property. |
| param_spec_double |
Creates a new GParamSpecDouble instance specifying a G_TYPE_DOUBLEproperty. |
| param_spec_enum |
Creates a new GParamSpecEnum instance specifying a G_TYPE_ENUMproperty. |
| param_spec_flags |
Creates a new GParamSpecFlags instance specifying a G_TYPE_FLAGSproperty. |
| param_spec_float |
Creates a new GParamSpecFloat instance specifying a G_TYPE_FLOAT property. |
| param_spec_gtype |
Creates a new GParamSpecGType instance specifying aG_TYPE_GTYPE property. since: 2.10 |
| param_spec_int |
Creates a new GParamSpecInt instance specifying a G_TYPE_INT property. |
| param_spec_int64 |
Creates a new GParamSpecInt64 instance specifying a G_TYPE_INT64 property. |
| param_spec_long |
Creates a new GParamSpecLong instance specifying a G_TYPE_LONG property. |
| param_spec_object |
Creates a new GParamSpecBoxed instance specifying a G_TYPE_OBJECTderived property. |
| param_spec_override |
Creates a new property of type GParamSpecOverride. This is used to direct operations to another paramspec, and will not be directly useful unless you are implementing a new base type similar to GObject. since: 2.4 |
| param_spec_param |
Creates a new GParamSpecParam instance specifying a G_TYPE_PARAMproperty. |
| param_spec_pointer |
Creates a new GParamSpecPointer instance specifying a pointer property. Where possible, it is better to use g_param_spec_object() org_param_spec_boxed() to expose memory management information. |
| param_spec_string |
Creates a new GParamSpecString instance. |
| param_spec_uchar |
Creates a new GParamSpecUChar instance specifying a G_TYPE_UCHAR property. |
| param_spec_uint |
Creates a new GParamSpecUInt instance specifying a G_TYPE_UINT property. |
| param_spec_uint64 |
Creates a new GParamSpecUInt64 instance specifying a G_TYPE_UINT64property. |
| param_spec_ulong |
Creates a new GParamSpecULong instance specifying a G_TYPE_ULONGproperty. |
| param_spec_unichar |
Creates a new GParamSpecUnichar instance specifying a G_TYPE_UINTproperty. GValue structures for this property can be accessed withg_value_set_uint() and g_value_get_uint(). |
| param_spec_value_array |
Creates a new GParamSpecValueArray instance specifying aG_TYPE_VALUE_ARRAY property. G_TYPE_VALUE_ARRAY is aG_TYPE_BOXED type, as such, GValue structures for this property can be accessed with g_value_set_boxed() and g_value_get_boxed(). |
| param_spec_variant |
Creates a new GParamSpecVariant instance specifying a GVariantproperty. since: 2.26 |
| param_type_register_static |
Registers name as the name of a new static type derived from G_TYPE_PARAM. |
| param_value_convert |
Transforms src_value into dest_value if possible, and then validates dest_value, in order for it to conform to pspec. Ifstrict_validation is TRUE this function will only succeed if the transformed dest_value complied to pspec without modifications. |
| param_value_defaults |
Checks whether value contains the default value as specified in pspec. |
| param_value_is_valid |
Return whether the contents of value comply with the specifications set out by pspec. since: 2.74 |
| param_value_set_default |
Sets value to its default value as specified in pspec. |
| param_value_validate |
Ensures that the contents of value comply with the specifications set out by pspec. For example, a GParamSpecInt might require that integers stored in value may not be smaller than -42 and not be greater than +42. If value contains an integer outside of this range, it is modified accordingly, so the resulting value will fit into the range -42 .. +42. |
| param_values_cmp |
Compares value1 with value2 according to pspec, and return -1, 0 or +1, if value1 is found to be less than, equal to or greater than value2, respectively. |
| pointer_type_register_static |
Creates a new G_TYPE_POINTER derived type id for a new pointer type with name name. |
| signal_accumulator_first_wins |
A predefined GSignalAccumulator for signals intended to be used as a hook for application code to provide a particular value. Usually only one such value is desired and multiple handlers for the same signal don’t make much sense (except for the case of the default handler defined in the class structure, in which case you will usually want the signal connection to override the class handler). since: 2.28 |
| signal_accumulator_true_handled |
A predefined GSignalAccumulator for signals that return a boolean values. The behavior that this accumulator gives is that a return of TRUE stops the signal emission: no further callbacks will be invoked, while a return of FALSE allows the emission to continue. The idea here is that a TRUE return indicates that the callback handled the signal, and no further handling is needed. since: 2.4 |
| signal_add_emission_hook |
Adds an emission hook for a signal, which will get called for any emission of that signal, independent of the instance. This is possible only for signals which don’t have G_SIGNAL_NO_HOOKS flag set. |
| signal_chain_from_overridden |
Calls the original class closure of a signal. This function should only be called from an overridden class closure; seeg_signal_override_class_closure() and g_signal_override_class_handler(). |
| signal_chain_from_overridden_handler |
Calls the original class closure of a signal. This function should only be called from an overridden class closure; seeg_signal_override_class_closure() and g_signal_override_class_handler(). since: 2.18 |
| signal_connect_closure |
Connects a closure to a signal for a particular object. |
| signal_connect_closure_by_id |
Connects a closure to a signal for a particular object. |
| signal_connect_data |
Connects a GCallback function to a signal for a particular object. Similar to g_signal_connect(), but allows to provide a GClosureNotify for the data which will be called when the signal handler is disconnected and no longer used. Specify connect_flags if you need ..._after() or..._swapped() variants of this function. |
| signal_connect_object |
This is similar to g_signal_connect_data(), but uses a closure which ensures that the gobject stays alive during the call to c_handlerby temporarily adding a reference count to gobject. |
| signal_emit |
Emits a signal. Signal emission is done synchronously. The method will only return control after all handlers are called or signal emission was stopped. |
| signal_emit_by_name |
Emits a signal. Signal emission is done synchronously. The method will only return control after all handlers are called or signal emission was stopped. |
| signal_emit_valist |
Emits a signal. Signal emission is done synchronously. The method will only return control after all handlers are called or signal emission was stopped. |
| signal_emitv |
Emits a signal. Signal emission is done synchronously. The method will only return control after all handlers are called or signal emission was stopped. |
| signal_get_invocation_hint |
Returns the invocation hint of the innermost signal emission of instance. |
| signal_handler_block |
Blocks a handler of an instance so it will not be called during any signal emissions unless it is unblocked again. Thus “blocking” a signal handler means to temporarily deactivate it, a signal handler has to be unblocked exactly the same amount of times it has been blocked before to become active again. |
| signal_handler_disconnect |
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. The handler_id becomes invalid and may be reused. |
| signal_handler_find |
Finds the first signal handler that matches certain selection criteria. The criteria mask is passed as an OR-ed combination of GSignalMatchTypeflags, and the criteria values are passed as arguments. The match mask has to be non-0 for successful matches. If no handler was found, 0 is returned. |
| signal_handler_is_connected |
Returns whether handler_id is the ID of a handler connected to instance. |
| signal_handler_unblock |
Undoes the effect of a previous g_signal_handler_block() call. A blocked handler is skipped during signal emissions and will not be invoked, unblocking it (for exactly the amount of times it has been blocked before) reverts its “blocked” state, so the handler will be recognized by the signal system and is called upon future or currently ongoing signal emissions (since the order in which handlers are called during signal emissions is deterministic, whether the unblocked handler in question is called as part of a currently ongoing emission depends on how far that emission has proceeded yet). |
| signal_handlers_block_matched |
Blocks all handlers on an instance that match a certain selection criteria. |
| signal_handlers_destroy |
Destroy all signal handlers of a type instance. This function is an implementation detail of the GObject dispose implementation, and should not be used outside of the type system. |
| signal_handlers_disconnect_matched |
Disconnects all handlers on an instance that match a certain selection criteria. |
| signal_handlers_unblock_matched |
Unblocks all handlers on an instance that match a certain selection criteria. |
| signal_has_handler_pending |
Returns whether there are any handlers connected to instance for the given signal id and detail. |
| signal_is_valid_name |
Validate a signal name. This can be useful for dynamically-generated signals which need to be validated at run-time before actually trying to create them. since: 2.66 |
| signal_list_ids |
Lists the signals by id that a certain instance or interface type created. Further information about the signals can be acquired through g_signal_query(). |
| signal_lookup |
Given the name of the signal and the type of object it connects to, gets the signal’s identifying integer. Emitting the signal by number is somewhat faster than using the name each time. |
| signal_name |
Given the signal’s identifier, finds its name. |
| signal_new |
Creates a new signal. (This is usually done in the class initializer.). |
| signal_new_class_handler |
Creates a new signal. (This is usually done in the class initializer.). since: 2.18 |
| signal_new_valist |
Creates a new signal. (This is usually done in the class initializer.). |
| signal_newv |
Creates a new signal. (This is usually done in the class initializer.). |
| signal_override_class_closure |
Overrides the class closure (i.e. the default handler) for the given signal for emissions on instances of instance_type. instance_type must be derived from the type to which the signal belongs. |
| signal_override_class_handler |
Overrides the class closure (i.e. the default handler) for the given signal for emissions on instances of instance_type with callback class_handler. instance_type must be derived from the type to which the signal belongs. since: 2.18 |
| signal_parse_name |
Internal function to parse a signal name into its signal_idand detail quark. |
| signal_query |
Queries the signal system for in-depth information about a specific signal. This function will fill in a user-provided structure to hold signal-specific information. If an invalid signal id is passed in, the signal_id member of the GSignalQueryis 0. All members filled into the GSignalQuery structure should be considered constant and have to be left untouched. |
| signal_remove_emission_hook |
Deletes an emission hook. |
| signal_set_va_marshaller |
Change the GSignalCVaMarshaller used for a given signal. This is a specialised form of the marshaller that can often be used for the common case of a single connected signal handler and avoids the overhead of GValue. Its use is optional. since: 2.32 |
| signal_stop_emission |
Stops a signal’s current emission. |
| signal_stop_emission_by_name |
Stops a signal’s current emission. |
| signal_type_cclosure_new |
Creates a new closure which invokes the function found at the offsetstruct_offset in the class structure of the interface or classed type identified by itype. |
| source_set_closure |
Set the callback for a source as a GClosure. |
| source_set_dummy_callback |
Sets a dummy callback for source. The callback will do nothing, and if the source expects a #gboolean return value, it will return TRUE. (If the source expects any other type of return value, it will return a 0/NULL value; whatever g_value_init() initializes a GValue to for that type.). |
| strdup_value_contents |
Return a newly allocated string, which describes the contents of aGValue. The main purpose of this function is to describe GValuecontents for debugging output, the way in which the contents are described may change between different GLib versions. |
| type_add_class_cache_func |
Adds a GTypeClassCacheFunc to be called before the reference count of a class goes from one to zero. This can be used to prevent premature class destruction. All installed GTypeClassCacheFunc functions will be chained until one of them returns TRUE. The functions have to check the class id passed in to figure whether they actually want to cache the class of this type, since all classes are routed through the same GTypeClassCacheFuncchain. |
| type_add_class_private |
Registers a private class structure for a classed type; when the class is allocated, the private structures for the class and all of its parent types are allocated sequentially in the same memory block as the public structures, and are zero-filled. since: 2.24 |
| type_add_instance_private |
|
| type_add_interface_check |
Adds a function to be called after an interface vtable is initialized for any class (i.e. after the interface_initmember of GInterfaceInfo has been called). since: 2.4 |
| type_add_interface_dynamic |
Adds interface_type to the dynamic instance_type. The information contained in the GTypePlugin structure pointed to by pluginis used to manage the relationship. |
| type_add_interface_static |
Adds interface_type to the static instance_type. The information contained in the GInterfaceInfo structure pointed to by info is used to manage the relationship. |
| type_check_class_cast |
|
| type_check_class_is_a |
|
| type_check_instance |
Private helper function to aid implementation of the G_TYPE_CHECK_INSTANCE() macro. |
| type_check_instance_cast |
|
| type_check_instance_is_a |
|
| type_check_instance_is_fundamentally_a |
|
| type_check_is_value_type |
|
| type_check_value |
|
| type_check_value_holds |
|
| type_children |
Return a newly allocated and 0-terminated array of type IDs, listing the child types of type. |
| type_create_instance |
Creates and initializes an instance of type if type is valid and can be instantiated. The type system only performs basic allocation and structure setups for instances: actual instance creation should happen through functions supplied by the type’s fundamental type implementation. So use of g_type_create_instance() is reserved for implementers of fundamental types only. E.g. instances of theGObject hierarchy should be created via g_object_new() and never directly through g_type_create_instance() which doesn’t handle things like singleton objects or object construction. |
| type_default_interface_get |
Returns the default interface vtable for the given g_type. since: 2.84 |
| type_default_interface_peek |
If the interface type g_type is currently in use, returns its default interface vtable. since: 2.4 |
| type_default_interface_ref |
Increments the reference count for the interface type g_type, and returns the default interface vtable for the type. deprecated: 2.84 since: 2.4 |
| type_default_interface_unref |
Decrements the reference count for the type corresponding to the interface default vtable g_iface. deprecated: 2.84 since: 2.4 |
| type_depth |
Returns the length of the ancestry of the passed in type. This includes the type itself, so that e.g. a fundamental type has depth 1. |
| type_ensure |
Ensures that the indicated type has been registered with the type system, and its _class_init() method has been run. since: 2.34 |
| type_free_instance |
Frees an instance of a type, returning it to the instance pool for the type, if there is one. |
| type_from_name |
Look up the type ID from a given type name, returning 0 if no type has been registered under this name (this is the preferred method to find out by name whether a specific type has been registered yet). |
| type_fundamental |
Internal function, used to extract the fundamental type ID portion. Use G_TYPE_FUNDAMENTAL() instead. |
| type_fundamental_next |
Returns the next free fundamental type id which can be used to register a new fundamental type with g_type_register_fundamental(). The returned type ID represents the highest currently registered fundamental type identifier. |
| type_get_instance_count |
Returns the number of instances allocated of the particular type; this is only available if GLib is built with debugging support and the instance-count debug flag is set (by setting the GOBJECT_DEBUGvariable to include instance-count). since: 2.44 |
| type_get_plugin |
Returns the GTypePlugin structure for type. |
| type_get_qdata |
Obtains data which has previously been attached to typewith g_type_set_qdata(). |
| type_get_type_registration_serial |
Returns an opaque serial number that represents the state of the set of registered types. Any time a type is registered this serial changes, which means you can cache information based on type lookups (such as g_type_from_name()) and know if the cache is still valid at a later time by comparing the current serial with the one at the type lookup. since: 2.36 |
| type_init |
This function used to initialise the type system. Since GLib 2.36, the type system is initialised automatically and this function does nothing. deprecated: 2.36 |
| type_init_with_debug_flags |
This function used to initialise the type system with debugging flags. Since GLib 2.36, the type system is initialised automatically and this function does nothing. deprecated: 2.36 |
| type_interfaces |
Return a newly allocated and 0-terminated array of type IDs, listing the interface types that type conforms to. |
| type_is_a |
If is_a_type is a derivable type, check whether type is a descendant of is_a_type. If is_a_type is an interface, check whether type conforms to it. |
| type_name |
Get the unique name that is assigned to a type ID. |
| type_name_from_class |
|
| type_name_from_instance |
|
| type_next_base |
Given a leaf_type and a root_type which is contained in its ancestry, return the type that root_type is the immediate parent of. In other words, this function determines the type that is derived directly from root_type which is also a base class ofleaf_type. Given a root type and a leaf type, this function can be used to determine the types and order in which the leaf type is descended from the root type. |
| type_parent |
Return the direct parent type of the passed in type. If the passed in type has no parent, i.e. is a fundamental type, 0 is returned. |
| type_qname |
Get the corresponding quark of the type IDs name. |
| type_query |
Queries the type system for information about a specific type. |
| type_register_dynamic |
Registers type_name as the name of a new dynamic type derived fromparent_type. The type system uses the information contained in theGTypePlugin structure pointed to by plugin to manage the type and its instances (if not abstract). The value of flags determines the nature (e.g. abstract or not) of the type. |
| type_register_fundamental |
Registers type_id as the predefined identifier and type_name as the name of a fundamental type. If type_id is already registered, or a type named type_name is already registered, the behaviour is undefined. The type system uses the information contained in the GTypeInfo structure pointed to by info and the GTypeFundamentalInfo structure pointed to byfinfo to manage the type and its instances. The value of flags determines additional characteristics of the fundamental type. |
| type_register_static |
Registers type_name as the name of a new static type derived fromparent_type. The type system uses the information contained in theGTypeInfo structure pointed to by info to manage the type and its instances (if not abstract). The value of flags determines the nature (e.g. abstract or not) of the type. |
| type_register_static_simple |
Registers type_name as the name of a new static type derived fromparent_type. The value of flags determines the nature (e.g. abstract or not) of the type. It works by filling a GTypeInfostruct and calling g_type_register_static(). since: 2.12 |
| type_remove_class_cache_func |
Removes a previously installed GTypeClassCacheFunc. The cache maintained by cache_func has to be empty when callingg_type_remove_class_cache_func() to avoid leaks. |
| type_remove_interface_check |
Removes an interface check function added with g_type_add_interface_check(). since: 2.4 |
| type_set_qdata |
Attaches arbitrary data to a type. |
| type_test_flags |
|
| variant_get_gtype |
|