def select_diagonal(self):
vb = self.widget.curveplot.plot.vb
vb.set_mode_select()
vr = vb.viewRect()
QTest.qWait(100)
tls = vr.bottomRight() if self.widget.curveplot.invertX else vr.bottomLeft()
brs = vr.topLeft() if self.widget.curveplot.invertX else vr.topRight()
tl = vb.mapViewToScene(tls).toPoint() + QPoint(2, 2)
br = vb.mapViewToScene(brs).toPoint() - QPoint(2, 2)
ca = self.widget.curveplot.childAt(tl)
QTest.mouseClick(ca, Qt.LeftButton, pos=tl)
QTest.mouseMove(self.widget.curveplot, pos=tl)
QTest.mouseMove(self.widget.curveplot)
QTest.qWait(1)
QTest.mouseClick(ca, Qt.LeftButton, pos=br)
def test_arrow_annotation_action(self):
w = self.w
workflow = w.scheme()
workflow.clear()
view = w.view()
w.resize(300, 300)
actions = w.toolbarActions()
action_by_name(actions, "new-arrow-action").trigger()
QTest.mousePress(view.viewport(), Qt.LeftButton, pos=QPoint(50, 50))
mouseMove(view.viewport(), Qt.LeftButton, pos=QPoint(100, 100))
QTest.mouseRelease(view.viewport(),
Qt.LeftButton,
pos=QPoint(100, 100))
self.assertEqual(len(workflow.annotations), 1)
self.assertIsInstance(workflow.annotations[0], SchemeArrowAnnotation)
def test_selection(self):
data = Table('iris')
selected_indices = []
def selection_callback(indices):
nonlocal selected_indices
selected_indices = indices
scatter = SelectionScatter(selection_callback)
scatter.chart(options=dict(series=[dict(data=data.X[:, :2])]))
scatter.show()
while scatter.isHidden() or not scatter.geometry().isValid():
qApp.processEvents()
time.sleep(.05)
time.sleep(1) # add some time for WM to place window or whatever
topleft = scatter.geometry().topLeft()
bottomright = scatter.geometry().bottomRight()
startpos = topleft + QPoint(100, 100)
endpos = bottomright - QPoint(300, 300)
# Simulate selection
QTest.mousePress(scatter, Qt.LeftButton, Qt.NoModifier, startpos, 1000)
qApp.processEvents()
QTest.mouseMove(scatter, endpos)
qApp.processEvents()
QTest.mouseRelease(scatter, Qt.LeftButton, Qt.NoModifier, endpos, 100)
while not selected_indices:
qApp.processEvents()
time.sleep(.05)
self.assertEqual(len(selected_indices), 1)
self.assertGreater(len(selected_indices[0]), 0)
# Simulate deselection
QTest.mouseClick(scatter, Qt.LeftButton, Qt.NoModifier,
startpos - QPoint(10, 10))
while selected_indices:
qApp.processEvents()
time.sleep(.05)
self.assertFalse(len(selected_indices))
QTest.keyClick(scatter, Qt.Key_Escape)
self.assertTrue(scatter.isHidden())
def is_valid_url(self, url):
if is_valid_url(url):
self.Error.invalid_url.clear()
return True
self.Error.invalid_url()
QToolTip.showText(self.combo.mapToGlobal(QPoint(0, 0)),
self.combo.toolTip())
def decorate_welcome_icon(icon, background_color):
"""Return a `QIcon` with a circle shaped background.
"""
welcome_icon = QIcon()
sizes = [32, 48, 64, 80]
background_color = NAMED_COLORS.get(background_color, background_color)
background_color = QColor(background_color)
grad = radial_gradient(background_color)
for size in sizes:
icon_pixmap = icon.pixmap(5 * size / 8, 5 * size / 8)
icon_size = icon_pixmap.size()
icon_rect = QRect(QPoint(0, 0), icon_size)
pixmap = QPixmap(size, size)
pixmap.fill(QColor(0, 0, 0, 0))
p = QPainter(pixmap)
p.setRenderHint(QPainter.Antialiasing, True)
p.setBrush(QBrush(grad))
p.setPen(Qt.NoPen)
ellipse_rect = QRect(0, 0, size, size)
p.drawEllipse(ellipse_rect)
icon_rect.moveCenter(ellipse_rect.center())
p.drawPixmap(icon_rect.topLeft(), icon_pixmap)
p.end()
welcome_icon.addPixmap(pixmap)
return welcome_icon
def __testaxis(self, event):
viewbox = self.parent()
widget = event.widget()
assert widget is not None
view = widget.parent()
assert isinstance(view, QGraphicsView)
pos = view.mapFromGlobal(event.screenPos())
hitarea = view.mapToScene(QRect(pos - QPoint(2, 2), QSize(4, 4)))
hitarea = viewbox.mapFromScene(hitarea)
hitarea = viewbox.mapToView(hitarea).boundingRect()
center = hitarea.center()
if center.x() < 0:
hitarea.moveCenter(QPointF(-center.x(), center.y()))
cx = self.selection[1][1].x()
cy = self.selection[1][1].y()
if hitarea.contains(QPointF(cx, cy)):
axes = Qt.Horizontal | Qt.Vertical
elif hitarea.bottom() > cy > hitarea.top() and hitarea.left() > cx:
axes = Qt.Vertical
elif hitarea.left() < cx < hitarea.right() and hitarea.bottom() > cy:
axes = Qt.Horizontal
else:
axes = 0
return axes
def test_show_tip(self):
w = QWidget()
show_tip(w, QPoint(100, 100), "Ha Ha")
app = QApplication.instance()
windows = app.topLevelWidgets()
label = [
tl for tl in windows
if tl.parent() is w and tl.objectName() == "tip-label"
][0]
self.assertTrue(label.isVisible())
self.assertTrue(label.text() == "Ha Ha")
show_tip(w, QPoint(100, 100), "Ha")
self.assertTrue(label.text() == "Ha")
show_tip(w, QPoint(100, 100), "")
self.assertFalse(label.isVisible())
def test_text_annotation_action(self):
w = self.w
workflow = w.scheme()
workflow.clear()
view = w.view()
w.resize(300, 300)
actions = w.toolbarActions()
action_by_name(actions, "new-text-action").trigger()
QTest.mousePress(view.viewport(), Qt.LeftButton, pos=QPoint(50, 50))
mouseMove(view.viewport(), Qt.LeftButton, pos=QPoint(100, 100))
QTest.mouseRelease(view.viewport(), Qt.LeftButton, pos=QPoint(100, 100))
# need to steal focus from the item for it to be commited.
w.scene().setFocusItem(None)
self.assertEqual(len(workflow.annotations), 1)
self.assertIsInstance(workflow.annotations[0], SchemeTextAnnotation)
def dragEnterLeave(widget: QWidget,
mime: QMimeData,
pos=QPoint(),
action=Qt.CopyAction,
buttons=Qt.LeftButton,
modifiers=Qt.NoModifier) -> None:
"""
Simulate a drag/move/leave interaction on the `widget`.
A QDragEnterEvent, QDragMoveEvent and a QDragLeaveEvent are created
and dispatched to the widget.
"""
if pos.isNull():
pos = widget.rect().center()
ev = QDragEnterEvent(pos, action, mime, buttons, modifiers)
ev.setAccepted(False)
QApplication.sendEvent(widget, ev)
ev = QDragMoveEvent(pos, action, mime, buttons, modifiers,
QDragMoveEvent.DragMove)
ev.setAccepted(False)
QApplication.sendEvent(widget, ev)
ev = QDragLeaveEvent()
ev.setAccepted(False)
QApplication.sendEvent(widget, ev)
return
def __shadowPixmapForDpr(self, dpr=1.0):
# type: (float) -> QPixmap
"""
Return a shadow pixmap rendered in `dpr` device pixel ratio.
"""
offset = self.offset()
radius = self.radius()
color = self.color()
fill_color = self.palette().color(QPalette.Window)
rect_size = QSize(int(50 * dpr), int(50 * dpr))
left = top = right = bottom = int(radius * dpr)
# Size of the pixmap.
pixmap_size = QSize(rect_size.width() + left + right,
rect_size.height() + top + bottom)
shadow_rect = QRect(QPoint(left, top) - offset * dpr, rect_size)
pixmap = QPixmap(pixmap_size)
pixmap.fill(Qt.transparent)
pixmap = render_drop_shadow_frame(
pixmap,
QRectF(shadow_rect),
shadow_color=color,
offset=QPointF(offset * dpr),
radius=radius * dpr,
rect_fill_color=fill_color
)
pixmap.setDevicePixelRatio(dpr)
return pixmap
def popup(self, pos=None, searchText=""):
"""
Popup the menu at `pos` (in screen coordinates). 'Search' text field
is initialized with `searchText` if provided.
"""
if pos is None:
pos = QPoint()
self.__clearCurrentItems()
self.__search.setText(searchText)
patt = QRegExp("(^|\W)" + searchText)
patt.setCaseSensitivity(False)
self.__suggestPage.setFilterRegExp(patt)
self.ensurePolished()
if self.testAttribute(Qt.WA_Resized) and self.sizeGripEnabled():
size = self.size()
else:
size = self.sizeHint()
desktop = QApplication.desktop()
screen_geom = desktop.availableGeometry(pos)
# Adjust the size to fit inside the screen.
if size.height() > screen_geom.height():
size.setHeight(screen_geom.height())
if size.width() > screen_geom.width():
size.setWidth(screen_geom.width())
geom = QRect(pos, size)
if geom.top() < screen_geom.top():
geom.setTop(screen_geom.top())
if geom.left() < screen_geom.left():
geom.setLeft(screen_geom.left())
bottom_margin = screen_geom.bottom() - geom.bottom()
right_margin = screen_geom.right() - geom.right()
if bottom_margin < 0:
# Falls over the bottom of the screen, move it up.
geom.translate(0, bottom_margin)
# TODO: right to left locale
if right_margin < 0:
# Falls over the right screen edge, move the menu to the
# other side of pos.
geom.translate(-size.width(), 0)
self.setGeometry(geom)
self.show()
if searchText:
self.setFocusProxy(self.__search)
else:
self.setFocusProxy(None)
def test_drop_sample(self):
path = os.path.join(self._path, "lib.cell.count")
data = QMimeData()
data.setUrls([QUrl.fromLocalFile(path)])
event = QDropEvent(QPoint(10, 10), Qt.MoveAction, data, Qt.NoButton,
Qt.NoModifier, QDropEvent.Drop)
self.widget.view.dropEvent(event)
self.assertEqual(self.widget.view.model().rowCount(), 3)
def test_tool_tips(self):
scene = GraphicsScene()
view = QGraphicsView(scene)
w = TextListWidget()
text = "A" * 10
w.setItems([text, text])
scene.addItem(w)
view.grab() # ensure w is laid out
wrect = view.mapFromScene(w.mapToScene(
w.contentsRect())).boundingRect()
p = QPoint(wrect.topLeft() + QPoint(5, 5))
ev = QHelpEvent(QHelpEvent.ToolTip, p, view.viewport().mapToGlobal(p))
try:
QApplication.sendEvent(view.viewport(), ev)
self.assertEqual(QToolTip.text(), text)
finally:
QToolTip.hideText()
def __init__(self, *args, **kwargs):
self.__scaledMinimum = kwargs.pop('minimum', 0)
self.__scaledMaximum = kwargs.pop('maximum', 99)
tracking = kwargs.pop('tracking', True)
self.__steps = max(kwargs.pop('steps', 1024), 1)
self.__scale = (self.__scaledMaximum -
self.__scaledMinimum) / self.__steps
self._tickList = kwargs.pop('ticks', None)
if self._tickList is not None:
self._tickList = np.unique(self._tickList)
self._tickImage = QPixmap()
minimum = kwargs['minimum'] = 0
maximum = kwargs['maximum'] = self.__steps
self.__position0 = self.__value0 = kwargs.pop('value0', minimum)
self.__position1 = self.__value1 = kwargs.pop('value1', maximum)
self._handleWidth = kwargs.pop('handleWidth', 10)
self._tickHeight = 4
kwargs['orientation'] = Qt.Horizontal
super().__init__(*args, **kwargs)
self.setTracking(tracking)
self.setMouseTracking(True)
self.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed)
# holds bounding rectangles for handle0, handle1, inner handle and groove respectively; last rect is invalid
self._rects = [QRect(), QRect(), QRect(), QRect()]
# the index of the handle used as index to _rects; -1 is none
self._hover = -1
self._press = -1
# used to calculate mouse events
self._handleOffset = QPoint()
self._lastPos = (maximum, minimum)
self._lastClick = QPoint()
#
self._makeTickMarks()
def dragDrop(widget: QWidget,
mime: QMimeData,
pos: QPoint = QPoint(),
action=Qt.CopyAction,
buttons=Qt.LeftButton,
modifiers=Qt.NoModifier) -> bool:
"""
Simulate a drag/drop interaction on the `widget`.
A `QDragEnterEvent`, `QDragMoveEvent` and `QDropEvent` are created and
dispatched to the `widget`. However if any of the `QDragEnterEvent` or
`QDragMoveEvent` are not accepted, a `QDragLeaveEvent` is dispatched
to 'reset' the widget state before this function returns `False`
Parameters
----------
widget: QWidget
The target widget.
mime: QMimeData
The mime data associated with the drag/drop.
pos: QPoint
Position of the drop
action: Qt.DropActions
Type of acceptable drop actions
buttons: Qt.MouseButtons:
Pressed mouse buttons.
modifiers: Qt.KeyboardModifiers
Pressed keyboard modifiers.
Returns
-------
state: bool
Were the events accepted.
See Also
--------
QDragEnterEvent, QDropEvent
"""
if pos.isNull():
pos = widget.rect().center()
ev = QDragEnterEvent(pos, action, mime, buttons, modifiers)
ev.setAccepted(False)
QApplication.sendEvent(widget, ev)
ev = QDragMoveEvent(pos, action, mime, buttons, modifiers)
ev.setAccepted(False)
QApplication.sendEvent(widget, ev)
if not ev.isAccepted():
QApplication.sendEvent(widget, QDragLeaveEvent())
return False
ev = QDropEvent(QPointF(pos), action, mime, buttons, modifiers)
ev.setAccepted(False)
QApplication.sendEvent(widget, ev)
return ev.isAccepted()
def dragDrop(widget: 'QWidget',
mime: QMimeData,
pos: QPoint = QPoint(-1, -1),
action=Qt.CopyAction,
buttons=Qt.LeftButton,
modifiers=Qt.NoModifier) -> bool:
if pos == QPoint(-1, -1):
pos = widget.rect().center()
ev = QDragEnterEvent(pos, action, mime, buttons, modifiers)
ev.setAccepted(False)
QApplication.sendEvent(widget, ev)
if not ev.isAccepted():
return False
ev = QDropEvent(QPointF(pos), action, mime, buttons, modifiers)
ev.setAccepted(False)
QApplication.sendEvent(widget, ev)
return ev.isAccepted()
