lsurf 1.0.0__py3-none-any.whl

lsurf/gui/views/scene_tree.py

@@ -0,0 +1,180 @@
+# The Clear BSD License
+#
+# Copyright (c) 2026 Tobias Heibges
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted (subject to the limitations in the disclaimer
+# below) provided that the following conditions are met:
+#
+#      * Redistributions of source code must retain the above copyright notice,
+#      this list of conditions and the following disclaimer.
+#
+#      * Redistributions in binary form must reproduce the above copyright
+#      notice, this list of conditions and the following disclaimer in the
+#      documentation and/or other materials provided with the distribution.
+#
+#      * Neither the name of the copyright holder nor the names of its
+#      contributors may be used to endorse or promote products derived from this
+#      software without specific prior written permission.
+#
+# NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY
+# THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+# CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+# BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+# IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+"""Scene tree panel - displays hierarchical view of scene objects.
+
+Shows surfaces, detectors, sources, and simulation results in a tree structure
+with visibility toggles and selection.
+"""
+
+from typing import TYPE_CHECKING
+
+import dearpygui.dearpygui as dpg
+
+if TYPE_CHECKING:
+    from ..core.scene import Scene, SceneObject
+
+
+class SceneTreePanel:
+    """Tree view panel showing scene object hierarchy."""
+
+    def __init__(self, scene: "Scene") -> None:
+        self.scene = scene
+        self._window_tag: int | None = None
+        self._tree_tag: int | None = None
+
+    def create(self, parent: int | str) -> int:
+        """Create the scene tree panel.
+
+        Args:
+            parent: Parent container tag
+
+        Returns:
+            The window tag
+        """
+        self._window_tag = parent
+
+        dpg.add_text("Scene", color=(200, 200, 200), parent=parent)
+        dpg.add_separator(parent=parent)
+
+        # Tree container
+        with dpg.group(tag="scene_tree_container", parent=parent):
+            self._rebuild_tree()
+
+        # Register scene change callback
+        self.scene.on_change(self._rebuild_tree)
+
+        return self._window_tag
+
+    def _rebuild_tree(self) -> None:
+        """Rebuild the tree structure from scene objects."""
+        container_tag = "scene_tree_container"
+
+        if not dpg.does_item_exist(container_tag):
+            return
+
+        # Clear existing tree
+        dpg.delete_item(container_tag, children_only=True)
+
+        # Group objects by type
+        from ..core.scene import ObjectType
+
+        type_labels = {
+            ObjectType.SURFACE: "Surfaces",
+            ObjectType.DETECTOR: "Detectors",
+            ObjectType.SOURCE: "Sources",
+            ObjectType.RAY_PATHS: "Ray Paths",
+            ObjectType.DETECTIONS: "Detections",
+        }
+
+        type_icons = {
+            ObjectType.SURFACE: "[S]",
+            ObjectType.DETECTOR: "[D]",
+            ObjectType.SOURCE: "[*]",
+            ObjectType.RAY_PATHS: "[~]",
+            ObjectType.DETECTIONS: "[.]",
+        }
+
+        for obj_type, label in type_labels.items():
+            objects = self.scene.get_objects_by_type(obj_type)
+            if not objects:
+                continue
+
+            # Create collapsible header for this type
+            with dpg.tree_node(
+                label=f"{label} ({len(objects)})",
+                default_open=True,
+                parent=container_tag,
+            ):
+                for obj in objects:
+                    self._create_object_row(obj, type_icons[obj_type])
+
+        # Show message if empty
+        if not self.scene.objects:
+            dpg.add_text(
+                "No objects",
+                color=(128, 128, 128),
+                parent=container_tag,
+            )
+            dpg.add_text(
+                "Load a config or",
+                color=(100, 100, 100),
+                parent=container_tag,
+            )
+            dpg.add_text(
+                "run a simulation",
+                color=(100, 100, 100),
+                parent=container_tag,
+            )
+
+    def _create_object_row(self, obj: "SceneObject", icon: str) -> None:
+        """Create a row for a single object."""
+
+        with dpg.group(horizontal=True):
+            # Visibility checkbox
+            dpg.add_checkbox(
+                default_value=obj.visible,
+                callback=lambda s, a, u: self._on_visibility_toggle(u),
+                user_data=obj.name,
+            )
+
+            # Object name (clickable for selection)
+            color = (255, 255, 100) if obj.selected else (200, 200, 200)
+            dpg.add_text(
+                f"{icon} {obj.name}",
+                color=color,
+            )
+
+            # Make the text selectable
+            if dpg.get_item_children(dpg.last_item()):
+                pass  # Text items don't have click handlers directly
+
+        # Add click handler by making it a selectable
+        dpg.add_selectable(
+            label=f"  {obj.name}",
+            default_value=obj.selected,
+            callback=lambda s, a, u: self._on_object_select(u),
+            user_data=obj.name,
+            indent=20,
+        )
+
+    def _on_visibility_toggle(self, name: str) -> None:
+        """Handle visibility checkbox toggle."""
+        self.scene.toggle_visibility(name)
+
+    def _on_object_select(self, name: str) -> None:
+        """Handle object selection."""
+        if self.scene.selected_object == name:
+            self.scene.select_object(None)  # Deselect if already selected
+        else:
+            self.scene.select_object(name)