def open_menu(self, position): menu = QMenu(self) preset_menu = menu.addMenu('Presets') preset_menu.addAction('New preset', self.new_preset_dialog) preset_menu.addSeparator() preset_names = CONFIG.get_header_presets() if len(preset_names) == 0: action = preset_menu.addAction('No presets') action.setEnabled(False) else: delete_menu = menu.addMenu('Delete preset') for name in preset_names: preset_menu.addAction(name, partial(self.load_preset, name)) delete_menu.addAction(name, partial(self.delete_preset, name)) menu.addSeparator() menu.addAction('New column...', self.create_new_column_dialog) if len(self.columnList.selectedIndexes()) > 0: menu.addAction('Delete selected', self.delete_selected) menu.popup(self.columnList.viewport().mapToGlobal(position))
def context_menu(self): try: menu = super(PyDMRelatedDisplayButton, self).context_menu() except: menu = QMenu(self) if len(menu.findChildren(QAction)) > 0: menu.addSeparator() if len(self.filenames) <= 1: menu.addAction(self.open_in_new_window_action) return menu sub_menu = menu.addMenu("Open in New Window") self._assemble_menu(sub_menu, target=self.NEW_WINDOW) return menu
def populate_qmenu(menu: QMenu, menu_key: str): """Populate `menu` from a `menu_key` offering in the manifest.""" # TODO: declare somewhere what menu_keys are valid. pm = npe2.PluginManager.instance() for item in pm.iter_menu(menu_key): if hasattr(item, 'submenu'): subm_contrib = pm.get_submenu(item.submenu) subm = menu.addMenu(subm_contrib.label) populate_qmenu(subm, subm_contrib.id) else: cmd = pm.get_command(item.command) action = menu.addAction(cmd.title) action.triggered.connect(lambda *args: cmd.exec(args=args))
def _set_bpm_menu(self, sec): cmd = ['sirius-hla-as-di-bpm.py', sec] menu = QMenu('BPMs', self) menu.setObjectName(sec.upper() + 'App') menu.setIcon(qta.icon('mdi.currency-sign')) action = menu.addAction('Monitor') action.setIcon(util.get_monitor_icon('mdi.currency-sign')) self.connect_newprocess(action, cmd + [ '-w', 'Monitor', ]) typs = ('Single Pass', 'Multi Turn') acts = ('SPass', 'MTurn') for typ, act in zip(typs, acts): if sec in {'bo', 'si'}: menu2 = menu.addMenu(typ) menu2.setObjectName(sec.upper() + 'App') if act == 'SPass': self._create_bpm_actions(sec, menu2, act, cmd) else: for mode in ('Antennas', 'Positions'): menu3 = menu2.addMenu(mode) menu3.setObjectName(sec.upper() + 'App') cmd2 = cmd + ['-m', mode] self._create_bpm_actions(sec, menu3, act, cmd2) else: if act == 'SPass': self._create_bpm_actions(sec, menu, act, cmd, typ) else: menu2 = menu.addMenu(typ) menu2.setObjectName(sec.upper() + 'App') for mode in ('Antennas', 'Positions'): cmd2 = cmd + ['-m', mode] self._create_bpm_actions(sec, menu2, act, cmd2, mode) return menu
def _make_context_menu(self): """ Makes the context menu with options relating to plots :return: The context menu, and export sub-menu with a list of export types """ context_menu = QMenu() context_menu.addAction("Show", self.presenter.show_multiple_selected) context_menu.addAction("Hide", self.presenter.hide_selected_plots) context_menu.addAction("Delete", self.presenter.close_action_called) context_menu.addAction("Rename", self.rename_selected_in_context_menu) export_menu = context_menu.addMenu("Export") for text, extension in EXPORT_TYPES: export_menu.addAction(text, lambda ext=extension: self.presenter.export_plots_called(ext)) return context_menu, export_menu
def dict_to_menu(parent, menu_dict, menu_widget=None): if not menu_widget: menu_widget = QMenu(parent) for k, v in menu_dict.items(): if isinstance(v, dict): new_menu = menu_widget.addMenu(k) dict_to_menu(v, menu_widget=new_menu) else: act = QAction(k, menu_widget) if isinstance(v, list): if v[0] == 'checkable': v = v[1] act.setCheckable(True) act.setChecked(False) act.triggered.connect(v) menu_widget.addAction(act) return menu_widget
def _dict_to_menu(self, menu_dict): '''Stolen shamelessly from specviz. Thanks!''' menu_widget = QMenu() for k, v in menu_dict.items(): if isinstance(v, dict): new_menu = menu_widget.addMenu(k) self._dict_to_menu(v, menu_widget=new_menu) else: act = QAction(k, menu_widget) if isinstance(v, list): if v[0] == 'checkable': v = v[1] act.setCheckable(True) act.setChecked(True) act.triggered.connect(v) menu_widget.addAction(act) return menu_widget
def _dict_to_menu(self, menu_dict, menu_widget=None): '''Stolen shamelessly from specviz. Thanks!''' if not menu_widget: menu_widget = QMenu() for k, v in menu_dict.items(): if isinstance(v, dict): new_menu = menu_widget.addMenu(k) self._dict_to_menu(v, menu_widget=new_menu) else: act = QAction(k, menu_widget) if isinstance(v, list): if v[0] == 'checkable': v = v[1] act.setCheckable(True) act.setChecked(False) act.triggered.connect(v) menu_widget.addAction(act) return menu_widget
def header_menu(self, position): ''' Creates a menu allowing users to show and hide columns ''' header = self.sender() # type: QHeaderView index = header.logicalIndexAt(position) menu = QMenu("Options") action = menu.addAction("Hide Column") # type: QAction column_name = str(header.model().headerData(index, Qt.Horizontal)) action.triggered.connect(lambda: self.hide_column(header, index)) show_columns_menu = menu.addMenu("Show Columns") for i in range(header.count()): if header.isSectionHidden(i): column_name = str(header.model().headerData(i, Qt.Horizontal)) action = show_columns_menu.addAction(column_name) action.triggered.connect( functools.partial(self.unhide_column, header, i)) # why does below work, but not: lambda: self.unhide_column(header, i) # action.triggered.connect(lambda triggered, logicalIndex=i: self.unhide_column(header, logicalIndex)) menu.exec_(header.mapToGlobal(position))
def _popup_menu(self, event): axes = self._find_calling_axes(event) # find axes calling right click if axes is None: return pos = self.parent.mapFromGlobal(QtGui.QCursor().pos()) popup_menu = QMenu(self.parent) xScaleMenu = popup_menu.addMenu('x-scale') yScaleMenu = popup_menu.addMenu('y-scale') for coord in ['x', 'y']: menu = eval(coord + 'ScaleMenu') for type in axes.scale[coord].keys(): action = QAction(type, menu, checkable=True) if axes.scale[coord][type]: # if it's checked action.setEnabled(False) else: action.setEnabled(True) menu.addAction(action) action.setChecked(axes.scale[coord][type]) fcn = lambda event, coord=coord, type=type: self._set_scale( coord, type, axes, True) action.triggered.connect(fcn) # Create menu for AutoScale options X Y All popup_menu.addSeparator() autoscale_options = ['AutoScale X', 'AutoScale Y', 'AutoScale All'] for n, text in enumerate(autoscale_options): action = QAction(text, menu, checkable=True) if n < len(self.autoScale): action.setChecked(self.autoScale[n]) else: action.setChecked(all(self.autoScale)) popup_menu.addAction(action) action.toggled.connect( lambda event, n=n: self._setAutoScale(n, event, axes)) popup_menu.exec_(self.parent.mapToGlobal(pos))
class InjSysStbyControlWidget(QWidget): """Injection System Control Widget.""" expand = Signal() def __init__(self, parent=None, prefix=VACA_PREFIX, is_summary=False, handler=None): """Init.""" super().__init__(parent) self.prefix = prefix self._inj_prefix = SiriusPVName('AS-Glob:AP-InjCtrl').substitute( prefix=prefix) self._is_summary = is_summary self._last_comm = None self._handler = handler or InjSysStandbyHandler() self._icon_off = qta.icon('mdi.power-off') self._icon_on = qta.icon('mdi.power-on') self._icon_check = qta.icon('fa5s.check') self._pixmap_check = self._icon_check.pixmap( self._icon_check.actualSize(QSize(16, 16))) self._icon_not = qta.icon('fa5s.times') self._pixmap_not = self._icon_not.pixmap( self._icon_not.actualSize(QSize(16, 16))) self.menu = QMenu(self) self.rstord_act = self.menu.addAction('Reset Commands') self.rstord_act.triggered.connect(self._reset_commands_order) if is_summary: self._setupSummary() else: self._setupFull() self._ch_cmdsts = SiriusConnectionSignal( self._inj_prefix.substitute(propty='InjSysCmdSts-Mon')) self._ch_off_order_sp = SiriusConnectionSignal( self._inj_prefix.substitute(propty='InjSysTurnOffOrder-SP')) self._ch_off_order_rb = SiriusConnectionSignal( self._inj_prefix.substitute(propty='InjSysTurnOffOrder-RB')) self._ch_on_order_sp = SiriusConnectionSignal( self._inj_prefix.substitute(propty='InjSysTurnOnOrder-SP')) self._ch_on_order_rb = SiriusConnectionSignal( self._inj_prefix.substitute(propty='InjSysTurnOnOrder-RB')) if not is_summary: self._ch_cmdone = SiriusConnectionSignal( self._inj_prefix.substitute(propty='InjSysCmdDone-Mon')) self._ch_cmdsts.new_value_signal[int].connect( self._handle_cmdsts_buttons_enbl) self._ch_off_order_rb.new_value_signal[str].connect( self._handle_buttons_color) self._ch_on_order_rb.new_value_signal[str].connect( self._handle_buttons_color) self._ch_off_order_rb.new_value_signal[str].connect( self._handle_actions_state) self._ch_on_order_rb.new_value_signal[str].connect( self._handle_actions_state) if not is_summary: self._ch_cmdone.new_value_signal[str].connect( self._handle_cmdone_labels) self._ch_cmdsts.new_value_signal[int].connect( self._handle_cmdsts_labels) def _setupSummary(self): self._pb_off = PyDMPushButton(self, label='', icon=self._icon_off, init_channel=self._inj_prefix.substitute( propty='InjSysTurnOff-Cmd'), pressValue=0) self._pb_off.setObjectName('bt') self._pb_off.setStyleSheet( '#bt{min-width:25px; max-width:25px; icon-size:20px;}') self._pb_on = PyDMPushButton(self, label='', icon=self._icon_on, init_channel=self._inj_prefix.substitute( propty='InjSysTurnOn-Cmd'), pressValue=0) self._pb_on.setObjectName('bt') self._pb_on.setStyleSheet( '#bt{min-width:25px; max-width:25px; icon-size:20px;}') self._led_sts = InjSysStbyLed(self) self._led_sts.setStyleSheet( 'QLed{min-width:1.29em; max-width:1.29em;}') lay = QGridLayout(self) lay.setAlignment(Qt.AlignCenter) lay.addWidget(self._pb_off, 0, 0) lay.addWidget(self._pb_on, 0, 1) lay.addWidget(self._led_sts, 1, 0, 1, 2, alignment=Qt.AlignCenter) # menu for cmmtype in ['on', 'off']: order = getattr(self._handler, cmmtype + '_order') menu = QMenu('Select Turn ' + cmmtype.upper() + ' Commands', self) setattr(self, cmmtype + '_menu', menu) self.menu.addMenu(menu) for cmm in order: act = menu.addAction(self._handler.HANDLER_DESC[cmm]) act.setObjectName(cmm) act.setCheckable(True) def _setupFull(self): lay = QGridLayout(self) lay.addWidget(QLabel('Off', self, alignment=Qt.AlignCenter), 0, 1) lay.addWidget(QLabel('On', self, alignment=Qt.AlignCenter), 0, 2) lay.addWidget(QLabel('Status', self, alignment=Qt.AlignCenter), 0, 3) self._checkbox_off = dict() self._checkbox_on = dict() self._labels_sts = dict() for idx, name in enumerate(self._handler.DEF_ON_ORDER): cb_off = QCheckBox(self) cb_off.setObjectName(name) self._checkbox_off[name] = cb_off cb_on = QCheckBox(self) cb_on.setObjectName(name) self._checkbox_on[name] = cb_on desc = self._handler.HANDLER_DESC[name] splitd = desc.split('(') lbl_txt = splitd[0] tip = '' if len(splitd) > 1: lbl_txt, tip = splitd lb_dsc = QLabel(lbl_txt, self, alignment=Qt.AlignLeft) if tip: lb_dsc.setToolTip(tip[:-1]) lb_sts = QLabel('', self, alignment=Qt.AlignCenter) lb_sts.setObjectName(name) self._labels_sts[name] = lb_sts lay.addWidget(lb_dsc, idx + 1, 0) lay.addWidget(cb_off, idx + 1, 1, alignment=Qt.AlignCenter) lay.addWidget(cb_on, idx + 1, 2, alignment=Qt.AlignCenter) lay.addWidget(lb_sts, idx + 1, 3) self._pb_off = PyDMPushButton(self, label='', icon=self._icon_off, init_channel=self._inj_prefix.substitute( propty='InjSysTurnOff-Cmd'), pressValue=0) self._pb_off.setObjectName('bt') self._pb_off.setStyleSheet( '#bt{min-width:25px; max-width:25px; icon-size:20px;}') self._pb_on = PyDMPushButton(self, label='', icon=self._icon_on, init_channel=self._inj_prefix.substitute( propty='InjSysTurnOn-Cmd'), pressValue=0) self._pb_on.setObjectName('bt') self._pb_on.setStyleSheet( '#bt{min-width:25px; max-width:25px; icon-size:20px;}') self._led_sts = InjSysStbyLed(self) lay.addWidget(self._pb_off, 6, 1) lay.addWidget(self._pb_on, 6, 2) lay.addWidget(self._led_sts, 6, 3) @Slot(int) def _handle_cmdsts_buttons_enbl(self, new_sts): if new_sts == _Const.InjSysCmdSts.On: self._pb_on.setEnabled(False) self._pb_on.setIcon( qta.icon('fa5s.spinner', animation=qta.Spin(self._pb_on))) self._pb_off.setEnabled(False) elif new_sts == _Const.InjSysCmdSts.Off: self._pb_on.setEnabled(False) self._pb_off.setEnabled(False) self._pb_off.setIcon( qta.icon('fa5s.spinner', animation=qta.Spin(self._pb_off))) else: if not self._pb_on.isEnabled(): self._pb_on.setEnabled(True) self._pb_off.setEnabled(True) self._pb_on.setIcon(self._icon_on) self._pb_off.setIcon(self._icon_off) @Slot(str) def _handle_cmdone_labels(self, new_done): for name in self._handler.DEF_ON_ORDER: lbl = self._labels_sts[name] if name in new_done: lbl.setPixmap(self._pixmap_check) elif self._ch_cmdsts.value == _Const.InjSysCmdSts.Idle: lbl.setPixmap(self._pixmap_not) @Slot(int) def _handle_cmdsts_labels(self, new_sts): if new_sts == _Const.InjSysCmdSts.On: self._last_comm = new_sts for name in self._handler.DEF_ON_ORDER: if self._ch_on_order_rb.value is None: break lbl = self._labels_sts[name] if name in self._ch_on_order_rb.value: icon = qta.icon('fa5s.spinner') pixmap = icon.pixmap(icon.actualSize(QSize(16, 16))) lbl.setPixmap(pixmap) else: lbl.setPixmap(QPixmap()) elif new_sts == _Const.InjSysCmdSts.Off: self._last_comm = new_sts for name in self._handler.DEF_OFF_ORDER: if self._ch_off_order_rb.value is None: break lbl = self._labels_sts[name] if name in self._ch_off_order_rb.value: icon = qta.icon('fa5s.spinner') pixmap = icon.pixmap(icon.actualSize(QSize(16, 16))) lbl.setPixmap(pixmap) else: lbl.setPixmap(QPixmap()) else: done = self._ch_cmdone.value for name in self._handler.DEF_ON_ORDER: if done is None or name in done: continue lbl = self._labels_sts[name] if self._last_comm == _Const.InjSysCmdSts.On and \ name in self._ch_on_order_rb.value: lbl.setPixmap(self._pixmap_not) elif self._last_comm == _Const.InjSysCmdSts.Off and \ name in self._ch_off_order_rb.value: lbl.setPixmap(self._pixmap_not) self._last_comm = None @Slot() def _set_commands_order(self): if self._is_summary: if self.sender() in self.on_menu.actions(): on_order = [ a.objectName() for a in self.on_menu.actions() if a.isChecked() ] self._ch_on_order_sp.send_value_signal[str].emit( ','.join(on_order)) elif self.sender() in self.off_menu.actions(): off_order = [ a.objectName() for a in self.off_menu.actions() if a.isChecked() ] self._ch_off_order_sp.send_value_signal[str].emit( ','.join(off_order)) else: if self.sender() in self._checkbox_on.values(): checked = [ w.objectName() for w in self._checkbox_on.values() if w.isChecked() ] on_order = [ h for h in self._handler.DEF_ON_ORDER if h in checked ] self._ch_on_order_sp.send_value_signal[str].emit( ','.join(on_order)) elif self.sender() in self._checkbox_off.values(): checked = [ w.objectName() for w in self._checkbox_off.values() if w.isChecked() ] off_order = [ h for h in self._handler.DEF_OFF_ORDER if h in checked ] self._ch_off_order_sp.send_value_signal[str].emit( ','.join(off_order)) @Slot() def _reset_commands_order(self): self._ch_off_order_sp.send_value_signal[str].emit(','.join( self._handler.DEF_OFF_ORDER)) self._ch_on_order_sp.send_value_signal[str].emit(','.join( self._handler.DEF_ON_ORDER)) if self._is_summary: for menu in [self.off_menu, self.on_menu]: for act in menu.actions(): act.toggled.disconnect() act.setChecked(True) act.toggled.connect(self._set_commands_order) else: for group in [self._checkbox_off, self._checkbox_on]: for wid in group.values(): wid.toggled.disconnect() wid.setChecked(True) wid.toggled.connect(self._set_commands_order) @Slot() def _handle_buttons_color(self): off_color = 'yellow' if self._ch_off_order_rb.value != \ ','.join(self._handler.DEF_OFF_ORDER) else 'white' self._pb_off.setStyleSheet( '#bt{min-width:25px; max-width:25px; icon-size:20px;' 'background-color: ' + off_color + ';}') on_color = 'yellow' if self._ch_on_order_rb.value != \ ','.join(self._handler.DEF_ON_ORDER) else 'white' self._pb_on.setStyleSheet( '#bt{min-width:25px; max-width:25px; icon-size:20px;' 'background-color: ' + on_color + ';}') @Slot(str) def _handle_actions_state(self, sts): state = 'on' if 'On' in self.sender().address else 'off' channel = getattr(self, '_ch_' + state + '_order_rb') if channel.value is None: return if self._is_summary: group = getattr(self, state + '_menu').actions() else: group = getattr(self, '_checkbox_' + state).values() for obj in group: obj.disconnect() ost = obj.objectName() in sts obj.setChecked(ost) obj.toggled.connect(self._set_commands_order) def contextMenuEvent(self, event): """Show a custom context menu.""" self.menu.popup(self.mapToGlobal(event.pos()))
def populate_menu(menu: QMenu, actions: List['MenuItem']): """Populate a QMenu from a declarative list of QAction dicts. Parameters ---------- menu : QMenu the menu to populate actions : list of dict A list of dicts with one or more of the following keys **Required: One of "text" or "menu" MUST be present in the dict** text: str the name of the QAction to add menu: str if present, creates a submenu instead. "menu" keys may also provide an "items" key to populate the menu. **Optional:** slot: callable a callback to call when the action is triggered shortcut: str a keyboard shortcut to trigger the actoin statusTip: str used for setStatusTip menuRole: QAction.MenuRole used for setMenuRole checkable: bool used for setCheckable checked: bool used for setChecked (only if `checkable` is provided and True) check_on: EventEmitter If provided, and `checkable` is True, this EventEmitter will be connected to action.setChecked: `dct['check_on'].connect(lambda e: action.setChecked(e.value))` """ for ax in actions: if not ax: menu.addSeparator() continue if not ax.get("when", True): continue if 'menu' in ax: sub = ax['menu'] if isinstance(sub, QMenu): menu.addMenu(sub) sub.setParent(menu) else: sub = menu.addMenu(sub) populate_menu(sub, ax.get("items", [])) continue action: QAction = menu.addAction(ax['text']) if 'slot' in ax: if ax.get("checkable"): action.toggled.connect(ax['slot']) else: action.triggered.connect(ax['slot']) action.setShortcut(ax.get('shortcut', '')) action.setStatusTip(ax.get('statusTip', '')) if 'menuRole' in ax: action.setMenuRole(ax['menuRole']) if ax.get("checkable"): action.setCheckable(True) action.setChecked(ax.get("checked", False)) if 'check_on' in ax: emitter = ax['check_on'] @emitter.connect def _setchecked(e, action=action): action.setChecked(e.value if hasattr(e, 'value') else e) action.setData(ax)
class Window: """Application window that contains the menu bar and viewer. Parameters ---------- viewer : napari.components.ViewerModel Contained viewer widget. Attributes ---------- file_menu : qtpy.QtWidgets.QMenu File menu. help_menu : qtpy.QtWidgets.QMenu Help menu. main_menu : qtpy.QtWidgets.QMainWindow.menuBar Main menubar. qt_viewer : QtViewer Contained viewer widget. view_menu : qtpy.QtWidgets.QMenu View menu. window_menu : qtpy.QtWidgets.QMenu Window menu. """ def __init__(self, viewer, *, show: bool = True): # create QApplication if it doesn't already exist get_app() self._unnamed_dockwidget_count = 1 # Connect the Viewer and create the Main Window self.qt_viewer = QtViewer(viewer, show_welcome_screen=True) self._qt_window = _QtMainWindow(self.qt_viewer) self._status_bar = self._qt_window.statusBar() # Dictionary holding dock widgets self._dock_widgets: Dict[str, QtViewerDockWidget] = {} # since we initialize canvas before window, we need to manually connect them again. if self._qt_window.windowHandle() is not None: self._qt_window.windowHandle().screenChanged.connect( self.qt_viewer.canvas._backend.screen_changed) self._add_menubar() self._add_file_menu() self._add_view_menu() self._add_window_menu() self._add_plugins_menu() self._add_help_menu() self._status_bar.showMessage(trans._('Ready')) self._help = QLabel('') self._status_bar.addPermanentWidget(self._help) self.qt_viewer.viewer.theme = SETTINGS.appearance.theme self._update_theme() self._add_viewer_dock_widget(self.qt_viewer.dockConsole, tabify=False) self._add_viewer_dock_widget(self.qt_viewer.dockLayerControls, tabify=False) self._add_viewer_dock_widget(self.qt_viewer.dockLayerList, tabify=False) self._add_viewer_dock_widget(self.qt_viewer.activityDock, tabify=False) self.window_menu.addSeparator() SETTINGS.appearance.events.theme.connect(self._update_theme) viewer.events.status.connect(self._status_changed) viewer.events.help.connect(self._help_changed) viewer.events.title.connect(self._title_changed) viewer.events.theme.connect(self._update_theme) if perf.USE_PERFMON: # Add DebugMenu and dockPerformance if using perfmon. self._debug_menu = DebugMenu(self) self._add_viewer_dock_widget(self.qt_viewer.dockPerformance) else: self._debug_menu = None if show: self.show() def _add_menubar(self): """Add menubar to napari app.""" self.main_menu = self._qt_window.menuBar() # Menubar shortcuts are only active when the menubar is visible. # Therefore, we set a global shortcut not associated with the menubar # to toggle visibility, *but*, in order to not shadow the menubar # shortcut, we disable it, and only enable it when the menubar is # hidden. See this stackoverflow link for details: # https://stackoverflow.com/questions/50537642/how-to-keep-the-shortcuts-of-a-hidden-widget-in-pyqt5 self._main_menu_shortcut = QShortcut(QKeySequence('Ctrl+M'), self._qt_window) self._main_menu_shortcut.activated.connect( self._toggle_menubar_visible) self._main_menu_shortcut.setEnabled(False) def _toggle_menubar_visible(self): """Toggle visibility of app menubar. This function also disables or enables a global keyboard shortcut to show the menubar, since menubar shortcuts are only available while the menubar is visible. """ if self.main_menu.isVisible(): self.main_menu.setVisible(False) self._main_menu_shortcut.setEnabled(True) else: self.main_menu.setVisible(True) self._main_menu_shortcut.setEnabled(False) def _add_file_menu(self): """Add 'File' menu to app menubar.""" open_images = QAction(trans._('Open File(s)...'), self._qt_window) open_images.setShortcut('Ctrl+O') open_images.setStatusTip(trans._('Open file(s)')) open_images.triggered.connect(self.qt_viewer._open_files_dialog) open_stack = QAction(trans._('Open Files as Stack...'), self._qt_window) open_stack.setShortcut('Ctrl+Alt+O') open_stack.setStatusTip(trans._('Open files')) open_stack.triggered.connect( self.qt_viewer._open_files_dialog_as_stack_dialog) open_folder = QAction(trans._('Open Folder...'), self._qt_window) open_folder.setShortcut('Ctrl+Shift+O') open_folder.setStatusTip(trans._('Open a folder')) open_folder.triggered.connect(self.qt_viewer._open_folder_dialog) # OS X will rename this to Quit and put it in the app menu. preferences = QAction(trans._('Preferences'), self._qt_window) preferences.setShortcut('Ctrl+Shift+P') preferences.setStatusTip(trans._('Open preferences dialog')) preferences.setMenuRole(QAction.PreferencesRole) preferences.triggered.connect(self._open_preferences) save_selected_layers = QAction(trans._('Save Selected Layer(s)...'), self._qt_window) save_selected_layers.setShortcut('Ctrl+S') save_selected_layers.setStatusTip(trans._('Save selected layers')) save_selected_layers.triggered.connect( lambda: self.qt_viewer._save_layers_dialog(selected=True)) save_all_layers = QAction(trans._('Save All Layers...'), self._qt_window) save_all_layers.setShortcut('Ctrl+Shift+S') save_all_layers.setStatusTip(trans._('Save all layers')) save_all_layers.triggered.connect( lambda: self.qt_viewer._save_layers_dialog(selected=False)) screenshot = QAction(trans._('Save Screenshot...'), self._qt_window) screenshot.setShortcut('Alt+S') screenshot.setStatusTip( trans._('Save screenshot of current display, default .png')) screenshot.triggered.connect(self.qt_viewer._screenshot_dialog) screenshot_wv = QAction(trans._('Save Screenshot with Viewer...'), self._qt_window) screenshot_wv.setShortcut('Alt+Shift+S') screenshot_wv.setStatusTip( trans. _('Save screenshot of current display with the viewer, default .png' )) screenshot_wv.triggered.connect(self._screenshot_dialog) # OS X will rename this to Quit and put it in the app menu. # This quits the entire QApplication and all windows that may be open. quitAction = QAction(trans._('Exit'), self._qt_window) quitAction.setShortcut('Ctrl+Q') quitAction.setMenuRole(QAction.QuitRole) quitAction.triggered.connect( lambda: self._qt_window.close(quit_app=True)) if running_as_bundled_app(): restartAction = QAction(trans._('Restart'), self._qt_window) restartAction.triggered.connect(self._qt_window.restart) closeAction = QAction(trans._('Close Window'), self._qt_window) closeAction.setShortcut('Ctrl+W') closeAction.triggered.connect(self._qt_window.close_window) plugin_manager.discover_sample_data() open_sample_menu = QMenu(trans._('Open Sample'), self._qt_window) for plugin_name, samples in plugin_manager._sample_data.items(): multiprovider = len(samples) > 1 if multiprovider: menu = QMenu(plugin_name, self._qt_window) open_sample_menu.addMenu(menu) else: menu = open_sample_menu for samp_name, samp_dict in samples.items(): display_name = samp_dict['display_name'] if multiprovider: action = QAction(display_name, parent=self._qt_window) else: full_name = plugin_menu_item_template.format( plugin_name, display_name) action = QAction(full_name, parent=self._qt_window) def _add_sample(*args, plg=plugin_name, smp=samp_name): self.qt_viewer.viewer.open_sample(plg, smp) menu.addAction(action) action.triggered.connect(_add_sample) self.file_menu = self.main_menu.addMenu(trans._('&File')) self.file_menu.addAction(open_images) self.file_menu.addAction(open_stack) self.file_menu.addAction(open_folder) self.file_menu.addMenu(open_sample_menu) self.file_menu.addSeparator() self.file_menu.addAction(preferences) self.file_menu.addSeparator() self.file_menu.addAction(save_selected_layers) self.file_menu.addAction(save_all_layers) self.file_menu.addAction(screenshot) self.file_menu.addAction(screenshot_wv) self.file_menu.addSeparator() self.file_menu.addAction(closeAction) if running_as_bundled_app(): self.file_menu.addAction(restartAction) self.file_menu.addAction(quitAction) def _open_preferences(self): """Edit preferences from the menubar.""" if self._qt_window._preferences_dialog is None: win = PreferencesDialog(parent=self._qt_window) win.resized.connect( self._qt_window._update_preferences_dialog_size) if self._qt_window._preferences_dialog_size: win.resize(self._qt_window._preferences_dialog_size) self._qt_window._preferences_dialog = win win.closed.connect(self._on_preferences_closed) win.show() else: self._qt_window._preferences_dialog.raise_() def _on_preferences_closed(self): """Reset preferences dialog variable.""" self._qt_window._preferences_dialog = None def _add_view_menu(self): """Add 'View' menu to app menubar.""" toggle_visible = QAction(trans._('Toggle Menubar Visibility'), self._qt_window) toggle_visible.setShortcut('Ctrl+M') toggle_visible.setStatusTip(trans._('Hide Menubar')) toggle_visible.triggered.connect(self._toggle_menubar_visible) toggle_fullscreen = QAction(trans._('Toggle Full Screen'), self._qt_window) toggle_fullscreen.setShortcut('Ctrl+F') toggle_fullscreen.setStatusTip(trans._('Toggle full screen')) toggle_fullscreen.triggered.connect(self._toggle_fullscreen) toggle_play = QAction(trans._('Toggle Play'), self._qt_window) toggle_play.triggered.connect(self._toggle_play) toggle_play.setShortcut('Ctrl+Alt+P') toggle_play.setStatusTip(trans._('Toggle Play')) self.view_menu = self.main_menu.addMenu(trans._('&View')) self.view_menu.addAction(toggle_fullscreen) self.view_menu.addAction(toggle_visible) self.view_menu.addAction(toggle_play) self.view_menu.addSeparator() # Add octree actions. if config.async_octree: toggle_outline = QAction(trans._('Toggle Chunk Outlines'), self._qt_window) toggle_outline.triggered.connect( self.qt_viewer._toggle_chunk_outlines) toggle_outline.setShortcut('Ctrl+Alt+O') toggle_outline.setStatusTip(trans._('Toggle Chunk Outlines')) self.view_menu.addAction(toggle_outline) # Add axes menu axes = self.qt_viewer.viewer.axes axes_menu = QMenu(trans._('Axes'), parent=self._qt_window) axes_visible_action = QAction( trans._('Visible'), parent=self._qt_window, checkable=True, checked=self.qt_viewer.viewer.axes.visible, ) axes_visible_action.triggered.connect(self._toggle_axes_visible) self._event_to_action(axes_visible_action, axes.events.visible) axes_colored_action = QAction( trans._('Colored'), parent=self._qt_window, checkable=True, checked=self.qt_viewer.viewer.axes.colored, ) axes_colored_action.triggered.connect(self._toggle_axes_colored) self._event_to_action(axes_colored_action, axes.events.colored) axes_labels_action = QAction( trans._('Labels'), parent=self._qt_window, checkable=True, checked=self.qt_viewer.viewer.axes.labels, ) axes_labels_action.triggered.connect(self._toggle_axes_labels) self._event_to_action(axes_labels_action, axes.events.labels) axes_dashed_action = QAction( trans._('Dashed'), parent=self._qt_window, checkable=True, checked=self.qt_viewer.viewer.axes.dashed, ) axes_dashed_action.triggered.connect(self._toggle_axes_dashed) self._event_to_action(axes_dashed_action, axes.events.dashed) axes_arrows_action = QAction( trans._('Arrows'), parent=self._qt_window, checkable=True, checked=self.qt_viewer.viewer.axes.arrows, ) axes_arrows_action.triggered.connect(self._toggle_axes_arrows) self._event_to_action(axes_arrows_action, axes.events.arrows) axes_menu.addAction(axes_visible_action) axes_menu.addAction(axes_colored_action) axes_menu.addAction(axes_labels_action) axes_menu.addAction(axes_dashed_action) axes_menu.addAction(axes_arrows_action) self.view_menu.addMenu(axes_menu) # Add scale bar menu scale_bar = self.qt_viewer.viewer.scale_bar scale_bar_menu = QMenu(trans._('Scale Bar'), parent=self._qt_window) scale_bar_visible_action = QAction( trans._('Visible'), parent=self._qt_window, checkable=True, checked=self.qt_viewer.viewer.scale_bar.visible, ) scale_bar_visible_action.triggered.connect( self._toggle_scale_bar_visible) self._event_to_action(scale_bar_visible_action, scale_bar.events.visible) scale_bar_colored_action = QAction( trans._('Colored'), parent=self._qt_window, checkable=True, checked=self.qt_viewer.viewer.scale_bar.colored, ) scale_bar_colored_action.triggered.connect( self._toggle_scale_bar_colored) self._event_to_action(scale_bar_colored_action, scale_bar.events.colored) scale_bar_ticks_action = QAction( trans._('Ticks'), parent=self._qt_window, checkable=True, checked=self.qt_viewer.viewer.scale_bar.ticks, ) scale_bar_ticks_action.triggered.connect(self._toggle_scale_bar_ticks) self._event_to_action(scale_bar_ticks_action, scale_bar.events.ticks) scale_bar_menu.addAction(scale_bar_visible_action) scale_bar_menu.addAction(scale_bar_colored_action) scale_bar_menu.addAction(scale_bar_ticks_action) self.view_menu.addMenu(scale_bar_menu) self.view_menu.addSeparator() def _event_to_action(self, action, event): """Connect triggered event in model to respective action in menu.""" # TODO: use action manager to keep in sync event.connect(lambda e: action.setChecked(e.value)) def _add_window_menu(self): """Add 'Window' menu to app menubar.""" clear_action = QAction(trans._("Remove Dock Widgets"), self._qt_window) clear_action.setStatusTip(trans._('Remove all dock widgets')) clear_action.triggered.connect( lambda e: self.remove_dock_widget('all')) self.window_menu = self.main_menu.addMenu(trans._('&Window')) self.window_menu.addAction(clear_action) self.window_menu.addSeparator() def _add_plugins_menu(self): """Add 'Plugins' menu to app menubar.""" self.plugins_menu = self.main_menu.addMenu(trans._('&Plugins')) pip_install_action = QAction( trans._("Install/Uninstall Package(s)..."), self._qt_window) pip_install_action.triggered.connect(self._show_plugin_install_dialog) self.plugins_menu.addAction(pip_install_action) report_plugin_action = QAction(trans._("Plugin Errors..."), self._qt_window) report_plugin_action.setStatusTip( trans. _('Review stack traces for plugin exceptions and notify developers' )) report_plugin_action.triggered.connect(self._show_plugin_err_reporter) self.plugins_menu.addAction(report_plugin_action) self._plugin_dock_widget_menu = QMenu(trans._('Add Dock Widget'), self._qt_window) plugin_manager.discover_widgets() # Add a menu item (QAction) for each available plugin widget for hook_type, (plugin_name, widgets) in plugin_manager.iter_widgets(): multiprovider = len(widgets) > 1 if multiprovider: menu = QMenu(plugin_name, self._qt_window) self._plugin_dock_widget_menu.addMenu(menu) else: menu = self._plugin_dock_widget_menu for wdg_name in widgets: key = (plugin_name, wdg_name) if multiprovider: action = QAction(wdg_name, parent=self._qt_window) else: full_name = plugin_menu_item_template.format(*key) action = QAction(full_name, parent=self._qt_window) def _add_widget(*args, key=key, hook_type=hook_type): if hook_type == 'dock': self.add_plugin_dock_widget(*key) else: self._add_plugin_function_widget(*key) menu.addAction(action) action.triggered.connect(_add_widget) self.plugins_menu.addMenu(self._plugin_dock_widget_menu) def _show_plugin_install_dialog(self): """Show dialog that allows users to sort the call order of plugins.""" self.plugin_dialog = QtPluginDialog(self._qt_window) self.plugin_dialog.exec_() def _show_plugin_err_reporter(self): """Show dialog that allows users to review and report plugin errors.""" QtPluginErrReporter(parent=self._qt_window).exec_() def _add_help_menu(self): """Add 'Help' menu to app menubar.""" self.help_menu = self.main_menu.addMenu(trans._('&Help')) about_action = QAction(trans._("napari Info"), self._qt_window) about_action.setShortcut("Ctrl+/") about_action.setStatusTip(trans._('About napari')) about_action.triggered.connect( lambda e: QtAbout.showAbout(self.qt_viewer, self._qt_window)) self.help_menu.addAction(about_action) about_key_bindings = QAction(trans._("Show Key Bindings"), self._qt_window) about_key_bindings.setShortcut("Ctrl+Alt+/") about_key_bindings.setShortcutContext(Qt.ApplicationShortcut) about_key_bindings.setStatusTip(trans._('key_bindings')) about_key_bindings.triggered.connect( self.qt_viewer.show_key_bindings_dialog) self.help_menu.addAction(about_key_bindings) def _toggle_scale_bar_visible(self, state): self.qt_viewer.viewer.scale_bar.visible = state def _toggle_scale_bar_colored(self, state): self.qt_viewer.viewer.scale_bar.colored = state def _toggle_scale_bar_ticks(self, state): self.qt_viewer.viewer.scale_bar.ticks = state def _toggle_axes_visible(self, state): self.qt_viewer.viewer.axes.visible = state def _toggle_axes_colored(self, state): self.qt_viewer.viewer.axes.colored = state def _toggle_axes_labels(self, state): self.qt_viewer.viewer.axes.labels = state def _toggle_axes_dashed(self, state): self.qt_viewer.viewer.axes.dashed = state def _toggle_axes_arrows(self, state): self.qt_viewer.viewer.axes.arrows = state def _toggle_fullscreen(self, event): """Toggle fullscreen mode.""" if self._qt_window.isFullScreen(): self._qt_window.showNormal() else: self._qt_window.showFullScreen() def _toggle_play(self, state): """Toggle play.""" if self.qt_viewer.dims.is_playing: self.qt_viewer.dims.stop() else: axis = self.qt_viewer.viewer.dims.last_used or 0 self.qt_viewer.dims.play(axis) def add_plugin_dock_widget( self, plugin_name: str, widget_name: str = None) -> Tuple[QtViewerDockWidget, Any]: """Add plugin dock widget if not already added. Parameters ---------- plugin_name : str Name of a plugin providing a widget widget_name : str, optional Name of a widget provided by `plugin_name`. If `None`, and the specified plugin provides only a single widget, that widget will be returned, otherwise a ValueError will be raised, by default None Returns ------- tuple A 2-tuple containing (the DockWidget instance, the plugin widget instance). """ from ..viewer import Viewer Widget, dock_kwargs = plugin_manager.get_widget( plugin_name, widget_name) if not widget_name: # if widget_name wasn't provided, `get_widget` will have # ensured that there is a single widget available. widget_name = list(plugin_manager._dock_widgets[plugin_name])[0] full_name = plugin_menu_item_template.format(plugin_name, widget_name) if full_name in self._dock_widgets: dock_widget = self._dock_widgets[full_name] dock_widget.show() wdg = dock_widget.widget() if hasattr(wdg, '_magic_widget'): wdg = wdg._magic_widget return dock_widget, wdg # if the signature is looking a for a napari viewer, pass it. kwargs = {} for param in inspect.signature(Widget.__init__).parameters.values(): if param.name == 'napari_viewer': kwargs['napari_viewer'] = self.qt_viewer.viewer break if param.annotation in ('napari.viewer.Viewer', Viewer): kwargs[param.name] = self.qt_viewer.viewer break # cannot look for param.kind == param.VAR_KEYWORD because # QWidget allows **kwargs but errs on unknown keyword arguments # instantiate the widget wdg = Widget(**kwargs) # Add dock widget dock_kwargs.pop('name', None) dock_widget = self.add_dock_widget(wdg, name=full_name, **dock_kwargs) return dock_widget, wdg def _add_plugin_function_widget(self, plugin_name: str, widget_name: str): """Add plugin function widget if not already added. Parameters ---------- plugin_name : str Name of a plugin providing a widget widget_name : str, optional Name of a widget provided by `plugin_name`. If `None`, and the specified plugin provides only a single widget, that widget will be returned, otherwise a ValueError will be raised, by default None """ full_name = plugin_menu_item_template.format(plugin_name, widget_name) if full_name in self._dock_widgets: self._dock_widgets[full_name].show() return func = plugin_manager._function_widgets[plugin_name][widget_name] # Add function widget self.add_function_widget(func, name=full_name, area=None, allowed_areas=None) def add_dock_widget( self, widget: QWidget, *, name: str = '', area: str = 'right', allowed_areas: Optional[Sequence[str]] = None, shortcut=_sentinel, add_vertical_stretch=True, ): """Convenience method to add a QDockWidget to the main window. If name is not provided a generic name will be addded to avoid `saveState` warnings on close. Parameters ---------- widget : QWidget `widget` will be added as QDockWidget's main widget. name : str, optional Name of dock widget to appear in window menu. area : str Side of the main window to which the new dock widget will be added. Must be in {'left', 'right', 'top', 'bottom'} allowed_areas : list[str], optional Areas, relative to main window, that the widget is allowed dock. Each item in list must be in {'left', 'right', 'top', 'bottom'} By default, all areas are allowed. shortcut : str, optional Keyboard shortcut to appear in dropdown menu. add_vertical_stretch : bool, optional Whether to add stretch to the bottom of vertical widgets (pushing widgets up towards the top of the allotted area, instead of letting them distribute across the vertical space). By default, True. .. deprecated:: 0.4.8 The shortcut parameter is deprecated since version 0.4.8, please use the action and shortcut manager APIs. The new action manager and shortcut API allow user configuration and localisation. Returns ------- dock_widget : QtViewerDockWidget `dock_widget` that can pass viewer events. """ if not name: try: name = widget.objectName() except AttributeError: name = trans._( "Dock widget {number}", number=self._unnamed_dockwidget_count, ) self._unnamed_dockwidget_count += 1 if shortcut is not _sentinel: warnings.warn( _SHORTCUT_DEPRECATION_STRING.format(shortcut=shortcut), FutureWarning, stacklevel=2, ) dock_widget = QtViewerDockWidget( self.qt_viewer, widget, name=name, area=area, allowed_areas=allowed_areas, shortcut=shortcut, add_vertical_stretch=add_vertical_stretch, ) else: dock_widget = QtViewerDockWidget( self.qt_viewer, widget, name=name, area=area, allowed_areas=allowed_areas, add_vertical_stretch=add_vertical_stretch, ) self._add_viewer_dock_widget(dock_widget) if hasattr(widget, 'reset_choices'): # Keep the dropdown menus in the widget in sync with the layer model # if widget has a `reset_choices`, which is true for all magicgui # `CategoricalWidget`s layers_events = self.qt_viewer.viewer.layers.events layers_events.inserted.connect(widget.reset_choices) layers_events.removed.connect(widget.reset_choices) layers_events.reordered.connect(widget.reset_choices) # Add dock widget to dictionary self._dock_widgets[dock_widget.name] = dock_widget return dock_widget def _add_viewer_dock_widget(self, dock_widget: QtViewerDockWidget, tabify=False): """Add a QtViewerDockWidget to the main window If other widgets already present in area then will tabify. Parameters ---------- dock_widget : QtViewerDockWidget `dock_widget` will be added to the main window. tabify : bool Flag to tabify dockwidget or not. """ # Find if any othe dock widgets are currently in area current_dws_in_area = [ dw for dw in self._qt_window.findChildren(QDockWidget) if self._qt_window.dockWidgetArea(dw) == dock_widget.qt_area ] self._qt_window.addDockWidget(dock_widget.qt_area, dock_widget) # If another dock widget present in area then tabify if current_dws_in_area: if tabify: self._qt_window.tabifyDockWidget(current_dws_in_area[-1], dock_widget) dock_widget.show() dock_widget.raise_() elif dock_widget.area in ('right', 'left'): _wdg = current_dws_in_area + [dock_widget] # add sizes to push lower widgets up sizes = list(range(1, len(_wdg) * 4, 4)) self._qt_window.resizeDocks(_wdg, sizes, Qt.Vertical) action = dock_widget.toggleViewAction() action.setStatusTip(dock_widget.name) action.setText(dock_widget.name) import warnings with warnings.catch_warnings(): warnings.simplefilter("ignore", FutureWarning) # deprecating with 0.4.8, but let's try to keep compatibility. shortcut = dock_widget.shortcut if shortcut is not None: action.setShortcut(shortcut) self.window_menu.addAction(action) def remove_dock_widget(self, widget: QWidget): """Removes specified dock widget. If a QDockWidget is not provided, the existing QDockWidgets will be searched for one whose inner widget (``.widget()``) is the provided ``widget``. Parameters ---------- widget : QWidget | str If widget == 'all', all docked widgets will be removed. """ if widget == 'all': for dw in list(self._dock_widgets.values()): self.remove_dock_widget(dw) return if not isinstance(widget, QDockWidget): for dw in self._qt_window.findChildren(QDockWidget): if dw.widget() is widget: _dw: QDockWidget = dw break else: raise LookupError( trans._( "Could not find a dock widget containing: {widget}", deferred=True, widget=widget, )) else: _dw = widget if _dw.widget(): _dw.widget().setParent(None) self._qt_window.removeDockWidget(_dw) self.window_menu.removeAction(_dw.toggleViewAction()) # Remove dock widget from dictionary del self._dock_widgets[_dw.name] # Deleting the dock widget means any references to it will no longer # work but it's not really useful anyway, since the inner widget has # been removed. and anyway: people should be using add_dock_widget # rather than directly using _add_viewer_dock_widget _dw.deleteLater() def add_function_widget( self, function, *, magic_kwargs=None, name: str = '', area=None, allowed_areas=None, shortcut=_sentinel, ): """Turn a function into a dock widget via magicgui. Parameters ---------- function : callable Function that you want to add. magic_kwargs : dict, optional Keyword arguments to :func:`magicgui.magicgui` that can be used to specify widget. name : str, optional Name of dock widget to appear in window menu. area : str, optional Side of the main window to which the new dock widget will be added. Must be in {'left', 'right', 'top', 'bottom'}. If not provided the default will be determined by the widget.layout, with 'vertical' layouts appearing on the right, otherwise on the bottom. allowed_areas : list[str], optional Areas, relative to main window, that the widget is allowed dock. Each item in list must be in {'left', 'right', 'top', 'bottom'} By default, only provided areas is allowed. shortcut : str, optional Keyboard shortcut to appear in dropdown menu. Returns ------- dock_widget : QtViewerDockWidget `dock_widget` that can pass viewer events. """ from magicgui import magicgui if magic_kwargs is None: magic_kwargs = { 'auto_call': False, 'call_button': "run", 'layout': 'vertical', } widget = magicgui(function, **magic_kwargs or {}) if area is None: if str(widget.layout) == 'vertical': area = 'right' else: area = 'bottom' if allowed_areas is None: allowed_areas = [area] if shortcut is not _sentinel: return self.add_dock_widget( widget, name=name or function.__name__.replace('_', ' '), area=area, allowed_areas=allowed_areas, shortcut=shortcut, ) else: return self.add_dock_widget( widget, name=name or function.__name__.replace('_', ' '), area=area, allowed_areas=allowed_areas, ) def resize(self, width, height): """Resize the window. Parameters ---------- width : int Width in logical pixels. height : int Height in logical pixels. """ self._qt_window.resize(width, height) def show(self): """Resize, show, and bring forward the window. Raises ------ RuntimeError If the viewer.window has already been closed and deleted. """ try: self._qt_window.show() except (AttributeError, RuntimeError): raise RuntimeError( trans._( "This viewer has already been closed and deleted. Please create a new one.", deferred=True, )) if SETTINGS.application.first_time: SETTINGS.application.first_time = False try: self._qt_window.resize(self._qt_window.layout().sizeHint()) except (AttributeError, RuntimeError): raise RuntimeError( trans._( "This viewer has already been closed and deleted. Please create a new one.", deferred=True, )) else: try: if SETTINGS.application.save_window_geometry: self._qt_window._set_window_settings( *self._qt_window._load_window_settings()) except Exception as err: import warnings warnings.warn( trans._( "The window geometry settings could not be loaded due to the following error: {err}", deferred=True, err=err, ), category=RuntimeWarning, stacklevel=2, ) # Resize axis labels now that window is shown self.qt_viewer.dims._resize_axis_labels() # We want to bring the viewer to the front when # A) it is our own event loop OR we are running in jupyter # B) it is not the first time a QMainWindow is being created # `app_name` will be "napari" iff the application was instantiated in # get_app(). isActiveWindow() will be True if it is the second time a # _qt_window has been created. # See #721, #732, #735, #795, #1594 app_name = QApplication.instance().applicationName() if (app_name == 'napari' or in_jupyter()) and self._qt_window.isActiveWindow(): self.activate() def activate(self): """Make the viewer the currently active window.""" self._qt_window.raise_() # for macOS self._qt_window.activateWindow() # for Windows def _update_theme(self, event=None): """Update widget color theme.""" if event: value = event.value SETTINGS.appearance.theme = value self.qt_viewer.viewer.theme = value else: value = self.qt_viewer.viewer.theme try: self._qt_window.setStyleSheet(get_stylesheet(value)) except AttributeError: pass except RuntimeError: # wrapped C/C++ object may have been deleted pass def _status_changed(self, event): """Update status bar. Parameters ---------- event : napari.utils.event.Event The napari event that triggered this method. """ self._status_bar.showMessage(event.value) def _title_changed(self, event): """Update window title. Parameters ---------- event : napari.utils.event.Event The napari event that triggered this method. """ self._qt_window.setWindowTitle(event.value) def _help_changed(self, event): """Update help message on status bar. Parameters ---------- event : napari.utils.event.Event The napari event that triggered this method. """ self._help.setText(event.value) def _screenshot_dialog(self): """Save screenshot of current display with viewer, default .png""" hist = get_save_history() dial = ScreenshotDialog(self.screenshot, self.qt_viewer, hist[0], hist) if dial.exec_(): update_save_history(dial.selectedFiles()[0]) def _restart(self): """Restart the napari application.""" self._qt_window.restart() def screenshot(self, path=None): """Take currently displayed viewer and convert to an image array. Parameters ---------- path : str Filename for saving screenshot image. Returns ------- image : array Numpy array of type ubyte and shape (h, w, 4). Index [0, 0] is the upper-left corner of the rendered region. """ img = self._qt_window.grab().toImage() if path is not None: imsave(path, QImg2array(img)) # scikit-image imsave method return QImg2array(img) def close(self): """Close the viewer window and cleanup sub-widgets.""" # Someone is closing us twice? Only try to delete self._qt_window # if we still have one. if hasattr(self, '_qt_window'): self.qt_viewer.close() self._qt_window.close() del self._qt_window
def _add_file_menu(self): """Add 'File' menu to app menubar.""" open_images = QAction(trans._('Open File(s)...'), self._qt_window) open_images.setShortcut('Ctrl+O') open_images.setStatusTip(trans._('Open file(s)')) open_images.triggered.connect(self.qt_viewer._open_files_dialog) open_stack = QAction(trans._('Open Files as Stack...'), self._qt_window) open_stack.setShortcut('Ctrl+Alt+O') open_stack.setStatusTip(trans._('Open files')) open_stack.triggered.connect( self.qt_viewer._open_files_dialog_as_stack_dialog) open_folder = QAction(trans._('Open Folder...'), self._qt_window) open_folder.setShortcut('Ctrl+Shift+O') open_folder.setStatusTip(trans._('Open a folder')) open_folder.triggered.connect(self.qt_viewer._open_folder_dialog) # OS X will rename this to Quit and put it in the app menu. preferences = QAction(trans._('Preferences'), self._qt_window) preferences.setShortcut('Ctrl+Shift+P') preferences.setStatusTip(trans._('Open preferences dialog')) preferences.setMenuRole(QAction.PreferencesRole) preferences.triggered.connect(self._open_preferences) save_selected_layers = QAction(trans._('Save Selected Layer(s)...'), self._qt_window) save_selected_layers.setShortcut('Ctrl+S') save_selected_layers.setStatusTip(trans._('Save selected layers')) save_selected_layers.triggered.connect( lambda: self.qt_viewer._save_layers_dialog(selected=True)) save_all_layers = QAction(trans._('Save All Layers...'), self._qt_window) save_all_layers.setShortcut('Ctrl+Shift+S') save_all_layers.setStatusTip(trans._('Save all layers')) save_all_layers.triggered.connect( lambda: self.qt_viewer._save_layers_dialog(selected=False)) screenshot = QAction(trans._('Save Screenshot...'), self._qt_window) screenshot.setShortcut('Alt+S') screenshot.setStatusTip( trans._('Save screenshot of current display, default .png')) screenshot.triggered.connect(self.qt_viewer._screenshot_dialog) screenshot_wv = QAction(trans._('Save Screenshot with Viewer...'), self._qt_window) screenshot_wv.setShortcut('Alt+Shift+S') screenshot_wv.setStatusTip( trans. _('Save screenshot of current display with the viewer, default .png' )) screenshot_wv.triggered.connect(self._screenshot_dialog) # OS X will rename this to Quit and put it in the app menu. # This quits the entire QApplication and all windows that may be open. quitAction = QAction(trans._('Exit'), self._qt_window) quitAction.setShortcut('Ctrl+Q') quitAction.setMenuRole(QAction.QuitRole) quitAction.triggered.connect( lambda: self._qt_window.close(quit_app=True)) if running_as_bundled_app(): restartAction = QAction(trans._('Restart'), self._qt_window) restartAction.triggered.connect(self._qt_window.restart) closeAction = QAction(trans._('Close Window'), self._qt_window) closeAction.setShortcut('Ctrl+W') closeAction.triggered.connect(self._qt_window.close_window) plugin_manager.discover_sample_data() open_sample_menu = QMenu(trans._('Open Sample'), self._qt_window) for plugin_name, samples in plugin_manager._sample_data.items(): multiprovider = len(samples) > 1 if multiprovider: menu = QMenu(plugin_name, self._qt_window) open_sample_menu.addMenu(menu) else: menu = open_sample_menu for samp_name, samp_dict in samples.items(): display_name = samp_dict['display_name'] if multiprovider: action = QAction(display_name, parent=self._qt_window) else: full_name = plugin_menu_item_template.format( plugin_name, display_name) action = QAction(full_name, parent=self._qt_window) def _add_sample(*args, plg=plugin_name, smp=samp_name): self.qt_viewer.viewer.open_sample(plg, smp) menu.addAction(action) action.triggered.connect(_add_sample) self.file_menu = self.main_menu.addMenu(trans._('&File')) self.file_menu.addAction(open_images) self.file_menu.addAction(open_stack) self.file_menu.addAction(open_folder) self.file_menu.addMenu(open_sample_menu) self.file_menu.addSeparator() self.file_menu.addAction(preferences) self.file_menu.addSeparator() self.file_menu.addAction(save_selected_layers) self.file_menu.addAction(save_all_layers) self.file_menu.addAction(screenshot) self.file_menu.addAction(screenshot_wv) self.file_menu.addSeparator() self.file_menu.addAction(closeAction) if running_as_bundled_app(): self.file_menu.addAction(restartAction) self.file_menu.addAction(quitAction)
class PMGFilesTreeview(QTreeView): """ 文件树 """ open_signal = Signal(str) open_folder_signal = Signal(str) new_file_signal = Signal(str) new_folder_signal = Signal(str) delete_file_signal = Signal(str) rename_file_signal = Signal(str, str) signal_ext_filter_adapt = Signal(bool) signal_ext_filter_changed = Signal(dict) def __init__(self, initial_dir: str = '', parent=None): super().__init__(parent) self.initial_dir = initial_dir self.setup_ui() self.bind_events() self.filter_exts = True self.exts_to_filter = { 'Program Scripts': { '.pyx': True, '.py': True, '.c': True, '.pyi': True, '.dll': True, '.h': True, '.cpp': True, '.ipynb': True, '.sh': True, '.cmd': True, '.bat': True }, 'Documents': { '.txt': True, '.md': True, '.doc': True, '.docx': True, '.ppt': True, '.pptx': True, '.html': True }, 'Data Files': { '.csv': True, '.xls': True, '.xlsx': True, '.tab': True, '.dat': True, '.tsv': True, '.sav': True, '.zsav': True, '.sas7bdat': True, '.pkl': True, '.json': True, '.mat': True, '.pmjson': True, '.pmd': True }, 'Medias': { '.mp3': False, '.mp4': False, '.avi': False, '.wma': False, '.png': True, '.jpg': True, '.svg': True }, 'Resources': { '.qm': True, '.ts': True } } def setup_ui(self): """ 界面初始化 :return: """ self.translator = create_translator(path=os.path.join( os.path.dirname(__file__), 'translations', 'qt_{0}.qm'.format(QLocale.system().name()))) # translator self.setTabKeyNavigation(True) self.setDragEnabled(True) self.setDragDropOverwriteMode(True) self.setAlternatingRowColors(False) self.setUniformRowHeights(True) self.setSortingEnabled(True) self.setAnimated(True) self.setAllColumnsShowFocus(False) self.setWordWrap(False) self.setHeaderHidden(False) self.setObjectName("treeView_files") self.header().setSortIndicatorShown(True) self.model = PMFileSystemModel() self.model.setRootPath(self.initial_dir) self.setModel(self.model) self.setRootIndex(self.model.index(self.initial_dir)) self.setAnimated(False) self.setSortingEnabled(True) # 启用排序 self.header().setSortIndicatorShown(True) # 启用标题排序 self.setContextMenuPolicy(Qt.CustomContextMenu) self.customContextMenuRequested.connect(self.show_context_menu) self.init_context_menu() def bind_events(self): """ 回调、事件与信号初始化 :return: """ self.doubleClicked.connect(lambda index: self.on_open()) self.openAction.triggered.connect(self.on_open) self.importAction.triggered.connect(self.on_import) self.renameAction.triggered.connect(self.on_rename) self.deleteAction.triggered.connect(self.on_delete) self.copyAction.triggered.connect(self.on_copy) self.pasteAction.triggered.connect(self.on_paste) self.filterAction.triggered.connect( self.show_ext_filter_selection_dialog) self.copyPathAction.triggered.connect(self.copy_path) self.new_file_action.triggered.connect(lambda: self.on_new_file('')) self.new_python_file_action.triggered.connect( lambda: self.on_new_file('py')) self.new_folder_action.triggered.connect(self.on_new_folder) self.open_file_manager_action.triggered.connect( self.on_open_file_manager) self.rename_shortcut.activated.connect(self.on_rename) self.paste_shortcut.activated.connect(self.on_paste) self.copy_shortcut.activated.connect(self.on_copy) self.open_shortcut.activated.connect(self.on_open) self.delete_shortcut.activated.connect(self.on_delete) self.goto_parent_path_shortcut.activated.connect( self.slot_goto_parent_path) self.customContextMenuRequested.connect(self.show_context_menu) def init_context_menu(self): """ 初始化右键菜单 :return: """ self.contextMenu = QMenu(self) self.openAction = self.contextMenu.addAction(self.tr('Open')) self.importAction = self.contextMenu.addAction(self.tr('Import')) self.importAction.setEnabled(False) self.new_file_or_folder_menu = QMenu(self.tr('New..')) self.contextMenu.addMenu(self.new_file_or_folder_menu) self.new_file_action = self.new_file_or_folder_menu.addAction( self.tr('File..')) self.new_python_file_action = self.new_file_or_folder_menu.addAction( self.tr('Python File')) self.new_folder_action = self.new_file_or_folder_menu.addAction( self.tr('Folder')) self.new_file_or_folder_menu.addSeparator() self.copyAction = self.contextMenu.addAction(self.tr("Copy")) self.pasteAction = self.contextMenu.addAction(self.tr("Paste")) self.pasteAction.setEnabled(False) self.renameAction = self.contextMenu.addAction(self.tr('Rename')) self.deleteAction = self.contextMenu.addAction(self.tr('Delete')) self.filterAction = self.contextMenu.addAction(self.tr('Filter')) self.copyPathAction = self.contextMenu.addAction(self.tr('Copy Path')) self.open_file_manager_action = self.contextMenu.addAction( self.tr('Open Explorer')) self.renameAction.setShortcut(QKeySequence('F2')) self.copyAction.setShortcut(QKeySequence('Ctrl+C')) self.pasteAction.setShortcut(QKeySequence('Ctrl+V')) self.deleteAction.setShortcut(QKeySequence('Delete')) self.rename_shortcut = QShortcut(QKeySequence('F2'), self, context=Qt.WidgetShortcut) self.copy_shortcut = QShortcut(QKeySequence.Copy, self, context=Qt.WidgetShortcut) self.paste_shortcut = QShortcut(QKeySequence.Paste, self, context=Qt.WidgetShortcut) self.delete_shortcut = QShortcut(QKeySequence('Delete'), self, context=Qt.WidgetShortcut) self.open_shortcut = QShortcut(QKeySequence('Return'), self, context=Qt.WidgetShortcut) self.goto_parent_path_shortcut = QShortcut(QKeySequence('Backspace'), self, context=Qt.WidgetShortcut) def show_context_menu(self): """ 显示上下文右键菜单 :return: """ self.contextMenu.popup(QCursor.pos()) self.contextMenu.show() def get_current_file_path(self): """ 获取当前选中文件的路径。 如果当前没有选中的文件,就返回根路径。 :return: """ if len(self.selectedIndexes()) > 0: index = self.currentIndex() file_info = self.model.fileInfo(index) return file_info.absoluteFilePath() else: return self.get_root_path() def get_root_path(self): """ 获取根路径 :return: """ return self.model.rootPath() def set_item_focus(self, file_path: str): """ set item focus in TreeView :param file_path: File or Dir :return: """ self.setCurrentIndex(self.model.index(file_path)) def on_open_file_manager(self): path = self.get_current_file_path() print(path) if os.path.isdir(path): open_file_manager(path) else: open_file_manager(os.path.dirname(path)) # if os.path.exists(new_folder_path): # self.set_item_focus(new_folder_path) # 设置focus liugang 200923 # QMessageBox.critical(self, self.tr('Error'), # self.tr('Folder %s already exists!' % name)) # return # else: # os.mkdir(new_folder_path) # self.new_folder_signal[str].emit(new_folder_path) # self.set_item_focus(new_folder_path) # 设置focus liugang 200923 def on_new_folder(self): """ 新建文件夹时出发的回调 :return: """ path = self.get_current_file_path() name, stat = QInputDialog.getText(self, self.tr('Please Input folder name'), '', QLineEdit.Normal, '') if name.find('.') != -1: QMessageBox.critical(self, self.tr('Error'), self.tr('Folder name %s is illeagal!' % name)) return if stat: if os.path.isdir(path): new_folder_path = os.path.join(path, name) else: new_folder_path = os.path.join(os.path.dirname(path), name) if os.path.exists(new_folder_path): self.set_item_focus(new_folder_path) # 设置focus liugang 200923 QMessageBox.critical( self, self.tr('Error'), self.tr('Folder %s already exists!' % name)) return else: os.mkdir(new_folder_path) self.new_folder_signal[str].emit(new_folder_path) self.set_item_focus(new_folder_path) # 设置focus liugang 200923 def on_new_file(self, ext: str = ''): """ 新建文件时触发的回调 :return: """ path = self.get_current_file_path() dlg = InputFilenameDialog(parent=self, title=self.tr('Please input file name'), ext=ext) dlg.exec_() name = dlg.name_input.text() stat = dlg.status if stat: if os.path.isdir(path): new_file_path = os.path.join(path, name) else: new_file_path = os.path.join(os.path.dirname(path), name) if os.path.exists(new_file_path): self.set_item_focus(new_file_path) # 设置focus liugang 200923 QMessageBox.critical(self, self.tr('Error'), self.tr('File %s already exists!' % name)) return with open(new_file_path, 'wb') as f: f.close() self.new_file_signal[str].emit(new_file_path) self.set_item_focus(new_file_path) self.on_open() # 创建文件后打开 liugang 200923 def on_open(self): """ 点击‘open’时候触发的回调, 等效的方式还有双击以及按下回车键。 :return: """ path = self.get_current_file_path() if os.path.isdir(path): self.open_folder_signal.emit(path) else: self.open_signal[str].emit(path) def on_import(self): """ :return: """ pass def on_rename(self): """ 点击’重命名‘时候的回调。 :return: """ from pmgwidgets import rename_file path = self.get_current_file_path() basename = os.path.basename(path) dir_name = os.path.dirname(path) name, stat = QInputDialog.getText(self, self.tr('Please Input file name'), '', QLineEdit.Normal, basename) if stat: new_absolute_path = os.path.join(dir_name, name) rename_result = rename_file(path, new_absolute_path) if not rename_result: QMessageBox.critical(self, self.tr('Error'), self.tr('Unable to Rename this file.')) else: self.rename_file_signal[str, str].emit(path, new_absolute_path) def on_delete(self): """ 点击’删除‘时的回调 :return: """ from pmgwidgets import move_to_trash path = self.get_current_file_path() moved_successful = move_to_trash(path) if not moved_successful: QMessageBox.critical( self, self.tr('Error'), self.tr('Unable to Move this file to recycle bin.')) else: self.delete_file_signal[str].emit(path) def on_copy(self): """ copy file or dir , save path in pasteAction data. :return: """ path = self.get_current_file_path() self.pasteAction.setEnabled(True) self.pasteAction.setData(path) data = QMimeData() data.setUrls([QUrl.fromLocalFile(path)]) # 复制到系统剪贴板 clip = QApplication.clipboard() clip.setMimeData(data) def on_paste(self): """ Paste file or dir in pasteAction data :return: """ from pmgwidgets import copy_paste path = self.get_current_file_path() target_dir_name = path if os.path.isdir(path) else os.path.dirname( path) url: QUrl = None mimedata = QApplication.clipboard().mimeData(mode=QClipboard.Clipboard) print(mimedata) urls: List[QUrl] = mimedata.urls() for url in urls: source_path = url.toLocalFile() # self.pasteAction.data() # File if os.path.isfile(source_path): source_file_name = os.path.basename(source_path) # if exist ,rename to copy_xxx if os.path.isfile( os.path.join(target_dir_name, source_file_name)): target_file_name = "copy_{0}".format(source_file_name) else: target_file_name = source_file_name target_path = os.path.join(target_dir_name, target_file_name) # Directory else: last_dir_name = os.path.split(source_path)[-1] # if exist , rename dir copy_xxxx if os.path.isdir(os.path.join(target_dir_name, last_dir_name)): target_name = "copy_{0}".format(last_dir_name) else: target_name = last_dir_name target_path = os.path.join(target_dir_name, target_name) copy_succ = copy_paste(source_path, target_path) if not copy_succ: QMessageBox.critical(self, self.tr('Error'), self.tr('Copy File or Directory Error.')) else: self.set_item_focus(target_path) def show_ext_filter_selection_dialog(self): self.dlg = QDialog(self) self.dlg.setWindowTitle(self.tr('Extension Name To Show')) self.dlg.setLayout(QVBoxLayout()) self.dlg.layout().addWidget(QLabel('过滤文件名')) check_box = QCheckBox() self.dlg.check_box = check_box check_box.setChecked(self.filter_exts) self.dlg.layout().addWidget(check_box) check_box.stateChanged.connect( lambda stat: self.signal_ext_filter_adapt.emit(stat)) check_widget = PMCheckTree(data=self.exts_to_filter) self.dlg.check_widget = check_widget self.dlg.layout().addWidget(check_widget) buttonBox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) buttonBox.accepted.connect(self.on_ext_filter_changed) buttonBox.rejected.connect(self.dlg.deleteLater) # 清除选择功能不完善目前禁用 # button_clear = buttonBox.addButton(self.tr('Clear Filter'), QDialogButtonBox.ApplyRole) # button_clear.clicked.connect(self.clear_ext_filter) self.dlg.layout().addWidget(buttonBox) self.dlg.exec_() def on_ext_filter_changed(self): """ 当扩展名过滤改变的时候。 :return: """ self.exts_to_filter = self.dlg.check_widget.get_data() self.filter_exts = self.dlg.check_box.isChecked() self.update_ext_filter() self.dlg.deleteLater() self.signal_ext_filter_changed.emit(self.exts_to_filter) def clear_ext_filter(self): self.set_ext_filter(None) self.dlg.deleteLater() def update_ext_filter(self): """ 刷新扩展名过滤。 :return: """ ext_list = [] for key in self.exts_to_filter.keys(): for name in self.exts_to_filter[key].keys(): if self.exts_to_filter[key][name]: ext_list.append('*' + name) self.set_ext_filter(ext_list) def set_ext_filter(self, ext_names: List[str]): """ 文件名过滤 例如要过滤出.py和.pyx文件,就是ext_names=['*.py','*.pyx'] discard功能不太完善,目前先禁用。 :param ext_names: :return: """ if ext_names is not None and self.filter_exts: self.model.setNameFilterDisables(False) self.model.setNameFilters(ext_names) else: self.model.setNameFilterDisables(True) self.model.setNameFilters(["*"]) def slot_goto_parent_path(self): """ Returns: """ root = self.get_root_path() parent = os.path.dirname(root) if os.path.exists(parent): pass self.open_folder_signal.emit(parent) def copy_path(self): """ 复制当前文件的路径的回调 Returns: """ path = self.get_current_file_path() # data = QMimeData() clipboard = QApplication.clipboard() clipboard.setText(path)
class Q7Tree(Q7Window, Ui_Q7TreeWindow): def __init__(self, control, path, fgprintindex): Q7Window.__init__(self, Q7Window.VIEW_TREE, control, path, fgprintindex) self._depthExpanded = 0 self._lastEntered = None self.lastdiag = None self._linkwindow = None self._querywindow = None self._vtkwindow = None self._selectwindow = None self._column = {NMT.COLUMN_SIDS: OCTXT.ShowSIDSColumn, NMT.COLUMN_FLAG_LINK: OCTXT.ShowLinkColumn, NMT.COLUMN_FLAG_SELECT: OCTXT.ShowSelectColumn, NMT.COLUMN_FLAG_CHECK: OCTXT.ShowCheckColumn, NMT.COLUMN_FLAG_USER: OCTXT.ShowUserColumn, NMT.COLUMN_SHAPE: OCTXT.ShowShapeColumn, NMT.COLUMN_DATATYPE: OCTXT.ShowDataTypeColumn} self.selectForLinkSrc = None # one link source per tree view allowed #self.treeview.expanded[QModelIndex].connect(self.expandNode) self.treeview.collapsed.connect(self.collapseNode) self.treeview.pressed[QModelIndex].connect(self.clickedPressedNode) self.treeview.customContextMenuRequested.connect(self.clickedNode) # QObject.connect(self.treeview, # SIGNAL("expanded(QModelIndex)"), # self.expandNode) # QObject.connect(self.treeview, # SIGNAL("collapsed()"), # self.collapseNode) # QObject.connect(self.treeview, # SIGNAL("pressed(QModelIndex)"), # self.clickedPressedNode) # QObject.connect(self.treeview, # SIGNAL("customContextMenuRequested(QPoint)"), # self.clickedNode) self.bSave.clicked.connect(self.savetree) self.lockable(self.bSave) self.bQueryView.clicked.connect(self.queryview) self.lockable(self.bQueryView) self.bSaveAs.clicked.connect(self.savetreeas) self.lockable(self.bSaveAs) self.bInfo.clicked.connect(self.infoTreeView) self.bZoomIn.clicked.connect(self.expandLevel) self.bZoomOut.clicked.connect(self.collapseLevel) self.bZoomAll.clicked.connect(self.expandMinMax) self.bFormView.clicked.connect(self.formview) self.bMarkAll.clicked.connect(self.markall) self.bUnmarkAll_1.clicked.connect(self.unmarkall) self.bUnmarkAll_2.clicked.connect(self.unmarkall) self.bPreviousMark.clicked.connect(self.previousmark) self.bNextMark.clicked.connect(self.nextmark) self.bSwapMarks.clicked.connect(self.swapmarks) self.bMarksAsList.clicked.connect(self.selectionlist) self.bVTKView.clicked.connect(self.vtkview) self.lockable(self.bVTKView) self.bScreenShot.clicked.connect(self.screenshot) self.bCheck.clicked.connect(self.check) self.bCheckList.clicked.connect(self.checklist) self.bClearChecks.clicked.connect(self.clearchecks) self.bLinkView.clicked.connect(self.linklist) self.bPatternView.clicked.connect(self.patternlist) self.bToolsView.clicked.connect(self.tools) self.setContextMenuPolicy(Qt.CustomContextMenu) self.popupmenu = QMenu() self.diagview = None lmodel = self.FG.model self.treeview.setModel(lmodel) self.treeview.setItemDelegate(Q7TreeItemDelegate(self.treeview, lmodel)) self.treeview.setControlWindow(self, self.FG.index) if (self._control.transientRecurse or OCTXT.RecursiveTreeDisplay): self.expandMinMax() if (self._control.transientVTK): self.vtkview() self._control.transientRecurse = False self._control.transientVTK = False self.clearchecks() # self.bCheckList.setDisabled(True) if (not OCTXT._HasProPackage): self.bToolsView.setDisabled(True) self.bCheckView.setDisabled(True) self.bPatternDB.setDisabled(True) self.bAddLink.clicked.connect(self.linkadd) self.bSelectLinkSrc.clicked.connect(self.linkselectsrc) self.bSelectLinkDst.clicked.connect(self.linkselectdst) self.bAddLink.setDisabled(True) self.lineEdit.returnPressed.connect(self.jumpToNode) # QObject.connect(self.lineEdit, # SIGNAL("returnPressed()"), # self.jumpToNode) tvh = self.treeview.header() tvh.setContextMenuPolicy(Qt.CustomContextMenu) tvh.customContextMenuRequested.connect(self.headerMenu) self._hmenu = QMenu() self._hmenu._idx = {} self._tlist = (('SIDS type', NMT.COLUMN_SIDS), ('Link flag', NMT.COLUMN_FLAG_LINK), ('Mark flag', NMT.COLUMN_FLAG_SELECT), ('Check flag', NMT.COLUMN_FLAG_CHECK), ('User flag', NMT.COLUMN_FLAG_USER), ('Shape', NMT.COLUMN_SHAPE), ('Data type', NMT.COLUMN_DATATYPE)) for (tag, idx) in self._tlist: a = QAction(tag, self._hmenu, checkable=True) self._hmenu._idx[idx] = a if (self._column[idx]): a.setChecked(True) else: a.setChecked(False) self._hmenu.addAction(a) self.treeview.setColumnHidden(idx, not self._column[idx]) self._recursiveAddNewNode = False self.updateTreeStatus() def headerMenu(self, pos): for (tag, idx) in self._tlist: self._hmenu._idx[idx].setChecked(self._column[idx]) self._hmenu.exec_(self.treeview.mapToGlobal(pos)) for (tag, idx) in self._tlist: if (self._hmenu._idx[idx].isChecked()): self._column[idx] = True else: self._column[idx] = False self.treeview.setColumnHidden(idx, not self._column[idx]) def model(self): return self.FG.model def modelIndex(self, idx): if not idx.isValid(): return -1 midx = idx if idx.model() != self.treeview.M(): midx = self.treeview.model().mapToSource(idx) return midx def modelData(self, idx): if not idx.isValid(): return None return self.modelIndex(idx).internalPointer() def savetree(self): if (not (self.FG.isSaveable() and self.FG.isModified())): return self._control.savedirect(self.FG) self.updateTreeStatus() def tools(self): from CGNS.NAV.wtools import Q7ToolsView if (self._control._toolswindow is None): self._control._toolswindow = Q7ToolsView(self._control, self.FG, self) self._control._toolswindow.show() else: self._control._toolswindow.raise_() def savetreeas(self): self._control.save(self.FG) self.updateTreeStatus() def infoTreeView(self): self._control.helpWindow('Tree') def screenshot(self): self.treeview.model().sort(0) sshot = QScreen.grabWindow(self.treeview.winId()) sshot.save('/tmp/foo.png', 'png') def expandMinMax(self): if (self._depthExpanded == self.FG.depth - 2): self._depthExpanded = -1 self.treeview.collapseAll() else: self._depthExpanded = self.FG.depth - 2 self.treeview.expandAll() self.resizeAll() def resetOptions(self): if (OCTXT.AutoExpand): self.treeview.setAutoExpandDelay(1000) else: self.treeview.setAutoExpandDelay(-1) def expandLevel(self): if (self._depthExpanded < self.FG.depth - 2): self._depthExpanded += 1 self.treeview.expandToDepth(self._depthExpanded) self.resizeAll() def collapseLevel(self): if (self._depthExpanded != -1): self._depthExpanded -= 1 if (self._depthExpanded == -1): self.treeview.collapseAll() else: self.treeview.expandToDepth(self._depthExpanded) self.resizeAll() def updateStatus(self, node): if (not self.lineEditLock.isChecked()): self.lineEdit.clear() self.lineEdit.insert(node.sidsPath()) def jumpToNode(self): path = self.lineEdit.text() self.treeview.selectByPath(path) def popform(self): self.formview() def openLkTree(self): self.busyCursor() filename = self.getLastEntered().sidsLinkFilename() if (filename is not None): self._control.loadfile(filename) self.readyCursor() def openSubTree(self): self.busyCursor() node = self.getLastEntered().sidsPath() child = Q7Tree(self._control, node, self.FG) self.readyCursor() child.show() def pop0(self): pass def newnodebrother(self): if (self.getLastEntered() is not None): self.model().newNodeBrother(self.getLastEntered()) def newnodechild(self): if (self.getLastEntered() is not None): self.model().newNodeChild(self.getLastEntered()) def marknode(self): if (self.getLastEntered() is not None): self.treeview.markNode(self.getLastEntered()) def mcopy(self): if (self.getLastEntered() is not None): self.model().copyNode(self.getLastEntered()) self.clearOtherSelections() def mcutselected(self): self.model().cutAllSelectedNodes() self.clearLastEntered() self.clearOtherSelections() def mcut(self): if (self.getLastEntered() is not None): self.model().cutNode(self.getLastEntered()) self.clearLastEntered() self.clearOtherSelections() def mpasteasbrotherselected(self): self.model().pasteAsBrotherAllSelectedNodes() def mpasteasbrother(self): if (self.getLastEntered() is not None): self.model().pasteAsBrother(self.getLastEntered()) def mpasteaschildselected(self): self.model().pasteAsChildAllSelectedNodes() def mpasteaschild(self): if (self.getLastEntered() is not None): self.model().pasteAsChild(self.getLastEntered()) def updateMenu(self, nodeidxs): nodeidx = self.modelIndex(nodeidxs) if (not nodeidx.isValid): return False if (nodeidx.internalPointer() is None): return False if (nodeidx.internalPointer().sidsPath() == '/CGNSTree'): return False self.setLastEntered(nodeidxs) if (nodeidx != -1): node = nodeidx.internalPointer() lknode = not node.sidsIsLink() lznode = node.hasLazyLoad() actlist = ( ("%s goodies" % node.sidsType(),), None, ("Expand sub-tree from this node", self.expand_sb, 'Ctrl++', False), ("Collapses sub-tree from this node", self.collapse_sb, 'Ctrl+-', False), None, ['Mark nodes...',[ ("Mark/unmark node", self.marknode, 'Space', False), None, ("Mark all nodes same SIDS type", self.marknode_t, 'Ctrl+1', False), ("Mark all nodes same name", self.marknode_n, 'Ctrl+2', False), ("Mark all nodes same value", self.marknode_v, 'Ctrl+3', False), None, ("Mark parent path", self.marknode_p, 'Ctrl+4', False)]], ("Add new child node", self.newnodechild, 'Ctrl+A', False), ("Add new brother node", self.newnodebrother, 'Ctrl+Z', False), # None, # ("Open form",self.popform,'Ctrl+F',False), # ("Open view",self.openSubTree,'Ctrl+W',False), # ("Open view on linked-to file",self.openLkTree,'Ctrl+O',lknode), None, ("Load node data in memory", self.dataLoad, 'Ctrl+L', not lznode), ("Release memory node data", self.dataRelease, 'Ctrl+R', lznode), None, ("Copy current", self.mcopy, 'Ctrl+C', False), ("Cut current", self.mcut, 'Ctrl+X', False), ("Paste as brother", self.mpasteasbrother, 'Ctrl+V', False), ("Paste as child", self.mpasteaschild, 'Ctrl+Y', False), None, ['On selected nodes...',[ ("Expand sub-tree from all selected nodes", self.sexpand_sb, 'Ctrl+Shift++', False), ("Collapses sub-tree from all selected nodes", self.scollapse_sb, 'Ctrl+Shift+-', False), None, ("Cut all selected", self.mcutselected, 'Ctrl+Shift+X', False), ("Paste as brother for each selected", self.mpasteasbrotherselected, 'Ctrl+Shift+V', False), ("Paste as child for each selected", self.mpasteaschildselected, 'Ctrl+Shift+Y', False), None, ("Load nodes data in memory for each selected", self.dataLoadSelected, 'Ctrl+Shift+L', False), ("Release memory node data for each selected", self.dataReleaseSelected, 'Ctrl+Shift+R', False)]], ) self.popupmenu.clear() self.popupmenu.setTitle('Node menu') for aparam in actlist: if (aparam is None): self.popupmenu.addSeparator() elif (len(aparam) == 1): stp = node.sidsType() tag = '_GM_{}'.format(stp) subm = self.popupmenu.addMenu('{}...'.format(stp)) a = QAction("About %s" % node.sidsType(), self, triggered=self.aboutSIDS) subm.addAction(a) patmenu = subm.addMenu('Insert pattern') self.patternMenu(patmenu, node.sidsNode()) subm.addSeparator() if (hasattr(self, tag)): getattr(self, tag)(subm, node) else: if isinstance(aparam,list): subm = self.popupmenu.addMenu(aparam[0]) for aaparam in aparam[1]: if (aaparam is None): subm.addSeparator() else: a = QAction(aaparam[0], self, triggered=aaparam[1]) if (aaparam[2] is not None): a.setShortcut(aaparam[2]) subm.addAction(a) a.setDisabled(aaparam[3]) else: a = QAction(aparam[0], self, triggered=aparam[1]) if (aparam[2] is not None): a.setShortcut(aparam[2]) self.popupmenu.addAction(a) a.setDisabled(aparam[3]) return True def _runAndSelect(self, qname, value): q = Q7Query.getQuery(qname) sl = q.run(self.FG.tree, self.FG.links, list(self.FG.lazy), False, value) self.model().markExtendToList(sl) self.model().updateSelected() self.treeview.refreshView() def patternMenu(self, menu, node): a = QAction("Recursive sub-pattern add", self, checkable=True) menu.addAction(a) a.setChecked(self._recursiveAddNewNode) menu.addSeparator() for t in [n[0] for n in CGU.getAuthChildren(node)]: def genCopyPattern(arg): def copyPattern(): self.model().copyNodeRaw(CGS.profile[arg][0]) if (self.getLastEntered() is not None): self.model().pasteAsChild(self.getLastEntered()) return copyPattern a = QAction("{}".format(t), self, triggered=genCopyPattern(t)) menu.addAction(a) def _gm_family_1(self, node): self._runAndSelect('013. FamilyName reference', "'%s'" % node.sidsName()) def _gm_family_2(self, node): self._runAndSelect('003. Node type', "'Family_t'") def _GM_Family_t(self, m, node): a = QAction('Select references to myself', self) a.triggered.connect(functools.partial(self._gm_family_1, node)) m.addAction(a) a = QAction('Select all families', self) a.triggered.connect(functools.partial(self._gm_family_2, node)) m.addAction(a) m.addSeparator() return True def _GM_IndexRange_t(self, m, node): if (node.sidsName() != CGK.ElementRange_s): v = 0 a = QAction('Range size: %d' % (v), self) m.addAction(a) else: v = node.sidsValue()[1] - node.sidsValue()[0] etp = CGU.getEnumAsString(node.sidsParent()) a = QAction('Number of elements of type [%s]: %d' % (etp, v), self) m.addAction(a) return True def _GM_Elements_t(self, m, node): etp = CGU.getEnumAsString(node.sidsNode()) npe = CGK.ElementTypeNPE[etp] a = QAction('Element type [%s] npe [%d]' % (etp, npe), self) m.addAction(a) return True def marknode_t(self): node = self.getLastEntered() self._runAndSelect('003. Node type', "'%s'" % node.sidsType()) def marknode_n(self): node = self.getLastEntered() self._runAndSelect('001. Node name', "'%s'" % node.sidsName()) def marknode_v(self): node = self.getLastEntered() value = node.sidsValue() self._runAndSelect('005. Node value', value) def marknode_p(self): node = self.getLastEntered() node.switchMarked() path = node.sidsPath() while path is not None: path = CGU.getPathAncestor(path) if (path not in ['/', None]): node = self.model().nodeFromPath('/CGNSTree' + path) node.switchMarked() self.model().updateSelected() def setLastEntered(self, nix=None): if ((nix is None) or (not nix.isValid())): nix = self.treeview.modelCurrentIndex() self._lastEntered = None if (nix.isValid()): self.treeview.exclusiveSelectRow(nix, False) self._lastEntered = self.modelData(nix) def getLastEntered(self): return self._lastEntered def clearLastEntered(self): self._lastEntered = None self.treeview.selectionModel().clearSelection() return None def clearOtherSelections(self): if (self._control._patternwindow is not None): self._control._patternwindow.clearSelection() def clickedPressedNode(self, index): self.clickedNode(index) def clickedNode(self, index): self.treeview.exclusiveSelectRow(index) if (self.treeview.lastButton == Qt.RightButton): if (self.updateMenu(index)): self.popupmenu.popup(self.treeview.lastPos) def expandNode(self, *args): self.resizeAll() def collapseNode(self, *args): pass def expand_sb(self): self.treeview.expand_sb() def collapse_sb(self): self.treeview.collapse_sb() def sexpand_sb(self): self.treeview.sexpand_sb() def scollapse_sb(self): self.treeview.scollapse_sb() def resizeAll(self): for n in range(NMT.COLUMN_LAST + 1): self.treeview.resizeColumnToContents(n) def show(self): super(Q7Tree, self).show() def linkselectsrc(self): if (self.bSelectLinkSrc.isChecked()): if (self.getLastEntered() is None): return self.bAddLink.setDisabled(False) node = self.getLastEntered() self.selectForLinkSrc = (node, node.sidsPath()) else: self.bAddLink.setDisabled(True) self.selectForLinkSrc = None def linkselectdst(self): if (self.getLastEntered() is None): return node = self.getLastEntered() if (node is None): return if (node.sidsIsLink()): return if (node.sidsType() == CGK.CGNSTree_ts): return if (self._control.selectForLinkDst is not None): bt = self._control.selectForLinkDst[-1].bSelectLinkDst bt.setChecked(Qt.Unchecked) if (self._control.selectForLinkDst[-1] == self): self._control.selectForLinkDst = None return self._control.selectForLinkDst = (node, node.sidsPath(), self.FG.filedir, self.FG.filename, self) self.bSelectLinkDst.setChecked(Qt.Checked) if (self._linkwindow is not None): n = node.sidsPath() d = self.FG.filedir f = self.FG.filename self._linkwindow.updateSelected(d, f, n) def linkadd(self): if (self._control.selectForLinkDst is None): return dst = self._control.selectForLinkDst str_dst = "%s:%s" % (dst[3], dst[1]) tpath = 'relative' newname = CGU.getPathLeaf(dst[1]) if (CGU.checkDuplicatedName(self.selectForLinkSrc[0].sidsNode(), newname, dienow=False)): str_cnm = "New child node name is <b>%s</b>" % newname else: count = 0 while (not CGU.checkDuplicatedName(self.selectForLinkSrc[0].sidsNode(), newname, dienow=False)): count += 1 newname = '{%s#%.3d}' % (dst[0].sidsType(), count) str_cnm = """As a child with this name already exists, the name <b>%s</b> is used (generated name)""" % \ newname str_src = "%s:%s/%s" % (self.FG.filename, self.selectForLinkSrc[1], newname) str_msg = "you want to create a link from <b>%s</b> to <b>%s</b><br>%s<br>Your current user options do force " \ "the link to use <b>%s</b> destination file path.""" % ( str_src, str_dst, str_cnm, tpath) reply = MSG.wQuestion(self, 231, 'Create link as a new node', str_msg) def linklist(self): if (self._linkwindow is None): self._linkwindow = Q7LinkList(self._control, self.FG.index, self) self._linkwindow.show() else: self._linkwindow.raise_() def patternlist(self): if (self._control._patternwindow is None): self._control._patternwindow = Q7PatternList(self._control, self.FG) self._control._patternwindow.show() self._control._patternwindow.raise_() def check(self): self.busyCursor() if (self.diagview is not None): self.diagview.close() self.diagview = None self.lastdiag = self.model().checkSelected() self.readyCursor() self.treeview.refreshView() self.bCheckList.setDisabled(False) def checklist(self): if (self.lastdiag is None): return self.diagview = Q7CheckList(self, self.lastdiag, self.FG.index) self.diagview.show() def clearchecks(self): self.model().checkClear() self.treeview.refreshView() self.lastdiag = None self.bCheckList.setDisabled(True) def selectionlist(self): if (self._selectwindow is not None): self._selectwindow.close() self._selectwindow = None self._selectwindow = Q7SelectionList(self, self.model(), self.FG.index) self._selectwindow.show() self._selectwindow.raise_() def previousmark(self): self.treeview.changeSelectedMark(-1) def nextmark(self): self.treeview.changeSelectedMark(+1) def markall(self): self.model().markAll() self.model().updateSelected() self.treeview.refreshView() def unmarkall(self): self.model().unmarkAll() self.model().updateSelected() self.treeview.refreshView() def swapmarks(self): self.model().swapMarks() self.model().updateSelected() self.treeview.refreshView() def formview(self): ix = self.treeview.modelCurrentIndex() node = self.modelData(ix) if (node is None): MSG.wInfo(self, 254, "Form view:", """You have to select a node to open its form view""", again=False) return if (node.sidsType() == CGK.CGNSTree_ts): return form = Q7Form(self._control, node, self.FG.index) form.show() def vtkview(self): if (not HAS_VTK): return from CGNS.NAV.wvtk import Q7VTK if (self._vtkwindow is None): self.busyCursor() ix = self.treeview.modelCurrentIndex() zlist = self.model().getSelectedZones() node = self.modelData(ix) self._vtkwindow = Q7VTK(self._control, self, node, self.FG.index, self.model(), zlist) if (self._vtkwindow._vtkstatus): self._vtkwindow.show() else: self._vtkwindow.close() self._vtkwindow = None self.readyCursor() else: self._vtkwindow.raise_() def plotview(self): return def queryview(self): if (self._querywindow is None): self._querywindow = Q7Query(self._control, self.FG.index, self) self._querywindow.show() else: self._querywindow.raise_() def aboutSIDS(self): path = self.getLastEntered().sidsPath() def dataLoadSelected(self): self.model().dataLoadSelected() def dataReleaseSelected(self): self.model().dataReleaseSelected() def dataLoad(self): node = self.getLastEntered() self.model().dataLoadSelected(single=node.sidsPath()) def dataRelease(self): node = self.getLastEntered() self.model().dataReleaseSelected(single=node.sidsPath()) def forceapply(self): pass def updateTreeStatus(self): if ((Q7FingerPrint.STATUS_MODIFIED in self.FG._status) and (Q7FingerPrint.STATUS_SAVEABLE in self.FG._status)): self.bSave.setEnabled(True) else: self.bSave.setEnabled(False) def doRelease(self): # break cyclic refs to allow garbage self.treeview.itemDelegate().doRelease() self.treeview.setItemDelegate(None) self.treeview.doRelease() self.treeview = None
class Window: """Application window that contains the menu bar and viewer. Parameters ---------- viewer : napari.components.ViewerModel Contained viewer widget. Attributes ---------- file_menu : qtpy.QtWidgets.QMenu File menu. help_menu : qtpy.QtWidgets.QMenu Help menu. main_menu : qtpy.QtWidgets.QMainWindow.menuBar Main menubar. qt_viewer : QtViewer Contained viewer widget. view_menu : qtpy.QtWidgets.QMenu View menu. window_menu : qtpy.QtWidgets.QMenu Window menu. """ raw_stylesheet = get_stylesheet() def __init__(self, viewer, *, show: bool = True): # create QApplication if it doesn't already exist # note: the return value must be retained to prevent garbage collection _ = get_app() # Connect the Viewer and create the Main Window self.qt_viewer = QtViewer(viewer) self._qt_window = _QtMainWindow() self._qt_window.setWindowTitle(self.qt_viewer.viewer.title) self._qt_center = self._qt_window.centralWidget() self._status_bar = self._qt_window.statusBar() # Dictionary holding dock widgets self._dock_widgets: Dict[str, QtViewerDockWidget] = {} self._plugin_menus: Dict[str, QMenu] = {} # since we initialize canvas before window, we need to manually connect them again. if self._qt_window.windowHandle() is not None: self._qt_window.windowHandle().screenChanged.connect( self.qt_viewer.canvas._backend.screen_changed) self._add_menubar() self._add_file_menu() self._add_view_menu() self._add_window_menu() self._add_plugins_menu() self._add_help_menu() self._status_bar.showMessage('Ready') self._help = QLabel('') self._status_bar.addPermanentWidget(self._help) self._qt_center.layout().addWidget(self.qt_viewer) self._qt_center.layout().setContentsMargins(4, 0, 4, 0) self._update_theme() self._add_viewer_dock_widget(self.qt_viewer.dockConsole, tabify=False) self._add_viewer_dock_widget(self.qt_viewer.dockLayerControls, tabify=False) self._add_viewer_dock_widget(self.qt_viewer.dockLayerList, tabify=False) self.window_menu.addSeparator() self.qt_viewer.viewer.events.status.connect(self._status_changed) self.qt_viewer.viewer.events.help.connect(self._help_changed) self.qt_viewer.viewer.events.title.connect(self._title_changed) self.qt_viewer.viewer.events.theme.connect(self._update_theme) if perf.USE_PERFMON: # Add DebugMenu and dockPerformance if using perfmon. self._debug_menu = DebugMenu(self) self._add_viewer_dock_widget(self.qt_viewer.dockPerformance) else: self._debug_menu = None if show: self.show() def _add_menubar(self): """Add menubar to napari app.""" self.main_menu = self._qt_window.menuBar() # Menubar shortcuts are only active when the menubar is visible. # Therefore, we set a global shortcut not associated with the menubar # to toggle visibility, *but*, in order to not shadow the menubar # shortcut, we disable it, and only enable it when the menubar is # hidden. See this stackoverflow link for details: # https://stackoverflow.com/questions/50537642/how-to-keep-the-shortcuts-of-a-hidden-widget-in-pyqt5 self._main_menu_shortcut = QShortcut(QKeySequence('Ctrl+M'), self._qt_window) self._main_menu_shortcut.activated.connect( self._toggle_menubar_visible) self._main_menu_shortcut.setEnabled(False) def _toggle_menubar_visible(self): """Toggle visibility of app menubar. This function also disables or enables a global keyboard shortcut to show the menubar, since menubar shortcuts are only available while the menubar is visible. """ if self.main_menu.isVisible(): self.main_menu.setVisible(False) self._main_menu_shortcut.setEnabled(True) else: self.main_menu.setVisible(True) self._main_menu_shortcut.setEnabled(False) def _add_file_menu(self): """Add 'File' menu to app menubar.""" open_images = QAction('Open File(s)...', self._qt_window) open_images.setShortcut('Ctrl+O') open_images.setStatusTip('Open file(s)') open_images.triggered.connect(self.qt_viewer._open_files_dialog) open_stack = QAction('Open Files as Stack...', self._qt_window) open_stack.setShortcut('Ctrl+Alt+O') open_stack.setStatusTip('Open files') open_stack.triggered.connect( self.qt_viewer._open_files_dialog_as_stack_dialog) open_folder = QAction('Open Folder...', self._qt_window) open_folder.setShortcut('Ctrl+Shift+O') open_folder.setStatusTip('Open a folder') open_folder.triggered.connect(self.qt_viewer._open_folder_dialog) save_selected_layers = QAction('Save Selected Layer(s)...', self._qt_window) save_selected_layers.setShortcut('Ctrl+S') save_selected_layers.setStatusTip('Save selected layers') save_selected_layers.triggered.connect( lambda: self.qt_viewer._save_layers_dialog(selected=True)) save_all_layers = QAction('Save All Layers...', self._qt_window) save_all_layers.setShortcut('Ctrl+Shift+S') save_all_layers.setStatusTip('Save all layers') save_all_layers.triggered.connect( lambda: self.qt_viewer._save_layers_dialog(selected=False)) screenshot = QAction('Save Screenshot...', self._qt_window) screenshot.setShortcut('Alt+S') screenshot.setStatusTip( 'Save screenshot of current display, default .png') screenshot.triggered.connect(self.qt_viewer._screenshot_dialog) screenshot_wv = QAction('Save Screenshot with Viewer...', self._qt_window) screenshot_wv.setShortcut('Alt+Shift+S') screenshot_wv.setStatusTip( 'Save screenshot of current display with the viewer, default .png') screenshot_wv.triggered.connect(self._screenshot_dialog) # OS X will rename this to Quit and put it in the app menu. exitAction = QAction('Exit', self._qt_window) exitAction.setShortcut('Ctrl+Q') exitAction.setMenuRole(QAction.QuitRole) def handle_exit(): # if the event loop was started in gui_qt() then the app will be # named 'napari'. Since the Qapp was started by us, just close it. if QApplication.applicationName() == 'napari': QApplication.closeAllWindows() QApplication.quit() # otherwise, something else created the QApp before us (such as # %gui qt IPython magic). If we quit the app in this case, then # *later* attempts to instantiate a napari viewer won't work until # the event loop is restarted with app.exec_(). So rather than # quit just close all the windows (and clear our app icon). else: QApplication.setWindowIcon(QIcon()) self.close() if perf.USE_PERFMON: # Write trace file before exit, if we were writing one. # Is there a better place to make sure this is done on exit? perf.timers.stop_trace_file() _stop_monitor() _shutdown_chunkloader() exitAction.triggered.connect(handle_exit) self.file_menu = self.main_menu.addMenu('&File') self.file_menu.addAction(open_images) self.file_menu.addAction(open_stack) self.file_menu.addAction(open_folder) self.file_menu.addSeparator() self.file_menu.addAction(save_selected_layers) self.file_menu.addAction(save_all_layers) self.file_menu.addAction(screenshot) self.file_menu.addAction(screenshot_wv) self.file_menu.addSeparator() self.file_menu.addAction(exitAction) def _add_view_menu(self): """Add 'View' menu to app menubar.""" toggle_visible = QAction('Toggle Menubar Visibility', self._qt_window) toggle_visible.setShortcut('Ctrl+M') toggle_visible.setStatusTip('Hide Menubar') toggle_visible.triggered.connect(self._toggle_menubar_visible) toggle_theme = QAction('Toggle Theme', self._qt_window) toggle_theme.setShortcut('Ctrl+Shift+T') toggle_theme.setStatusTip('Toggle theme') toggle_theme.triggered.connect(self.qt_viewer.viewer._toggle_theme) toggle_fullscreen = QAction('Toggle Full Screen', self._qt_window) toggle_fullscreen.setShortcut('Ctrl+F') toggle_fullscreen.setStatusTip('Toggle full screen') toggle_fullscreen.triggered.connect(self._toggle_fullscreen) toggle_play = QAction('Toggle Play', self._qt_window) toggle_play.triggered.connect(self._toggle_play) toggle_play.setShortcut('Ctrl+Alt+P') toggle_play.setStatusTip('Toggle Play') self.view_menu = self.main_menu.addMenu('&View') self.view_menu.addAction(toggle_fullscreen) self.view_menu.addAction(toggle_visible) self.view_menu.addAction(toggle_theme) self.view_menu.addAction(toggle_play) self.view_menu.addSeparator() # Add octree actions. if config.async_octree: toggle_outline = QAction('Toggle Chunk Outlines', self._qt_window) toggle_outline.triggered.connect( self.qt_viewer._toggle_chunk_outlines) toggle_outline.setShortcut('Ctrl+Alt+O') toggle_outline.setStatusTip('Toggle Chunk Outlines') self.view_menu.addAction(toggle_outline) # Add axes menu axes_menu = QMenu('Axes', parent=self._qt_window) axes_visible_action = QAction( 'Visible', parent=self._qt_window, checkable=True, checked=self.qt_viewer.viewer.axes.visible, ) axes_visible_action.triggered.connect(self._toggle_axes_visible) axes_colored_action = QAction( 'Colored', parent=self._qt_window, checkable=True, checked=self.qt_viewer.viewer.axes.colored, ) axes_colored_action.triggered.connect(self._toggle_axes_colored) axes_labels_action = QAction( 'Labels', parent=self._qt_window, checkable=True, checked=self.qt_viewer.viewer.axes.labels, ) axes_labels_action.triggered.connect(self._toggle_axes_labels) axes_dashed_action = QAction( 'Dashed', parent=self._qt_window, checkable=True, checked=self.qt_viewer.viewer.axes.dashed, ) axes_dashed_action.triggered.connect(self._toggle_axes_dashed) axes_arrows_action = QAction( 'Arrows', parent=self._qt_window, checkable=True, checked=self.qt_viewer.viewer.axes.arrows, ) axes_arrows_action.triggered.connect(self._toggle_axes_arrows) axes_menu.addAction(axes_visible_action) axes_menu.addAction(axes_colored_action) axes_menu.addAction(axes_labels_action) axes_menu.addAction(axes_dashed_action) axes_menu.addAction(axes_arrows_action) self.view_menu.addMenu(axes_menu) # Add scale bar menu scale_bar_menu = QMenu('Scale Bar', parent=self._qt_window) scale_bar_visible_action = QAction( 'Visible', parent=self._qt_window, checkable=True, checked=self.qt_viewer.viewer.scale_bar.visible, ) scale_bar_visible_action.triggered.connect( self._toggle_scale_bar_visible) scale_bar_colored_action = QAction( 'Colored', parent=self._qt_window, checkable=True, checked=self.qt_viewer.viewer.scale_bar.colored, ) scale_bar_colored_action.triggered.connect( self._toggle_scale_bar_colored) scale_bar_ticks_action = QAction( 'Ticks', parent=self._qt_window, checkable=True, checked=self.qt_viewer.viewer.scale_bar.ticks, ) scale_bar_ticks_action.triggered.connect(self._toggle_scale_bar_ticks) scale_bar_menu.addAction(scale_bar_visible_action) scale_bar_menu.addAction(scale_bar_colored_action) scale_bar_menu.addAction(scale_bar_ticks_action) self.view_menu.addMenu(scale_bar_menu) self.view_menu.addSeparator() def _add_window_menu(self): """Add 'Window' menu to app menubar.""" exit_action = QAction("Close Window", self._qt_window) exit_action.setShortcut("Ctrl+W") exit_action.setStatusTip('Close napari window') exit_action.triggered.connect(self._qt_window.close) clear_action = QAction("Remove Dock Widgets", self._qt_window) clear_action.setStatusTip('Remove all dock widgets') clear_action.triggered.connect( lambda e: self.remove_dock_widget('all')) self.window_menu = self.main_menu.addMenu('&Window') self.window_menu.addAction(exit_action) self.window_menu.addAction(clear_action) self.window_menu.addSeparator() def _add_plugins_menu(self): """Add 'Plugins' menu to app menubar.""" self.plugins_menu = self.main_menu.addMenu('&Plugins') pip_install_action = QAction("Install/Uninstall Package(s)...", self._qt_window) pip_install_action.triggered.connect(self._show_plugin_install_dialog) self.plugins_menu.addAction(pip_install_action) order_plugin_action = QAction("Plugin Call Order...", self._qt_window) order_plugin_action.setStatusTip('Change call order for plugins') order_plugin_action.triggered.connect(self._show_plugin_sorter) self.plugins_menu.addAction(order_plugin_action) report_plugin_action = QAction("Plugin Errors...", self._qt_window) report_plugin_action.setStatusTip( 'Review stack traces for plugin exceptions and notify developers') report_plugin_action.triggered.connect(self._show_plugin_err_reporter) self.plugins_menu.addAction(report_plugin_action) self._plugin_dock_widget_menu = QMenu('Add Dock Widget', self._qt_window) # Get names of all plugins providing dock widgets or functions plugin_widgets = chain(plugins.dock_widgets, plugins.function_widgets) plugin_counts = Counter(plug_name for plug_name, _ in plugin_widgets) # Add submenu for each plugin with more than 1 item for plugin_name, count in plugin_counts.items(): if count > 1: menu = QMenu(plugin_name, self._qt_window) self._plugin_menus[plugin_name] = menu self._plugin_dock_widget_menu.addMenu(menu) # Add a menu item (QAction) for each available plugin widget docks = zip(repeat("dock"), plugins.dock_widgets) funcs = zip(repeat("func"), plugins.function_widgets) for hook_type, key in chain(docks, funcs): plugin_name, wdg_name = key if plugin_name in self._plugin_menus: # this plugin has a submenu. action = QAction(wdg_name, parent=self._qt_window) self._plugin_menus[plugin_name].addAction(action) else: # this plugin only has one widget, add a namespaced menu item full_name = plugins.menu_item_template.format(*key) action = QAction(full_name, parent=self._qt_window) self._plugin_dock_widget_menu.addAction(action) def _add_widget(*args, key=key, hook_type=hook_type): if hook_type == 'dock': self._add_plugin_dock_widget(key) else: self._add_plugin_function_widget(key) action.triggered.connect(_add_widget) self.plugins_menu.addMenu(self._plugin_dock_widget_menu) def _show_plugin_sorter(self): """Show dialog that allows users to sort the call order of plugins.""" plugin_sorter = QtPluginSorter(parent=self._qt_window) if hasattr(self, 'plugin_sorter_widget'): self.plugin_sorter_widget.show() else: self.plugin_sorter_widget = self.add_dock_widget( plugin_sorter, name='Plugin Sorter', area="right") def _show_plugin_install_dialog(self): """Show dialog that allows users to sort the call order of plugins.""" self.plugin_dialog = QtPluginDialog(self._qt_window) self.plugin_dialog.exec_() def _show_plugin_err_reporter(self): """Show dialog that allows users to review and report plugin errors.""" QtPluginErrReporter(parent=self._qt_window).exec_() def _add_help_menu(self): """Add 'Help' menu to app menubar.""" self.help_menu = self.main_menu.addMenu('&Help') about_action = QAction("napari Info", self._qt_window) about_action.setShortcut("Ctrl+/") about_action.setStatusTip('About napari') about_action.triggered.connect( lambda e: QtAbout.showAbout(self.qt_viewer)) self.help_menu.addAction(about_action) about_key_bindings = QAction("Show Key Bindings", self._qt_window) about_key_bindings.setShortcut("Ctrl+Alt+/") about_key_bindings.setShortcutContext(Qt.ApplicationShortcut) about_key_bindings.setStatusTip('key_bindings') about_key_bindings.triggered.connect( self.qt_viewer.show_key_bindings_dialog) self.help_menu.addAction(about_key_bindings) def _toggle_scale_bar_visible(self, state): self.qt_viewer.viewer.scale_bar.visible = state def _toggle_scale_bar_colored(self, state): self.qt_viewer.viewer.scale_bar.colored = state def _toggle_scale_bar_ticks(self, state): self.qt_viewer.viewer.scale_bar.ticks = state def _toggle_axes_visible(self, state): self.qt_viewer.viewer.axes.visible = state def _toggle_axes_colored(self, state): self.qt_viewer.viewer.axes.colored = state def _toggle_axes_labels(self, state): self.qt_viewer.viewer.axes.labels = state def _toggle_axes_dashed(self, state): self.qt_viewer.viewer.axes.dashed = state def _toggle_axes_arrows(self, state): self.qt_viewer.viewer.axes.arrows = state def _toggle_fullscreen(self, event): """Toggle fullscreen mode.""" if self._qt_window.isFullScreen(): self._qt_window.showNormal() else: self._qt_window.showFullScreen() def _toggle_play(self, state): """Toggle play.""" if self.qt_viewer.dims.is_playing: self.qt_viewer.dims.stop() else: axis = self.qt_viewer.viewer.dims.last_used or 0 self.qt_viewer.dims.play(axis) def _add_plugin_dock_widget(self, key): """Add plugin dock widget if not already added. Parameters ---------- key : 2-tuple of str Plugin name and widget name. """ from ..viewer import Viewer full_name = plugins.menu_item_template.format(*key) if full_name in self._dock_widgets: warnings.warn(f'Dock widget {key!r} already added') return Widget, dock_kwargs = plugins.dock_widgets[key] # if the signature is looking a for a napari viewer, pass it. kwargs = {} for param in inspect.signature(Widget.__init__).parameters.values(): if param.name == 'napari_viewer': kwargs['napari_viewer'] = self.qt_viewer.viewer break if param.annotation in ('napari.viewer.Viewer', Viewer): kwargs[param.name] = self.qt_viewer.viewer break # cannot look for param.kind == param.VAR_KEYWORD because # QWidget allows **kwargs but errs on unknown keyword arguments # instantiate the widget wdg = Widget(**kwargs) # Add dock widget self.add_dock_widget( wdg, name=plugins.menu_item_template.format(*key), area=dock_kwargs.get('area', 'right'), allowed_areas=dock_kwargs.get('allowed_areas', None), ) def _add_plugin_function_widget(self, key): """Add plugin function widget if not already added. Parameters ---------- key : 2-tuple of str Plugin name and function name. """ full_name = plugins.menu_item_template.format(*key) if full_name in self._dock_widgets: warnings.warn(f'Dock widget {key!r} already added') return func, magic_kwargs, dock_kwargs = plugins.function_widgets[key] # Add function widget self.add_function_widget( func, magic_kwargs=magic_kwargs, name=plugins.menu_item_template.format(*key), area=dock_kwargs.get('area', None), allowed_areas=dock_kwargs.get('allowed_areas', None), ) def add_dock_widget( self, widget: QWidget, *, name: str = '', area: str = 'bottom', allowed_areas=None, shortcut=None, ): """Convenience method to add a QDockWidget to the main window Parameters ---------- widget : QWidget `widget` will be added as QDockWidget's main widget. name : str, optional Name of dock widget to appear in window menu. area : str Side of the main window to which the new dock widget will be added. Must be in {'left', 'right', 'top', 'bottom'} allowed_areas : list[str], optional Areas, relative to main window, that the widget is allowed dock. Each item in list must be in {'left', 'right', 'top', 'bottom'} By default, all areas are allowed. shortcut : str, optional Keyboard shortcut to appear in dropdown menu. Returns ------- dock_widget : QtViewerDockWidget `dock_widget` that can pass viewer events. """ dock_widget = QtViewerDockWidget( self.qt_viewer, widget, name=name, area=area, allowed_areas=allowed_areas, shortcut=shortcut, ) self._add_viewer_dock_widget(dock_widget) if hasattr(widget, 'reset_choices'): # Keep the dropdown menus in the widget in sync with the layer model # if widget has a `reset_choices`, which is true for all magicgui # `CategoricalWidget`s layers_events = self.qt_viewer.viewer.layers.events layers_events.inserted.connect(widget.reset_choices) layers_events.removed.connect(widget.reset_choices) layers_events.reordered.connect(widget.reset_choices) # Add dock widget to dictionary self._dock_widgets[dock_widget.name] = dock_widget return dock_widget def _add_viewer_dock_widget(self, dock_widget: QtViewerDockWidget, tabify=False): """Add a QtViewerDockWidget to the main window If other widgets already present in area then will tabify. Parameters ---------- dock_widget : QtViewerDockWidget `dock_widget` will be added to the main window. tabify : bool Flag to tabify dockwidget or not. """ # Find if any othe dock widgets are currently in area current_dws_in_area = [] for dw in self._qt_window.findChildren(QDockWidget): if self._qt_window.dockWidgetArea(dw) == dock_widget.qt_area: current_dws_in_area.append(dw) self._qt_window.addDockWidget(dock_widget.qt_area, dock_widget) # If another dock widget present in area then tabify if len(current_dws_in_area) > 0 and tabify: self._qt_window.tabifyDockWidget(current_dws_in_area[-1], dock_widget) dock_widget.show() dock_widget.raise_() action = dock_widget.toggleViewAction() action.setStatusTip(dock_widget.name) action.setText(dock_widget.name) if dock_widget.shortcut is not None: action.setShortcut(dock_widget.shortcut) self.window_menu.addAction(action) def remove_dock_widget(self, widget: QWidget): """Removes specified dock widget. If a QDockWidget is not provided, the existing QDockWidgets will be searched for one whose inner widget (``.widget()``) is the provided ``widget``. Parameters ---------- widget : QWidget | str If widget == 'all', all docked widgets will be removed. """ if widget == 'all': for dw in list(self._dock_widgets.values()): self.remove_dock_widget(dw) return if not isinstance(widget, QDockWidget): for dw in self._qt_window.findChildren(QDockWidget): if dw.widget() is widget: _dw: QDockWidget = dw break else: raise LookupError( f"Could not find a dock widget containing: {widget}") else: _dw = widget if _dw.widget(): _dw.widget().setParent(None) self._qt_window.removeDockWidget(_dw) self.window_menu.removeAction(_dw.toggleViewAction()) # Remove dock widget from dictionary del self._dock_widgets[_dw.name] # Deleting the dock widget means any references to it will no longer # work but it's not really useful anyway, since the inner widget has # been removed. and anyway: people should be using add_dock_widget # rather than directly using _add_viewer_dock_widget _dw.deleteLater() def add_function_widget( self, function, *, magic_kwargs=None, name: str = '', area=None, allowed_areas=None, shortcut=None, ): """Turn a function into a dock widget via magicgui. Parameters ---------- function : callable Function that you want to add. magic_kwargs : dict, optional Keyword arguments to :func:`magicgui.magicgui` that can be used to specify widget. name : str, optional Name of dock widget to appear in window menu. area : str, optional Side of the main window to which the new dock widget will be added. Must be in {'left', 'right', 'top', 'bottom'}. If not provided the default will be determined by the widget.layout, with 'vertical' layouts appearing on the right, otherwise on the bottom. allowed_areas : list[str], optional Areas, relative to main window, that the widget is allowed dock. Each item in list must be in {'left', 'right', 'top', 'bottom'} By default, only provided areas is allowed. shortcut : str, optional Keyboard shortcut to appear in dropdown menu. Returns ------- dock_widget : QtViewerDockWidget `dock_widget` that can pass viewer events. """ from magicgui import magicgui widget = magicgui(function, **magic_kwargs or {}) if area is None: if str(widget.layout) == 'vertical': area = 'right' else: area = 'bottom' if allowed_areas is None: allowed_areas = [area] return self.add_dock_widget( widget, name=name or function.__name__.replace('_', ' '), area=area, allowed_areas=allowed_areas, shortcut=shortcut, ) def resize(self, width, height): """Resize the window. Parameters ---------- width : int Width in logical pixels. height : int Height in logical pixels. """ self._qt_window.resize(width, height) def show(self): """Resize, show, and bring forward the window.""" self._qt_window.resize(self._qt_window.layout().sizeHint()) self._qt_window.show() # Resize axis labels now that window is shown self.qt_viewer.dims._resize_axis_labels() # We want to bring the viewer to the front when # A) it is our own (gui_qt) event loop OR we are running in jupyter # B) it is not the first time a QMainWindow is being created # `app_name` will be "napari" iff the application was instantiated in # gui_qt(). isActiveWindow() will be True if it is the second time a # _qt_window has been created. # See #721, #732, #735, #795, #1594 app_name = QApplication.instance().applicationName() if (app_name == 'napari' or in_jupyter()) and self._qt_window.isActiveWindow(): self.activate() def activate(self): """Make the viewer the currently active window.""" self._qt_window.raise_() # for macOS self._qt_window.activateWindow() # for Windows def _update_theme(self, event=None): """Update widget color theme.""" # set window styles which don't use the primary stylesheet # FIXME: this is a problem with the stylesheet not using properties theme = get_theme(self.qt_viewer.viewer.theme) self._status_bar.setStyleSheet( template( 'QStatusBar { background: {{ background }}; ' 'color: {{ text }}; }', **theme, )) self._qt_center.setStyleSheet( template('QWidget { background: {{ background }}; }', **theme)) self._qt_window.setStyleSheet(template(self.raw_stylesheet, **theme)) def _status_changed(self, event): """Update status bar. Parameters ---------- event : napari.utils.event.Event The napari event that triggered this method. """ self._status_bar.showMessage(event.value) def _title_changed(self, event): """Update window title. Parameters ---------- event : napari.utils.event.Event The napari event that triggered this method. """ self._qt_window.setWindowTitle(event.value) def _help_changed(self, event): """Update help message on status bar. Parameters ---------- event : napari.utils.event.Event The napari event that triggered this method. """ self._help.setText(event.value) def _screenshot_dialog(self): """Save screenshot of current display with viewer, default .png""" dial = ScreenshotDialog(self.screenshot, self.qt_viewer, self.qt_viewer._last_visited_dir) if dial.exec_(): self._last_visited_dir = os.path.dirname(dial.selectedFiles()[0]) def screenshot(self, path=None): """Take currently displayed viewer and convert to an image array. Parameters ---------- path : str Filename for saving screenshot image. Returns ------- image : array Numpy array of type ubyte and shape (h, w, 4). Index [0, 0] is the upper-left corner of the rendered region. """ img = self._qt_window.grab().toImage() if path is not None: imsave(path, QImg2array(img)) # scikit-image imsave method return QImg2array(img) def close(self): """Close the viewer window and cleanup sub-widgets.""" # Someone is closing us twice? Only try to delete self._qt_window # if we still have one. if hasattr(self, '_qt_window'): self._delete_qt_window() def _delete_qt_window(self): """Delete our self._qt_window.""" # On some versions of Darwin, exiting while fullscreen seems to tickle # some bug deep in NSWindow. This forces the fullscreen keybinding # test to complete its draw cycle, then pop back out of fullscreen. if self._qt_window.isFullScreen(): self._qt_window.showNormal() for i in range(8): time.sleep(0.1) QApplication.processEvents() self.qt_viewer.close() self._qt_window.close() del self._qt_window
def setup_ui(self): """Set up Ui of Context Menu.""" self.setStyleSheet(""" #{}{{ min-width:11.29em; }}""".format(self.objectName())) hbl = QHBoxLayout(self) btn = QPushButton(self.name, self) hbl.addWidget(btn) btn.setEnabled(True) btn.setAutoDefault(False) lbl = QLabel(self) hbl.addWidget(lbl) sz_pol = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred) sz_pol.setHorizontalStretch(1) lbl.setSizePolicy(sz_pol) lbl.setMouseTracking(True) lbl.setAcceptDrops(True) lbl.setTextInteractionFlags(Qt.TextEditorInteraction) self.new_string_signal.connect(lbl.setText) menu = QMenu(btn) btn.setContextMenuPolicy(Qt.CustomContextMenu) btn.setMenu(menu) btn.clicked.connect(btn.showMenu) act = menu.addAction('Get From &File') act.setIcon(qta.icon('mdi.file-download-outline')) act.triggered.connect(self._load_orbit_from_file) act = menu.addAction('Get From &ServConf') act.setIcon(qta.icon('mdi.cloud-download-outline')) act.triggered.connect(self._load_orbit_from_servconf) menu2 = menu.addMenu('Get from &IOC') menu2.setIcon(qta.icon('mdi.download-network-outline')) if self._csorb.acc == 'SI': act = menu2.addAction('&SlowOrb') act.setIcon(qta.icon('mdi.turtle')) act.triggered.connect(_part(self._register_orbit, 'orb')) if self._csorb.isring: act = menu2.addAction('&MTurnOrb') act.setIcon(qta.icon('mdi.alarm-multiple')) act.triggered.connect(_part(self._register_orbit, 'mti')) act = menu2.addAction('S&PassOrb') act.setIcon(qta.icon('mdi.clock-fast')) act.triggered.connect(_part(self._register_orbit, 'sp')) act = menu2.addAction('&RefOrb') act.triggered.connect(_part(self._register_orbit, 'ref')) act = menu2.addAction('&OfflineOrb') act.setIcon(qta.icon('mdi.signal-off')) act.triggered.connect(_part(self._register_orbit, 'off')) act = menu2.addAction('&BPM Offsets') act.setIcon(qta.icon('mdi.currency-sign')) act.triggered.connect(_part(self._register_orbit, 'bpm')) act = menu2.addAction('RespMat') act.setIcon(qta.icon('mdi.matrix')) act.triggered.connect(self._open_matrix_sel) act = menu.addAction('&Edit Orbit') act.setIcon(qta.icon('mdi.table-edit')) act.triggered.connect(self._edit_orbit) if self._csorb.acc == 'SI': act = menu.addAction('Create &Bump') act.setIcon( qta.icon('mdi.chart-bell-curve', scale_factor=1.2, offset=(-0.2, 0.2))) act.triggered.connect(self._create_bump) act = menu.addAction('&Clear') act.setIcon(qta.icon('mdi.delete-empty')) act.triggered.connect(self._reset_orbit) act = menu.addAction('Save To File') act.setIcon(qta.icon('mdi.file-upload-outline')) act.triggered.connect(self._save_orbit_to_file) act = menu.addAction('Save To ServConf') act.setIcon(qta.icon('mdi.cloud-upload-outline')) act.triggered.connect(self._save_orbit_to_servconf)
def custom_context_menu(self, position): menu_main = QMenu() plot = QMenu("Plot...", menu_main) plot_line = QAction("Line", plot) plot_line.triggered.connect(partial(self.presenter.action_plot, PlotType.LINEAR)) plot_line_with_yerr = QAction("Line with Y Errors", plot) plot_line_with_yerr.triggered.connect(partial(self.presenter.action_plot, PlotType.LINEAR_WITH_ERR)) plot_scatter = QAction("Scatter", plot) plot_scatter.triggered.connect(partial(self.presenter.action_plot, PlotType.SCATTER)) plot_line_and_points = QAction("Line + Symbol", plot) plot_line_and_points.triggered.connect(partial(self.presenter.action_plot, PlotType.LINE_AND_SYMBOL)) plot.addAction(plot_line) plot.addAction(plot_line_with_yerr) plot.addAction(plot_scatter) plot.addAction(plot_line_and_points) menu_main.addMenu(plot) copy_bin_values = QAction(self.COPY_ICON, "Copy", menu_main) copy_bin_values.triggered.connect(self.presenter.action_copy_bin_values) set_as_x = QAction("Set as X", menu_main) set_as_x.triggered.connect(self.presenter.action_set_as_x) set_as_y = QAction("Set as Y", menu_main) set_as_y.triggered.connect(self.presenter.action_set_as_y) set_as_none = QAction("Set as None", menu_main) set_as_none.triggered.connect(self.presenter.action_set_as_none) statistics_on_columns = QAction("Statistics on Columns", menu_main) statistics_on_columns.triggered.connect(self.presenter.action_statistics_on_columns) hide_selected = QAction("Hide Selected", menu_main) hide_selected.triggered.connect(self.presenter.action_hide_selected) show_all_columns = QAction("Show All Columns", menu_main) show_all_columns.triggered.connect(self.presenter.action_show_all_columns) sort_ascending = QAction("Sort Ascending", menu_main) sort_ascending.triggered.connect(partial(self.presenter.action_sort_ascending, Qt.AscendingOrder)) sort_descending = QAction("Sort Descending", menu_main) sort_descending.triggered.connect(partial(self.presenter.action_sort_ascending, Qt.DescendingOrder)) menu_main.addAction(copy_bin_values) menu_main.addAction(self.make_separator(menu_main)) menu_main.addAction(set_as_x) menu_main.addAction(set_as_y) marked_y_cols = self.presenter.get_columns_marked_as_y() num_y_cols = len(marked_y_cols) # If any columns are marked as Y then generate the set error menu if num_y_cols > 0: menu_set_as_y_err = QMenu("Set error for Y...") for col in range(num_y_cols): set_as_y_err = QAction("Y{}".format(col), menu_main) # the column index of the column relative to the whole table, this is necessary # so that later the data of the column marked as error can be retrieved real_column_index = marked_y_cols[col] # col here holds the index in the LABEL (multiple Y columns have labels Y0, Y1, YN...) # this is NOT the same as the column relative to the WHOLE table set_as_y_err.triggered.connect(partial(self.presenter.action_set_as_y_err, real_column_index, col)) menu_set_as_y_err.addAction(set_as_y_err) menu_main.addMenu(menu_set_as_y_err) menu_main.addAction(set_as_none) menu_main.addAction(self.make_separator(menu_main)) menu_main.addAction(statistics_on_columns) menu_main.addAction(self.make_separator(menu_main)) menu_main.addAction(hide_selected) menu_main.addAction(show_all_columns) menu_main.addAction(self.make_separator(menu_main)) menu_main.addAction(sort_ascending) menu_main.addAction(sort_descending) menu_main.exec_(self.mapToGlobal(position))
class MenuNode(object): _currentMenuContext = None """docstring for MenuNode""" def __init__(self, option, parent, menubar=None): if isinstance(option, str): blobs = option.split('|') _option = {'label': blobs[0]} l = len(blobs) if l > 1: _option['shortcut'] = blobs[1] if l > 2: _option['help'] = blobs[2] option = _option self.qtmenubar = menubar self.qtaction = None self.qtmenu = None # self.qtaction = None self.owner = None self.parent = parent self.groupName = None signal = option.get('signal', None) self.setSignal(signal) self.mgr = parent and parent.mgr self.owner = parent and parent.owner self.children = [] self.actionGroups = {} self.label = option.get('label', 'UNNAMED') self.name = option.get('name', self.label.replace('&', '').replace(' ', '_')) self.name = self.name.lower() self.shortcut = option.get('shortcut', False) self.help = option.get('help', '') self.priority = option.get('priority', 0) self.itemType = option.get('type', False) self.onClick = option.get('on_click', None) self.cmd = option.get('command', None) self.cmdArgs = option.get('command_args', None) self.link = None self.groupName = option.get('group', None) self.menuType = self.qtmenubar and 'menubar' or 'item' children = option.get('children', None) link = option.get('link', None) if children or self.itemType == 'menu': if self.menuType != 'menubar': self.menuType = 'menu' self.itemType = False elif link: self.link = link if self.menuType != 'menubar': self.menuType = 'link' elif parent and parent.menuType == 'menubar': self.menuType = 'menu' if self.menuType == 'menu': self.qtmenu = QMenu(self.label) if not parent or parent.menuType == 'root': return parent.addChildControl(self) if self.itemType == 'check': checked = option.get('checked', False) self.setValue(checked or False) if children: for data in children: self.addChild(data) # self.mgr.addNodeIndex(self) def getFullName(self): if parent: return parent.getFullName() + '/' + self.name return self.name def addChild(self, option, owner=None): if option == '----': if self.qtmenu: self.qtmenu.addSeparator() elif isinstance(option, list): output = [] for data in option: n = self.addChild(data) if n: output.append(n) if owner: n.owner = owner return output else: node = MenuNode(option, self) if owner: node.owner = owner self.children.append(node) return node def affirmQtActionGroup(self, name): group = self.actionGroups.get(name, None) if not group: group = QtWidgets.QActionGroup(self.qtmenu) self.actionGroups[name] = group return group def addChildControl(self, child): childType = child.menuType selfType = self.menuType if selfType == 'menu': if childType == 'menu': child.qtaction = self.qtmenu.addMenu(child.qtmenu) elif child.link: qtmenu = child.link.qtmenu child.qtaction = self.qtmenu.addMenu(qtmenu) else: action = QtWidgets.QAction(child.label, None, shortcut=child.shortcut, statusTip=child.help, checkable=child.itemType == 'check', triggered=child.handleEvent) self.qtmenu.addAction(action) child.qtaction = action if child.groupName: self.affirmQtActionGroup(child.groupName).addAction(action) elif selfType == 'menubar': if childType == 'menu': self.qtmenubar.addMenu(child.qtmenu) child.qtaction = child.qtmenu.menuAction() else: logging.warning('attempt to add menuitem/link to a menubar') return else: logging.warning('menuitem has no child') def setEnabled(self, enabled): #todo: set state of linked item selfType = self.menuType if selfType == 'menubar': self.qtmenubar.setEnable(enabled) return if self.qtmenu: self.qtmenu.setEnabled(enabled) else: self.qtaction.setEnabled(enabled) def remove(self): self.clear() self.parent.children.remove(self) selfType = self.menuType if not self.parent: return if selfType == 'menubar': return parentType = self.parent.menuType if parentType == 'menu': self.parent.qtmenu.removeAction(self.qtaction) elif parentType == 'menubar': self.parent.qtmenubar.removeAction(self.qtaction) logging.info('remove menunode:' + self.name) def clear(self): if self.menuType in ['menu', 'menubar']: for node in self.children[:]: node.remove() def findChild(self, name): name = name.lower() for c in self.children: if c.name == name: return c return None def getValue(self): if self.itemType in ('check', 'radio'): return self.qtaction.isChecked() return True def setValue(self, v): if self.itemType in ('check', 'radio'): self.qtaction.setChecked(v and True or False) def setSignal(self, signal): if isinstance(signal, str): signal = signals.get(signal) self.signal = signal def popUp(self, **option): if self.qtmenu: context = option.get('context', None) MenuNode._currentMenuContext = context self.qtmenu.exec_(QtGui.QCursor.pos()) def getContext(self): return MenuNode._currentMenuContext def setOnClick(self, onClick): self.onClick = onClick def handleEvent(self): itemtype = self.itemType value = self.getValue() logging.debug('menu event:' + self.name) if self.owner: if hasattr(self.owner, 'onMenu'): self.owner.onMenu(self) if self.signal: self.signal(value) if self.onClick != None: self.onClick(value) if self.cmd: args = self.cmdArgs or {} app.doCommand(self.cmd, **args) MenuNode._currentMenuContext = None
class PlotWindow(QMdiSubWindow): """ Displayed plotting subwindow available in the ``QMdiArea``. """ window_removed = Signal() color_changed = Signal(PlotDataItem, QColor) width_changed = Signal(int) def __init__(self, model, *args, **kwargs): super(PlotWindow, self).__init__(*args, **kwargs) # Hide the icon in the title bar self.setWindowIcon(qta.icon('fa.circle', opacity=0)) # The central widget of the sub window will be a main window so that it # can support having tab bars self._central_widget = QMainWindow() self.setWidget(self._central_widget) loadUi(os.path.join(os.path.dirname(__file__), "ui", "plot_window.ui"), self._central_widget) # The central widget of the main window widget will be the plot self._model = model self._current_item_index = None self._plot_widget = PlotWidget(model=self._model) self._plot_widget.plotItem.setMenuEnabled(False) self._central_widget.setCentralWidget(self._plot_widget) # Setup action group for interaction modes mode_group = QActionGroup(self.tool_bar) mode_group.addAction(self._central_widget.pan_mode_action) self._central_widget.pan_mode_action.setChecked(True) mode_group.addAction(self._central_widget.zoom_mode_action) def _toggle_mode(state): view_state = self.plot_widget.plotItem.getViewBox().state.copy() view_state.update({ 'mouseMode': pg.ViewBox.RectMode if state else pg.ViewBox.PanMode }) self.plot_widget.plotItem.getViewBox().setState(view_state) # Setup plot settings options menu self.plot_settings_button = self.tool_bar.widgetForAction( self._central_widget.plot_settings_action) self.plot_settings_button.setPopupMode(QToolButton.InstantPopup) self.plot_settings_menu = QMenu(self.plot_settings_button) self.plot_settings_button.setMenu(self.plot_settings_menu) self.color_change_action = QAction("Line Color") self.plot_settings_menu.addAction(self.color_change_action) self.line_width_menu = QMenu("Line Widths") self.plot_settings_menu.addMenu(self.line_width_menu) # Setup the line width plot setting options for i in range(1, 4): act = QAction(str(i), self.line_width_menu) self.line_width_menu.addAction(act) act.triggered.connect( lambda *args, size=i: self._on_change_width(size)) # Setup connections self._central_widget.pan_mode_action.triggered.connect( lambda: _toggle_mode(False)) self._central_widget.zoom_mode_action.triggered.connect( lambda: _toggle_mode(True)) self._central_widget.linear_region_action.triggered.connect( self.plot_widget._on_add_linear_region) self._central_widget.remove_region_action.triggered.connect( self.plot_widget._on_remove_linear_region) self.color_change_action.triggered.connect(self._on_change_color) self._central_widget.export_plot_action.triggered.connect( self._on_export_plot) self._central_widget.reset_view_action.triggered.connect( lambda: self._on_reset_view()) @property def tool_bar(self): """ Return the tool bar for the embedded plot widget. """ return self._central_widget.tool_bar @property def current_item(self): """ The currently selected plot data item. """ if self._current_item_index is not None: return self.proxy_model.item_from_index(self._current_item_index) @property def plot_widget(self): """ Return the embedded plot widget """ return self._plot_widget @property def proxy_model(self): """ The proxy model defined in the internal plot widget. """ return self.plot_widget.proxy_model def closeEvent(self, event): """ Called by qt when window closes, upon which it emits the window_removed signal. Parameters ---------- event : ignored in this implementation. """ self.window_removed.emit() def _on_current_item_changed(self, current_idx, prev_idx): self._current_item_index = current_idx def _on_reset_view(self): """ Resets the visible range of the plot taking into consideration only the PlotDataItem objects currently attached. """ self.plot_widget.autoRange(items=[ item for item in self.plot_widget.listDataItems() if isinstance(item, PlotDataItem) ]) self.plot_widget.sigRangeChanged.emit(*self.plot_widget.viewRange()) def _on_change_color(self): """ Listens for color changed events in plot windows, gets the currently selected item in the data list view, and changes the stored color value. """ # If there is no currently selected rows, raise an error if self.current_item is None: message_box = QMessageBox() message_box.setText("No item selected, cannot change color.") message_box.setIcon(QMessageBox.Warning) message_box.setInformativeText( "There is currently no item selected. Please select an item " "before changing its plot color.") message_box.exec() return color = QColorDialog.getColor(options=QColorDialog.ShowAlphaChannel) if color.isValid(): self.current_item.color = color.toRgb() self.color_changed.emit(self.current_item, self.current_item.color) def _on_change_width(self, size): self.plot_widget.change_width(size) self.width_changed.emit(size) def _on_export_plot(self): file_path, key = compat.getsavefilename( filters=";;".join(EXPORT_FILTERS.keys())) if key == '': return exporter = EXPORT_FILTERS[key](self.plot_widget.plotItem) # TODO: Current issue in pyqtgraph where the user cannot explicitly # define the output size. Fix incoming. # plot_size_dialog = PlotSizeDialog(self) # plot_size_dialog.height_line_edit.setText( # str(int(exporter.params.param('height').value()))) # plot_size_dialog.width_line_edit.setText( # str(int(exporter.params.param('width').value()))) # # if key != "*.svg": # if plot_size_dialog.exec_(): # exporter.params.param('height').setValue(int(exporter.params.param('height').value()), # blockSignal=exporter.heightChanged) # exporter.params.param('width').setValue(int(exporter.params.param('height').value()), # blockSignal=exporter.widthChanged) # else: # return exporter.export(file_path)
class CustomMenu(QtWidgets.QPushButton): """合约管理组件""" signal = QtCore.Signal(type(Event())) # ---------------------------------------------------------------------- def __init__(self, parent): """Constructor""" super(CustomMenu, self).__init__() self.parent = parent # self.initUi() self.initMenu() #----------------------------------------------------------------------- def initMenu(self): self.setStyleSheet( "QMenu{background:purple;}" "QMenu{border:1px solid lightgray;}" "QMenu{border-color:green;}" "QMenu::item{padding:0px 20px 0px 15px;}" "QMenu::item{height:30px;}" "QMenu::item{color:blue;}" "QMenu::item{background:white;}" "QMenu::item{margin:1px 0px 0px 0px;}" "QMenu::item:selected:enabled{background:lightgray;}" "QMenu::item:selected:enabled{color:blue;}" "QMenu::item:selected:!enabled{background:transparent;}" "QMenu::separator{height:50px;}" "QMenu::separator{width:1px;}" "QMenu::separator{background:white;}" "QMenu::separator{margin:1px 1px 1px 1px;}" "QMenu#menu{background:white;}" "QMenu#menu{border:1px solid lightgray;}" "QMenu#menu::item{padding:0px 20px 0px 15px;}" "QMenu#menu::item{height:15px;}" "QMenu#menu::item:selected:enabled{background:lightgray;}" "QMenu#menu::item:selected:enabled{color:white;}" "QMenu#menu::item:selected:!enabled{background:transparent;}" "QMenu#menu::separator{height:1px;}" "QMenu#menu::separator{background:lightgray;}" "QMenu#menu::separator{margin:2px 0px 2px 0px;}" "QMenu#menu::indicator {padding:5px;}") self.color = QColor(Qt.gray) self.opacity = 1.0 '''''' ' 创建右键菜单 ' '' # 必须将ContextMenuPolicy设置为Qt.CustomContextMenu # 否则无法使用customContextMenuRequested信号 self.setContextMenuPolicy(Qt.CustomContextMenu) self.customContextMenuRequested.connect(self.showContextMenu) # 创建QMenu self.contextMenu = QMenu(self) self.trendMenu = self.contextMenu.addMenu(u"k线形态") self.swingMenu = self.contextMenu.addMenu(u"技术指标") self.amountMenu = self.contextMenu.addMenu(u"策略研究") self.pzxzMenu = self.contextMenu.addMenu(u"品种选择") # 添加二级菜单 #趋势分析指标 self.actionSAR = self.trendMenu.addAction(u'k线') self.actionSAR.triggered.connect( lambda: self.parent.initIndicator(u"KLINE")) self.actionMA = self.trendMenu.addAction(u'信号隐藏') self.actionMA.triggered.connect( lambda: self.parent.initIndicator(u"信号隐藏")) self.actionMA = self.trendMenu.addAction(u'信号显示') self.actionMA.triggered.connect( lambda: self.parent.initIndicator(u"信号显示")) #摆动分析 self.actionCCI = self.swingMenu.addAction(u'MA SHORT') self.actionCCI.triggered.connect( lambda: self.parent.initIndicator(u"MA SHORT")) self.actionROC = self.swingMenu.addAction(u'MA LONG') self.actionROC.triggered.connect( lambda: self.parent.initIndicator(u"MA LONG")) self.actionSHORTTERM = self.swingMenu.addAction(u'SHORT TERM(Limit)') self.actionSHORTTERM.triggered.connect( lambda: self.parent.initIndicator(u"SHORT TERM(Limit)")) self.actionSHORTTERMF = self.swingMenu.addAction(u'SHORT TERM(First)') self.actionSHORTTERMF.triggered.connect( lambda: self.parent.initIndicator(u"SHORT TERM(First)")) self.actionSHORTTERMALL = self.swingMenu.addAction(u'SHORT TERM(All)') self.actionSHORTTERMALL.triggered.connect( lambda: self.parent.initIndicator(u"SHORT TERM(All)")) self.actionWAIBAORI = self.swingMenu.addAction(u'外包日') self.actionWAIBAORI.triggered.connect( lambda: self.parent.initIndicator(u"外包日")) self.actionGJR_BUY = self.swingMenu.addAction(u'攻击日(买入)') self.actionGJR_BUY.triggered.connect( lambda: self.parent.initIndicator(u"攻击日(买入)")) self.actionGJR_SELL = self.swingMenu.addAction(u'攻击日(卖出)') self.actionGJR_SELL.triggered.connect( lambda: self.parent.initIndicator(u"攻击日(卖出)")) ##设为起始日期 self.actionOPI = self.amountMenu.addAction(u'设为起始日期') self.actionOPI.triggered.connect( lambda: self.parent.initIndicator(u"设为起始日期")) self.actionOPI1 = self.amountMenu.addAction(u'设为结束日期') self.actionOPI1.triggered.connect( lambda: self.parent.initIndicator(u"设为结束日期")) ##量仓分析 self.actionOPI2 = self.amountMenu.addAction(u'MA_螺纹空_PLUS') self.actionOPI2.triggered.connect( lambda: self.parent.initIndicator(u"MA_螺纹空_PLUS")) ##成交量分析 self.actionVOL = self.amountMenu.addAction(u'SHORTTERM_螺纹_多') self.actionVOL.triggered.connect( lambda: self.parent.initIndicator(u"SHORTTERM_螺纹_多")) self.action1 = self.amountMenu.addAction(u'SHORTTERM_螺纹_空') self.action1.triggered.connect( lambda: self.parent.initIndicator(u"SHORTTERM_螺纹_空")) self.action2 = self.amountMenu.addAction(u'SHORTTERM_螺纹_多_加仓') self.action2.triggered.connect( lambda: self.parent.initIndicator(u"SHORTTERM_螺纹_多_加仓")) self.action5 = self.amountMenu.addAction(u'VOLATILITY_螺纹_多') self.action5.triggered.connect( lambda: self.parent.initIndicator(u"VOLATILITY_螺纹_多")) self.action6 = self.amountMenu.addAction(u'VOLATILITY_螺纹_空') self.action6.triggered.connect( lambda: self.parent.initIndicator(u"VOLATILITY_螺纹_空")) self.action9 = self.amountMenu.addAction(u'VOLATILITY_螺纹_V1') self.action9.triggered.connect( lambda: self.parent.initIndicator(u"VOLATILITY_螺纹_V1")) self.action7 = self.amountMenu.addAction(u'外包日_螺纹_多') self.action7.triggered.connect( lambda: self.parent.initIndicator(u"外包日_螺纹_多")) self.action3 = self.pzxzMenu.addAction(u'RB9999') self.action3.triggered.connect( lambda: self.parent.initIndicator(u"RB9999")) self.action4 = self.pzxzMenu.addAction(u'BU9999') self.action4.triggered.connect( lambda: self.parent.initIndicator(u"BU9999")) #self.contextMenu.exec_(QCursor.pos()) # 在鼠标位置显示 #添加二级菜单 def showContextMenu(self, pos): ''''' 右键点击时调用的函数 ''' # 菜单显示前,将它移动到鼠标点击的位置 # self.contextMenu.move(self.pos() + pos) self.contextMenu.show() self.contextMenu.exec_(QCursor.pos())
class PreviewTable(QTableView): """Import wizard preview widget""" def __init__(self, parent): QTableView.__init__(self, parent) self._model = None # Setting up actions self.date_dayfirst_action = create_action(self, "dayfirst", triggered=ft_partial( self.parse_to_type, atype="date", dayfirst=True)) self.date_monthfirst_action = create_action(self, "monthfirst", triggered=ft_partial( self.parse_to_type, atype="date", dayfirst=False)) self.perc_action = create_action(self, "perc", triggered=ft_partial( self.parse_to_type, atype="perc")) self.acc_action = create_action(self, "account", triggered=ft_partial( self.parse_to_type, atype="account")) self.str_action = create_action(self, "unicode", triggered=ft_partial( self.parse_to_type, atype="unicode")) self.int_action = create_action(self, "int", triggered=ft_partial( self.parse_to_type, atype="int")) self.float_action = create_action(self, "float", triggered=ft_partial( self.parse_to_type, atype="float")) # Setting up menus self.date_menu = QMenu() self.date_menu.setTitle("Date") add_actions(self.date_menu, (self.date_dayfirst_action, self.date_monthfirst_action)) self.parse_menu = QMenu(self) self.parse_menu.addMenu(self.date_menu) add_actions(self.parse_menu, (self.perc_action, self.acc_action)) self.parse_menu.setTitle("String to") self.opt_menu = QMenu(self) self.opt_menu.addMenu(self.parse_menu) add_actions(self.opt_menu, (self.str_action, self.int_action, self.float_action)) def _shape_text(self, text, colsep=u"\t", rowsep=u"\n", transpose=False, skiprows=0, comments='#'): """Decode the shape of the given text""" assert colsep != rowsep out = [] text_rows = text.split(rowsep)[skiprows:] for row in text_rows: stripped = to_text_string(row).strip() if len(stripped) == 0 or stripped.startswith(comments): continue line = to_text_string(row).split(colsep) line = [try_to_parse(to_text_string(x)) for x in line] out.append(line) # Replace missing elements with np.nan's or None's if programs.is_module_installed('numpy'): from numpy import nan out = list(zip_longest(*out, fillvalue=nan)) else: out = list(zip_longest(*out, fillvalue=None)) # Tranpose the last result to get the expected one out = [[r[col] for r in out] for col in range(len(out[0]))] if transpose: return [[r[col] for r in out] for col in range(len(out[0]))] return out def get_data(self): """Return model data""" if self._model is None: return None return self._model.get_data() def process_data(self, text, colsep=u"\t", rowsep=u"\n", transpose=False, skiprows=0, comments='#'): """Put data into table model""" data = self._shape_text(text, colsep, rowsep, transpose, skiprows, comments) self._model = PreviewTableModel(data) self.setModel(self._model) @Slot() def parse_to_type(self, **kwargs): """Parse to a given type""" indexes = self.selectedIndexes() if not indexes: return for index in indexes: self.model().parse_data_type(index, **kwargs) def contextMenuEvent(self, event): """Reimplement Qt method""" self.opt_menu.popup(event.globalPos()) event.accept()
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 menu = QMenu(self.parent_no_ui) if self.parent_no_ui.table_selection_buffer == {}: paste_status = False else: paste_status = True if (self.parent.table.rowCount() > 0): _undo = menu.addAction("Undo") _undo.setEnabled(self.parent_no_ui.undo_button_enabled) _redo = menu.addAction("Redo") _redo.setEnabled(self.parent_no_ui.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.parent.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.parent_no_ui.action_undo_clicked() elif action == _redo: self.parent_no_ui.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()
class CustomMenu(QtWidgets.QPushButton): """合约管理组件""" signal = QtCore.Signal(type(Event())) # ---------------------------------------------------------------------- def __init__(self, parent): """Constructor""" super(CustomMenu, self).__init__() self.parent = parent # self.initUi() self.initMenu() #----------------------------------------------------------------------- def initMenu(self): self.setStyleSheet( "QMenu{background:purple;}" "QMenu{border:1px solid lightgray;}" "QMenu{border-color:green;}" "QMenu::item{padding:0px 20px 0px 15px;}" "QMenu::item{height:30px;}" "QMenu::item{color:blue;}" "QMenu::item{background:white;}" "QMenu::item{margin:1px 0px 0px 0px;}" "QMenu::item:selected:enabled{background:lightgray;}" "QMenu::item:selected:enabled{color:blue;}" "QMenu::item:selected:!enabled{background:transparent;}" "QMenu::separator{height:50px;}" "QMenu::separator{width:1px;}" "QMenu::separator{background:white;}" "QMenu::separator{margin:1px 1px 1px 1px;}" "QMenu#menu{background:white;}" "QMenu#menu{border:1px solid lightgray;}" "QMenu#menu::item{padding:0px 20px 0px 15px;}" "QMenu#menu::item{height:15px;}" "QMenu#menu::item:selected:enabled{background:lightgray;}" "QMenu#menu::item:selected:enabled{color:white;}" "QMenu#menu::item:selected:!enabled{background:transparent;}" "QMenu#menu::separator{height:1px;}" "QMenu#menu::separator{background:lightgray;}" "QMenu#menu::separator{margin:2px 0px 2px 0px;}" "QMenu#menu::indicator {padding:5px;}") self.color = QColor(Qt.gray) self.opacity = 1.0 '''''' ' 创建右键菜单 ' '' # 必须将ContextMenuPolicy设置为Qt.CustomContextMenu # 否则无法使用customContextMenuRequested信号 self.setContextMenuPolicy(Qt.CustomContextMenu) self.customContextMenuRequested.connect(self.showContextMenu) # 创建QMenu self.contextMenu = QMenu(self) self.trendMenu = self.contextMenu.addMenu(u"k线形态") self.swingMenu = self.contextMenu.addMenu(u"技术指标") self.amountMenu = self.contextMenu.addMenu(u"策略研究") # 添加二级菜单 #趋势分析指标 self.actionSAR = self.trendMenu.addAction(u'k线') self.actionSAR.triggered.connect( lambda: self.parent.initIndicator(u"KLINE")) self.actionMA = self.trendMenu.addAction(u'信号隐藏') self.actionMA.triggered.connect( lambda: self.parent.initIndicator(u"信号隐藏")) self.actionMA = self.trendMenu.addAction(u'信号显示') self.actionMA.triggered.connect( lambda: self.parent.initIndicator(u"信号显示")) #摆动分析 self.actionCCI = self.swingMenu.addAction(u'MA SHORT') self.actionCCI.triggered.connect( lambda: self.parent.initIndicator(u"MA SHORT")) self.actionROC = self.swingMenu.addAction(u'MA LONG') self.actionROC.triggered.connect( lambda: self.parent.initIndicator(u"MA LONG")) ##设为起始日期 self.actionOPI = self.amountMenu.addAction(u'设为起始日期') self.actionOPI.triggered.connect( lambda: self.parent.initIndicator(u"设为起始日期")) ##量仓分析 self.actionOPI = self.amountMenu.addAction(u'MA_螺纹多_PLUS') self.actionOPI.triggered.connect( lambda: self.parent.initIndicator(u"MA_螺纹多_PLUS")) ##成交量分析 self.actionVOL = self.amountMenu.addAction(u'CJL') self.actionVOL.triggered.connect( lambda: self.parent.initIndicator(u"CJL")) #self.contextMenu.exec_(QCursor.pos()) # 在鼠标位置显示 #添加二级菜单 def showContextMenu(self, pos): ''''' 右键点击时调用的函数 ''' # 菜单显示前,将它移动到鼠标点击的位置 # self.contextMenu.move(self.pos() + pos) self.contextMenu.show() self.contextMenu.exec_(QCursor.pos())
def custom_context_menu(self, position): menu_main = QMenu() plot = QMenu("Plot...", menu_main) plot_line = QAction("Line", plot) plot_line.triggered.connect( partial(self.presenter.action_plot, PlotType.LINEAR)) plot_line_with_yerr = QAction("Line with Y Errors", plot) plot_line_with_yerr.triggered.connect( partial(self.presenter.action_plot, PlotType.LINEAR_WITH_ERR)) plot_scatter = QAction("Scatter", plot) plot_scatter.triggered.connect( partial(self.presenter.action_plot, PlotType.SCATTER)) plot_scatter_with_yerr = QAction("Scatter with Y Errors", plot) plot_scatter_with_yerr.triggered.connect( partial(self.presenter.action_plot, PlotType.SCATTER_WITH_ERR)) plot_line_and_points = QAction("Line + Symbol", plot) plot_line_and_points.triggered.connect( partial(self.presenter.action_plot, PlotType.LINE_AND_SYMBOL)) plot.addAction(plot_line) plot.addAction(plot_line_with_yerr) plot.addAction(plot_scatter) plot.addAction(plot_scatter_with_yerr) plot.addAction(plot_line_and_points) menu_main.addMenu(plot) copy_bin_values = QAction(self.COPY_ICON, "Copy", menu_main) copy_bin_values.triggered.connect( self.presenter.action_copy_bin_values) set_as_x = QAction("Set as X", menu_main) set_as_x.triggered.connect(self.presenter.action_set_as_x) set_as_y = QAction("Set as Y", menu_main) set_as_y.triggered.connect(self.presenter.action_set_as_y) set_as_none = QAction("Set as None", menu_main) set_as_none.triggered.connect(self.presenter.action_set_as_none) statistics_on_columns = QAction("Statistics on Columns", menu_main) statistics_on_columns.triggered.connect( self.presenter.action_statistics_on_columns) hide_selected = QAction("Hide Selected", menu_main) hide_selected.triggered.connect(self.presenter.action_hide_selected) show_all_columns = QAction("Show All Columns", menu_main) show_all_columns.triggered.connect( self.presenter.action_show_all_columns) sort_ascending = QAction("Sort Ascending", menu_main) sort_ascending.triggered.connect( partial(self.presenter.action_sort, True)) sort_descending = QAction("Sort Descending", menu_main) sort_descending.triggered.connect( partial(self.presenter.action_sort, False)) menu_main.addAction(copy_bin_values) menu_main.addAction(self.make_separator(menu_main)) menu_main.addAction(set_as_x) menu_main.addAction(set_as_y) marked_y_cols = self.presenter.get_columns_marked_as_y() num_y_cols = len(marked_y_cols) # If any columns are marked as Y then generate the set error menu if num_y_cols > 0: menu_set_as_y_err = QMenu("Set error for Y...") for label_index in range(num_y_cols): set_as_y_err = QAction("Y{}".format(label_index), menu_main) # This is the column index of the Y column for which a YERR column is being added. # The column index is relative to the whole table, this is necessary # so that later the data of the column marked as error can be retrieved related_y_column = marked_y_cols[label_index] # label_index here holds the index in the LABEL (multiple Y columns have labels Y0, Y1, YN...) # this is NOT the same as the column relative to the WHOLE table set_as_y_err.triggered.connect( partial(self.presenter.action_set_as_y_err, related_y_column)) menu_set_as_y_err.addAction(set_as_y_err) menu_main.addMenu(menu_set_as_y_err) menu_main.addAction(set_as_none) menu_main.addAction(self.make_separator(menu_main)) menu_main.addAction(statistics_on_columns) menu_main.addAction(self.make_separator(menu_main)) menu_main.addAction(hide_selected) menu_main.addAction(show_all_columns) menu_main.addAction(self.make_separator(menu_main)) menu_main.addAction(sort_ascending) menu_main.addAction(sort_descending) menu_main.exec_(self.mapToGlobal(position))
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()
class PreviewTable(QTableView): """Import wizard preview widget""" def __init__(self, parent): QTableView.__init__(self, parent) self._model = None # Setting up actions self.date_dayfirst_action = create_action(self, "dayfirst", triggered=ft_partial(self.parse_to_type, atype="date", dayfirst=True)) self.date_monthfirst_action = create_action(self, "monthfirst", triggered=ft_partial(self.parse_to_type, atype="date", dayfirst=False)) self.perc_action = create_action(self, "perc", triggered=ft_partial(self.parse_to_type, atype="perc")) self.acc_action = create_action(self, "account", triggered=ft_partial(self.parse_to_type, atype="account")) self.str_action = create_action(self, "unicode", triggered=ft_partial(self.parse_to_type, atype="unicode")) self.int_action = create_action(self, "int", triggered=ft_partial(self.parse_to_type, atype="int")) self.float_action = create_action(self, "float", triggered=ft_partial(self.parse_to_type, atype="float")) # Setting up menus self.date_menu = QMenu() self.date_menu.setTitle("Date") add_actions( self.date_menu, (self.date_dayfirst_action, self.date_monthfirst_action)) self.parse_menu = QMenu(self) self.parse_menu.addMenu(self.date_menu) add_actions( self.parse_menu, (self.perc_action, self.acc_action)) self.parse_menu.setTitle("String to") self.opt_menu = QMenu(self) self.opt_menu.addMenu(self.parse_menu) add_actions( self.opt_menu, (self.str_action, self.int_action, self.float_action)) def _shape_text(self, text, colsep=u"\t", rowsep=u"\n", transpose=False, skiprows=0, comments='#'): """Decode the shape of the given text""" assert colsep != rowsep out = [] text_rows = text.split(rowsep)[skiprows:] for row in text_rows: stripped = to_text_string(row).strip() if len(stripped) == 0 or stripped.startswith(comments): continue line = to_text_string(row).split(colsep) line = [try_to_parse(to_text_string(x)) for x in line] out.append(line) # Replace missing elements with np.nan's or None's if programs.is_module_installed('numpy'): from numpy import nan out = list(zip_longest(*out, fillvalue=nan)) else: out = list(zip_longest(*out, fillvalue=None)) # Tranpose the last result to get the expected one out = [[r[col] for r in out] for col in range(len(out[0]))] if transpose: return [[r[col] for r in out] for col in range(len(out[0]))] return out def get_data(self): """Return model data""" if self._model is None: return None return self._model.get_data() def process_data(self, text, colsep=u"\t", rowsep=u"\n", transpose=False, skiprows=0, comments='#'): """Put data into table model""" data = self._shape_text(text, colsep, rowsep, transpose, skiprows, comments) self._model = PreviewTableModel(data) self.setModel(self._model) @Slot() def parse_to_type(self,**kwargs): """Parse to a given type""" indexes = self.selectedIndexes() if not indexes: return for index in indexes: self.model().parse_data_type(index, **kwargs) def contextMenuEvent(self, event): """Reimplement Qt method""" self.opt_menu.popup(event.globalPos()) event.accept()
class PlotWindow(QMdiSubWindow): """ Displayed plotting subwindow available in the ``QMdiArea``. """ window_removed = Signal() color_changed = Signal(PlotDataItem, QColor) width_changed = Signal(int) def __init__(self, model, *args, **kwargs): super(PlotWindow, self).__init__(*args, **kwargs) # Hide the icon in the title bar self.setWindowIcon(qta.icon('fa.circle', opacity=0)) # The central widget of the sub window will be a main window so that it # can support having tab bars self._central_widget = QMainWindow() self.setWidget(self._central_widget) loadUi(os.path.join(os.path.dirname(__file__), "ui", "plot_window.ui"), self._central_widget) # The central widget of the main window widget will be the plot self._model = model self._current_item_index = None self._plot_widget = PlotWidget(model=self._model) self._plot_widget.plotItem.setMenuEnabled(False) self._central_widget.setCentralWidget(self._plot_widget) # Setup action group for interaction modes mode_group = QActionGroup(self.tool_bar) mode_group.addAction(self._central_widget.pan_mode_action) self._central_widget.pan_mode_action.setChecked(True) mode_group.addAction(self._central_widget.zoom_mode_action) def _toggle_mode(state): view_state = self.plot_widget.plotItem.getViewBox().state.copy() view_state.update({'mouseMode': pg.ViewBox.RectMode if state else pg.ViewBox.PanMode}) self.plot_widget.plotItem.getViewBox().setState(view_state) # Setup plot settings options menu self.plot_settings_button = self.tool_bar.widgetForAction( self._central_widget.plot_settings_action) self.plot_settings_button.setPopupMode(QToolButton.InstantPopup) self.plot_settings_menu = QMenu(self.plot_settings_button) self.plot_settings_button.setMenu(self.plot_settings_menu) self.color_change_action = QAction("Line Color") self.plot_settings_menu.addAction(self.color_change_action) self.line_width_menu = QMenu("Line Widths") self.plot_settings_menu.addMenu(self.line_width_menu) # Setup the line width plot setting options for i in range(1, 4): act = QAction(str(i), self.line_width_menu) self.line_width_menu.addAction(act) act.triggered.connect(lambda *args, size=i: self._on_change_width(size)) # Setup connections self._central_widget.pan_mode_action.triggered.connect( lambda: _toggle_mode(False)) self._central_widget.zoom_mode_action.triggered.connect( lambda: _toggle_mode(True)) self._central_widget.linear_region_action.triggered.connect( self.plot_widget._on_add_linear_region) self._central_widget.remove_region_action.triggered.connect( self.plot_widget._on_remove_linear_region) self.color_change_action.triggered.connect( self._on_change_color) self._central_widget.export_plot_action.triggered.connect( self._on_export_plot) self._central_widget.reset_view_action.triggered.connect( lambda: self._on_reset_view()) @property def tool_bar(self): """ Return the tool bar for the embedded plot widget. """ return self._central_widget.tool_bar @property def current_item(self): """ The currently selected plot data item. """ if self._current_item_index is not None: return self.proxy_model.item_from_index(self._current_item_index) @property def plot_widget(self): """ Return the embedded plot widget """ return self._plot_widget @property def proxy_model(self): """ The proxy model defined in the internal plot widget. """ return self.plot_widget.proxy_model def closeEvent(self, event): """ Called by qt when window closes, upon which it emits the window_removed signal. Parameters ---------- event : ignored in this implementation. """ self.window_removed.emit() def _on_current_item_changed(self, current_idx, prev_idx): self._current_item_index = current_idx def _on_reset_view(self): """ Resets the visible range of the plot taking into consideration only the PlotDataItem objects currently attached. """ self.plot_widget.autoRange( items=[item for item in self.plot_widget.listDataItems() if isinstance(item, PlotDataItem)]) self.plot_widget.sigRangeChanged.emit(*self.plot_widget.viewRange()) def _on_change_color(self): """ Listens for color changed events in plot windows, gets the currently selected item in the data list view, and changes the stored color value. """ # If there is no currently selected rows, raise an error if self.current_item is None: message_box = QMessageBox() message_box.setText("No item selected, cannot change color.") message_box.setIcon(QMessageBox.Warning) message_box.setInformativeText( "There is currently no item selected. Please select an item " "before changing its plot color.") message_box.exec() return color = QColorDialog.getColor(options=QColorDialog.ShowAlphaChannel) if color.isValid(): self.current_item.color = color.toRgb() self.color_changed.emit(self.current_item, self.current_item.color) def _on_change_width(self, size): self.plot_widget.change_width(size) self.width_changed.emit(size) def _on_export_plot(self): file_path, key = compat.getsavefilename(filters=";;".join( EXPORT_FILTERS.keys())) if key == '': return exporter = EXPORT_FILTERS[key](self.plot_widget.plotItem) # TODO: Current issue in pyqtgraph where the user cannot explicitly # define the output size. Fix incoming. # plot_size_dialog = PlotSizeDialog(self) # plot_size_dialog.height_line_edit.setText( # str(int(exporter.params.param('height').value()))) # plot_size_dialog.width_line_edit.setText( # str(int(exporter.params.param('width').value()))) # # if key != "*.svg": # if plot_size_dialog.exec_(): # exporter.params.param('height').setValue(int(exporter.params.param('height').value()), # blockSignal=exporter.heightChanged) # exporter.params.param('width').setValue(int(exporter.params.param('height').value()), # blockSignal=exporter.widthChanged) # else: # return exporter.export(file_path)