gobject.global

Undocumented in source.

Members

Functions

boxedCopy
void* boxedCopy(gobject.types.GType boxedType, const(void)* srcBoxed)

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

boxedFree
void boxedFree(gobject.types.GType boxedType, void* boxed)

Free the boxed structure boxed which is of type boxed_type.

clearSignalHandler
void clearSignalHandler(gulong handlerIdPtr, gobject.object.ObjectG instance)

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

enumGetValue
gobject.enum_value.EnumValue enumGetValue(gobject.enum_class.EnumClass enumClass, int value)

Returns the #GEnumValue for a value.

enumGetValueByName
gobject.enum_value.EnumValue enumGetValueByName(gobject.enum_class.EnumClass enumClass, string name)

Looks up a #GEnumValue by name.

enumGetValueByNick
gobject.enum_value.EnumValue enumGetValueByNick(gobject.enum_class.EnumClass enumClass, string nick)

Looks up a #GEnumValue by nickname.

enumRegisterStatic
gobject.types.GType enumRegisterStatic(string name, gobject.enum_value.EnumValue constStaticValues)

Registers a new static enumeration type with the name name.

enumToString
string enumToString(gobject.types.GType gEnumType, int value)

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

flagsGetFirstValue
gobject.flags_value.FlagsValue flagsGetFirstValue(gobject.flags_class.FlagsClass flagsClass, uint value)

Returns the first #GFlagsValue which is set in value.

flagsGetValueByName
gobject.flags_value.FlagsValue flagsGetValueByName(gobject.flags_class.FlagsClass flagsClass, string name)

Looks up a #GFlagsValue by name.

flagsGetValueByNick
gobject.flags_value.FlagsValue flagsGetValueByNick(gobject.flags_class.FlagsClass flagsClass, string nick)

Looks up a #GFlagsValue by nickname.

flagsRegisterStatic
gobject.types.GType flagsRegisterStatic(string name, gobject.flags_value.FlagsValue constStaticValues)

Registers a new static flags type with the name name.

flagsToString
string flagsToString(gobject.types.GType flagsType, uint value)

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.

gtypeGetType
gobject.types.GType gtypeGetType()
paramSpecBoolean
gobject.param_spec.ParamSpec paramSpecBoolean(string name, string nick, string blurb, bool defaultValue, gobject.types.ParamFlags flags)

Creates a new #GParamSpecBoolean instance specifying a G_TYPE_BOOLEAN property. In many cases, it may be more appropriate to use an enum with gobject.global.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.

paramSpecBoxed
gobject.param_spec.ParamSpec paramSpecBoxed(string name, string nick, string blurb, gobject.types.GType boxedType, gobject.types.ParamFlags flags)

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

paramSpecChar
gobject.param_spec.ParamSpec paramSpecChar(string name, string nick, string blurb, byte minimum, byte maximum, byte defaultValue, gobject.types.ParamFlags flags)

Creates a new #GParamSpecChar instance specifying a G_TYPE_CHAR property.

paramSpecDouble
gobject.param_spec.ParamSpec paramSpecDouble(string name, string nick, string blurb, double minimum, double maximum, double defaultValue, gobject.types.ParamFlags flags)

Creates a new #GParamSpecDouble instance specifying a G_TYPE_DOUBLE property.

paramSpecEnum
gobject.param_spec.ParamSpec paramSpecEnum(string name, string nick, string blurb, gobject.types.GType enumType, int defaultValue, gobject.types.ParamFlags flags)

Creates a new #GParamSpecEnum instance specifying a G_TYPE_ENUM property.

paramSpecFlags
gobject.param_spec.ParamSpec paramSpecFlags(string name, string nick, string blurb, gobject.types.GType flagsType, uint defaultValue, gobject.types.ParamFlags flags)

Creates a new #GParamSpecFlags instance specifying a G_TYPE_FLAGS property.

paramSpecFloat
gobject.param_spec.ParamSpec paramSpecFloat(string name, string nick, string blurb, float minimum, float maximum, float defaultValue, gobject.types.ParamFlags flags)

Creates a new #GParamSpecFloat instance specifying a G_TYPE_FLOAT property.

paramSpecGtype
gobject.param_spec.ParamSpec paramSpecGtype(string name, string nick, string blurb, gobject.types.GType isAType, gobject.types.ParamFlags flags)

Creates a new #GParamSpecGType instance specifying a G_TYPE_GTYPE property.

paramSpecInt
gobject.param_spec.ParamSpec paramSpecInt(string name, string nick, string blurb, int minimum, int maximum, int defaultValue, gobject.types.ParamFlags flags)

Creates a new #GParamSpecInt instance specifying a G_TYPE_INT property.

paramSpecInt64
gobject.param_spec.ParamSpec paramSpecInt64(string name, string nick, string blurb, long minimum, long maximum, long defaultValue, gobject.types.ParamFlags flags)

Creates a new #GParamSpecInt64 instance specifying a G_TYPE_INT64 property.

paramSpecLong
gobject.param_spec.ParamSpec paramSpecLong(string name, string nick, string blurb, glong minimum, glong maximum, glong defaultValue, gobject.types.ParamFlags flags)

Creates a new #GParamSpecLong instance specifying a G_TYPE_LONG property.

paramSpecObject
gobject.param_spec.ParamSpec paramSpecObject(string name, string nick, string blurb, gobject.types.GType objectType, gobject.types.ParamFlags flags)

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

paramSpecParam
gobject.param_spec.ParamSpec paramSpecParam(string name, string nick, string blurb, gobject.types.GType paramType, gobject.types.ParamFlags flags)

Creates a new #GParamSpecParam instance specifying a G_TYPE_PARAM property.

paramSpecPointer
gobject.param_spec.ParamSpec paramSpecPointer(string name, string nick, string blurb, gobject.types.ParamFlags flags)

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

paramSpecString
gobject.param_spec.ParamSpec paramSpecString(string name, string nick, string blurb, string defaultValue, gobject.types.ParamFlags flags)

Creates a new #GParamSpecString instance.

paramSpecUchar
gobject.param_spec.ParamSpec paramSpecUchar(string name, string nick, string blurb, ubyte minimum, ubyte maximum, ubyte defaultValue, gobject.types.ParamFlags flags)

Creates a new #GParamSpecUChar instance specifying a G_TYPE_UCHAR property.

paramSpecUint
gobject.param_spec.ParamSpec paramSpecUint(string name, string nick, string blurb, uint minimum, uint maximum, uint defaultValue, gobject.types.ParamFlags flags)

Creates a new #GParamSpecUInt instance specifying a G_TYPE_UINT property.

paramSpecUint64
gobject.param_spec.ParamSpec paramSpecUint64(string name, string nick, string blurb, ulong minimum, ulong maximum, ulong defaultValue, gobject.types.ParamFlags flags)

Creates a new #GParamSpecUInt64 instance specifying a G_TYPE_UINT64 property.

paramSpecUlong
gobject.param_spec.ParamSpec paramSpecUlong(string name, string nick, string blurb, gulong minimum, gulong maximum, gulong defaultValue, gobject.types.ParamFlags flags)

Creates a new #GParamSpecULong instance specifying a G_TYPE_ULONG property.

paramSpecUnichar
gobject.param_spec.ParamSpec paramSpecUnichar(string name, string nick, string blurb, dchar defaultValue, gobject.types.ParamFlags flags)

Creates a new #GParamSpecUnichar instance specifying a G_TYPE_UINT property. #GValue structures for this property can be accessed with gobject.value.Value.setUint and gobject.value.Value.getUint.

paramSpecVariant
gobject.param_spec.ParamSpec paramSpecVariant(string name, string nick, string blurb, glib.variant_type.VariantType type, glib.variant.VariantG defaultValue, gobject.types.ParamFlags flags)

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

paramTypeRegisterStatic
gobject.types.GType paramTypeRegisterStatic(string name, gobject.types.ParamSpecTypeInfo pspecInfo)

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

paramValueConvert
bool paramValueConvert(gobject.param_spec.ParamSpec pspec, gobject.value.Value srcValue, gobject.value.Value destValue, bool strictValidation)

Transforms src_value into dest_value if possible, and then validates dest_value, in order for it to conform to pspec. If strict_validation is true this function will only succeed if the transformed dest_value complied to pspec without modifications.

paramValueDefaults
bool paramValueDefaults(gobject.param_spec.ParamSpec pspec, gobject.value.Value value)

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

paramValueIsValid
bool paramValueIsValid(gobject.param_spec.ParamSpec pspec, gobject.value.Value value)

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

paramValueSetDefault
void paramValueSetDefault(gobject.param_spec.ParamSpec pspec, gobject.value.Value value)

Sets value to its default value as specified in pspec.

paramValueValidate
bool paramValueValidate(gobject.param_spec.ParamSpec pspec, gobject.value.Value value)

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.

paramValuesCmp
int paramValuesCmp(gobject.param_spec.ParamSpec pspec, gobject.value.Value value1, gobject.value.Value value2)

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.

pointerTypeRegisterStatic
gobject.types.GType pointerTypeRegisterStatic(string name)

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

setClosure
void setClosure(glib.source.Source source, gobject.closure.Closure closure)

Set the callback for a source as a #GClosure.

setDummyCallback
void setDummyCallback(glib.source.Source source)

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 gobject.value.Value.init_ initializes a #GValue to for that type.)

signalAccumulatorFirstWins
bool signalAccumulatorFirstWins(gobject.types.SignalInvocationHint ihint, gobject.value.Value returnAccu, gobject.value.Value handlerReturn, void* dummy)

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

signalAccumulatorTrueHandled
bool signalAccumulatorTrueHandled(gobject.types.SignalInvocationHint ihint, gobject.value.Value returnAccu, gobject.value.Value handlerReturn, void* dummy)

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.

signalAddEmissionHook
gulong signalAddEmissionHook(uint signalId, glib.types.Quark detail, gobject.types.SignalEmissionHook hookFunc)

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.

signalConnectClosure
gulong signalConnectClosure(gobject.object.ObjectG instance, string detailedSignal, gobject.closure.Closure closure, bool after)

Connects a closure to a signal for a particular object.

signalConnectClosureById
gulong signalConnectClosureById(gobject.object.ObjectG instance, uint signalId, glib.types.Quark detail, gobject.closure.Closure closure, bool after)

Connects a closure to a signal for a particular object.

signalGetInvocationHint
gobject.types.SignalInvocationHint signalGetInvocationHint(gobject.object.ObjectG instance)

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

signalHandlerBlock
void signalHandlerBlock(gobject.object.ObjectG instance, gulong handlerId)

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.

signalHandlerDisconnect
void signalHandlerDisconnect(gobject.object.ObjectG instance, gulong handlerId)

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.

signalHandlerFind
gulong signalHandlerFind(gobject.object.ObjectG instance, gobject.types.SignalMatchType mask, uint signalId, glib.types.Quark detail, gobject.closure.Closure closure, void* func)

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.

signalHandlerIsConnected
bool signalHandlerIsConnected(gobject.object.ObjectG instance, gulong handlerId)

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

signalHandlerUnblock
void signalHandlerUnblock(gobject.object.ObjectG instance, gulong handlerId)

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

signalHandlersBlockMatched
uint signalHandlersBlockMatched(gobject.object.ObjectG instance, gobject.types.SignalMatchType mask, uint signalId, glib.types.Quark detail, gobject.closure.Closure closure, void* func)

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

signalHandlersDestroy
void signalHandlersDestroy(gobject.object.ObjectG 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.

signalHandlersDisconnectMatched
uint signalHandlersDisconnectMatched(gobject.object.ObjectG instance, gobject.types.SignalMatchType mask, uint signalId, glib.types.Quark detail, gobject.closure.Closure closure, void* func)

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

signalHandlersUnblockMatched
uint signalHandlersUnblockMatched(gobject.object.ObjectG instance, gobject.types.SignalMatchType mask, uint signalId, glib.types.Quark detail, gobject.closure.Closure closure, void* func)

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

signalHasHandlerPending
bool signalHasHandlerPending(gobject.object.ObjectG instance, uint signalId, glib.types.Quark detail, bool mayBeBlocked)

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

signalIsValidName
bool signalIsValidName(string 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.

signalListIds
uint[] signalListIds(gobject.types.GType itype)

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

signalLookup
uint signalLookup(string name, gobject.types.GType itype)

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.

signalName
string signalName(uint signalId)

Given the signal's identifier, finds its name.

signalNewv
uint signalNewv(string signalName, gobject.types.GType itype, gobject.types.SignalFlags signalFlags, gobject.closure.Closure classClosure, gobject.types.SignalAccumulator accumulator, gobject.types.SignalCMarshaller cMarshaller, gobject.types.GType returnType, gobject.types.GType[] paramTypes)

Creates a new signal. (This is usually done in the class initializer.)

signalOverrideClassClosure
void signalOverrideClassClosure(uint signalId, gobject.types.GType instanceType, gobject.closure.Closure classClosure)

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.

signalParseName
bool signalParseName(string detailedSignal, gobject.types.GType itype, uint signalIdP, glib.types.Quark detailP, bool forceDetailQuark)

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

signalQuery
void signalQuery(uint signalId, gobject.signal_query.SignalQuery 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 #GSignalQuery is 0. All members filled into the #GSignalQuery structure should be considered constant and have to be left untouched.

signalRemoveEmissionHook
void signalRemoveEmissionHook(uint signalId, gulong hookId)

Deletes an emission hook.

signalStopEmission
void signalStopEmission(gobject.object.ObjectG instance, uint signalId, glib.types.Quark detail)

Stops a signal's current emission.

signalStopEmissionByName
void signalStopEmissionByName(gobject.object.ObjectG instance, string detailedSignal)

Stops a signal's current emission.

signalTypeCclosureNew
gobject.closure.Closure signalTypeCclosureNew(gobject.types.GType itype, uint structOffset)

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

strdupValueContents
string strdupValueContents(gobject.value.Value value)

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.

typeAddClassPrivate
void typeAddClassPrivate(gobject.types.GType classType, size_t privateSize)

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.

typeAddInstancePrivate
int typeAddInstancePrivate(gobject.types.GType classType, size_t privateSize)
typeCheckInstance
bool typeCheckInstance(gobject.type_instance.TypeInstance instance)

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

typeCheckInstanceIsA
bool typeCheckInstanceIsA(gobject.type_instance.TypeInstance instance, gobject.types.GType ifaceType)
typeCheckInstanceIsFundamentallyA
bool typeCheckInstanceIsFundamentallyA(gobject.type_instance.TypeInstance instance, gobject.types.GType fundamentalType)
typeCheckIsValueType
bool typeCheckIsValueType(gobject.types.GType type)
typeCheckValue
bool typeCheckValue(gobject.value.Value value)
typeCheckValueHolds
bool typeCheckValueHolds(gobject.value.Value value, gobject.types.GType type)
typeChildren
gobject.types.GType[] typeChildren(gobject.types.GType type)

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

typeDepth
uint typeDepth(gobject.types.GType type)

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.

typeEnsure
void typeEnsure(gobject.types.GType type)

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

typeFreeInstance
void typeFreeInstance(gobject.type_instance.TypeInstance instance)

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

typeFromName
gobject.types.GType typeFromName(string 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).

typeFundamental
gobject.types.GType typeFundamental(gobject.types.GType typeId)

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

typeFundamentalNext
gobject.types.GType typeFundamentalNext()

Returns the next free fundamental type id which can be used to register a new fundamental type with gobject.global.typeRegisterFundamental. The returned type ID represents the highest currently registered fundamental type identifier.

typeGetInstanceCount
int typeGetInstanceCount(gobject.types.GType type)

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

typeGetQdata
void* typeGetQdata(gobject.types.GType type, glib.types.Quark quark)

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

typeGetTypeRegistrationSerial
uint typeGetTypeRegistrationSerial()

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 gobject.global.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.

typeInit
void typeInit()

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

typeInitWithDebugFlags
void typeInitWithDebugFlags(gobject.types.TypeDebugFlags debugFlags)

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.

typeInterfaces
gobject.types.GType[] typeInterfaces(gobject.types.GType type)

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

typeIsA
bool typeIsA(gobject.types.GType type, gobject.types.GType isAType)

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.

typeName
string typeName(gobject.types.GType type)

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.

typeNameFromInstance
string typeNameFromInstance(gobject.type_instance.TypeInstance instance)
typeNextBase
gobject.types.GType typeNextBase(gobject.types.GType leafType, gobject.types.GType rootType)

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

typeParent
gobject.types.GType typeParent(gobject.types.GType 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.

typeQname
glib.types.Quark typeQname(gobject.types.GType type)

Get the corresponding quark of the type IDs name.

typeQuery
void typeQuery(gobject.types.GType type, gobject.type_query.TypeQuery query)

Queries the type system for information about a specific type.

typeSetQdata
void typeSetQdata(gobject.types.GType type, glib.types.Quark quark, void* data)

Attaches arbitrary data to a type.

typeTestFlags
bool typeTestFlags(gobject.types.GType type, uint flags)