Signals

struct Signals {}

Members

Static functions

accumulatorFirstWins
bool accumulatorFirstWins(GSignalInvocationHint* ihint, Value returnAccu, 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).

accumulatorTrueHandled
bool accumulatorTrueHandled(GSignalInvocationHint* ihint, Value returnAccu, 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.

addEmissionHook
gulong addEmissionHook(uint signalId, GQuark detail, GSignalEmissionHook hookFunc, void* hookData, GDestroyNotify dataDestroy)

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.

chainFromOverridden
void chainFromOverridden(Value[] instanceAndParams, Value returnValue)

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

connect
gulong connect(ObjectG instance, string detailedSignal, T callback, ConnectFlags connectFlags)

Connects a callback to a signal for a particular object.

connect
gulong connect(ObjectG instanc, string detailedSignal, GCallback cHandler, void* data)

Connects a GCallback function to a signal for a particular object.

connectClosure
gulong connectClosure(ObjectG instance_, string detailedSignal, Closure closure, bool after)

Connects a closure to a signal for a particular object.

connectClosureById
gulong connectClosureById(ObjectG instance_, uint signalId, GQuark detail, Closure closure, bool after)

Connects a closure to a signal for a particular object.

connectData
deprecated gulong connectData(void* instanc, string detailedSignal, GCallback cHandler, Object data, GClosureNotify destroyData, GConnectFlags connectFlags)
Undocumented in source. Be warned that the author may not have intended to support it.
connectData
gulong connectData(ObjectG instance_, string detailedSignal, GCallback cHandler, void* data, GClosureNotify destroyData, GConnectFlags connectFlags)

Connects a #GCallback function to a signal for a particular object. Similar to g_signal_connect(), but allows to provide a #GClosureNotify for the data which will be called when the signal handler is disconnected and no longer used. Specify @connect_flags if you need ..._after() or ..._swapped() variants of this function.

connectObject
gulong connectObject(TypeInstance instance_, string detailedSignal, GCallback cHandler, ObjectG gobject, GConnectFlags connectFlags)

This is similar to g_signal_connect_data(), but uses a closure which ensures that the @gobject stays alive during the call to @c_handler by temporarily adding a reference count to @gobject.

emitValist
void emitValist(TypeInstance instance_, uint signalId, GQuark detail, void* varArgs)

Emits a signal.

emitv
void emitv(Value[] instanceAndParams, uint signalId, GQuark detail, Value returnValue)

Emits a signal.

getInvocationHint
GSignalInvocationHint* getInvocationHint(ObjectG instance_)

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

handlerBlock
void handlerBlock(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 deactive it, a signal handler has to be unblocked exactly the same amount of times it has been blocked before to become active again.

handlerDisconnect
void handlerDisconnect(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.

handlerFind
gulong handlerFind(ObjectG instance_, GSignalMatchType mask, uint signalId, GQuark detail, Closure closure, void* func, void* data)

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.

handlerIsConnected
bool handlerIsConnected(ObjectG instance_, gulong handlerId)

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

handlerUnblock
void handlerUnblock(ObjectG instance_, gulong handlerId)

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

handlersBlockMatched
uint handlersBlockMatched(ObjectG instance_, GSignalMatchType mask, uint signalId, GQuark detail, Closure closure, void* func, void* data)

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

handlersDestroy
void handlersDestroy(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.

handlersDisconnectMatched
uint handlersDisconnectMatched(ObjectG instance_, GSignalMatchType mask, uint signalId, GQuark detail, Closure closure, void* func, void* data)

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

handlersUnblockMatched
uint handlersUnblockMatched(ObjectG instance_, GSignalMatchType mask, uint signalId, GQuark detail, Closure closure, void* func, void* data)

Unblocks all handlers on an instance that match a certain selection criteria. The criteria mask is passed as an OR-ed combination of #GSignalMatchType flags, and the criteria values are passed as arguments. Passing at least one of the %G_SIGNAL_MATCH_CLOSURE, %G_SIGNAL_MATCH_FUNC or %G_SIGNAL_MATCH_DATA 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.

hasHandlerPending
bool hasHandlerPending(ObjectG instance_, uint signalId, GQuark detail, bool mayBeBlocked)

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

listIds
uint[] listIds(GType itype)

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

lookup
uint lookup(string name, 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.

name
string name(uint signalId)

Given the signal's identifier, finds its name.

newValist
uint newValist(string signalName, GType itype, GSignalFlags signalFlags, Closure classClosure, GSignalAccumulator accumulator, void* accuData, GSignalCMarshaller cMarshaller, GType returnType, uint nParams, void* args)

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

newv
uint newv(string signalName, GType itype, GSignalFlags signalFlags, Closure classClosure, GSignalAccumulator accumulator, void* accuData, GSignalCMarshaller cMarshaller, GType returnType, GType[] paramTypes)

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

overrideClassClosure
void overrideClassClosure(uint signalId, GType instanceType, 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.

overrideClassHandler
void overrideClassHandler(string signalName, GType instanceType, GCallback classHandler)

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

parseName
bool parseName(string detailedSignal, GType itype, uint signalIdP, GQuark detailP, bool forceDetailQuark)

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

query
void query(uint signalId, GSignalQuery 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.

removeEmission
void removeEmission(uint signalId, gulong hookId)

Deletes an emission hook.

setVaMarshaller
void setVaMarshaller(uint signalId, GType instanceType, GSignalCVaMarshaller vaMarshaller)

Change the #GSignalCVaMarshaller used for a given signal. This is a specialised form of the marshaller that can often be used for the common case of a single connected signal handler and avoids the overhead of #GValue. Its use is optional.

stopEmission
void stopEmission(ObjectG instance_, uint signalId, GQuark detail)

Stops a signal's current emission.

stopEmissionByName
void stopEmissionByName(ObjectG instance_, string detailedSignal)

Stops a signal's current emission.

typeCclosureNew
Closure typeCclosureNew(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.

Meta