Methods

Provide a copy of a boxed structure srcBoxed which is of type boxedType.

Free the boxed structure boxed which is of type boxedType.

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 handlerIdPtr is then set to zero, which is never a valid handler ID value (see g_signal_connect()).

If the handler ID is 0 then this function does nothing.

There is also a macro version of this function so that the code will be inlined.

Since: 2.62

This function is meant to be called from the complete_type_info function of a TypePlugin implementation, as in the following example:

C code

static void
my_enum_complete_type_info (GTypePlugin     *plugin,
                            GType            g_type,
                            GTypeInfo       *info,
                            GTypeValueTable *value_table)
{
  static const GEnumValue values[] = {
    { MY_ENUM_FOO, "MY_ENUM_FOO", "foo" },
    { MY_ENUM_BAR, "MY_ENUM_BAR", "bar" },
    { 0, NULL, NULL }
  };

  g_enum_complete_type_info (type, info, values);
}

Returns the EnumValue for a value.

Looks up a EnumValue by name.

Looks up a EnumValue by nickname.

Registers a new static enumeration type with the name name.

It is normally more convenient to let [glib-mkenums][glib-mkenums], generate a my_enum_get_type() function from a usual C enumeration definition than to write one yourself using enumRegisterStatic.

Pretty-prints value in the form of the enum’s name.

This is intended to be used for debugging purposes. The format of the output may change in the future.

Since: 2.54

This function is meant to be called from the complete_type_info() function of a TypePlugin implementation, see the example for enumCompleteTypeInfo above.

Returns the first FlagsValue which is set in value.

Looks up a FlagsValue by name.

Looks up a FlagsValue by nickname.

Registers a new static flags type with the name name.

It is normally more convenient to let [glib-mkenums][glib-mkenums] generate a my_flags_get_type() function from a usual C enumeration definition than to write one yourself using flagsRegisterStatic.

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.

This is intended to be used for debugging purposes. The format of the output may change in the future.

Since: 2.54

No description available in the introspection data.

Creates a new ParamSpecBoolean instance specifying a G_TYPE_BOOLEAN property. In many cases, it may be more appropriate to use an enum with paramSpecEnum, both to improve code clarity by using explicitly named values, and to allow for more values to be added in future without breaking API.

See g_param_spec_internal() for details on property names.

Creates a new ParamSpecBoxed instance specifying a G_TYPE_BOXED derived property.

See g_param_spec_internal() for details on property names.

Creates a new ParamSpecChar instance specifying a G_TYPE_CHAR property.

Creates a new ParamSpecDouble instance specifying a G_TYPE_DOUBLE property.

See g_param_spec_internal() for details on property names.

Creates a new ParamSpecEnum instance specifying a G_TYPE_ENUM property.

See g_param_spec_internal() for details on property names.

Creates a new ParamSpecFlags instance specifying a G_TYPE_FLAGS property.

See g_param_spec_internal() for details on property names.

Creates a new ParamSpecFloat instance specifying a G_TYPE_FLOAT property.

See g_param_spec_internal() for details on property names.

Creates a new ParamSpecGType instance specifying a G_TYPE_GTYPE property.

See g_param_spec_internal() for details on property names.

Since: 2.10

Creates a new ParamSpecInt instance specifying a G_TYPE_INT property.

See g_param_spec_internal() for details on property names.

Creates a new ParamSpecInt64 instance specifying a G_TYPE_INT64 property.

See g_param_spec_internal() for details on property names.

Creates a new ParamSpecLong instance specifying a G_TYPE_LONG property.

See g_param_spec_internal() for details on property names.

Creates a new ParamSpecBoxed instance specifying a G_TYPE_OBJECT derived property.

See g_param_spec_internal() for details on property names.

Creates a new ParamSpecParam instance specifying a G_TYPE_PARAM property.

See g_param_spec_internal() for details on property names.

Creates a new ParamSpecPointer instance specifying a pointer property. Where possible, it is better to use paramSpecObject or paramSpecBoxed to expose memory management information.

See g_param_spec_internal() for details on property names.

Creates a new ParamSpecString instance.

See g_param_spec_internal() for details on property names.

Creates a new ParamSpecUChar instance specifying a G_TYPE_UCHAR property.

Creates a new ParamSpecUInt instance specifying a G_TYPE_UINT property.

See g_param_spec_internal() for details on property names.

Creates a new ParamSpecUInt64 instance specifying a G_TYPE_UINT64 property.

See g_param_spec_internal() for details on property names.

Creates a new ParamSpecULong instance specifying a G_TYPE_ULONG property.

See g_param_spec_internal() for details on property names.

Creates a new ParamSpecUnichar instance specifying a G_TYPE_UINT property. Value structures for this property can be accessed with valueSetUint and valueGetUint.

See g_param_spec_internal() for details on property names.

Creates a new ParamSpecVariant instance specifying a GVariant property.

If defaultValue is floating, it is consumed.

See g_param_spec_internal() for details on property names.

Since: 2.26

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

The type system uses the information contained in the ParamSpecTypeInfo structure pointed to by info to manage the ParamSpec type and its instances.

Transforms srcValue into destValue if possible, and then validates destValue, in order for it to conform to pspec. If strictValidation is True this function will only succeed if the transformed destValue complied to pspec without modifications.

See also valueTypeTransformable, valueTransform and paramValueValidate.

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

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

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.

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

A predefined SignalAccumulator 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).

This accumulator will use the return value from the first signal handler that is run as the return value for the signal and not run any further handlers (ie: the first handler "wins").

Since: 2.28

A predefined SignalAccumulator 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

Calls the original class closure of a signal. This function should only be called from an overridden class closure; see signalOverrideClassClosure and g_signal_override_class_handler().

Connects a closure to a signal for a particular object.

Connects a closure to a signal for a particular object.

Emits a signal.

Note that signalEmitv doesn't change returnValue if no handlers are connected, in contrast to g_signal_emit() and g_signal_emit_valist().

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.

The handlerId has to be a valid signal handler id, connected to a signal of instance.

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 handlerId becomes invalid and may be reused.

The handlerId has to be a valid signal handler id, connected to a signal of instance.

Finds the first signal handler that matches certain selection criteria. The criteria mask is passed as an OR-ed combination of SignalMatchType flags, 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.

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

Undoes the effect of a previous signalHandlerBlock 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).

The handlerId has to be a valid id of a signal handler that is connected to a signal of instance and is currently blocked.

Blocks all handlers on an instance that match a certain selection criteria. The criteria mask is passed as an OR-ed combination of SignalMatchType flags, and the criteria values are passed as arguments. Passing at least one of the SignalMatchTypeClosure, SignalMatchTypeFunc or SignalMatchTypeData match flags is required for successful matches. If no handlers were found, 0 is returned, the number of blocked handlers otherwise.

Destroy all signal handlers of a type instance. This function is an implementation detail of the Object dispose implementation, and should not be used outside of the type system.

Disconnects all handlers on an instance that match a certain selection criteria. The criteria mask is passed as an OR-ed combination of SignalMatchType flags, and the criteria values are passed as arguments. Passing at least one of the SignalMatchTypeClosure, SignalMatchTypeFunc or SignalMatchTypeData match flags is required for successful matches. If no handlers were found, 0 is returned, the number of disconnected handlers otherwise.

Unblocks all handlers on an instance that match a certain selection criteria. The criteria mask is passed as an OR-ed combination of SignalMatchType flags, and the criteria values are passed as arguments. Passing at least one of the SignalMatchTypeClosure, SignalMatchTypeFunc or SignalMatchTypeData match flags is required for successful matches. If no handlers were found, 0 is returned, the number of unblocked handlers otherwise. The match criteria should not apply to any handlers that are not currently blocked.

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

If detail is 0 then it will only match handlers that were connected without detail. If detail is non-zero then it will match handlers connected both without detail and with the given detail. This is consistent with how a signal emitted with detail would be delivered to those handlers.

Since 2.46 this also checks for a non-default class closure being installed, as this is basically always what you want.

One example of when you might use this is when the arguments to the signal are difficult to compute. A class implementor may opt to not emit the signal if no one is attached anyway, thus saving the cost of building the arguments.

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.

See [canonical parameter names][canonical-parameter-names] for details of the rules for valid names. The rules for signal names are the same as those for property names.

Since: 2.66

Lists the signals by id that a certain instance or interface type created. Further information about the signals can be acquired through signalQuery.

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.

Also tries the ancestors of the given type.

The type class passed as itype must already have been instantiated (for example, using typeClassRef) for this function to work, as signals are always installed during class initialization.

See g_signal_new() for details on allowed signal names.

Given the signal's identifier, finds its name.

Two different signals may have the same name, if they have differing types.

Overrides the class closure (i.e. the default handler) for the given signal for emissions on instances of instanceType. instanceType must be derived from the type to which the signal belongs.

See signalChainFromOverridden and g_signal_chain_from_overridden_handler() for how to chain up to the parent class closure from inside the overridden one.

Internal function to parse a signal name into its signalId and detail quark.

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

Deletes an emission hook.

Stops a signal's current emission.

This will prevent the default method from running, if the signal was SignalFlagsRunLast and you connected normally (i.e. without the "after" flag).

Prints a warning if used on a signal which isn't being emitted.

Stops a signal's current emission.

This is just like signalStopEmission except it will look up the signal id for you.

Creates a new closure which invokes the function found at the offset structOffset in the class structure of the interface or classed type identified by itype.

Set the callback for a source as a Closure.

If the source is not one of the standard GLib types, the closureCallback and closureMarshal fields of the SourceFuncs structure must have been filled in with pointers to appropriate functions.

Sets a dummy callback for source. The callback will do nothing, and if the source expects a Bool return value, it will return True. (If the source expects any other type of return value, it will return a 0/Nothing value; whatever valueInit initializes a Value to for that type.)

If the source is not one of the standard GLib types, the closureCallback and closureMarshal fields of the SourceFuncs structure must have been filled in with pointers to appropriate functions.

Return a newly allocated string, which describes the contents of a Value. The main purpose of this function is to describe Value contents for debugging output, the way in which the contents are described may change between different GLib versions.

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.

This function should be called in the type's get_type() function after the type is registered. The private structure can be retrieved using the G_TYPE_CLASS_GET_PRIVATE() macro.

Since: 2.24

No description available in the introspection data.

Adds interfaceType to the dynamic instanceType. The information contained in the TypePlugin structure pointed to by plugin is used to manage the relationship.

Adds interfaceType to the static instanceType. The information contained in the InterfaceInfo structure pointed to by info is used to manage the relationship.

No description available in the introspection data.

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

No description available in the introspection data.

No description available in the introspection data.

No description available in the introspection data.

No description available in the introspection data.

No description available in the introspection data.

Return a newly allocated and 0-terminated array of type IDs, listing the child types of type.

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

Since: 2.4

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

If the type is not currently in use, then the default vtable for the type will be created and initialized by calling the base interface init and default vtable init functions for the type (the baseInit and classInit members of TypeInfo). Calling typeDefaultInterfaceRef is useful when you want to make sure that signals and properties for an interface have been installed.

Since: 2.4

Decrements the reference count for the type corresponding to the interface default vtable gIface. 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 classFinalize member of TypeInfo) will be called.

Since: 2.4

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.

In theory, simply calling the type's _get_type() method (or using the corresponding macro) is supposed take care of this. However, _get_type() methods are often marked G_GNUC_CONST for performance reasons, even though this is technically incorrect (since G_GNUC_CONST requires that the function not have side effects, which _get_type() methods do on the first call). As a result, if you write a bare call to a _get_type() macro, it may get optimized out by the compiler. Using typeEnsure guarantees that the type's _get_type() method is called.

Since: 2.34

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

Like g_type_create_instance(), this function is reserved for implementors of fundamental types.

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

Since: 2.44

Returns the TypePlugin structure for type.

Obtains data which has previously been attached to type with typeSetQdata.

Note that this does not take subtyping into account; data attached to one type with typeSetQdata cannot be retrieved from a subtype using typeGetQdata.

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

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.

If you need to enable debugging features, use the GOBJECT_DEBUG environment variable.

Return a newly allocated and 0-terminated array of type IDs, listing the interface types that type conforms to.

If isAType is a derivable type, check whether type is a descendant of isAType. If isAType 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.

No description available in the introspection data.

No description available in the introspection data.

Given a leafType and a rootType which is contained in its ancestry, return the type that rootType is the immediate parent of. In other words, this function determines the type that is derived directly from rootType which is also a base class of leafType. 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.

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

Registers typeName as the name of a new dynamic type derived from parentType. The type system uses the information contained in the TypePlugin 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.

Registers typeId as the predefined identifier and typeName as the name of a fundamental type. If typeId is already registered, or a type named typeName is already registered, the behaviour is undefined. The type system uses the information contained in the TypeInfo structure pointed to by info and the TypeFundamentalInfo structure pointed to by finfo to manage the type and its instances. The value of flags determines additional characteristics of the fundamental type.

Registers typeName as the name of a new static type derived from parentType. The type system uses the information contained in the TypeInfo 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.

Attaches arbitrary data to a type.

No description available in the introspection data.