setiastrosuitepro 1.6.0__py3-none-any.whl → 1.6.4.post1__py3-none-any.whl

setiastro/saspro/blink_comparator_pro.py

@@ -12,7 +12,7 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
 from typing import Optional, List
 from collections import defaultdict
 # Qt
-from PyQt6.QtCore import Qt, QTimer, QEvent, QPointF, QRectF, pyqtSignal, QSettings, QPoint
+from PyQt6.QtCore import Qt, QTimer, QEvent, QPointF, QRectF, pyqtSignal, QSettings, QPoint, QCoreApplication
 from PyQt6.QtGui import (QAction, QIcon, QImage, QPixmap, QBrush, QColor, QPalette,
                          QKeySequence, QWheelEvent, QShortcut, QDoubleValidator, QIntValidator)
 from PyQt6.QtWidgets import (
@@ -65,7 +65,7 @@ class MetricsPanel(QWidget):
         self._open_previews = []
 
         self.plots, self.scats, self.lines = [], [], []
-        titles = ["FWHM (px)", "Eccentricity", "Background", "Star Count"]
+        titles = [self.tr("FWHM (px)"), self.tr("Eccentricity"), self.tr("Background"), self.tr("Star Count")]
         for idx, title in enumerate(titles):
             pw = pg.PlotWidget()
             pw.setTitle(title)
@@ -167,14 +167,14 @@ class MetricsPanel(QWidget):
         show = settings.value("metrics/showWarning", True, type=bool)
         if show:
             msg = QMessageBox(self)
-            msg.setWindowTitle("Heads-up")
-            msg.setText(
+            msg.setWindowTitle(self.tr("Heads-up"))
+            msg.setText(self.tr(
                 "This is going to use ALL your CPU cores and the UI may lock up until it finishes.\n\n"
                 "Continue?"
-            )
+            ))
             msg.setStandardButtons(QMessageBox.StandardButton.Yes |
                                 QMessageBox.StandardButton.No)
-            cb = QCheckBox("Don't show again", msg)
+            cb = QCheckBox(self.tr("Don't show again"), msg)
             msg.setCheckBox(cb)
             if msg.exec() != QMessageBox.StandardButton.Yes:
                 return
@@ -189,7 +189,7 @@ class MetricsPanel(QWidget):
         flags = [e.get('flagged', False) for e in loaded_images]
 
         # progress dialog
-        prog = QProgressDialog("Computing frame metrics…", "Cancel", 0, n, self)
+        prog = QProgressDialog(self.tr("Computing frame metrics…"), self.tr("Cancel"), 0, n, self)
         prog.setWindowModality(Qt.WindowModality.WindowModal)
         prog.setMinimumDuration(0)
         prog.setValue(0)
@@ -343,18 +343,19 @@ class MetricsWindow(QWidget):
     def __init__(self, parent=None):
         super().__init__(parent, Qt.WindowType.Window)
         self._thresholds_per_group: dict[str, List[float|None]] = {}
-        self.setWindowTitle("Frame Metrics")
+        self.setWindowTitle(self.tr("Frame Metrics"))
         self.resize(800, 600)
 
         vbox = QVBoxLayout(self)
 
         # ← **new** instructions label
-        instr = QLabel(
+        instr = QLabel(self.tr(
             "Instructions:\n"
             " • Use the filter dropdown to restrict by FILTER.\n"
             " • Click a dot to flag/unflag a frame.\n"
             " • Shift-click a dot to preview the image.\n"
-            " • Drag the red lines to set thresholds.",
+            " • Drag the red lines to set thresholds."
+        ),
             self
         )
         instr.setWordWrap(True)
@@ -363,7 +364,7 @@ class MetricsWindow(QWidget):
 
         # → filter selector
         self.group_combo = QComboBox(self)
-        self.group_combo.addItem("All")
+        self.group_combo.addItem(self.tr("All"))
         self.group_combo.currentTextChanged.connect(self._on_group_change)
         vbox.addWidget(self.group_combo)
 
@@ -407,7 +408,7 @@ class MetricsWindow(QWidget):
                 continue
 
         pct = (flagged_cnt / total * 100.0) if total else 0.0
-        self.status_label.setText(f"Flagged Items {flagged_cnt}/{total}  ({pct:.1f}%)")
+        self.status_label.setText(self.tr("Flagged Items {0}/{1}  ({2:.1f}%)").format(flagged_cnt, total, pct))
 
 
     def set_images(self, loaded_images, order=None):
@@ -417,7 +418,7 @@ class MetricsWindow(QWidget):
         # ─── rebuild the combo-list of FILTER groups ─────────────
         self.group_combo.blockSignals(True)
         self.group_combo.clear()
-        self.group_combo.addItem("All")
+        self.group_combo.addItem(self.tr("All"))
         seen = set()
         for entry in loaded_images:
             filt = entry.get('header', {}).get('FILTER', 'Unknown')
@@ -459,7 +460,7 @@ class MetricsWindow(QWidget):
         cur = self.group_combo.currentText()
         self.group_combo.blockSignals(True)
         self.group_combo.clear()
-        self.group_combo.addItem("All")
+        self.group_combo.addItem(self.tr("All"))
         seen = set()
         for entry in self._all_images:
             filt = (entry.get('header', {}) or {}).get('FILTER', 'Unknown')
@@ -478,32 +479,82 @@ class MetricsWindow(QWidget):
         """
         Called when some frames were deleted/moved out of the list.
         Does NOT recompute metrics. Just trims cached arrays and re-plots.
+
+        Robust against:
+        - removed indices referring to the old list (out of range)
+        - metrics_panel arrays being a different length than _all_images
+        - stale _order_all / _current_indices containing out-of-bounds indices
         """
         if not removed:
             return
-        removed = sorted(set(int(i) for i in removed))
 
-        # 1) shrink cached arrays in the panel
-        self.metrics_panel.remove_frames(removed)
+        # Unique + int
+        removed = sorted({int(i) for i in removed})
+
+        # ---- 1) Trim metrics panel caches SAFELY ----
+        # Prefer panel's current frame count, because it represents the arrays we must slice.
+        n_panel = getattr(self.metrics_panel, "n_frames", None)
+        if callable(n_panel):
+            n_panel = n_panel()
+        if not isinstance(n_panel, int) or n_panel <= 0:
+            # fallback: infer from metrics_data if present
+            md = getattr(self.metrics_panel, "metrics_data", None)
+            if md is not None and len(md) and md[0] is not None:
+                try:
+                    n_panel = int(len(md[0]))
+                except Exception:
+                    n_panel = 0
+            else:
+                n_panel = 0
+
+        if n_panel > 0:
+            removed_panel = [i for i in removed if 0 <= i < n_panel]
+            if removed_panel:
+                self.metrics_panel.remove_frames(removed_panel)
+        # else: panel has nothing (or isn't initialized) — just continue with ordering cleanup
 
-        # 2) update our “master” list and ordering (object identity unchanged)
-        #    (BlinkTab will already have mutated the underlying list for us)
+        # ---- 2) Update ordering arrays with the SAME removed set (but clamp later) ----
         self._order_all = self._reindex_list_after_remove(self._order_all, removed)
-        self._current_indices = self._reindex_list_after_remove(self._current_indices, removed)
+        if self._current_indices is not None:
+            self._current_indices = self._reindex_list_after_remove(self._current_indices, removed)
 
-        # 3) rebuild group list (filters may have disappeared)
+        # ---- 3) Rebuild groups (filters may have disappeared) ----
         self._rebuild_groups_from_images()
 
-        # 4) replot current group with updated order
+        # ---- 4) Plot with VALID indices only ----
+        n_imgs = len(self._all_images) if self._all_images is not None else 0
+
+        def _sanitize_indices(ixs):
+            if not ixs:
+                return []
+            out = []
+            seen = set()
+            for i in ixs:
+                try:
+                    ii = int(i)
+                except Exception:
+                    continue
+                if 0 <= ii < n_imgs and ii not in seen:
+                    seen.add(ii)
+                    out.append(ii)
+            return out
+
         indices = self._current_indices if self._current_indices is not None else self._order_all
+        indices = _sanitize_indices(indices)
+
+        # If the current group became empty, fall back to "all"
+        if not indices and n_imgs:
+            indices = list(range(n_imgs))
+            self._current_indices = indices  # optional: keeps UI consistent
+
         self.metrics_panel.plot(self._all_images, indices=indices)
 
-        # 5) recolor & status
+        # ---- 5) Recolor & status ----
         self.metrics_panel.refresh_colors_and_status()
         self._update_status()
 
     def _on_group_change(self, name: str):
-        if name == "All":
+        if name == self.tr("All"):
             self._current_indices = self._order_all
         else:
             # preserve Tree order inside the chosen FILTER
@@ -538,7 +589,7 @@ class MetricsWindow(QWidget):
         else:
             if order is not None:
                 self._order_all = list(order)
-            # re-plot the current group with the new ordering
+    # re-plot the current group with the new ordering
             self._on_group_change(self.group_combo.currentText())
 
 class BlinkComparatorPro(QDialog):
@@ -547,7 +598,7 @@ class BlinkComparatorPro(QDialog):
     def __init__(self, doc_manager=None, parent=None):
         super().__init__(parent)
         self.doc_manager = doc_manager
-        self.setWindowTitle("Blink Comparator")
+        self.setWindowTitle(self.tr("Blink Comparator"))
         self.resize(1200, 700)
 
         self.tab = BlinkTab(doc_manager=self.doc_manager, parent=self)
@@ -603,7 +654,7 @@ class BlinkTab(QWidget):
         # --------------------
         # Instruction Label
         # --------------------
-        instruction_text = "Press 'F' to flag/unflag an image.\nRight-click on an image for more options."
+        instruction_text = self.tr("Press 'F' to flag/unflag an image.\nRight-click on an image for more options.")
         self.instruction_label = QLabel(instruction_text, self)
         self.instruction_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
         self.instruction_label.setWordWrap(True)
@@ -622,33 +673,33 @@ class BlinkTab(QWidget):
         button_layout = QHBoxLayout()
 
         # "Select Images" Button
-        self.fileButton = QPushButton('Select Images', self)
+        self.fileButton = QPushButton(self.tr('Select Images'), self)
         self.fileButton.clicked.connect(self.openFileDialog)
         button_layout.addWidget(self.fileButton)
 
         # "Select Directory" Button
-        self.dirButton = QPushButton('Select Directory', self)
+        self.dirButton = QPushButton(self.tr('Select Directory'), self)
         self.dirButton.clicked.connect(self.openDirectoryDialog)
         button_layout.addWidget(self.dirButton)
 
-        self.addButton = QPushButton("Add Additional", self)
+        self.addButton = QPushButton(self.tr("Add Additional"), self)
         self.addButton.clicked.connect(self.addAdditionalImages)
         button_layout.addWidget(self.addButton)
 
         left_layout.addLayout(button_layout)
 
-        self.metrics_button = QPushButton("Show Metrics", self)
+        self.metrics_button = QPushButton(self.tr("Show Metrics"), self)
         self.metrics_button.clicked.connect(self.show_metrics)
         left_layout.addWidget(self.metrics_button)
 
         push_row = QHBoxLayout()
-        self.send_lights_btn = QPushButton("→ Stacking: Lights", self)
-        self.send_lights_btn.setToolTip("Send selected (or all) blink files to the Stacking Suite → Light tab")
+        self.send_lights_btn = QPushButton(self.tr("→ Stacking: Lights"), self)
+        self.send_lights_btn.setToolTip(self.tr("Send selected (or all) blink files to the Stacking Suite → Light tab"))
         self.send_lights_btn.clicked.connect(self._send_to_stacking_lights)
         push_row.addWidget(self.send_lights_btn)
 
-        self.send_integ_btn = QPushButton("→ Stacking: Integration", self)
-        self.send_integ_btn.setToolTip("Send selected (or all) blink files to the Stacking Suite → Image Integration tab")
+        self.send_integ_btn = QPushButton(self.tr("→ Stacking: Integration"), self)
+        self.send_integ_btn.setToolTip(self.tr("Send selected (or all) blink files to the Stacking Suite → Image Integration tab"))
         self.send_integ_btn.clicked.connect(self._send_to_stacking_integration)
         push_row.addWidget(self.send_integ_btn)
 
@@ -687,7 +738,7 @@ class BlinkTab(QWidget):
         # ----- Playback speed controls (0.1–10.0 fps) -----
         speed_layout = QHBoxLayout()
 
-        speed_label = QLabel("Speed:", self)
+        speed_label = QLabel(self.tr("Speed:"), self)
         speed_layout.addWidget(speed_label)
 
         # Slider maps 1..100 -> 0.1..10.0 fps
@@ -695,7 +746,7 @@ class BlinkTab(QWidget):
         self.speed_slider.setRange(1, 100)
         self.speed_slider.setValue(int(round(self.play_fps * 10)))  # play_fps is float
         self.speed_slider.setTickPosition(QSlider.TickPosition.NoTicks)
-        self.speed_slider.setToolTip("Playback speed (0.1–10.0 fps)")
+        self.speed_slider.setToolTip(self.tr("Playback speed (0.1–10.0 fps)"))
         speed_layout.addWidget(self.speed_slider, 1)
 
         # Custom float spin (your class)
@@ -717,7 +768,7 @@ class BlinkTab(QWidget):
 
         left_layout.addLayout(speed_layout)
 
-        self.export_button = QPushButton("Export Video…", self)
+        self.export_button = QPushButton(self.tr("Export Video…"), self)
         self.export_button.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_DialogSaveButton))
         self.export_button.clicked.connect(self.export_blink_video)
         left_layout.addWidget(self.export_button)
@@ -725,7 +776,7 @@ class BlinkTab(QWidget):
         # Tree view for file names
         self.fileTree = QTreeWidget(self)
         self.fileTree.setColumnCount(1)
-        self.fileTree.setHeaderLabels(["Image Files"])
+        self.fileTree.setHeaderLabels([self.tr("Image Files")])
         self.fileTree.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)  # Allow multiple selections
         #self.fileTree.itemClicked.connect(self.on_item_clicked)
         self.fileTree.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
@@ -740,12 +791,12 @@ class BlinkTab(QWidget):
         left_layout.addWidget(self.fileTree)
 
         # "Clear Flags" Button
-        self.clearFlagsButton = QPushButton('Clear Flags', self)
+        self.clearFlagsButton = QPushButton(self.tr('Clear Flags'), self)
         self.clearFlagsButton.clicked.connect(self.clearFlags)
         left_layout.addWidget(self.clearFlagsButton)
 
         # "Clear Images" Button
-        self.clearButton = QPushButton('Clear Images', self)
+        self.clearButton = QPushButton(self.tr('Clear Images'), self)
         self.clearButton.clicked.connect(self.clearImages)
         left_layout.addWidget(self.clearButton)
 
@@ -755,7 +806,7 @@ class BlinkTab(QWidget):
         left_layout.addWidget(self.progress_bar)
 
         # Add loading message label
-        self.loading_label = QLabel("Loading images...", self)
+        self.loading_label = QLabel(self.tr("Loading images..."), self)
         left_layout.addWidget(self.loading_label)
         self.imagesChanged.emit(len(self.loaded_images)) 
 
@@ -772,9 +823,9 @@ class BlinkTab(QWidget):
         # Zoom / preview toolbar (standardized)
         zoom_controls_layout = QHBoxLayout()
 
-        self.zoom_in_btn  = themed_toolbtn("zoom-in", "Zoom In")
-        self.zoom_out_btn = themed_toolbtn("zoom-out", "Zoom Out")
-        self.fit_btn      = themed_toolbtn("zoom-fit-best", "Fit to Preview")
+        self.zoom_in_btn  = themed_toolbtn("zoom-in", self.tr("Zoom In"))
+        self.zoom_out_btn = themed_toolbtn("zoom-out", self.tr("Zoom Out"))
+        self.fit_btn      = themed_toolbtn("zoom-fit-best", self.tr("Fit to Preview"))
 
         self.zoom_in_btn.clicked.connect(self.zoom_in)
         self.zoom_out_btn.clicked.connect(self.zoom_out)
@@ -787,7 +838,7 @@ class BlinkTab(QWidget):
         zoom_controls_layout.addStretch(1)
 
         # Keep Aggressive Stretch as a text toggle (it’s not really a zoom action)
-        self.aggressive_button = QPushButton("Aggressive Stretch", self)
+        self.aggressive_button = QPushButton(self.tr("Aggressive Stretch"), self)
         self.aggressive_button.setCheckable(True)
         self.aggressive_button.clicked.connect(self.toggle_aggressive)
         zoom_controls_layout.addWidget(self.aggressive_button)
@@ -928,14 +979,14 @@ class BlinkTab(QWidget):
     def _send_to_stacking_lights(self):
         paths = self._collect_paths_for_stacking()
         if not paths:
-            QMessageBox.information(self, "No images", "There are no images to send.")
+            QMessageBox.information(self, self.tr("No images"), self.tr("There are no images to send."))
             return
         self.sendToStacking.emit(paths, "lights")
 
     def _send_to_stacking_integration(self):
         paths = self._collect_paths_for_stacking()
         if not paths:
-            QMessageBox.information(self, "No images", "There are no images to send.")
+            QMessageBox.information(self, self.tr("No images"), self.tr("There are no images to send."))
             return
         self.sendToStacking.emit(paths, "integration")
 
@@ -945,7 +996,7 @@ class BlinkTab(QWidget):
         # Ensure we have frames
         leaves = self.get_all_leaf_items()
         if not leaves:
-            QMessageBox.information(self, "No Images", "Load images before exporting.")
+            QMessageBox.information(self, self.tr("No Images"), self.tr("Load images before exporting."))
             return
 
         # Ask options first (size, fps, selection scope)
@@ -960,7 +1011,7 @@ class BlinkTab(QWidget):
         if only_selected:
             sel_leaves = [it for it in self.fileTree.selectedItems() if it.childCount() == 0]
             if not sel_leaves:
-                QMessageBox.information(self, "No Selection", "No individual frames selected.")
+                QMessageBox.information(self, self.tr("No Selection"), self.tr("No individual frames selected."))
                 return
             names = {it.text(0).lstrip("⚠️ ").strip() for it in sel_leaves}
             order = [i for i in self._tree_order_indices()
@@ -969,13 +1020,13 @@ class BlinkTab(QWidget):
             order = self._tree_order_indices()
 
         if not order:
-            QMessageBox.information(self, "No Frames", "Nothing to export.")
+            QMessageBox.information(self, self.tr("No Frames"), self.tr("Nothing to export."))
             return
 
         if len(order) < 2:
             ret = QMessageBox.question(
-                self, "Only one frame",
-                "You're about to export a video with a single frame. Continue?",
+                self, self.tr("Only one frame"),
+                self.tr("You're about to export a video with a single frame. Continue?"),
                 QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
                 QMessageBox.StandardButton.No,
             )
@@ -984,22 +1035,22 @@ class BlinkTab(QWidget):
 
         # Ask where to save
         out_path, _ = QFileDialog.getSaveFileName(
-            self, "Export Blink Video", "blink.mp4", "Video (*.mp4 *.avi)"
+            self, self.tr("Export Blink Video"), "blink.mp4", self.tr("Video (*.mp4 *.avi)")
         )
         if not out_path:
             return
         # Let _open_video_writer_portable decide the real extension; we pass requested
         writer, out_path, backend = self._open_video_writer_portable(out_path, (target_w, target_h), fps)
         if writer is None:
-            QMessageBox.critical(self, "Export",
-                "No compatible video codec found.\n\n"
-                "Tip: install FFmpeg or `pip install imageio[ffmpeg]` for a portable fallback."
+            QMessageBox.critical(self, self.tr("Export"),
+                self.tr("No compatible video codec found.\n\n"
+                "Tip: install FFmpeg or `pip install imageio[ffmpeg]` for a portable fallback.")
             )
             return
 
         # Progress UI
-        prog = QProgressDialog("Rendering video…", "Cancel", 0, len(order), self)
-        prog.setWindowTitle("Export Blink Video")
+        prog = QProgressDialog(self.tr("Rendering video…"), self.tr("Cancel"), 0, len(order), self)
+        prog.setWindowTitle(self.tr("Export Blink Video"))
         prog.setAutoClose(True)
         prog.setMinimumDuration(300)
 
@@ -1047,25 +1098,25 @@ class BlinkTab(QWidget):
                 os.remove(out_path)
             except Exception:
                 pass
-            QMessageBox.information(self, "Export", "Export canceled.")
+            QMessageBox.information(self, self.tr("Export"), self.tr("Export canceled."))
             return
 
         if frames_written == 0:
-            QMessageBox.critical(self, "Export", "No frames were written (codec/back-end issue?).")
+            QMessageBox.critical(self, self.tr("Export"), self.tr("No frames were written (codec/back-end issue?)."))
             return
 
-        QMessageBox.information(self, "Export", f"Saved: {out_path}\nFrames: {frames_written} @ {fps} fps")
+        QMessageBox.information(self, self.tr("Export"), self.tr("Saved: {0}\nFrames: {1} @ {2} fps").format(out_path, frames_written, fps))
 
 
 
     def _ask_video_options(self, default_fps: float):
         """Options dialog for size, fps, and whether to limit to current selection."""
         dlg = QDialog(self)
-        dlg.setWindowTitle("Video Options")
+        dlg.setWindowTitle(self.tr("Video Options"))
         layout = QGridLayout(dlg)
 
         # Size
-        layout.addWidget(QLabel("Size:"), 0, 0)
+        layout.addWidget(QLabel(self.tr("Size:")), 0, 0)
         size_combo = QComboBox(dlg)
         size_combo.addItem("HD 1280×720", (1280, 720))
         size_combo.addItem("Full HD 1920×1080", (1920, 1080))
@@ -1074,7 +1125,7 @@ class BlinkTab(QWidget):
         layout.addWidget(size_combo, 0, 1)
 
         # FPS
-        layout.addWidget(QLabel("FPS:"), 1, 0)
+        layout.addWidget(QLabel(self.tr("FPS:")), 1, 0)
         fps_edit = QDoubleSpinBox(dlg)
         fps_edit.setRange(0.1, 60.0)
         fps_edit.setDecimals(2)
@@ -1083,13 +1134,13 @@ class BlinkTab(QWidget):
         layout.addWidget(fps_edit, 1, 1)
 
         # Only selected?
-        only_selected = QCheckBox("Export only selected frames", dlg)
+        only_selected = QCheckBox(self.tr("Export only selected frames"), dlg)
         only_selected.setChecked(False)  # default: export everything in tree order
         layout.addWidget(only_selected, 2, 0, 1, 2)
 
         # Buttons
         btns = QHBoxLayout()
-        ok = QPushButton("OK", dlg); cancel = QPushButton("Cancel", dlg)
+        ok = QPushButton(self.tr("OK"), dlg); cancel = QPushButton(self.tr("Cancel"), dlg)
         ok.clicked.connect(dlg.accept); cancel.clicked.connect(dlg.reject)
         btns.addWidget(ok); btns.addWidget(cancel)
         layout.addLayout(btns, 3, 0, 1, 2)
@@ -1110,12 +1161,13 @@ class BlinkTab(QWidget):
 
         if not use_aggr:
             if stored.dtype == np.uint8:
-                disp8 = stored
+                return stored
             elif stored.dtype == np.uint16:
-                disp8 = (stored >> 8).astype(np.uint8)
+                return (stored >> 8).astype(np.uint8)
             else:
-                disp8 = (np.clip(stored, 0.0, 1.0) * 255.0).astype(np.uint8)
-            return disp8
+                # ✅ display-only normalization for float / weird ranges
+                f01 = self._ensure_float01(stored)
+                return (f01 * 255.0).astype(np.uint8)
 
         base01 = self._as_float01(stored)
 
@@ -1206,14 +1258,32 @@ class BlinkTab(QWidget):
 
     def _update_loaded_count_label(self, n: int):
         # pluralize nicely
-        self.loading_label.setText(f"Loaded {n} image{'s' if n != 1 else ''}.")
+        self.loading_label.setText(self.tr("Loaded {0} image{1}.").format(n, 's' if n != 1 else ''))
 
     def _apply_playback_interval(self, *_):
-        # read from custom spin if present
-        fps = float(self.speed_spin.value) if hasattr(self, "speed_spin") else float(getattr(self, "play_fps", 1.0))
+        # read from custom spin if present (support both .value() and .value attribute)
+        fps = float(getattr(self, "play_fps", 1.0))
+
+        if hasattr(self, "speed_spin") and self.speed_spin is not None:
+            try:
+                v = getattr(self.speed_spin, "value", None)
+                if callable(v):
+                    fps = float(v())          # QDoubleSpinBox-style
+                elif v is not None:
+                    fps = float(v)            # CustomDoubleSpinBox stores numeric attribute
+                else:
+                    # last-resort: try Qt API name
+                    fps = float(self.speed_spin.value())
+            except Exception:
+                # fall back to existing play_fps
+                pass
+
         fps = max(0.1, min(10.0, fps))
         self.play_fps = fps
-        self.playback_timer.setInterval(int(round(1000.0 / fps)))  # 0.1 fps -> 10000 ms
+
+        if hasattr(self, "playback_timer") and self.playback_timer is not None:
+            self.playback_timer.setInterval(int(round(1000.0 / fps)))  # 0.1 fps -> 10000 ms
+
 
     def _on_current_item_changed_safe(self, current, previous):
         if not current:
@@ -1238,12 +1308,41 @@ class BlinkTab(QWidget):
             if item is not None:
                 self.fileTree.scrollToItem(item, QAbstractItemView.ScrollHint.EnsureVisible)
 
-    def toggle_aggressive(self):
-        self.aggressive_stretch_enabled = self.aggressive_button.isChecked()
-        # force a redisplay of the current image
-        cur = self.fileTree.currentItem()
-        if cur:
-            self.on_item_clicked(cur, 0)
+    def _leaf_path(self, item: QTreeWidgetItem) -> str | None:
+        """Return full path for a leaf item, preferring UserRole; fallback to basename match."""
+        if not item or item.childCount() > 0:
+            return None
+
+        p = item.data(0, Qt.ItemDataRole.UserRole)
+        if p and isinstance(p, str):
+            return p
+
+        # fallback: basename match (legacy items)
+        name = item.text(0).lstrip("⚠️ ").strip()
+        if not name:
+            return None
+        return next((x for x in self.image_paths if os.path.basename(x) == name), None)
+
+
+    def _leaf_index(self, item: QTreeWidgetItem) -> int | None:
+        """Return index into image_paths/loaded_images for a leaf item."""
+        p = self._leaf_path(item)
+        if not p:
+            return None
+        try:
+            return self.image_paths.index(p)
+        except ValueError:
+            return None
+
+
+    def _set_leaf_display(self, item: QTreeWidgetItem, *, base_name: str, flagged: bool, full_path: str):
+        """Update a leaf item's text + UserRole consistently."""
+        disp = base_name
+        if flagged:
+            disp = f"⚠️ {disp}"
+        item.setText(0, disp)
+        item.setData(0, Qt.ItemDataRole.UserRole, full_path)
+
 
     def clearFlags(self):
         """Clear all flagged states, update tree icons & metrics."""
@@ -1280,14 +1379,14 @@ class BlinkTab(QWidget):
         """Let the user pick more images to append to the blink list."""
         file_paths, _ = QFileDialog.getOpenFileNames(
             self,
-            "Add Additional Images",
+            self.tr("Add Additional Images"),
             "",
-            "Images (*.png *.tif *.tiff *.fits *.fit *.xisf *.cr2 *.nef *.arw *.dng *.raf *.orf *.rw2 *.pef);;All Files (*)"
+            self.tr("Images (*.png *.tif *.tiff *.fits *.fit *.xisf *.cr2 *.nef *.arw *.dng *.raf *.orf *.rw2 *.pef);;All Files (*)")
         )
         # filter out duplicates
         new_paths = [p for p in file_paths if p not in self.image_paths]
         if not new_paths:
-            QMessageBox.information(self, "No New Images", "No new images selected or already loaded.")
+            QMessageBox.information(self, self.tr("No New Images"), self.tr("No new images selected or already loaded."))
             return
         self._appendImages(new_paths)
 
@@ -1335,7 +1434,7 @@ class BlinkTab(QWidget):
             self.add_item_to_tree(path)
 
         # update status
-        self.loading_label.setText(f"Loaded {len(self.loaded_images)} images.")
+        self.loading_label.setText(self.tr("Loaded {0} images.").format(len(self.loaded_images)))
         if self.metrics_window and self.metrics_window.isVisible():
             self.metrics_window.update_metrics(self.loaded_images, order=self._tree_order_indices())
 
@@ -1351,7 +1450,7 @@ class BlinkTab(QWidget):
         order = self._tree_order_indices()
         self.metrics_window.set_images(self.loaded_images, order=order)
         panel = self.metrics_window.metrics_panel
-        self.thresholds_by_group["All"] = [line.value() for line in panel.lines]
+        self.thresholds_by_group[self.tr("All")] = [line.value() for line in panel.lines]
         self.metrics_window.show()
         self.metrics_window.raise_()
 
@@ -1405,7 +1504,7 @@ class BlinkTab(QWidget):
         thr_list[metric_idx] = threshold
 
         # build the list of indices to re-evaluate
-        if group == "All":
+        if group == self.tr("All"):
             indices = range(len(self.loaded_images))
         else:
             indices = [
@@ -1450,6 +1549,7 @@ class BlinkTab(QWidget):
         """Rebuild the left tree from self.loaded_images without reloading or recomputing."""
         self.fileTree.clear()
         from collections import defaultdict
+
         grouped = defaultdict(list)
         for entry in self.loaded_images:
             hdr = entry.get('header', {}) or {}
@@ -1467,25 +1567,29 @@ class BlinkTab(QWidget):
             by_object[obj][fil][exp] = paths
 
         for obj in sorted(by_object, key=lambda o: o.lower()):
-            obj_item = QTreeWidgetItem([f"Object: {obj}"])
+            obj_item = QTreeWidgetItem([self.tr("Object: {0}").format(obj)])
             self.fileTree.addTopLevelItem(obj_item)
             obj_item.setExpanded(True)
+
             for fil in sorted(by_object[obj], key=lambda f: f.lower()):
-                fil_item = QTreeWidgetItem([f"Filter: {fil}"])
-                obj_item.addChild(fil_item)
-                fil_item.setExpanded(True)
+                filt_item = QTreeWidgetItem([self.tr("Filter: {0}").format(fil)])
+                obj_item.addChild(filt_item)
+                filt_item.setExpanded(True)
+
                 for exp in sorted(by_object[obj][fil], key=lambda e: str(e).lower()):
-                    exp_item = QTreeWidgetItem([f"Exposure: {exp}"])
-                    fil_item.addChild(exp_item)
+                    exp_item = QTreeWidgetItem([self.tr("Exposure: {0}").format(exp)])
+                    filt_item.addChild(exp_item)
                     exp_item.setExpanded(True)
+
                     for p in by_object[obj][fil][exp]:
                         leaf = QTreeWidgetItem([os.path.basename(p)])
                         leaf.setData(0, Qt.ItemDataRole.UserRole, p)
                         exp_item.addChild(leaf)
 
-        # 🔹 NEW: re-apply flagged styling
+        # 🔹 Re-apply flagged styling
         RED = Qt.GlobalColor.red
         normal = self.fileTree.palette().color(QPalette.ColorRole.WindowText)
+
         for idx, entry in enumerate(self.loaded_images):
             item = self.get_tree_item_for_index(idx)
             if not item:
@@ -1499,32 +1603,25 @@ class BlinkTab(QWidget):
                 item.setForeground(0, QBrush(normal))
 
 
+
     def _after_list_changed(self, removed_indices: List[int] | None = None):
-        """Call after you mutate image_paths/loaded_images. Keeps UI + metrics in sync w/o recompute."""
-        # 1) rebuild the tree (groups collapse if empty)
         self._rebuild_tree_from_loaded()
         self.imagesChanged.emit(len(self.loaded_images))
 
-        # 2) refresh metrics (if open) WITHOUT recomputing SEP
         if self.metrics_window and self.metrics_window.isVisible():
-            if removed_indices:
-                # drop points and reindex
-                self.metrics_window._all_images = self.loaded_images
-                self.metrics_window.remove_indices(list(removed_indices))
-            else:
-                # just order changed or paths changed -> replot current group
-                self.metrics_window.update_metrics(
-                    self.loaded_images,
-                    order=self._tree_order_indices()
-                )
+            # ✅ safest: rebind images + rebuild plot order from tree
+            self.metrics_window.set_images(self.loaded_images, order=self._tree_order_indices())
+            self._sync_metrics_flags()
 
     def get_tree_item_for_index(self, idx):
-        target = os.path.basename(self.image_paths[idx])
+        target_path = self.image_paths[idx]
         for item in self.get_all_leaf_items():
-            if item.text(0).lstrip("⚠️ ") == target:
+            p = item.data(0, Qt.ItemDataRole.UserRole)
+            if p == target_path:
                 return item
         return None
 
+
     def compute_metric(self, metric_idx, entry):
         """Recompute a single metric for one image.  Use cached orig_background for metric 2."""
         # metric 2 is the pre-stretch background we already computed
@@ -1573,7 +1670,7 @@ class BlinkTab(QWidget):
 
     def openDirectoryDialog(self):
         """Allow users to select a directory and load all images within it recursively."""
-        directory = QFileDialog.getExistingDirectory(self, "Select Directory", "")
+        directory = QFileDialog.getExistingDirectory(self, self.tr("Select Directory"), "")
         if directory:
             # Supported image extensions
             supported_extensions = (
@@ -1594,15 +1691,15 @@ class BlinkTab(QWidget):
             if new_file_paths:
                 self.loadImages(new_file_paths)
             else:
-                QMessageBox.information(self, "No Images Found", "No supported image files were found in the selected directory.")
+                QMessageBox.information(self, self.tr("No Images Found"), self.tr("No supported image files were found in the selected directory."))
 
 
     def clearImages(self):
         """Clear all loaded images and reset the tree view."""
         confirmation = QMessageBox.question(
             self,
-            "Clear All Images",
-            "Are you sure you want to clear all loaded images?",
+            self.tr("Clear All Images"),
+            self.tr("Are you sure you want to clear all loaded images?"),
             QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
             QMessageBox.StandardButton.No
         )
@@ -1613,10 +1710,10 @@ class BlinkTab(QWidget):
             self.image_labels.clear()
             self.fileTree.clear()
             self.preview_label.clear()
-            self.preview_label.setText('No image selected.')
+            self.preview_label.setText(self.tr('No image selected.'))
             self.current_pixmap = None
             self.progress_bar.setValue(0)
-            self.loading_label.setText("Loading images...")
+            self.loading_label.setText(self.tr("Loading images..."))
             self.imagesChanged.emit(len(self.loaded_images)) 
 
             # (legacy) if you still have this, you can delete it:
@@ -1649,31 +1746,27 @@ class BlinkTab(QWidget):
         # 1) load
         image, header, bit_depth, is_mono = load_image(file_path)
         if image is None or image.size == 0:
-            raise ValueError("Empty image")
+            msg = QCoreApplication.translate("BlinkTab", "Empty image")
+            raise ValueError(msg)
 
         # 2) optional debayer
         if is_mono:
-            # adjust this call to match your debayer signature
             image = BlinkTab.debayer_image(image, file_path, header)
 
-        # ✅ NEW: force 0..1 range BEFORE SEP + stretch
         image = BlinkTab._ensure_float01(image)
 
-        # 3) SEP background on mono float32
         data = np.asarray(image, dtype=np.float32, order='C')
         if data.ndim == 3:
             data = data.mean(axis=2)
         bkg = sep.Background(data)
         global_back = bkg.globalback
 
-        # 4) stretch
         target_med = 0.25
         if image.ndim == 2:
             stretched = stretch_mono_image(image, target_med)
         else:
             stretched = stretch_color_image(image, target_med, linked=False)
 
-        # 5) cast to target_dtype
         clipped = np.clip(stretched, 0.0, 1.0)
         if target_dtype is np.uint8:
             stored = (clipped * 255).astype(np.uint8)
@@ -1823,7 +1916,7 @@ class BlinkTab(QWidget):
                         leaf.setData(0, Qt.ItemDataRole.UserRole, p)  
                         exp_item.addChild(leaf)
 
-        self.loading_label.setText(f"Loaded {len(self.loaded_images)} images.")
+        self.loading_label.setText(self.tr("Loaded {0} images.").format(len(self.loaded_images)))
         self.progress_bar.setValue(100)
         self.imagesChanged.emit(len(self.loaded_images))
         if self.metrics_window and self.metrics_window.isVisible():
@@ -1848,33 +1941,35 @@ class BlinkTab(QWidget):
 
 
     def _toggle_flag_on_item(self, item: QTreeWidgetItem, *, sync_metrics: bool = True):
-        file_name = item.text(0).lstrip("⚠️ ")
-        file_path = next((p for p in self.image_paths if os.path.basename(p) == file_name), None)
-        if file_path is None:
+        idx = self._leaf_index(item)
+        if idx is None:
             return
 
-        idx = self.image_paths.index(file_path)
         entry = self.loaded_images[idx]
-        entry['flagged'] = not entry['flagged']
+        entry['flagged'] = not bool(entry.get('flagged', False))
 
         RED = Qt.GlobalColor.red
-        palette = self.fileTree.palette()
-        normal_color = palette.color(QPalette.ColorRole.WindowText)
+        normal_color = self.fileTree.palette().color(QPalette.ColorRole.WindowText)
+
+        base = os.path.basename(self.image_paths[idx])
 
         if entry['flagged']:
-            item.setText(0, f"⚠️ {file_name}")
+            item.setText(0, f"⚠️ {base}")
             item.setForeground(0, QBrush(RED))
         else:
-            item.setText(0, file_name)
+            item.setText(0, base)
             item.setForeground(0, QBrush(normal_color))
 
+        # Keep UserRole correct (in case this was a legacy leaf)
+        item.setData(0, Qt.ItemDataRole.UserRole, self.image_paths[idx])
+
         if sync_metrics:
             self._sync_metrics_flags()
 
     def flag_current_image(self):
         item = self.fileTree.currentItem()
         if not item:
-            QMessageBox.warning(self, "No Selection", "No image is currently selected to flag.")
+            QMessageBox.warning(self, self.tr("No Selection"), self.tr("No image is currently selected to flag."))
             return
         self._toggle_flag_on_item(item)   # ← this now updates the metrics panel too
         self.next_item()
@@ -1950,7 +2045,7 @@ class BlinkTab(QWidget):
 
         leaves = self.get_all_leaf_items()
         if not leaves:
-            QMessageBox.information(self, "No Images", "Load some images first.")
+            QMessageBox.information(self, self.tr("No Images"), self.tr("Load some images first."))
             return
 
         # Ensure a current leaf item is selected
@@ -1972,9 +2067,9 @@ class BlinkTab(QWidget):
         """Allow users to select multiple images and add them to the existing list."""
         file_paths, _ = QFileDialog.getOpenFileNames(
             self,
-            "Open Images",
+            self.tr("Open Images"),
             "",
-            "Images (*.png *.tif *.tiff *.fits *.fit *.xisf *.cr2 *.cr3 *.nef *.arw *.dng *.raf *.orf *.rw2 *.pef);;All Files (*)"
+            self.tr("Images (*.png *.tif *.tiff *.fits *.fit *.xisf *.cr2 *.cr3 *.nef *.arw *.dng *.raf *.orf *.rw2 *.pef);;All Files (*)")
         )
         
         # Filter out already loaded images to prevent duplicates
@@ -1983,7 +2078,7 @@ class BlinkTab(QWidget):
         if new_file_paths:
             self.loadImages(new_file_paths)
         else:
-            QMessageBox.information(self, "No New Images", "No new images were selected or all selected images are already loaded.")
+            QMessageBox.information(self, self.tr("No New Images"), self.tr("No new images were selected or all selected images are already loaded."))
 
 
     def debayer_fits(self, image_data, bayer_pattern):
@@ -2033,7 +2128,7 @@ class BlinkTab(QWidget):
             return np.stack([r, g, b], axis=-1)
 
         else:
-            raise ValueError(f"Unsupported Bayer pattern: {bayer_pattern}")
+            raise ValueError(self.tr("Unsupported Bayer pattern: {0}").format(bayer_pattern))
 
     def remove_item_from_tree(self, file_path):
         """Remove a specific item from the tree view based on file path."""
@@ -2150,59 +2245,36 @@ class BlinkTab(QWidget):
             g = (g1 + g2) / 2
             return np.stack([r, g, b], axis=-1)
         else:
-            raise ValueError(f"Unsupported Bayer pattern: {bayer_pattern}")
+            raise ValueError(self.tr("Unsupported Bayer pattern: {0}").format(bayer_pattern))
 
     
 
     def on_item_clicked(self, item, column):
         self.fileTree.setFocus()
+        if not item or item.childCount() > 0:
+            return
 
-        name = item.text(0).lstrip("⚠️ ").strip()
-        file_path = next((p for p in self.image_paths if os.path.basename(p) == name), None)
+        file_path = self._leaf_path(item)
         if not file_path:
             return
 
         self._capture_view_center_norm()
 
-        idx = self.image_paths.index(file_path)
-        entry = self.loaded_images[idx]
-        stored = entry['image_data']  # already stretched & clipped at load time
-
-        # --- Fast path: just display what we cached in RAM ---
-        if not self.aggressive_stretch_enabled:
-            # Convert to 8-bit only if needed (no additional stretch)
-            if stored.dtype == np.uint8:
-                disp8 = stored
-            elif stored.dtype == np.uint16:
-                disp8 = (stored >> 8).astype(np.uint8)   # ~ /257, quick & vectorized
-            else:  # float32 in [0..1]
-                disp8 = (np.clip(stored, 0.0, 1.0) * 255.0).astype(np.uint8)
-
-        else:
-            # Aggressive mode: compute only here (from float01)
-            base01 = self._as_float01(stored)
-            # Siril-style autostretch
-            if base01.ndim == 2:
-                st = siril_style_autostretch(base01, sigma=self.current_sigma)
-                disp01 = self._as_float01(st)   # <-- IMPORTANT: handles 0..255 or 0..1 correctly
-            else:
-                base01 = self._as_float01(stored)
-
-                if base01.ndim == 2:
-                    disp01 = self._aggressive_display_boost(base01, strength=self.current_sigma)
-                else:
-                    lum = base01.mean(axis=2).astype(np.float32)
-                    lum_boost = self._aggressive_display_boost(lum, strength=self.current_sigma)
-                    gain = lum_boost / (lum + 1e-6)
-                    disp01 = np.clip(base01 * gain[..., None], 0.0, 1.0)
+        try:
+            idx = self.image_paths.index(file_path)
+        except ValueError:
+            return
 
-                disp8 = (disp01 * 255.0).astype(np.uint8)
+        entry = self.loaded_images[idx]
 
+        # ✅ single source of truth (handles aggressive + mono + color)
+        disp8 = self._make_display_frame(entry)
 
         qimage = self.convert_to_qimage(disp8)
         self.current_pixmap = QPixmap.fromImage(qimage)
         self.apply_zoom()
 
+
     def _capture_view_center_norm(self):
         """Remember the current viewport center as a fraction of the content size."""
         sa = self.scroll_area
@@ -2305,7 +2377,7 @@ class BlinkTab(QWidget):
             self.apply_zoom()
         else:
             print("No image loaded. Cannot fit to preview.")
-            QMessageBox.warning(self, "Warning", "No image loaded. Cannot fit to preview.")
+            QMessageBox.warning(self, self.tr("Warning"), self.tr("No image loaded. Cannot fit to preview."))
 
     def _is_leaf(self, item: Optional[QTreeWidgetItem]) -> bool:
         return bool(item and item.childCount() == 0)
@@ -2318,108 +2390,173 @@ class BlinkTab(QWidget):
 
         menu = QMenu(self)
 
-        push_action = QAction("Open in Document Window", self)
+        push_action = QAction(self.tr("Open in Document Window"), self)
         push_action.triggered.connect(lambda: self.push_to_docs(item))
         menu.addAction(push_action)
 
-        rename_action = QAction("Rename", self)
+        rename_action = QAction(self.tr("Rename"), self)
         rename_action.triggered.connect(lambda: self.rename_item(item))
         menu.addAction(rename_action)
 
         # 🔹 NEW: batch rename selected
-        batch_rename_action = QAction("Batch Rename Selected…", self)
+        batch_rename_action = QAction(self.tr("Batch Rename Selected…"), self)
         batch_rename_action.triggered.connect(self.batch_rename_items)
         menu.addAction(batch_rename_action)
 
-        move_action = QAction("Move Selected Items", self)
+        move_action = QAction(self.tr("Move Selected Items"), self)
         move_action.triggered.connect(self.move_items)
         menu.addAction(move_action)
 
-        delete_action = QAction("Delete Selected Items", self)
+        delete_action = QAction(self.tr("Delete Selected Items"), self)
         delete_action.triggered.connect(self.delete_items)
         menu.addAction(delete_action)
 
         menu.addSeparator()
 
-        batch_delete_action = QAction("Delete All Flagged Images", self)
+        batch_delete_action = QAction(self.tr("Delete All Flagged Images"), self)
         batch_delete_action.triggered.connect(self.batch_delete_flagged_images)
         menu.addAction(batch_delete_action)
 
-        batch_move_action = QAction("Move All Flagged Images", self)
+        batch_move_action = QAction(self.tr("Move All Flagged Images"), self)
         batch_move_action.triggered.connect(self.batch_move_flagged_images)
         menu.addAction(batch_move_action)
 
         # 🔹 NEW: rename all flagged images
-        rename_flagged_action = QAction("Rename Flagged Images…", self)
+        rename_flagged_action = QAction(self.tr("Rename Flagged Images…"), self)
         rename_flagged_action.triggered.connect(self.rename_flagged_images)
         menu.addAction(rename_flagged_action)
 
         menu.addSeparator()
 
-        send_lights_act = QAction("Send to Stacking → Lights", self)
+        send_lights_act = QAction(self.tr("Send to Stacking → Lights"), self)
         send_lights_act.triggered.connect(self._send_to_stacking_lights)
         menu.addAction(send_lights_act)
 
-        send_integ_act = QAction("Send to Stacking → Integration", self)
+        send_integ_act = QAction(self.tr("Send to Stacking → Integration"), self)
         send_integ_act.triggered.connect(self._send_to_stacking_integration)
         menu.addAction(send_integ_act)
 
         menu.exec(self.fileTree.mapToGlobal(pos))
 
 
-    def push_to_docs(self, item):
-        # Resolve file + entry
-        file_name = item.text(0).lstrip("⚠️ ")
-        file_path = next((p for p in self.image_paths if os.path.basename(p) == file_name), None)
+    def push_to_docs(self, item: QTreeWidgetItem):
+        """
+        Push the currently selected blink leaf image into DocManager as a new document,
+        preserving all original metadata (original_header, meta, bit_depth, is_mono, etc.)
+        and swapping ONLY the numpy image array.
+        """
+        if not item or item.childCount() > 0:
+            return
+
+        # --- Resolve full path safely (UserRole-first) ---
+        file_path = item.data(0, Qt.ItemDataRole.UserRole)
+        if not file_path or not isinstance(file_path, str):
+            # legacy fallback: try to map by displayed name
+            file_name = item.text(0).lstrip("⚠️ ").strip()
+            file_path = next((p for p in self.image_paths if os.path.basename(p) == file_name), None)
+
         if not file_path:
             return
-        idx   = self.image_paths.index(file_path)
+
+        try:
+            idx = self.image_paths.index(file_path)
+        except ValueError:
+            return
+
         entry = self.loaded_images[idx]
 
-        # Find main window + doc manager
+        # --- Find main window + doc manager ---
         mw = self._main_window()
         dm = self.doc_manager or (getattr(mw, "docman", None) if mw else None)
         if not mw or not dm:
-            QMessageBox.warning(self, "Document Manager", "Main window or DocManager not available.")
+            QMessageBox.warning(self, self.tr("Document Manager"), self.tr("Main window or DocManager not available."))
             return
 
-        # Prepare image + metadata for a real document
-        np_image_f01 = self._as_float01(entry['image_data'])  # ensure float32 [0..1]
-        metadata  = {
-            'file_path': file_path,
-            'original_header': entry.get('header', {}),
-            'bit_depth': entry.get('bit_depth'),
-            'is_mono': entry.get('is_mono'),
-            'source': 'BlinkComparatorPro',
+        # --- Build the swapped payload (image replaced, metadata preserved) ---
+        # Whatever you're storing as entry['image_data'] (uint16/float/etc), normalize to float01 for display pipeline.
+        # If your DocManager expects native dtype instead, swap _as_float01 for your native image.
+        np_image_f01 = self._as_float01(entry["image_data"]).astype(np.float32, copy=False)
+
+        # Preserve your full load_image return structure as much as possible:
+        # load_image returns: image, original_header, bit_depth, is_mono, meta
+        original_header = entry.get("original_header", entry.get("header", None))
+        bit_depth       = entry.get("bit_depth", None)
+        is_mono         = entry.get("is_mono", None)
+        meta            = entry.get("meta", {})
+
+        # Keep meta dict style your app uses; add source tag without clobbering
+        if isinstance(meta, dict):
+            meta = dict(meta)
+            meta.setdefault("source", "BlinkComparatorPro")
+            meta.setdefault("file_path", file_path)
+
+        # This is the "all the other stuff" you wanted preserved
+        payload = {
+            "file_path": file_path,
+            "original_header": original_header,
+            "bit_depth": bit_depth,
+            "is_mono": is_mono,
+            "meta": meta,
+            "source": "BlinkComparatorPro",
         }
+
         title = os.path.basename(file_path)
 
-        # Create the document using whatever API your DocManager has
+        # --- Create document using whatever DocManager API exists ---
         doc = None
         try:
-            if hasattr(dm, "open_array"):
-                doc = dm.open_array(np_image_f01, metadata=metadata, title=title)
+            # Preferred: if you have a method that mirrors open_file/load_image shape
+            if hasattr(dm, "open_from_load_image"):
+                # (image, original_header, bit_depth, is_mono, meta)
+                doc = dm.open_from_load_image(np_image_f01, original_header, bit_depth, is_mono, meta, title=title)
+
+            elif hasattr(dm, "open_array"):
+                # Some of your code expects metadata in doc.metadata; pass payload whole
+                doc = dm.open_array(np_image_f01, metadata=payload, title=title)
+
             elif hasattr(dm, "open_numpy"):
-                doc = dm.open_numpy(np_image_f01, metadata=metadata, title=title)
+                doc = dm.open_numpy(np_image_f01, metadata=payload, title=title)
+
             elif hasattr(dm, "create_document"):
-                doc = dm.create_document(image=np_image_f01, metadata=metadata, name=title)
+                # Try both signatures
+                try:
+                    doc = dm.create_document(image=np_image_f01, metadata=payload, name=title)
+                except TypeError:
+                    doc = dm.create_document(np_image_f01, payload, title)
+
             else:
-                raise AttributeError("DocManager lacks open_array/open_numpy/create_document")
+                raise AttributeError("DocManager lacks a known creation method")
+
         except Exception as e:
-            QMessageBox.critical(self, "Doc Manager", f"Failed to create document:\n{e}")
+            QMessageBox.critical(self, self.tr("Doc Manager"), self.tr("Failed to create document:\n{0}").format(e))
             return
 
         if doc is None:
-            QMessageBox.critical(self, "Doc Manager", "DocManager returned no document.")
+            QMessageBox.critical(self, self.tr("Doc Manager"), self.tr("DocManager returned no document."))
             return
 
-        # SHOW it: ask the main window to spawn an MDI subwindow
+        # --- Hand off to DocManager flow (DocManager should trigger MDI + window creation) ---
         try:
-            mw._spawn_subwindow_for(doc)
+            # If your architecture already auto-spawns windows on documentAdded,
+            # you should NOT call mw._spawn_subwindow_for(doc) here.
+            if hasattr(dm, "add_document"):
+                dm.add_document(doc)
+            elif hasattr(dm, "register_document"):
+                dm.register_document(doc)
+            else:
+                # If open_array/open_numpy already registers the doc internally, do nothing.
+                pass
+
+            # If you *must* spawn manually (older path), keep as fallback
+            if hasattr(mw, "_spawn_subwindow_for"):
+                mw._spawn_subwindow_for(doc)
+
             if hasattr(mw, "_log"):
                 mw._log(f"Blink → opened '{title}' as new document")
+
         except Exception as e:
-            QMessageBox.critical(self, "UI", f"Failed to open subwindow:\n{e}")
+            QMessageBox.critical(self, self.tr("UI"), self.tr("Failed to open subwindow:\n{0}").format(e))
+
 
 
     # optional shim to keep any old calls working
@@ -2428,27 +2565,55 @@ class BlinkTab(QWidget):
 
 
 
-    def rename_item(self, item):
-        """Allow the user to rename the selected image."""
-        current_name = item.text(0).lstrip("⚠️ ")
-        new_name, ok = QInputDialog.getText(self, "Rename Image", "Enter new name:", text=current_name)
+    def rename_item(self, item: QTreeWidgetItem):
+        if not item or item.childCount() > 0:
+            return
 
-        if ok and new_name:
-            file_path = next((path for path in self.image_paths if os.path.basename(path) == current_name), None)
-            if file_path:
-                # Get the new file path with the new name
-                new_file_path = os.path.join(os.path.dirname(file_path), new_name)
+        idx = self._leaf_index(item)
+        if idx is None:
+            return
+
+        old_path = self.image_paths[idx]
+        old_base = os.path.basename(old_path)
+
+        new_name, ok = QInputDialog.getText(
+            self,
+            self.tr("Rename Image"),
+            self.tr("Enter new name:"),
+            text=old_base
+        )
+        if not ok:
+            return
+
+        new_name = (new_name or "").strip()
+        if not new_name:
+            return
+
+        new_path = os.path.join(os.path.dirname(old_path), new_name)
+
+        # Avoid overwrite
+        if os.path.exists(new_path):
+            QMessageBox.critical(self, self.tr("Error"), self.tr("A file with that name already exists."))
+            return
+
+        try:
+            os.rename(old_path, new_path)
+        except Exception as e:
+            QMessageBox.critical(self, self.tr("Error"), self.tr("Failed to rename the file: {0}").format(e))
+            return
+
+        # Update internal structures
+        self.image_paths[idx] = new_path
+        self.loaded_images[idx]['file_path'] = new_path
+
+        # Update the leaf item
+        flagged = bool(self.loaded_images[idx].get("flagged", False))
+        self._set_leaf_display(item, base_name=new_name, flagged=flagged, full_path=new_path)
+
+        # Rebuild so natural sort stays correct and groups update
+        self._after_list_changed()
+        self._sync_metrics_flags()
 
-                try:
-                    # Rename the file
-                    os.rename(file_path, new_file_path)
-                    print(f"File renamed from {current_name} to {new_name}")
-                    
-                    # Update the image paths and tree view
-                    self.image_paths[self.image_paths.index(file_path)] = new_file_path
-                    item.setText(0, new_name)
-                except Exception as e:
-                    QMessageBox.critical(self, "Error", f"Failed to rename the file: {e}")
 
     def rename_flagged_images(self):
         """Prefix all *flagged* images on disk and in the tree."""
@@ -2459,17 +2624,17 @@ class BlinkTab(QWidget):
         if not flagged_indices:
             QMessageBox.information(
                 self,
-                "Rename Flagged Images",
-                "There are no flagged images to rename."
+                self.tr("Rename Flagged Images"),
+                self.tr("There are no flagged images to rename.")
             )
             return
 
         # Small dialog like in your mockup: just a prefix field
         dlg = QDialog(self)
-        dlg.setWindowTitle("Rename flagged images")
+        dlg.setWindowTitle(self.tr("Rename flagged images"))
         layout = QVBoxLayout(dlg)
 
-        layout.addWidget(QLabel("Prefix to add to flagged image filenames:", dlg))
+        layout.addWidget(QLabel(self.tr("Prefix to add to flagged image filenames:"), dlg))
 
         prefix_edit = QLineEdit(dlg)
         prefix_edit.setText("Bad_")  # sensible default
@@ -2494,9 +2659,9 @@ class BlinkTab(QWidget):
             # Allow empty but warn – otherwise user may be confused
             ret = QMessageBox.question(
                 self,
-                "No Prefix",
-                "No prefix entered. This will not change any filenames.\n\n"
-                "Continue anyway?",
+                self.tr("No Prefix"),
+                self.tr("No prefix entered. This will not change any filenames.\n\n"
+                "Continue anyway?"),
                 QMessageBox.StandardButton.Yes | QDialogButtonBox.StandardButton.No,
                 QMessageBox.StandardButton.No,
             )
@@ -2549,102 +2714,125 @@ class BlinkTab(QWidget):
         # Also sync the metrics panel flags/colors
         self._sync_metrics_flags()
 
-        msg = f"Renamed {successes} flagged image{'s' if successes != 1 else ''}."
+        msg = self.tr("Renamed {0} flagged image{1}.").format(successes, 's' if successes != 1 else '')
         if failures:
-            msg += f"\n\n{len(failures)} file(s) could not be renamed:"
+            msg += self.tr("\n\n{0} file(s) could not be renamed:").format(len(failures))
             for old, err in failures[:10]:  # don’t spam too hard
                 msg += f"\n• {os.path.basename(old)} – {err}"
 
-        QMessageBox.information(self, "Rename Flagged Images", msg)
+        QMessageBox.information(self, self.tr("Rename Flagged Images"), msg)
 
 
     def batch_rename_items(self):
-        """Batch rename selected items by adding a prefix or suffix."""
-        selected_items = self.fileTree.selectedItems()
-
+        """Batch rename selected leaf items by adding a prefix and/or suffix."""
+        selected_items = [it for it in self.fileTree.selectedItems() if it and it.childCount() == 0]
         if not selected_items:
-            QMessageBox.warning(self, "Warning", "No items selected for renaming.")
+            QMessageBox.warning(self, self.tr("Warning"), self.tr("No individual image items selected for renaming."))
             return
 
-        # Create a custom dialog for entering the prefix and suffix
         dialog = QDialog(self)
-        dialog.setWindowTitle("Batch Rename")
+        dialog.setWindowTitle(self.tr("Batch Rename"))
         dialog_layout = QVBoxLayout(dialog)
 
-        instruction_label = QLabel("Enter a prefix or suffix to rename selected files:")
-        dialog_layout.addWidget(instruction_label)
+        dialog_layout.addWidget(QLabel(self.tr("Enter a prefix or suffix to rename selected files:"), dialog))
 
-        # Create fields for prefix and suffix
         form_layout = QHBoxLayout()
-
         prefix_field = QLineEdit(dialog)
-        prefix_field.setPlaceholderText("Prefix")
+        prefix_field.setPlaceholderText(self.tr("Prefix"))
         form_layout.addWidget(prefix_field)
 
-        current_filename_label = QLabel("currentfilename", dialog)
-        form_layout.addWidget(current_filename_label)
+        mid_label = QLabel(self.tr("filename"), dialog)
+        mid_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        form_layout.addWidget(mid_label)
 
         suffix_field = QLineEdit(dialog)
-        suffix_field.setPlaceholderText("Suffix")
+        suffix_field.setPlaceholderText(self.tr("Suffix"))
         form_layout.addWidget(suffix_field)
-
         dialog_layout.addLayout(form_layout)
 
-        # Add OK and Cancel buttons
-        button_layout = QHBoxLayout()
-        ok_button = QPushButton("OK", dialog)
+        btns = QHBoxLayout()
+        ok_button = QPushButton(self.tr("OK"), dialog)
+        cancel_button = QPushButton(self.tr("Cancel"), dialog)
         ok_button.clicked.connect(dialog.accept)
-        button_layout.addWidget(ok_button)
-
-        cancel_button = QPushButton("Cancel", dialog)
         cancel_button.clicked.connect(dialog.reject)
-        button_layout.addWidget(cancel_button)
+        btns.addWidget(ok_button)
+        btns.addWidget(cancel_button)
+        dialog_layout.addLayout(btns)
 
-        dialog_layout.addLayout(button_layout)
+        if dialog.exec() != QDialog.DialogCode.Accepted:
+            return
 
-        # Show the dialog and handle user input
-        if dialog.exec() == QDialog.DialogCode.Accepted:
-            prefix = prefix_field.text().strip()
-            suffix = suffix_field.text().strip()
+        prefix = (prefix_field.text() or "").strip()
+        suffix = (suffix_field.text() or "").strip()
 
-            # Rename each selected file
-            for item in selected_items:
-                current_name = item.text(0)
-                file_path = next((path for path in self.image_paths if os.path.basename(path) == current_name), None)
+        if not prefix and not suffix:
+            QMessageBox.information(self, self.tr("Batch Rename"), self.tr("No prefix or suffix entered. Nothing to do."))
+            return
 
-                if file_path:
-                    # Construct the new filename
-                    directory = os.path.dirname(file_path)
-                    new_name = f"{prefix}{current_name}{suffix}"
-                    new_file_path = os.path.join(directory, new_name)
+        renamed = 0
+        failures = []
 
-                    try:
-                        # Rename the file
-                        os.rename(file_path, new_file_path)
-                        print(f"File renamed from {file_path} to {new_file_path}")
+        # Work on indices so we can update lists safely
+        indices = []
+        for it in selected_items:
+            idx = self._leaf_index(it)
+            if idx is not None:
+                indices.append((idx, it))
 
-                        # Update the paths and tree view
-                        self.image_paths[self.image_paths.index(file_path)] = new_file_path
-                        item.setText(0, new_name)
+        for idx, it in indices:
+            old_path = self.image_paths[idx]
+            directory, base = os.path.split(old_path)
 
-                    except Exception as e:
-                        print(f"Failed to rename {file_path}: {e}")
-                        QMessageBox.critical(self, "Error", f"Failed to rename the file: {e}")
+            new_base = f"{prefix}{base}{suffix}"
+            new_path = os.path.join(directory, new_base)
+
+            if new_path == old_path:
+                continue
+
+            if os.path.exists(new_path):
+                failures.append((old_path, self.tr("target already exists")))
+                continue
+
+            try:
+                os.rename(old_path, new_path)
+            except Exception as e:
+                failures.append((old_path, str(e)))
+                continue
+
+            # Update internal lists
+            self.image_paths[idx] = new_path
+            self.loaded_images[idx]["file_path"] = new_path
+
+            # Update leaf item
+            flagged = bool(self.loaded_images[idx].get("flagged", False))
+            self._set_leaf_display(it, base_name=new_base, flagged=flagged, full_path=new_path)
+
+            renamed += 1
+
+        # Rebuild so group headers + natural order stay correct
+        self._after_list_changed()
+        self._sync_metrics_flags()
+
+        msg = self.tr("Batch renamed {0} file{1}.").format(renamed, "s" if renamed != 1 else "")
+        if failures:
+            msg += self.tr("\n\n{0} file(s) failed:").format(len(failures))
+            for old, err in failures[:10]:
+                msg += f"\n• {os.path.basename(old)} – {err}"
+        QMessageBox.information(self, self.tr("Batch Rename"), msg)
 
-            print(f"Batch renamed {len(selected_items)} items.")
 
     def batch_delete_flagged_images(self):
         """Delete all flagged images."""
         flagged_images = [img for img in self.loaded_images if img['flagged']]
         
         if not flagged_images:
-            QMessageBox.information(self, "No Flagged Images", "There are no flagged images to delete.")
+            QMessageBox.information(self, self.tr("No Flagged Images"), self.tr("There are no flagged images to delete."))
             return
 
         confirmation = QMessageBox.question(
             self,
-            "Confirm Batch Deletion",
-            f"Are you sure you want to permanently delete {len(flagged_images)} flagged images? This action is irreversible.",
+            self.tr("Confirm Batch Deletion"),
+            self.tr("Are you sure you want to permanently delete {0} flagged images? This action is irreversible.").format(len(flagged_images)),
             QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
             QMessageBox.StandardButton.No
         )
@@ -2672,147 +2860,187 @@ class BlinkTab(QWidget):
                     self.loaded_images.remove(img)
                 self.remove_item_from_tree(file_path)
 
-            QMessageBox.information(self, "Batch Deletion", f"Deleted {len(removed_indices)} flagged images.")
+            QMessageBox.information(self, self.tr("Batch Deletion"), self.tr("Deleted {0} flagged images.").format(len(removed_indices)))
 
             # 🔁 refresh tree + metrics (no recompute)
             self._after_list_changed(removed_indices)
 
     def batch_move_flagged_images(self):
-        """Move all flagged images to a selected directory."""
-        flagged_images = [img for img in self.loaded_images if img['flagged']]
-        
-        if not flagged_images:
-            QMessageBox.information(self, "No Flagged Images", "There are no flagged images to move.")
+        """Move all flagged images to a selected directory AND remove them from the blink list."""
+        flagged_indices = [i for i, e in enumerate(self.loaded_images) if e.get("flagged", False)]
+        if not flagged_indices:
+            QMessageBox.information(self, self.tr("No Flagged Images"), self.tr("There are no flagged images to move."))
             return
 
-        # Select destination directory
-        destination_dir = QFileDialog.getExistingDirectory(self, "Select Destination Folder", "")
+        destination_dir = QFileDialog.getExistingDirectory(self, self.tr("Select Destination Folder"), "")
         if not destination_dir:
-            return  # User canceled
+            return
 
-        for img in flagged_images:
-            src_path = img['file_path']
-            file_name = os.path.basename(src_path)
-            dest_path = os.path.join(destination_dir, file_name)
+        failures = []
 
+        # Move first (use current paths from indices)
+        for i in flagged_indices:
+            src_path = self.image_paths[i]
+            dest_path = os.path.join(destination_dir, os.path.basename(src_path))
             try:
                 os.rename(src_path, dest_path)
-                print(f"Moved flagged image from {src_path} to {dest_path}")
             except Exception as e:
-                print(f"Failed to move {src_path}: {e}")
-                QMessageBox.critical(self, "Error", f"Failed to move {src_path}: {e}")
-                continue
+                failures.append((src_path, str(e)))
 
-            # Update data structures
-            self.image_paths.remove(src_path)
-            self.image_paths.append(dest_path)
-            img['file_path'] = dest_path
-            img['flagged'] = False  # Reset flag if desired
+        # Remove from lists ONLY if move succeeded
+        # Build a set of indices to remove: those that did NOT fail
+        failed_src = {p for p, _ in failures}
+        removed_indices = [i for i in flagged_indices if self.image_paths[i] not in failed_src]
 
-            # Update tree view
-            self.remove_item_from_tree(src_path)
-            self.add_item_to_tree(dest_path)
+        removed_indices = sorted(set(removed_indices), reverse=True)
+        for idx in removed_indices:
+            if 0 <= idx < len(self.image_paths):
+                del self.image_paths[idx]
+            if 0 <= idx < len(self.loaded_images):
+                del self.loaded_images[idx]
+
+        if removed_indices:
+            self._after_list_changed(removed_indices)
+
+        if failures:
+            msg = self.tr("Moved {0} flagged file(s). {1} failed:").format(len(removed_indices), len(failures))
+            for p, err in failures[:10]:
+                msg += f"\n• {os.path.basename(p)} – {err}"
+            QMessageBox.warning(self, self.tr("Batch Move"), msg)
+        else:
+            QMessageBox.information(self, self.tr("Batch Move"), self.tr("Moved and removed {0} flagged image(s).").format(len(removed_indices)))
 
-        QMessageBox.information(self, "Batch Move", f"Moved {len(flagged_images)} flagged images.")
-        self._after_list_changed(removed_indices=None)
 
     def move_items(self):
-        """Move selected images *and* remove them from the tree+metrics."""
-        selected_items = self.fileTree.selectedItems()
+        """Move selected leaf images to a selected directory AND remove them from the blink list."""
+        selected_items = [it for it in self.fileTree.selectedItems() if it and it.childCount() == 0]
         if not selected_items:
-            QMessageBox.warning(self, "Warning", "No items selected for moving.")
+            QMessageBox.warning(self, self.tr("Warning"), self.tr("No individual image items selected for moving."))
             return
 
-        # Ask where to move
-        new_dir = QFileDialog.getExistingDirectory(self,
-                                                "Select Destination Folder",
-                                                "")
+        new_dir = QFileDialog.getExistingDirectory(self, self.tr("Select Destination Folder"), "")
         if not new_dir:
             return
 
-        # Keep track of which on‐disk paths we actually moved
-        moved_old_paths = []
         removed_indices = []
+        failures = []
 
-        for item in selected_items:
-            name = item.text(0).lstrip("⚠️ ")
-            old_path = next((p for p in self.image_paths 
-                            if os.path.basename(p) == name), None)
-            if not old_path:
+        # Collect (idx, old_path, item) first to avoid index drift
+        triplets = []
+        for it in selected_items:
+            p = self._leaf_path(it)
+            if not p:
                 continue
-            removed_indices.append(self.image_paths.index(old_path)) 
+            try:
+                idx = self.image_paths.index(p)
+            except ValueError:
+                continue
+            triplets.append((idx, p, it))
 
-            new_path = os.path.join(new_dir, name)
+        for idx, old_path, it in triplets:
+            base = os.path.basename(old_path)
+            new_path = os.path.join(new_dir, base)
             try:
                 os.rename(old_path, new_path)
             except Exception as e:
-                QMessageBox.critical(self, "Error", f"Failed to move {old_path}: {e}")
+                failures.append((old_path, str(e)))
                 continue
 
-            moved_old_paths.append(old_path)
-
-            # 1) Remove the leaf from the tree
-            parent = item.parent() or self.fileTree.invisibleRootItem()
-            parent.removeChild(item)
+            removed_indices.append(idx)
 
-        # 2) Purge them from your internal lists
-        for idx in sorted(removed_indices, reverse=True):
-            del self.image_paths[idx]
-            del self.loaded_images[idx]
+            # remove leaf from tree immediately (optional; _after_list_changed will rebuild anyway)
+            #parent = it.parent() or self.fileTree.invisibleRootItem()
+            #parent.removeChild(it)
 
-        self._after_list_changed(removed_indices)
-        print(f"Moved and removed {len(removed_indices)} items.")
+        # Purge arrays descending
+        removed_indices = sorted(set(removed_indices), reverse=True)
+        for idx in removed_indices:
+            if 0 <= idx < len(self.image_paths):
+                del self.image_paths[idx]
+            if 0 <= idx < len(self.loaded_images):
+                del self.loaded_images[idx]
 
+        if removed_indices:
+            self._after_list_changed(removed_indices)
 
+        if failures:
+            msg = self.tr("Moved {0} file(s). {1} failed:").format(len(removed_indices), len(failures))
+            for old, err in failures[:10]:
+                msg += f"\n• {os.path.basename(old)} – {err}"
+            QMessageBox.warning(self, self.tr("Move Selected Items"), msg)
+        else:
+            QMessageBox.information(self, self.tr("Move Selected Items"), self.tr("Moved and removed {0} item(s).").format(len(removed_indices)))
 
     def delete_items(self):
-        """Delete the selected items from the tree, the loaded images list, and the file system."""
-        selected_items = self.fileTree.selectedItems()
-
+        """Delete selected leaf images from disk and remove them from the blink list."""
+        selected_items = [it for it in self.fileTree.selectedItems() if it and it.childCount() == 0]
         if not selected_items:
-            QMessageBox.warning(self, "Warning", "No items selected for deletion.")
+            QMessageBox.warning(self, self.tr("Warning"), self.tr("No individual image items selected for deletion."))
             return
 
-        # Confirmation dialog
         reply = QMessageBox.question(
             self,
-            'Confirm Deletion',
-            f"Are you sure you want to permanently delete {len(selected_items)} selected images? This action is irreversible.",
+            self.tr("Confirm Deletion"),
+            self.tr("Are you sure you want to permanently delete {0} selected images? This action is irreversible.").format(len(selected_items)),
             QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
             QMessageBox.StandardButton.No
         )
+        if reply != QMessageBox.StandardButton.Yes:
+            return
 
         removed_indices = []
-        if reply == QMessageBox.StandardButton.Yes:
-            for item in selected_items:
-                file_name = item.text(0).lstrip("⚠️ ")
-                file_path = next((path for path in self.image_paths if os.path.basename(path) == file_name), None)
-                if file_path:
-                    try:
-                        idx = self.image_paths.index(file_path)
-                        removed_indices.append(idx)  # collect BEFORE mutation
-                        ...
-                        os.remove(file_path)
-                    except Exception as e:
-                        ...
-            # Remove from widgets
-            for item in selected_items:
-                parent = item.parent() or self.fileTree.invisibleRootItem()
-                parent.removeChild(item)
-
-            # Purge arrays (descending order)
-            for idx in sorted(removed_indices, reverse=True):
+        failures = []
+
+        # Snapshot first
+        triplets = []
+        for it in selected_items:
+            p = self._leaf_path(it)
+            if not p:
+                continue
+            try:
+                idx = self.image_paths.index(p)
+            except ValueError:
+                continue
+            triplets.append((idx, p, it))
+
+        for idx, path, it in triplets:
+            try:
+                os.remove(path)
+            except Exception as e:
+                failures.append((path, str(e)))
+                continue
+
+            removed_indices.append(idx)
+
+            # remove from tree immediately (optional)
+            parent = it.parent() or self.fileTree.invisibleRootItem()
+            parent.removeChild(it)
+
+        # Purge arrays descending
+        removed_indices = sorted(set(removed_indices), reverse=True)
+        for idx in removed_indices:
+            if 0 <= idx < len(self.image_paths):
                 del self.image_paths[idx]
+            if 0 <= idx < len(self.loaded_images):
                 del self.loaded_images[idx]
 
-            # Clear preview
-            self.preview_label.clear()
-            self.preview_label.setText('No image selected.')
-            self.current_image = None
+        # Clear preview safely
+        self.preview_label.clear()
+        self.preview_label.setText(self.tr("No image selected."))
+        self.current_pixmap = None
 
-            # 🔁 refresh tree + metrics (no recompute)
+        if removed_indices:
             self._after_list_changed(removed_indices)
 
+        if failures:
+            msg = self.tr("Deleted {0} file(s). {1} failed:").format(len(removed_indices), len(failures))
+            for p, err in failures[:10]:
+                msg += f"\n• {os.path.basename(p)} – {err}"
+            QMessageBox.warning(self, self.tr("Delete Selected Items"), msg)
+        else:
+            QMessageBox.information(self, self.tr("Delete Selected Items"), self.tr("Deleted {0} item(s).").format(len(removed_indices)))
+
+
     def eventFilter(self, source, event):
         """Handle mouse events for dragging."""
         if source == self.scroll_area.viewport():
@@ -2875,16 +3103,14 @@ class BlinkTab(QWidget):
             self.on_item_clicked(cur, 0)
 
     def convert_to_qimage(self, img_array):
-        """Convert numpy image array to QImage."""
-        # 1) Bring everything into a uint8 (0–255) array
         if img_array.dtype == np.uint8:
             arr8 = img_array
         elif img_array.dtype == np.uint16:
-            # downscale 16-bit → 8-bit
             arr8 = (img_array.astype(np.float32) / 65535.0 * 255.0).clip(0,255).astype(np.uint8)
         else:
-            # assume float in [0..1]
-            arr8 = (img_array.clip(0.0, 1.0) * 255.0).astype(np.uint8)
+            # ✅ display-only normalize floats outside 0..1
+            f01 = self._ensure_float01(img_array)
+            arr8 = (f01 * 255.0).astype(np.uint8)
 
         h, w = arr8.shape[:2]
         buffer = arr8.tobytes()