def enterEvent(self, event): """ Reimplemented to cancel the hide timer. """ super(CallTipWidget, self).enterEvent(event) if (self._hide_timer.isActive() and self.app.topLevelAt(QCursor.pos()) == self): self._hide_timer.stop()
def eventFilter(self, obj, event): """ Reimplemented to hide on certain key presses and on text edit focus changes. """ if obj == self._text_edit: etype = event.type() if etype == QEvent.KeyPress: key = event.key() if key in (Qt.Key_Enter, Qt.Key_Return, Qt.Key_Down): self.hide() elif key == Qt.Key_Escape: self.hide() return True elif etype == QEvent.FocusOut: self.hide() elif etype == QEvent.Enter: if (self._hide_timer.isActive() and self.app.topLevelAt(QCursor.pos()) == self): self._hide_timer.stop() elif etype == QEvent.Leave: self._leave_event_hide() return super(CallTipWidget, self).eventFilter(obj, event)
def show_mouse_toast(message): # Creates a text with empty space to get the height of the rendered text - this is used # to provide the same offset for the tooltip, scaled relative to the current resolution and zoom. font_metrics = QFontMetrics(QFont(" ")) # The height itself is divided by 2 just to reduce the offset so that the tooltip is # reasonably position relative to the cursor QToolTip.showText(QCursor.pos() + QPoint(font_metrics.height() / 2, 0), message)
def get_cursor_at_y(self, y): """ Get an override cursor for an y coordinate given that the x == self.x :param y: A y coordinate. :return: QCursor or None. """ is_at_top = self.is_at_top if self.is_moving else self._is_at_top(y) return QCursor( Qt.SizeAllCursor) if is_at_top else VerticalMarker.get_cursor_at_y( self, y)
def func(button): button_id = widget.standardButton(button) for button_name in _QtDialog.supported_button_names: if button_id == getattr(QMessageBox, button_name): widget.setCursor(QCursor(Qt.WaitCursor)) try: callback(button_name) finally: widget.unsetCursor() break
def _display_roi_context_menu(self, roi_index): def delete_roi(event): self._dc.remove_subset_group(self._dc.subset_groups[roi_index]) context_menu = QMenu() action = QAction("Delete ROI", context_menu) action.triggered.connect(delete_roi) context_menu.addAction(action) pos = self._viewer.mapToParent(QCursor().pos()) context_menu.exec_(pos)
def _leave_event_hide(self): """ Hides the tooltip after some time has passed (assuming the cursor is not over the tooltip). """ if (self.hide_timer_on and not self._hide_timer.isActive() and # If Enter events always came after Leave events, we wouldn't need # this check. But on Mac OS, it sometimes happens the other way # around when the tooltip is created. self.app.topLevelAt(QCursor.pos()) != self): self._hide_timer.start(800, self)
def _leave_event_hide(self): """ Hides the tooltip after some time has passed (assuming the cursor is not over the tooltip). """ if (not self._hide_timer.isActive() and # If Enter events always came after Leave events, we wouldn't need # this check. But on Mac OS, it sometimes happens the other way # around when the tooltip is created. self.app.topLevelAt(QCursor.pos()) != self): self._hide_timer.start(800, self)
def enterEvent(self, event): """ Reimplemented to cancel the hide timer. """ super(CallTipWidget, self).enterEvent(event) if self.as_tooltip: self.hide() if (self._hide_timer.isActive() and self.app.topLevelAt(QCursor.pos()) == self): self._hide_timer.stop()
def wait_cursor(msg=None): ''' Allows long running functions to show a busy cursor. :param msg: a message to put in the status bar. ''' try: QApplication.setOverrideCursor(QCursor(QtCore.Qt.WaitCursor)) yield finally: QApplication.restoreOverrideCursor()
def on_mouse_press_event(self, event): """ Event handling for mouse press action Args: event: Returns: """ # get the button and position information. curr_x = event.xdata curr_y = event.ydata if curr_x is None or curr_y is None: # outside of canvas return button = event.button if button == 1: # left button: no operation pass elif button == 3: # right button: # Pop-out menu self.menu = QMenu(self) if self.get_canvas().is_legend_on: # figure has legend: remove legend action1 = QAction('Hide legend', self) action1.triggered.connect(self._myCanvas.hide_legend) action2 = QAction('Legend font larger', self) action2.triggered.connect( self._myCanvas.increase_legend_font_size) action3 = QAction('Legend font smaller', self) action3.triggered.connect( self._myCanvas.decrease_legend_font_size) self.menu.addAction(action2) self.menu.addAction(action3) else: # figure does not have legend: add legend action1 = QAction('Show legend', self) action1.triggered.connect(self._myCanvas.show_legend) self.menu.addAction(action1) # pop up menu self.menu.popup(QCursor.pos()) # END-IF-ELSE return
def set_cursor(self, cursor, size=10): if cursor == 'square': if size < 10 or size > 300: q_cursor = self._cursors['cross'] else: q_cursor = QCursor( QPixmap(':/icons/cursor/cursor_square.png').scaledToHeight( size)) else: q_cursor = self._cursors[cursor] self.canvas.native.setCursor(q_cursor)
def show_context_menu(self, task_id) -> None: self.menu = QMenu(self) force_start_action = QAction('Force start', self) force_start_action.triggered.connect( lambda: self.on_force_start_action_triggered(task_id)) stop_action = QAction('Stop', self) stop_action.triggered.connect( lambda: self.on_stop_action_triggered(task_id)) self.menu.addAction(force_start_action) self.menu.addAction(stop_action) self.menu.popup(QCursor.pos())
def _fix_cursor(self, from_index, to_index): """Fix mouse cursor position to adjust for different tab sizes.""" # The direction is +1 (moving to the right) or -1 (moving to the left) direction = abs(to_index - from_index)/(to_index - from_index) tab_width = self.dock_tabbar.tabRect(to_index).width() tab_x_min = self.dock_tabbar.tabRect(to_index).x() tab_x_max = tab_x_min + tab_width previous_width = self.dock_tabbar.tabRect(to_index - direction).width() delta = previous_width - tab_width if delta > 0: delta = delta * direction else: delta = 0 cursor = QCursor() pos = self.dock_tabbar.mapFromGlobal(cursor.pos()) x, y = pos.x(), pos.y() if x < tab_x_min or x > tab_x_max: new_pos = self.dock_tabbar.mapToGlobal(QPoint(x + delta, y)) cursor.setPos(new_pos)
def _fix_cursor(self, from_index, to_index): """Fix mouse cursor position to adjust for different tab sizes.""" # The direction is +1 (moving to the right) or -1 (moving to the left) direction = abs(to_index - from_index) / (to_index - from_index) tab_width = self.dock_tabbar.tabRect(to_index).width() tab_x_min = self.dock_tabbar.tabRect(to_index).x() tab_x_max = tab_x_min + tab_width previous_width = self.dock_tabbar.tabRect(to_index - direction).width() delta = previous_width - tab_width if delta > 0: delta = delta * direction else: delta = 0 cursor = QCursor() pos = self.dock_tabbar.mapFromGlobal(cursor.pos()) x, y = pos.x(), pos.y() if x < tab_x_min or x > tab_x_max: new_pos = self.dock_tabbar.mapToGlobal(QPoint(x + delta, y)) cursor.setPos(new_pos)
def set_zoom(self, zoom: int) -> None: """Update zoom factor.""" zoom_old = self.zoom self.zoom = zoom / 50. zoom_old -= self.zoom if self.zoomby == ZoomBy.CANVAS: pos = self.mapFromGlobal(QCursor.pos()) else: pos = QPointF(self.width() / 2, self.height() / 2) self.ox += (pos.x() - self.ox) / self.zoom * zoom_old self.oy += (pos.y() - self.oy) / self.zoom * zoom_old self.update()
def on_mouse_press_event(self, event): """ Event handling for mouse press action Args: event: Returns: """ # get the button and position information. curr_x = event.xdata curr_y = event.ydata if curr_x is None or curr_y is None: # outside of canvas return button = event.button if button == 1: # left button: no operation pass elif button == 3: # right button: # Pop-out menu self.menu = QMenu(self) if self.get_canvas().is_legend_on: # figure has legend: remove legend action1 = QAction('Hide legend', self) action1.triggered.connect(self._myCanvas.hide_legend) action2 = QAction('Legend font larger', self) action2.triggered.connect(self._myCanvas.increase_legend_font_size) action3 = QAction('Legend font smaller', self) action3.triggered.connect(self._myCanvas.decrease_legend_font_size) self.menu.addAction(action2) self.menu.addAction(action3) else: # figure does not have legend: add legend action1 = QAction('Show legend', self) action1.triggered.connect(self._myCanvas.show_legend) self.menu.addAction(action1) # pop up menu self.menu.popup(QCursor.pos()) # END-IF-ELSE return
def __init__(self, parent=None, command=None): QPushButton.__init__(self, parent) PyDMPrimitiveWidget.__init__(self) self.iconFont = IconFont() self._icon = self.iconFont.icon("cog") self.setIconSize(QSize(16, 16)) self.setIcon(self._icon) self.setCursor(QCursor(self._icon.pixmap(16, 16))) self._command = command self._allow_multiple = False self.process = None self._show_icon = True
def __setValue(self): """ This function is run to update the value on the parent widget. This will update the value on the widget, and then run the valueUpdateEvent """ current_pos = QCursor.pos() magnitude = getMagnitude(self._calc_pos, current_pos) self._slider_pos, self._num_ticks = math.modf(magnitude / self.pixelsPerTick()) # update values self.valueUpdateEvent() self.__updateValue()
def mouseMoveEvent(self, event): """Show Pointing Hand Cursor on error messages""" text = self.get_line_at(event.pos()) if get_error_match(text): if not self.__cursor_changed: QApplication.setOverrideCursor(QCursor(Qt.PointingHandCursor)) self.__cursor_changed = True event.accept() return if self.__cursor_changed: QApplication.restoreOverrideCursor() self.__cursor_changed = False self.QT_CLASS.mouseMoveEvent(self, event)
def set_override_cursor( override: bool, override_cursor: Qt.CursorShape = Qt.SizeAllCursor) -> None: """ Sets the override cursor if an override cursor doesn't exist. Otherwise, restores the override cursor :param override: A boolean for whether to set the override cursor or not :param override_cursor: The override cursor to use if the override parameter is true """ cursor = QApplication.overrideCursor() if override and cursor is None: QApplication.setOverrideCursor(QCursor(override_cursor)) elif not override and cursor is not None: QApplication.restoreOverrideCursor()
def motion_notify_callback(self, event): x = event.x if x is not None and (self.fit_start_x.should_override_cursor(x) or self.fit_end_x.should_override_cursor(x)): if not self.is_cursor_overridden: QApplication.setOverrideCursor(QCursor(Qt.SizeHorCursor)) self.is_cursor_overridden = True else: QApplication.restoreOverrideCursor() self.is_cursor_overridden = False self.fit_start_x.mouse_move(event.xdata) self.fit_end_x.mouse_move(event.xdata) self.canvas.draw()
def _on_cursor(self, event): cursor = self.viewer.cursor size = self.viewer.cursor_size if cursor == 'square': if size < 10 or size > 300: q_cursor = self._cursors['cross'] else: q_cursor = QCursor( QPixmap(':/icons/cursor/cursor_square.png').scaledToHeight( size)) else: q_cursor = self._cursors[cursor] self.canvas.native.setCursor(q_cursor)
def move_marker(self, canvas, marker, pos, dx, try_other_way_if_failed): tr = self.fit_browser.tool.ax.get_xaxis_transform() x0 = tr.transform((0, 0))[0] dx_pxl = tr.transform((dx, 0))[0] - x0 pos.setX(marker.get_x_in_pixels()) new_pos = pos + QPoint(dx_pxl, 0) yield drag_mouse(canvas, pos, new_pos) pos1 = canvas.mapFromGlobal(QCursor.pos()) if try_other_way_if_failed and pos1 != new_pos: new_x = marker.x + dx marker.on_click(pos.x()) marker.mouse_move(new_x) yield 0.1 marker.stop()
def check_mouse_move(self, event): self.manager.updateDragPosition() if event.buttons() == Qt.LeftButton \ and not self.rect().contains( self.mapFromGlobal( QCursor.pos() ) ) \ and self.dragCanStart: self.dragCanStart = False toolWindows = [] for i in range(self.count()): toolWindow = self.widget(i) if self.manager.hasToolWindow(toolWindow): toolWindows.append(toolWindow) else: qWarning("tab widget contains unmanaged widget") self.manager.startDrag(toolWindows)
def override_cursor(self, x, y): """ Get the override cursor for mouse position (x, y) :param x: An x mouse coordinate. :param y: An y mouse coordinate. :return: QCursor or None. """ if self.x0 is not None and x < self.x0: return None if self.x1 is not None and x > self.x1: return None if self.is_moving or self.is_above(x, y): return QCursor(Qt.SizeVerCursor) return None
def __activateStickyDrag(self, obj): """ This should be run every time the user clicks. Args: obj (QWidget / QItem --> DragWidget): Object to install all of the extra attrs on """ obj._cursor_pos = QCursor.pos() top_left = getTopLeftPos(obj) QCursor.setPos(top_left + QPoint(10, 10)) obj.setFocus() # set up drag time attrs obj.updateOrigValue() obj._calc_pos = QCursor.pos() obj._drag_STICKY = not obj._drag_STICKY obj._num_ticks = 0 obj._pixels_per_tick = self.pixelsPerTick() obj._value_per_tick = self.valuePerTick() # toggle cursor display if obj._drag_STICKY: obj.setCursor(Qt.BlankCursor)
def _on_cursor(self, event): """Set the appearance of the mouse cursor. Parameters ---------- event : napari.utils.event.Event The napari event that triggered this method. """ cursor = self.viewer.cursor if cursor == 'square': size = self.viewer.cursor_size # make sure the square fits within the current canvas if size < 8 or size > ( min(*self.viewer.window.qt_viewer.canvas.size) - 4): q_cursor = self._cursors['cross'] else: q_cursor = QCursor(square_pixmap(size)) elif cursor == 'circle': size = self.viewer.cursor_size q_cursor = QCursor(circle_pixmap(size)) else: q_cursor = self._cursors[cursor] self.canvas.native.setCursor(q_cursor)
def before_long_process(self, message): """ Show a message in main window's status bar and change the mouse pointer to Qt.WaitCursor when starting a long process. Parameters ---------- message: str Message to show in the status bar when the long process starts. """ if message: self.show_status_message(message) QApplication.setOverrideCursor(QCursor(Qt.WaitCursor)) QApplication.processEvents()
def move_from(self, cur_pos_data: Tuple[float, float]) -> None: """ Calculate a new position based on the given starting position and self.newpixel transform and move the mouse cursor there. :param cur_pos_data: Current cursor position in data coordinates """ new_pos_data = self.clip(self.new_pixel(*cur_pos_data)) xdisp, ydisp = self.data_to_display.transform_point(new_pos_data) canvas = self.canvas dpi_ratio = canvas._dpi_ratio to_int = self.to_int xp = to_int(xdisp / dpi_ratio) yp = to_int((canvas.figure.bbox.height - ydisp) / dpi_ratio) # in the special case of just vertical/horizontal moves # use the original cursor position for the orthogonal coordinate # to avoid rounding errors and mouse jitter new_global_pos = canvas.mapToGlobal(QPoint(xp, yp)) cur_global_pos = QCursor.pos() if new_pos_data[0] == cur_pos_data[0]: new_global_pos.setX(cur_global_pos.x()) if new_pos_data[1] == cur_pos_data[1]: new_global_pos.setY(cur_global_pos.y()) QCursor.setPos(new_global_pos)
def peak_range_table_right_click(self, position=-1): nbr_row = self.parent.ui.peak_range_table.rowCount() if nbr_row == 0: return menu = QMenu(self.parent) _remove_row = menu.addAction("Remove") action = menu.exec_(QCursor.pos()) if action == _remove_row: self.remove_peak_range_table_row() o_gui = GuiUtilities(parent=self.parent) o_gui.check_if_fitting_widgets_can_be_enabled()
def _on_cursor(self): """Set the appearance of the mouse cursor.""" cursor = self.viewer.cursor.style # Scale size by zoom if needed if self.viewer.cursor.scaled: size = self.viewer.cursor.size * self.viewer.camera.zoom else: size = self.viewer.cursor.size if cursor == 'square': # make sure the square fits within the current canvas if size < 8 or size > ( min(*self.viewer.window._qt_viewer.canvas.size) - 4): q_cursor = self._cursors['cross'] else: q_cursor = QCursor(square_pixmap(size)) elif cursor == 'circle': q_cursor = QCursor(circle_pixmap(size)) elif cursor == 'crosshair': q_cursor = QCursor(crosshair_pixmap()) else: q_cursor = self._cursors[cursor] self.canvas.native.setCursor(q_cursor)
def mouseMoveEvent(self, event): """ Detect mouser over indicator and highlight the current scope in the editor (up and down decoration arround the foldable text when the mouse is over an indicator). :param event: event """ super(FoldingPanel, self).mouseMoveEvent(event) th = TextHelper(self.editor) line = th.line_nbr_from_position(event.pos().y()) if line >= 0: block = self.editor.document().findBlockByNumber(line) block = self.find_parent_scope(block) line_number = block.blockNumber() if line_number in self.folding_regions: if self._mouse_over_line is None: # mouse enter fold scope QApplication.setOverrideCursor( QCursor(Qt.PointingHandCursor)) if (self._mouse_over_line != block.blockNumber() and self._mouse_over_line is not None): # fold scope changed, a previous block was highlighter so # we quickly update our highlighting self._mouse_over_line = block.blockNumber() try: self._highlight_block(block) except KeyError: # Catching the KeyError above is necessary to avoid # issue spyder-ide/spyder#13230. pass else: # same fold scope, request highlight self._mouse_over_line = block.blockNumber() try: self._highlight_runner.request_job( self._highlight_block, block) except KeyError: # Catching the KeyError above is necessary to avoid # issue spyder-ide/spyder#11291. pass self._highight_block = block else: # no fold scope to highlight, cancel any pending requests self._highlight_runner.cancel_requests() self._mouse_over_line = None QApplication.restoreOverrideCursor() self.repaint()
def initialize(self, checked=True): """ Start pydoc server. Parameters ---------- checked: bool, optional This method is connected to the `sig_toggle_view_changed` signal, so that the first time the widget is made visible it will start the server. Default is True. """ if checked and self.server is None: self.sig_toggle_view_changed.disconnect(self.initialize) QApplication.setOverrideCursor(QCursor(Qt.WaitCursor)) QApplication.processEvents() self.start_server()
def _update_hover_html_link_style(self, url): """Update style of labels that include rich text and html links.""" link = 'text-decoration:none;' link_hovered = 'text-decoration:underline;' self._url = url if url: QApplication.setOverrideCursor(QCursor(Qt.PointingHandCursor)) new_text, old_text = link_hovered, link else: new_text, old_text = link, link_hovered QApplication.restoreOverrideCursor() text = self.text() new_text = text.replace(old_text, new_text) self.setText(new_text)
def cursor_location(self) -> DockWidgetArea: ''' Returns the dock widget area depending on the current cursor location. The function checks, if the mouse cursor is inside of any drop indicator widget and returns the corresponding DockWidgetArea. Returns ------- value : DockWidgetArea ''' pos = self.mapFromGlobal(QCursor.pos()) allowed_areas = self.d.dock_overlay.allowed_areas() for area, widget in self.d.drop_indicator_widgets.items(): if (area in allowed_areas and widget and widget.isVisible() and widget.geometry().contains(pos)): return area return DockWidgetArea.invalid
def _show_context_menu(self, event): """Display a relevant context menu on the canvas :param event: The MouseEvent that generated this call """ if not event.inaxes: # the current context menus are ony relevant for axes return fig_type = figure_type(self.canvas.figure) if fig_type == FigureType.Empty or fig_type == FigureType.Image: # Fitting or changing scale types does not make sense in # these cases return menu = QMenu() if self.fit_browser.tool is not None: self.fit_browser.add_to_menu(menu) menu.addSeparator() self._add_axes_scale_menu(menu) menu.exec_(QCursor.pos())
def move_and_show(editor): editor.move(QCursor.pos()) editor.exec_()
def right_click(self, position=None): _duplicate_row = -1 _plot_sofq = -1 _remove_row = -1 _new_row = -1 _copy = -1 _paste = -1 _cut = -1 _refresh_table = -1 _clear_table = -1 # _import = -1 # _export = -1 _check_all = -1 _uncheck_all = -1 _undo = -1 _redo = -1 _plot_sofq_diff_first_run_row = -1 _plot_sofq_diff_average_row = -1 _plot_cryostat = -1 _plot_furnace = -1 _invert_selection = -1 menu = QMenu(self.main_window) if self.main_window.table_selection_buffer == {}: paste_status = False else: paste_status = True if (self.main_window.postprocessing_ui.table.rowCount() > 0): _undo = menu.addAction("Undo") _undo.setEnabled(self.main_window.undo_button_enabled) _redo = menu.addAction("Redo") _redo.setEnabled(self.main_window.redo_button_enabled) menu.addSeparator() _copy = menu.addAction("Copy") _paste = menu.addAction("Paste") self._paste_menu = _paste _paste.setEnabled(paste_status) _cut = menu.addAction("Clear") menu.addSeparator() _check_all = menu.addAction("Check All") _uncheck_all = menu.addAction("Unchecked All") menu.addSeparator() _invert_selection = menu.addAction("Inverse Selection") menu.addSeparator() _new_row = menu.addAction("Insert Blank Row") if (self.main_window.postprocessing_ui.table.rowCount() > 0): _duplicate_row = menu.addAction("Duplicate Row") _remove_row = menu.addAction("Remove Row(s)") menu.addSeparator() _plot_menu = menu.addMenu('Plot') _plot_sofq = _plot_menu.addAction("S(Q) ...") _plot_sofq_diff_first_run_row = _plot_menu.addAction("S(Q) Diff (1st run)...") _plot_sofq_diff_average_row = _plot_menu.addAction("S(Q) Diff (Avg.)...") _temp_menu = _plot_menu.addMenu("Temperature") _plot_cryostat = _temp_menu.addAction("Cyrostat...") _plot_furnace = _temp_menu.addAction("Furnace...") menu.addSeparator() _refresh_table = menu.addAction("Refresh/Reset Table") _clear_table = menu.addAction("Clear Table") action = menu.exec_(QCursor.pos()) self.current_row = self.current_row() if action == _undo: self.main_window.action_undo_clicked() elif action == _redo: self.main_window.action_redo_clicked() elif action == _copy: self._copy() elif action == _paste: self._paste() elif action == _cut: self._cut() elif action == _duplicate_row: self._duplicate_row() elif action == _plot_sofq: self._plot_sofq() elif action == _plot_sofq_diff_first_run_row: self._plot_sofq_diff_first_run_row() elif action == _plot_sofq_diff_average_row: self._plot_sofq_diff_average_row() elif action == _plot_cryostat: self._plot_temperature(samp_env_choice='cryostat') elif action == _plot_furnace: self._plot_temperature(samp_env_choice='furnace') elif action == _invert_selection: self._inverse_selection() elif action == _new_row: self._new_row() elif action == _remove_row: self._remove_selected_rows() elif action == _refresh_table: self._refresh_table() elif action == _clear_table: self._clear_table() elif action == _check_all: self.check_all() elif action == _uncheck_all: self.uncheck_all()
def on_mouse_press_event(self, event): """ Handle mouse pressing event (1) left mouse: in show-boundary mode, check the action to select a boundary indicator (2) right mouse: pop up the menu Returns ------- """ # get the button button = event.button if button == 3: # right button: # Pop-out menu self.menu = QMenu(self) if self.get_canvas().is_legend_on: # figure has legend: remove legend action1 = QAction('Hide legend', self) action1.triggered.connect(self._myCanvas.hide_legend) action2 = QAction('Legend font larger', self) action2.triggered.connect(self._myCanvas.increase_legend_font_size) action3 = QAction('Legend font smaller', self) action3.triggered.connect(self._myCanvas.decrease_legend_font_size) self.menu.addAction(action2) self.menu.addAction(action3) else: # figure does not have legend: add legend action1 = QAction('Show legend', self) action1.triggered.connect(self._myCanvas.show_legend) self.menu.addAction(action1) # pop up menu self.menu.popup(QCursor.pos()) return # END-IF # ignore if boundary is not shown and the pressed mouse button is left or middle if not self._showBoundary: return # get mouse cursor x position mouse_x_pos = event.xdata if mouse_x_pos is None: return else: self._prevCursorPos = mouse_x_pos # get absolute resolution x_range = self.getXLimit() resolution = (x_range[1] - x_range[0]) * self.IndicatorResolution # see whether it is close enough to any boundary left_bound_pos = self.get_indicator_position(self._leftID)[0] right_bound_pos = self.get_indicator_position(self._rightID)[0] if abs(mouse_x_pos - left_bound_pos) < resolution: self._selectedBoundary = 1 elif abs(mouse_x_pos - right_bound_pos) < resolution: self._selectedBoundary = 2 else: self._selectedBoundary = 0 # END-IF-ELSE return
def mouse_move(self, event): """ Event handler for matplotlib motion_notify_event. Updates coord display and vars. :param event: matplotlib event. """ # Check if mouse is in widget but not on plot if not event.inaxes: self.is_mouse_over = False self.clear_coords() return mouse_pos = QCursor.pos() self.is_mouse_over = True # If hold_coords is active, return if self.hold_coords: return # Get x and y of the pixel under the mouse x, y = [int(event.xdata + 0.5), int(event.ydata + 0.5)] self.x_mouse, self.y_mouse = [x, y] # Create coord display string if self._slice_index is not None: string = "({:1.0f}, {:1.0f}, {:1.0f})".format(x, y, self._slice_index) else: string = "({:1.0f}, {:1.0f})".format(x, y) self.mouse_value = "" # If viewer has a layer. if len(self.visible_layers()) > 0: arr = self.first_visible_layer().state.get_sliced_data() if 0 <= y < arr.shape[0] and 0 <= x < arr.shape[1]: # if x and y are in bounds. Note: x and y are swapped in array. # get value and check if wcs is obtainable # WCS: if len(self.figure.axes) > 0: wcs = self.figure.axes[0].wcs.celestial if wcs is not None: # Check the number of axes in the WCS and add to string ra = dec = None if wcs.naxis == 3 and self.slice_index is not None: ra, dec, wave = wcs.wcs_pix2world([[x, y, self._slice_index]], 0)[0] elif wcs.naxis == 2: ra, dec = wcs.wcs_pix2world([[x, y]], 0)[0] if ra is not None and dec is not None: string = string + " " + self._coords_format_function(ra, dec) # Pixel Value: v = arr[y][x] if self.cubeviz_unit is not None: wave = self.cubeviz_layout.get_wavelength(self.slice_index) v = self.cubeviz_unit.convert_value(v, wave=wave) unit_string = "" if self.component_unit_label: unit_string = "[{0}]".format(self.component_unit_label) if 0.001 <= abs(v) <= 1000 or abs(v) == 0.0: value_string = "{0:.3f} ".format(v) else: value_string = "{0:.3e} ".format(v) self.mouse_value = value_string + unit_string string = value_string + string # Add a gap to string and add to viewer. string += " " self._dont_update_status = True self.statusBar().clearMessage() self._dont_update_status = False self.coord_label.setText(string) if self._is_tooltip_on: if self.mouse_value: QToolTip.showText(mouse_pos, "...", self) QToolTip.showText(mouse_pos, self.mouse_value, self) else: QToolTip.showText(mouse_pos, "...", self) QToolTip.showText(mouse_pos, " ", self) return