def test_saved_selection(self):
self.send_signal(self.widget.Inputs.data, self.heart)
rf_cls = RandomForestLearner(random_state=42)(self.heart)
self.send_signal(self.widget.Inputs.model, rf_cls)
self.wait_until_finished()
plot = self.widget._violin_plot
h = plot.layout().itemAt(0, plot.VIOLIN_COLUMN)
pos = self.widget.view.mapFromScene(h.scenePos())
QTest.mousePress(self.widget.view.viewport(),
Qt.LeftButton,
pos=pos + QPoint(250, 10))
mouseMove(self.widget.view.viewport(),
Qt.LeftButton,
pos=pos + QPoint(300, 20))
QTest.mouseRelease(self.widget.view.viewport(),
Qt.LeftButton,
pos=pos + QPoint(300, 30))
saved_selection = self.get_output(self.widget.Outputs.selected_data)
settings = self.widget.settingsHandler.pack_data(self.widget)
widget = self.create_widget(OWExplainModel, stored_settings=settings)
self.send_signal(widget.Inputs.data, self.heart, widget=widget)
rf_cls = RandomForestLearner(random_state=42)(self.heart)
self.send_signal(widget.Inputs.model, rf_cls, widget=widget)
self.wait_until_finished(widget=widget)
selection = self.get_output(widget.Outputs.selected_data,
widget=widget)
np.testing.assert_array_equal(selection.X, saved_selection.X)
def test_selection(self):
w = HeatmapGridWidget()
self.scene.addItem(w)
w.setHeatmaps(self._Data["2-2"])
view = self.view
w.resize(w.effectiveSizeHint(Qt.PreferredSize))
h = w.layout().itemAt(w.Row0, w.Col0 + 1)
pos = view.mapFromScene(h.scenePos())
spy = QSignalSpy(w.selectionFinished)
QTest.mouseClick(
view.viewport(), Qt.LeftButton, pos=pos + QPoint(1, 1)
)
self.assertSequenceEqual(list(spy), [[]])
self.assertSequenceEqual(w.selectedRows(), [0])
spy = QSignalSpy(w.selectionFinished)
QTest.mouseClick(
view.viewport(), Qt.LeftButton, Qt.ControlModifier,
pos=pos + QPoint(1, 1)
)
self.assertSequenceEqual(list(spy), [[]])
self.assertSequenceEqual(w.selectedRows(), [])
spy = QSignalSpy(w.selectionFinished)
QTest.mousePress(view.viewport(), Qt.LeftButton, pos=pos + QPoint(1, 1))
mouseMove(view.viewport(), Qt.LeftButton, pos=pos + QPoint(20, 20))
QTest.mouseRelease(view.viewport(), Qt.LeftButton,
pos=pos + QPoint(30, 40))
self.assertSequenceEqual(list(spy), [[]])
spy_fin = QSignalSpy(w.selectionFinished)
spy_chn = QSignalSpy(w.selectionChanged)
w.selectRows([1])
self.assertSequenceEqual(list(spy_fin), [])
self.assertSequenceEqual(list(spy_chn), [[]])
def test_drag_drop(self):
w = self.w
w.setRegistry(self.reg)
handler = TestDropHandler()
w.setDropHandlers([handler])
viewport = w.view().viewport()
mime = QMimeData()
mime.setData(handler.format_, b'abc')
dragDrop(viewport, mime, QPoint(10, 10))
self.assertEqual(handler.doDrop_calls, 1)
self.assertGreaterEqual(handler.accepts_calls, 1)
self.assertIsNone(w._userInteractionHandler())
handler.accepts_calls = 0
handler.doDrop_calls = 0
mime = QMimeData()
mime.setData("application/prs.do-not-accept-this", b'abc')
dragDrop(viewport, mime, QPoint(10, 10))
self.assertGreaterEqual(handler.accepts_calls, 1)
self.assertEqual(handler.doDrop_calls, 0)
self.assertIsNone(w._userInteractionHandler())
dragEnterLeave(viewport, mime, QPoint(10, 10))
self.assertIsNone(w._userInteractionHandler())
def do_zoom_rect(self, invertX):
""" Test zooming with two clicks. """
self.send_signal("Data", self.iris)
vb = self.widget.curveplot.plot.vb
self.widget.curveplot.invertX = invertX
self.widget.curveplot.invertX_apply()
vb.set_mode_zooming()
vr = vb.viewRect()
tls = vr.bottomRight(
) if self.widget.curveplot.invertX else vr.bottomLeft()
# move down to avoid clicking on the menu button
tl = vb.mapViewToScene(tls).toPoint() + QPoint(0, 100)
br = vb.mapViewToScene(vr.center()).toPoint()
tlw = vb.mapSceneToView(tl)
brw = vb.mapSceneToView(br)
ca = self.widget.curveplot.childAt(tl)
QTest.mouseClick(ca, Qt.LeftButton, pos=tl)
QTest.qWait(1)
self.widget.curveplot.plot.scene().sigMouseMoved.emit(tl)
QTest.qWait(1)
self.widget.curveplot.plot.scene().sigMouseMoved.emit(tl +
QPoint(10, 10))
QTest.qWait(1)
QTest.mouseClick(ca, Qt.LeftButton, pos=br)
vr = vb.viewRect()
self.assertAlmostEqual(vr.bottom(), tlw.y())
self.assertAlmostEqual(vr.top(), brw.y())
if self.widget.curveplot.invertX:
self.assertAlmostEqual(vr.right(), tlw.x())
self.assertAlmostEqual(vr.left(), brw.x())
else:
self.assertAlmostEqual(vr.left(), tlw.x())
self.assertAlmostEqual(vr.right(), brw.x())
def test_popup_position(self):
menu = QuickMenu()
screen = menu.screen()
screen_geom = screen.availableGeometry()
menu.popup(QPoint(screen_geom.topLeft() - QPoint(20, 20)))
geom = menu.geometry()
self.assertEqual(screen_geom.intersected(geom), geom)
def testArrowContact(self, indices, x, y):
if type(indices) != list: indices = [indices]
for index in indices:
if index >= len(self.attributes) or index < 0:
continue
int_x = self.transform(xBottom, index)
bottom = self.transform(
yLeft,
self.selection_conditions.get(self.attributes[index],
[0, 1])[0])
bottom_rect = QRect(int_x - self.bottom_pixmap.width() / 2, bottom,
self.bottom_pixmap.width(),
self.bottom_pixmap.height())
if bottom_rect.contains(QPoint(x, y)):
return 1, (index, 0)
top = self.transform(
yLeft,
self.selection_conditions.get(self.attributes[index],
[0, 1])[1])
top_rect = QRect(int_x - self.top_pixmap.width() / 2,
top - self.top_pixmap.height(),
self.top_pixmap.width(), self.top_pixmap.height())
if top_rect.contains(QPoint(x, y)):
return 1, (index, 1)
return 0, (0, 0)
def test_select_by_click(self):
view = self.widget.table_view
self.send_signal(self.widget.Inputs.data, self.heart_disease)
self.agg_checkboxes[Pivot.Functions.Sum.value].click()
simulate.combobox_activate_item(self.widget.controls.val_feature,
self.heart_disease.domain[0].name)
# column in a group
QTest.mouseClick(view.viewport(), Qt.LeftButton, pos=QPoint(208, 154))
self.assertSetEqual({(3, 0), (2, 0)}, view.get_selection())
# column
QTest.mouseClick(view.viewport(), Qt.LeftButton, pos=QPoint(340, 40))
self.assertSetEqual({(0, 1), (3, 1), (1, 1), (2, 1)},
view.get_selection())
# group
QTest.mouseClick(view.viewport(), Qt.LeftButton, pos=QPoint(155, 75))
self.assertSetEqual({(0, 1), (1, 0), (0, 0), (1, 1)},
view.get_selection())
# all
QTest.mouseClick(view.viewport(), Qt.LeftButton, pos=QPoint(400, 198))
self.assertSetEqual(
{(0, 1), (0, 0), (3, 0), (3, 1), (2, 1), (2, 0), (1, 0), (1, 1)},
view.get_selection())
def wheelEvent(self, event: QWheelEvent):
# Zoom
if event.modifiers() & Qt.ControlModifier \
and event.buttons() == Qt.NoButton:
delta = event.angleDelta().y()
# use mouse position as anchor while zooming
anchor = self.transformationAnchor()
self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.__setZoomLevel(self.__zoomLevel + 10 * delta / 120)
self.setTransformationAnchor(anchor)
event.accept()
# Scroll horizontally
elif self.__should_scroll_horizontally(event):
x, y = event.angleDelta().x(), event.angleDelta().y()
sign_value = x if x != 0 else y
sign = 1 if sign_value >= 0 else -1
new_angle_delta = QPoint(sign * max(abs(x), abs(y), sign_value), 0)
new_pixel_delta = QPoint(0, 0)
new_modifiers = event.modifiers() & ~(Qt.ShiftModifier
| Qt.AltModifier)
new_event = QWheelEvent(event.pos(), event.globalPos(),
new_pixel_delta, new_angle_delta,
event.buttons(), new_modifiers,
event.phase(), event.inverted(),
event.source())
event.accept()
super().wheelEvent(new_event)
else:
super().wheelEvent(event)
def test_widget(self):
w = self.widget
T = hierarchical.Tree
C = hierarchical.ClusterData
S = hierarchical.SingletonData
def t(h: float, left: T, right: T):
return T(C((left.value.first, right.value.last), h), (left, right))
def leaf(r, index):
return T(S((r, r + 1), 0.0, index))
T = hierarchical.Tree
w.set_root(t(0.0, leaf(0, 0), leaf(1, 1)))
w.resize(w.effectiveSizeHint(Qt.PreferredSize))
h = w.height_at(QPoint())
self.assertEqual(h, 0)
h = w.height_at(QPoint(10, 0))
self.assertEqual(h, 0)
self.assertEqual(w.pos_at_height(0).x(), w.rect().x())
self.assertEqual(w.pos_at_height(1).x(), w.rect().x())
height = np.finfo(float).eps
w.set_root(t(height, leaf(0, 0), leaf(1, 1)))
h = w.height_at(QPoint())
self.assertEqual(h, height)
h = w.height_at(QPoint(w.size().width(), 0))
self.assertEqual(h, 0)
self.assertEqual(w.pos_at_height(0).x(), w.rect().right())
self.assertEqual(w.pos_at_height(height).x(), w.rect().left())
def test_saved_selection(self):
log_reg = RandomForestLearner(random_state=0)(self.heart)
self.send_signal(self.widget.Inputs.data, self.heart)
self.send_signal(self.widget.Inputs.model, log_reg)
self.wait_until_finished()
plot = self.widget.plot
h = plot.layout().itemAt(0, plot.ITEM_COLUMN)
pos = self.widget.view.mapFromScene(h.scenePos())
QTest.mousePress(self.widget.view.viewport(), Qt.LeftButton,
pos=pos + QPoint(0, 10))
mouseMove(self.widget.view.viewport(), Qt.LeftButton,
pos=pos + QPoint(300, 20))
QTest.mouseRelease(self.widget.view.viewport(), Qt.LeftButton,
pos=pos + QPoint(300, 30))
saved_selection = self.get_output(self.widget.Outputs.selected_data)
self.assertIsNotNone(saved_selection)
settings = self.widget.settingsHandler.pack_data(self.widget)
w = self.create_widget(OWPermutationImportance,
stored_settings=settings)
self.send_signal(w.Inputs.data, self.heart, widget=w)
log_reg = RandomForestLearner(random_state=0)(self.heart)
self.send_signal(w.Inputs.model, log_reg, widget=w)
self.wait_until_finished(widget=w)
selection = self.get_output(w.Outputs.selected_data, widget=w)
np.testing.assert_array_equal(selection.X, saved_selection.X)
def wheelEvent(self, event: QWheelEvent):
if event.modifiers() & Qt.ControlModifier \
and event.buttons() == Qt.NoButton:
# Zoom
delta = event.angleDelta().y()
# use mouse position as anchor while zooming
anchor = self.transformationAnchor()
self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.__setZoomLevel(self.__zoomLevel + 10 * delta / 120)
self.setTransformationAnchor(anchor)
event.accept()
elif event.source() == Qt.MouseEventNotSynthesized \
and (event.angleDelta().x() == 0 \
and not self.verticalScrollBar().isVisible()) \
or (sys.platform == 'darwin' and event.modifiers() & Qt.ShiftModifier
or sys.platform != 'darwin' and event.modifiers() & Qt.AltModifier):
# Scroll horizontally
x, y = event.angleDelta().x(), event.angleDelta().y()
sign_value = x if x != 0 else y
sign = 1 if sign_value >= 0 else -1
new_angle_delta = QPoint(sign * max(abs(x), abs(y), sign_value), 0)
new_pixel_delta = QPoint(0, 0)
new_modifiers = event.modifiers() & ~(Qt.ShiftModifier
| Qt.AltModifier)
new_event = QWheelEvent(event.pos(), event.globalPos(),
new_pixel_delta, new_angle_delta,
event.buttons(), new_modifiers,
event.phase(), event.inverted(),
event.source())
event.accept()
super().wheelEvent(new_event)
else:
super().wheelEvent(event)
def add_arc_arrows(x, y, col):
func = self.view_box.childGroup.mapToDevice
dx = (func(QPoint(1, 0)) - func(QPoint(-1, 0))).x()
dangle = 6000 / dx
arc = add_arc(np.arctan2(y, x), col, dangle)
for a in arc:
self.plot_widget.addItem(a)
self.master.plotdata.arcarrows += arc
def _add_indicator_item(self, point_i):
if point_i is None:
return
x, y = self._points[point_i][:2]
col = self.view_box.mouse_state
dx = (self.view_box.childGroup.mapToDevice(QPoint(1, 0)) -
self.view_box.childGroup.mapToDevice(QPoint(-1, 0))).x()
self._indicator_item = MoveIndicator(np.arctan2(y, x), col, 6000 / dx)
self.plot_widget.addItem(self._indicator_item)
def _add_indicator_item(self, anchor_idx):
if anchor_idx is None:
return
x, y = self.anchor_items[anchor_idx].get_xy()
col = self.view_box.mouse_state
dx = (self.view_box.childGroup.mapToDevice(QPoint(1, 0)) -
self.view_box.childGroup.mapToDevice(QPoint(-1, 0))).x()
self.indicator_item = MoveIndicator(np.arctan2(y, x), col, 6000 / dx)
self.plot_widget.addItem(self.indicator_item)
def show_indicator(self, point_i):
points = self.master.plotdata.anchors
func = self.view_box.childGroup.mapToDevice
dx = (func(QPoint(1, 0)) - func(QPoint(-1, 0))).x()
scene_size = 600 / dx
self.master.plotdata.indicators.append(
MoveIndicator(points[point_i][0], points[point_i][1], scene_size=scene_size)
)
self.plot_widget.addItem(self.master.plotdata.indicators[0])
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 test_arrow_annotation_action(self):
w = self.w
workflow = w.scheme()
workflow.clear()
view = w.view()
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 __calcSloppyRegion(self, current):
# type: (QPoint) -> QRegion
"""
Given a current mouse cursor position return a region of the widget
where hover/move events should change the current tab only on a
timeout.
"""
p1 = current + QPoint(0, 2)
p2 = current + QPoint(0, -2)
p3 = self.pos() + QPoint(self.width() + 10, 0)
p4 = self.pos() + QPoint(self.width() + 10, self.height())
return QRegion(QPolygon([p1, p2, p3, p4]))
def paintEvent(self, event):
"""
Paint the interpolated pixmap image.
"""
p = QPainter(self)
p.setClipRect(event.rect())
factor = self.blendingFactor_**2
if self.pixmap1 and 1. - factor:
p.setOpacity(1. - factor)
p.drawPixmap(QPoint(0, 0), self.pixmap1)
if self.pixmap2 and factor:
p.setOpacity(factor)
p.drawPixmap(QPoint(0, 0), self.pixmap2)
def qWheelScroll(
widget: QWidget,
buttons=Qt.NoButton,
modifiers=Qt.NoModifier,
pos=QPoint(),
angleDelta=QPoint(0, 1),
):
if pos.isNull():
pos = widget.rect().center()
globalPos = widget.mapToGlobal(pos)
event = QWheelEvent(QPointF(pos), QPointF(globalPos), QPoint(), angleDelta,
buttons, modifiers, Qt.NoScrollPhase, False)
QApplication.sendEvent(widget, event)
def drawBackground(self, painter, rect):
super().drawBackground(painter, rect)
if not self.__backgroundIcon.isNull():
painter.setClipRect(rect)
vrect = QRect(QPoint(0, 0), self.viewport().size())
vrect = self.mapToScene(vrect).boundingRect()
pm = self.__backgroundIcon.pixmap(vrect.size().toSize().boundedTo(
QSize(200, 200)))
pmrect = QRect(QPoint(0, 0), pm.size())
pmrect.moveCenter(vrect.center().toPoint())
if rect.toRect().intersects(pmrect):
painter.drawPixmap(pmrect, pm)
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 select_diagonal(self):
vb = self.widget.curveplot.plot.vb
vb.set_mode_select()
vr = vb.viewRect()
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, 100) # avoid menu button
br = vb.mapViewToScene(brs).toPoint() - QPoint(2, 2)
ca = self.widget.curveplot.childAt(tl)
QTest.mouseClick(ca, Qt.LeftButton, pos=tl)
self.widget.curveplot.plot.scene().sigMouseMoved.emit(tl)
self.widget.curveplot.plot.scene().sigMouseMoved.emit(tl + QPoint(10, 10))
QTest.qWait(1)
QTest.mouseClick(ca, Qt.LeftButton, pos=br)
def test_text_annotation_action(self):
w = self.w
workflow = w.scheme()
workflow.clear()
view = w.view()
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 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 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) # test mouseMoved code
QTest.mouseMove(self.widget.curveplot) # test mouseMoved code
QTest.qWait(1)
QTest.mouseClick(ca, Qt.LeftButton, pos=br)
def test_zoom_rect(self):
""" Test zooming with two clicks. """
self.widget.show()
qWaitForWindow(self.widget)
self.send_signal("Data", self.iris)
vb = self.widget.curveplot.plot.vb
vb.set_mode_zooming()
vr = vb.viewRect()
QTest.qWait(100)
tls = vr.bottomRight(
) if self.widget.curveplot.invertX else vr.bottomLeft()
tl = vb.mapViewToScene(tls).toPoint() + QPoint(2, 2)
br = vb.mapViewToScene(vr.center()).toPoint()
tlw = vb.mapSceneToView(tl)
brw = vb.mapSceneToView(br)
ca = self.widget.curveplot.childAt(tl)
QTest.mouseClick(ca, Qt.LeftButton, pos=tl)
QTest.qWait(1)
QTest.mouseMove(self.widget.curveplot, pos=tl) # test mouseMoved code
QTest.qWait(1)
QTest.mouseMove(self.widget.curveplot) # test mouseMoved code
QTest.qWait(1)
QTest.mouseClick(ca, Qt.LeftButton, pos=br)
vr = vb.viewRect()
self.assertAlmostEqual(vr.bottom(), tlw.y())
self.assertAlmostEqual(vr.top(), brw.y())
if self.widget.curveplot.invertX:
self.assertAlmostEqual(vr.right(), tlw.x())
self.assertAlmostEqual(vr.left(), brw.x())
else:
self.assertAlmostEqual(vr.left(), tlw.x())
self.assertAlmostEqual(vr.right(), brw.x())
self.widget.hide()
def __calculate_actual_offset(self, offset):
"""Take the offset specified in the constructor and calculate the
actual offset from the top left corner of the item so positioning can
be done correctly."""
off_x, off_y = offset.x(), offset.y()
width = self.boundingRect().width()
height = self.boundingRect().height()
if self.__corner_str == self.TOP_LEFT:
return QPoint(-off_x, -off_y)
elif self.__corner_str == self.TOP_RIGHT:
return QPoint(off_x + width, -off_y)
elif self.__corner_str == self.BOTTOM_RIGHT:
return QPoint(off_x + width, off_y + height)
elif self.__corner_str == self.BOTTOM_LEFT:
return QPoint(-off_x, off_y + height)
def splash_screen():
splash_n = random.randint(1, 3)
path = pkg_resources.resource_filename(
__name__, f"icons/orange-splash-screen-{splash_n:02}.png")
pm = QPixmap(path)
version = Config.ApplicationVersion
if version:
version_parsed = LooseVersion(version)
version_comp = version_parsed.version
version = ".".join(map(str, version_comp[:2]))
size = 13
font = QFont("Helvetica")
font.setPixelSize(size)
metrics = QFontMetrics(font)
br = metrics.boundingRect(version)
br.moveTopLeft(QPoint(171, 438))
p = QPainter(pm)
p.setRenderHint(QPainter.Antialiasing)
p.setRenderHint(QPainter.TextAntialiasing)
p.setFont(font)
p.setPen(QColor("#000000"))
p.drawText(br, Qt.AlignLeft, version)
p.end()
return pm, QRect(23, 24, 200, 20)
def _select_data(self):
self.widget.attr_x, self.widget.attr_y = self.data.domain[:2]
area = self.widget.areas[0]
self.widget.select_area(area, QMouseEvent(
QEvent.MouseButtonPress, QPoint(), Qt.LeftButton,
Qt.LeftButton, Qt.KeyboardModifiers()))
return [0, 4, 6, 7, 11, 17, 19, 21, 22, 24, 26, 39, 40, 43, 44, 46]
