Source code for cdl.core.gui.main

# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.

"""
Main window
===========

The :mod:`cdl.core.gui.main` module provides the main window of the
DataLab (CDL) project.

.. autoclass:: CDLMainWindow
"""

# pylint: disable=invalid-name  # Allows short reference names like x, y, ...

from __future__ import annotations

import abc
import base64
import functools
import os
import os.path as osp
import sys
import time
import webbrowser
from typing import TYPE_CHECKING

import guidata.dataset as gds
import numpy as np
import scipy.ndimage as spi
import scipy.signal as sps
from guidata import qthelpers as guidata_qth
from guidata.configtools import get_icon
from guidata.qthelpers import add_actions, create_action
from guidata.widgets.console import DockableConsole
from plotpy import config as plotpy_config
from plotpy.builder import make
from plotpy.constants import PlotType
from qtpy import QtCore as QC
from qtpy import QtGui as QG
from qtpy import QtWidgets as QW
from qtpy.compat import getopenfilenames, getsavefilename

import cdl
from cdl import __docurl__, __homeurl__, __supporturl__, env
from cdl.config import (
    APP_DESC,
    APP_NAME,
    DATAPATH,
    DEBUG,
    IS_FROZEN,
    TEST_SEGFAULT_ERROR,
    Conf,
    _,
)
from cdl.core.baseproxy import AbstractCDLControl
from cdl.core.gui.actionhandler import ActionCategory
from cdl.core.gui.docks import DockablePlotWidget
from cdl.core.gui.h5io import H5InputOutput
from cdl.core.gui.panel import base, image, macro, signal
from cdl.core.gui.settings import edit_settings
from cdl.core.model.image import ImageObj, create_image
from cdl.core.model.signal import SignalObj, create_signal
from cdl.core.remote import RemoteServer
from cdl.env import execenv
from cdl.plugins import PluginRegistry, discover_plugins
from cdl.utils import dephash
from cdl.utils import qthelpers as qth
from cdl.utils.misc import go_to_error
from cdl.utils.qthelpers import (
    add_corner_menu,
    bring_to_front,
    configure_menu_about_to_show,
)
from cdl.widgets import instconfviewer, logviewer, status

if TYPE_CHECKING:
    from typing import Literal

    from cdl.core.gui.panel.base import AbstractPanel, BaseDataPanel
    from cdl.core.gui.panel.image import ImagePanel
    from cdl.core.gui.panel.macro import MacroPanel
    from cdl.core.gui.panel.signal import SignalPanel
    from cdl.plugins import PluginBase


def remote_controlled(func):
    """Decorator for remote-controlled methods"""

    @functools.wraps(func)
    def method_wrapper(*args, **kwargs):
        """Decorator wrapper function"""
        win = args[0]  # extracting 'self' from method arguments
        already_busy = not win.ready_flag
        win.ready_flag = False
        try:
            output = func(*args, **kwargs)
        finally:
            if not already_busy:
                win.SIG_READY.emit()
                win.ready_flag = True
            QW.QApplication.processEvents()
        return output

    return method_wrapper


class CDLMainWindowMeta(type(QW.QMainWindow), abc.ABCMeta):
    """Mixed metaclass to avoid conflicts"""


[docs] class CDLMainWindow(QW.QMainWindow, AbstractCDLControl, metaclass=CDLMainWindowMeta): """DataLab main window Args: console: enable internal console hide_on_close: True to hide window on close """ __instance = None SIG_READY = QC.Signal() SIG_SEND_OBJECT = QC.Signal(object) SIG_SEND_OBJECTLIST = QC.Signal(object) SIG_CLOSING = QC.Signal()
[docs] @staticmethod def get_instance(console=None, hide_on_close=False): """Return singleton instance""" if CDLMainWindow.__instance is None: return CDLMainWindow(console, hide_on_close) return CDLMainWindow.__instance
def __init__(self, console=None, hide_on_close=False): """Initialize main window""" CDLMainWindow.__instance = self super().__init__() self.setObjectName(APP_NAME) self.setWindowIcon(get_icon("DataLab.svg")) execenv.log(self, "Starting initialization") self.ready_flag = True self.hide_on_close = hide_on_close self.__old_size: tuple[int, int] | None = None self.__memory_warning = False self.memorystatus: status.MemoryStatus | None = None self.console: DockableConsole | None = None self.macropanel: MacroPanel | None = None self.main_toolbar: QW.QToolBar | None = None self.signalpanel_toolbar: QW.QToolBar | None = None self.imagepanel_toolbar: QW.QToolBar | None = None self.signalpanel: SignalPanel | None = None self.imagepanel: ImagePanel | None = None self.tabwidget: QW.QTabWidget | None = None self.tabmenu: QW.QMenu | None = None self.docks: dict[AbstractPanel, QW.QDockWidget] | None = None self.h5inputoutput = H5InputOutput(self) self.openh5_action: QW.QAction | None = None self.saveh5_action: QW.QAction | None = None self.browseh5_action: QW.QAction | None = None self.settings_action: QW.QAction | None = None self.quit_action: QW.QAction | None = None self.autorefresh_action: QW.QAction | None = None self.showfirstonly_action: QW.QAction | None = None self.showlabel_action: QW.QAction | None = None self.file_menu: QW.QMenu | None = None self.edit_menu: QW.QMenu | None = None self.operation_menu: QW.QMenu | None = None self.processing_menu: QW.QMenu | None = None self.analysis_menu: QW.QMenu | None = None self.plugins_menu: QW.QMenu | None = None self.view_menu: QW.QMenu | None = None self.help_menu: QW.QMenu | None = None self.__update_color_mode(startup=True) self.__is_modified = False self.set_modified(False) # Starting XML-RPC server thread self.remote_server = RemoteServer(self) if Conf.main.rpc_server_enabled.get(): self.remote_server.SIG_SERVER_PORT.connect(self.xmlrpc_server_started) self.remote_server.start() # Setup actions and menus if console is None: console = Conf.console.console_enabled.get() self.setup(console) self.__restore_pos_and_size() execenv.log(self, "Initialization done") # ------API related to XML-RPC remote control
[docs] @staticmethod def xmlrpc_server_started(port): """XML-RPC server has started, writing comm port in configuration file""" Conf.main.rpc_server_port.set(port)
def __get_current_basedatapanel(self) -> BaseDataPanel: """Return the current BaseDataPanel, or the signal panel if macro panel is active Returns: BaseDataPanel: current panel """ panel = self.tabwidget.currentWidget() if not isinstance(panel, base.BaseDataPanel): panel = self.signalpanel return panel def __get_datapanel(self, panel: str | None) -> BaseDataPanel: """Return a specific BaseDataPanel. Args: panel: panel name (valid values: "signal", "image"). If None, current panel is used. Returns: Panel widget Raises: ValueError: if panel is unknown """ if not panel: return self.__get_current_basedatapanel() if panel == "signal": return self.signalpanel if panel == "image": return self.imagepanel raise ValueError(f"Unknown panel: {panel}")
[docs] @remote_controlled def get_group_titles_with_object_infos( self, ) -> tuple[list[str], list[list[str]], list[list[str]]]: """Return groups titles and lists of inner objects uuids and titles. Returns: Tuple: groups titles, lists of inner objects uuids and titles """ panel = self.__get_current_basedatapanel() return panel.objmodel.get_group_titles_with_object_infos()
[docs] @remote_controlled def get_object_titles(self, panel: str | None = None) -> list[str]: """Get object (signal/image) list for current panel. Objects are sorted by group number and object index in group. Args: panel: panel name (valid values: "signal", "image", "macro"). If None, current data panel is used (i.e. signal or image panel). Returns: List of object titles Raises: ValueError: if panel is unknown """ if not panel or panel in ("signal", "image"): return self.__get_datapanel(panel).objmodel.get_object_titles() if panel == "macro": return self.macropanel.get_macro_titles() raise ValueError(f"Unknown panel: {panel}")
[docs] @remote_controlled def get_object( self, nb_id_title: int | str | None = None, panel: str | None = None, ) -> SignalObj | ImageObj: """Get object (signal/image) from index. Args: nb_id_title: Object number, or object id, or object title. Defaults to None (current object). panel: Panel name. Defaults to None (current panel). Returns: Object Raises: KeyError: if object not found TypeError: if index_id_title type is invalid """ panelw = self.__get_datapanel(panel) if nb_id_title is None: return panelw.objview.get_current_object() if isinstance(nb_id_title, int): return panelw.objmodel.get_object_from_number(nb_id_title) if isinstance(nb_id_title, str): try: return panelw.objmodel[nb_id_title] except KeyError: try: return panelw.objmodel.get_object_from_title(nb_id_title) except KeyError as exc: raise KeyError( f"Invalid object index, id or title: {nb_id_title}" ) from exc raise TypeError(f"Invalid index_id_title type: {type(nb_id_title)}")
[docs] @remote_controlled def get_object_uuids(self, panel: str | None = None) -> list[str]: """Get object (signal/image) uuid list for current panel. Objects are sorted by group number and object index in group. Args: panel (str | None): panel name (valid values: "signal", "image"). If None, current panel is used. Returns: list[str]: list of object uuids Raises: ValueError: if panel is unknown """ return self.__get_datapanel(panel).objmodel.get_object_ids()
[docs] @remote_controlled def get_sel_object_uuids(self, include_groups: bool = False) -> list[str]: """Return selected objects uuids. Args: include_groups: If True, also return objects from selected groups. Returns: List of selected objects uuids. """ panel = self.__get_current_basedatapanel() return panel.objview.get_sel_object_uuids(include_groups)
[docs] @remote_controlled def select_objects( self, selection: list[int | str], panel: str | None = None, ) -> None: """Select objects in current panel. Args: selection: List of object numbers (1 to N) or uuids to select panel: panel name (valid values: "signal", "image"). If None, current panel is used. Defaults to None. """ panel = self.__get_datapanel(panel) panel.objview.select_objects(selection)
[docs] @remote_controlled def select_groups( self, selection: list[int | str] | None = None, panel: str | None = None ) -> None: """Select groups in current panel. Args: selection: List of group numbers (1 to N), or list of group uuids, or None to select all groups. Defaults to None. panel (str | None): panel name (valid values: "signal", "image"). If None, current panel is used. Defaults to None. """ panel = self.__get_datapanel(panel) panel.objview.select_groups(selection)
[docs] @remote_controlled def delete_metadata( self, refresh_plot: bool = True, keep_roi: bool = False ) -> None: """Delete metadata of selected objects Args: refresh_plot: Refresh plot. Defaults to True. keep_roi: Keep ROI. Defaults to False. """ panel = self.__get_current_basedatapanel() panel.delete_metadata(refresh_plot, keep_roi)
[docs] @remote_controlled def get_object_shapes( self, nb_id_title: int | str | None = None, panel: str | None = None, ) -> list: """Get plot item shapes associated to object (signal/image). Args: nb_id_title: Object number, or object id, or object title. Defaults to None (current object). panel: Panel name. Defaults to None (current panel). Returns: List of plot item shapes """ obj = self.get_object(nb_id_title, panel) return list(obj.iterate_shape_items(editable=False))
[docs] @remote_controlled def add_annotations_from_items( self, items: list, refresh_plot: bool = True, panel: str | None = None ) -> None: """Add object annotations (annotation plot items). Args: items (list): annotation plot items refresh_plot (bool | None): refresh plot. Defaults to True. panel (str | None): panel name (valid values: "signal", "image"). If None, current panel is used. """ panel = self.__get_datapanel(panel) panel.add_annotations_from_items(items, refresh_plot)
[docs] @remote_controlled def add_label_with_title( self, title: str | None = None, panel: str | None = None ) -> None: """Add a label with object title on the associated plot Args: title (str | None): Label title. Defaults to None. If None, the title is the object title. panel (str | None): panel name (valid values: "signal", "image"). If None, current panel is used. """ self.__get_datapanel(panel).add_label_with_title(title)
[docs] @remote_controlled def run_macro(self, number_or_title: int | str | None = None) -> None: """Run macro. Args: number: Number of the macro (starting at 1). Defaults to None (run current macro, or does nothing if there is no macro). """ self.macropanel.run_macro(number_or_title)
[docs] @remote_controlled def stop_macro(self, number_or_title: int | str | None = None) -> None: """Stop macro. Args: number: Number of the macro (starting at 1). Defaults to None (stop current macro, or does nothing if there is no macro). """ self.macropanel.stop_macro(number_or_title)
[docs] @remote_controlled def import_macro_from_file(self, filename: str) -> None: """Import macro from file Args: filename: Filename. """ self.macropanel.import_macro_from_file(filename)
# ------Misc. @property def panels(self) -> tuple[AbstractPanel, ...]: """Return the tuple of implemented panels (signal, image) Returns: tuple[SignalPanel, ImagePanel, MacroPanel]: tuple of panels """ return (self.signalpanel, self.imagepanel, self.macropanel) def __set_low_memory_state(self, state: bool) -> None: """Set memory warning state""" self.__memory_warning = state
[docs] def confirm_memory_state(self) -> bool: # pragma: no cover """Check memory warning state and eventually show a warning dialog Returns: bool: True if memory state is ok """ if not env.execenv.unattended and self.__memory_warning: threshold = Conf.main.available_memory_threshold.get() answer = QW.QMessageBox.critical( self, _("Warning"), _("Available memory is below %d MB.<br><br>Do you want to continue?") % threshold, QW.QMessageBox.Yes | QW.QMessageBox.No, ) return answer == QW.QMessageBox.Yes return True
[docs] def check_stable_release(self) -> None: # pragma: no cover """Check if this is a stable release""" if cdl.__version__.replace(".", "").isdigit(): # This is a stable release return if "b" in cdl.__version__: # This is a beta release rel = _( "This software is in the <b>beta stage</b> of its release cycle. " "The focus of beta testing is providing a feature complete " "software for users interested in trying new features before " "the final release. However, <u>beta software may not behave as " "expected and will probably have more bugs or performance issues " "than completed software</u>." ) else: # This is an alpha release rel = _( "This software is in the <b>alpha stage</b> of its release cycle. " "The focus of alpha testing is providing an incomplete software " "for early testing of specific features by users. " "Please note that <u>alpha software was not thoroughly tested</u> " "by the developer before it is released." ) txtlist = [ f"<b>{APP_NAME}</b> v{cdl.__version__}:", "", _("<i>This is not a stable release.</i>"), "", rel, ] if not env.execenv.unattended: QW.QMessageBox.warning( self, APP_NAME, "<br>".join(txtlist), QW.QMessageBox.Ok )
def __check_dependencies(self) -> None: # pragma: no cover """Check dependencies""" if IS_FROZEN or execenv.unattended: # No need to check dependencies if DataLab has been frozen, or if # the user has chosen to ignore this check, or if we are in unattended mode # (i.e. running automated tests) if IS_FROZEN: QW.QMessageBox.information( self, _("Information"), _( "The dependency check feature is not relevant for the " "standalone version of DataLab." ), QW.QMessageBox.Ok, ) return try: state = dephash.check_dependencies_hash(DATAPATH) bad_deps = [name for name in state if not state[name]] if not bad_deps: # Everything is OK QW.QMessageBox.information( self, _("Information"), _( "All critical dependencies of DataLab have been qualified " "on this operating system." ), QW.QMessageBox.Ok, ) return except IOError: bad_deps = None txt0 = _("Non-compliant dependency:") if bad_deps is None or len(bad_deps) > 1: txt0 = _("Non-compliant dependencies:") if bad_deps is None: txtlist = [ _("DataLab has not yet been qualified on your operating system."), ] else: txtlist = [ "<u>" + txt0 + "</u> " + ", ".join(bad_deps), "", _( "At least one dependency does not comply with DataLab " "qualification standard reference (wrong dependency version " "has been installed, or dependency source code has been " "modified, or the application has not yet been qualified " "on your operating system)." ), ] txtlist += [ "", _( "This means that the application has not been officially qualified " "in this context and may not behave as expected." ), ] txt = "<br>".join(txtlist) QW.QMessageBox.warning(self, APP_NAME, txt, QW.QMessageBox.Ok)
[docs] def check_for_previous_crash(self) -> None: # pragma: no cover """Check for previous crash""" if execenv.unattended and not execenv.do_not_quit: # Showing the log viewer for testing purpose (unattended mode) but only # if option 'do_not_quit' is not set, to avoid blocking the test suite self.__show_logviewer() elif Conf.main.faulthandler_log_available.get( False ) or Conf.main.traceback_log_available.get(False): txt = "<br>".join( [ logviewer.get_log_prompt_message(), "", _("Do you want to see available log files?"), ] ) btns = QW.QMessageBox.StandardButton.Yes | QW.QMessageBox.StandardButton.No choice = QW.QMessageBox.warning(self, APP_NAME, txt, btns) if choice == QW.QMessageBox.StandardButton.Yes: self.__show_logviewer()
[docs] def execute_post_show_actions(self) -> None: """Execute post-show actions""" self.check_stable_release() self.check_for_previous_crash() tour = Conf.main.tour_enabled.get() if tour: Conf.main.tour_enabled.set(False) self.show_tour()
[docs] def take_screenshot(self, name: str) -> None: # pragma: no cover """Take main window screenshot""" self.memorystatus.set_demo_mode(True) qth.grab_save_window(self, f"{name}") self.memorystatus.set_demo_mode(False)
[docs] def take_menu_screenshots(self) -> None: # pragma: no cover """Take menu screenshots""" for panel in self.panels: if isinstance(panel, base.BaseDataPanel): self.tabwidget.setCurrentWidget(panel) for name in ( "file", "edit", "view", "operation", "processing", "analysis", "help", ): menu = getattr(self, f"{name}_menu") menu.popup(self.pos()) qth.grab_save_window(menu, f"{panel.objectName()}_{name}") menu.close()
# ------GUI setup def __restore_pos_and_size(self) -> None: """Restore main window position and size from configuration""" pos = Conf.main.window_position.get(None) if pos is not None: posx, posy = pos self.move(QC.QPoint(posx, posy)) size = Conf.main.window_size.get(None) if size is None: size = 1200, 700 width, height = size self.resize(QC.QSize(width, height)) if pos is not None and size is not None: sgeo = self.screen().availableGeometry() out_inf = posx < -int(0.9 * width) or posy < -int(0.9 * height) out_sup = posx > int(0.9 * sgeo.width()) or posy > int(0.9 * sgeo.height()) if len(QW.QApplication.screens()) == 1 and (out_inf or out_sup): # Main window is offscreen posx = min(max(posx, 0), sgeo.width() - width) posy = min(max(posy, 0), sgeo.height() - height) self.move(QC.QPoint(posx, posy)) def __restore_state(self) -> None: """Restore main window state from configuration""" state = Conf.main.window_state.get(None) if state is not None: state = base64.b64decode(state) self.restoreState(QC.QByteArray(state)) for widget in self.children(): if isinstance(widget, QW.QDockWidget): self.restoreDockWidget(widget) def __save_pos_size_and_state(self) -> None: """Save main window position, size and state to configuration""" is_maximized = self.windowState() == QC.Qt.WindowMaximized Conf.main.window_maximized.set(is_maximized) if not is_maximized: size = self.size() Conf.main.window_size.set((size.width(), size.height())) pos = self.pos() Conf.main.window_position.set((pos.x(), pos.y())) # Encoding window state into base64 string to avoid sending binary data # to the configuration file: state = base64.b64encode(self.saveState().data()).decode("ascii") Conf.main.window_state.set(state)
[docs] def setup(self, console: bool = False) -> None: """Setup main window Args: console: True to setup console """ self.__register_plugins() self.__configure_statusbar() self.__setup_global_actions() self.__add_signal_image_panels() self.__create_plugins_actions() self.__setup_central_widget() self.__add_menus() if console: self.__setup_console() self.__update_actions(update_other_data_panel=True) self.__add_macro_panel() self.__configure_panels() # Now that everything is set up, we can restore the window state: self.__restore_state()
def __register_plugins(self) -> None: """Register plugins""" with qth.try_or_log_error("Discovering plugins"): # Discovering plugins plugin_nb = len(discover_plugins()) execenv.log(self, f"{plugin_nb} plugin(s) found") for plugin_class in PluginRegistry.get_plugin_classes(): with qth.try_or_log_error(f"Instantiating plugin {plugin_class.__name__}"): # Instantiating plugin plugin: PluginBase = plugin_class() with qth.try_or_log_error(f"Registering plugin {plugin.info.name}"): # Registering plugin plugin.register(self) def __create_plugins_actions(self) -> None: """Create plugins actions""" with self.signalpanel.acthandler.new_category(ActionCategory.PLUGINS): with self.imagepanel.acthandler.new_category(ActionCategory.PLUGINS): for plugin in PluginRegistry.get_plugins(): with qth.try_or_log_error(f"Create actions for {plugin.info.name}"): plugin.create_actions() @staticmethod def __unregister_plugins() -> None: """Unregister plugins""" while PluginRegistry.get_plugins(): # Unregistering plugin plugin = PluginRegistry.get_plugins()[-1] with qth.try_or_log_error(f"Unregistering plugin {plugin.info.name}"): plugin.unregister() def __configure_statusbar(self) -> None: """Configure status bar""" self.statusBar().showMessage(_("Welcome to %s!") % APP_NAME, 5000) # Plugin status pluginstatus = status.PluginStatus() self.statusBar().addPermanentWidget(pluginstatus) # XML-RPC server status xmlrpcstatus = status.XMLRPCStatus() xmlrpcstatus.set_port(self.remote_server.port) self.statusBar().addPermanentWidget(xmlrpcstatus) # Memory status threshold = Conf.main.available_memory_threshold.get() self.memorystatus = status.MemoryStatus(threshold) self.memorystatus.SIG_MEMORY_ALARM.connect(self.__set_low_memory_state) self.statusBar().addPermanentWidget(self.memorystatus) def __add_toolbar( self, title: str, position: Literal["top", "bottom", "left", "right"], name: str ) -> QW.QToolBar: """Add toolbar to main window Args: title: toolbar title position: toolbar position name: toolbar name (Qt object name) """ toolbar = QW.QToolBar(title, self) toolbar.setObjectName(name) area = getattr(QC.Qt, f"{position.capitalize()}ToolBarArea") self.addToolBar(area, toolbar) return toolbar def __setup_global_actions(self) -> None: """Setup global actions""" self.openh5_action = create_action( self, _("Open HDF5 files..."), icon=get_icon("fileopen_h5.svg"), tip=_("Open one or several HDF5 files"), triggered=lambda checked=False: self.open_h5_files(import_all=True), ) self.saveh5_action = create_action( self, _("Save to HDF5 file..."), icon=get_icon("filesave_h5.svg"), tip=_("Save to HDF5 file"), triggered=self.save_to_h5_file, ) self.browseh5_action = create_action( self, _("Browse HDF5 file..."), icon=get_icon("h5browser.svg"), tip=_("Browse an HDF5 file"), triggered=lambda checked=False: self.open_h5_files(import_all=None), ) self.settings_action = create_action( self, _("Settings..."), icon=get_icon("libre-gui-settings.svg"), tip=_("Open settings dialog"), triggered=self.__edit_settings, ) self.main_toolbar = self.__add_toolbar( _("Main Toolbar"), "left", "main_toolbar" ) add_actions( self.main_toolbar, [ self.openh5_action, self.saveh5_action, self.browseh5_action, None, self.settings_action, ], ) # Quit action for "File menu" (added when populating menu on demand) if self.hide_on_close: quit_text = _("Hide window") quit_tip = _("Hide DataLab window") else: quit_text = _("Quit") quit_tip = _("Quit application") if sys.platform != "darwin": # On macOS, the "Quit" action is automatically added to the application menu self.quit_action = create_action( self, quit_text, shortcut=QG.QKeySequence(QG.QKeySequence.Quit), icon=get_icon("libre-gui-close.svg"), tip=quit_tip, triggered=self.close, ) # View menu actions self.autorefresh_action = create_action( self, _("Auto-refresh"), icon=get_icon("refresh-auto.svg"), tip=_("Auto-refresh plot when object is modified, added or removed"), toggled=self.toggle_auto_refresh, ) self.showfirstonly_action = create_action( self, _("Show first object only"), icon=get_icon("show_first.svg"), tip=_("Show only the first selected object (signal or image)"), toggled=self.toggle_show_first_only, ) self.showlabel_action = create_action( self, _("Show graphical object titles"), icon=get_icon("show_titles.svg"), tip=_("Show or hide ROI and other graphical object titles or subtitles"), toggled=self.toggle_show_titles, ) def __add_signal_panel(self) -> None: """Setup signal toolbar, widgets and panel""" self.signalpanel_toolbar = self.__add_toolbar( _("Signal Panel Toolbar"), "left", "signalpanel_toolbar" ) dpw = DockablePlotWidget(self, PlotType.CURVE) self.signalpanel = signal.SignalPanel(self, dpw, self.signalpanel_toolbar) self.signalpanel.SIG_STATUS_MESSAGE.connect(self.statusBar().showMessage) plot = dpw.get_plot() plot.add_item(make.legend("TR")) plot.SIG_ITEM_PARAMETERS_CHANGED.connect( self.signalpanel.plot_item_parameters_changed ) plot.SIG_ITEM_MOVED.connect(self.signalpanel.plot_item_moved) return dpw def __add_image_panel(self) -> None: """Setup image toolbar, widgets and panel""" self.imagepanel_toolbar = self.__add_toolbar( _("Image Panel Toolbar"), "left", "imagepanel_toolbar" ) dpw = DockablePlotWidget(self, PlotType.IMAGE) self.imagepanel = image.ImagePanel(self, dpw, self.imagepanel_toolbar) # ----------------------------------------------------------------------------- # # Before eventually disabling the "peritem" mode by default, wait for the # # plotpy bug to be fixed (peritem mode is not compatible with multiple image # # items): # for cspanel in ( # self.imagepanel.plotwidget.get_xcs_panel(), # self.imagepanel.plotwidget.get_ycs_panel(), # ): # cspanel.peritem_ac.setChecked(False) # ----------------------------------------------------------------------------- self.imagepanel.SIG_STATUS_MESSAGE.connect(self.statusBar().showMessage) plot = dpw.get_plot() plot.SIG_ITEM_PARAMETERS_CHANGED.connect( self.imagepanel.plot_item_parameters_changed ) plot.SIG_ITEM_MOVED.connect(self.imagepanel.plot_item_moved) plot.SIG_LUT_CHANGED.connect(self.imagepanel.plot_lut_changed) return dpw def __update_tab_menu(self) -> None: """Update tab menu""" current_panel: BaseDataPanel = self.tabwidget.currentWidget() add_actions(self.tabmenu, current_panel.get_context_menu().actions()) def __add_signal_image_panels(self) -> None: """Add signal and image panels""" self.tabwidget = QW.QTabWidget() self.tabmenu = add_corner_menu(self.tabwidget) configure_menu_about_to_show(self.tabmenu, self.__update_tab_menu) cdock = self.__add_dockwidget(self.__add_signal_panel(), title=_("Signal View")) idock = self.__add_dockwidget(self.__add_image_panel(), title=_("Image View")) self.tabifyDockWidget(cdock, idock) self.docks = {self.signalpanel: cdock, self.imagepanel: idock} self.tabwidget.currentChanged.connect(self.__tab_index_changed) self.signalpanel.SIG_OBJECT_ADDED.connect( lambda: self.set_current_panel("signal") ) self.imagepanel.SIG_OBJECT_ADDED.connect( lambda: self.set_current_panel("image") ) for panel in (self.signalpanel, self.imagepanel): panel.setup_panel() def __setup_central_widget(self) -> None: """Setup central widget (main panel)""" self.tabwidget.setMaximumWidth(500) self.tabwidget.addTab( self.signalpanel, get_icon("signal.svg"), _("Signal Panel") ) self.tabwidget.addTab(self.imagepanel, get_icon("image.svg"), _("Image Panel")) self.setCentralWidget(self.tabwidget) @staticmethod def __get_local_doc_path() -> str | None: """Return local documentation path, if it exists""" locale = QC.QLocale.system().name() for suffix in ("_" + locale[:2], "_en"): path = osp.join(DATAPATH, "doc", f"{APP_NAME}{suffix}.pdf") if osp.isfile(path): return path return None def __add_menus(self) -> None: """Adding menus""" self.file_menu = self.menuBar().addMenu(_("File")) configure_menu_about_to_show(self.file_menu, self.__update_file_menu) self.edit_menu = self.menuBar().addMenu(_("&Edit")) self.operation_menu = self.menuBar().addMenu(_("Operations")) self.processing_menu = self.menuBar().addMenu(_("Processing")) self.analysis_menu = self.menuBar().addMenu(_("Analysis")) self.plugins_menu = self.menuBar().addMenu(_("Plugins")) self.view_menu = self.menuBar().addMenu(_("&View")) configure_menu_about_to_show(self.view_menu, self.__update_view_menu) self.help_menu = self.menuBar().addMenu("?") for menu in ( self.edit_menu, self.operation_menu, self.processing_menu, self.analysis_menu, self.plugins_menu, ): configure_menu_about_to_show(menu, self.__update_generic_menu) help_menu_actions = [ create_action( self, _("Online documentation"), icon=get_icon("libre-gui-help.svg"), triggered=lambda: webbrowser.open(__docurl__), ), ] localdocpath = self.__get_local_doc_path() if localdocpath is not None: help_menu_actions += [ create_action( self, _("PDF documentation"), icon=get_icon("help_pdf.svg"), triggered=lambda: webbrowser.open(localdocpath), ), ] help_menu_actions += [ create_action( self, _("Tour") + "...", icon=get_icon("tour.svg"), triggered=self.show_tour, ), create_action( self, _("Demo") + "...", icon=get_icon("play_demo.svg"), triggered=self.play_demo, ), None, ] if TEST_SEGFAULT_ERROR: help_menu_actions += [ create_action( self, _("Test segfault/Python error"), triggered=self.test_segfault_error, ) ] help_menu_actions += [ create_action( self, _("Log files") + "...", icon=get_icon("logs.svg"), triggered=self.__show_logviewer, ), create_action( self, _("Installation and configuration") + "...", icon=get_icon("libre-toolbox.svg"), triggered=lambda: instconfviewer.exec_cdl_installconfig_dialog(self), ), None, create_action( self, _("Project home page"), icon=get_icon("libre-gui-globe.svg"), triggered=lambda: webbrowser.open(__homeurl__), ), create_action( self, _("Bug report or feature request"), icon=get_icon("libre-gui-globe.svg"), triggered=lambda: webbrowser.open(__supporturl__), ), create_action( self, _("Check critical dependencies..."), triggered=self.__check_dependencies, ), create_action( self, _("About..."), icon=get_icon("libre-gui-about.svg"), triggered=self.__about, ), ] add_actions(self.help_menu, help_menu_actions) def __setup_console(self) -> None: """Add an internal console""" ns = { "cdl": self, "np": np, "sps": sps, "spi": spi, "os": os, "sys": sys, "osp": osp, "time": time, } msg = ( "Welcome to DataLab console!\n" "---------------------------\n" "You can access the main window with the 'cdl' variable.\n" "Example:\n" " o = cdl.get_object() # returns currently selected object\n" " o = cdl[1] # returns object number 1\n" " o = cdl['My image'] # returns object which title is 'My image'\n" " o.data # returns object data\n" "Modules imported at startup: " "os, sys, os.path as osp, time, " "numpy as np, scipy.signal as sps, scipy.ndimage as spi" ) self.console = DockableConsole(self, namespace=ns, message=msg, debug=DEBUG) self.console.setMaximumBlockCount(Conf.console.max_line_count.get(5000)) self.console.go_to_error.connect(go_to_error) console_dock = self.__add_dockwidget(self.console, _("Console")) console_dock.hide() self.console.interpreter.widget_proxy.sig_new_prompt.connect( lambda txt: self.repopulate_panel_trees() ) def __add_macro_panel(self) -> None: """Add macro panel""" self.macropanel = macro.MacroPanel() mdock = self.__add_dockwidget(self.macropanel, _("Macro Panel")) self.docks[self.macropanel] = mdock self.tabifyDockWidget(self.docks[self.imagepanel], mdock) self.docks[self.signalpanel].raise_() def __configure_panels(self) -> None: """Configure panels""" # Connectings signals for panel in self.panels: panel.SIG_OBJECT_ADDED.connect(self.set_modified) panel.SIG_OBJECT_REMOVED.connect(self.set_modified) self.macropanel.SIG_OBJECT_MODIFIED.connect(self.set_modified) # Initializing common panel actions self.autorefresh_action.setChecked(Conf.view.auto_refresh.get(True)) self.showfirstonly_action.setChecked(Conf.view.show_first_only.get(False)) self.showlabel_action.setChecked(Conf.view.show_label.get(False)) # Restoring current tab from last session tab_idx = Conf.main.current_tab.get(None) if tab_idx is not None: self.tabwidget.setCurrentIndex(tab_idx) # Set focus on current panel, so that keyboard shortcuts work (Fixes #10) self.tabwidget.currentWidget().setFocus()
[docs] def set_process_isolation_enabled(self, state: bool) -> None: """Enable/disable process isolation Args: state (bool): True to enable process isolation """ for processor in (self.imagepanel.processor, self.signalpanel.processor): processor.set_process_isolation_enabled(state)
# ------Remote control
[docs] @remote_controlled def get_current_panel(self) -> str: """Return current panel name Returns: str: panel name (valid values: "signal", "image", "macro") """ panel = self.tabwidget.currentWidget() dock = self.docks[panel] if panel is self.signalpanel and dock.isVisible(): return "signal" if panel is self.imagepanel and dock.isVisible(): return "image" return "macro"
[docs] @remote_controlled def set_current_panel(self, panel: str) -> None: """Switch to panel. Args: panel (str): panel name (valid values: "signal", "image", "macro") Raises: ValueError: unknown panel """ if self.get_current_panel() == panel: if panel in ("signal", "image"): # Force tab index changed event to be sure that the dock associated # to the current panel is raised self.__tab_index_changed(self.tabwidget.currentIndex()) return if panel == "signal": self.tabwidget.setCurrentWidget(self.signalpanel) elif panel == "image": self.tabwidget.setCurrentWidget(self.imagepanel) elif panel == "macro": self.docks[self.macropanel].raise_() else: raise ValueError(f"Unknown panel {panel}")
[docs] @remote_controlled def calc(self, name: str, param: gds.DataSet | None = None) -> None: """Call compute function ``name`` in current panel's processor. Args: name: Compute function name param: Compute function parameter. Defaults to None. Raises: ValueError: unknown function """ panels = [self.tabwidget.currentWidget()] panels.extend(self.panels) for panel in panels: if isinstance(panel, base.BaseDataPanel): for funcname in (name, f"compute_{name}"): func = getattr(panel.processor, funcname, None) if func is not None: if param is None: func() else: func(param) return raise ValueError(f"Unknown function {name}")
# ------GUI refresh
[docs] def has_objects(self) -> bool: """Return True if sig/ima panels have any object""" return sum(len(panel) for panel in self.panels) > 0
[docs] def set_modified(self, state: bool = True) -> None: """Set mainwindow modified state""" state = state and self.has_objects() self.__is_modified = state title = APP_NAME + ("*" if state else "") if not cdl.__version__.replace(".", "").isdigit(): title += f" [{cdl.__version__}]" self.setWindowTitle(title)
def __add_dockwidget(self, child, title: str) -> QW.QDockWidget: """Add QDockWidget and toggleViewAction""" dockwidget, location = child.create_dockwidget(title) dockwidget.setObjectName(title) self.addDockWidget(location, dockwidget) return dockwidget
[docs] def repopulate_panel_trees(self) -> None: """Repopulate all panel trees""" for panel in self.panels: if isinstance(panel, base.BaseDataPanel): panel.objview.populate_tree()
def __update_actions(self, update_other_data_panel: bool = False) -> None: """Update selection dependent actions Args: update_other_data_panel: True to update other data panel actions (i.e. if the current panel is the signal panel, also update the image panel actions, and vice-versa) """ is_signal = self.tabwidget.currentWidget() is self.signalpanel panel = self.signalpanel if is_signal else self.imagepanel other_panel = self.imagepanel if is_signal else self.signalpanel if update_other_data_panel: other_panel.selection_changed() panel.selection_changed() self.signalpanel_toolbar.setVisible(is_signal) self.imagepanel_toolbar.setVisible(not is_signal) if self.plugins_menu is not None: plugin_actions = panel.get_category_actions(ActionCategory.PLUGINS) self.plugins_menu.setEnabled(len(plugin_actions) > 0) def __tab_index_changed(self, index: int) -> None: """Switch from signal to image mode, or vice-versa""" dock = self.docks[self.tabwidget.widget(index)] dock.raise_() self.__update_actions() def __update_generic_menu(self, menu: QW.QMenu | None = None) -> None: """Update menu before showing up -- Generic method""" if menu is None: menu = self.sender() menu.clear() panel = self.tabwidget.currentWidget() category = { self.file_menu: ActionCategory.FILE, self.edit_menu: ActionCategory.EDIT, self.view_menu: ActionCategory.VIEW, self.operation_menu: ActionCategory.OPERATION, self.processing_menu: ActionCategory.PROCESSING, self.analysis_menu: ActionCategory.ANALYSIS, self.plugins_menu: ActionCategory.PLUGINS, }[menu] actions = panel.get_category_actions(category) add_actions(menu, actions) def __update_file_menu(self) -> None: """Update file menu before showing up""" self.saveh5_action.setEnabled(self.has_objects()) self.__update_generic_menu(self.file_menu) add_actions( self.file_menu, [ None, self.openh5_action, self.saveh5_action, self.browseh5_action, None, self.settings_action, ], ) if self.quit_action is not None: add_actions(self.file_menu, [None, self.quit_action]) def __update_view_menu(self) -> None: """Update view menu before showing up""" self.__update_generic_menu(self.view_menu) add_actions(self.view_menu, [None] + self.createPopupMenu().actions())
[docs] @remote_controlled def toggle_show_titles(self, state: bool) -> None: """Toggle show annotations option Args: state: state """ Conf.view.show_label.set(state) for datapanel in (self.signalpanel, self.imagepanel): for obj in datapanel.objmodel: obj.set_metadata_option("showlabel", state) datapanel.SIG_REFRESH_PLOT.emit("selected", True)
[docs] @remote_controlled def toggle_auto_refresh(self, state: bool) -> None: """Toggle auto refresh option Args: state: state """ Conf.view.auto_refresh.set(state) for datapanel in (self.signalpanel, self.imagepanel): datapanel.plothandler.set_auto_refresh(state)
[docs] @remote_controlled def toggle_show_first_only(self, state: bool) -> None: """Toggle show first only option Args: state: state """ Conf.view.show_first_only.set(state) for datapanel in (self.signalpanel, self.imagepanel): datapanel.plothandler.set_show_first_only(state)
# ------Common features
[docs] @remote_controlled def reset_all(self) -> None: """Reset all application data""" for panel in self.panels: if panel is not None: panel.remove_all_objects()
@staticmethod def __check_h5file(filename: str, operation: str) -> str: """Check HDF5 filename""" filename = osp.abspath(osp.normpath(filename)) bname = osp.basename(filename) if operation == "load" and not osp.isfile(filename): raise IOError(f'File not found "{bname}"') Conf.main.base_dir.set(filename) return filename
[docs] @remote_controlled def save_to_h5_file(self, filename=None) -> None: """Save to a DataLab HDF5 file Args: filename (str): HDF5 filename. If None, a file dialog is opened. Raises: IOError: if filename is invalid or file cannot be saved. """ if filename is None: basedir = Conf.main.base_dir.get() with qth.save_restore_stds(): filename, _fl = getsavefilename(self, _("Save"), basedir, "HDF5 (*.h5)") if not filename: return with qth.qt_try_loadsave_file(self, filename, "save"): filename = self.__check_h5file(filename, "save") self.h5inputoutput.save_file(filename) self.set_modified(False)
[docs] @remote_controlled def open_h5_files( self, h5files: list[str] | None = None, import_all: bool | None = None, reset_all: bool | None = None, ) -> None: """Open a DataLab HDF5 file or import from any other HDF5 file. Args: h5files: HDF5 filenames (optionally with dataset name, separated by ":") import_all (bool): Import all datasets from HDF5 files reset_all (bool): Reset all application data before importing Returns: None """ if not self.confirm_memory_state(): return if reset_all is None: reset_all = False if self.has_objects(): answer = QW.QMessageBox.question( self, _("Warning"), _( "Do you want to remove all signals and images " "before importing data from HDF5 files?" ), QW.QMessageBox.Yes | QW.QMessageBox.No, ) if answer == QW.QMessageBox.Yes: reset_all = True if h5files is None: basedir = Conf.main.base_dir.get() with qth.save_restore_stds(): h5files, _fl = getopenfilenames( self, _("Open"), basedir, _("HDF5 files (*.h5 *.hdf5)") ) if not h5files: return filenames, dsetnames = [], [] for fname_with_dset in h5files: if "," in fname_with_dset: filename, dsetname = fname_with_dset.split(",") dsetnames.append(dsetname) else: filename = fname_with_dset dsetnames.append(None) filenames.append(filename) if import_all is None and all(dsetname is None for dsetname in dsetnames): self.browse_h5_files(filenames, reset_all) return for filename, dsetname in zip(filenames, dsetnames): if import_all is None and dsetname is None: self.import_h5_file(filename, reset_all) else: with qth.qt_try_loadsave_file(self, filename, "load"): filename = self.__check_h5file(filename, "load") if dsetname is None: self.h5inputoutput.open_file(filename, import_all, reset_all) else: self.h5inputoutput.import_dataset_from_file(filename, dsetname) reset_all = False
[docs] def browse_h5_files(self, filenames: list[str], reset_all: bool) -> None: """Browse HDF5 files Args: filenames (list): HDF5 filenames reset_all (bool): Reset all application data before importing Returns: None """ for filename in filenames: self.__check_h5file(filename, "load") self.h5inputoutput.import_files(filenames, False, reset_all)
[docs] @remote_controlled def import_h5_file(self, filename: str, reset_all: bool | None = None) -> None: """Import HDF5 file into DataLab Args: filename (str): HDF5 filename (optionally with dataset name, separated by ":") reset_all (bool): Delete all DataLab signals/images before importing data Returns: None """ with qth.qt_try_loadsave_file(self, filename, "load"): filename = self.__check_h5file(filename, "load") self.h5inputoutput.import_files([filename], False, reset_all)
# This method is intentionally *not* remote controlled # (see TODO regarding RemoteClient.add_object method) # @remote_controlled
[docs] def add_object(self, obj: SignalObj | ImageObj) -> None: """Add object - signal or image Args: obj (SignalObj or ImageObj): object to add (signal or image) """ if self.confirm_memory_state(): if isinstance(obj, SignalObj): self.signalpanel.add_object(obj) elif isinstance(obj, ImageObj): self.imagepanel.add_object(obj) else: raise TypeError(f"Unsupported object type {type(obj)}")
[docs] @remote_controlled def load_from_files(self, filenames: list[str]) -> None: """Open objects from files in current panel (signals/images) Args: filenames: list of filenames """ panel = self.__get_current_basedatapanel() panel.load_from_files(filenames)
# ------Other methods related to AbstractCDLControl interface
[docs] def get_version(self) -> str: """Return DataLab public version. Returns: str: DataLab version """ return cdl.__version__
[docs] def close_application(self) -> None: # Implementing AbstractCDLControl interface """Close DataLab application""" self.close()
[docs] def raise_window(self) -> None: # Implementing AbstractCDLControl interface """Raise DataLab window""" bring_to_front(self)
[docs] def add_signal( self, title: str, xdata: np.ndarray, ydata: np.ndarray, xunit: str | None = None, yunit: str | None = None, xlabel: str | None = None, ylabel: str | None = None, ) -> bool: # pylint: disable=too-many-arguments """Add signal data to DataLab. Args: title (str): Signal title xdata (numpy.ndarray): X data ydata (numpy.ndarray): Y data xunit (str | None): X unit. Defaults to None. yunit (str | None): Y unit. Defaults to None. xlabel (str | None): X label. Defaults to None. ylabel (str | None): Y label. Defaults to None. Returns: bool: True if signal was added successfully, False otherwise Raises: ValueError: Invalid xdata dtype ValueError: Invalid ydata dtype """ obj = create_signal( title, xdata, ydata, units=(xunit, yunit), labels=(xlabel, ylabel), ) self.add_object(obj) return True
[docs] def add_image( self, title: str, data: np.ndarray, xunit: str | None = None, yunit: str | None = None, zunit: str | None = None, xlabel: str | None = None, ylabel: str | None = None, zlabel: str | None = None, ) -> bool: # pylint: disable=too-many-arguments """Add image data to DataLab. Args: title (str): Image title data (numpy.ndarray): Image data xunit (str | None): X unit. Defaults to None. yunit (str | None): Y unit. Defaults to None. zunit (str | None): Z unit. Defaults to None. xlabel (str | None): X label. Defaults to None. ylabel (str | None): Y label. Defaults to None. zlabel (str | None): Z label. Defaults to None. Returns: bool: True if image was added successfully, False otherwise Raises: ValueError: Invalid data dtype """ obj = create_image( title, data, units=(xunit, yunit, zunit), labels=(xlabel, ylabel, zlabel), ) self.add_object(obj) return True
# ------? def __about(self) -> None: # pragma: no cover """About dialog box""" self.check_stable_release() if self.remote_server.port is None: xrpcstate = '<font color="red">' + _("not started") + "</font>" else: xrpcstate = _("started (port %s)") % self.remote_server.port xrpcstate = f"<font color='green'>{xrpcstate}</font>" if Conf.main.process_isolation_enabled.get(): pistate = "<font color='green'>" + _("enabled") + "</font>" else: pistate = "<font color='red'>" + _("disabled") + "</font>" adv_conf = "<br>".join( [ "<i>" + _("Advanced configuration:") + "</i>", "• " + _("XML-RPC server:") + " " + xrpcstate, "• " + _("Process isolation:") + " " + pistate, ] ) created_by = _("Created by") dev_by = _("Developed and maintained by %s open-source project team") % APP_NAME cprght = "2023 DataLab Platform Developers" QW.QMessageBox.about( self, _("About") + " " + APP_NAME, f"""<b>{APP_NAME}</b> v{cdl.__version__}<br>{APP_DESC} <p>{created_by} Pierre Raybaut<br>{dev_by}<br>Copyright &copy; {cprght} <p>{adv_conf}""", ) def __update_color_mode(self, startup: bool = False) -> None: """Update color mode Args: startup: True if method is called during application startup (in that case, color theme is applied only if mode != "auto") """ mode = Conf.main.color_mode.get() if startup and mode == "auto": guidata_qth.win32_fix_title_bar_background(self) return # Prevent Qt from refreshing the window when changing the color mode: self.setUpdatesEnabled(False) plotpy_config.set_plotpy_color_mode(mode) if self.console is not None: self.console.update_color_mode() if self.macropanel is not None: self.macropanel.update_color_mode() if self.docks is not None: for dock in self.docks.values(): widget = dock.widget() if isinstance(widget, DockablePlotWidget): widget.update_color_mode() # Allow Qt to refresh the window: self.setUpdatesEnabled(True) def __edit_settings(self) -> None: """Edit settings""" changed_options = edit_settings(self) for option in changed_options: if option == "color_mode": self.__update_color_mode() if option == "plot_toolbar_position": for dock in self.docks.values(): widget = dock.widget() if isinstance(widget, DockablePlotWidget): widget.update_toolbar_position() if option.startswith("sig_autodownsampling"): self.signalpanel.SIG_REFRESH_PLOT.emit("existing", True) if option == "ima_defaults" and len(self.imagepanel) > 0: answer = QW.QMessageBox.question( self, _("Visualization settings"), _( "Default visualization settings have changed.<br><br>" "Do you want to update all active %s objects?" ) % _("image"), QW.QMessageBox.Yes | QW.QMessageBox.No, ) if answer == QW.QMessageBox.Yes: self.imagepanel.update_metadata_view_settings() def __show_logviewer(self) -> None: """Show error logs""" logviewer.exec_cdl_logviewer_dialog(self)
[docs] def play_demo(self) -> None: """Play demo""" # pylint: disable=import-outside-toplevel # pylint: disable=cyclic-import from cdl.tests.scenarios import demo demo.play_demo(self)
[docs] def show_tour(self) -> None: """Show tour""" # pylint: disable=import-outside-toplevel # pylint: disable=cyclic-import from cdl.core.gui import tour tour.start(self)
[docs] @staticmethod def test_segfault_error() -> None: """Generate errors (both fault and traceback)""" import ctypes # pylint: disable=import-outside-toplevel ctypes.string_at(0) raise RuntimeError("!!! Testing RuntimeError !!!")
[docs] def show(self) -> None: """Reimplement QMainWindow method""" super().show() if self.__old_size is not None: self.resize(self.__old_size)
# ------Close window
[docs] def close_properly(self) -> bool: """Close properly Returns: bool: True if closed properly, False otherwise """ if not env.execenv.unattended and self.__is_modified: answer = QW.QMessageBox.warning( self, _("Quit"), _( "Do you want to save all signals and images " "to an HDF5 file before quitting DataLab?" ), QW.QMessageBox.Yes | QW.QMessageBox.No | QW.QMessageBox.Cancel, ) if answer == QW.QMessageBox.Yes: self.save_to_h5_file() if self.__is_modified: return False elif answer == QW.QMessageBox.Cancel: return False self.hide() # Avoid showing individual widgets closing one after the other for panel in self.panels: if panel is not None: panel.close() if self.console is not None: try: self.console.close() except RuntimeError: # TODO: [P3] Investigate further why the following error occurs when # restarting the mainwindow (this is *not* a production case): # "RuntimeError: wrapped C/C++ object of type DockableConsole # has been deleted". # Another solution to avoid this error would be to really restart # the application (run each unit test in a separate process), but # it would represent too much effort for an error occuring in test # configurations only. pass self.reset_all() self.__save_pos_size_and_state() self.__unregister_plugins() # Saving current tab for next session Conf.main.current_tab.set(self.tabwidget.currentIndex()) execenv.log(self, "closed properly") return True
[docs] def closeEvent(self, event: QG.QCloseEvent) -> None: """Reimplement QMainWindow method""" if self.hide_on_close: self.__old_size = self.size() self.hide() else: if self.close_properly(): self.SIG_CLOSING.emit() event.accept() else: event.ignore()