class QtKernelClientMixin(MetaQObjectHasTraits('NewBase', (HasTraits, SuperQObject), {})): """ A KernelClient that provides signals and slots. """ # Emitted when the kernel client has started listening. started_channels = QtCore.Signal() # Emitted when the kernel client has stopped listening. stopped_channels = QtCore.Signal() #--------------------------------------------------------------------------- # 'KernelClient' interface #--------------------------------------------------------------------------- #------ Channel management ------------------------------------------------- def start_channels(self, *args, **kw): """ Reimplemented to emit signal. """ super(QtKernelClientMixin, self).start_channels(*args, **kw) self.started_channels.emit() def stop_channels(self): """ Reimplemented to emit signal. """ super(QtKernelClientMixin, self).stop_channels() self.stopped_channels.emit()
def mouseMoveEvent(self, event): if self.image.isNull() or self.w == 0 or self.h == 0: return mousePosOrig = QtCore.QPointF(event.x(), event.y()) mousePosScaled = QtCore.QPointF(float(mousePosOrig.x() - self.xoff) / self.scale, float(mousePosOrig.y() - self.yoff) / self.scale) mouseOutsideImage = not self.image.rect().contains(mousePosScaled.toPoint()) mousePosScaled.setX(max(mousePosScaled.x(), 0.)) mousePosScaled.setY(max(mousePosScaled.y(), 0.)) mousePosScaled.setX(min(mousePosScaled.x(), self.image.rect().right())) mousePosScaled.setY(min(mousePosScaled.y(), self.image.rect().bottom())) if not self.image.rect().contains(mousePosScaled.toPoint()): print(self.image.rect()) print(mousePosScaled.toPoint()) self.mousePosScaled = None self.mousePosOrig = None self.updateMouseObject() self.update() return self.mousePosScaled = mousePosScaled self.mousePosOrig = mousePosOrig self.mouseOutsideImage = mouseOutsideImage # Redraw self.updateMouseObject() self.update()
def test_link_handling(self): noKeys = QtCore.Qt noButton = QtCore.Qt.MouseButton(0) noButtons = QtCore.Qt.MouseButtons(0) noModifiers = QtCore.Qt.KeyboardModifiers(0) MouseMove = QtCore.QEvent.MouseMove QMouseEvent = QtGui.QMouseEvent w = ConsoleWidget() cursor = w._get_prompt_cursor() w._insert_html(cursor, '<a href="http://python.org">written in</a>') obj = w._control tip = QtGui.QToolTip self.assertEqual(tip.text(), u'') # should be somewhere else elsewhereEvent = QMouseEvent(MouseMove, QtCore.QPoint(50, 50), noButton, noButtons, noModifiers) w.eventFilter(obj, elsewhereEvent) self.assertEqual(tip.isVisible(), False) self.assertEqual(tip.text(), u'') # should be over text overTextEvent = QMouseEvent(MouseMove, QtCore.QPoint(1, 5), noButton, noButtons, noModifiers) w.eventFilter(obj, overTextEvent) self.assertEqual(tip.isVisible(), True) self.assertEqual(tip.text(), "http://python.org") # should still be over text stillOverTextEvent = QMouseEvent(MouseMove, QtCore.QPoint(1, 5), noButton, noButtons, noModifiers) w.eventFilter(obj, stillOverTextEvent) self.assertEqual(tip.isVisible(), True) self.assertEqual(tip.text(), "http://python.org")
def drawLabelAtMouse(self, qp): # Nothing to do without a highlighted object if not self.highlightObj: return # Nothing to without a mouse position if not self.mousePosOrig: return # Save QPainter settings to stack qp.save() # That is the mouse positiong mouse = self.mousePosOrig # Will show zoom showZoom = self.zoom and not self.image.isNull() and self.w and self.h # The text that is written next to the mouse mouseText = self.highlightObj.label # Where to write the text # Depends on the zoom (additional offset to mouse to make space for zoom?) # The location in the image (if we are at the top we want to write below of the mouse) off = 36 if showZoom: off += self.zoomSize / 2 if mouse.y() - off > self.toolbar.height(): top = mouse.y() - off btm = mouse.y() vAlign = QtCore.Qt.AlignTop else: # The height of the cursor if not showZoom: off += 20 top = mouse.y() btm = mouse.y() + off vAlign = QtCore.Qt.AlignBottom # Here we can draw rect = QtCore.QRect() rect.setTopLeft(QtCore.QPoint(mouse.x() - 200, top)) rect.setBottomRight(QtCore.QPoint(mouse.x() + 200, btm)) # The color qp.setPen(QtGui.QColor('white')) # The font to use font = QtGui.QFont("Helvetica", 20, QtGui.QFont.Bold) qp.setFont(font) # Non-transparent qp.setOpacity(1) # Draw the text, horizontally centered qp.drawText(rect, QtCore.Qt.AlignHCenter | vAlign, mouseText) # Restore settings qp.restore()
def test_droplist_completer_mousepick(self): leftButton = QtCore.Qt.LeftButton w = CompletionWidget(self.console) w.show_items(self.text_edit.textCursor(), ["item1", "item2", "item3"]) QTest.mouseClick(w.viewport(), leftButton, pos=QtCore.QPoint(19, 8)) QTest.mouseRelease(w.viewport(), leftButton, pos=QtCore.QPoint(19, 8)) QTest.mouseDClick(w.viewport(), leftButton, pos=QtCore.QPoint(19, 8)) self.assertEqual(self.text_edit.toPlainText(), "item1") self.assertFalse(w.isVisible())
class TviewConsoleWidget(HistoryConsoleWidget): line_input = QtCore.Signal(str) def __init__(self, *args, **kw): super(TviewConsoleWidget, self).__init__(*args, **kw) self._prompt = '>>> ' self.clear() # The bionic version of ConsoleWidget seems to get the cursor # position screwed up after a clear. Let's just fix it up # here. self._append_before_prompt_cursor.setPosition(0) def sizeHint(self): return QtCore.QSize(600, 200) def add_text(self, data): assert data.endswith('\n') or data.endswith('\r') self._append_plain_text(data, before_prompt=True) self._control.moveCursor(QtGui.QTextCursor.End) def _handle_timeout(self): self._append_plain_text('%s\r\n' % time.time(), before_prompt=True) self._control.moveCursor(QtGui.QTextCursor.End) def _is_complete(self, source, interactive): return True, False def _execute(self, source, hidden): self.line_input.emit(source) self._show_prompt(self._prompt) return True
def svg_to_image(string, size=None): """ Convert a SVG document to a QImage. Parameters ---------- string : basestring A Python string containing a SVG document. size : QSize, optional The size of the image that is produced. If not specified, the SVG document's default size is used. Raises ------ ValueError If an invalid SVG string is provided. Returns ------- A QImage of format QImage.Format_ARGB32. """ if isinstance(string, unicode_type): string = string.encode('utf-8') renderer = QtSvg.QSvgRenderer(QtCore.QByteArray(string)) if not renderer.isValid(): raise ValueError('Invalid SVG data.') if size is None: size = renderer.defaultSize() image = QtGui.QImage(size, QtGui.QImage.Format_ARGB32) painter = QtGui.QPainter(image) renderer.render(painter) return image
def _get_image(self, name): """ Returns the QImage stored as the ImageResource with 'name'. """ document = self._control.document() image = document.resource(QtGui.QTextDocument.ImageResource, QtCore.QUrl(name)) return image
def __init__(self, options, parent=None): self.options = options self.port = None self.devices = [] self.default_rate = 100 current_script_dir = os.path.dirname(os.path.abspath(__file__)) uifilename = os.path.join(current_script_dir, "tview_main_window.ui") loader = QtUiTools.QUiLoader() uifile = QtCore.QFile(uifilename) uifile.open(QtCore.QFile.ReadOnly) self.ui = loader.load(uifile, parent) uifile.close() self.ui.configTreeWidget = SizedTreeWidget() self.ui.configDock.setWidget(self.ui.configTreeWidget) self.ui.telemetryTreeWidget = SizedTreeWidget() self.ui.telemetryDock.setWidget(self.ui.telemetryTreeWidget) self.ui.telemetryTreeWidget.itemExpanded.connect( self._handle_tree_expanded) self.ui.telemetryTreeWidget.itemCollapsed.connect( self._handle_tree_collapsed) self.ui.telemetryTreeWidget.setContextMenuPolicy( QtCore.Qt.CustomContextMenu) self.ui.telemetryTreeWidget.customContextMenuRequested.connect( self._handle_telemetry_context_menu) self.ui.configTreeWidget.setItemDelegateForColumn( 0, NoEditDelegate(self.ui)) self.ui.configTreeWidget.itemExpanded.connect( self._handle_config_expanded) self.ui.configTreeWidget.itemChanged.connect( self._handle_config_item_changed) self.ui.plotItemRemoveButton.clicked.connect( self._handle_plot_item_remove) self.console = TviewConsoleWidget() self.console.ansi_codes = False self.console.line_input.connect(self._handle_user_input) self.ui.consoleDock.setWidget(self.console) self.ui.tabifyDockWidget(self.ui.configDock, self.ui.telemetryDock) layout = QtWidgets.QVBoxLayout(self.ui.plotHolderWidget) layout.setContentsMargins(0, 0, 0, 0) layout.setSpacing(0) self.ui.plotHolderWidget.setLayout(layout) self.ui.plotWidget = PlotWidget(self.ui.plotHolderWidget) layout.addWidget(self.ui.plotWidget) def update_plotwidget(value): self.ui.plotWidget.history_s = value self.ui.historySpin.valueChanged.connect(update_plotwidget) QtCore.QTimer.singleShot(0, self._handle_startup)
def deleteRow(self): print('Delete Row Clicked') indices = [] for index in self.table.selectionModel().selectedRows(): indices.append(QtCore.QPersistentModelIndex(index)) for index in indices: self.table.removeRow(index.row())
def mousePressEvent(self, event): try: if self.scene.isUnderMouse(): self.photoClicked.emit(QtCore.QPoint(event.pos())) # keep the default behaviour super(MyQGraphicsView, self).mousePressEvent(event) except Exception as e: print(e)
def addRow(self): print('Add Row Clicked') indices = [] for index in self.table.selectionModel().selectedRows(): indices.append(QtCore.QPersistentModelIndex(index)) if len(indices) > 0: for index in indices: self.insertRow(index.row()) else: self.insertRow(self.table.rowCount())
def __init__(self, parent=None): super(MainDialog, self).__init__(parent) self.setupUi(self) self.setWindowIcon(QIcon(resource_path('assets/weather.ico'))) icon = QIcon() icon.addPixmap(QPixmap(resource_path("assets/search.png")), QIcon.Normal, QIcon.Off) self.pushButton.setIcon(icon) self.pushButton.setIconSize(QtCore.QSize(30, 30)) self.pushButton.setAutoRepeatDelay(200) self.flag = 0 self.pushButton.clicked.connect(self.push_info)
def _add_image(self, image): """ Adds the specified QImage to the document and returns a QTextImageFormat that references it. """ document = self._control.document() name = str(image.cacheKey()) document.addResource(QtGui.QTextDocument.ImageResource, QtCore.QUrl(name), image) format = QtGui.QTextImageFormat() format.setName(name) return format
def drawImage(self, qp): # Return if no image available if self.image.isNull(): return # Save the painters current setting to a stack qp.save() # Draw the image qp.drawImage(QtCore.QRect(self.xoff, self.yoff, self.w, self.h), self.image) # Restore the saved setting from the stack qp.restore()
class QtInProcessChannel(SuperQObject, InProcessChannel): # Emitted when the channel is started. started = QtCore.Signal() # Emitted when the channel is stopped. stopped = QtCore.Signal() # Emitted when any message is received. message_received = QtCore.Signal(object) def start(self): """ Reimplemented to emit signal. """ super(QtInProcessChannel, self).start() self.started.emit() def stop(self): """ Reimplemented to emit signal. """ super(QtInProcessChannel, self).stop() self.stopped.emit() def call_handlers_later(self, *args, **kwds): """ Call the message handlers later. """ do_later = lambda: self.call_handlers(*args, **kwds) QtCore.QTimer.singleShot(0, do_later) def call_handlers(self, msg): self.message_received.emit(msg) def process_events(self): """ Process any pending GUI events. """ QtCore.QCoreApplication.instance().processEvents() def flush(self, timeout=1.0): """ Reimplemented to ensure that signals are dispatched immediately. """ super(QtInProcessChannel, self).flush() self.process_events()
class QtHBChannel(SuperQObject, HBChannel): # A longer timeout than the base class time_to_dead = 3.0 # Emitted when the kernel has died. kernel_died = QtCore.Signal(object) def call_handlers(self, since_last_heartbeat): """ Reimplemented to emit signals instead of making callbacks. """ # Emit the generic signal. self.kernel_died.emit(since_last_heartbeat)
def init_signal(self): """allow clean shutdown on sigint""" signal.signal(signal.SIGINT, lambda sig, frame: self.exit(-2)) # need a timer, so that QApplication doesn't block until a real # Qt event fires (can require mouse movement) # timer trick from http://stackoverflow.com/q/4938723/938949 timer = QtCore.QTimer() # Let the interpreter run each 200 ms: timer.timeout.connect(lambda: None) timer.start(200) # hold onto ref, so the timer doesn't get cleaned up self._sigint_timer = timer
def svg_to_clipboard(string): """ Copy a SVG document to the clipboard. Parameters ---------- string : basestring A Python string containing a SVG document. """ if isinstance(string, unicode_type): string = string.encode('utf-8') mime_data = QtCore.QMimeData() mime_data.setData('image/svg+xml', string) QtGui.QApplication.clipboard().setMimeData(mime_data)
def drawDisp(self, qp): if not self.dispOverlay: return # Save QPainter settings to stack qp.save() # Define transparency qp.setOpacity(self.transp) # Draw the overlay image qp.drawImage(QtCore.QRect(self.xoff, self.yoff, self.w, self.h), self.dispOverlay) # Restore settings qp.restore() return self.dispOverlay
def test_complete(self): class TestKernelClient(object): def is_complete(self, source): calls.append(source) return msg_id w = ConsoleWidget() cursor = w._get_prompt_cursor() w._execute = lambda *args: calls.append(args) w.kernel_client = TestKernelClient() msg_id = object() calls = [] # test incomplete statement (no _execute called, but indent added) w.execute("thing", interactive=True) self.assertEqual(calls, ["thing"]) calls = [] w._handle_is_complete_reply( dict(parent_header=dict(msg_id=msg_id), content=dict(status="incomplete", indent="!!!"))) self.assert_text_equal(cursor, u"thing\u2029> !!!") self.assertEqual(calls, []) # test complete statement (_execute called) msg_id = object() w.execute("else", interactive=True) self.assertEqual(calls, ["else"]) calls = [] w._handle_is_complete_reply( dict(parent_header=dict(msg_id=msg_id), content=dict(status="complete", indent="###"))) self.assertEqual(calls, [("else", False)]) calls = [] self.assert_text_equal(cursor, u"thing\u2029> !!!else\u2029") # test missing answer from is_complete msg_id = object() w.execute("done", interactive=True) self.assertEqual(calls, ["done"]) calls = [] self.assert_text_equal(cursor, u"thing\u2029> !!!else\u2029") event = QtCore.QEvent(QtCore.QEvent.User) w.eventFilter(w, event) self.assert_text_equal(cursor, u"thing\u2029> !!!else\u2029\u2029> ") # assert that late answer isn't destroying anything w._handle_is_complete_reply( dict(parent_header=dict(msg_id=msg_id), content=dict(status="complete", indent="###"))) self.assertEqual(calls, [])
def drawZoom(self, qp, overlay): # Zoom disabled? if not self.zoom: return # No image if self.image.isNull() or not self.w or not self.h: return # No mouse if not self.mousePosOrig: return # Abbrevation for the zoom window size zoomSize = self.zoomSize # Abbrevation for the mouse position mouse = self.mousePosOrig # The pixel that is the zoom center pix = self.mousePosScaled # The size of the part of the image that is drawn in the zoom window selSize = zoomSize / (self.zoomFactor * self.zoomFactor) # The selection window for the image sel = QtCore.QRectF(pix.x() - selSize / 2, pix.y() - selSize / 2, selSize, selSize) # The selection window for the widget view = QtCore.QRectF(mouse.x() - zoomSize / 2, mouse.y() - zoomSize / 2, zoomSize, zoomSize) if overlay: overlay_scaled = overlay.scaled(self.image.width(), self.image.height()) else: overlay_scaled = QtGui.QImage(self.image.width(), self.image.height(), QtGui.QImage.Format_ARGB32_Premultiplied) # Show the zoom image qp.save() qp.drawImage(view, self.image, sel) qp.setOpacity(self.transp) qp.drawImage(view, overlay_scaled, sel) qp.restore()
def selectImage(self): if not self.images: return dlgTitle = "Select image to load" self.statusBar().showMessage(dlgTitle) items = QtCore.QStringList([os.path.basename(i) for i in self.images]) (item, ok) = QtGui.QInputDialog.getItem(self, dlgTitle, "Image", items, self.idx, False) if (ok and item): idx = items.indexOf(item) if idx != self.idx: self.idx = idx self.imageChanged() else: # Restore the message self.statusBar().showMessage(self.defaultStatusbar)
def __init__(self): QWidget.__init__(self) self.setGeometry(100, 100, 300, 200) self.show() self.grid = QGridLayout(self) self.grid.setContentsMargins(0, 0, 0, 0) self.web = QWebEngineView() self.web.load(QUrl(link)) self.grid.addWidget(self.web, 0, 0) self.web2 = QWebEngineView() self.web2.hide() self.web2.load(QUrl(link)) self.grid.addWidget(self.web2, 0, 0) timer = QtCore.QTimer(self) timer.timeout.connect(self.refresh) timer.start(int(sys.argv[-1]))
class QtZMQSocketChannel(ThreadedZMQSocketChannel, SuperQObject): """A ZMQ socket emitting a Qt signal when a message is received.""" message_received = QtCore.Signal(object) def process_events(self): """ Process any pending GUI events. """ QtCore.QCoreApplication.instance().processEvents() def call_handlers(self, msg): """This method is called in the ioloop thread when a message arrives. It is important to remember that this method is called in the thread so that some logic must be done to ensure that the application level handlers are called in the application thread. """ # Emit the generic signal. self.message_received.emit(msg)
def closeEvent(self, event): """ Forward the close event to every tabs contained by the windows """ if self.tab_widget.count() == 0: # no tabs, just close event.accept() return # Do Not loop on the widget count as it change while closing title = self.window().windowTitle() cancel = QtGui.QMessageBox.Cancel okay = QtGui.QMessageBox.Ok accept_role = QtGui.QMessageBox.AcceptRole if self.confirm_exit: if self.tab_widget.count() > 1: msg = "Close all tabs, stop all kernels, and Quit?" else: msg = "Close console, stop kernel, and Quit?" info = "Kernels not started here (e.g. notebooks) will be left alone." closeall = QtGui.QPushButton("&Quit", self) closeall.setShortcut('Q') box = QtGui.QMessageBox(QtGui.QMessageBox.Question, title, msg) box.setInformativeText(info) box.addButton(cancel) box.addButton(closeall, QtGui.QMessageBox.YesRole) box.setDefaultButton(closeall) box.setEscapeButton(cancel) pixmap = QtGui.QPixmap(self._app.icon.pixmap(QtCore.QSize(64,64))) box.setIconPixmap(pixmap) reply = box.exec_() else: reply = okay if reply == cancel: event.ignore() return if reply == okay or reply == accept_role: while self.tab_widget.count() >= 1: # prevent further confirmations: widget = self.active_frontend widget._confirm_exit = False self.close_tab(widget) event.accept()
class MyQGraphicsView(QtGui.QGraphicsView): photoClicked = QtCore.pyqtSignal(QtCore.QPoint) ... def toggleDragMode(self): if self.dragMode() == QtGui.QGraphicsView.ScrollHandDrag: self.setDragMode(QtGui.QGraphicsView.NoDrag) elif not self._photo.pixmap().isNull(): self.setDragMode(QtGui.QGraphicsView.ScrollHandDrag) def mousePressEvent(self, event): try: if self.scene.isUnderMouse(): self.photoClicked.emit(QtCore.QPoint(event.pos())) # keep the default behaviour super(MyQGraphicsView, self).mousePressEvent(event) except Exception as e: print(e) def sizeHint(self): return QSize(400, 400)
def __init__(self, text_edit): """ Create a call tip manager that is attached to the specified Qt text edit widget. """ assert isinstance(text_edit, (QtGui.QTextEdit, QtGui.QPlainTextEdit)) super(CallTipWidget, self).__init__(None, QtCore.Qt.ToolTip) self._hide_timer = QtCore.QBasicTimer() self._text_edit = text_edit self.setFont(text_edit.document().defaultFont()) self.setForegroundRole(QtGui.QPalette.ToolTipText) self.setBackgroundRole(QtGui.QPalette.ToolTipBase) self.setPalette(QtGui.QToolTip.palette()) self.setAlignment(QtCore.Qt.AlignLeft) self.setIndent(1) self.setFrameStyle(QtGui.QFrame.NoFrame) self.setMargin(1 + self.style().pixelMetric( QtGui.QStyle.PM_ToolTipLabelFrameWidth, None, self)) self.setWindowOpacity(self.style().styleHint( QtGui.QStyle.SH_ToolTipLabel_Opacity, None, self, None) / 255.0) self.setWordWrap(True)
class QtInProcessHBChannel(SuperQObject, InProcessHBChannel): # This signal will never be fired, but it needs to exist kernel_died = QtCore.Signal()
def sizeHint(self): return QtCore.QSize(600, 200)