Uranium
Application Framework
|
Public Member Functions | |
None | __init__ (self, int type=Auto) |
getName (self) | |
None | __call__ (self) |
int | getType (self) |
None | emit (self, *Any args, **Any kwargs) |
None | connect (self, Union["Signal", Callable[[], None]] connector) |
disconnect (self, connector) | |
disconnectAll (self) | |
__getstate__ (self) | |
__deepcopy__ (self, memo) | |
Static Public Attributes | |
int | Direct = 1 |
int | Auto = 2 |
int | Queued = 3 |
Protected Attributes | |
bool | _postpone_emit = False |
_postpone_thread = None | |
bool | _compress_postpone = False |
tuple | _postponed_emits = None |
Static Protected Attributes | |
_app = None | |
_signalQueue = None | |
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 :sa SignalEmitter
None UM.Signal.Signal.__init__ | ( | self, | |
int | type = Auto ) |
Initialize the instance. :param type: The signal type. Defaults to Auto.
None UM.Signal.Signal.__call__ | ( | self | ) |
:exception NotImplementedError:
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__.
UM.Signal.Signal.__getstate__ | ( | self | ) |
To support Pickle Since Weak containers cannot be serialized by Pickle we just return an empty dict as state.
None UM.Signal.Signal.connect | ( | self, | |
Union["Signal", Callable[[], None]] | connector ) |
Connect to this signal. :param connector: The signal or slot (function) to connect.
UM.Signal.Signal.disconnect | ( | self, | |
connector ) |
Disconnect from this signal. :param connector: The signal or slot (function) to disconnect.
UM.Signal.Signal.disconnectAll | ( | self | ) |
Disconnect all connected slots.
None UM.Signal.Signal.emit | ( | self, | |
*Any | args, | ||
**Any | kwargs ) |
Emit the signal which indirectly calls all of the connected slots. :param args: The positional arguments to pass along. :param kwargs: The 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.
int UM.Signal.Signal.getType | ( | self | ) |
Get type of the signal :return: Direct(1), Auto(2) or Queued(3)