def __init__(self, qapp, name, parentWinName=None): super(MainWindow, self).__init__() self.qapp = qapp self.name = name self.panels = qapp.panels self.dragState = DragState.placed self.qapp.panels.ezm if not parentWinName is None: self.setParent(self.qapp.windows[parentWinName]) self.setWindowFlags(self.windowFlags() | Qt.Tool) #self.setWindowFlags(self.windowFlags() | Qt.WindowStaysOnTopHint) self.container = self.qapp.panels.ezm.new_container(self, self.name) self.setCentralWidget(self.container) self.setWindowTitle(f'[{self.name}]') self.createMenus() self.createStatusBar() #Hiding panelsDialog will disable all shortcuts sc = QShortcut( QKeySequence("Ctrl+Shift+Alt+F12"), self, lambda: self.qapp. panelsDialog.setVisible(not self.qapp.panelsDialog.isVisible())) sc.setContext(Qt.ApplicationShortcut) self.moveQueued.connect(self.moveWindow, Qt.QueuedConnection) self.activeCategory = None self.activePanId = None self.priorHoverButton = None
def _add_menus(self): """Add menubar to napari app.""" # TODO: move this to _QMainWindow... but then all of the Menu() # items will not have easy access to the methods on this Window obj. 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('Ctrl+M', self._qt_window) self._main_menu_shortcut.setEnabled(False) self._main_menu_shortcut.activated.connect( self._toggle_menubar_visible ) self.file_menu = menus.FileMenu(self) self.main_menu.addMenu(self.file_menu) self.view_menu = menus.ViewMenu(self) self.main_menu.addMenu(self.view_menu) self.window_menu = menus.WindowMenu(self) self.main_menu.addMenu(self.window_menu) self.plugins_menu = menus.PluginsMenu(self) self.main_menu.addMenu(self.plugins_menu) self.help_menu = menus.HelpMenu(self) self.main_menu.addMenu(self.help_menu) if perf.USE_PERFMON: self._debug_menu = menus.DebugMenu(self) self.main_menu.addMenu(self._debug_menu)
def fixed_shortcut(keystr, parent, action): """ DEPRECATED: This function will be removed in Spyder 4.0 Define a fixed shortcut according to a keysequence string """ sc = QShortcut(QKeySequence(keystr), parent, action) sc.setContext(Qt.WidgetWithChildrenShortcut) return sc
def __init__(self, parent): """Widget constructor.""" SpyderPluginWidget.__init__(self, parent) self.tab_widget = None self.menu_actions = None self.port = select_port(default_port=8070) self.server = subprocess.Popen([ sys.executable, osp.join(LOCATION, 'server', 'main.py'), '--port', str(self.port) ], stdout=subprocess.PIPE, stderr=subprocess.PIPE) time.sleep(0.5) self.main = parent self.terms = [] self.untitled_num = 0 self.initialize_plugin() layout = QVBoxLayout() new_term_btn = create_toolbutton(self, icon=ima.icon('project_expanded'), tip=_('Open a new terminal'), triggered=self.create_new_term) menu_btn = create_toolbutton(self, icon=ima.icon('tooloptions'), tip=_('Options')) self.menu = QMenu(self) menu_btn.setMenu(self.menu) menu_btn.setPopupMode(menu_btn.InstantPopup) add_actions(self.menu, self.menu_actions) # if self.get_option('first_time', True): # self.setup_shortcuts() # self.shortcuts = self.create_shortcuts() corner_widgets = {Qt.TopRightCorner: [new_term_btn, menu_btn]} self.tabwidget = Tabs(self, menu=self.menu, actions=self.menu_actions, corner_widgets=corner_widgets) if hasattr(self.tabwidget, 'setDocumentMode') \ and not sys.platform == 'darwin': # Don't set document mode to true on OSX because it generates # a crash when the console is detached from the main window # Fixes Issue 561 self.tabwidget.setDocumentMode(True) self.tabwidget.currentChanged.connect(self.refresh_plugin) self.tabwidget.move_data.connect(self.move_tab) self.tabwidget.set_close_function(self.close_term) layout.addWidget(self.tabwidget) self.setLayout(layout) paste_shortcut = QShortcut(QKeySequence("Ctrl+Shift+T"), self, self.create_new_term) paste_shortcut.setContext(Qt.WidgetWithChildrenShortcut)
def _config_shortcut(action, context, name, keystr, parent): """ Create a Shortcut namedtuple for a widget. The data contained in this tuple will be registered in our shortcuts preferences page. """ qsc = QShortcut(QKeySequence(keystr), parent, action) qsc.setContext(Qt.WidgetWithChildrenShortcut) sc = Shortcut(data=(qsc, context, name)) return sc
def config_shortcut(action, context, name, parent): """ Create a Shortcut namedtuple for a widget The data contained in this tuple will be registered in our shortcuts preferences page """ keystr = get_shortcut(context, name) qsc = QShortcut(QKeySequence(keystr), parent, action) qsc.setContext(Qt.WidgetWithChildrenShortcut) sc = Shortcut(data=(qsc, context, name)) return sc
def register_plugin(self): """Register plugin in Spyder's main window.""" try: # Spyder 3 compatibility super(Vim, self).register_plugin() except NotImplementedError: pass self.focus_changed.connect(self.main.plugin_focus_changed) self.vim_cmd.editor_widget.layout().addWidget(self.vim_cmd) sc = QShortcut(QKeySequence("Esc"), self.vim_cmd.editor_widget.editorsplitter, self.vim_cmd.commandline.setFocus) sc.setContext(Qt.WidgetWithChildrenShortcut)
def _add_menubar(self): 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 __init__(self, parent, term_url='http://127.0.0.1:8070'): """Webview main constructor.""" WebView.__init__(self, parent) self.parent = parent self.copy_action = create_action(self, _("Copy text"), icon=ima.icon('editcopy'), triggered=self.copy, shortcut='Ctrl+Alt+C') self.paste_action = create_action(self, _("Paste text"), icon=ima.icon('editpaste'), triggered=self.paste, shortcut='Ctrl+Alt+V') self.term_url = QUrl(term_url) self.load(self.term_url) copy_shortcut = QShortcut(QKeySequence("Ctrl+Alt+C"), self, self.copy) copy_shortcut.setContext(Qt.WidgetWithChildrenShortcut) paste_shortcut = QShortcut(QKeySequence("Ctrl+Alt+V"), self, self.paste) paste_shortcut.setContext(Qt.WidgetWithChildrenShortcut) if WEBENGINE: self.document = self.page() else: self.document = self.page().mainFrame() self.initial_y_pos = 0
def __init__(self, package, parent=None): QSplitter.__init__(self, parent) self.setWindowTitle(_("Tests - %s module") % package.__name__) self.setWindowIcon(get_icon("%s.svg" % package.__name__, "guidata.svg")) test_package_name = "%s.tests" % package.__name__ _temp = __import__(test_package_name) test_package = sys.modules[test_package_name] tests = get_tests(test_package) listwidget = QListWidget(self) listwidget.addItems([osp.basename(test.filename) for test in tests]) self.properties = TestPropertiesWidget(self) self.addWidget(listwidget) self.addWidget(self.properties) self.properties.run_button.clicked.connect( lambda: tests[listwidget.currentRow()].run()) self.properties.quit_button.clicked.connect(self.close) listwidget.currentRowChanged.connect( lambda row: self.properties.set_item(tests[row])) listwidget.itemActivated.connect( lambda: tests[listwidget.currentRow()].run()) listwidget.setCurrentRow(0) QShortcut(QKeySequence("Escape"), self, self.close) self.setSizes([150, 1]) self.setStretchFactor(1, 1) self.resize(QSize(950, 600)) self.properties.set_item(tests[0])
def _create_dockwidget(self): """Add to parent QMainWindow as a dock widget""" # Creating dock widget dock = SpyderDockWidget(self.get_plugin_title(), self.main) # Set properties dock.setObjectName(self.__class__.__name__ + "_dw") dock.setAllowedAreas(dock.ALLOWED_AREAS) dock.setFeatures(dock.FEATURES) dock.setWidget(self) self._update_margins() dock.visibilityChanged.connect(self._visibility_changed) dock.topLevelChanged.connect(self._on_top_level_changed) dock.sig_plugin_closed.connect(self._plugin_closed) self.dockwidget = dock # NOTE: Don't use the default option of CONF.get to assign a # None shortcut to plugins that don't have one. That will mess # the creation of our Keyboard Shortcuts prefs page try: context = '_' name = 'switch to {}'.format(self.CONF_SECTION) self.shortcut = CONF.get_shortcut(context, name, plugin_name=self.CONF_SECTION) except (configparser.NoSectionError, configparser.NoOptionError): pass if self.shortcut is not None and self.main is not None: sc = QShortcut(QKeySequence(self.shortcut), self.main, self.switch_to_plugin) self.register_shortcut(sc, "_", "Switch to {}".format(self.CONF_SECTION)) return (dock, dock.LOCATION)
def create_dockwidget(self): """Add to parent QMainWindow as a dock widget""" # This is not clear yet why the following do not work... # (see Issue #880) ## # Using Qt.Window window flags solves Issue #880 (detached dockwidgets ## # are not painted after restarting Spyder and restoring their hexstate) ## # but it does not work with PyQt <=v4.7 (dockwidgets can't be docked) ## # or non-Windows platforms (lot of warnings are printed out) ## # (so in those cases, we use the default window flags: Qt.Widget): ## flags = Qt.Widget if is_old_pyqt or os.name != 'nt' else Qt.Window dock = SpyderDockWidget(self.get_plugin_title(), self.main) #, flags) dock.setObjectName(self.__class__.__name__ + "_dw") dock.setAllowedAreas(self.ALLOWED_AREAS) dock.setFeatures(self.FEATURES) dock.setWidget(self) self.update_margins() dock.visibilityChanged.connect(self.visibility_changed) dock.plugin_closed.connect(self.plugin_closed) self.dockwidget = dock if self.shortcut is not None: sc = QShortcut(QKeySequence(self.shortcut), self.main, self.switch_to_plugin) self.register_shortcut(sc, "_", "Switch to %s" % self.CONF_SECTION) return (dock, self.LOCATION)
def __init__(self, parent=None, macros=None, **kwargs): super().__init__(parent=parent, macros=macros, ui_filename=EPICSTEL_MAIN_UI) self.login_remote() self.delete_pv_btn.clicked.connect(self.del_pv) self.delete_user_btn.clicked.connect(self.del_user) self.delete_team_btn.clicked.connect(self.del_team) self.add_user_btn.clicked.connect(lambda: self.show_add_dialog("user")) self.add_pv_btn.clicked.connect(lambda: self.show_add_dialog("pv")) self.add_team_btn.clicked.connect(lambda: self.show_add_dialog("team")) self.pvs_table.clicked.connect(lambda c: self.cell_clicked(c, "pvs")) self.teams_table.clicked.connect( lambda c: self.cell_clicked(c, "teams")) self.users_table.clicked.connect( lambda c: self.cell_clicked(c, "users")) ip_regex = "^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]).){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$" self.ca_addr_input.setValidator(QRegExpValidator(QRegExp(ip_regex))) self.del_sc = QShortcut(QKeySequence("Del"), self) self.del_sc.activated.connect(self.del_ca_addr) self.add_ca_addr_btn.clicked.connect(self.add_ca_addr)
def setupKeyboardShortcuts(self): for index, shortcut in enumerate( (sc.openControlPanelTab0, sc.openControlPanelTab1, sc.openControlPanelTab2, sc.openControlPanelTab3, sc.openControlPanelTab4, sc.openControlPanelTab5)): shortcut = QShortcut(QKeySequence(shortcut), self) shortcut.activated.connect( lambda index=index: self.tabs.setCurrentIndex(index))
def __init__(self, *args, **kwargs): super(DebuggableMenuBar, self).__init__(*args, **kwargs) self.debugshortcut = QShortcut(QKeySequence("Ctrl+Return"), self, self.showDebugMenu, context=Qt.ApplicationShortcut) self._debugmenu = QMenu("Debugging") self._debugmenu.addAction("Debug widget", self.startDebugging) self._debugmenu.addAction("Hot-reload", plugin_manager.hot_reload) self.mousedebugger = MouseDebugger()
def __init__(self): QPlainTextEdit.__init__(self) self.setWordWrapMode(QTextOption.NoWrap) self.setFont(QFont("monospace", 10)) self.setCursorWidth(2) self.installEventFilter(self) self.completer = QCompleter(self) self.completer.setWidget(self) self.completer.setCaseSensitivity(Qt.CaseInsensitive) self.completer.activated.connect(self.insertCompletion) auto_complete = QShortcut(QKeySequence("Ctrl+Space"), self) auto_complete.activated.connect(self.activateCompleter) copy_line = QShortcut(QKeySequence("Ctrl+D"), self) copy_line.activated.connect(self.duplicateLine) select_fragment = QShortcut(QKeySequence("Ctrl+J"), self) select_fragment.activated.connect(self.selectFragment)
def __init__(self, main_window, shortcut): self.shortcut = shortcut self.main_window = main_window shortcut_ = QShortcut(self.shortcut, main_window) shortcut_.setContext(Qt.ApplicationShortcut) def ShowStyleSheetEditor(): style_sheet_inspector_class = GetStyleSheetInspectorClass() style_sheet_inspector = [ c for c in self.main_window.children() if isinstance(c, style_sheet_inspector_class) ] if style_sheet_inspector: style_sheet_inspector = style_sheet_inspector[0] else: style_sheet_inspector = style_sheet_inspector_class( self.main_window) style_sheet_inspector.setFixedSize(600, 400) style_sheet_inspector.show() shortcut_.activated.connect(ShowStyleSheetEditor)
def setup_shortcuts(self): self.searchSC_Home = QShortcut('Home', self) self.searchSC_Home.activated.connect( partial(self.loggerTable.selectRow, 0)) self.searchSC_Home.setAutoRepeat(False) self.searchSC_End = QShortcut('End', self) self.searchSC_End.activated.connect(self.select_last_row) self.searchSC_End.setAutoRepeat(False) self.searchSC = QShortcut('Ctrl+F', self) self.searchSC.activated.connect(self.toggle_search) self.searchSC.setAutoRepeat(False) self.searchSC_F3 = QShortcut('F3', self) self.searchSC_F3.activated.connect(self.search_down_or_close) self.searchSC_F3.setAutoRepeat(True) self.searchSC_Esc = QShortcut('Esc', self) self.searchSC_Esc.activated.connect( partial(self.set_search_visible, False)) self.searchSC_Esc.setAutoRepeat(False)
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 __init__(self, parent=None, table_view: 'PMTableView' = None): super().__init__(parent) self.setLayout(QVBoxLayout()) self.top_layout = QHBoxLayout() self.layout().addLayout(self.top_layout) self.table_view = table_view self.slice_input = QLineEdit() self.help_button = QPushButton(QCoreApplication.translate('PMGTableViewer','Help')) self.slice_refresh_button = QPushButton(QCoreApplication.translate('PMGTableViewer','Slice')) self.save_change_button = QPushButton(QCoreApplication.translate('PMGTableViewer','Save')) self.goto_cell_button = QPushButton(QCoreApplication.translate('PMGTableViewer','Go To Cell')) self.save_change_button.clicked.connect(self.on_save) self.slice_refresh_button.clicked.connect(self.slice) self.help_button.clicked.connect(self.on_help) self.goto_cell_button.clicked.connect(self.on_goto_cell) self.slice_input.hide() self.slice_refresh_button.hide() self.table_view.signal_need_save.connect(self.signal_need_save.emit) self.signal_need_save.connect(self.on_signal_need_save) self.top_layout.addWidget(self.goto_cell_button) self.top_layout.addWidget(self.save_change_button) self.top_layout.addWidget(self.help_button) self.top_layout.addWidget(self.slice_input) self.top_layout.addWidget(self.slice_refresh_button) self.top_layout.addItem(QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Minimum)) if table_view is not None: self.layout().addWidget(self.table_view) self.shortcut_save = QShortcut(QKeySequence.Save, self.table_view, context=Qt.WidgetShortcut) self.shortcut_save.activated.connect(self.on_save) self.shortcut_goto = QShortcut(QKeySequence('Ctrl+G'), self.table_view, context=Qt.WidgetShortcut) self.shortcut_goto.activated.connect(self.on_goto_cell)
def __connect__(self): """ Connects events to event handlers. :return: """ self.ui.action_AddDay.triggered.connect(self.add_new_day) self.ui.action_Exit.triggered.connect(self.close) self.ui.list_days.itemClicked.connect(self.activated_details) self.ui.pushButton_addRow.clicked.connect(self.add_entry_row) self.ui.pushButton_save.clicked.connect(self.save_entity_table) self.ui.pushButton_addBookRow.clicked.connect(self.add_booking_row) self.ui.pushButton_saveBookRow.clicked.connect(self.save_booking_table) self.ui.pushButton_deleteEntityRow.clicked.connect(self.delete_entry_row) self.ui.pushButton_deleteBookingRow.clicked.connect(self.delete_booking_row) self.ui.pushButton_copyTime.clicked.connect(self.copy_entries_to_bookings) self.ui.pushButton_rowUp.clicked.connect(self.shift_up_entry_row) self.ui.pushButton_rowDown.clicked.connect(self.shift_down_entry_row) self.ui.pushButton_bookingRowUp.clicked.connect(self.shift_up_booking_row) self.ui.pushButton_bookingRowDown.clicked.connect(self.shift_down_booking_row) self.ui.tabWidget_Details.currentChanged.connect(self.__set_selected_tab__) QShortcut(QKeySequence("Alt+a"), self, self.hit_alt_a) QShortcut(QKeySequence("Alt+d"), self, self.hit_alt_d) QShortcut(QKeySequence("Alt+s"), self, self.hit_alt_s)
def event_startup(self): from jupyter_tabwidget import ConsoleTabWidget self.set_busy(True) self._jupyter_console = ConsoleTabWidget(self.main_window) self._dock_widget = QDockWidget(u'Console', self.main_window) self._dock_widget.setObjectName(u'JupyterConsole') self._dock_widget.setWidget(self._jupyter_console) self._dock_widget.closeEvent = self._on_close_event self.main_window.addDockWidget(Qt.BottomDockWidgetArea, self._dock_widget) self._set_visible(cfg.jupyter_visible) self._shortcut_focus = QShortcut(QKeySequence( cfg.jupyter_focus_shortcut), self.main_window, self._focus, context=Qt.ApplicationShortcut) self.set_busy(False)
def _create_dockwidget(self): """Add to parent QMainWindow as a dock widget""" # Creating dock widget dock = SpyderDockWidget(self.get_plugin_title(), self.main) # Set properties dock.setObjectName(self.__class__.__name__ + "_dw") dock.setAllowedAreas(self._ALLOWED_AREAS) dock.setFeatures(self._FEATURES) dock.setWidget(self) self._update_margins() dock.visibilityChanged.connect(self._visibility_changed) dock.topLevelChanged.connect(self._on_top_level_changed) dock.sig_plugin_closed.connect(self._plugin_closed) self.dockwidget = dock if self.shortcut is not None: sc = QShortcut(QKeySequence(self.shortcut), self.main, self.switch_to_plugin) self.register_shortcut(sc, "_", "Switch to %s" % self.CONF_SECTION) return (dock, self._LOCATION)
def __init__(self, parent, model): # check model if not isinstance(model, DataArrayModel): raise TypeError( "Expected model of type {}. Received {} instead".format( DataArrayModel.__name__, type(model).__name__)) AbstractView.__init__(self, parent, model, RIGHT, BOTTOM) self.context_menu = self.setup_context_menu() # TODO: find a cleaner way to do this # For some reason the shortcuts in the context menu are not available if the widget does not have the focus, # EVEN when using action.setShortcutContext(Qt.ApplicationShortcut) (or Qt.WindowShortcut) so we redefine them # here. I was also unable to get the function an action.triggered is connected to, so I couldn't do this via # a loop on self.context_menu.actions. shortcuts = [(keybinding('Copy'), self.parent().copy), (QKeySequence("Ctrl+E"), self.parent().to_excel), (keybinding('Paste'), self.parent().paste), (keybinding('Print'), self.parent().plot)] for key_seq, target in shortcuts: shortcut = QShortcut(key_seq, self) shortcut.activated.connect(target)
def setup_ui(self): """Initialize widgets.""" def switch_style(i): view = self.landscape_view if self.view_mode == MainApp.LANDSCAPE else self.portrait_view self.style_changed.emit(self.styles[i]) view.selected_style = self.styles[i] for i in range(min(len(self.styles), len(settings.STYLE_SHORTCUTS))): QShortcut(QKeySequence(settings.STYLE_SHORTCUTS[i]), self, lambda x=i: switch_style(x)) self.landscape_view = LandscapeView(self.styles) self.landscape_view.style_changed.connect(self.style_button_clicked) self.landscape_view.toggle_fullscreen_signal.connect( self.toggle_fullscreen) self.landscape_view.quality_changed.connect(self.quality_choice) self.portrait_view = PortraitView(self.styles) self.portrait_view.style_changed.connect(self.style_button_clicked) self.portrait_view.toggle_fullscreen_signal.connect( self.toggle_fullscreen) self.portrait_view.quality_changed.connect(self.quality_choice) self.main_layout = QStackedLayout() self.main_layout.addWidget(self.landscape_view) self.main_layout.addWidget(self.portrait_view) self.setLayout(self.main_layout) self.view_mode = MainApp.LANDSCAPE self.setStyleSheet('background-color:black;' 'font-family: Arial;' 'font-style: normal;' 'font-size: 12pt;' 'font-weight: bold;' 'color:white;') self.setWindowTitle('Stylize')
def __init__(self, parent, init_val): super(EditVal_Dialog, self).__init__(parent) # shortcut save_shortcut = QShortcut(QKeySequence.Save, self) save_shortcut.activated.connect(self.save_triggered) main_layout = QVBoxLayout() self.val_text_edit = QPlainTextEdit() val_str = '' try: val_str = str(init_val) except Exception as e: msg_box = QMessageBox(QMessageBox.Warning, 'Value parsing failed', 'Couldn\'t stringify value', QMessageBox.Ok, self) msg_box.setDefaultButton(QMessageBox.Ok) msg_box.exec_() self.reject() self.val_text_edit.setPlainText(val_str) main_layout.addWidget(self.val_text_edit) button_box = QDialogButtonBox() button_box.setStandardButtons(QDialogButtonBox.Cancel | QDialogButtonBox.Ok) button_box.accepted.connect(self.accept) button_box.rejected.connect(self.reject) main_layout.addWidget(button_box) self.setLayout(main_layout) self.resize(450, 300) self.setWindowTitle('edit val')
class Window: """Application window that contains the menu bar and viewer. Parameters ---------- qt_viewer : QtViewer Contained viewer widget. Attributes ---------- qt_viewer : QtViewer Contained viewer widget. """ def __init__(self, qt_viewer, *, show=True): self.qt_viewer = qt_viewer self._qt_window = QMainWindow() self._qt_window.setUnifiedTitleAndToolBarOnMac(True) self._qt_center = QWidget() self._qt_window.setCentralWidget(self._qt_center) self._qt_window.setWindowTitle(self.qt_viewer.viewer.title) self._qt_center.setLayout(QHBoxLayout()) self._status_bar = self._qt_window.statusBar() self._qt_window.closeEvent = self.closeEvent self.close = self._qt_window.close self._add_menubar() self._add_file_menu() self._add_view_menu() self._add_window_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_palette(qt_viewer.viewer.palette) 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.palette.connect( lambda event: self._update_palette(event.palette)) if show: self.show() def _add_menubar(self): 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): open_images = QAction('Open', self._qt_window) open_images.setShortcut('Ctrl+O') open_images.setStatusTip('Open image file(s)') open_images.triggered.connect(self.qt_viewer._open_images) self.file_menu = self.main_menu.addMenu('&File') self.file_menu.addAction(open_images) def _add_view_menu(self): 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) self.view_menu = self.main_menu.addMenu('&View') self.view_menu.addAction(toggle_visible) def _add_window_menu(self): 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) self.window_menu = self.main_menu.addMenu('&Window') self.window_menu.addAction(exit_action) 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() self._qt_window.raise_() def _update_palette(self, palette): # set window styles which don't use the primary stylesheet # FIXME: this is a problem with the stylesheet not using properties self._status_bar.setStyleSheet( template( 'QStatusBar { background: {{ background }}; ' 'color: {{ text }}; }', **palette, )) self._qt_center.setStyleSheet( template('QWidget { background: {{ background }}; }', **palette)) def _status_changed(self, event): """Update status bar. """ self._status_bar.showMessage(event.text) def _title_changed(self, event): """Update window title. """ self._qt_window.setWindowTitle(event.text) def _help_changed(self, event): """Update help message on status bar. """ self._help.setText(event.text) def closeEvent(self, event): # Forward close event to the console to trigger proper shutdown self.qt_viewer.console.shutdown() event.accept()
def __init__(self, parent=None, opts=None, ui_file=None, stylesheet=None, maximize=False, fullscreen=False, position=None, size=None, confirm_exit=True, title=None, menu='default'): super(VCPMainWindow, self).__init__(parent) if opts is None: opts = qtpyvcp.OPTIONS self.setWindowTitle(title) self.app = QApplication.instance() self.confirm_exit = confirm_exit if opts.confirm_exit is None else opts.confirm_exit # Load the UI file AFTER defining variables, otherwise the values # set in QtDesigner get overridden by the default values if ui_file is not None: self.loadUi(ui_file) self.initUi() if menu is not None: try: # delete any preexisting menuBar added in QtDesigner # because it shadows the QMainWindow.menuBar() method del self.menuBar except AttributeError: pass if menu == 'default': menu = qtpyvcp.CONFIG.get('default_menubar', []) self.setMenuBar(self.buildMenuBar(menu)) if title is not None: self.setWindowTitle(title) if stylesheet is not None: self.loadStylesheet(stylesheet) maximize = opts.maximize if opts.maximize is not None else maximize if maximize: QTimer.singleShot(0, self.showMaximized) fullscreen = opts.fullscreen if opts.fullscreen is not None else fullscreen if fullscreen: QTimer.singleShot(0, self.showFullScreen) if opts.hide_menu_bar: self.menuBar().hide() size = opts.size or size if size: try: width, height = size.lower().split('x') self.resize(int(width), int(height)) except: LOG.exception('Error parsing --size argument: %s', size) pos = opts.position or position if pos: try: xpos, ypos = pos.lower().split('x') self.move(int(xpos), int(ypos)) except: LOG.exception('Error parsing --position argument: %s', pos) QShortcut(QKeySequence("F11"), self, self.toggleFullscreen) self.app.focusChanged.connect(self.focusChangedEvent)
class Window: """Application window that contains the menu bar and viewer. Parameters ---------- qt_viewer : QtViewer 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 = combine_stylesheets() def __init__(self, qt_viewer, *, show=True): self.qt_viewer = qt_viewer self._qt_window = QMainWindow() self._qt_window.setAttribute(Qt.WA_DeleteOnClose) self._qt_window.setUnifiedTitleAndToolBarOnMac(True) self._qt_center = QWidget(self._qt_window) self._qt_window.setCentralWidget(self._qt_center) self._qt_window.setWindowTitle(self.qt_viewer.viewer.title) self._qt_center.setLayout(QHBoxLayout()) self._status_bar = QStatusBar() self._qt_window.setStatusBar(self._status_bar) self._add_menubar() self._add_file_menu() self._add_view_menu() self._add_window_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_palette(qt_viewer.viewer.palette) if self.qt_viewer.console.shell is not None: self._add_viewer_dock_widget(self.qt_viewer.dockConsole) self._add_viewer_dock_widget(self.qt_viewer.dockLayerControls) self._add_viewer_dock_widget(self.qt_viewer.dockLayerList) 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.palette.connect( lambda event: self._update_palette(event.palette)) 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 image(s)...', self._qt_window) open_images.setShortcut('Ctrl+O') open_images.setStatusTip('Open image file(s)') open_images.triggered.connect(self.qt_viewer._open_images) open_folder = QAction('Open Folder...', self._qt_window) open_folder.setShortcut('Ctrl+Shift+O') open_folder.setStatusTip( 'Open a folder of image file(s) or a zarr file') open_folder.triggered.connect(self.qt_viewer._open_folder) screenshot = QAction('Screenshot', self._qt_window) screenshot.setShortcut('Ctrl+Alt+S') screenshot.setStatusTip( 'Save screenshot of current display, default .png') screenshot.triggered.connect(self.qt_viewer._save_screenshot) self.file_menu = self.main_menu.addMenu('&File') self.file_menu.addAction(open_images) self.file_menu.addAction(open_folder) self.file_menu.addAction(screenshot) 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) self.view_menu = self.main_menu.addMenu('&View') self.view_menu.addAction(toggle_visible) self.view_menu.addAction(toggle_theme) 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) self.window_menu = self.main_menu.addMenu('&Window') self.window_menu.addAction(exit_action) 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_keybindings = QAction("keybindings", self._qt_window) about_keybindings.setShortcut("Ctrl+Alt+/") about_keybindings.setShortcutContext(Qt.ApplicationShortcut) about_keybindings.setStatusTip('keybindings') about_keybindings.triggered.connect( self.qt_viewer.show_keybindings_dialog) self.help_menu.addAction(about_keybindings) 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) return dock_widget def _add_viewer_dock_widget(self, dock_widget: QtViewerDockWidget): """Add a QtViewerDockWidget to the main window Parameters ---------- dock_widget : QtViewerDockWidget `dock_widget` will be added to the main window. """ dock_widget.setParent(self._qt_window) self._qt_window.addDockWidget(dock_widget.qt_area, dock_widget) 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): """Removes specified dock widget. Parameters ---------- widget : QWidget | str If widget == 'all', all docked widgets will be removed. """ if widget == 'all': for dw in self._qt_window.findChildren(QDockWidget): self._qt_window.removeDockWidget(dw) else: self._qt_window.removeDockWidget(widget) 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() # We want to call Window._qt_window.raise_() in every case *except* # when instantiating a viewer within a gui_qt() context for the # _first_ time within the Qt app's lifecycle. # # `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 #732 app_name = QApplication.instance().applicationName() if app_name != 'napari' or self._qt_window.isActiveWindow(): self._qt_window.raise_() # for macOS self._qt_window.activateWindow() # for Windows def _update_palette(self, palette): """Update widget color palette. Parameters ---------- palette : qtpy.QtGui.QPalette Color palette for each widget state (Active, Disabled, Inactive). """ # set window styles which don't use the primary stylesheet # FIXME: this is a problem with the stylesheet not using properties self._status_bar.setStyleSheet( template( 'QStatusBar { background: {{ background }}; ' 'color: {{ text }}; }', **palette, )) self._qt_center.setStyleSheet( template('QWidget { background: {{ background }}; }', **palette)) self._qt_window.setStyleSheet(template(self.raw_stylesheet, **palette)) def _status_changed(self, event): """Update status bar. Parameters ---------- event : qtpy.QtCore.QEvent Event from the Qt context. """ self._status_bar.showMessage(event.text) def _title_changed(self, event): """Update window title. Parameters ---------- event : qtpy.QtCore.QEvent Event from the Qt context. """ self._qt_window.setWindowTitle(event.text) def _help_changed(self, event): """Update help message on status bar. Parameters ---------- event : qtpy.QtCore.QEvent Event from the Qt context. """ self._help.setText(event.text) 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.""" # 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 new_shortcut(keystr, parent, action): """Define a new shortcut according to a keysequence string""" sc = QShortcut(QKeySequence(keystr), parent, action) sc.setContext(Qt.WidgetWithChildrenShortcut) return sc
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): # Check there is a running app # instance() returns the singleton instance if it exists, or None app = QApplication.instance() # if None, raise a RuntimeError with the appropriate message if app is None: message = ( "napari requires a Qt event loop to run. To create one, " "try one of the following: \n" " - use the `napari.gui_qt()` context manager. See " "https://github.com/napari/napari/tree/master/examples for" " usage examples.\n" " - In IPython or a local Jupyter instance, use the " "`%gui qt` magic command.\n" " - Launch IPython with the option `--gui=qt`.\n" " - (recommended) in your IPython configuration file, add" " or uncomment the line `c.TerminalIPythonApp.gui = 'qt'`." " Then, restart IPython." ) raise RuntimeError(message) if perf_config: if perf_config.trace_qt_events: from .tracing.qt_event_tracing import convert_app_for_tracing # For tracing Qt events we need a special QApplication. If # using `gui_qt` we already have the special one, and no # conversion is done here. However when running inside # IPython or Jupyter this is where we switch out the # QApplication. app = convert_app_for_tracing(app) # Will patch based on config file. perf_config.patch_callables() _napari_app_id = getattr( viewer, "_napari_app_id", 'napari.napari.viewer.' + str(__version__), ) if ( platform.system() == "Windows" and not getattr(sys, 'frozen', False) and _napari_app_id ): import ctypes ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID( _napari_app_id ) logopath = os.path.join( os.path.dirname(__file__), '..', 'resources', 'logo.png' ) if getattr(viewer, "_napari_global_logo", True): app = QApplication.instance() app.setWindowIcon(QIcon(logopath)) # see docstring of `wait_for_workers_to_quit` for caveats on killing # workers at shutdown. app.aboutToQuit.connect(wait_for_workers_to_quit) # Connect the Viewer and create the Main Window self.qt_viewer = QtViewer(viewer) self._qt_window = QMainWindow() self._qt_window.setWindowIcon(QIcon(logopath)) self._qt_window.setAttribute(Qt.WA_DeleteOnClose) self._qt_window.setUnifiedTitleAndToolBarOnMac(True) # 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._qt_center = QWidget(self._qt_window) self._qt_window.setCentralWidget(self._qt_center) self._qt_window.setWindowTitle(self.qt_viewer.viewer.title) self._qt_center.setLayout(QHBoxLayout()) self._status_bar = QStatusBar() self._qt_window.setStatusBar(self._status_bar) self._add_menubar() self._add_file_menu() self._add_view_menu() self._add_window_menu() if not os.getenv("DISABLE_ALL_PLUGINS"): 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_palette() self._add_viewer_dock_widget(self.qt_viewer.dockConsole) self._add_viewer_dock_widget(self.qt_viewer.dockLayerControls) self._add_viewer_dock_widget(self.qt_viewer.dockLayerList) 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.palette.connect(self._update_palette) 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() 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) self.window_menu = self.main_menu.addMenu('&Window') self.window_menu.addAction(exit_action) 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) 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_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) return dock_widget def _add_viewer_dock_widget(self, dock_widget: QtViewerDockWidget): """Add a QtViewerDockWidget to the main window Parameters ---------- dock_widget : QtViewerDockWidget `dock_widget` will be added to the main window. """ dock_widget.setParent(self._qt_window) self._qt_window.addDockWidget(dock_widget.qt_area, dock_widget) 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): """Removes specified dock widget. Parameters ---------- widget : QWidget | str If widget == 'all', all docked widgets will be removed. """ if widget == 'all': for dw in self._qt_window.findChildren(QDockWidget): self._qt_window.removeDockWidget(dw) else: self._qt_window.removeDockWidget(widget) 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_palette(self, event=None): """Update widget color palette.""" # set window styles which don't use the primary stylesheet # FIXME: this is a problem with the stylesheet not using properties palette = self.qt_viewer.viewer.palette self._status_bar.setStyleSheet( template( 'QStatusBar { background: {{ background }}; ' 'color: {{ text }}; }', **palette, ) ) self._qt_center.setStyleSheet( template('QWidget { background: {{ background }}; }', **palette) ) self._qt_window.setStyleSheet(template(self.raw_stylesheet, **palette)) 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.text) 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.text) 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.text) 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
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