Merge pull request #908 from eoyilmaz/901-qt-visual-whitepoint-editor-pin-float

[#901] Add pin/float button to Qt visual whitepoint editor controls panel

Author: eoyilmaz

DisplayCAL/VERSION

@@ -1 +1 @@
-3.10.0.dev61
+3.10.0.dev62

DisplayCAL/lang/en.yaml

@@ -2662,6 +2662,10 @@
   Visual whitepoint editor
 "whitepoint.visual_editor.display_changed.warning": |-
   Attention: The display configuration has changed and the visual whitepoint editor may no longer be able to correctly restore display profiles. Please check display profile associations carefully after closing the editor and restart DisplayCAL.
+"whitepoint.visual_editor.panel.dock": |-
+  Attach panel to editor window
+"whitepoint.visual_editor.panel.float": |-
+  Detach panel into its own window
 "whitepoint.xy": |-
   Chromaticity coordinates
 "window.title": |-

DisplayCAL/ui/tools/visual_whitepoint_editor.py

@@ -22,7 +22,11 @@
 (see ``_visual_whitepoint_editor_measure_handler``), mirroring how wx's button
 called back into the parent's ``ambient_measure_handler``. Still deliberately
 dropped: the network **pattern-generator** patch output (tracked separately).
-The custom wx spinners/sliders/AUI docking are replaced by native Qt widgets.
+The custom wx spinners/sliders are replaced by native Qt widgets; wx's
+AUI-managed pin/float pane has no docking-framework equivalent under Qt, so
+:meth:`VisualWhitepointEditorWindow.float_panel`/``dock_panel`` instead detach
+the controls panel into a plain top-level :class:`_FloatingControlsWindow`
+and re-embed it, toggled via the header row's pin button.
 """
 
 from __future__ import annotations
@@ -795,6 +799,35 @@ def restore_display_profiles(
                 thread.join()
 
 
+class _FloatingControlsWindow(QWidget):
+    """Floating window that hosts the detached controls panel.
+
+    Qt port of wx's AUI-floated ``mainPanel`` pane (see wx's
+    ``PinButton(True)`` / ``float_pane_handler``). There is no AUI-docking
+    equivalent under Qt, so this is a plain top-level ``QWidget`` (no modal
+    dialog semantics, e.g. no Escape-to-close) that clicking its native close
+    button re-docks rather than destroys, mirroring wx's
+    ``close_pane_handler`` (which vetoes the close and docks the pane
+    instead).
+
+    Args:
+        editor (VisualWhitepointEditorWindow): The owning editor.
+    """
+
+    def __init__(self, editor: VisualWhitepointEditorWindow) -> None:
+        super().__init__(editor, Qt.Tool)
+        self._editor = editor
+
+    def closeEvent(self, event: QCloseEvent) -> None:  # noqa: N802 (Qt override)
+        """Dock the panel back into the editor instead of closing.
+
+        Args:
+            event (QCloseEvent): The Qt close event.
+        """
+        event.ignore()
+        self._editor.dock_panel()
+
+
 class VisualWhitepointEditorWindow(BaseWindow):
     """Standalone visual whitepoint editor window."""
 
@@ -824,6 +857,7 @@ def __init__(self) -> None:
         self.display_size_mm: dict[tuple, list[float]] = {}
         self.default_size = 300.0
         self._pm: _ProfileManager | None = None
+        self._float_window: _FloatingControlsWindow | None = None
 
         cfg_x, cfg_y, cfg_scale = (
             float(v)
@@ -861,7 +895,16 @@ def _build_ui(self, cfg_x: float, cfg_y: float, cfg_scale: float) -> None:
         panel.setContentsMargins(12, 12, 12, 12)
         panel.setSpacing(10)
 
-        panel.addWidget(_section_label(lang.getstr("whitepoint")))
+        header_row = QHBoxLayout()
+        header_row.addWidget(_section_label(lang.getstr("whitepoint")))
+        header_row.addStretch(1)
+        self.pin_btn = _icon_button(
+            "button-pin", lang.getstr("whitepoint.visual_editor.panel.float")
+        )
+        self.pin_btn.setCheckable(True)
+        self.pin_btn.toggled.connect(self._on_pin_toggled)
+        header_row.addWidget(self.pin_btn)
+        panel.addLayout(header_row)
 
         self.hsv_wheel = HSVWheel(self)
         self.bright_ctrl = BrightCtrl(self, self.colour)
@@ -947,6 +990,8 @@ def _build_ui(self, cfg_x: float, cfg_y: float, cfg_scale: float) -> None:
         panel.addStretch(1)
 
         self.bg_area = _BackgroundArea(central)
+        self.controls = controls
+        self._root_layout = root
         root.addWidget(controls, 0)
         root.addWidget(self.bg_area, 1)
         self.setCentralWidget(central)
@@ -1093,6 +1138,51 @@ def _center_slider(slider: QSlider) -> None:
         """
         slider.setValue(500)
 
+    # -- controls panel float/dock ------------------------------------------
+
+    def _on_pin_toggled(self, checked: bool) -> None:
+        """Float or dock the controls panel in response to the pin button.
+
+        Args:
+            checked (bool): True to float the panel, False to dock it.
+        """
+        if checked:
+            self.float_panel()
+        else:
+            self.dock_panel()
+
+    def float_panel(self) -> None:
+        """Detach the controls panel into its own top-level window."""
+        if self._float_window is not None:
+            return
+        self._root_layout.removeWidget(self.controls)
+        float_window = _FloatingControlsWindow(self)
+        layout = QVBoxLayout(float_window)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.addWidget(self.controls)
+        self.controls.show()
+        self._float_window = float_window
+        top_left = self.mapToGlobal(QPoint(0, 0))
+        float_window.move(top_left.x() + 10, top_left.y() + 10)
+        float_window.resize(self.controls.sizeHint())
+        float_window.show()
+        self.pin_btn.setToolTip(lang.getstr("whitepoint.visual_editor.panel.dock"))
+
+    def dock_panel(self) -> None:
+        """Re-embed a floating controls panel back into the editor window."""
+        if self._float_window is None:
+            return
+        float_window = self._float_window
+        self._float_window = None
+        self.controls.setParent(None)
+        self._root_layout.insertWidget(0, self.controls, 0)
+        self.controls.show()
+        float_window.deleteLater()
+        self.pin_btn.blockSignals(True)
+        self.pin_btn.setChecked(False)
+        self.pin_btn.blockSignals(False)
+        self.pin_btn.setToolTip(lang.getstr("whitepoint.visual_editor.panel.float"))
+
     def apply_initial_whitepoint(self, r: int, g: int, b: int) -> None:
         """Seed the editor from a display profile's ``vcgt`` whitepoint.
 
@@ -1197,6 +1287,7 @@ def closeEvent(self, event: QCloseEvent) -> None:  # noqa: N802 (Qt override)
         Args:
             event (QCloseEvent): The Qt close event.
         """
+        self.dock_panel()
         self._save_cfg()
         if self._pm is not None:
             self._pm.restore_display_profiles(wrapup=True, wait=True)

tests/test_ui_main_window.py

@@ -1115,6 +1115,63 @@ def test_visual_whitepoint_editor_measure_btn_missing_argyll_reenables_button(
     assert editor.measure_btn.isEnabled() is True
 
 
+def test_visual_whitepoint_editor_pin_btn_floats_and_docks_controls_panel(window):
+    # Issue #901: wx's AUI-managed controls pane can be pinned/floated into
+    # its own draggable window; Qt has no AUI-docking equivalent, so the
+    # ported pin button instead detaches the panel into a plain top-level
+    # window and re-embeds it on toggle.
+    window._visual_whitepoint_editor_btn_handler()
+    editor = window._visual_whitepoint_editor_window
+    assert editor.controls.window() is editor
+    assert editor._float_window is None
+
+    editor.pin_btn.setChecked(True)
+    assert editor._float_window is not None
+    assert editor.controls.window() is editor._float_window
+    assert editor.pin_btn.toolTip() == lang.getstr(
+        "whitepoint.visual_editor.panel.dock"
+    )
+
+    editor.pin_btn.setChecked(False)
+    assert editor._float_window is None
+    assert editor.controls.window() is editor
+    assert editor.pin_btn.toolTip() == lang.getstr(
+        "whitepoint.visual_editor.panel.float"
+    )
+
+
+def test_visual_whitepoint_editor_float_window_close_docks_instead_of_destroying(
+    window,
+):
+    # wx's close_pane_handler vetoes the floating pane's close and docks it
+    # back instead of destroying it; the Qt port's _FloatingControlsWindow
+    # mirrors that via its own closeEvent override.
+    window._visual_whitepoint_editor_btn_handler()
+    editor = window._visual_whitepoint_editor_window
+    editor.float_panel()
+    float_window = editor._float_window
+    assert float_window is not None
+
+    float_window.close()
+
+    assert editor._float_window is None
+    assert editor.controls.window() is editor
+    assert editor.pin_btn.isChecked() is False
+
+
+def test_visual_whitepoint_editor_close_docks_floating_panel(window):
+    window._visual_whitepoint_editor_btn_handler()
+    editor = window._visual_whitepoint_editor_window
+    editor.float_panel()
+    assert editor._float_window is not None
+
+    editor.close()
+
+    assert editor._float_window is None
+    # Re-open so later tests in this module still find a live singleton.
+    window._visual_whitepoint_editor_window = None
+
+
 def test_visual_whitepoint_editor_measure_consumer_sets_colortemp_whitepoint(window):
     window._visual_whitepoint_editor_btn_handler()
     editor = window._visual_whitepoint_editor_window