orisys-app/apps/studio/tests/test_scene3d_pane_ui.py

"""The 3D pane's interface: a picture, one legend line, and a settings dialog.

The pane used to be half form fields, and that is what left the 3D view occupying a
corner of its own splitter slot. Everything configurable now lives in
``Scene3dSettingsDialog``; what stays under the picture is what *reading* it needs — the
colour ramp, the numbers it was drawn with, and which source produced the field.

These tests pin three things: the pane shows no settings, the dialog holds the **same**
control widgets the panel has always had (so the settings path did not fork), and the
view menu / the pane's header both reach that dialog.
"""

from __future__ import annotations

import pytest
from PyQt5.QtCore import pyqtSignal
from PyQt5.QtWidgets import QWidget

from orisys_app_shared.i18n import t
from orisys_studio.ui import icons


@pytest.fixture
def panel(qt_app):
    """A ``ThreeDPanel`` with the coordinator and widget it needs, and no scene."""
    from orisys_studio.scene3d.camera import OrbitCamera
    from orisys_studio.scene3d.coordinator import ThreeDCoordinator
    from orisys_studio.scene3d.gl_backend import GLRenderer
    from orisys_studio.scene3d.panel import ThreeDPanel
    from orisys_studio.scene3d.widget import Sensor3DWidget

    widget = Sensor3DWidget(GLRenderer(), OrbitCamera())
    coordinator = ThreeDCoordinator(widget, composer=object(), executor=None, max_fps=30)
    created = ThreeDPanel(coordinator, widget)
    yield created
    coordinator.close()
    created.deleteLater()


# --------------------------------------------------------------------- the pane


def test_the_pane_holds_a_legend_and_no_settings(qt_app, panel):
    """What is on the pane has to be readable, not adjustable."""
    # The readouts are part of the pane itself...
    assert panel.legend_label.parent() is panel
    assert panel.source_label.parent() is panel
    assert panel.scale_bar.parent() is panel
    # ...and every setting is in one block that the pane never shows.
    assert panel.controls_widget.parent() is panel
    assert not panel.controls_widget.isVisible()
    for control in (
        panel.enable_check,
        panel.preset_combo,
        panel.housing_check,
        panel.deform_check,
        panel.gain_spin,
        panel.scale_combo,
        panel.fps_combo,
        panel.reset_button,
    ):
        assert control.parent() is panel.controls_widget, control
    # The engineering counters went with the settings rather than under the picture.
    assert panel.stats_label.parent() is panel.controls_widget


def test_the_settings_dialog_hosts_the_panes_own_controls(qt_app, panel):
    """One set of widgets either way: the dialog moves them, it does not copy them."""
    from orisys_studio.scene3d.settings_dialog import Scene3dSettingsDialog

    dialog = Scene3dSettingsDialog(panel)
    try:
        assert panel.controls_widget.parent() is dialog, (
            "the dialog kept a second copy of the controls"
        )
        assert panel.controls_widget.isVisibleTo(dialog)
        assert not dialog.isModal(), "the pane has to stay visible while tuning it"
        assert dialog.windowTitle() == t("scene3d.settings_title")

        # ...and they still work from there: the signal path is the panel's own.
        seen: list[bool] = []
        panel.enabledChanged.connect(seen.append)
        panel.enable_check.setChecked(True)
        assert seen == [True], "a control in the dialog stopped reaching the view"

        # Closing hides it: the controls have to survive for the next time.
        dialog.close()
        assert not dialog.isVisible()
        assert panel.enable_check.text(), "closing the dialog destroyed its controls"
        assert panel.settings().max_fps == 30
    finally:
        dialog.deleteLater()


def test_the_pane_header_offers_the_two_actions(qt_app):
    """A gear and a view reset: the two things that belong to *looking*."""
    from orisys_studio.ui.mesh3d_panel import Mesh3dPanel

    pane = Mesh3dPanel(theme="dark")
    try:
        assert pane.btn_settings.toolTip() == t("panels.mesh3d_settings_tip")
        assert pane.btn_reset_view.toolTip() == t("panels.mesh3d_reset_tip")
        assert not pane.btn_settings.icon().isNull()
        assert not pane.btn_reset_view.icon().isNull()

        # A box sensor has no scene, so there is nothing to configure and the pane says
        # so instead of opening an empty dialog.
        pane.set_sensor("box")
        assert pane.open_settings() is False
        assert pane.view is None

        # Reset forwards to the view when there is one.
        class _View(QWidget):
            diagnosticRaised = pyqtSignal(object)
            enabledChanged = pyqtSignal(bool)

            def __init__(self) -> None:
                super().__init__()
                self.resets = 0
                self.available = True

            def set_source_kind(self, kind: str) -> None:
                self.source_kind = kind

            def set_enabled(self, enabled: bool) -> None:
                self.enabled = bool(enabled)

            def restore_settings(self, settings) -> None:
                self.settings_value = settings

            def reset_view(self) -> None:
                self.resets += 1

        view = _View()
        pane.attach_view(view)  # type: ignore[arg-type]
        pane.reset_view()
        assert view.resets == 1
    finally:
        pane.deleteLater()


def test_the_reset_view_icon_is_painted_from_the_theme():
    assert "reset_view" in icons.NAMES
    for theme in ("dark", "light"):
        assert not icons.icon("reset_view", theme).isNull()


# --------------------------------------------------------------------- the menu


def test_the_view_menu_opens_the_3d_settings(qt_app, make_window):
    """视图 ▸ 三维显示设置… is the way in that does not depend on the pane's header."""
    from PyQt5.QtWidgets import QApplication

    window = make_window(sensor_type="finger", show_finger_3d=True)
    window.show()
    QApplication.processEvents()
    try:
        assert window.act_scene3d_settings.text() == t("menu.scene3d_settings")
        assert window.act_scene3d_settings in window.view_menu.actions()

        view = window.mesh3d_panel.view
        if view is None or not view.available:
            # No GL here: the entry has to say why instead of doing nothing.
            window.act_scene3d_settings.trigger()
            QApplication.processEvents()
            assert window.statusBar().currentMessage().strip()
            return
        window.mesh3d_panel.ensure_view()
        window.act_scene3d_settings.trigger()
        QApplication.processEvents()
        dialog = window.mesh3d_panel.view.settings_dialog()
        assert dialog is not None and dialog.isVisible()
        dialog.hide()
    finally:
        window.close()