class SettingChangedEvent(QEvent):
"""
A settings has changed.
This event is sent by Settings instance to itself when a setting for
a key has changed.
"""
SettingChanged = QEvent.registerEventType()
"""Setting was changed"""
SettingAdded = QEvent.registerEventType()
"""A setting was added"""
SettingRemoved = QEvent.registerEventType()
"""A setting was removed"""
def __init__(self, etype, key, value=None, oldValue=None):
"""
Initialize the event instance
"""
QEvent.__init__(self, etype)
self.__key = key
self.__value = value
self.__oldValue = oldValue
def key(self):
return self.__key
def value(self):
return self.__value
def oldValue(self):
return self.__oldValue
def __init__(self, event_id=1000, name="", data=None):
'''after id 1000 starts custom_user_event'''
self.idType = QEvent.registerEventType(event_id)
self.name = name
self.data = data
QEvent.__init__(self, self.idType)
print("Created CustomEvent with id: ", self.idType)
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 RunnableFinishedEvent(QEvent):
TYPE = QEvent.registerEventType()
def __init__(self, error, data):
QEvent.__init__(self, self.TYPE)
self.error = error
self.data = data
class Event(QEvent):
EVENT_TYPE = QEvent.Type(QEvent.registerEventType())
def __init__(self, data):
#thread-safe
QEvent.__init__(self, Event.EVENT_TYPE)
self.data = data
def start():
# Start the Qt main object
app = QApplication([])
# Start the bluesky network client
client = GuiClient()
# Enable HiDPI support (Qt5 only)
if QT_VERSION >= 0x050000:
app.setAttribute(Qt.AA_UseHighDpiPixmaps)
splash = Splash()
# Register our custom pan/zoom event
for etype in range(1000, 1000 + NUMCUSTOMEVENTS):
reg_etype = QEvent.registerEventType(etype)
if reg_etype != etype:
print((
'Warning: Registered event type differs from requested type id (%d != %d)'
% (reg_etype, etype)))
splash.show()
# Install error message handler
handler = QErrorMessage.qtHandler()
handler.setWindowFlags(Qt.WindowStaysOnTopHint)
# Check and set OpenGL capabilities
if not QGLFormat.hasOpenGL():
raise RuntimeError('No OpenGL support detected for this system!')
else:
f = QGLFormat()
f.setVersion(3, 3)
f.setProfile(QGLFormat.CoreProfile)
f.setDoubleBuffer(True)
QGLFormat.setDefaultFormat(f)
print(('QGLWidget initialized for OpenGL version %d.%d' %
(f.majorVersion(), f.minorVersion())))
splash.showMessage('Constructing main window')
app.processEvents()
win = MainWindow()
win.show()
splash.showMessage('Done!')
app.processEvents()
splash.finish(win)
# If this instance of the gui is started in client-only mode, show
# server selection dialog
if bs.settings.is_client:
dialog = DiscoveryDialog(win)
dialog.show()
bs.net.start_discovery()
else:
client.connect(event_port=bs.settings.event_port,
stream_port=bs.settings.stream_port)
# Start the Qt main loop
app.exec_()
def start(mode):
# Install message handler for Qt messages
qInstallMessageHandler(gui_msg_handler)
# Start the Qt main object
app = QApplication([])
# Start the bluesky network client
client = GuiClient()
# Enable HiDPI support (Qt5 only)
if QT_VERSION >= 0x050000:
app.setAttribute(Qt.AA_UseHighDpiPixmaps)
splash = Splash()
# Register our custom pan/zoom event
for etype in range(1000, 1000 + NUMCUSTOMEVENTS):
reg_etype = QEvent.registerEventType(etype)
if reg_etype != etype:
print(('Warning: Registered event type differs from requested type id (%d != %d)' % (reg_etype, etype)))
splash.show()
# Install error message handler
handler = QErrorMessage.qtHandler()
handler.setWindowFlags(Qt.WindowStaysOnTopHint)
# Check and set OpenGL capabilities
if not QGLFormat.hasOpenGL():
raise RuntimeError('No OpenGL support detected for this system!')
else:
f = QGLFormat()
f.setVersion(3, 3)
f.setProfile(QGLFormat.CoreProfile)
f.setDoubleBuffer(True)
QGLFormat.setDefaultFormat(f)
print(('QGLWidget initialized for OpenGL version %d.%d' % (f.majorVersion(), f.minorVersion())))
splash.showMessage('Constructing main window')
app.processEvents()
win = MainWindow(mode)
win.show()
splash.showMessage('Done!')
app.processEvents()
splash.finish(win)
# If this instance of the gui is started in client-only mode, show
# server selection dialog
if mode == 'client':
dialog = DiscoveryDialog(win)
dialog.show()
bs.net.start_discovery()
else:
client.connect(event_port=bs.settings.event_port,
stream_port=bs.settings.stream_port)
# Start the Qt main loop
app.exec_()
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 WidgetInitEvent(QEvent):
DelayedInit = QEvent.registerEventType()
def __init__(self, initstate):
super().__init__(WidgetManager.WidgetInitEvent.DelayedInit)
self._initstate = initstate
def initstate(self):
return self._initstate
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 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 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)
def start(hostname=None):
# Install message handler for Qt messages
qInstallMessageHandler(gui_msg_handler)
# Start the Qt main object
app = QApplication([])
# Explicitly set font to avoid font loading warning dialogs
app.setFont(QFont('Sans'))
# Start the bluesky network client
client = GuiClient()
# Enable HiDPI support (Qt5 only)
if QT_VERSION_STR[0] == '5' and QT_VERSION >= 0x050000:
app.setAttribute(Qt.AA_UseHighDpiPixmaps)
splash = Splash()
# Register our custom pan/zoom event
for etype in range(1000, 1000 + NUMCUSTOMEVENTS):
reg_etype = QEvent.registerEventType(etype)
if reg_etype != etype:
print((
'Warning: Registered event type differs from requested type id (%d != %d)'
% (reg_etype, etype)))
splash.show()
# Install error message handler
# handler = QErrorMessage.qtHandler()
# handler.setWindowFlags(Qt.WindowType.WindowStaysOnTopHint)
splash.showMessage('Constructing main window')
app.processEvents()
win = MainWindow(bs.mode)
win.show()
splash.showMessage('Done!')
app.processEvents()
splash.finish(win)
# If this instance of the gui is started in client-only mode, show
# server selection dialog
if bs.mode == 'client' and hostname is None:
dialog = DiscoveryDialog(win)
dialog.show()
bs.net.start_discovery()
else:
client.connect(hostname=hostname)
# Start the Qt main loop
# app.exec_()
app.exec()
class DeleteArticleTagEvent(QEvent):
"""Событие удаления тега страницы"""
idType = QEvent.registerEventType()
def __init__(self, tag: str):
"""
Args:
tag (str): Тег статьи.
"""
# noinspection PyTypeChecker
QEvent.__init__(self, DeleteArticleTagEvent.idType)
self.tag = tag
class CallEvent(QEvent):
"""An event containing a request for a function call."""
EVENT_TYPE = QEvent(QEvent.registerEventType())
def __init__(self, queue, exceptions_in_main, fn, *args, **kwargs):
QEvent.__init__(self, self.EVENT_TYPE)
self.fn = fn
self.args = args
self.kwargs = kwargs
self._returnval = queue
# Whether to raise exceptions in the main thread or store them
# for raising in the calling thread:
self._exceptions_in_main = exceptions_in_main
class MyEvent(QEvent):
"""Класс события
Событие будет генерироваться при клике на ссылках. Будет использаватья вместо сигнал urlChanged
"""
idType = QEvent.registerEventType()
def __init__(self, data):
QEvent.__init__(self, MyEvent.idType)
self.data = data
def get_data(self):
return self.data
def __init__(self):
super(Gui, self).__init__([])
self.acdata = ACDataEvent()
self.birddata = BirdDataEvent()
self.navdb = None
self.radarwidget = []
self.command_history = []
self.cmd = ''
self.args = []
self.history_pos = 0
self.command_mem = ''
self.command_line = ''
self.prev_cmdline = ''
self.mousedragged = False
self.mousepos = (0, 0)
self.prevmousepos = (0, 0)
self.panzoomchanged = False
self.simt = 0.0
# Register our custom pan/zoom event
for etype in range(1000, 1000 + NUMEVENTS):
reg_etype = QEvent.registerEventType(etype)
if reg_etype != etype:
print(
'Warning: Registered event type differs from requested type id (%d != %d)'
% (reg_etype, etype))
self.splash = Splash()
self.splash.show()
# Install error message handler
handler = QErrorMessage.qtHandler()
handler.setWindowFlags(Qt.WindowStaysOnTopHint)
# Check and set OpenGL capabilities
if not QGLFormat.hasOpenGL():
raise RuntimeError('No OpenGL support detected for this system!')
else:
f = QGLFormat()
f.setVersion(3, 3)
f.setProfile(QGLFormat.CoreProfile)
f.setDoubleBuffer(True)
QGLFormat.setDefaultFormat(f)
print('QGLWidget initialized for OpenGL version %d.%d' %
(f.majorVersion(), f.minorVersion()))
# Enable HiDPI support (Qt5 only)
if QT_VERSION == 5:
self.setAttribute(Qt.AA_UseHighDpiPixmaps)
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
def __init__(self):
super(Gui, self).__init__([])
self.acdata = ACDataEvent()
self.routedata = RouteDataEvent()
self.navdb = None
self.radarwidget = []
self.command_history = []
self.cmd = ''
self.args = []
self.history_pos = 0
self.command_mem = ''
self.command_line = ''
self.prev_cmdline = ''
self.mousedragged = False
self.mousepos = (0, 0)
self.prevmousepos = (0, 0)
self.panzoomchanged = False
self.simt = 0.0
# Register our custom pan/zoom event
for etype in range(1000, 1000 + NUMEVENTS):
reg_etype = QEvent.registerEventType(etype)
if reg_etype != etype:
print('Warning: Registered event type differs from requested type id (%d != %d)' % (reg_etype, etype))
self.splash = Splash()
self.splash.show()
# Install error message handler
handler = QErrorMessage.qtHandler()
handler.setWindowFlags(Qt.WindowStaysOnTopHint)
# Check and set OpenGL capabilities
if not QGLFormat.hasOpenGL():
raise RuntimeError('No OpenGL support detected for this system!')
else:
f = QGLFormat()
f.setVersion(3, 3)
f.setProfile(QGLFormat.CoreProfile)
f.setDoubleBuffer(True)
QGLFormat.setDefaultFormat(f)
print('QGLWidget initialized for OpenGL version %d.%d' % (f.majorVersion(), f.minorVersion()))
# Enable HiDPI support (Qt5 only)
if QT_VERSION == 5:
self.setAttribute(Qt.AA_UseHighDpiPixmaps)
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)
class CallbackEvent(QEvent):
"""
A custom QEvent that contains a callback reference
Also provides class methods for conveniently executing
arbitrary callback, to be dispatched to the event loop.
"""
EVENT_TYPE = QEvent.registerEventType()
def __init__(self, func, *args, **kwargs):
super(CallbackEvent, self).__init__(self.EVENT_TYPE)
self.func = func
self.args = args
self.kwargs = kwargs
def callback(self):
"""
Convenience method to run the callable.
Equivalent to:
self.func(*self.args, **self.kwargs)
"""
self.func(*self.args, **self.kwargs)
@classmethod
def post_to(cls, receiver, func, *args, **kwargs):
"""
Post a callable to be delivered to a specific
receiver as a CallbackEvent.
It is the responsibility of this receiver to
handle the event and choose to call the callback.
"""
# We can create a weak proxy reference to the
# callback so that if the object associated with
# a bound method is deleted, it won't call a dead method
if not isinstance(func, proxy):
reference = proxy(func, quiet=True)
else:
reference = func
event = cls(reference, *args, **kwargs)
# post the event to the given receiver
QApplication.postEvent(receiver, event)
class QueuedCallEvent(QEvent):
QueuedCall = QEvent.registerEventType()
def __init__(self, function, args, kwargs, semaphore=None):
QEvent.__init__(self, QueuedCallEvent.QueuedCall)
self.function = function
self.args = args
self.kwargs = kwargs
self.semaphore = semaphore
self._result = None
self._exc_info = None
self._state = 0
def call(self):
try:
self._result = self.function(*self.args, **self.kwargs)
self._state = 1
if self.semaphore is not None:
self.semaphore.release()
except BaseException as ex:
self._exc_info = (type(ex), ex.args, None)
if self.semaphore is not None:
self.semaphore.release()
raise
def result(self):
if self._state == 1:
return self._result
elif self._exc_info:
raise self._exc_info[0](self._exc_info[1])
else:
# Should this block, add timeout?
raise RuntimeError("Result of a QueuedCallEvent is not yet ready")
def isready(self):
return self._state == 1 or self._exc_info
class MogEdited(QEvent):
_type = QEvent.registerEventType()
def __init__(self):
super(MogEdited, self).__init__(MogEdited._type)
def __init__(self, navdb):
super(Gui, self).__init__([])
self.acdata = ACDataEvent()
self.navdb = navdb
self.radarwidget = []
self.command_history = []
self.cmdargs = []
self.history_pos = 0
self.command_mem = ''
self.command_line = ''
self.prev_cmdline = ''
self.simevent_target = 0
self.mousedragged = False
self.mousepos = (0, 0)
self.prevmousepos = (0, 0)
self.panzoomchanged = False
self.simt = 0.0
# Register our custom pan/zoom event
for etype in [PanZoomEventType, ACDataEventType, SimInfoEventType,
StackTextEventType, ShowDialogEventType,
DisplayFlagEventType, RouteDataEventType,
DisplayShapeEventType, SimQuitEventType,
AMANEventType]:
reg_etype = QEvent.registerEventType(etype)
if reg_etype != etype:
print('Warning: Registered event type differs from requested type id (%d != %d)' % (reg_etype, etype))
self.splash = Splash()
self.splash.show()
self.splash.showMessage('Constructing main window')
self.processEvents()
# Install error message handler
handler = QErrorMessage.qtHandler()
handler.setWindowFlags(Qt.WindowStaysOnTopHint)
# Check and set OpenGL capabilities
if not QGLFormat.hasOpenGL():
raise RuntimeError('No OpenGL support detected for this system!')
else:
f = QGLFormat()
f.setVersion(3, 3)
f.setProfile(QGLFormat.CoreProfile)
f.setDoubleBuffer(True)
QGLFormat.setDefaultFormat(f)
print('QGLWidget initialized for OpenGL version %d.%d' % (f.majorVersion(), f.minorVersion()))
# Create the main window and related widgets
self.radarwidget = RadarWidget(navdb)
self.win = MainWindow(self, self.radarwidget)
self.nd = ND(shareWidget=self.radarwidget)
#self.aman = AMANDisplay(shareWidget=self.radarwidget)
# Enable HiDPI support (Qt5 only)
if QT_VERSION == 5:
self.setAttribute(Qt.AA_UseHighDpiPixmaps)
timer = QTimer(self)
timer.timeout.connect(self.radarwidget.updateGL)
timer.timeout.connect(self.nd.updateGL)
#timer.timeout.connect(self.aman.updateGL)
timer.start(50)
def __init__(cls, name, bases, dct):
super(EventMeta, cls).__init__(name, bases, dct)
cls.id = QEvent.registerEventType() if name != 'EventBase' else None
def start(mode):
# Install message handler for Qt messages
qInstallMessageHandler(gui_msg_handler)
# Start the Qt main object
app = QApplication([])
# Start the bluesky network client
client = GuiClient()
# Enable HiDPI support (Qt5 only)
if QT_VERSION >= 0x050000:
app.setAttribute(Qt.AA_UseHighDpiPixmaps)
splash = Splash()
# Register our custom pan/zoom event
for etype in range(1000, 1000 + NUMCUSTOMEVENTS):
reg_etype = QEvent.registerEventType(etype)
if reg_etype != etype:
print((
'Warning: Registered event type differs from requested type id (%d != %d)'
% (reg_etype, etype)))
splash.show()
# Install error message handler
handler = QErrorMessage.qtHandler()
handler.setWindowFlags(Qt.WindowStaysOnTopHint)
# Check and set OpenGL capabilities
if not QGLFormat.hasOpenGL():
raise RuntimeError('No OpenGL support detected for this system!')
else:
f = QGLFormat()
f.setVersion(3, 3)
f.setProfile(QGLFormat.CoreProfile)
f.setDoubleBuffer(True)
QGLFormat.setDefaultFormat(f)
print(('QGLWidget initialized for OpenGL version %d.%d' %
(f.majorVersion(), f.minorVersion())))
splash.showMessage('Constructing main window')
app.processEvents()
win = MainWindow(mode)
splash.showMessage('Done!')
app.processEvents()
splash.finish(win)
# Quick hack to connect to a remote simulation
import sys
arg = '--bluesky_host='
host = next((x for x in sys.argv if x.startswith(arg)), None)
if host is not None:
host = host[len(arg):]
try:
print('Attempting connection to BlueSky at: {}'.format(host))
client.connect(hostname=host,
event_port=bs.settings.event_port,
stream_port=bs.settings.stream_port,
timeout=5)
except TimeoutError:
print('Failed to connect to BlueSky server at {}, exiting'.format(
host))
QApplication.quit()
sys.exit(0)
win.show()
app.exec_()
return
win.show()
# If this instance of the gui is started in client-only mode, show
# server selection dialog
if mode == 'client':
dialog = DiscoveryDialog(win)
dialog.show()
bs.net.start_discovery()
else:
client.connect(event_port=bs.settings.event_port,
stream_port=bs.settings.stream_port)
# Start the Qt main loop
app.exec_()
class IntentEvent(QEvent):
"""Intent
"""
Type = QEvent.registerEventType()
def __init__(self, intent_type, **kwargs):
super(IntentEvent, self).__init__(self.Type)
self.intent_type = intent_type
"""Type of the intent
An intent has a type, which is a simple string, for example `"openEditor"` for the intent to open an
editor with a particular file displayed.
:type: str
"""
self.source = kwargs.pop('source', None)
"""Object that sent the intent
:type: QObject
"""
self.info = PropDict(**kwargs)
"""Extra info about the intent
This info is filled when the intent is sent (:any:`sendIntent`).
:type: :any:`eye.structs.PropDict`
"""
self.result = None
"""Result of the intent (if applicable)
Optionally set by a handler with :any:`accept`.
"""
self.ignore()
def accept(self, result=None):
"""Accept the intent
When an intent listener handles an `IntentEvent`, it should return True to avoid the intent being
handled multiple times.
Optionally, when the intent is handled, it can also be marked as accepted, with a result value. This
result can then be retrieved by the object which sent the intent. The result is set in the
:any:`result` attribute of the IntentEvent.
For example, there could be an intent for querying user input, an object needing input would send the
intent and would get back the input that one of the listeners produced, in the :any:`result`
attribute.
Or there could be an intent for creating a new tab, and a handler would create a different widget than
the normal :any:`eye.widgets.editor.Editor`, and return it through this result.
"""
self.setAccepted(True)
self.result = result
def __repr__(self):
return '<IntentEvent type=%r source=%r info=%r>' % (
self.intent_type, self.source, self.info)
QLabel,
QLineEdit,
QMenu,
QMessageBox,
QPushButton,
QSizePolicy,
QStyle,
QStyleOption,
QToolButton,
QVBoxLayout,
QWidget,
)
from PyQt5.QtGui import QPixmap, QPainter, QIcon, QPalette
events = utils.dotdict({
"RELOAD_WIDGETS": QEvent.registerEventType(1337),
"COLLAPSE_WINDOW": QEvent.registerEventType(1338),
"EXPAND_WINDOW": QEvent.registerEventType(1339),
"CLOSE_WINDOW": QEvent.registerEventType(1340),
})
re_url = re.compile(
r"^(?:(?:http|ftp)s?://)?" # http:// or https://
r"(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}\.?)|" # domain...
r"localhost|" # localhost...
r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})" # ...or ip
r"(?::\d+)?" # optional port
r"(?:/?|[/?]\S+)$",
re.IGNORECASE,
)
class BoreholeEdited(QEvent):
_type = QEvent.registerEventType()
def __init__(self):
super(BoreholeEdited, self).__init__(BoreholeEdited._type)
def __init__(self):
"""
Initializes the new packet event.
"""
evtype = QEvent.Type(QEvent.registerEventType())
super(PacketEvent, self).__init__(evtype)
class CovarianceEdited(QEvent):
_type = QEvent.registerEventType()
def __init__(self):
super(CovarianceEdited, self).__init__(CovarianceEdited._type)
class WorkflowEvent(QEvent):
#: Delivered to Scheme when a node has been added
NodeAdded = QEvent.registerEventType()
#: Delivered to Scheme when a node has been removed
NodeRemoved = QEvent.registerEventType()
#: A Link has been added to the scheme
LinkAdded = QEvent.registerEventType()
#: A Link has been removed from the scheme
LinkRemoved = QEvent.registerEventType()
#: Node's (runtime) state has changed
NodeStateChange = QEvent.registerEventType()
#: Link's (runtime) state has changed
LinkStateChange = QEvent.registerEventType()
#: Request for Node's runtime initialization (e.g.
#: load required data, establish connection, ...)
NodeInitialize = QEvent.registerEventType()
#: Restore the node from serialized state
NodeRestore = QEvent.registerEventType()
NodeSaveStateRequest = QEvent.registerEventType() # ?
#: Node user activate request (e.g. on double click in the
#: canvas GUI)
NodeActivateRequest = QEvent.registerEventType()
# Workflow runtime changed (Running/Paused/Stopped, ...)
RuntimeStateChange = QEvent.registerEventType()
#: Workflow resource changed (e.g. work directory, env variable)
WorkflowResourceChange = QEvent.registerEventType()
#: Workflow is about to close.
WorkflowAboutToClose = QEvent.registerEventType()
WorkflowClose = QEvent.registerEventType()
AnnotationAdded = QEvent.registerEventType()
AnnotationRemoved = QEvent.registerEventType()
AnnotationChange = QEvent.registerEventType()
#: Request activation (show and raise) of the window containing
#: the workflow view
ActivateParentRequest = QEvent.registerEventType()
def __init__(self, etype):
QEvent.__init__(self, etype)
def __init__(cls, name, bases, dct):
super(EventMeta, cls).__init__(name, bases, dct)
cls.id = QEvent.registerEventType() if name != 'EventBase' else None
