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 help_event(self, event): if self.scatterplot_item is None: return False act_pos = self.scatterplot_item.mapFromScene(event.scenePos()) points = self.scatterplot_item.pointsAt(act_pos) text = "" vars = self.master.model_selected if len(points): for i, p in enumerate(points): index = p.data() text += "Attributes:\n" text += "".join( " {} = {}\n".format(attr.name, self.data[index][attr]) for attr in vars) if len(vars[:]) > 10: text += " ... and {} others\n\n".format(len(vars[:]) - 12) # class_var is always: text += "Class:\n {} = {}\n".format(self.domain.class_var.name, self.data[index][self.data.domain.class_var]) if i < len(points) - 1: text += '------------------\n' text = ('<span style="white-space:pre">{}</span>'.format(escape(text))) QToolTip.showText(event.screenPos(), text, widget=self.plot_widget) return True return False
def help_event(self, event): if self.scatterplot_item is None: return False act_pos = self.scatterplot_item.mapFromScene(event.scenePos()) points = self.scatterplot_item.pointsAt(act_pos) text = "" attr = lambda i: self.domain.attributes[i] if len(points): for i, p in enumerate(points): index = p.data() text += "Attributes:\n" text += "".join(" {} = {}\n".format( attr(i).name, self.data[index][attr(i)]) for i in self.master.plotdata.topattrs[index]) if len(self.domain.attributes) > 10: text += " ... and {} others\n\n".format( len(self.domain.attributes) - 12) # class_var is always: text += "Class:\n {} = {}\n".format( self.domain.class_var.name, self.data[index][self.data.domain.class_var]) if i < len(points) - 1: text += '------------------\n' text = ('<span style="white-space:pre">{}</span>'.format( escape(text))) QToolTip.showText(event.screenPos(), text, widget=self.plot_widget) return True else: return False
def help_event(self, event): if self.scatterplot_item is None: return False act_pos = self.scatterplot_item.mapFromScene(event.scenePos()) points = self.scatterplot_item.pointsAt(act_pos) text = "" vars = self.master.model_selected if len(points): for i, p in enumerate(points): index = p.data() text += "Attributes:\n" text += "".join( " {} = {}\n".format(attr.name, self.data[index][attr]) for attr in vars ) if len(vars[:]) > 10: text += " ... and {} others\n\n".format(len(vars[:]) - 12) # class_var is always: text += "Class:\n {} = {}\n".format( self.domain.class_var.name, self.data[index][self.data.domain.class_var], ) if i < len(points) - 1: text += "------------------\n" text = '<span style="white-space:pre">{}</span>'.format(escape(text)) QToolTip.showText(event.screenPos(), text, widget=self.plot_widget) return True return False
def _handleHelpEvent(self, event): # Handle a help event for the plot viewbox = self.graph.getViewBox() pos = viewbox.mapToView(viewbox.mapFromScene(event.scenePos())) logr = pos.x() logp = pos.y() text = "" points = [] if self.graph._item is not None: points = self.graph._item.pointsAt(pos) if points: point = points[0] pos = point.pos() logr, logp = pos.x(), pos.y() index = point.data() text = ("<b>{index}</b><hr/>" "log<sub>2</sub>(ratio): {logr:.5f}<br/>" "p-value: {p:.5f}").format(logr=logr, p=10 ** -logp, index=index) if len(points) > 1: text += "<br/>... (and {} not shown)".format(len(points) - 1) else: text = "" QToolTip.showText(event.screenPos(), text, widget=self.graph) return True
def _handleHelpEvent(self, event): # Handle a help event for the plot viewbox = self.graph.getViewBox() pos = viewbox.mapToView(viewbox.mapFromScene(event.scenePos())) logr = pos.x() logp = pos.y() text = "" points = [] if self.graph._item is not None: points = self.graph._item.pointsAt(pos) if points: point = points[0] pos = point.pos() logr, logp = pos.x(), pos.y() index = point.data() text = ("<b>{index}</b><hr/>" "log<sub>2</sub>(ratio): {logr:.5f}<br/>" "p-value: {p:.5f}").format(logr=logr, p=10**-logp, index=index) if len(points) > 1: text += "<br/>... (and {} not shown)".format(len(points) - 1) else: text = "" QToolTip.showText(event.screenPos(), text, widget=self.graph) return True
def mouseMoved(self, evt): pos = evt[0] if self.plot.sceneBoundingRect().contains(pos): mousePoint = self.plot.vb.mapSceneToView(pos) posx, posy = mousePoint.x(), mousePoint.y() labels = [] for a, vs in sorted(self.reports.items()): for v in vs: if isinstance(v, tuple) and len(v) == 2: if v[0] == "x": labels.append( ("%0." + str(self.important_decimals[0]) + "f") % v[1]) continue labels.append(str(v)) labels = " ".join(labels) self.crosshair_hidden = bool(labels) if self.location and not labels: fs = "%0." + str(self.important_decimals[0]) + "f %0." + str( self.important_decimals[1]) + "f" labels = fs % (posx, posy) self.label.setText(labels, color=(0, 0, 0)) if self.curves and len(self.curves[0][0]): # need non-zero x axis! cache = {} bd = None if self.markclosest and self.plot.vb.action != ZOOMING: xpixel, ypixel = self.plot.vb.viewPixelSize() distances = distancetocurves(self.curves[0], posx, posy, xpixel, ypixel, r=self.MOUSE_RADIUS, cache=cache) try: mindi = np.nanargmin(distances) if distances[mindi] < self.MOUSE_RADIUS: bd = mindi except ValueError: # if all distances are NaN pass if self.highlighted != bd: QToolTip.hideText() if self.highlighted is not None and bd is None: self.highlighted = None self.highlighted_curve.hide() if bd is not None: self.highlighted = bd x = self.curves[0][0] y = self.curves[0][1][self.highlighted] self.highlighted_curve.setData(x=x, y=y) self.highlighted_curve.show() self.vLine.setPos(posx) self.hLine.setPos(posy) self.viewhelpers_show() else: self.viewhelpers_hide()
def help_event(self, ev): pos = self.plot.vb.mapSceneToView(ev.scenePos()) sel = self._points_at_pos(pos) prepared = [] if sel is not None: data, vals, points = self.data[sel], self.data_values[ sel], self.data_points[sel] for d, v, p in zip(data, vals, points): basic = "({}, {}): {}".format(p[0], p[1], v) variables = [ v for v in self.data.domain.metas + self.data.domain.class_vars if v not in [self.attr_x, self.attr_y] ] features = [ '{} = {}'.format(attr.name, d[attr]) for attr in variables ] prepared.append("\n".join([basic] + features)) text = "\n\n".join(prepared) if text: text = ('<span style="white-space:pre">{}</span>'.format( escape(text))) QToolTip.showText(ev.screenPos(), text, widget=self.plotview) return True else: return False
def help_event(self, ev): text = "" if self.highlighted is not None: if self.viewtype == INDIVIDUAL: index = self.sampled_indices[self.highlighted] variables = self.data.domain.metas + self.data.domain.class_vars text += "".join( '{} = {}\n'.format(attr.name, self.data[index][attr]) for attr in variables) elif self.viewtype == AVERAGE: c = self.multiple_curves_info[self.highlighted] nc = sum(c[2]) if c[0] is not None: text += str(c[0]) + " " if c[1]: text += "({})".format(c[1]) if text: text += "\n" text += "{} curves".format(nc) if text: text = text.rstrip() text = ('<span style="white-space:pre">{}</span>'.format( escape(text))) QToolTip.showText(ev.screenPos(), text, widget=self.plotview) return True else: return False
def helpEvent(self, event, view, option, index): if self.tooltip is not None: # ... but can be an empty string, so the current tooltip is removed QToolTip.showText(event.globalPos(), self.tooltip, view) return True else: return super().helpEvent(event, view, option, index)
def graphicsscene_help_event(scene: QGraphicsScene, event: QGraphicsSceneHelpEvent) -> None: """ Send the help event to every graphics item that is under the `event` scene position. """ widget = event.widget() if widget is not None and isinstance(widget.parentWidget(), QGraphicsView): view = widget.parentWidget() deviceTransform = view.viewportTransform() else: deviceTransform = QTransform() items = scene.items( event.scenePos(), Qt.IntersectsItemShape, Qt.DescendingOrder, deviceTransform, ) text = "" event.setAccepted(False) for item in items: scene.sendEvent(item, event) if event.isAccepted(): return elif item.toolTip(): text = item.toolTip() break QToolTip.showText(event.screenPos(), text, event.widget()) event.setAccepted(bool(text))
def help_event(self, event): if self.scatterplot_item is None: return False domain = self.data.domain PARTS = ( ("Class", "Classes", 4, domain.class_vars), ("Meta", "Metas", 4, domain.metas), ("Feature", "Features", 10, domain.attributes), ) def format_val(var, point_data, bold=False): text = escape("{} = {}".format(var.name, point_data[var])) if bold: text = "<b>{}</b>".format(text) return text def show_part(point_data, singular, plural, max_shown, vars): cols = [ format_val(var, point_data) for var in vars[:max_shown + 2] if vars == domain.class_vars or var not in (self.shown_x, self.shown_y) ][:max_shown] if not cols: return "" n_vars = len(vars) if n_vars > max_shown: cols[-1] = "... and {} others".format(n_vars - max_shown + 1) return "<br/><b>{}</b>:<br/>".format( singular if n_vars < 2 else plural) + "<br/>".join(cols) def point_data(p): point_data = self.data[p.data()] text = "<br/>".join( format_val(var, point_data, bold=self.tooltip_shows_all) for var in (self.shown_x, self.shown_y)) if self.tooltip_shows_all: text += "<br/>" + "".join( show_part(point_data, *columns) for columns in PARTS) return text act_pos = self.scatterplot_item.mapFromScene(event.scenePos()) points = self.scatterplot_item.pointsAt(act_pos) if len(points): if len(points) > MAX_POINTS_IN_TOOLTIP: text = "{} instances<hr/>{}<hr/>...".format( len(points), "<hr/>".join( point_data(point) for point in points[:MAX_POINTS_IN_TOOLTIP]), ) else: text = "<hr/>".join(point_data(point) for point in points) QToolTip.showText(event.screenPos(), text, widget=self.plot_widget) return True else: return False
def help_event(self, event): if self.scatterplot_item is None: return False domain = self.data.domain PARTS = (("Class", "Classes", 4, domain.class_vars), ("Meta", "Metas", 4, domain.metas), ("Feature", "Features", 10, domain.attributes)) def format_val(var, point_data, bold=False): text = escape('{} = {}'.format(var.name, point_data[var])) if bold: text = "<b>{}</b>".format(text) return text def show_part(point_data, singular, plural, max_shown, vars): cols = [format_val(var, point_data) for var in vars[:max_shown + 2] if vars == domain.class_vars or var not in (self.shown_x, self.shown_y)][:max_shown] if not cols: return "" n_vars = len(vars) if n_vars > max_shown: cols[-1] = "... and {} others".format(n_vars - max_shown + 1) return \ "<br/><b>{}</b>:<br/>".format(singular if n_vars < 2 else plural) \ + "<br/>".join(cols) def point_data(p): point_data = self.data[p.data()] text = "<br/>".join( format_val(var, point_data, bold=self.tooltip_shows_all) for var in (self.shown_x, self.shown_y)) if self.tooltip_shows_all: text += "<br/>" + \ "".join(show_part(point_data, *columns) for columns in PARTS) return text act_pos = self.scatterplot_item.mapFromScene(event.scenePos()) points = self.scatterplot_item.pointsAt(act_pos) if len(points): if len(points) > MAX_POINTS_IN_TOOLTIP: text = "{} instances<hr/>{}<hr/>...".format( len(points), "<hr/>".join(point_data(point) for point in points[:MAX_POINTS_IN_TOOLTIP]) ) else: text = "<hr/>".join(point_data(point) for point in points) QToolTip.showText(event.screenPos(), text, widget=self.plot_widget) return True else: return False
def test_tooltips(self): data_in = Orange.data.Table("titanic") res = Orange.evaluation.TestOnTrainingData( data=data_in, learners=[ Orange.classification.KNNLearner(), Orange.classification.LogisticRegressionLearner() ], store_data=True) self.send_signal(self.widget.Inputs.evaluation_results, res) self.widget.roc_averaging = OWROCAnalysis.Merge self.widget.target_index = 0 self.widget.selected_classifiers = [0, 1] vb = self.widget.plot.getViewBox() vb.childTransform() # Force pyqtgraph to update transforms curve = self.widget.plot_curves(self.widget.target_index, 0) curve_merge = curve.merge() view = self.widget.plotview item = curve_merge.curve_item # type: pg.PlotCurveItem # no tooltips to be shown pos = item.mapToScene(0.0, 1.0) pos = view.mapFromScene(pos) mouseMove(view.viewport(), pos) self.assertIs(self.widget._tooltip_cache, None) # test single point pos = item.mapToScene(0.22504, 0.45400) pos = view.mapFromScene(pos) mouseMove(view.viewport(), pos) shown_thresh = self.widget._tooltip_cache[1] self.assertTrue(QToolTip.isVisible()) np.testing.assert_almost_equal(shown_thresh, [0.40000], decimal=5) pos = item.mapToScene(0.0, 0.0) pos = view.mapFromScene(pos) # test overlapping points mouseMove(view.viewport(), pos) shown_thresh = self.widget._tooltip_cache[1] self.assertTrue(QToolTip.isVisible()) np.testing.assert_almost_equal(shown_thresh, [1.8, 1.89336], decimal=5) # test that cache is invalidated when changing averaging mode self.widget.roc_averaging = OWROCAnalysis.Threshold self.widget._replot() mouseMove(view.viewport(), pos) shown_thresh = self.widget._tooltip_cache[1] self.assertTrue(QToolTip.isVisible()) np.testing.assert_almost_equal(shown_thresh, [1, 1]) # test nan thresholds self.widget.roc_averaging = OWROCAnalysis.Vertical self.widget._replot() mouseMove(view.viewport(), pos) self.assertIs(self.widget._tooltip_cache, None)
def event(self, event: QEvent) -> bool: if event.type() == QEvent.ToolTip and self.toolTip(): action = self.defaultAction() if action is not None and action.toolTip(): text = tooltip_with_shortcut(action.toolTip(), action.shortcut()) QToolTip.showText(event.globalPos(), text) return True return super().event(event)
def test_tooltips(self): data_in = Orange.data.Table("titanic") res = Orange.evaluation.TestOnTrainingData( data=data_in, learners=[Orange.classification.KNNLearner(), Orange.classification.LogisticRegressionLearner()], store_data=True ) self.send_signal(self.widget.Inputs.evaluation_results, res) self.widget.roc_averaging = OWROCAnalysis.Merge self.widget.target_index = 0 self.widget.selected_classifiers = [0, 1] vb = self.widget.plot.getViewBox() vb.childTransform() # Force pyqtgraph to update transforms curve = self.widget.plot_curves(self.widget.target_index, 0) curve_merge = curve.merge() view = self.widget.plotview item = curve_merge.curve_item # type: pg.PlotCurveItem # no tooltips to be shown pos = item.mapToScene(0.0, 1.0) pos = view.mapFromScene(pos) mouseMove(view.viewport(), pos) self.assertIs(self.widget._tooltip_cache, None) # test single point pos = item.mapToScene(0.22504, 0.45400) pos = view.mapFromScene(pos) mouseMove(view.viewport(), pos) shown_thresh = self.widget._tooltip_cache[1] self.assertTrue(QToolTip.isVisible()) np.testing.assert_almost_equal(shown_thresh, [0.40000], decimal=5) pos = item.mapToScene(0.0, 0.0) pos = view.mapFromScene(pos) # test overlapping points mouseMove(view.viewport(), pos) shown_thresh = self.widget._tooltip_cache[1] self.assertTrue(QToolTip.isVisible()) np.testing.assert_almost_equal(shown_thresh, [1.8, 1.89336], decimal=5) # test that cache is invalidated when changing averaging mode self.widget.roc_averaging = OWROCAnalysis.Threshold self.widget._replot() mouseMove(view.viewport(), pos) shown_thresh = self.widget._tooltip_cache[1] self.assertTrue(QToolTip.isVisible()) np.testing.assert_almost_equal(shown_thresh, [1, 1]) # test nan thresholds self.widget.roc_averaging = OWROCAnalysis.Vertical self.widget._replot() mouseMove(view.viewport(), pos) self.assertIs(self.widget._tooltip_cache, None)
def help_event(self, ev: QGraphicsSceneHelpEvent) -> bool: if self.marg_prob_item is None: return False index = self.__get_index_at( self.marg_prob_item.mapFromScene(ev.scenePos())) if index is not None: QToolTip.showText(ev.screenPos(), self.labels[index], widget=self) return True return False
def helpEvent(self, event: QGraphicsSceneHelpEvent): idx = self.indexAt(self.mapFromScene(event.scenePos())) if idx is not None: rect = self.__textitems[idx].sceneBoundingRect() viewport = event.widget() view = viewport.parentWidget() rect = view.mapFromScene(rect).boundingRect() QToolTip.showText(event.screenPos(), self.__items[idx], view, rect) event.setAccepted(True)
def help_event(self, ev): in_graph_coor = self.plot.mapSceneToView(ev.scenePos()) ctooltip = [] for vb, item in self.tooltip_items: if isinstance(item, pg.PlotCurveItem) and item.mouseShape().contains(vb.mapSceneToView(ev.scenePos())): ctooltip.append(item.tooltip) elif isinstance(item, DistributionBarItem) and item.boundingRect().contains(vb.mapSceneToView(ev.scenePos())): ctooltip.append(item.tooltip) if ctooltip: QToolTip.showText(ev.screenPos(), "\n\n".join(ctooltip), widget=self.plotview) return True return False
def help_event(self, ev): if self.__dots is None: return False dot = self._dotAt(self.__dots.mapFromScene(ev.scenePos())) if dot is not None and dot.data() is not None: var, p, n = dot.data() q = round(p / n * 100, 1) text = f"{var.name}\nExpressed in {int(p)}/{int(n)} cells ({q}%)" QToolTip.showText(ev.screenPos(), text, widget=self) return True else: return False
def hide(self): """Override Qt method.""" self.completion_position = None self.completion_list = None self.clear() self.textedit.setFocus() tooltip = getattr(self.textedit, 'tooltip_widget', None) if tooltip: tooltip.hide() QListWidget.hide(self) QToolTip.hideText()
def help_event(self, ev: QGraphicsSceneHelpEvent): if self.bar_item is None: return False index = self.__get_index_at(self.bar_item.mapFromScene(ev.scenePos())) text = "" if index is not None: text = self.master.get_tooltip(index) if text: QToolTip.showText(ev.screenPos(), text, widget=self) return True else: return False
def help_event(self, event): """Tooltip""" if not self.choropleth_items: return False act_pos = self.choropleth_items[0].mapFromScene(event.scenePos()) ci = next((ci for ci in self.choropleth_items if ci.contains(act_pos)), None) if ci is not None: QToolTip.showText(event.screenPos(), ci.tooltip(), widget=self.plot_widget) return True else: return False
def helpEvent(self, event, view, option, index): # reimplemented # NOTE: This is a slot in Qt4, but is a virtual func in Qt5 value = index.data(Qt.EditRole) if isinstance(value, tuple) and len(value) == 2: try: tooltip = tool_tip(value) except ValueError: return False QToolTip.showText(event.globalPos(), tooltip, view) return True else: return super().helpEvent(event, view, option, index)
def help_event(self, event): """ Create a `QToolTip` for the point hovered by the mouse """ if self.scatterplot_item is None: return False act_pos = self.scatterplot_item.mapFromScene(event.scenePos()) point_data = [p.data() for p in self.scatterplot_item.pointsAt(act_pos)] text = self.master.get_tooltip(point_data) if text: QToolTip.showText(event.screenPos(), text, widget=self.plot_widget) return True else: return False
def event(self, event): # type: (QEvent) -> bool if event.type() == QEvent.ToolTip and self.toolTip(): action = self.defaultAction() if action is not None: text = "<span>{}</span> <kbd>{}</kbd>".format( action.toolTip(), action.shortcut().toString(QKeySequence.NativeText)) QToolTip.showText(event.globalPos(), text) else: QToolTip.hideText() return True else: return super().event(event)
def event(self, event): # type: (QEvent) -> bool if event.type() == QEvent.ToolTip and self.toolTip(): action = self.defaultAction() if action is not None: text = "<span>{}</span> <kbd>{}</kbd>".format( action.toolTip(), action.shortcut().toString(QKeySequence.NativeText) ) QToolTip.showText(event.globalPos(), text) else: QToolTip.hideText() return True else: return super().event(event)
def show_tool_tip(pos: QPoint, text: str, widget: Optional[QWidget] = None, rect=QRect(), elide=Qt.ElideRight): """ Show a plain text tool tip with limited length, eliding if necessary. """ if widget is not None: screen = widget.screen() else: screen = QApplication.screenAt(pos) font = QApplication.font("QTipLabel") fm = QFontMetrics(font) geom = screen.availableSize() etext = fm.elidedText(text, elide, geom.width()) if etext != text: text = f"<span>{etext}</span>" QToolTip.showText(pos, text, widget, rect)
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 mouseDragEvent(self, ev, axis=None): master = self.graph.master if master.data is None or master.graph.data is None: super().mouseDragEvent(ev, axis) return pos = self.childGroup.mapFromParent(ev.pos()) points = master.plotdata.points np_pos = np.array([[pos.x(), pos.y()]]) distances = distance.cdist(np_pos, points[:, :2]) is_near = np.min(distances) < 0.1 if ev.button() != Qt.LeftButton or (ev.start and not is_near): self.mouse_state = 2 if self.mouse_state == 2: if ev.finish: self.mouse_state = 0 super().mouseDragEvent(ev, axis) return ev.accept() if ev.start: self.setCursor(Qt.ClosedHandCursor) self.mouse_state = 1 self.point_i = np.argmin(distances) master.randomize_indices() if self.mouse_state == 1: if ev.finish: self.setCursor(Qt.ArrowCursor) self.mouse_state = 0 angle = np.arctan2(pos.y(), pos.x()) QToolTip.showText( QPoint(ev.screenPos().x(), ev.screenPos().y()), "{:.2f}".format(np.rad2deg(angle)), ) points[self.point_i][0] = np.cos(angle) points[self.point_i][1] = np.sin(angle) if ev.finish: master.setup_plot() master.commit() else: master.manual_move() self.graph.show_arc_arrow(pos.x(), pos.y())
def help_event(self, ev): pos = self.plot.vb.mapSceneToView(ev.scenePos()) sel, wavenumber_ind = self._points_at_pos(pos) prepared = [] if sel is not None: prepared.append(str(self.wavenumbers[wavenumber_ind])) for d in self.data[sel]: variables = [v for v in self.data.domain.metas + self.data.domain.class_vars if v not in [self.attr_x]] features = ['{} = {}'.format(attr.name, d[attr]) for attr in variables] features.append('value = {}'.format(d[wavenumber_ind])) prepared.append("\n".join(features)) text = "\n\n".join(prepared) if text: text = ('<span style="white-space:pre">{}</span>' .format(escape(text))) QToolTip.showText(ev.screenPos(), text, widget=self.plotview) return True else: return False
def help_event(self, ev): pos = self.plot.vb.mapSceneToView(ev.scenePos()) sel = self._points_at_pos(pos) prepared = [] if sel is not None: data, vals, points = self.data[sel], self.data_values[sel], self.data_points[sel] for d, v, p in zip(data, vals, points): basic = "({}, {}): {}".format(p[0], p[1], v) variables = [v for v in self.data.domain.metas + self.data.domain.class_vars if v not in [self.attr_x, self.attr_y]] features = ['{} = {}'.format(attr.name, d[attr]) for attr in variables] prepared.append("\n".join([basic] + features)) text = "\n\n".join(prepared) if text: text = ('<span style="white-space:pre">{}</span>' .format(escape(text))) QToolTip.showText(ev.screenPos(), text, widget=self.plotview) return True else: return False
def mouseDragEvent(self, ev, axis=None): master = self.graph.master if master.data is None or master.graph.data is None: super().mouseDragEvent(ev, axis) return pos = self.childGroup.mapFromParent(ev.pos()) points = master.plotdata.points np_pos = np.array([[pos.x(), pos.y()]]) distances = distance.cdist(np_pos, points[:, :2]) is_near = np.min(distances) < 0.1 if ev.button() != Qt.LeftButton or (ev.start and not is_near): self.mouse_state = 2 if self.mouse_state == 2: if ev.finish: self.mouse_state = 0 super().mouseDragEvent(ev, axis) return ev.accept() if ev.start: self.setCursor(Qt.ClosedHandCursor) self.mouse_state = 1 self.point_i = np.argmin(distances) master.randomize_indices() if self.mouse_state == 1: if ev.finish: self.setCursor(Qt.ArrowCursor) self.mouse_state = 0 angle = np.arctan2(pos.y(), pos.x()) QToolTip.showText( QPoint(ev.screenPos().x(), ev.screenPos().y()), "{:.2f}".format(np.rad2deg(angle))) points[self.point_i][0] = np.cos(angle) points[self.point_i][1] = np.sin(angle) if ev.finish: master.setup_plot() master.commit() else: master.manual_move() self.graph.show_arc_arrow(pos.x(), pos.y())
def mouseMoveEvent(self, e): if hasattr(self, "pressed_arrow"): canvas_position = self.mapToScene(e.pos()) y = min(1, max(0, self.inv_transform(yLeft, canvas_position.y()))) index, pos = self.pressed_arrow attr = self.domain[self.attributes[index]] old_condition = self.selection_conditions.get(attr.name, [0, 1]) old_condition[pos] = y self.selection_conditions[attr.name] = old_condition self.update_data(self.attributes, self.visualized_mid_labels) if attr.is_continuous: val = self.attr_values[attr][0] + old_condition[pos] * ( self.attr_values[attr][1] - self.attr_values[attr][0]) strVal = attr.name + "= %.2f" % val QToolTip.showText(e.globalPos(), strVal) if self.sendSelectionOnUpdate and self.auto_send_selection_callback: self.auto_send_selection_callback() else: OWPlot.mouseMoveEvent(self, e)
def help_event(self, event): if self.scatterplot_item is None: return False act_pos = self.scatterplot_item.mapFromScene(event.scenePos()) points = self.scatterplot_item.pointsAt(act_pos) text = "" if len(points): for i, p in enumerate(points): index = p.data() text += "Attributes:\n" if self.tooltip_shows_all and \ len(self.domain.attributes) < 30: text += "".join( ' {} = {}\n'.format(attr.name, self.data[index][attr]) for attr in self.domain.attributes) else: text += ' {} = {}\n {} = {}\n'.format( self.shown_x, self.data[index][self.shown_x], self.shown_y, self.data[index][self.shown_y]) if self.tooltip_shows_all: text += " ... and {} others\n\n".format( len(self.domain.attributes) - 2) if self.domain.class_var: text += 'Class:\n {} = {}\n'.format( self.domain.class_var.name, self.data[index][self.data.domain.class_var]) if i < len(points) - 1: text += '------------------\n' text = ('<span style="white-space:pre">{}</span>' .format(escape(text))) QToolTip.showText(event.screenPos(), text, widget=self.plot_widget) return True else: return False
def help_event(self, ev): pos = self.plot.vb.mapSceneToView(ev.scenePos()) sel, wavenumber_ind = self._points_at_pos(pos) prepared = [] if sel is not None: prepared.append(str(self.wavenumbers[wavenumber_ind])) for d in self.data[sel]: variables = [ v for v in self.data.domain.metas + self.data.domain.class_vars if v not in [self.attr_x] ] features = [ '{} = {}'.format(attr.name, d[attr]) for attr in variables ] features.append('value = {}'.format(d[wavenumber_ind])) prepared.append("\n".join(features)) text = "\n\n".join(prepared) if text: text = ('<span style="white-space:pre">{}</span>'.format( escape(text))) QToolTip.showText(ev.screenPos(), text, widget=self.plotview) return True else: return False
def show_tip(widget: QWidget, pos: QPoint, text: str, timeout=-1, textFormat=Qt.AutoText, wordWrap=None): propname = __name__ + "::show_tip_qlabel" if timeout < 0: timeout = widget.toolTipDuration() if timeout < 0: timeout = 5000 + 40 * max(0, len(text) - 100) tip = widget.property(propname) if not text and tip is None: return def hide(): w = tip.parent() w.setProperty(propname, None) tip.timer.stop() tip.close() tip.deleteLater() if not isinstance(tip, QLabel): tip = QLabel(objectName="tip-label", focusPolicy=Qt.NoFocus) tip.setBackgroundRole(QPalette.ToolTipBase) tip.setForegroundRole(QPalette.ToolTipText) tip.setPalette(QToolTip.palette()) tip.setFont(QApplication.font("QTipLabel")) tip.timer = QTimer(tip, singleShot=True, objectName="hide-timer") tip.timer.timeout.connect(hide) widget.setProperty(propname, tip) tip.setParent(widget, Qt.ToolTip) tip.setText(text) tip.setTextFormat(textFormat) if wordWrap is None: wordWrap = textFormat != Qt.PlainText tip.setWordWrap(wordWrap) if not text: hide() else: tip.timer.start(timeout) tip.show() tip.move(pos)
def event(self, ev): if ev.type() == QEvent.ToolTip: x = self.inv_transform(xBottom, ev.pos().x()) y = self.inv_transform(yLeft, ev.pos().y()) canvas_position = self.mapToScene(ev.pos()) x_float = self.inv_transform(xBottom, canvas_position.x()) contact, (index, pos) = self.testArrowContact(int(round(x_float)), canvas_position.x(), canvas_position.y()) if contact: attr = self.domain[self.attributes[index]] if attr.is_continuous: condition = self.selection_conditions.get( attr.name, [0, 1]) val = self.attr_values[attr][0] + condition[pos] * ( self.attr_values[attr][1] - self.attr_values[attr][0]) str_val = attr.name + "= %%.%df" % attr.number_of_decimals % val QToolTip.showText(ev.globalPos(), str_val) else: for curve in self.items(): if type(curve) == PolygonCurve and \ curve.boundingRect().contains(x, y) and \ getattr(curve, "tooltip", None): (name, value, total, dist) = curve.tooltip count = sum([v[1] for v in dist]) if count == 0: continue tooltip_text = "Attribute: <b>%s</b><br>Value: <b>%s</b><br>" \ "Total instances: <b>%i</b> (%.1f%%)<br>" \ "Class distribution:<br>" % ( name, value, count, 100.0 * count / float(total)) for (val, n) in dist: tooltip_text += " <b>%s</b> : <b>%i</b> (%.1f%%)<br>" % ( val, n, 100.0 * float(n) / float(count)) QToolTip.showText(ev.globalPos(), tooltip_text[:-4]) elif ev.type() == QEvent.MouseMove: QToolTip.hideText() return OWPlot.event(self, ev)
def event(self, ev): if ev.type() == QEvent.ToolTip: x = self.inv_transform(xBottom, ev.pos().x()) y = self.inv_transform(yLeft, ev.pos().y()) canvas_position = self.mapToScene(ev.pos()) x_float = self.inv_transform(xBottom, canvas_position.x()) contact, (index, pos) = self.testArrowContact(int(round(x_float)), canvas_position.x(), canvas_position.y()) if contact: attr = self.domain[self.attributes[index]] if attr.is_continuous: condition = self.selection_conditions.get(attr.name, [0, 1]) val = self.attr_values[attr][0] + condition[pos] * ( self.attr_values[attr][1] - self.attr_values[attr][0]) str_val = attr.name + "= %%.%df" % attr.number_of_decimals % val QToolTip.showText(ev.globalPos(), str_val) else: for curve in self.items(): if type(curve) == PolygonCurve and \ curve.boundingRect().contains(x, y) and \ getattr(curve, "tooltip", None): (name, value, total, dist) = curve.tooltip count = sum([v[1] for v in dist]) if count == 0: continue tooltip_text = "Attribute: <b>%s</b><br>Value: <b>%s</b><br>" \ "Total instances: <b>%i</b> (%.1f%%)<br>" \ "Class distribution:<br>" % ( name, value, count, 100.0 * count / float(total)) for (val, n) in dist: tooltip_text += " <b>%s</b> : <b>%i</b> (%.1f%%)<br>" % ( val, n, 100.0 * float(n) / float(count)) QToolTip.showText(ev.globalPos(), tooltip_text[:-4]) elif ev.type() == QEvent.MouseMove: QToolTip.hideText() return OWPlot.event(self, ev)
def _on_mouse_moved(self, pos): target = self.target_index selected = self.selected_classifiers curves = [(clf_idx, self.plot_curves(target, clf_idx)) for clf_idx in selected] # type: List[Tuple[int, plot_curves]] valid_thresh, valid_clf = [], [] pt, ave_mode = None, self.roc_averaging for clf_idx, crv in curves: if self.roc_averaging == OWROCAnalysis.Merge: curve = crv.merge() elif self.roc_averaging == OWROCAnalysis.Vertical: curve = crv.avg_vertical() elif self.roc_averaging == OWROCAnalysis.Threshold: curve = crv.avg_threshold() else: # currently not implemented for 'Show Individual Curves' return sp = curve.curve_item.childItems()[0] # type: pg.ScatterPlotItem act_pos = sp.mapFromScene(pos) pts = sp.pointsAt(act_pos) if len(pts) > 0: mouse_pt = pts[0].pos() if self._tooltip_cache: cache_pt, cache_thresh, cache_clf, cache_ave = self._tooltip_cache curr_thresh, curr_clf = [], [] if numpy.linalg.norm(mouse_pt - cache_pt) < 10e-6 \ and cache_ave == self.roc_averaging: mask = numpy.equal(cache_clf, clf_idx) curr_thresh = numpy.compress(mask, cache_thresh).tolist() curr_clf = numpy.compress(mask, cache_clf).tolist() else: QToolTip.showText(QCursor.pos(), "") self._tooltip_cache = None if curr_thresh: valid_thresh.append(*curr_thresh) valid_clf.append(*curr_clf) pt = cache_pt continue curve_pts = curve.curve.points roc_points = numpy.column_stack((curve_pts.fpr, curve_pts.tpr)) diff = numpy.subtract(roc_points, mouse_pt) # Find closest point on curve and save the corresponding threshold idx_closest = numpy.argmin(numpy.linalg.norm(diff, axis=1)) thresh = curve_pts.thresholds[idx_closest] if not numpy.isnan(thresh): valid_thresh.append(thresh) valid_clf.append(clf_idx) pt = [curve_pts.fpr[idx_closest], curve_pts.tpr[idx_closest]] if valid_thresh: clf_names = self.classifier_names msg = "Thresholds:\n" + "\n".join(["({:s}) {:.3f}".format(clf_names[i], thresh) for i, thresh in zip(valid_clf, valid_thresh)]) QToolTip.showText(QCursor.pos(), msg) self._tooltip_cache = (pt, valid_thresh, valid_clf, ave_mode)