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 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 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)