def __init__(self, parent=None): super(MainWindowBase, self).__init__(parent) # Do the import here to update the splash import hyperspyui.mdi_mpl_backend from hyperspyui.settings import Settings # Setup settings: self.settings = Settings(self, 'General') # Default setting values: self.settings.set_default('toolbar_button_size', 24) self.settings.set_default('default_widget_floating', False) self.settings.set_default('working_directory', "") self.settings.set_default('low_process_priority', False) # Override any possible invalid stored values, which could prevent load if 'toolbar_button_size' not in self.settings or \ not isinstance(self.settings['toolbar_button_size'], int): self.settings['toolbar_button_size'] = 24 if self.low_process_priority: lowpriority() # State varaibles self.should_capture_traits = None self.active_tool = None # Collections self.widgets = [] # Widgets in widget bar self.figures = [] # Matplotlib figures self.editors = [] # EditorWidgets self.traits_dialogs = [] self.actions = {} self._action_selection_cbs = {} self.toolbars = {} self.menus = {} self.tools = [] self.plugin_manager = None # MPL backend bindings hyperspyui.mdi_mpl_backend.connect_on_new_figure(self.on_new_figure) hyperspyui.mdi_mpl_backend.connect_on_destroy(self.on_destroy_figure) # Create UI self.windowmenu = None self.create_ui() # Connect figure management functions self.main_frame.subWindowActivated.connect(self.on_subwin_activated) # Save standard layout/state self.settings.set_default('_geometry', self.saveGeometry()) self.settings.set_default('_windowState', self.saveState()) # Restore layout/state if saved geometry = self.settings['_geometry'] state = self.settings['_windowState'] if geometry: self.restoreGeometry(geometry) if state: self.restoreState(state)
def main(): from python_qt_binding import QtGui, QtCore, QT_BINDING import hyperspyui.info from hyperspyui.singleapplication import get_app from hyperspyui.settings import Settings from hyperspyui.util import dummy_context_manager # Need to set early to make QSettings accessible QtCore.QCoreApplication.setApplicationName("HyperSpyUI") QtCore.QCoreApplication.setOrganizationName("Hyperspy") QtCore.QCoreApplication.setApplicationVersion(hyperspyui.info.version) # First, clear all default settings! Settings.clear_defaults() # Setup default for single/multi-instance settings = Settings(group="General") settings.set_default('allow_multiple_instances', False) if settings['allow_multiple_instances', bool]: # Using multiple instances, get a new application app = QtGui.QApplication(sys.argv) else: # Make sure we only have a single instance app = get_app('hyperspyui') log_file = _get_logfile() if log_file: sys.stdout = sys.stderr = log_file else: log_file = dummy_context_manager() with log_file: # Create and display the splash screen splash_pix = QtGui.QPixmap( os.path.dirname(__file__) + './images/splash.png') splash = QtGui.QSplashScreen(splash_pix, QtCore.Qt.WindowStaysOnTopHint) splash.setMask(splash_pix.mask()) splash.show() app.processEvents() # Need to have import here, as it can take some time, so should happen # after displaying splash from hyperspyui.mainwindow import MainWindow form = MainWindow() if not settings['allow_multiple_instances', bool]: if QT_BINDING == 'pyqt': app.messageAvailable.connect(form.handleSecondInstance) elif QT_BINDING == 'pyside': app.messageReceived.connect(form.handleSecondInstance) form.showMaximized() splash.finish(form) form.load_complete.emit() # Ensure logging is OK import hyperspy.api as hs hs.set_log_level(LOGLEVEL) app.exec_()
def main(): from qtpy.QtCore import Qt, QCoreApplication from qtpy.QtWidgets import QApplication from qtpy import API import hyperspyui.info from hyperspyui.settings import Settings QCoreApplication.setAttribute(Qt.AA_ShareOpenGLContexts) # Need to set early to make QSettings accessible QCoreApplication.setApplicationName("HyperSpyUI") QCoreApplication.setOrganizationName("Hyperspy") QCoreApplication.setApplicationVersion(hyperspyui.info.__version__) # First, clear all default settings! # TODO: This will cause a concurrency issue with multiple launch Settings.clear_defaults() # Setup default for single/multi-instance settings = Settings(group="General") settings.set_default('allow_multiple_instances', False) if settings['allow_multiple_instances', bool]: # Using multiple instances, get a new application app = QApplication(sys.argv) else: # Make sure we only have a single instance from hyperspyui.singleapplication import get_app app = get_app('hyperspyui') splash = get_splash() log_file = _get_logfile() if log_file: sys.stdout = sys.stderr = log_file else: @contextmanager def dummy_context_manager(*args, **kwargs): yield log_file = dummy_context_manager() with log_file: # Need to have import here, since QApplication needs to be called first from hyperspyui.mainwindow import MainWindow form = MainWindow(splash=splash) if not settings['allow_multiple_instances', bool]: if "pyqt" in API: app.messageAvailable.connect(form.handleSecondInstance) elif API == 'pyside': app.messageReceived.connect(form.handleSecondInstance) form.showMaximized() form.splash.hide() form.load_complete.emit() # Ensure logging is OK import hyperspy.api as hs hs.set_log_level(LOGLEVEL) app.exec_()
def _create_settings_widgets(self, settings): """ Create a widget for a settings instance, containing label/editor pairs for each setting in the current level of the passed QSettings instance. The key of the setting is used as the label, but it's capitalized and underscores are replaced by spaces. """ wrap = QWidget(self) form = QFormLayout() hint_lookup = Settings() for k in settings.allKeys(): if k.startswith("_"): continue # Ignore hidden keys v = settings.value(k) # Read value label = k.capitalize().replace('_', ' ') abs_key = settings.group() + '/' + k self._initial_values[abs_key] = v # Store initial value hints = hint_lookup.get_enum_hint(abs_key) # Check for enum hints # Create a fitting editor widget based on value type: if hints is not None: w = QComboBox() w.addItems(hints) w.setEditable(True) w.setEditText(v) w.editTextChanged.connect( partial(self._on_setting_changed, abs_key, w)) elif isinstance(v, str): if v.lower() in ('true', 'false'): w = QCheckBox() w.setChecked(v.lower() == 'true') w.toggled.connect( partial(self._on_setting_changed, abs_key, w)) else: w = QLineEdit(v) w.textChanged.connect( partial(self._on_setting_changed, abs_key, w)) elif isinstance(v, int): w = QSpinBox() w.setRange(np.iinfo(np.int32).min, np.iinfo(np.int32).max) w.setValue(v) w.valueChanged.connect( partial(self._on_setting_changed, abs_key, w)) elif isinstance(v, float): w = QDoubleSpinBox() w.setRange(np.finfo(np.float32).min, np.finfo(np.float32).max) w.setValue(v) w.valueChanged.connect( partial(self._on_setting_changed, abs_key, w)) else: w = QLineEdit(str(v)) w.textChanged.connect( partial(self._on_setting_changed, abs_key, w)) self._lut[abs_key] = w form.addRow(label, w) wrap.setLayout(form) return wrap
def _create_settings_widgets(self, settings): """ Create a widget for a settings instance, containing label/editor pairs for each setting in the current level of the passed QSettings instance. The key of the setting is used as the label, but it's capitalized and underscores are replaced by spaces. """ wrap = QWidget(self) form = QFormLayout() hint_lookup = Settings() for k in settings.allKeys(): if k.startswith("_"): continue # Ignore hidden keys v = settings.value(k) # Read value label = k.capitalize().replace('_', ' ') abs_key = settings.group() + '/' + k self._initial_values[abs_key] = v # Store initial value hints = hint_lookup.get_enum_hint(abs_key) # Check for enum hints # Create a fitting editor widget based on value type: if hints is not None: w = QComboBox() w.addItems(hints) w.setEditable(True) w.setEditText(v) w.editTextChanged.connect(partial(self._on_setting_changed, abs_key, w)) elif isinstance(v, str): if v.lower() in ('true', 'false'): w = QCheckBox() w.setChecked(v.lower() == 'true') w.toggled.connect(partial(self._on_setting_changed, abs_key, w)) else: w = QLineEdit(v) w.textChanged.connect(partial(self._on_setting_changed, abs_key, w)) elif isinstance(v, int): w = QSpinBox() w.setRange(np.iinfo(np.int32).min, np.iinfo(np.int32).max) w.setValue(v) w.valueChanged.connect(partial(self._on_setting_changed, abs_key, w)) elif isinstance(v, float): w = QDoubleSpinBox() w.setRange(np.finfo(np.float32).min, np.finfo(np.float32).max) w.setValue(v) w.valueChanged.connect(partial(self._on_setting_changed, abs_key, w)) else: w = QLineEdit(str(v)) w.textChanged.connect(partial(self._on_setting_changed, abs_key, w)) self._lut[abs_key] = w form.addRow(label, w) wrap.setLayout(form) return wrap
def __init__(self, main_window): """ Initializates the manager, and performs discovery of plugins """ self.plugins = AttributeDict() self.ui = main_window self._enabled = {} self.settings = Settings(self.ui, group="General") self.settings.set_default("extra_plugin_directories", "") self.enabled_store = Settings(self.ui, group="PluginManager/enabled") self.discover()
def _on_reset(self): """ Callback for reset button. Prompts user for confirmation, then proceeds to reset settings to default values if confirmed, before updating controls and applying any changes (emits change signal if any changes). """ mb = QMessageBox( QMessageBox.Warning, tr("Reset all settings"), tr("This will reset all settings to their default " + "values. Are you sure you want to continue?"), QMessageBox.Yes | QMessageBox.No) mb.setDefaultButton(QMessageBox.No) dr = mb.exec_() if dr == QMessageBox.Yes: # This clears all settings, and recreates only those values # initialized with set_default this session. Settings.restore_from_defaults() # Now we update controls: s = QSettings(self.ui) keys = list( self._initial_values.keys()) # Use copy, as we may modify for k in keys: # Check if setting is still present if s.contains(k): # Present, update to new value (triggers _on_change) v = s.value(k) w = self._lut[k] if isinstance(w, QLineEdit): w.setText(v) elif isinstance(w, QCheckBox): w.setChecked(v.lower() == "true") elif isinstance(w, (QSpinBox, QDoubleSpinBox)): w.setValue(v) else: # Setting was removed, remove editor w = self._lut[k] layout = w.parent().layout() label = layout.labelForField(w) layout.removeWidget(w) w.close() if label is not None: layout.removeWidget(label) label.close() del self._lut[k] del self._initial_values[k] self._changes[k] = None # Check whether all editors for tab was removed if layout.count() == 0: wrap = w.parent() self.tabs.removeTab(self.tabs.indexOf(wrap)) # Finally apply changes (update _initial_values, and emit signal) self.apply_changes()
def _on_reset(self): """ Callback for reset button. Prompts user for confirmation, then proceeds to reset settings to default values if confirmed, before updating controls and applying any changes (emits change signal if any changes). """ mb = QMessageBox(QMessageBox.Warning, tr("Reset all settings"), tr("This will reset all settings to their default " + "values. Are you sure you want to continue?"), QMessageBox.Yes | QMessageBox.No) mb.setDefaultButton(QMessageBox.No) dr = mb.exec_() if dr == QMessageBox.Yes: # This clears all settings, and recreates only those values # initialized with set_default this session. Settings.restore_from_defaults() # Now we update controls: s = QSettings(self.ui) keys = list(self._initial_values.keys()) # Use copy, as we may modify for k in keys: # Check if setting is still present if s.contains(k): # Present, update to new value (triggers _on_change) v = s.value(k) w = self._lut[k] if isinstance(w, QLineEdit): w.setText(v) elif isinstance(w, QCheckBox): w.setChecked(v.lower() == "true") elif isinstance(w, (QSpinBox, QDoubleSpinBox)): w.setValue(v) else: # Setting was removed, remove editor w = self._lut[k] layout = w.parent().layout() label = layout.labelForField(w) layout.removeWidget(w) w.close() if label is not None: layout.removeWidget(label) label.close() del self._lut[k] del self._initial_values[k] self._changes[k] = None # Check whether all editors for tab was removed if layout.count() == 0: wrap = w.parent() self.tabs.removeTab(self.tabs.indexOf(wrap)) # Finally apply changes (update _initial_values, and emit signal) self.apply_changes()
def __init__(self, main_window): """ Initializates the manager, and performs discovery of plugins """ self.plugins = AttributeDict() self.ui = main_window self._enabled = {} self.settings = Settings(self.ui, group="General") self.settings.set_default("extra_plugin_directories", "") self.enabled_store = Settings(self.ui, group="PluginManager/enabled") self.discover()
def main(): from python_qt_binding import QtGui, QtCore, QT_BINDING import hyperspyui.info from hyperspyui.singleapplication import get_app from hyperspyui.settings import Settings from hyperspyui.util import dummy_context_manager # Need to set early to make QSettings accessible QtCore.QCoreApplication.setApplicationName("HyperSpyUI") QtCore.QCoreApplication.setOrganizationName("Hyperspy") QtCore.QCoreApplication.setApplicationVersion(hyperspyui.info.version) # First, clear all default settings! # TODO: This will cause a concurrency issue with multiple launch Settings.clear_defaults() # Setup default for single/multi-instance settings = Settings(group="General") settings.set_default('allow_multiple_instances', False) if settings['allow_multiple_instances', bool]: # Using multiple instances, get a new application app = QtGui.QApplication(sys.argv) else: # Make sure we only have a single instance app = get_app('hyperspyui') log_file = _get_logfile() if log_file: sys.stdout = sys.stderr = log_file else: log_file = dummy_context_manager() with log_file: # Create and display the splash screen splash_pix = QtGui.QPixmap( os.path.dirname(__file__) + './images/splash.png') splash = QtGui.QSplashScreen(splash_pix, QtCore.Qt.WindowStaysOnTopHint) splash.setMask(splash_pix.mask()) splash.show() app.processEvents() # Need to have import here, as it can take some time, so should happen # after displaying splash from hyperspyui.mainwindow import MainWindow form = MainWindow() if not settings['allow_multiple_instances', bool]: if QT_BINDING == 'pyqt': app.messageAvailable.connect(form.handleSecondInstance) elif QT_BINDING == 'pyside': app.messageReceived.connect(form.handleSecondInstance) form.showMaximized() splash.finish(form) form.load_complete.emit() # Ensure logging is OK import hyperspy.api as hs hs.set_log_level(LOGLEVEL) app.exec_()
def main(): from qtpy.QtCore import QCoreApplication from qtpy.QtWidgets import QApplication from qtpy import API import hyperspyui.info from hyperspyui.settings import Settings # Need to set early to make QSettings accessible QCoreApplication.setApplicationName("HyperSpyUI") QCoreApplication.setOrganizationName("Hyperspy") QCoreApplication.setApplicationVersion(hyperspyui.info.version) # First, clear all default settings! # TODO: This will cause a concurrency issue with multiple launch Settings.clear_defaults() # Setup default for single/multi-instance settings = Settings(group="General") settings.set_default('allow_multiple_instances', False) if settings['allow_multiple_instances', bool]: # Using multiple instances, get a new application app = QApplication(sys.argv) else: # Make sure we only have a single instance from hyperspyui.singleapplication import get_app app = get_app('hyperspyui') splash = get_splash() log_file = _get_logfile() if log_file: sys.stdout = sys.stderr = log_file else: @contextmanager def dummy_context_manager(*args, **kwargs): yield log_file = dummy_context_manager() with log_file: # Need to have import here, since QApplication needs to be called first from hyperspyui.mainwindow import MainWindow form = MainWindow(splash=splash) if not settings['allow_multiple_instances', bool]: if "pyqt" in API: app.messageAvailable.connect(form.handleSecondInstance) elif API == 'pyside': app.messageReceived.connect(form.handleSecondInstance) form.showMaximized() form.splash.hide() form.load_complete.emit() # Ensure logging is OK import hyperspy.api as hs hs.set_log_level(LOGLEVEL) app.exec_()
def __init__(self, main_window): super(Plugin, self).__init__() self.ui = main_window if self.name is None: set_group = 'plugins/' + str.lower(self.__class__.__name__) set_group = set_group.replace('.', '') else: set_group = 'plugins/' + self.name.replace('/', '-').replace( '\\', '-') self.settings = Settings(self.ui, group=set_group) self.actions = {} self.menu_actions = {} self.toolbar_actions = {} self.tools = [] self.widgets = set() self.dialogs = []
class MainWindowBase(QtWidgets.QMainWindow): """ Base layer in application stack. Should handle the connection to our custom matplotlib backend, and manage the Figures. As such, it does not know anything about hyperspy, and can readily be reused for other projects. Should also set up basic UI with utilities, and relevant functions for inhereting classes to override. """ def __init__(self, parent=None): super(MainWindowBase, self).__init__(parent) # Do the import here to update the splash import hyperspyui.mdi_mpl_backend from hyperspyui.settings import Settings # Setup settings: self.settings = Settings(self, 'General') # Default setting values: self.settings.set_default('toolbar_button_size', 24) self.settings.set_default('default_widget_floating', False) self.settings.set_default('working_directory', "") self.settings.set_default('low_process_priority', False) # Override any possible invalid stored values, which could prevent load if 'toolbar_button_size' not in self.settings or \ not isinstance(self.settings['toolbar_button_size'], int): self.settings['toolbar_button_size'] = 24 if self.low_process_priority: lowpriority() # State varaibles self.should_capture_traits = None self.active_tool = None # Collections self.widgets = [] # Widgets in widget bar self.figures = [] # Matplotlib figures self.editors = [] # EditorWidgets self.traits_dialogs = [] self.actions = {} self._action_selection_cbs = {} self.toolbars = {} self.menus = {} self.tools = [] self.plugin_manager = None # MPL backend bindings hyperspyui.mdi_mpl_backend.connect_on_new_figure(self.on_new_figure) hyperspyui.mdi_mpl_backend.connect_on_destroy(self.on_destroy_figure) # Create UI self.windowmenu = None self.create_ui() # Connect figure management functions self.main_frame.subWindowActivated.connect(self.on_subwin_activated) # Save standard layout/state self.settings.set_default('_geometry', self.saveGeometry()) self.settings.set_default('_windowState', self.saveState()) # Restore layout/state if saved geometry = self.settings['_geometry'] state = self.settings['_windowState'] if geometry: self.restoreGeometry(geometry) if state: self.restoreState(state) @property def toolbar_button_size(self): return self.settings['toolbar_button_size', int] @toolbar_button_size.setter def toolbar_button_size(self, value): self.settings['toolbar_button_size'] = value self.setIconSize( QtCore.QSize(self.toolbar_button_size, self.toolbar_button_size)) @property def cur_dir(self): return self.settings['working_directory'] or '' @cur_dir.setter def cur_dir(self, value): self.settings['working_directory'] = value @property def low_process_priority(self): return self.settings['low_process_priority', bool] @low_process_priority.setter def low_process_priority(self, value): self.settings['low_process_priority'] = value if value: lowpriority() else: normalpriority() @property def plugins(self): return self.plugin_manager.plugins def handleSecondInstance(self, argv): # overload if needed self.setWindowState(self.windowState() & ~Qt.WindowMinimized | Qt.WindowActive) self.activateWindow() def closeEvent(self, event): self.settings['_geometry'] = self.saveGeometry() self.settings['_windowState'] = self.saveState() return super(MainWindowBase, self).closeEvent(event) def reset_geometry(self): self.settings.restore_key_default('_geometry') self.settings.restore_key_default('_windowState') geometry = self.settings['_geometry'] state = self.settings['_windowState'] if geometry: self.restoreGeometry(geometry) if state: self.restoreState(state) self.setWindowState(Qt.WindowMaximized) def create_ui(self): self.setIconSize( QtCore.QSize(self.toolbar_button_size, self.toolbar_button_size)) self.main_frame = QtWidgets.QMdiArea() self.setCorner(Qt.TopRightCorner, Qt.RightDockWidgetArea) self.setCorner(Qt.TopLeftCorner, Qt.LeftDockWidgetArea) self.set_splash("Initializing plugins") self.init_plugins() self.set_splash("Creating default actions") self.create_default_actions() # Goes before menu/toolbar/widgetbar # Needs to go before menu, so console can be in menu self.set_splash("Creating console") self.create_console() # This needs to happen before the widgetbar and toolbar self.set_splash("Creating menus") self.create_menu() self.set_splash("Creating toolbars") self.create_toolbars() self.set_splash("Creating widgets") self.create_widgetbar() self.setCentralWidget(self.main_frame) def init_plugins(self): from .pluginmanager import PluginManager self.plugin_manager = PluginManager(self) # Disable Version selector plugin until it is fixed self.plugin_manager.enabled_store['Version selector'] = False self.plugin_manager.init_plugins() def create_default_actions(self): """ Create default actions that can be used for e.g. toolbars and menus, or triggered manually. """ self.set_splash("Creating plugin actions") self.plugin_manager.create_actions() self.selectable_tools = QtWidgets.QActionGroup(self) self.selectable_tools.setExclusive(True) # Nested docking action ac_nested = QtWidgets.QAction(tr("Nested docking"), self) ac_nested.setStatusTip(tr("Allow nested widget docking")) ac_nested.setCheckable(True) ac_nested.setChecked(self.isDockNestingEnabled()) ac_nested.triggered[bool].connect(self.setDockNestingEnabled) self.actions['nested_docking'] = ac_nested # Tile windows action ac_tile = QtWidgets.QAction(tr("Tile"), self) ac_tile.setStatusTip(tr("Arranges all figures in a tile pattern")) ac_tile.triggered.connect(self.main_frame.tileSubWindows) self.actions['tile_windows'] = ac_tile # Cascade windows action ac_cascade = QtWidgets.QAction(tr("Cascade"), self) ac_cascade.setStatusTip( tr("Arranges all figures in a cascade pattern")) ac_cascade.triggered.connect(self.main_frame.cascadeSubWindows) self.actions['cascade_windows'] = ac_cascade # Close all figures action ac_close_figs = QtWidgets.QAction(tr("Close all"), self) ac_close_figs.setStatusTip(tr("Closes all matplotlib figures")) ac_close_figs.triggered.connect(lambda: matplotlib.pyplot.close("all")) self.actions['close_all_windows'] = ac_close_figs # Reset geometry action ac_reset_layout = QtWidgets.QAction(tr("Reset layout"), self) ac_reset_layout.setStatusTip(tr("Resets layout of toolbars and " "widgets")) ac_reset_layout.triggered.connect(self.reset_geometry) self.actions['reset_layout'] = ac_reset_layout def create_menu(self): mb = self.menuBar() # Window menu is filled in add_widget and add_figure self.windowmenu = mb.addMenu(tr("&Windows")) self.windowmenu.addAction(self._console_dock.toggleViewAction()) self.windowmenu.addAction(self.actions['nested_docking']) # Figure windows go below this separator. Other windows can be added # above it with insertAction(self.windowmenu_sep, QAction) self.windowmenu_sep = self.windowmenu.addSeparator() self.windowmenu.addAction(self.actions['tile_windows']) self.windowmenu.addAction(self.actions['cascade_windows']) self.windowmenu.addSeparator() self.windowmenu.addAction(self.actions['close_all_windows']) self.windowmenu_actions_sep = self.windowmenu.addSeparator() self.plugin_manager.create_menu() def create_tools(self): """Override to create tools on UI construction. """ self.plugin_manager.create_tools() def create_toolbars(self): """ Override to create toolbars and toolbar buttons on UI construction. It is called after create_default_action(), so add_toolbar_button() can be used to add previously defined acctions. """ self.create_tools() self.plugin_manager.create_toolbars() def create_widgetbar(self): """ The widget bar itself is created and managed implicitly by Qt. Override this function to add widgets on UI construction. """ self.plugin_manager.create_widgets() def edit_settings(self): """ Shows a dialog for editing the application and plugins settings. """ from hyperspyui.widgets.settingsdialog import SettingsDialog d = SettingsDialog(self, self) d.settings_changed.connect(self.on_settings_changed) d.exec_() def on_settings_changed(self): """ Callback for SettingsDialog, or anything else that updates settings and need to apply the change. """ # Due to the way the property is defined, this updates the UI: self.toolbar_button_size = self.toolbar_button_size self.low_process_priority = self.low_process_priority def select_tool(self, tool): if self.active_tool is not None: try: self.active_tool.disconnect_windows(self.figures) except Exception as e: warnings.warn("Exception disabling tool %s: %s" % ( self.active_tool.get_name(), e)) self.active_tool = tool tool.connect_windows(self.figures) # --------- Figure management --------- # --------- MPL Events --------- def on_new_figure(self, figure, userdata=None): """ Callback for MPL backend. """ self.main_frame.addSubWindow(figure) self.figures.append(figure) self.windowmenu.addAction(figure.activateAction()) for tool in self.tools: if tool.single_action() is not None: tool.connect_windows(figure) if self.active_tool is not None: self.active_tool.connect_windows(figure) def on_destroy_figure(self, figure, userdata=None): """ Callback for MPL backend. """ if figure in self.figures: self.figures.remove(figure) self.windowmenu.removeAction(figure.activateAction()) for tool in self.tools: if tool.single_action() is not None: tool.disconnect_windows(figure) if self.active_tool is not None: self.active_tool.disconnect_windows(figure) self.main_frame.removeSubWindow(figure) # --------- End MPL Events --------- def on_subwin_activated(self, mdi_figure): if mdi_figure and API == 'pyside': mdi_figure.activateAction().setChecked(True) self.check_action_selections(mdi_figure) def check_action_selections(self, mdi_figure=None): if mdi_figure is None: mdi_figure = self.main_frame.activeSubWindow() for key, cb in self._action_selection_cbs.items(): cb(mdi_figure, self.actions[key]) # --------- End figure management --------- # --------- Console functions --------- def _get_console_exec(self): return "" def _get_console_exports(self): return {'ui': self} def _get_console_config(self): return None def on_console_executing(self, source): """ Override when inherited to perform actions before exectuing 'source'. """ pass def on_console_executed(self, response): """ Override when inherited to perform actions after executing, given the 'response' returned. """ pass def create_console(self): # We could inherit QAction, and have it reroute when it triggers, # and then drop route when it finishes, however this will not catch # interactive dialogs and such. c = self._get_console_config() self.settings.set_default('console_completion_type', 'droplist') valid_completions = ConsoleWidget.gui_completion.values self.settings.set_enum_hint('console_completion_type', valid_completions) gui_completion = self.settings['console_completion_type'] if gui_completion not in valid_completions: gui_completion = 'droplist' control = ConsoleWidget(config=c, gui_completion=gui_completion) control.executing.connect(self.on_console_executing) control.executed.connect(self.on_console_executed) # This is where we push variables to the console ex = self._get_console_exec() push = self._get_console_exports() control.ex(ex) control.push(push) self.console = control self._console_dock = QtWidgets.QDockWidget("Console") self._console_dock.setObjectName('console_widget') self._console_dock.setWidget(control) self.addDockWidget(Qt.BottomDockWidgetArea, self._console_dock)
class PluginManager(object): def __init__(self, main_window): """ Initializates the manager, and performs discovery of plugins """ self.plugins = AttributeDict() self.ui = main_window self._enabled = {} self.settings = Settings(self.ui, group="General") self.settings.set_default("extra_plugin_directories", "") self.enabled_store = Settings(self.ui, group="PluginManager/enabled") self.discover() @property def enabled(self): """Returns a read-only dictionary showing the enabled/disabled state of all plugins. """ d = ReadOnlyDict() for name, (enabled, _) in d.items(): d[name] = enabled d._readonly = True return d def enable_plugin(self, name, value=True): """Enable/disable plugin functionality. Also loads/unloads plugin. If enabling and the plugin is already loaded, this will reload the plugin. """ self.enabled_store[name] = value ptype = self._enabled[name][1] self._enabled[name] = (value, ptype) if name in self.plugins: self.unload(self.plugins[name]) if value: self.load(ptype) def disable_plugin(self, name): """Disable plugin functionality. Also unloads plugin. """ self.enable_plugin(name, False) def _import_plugin_from_path(self, name, path): try: mname = "hyperspyui.plugins." + name if sys.version_info >= (3, 5): import importlib.util spec = importlib.util.spec_from_file_location(mname, path) module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) else: from importlib.machinery import SourceFileLoader loader = SourceFileLoader(mname, path) loader.load_module() except Exception: self.warn("import", path) def discover(self): """Auto-discover all plugins defined in plugin directory. """ import hyperspyui.plugins as plugins for plug in plugins.__all__: try: __import__('hyperspyui.plugins.' + plug, globals()) except Exception: self.warn("import", plug) # Import any plugins in extra dirs. extra_paths = self.settings['extra_plugin_directories'] if extra_paths: extra_paths = extra_paths.split(os.path.pathsep) for path in extra_paths: if not os.path.isdir(path): path = os.path.dirname(path) modules = glob.glob(path + "/*.py") # TODO: In release form, we should consider supporting # compiled plugins in pyc/pyo format # modules.extend(glob.glob(os.path.dirname(__file__)+"/*.py?")) # If so, ensure that duplicates are removed (picks py over pyc) modules = [ m for m in modules if not os.path.basename(m).startswith('_') ] for m in modules: name = os.path.splitext(os.path.basename(m))[0] self._import_plugin_from_path(name, m) master = Plugin self.implementors = sorted(self._inheritors(master), key=lambda x: x.name) logger.debug("Found plugins: %s", self.implementors) @staticmethod def _inheritors(klass): """Return all defined classes that inherit from 'klass'. """ subclasses = set() work = [klass] while work: parent = work.pop() for child in parent.__subclasses__(): if child not in subclasses: subclasses.add(child) work.append(child) return subclasses def warn(self, f_name, p_name, category=RuntimeWarning): tbf = ''.join(traceback.format_exception(*sys.exc_info())[2:]) warnings.warn(("Exception in {0} of hyperspyui plugin " + "\"{1}\" error:\n{2}").format(f_name, p_name, tbf), RuntimeWarning, 2) def init_plugins(self): self.plugins.clear() for plug_type in self.implementors: try: self._load_if_enabled(plug_type) except Exception: self.warn("initialization", plug_type.name) def create_actions(self): for p in self.plugins.values(): try: p.create_actions() except Exception: self.warn(sys._getframe().f_code.co_name, p.name) def create_menu(self): for p in self.plugins.values(): try: p.create_menu() except Exception: self.warn(sys._getframe().f_code.co_name, p.name) def create_tools(self): for p in self.plugins.values(): try: p.create_tools() except Exception: self.warn(sys._getframe().f_code.co_name, p.name) def create_toolbars(self): for p in self.plugins.values(): try: p.create_toolbars() except Exception: self.warn(sys._getframe().f_code.co_name, p.name) def create_widgets(self): for p in self.plugins.values(): try: p.create_widgets() except Exception: self.warn(sys._getframe().f_code.co_name, p.name) def _load_if_enabled(self, p_type): if p_type is None or p_type.name is None: return if self.enabled_store[p_type.name] is None: # Init setting to True on first encounter self.enabled_store[p_type.name] = True enabled = self.enabled_store[p_type.name, bool] self._enabled[p_type.name] = (enabled, p_type) if enabled: # Init logger.debug("Initializing plugin: %s", p_type) p = p_type(self.ui) self.plugins[p.name] = p logger.debug("Plugin loaded: %s", p.name) return p return None def load(self, plugin_type): try: p = self._load_if_enabled(plugin_type) if p is not None: # Order of execution is significant! p.create_actions() p.create_menu() p.create_tools() p.create_toolbars() p.create_widgets() except Exception: self.warn(sys._getframe().f_code.co_name, plugin_type) def load_from_file(self, path): master = Plugin prev = self._inheritors(master) name = os.path.splitext(os.path.basename(path))[0] mod_name = 'hyperspyui.plugins.' + name reload_plugins = mod_name in sys.modules try: if sys.version_info >= (3, 5): spec = importlib.util.spec_from_file_location(mod_name, path) mod = importlib.util.module_from_spec(spec) spec.loader.exec_module(mod) else: importlib.machinery.SourceFileLoader(mod_name, path).load_module() except Exception: self.warn("import", name) loaded = self._inheritors(master).difference(prev) new_ps = [] for plug_type in loaded: if reload_plugins and plug_type.name in self.plugins: # Unload any plugins with same name self.unload(self.plugins[plug_type.name]) try: p = self._load_if_enabled(plug_type) except Exception: self.warn('load', plug_type.name) if p is not None: new_ps.append(p) for p in new_ps: try: p.create_actions() except Exception: self.warn('create_actions', p.name) for p in new_ps: try: p.create_menu() except Exception: self.warn('create_menu', p.name) for p in new_ps: try: p.create_tools() except Exception: self.warn('create_tools', p.name) for p in new_ps: try: p.create_toolbars() except Exception: self.warn('create_toolbars', p.name) for p in new_ps: try: p.create_widgets() except Exception: self.warn('create_widgets', p.name) return new_ps def unload(self, plugin): plugin.unload() self.plugins.pop(plugin.name) def reload(self, plugin): new_module = importlib.reload(sys.modules[plugin.__module__]) new_ptype = new_module[plugin.__class__.__name__] if new_ptype is not None: self.unload(plugin) self.load(new_ptype)
class PluginManager(object): def __init__(self, main_window): """ Initializates the manager, and performs discovery of plugins """ self.plugins = AttributeDict() self.ui = main_window self._enabled = {} self.settings = Settings(self.ui, group="General") self.settings.set_default("extra_plugin_directories", "") self.enabled_store = Settings(self.ui, group="PluginManager/enabled") self.discover() @property def enabled(self): """Returns a read-only dictionary showing the enabled/disabled state of all plugins. """ d = ReadOnlyDict() for name, (enabled, _) in d.items(): d[name] = enabled d._readonly = True return d def enable_plugin(self, name, value=True): """Enable/disable plugin functionality. Also loads/unloads plugin. If enabling and the plugin is already loaded, this will reload the plugin. """ self.enabled_store[name] = value ptype = self._enabled[name][1] self._enabled[name] = (value, ptype) if name in self.plugins: self.unload(self.plugins[name]) if value: self.load(ptype) def disable_plugin(self, name): """Disable plugin functionality. Also unloads plugin. """ self.enable_plugin(name, False) def _import_plugin_from_path(self, name, path): try: mname = "hyperspyui.plugins." + name if sys.version_info >= (3, 5): import importlib.util spec = importlib.util.spec_from_file_location(mname, path) module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) else: from importlib.machinery import SourceFileLoader loader = SourceFileLoader(mname, path) loader.load_module() except Exception: self.warn("import", path) def discover(self): """Auto-discover all plugins defined in plugin directory. """ import hyperspyui.plugins as plugins for plug in plugins.__all__: try: __import__('hyperspyui.plugins.' + plug, globals()) except Exception: self.warn("import", plug) # Import any plugins in extra dirs. extra_paths = self.settings['extra_plugin_directories'] if extra_paths: extra_paths = extra_paths.split(os.path.pathsep) for path in extra_paths: if not os.path.isdir(path): path = os.path.dirname(path) modules = glob.glob(path + "/*.py") # TODO: In release form, we should consider supporting # compiled plugins in pyc/pyo format # modules.extend(glob.glob(os.path.dirname(__file__)+"/*.py?")) # If so, ensure that duplicates are removed (picks py over pyc) modules = [m for m in modules if not os.path.basename(m).startswith('_')] for m in modules: name = os.path.splitext(os.path.basename(m))[0] self._import_plugin_from_path(name, m) master = Plugin self.implementors = sorted(self._inheritors(master), key=lambda x: x.name) logger.debug("Found plugins: %s", self.implementors) @staticmethod def _inheritors(klass): """Return all defined classes that inherit from 'klass'. """ subclasses = set() work = [klass] while work: parent = work.pop() for child in parent.__subclasses__(): if child not in subclasses: subclasses.add(child) work.append(child) return subclasses def warn(self, f_name, p_name, category=RuntimeWarning): tbf = ''.join(traceback.format_exception(*sys.exc_info())[2:]) warnings.warn(("Exception in {0} of hyperspyui plugin " + "\"{1}\" error:\n{2}").format(f_name, p_name, tbf), RuntimeWarning, 2) def init_plugins(self): self.plugins.clear() for plug_type in self.implementors: try: self._load_if_enabled(plug_type) except Exception: self.warn("initialization", plug_type.name) def create_actions(self): for p in self.plugins.values(): try: p.create_actions() except Exception: self.warn(sys._getframe().f_code.co_name, p.name) def create_menu(self): for p in self.plugins.values(): try: p.create_menu() except Exception: self.warn(sys._getframe().f_code.co_name, p.name) def create_tools(self): for p in self.plugins.values(): try: p.create_tools() except Exception: self.warn(sys._getframe().f_code.co_name, p.name) def create_toolbars(self): for p in self.plugins.values(): try: p.create_toolbars() except Exception: self.warn(sys._getframe().f_code.co_name, p.name) def create_widgets(self): for p in self.plugins.values(): try: p.create_widgets() except Exception: self.warn(sys._getframe().f_code.co_name, p.name) def _load_if_enabled(self, p_type): if p_type is None or p_type.name is None: return if self.enabled_store[p_type.name] is None: # Init setting to True on first encounter self.enabled_store[p_type.name] = True enabled = self.enabled_store[p_type.name, bool] self._enabled[p_type.name] = (enabled, p_type) if enabled: # Init logger.debug("Initializing plugin: %s", p_type) p = p_type(self.ui) self.plugins[p.name] = p logger.debug("Plugin loaded: %s", p.name) return p return None def load(self, plugin_type): try: p = self._load_if_enabled(plugin_type) if p is not None: # Order of execution is significant! p.create_actions() p.create_menu() p.create_tools() p.create_toolbars() p.create_widgets() except Exception: self.warn(sys._getframe().f_code.co_name, p.name) def load_from_file(self, path): master = Plugin prev = self._inheritors(master) name = os.path.splitext(os.path.basename(path))[0] mod_name = 'hyperspyui.plugins.' + name reload_plugins = mod_name in sys.modules try: if sys.version_info >= (3, 5): spec = importlib.util.spec_from_file_location( mod_name, path) mod = importlib.util.module_from_spec(spec) spec.loader.exec_module(mod) else: importlib.machinery.SourceFileLoader( mod_name, path).load_module() except Exception: self.warn("import", name) loaded = self._inheritors(master).difference(prev) new_ps = [] for plug_type in loaded: if reload_plugins and plug_type.name in self.plugins: # Unload any plugins with same name self.unload(self.plugins[plug_type.name]) try: p = self._load_if_enabled(plug_type) except Exception: self.warn('load', plug_type.name) if p is not None: new_ps.append(p) for p in new_ps: try: p.create_actions() except Exception: self.warn('create_actions', p.name) for p in new_ps: try: p.create_menu() except Exception: self.warn('create_menu', p.name) for p in new_ps: try: p.create_tools() except Exception: self.warn('create_tools', p.name) for p in new_ps: try: p.create_toolbars() except Exception: self.warn('create_toolbars', p.name) for p in new_ps: try: p.create_widgets() except Exception: self.warn('create_widgets', p.name) return new_ps def unload(self, plugin): plugin.unload() self.plugins.pop(plugin.name) def reload(self, plugin): new_module = importlib.reload(sys.modules[plugin.__module__]) new_ptype = new_module[plugin.__class__.__name__] if new_ptype is not None: self.unload(plugin) self.load(new_ptype)
def main(): from qtpy.QtCore import Qt, QCoreApplication from qtpy.QtWidgets import QApplication from qtpy import API import hyperspyui.info from hyperspyui.settings import Settings # QtWebEngineWidgets must be imported before a QCoreApplication instance # is created (used in eelsdb plugin) # Avoid a bug in Qt: https://bugreports.qt.io/browse/QTBUG-46720 from qtpy import QtWebEngineWidgets # Need to set early to make QSettings accessible QCoreApplication.setApplicationName("HyperSpyUI") QCoreApplication.setOrganizationName("Hyperspy") QCoreApplication.setApplicationVersion(hyperspyui.info.__version__) # To avoid the warning: # Qt WebEngine seems to be initialized from a plugin. Please set # Qt::AA_ShareOpenGLContexts using QCoreApplication::setAttribute before # constructing QGuiApplication. # Only available for pyqt>=5.4 if hasattr(Qt, "AA_ShareOpenGLContexts"): QCoreApplication.setAttribute(Qt.AA_ShareOpenGLContexts) # First, clear all default settings! # TODO: This will cause a concurrency issue with multiple launch Settings.clear_defaults() # Setup default for single/multi-instance settings = Settings(group="General") settings.set_default('allow_multiple_instances', False) if settings['allow_multiple_instances', bool]: # Using multiple instances, get a new application app = QApplication(sys.argv) else: # Make sure we only have a single instance from hyperspyui.singleapplication import get_app app = get_app('hyperspyui') splash = get_splash() log_file = _get_logfile() if log_file: sys.stdout = sys.stderr = log_file else: @contextmanager def dummy_context_manager(*args, **kwargs): yield log_file = dummy_context_manager() with log_file: # Need to have import here, since QApplication needs to be called first from hyperspyui.mainwindow import MainWindow form = MainWindow(splash=splash) if not settings['allow_multiple_instances', bool]: if "pyqt" in API: app.messageAvailable.connect(form.handleSecondInstance) elif API == 'pyside': app.messageReceived.connect(form.handleSecondInstance) form.showMaximized() form.splash.hide() form.load_complete.emit() # Ensure logging is OK import hyperspy.api as hs hs.set_log_level(LOGLEVEL) app.exec_()