class _Event(QEvent):
EVENT_TYPE = QEvent.Type(QEvent.registerEventType())
def __init__(self, callback):
# Thread-safe
QEvent.__init__(self, _Event.EVENT_TYPE)
self.callback = callback
class ThunkEvent(QEvent):
"""
A QEvent subclass that holds a callable which can be executed by its listeners.
Sort of like a "queued connection" signal.
"""
EventType = QEvent.Type(QEvent.registerEventType())
def __init__(self, func, *args):
QEvent.__init__(self, self.EventType)
if len(args) > 0:
self.thunk = partial(func, *args)
else:
self.thunk = func
def __call__(self):
self.thunk()
@classmethod
def post(cls, handlerObject, func, *args):
e = ThunkEvent(func, *args)
QApplication.postEvent(handlerObject, e)
@classmethod
def send(cls, handlerObject, func, *args):
e = ThunkEvent(func, *args)
QApplication.sendEvent(handlerObject, e)
class Event(QEvent):
EVENT_TYPE = QEvent.Type(QEvent.registerEventType())
def __init__(self, data):
#thread-safe
QEvent.__init__(self, Event.EVENT_TYPE)
self.data = data
class QSlotEvent(QEvent):
EVENT_TYPE = QEvent.Type(QEvent.registerEventType())
def __init__(self, reference, *args, **kwargs):
QEvent.__init__(self, QSlotEvent.EVENT_TYPE)
self.reference = reference
self.args = args
self.kwargs = kwargs
class PacketEvent(QEvent):
"""
This Qt event is fired when a new packet is received by the client,
urging it to go check the incoming messages queue.
"""
EVENT_TYPE = QEvent.Type(QEvent.registerEventType())
def __init__(self):
super(PacketEvent, self).__init__(PacketEvent.EVENT_TYPE)
class ReenterEvent(QEvent):
REENTER_EVENT = QEvent.Type(QEvent.registerEventType())
def __init__(self, fn):
self._fn = fn
super().__init__(self.REENTER_EVENT)
def consume(self):
self._fn()
return False
class SocketEvent(QEvent):
"""
This Event is being sent when a new socket event is happening,
for instance, when an incoming packet has arrived
"""
EVENT_TYPE = QEvent.Type(QEvent.registerEventType())
def __init__(self):
super(SocketEvent, self).__init__(SocketEvent.EVENT_TYPE)
class WorkerEvent(QEvent):
""" thread-safe callback execution by raising
these custom events in the main ui loop
"""
EVENT_TYPE = QEvent.Type(QEvent.registerEventType())
def __init__(self, callback, response):
""" A WorkerEvent encapsulates a function to be called in the main ui loop and its argument
:param callback: The function to be called when the event gets processed
:type callback: function
:param response: Response message from the worker, passed as argument to the callback function
:type response: str
"""
QEvent.__init__(self, WorkerEvent.EVENT_TYPE)
self.callback = callback
self.response = response
class DeferredExecute(QEvent):
EVENT_TYPE = QEvent.Type(QEvent.registerEventType())
__processor = _Processor()
def __init__(self, func, *args, **kwargs):
QEvent.__init__(self, self.EVENT_TYPE)
self.func = func
self.args = args
self.kwargs = kwargs
def dispatch(self):
QApplication.postEvent(self.__processor, self)
def process(self):
self.func(*self.args, **self.kwargs)
def __init__(self):
"""
Initializes the new packet event.
"""
evtype = QEvent.Type(QEvent.registerEventType())
super(PacketEvent, self).__init__(evtype)
target = EventDistributor.__CustomEventReceiver.get(receiver, None)
if target is None:
print(str(EventReceiver(receiver[1]).name),
"is currently not added as receiver yet!")
else:
QApplication.sendEvent(target, event)
else:
for identifier, receiver in EventDistributor.__CustomEventReceiver.items(
):
QApplication.sendEvent(receiver, event)
############################################################################ Player Event Types between 1001 - 1050 ###
PlayerVideoTimeChanged \
= QEvent.Type(1001)
PlayerRemainingVideoTimeChanged \
= QEvent.Type(1002)
PlayerPercentChanged \
= QEvent.Type(1003)
##################################################################### Comment Table Event Types between 1051 - 1070 ###
CommentAmountChanged \
= QEvent.Type(1051)
CommentCurrentSelectionChanged \
= QEvent.Type(1052)
def updateTarget(self):
event = QEvent(QEvent.Type(StyleAnimationUpdate))
event.setAccepted(False)
QCoreApplication.sendEvent(self.target(), event)
if not event.isAccepted():
self.stop()
class ReleasePosEvent(QEvent):
EventType = QEvent.Type(QEvent.registerEventType())
def __init__(self, point):
QEvent.__init__(self, ReleasePosEvent.EventType)
self.point = point
def eventTest(self, event):
if event.type() != QEvent.Type(QEvent.User + 1):
return False
return event.mode == self.value
def __init__(self, mode, parent=None):
super(FlightModeEvent, self).__init__(QEvent.Type(QEvent.User + 1))
self.mode = mode
