Learn R Programming

RGtk2 (version 2.20.31)

GSignal: The GSignal API

Description

The basic concept of the signal system is that of the emission of a signal. Signals are introduced per-type and are identified through strings. Signals introduced for a parent type are available in derived types as well, so basically they are a per-type facility that is inherited.

Usage

gSignalConnect(obj, signal, f, data = NULL, after = FALSE, user.data.first = FALSE) gSignalHandlerDisconnect(obj, id) gSignalHandlerBlock(obj, id) gSignalHandlerUnblock(obj, id) gSignalEmit(obj, signal, ..., detail = NULL) gSignalStopEmission(obj, signal, detail = NULL) gSignalGetInfo(sig)

Arguments

obj
The object that owns the signal
signal
The detailed name of the signal
f
The R function to connect as a callback
data
Arbitrary "user data" that will be passed to the callback f
after
Whether f will be called before or after the default handler
user.data.first
Whether the data is the first or last argument to the callback
id
The signal handler id obtained upon connection to the signal
...
Arguments to pass to the signal handlers
detail
Optional separate argument for the detail portion of the signal
sig
A signal id provided by gObjectGetSignals.

Value

gSignalConnect returns a numeric id for the signal handler. It is used for blocking and disconnecting the handler.gSignalGetInfo returns detailed information about a signal. The returned list contains the following elements:
returnType
The return GType id of the signal
signal
The signal id
parameters
A list of GType ids for the parameters
objectType
The GType id owning the signal
runFlags
The flags determining behavior of the signal, see reference

Details

A signal emission mainly involves invocation of a certain set of callbacks in precisely defined manner. There are two main categories of such callbacks, per-object ones and user provided ones. The per-object callbacks are most often referred to as "object method handler" or "default (signal) handler", while user provided callbacks are usually just called "signal handler". The object method handler is provided at signal creation time (this most frequently happens at the end of an object class' creation), while user provided handlers are frequently connected and disconnected to/from a certain signal on certain object instances.

A signal emission consists of five stages, unless prematurely stopped:

  1. Invocation of the object method handler for G_SIGNAL_RUN_FIRST signals
  2. Invocation of normal user-provided signal handlers (after flag FALSE)
  3. Invocation of the object method handler for G_SIGNAL_RUN_LAST signals
  4. Invocation of user provided signal handlers, connected with an after flag of TRUE
  5. Invocation of the object method handler for G_SIGNAL_RUN_CLEANUP signals

The user-provided signal handlers are called in the order they were connected in. All handlers may prematurely stop a signal emission, and any number of handlers may be connected, disconnected, blocked or unblocked during a signal emission. There are certain criteria for skipping user handlers in stages 2 and 4 of a signal emission. First, user handlers may be blocked, blocked handlers are omitted during callback invocation, to return from the "blocked" state, a handler has to get unblocked exactly the same amount of times it has been blocked before. Second, upon emission of a G_SIGNAL_DETAILED signal, an additional "detail" argument passed in to gSignalEmit has to match the detail argument of the signal handler currently subject to invocation. Specification of no detail argument for signal handlers (omission of the detail part of the signal specification upon connection) serves as a wildcard and matches any detail argument passed in to emission.

Most of the time, the RGtk2 user will be connecting to signals using gSignalConnect. This attaches an R function (and, optionally, some arbitrary "user data") to a specific GObject as a listener to the named signal.

gSignalHandlerBlock and gSignalHandlerUnblock provide facilities for (temporarily) blocking and unblocking the calling of an R function in response to some signal. To permanately disconnect the handler from the object and signal, use gSignalHandlerDisconnect.

A signal may be manually emitted with gSignalEmit. The emission of a signal may be killed prematurely with gSignalStopEmission.

Detailed information about a signal may be introspected with gSignalGetInfo using ids obtained with gObjectGetSignals.

References

http://developer.gnome.org/doc/API/2.0/gobject/gobject-Signals.html

See Also

GObject