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)
