GObject

object GObject

Skipped during bindings generation

  • alias SignalCMarshaller: ClosureMarshal

  • parameter boxed_copy: BoxedCopyFunc

  • parameter handler_id_ptr: Unsupported pointer to primitive type

  • parameter info: info: Out parameter is not supported

  • parameter info: info: Out parameter is not supported

  • parameter instance_and_params: Value

  • function signal_chain_from_overridden_handler: Varargs parameter is not supported

  • parameter destroy_data: ClosureNotify

  • parameter c_handler: Callback

  • function signal_emit: Varargs parameter is not supported

  • function signal_emit_by_name: Varargs parameter is not supported

  • parameter var_args: va_list

  • function signal_emitv: In/Out parameter is not supported

  • parameter n_ids: n_ids: Out parameter is not supported

  • function signal_new: Varargs parameter is not supported

  • function signal_new_class_handler: Varargs parameter is not supported

  • parameter c_marshaller: ClosureMarshal

  • parameter c_marshaller: ClosureMarshal

  • parameter class_handler: Callback

  • parameter signal_id_p: signal_id_p: Out parameter is not supported

  • parameter cache_func: TypeClassCacheFunc

  • parameter check_func: TypeInterfaceCheckFunc

  • parameter n_children: n_children: Out parameter is not supported

  • parameter n_interfaces: n_interfaces: Out parameter is not supported

  • parameter class_init: ClassInitFunc

  • parameter cache_func: TypeClassCacheFunc

  • parameter check_func: TypeInterfaceCheckFunc

  • record InitiallyUnownedClass: glib type struct are ignored

  • record ParamSpecClass: glib type struct are ignored

  • record TypeModuleClass: glib type struct are ignored

  • union _Value__data__union: Missing cType on union

Properties

Link copied to clipboard
const val PARAM_MASK: <Error class: unknown class>

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

Link copied to clipboard
const val PARAM_STATIC_STRINGS: <Error class: unknown class> = 224

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

Link copied to clipboard
const val PARAM_USER_SHIFT: <Error class: unknown class> = 8

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

Link copied to clipboard
const val SIGNAL_FLAGS_MASK: <Error class: unknown class> = 511

A mask for all #GSignalFlags bits.

Link copied to clipboard
const val SIGNAL_MATCH_MASK: <Error class: unknown class> = 63

A mask for all #GSignalMatchType bits.

Link copied to clipboard
const val TYPE_FLAG_RESERVED_ID_BIT: <Error class: unknown class>

A bit in the type number that's supposed to be left untouched.

Link copied to clipboard
const val TYPE_FUNDAMENTAL_MAX: <Error class: unknown class> = 1020

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

Link copied to clipboard
const val TYPE_FUNDAMENTAL_SHIFT: <Error class: unknown class> = 2

Shift value used in converting numbers to type IDs.

Link copied to clipboard
const val TYPE_RESERVED_BSE_FIRST: <Error class: unknown class> = 32

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

Link copied to clipboard
const val TYPE_RESERVED_BSE_LAST: <Error class: unknown class> = 48

Last fundamental type number reserved for BSE.

Link copied to clipboard
const val TYPE_RESERVED_GLIB_FIRST: <Error class: unknown class> = 22

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

Link copied to clipboard
const val TYPE_RESERVED_GLIB_LAST: <Error class: unknown class> = 31

Last fundamental type number reserved for GLib.

Link copied to clipboard
const val TYPE_RESERVED_USER_FIRST: <Error class: unknown class> = 49

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

Link copied to clipboard
const val VALUE_COLLECT_FORMAT_MAX_LENGTH: <Error class: unknown class> = 8

The maximal number of #GTypeCValues which can be collected for a single #GValue.

Link copied to clipboard
const val VALUE_INTERNED_STRING: <Error class: unknown class> = 268435456

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

Link copied to clipboard
const val VALUE_NOCOPY_CONTENTS: <Error class: unknown class> = 134217728

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.

Functions

Link copied to clipboard
fun boxedCopy(boxedType: <Error class: unknown class>, srcBoxed: <Error class: unknown class>): <Error class: unknown class>

Provide a copy of a boxed structure @src_boxed which is of type @boxed_type.

Link copied to clipboard
fun boxedFree(boxedType: <Error class: unknown class>, boxed: <Error class: unknown class>)

Free the boxed structure @boxed which is of type @boxed_type.

Link copied to clipboard
fun clearObject(objectPtr: Object)

Clears a reference to a #GObject.

Link copied to clipboard
fun enumGetValue(enumClass: EnumClass, value: <Error class: unknown class>): EnumValue?

Returns the #GEnumValue for a value.

Link copied to clipboard
fun enumGetValueByName(enumClass: EnumClass, name: String): EnumValue?

Looks up a #GEnumValue by name.

Link copied to clipboard
fun enumGetValueByNick(enumClass: EnumClass, nick: String): EnumValue?

Looks up a #GEnumValue by nickname.

Link copied to clipboard
fun enumRegisterStatic(name: String, constStaticValues: EnumValue): <Error class: unknown class>

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

Link copied to clipboard
fun enumToString(gEnumType: <Error class: unknown class>, value: <Error class: unknown class>): String

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

Link copied to clipboard
fun flagsGetFirstValue(flagsClass: FlagsClass, value: <Error class: unknown class>): FlagsValue?

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

Link copied to clipboard

Looks up a #GFlagsValue by name.

Link copied to clipboard

Looks up a #GFlagsValue by nickname.

Link copied to clipboard
fun flagsRegisterStatic(name: String, constStaticValues: FlagsValue): <Error class: unknown class>

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

Link copied to clipboard
fun flagsToString(flagsType: <Error class: unknown class>, value: <Error class: unknown class>): 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.

Link copied to clipboard
fun gtypeGetType(): <Error class: unknown class>
Link copied to clipboard
fun paramSpecBoolean(name: String, nick: String? = null, blurb: String? = null, defaultValue: Boolean, flags: ParamFlags): ParamSpec

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.

Link copied to clipboard
fun paramSpecBoxed(name: String, nick: String? = null, blurb: String? = null, boxedType: <Error class: unknown class>, flags: ParamFlags): ParamSpec

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

Link copied to clipboard
fun paramSpecChar(name: String, nick: String? = null, blurb: String? = null, minimum: <Error class: unknown class>, maximum: <Error class: unknown class>, defaultValue: <Error class: unknown class>, flags: ParamFlags): ParamSpec

Creates a new #GParamSpecChar instance specifying a %G_TYPE_CHAR property.

Link copied to clipboard
fun paramSpecDouble(name: String, nick: String? = null, blurb: String? = null, minimum: <Error class: unknown class>, maximum: <Error class: unknown class>, defaultValue: <Error class: unknown class>, flags: ParamFlags): ParamSpec

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

Link copied to clipboard
fun paramSpecEnum(name: String, nick: String? = null, blurb: String? = null, enumType: <Error class: unknown class>, defaultValue: <Error class: unknown class>, flags: ParamFlags): ParamSpec

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

Link copied to clipboard
fun paramSpecFlags(name: String, nick: String? = null, blurb: String? = null, flagsType: <Error class: unknown class>, defaultValue: <Error class: unknown class>, flags: ParamFlags): ParamSpec

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

Link copied to clipboard
fun paramSpecFloat(name: String, nick: String? = null, blurb: String? = null, minimum: <Error class: unknown class>, maximum: <Error class: unknown class>, defaultValue: <Error class: unknown class>, flags: ParamFlags): ParamSpec

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

Link copied to clipboard
fun paramSpecGtype(name: String, nick: String? = null, blurb: String? = null, isAType: <Error class: unknown class>, flags: ParamFlags): ParamSpec

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

Link copied to clipboard
fun paramSpecInt(name: String, nick: String? = null, blurb: String? = null, minimum: <Error class: unknown class>, maximum: <Error class: unknown class>, defaultValue: <Error class: unknown class>, flags: ParamFlags): ParamSpec

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

Link copied to clipboard
fun paramSpecInt64(name: String, nick: String? = null, blurb: String? = null, minimum: <Error class: unknown class>, maximum: <Error class: unknown class>, defaultValue: <Error class: unknown class>, flags: ParamFlags): ParamSpec

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

Link copied to clipboard
fun paramSpecLong(name: String, nick: String? = null, blurb: String? = null, minimum: <Error class: unknown class>, maximum: <Error class: unknown class>, defaultValue: <Error class: unknown class>, flags: ParamFlags): ParamSpec

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

Link copied to clipboard
fun paramSpecObject(name: String, nick: String? = null, blurb: String? = null, objectType: <Error class: unknown class>, flags: ParamFlags): ParamSpec

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

Link copied to clipboard
fun paramSpecOverride(name: String, overridden: ParamSpec): ParamSpec

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.

Link copied to clipboard
fun paramSpecParam(name: String, nick: String? = null, blurb: String? = null, paramType: <Error class: unknown class>, flags: ParamFlags): ParamSpec

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

Link copied to clipboard
fun paramSpecPointer(name: String, nick: String? = null, blurb: String? = null, flags: ParamFlags): ParamSpec

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.

Link copied to clipboard
fun paramSpecString(name: String, nick: String? = null, blurb: String? = null, defaultValue: String? = null, flags: ParamFlags): ParamSpec

Creates a new #GParamSpecString instance.

Link copied to clipboard
fun paramSpecUchar(name: String, nick: String? = null, blurb: String? = null, minimum: <Error class: unknown class>, maximum: <Error class: unknown class>, defaultValue: <Error class: unknown class>, flags: ParamFlags): ParamSpec

Creates a new #GParamSpecUChar instance specifying a %G_TYPE_UCHAR property.

Link copied to clipboard
fun paramSpecUint(name: String, nick: String? = null, blurb: String? = null, minimum: <Error class: unknown class>, maximum: <Error class: unknown class>, defaultValue: <Error class: unknown class>, flags: ParamFlags): ParamSpec

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

Link copied to clipboard
fun paramSpecUint64(name: String, nick: String? = null, blurb: String? = null, minimum: <Error class: unknown class>, maximum: <Error class: unknown class>, defaultValue: <Error class: unknown class>, flags: ParamFlags): ParamSpec

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

Link copied to clipboard
fun paramSpecUlong(name: String, nick: String? = null, blurb: String? = null, minimum: <Error class: unknown class>, maximum: <Error class: unknown class>, defaultValue: <Error class: unknown class>, flags: ParamFlags): ParamSpec

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

Link copied to clipboard
fun paramSpecUnichar(name: String, nick: String? = null, blurb: String? = null, defaultValue: <Error class: unknown class>, flags: ParamFlags): ParamSpec

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

Link copied to clipboard
fun paramSpecValueArray(name: String, nick: String? = null, blurb: String? = null, elementSpec: ParamSpec, flags: ParamFlags): ParamSpec

Creates a new #GParamSpecValueArray instance specifying a %G_TYPE_VALUE_ARRAY property. %G_TYPE_VALUE_ARRAY is a %G_TYPE_BOXED type, as such, #GValue structures for this property can be accessed with g_value_set_boxed() and g_value_get_boxed().

Link copied to clipboard
fun paramSpecVariant(name: String, nick: String? = null, blurb: String? = null, type: <Error class: unknown class>, defaultValue: <Error class: unknown class>? = null, flags: ParamFlags): ParamSpec

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

Link copied to clipboard
fun paramTypeRegisterStatic(name: String, pspecInfo: ParamSpecTypeInfo): <Error class: unknown class>

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

Link copied to clipboard
fun paramValueConvert(pspec: ParamSpec, srcValue: Value, destValue: Value, strictValidation: Boolean): Boolean

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

Link copied to clipboard

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

Link copied to clipboard

Return whether the contents of @value comply with the specifications set out by @pspec.

Link copied to clipboard
fun paramValuesCmp(pspec: ParamSpec, value1: Value, value2: Value): <Error class: unknown class>

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.

Link copied to clipboard

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

Link copied to clipboard

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.

Link copied to clipboard
fun pointerTypeRegisterStatic(name: String): <Error class: unknown class>

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

Link copied to clipboard
fun signalAccumulatorFirstWins(ihint: SignalInvocationHint, returnAccu: Value, handlerReturn: Value, dummy: <Error class: unknown class>? = null): Boolean

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

Link copied to clipboard
fun signalAccumulatorTrueHandled(ihint: SignalInvocationHint, returnAccu: Value, handlerReturn: Value, dummy: <Error class: unknown class>? = null): Boolean

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.

Link copied to clipboard
fun signalAddEmissionHook(signalId: <Error class: unknown class>, detail: <Error class: unknown class>, hookFunc: SignalEmissionHook): <Error class: unknown class>

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.

Link copied to clipboard
fun signalConnectClosure(instance: Object, detailedSignal: String, closure: Closure, after: Boolean): <Error class: unknown class>

Connects a closure to a signal for a particular object.

Link copied to clipboard
fun signalConnectClosureById(instance: Object, signalId: <Error class: unknown class>, detail: <Error class: unknown class>, closure: Closure, after: Boolean): <Error class: unknown class>

Connects a closure to a signal for a particular object.

Link copied to clipboard

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

Link copied to clipboard
fun signalHandlerBlock(instance: Object, handlerId: <Error class: unknown class>)

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.

Link copied to clipboard
fun signalHandlerDisconnect(instance: Object, handlerId: <Error class: unknown class>)

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.

Link copied to clipboard
fun signalHandlerFind(instance: Object, mask: SignalMatchType, signalId: <Error class: unknown class>, detail: <Error class: unknown class>, closure: Closure? = null, func: <Error class: unknown class>? = null, data: <Error class: unknown class>? = null): <Error class: unknown class>

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

Link copied to clipboard
fun signalHandlerIsConnected(instance: Object, handlerId: <Error class: unknown class>): Boolean

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

Link copied to clipboard
fun signalHandlersBlockMatched(instance: Object, mask: SignalMatchType, signalId: <Error class: unknown class>, detail: <Error class: unknown class>, closure: Closure? = null, func: <Error class: unknown class>? = null, data: <Error class: unknown class>? = null): <Error class: unknown class>

Blocks all handlers on an instance that match a certain selection criteria.

Link copied to clipboard

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.

Link copied to clipboard
fun signalHandlersDisconnectMatched(instance: Object, mask: SignalMatchType, signalId: <Error class: unknown class>, detail: <Error class: unknown class>, closure: Closure? = null, func: <Error class: unknown class>? = null, data: <Error class: unknown class>? = null): <Error class: unknown class>

Disconnects all handlers on an instance that match a certain selection criteria.

Link copied to clipboard
fun signalHandlersUnblockMatched(instance: Object, mask: SignalMatchType, signalId: <Error class: unknown class>, detail: <Error class: unknown class>, closure: Closure? = null, func: <Error class: unknown class>? = null, data: <Error class: unknown class>? = null): <Error class: unknown class>

Unblocks all handlers on an instance that match a certain selection criteria.

Link copied to clipboard
fun signalHandlerUnblock(instance: Object, handlerId: <Error class: unknown class>)

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

Link copied to clipboard
fun signalHasHandlerPending(instance: Object, signalId: <Error class: unknown class>, detail: <Error class: unknown class>, mayBeBlocked: Boolean): Boolean

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

Link copied to clipboard

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.

Link copied to clipboard
fun signalLookup(name: String, itype: <Error class: unknown class>): <Error class: unknown class>

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.

Link copied to clipboard
fun signalName(signalId: <Error class: unknown class>): String?

Given the signal's identifier, finds its name.

Link copied to clipboard
fun signalOverrideClassClosure(signalId: <Error class: unknown class>, instanceType: <Error class: unknown class>, classClosure: 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.

Link copied to clipboard
fun signalQuery(signalId: <Error class: unknown class>, query: SignalQuery)

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.

Link copied to clipboard
fun signalRemoveEmissionHook(signalId: <Error class: unknown class>, hookId: <Error class: unknown class>)

Deletes an emission hook.

Link copied to clipboard
fun signalStopEmission(instance: Object, signalId: <Error class: unknown class>, detail: <Error class: unknown class>)

Stops a signal's current emission.

Link copied to clipboard
fun signalStopEmissionByName(instance: Object, detailedSignal: String)

Stops a signal's current emission.

Link copied to clipboard
fun signalTypeCclosureNew(itype: <Error class: unknown class>, structOffset: <Error class: unknown class>): Closure

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

Link copied to clipboard

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

Link copied to clipboard
fun typeAddClassPrivate(classType: <Error class: unknown class>, privateSize: <Error class: unknown class>)

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.

Link copied to clipboard
fun typeAddInstancePrivate(classType: <Error class: unknown class>, privateSize: <Error class: unknown class>): <Error class: unknown class>
Link copied to clipboard
fun typeAddInterfaceDynamic(instanceType: <Error class: unknown class>, interfaceType: <Error class: unknown class>, plugin: TypePlugin)

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.

Link copied to clipboard
fun typeAddInterfaceStatic(instanceType: <Error class: unknown class>, interfaceType: <Error class: unknown class>, info: InterfaceInfo)

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.

Link copied to clipboard
fun typeCheckClassCast(gClass: TypeClass, isAType: <Error class: unknown class>): TypeClass
Link copied to clipboard
fun typeCheckClassIsA(gClass: TypeClass, isAType: <Error class: unknown class>): Boolean
Link copied to clipboard

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

Link copied to clipboard
fun typeCheckInstanceCast(instance: TypeInstance, ifaceType: <Error class: unknown class>): TypeInstance
Link copied to clipboard
fun typeCheckInstanceIsA(instance: TypeInstance, ifaceType: <Error class: unknown class>): Boolean
Link copied to clipboard
fun typeCheckInstanceIsFundamentallyA(instance: TypeInstance, fundamentalType: <Error class: unknown class>): Boolean
Link copied to clipboard
fun typeCheckIsValueType(type: <Error class: unknown class>): Boolean
Link copied to clipboard
Link copied to clipboard
fun typeCheckValueHolds(value: Value, type: <Error class: unknown class>): Boolean
Link copied to clipboard
fun typeCreateInstance(type: <Error class: unknown class>): TypeInstance

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 the #GObject 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.

Link copied to clipboard
fun typeDefaultInterfacePeek(gType: <Error class: unknown class>): TypeInterface

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

Link copied to clipboard
fun typeDefaultInterfaceRef(gType: <Error class: unknown class>): TypeInterface

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

Link copied to clipboard

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.

Link copied to clipboard
fun typeDepth(type: <Error class: unknown class>): <Error class: unknown class>

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.

Link copied to clipboard
fun typeEnsure(type: <Error class: unknown class>)

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

Link copied to clipboard

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

Link copied to clipboard
fun typeFromName(name: String): <Error class: unknown class>

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

Link copied to clipboard
fun typeFundamental(typeId: <Error class: unknown class>): <Error class: unknown class>

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

Link copied to clipboard
fun typeFundamentalNext(): <Error class: unknown class>

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.

Link copied to clipboard
fun typeGetInstanceCount(type: <Error class: unknown class>): <Error class: unknown class>

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

Link copied to clipboard
fun typeGetPlugin(type: <Error class: unknown class>): TypePlugin

Returns the #GTypePlugin structure for @type.

Link copied to clipboard
fun typeGetQdata(type: <Error class: unknown class>, quark: <Error class: unknown class>): <Error class: unknown class>?

Obtains data which has previously been attached to @type with g_type_set_qdata().

Link copied to clipboard
fun typeGetTypeRegistrationSerial(): <Error class: unknown class>

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.

Link copied to clipboard
fun typeInit()

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

Link copied to clipboard

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.

Link copied to clipboard
fun typeIsA(type: <Error class: unknown class>, isAType: <Error class: unknown class>): Boolean

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.

Link copied to clipboard
fun typeName(type: <Error class: unknown class>): String?

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.

Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
fun typeNextBase(leafType: <Error class: unknown class>, rootType: <Error class: unknown class>): <Error class: unknown class>

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

Link copied to clipboard
fun typeParent(type: <Error class: unknown class>): <Error class: unknown class>

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.

Link copied to clipboard
fun typeQname(type: <Error class: unknown class>): <Error class: unknown class>

Get the corresponding quark of the type IDs name.

Link copied to clipboard
fun typeQuery(type: <Error class: unknown class>, query: TypeQuery)

Queries the type system for information about a specific type.

Link copied to clipboard
fun typeRegisterDynamic(parentType: <Error class: unknown class>, typeName: String, plugin: TypePlugin, flags: TypeFlags): <Error class: unknown class>

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

Link copied to clipboard
fun typeRegisterFundamental(typeId: <Error class: unknown class>, typeName: String, info: TypeInfo, finfo: TypeFundamentalInfo, flags: TypeFlags): <Error class: unknown class>

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

Link copied to clipboard
fun typeRegisterStatic(parentType: <Error class: unknown class>, typeName: String, info: TypeInfo, flags: TypeFlags): <Error class: unknown class>

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

Link copied to clipboard
fun typeSetQdata(type: <Error class: unknown class>, quark: <Error class: unknown class>, data: <Error class: unknown class>? = null)

Attaches arbitrary data to a type.

Link copied to clipboard
fun typeTestFlags(type: <Error class: unknown class>, flags: <Error class: unknown class>): Boolean
Link copied to clipboard
fun variantGetGtype(): <Error class: unknown class>