Gobject

Mask containing the bits of #GParamSpec.flags which are reserved for GLib.

#GParamFlags value alias for %G_PARAM_STATIC_NAME | %G_PARAM_STATIC_NICK | %G_PARAM_STATIC_BLURB.

Minimum shift count to be used for user defined flags, to be stored in #GParamSpec.flags. The maximum allowed is 10.

A mask for all #GSignalFlags bits.

A mask for all #GSignalMatchType bits.

An integer constant that represents the number of identifiers reserved for types that are assigned at compile-time.

Shift value used in converting numbers to type IDs.

First fundamental type number to create a new fundamental type id with G_TYPE_MAKE_FUNDAMENTAL() reserved for BSE.

Last fundamental type number reserved for BSE.

First fundamental type number to create a new fundamental type id with G_TYPE_MAKE_FUNDAMENTAL() reserved for GLib.

Last fundamental type number reserved for GLib.

First available fundamental type number to create new fundamental type id with G_TYPE_MAKE_FUNDAMENTAL().

For string values, indicates that the string contained is canonical and will exist for the duration of the process. See g_value_set_interned_string().

If passed to G_VALUE_COLLECT(), allocated data won't be copied but used verbatim. This does not affect ref-counted types like objects. This does not affect usage of g_value_copy(), the data will be copied if it is not ref-counted.

Returns the #GEnumValue for a value.

Looks up a #GEnumValue by name.

Looks up a #GEnumValue by nickname.

Registers a new static enumeration type with the name @name.

Returns the first #GFlagsValue which is set in @value.

Looks up a #GFlagsValue by name.

Looks up a #GFlagsValue by nickname.

Registers a new static flags type with the name @name.

Creates a new #GParamSpecBoolean instance specifying a %G_TYPE_BOOLEAN property. 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 breaking API.

Creates a new #GParamSpecBoxed instance specifying a %G_TYPE_BOXED derived property.

Creates a new #GParamSpecDouble instance specifying a %G_TYPE_DOUBLE property.

Creates a new #GParamSpecEnum instance specifying a %G_TYPE_ENUM property.

Creates a new #GParamSpecFlags instance specifying a %G_TYPE_FLAGS property.

Creates a new #GParamSpecFloat instance specifying a %G_TYPE_FLOAT property.

Creates a new #GParamSpecGType instance specifying a %G_TYPE_GTYPE property.

Creates a new #GParamSpecInt instance specifying a %G_TYPE_INT property.

Creates a new #GParamSpecInt64 instance specifying a %G_TYPE_INT64 property.

Creates a new #GParamSpecLong instance specifying a %G_TYPE_LONG property.

Creates a new #GParamSpecBoxed instance specifying a %G_TYPE_OBJECT derived property.

Creates a new #GParamSpecParam instance specifying a %G_TYPE_PARAM property.

Creates a new #GParamSpecPointer instance specifying a pointer property. Where possible, it is better to use g_param_spec_object() or g_param_spec_boxed() to expose memory management information.

Creates a new #GParamSpecString instance.

Creates a new #GParamSpecUInt instance specifying a %G_TYPE_UINT property.

Creates a new #GParamSpecUInt64 instance specifying a %G_TYPE_UINT64 property.

Creates a new #GParamSpecULong instance specifying a %G_TYPE_ULONG property.

Creates a new #GParamSpecUnichar instance specifying a %G_TYPE_UINT property. #GValue structures for this property can be accessed with g_value_set_uint() and g_value_get_uint().

Creates a new #GParamSpecVariant instance specifying a #GVariant property.

Registers @name as the name of a new static type derived from %G_TYPE_PARAM.

Transforms @src_value into @dest_value if possible, and then validates @dest_value, in order for it to conform to @pspec. If

Checks whether @value contains the default value as specified in @pspec.

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.

Sets @value to its default value as specified in @pspec.

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.

Creates a new %G_TYPE_POINTER derived type id for a new pointer type with name @name.

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.

Connects a closure to a signal for a particular object.

Connects a closure to a signal for a particular object.

Returns the invocation hint of the innermost signal emission of instance.

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.

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.

Returns whether @handler_id is the ID of a handler connected to @instance.

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.

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).

Returns whether there are any handlers connected to @instance for the given signal id and detail.

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.

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.

Given the signal's identifier, finds its name.

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.

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 #GSignalQuery is 0. All members filled into the #GSignalQuery structure should be considered constant and have to be left untouched.

Deletes an emission hook.

Stops a signal's current emission.

Stops a signal's current emission.

Creates a new closure which invokes the function found at the offset

Set the callback for a source as a #GClosure.

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.)

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.

Adds @interface_type to the dynamic @instance_type. The information contained in the #GTypePlugin structure pointed to by @plugin is used to manage the relationship.

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.

Private helper function to aid implementation of the G_TYPE_CHECK_INSTANCE() macro.

This function is essentially the same as g_type_class_ref(), except that the classes reference count isn't incremented. As a consequence, this function may return null if the class of the type passed in does not currently exist (hasn't been referenced before).

A more efficient version of g_type_class_peek() which works only for static types.

Increments the reference count of the class structure belonging to

If the interface type @g_type is currently in use, returns its default interface vtable.

Increments the reference count for the interface type @g_type, and returns the default interface vtable for the type.

Decrements the reference count for the type corresponding to the interface default vtable @g_iface. If the type is dynamic, then when no one is using the interface and all references have been released, the finalize function for the interface's default vtable (the @class_finalize member of #GTypeInfo) will be called.

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.

Ensures that the indicated @type has been registered with the type system, and its _class_init() method has been run.

Frees an instance of a type, returning it to the instance pool for the type, if there is one.

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).

Internal function, used to extract the fundamental type ID portion. Use G_TYPE_FUNDAMENTAL() instead.

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.

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_DEBUG variable to include instance-count).

Returns the #GTypePlugin structure for @type.

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.

This function used to initialise the type system. Since GLib 2.36, the type system is initialised automatically and this function does nothing.

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.

Adds @prerequisite_type to the list of prerequisites of @interface_type. This means that any type implementing @interface_type must also implement

Returns the #GTypePlugin structure for the dynamic interface

Returns the most specific instantiatable prerequisite of an interface type. If the interface type has no instantiatable prerequisite, %G_TYPE_INVALID is returned.

Returns the #GTypeInterface structure of an interface to which the passed in class conforms.

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.

Get the unique name that is assigned to a type ID. Note that this function (like all other GType API) cannot cope with invalid type IDs. %G_TYPE_INVALID may be passed to this function, as may be any other validly registered type ID, but randomized type IDs should not be passed in and will most likely lead to a crash.

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 of

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.

Get the corresponding quark of the type IDs name.

Queries the type system for information about a specific type. This function will fill in a user-provided structure to hold type-specific information. If an invalid #GType is passed in, the

Registers @type_name as the name of a new dynamic type derived from

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 by

Registers @type_name as the name of a new static type derived from

Returns whether a #GValue of type @src_type can be copied into a #GValue of type @dest_type.

Check whether g_value_transform() is able to transform values of type @src_type into values of type @dest_type. Note that for the types to be transformable, they must be compatible or a transformation function must be registered.