datalab-platform 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

datalab/control/proxy.py

@@ -300,6 +300,39 @@ class LocalProxy(BaseProxy):
         """
         self._datalab.add_annotations_from_items(items, refresh_plot, panel)
 
+    def load_h5_workspace(
+        self, h5files: list[str] | str, reset_all: bool = False
+    ) -> None:
+        """Load HDF5 workspace files without showing file dialog.
+
+        This method loads one or more DataLab native HDF5 files directly, bypassing
+        the file dialog. It is safe to call from the internal console or any context
+        where Qt dialogs would cause threading issues.
+
+        Args:
+            h5files: Path(s) to HDF5 file(s). Can be a single path string or a list
+             of paths
+            reset_all: If True, reset workspace before loading. Defaults to False.
+
+        Raises:
+            ValueError: if file is not a DataLab native HDF5 file
+        """
+        if isinstance(h5files, str):
+            h5files = [h5files]
+        self._datalab.load_h5_workspace(h5files, reset_all)
+
+    def save_h5_workspace(self, filename: str) -> None:
+        """Save workspace to HDF5 file without showing file dialog.
+
+        This method saves the current workspace to a DataLab native HDF5 file
+        directly, bypassing the file dialog. It is safe to call from the internal
+        console or any context where Qt dialogs would cause threading issues.
+
+        Args:
+            filename: Path to the output HDF5 file
+        """
+        self._datalab.save_h5_workspace(filename)
+
 
 @contextmanager
 def proxy_context(what: str) -> Generator[LocalProxy | RemoteProxy, None, None]:

datalab/control/remote.py

@@ -84,6 +84,8 @@ class RemoteServer(QC.QThread):
     SIG_SAVE_TO_H5 = QC.Signal(str)
     SIG_OPEN_H5 = QC.Signal(list, bool, bool)
     SIG_IMPORT_H5 = QC.Signal(str, bool)
+    SIG_LOAD_H5_WORKSPACE = QC.Signal(list, bool)
+    SIG_SAVE_H5_WORKSPACE = QC.Signal(str)
     SIG_CALC = QC.Signal(str, object)
     SIG_RUN_MACRO = QC.Signal(str)
     SIG_STOP_MACRO = QC.Signal(str)
@@ -114,6 +116,8 @@ class RemoteServer(QC.QThread):
         self.SIG_SAVE_TO_H5.connect(win.save_to_h5_file)
         self.SIG_OPEN_H5.connect(win.open_h5_files)
         self.SIG_IMPORT_H5.connect(win.import_h5_file)
+        self.SIG_LOAD_H5_WORKSPACE.connect(win.load_h5_workspace)
+        self.SIG_SAVE_H5_WORKSPACE.connect(win.save_h5_workspace)
         self.SIG_CALC.connect(win.calc)
         self.SIG_RUN_MACRO.connect(win.run_macro)
         self.SIG_STOP_MACRO.connect(win.stop_macro)
@@ -268,6 +272,37 @@ class RemoteServer(QC.QThread):
         reset_all = False if reset_all is None else reset_all
         self.SIG_IMPORT_H5.emit(filename, reset_all)
 
+    @remote_call
+    def load_h5_workspace(self, h5files: list[str], reset_all: bool = False) -> None:
+        """Load native DataLab HDF5 workspace files without any GUI elements.
+
+        This method can be safely called from scripts as it does not create
+        any Qt widgets, dialogs, or progress bars.
+
+        Args:
+            h5files: List of native DataLab HDF5 filenames
+            reset_all: Reset all application data before importing. Defaults to False.
+
+        Raises:
+            ValueError: If a file is not a valid native DataLab HDF5 file
+        """
+        self.SIG_LOAD_H5_WORKSPACE.emit(h5files, reset_all)
+
+    @remote_call
+    def save_h5_workspace(self, filename: str) -> None:
+        """Save current workspace to a native DataLab HDF5 file without GUI elements.
+
+        This method can be safely called from scripts as it does not create
+        any Qt widgets, dialogs, or progress bars.
+
+        Args:
+            filename: HDF5 filename to save to
+
+        Raises:
+            IOError: If file cannot be saved
+        """
+        self.SIG_SAVE_H5_WORKSPACE.emit(filename)
+
     @remote_call
     def load_from_files(self, filenames: list[str]) -> None:
         """Open objects from files in current panel (signals/images).

datalab/data/icons/create/linear_chirp.svg

@@ -3,5 +3,5 @@
     xmlns="http://www.w3.org/2000/svg">
     <rect style="fill:#696969;fill-opacity:1;stroke-width:0.547874" width="0.53186357" height="12.584304" x="6.7340684" y="0.70784807" />
     <rect style="fill:#696969;fill-opacity:1;stroke-width:0.54642" width="0.53186357" height="12.5176" x="6.7340684" y="-13.258801" transform="rotate(90)" />
-    <path style="fill:none;stroke:#009966;stroke-width:0.35;stroke-linejoin:round" d="M 1,7 C 1.5,5.5 2,4.5 2.5,5.5 3,7 3.3,8.5 3.6,7.5 3.9,6 4.2,4 4.5,5 4.8,6.5 5,8.5 5.3,7.5 5.6,6 5.9,3.5 6.3,5 6.7,7 6.9,9.5 7.2,7.5 7.5,5 7.8,2 8.2,5 8.6,8 8.9,11 9.3,8 9.7,5 10.1,2 10.6,5.5 11.1,9 11.6,12 12.2,8.5 12.8,5 13,2" />
+    <path style="fill:none;stroke:#009966;stroke-width:0.35;stroke-linejoin:round" d="M 1,7 C 1.5,5.5 2,4.5 2.5,5.5 C 3,7 3.3,8.5 3.6,7.5 C 3.9,6 4.2,4 4.5,5 C 4.8,6.5 5,8.5 5.3,7.5 C 5.6,6 5.9,3.5 6.3,5 C 6.7,7 6.9,9.5 7.2,7.5 C 7.5,5 7.8,2 8.2,5 C 8.6,8 8.9,11 9.3,8 C 9.7,5 10.1,2 10.6,5.5 C 11.1,9 11.6,12 12.2,8.5 C 12.8,5 13,3.5 13,2" />
 </svg>

datalab/data/icons/create/logistic.svg

@@ -3,5 +3,5 @@
     xmlns="http://www.w3.org/2000/svg">
     <rect style="fill:#696969;fill-opacity:1;stroke-width:0.547874" width="0.53186357" height="12.584304" x="6.7340684" y="0.70784807" />
     <rect style="fill:#696969;fill-opacity:1;stroke-width:0.54642" width="0.53186357" height="12.5176" x="6.7340684" y="-13.258801" transform="rotate(90)" />
-    <path style="fill:none;stroke:#9900cc;stroke-width:0.35;stroke-linejoin:round" d="M 1.5,12 C 2,12 2.5,12 3,11.9 3.5,11.8 4,11.6 4.5,11.2 5,10.8 5.5,10.2 6,9.5 6.5,8.5 7,7.2 7.5,5.5 8,4 8.5,3 9,2.5 9.5,2.2 10,2.1 10.5,2.05 11,2.02 11.5,2.01 12,2 12.5,2" />
+    <path style="fill:none;stroke:#9900cc;stroke-width:0.35;stroke-linejoin:round" d="M 1.5,12 C 2,12 2.5,12 3,11.9 C 3.5,11.8 4,11.6 4.5,11.2 C 5,10.8 5.5,10.2 6,9.5 C 6.5,8.5 7,7.2 7.5,5.5 C 8,4 8.5,3 9,2.5 C 9.5,2.2 10,2.1 10.5,2.05 C 11,2.02 11.5,2.01 12,2 L 12.5,2" />
 </svg>

datalab/gui/actionhandler.py

@@ -50,6 +50,10 @@ from qtpy import QtWidgets as QW
 from datalab.adapters_metadata import GeometryAdapter, TableAdapter, have_results
 from datalab.config import Conf, _
 from datalab.gui import newobject
+from datalab.gui.processor.base import (
+    clear_analysis_parameters,
+    extract_analysis_parameters,
+)
 from datalab.widgets import fitdialog
 
 if TYPE_CHECKING:
@@ -361,6 +365,15 @@ class BaseActionHandler(metaclass=abc.ABCMeta):
             obj: Object containing the result
             adapter: Adapter for the result to delete
         """
+        # Check if this result matches the stored analysis parameters
+        # If so, clear them to prevent auto-recompute from attempting to
+        # recompute the deleted analysis when ROI changes
+        analysis_params = extract_analysis_parameters(obj)
+        if (
+            analysis_params is not None
+            and analysis_params.func_name == adapter.func_name
+        ):
+            clear_analysis_parameters(obj)
         adapter.remove_from(obj)
         # Update properties panel to reflect the removal
         if obj is self.panel.objview.get_current_object():
@@ -1269,7 +1282,9 @@ class SignalActionHandler(BaseActionHandler):
             with self.new_menu(_("Axis transformation")):
                 self.action_for("transpose")
                 self.action_for("reverse_x")
-                self.action_for("to_cartesian")
+                self.action_for("replace_x_by_other_y")
+                self.action_for("xy_mode")
+                self.action_for("to_cartesian", separator=True)
                 self.action_for("to_polar")
             with self.new_menu(_("Frequency filters"), icon_name="highpass.svg"):
                 self.action_for("lowpass")
@@ -1364,7 +1379,6 @@ class SignalActionHandler(BaseActionHandler):
                     separator=True,
                     tip=_("Compute all stability features"),
                 )
-            self.action_for("xy_mode", separator=True)
 
         # MARK: ANALYSIS
         with self.new_category(ActionCategory.ANALYSIS):

datalab/gui/h5io.py

@@ -54,6 +54,31 @@ class H5InputOutput:
             panel.serialize_to_hdf5(writer)
         writer.close()
 
+    def open_file_headless(self, filename: str, reset_all: bool) -> bool:
+        """Open native DataLab HDF5 file without any GUI elements.
+
+        This method can be safely called from any thread (e.g., the console thread)
+        as it does not create any Qt widgets or dialogs.
+
+        Args:
+            filename: HDF5 filename
+            reset_all: Reset all application data before importing
+
+        Returns:
+            True if file was successfully opened as a native DataLab file,
+            False if the file format is not compatible (KeyError was raised)
+        """
+        try:
+            reader = NativeH5Reader(filename)
+            if reset_all:
+                self.mainwindow.reset_all()
+            for panel in self.mainwindow.panels:
+                panel.deserialize_from_hdf5(reader, reset_all)
+            reader.close()
+            return True
+        except KeyError:
+            return False
+
     def open_file(self, filename: str, import_all: bool, reset_all: bool) -> None:
         """Open HDF5 file"""
         progress = None

datalab/gui/macroeditor.py

@@ -93,6 +93,7 @@ print("All done!")
         self.set_code(self.MACRO_SAMPLE)
         self.editor.modificationChanged.connect(self.modification_changed)
         self.process = None
+        self.__last_exit_code = None
 
     @property
     def title(self) -> str:
@@ -185,8 +186,20 @@ print("All done!")
         """
         global UNTITLED_NB  # pylint: disable=global-statement
         UNTITLED_NB += 1
-        untitled = _("Untitled")
-        return f"{untitled} {UNTITLED_NB:02d}"
+        return f"macro_{UNTITLED_NB:02d}"
+
+    @staticmethod
+    def set_untitled_number(number: int) -> None:
+        """Set the untitled number counter
+
+        This is useful when loading macros from HDF5 or files to ensure
+        that the next untitled macro has a unique name.
+
+        Args:
+            number: New untitled number
+        """
+        global UNTITLED_NB  # pylint: disable=global-statement
+        UNTITLED_NB = number
 
     def modification_changed(self, state: bool) -> None:
         """Method called when macro's editor modification state changed
@@ -207,8 +220,10 @@ print("All done!")
         Returns:
             Locale str
         """
-        locale_codec = QC.QTextCodec.codecForLocale()
-        return locale_codec.toUnicode(bytearr.data())
+        # Python 3 outputs UTF-8 by default, so we need to decode as UTF-8
+        # instead of using the system locale codec (which might be cp1252 on Windows)
+        utf8_codec = QC.QTextCodec.codecForName(b"UTF-8")
+        return utf8_codec.toUnicode(bytearr.data())
 
     def get_stdout(self) -> str:
         """Return standard output str
@@ -257,9 +272,16 @@ print("All done!")
     def run(self) -> None:
         """Run macro"""
         self.process = QC.QProcess()
-        code = self.get_code().replace('"', "'")
+        code = self.get_code()
         datalab_path = osp.abspath(osp.join(osp.dirname(datalab.__file__), os.pardir))
-        code = f"import sys; sys.path.append(r'{datalab_path}'){os.linesep}{code}"
+        # Reconfigure stdout/stderr to use UTF-8 encoding to avoid UnicodeEncodeError
+        # on Windows with locales that don't support all Unicode characters
+        # (e.g., cp1252)
+        code = (
+            f"import sys; sys.path.append(r'{datalab_path}'); "
+            f"sys.stdout.reconfigure(encoding='utf-8'); "
+            f"sys.stderr.reconfigure(encoding='utf-8'){os.linesep}{code}"
+        )
         env = QC.QProcessEnvironment()
         env.insert(execenv.XMLRPCPORT_ENV, str(execenv.xmlrpcport))
         sysenv = env.systemEnvironment()
@@ -305,6 +327,15 @@ print("All done!")
             exit_code: Exit code
             exit_status: Exit status
         """
+        self.__last_exit_code = exit_code
         self.print(_("# <== '%s' macro has finished") % self.title, eol_before=False)
         self.FINISHED.emit()
         self.process = None
+
+    def get_exit_code(self) -> int | None:
+        """Return last exit code of the macro process
+
+        Returns:
+            Last exit code or None if process has not finished yet
+        """
+        return self.__last_exit_code

datalab/gui/main.py

@@ -1360,6 +1360,10 @@ class DLMainWindow(QW.QMainWindow, AbstractDLControl, metaclass=DLMainWindowMeta
             title += f" [{datalab.__version__}]"
         self.setWindowTitle(title)
 
+    def is_modified(self) -> bool:
+        """Return True if mainwindow is modified"""
+        return self.__is_modified
+
     def __add_dockwidget(self, child, title: str) -> QW.QDockWidget:
         """Add QDockWidget and toggleViewAction"""
         dockwidget, location = child.create_dockwidget(title)
@@ -1559,9 +1563,7 @@ class DLMainWindow(QW.QMainWindow, AbstractDLControl, metaclass=DLMainWindowMeta
             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)
+            self.save_h5_workspace(filename)
 
     @remote_controlled
     def open_h5_files(
@@ -1617,6 +1619,8 @@ class DLMainWindow(QW.QMainWindow, AbstractDLControl, metaclass=DLMainWindowMeta
                     )
                     if answer == QW.QMessageBox.Yes:
                         reset_all = True
+                    elif answer == QW.QMessageBox.No:
+                        reset_all = False
                     elif answer == QW.QMessageBox.Ignore:
                         Conf.io.h5_clear_workspace_ask.set(False)
         if h5files is None:
@@ -1665,6 +1669,59 @@ class DLMainWindow(QW.QMainWindow, AbstractDLControl, metaclass=DLMainWindowMeta
             self.__check_h5file(filename, "load")
         self.h5inputoutput.import_files(filenames, False, reset_all)
 
+    @remote_controlled
+    def load_h5_workspace(self, h5files: list[str], reset_all: bool = False) -> None:
+        """Load native DataLab HDF5 workspace files without any GUI elements.
+
+        This method can be safely called from the internal console as it does not
+        create any Qt widgets, dialogs, or progress bars. It is designed for
+        programmatic use when loading DataLab workspace files.
+
+        .. warning::
+
+            This method only supports native DataLab HDF5 files. For importing
+            arbitrary HDF5 files (non-native), use the GUI menu or macros with
+            :class:`datalab.control.proxy.RemoteProxy`.
+
+        Args:
+            h5files: List of native DataLab HDF5 filenames
+            reset_all: Reset all application data before importing. Defaults to False.
+
+        Raises:
+            ValueError: If a file is not a valid native DataLab HDF5 file
+        """
+        for idx, filename in enumerate(h5files):
+            filename = self.__check_h5file(filename, "load")
+            success = self.h5inputoutput.open_file_headless(
+                filename, reset_all=(reset_all and idx == 0)
+            )
+            if not success:
+                raise ValueError(
+                    f"File '{filename}' is not a native DataLab HDF5 file. "
+                    f"Use the GUI menu or a macro with RemoteProxy to import "
+                    f"arbitrary HDF5 files."
+                )
+        # Refresh panel trees after loading
+        self.repopulate_panel_trees()
+
+    @remote_controlled
+    def save_h5_workspace(self, filename: str) -> None:
+        """Save current workspace to a native DataLab HDF5 file without GUI elements.
+
+        This method can be safely called from the internal console as it does not
+        create any Qt widgets, dialogs, or progress bars. It is designed for
+        programmatic use when saving DataLab workspace files.
+
+        Args:
+            filename: HDF5 filename to save to
+
+        Raises:
+            IOError: If file cannot be saved
+        """
+        filename = self.__check_h5file(filename, "save")
+        self.h5inputoutput.save_file(filename)
+        self.set_modified(False)
+
     @remote_controlled
     def import_h5_file(self, filename: str, reset_all: bool | None = None) -> None:
         """Import HDF5 file into DataLab
@@ -2025,7 +2082,7 @@ class DLMainWindow(QW.QMainWindow, AbstractDLControl, metaclass=DLMainWindowMeta
         Returns:
             True if closed properly, False otherwise
         """
-        if not env.execenv.unattended and self.__is_modified:
+        if not env.execenv.unattended and self.is_modified():
             answer = QW.QMessageBox.warning(
                 self,
                 _("Quit"),
@@ -2037,7 +2094,7 @@ class DLMainWindow(QW.QMainWindow, AbstractDLControl, metaclass=DLMainWindowMeta
             )
             if answer == QW.QMessageBox.Yes:
                 self.save_to_h5_file()
-                if self.__is_modified:
+                if self.is_modified():
                     return False
             elif answer == QW.QMessageBox.Cancel:
                 return False

datalab/gui/newobject.py

@@ -122,6 +122,13 @@ def create_signal_gui(
         param = NewSignalParam()
         edit = True  # Default to editing if no parameters provided
 
+    # CustomSignalParam requires edit mode to initialize the xyarray.
+    # Without this, if edit=False (the default in new_object), the setup_array
+    # call would be skipped, leaving xyarray as None, which would cause an
+    # AttributeError when trying to access param.xyarray.T later.
+    if isinstance(param, OrigCustomSignalParam):
+        edit = True
+
     if isinstance(param, OrigCustomSignalParam) and edit:
         p_init = NewSignalParam(_("Custom signal"))
         p_init.size = 10  # Set smaller default size for initial input

datalab/gui/objectview.py

@@ -222,11 +222,26 @@ class SimpleObjectTree(QW.QTreeWidget):
             self.set_current_item_id(uuid)
 
     def update_tree(self) -> None:
-        """Update tree"""
+        """Update tree
+
+        Note: If an item is not found in the tree, the tree is repopulated to ensure
+        consistency between the tree and the model. This can happen in rare cases when
+        objects are added to the model but the tree was not properly updated.
+        """
         for group in self.objmodel.get_groups():
-            self.__update_item(self.get_item_from_id(get_uuid(group)), group)
+            group_item = self.get_item_from_id(get_uuid(group))
+            if group_item is None:
+                # Group item not found, repopulate tree to fix inconsistency
+                self.populate_tree()
+                return
+            self.__update_item(group_item, group)
             for obj in group:
-                self.__update_item(self.get_item_from_id(get_uuid(obj)), obj)
+                obj_item = self.get_item_from_id(get_uuid(obj))
+                if obj_item is None:
+                    # Object item not found, repopulate tree to fix inconsistency
+                    self.populate_tree()
+                    return
+                self.__update_item(obj_item, obj)
 
     def __add_to_group_item(
         self, obj: SignalObj | ImageObj, group_item: QW.QTreeWidgetItem

datalab/gui/panel/base.py

@@ -79,6 +79,7 @@ from datalab.gui.newobject import (
 from datalab.gui.processor.base import (
     PROCESSING_PARAMETERS_OPTION,
     ProcessingParameters,
+    clear_analysis_parameters,
     extract_processing_parameters,
     insert_processing_parameters,
 )
@@ -216,6 +217,13 @@ class ObjectProp(QW.QWidget):
         self.analysis_parameters.setReadOnly(True)
         self.analysis_parameters.setFont(font)
 
+        # Track newly created objects to show Creation tab only once
+        self.newly_created_obj_uuid: str | None = None
+        # Track when analysis results were just computed
+        self.fresh_analysis_obj_uuid: str | None = None
+        # Track when object was just processed (1-to-1)
+        self.fresh_processing_obj_uuid: str | None = None
+
         self.tabwidget.addTab(
             self.processing_history, get_icon("history.svg"), _("History")
         )
@@ -370,11 +378,16 @@ class ObjectProp(QW.QWidget):
         self.properties.get()
         self.properties.apply_button.setEnabled(False)
 
-    def update_properties_from(self, obj: SignalObj | ImageObj | None = None) -> None:
+    def update_properties_from(
+        self,
+        obj: SignalObj | ImageObj | None = None,
+        force_tab: Literal["creation", "processing", "analysis", None] | None = None,
+    ) -> None:
         """Update properties panel (properties, creation, processing) from object.
 
         Args:
             obj: Signal or Image object
+            force_tab: Force a specific tab to be current
         """
         self.properties.setDisabled(obj is None)
         if obj is None:
@@ -411,30 +424,56 @@ class ObjectProp(QW.QWidget):
         self.processing_scroll = None
 
         # Setup Creation and Processing tabs (if applicable)
-        has_creation_tab = has_processing_tab = False
+        has_creation_tab = False
+        has_processing_tab = False
         if obj is not None:
             has_creation_tab = self.setup_creation_tab(obj)
-            has_processing_tab = self.setup_processing_tab(obj)
+            has_processing_tab = self.setup_processing_tab(obj)  # Processing tab setup
 
         # Trigger visibility update for History and Analysis parameters tabs
         # (will be called via textChanged signals, but we call explicitly
         # here to ensure initial state is correct)
         self._update_tab_visibility()
 
-        # Handle priority regarding the tab to set as current:
-        # 1. Analysis parameters if content exists
-        # 2. Creation tab if it exists
-        # 3. Processing tab if it exists
-        # 4. Properties tab
-        if has_analysis_parameters:
-            self.tabwidget.setCurrentWidget(self.analysis_parameters)
-        elif has_creation_tab:
+        # Determine which tab to show based on force_tab parameter:
+        # - If force_tab="creation" and Creation tab exists, show it
+        # - If force_tab="processing" and Processing tab exists, show it
+        # - If force_tab="analysis" and Analysis tab has content, show it
+        # - Otherwise, always show Properties tab (default behavior)
+        if force_tab == "creation" and has_creation_tab:
             self.tabwidget.setCurrentWidget(self.creation_scroll)
-        elif has_processing_tab:
+        elif force_tab == "processing" and has_processing_tab:
             self.tabwidget.setCurrentWidget(self.processing_scroll)
+        elif force_tab == "analysis" and has_analysis_parameters:
+            self.tabwidget.setCurrentWidget(self.analysis_parameters)
         else:
+            # Default: always show Properties tab when switching objects
             self.tabwidget.setCurrentWidget(self.properties)
 
+    def mark_as_newly_created(self, obj: SignalObj | ImageObj) -> None:
+        """Mark object to show Creation tab on next selection.
+
+        Args:
+            obj: Object to mark
+        """
+        self.newly_created_obj_uuid = get_uuid(obj)
+
+    def mark_as_freshly_processed(self, obj: SignalObj | ImageObj) -> None:
+        """Mark object to show Processing tab on next selection.
+
+        Args:
+            obj: Object to mark
+        """
+        self.fresh_processing_obj_uuid = get_uuid(obj)
+
+    def mark_as_fresh_analysis(self, obj: SignalObj | ImageObj) -> None:
+        """Mark object to show Analysis tab on next selection.
+
+        Args:
+            obj: Object to mark
+        """
+        self.fresh_analysis_obj_uuid = get_uuid(obj)
+
     def get_changed_properties(self) -> dict[str, Any]:
         """Get dictionary of properties that have changed from original values.
 
@@ -1490,6 +1529,16 @@ class BaseDataPanel(AbstractPanel, Generic[TypeObj, TypeROI, TypeROIEditor]):
         obj.check_data()
         self.objmodel.add_object(obj, group_id)
 
+        # Mark this object as newly created to show Creation tab on first selection
+        # BUT: Don't overwrite if this object is already marked as freshly processed
+        # or has fresh analysis results (those take precedence)
+        obj_uuid = get_uuid(obj)
+        if obj_uuid not in (
+            self.objprop.fresh_processing_obj_uuid,
+            self.objprop.fresh_analysis_obj_uuid,
+        ):
+            self.objprop.mark_as_newly_created(obj)
+
         # Block signals to avoid updating the plot (unnecessary refresh)
         self.objview.blockSignals(True)
         self.objview.add_object_item(obj, group_id, set_current=set_current)
@@ -2419,7 +2468,26 @@ class BaseDataPanel(AbstractPanel, Generic[TypeObj, TypeROI, TypeROIEditor]):
         """
         selected_objects = self.objview.get_sel_objects(include_groups=True)
         selected_groups = self.objview.get_sel_groups()
-        self.objprop.update_properties_from(self.objview.get_current_object())
+
+        # Determine which tab to show based on object state
+        current_obj = self.objview.get_current_object()
+        force_tab = None
+        if current_obj is not None:
+            obj_uuid = get_uuid(current_obj)
+            # Show Creation tab for newly created objects (only once)
+            if obj_uuid == self.objprop.newly_created_obj_uuid:
+                force_tab = "creation"
+                self.objprop.newly_created_obj_uuid = None
+            # Show Processing tab for freshly processed objects (only once)
+            elif obj_uuid == self.objprop.fresh_processing_obj_uuid:
+                force_tab = "processing"
+                self.objprop.fresh_processing_obj_uuid = None
+            # Show Analysis tab for objects with fresh analysis results
+            elif obj_uuid == self.objprop.fresh_analysis_obj_uuid:
+                force_tab = "analysis"
+                self.objprop.fresh_analysis_obj_uuid = None
+
+        self.objprop.update_properties_from(current_obj, force_tab=force_tab)
         self.acthandler.selected_objects_changed(selected_groups, selected_objects)
         self.refresh_plot("selected", update_items, False)
 
@@ -2854,9 +2922,11 @@ class BaseDataPanel(AbstractPanel, Generic[TypeObj, TypeROI, TypeROIEditor]):
             dialog was accepted or not.
         """
         obj = self.objview.get_sel_objects(include_groups=True)[-1]
-        item = create_adapter_from_object(obj).make_item(
-            update_from=self.plothandler[get_uuid(obj)]
-        )
+        # Use get() instead of [] to avoid KeyError if the plot item doesn't exist
+        # (can happen when "auto refresh" is disabled or in "show first only" mode
+        # where not all objects have plot items created yet)
+        existing_item = self.plothandler.get(get_uuid(obj))
+        item = create_adapter_from_object(obj).make_item(update_from=existing_item)
         roi_editor_class = self.get_roieditor_class()  # pylint: disable=not-callable
         roi_editor = roi_editor_class(
             parent=self.parentWidget(),
@@ -3207,6 +3277,9 @@ class BaseDataPanel(AbstractPanel, Generic[TypeObj, TypeROI, TypeROIEditor]):
                     # Remove all table and geometry results using adapter methods
                     TableAdapter.remove_all_from(obj)
                     GeometryAdapter.remove_all_from(obj)
+                    # Clear analysis parameters to prevent auto-recompute from
+                    # attempting to recompute deleted analyses when ROI changes
+                    clear_analysis_parameters(obj)
                     if obj is self.objview.get_current_object():
                         self.objprop.update_properties_from(obj)
                 # Update action states to reflect the removal

datalab/gui/panel/macro.py

@@ -204,6 +204,10 @@ class MacroPanel(AbstractPanel, DockableWidgetMixin):
             self.addWidget(widget)
         self.setStretchFactor(0, 2)
         self.setStretchFactor(1, 1)
+        # Set initial sizes: give more space to editor (70%) than console (30%)
+        # This ensures proper layout on first open
+        total_height = 600  # Default reasonable height
+        self.setSizes([int(total_height * 0.7), int(total_height * 0.3)])
 
         self.run_action = None
         self.stop_action = None
@@ -252,6 +256,8 @@ class MacroPanel(AbstractPanel, DockableWidgetMixin):
                 #  in a group but directly in the root of the HDF5 file
                 obj = self.deserialize_object_from_hdf5(reader, name, reset_all)
                 self.add_object(obj)
+        # Update untitled number counter to prevent duplicate names
+        self.update_untitled_counter()
 
     def __len__(self) -> int:
         """Return number of objects"""
@@ -298,6 +304,8 @@ class MacroPanel(AbstractPanel, DockableWidgetMixin):
         self.tabwidget.clear()
         self.__macros.clear()
         super().remove_all_objects()
+        # Reset untitled counter when clearing all macros
+        Macro.set_untitled_number(0)
 
     # ---- Macro panel API -------------------------------------------------------------
     def setup_actions(self) -> None:
@@ -572,9 +580,27 @@ class MacroPanel(AbstractPanel, DockableWidgetMixin):
                 Conf.main.base_dir.set(filename)
                 macro = self.add_macro()
                 macro.from_file(filename)
+            # Update untitled number counter to prevent duplicate names
+            self.update_untitled_counter()
             return self.get_number_from_macro(macro)
         return -1
 
+    def update_untitled_counter(self) -> None:
+        """Update the untitled counter based on existing macro titles
+
+        This scans all macro titles to find the highest "macro_XX" number
+        and updates the global counter to prevent duplicate names.
+        """
+        max_untitled = 0
+        for macro in self.__macros:
+            # Match titles like "macro_01", "macro_02", etc.
+            match = re.match(r"macro_(\d+)", macro.title)
+            if match:
+                number = int(match.group(1))
+                max_untitled = max(max_untitled, number)
+        # Set the counter to the highest found number
+        Macro.set_untitled_number(max_untitled)
+
     def remove_macro(self, number_or_title: int | str | None = None) -> None:
         """Remove macro