class WorkspaceExplorer(BaseExtension):
@BaseExtension.as_thread(wait=2500)
def event_startup(self):
dm = DataMatrix(length=0)
dm.initializing = -1
self._workspace_cache = {}
self._label_kernel_not_supported = QLabel('<b>' +
_('Kernel not supported') +
'</b>')
self._label_kernel_not_supported.setAlignment(Qt.AlignHCenter
| Qt.AlignVCenter)
self._qdm = WorkspaceMatrix(dm, read_only=True)
self._qdm.setFont(QFont(cfg.pyqode_font_name, cfg.pyqode_font_size))
self._qdm.cell_double_clicked.connect(self._inspect_variable)
self._dock_widget = QDockWidget(self.main_window)
self._dock_widget.setWidget(self._qdm)
self._dock_widget.closeEvent = self._on_close_event
self._dock_widget.setWindowTitle(_(u'Workspace'))
self._dock_widget.setObjectName('WorkspaceExplorer')
self._dock_widget.visibilityChanged.connect(
self._on_visibility_changed)
self.main_window.addDockWidget(Qt.RightDockWidgetArea,
self._dock_widget)
self._set_visible(cfg.workspace_visible)
def _inspect_variable(self, row, column):
if self.extension_manager.provide('jupyter_kernel_running'):
self.extension_manager.fire(
'notify',
message=_(u'Cannot inspect variables in running kernel'))
return
if not row:
return
self.extension_manager.fire(
'data_viewer_inspect',
name=self._qdm.dm.name[row - 1],
workspace=self.extension_manager.provide('jupyter_workspace_name'))
def activate(self):
if not hasattr(self, '_qdm'):
oslogger.info('ignoring activate until after startup')
return
self._set_visible(not cfg.workspace_visible)
def _on_visibility_changed(self, visible):
if not visible:
return
self._update(
self.extension_manager.provide('jupyter_workspace_name'), lambda:
self.extension_manager.provide('jupyter_workspace_globals'))
def _on_close_event(self, e):
self._set_visible(False)
def _update(self, name, workspace_func):
if (not hasattr(self, '_dock_widget')
or not self._dock_widget.isVisible()):
return
self._dock_widget.setWidget(self._qdm)
self._dock_widget.setWindowTitle(_(u'Workspace ({})').format(name))
workspace = workspace_func()
self._workspace_cache[name] = workspace
# If the workspace didn't reply, we try again in a second
if workspace is None or workspace.get(u'no reply', False) is None:
QTimer.singleShot(1000, lambda: self._update(name, workspace_func))
return
# If the current kernel doesn't expose its workspace, indicate this
if workspace.get(u'not supported', False) is None:
dm = DataMatrix(length=0)
dm.kernel_not_supported = -1
self._dock_widget.setWidget(self._label_kernel_not_supported)
# Create a DataMatrix that exposes the workspace
else:
dm = DataMatrix(length=len(workspace))
dm.sorted = False
dm.name = ''
dm.value = ''
dm.shape = ''
dm.type = ''
for row, (var, data) in zip(dm, workspace.items()):
if data is None:
oslogger.warning(u'invalid workspace data: {}'.format(var))
continue
value, type_, shape = data
row.value = value
row.name = var
if shape is not None:
row.shape = repr(shape)
row.type = type_
self._qdm.dm = dm
self._qdm.refresh()
def _set_visible(self, visible):
cfg.workspace_visible = visible
self.set_checked(visible)
if visible:
self._dock_widget.show()
else:
self._dock_widget.hide()
def event_workspace_update(self, name, workspace_func):
self._update(name, workspace_func)
def event_workspace_restart(self, name, workspace_func):
self._update(name, workspace_func)
def event_workspace_switch(self, name, workspace_func):
# When a kernel is running (which includes being a debugging session)
# it doesn't respond to silent requests for the workspace. Therefore
# we use cached copy of the last update.
if self.extension_manager.provide('jupyter_kernel_running'):
self._update(name, lambda: self._workspace_cache.get(name, {}))
return
self._update(name, workspace_func)
def event_workspace_new(self, name, workspace_func):
self._update(name, workspace_func)
class MainWindow(QMainWindow):
def __init__(self, argv):
super(MainWindow, self).__init__()
self.main_widget = None
self.graphic_settings_dock = None
self.zero_loss_peak_dock = None
self.projects_dock = None
self.spectra = Spectra()
self.init_ui()
self.read_settings()
self.parse_arguments(argv)
def init_ui(self):
# Define standard icon.
standard_icon = self.style().standardIcon
# Central widget.
self.main_widget = SpectrumWidget(self.spectra)
self.main_widget.setFocus()
self.setCentralWidget(self.main_widget)
# Open spectrum action
open_spectrum_action = QAction(standard_icon(QStyle.SP_DialogOpenButton), 'Open spectrum', self)
open_spectrum_action.setShortcut('Ctrl+O')
open_spectrum_action.setStatusTip('Open spectrum')
open_spectrum_action.triggered.connect(self.open_spectrum)
# Exit action
exit_action = QAction(standard_icon(QStyle.SP_TitleBarCloseButton), 'Exit', self)
exit_action.setShortcut('Ctrl+Q')
exit_action.setStatusTip('Exit application')
exit_action.triggered.connect(self.close)
# Status bar.
self.statusBar()
# Menu bar.
menubar = self.menuBar()
file_menu = menubar.addMenu('&File')
file_menu.addAction(open_spectrum_action)
file_menu.addAction(exit_action)
view_menu = menubar.addMenu('&View')
analysis_menu = menubar.addMenu('&Analysis')
# Toolbar
file_toolbar = self.addToolBar('File')
file_toolbar.addAction(open_spectrum_action)
file_toolbar.addAction(exit_action)
view_menu.addAction(file_toolbar.toggleViewAction())
analysis_toolbar = self.addToolBar('Analysis')
view_menu.addAction(analysis_toolbar.toggleViewAction())
view_menu.addSeparator()
# Dock widget.
self.graphic_settings_dock = QDockWidget("Graphic settings", self)
self.graphic_settings_dock.setObjectName("graphic_settings_dock")
self.graphic_settings_dock.setAllowedAreas(Qt.AllDockWidgetAreas)
label_test = QLabel("Test label")
self.graphic_settings_dock.setWidget(label_test)
view_menu.addAction(self.graphic_settings_dock.toggleViewAction())
self.addDockWidget(Qt.AllDockWidgetAreas, self.graphic_settings_dock)
print(self.graphic_settings_dock.objectName())
self.zero_loss_peak_dock = ZeroLossPeakWidget(self, self.spectra)
analysis_menu.addAction(self.zero_loss_peak_dock.toggleViewAction())
self.addDockWidget(Qt.AllDockWidgetAreas, self.zero_loss_peak_dock)
self.projects_dock = ProjectWidget(self)
view_menu.addAction(self.projects_dock.toggleViewAction())
self.addDockWidget(Qt.AllDockWidgetAreas, self.projects_dock)
# Final options.
self.setWindowTitle('pySEM-EELS')
self.show()
def closeEvent(self, event):
self.save_settings()
super(MainWindow, self).closeEvent(event)
def save_settings(self):
settings = QSettings("openMicroanalysis", "pysemeelsgui")
# print(settings.fileName())
settings.beginGroup("MainWindow")
settings.setValue("geometry", self.saveGeometry())
settings.setValue("window_state", self.saveState())
settings.endGroup()
settings.beginGroup("graphic_settings_dock")
settings.setValue("visible", self.graphic_settings_dock.isVisible())
settings.endGroup()
settings.beginGroup("zero_loss_peak_dock")
settings.setValue("visible", self.zero_loss_peak_dock.isVisible())
settings.endGroup()
settings.beginGroup("projects_dock")
settings.setValue("visible", self.projects_dock.isVisible())
settings.endGroup()
def read_settings(self):
settings = QSettings("openMicroanalysis", "pysemeelsgui")
# print(settings.fileName())
# settings.clear()
settings.beginGroup("MainWindow")
geometry_value = settings.value("geometry")
if geometry_value is None:
self.setGeometry(300, 300, 600, 400)
else:
self.restoreGeometry(geometry_value)
window_state_value = settings.value("window_state")
if window_state_value is not None:
self.restoreState(window_state_value)
settings.endGroup()
settings.beginGroup("graphic_settings_dock")
visible_value = settings.value("visible")
if visible_value is not None:
if visible_value == "true":
self.graphic_settings_dock.setVisible(True)
elif visible_value == "false":
self.graphic_settings_dock.setVisible(False)
settings.endGroup()
settings.beginGroup("zero_loss_peak_dock")
visible_value = settings.value("visible")
if visible_value is not None:
if visible_value == "true":
self.zero_loss_peak_dock.setVisible(True)
elif visible_value == "false":
self.zero_loss_peak_dock.setVisible(False)
settings.endGroup()
def parse_arguments(self, argv):
option_parser = optparse.OptionParser()
option_parser.add_option("-s", "--spectrum", action="store", type="string", dest="spectrum_file", help="Open a eels spectrum")
options, arguments = option_parser.parse_args()
logging.info("Remaining arguments: {}".format(arguments))
logging.info("Spectrum file: {}".format(options.spectrum_file))
if options.spectrum_file:
self.spectra.open_spectrum(options.spectrum_file)
elv_file = self.spectra.get_current_elv_file()
spectrum_data = elv_file.get_spectrum_data()
self.main_widget.update_figure(spectrum_data)
def open_spectrum(self):
self.statusBar().showMessage("Opening spectrum", 2000)
path = os.path.dirname(__file__)
formats = ["*.elv"]
spectrum_filter = "Spectrum file ({:s})".format(" ".join(formats))
file_names = QFileDialog.getOpenFileName(self, "Open an EELS spectrum", path, spectrum_filter)
self.spectra.open_spectrum(file_names)
elv_file = self.spectra.get_current_elv_file()
spectrum_data = elv_file.get_spectrum_data()
self.main_widget.update_figure(spectrum_data)
class BaseMainWindow(QMainWindow):
"""
Base for main windows of subprograms
:ivar settings: store state of application. initial value is obtained from :py:attr:`.settings_class`
:ivar files_num: maximal number of files accepted by drag and rop event
:param config_folder: path to directory in which application save state. If `settings` parameter is note
then settings object is created with passing this path to :py:attr:`.settings_class`.
If this parameter and `settings`
are None then constructor fail with :py:exc:`ValueError`.
:param title: Window default title
:param settings: object to store application state
:param signal_fun: function which need to be called when window shown.
"""
show_signal = Signal()
"""Signal emitted when window has shown. Used to hide Launcher."""
@classmethod
def get_setting_class(cls) -> Type[BaseSettings]:
"""Get constructor for :py:attr:`settings`"""
return BaseSettings
def __init__(
self,
config_folder: Union[str, Path, None] = None,
title="PartSeg",
settings: Optional[BaseSettings] = None,
load_dict: Optional[Register] = None,
signal_fun=None,
):
if settings is None:
if config_folder is None:
raise ValueError("wrong config folder")
if not os.path.exists(config_folder):
import_config()
settings: BaseSettings = self.get_setting_class()(config_folder)
errors = settings.load()
if errors:
errors_message = QMessageBox()
errors_message.setText("There are errors during start")
errors_message.setInformativeText(
"During load saved state some of data could not be load properly\n"
"The files has prepared backup copies in "
" state directory (Help > State directory)")
errors_message.setStandardButtons(QMessageBox.Ok)
text = "\n".join("File: " + x[0] + "\n" + str(x[1])
for x in errors)
errors_message.setDetailedText(text)
errors_message.exec_()
super().__init__()
if signal_fun is not None:
self.show_signal.connect(signal_fun)
self.settings = settings
self._load_dict = load_dict
self.viewer_list: List[Viewer] = []
self.files_num = 1
self.setAcceptDrops(True)
self.setWindowTitle(title)
self.title_base = title
app = QApplication.instance()
if app is not None:
app.setStyleSheet(settings.style_sheet)
self.settings.theme_changed.connect(self.change_theme)
self.channel_info = ""
self.multiple_files = None
self.settings.request_load_files.connect(self.read_drop)
self.recent_file_menu = QMenu("Open recent")
self._refresh_recent()
self.settings.connect_(FILE_HISTORY, self._refresh_recent)
self.settings.napari_settings.appearance.events.theme.connect(
self.change_theme)
self.settings.set_parent(self)
self.console = None
self.console_dock = QDockWidget("console", self)
self.console_dock.setAllowedAreas(Qt.LeftDockWidgetArea
| Qt.BottomDockWidgetArea)
# self.console_dock.setWidget(self.console)
self.console_dock.hide()
self.addDockWidget(Qt.BottomDockWidgetArea, self.console_dock)
def _toggle_console(self):
if self.console is None:
self.console = QtConsole(self)
self.console_dock.setWidget(self.console)
self.console_dock.setVisible(not self.console_dock.isVisible())
def _refresh_recent(self):
self.recent_file_menu.clear()
for name_list, method in self.settings.get_last_files():
action = self.recent_file_menu.addAction(
f"{name_list[0]}, {method}")
action.setData((name_list, method))
action.triggered.connect(self._load_recent)
def _load_recent(self):
sender: QAction = self.sender()
data = sender.data()
try:
method: LoadBase = self._load_dict[data[1]]
dial = ExecuteFunctionDialog(
method.load, [data[0]],
exception_hook=load_data_exception_hook)
if dial.exec_():
result = dial.get_result()
self.main_menu.set_data(result)
self.settings.add_last_files(data[0], method.get_name())
self.settings.set(OPEN_DIRECTORY, os.path.dirname(data[0][0]))
self.settings.set(OPEN_FILE, data[0][0])
self.settings.set(OPEN_FILE_FILTER, data[1])
except KeyError:
self.read_drop(data[0])
def toggle_multiple_files(self):
self.settings.set("multiple_files_widget",
not self.settings.get("multiple_files_widget"))
def get_colormaps(self) -> List[Optional[colormap.Colormap]]:
channel_num = self.settings.image.channels
if not self.channel_info:
return [None for _ in range(channel_num)]
colormaps_name = [
self.settings.get_channel_colormap_name(self.channel_info, i)
for i in range(channel_num)
]
return [
self.settings.colormap_dict[name][0] for name in colormaps_name
]
def napari_viewer_show(self):
viewer = Viewer(title="Additional output",
settings=self.settings,
partseg_viewer_name=self.channel_info)
viewer.theme = self.settings.theme_name
viewer.create_initial_layers(image=True,
roi=True,
additional_layers=False,
points=True)
self.viewer_list.append(viewer)
viewer.window.qt_viewer.destroyed.connect(
lambda x: self.close_viewer(viewer))
def additional_layers_show(self, with_channels=False):
if not self.settings.additional_layers:
QMessageBox().information(
self, "No data",
"Last executed algoritm does not provide additional data")
return
viewer = Viewer(title="Additional output",
settings=self.settings,
partseg_viewer_name=self.channel_info)
viewer.theme = self.settings.theme_name
viewer.create_initial_layers(image=with_channels,
roi=False,
additional_layers=True,
points=False)
self.viewer_list.append(viewer)
viewer.window.qt_viewer.destroyed.connect(
lambda x: self.close_viewer(viewer))
def close_viewer(self, obj):
for i, el in enumerate(self.viewer_list):
if el == obj:
self.viewer_list.pop(i)
break
# @ensure_main_thread
def change_theme(self, event):
style_sheet = self.settings.style_sheet
app = QApplication.instance()
if app is not None:
app.setStyleSheet(style_sheet)
self.setStyleSheet(style_sheet)
def showEvent(self, a0: QShowEvent):
self.show_signal.emit()
def dragEnterEvent(self, event: QDragEnterEvent): # pylint: disable=R0201
if event.mimeData().hasUrls():
event.acceptProposedAction()
def read_drop(self, paths: List[str]):
"""Function to process loading files by drag and drop."""
self._read_drop(paths, self._load_dict)
def _read_drop(self, paths, load_dict):
ext_set = {os.path.splitext(x)[1].lower() for x in paths}
def exception_hook(exception):
if isinstance(exception, OSError):
QMessageBox().warning(
self, "IO Error",
"Disc operation error: " + ", ".join(exception.args),
QMessageBox.Ok)
for load_class in load_dict.values():
if load_class.partial(
) or load_class.number_of_files() != len(paths):
continue
if ext_set.issubset(load_class.get_extensions()):
dial = ExecuteFunctionDialog(load_class.load, [paths],
exception_hook=exception_hook)
if dial.exec_():
result = dial.get_result()
self.main_menu.set_data(result)
self.settings.add_last_files(paths, load_class.get_name())
return
QMessageBox.information(
self, "No method", "No methods for load files: " + ",".join(paths))
def dropEvent(self, event: QDropEvent):
"""
Support for load files by drag and drop.
At beginning it check number of files and if it greater than :py:attr:`.files_num` it refuse loading. Otherwise
it call :py:meth:`.read_drop` method and this method should be overwritten in sub classes
"""
if not all(x.isLocalFile() for x in event.mimeData().urls()):
QMessageBox().warning(
self, "Load error",
"Not all files are locally. Cannot load data.", QMessageBox.Ok)
paths = [x.toLocalFile() for x in event.mimeData().urls()]
if self.files_num != -1 and len(paths) > self.files_num:
QMessageBox.information(
self, "To many files",
"currently support only drag and drop one file")
return
self.read_drop(paths)
def show_settings_directory(self):
DirectoryDialog(
self.settings.json_folder_path,
"Path to place where PartSeg store the data between runs").exec_()
@staticmethod
def show_about_dialog():
"""Show about dialog."""
AboutDialog().exec_()
@staticmethod
def get_project_info(file_path, image):
raise NotADirectoryError()
def image_adjust_exec(self):
dial = ImageAdjustmentDialog(self.settings.image)
if dial.exec_():
algorithm = dial.result_val.algorithm
dial2 = ExecuteFunctionDialog(algorithm.transform, [], {
"image": self.settings.image,
"arguments": dial.result_val.values
})
if dial2.exec_():
result: Image = dial2.get_result()
self.settings.set_project_info(
self.get_project_info(result.file_path, result))
def closeEvent(self, event: QCloseEvent):
for el in self.viewer_list:
el.close()
del el
self.settings.napari_settings.appearance.events.theme.disconnect(
self.change_theme)
self.settings.dump()
super().closeEvent(event)
def screenshot(self, viewer: ImageView):
def _screenshot():
data = viewer.viewer_widget.screenshot()
dial = PSaveDialog(
SaveScreenshot,
settings=self.settings,
system_widget=False,
path="io.save_screenshot",
file_mode=PSaveDialog.AnyFile,
)
if not dial.exec_():
return
res = dial.get_result()
res.save_class.save(res.save_destination, data, res.parameters)
return _screenshot
def image_read(self):
folder_name, file_name = os.path.split(self.settings.image_path)
self.setWindowTitle(
f"{self.title_base}: {os.path.join(os.path.basename(folder_name), file_name)}"
)
self.statusBar().showMessage(self.settings.image_path)
def deleteLater(self) -> None:
self.settings.napari_settings.appearance.events.theme.disconnect(
self.change_theme)
super().deleteLater()
class MainWindow(QMainWindow):
def __init__(self):
self.logger = logging.getLogger(APPLICATION_NAME + '.MainWindow')
self.logger.info("MainWindow.__init__")
super(MainWindow, self).__init__()
self.init_ui()
self.read_settings()
def init_ui(self):
# Define standard icon.
standard_icon = self.style().standardIcon
# Central widget.
self.main_widget = SpectrumWidget()
self.main_widget.setFocus()
self.setCentralWidget(self.main_widget)
# Project action
new_project_action = QAction(QIcon(':/oi/svg/document.svg'),
'New project', self)
new_project_action.setShortcut('Ctrl+N')
new_project_action.setStatusTip('New project')
new_project_action.triggered.connect(self.new_project)
open_project_action = QAction(QIcon(':/oi/svg/envelope-open.svg'),
'Open project', self)
open_project_action.setShortcut('Ctrl+O')
open_project_action.setStatusTip('Open project')
open_project_action.triggered.connect(self.open_project)
close_project_action = QAction(QIcon(':/oi/svg/envelope-closed.svg'),
'Close project', self)
close_project_action.setShortcut('Ctrl+C')
close_project_action.setStatusTip('Close project')
close_project_action.triggered.connect(self.close_project)
save_project_action = QAction(QIcon(':/oi/svg/hard-drive.svg'),
'Save project', self)
save_project_action.setShortcut('Ctrl+S')
save_project_action.setStatusTip('Save project')
save_project_action.triggered.connect(self.save_project)
saveas_project_action = QAction(QIcon(':/oi/svg/hard-drive.svg'),
'Save project as ...', self)
# saveas_project_action.setShortcut('Ctrl+S')
saveas_project_action.setStatusTip('Save project as ...')
saveas_project_action.triggered.connect(self.saveas_project)
# Spectrum action
import_spectrum_action = QAction(QIcon(':/oi/svg/account-login.svg'),
'Import spectrum', self)
import_spectrum_action.setShortcut('Ctrl+I')
import_spectrum_action.setStatusTip('Import spectrum')
import_spectrum_action.triggered.connect(self.import_spectrum)
export_spectrum_action = QAction(QIcon(':/oi/svg/account-logout.svg'),
'Export spectrum', self)
# export_spectrum_action.setShortcut('Ctrl+I')
export_spectrum_action.setStatusTip('Export spectrum')
export_spectrum_action.triggered.connect(self.export_spectrum)
# Exit action
exit_action = QAction(QIcon(':/oi/svg/x.svg'), 'Exit', self)
exit_action.setShortcut('Ctrl+Q')
exit_action.setStatusTip('Exit application')
exit_action.triggered.connect(self.close)
# Status bar.
self.statusBar()
# Menu bar.
menubar = self.menuBar()
file_menu = menubar.addMenu('&File')
file_menu.addAction(new_project_action)
file_menu.addAction(open_project_action)
file_menu.addAction(save_project_action)
file_menu.addAction(saveas_project_action)
file_menu.addAction(close_project_action)
file_menu.addSeparator()
file_menu.addAction(exit_action)
view_menu = menubar.addMenu('&View')
spectrum_menu = menubar.addMenu('&Spectrum')
spectrum_menu.addAction(import_spectrum_action)
analysis_menu = menubar.addMenu('&Analysis')
# Toolbar
file_toolbar = self.addToolBar('File')
file_toolbar.addAction(new_project_action)
file_toolbar.addAction(open_project_action)
file_toolbar.addAction(save_project_action)
file_toolbar.addAction(saveas_project_action)
file_toolbar.addAction(close_project_action)
file_toolbar.addAction(exit_action)
view_menu.addAction(file_toolbar.toggleViewAction())
spectrum_toolbar = self.addToolBar('Spectrum')
spectrum_toolbar.addAction(import_spectrum_action)
view_menu.addAction(spectrum_toolbar.toggleViewAction())
analysis_toolbar = self.addToolBar('Analysis')
view_menu.addAction(analysis_toolbar.toggleViewAction())
view_menu.addSeparator()
# Dock widget.
self.graphic_settings_dock = QDockWidget("Graphic settings", self)
self.graphic_settings_dock.setObjectName("graphic_settings_dock")
self.graphic_settings_dock.setAllowedAreas(Qt.AllDockWidgetAreas)
label_test = QLabel("Test label")
self.graphic_settings_dock.setWidget(label_test)
view_menu.addAction(self.graphic_settings_dock.toggleViewAction())
self.addDockWidget(Qt.AllDockWidgetAreas, self.graphic_settings_dock)
print(self.graphic_settings_dock.objectName())
# Final options.
self.setWindowTitle('X-ray spectrum analyzer')
self.show()
def closeEvent(self, event):
self.save_settings()
super(MainWindow, self).closeEvent(event)
def save_settings(self):
settings = QSettings("openMicroanalysis", "xrayspectrumanalyzergui")
# print(settings.fileName())
settings.beginGroup("MainWindow")
settings.setValue("geometry", self.saveGeometry())
settings.setValue("window_state", self.saveState())
settings.endGroup()
settings.beginGroup("graphic_settings_dock")
settings.setValue("visible", self.graphic_settings_dock.isVisible())
settings.endGroup()
# settings.beginGroup("zero_loss_peak_dock")
# settings.setValue("visible", self.zero_loss_peak_dock.isVisible())
# settings.endGroup()
def read_settings(self):
settings = QSettings("openMicroanalysis", "xrayspectrumanalyzergui")
# print(settings.fileName())
# settings.clear()
settings.beginGroup("MainWindow")
geometry_value = settings.value("geometry")
if geometry_value is None:
self.setGeometry(300, 300, 600, 400)
else:
self.restoreGeometry(geometry_value)
window_state_value = settings.value("window_state")
if window_state_value is not None:
self.restoreState(window_state_value)
settings.endGroup()
settings.beginGroup("graphic_settings_dock")
visible_value = settings.value("visible")
if visible_value is not None:
if visible_value == "true":
self.graphic_settings_dock.setVisible(True)
elif visible_value == "false":
self.graphic_settings_dock.setVisible(False)
settings.endGroup()
# settings.beginGroup("zero_loss_peak_dock")
# visible_value = settings.value("visible")
# if visible_value is not None:
# if visible_value == "true":
# self.zero_loss_peak_dock.setVisible(True)
# elif visible_value == "false":
# self.zero_loss_peak_dock.setVisible(False)
# settings.endGroup()
def import_spectrum(self):
self.statusBar().showMessage("Import spectrum", 2000)
path = os.path.dirname(__file__)
formats = ["*.msa", "*.txt"]
file_filters = "Spectrum file ({:s})".format(" ".join(formats))
file_names = QFileDialog.getOpenFileName(self,
"Import an x-ray spectrum",
path, file_filters)
def export_spectrum(self):
self.statusBar().showMessage("Export spectrum", 2000)
def new_project(self):
self.statusBar().showMessage("New project", 2000)
def open_project(self):
self.statusBar().showMessage("Open project", 2000)
def close_project(self):
self.statusBar().showMessage("Close project", 2000)
def save_project(self):
self.statusBar().showMessage("Save project", 2000)
def saveas_project(self):
self.statusBar().showMessage("Save project as ...", 2000)
def create_gui(self):
self.logger.info("MainWindow.create_gui")
self._create_main_window()
self._create_actions()
self._create_menus()
self._create_toolbars()
self._create_tooltip()
self._create_spectra_display()
self._create_data_display()
self._create_operations_display()
self._create_layout()
self._create_statusbar()
self._read_settings()
self.show()
def _create_main_window(self):
self.setGeometry(300, 300, 500, 500)
self.setWindowTitle('Spectrum Analyzer')
# self.setWindowIcon(QIcon('../../../images/cog.svg'))
self.setWindowIcon(self.style().standardIcon(QStyle.SP_DesktopIcon))
self._center_main_window()
def _center_main_window(self):
self.logger.info("MainWindow._center_main_window")
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
def _create_menus(self):
self.logger.info("MainWindow._create_menus")
self.fileMenu = self.menuBar().addMenu("&File")
self.fileMenu.addAction(self.newAct)
self.fileMenu.addAction(self.openAct)
self.fileMenu.addAction(self.saveAct)
self.fileMenu.addAction(self.saveAsAct)
self.fileMenu.addSeparator()
self.fileMenu.addAction(self.exitAct)
self.menuBar().addSeparator()
self.helpMenu = self.menuBar().addMenu("&Help")
self.helpMenu.addAction(self.aboutAct)
self.helpMenu.addAction(self.aboutQtAct)
def _create_layout(self):
mainLayout = QHBoxLayout()
mainLayout.addWidget(self.dataGroupBox)
mainLayout.addWidget(self.plotGroupBox)
mainLayout.addWidget(self.operationsGroupBox)
self.mainGroupBox = QGroupBox("Main layout")
self.mainGroupBox.setLayout(mainLayout)
self.setCentralWidget(self.mainGroupBox)
def _create_spectra_display(self):
self.plotGroupBox = QGroupBox("Plot layout")
self.figure1 = Figure(facecolor=(1, 1, 1), edgecolor=(0, 0, 0))
self.canvas1 = FigureCanvas(self.figure1)
self.canvas1.setParent(self.plotGroupBox)
self.canvas1.setFocusPolicy(Qt.StrongFocus)
self.canvas1.setFocus()
self.canvas1.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.canvas1.updateGeometry()
self.mpl_toolbar1 = NavigationToolbar(self.canvas1, self.plotGroupBox)
self.canvas1.mpl_connect('key_press_event', self.on_key_press)
self.figure2 = Figure(facecolor=(1, 1, 1), edgecolor=(0, 0, 0))
self.canvas2 = FigureCanvas(self.figure2)
self.canvas2.setParent(self.plotGroupBox)
self.mpl_toolbar2 = NavigationToolbar(self.canvas1, self.plotGroupBox)
layout = QVBoxLayout()
layout.addWidget(self.canvas1)
layout.addWidget(self.mpl_toolbar1)
layout.addWidget(self.canvas2)
layout.addWidget(self.mpl_toolbar2)
self.plotGroupBox.setLayout(layout)
def _create_data_display(self):
self.dataGroupBox = QGroupBox("Data layout")
data_layout = QVBoxLayout()
group_box = QGroupBox("Spectra")
self.spectra_list_view = QListWidget(self)
self.spectra_list_view.setMinimumWidth(200)
layout = QVBoxLayout()
layout.addWidget(self.spectra_list_view)
group_box.setLayout(layout)
data_layout.addWidget(group_box)
group_box = QGroupBox("ROI")
roi_list_view = QListWidget(self)
layout = QVBoxLayout()
layout.addWidget(roi_list_view)
group_box.setLayout(layout)
data_layout.addWidget(group_box)
group_box = QGroupBox("Elements")
element_list_view = QListWidget(self)
layout = QVBoxLayout()
layout.addWidget(element_list_view)
group_box.setLayout(layout)
data_layout.addWidget(group_box)
self.dataGroupBox.setLayout(data_layout)
def _create_operations_display(self):
self.operationsGroupBox = QGroupBox("Operations layout")
results_layout = QVBoxLayout()
group_box = QGroupBox("Operation")
results_layout.addWidget(group_box)
group_box = QGroupBox("Results")
results_layout.addWidget(group_box)
self.operationsGroupBox.setLayout(results_layout)
def _create_tooltip(self):
QToolTip.setFont(QFont('SansSerif', 10))
self.setToolTip('This is a <b>QWidget</b> widget')
def _create_actions(self):
self.logger.info("MainWindow._create_actions")
self.newAct = QAction(self.style().standardIcon(QStyle.SP_FileIcon),
"&New",
self,
shortcut=QKeySequence.New,
statusTip="Create a new file",
triggered=self.newFile)
self.openAct = QAction(self.style().standardIcon(
QStyle.SP_DirOpenIcon),
"&Open...",
self,
shortcut=QKeySequence.Open,
statusTip="Open an existing file",
triggered=self.open)
self.saveAct = QAction(self.style().standardIcon(
QStyle.SP_DialogSaveButton),
"&Save",
self,
shortcut=QKeySequence.Save,
statusTip="Save the document to disk",
triggered=self.save)
self.saveAsAct = QAction(
self.style().standardIcon(QStyle.SP_DialogSaveButton),
"Save &As...",
self,
shortcut=QKeySequence.SaveAs,
statusTip="Save the document under a new name",
triggered=self.saveAs)
self.exitAct = QAction(self.style().standardIcon(
QStyle.SP_DialogCloseButton),
"E&xit",
self,
shortcut="Ctrl+Q",
statusTip="Exit the application",
triggered=self.close)
self.textEdit = QTextEdit()
self.aboutAct = QAction(self.style().standardIcon(
QStyle.SP_MessageBoxInformation),
"&About",
self,
statusTip="Show the application's About box",
triggered=self.about)
self.aboutQtAct = QAction(self.style().standardIcon(
QStyle.SP_TitleBarMenuButton),
"About &Qt",
self,
statusTip="Show the Qt library's About box",
triggered=QApplication().aboutQt)
def _create_toolbars(self):
self.logger.info("MainWindow._create_toolbars")
self.fileToolBar = self.addToolBar("File")
self.fileToolBar.addAction(self.newAct)
self.fileToolBar.addAction(self.openAct)
self.fileToolBar.addAction(self.saveAct)
def _create_statusbar(self):
self.logger.info("MainWindow._create_statusbar")
self.statusBar().showMessage("Ready")
def _read_settings(self):
self.logger.info("MainWindow._read_settings")
settings = QSettings(ORGANIZATION_NAME, APPLICATION_NAME)
pos = settings.value("pos", QPoint(200, 200))
size = settings.value("size", QSize(400, 400))
self.resize(size)
self.move(pos)
def _write_settings(self):
self.logger.info("MainWindow._write_settings")
settings = QSettings(ORGANIZATION_NAME, APPLICATION_NAME)
settings.setValue("pos", self.pos())
settings.setValue("size", self.size())
def maybeSave(self):
self.logger.info("MainWindow.maybeSave")
if self.textEdit.document().isModified():
ret = QMessageBox.warning(
self, "Application",
"The document has been modified.\nDo you want to save "
"your changes?",
QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel)
if ret == QMessageBox.Save:
return self.save()
elif ret == QMessageBox.Cancel:
return False
return True
def closeEvent(self, event):
self.logger.info("MainWindow.closeEvent")
if self.maybeSave():
self._write_settings()
event.accept()
else:
event.ignore()
def newFile(self):
self.logger.info("MainWindow.newFile")
if self.maybeSave():
self.textEdit.clear()
self.setCurrentFile('')
def open(self):
self.logger.info("MainWindow.open")
if self.maybeSave():
filepath, _filtr = QFileDialog.getOpenFileName(self)
if filepath:
self.spectrumAnalyzer.readSpectrum(filepath)
filename = os.path.basename(filepath)
self.spectra_list_view.addItem(filename)
self.spectrumAnalyzer.plotSpectrum(self.figure1)
self.canvas1.draw()
def save(self):
self.logger.info("MainWindow.save")
if self.curFile:
return self.saveFile(self.curFile)
return self.saveAs()
def saveAs(self):
self.logger.info("MainWindow.saveAs")
fileName, _filtr = QFileDialog.getSaveFileName(self)
if fileName:
return self.saveFile(fileName)
return False
def about(self):
self.logger.info("MainWindow.about")
QMessageBox.about(
self, "About xrayspectrumanalyzer",
"The <b>xrayspectrumanalyzer</b> extract peak intensity from EDS spectrum."
)
def documentWasModified(self):
self.logger.info("MainWindow.documentWasModified")
self.setWindowModified(self.textEdit.document().isModified())
def on_key_press(self, event):
print('you pressed', event.key)
# implement the default mpl key press events described at
# http://matplotlib.org/users/navigation_toolbar.html#navigation-keyboard-shortcuts
key_press_handler(event, self.canvas1, self.mpl_toolbar1)
class WorkspaceExplorer(BaseExtension):
@BaseExtension.as_thread(wait=2500)
def event_startup(self):
dm = DataMatrix(length=0)
dm.initializing = -1
self._qdm = WorkspaceMatrix(dm, read_only=True)
self._qdm.cell_double_clicked.connect(self._inspect_variable)
self._dock_widget = QDockWidget(self.main_window)
self._dock_widget.setWidget(self._qdm)
self._dock_widget.closeEvent = self._on_close_event
self._dock_widget.setWindowTitle(_(u'Workspace'))
self._dock_widget.setObjectName('WorkspaceExplorer')
self._dock_widget.visibilityChanged.connect(
self._on_visibility_changed)
self.main_window.addDockWidget(Qt.RightDockWidgetArea,
self._dock_widget)
self._set_visible(cfg.workspace_visible)
def _inspect_variable(self, row, column):
if not row:
return
name = self._qdm.dm.name[row - 1]
self.extension_manager.fire(
'data_viewer_inspect',
name=name,
workspace=self.extension_manager.provide('jupyter_workspace_name'))
def activate(self):
if not hasattr(self, '_qdm'):
oslogger.info('ignoring activate until after startup')
return
self._set_visible(not cfg.workspace_visible)
def _on_visibility_changed(self, visible):
if not visible:
return
self._update(
self.extension_manager.provide('jupyter_workspace_name'), lambda:
self.extension_manager.provide('jupyter_workspace_globals'))
def _on_close_event(self, e):
self._set_visible(False)
def _update(self, name, workspace_func):
if (not hasattr(self, '_dock_widget')
or not self._dock_widget.isVisible()):
return
self._dock_widget.setWindowTitle(_(u'Workspace ({})').format(name))
workspace = workspace_func()
# If the workspace didn't reply, we try again in a second
if workspace is None or workspace.get(u'no reply', False) is None:
QTimer.singleShot(1000, lambda: self._update(name, workspace_func))
return
# If the current kernel doesn't expose its workspace, indicate this
if workspace.get(u'not supported', False) is None:
dm = DataMatrix(length=0)
dm.kernel_not_supported = -1
# Create a DataMatrix that exposes the workspace
else:
dm = DataMatrix(length=len(workspace))
dm.sorted = False
dm.name = ''
dm.value = ''
dm.shape = ''
dm.type = ''
for row, (var, data) in zip(dm, workspace.items()):
if data is None:
oslogger.warning(u'invalid workspace data: {}'.format(var))
continue
value, type_, shape = data
row.value = value
row.name = var
if shape is not None:
row.shape = repr(shape)
row.type = type_
self._qdm.dm = dm
self._qdm.refresh()
def _set_visible(self, visible):
cfg.workspace_visible = visible
self.set_checked(visible)
if visible:
self._dock_widget.show()
else:
self._dock_widget.hide()
def event_workspace_update(self, name, workspace_func):
self._update(name, workspace_func)
def event_workspace_restart(self, name, workspace_func):
self._update(name, workspace_func)
def event_workspace_switch(self, name, workspace_func):
self._update(name, workspace_func)
def event_workspace_new(self, name, workspace_func):
self._update(name, workspace_func)
