Uranium
Application Framework
 All Classes Namespaces Files Functions Variables Pages
UM.Signal.Signal Class Reference

Simple implementation of signals and slots. More...

Public Member Functions

def __init__
 Initialize the instance. More...
 
def getName
 
def __call__
 
Exceptions
NotImplementedError

 
def getType
 Get type of the signal. More...
 
def emit
 Emit the signal which indirectly calls all of the connected slots. More...
 
def connect
 Connect to this signal. More...
 
def disconnect
 Disconnect from this signal. More...
 
def disconnectAll
 Disconnect all connected slots. More...
 
def __getstate__
 To support Pickle. More...
 
def __deepcopy__
 To properly handle deepcopy in combination with getstate More...
 

Static Public Attributes

int Direct = 1
 Signal types. More...
 
int Auto = 2
 
int Queued = 3
 

Detailed Description

Simple implementation of signals and slots.

Signals and slots can be used as a light weight event system. A class can define signals that other classes can connect functions or methods to, called slots. Whenever the signal is called, it will proceed to call the connected slots.

To create a signal, create an instance variable of type Signal. Other objects can then use that variable's connect() method to connect methods, callable objects or signals to the signal. To emit the signal, call emit() on the signal. Arguments can be passed along to the signal, but slots will be required to handle them. When connecting signals to other signals, the connected signal will be emitted whenever the signal is emitted.

Signal-slot connections are weak references and as such will not prevent objects from being destroyed. In addition, all slots will be implicitly disconnected when the signal is destroyed.

Warning
It is imperative that the signals are created as instance variables, otherwise emitting signals will get confused. To help with this, see the SignalEmitter class.

Loosely based on http://code.activestate.com/recipes/577980-improved-signalsslots-implementation-in-python/ #pylint: disable=wrong-spelling-in-comment

See also
SignalEmitter

Constructor & Destructor Documentation

def UM.Signal.Signal.__init__ (   self,
  type 
)

Initialize the instance.

Parameters
kwargsKeyword arguments. Possible keywords:
  • type: The signal type. Defaults to Auto.

Member Function Documentation

def UM.Signal.Signal.__deepcopy__ (   self,
  memo 
)

To properly handle deepcopy in combination with getstate

Apparently deepcopy uses getstate internally, which is not documented. The reimplementation of getstate then breaks deepcopy. On the other hand, if we do not reimplement it like that, we break pickle. So instead make sure to also reimplement deepcopy.

def UM.Signal.Signal.__getstate__ (   self)

To support Pickle.

Since Weak containers cannot be serialized by Pickle we just return an empty dict as state.

def UM.Signal.Signal.connect (   self,
  connector 
)

Connect to this signal.

Parameters
connectorThe signal or slot (function) to connect.
def UM.Signal.Signal.disconnect (   self,
  connector 
)

Disconnect from this signal.

Parameters
connectorThe signal or slot (function) to disconnect.
def UM.Signal.Signal.disconnectAll (   self)

Disconnect all connected slots.

def UM.Signal.Signal.emit (   self,
  args 
)

Emit the signal which indirectly calls all of the connected slots.

Parameters
argsThe positional arguments to pass along.
kwargsThe keyword arguments to pass along.
Note
If the Signal type is Queued and this is not called from the application thread the call will be posted as an event to the application main thread, which means the function will be called on the next application event loop tick.
def UM.Signal.Signal.getType (   self,
  int 
)

Get type of the signal.

Returns
int Direct(1), Auto(2) or Queued(3)

Member Data Documentation

int UM.Signal.Signal.Direct = 1
static

Signal types.

These indicate the type of a signal, that is, how the signal handles calling the connected slots.

  • Direct connections immediately call the connected slots from the thread that called emit().
  • Auto connections will push the call onto the event loop if the current thread is not the main thread, but make a direct call if it is.
  • Queued connections will always push the call on to the event loop.

The documentation for this class was generated from the following file: