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 processEvents(self):
# Process incoming data, and send to sim
while self.connection.poll():
(eventtype, event) = self.connection.recv()
if eventtype == SetNodeIdType:
self.nodeid = event
elif eventtype == SetActiveNodeType:
self.active = event
else:
# Data over pipes is pickled/unpickled, this causes problems with
# inherited classes. Solution is to call the ancestor's init
QEvent.__init__(event, eventtype)
self.sim.event(event)
# Process timers
Timer.updateTimers()
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_()
def changeEvent(self, evt: QEvent):
super(XNova_MainWindow, self).changeEvent(evt)
if evt.type() == QEvent.WindowStateChange:
if not isinstance(evt, QWindowStateChangeEvent):
return
# make sure we only do this for minimize events
if (evt.oldState() != Qt.WindowMinimized) and self.isMinimized():
# we were minimized! explicitly hide settings widget
# if it is open, otherwise it will be lost forever :(
if self.settings_widget is not None:
if self.settings_widget.isVisible():
self.settings_widget.hide()
# should we minimize to tray?
if self.cfg['tray']['icon_usage'] == 'show_min':
if not self._hidden_to_tray:
self._hidden_to_tray = True
self.hide()
def event(self, raw_ev: QEvent) -> bool:
if raw_ev.type() == QEvent.KeyPress:
ev = cast(QtGui.QKeyEvent, raw_ev)
if ev.key() == Qt.Key_Backtab \
and ev.modifiers() == Qt.ShiftModifier:
self.tab_pressed.emit(True)
return True
elif ev.key() == Qt.Key_Tab and ev.modifiers() == Qt.NoModifier:
self.tab_pressed.emit(False)
return True
return super().event(raw_ev)
def eventFilter(self_, obj: QtCore.QObject, event: QtCore.QEvent) -> bool:
if event.type() == QtCore.QEvent.KeyPress:
key_event = cast(QtGui.QKeyEvent, event)
actual_key = key_event.key() | int(cast(int, key_event.modifiers()))
if actual_key in self.settings.key_bindings:
command_string = self.settings.key_bindings[actual_key]
self.terminal.exec_command(command_string)
return True
elif actual_key == self.settings.terminal_key:
self.toggle_terminal()
return True
return False
def event(self, event: QEvent) -> bool:
""" Handle URL scheme events under macOS. """
url = getattr(event, "url", None)
if not url:
# This is not an event for us!
return super().event(event)
final_url = unquote(event.url().toString())
try:
return self._handle_nxdrive_url(final_url)
except:
log.exception(f"Error handling URL event {final_url!r}")
return False
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)
def send_event(self, evt: QEvent) -> None:
"""Send the given event to the underlying widget.
The event will be sent via QApplication.postEvent.
Note that a posted event must not be re-used in any way!
"""
# This only gives us some mild protection against re-using events, but
# it's certainly better than a segfault.
if getattr(evt, 'posted', False):
raise utils.Unreachable("Can't re-use an event which was already "
"posted!")
recipient = self.private_api.event_target()
if recipient is None:
# https://github.com/qutebrowser/qutebrowser/issues/3888
log.webview.warning("Unable to find event target!")
return
evt.posted = True
QApplication.postEvent(recipient, evt)
def eventFilter(self_, obj: QtCore.QObject,
event: QtCore.QEvent) -> bool:
if event.type() == QtCore.QEvent.Close:
self.settings.save_settings()
return False
def changeEvent(self, event: QtCore.QEvent) -> None:
QToolBar.changeEvent(self, event)
if event.type() == QtCore.QEvent.LanguageChange:
self._restranslateUi()
def closeEvent(self, e:QtCore.QEvent):
print("Closing app...")
self.config.close()
e.accept()
def __init__(cls, name, bases, dct):
super(EventMeta, cls).__init__(name, bases, dct)
cls.id = QEvent.registerEventType() if name != 'EventBase' else None
def eventFiletr(self, watched: QtCore.QObject,
event: QtCore.QEvent) -> bool:
if watched == self.textEdit_1 and event.type() == QtCore.QEvent.Resize:
print(self.textEdit_1.size().height())
def __init__(self):
QEvent.__init__(self, 2001)
self.registerEventType(self.event_type)
def test_log_events(qapp, caplog):
obj = EventObject()
qapp.sendEvent(obj, QEvent(QEvent.User))
qapp.processEvents()
assert len(caplog.records) == 1
assert caplog.records[0].msg == 'Event in test_debug.EventObject: User'
class MogEdited(QEvent):
_type = QEvent.registerEventType()
def __init__(self):
super(MogEdited, self).__init__(MogEdited._type)
def receiveFromNodes(self):
# Only look for incoming data if we're not quitting
if self.stopping:
return
# First look for new connections
r, w, e = select.select((self.listener, ), (), (), 0)
if self.listener in r:
conn = self.listener.accept()
address = self.listener.last_accepted[0]
if address in self.hosts:
nodeid = self.hosts[address]
else:
nodeid = (len(self.hosts), 0)
# Store host number and its number of nodes
self.hosts[address] = (nodeid[0], nodeid[1] + 1)
# Send the node information about its nodeid
connidx = len(self.connections)
conn.send((SetNodeIdType, nodeid))
self.connections.append([conn, nodeid, 0])
self.nodes_changed.emit(address, nodeid, connidx)
self.setActiveNode(connidx)
# Then process any data in the active connections
for connidx in range(len(self.connections)):
conn = self.connections[connidx]
if conn[0] is None or conn[0].closed:
continue
# Check for incoming events with poll
while conn[0].poll():
# Receive events that are waiting in the conn
try:
(eventtype, event) = conn[0].recv()
except:
continue
# Sender id is connection index and node id
self.sender_id = (connidx, conn[1])
if eventtype == AddNodeType:
# This event only consists of an int: the number of nodes to add
for i in range(event):
self.addNode()
continue
# Data over connections is pickled/unpickled, this causes problems with
# inherited classes. Solution is to call the ancestor's init
QEvent.__init__(event, eventtype)
# First check if this event is meant for the manager
if event.type() == SimStateEventType:
# Save the state together with the connection object
conn[2] = event.state
if event.state == event.end:
# Quit the main loop. Afterwards, manager will also quit
qapp.instance().quit()
elif event.state == event.init or event.state == event.hold:
if len(self.scenarios) > 0:
self.sendScenario(conn)
elif event.type() == BatchEventType:
self.scenarios = [scen for scen in split_scenarios(event.scentime, event.scencmd)]
# Check if the batch list contains scenarios
if len(self.scenarios) == 0:
qapp.sendEvent(qapp.instance(), StackTextEvent(disptext='No scenarios defined in batch file!'))
else:
qapp.sendEvent(qapp.instance(), StackTextEvent(disptext='Found %d scenarios in batch' % len(self.scenarios)))
# Available nodes (nodes that are in init or hold mode):
av_nodes = [n for n in range(len(self.connections)) if self.connections[n][2] in [0, 2]]
for i in range(min(len(av_nodes), len(self.scenarios))):
self.sendScenario(self.connections[i])
# If there are still scenarios left, determine and start the required number of local nodes
reqd_nnodes = min(len(self.scenarios), max(0, self.max_nnodes - len(self.localnodes)))
for n in range(reqd_nnodes):
self.addNode()
else:
# The event is meant for the gui
qapp.sendEvent(qapp.instance(), event)
# To avoid giving wrong information with sender() when it is called outside
# of this function, set sender_id to None
self.sender_id = None
class BoreholeEdited(QEvent):
_type = QEvent.registerEventType()
def __init__(self):
super(BoreholeEdited, self).__init__(BoreholeEdited._type)
class CovarianceEdited(QEvent):
_type = QEvent.registerEventType()
def __init__(self):
super(CovarianceEdited, self).__init__(CovarianceEdited._type)
def event(self, a0: QtCore.QEvent) -> bool:
if a0.__class__.__name__ == "QMouseEvent":
if a0.type() == QtCore.QEvent.MouseButtonRelease:
self.actionClick.emit(self.entity)
return super(GroupWidget, self).event(a0)
def eventFilter(self, object: QObject, event: QEvent) -> bool:
try:
# start dragging process
if event.type() == QEvent.MouseButtonPress:
# store mouse position and header being resized
mousePosition = event.pos()
self._header_being_resized = self.overHeaderEdge(mousePosition)
if self._header_being_resized is not None:
self.print('>>Resize triggered')
self.print('Header selected : ',
self._header_being_resized)
# store initial header size
if self.isHorizontal():
self._resize_start_position = mousePosition.x()
self._header_initial_size = self.columnWidth(
self._header_being_resized)
else:
self._resize_start_position = mousePosition.y()
self._header_initial_size = self.rowHeight(
self._header_being_resized)
return True
# end dragging process
elif event.type() == QEvent.MouseButtonRelease:
self._header_being_resized = None
return True
# Handle active drag resizing
elif event.type() == QEvent.MouseMove:
if self._header_being_resized is not None:
self.print('>>Resizing')
mousePosition = event.pos()
if self.isHorizontal():
new_size = self._header_initial_size + mousePosition.x(
) - self._resize_start_position
self.setColumnWidth(self._header_being_resized,
new_size)
self.dataView.setColumnWidth(
self._header_being_resized, new_size)
else:
new_size = self._header_initial_size + mousePosition.y(
) - self._resize_start_position
self.setRowHeight(self._header_being_resized, new_size)
self.dataView.setRowHeight(self._header_being_resized,
new_size)
return True
else:
# Change cursor upon hover
if self.overHeaderEdge(event.pos()) is not None:
if self.isHorizontal():
# QApplication.setOverrideCursor(Qt.SplitHCursor)
self.setCursor(Qt.SplitHCursor)
else:
# QApplication.setOverrideCursor(Qt.SplitVCursor)
self.setCursor(Qt.SplitVCursor)
else:
# QApplication.restoreOverrideCursor()
self.setCursor(Qt.ArrowCursor)
except Exception as e:
dumpException(e)
return False
def event(self, event: QEvent):
if event.type() == QEvent.KeyPress and event.key() == Qt.Key_Tab:
# print("tab pressed")
return True
return QGraphicsTextItem.event(self, event)
def event(self, event: QEvent):
if event.type() == QEvent.WindowDeactivate:
if isinstance(event, QMouseEvent):
self.mousePressEvent(event)
return True
return super().event(event)
def resizeEvent(self, event: QEvent) -> Any:
"""Reimplemented to make sure we cannot get smaller than 0."""
h = event.size().height()
if h <= 0:
return
return super().resizeEvent(event)
def changeEvent(self, event: QEvent) -> None:
if event.type() == QEvent.EnabledChange:
self.opacityEffect.setEnabled(not self.isEnabled())
def keyPressEvent(self, event: QtCore.QEvent) -> None:
if event.key() == QtCore.Qt.Key_Return:
event.accept()
self.enterPressed.emit(tuple(s.text() for s in self.selectedItems()))
else:
super().keyPressEvent(event)
def __init__(self, reference, *args, **kwargs):
QEvent.__init__(self, QSlotEvent.EVENT_TYPE)
self.reference = reference
self.args = args
self.kwargs = kwargs
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 test_log_events(qapp, caplog):
obj = EventObject()
qapp.sendEvent(obj, QEvent(QEvent.User))
qapp.processEvents()
assert caplog.messages == ['Event in test_debug.EventObject: User']
def __init__(self, etype):
QEvent.__init__(self, etype)
def event(self, e: QtCore.QEvent) -> bool:
if e.type() == QtCore.QEvent.Shortcut:
return True
else:
return super(DisabledShortcutAction, self).event(e)
def changeEvent(self, event: QtCore.QEvent) -> None:
# Change background colour when style changes to match themeZ
if event.type() == QtCore.QEvent.StyleChange:
self.page().setBackgroundColor(
QtWidgets.QApplication.palette().color(QtGui.QPalette.Base))
def event(self, e: QEvent):
if e.type() == QEvent.WinIdChange:
self.hWnd = HWND(int(self.winId()))
self.windowEffect.addShadowEffect(self.hWnd)
return QMenu.event(self, e)
def __init__(self, id, data=None, *args):
# Invoke parent init
QEvent.__init__(self, id)
self.data = data
self.id = id
def eventFilter(self, source: QObject, event: QEvent):
if event.type() == QtCore.QEvent.FocusOut:
self.save_scratch_pad()
return super().eventFilter(source, event)
def event(self, event: QEvent) -> bool:
if event.type() == _QtFunctionEvent.QtFunctionEvent:
event._function_event.call()
return True
return super().event(event)
def changeEvent(self, event: QEvent) -> None:
if event.type() == QEvent.WindowStateChange and self.isFullScreen():
self.option('osd-align-x', 'center')
self.showText(
'Press ESC or double mouse click to exit full screen')
QTimer.singleShot(5000, self.resetOSD)
def renderLater(self):
if not self.m_update_pending:
self.m_update_pending = True
QGuiApplication.postEvent(self, QEvent(QEvent.UpdateRequest))
def new_event(self: typing.Any, e: QEvent) -> bool:
"""Wrapper for event() which logs events."""
log.misc.debug("Event in {}: {}".format(utils.qualname(klass),
qenum_key(QEvent, e.type())))
return old_event(self, e)
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 event(self, event: QEvent) -> bool:
if event.type() == _QtFunctionEvent.QtFunctionEvent:
event._function_event.call()
return True
return super().event(event)
def eventFilter(self, target: QtCore.QObject, evt: QtCore.QEvent) -> bool:
if evt.type() == QtCore.QEvent.MouseMove:
assert isinstance(evt, QtGui.QMouseEvent), evt
assert isinstance(target, (QtWidgets.QWidget, QtGui.QWindow)), target
self.globalMousePosChanged.emit(target.mapToGlobal(evt.pos()))
return super().eventFilter(target, evt)
def __init__(self, func, *args, **kwargs):
QEvent.__init__(self, QEvent.User)
self.func = func
self.args = args
self.kwargs = kwargs
def _on_suggestion_click(self, event: QtCore.QEvent) -> None:
self._replacement_text_edit.setText(event.data())
def changeEvent(self, event: QEvent) -> None:
if event.type() == QEvent.ActivationChange and self.isActiveWindow():
self.dialogActivated.emit()
super().changeEvent(event)
def __init__(self, data):
QEvent.__init__(self, NotifyParent.idType)
self.data = data
def eventFilter(self_, obj: QtCore.QObject, event: QtCore.QEvent) -> bool:
if event.type() == QtCore.QEvent.Close:
self.settings.save_settings()
return False
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_()
def __init__(self, callback):
# Thread-safe
QEvent.__init__(self, _Event.EVENT_TYPE)
self.callback = callback
def __init__(self, func, *args):
QEvent.__init__(self, self.EventType)
if len(args) > 0:
self.thunk = partial(func, *args)
else:
self.thunk = func
def event(self, event: QEvent) -> bool:
if event.type() == QEvent.FocusOut or (
event.type() == QEvent.MouseButtonPress
and not self.geometry().contains(event.screenPos().toPoint())
):
# The click was outside of the systray
self.hide()
return super().event(event)
