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 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 _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
