scitex 2.4.3__py3-none-any.whl → 2.7.0__py3-none-any.whl

scitex/vis/editor/_dearpygui_editor.py

@@ -0,0 +1,1976 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: 2025-12-08
+# File: ./src/scitex/vis/editor/_dearpygui_editor.py
+"""DearPyGui-based figure editor with GPU-accelerated rendering."""
+
+from pathlib import Path
+from typing import Dict, Any, Optional
+import copy
+import io
+import base64
+
+
+def _create_checkerboard(width: int, height: int, square_size: int = 10) -> "Image":
+    """Create a checkerboard pattern image for transparency preview.
+
+    Parameters
+    ----------
+    width : int
+        Image width in pixels
+    height : int
+        Image height in pixels
+    square_size : int
+        Size of each checkerboard square (default: 10)
+
+    Returns
+    -------
+    PIL.Image
+        RGBA image with checkerboard pattern (light/dark gray)
+    """
+    from PIL import Image
+    import numpy as np
+
+    # Create checkerboard pattern
+    light_gray = (220, 220, 220, 255)
+    dark_gray = (180, 180, 180, 255)
+
+    # Create array
+    img_array = np.zeros((height, width, 4), dtype=np.uint8)
+
+    for y in range(height):
+        for x in range(width):
+            # Determine which square we're in
+            square_x = x // square_size
+            square_y = y // square_size
+            if (square_x + square_y) % 2 == 0:
+                img_array[y, x] = light_gray
+            else:
+                img_array[y, x] = dark_gray
+
+    return Image.fromarray(img_array, "RGBA")
+
+
+class DearPyGuiEditor:
+    """
+    GPU-accelerated figure editor using DearPyGui.
+
+    Features:
+    - Modern immediate-mode GUI with GPU acceleration
+    - Real-time figure preview
+    - Property editors with sliders, color pickers, and input fields
+    - Click-to-select traces on preview
+    - Save to .manual.json
+    - SciTeX style defaults pre-filled
+    - Dark/light theme support
+    """
+
+    def __init__(
+        self,
+        json_path: Path,
+        metadata: Dict[str, Any],
+        csv_data: Optional[Any] = None,
+        png_path: Optional[Path] = None,
+        manual_overrides: Optional[Dict[str, Any]] = None,
+    ):
+        self.json_path = Path(json_path)
+        self.metadata = metadata
+        self.csv_data = csv_data
+        self.png_path = Path(png_path) if png_path else None
+        self.manual_overrides = manual_overrides or {}
+
+        # Get SciTeX defaults and merge with metadata
+        from ._defaults import get_scitex_defaults, extract_defaults_from_metadata
+
+        self.scitex_defaults = get_scitex_defaults()
+        self.metadata_defaults = extract_defaults_from_metadata(metadata)
+
+        # Start with defaults, then overlay manual overrides
+        self.current_overrides = copy.deepcopy(self.scitex_defaults)
+        self.current_overrides.update(self.metadata_defaults)
+        self.current_overrides.update(self.manual_overrides)
+
+        # Track modifications
+        self._initial_overrides = copy.deepcopy(self.current_overrides)
+        self._user_modified = False
+        self._texture_id = None
+
+        # Click-to-select state
+        self._selected_element = None  # {'type': 'trace'|'title'|'xlabel'|'ylabel'|'legend'|'xaxis'|'yaxis', 'index': int|None}
+        self._selected_trace_index = None  # Legacy compat
+        self._preview_bounds = (
+            None  # (x_offset, y_offset, width, height) of figure in preview
+        )
+        self._axes_transform = None  # Transform info for data coordinates
+        self._element_bboxes = {}  # Store bboxes for all selectable elements
+
+        # Hover state
+        self._hovered_element = None  # Element currently being hovered
+        self._last_hover_check = 0  # For throttling hover updates
+        self._backend_name = "dearpygui"  # Backend name for title
+
+        # Cached rendering for fast hover response
+        self._cached_base_image = None  # PIL Image of base figure (no highlights)
+        self._cached_base_data = None  # Flattened RGBA data for DearPyGui
+        self._cache_dirty = True  # Flag to indicate cache needs rebuild
+
+    def run(self):
+        """Launch the DearPyGui editor."""
+        try:
+            import dearpygui.dearpygui as dpg
+        except ImportError:
+            raise ImportError(
+                "DearPyGui is required for this editor. "
+                "Install with: pip install dearpygui"
+            )
+
+        dpg.create_context()
+
+        # Configure viewport
+        dpg.create_viewport(
+            title=f"SciTeX Editor ({self._backend_name}) - {self.json_path.name}",
+            width=1400,
+            height=900,
+        )
+
+        # Create texture registry for image preview
+        with dpg.texture_registry(show=False):
+            # Create initial texture with placeholder
+            width, height = 800, 600
+            texture_data = [0.2, 0.2, 0.2, 1.0] * (width * height)
+            self._texture_id = dpg.add_dynamic_texture(
+                width=width,
+                height=height,
+                default_value=texture_data,
+                tag="preview_texture",
+            )
+
+        # Create main window
+        with dpg.window(label="SciTeX Figure Editor", tag="main_window"):
+            with dpg.group(horizontal=True):
+                # Left panel: Preview
+                self._create_preview_panel(dpg)
+
+                # Right panel: Controls
+                self._create_control_panel(dpg)
+
+        # Set main window as primary
+        dpg.set_primary_window("main_window", True)
+
+        # Initial render
+        self._update_preview(dpg)
+
+        # Setup and show
+        dpg.setup_dearpygui()
+        dpg.show_viewport()
+        dpg.start_dearpygui()
+        dpg.destroy_context()
+
+    def _create_preview_panel(self, dpg):
+        """Create the preview panel with figure image, click handler, and hover detection."""
+        with dpg.child_window(width=900, height=-1, tag="preview_panel"):
+            dpg.add_text(
+                "Figure Preview (click to select, hover to highlight)",
+                color=(100, 200, 100),
+            )
+            dpg.add_separator()
+
+            # Image display with click and move handlers
+            with dpg.handler_registry(tag="preview_handler"):
+                dpg.add_mouse_click_handler(callback=self._on_preview_click)
+                dpg.add_mouse_move_handler(callback=self._on_preview_hover)
+
+            dpg.add_image("preview_texture", tag="preview_image")
+
+            dpg.add_separator()
+            dpg.add_text("", tag="hover_text", color=(150, 200, 150))
+            dpg.add_text("", tag="status_text", color=(150, 150, 150))
+            dpg.add_text("", tag="selection_text", color=(200, 200, 100))
+
+    def _create_control_panel(self, dpg):
+        """Create the control panel with all editing options."""
+        with dpg.child_window(width=-1, height=-1, tag="control_panel"):
+            dpg.add_text("Properties", color=(100, 200, 100))
+            dpg.add_separator()
+
+            # Labels Section
+            with dpg.collapsing_header(label="Labels", default_open=True):
+                dpg.add_input_text(
+                    label="Title",
+                    default_value=self.current_overrides.get("title", ""),
+                    tag="title_input",
+                    callback=self._on_value_change,
+                    on_enter=True,
+                    width=250,
+                )
+                dpg.add_input_text(
+                    label="X Label",
+                    default_value=self.current_overrides.get("xlabel", ""),
+                    tag="xlabel_input",
+                    callback=self._on_value_change,
+                    on_enter=True,
+                    width=250,
+                )
+                dpg.add_input_text(
+                    label="Y Label",
+                    default_value=self.current_overrides.get("ylabel", ""),
+                    tag="ylabel_input",
+                    callback=self._on_value_change,
+                    on_enter=True,
+                    width=250,
+                )
+
+            # Axis Limits Section
+            with dpg.collapsing_header(label="Axis Limits", default_open=False):
+                with dpg.group(horizontal=True):
+                    xlim = self.current_overrides.get("xlim", [0, 1])
+                    dpg.add_input_float(
+                        label="X Min",
+                        default_value=xlim[0] if xlim else 0,
+                        tag="xmin_input",
+                        width=100,
+                    )
+                    dpg.add_input_float(
+                        label="X Max",
+                        default_value=xlim[1] if xlim else 1,
+                        tag="xmax_input",
+                        width=100,
+                    )
+                with dpg.group(horizontal=True):
+                    ylim = self.current_overrides.get("ylim", [0, 1])
+                    dpg.add_input_float(
+                        label="Y Min",
+                        default_value=ylim[0] if ylim else 0,
+                        tag="ymin_input",
+                        width=100,
+                    )
+                    dpg.add_input_float(
+                        label="Y Max",
+                        default_value=ylim[1] if ylim else 1,
+                        tag="ymax_input",
+                        width=100,
+                    )
+                dpg.add_button(
+                    label="Apply Limits",
+                    callback=self._apply_limits,
+                    width=150,
+                )
+
+            # Line Style Section
+            with dpg.collapsing_header(label="Line Style", default_open=True):
+                dpg.add_slider_float(
+                    label="Line Width (pt)",
+                    default_value=self.current_overrides.get("linewidth", 1.0),
+                    min_value=0.1,
+                    max_value=5.0,
+                    tag="linewidth_slider",
+                    callback=self._on_value_change,
+                    width=200,
+                )
+
+            # Font Settings Section
+            with dpg.collapsing_header(label="Font Settings", default_open=False):
+                dpg.add_slider_int(
+                    label="Title Font Size",
+                    default_value=self.current_overrides.get("title_fontsize", 8),
+                    min_value=6,
+                    max_value=20,
+                    tag="title_fontsize_slider",
+                    callback=self._on_value_change,
+                    width=200,
+                )
+                dpg.add_slider_int(
+                    label="Axis Font Size",
+                    default_value=self.current_overrides.get("axis_fontsize", 7),
+                    min_value=6,
+                    max_value=16,
+                    tag="axis_fontsize_slider",
+                    callback=self._on_value_change,
+                    width=200,
+                )
+                dpg.add_slider_int(
+                    label="Tick Font Size",
+                    default_value=self.current_overrides.get("tick_fontsize", 7),
+                    min_value=6,
+                    max_value=16,
+                    tag="tick_fontsize_slider",
+                    callback=self._on_value_change,
+                    width=200,
+                )
+                dpg.add_slider_int(
+                    label="Legend Font Size",
+                    default_value=self.current_overrides.get("legend_fontsize", 6),
+                    min_value=4,
+                    max_value=14,
+                    tag="legend_fontsize_slider",
+                    callback=self._on_value_change,
+                    width=200,
+                )
+
+            # Tick Settings Section
+            with dpg.collapsing_header(label="Tick Settings", default_open=False):
+                dpg.add_slider_int(
+                    label="N Ticks",
+                    default_value=self.current_overrides.get("n_ticks", 4),
+                    min_value=2,
+                    max_value=10,
+                    tag="n_ticks_slider",
+                    callback=self._on_value_change,
+                    width=200,
+                )
+                dpg.add_slider_float(
+                    label="Tick Length (mm)",
+                    default_value=self.current_overrides.get("tick_length", 0.8),
+                    min_value=0.2,
+                    max_value=3.0,
+                    tag="tick_length_slider",
+                    callback=self._on_value_change,
+                    width=200,
+                )
+                dpg.add_slider_float(
+                    label="Tick Width (mm)",
+                    default_value=self.current_overrides.get("tick_width", 0.2),
+                    min_value=0.05,
+                    max_value=1.0,
+                    tag="tick_width_slider",
+                    callback=self._on_value_change,
+                    width=200,
+                )
+                dpg.add_combo(
+                    label="Tick Direction",
+                    items=["out", "in", "inout"],
+                    default_value=self.current_overrides.get("tick_direction", "out"),
+                    tag="tick_direction_combo",
+                    callback=self._on_value_change,
+                    width=150,
+                )
+
+            # Style Section
+            with dpg.collapsing_header(label="Style", default_open=True):
+                dpg.add_checkbox(
+                    label="Show Grid",
+                    default_value=self.current_overrides.get("grid", False),
+                    tag="grid_checkbox",
+                    callback=self._on_value_change,
+                )
+                dpg.add_checkbox(
+                    label="Hide Top Spine",
+                    default_value=self.current_overrides.get("hide_top_spine", True),
+                    tag="hide_top_spine_checkbox",
+                    callback=self._on_value_change,
+                )
+                dpg.add_checkbox(
+                    label="Hide Right Spine",
+                    default_value=self.current_overrides.get("hide_right_spine", True),
+                    tag="hide_right_spine_checkbox",
+                    callback=self._on_value_change,
+                )
+                dpg.add_checkbox(
+                    label="Transparent Background",
+                    default_value=self.current_overrides.get("transparent", True),
+                    tag="transparent_checkbox",
+                    callback=self._on_value_change,
+                )
+                dpg.add_slider_float(
+                    label="Axis Width (mm)",
+                    default_value=self.current_overrides.get("axis_width", 0.2),
+                    min_value=0.05,
+                    max_value=1.0,
+                    tag="axis_width_slider",
+                    callback=self._on_value_change,
+                    width=200,
+                )
+
+            # Legend Section
+            with dpg.collapsing_header(label="Legend", default_open=False):
+                dpg.add_checkbox(
+                    label="Show Legend",
+                    default_value=self.current_overrides.get("legend_visible", True),
+                    tag="legend_visible_checkbox",
+                    callback=self._on_value_change,
+                )
+                dpg.add_checkbox(
+                    label="Show Frame",
+                    default_value=self.current_overrides.get("legend_frameon", False),
+                    tag="legend_frameon_checkbox",
+                    callback=self._on_value_change,
+                )
+                dpg.add_combo(
+                    label="Position",
+                    items=[
+                        "best",
+                        "upper right",
+                        "upper left",
+                        "lower right",
+                        "lower left",
+                        "center right",
+                        "center left",
+                        "upper center",
+                        "lower center",
+                        "center",
+                    ],
+                    default_value=self.current_overrides.get("legend_loc", "best"),
+                    tag="legend_loc_combo",
+                    callback=self._on_value_change,
+                    width=150,
+                )
+
+            # Selected Element Section (click on preview to select)
+            with dpg.collapsing_header(
+                label="Selected Element",
+                default_open=True,
+                tag="selected_element_header",
+            ):
+                dpg.add_text(
+                    "Click on preview to select elements",
+                    tag="element_hint_text",
+                    color=(150, 150, 150),
+                )
+                dpg.add_combo(
+                    label="Element",
+                    items=self._get_all_element_labels(),
+                    tag="element_selector_combo",
+                    callback=self._on_element_selected,
+                    width=200,
+                )
+                dpg.add_separator()
+
+                # Trace-specific controls (shown when trace selected)
+                with dpg.group(tag="trace_controls_group", show=False):
+                    dpg.add_input_text(
+                        label="Label",
+                        tag="trace_label_input",
+                        callback=self._on_trace_property_change,
+                        on_enter=True,
+                        width=200,
+                    )
+                    dpg.add_color_edit(
+                        label="Color",
+                        tag="trace_color_picker",
+                        callback=self._on_trace_property_change,
+                        no_alpha=True,
+                        width=200,
+                    )
+                    dpg.add_slider_float(
+                        label="Line Width",
+                        tag="trace_linewidth_slider",
+                        default_value=1.0,
+                        min_value=0.1,
+                        max_value=5.0,
+                        callback=self._on_trace_property_change,
+                        width=200,
+                    )
+                    dpg.add_combo(
+                        label="Line Style",
+                        items=["-", "--", "-.", ":", ""],
+                        default_value="-",
+                        tag="trace_linestyle_combo",
+                        callback=self._on_trace_property_change,
+                        width=100,
+                    )
+                    dpg.add_combo(
+                        label="Marker",
+                        items=["", "o", "s", "^", "v", "D", "x", "+", "*"],
+                        default_value="",
+                        tag="trace_marker_combo",
+                        callback=self._on_trace_property_change,
+                        width=100,
+                    )
+                    dpg.add_slider_float(
+                        label="Marker Size",
+                        tag="trace_markersize_slider",
+                        default_value=6.0,
+                        min_value=1.0,
+                        max_value=20.0,
+                        callback=self._on_trace_property_change,
+                        width=200,
+                    )
+
+                # Text element controls (title, xlabel, ylabel)
+                with dpg.group(tag="text_controls_group", show=False):
+                    dpg.add_input_text(
+                        label="Text",
+                        tag="element_text_input",
+                        callback=self._on_text_element_change,
+                        on_enter=True,
+                        width=200,
+                    )
+                    dpg.add_slider_int(
+                        label="Font Size",
+                        tag="element_fontsize_slider",
+                        default_value=8,
+                        min_value=4,
+                        max_value=24,
+                        callback=self._on_text_element_change,
+                        width=200,
+                    )
+                    dpg.add_color_edit(
+                        label="Color",
+                        tag="element_text_color",
+                        callback=self._on_text_element_change,
+                        no_alpha=True,
+                        default_value=[0, 0, 0],
+                        width=200,
+                    )
+
+                # Axis element controls (xaxis, yaxis)
+                with dpg.group(tag="axis_controls_group", show=False):
+                    dpg.add_slider_float(
+                        label="Line Width (mm)",
+                        tag="axis_linewidth_slider",
+                        default_value=0.2,
+                        min_value=0.05,
+                        max_value=1.0,
+                        callback=self._on_axis_element_change,
+                        width=200,
+                    )
+                    dpg.add_slider_float(
+                        label="Tick Length (mm)",
+                        tag="axis_tick_length_slider",
+                        default_value=0.8,
+                        min_value=0.2,
+                        max_value=3.0,
+                        callback=self._on_axis_element_change,
+                        width=200,
+                    )
+                    dpg.add_slider_int(
+                        label="Tick Font Size",
+                        tag="axis_tick_fontsize_slider",
+                        default_value=7,
+                        min_value=4,
+                        max_value=16,
+                        callback=self._on_axis_element_change,
+                        width=200,
+                    )
+                    dpg.add_checkbox(
+                        label="Show Spine",
+                        tag="axis_show_spine_checkbox",
+                        default_value=True,
+                        callback=self._on_axis_element_change,
+                    )
+
+                # Legend controls
+                with dpg.group(tag="legend_controls_group", show=False):
+                    dpg.add_checkbox(
+                        label="Visible",
+                        tag="legend_visible_edit",
+                        default_value=True,
+                        callback=self._on_legend_element_change,
+                    )
+                    dpg.add_checkbox(
+                        label="Show Frame",
+                        tag="legend_frameon_edit",
+                        default_value=False,
+                        callback=self._on_legend_element_change,
+                    )
+                    dpg.add_combo(
+                        label="Position",
+                        items=[
+                            "best",
+                            "upper right",
+                            "upper left",
+                            "lower right",
+                            "lower left",
+                            "center right",
+                            "center left",
+                            "upper center",
+                            "lower center",
+                            "center",
+                        ],
+                        default_value="best",
+                        tag="legend_loc_edit",
+                        callback=self._on_legend_element_change,
+                        width=150,
+                    )
+                    dpg.add_slider_int(
+                        label="Font Size",
+                        tag="legend_fontsize_edit",
+                        default_value=6,
+                        min_value=4,
+                        max_value=14,
+                        callback=self._on_legend_element_change,
+                        width=200,
+                    )
+
+                dpg.add_button(
+                    label="Deselect",
+                    callback=self._deselect_element,
+                    width=100,
+                )
+
+            # Dimensions Section
+            with dpg.collapsing_header(label="Dimensions", default_open=False):
+                fig_size = self.current_overrides.get("fig_size", [3.15, 2.68])
+                with dpg.group(horizontal=True):
+                    dpg.add_input_float(
+                        label="Width (in)",
+                        default_value=fig_size[0],
+                        tag="fig_width_input",
+                        width=100,
+                    )
+                    dpg.add_input_float(
+                        label="Height (in)",
+                        default_value=fig_size[1],
+                        tag="fig_height_input",
+                        width=100,
+                    )
+                dpg.add_slider_int(
+                    label="DPI",
+                    default_value=self.current_overrides.get("dpi", 300),
+                    min_value=72,
+                    max_value=600,
+                    tag="dpi_slider",
+                    callback=self._on_value_change,
+                    width=200,
+                )
+
+            # Annotations Section
+            with dpg.collapsing_header(label="Annotations", default_open=False):
+                dpg.add_input_text(
+                    label="Text",
+                    tag="annot_text_input",
+                    width=200,
+                )
+                with dpg.group(horizontal=True):
+                    dpg.add_input_float(
+                        label="X",
+                        default_value=0.5,
+                        tag="annot_x_input",
+                        width=80,
+                    )
+                    dpg.add_input_float(
+                        label="Y",
+                        default_value=0.5,
+                        tag="annot_y_input",
+                        width=80,
+                    )
+                dpg.add_button(
+                    label="Add Annotation",
+                    callback=self._add_annotation,
+                    width=150,
+                )
+                dpg.add_listbox(
+                    label="",
+                    items=[],
+                    tag="annotations_listbox",
+                    num_items=4,
+                    width=250,
+                )
+                dpg.add_button(
+                    label="Remove Selected",
+                    callback=self._remove_annotation,
+                    width=150,
+                )
+
+            dpg.add_separator()
+
+            # Action buttons
+            dpg.add_button(
+                label="Update Preview",
+                callback=lambda: self._update_preview(dpg),
+                width=-1,
+            )
+            dpg.add_button(
+                label="Save to .manual.json",
+                callback=self._save_manual,
+                width=-1,
+            )
+            dpg.add_button(
+                label="Reset to Original",
+                callback=self._reset_overrides,
+                width=-1,
+            )
+            dpg.add_button(
+                label="Export PNG",
+                callback=self._export_png,
+                width=-1,
+            )
+
+    def _on_value_change(self, sender, app_data, user_data=None):
+        """Handle value changes from widgets."""
+        import dearpygui.dearpygui as dpg
+
+        self._user_modified = True
+        self._collect_overrides(dpg)
+        self._update_preview(dpg)
+
+    def _collect_overrides(self, dpg):
+        """Collect current values from all widgets."""
+        # Labels
+        self.current_overrides["title"] = dpg.get_value("title_input")
+        self.current_overrides["xlabel"] = dpg.get_value("xlabel_input")
+        self.current_overrides["ylabel"] = dpg.get_value("ylabel_input")
+
+        # Line style
+        self.current_overrides["linewidth"] = dpg.get_value("linewidth_slider")
+
+        # Font settings
+        self.current_overrides["title_fontsize"] = dpg.get_value(
+            "title_fontsize_slider"
+        )
+        self.current_overrides["axis_fontsize"] = dpg.get_value("axis_fontsize_slider")
+        self.current_overrides["tick_fontsize"] = dpg.get_value("tick_fontsize_slider")
+        self.current_overrides["legend_fontsize"] = dpg.get_value(
+            "legend_fontsize_slider"
+        )
+
+        # Tick settings
+        self.current_overrides["n_ticks"] = dpg.get_value("n_ticks_slider")
+        self.current_overrides["tick_length"] = dpg.get_value("tick_length_slider")
+        self.current_overrides["tick_width"] = dpg.get_value("tick_width_slider")
+        self.current_overrides["tick_direction"] = dpg.get_value("tick_direction_combo")
+
+        # Style
+        self.current_overrides["grid"] = dpg.get_value("grid_checkbox")
+        self.current_overrides["hide_top_spine"] = dpg.get_value(
+            "hide_top_spine_checkbox"
+        )
+        self.current_overrides["hide_right_spine"] = dpg.get_value(
+            "hide_right_spine_checkbox"
+        )
+        self.current_overrides["transparent"] = dpg.get_value("transparent_checkbox")
+        self.current_overrides["axis_width"] = dpg.get_value("axis_width_slider")
+
+        # Legend
+        self.current_overrides["legend_visible"] = dpg.get_value(
+            "legend_visible_checkbox"
+        )
+        self.current_overrides["legend_frameon"] = dpg.get_value(
+            "legend_frameon_checkbox"
+        )
+        self.current_overrides["legend_loc"] = dpg.get_value("legend_loc_combo")
+
+        # Dimensions
+        self.current_overrides["fig_size"] = [
+            dpg.get_value("fig_width_input"),
+            dpg.get_value("fig_height_input"),
+        ]
+        self.current_overrides["dpi"] = dpg.get_value("dpi_slider")
+
+    def _apply_limits(self, sender=None, app_data=None, user_data=None):
+        """Apply axis limits."""
+        import dearpygui.dearpygui as dpg
+
+        xmin = dpg.get_value("xmin_input")
+        xmax = dpg.get_value("xmax_input")
+        ymin = dpg.get_value("ymin_input")
+        ymax = dpg.get_value("ymax_input")
+
+        if xmin < xmax:
+            self.current_overrides["xlim"] = [xmin, xmax]
+        if ymin < ymax:
+            self.current_overrides["ylim"] = [ymin, ymax]
+
+        self._user_modified = True
+        self._update_preview(dpg)
+
+    def _add_annotation(self, sender=None, app_data=None, user_data=None):
+        """Add text annotation."""
+        import dearpygui.dearpygui as dpg
+
+        text = dpg.get_value("annot_text_input")
+        if not text:
+            return
+
+        x = dpg.get_value("annot_x_input")
+        y = dpg.get_value("annot_y_input")
+
+        if "annotations" not in self.current_overrides:
+            self.current_overrides["annotations"] = []
+
+        self.current_overrides["annotations"].append(
+            {
+                "type": "text",
+                "text": text,
+                "x": x,
+                "y": y,
+                "fontsize": self.current_overrides.get("axis_fontsize", 7),
+            }
+        )
+
+        dpg.set_value("annot_text_input", "")
+        self._update_annotations_list(dpg)
+        self._user_modified = True
+        self._update_preview(dpg)
+
+    def _remove_annotation(self, sender=None, app_data=None, user_data=None):
+        """Remove selected annotation."""
+        import dearpygui.dearpygui as dpg
+
+        selected = dpg.get_value("annotations_listbox")
+        annotations = self.current_overrides.get("annotations", [])
+
+        if selected and annotations:
+            # Find index by text
+            for i, ann in enumerate(annotations):
+                label = f"{ann.get('text', '')[:20]} ({ann.get('x', 0):.2f}, {ann.get('y', 0):.2f})"
+                if label == selected:
+                    del annotations[i]
+                    break
+
+            self._update_annotations_list(dpg)
+            self._user_modified = True
+            self._update_preview(dpg)
+
+    def _update_annotations_list(self, dpg):
+        """Update the annotations listbox."""
+        annotations = self.current_overrides.get("annotations", [])
+        items = []
+        for ann in annotations:
+            if ann.get("type") == "text":
+                label = f"{ann.get('text', '')[:20]} ({ann.get('x', 0):.2f}, {ann.get('y', 0):.2f})"
+                items.append(label)
+
+        dpg.configure_item("annotations_listbox", items=items)
+
+    def _update_preview(self, dpg):
+        """Update the figure preview (full re-render)."""
+        try:
+            # Mark cache dirty and do full render
+            self._cache_dirty = True
+            img_data, width, height = self._render_figure()
+
+            # Update texture
+            dpg.set_value("preview_texture", img_data)
+
+            # Update status
+            dpg.set_value("status_text", f"Preview updated ({width}x{height})")
+
+        except Exception as e:
+            dpg.set_value("status_text", f"Error: {str(e)}")
+
+    def _update_hover_overlay(self, dpg):
+        """Fast hover overlay update using cached base image (no matplotlib re-render)."""
+        import numpy as np
+        from PIL import Image, ImageDraw
+
+        # If no cached base, do full render
+        if self._cached_base_image is None:
+            self._update_preview(dpg)
+            return
+
+        try:
+            # Start with a copy of cached base
+            img = self._cached_base_image.copy()
+            draw = ImageDraw.Draw(img, "RGBA")
+
+            # Get hover element type
+            hovered_type = (
+                self._hovered_element.get("type") if self._hovered_element else None
+            )
+            selected_type = (
+                self._selected_element.get("type") if self._selected_element else None
+            )
+
+            # Draw hover highlight (outline only, no fill) for non-trace elements
+            if (
+                hovered_type
+                and hovered_type != "trace"
+                and hovered_type != selected_type
+            ):
+                bbox = self._element_bboxes.get(hovered_type)
+                if bbox:
+                    x0, y0, x1, y1 = bbox
+                    # Transparent outline only - no fill to avoid covering content
+                    draw.rectangle(
+                        [x0 - 2, y0 - 2, x1 + 2, y1 + 2],
+                        fill=None,
+                        outline=(100, 180, 255, 100),
+                        width=1,
+                    )
+
+            # Draw selection highlight (outline only, no fill) for non-trace elements
+            if selected_type and selected_type != "trace":
+                bbox = self._element_bboxes.get(selected_type)
+                if bbox:
+                    x0, y0, x1, y1 = bbox
+                    # Transparent outline only - no fill to avoid covering content
+                    draw.rectangle(
+                        [x0 - 2, y0 - 2, x1 + 2, y1 + 2],
+                        fill=None,
+                        outline=(255, 200, 80, 150),
+                        width=2,
+                    )
+
+            # Convert to DearPyGui texture format
+            img_array = np.array(img).astype(np.float32) / 255.0
+            img_data = img_array.flatten().tolist()
+
+            # Update texture
+            dpg.set_value("preview_texture", img_data)
+
+        except Exception as e:
+            # Fallback to full render on error
+            self._update_preview(dpg)
+
+    def _render_figure(self):
+        """Render figure and return as RGBA data for texture."""
+        import matplotlib
+
+        matplotlib.use("Agg")
+        import matplotlib.pyplot as plt
+        from matplotlib.ticker import MaxNLocator
+        import numpy as np
+        from PIL import Image
+        import dearpygui.dearpygui as dpg
+
+        # mm to pt conversion
+        mm_to_pt = 2.83465
+
+        o = self.current_overrides
+
+        # Dimensions - use fixed size for preview
+        preview_dpi = 100
+        fig_size = o.get("fig_size", [3.15, 2.68])
+
+        # Create figure with white background for preview
+        fig, ax = plt.subplots(figsize=fig_size, dpi=preview_dpi)
+
+        # For preview, use white background (transparent doesn't show well in GUI)
+        fig.patch.set_facecolor("white")
+        ax.patch.set_facecolor("white")
+
+        # Plot from CSV data (only pass selection, hover is via PIL overlay for speed)
+        if self.csv_data is not None:
+            self._plot_from_csv(ax, o, highlight_trace=self._selected_trace_index)
+        else:
+            ax.text(
+                0.5,
+                0.5,
+                "No plot data available\n(CSV not found)",
+                ha="center",
+                va="center",
+                transform=ax.transAxes,
+                fontsize=o.get("axis_fontsize", 7),
+            )
+
+        # Apply labels
+        if o.get("title"):
+            ax.set_title(o["title"], fontsize=o.get("title_fontsize", 8))
+        if o.get("xlabel"):
+            ax.set_xlabel(o["xlabel"], fontsize=o.get("axis_fontsize", 7))
+        if o.get("ylabel"):
+            ax.set_ylabel(o["ylabel"], fontsize=o.get("axis_fontsize", 7))
+
+        # Tick styling
+        ax.tick_params(
+            axis="both",
+            labelsize=o.get("tick_fontsize", 7),
+            length=o.get("tick_length", 0.8) * mm_to_pt,
+            width=o.get("tick_width", 0.2) * mm_to_pt,
+            direction=o.get("tick_direction", "out"),
+        )
+
+        # Number of ticks
+        ax.xaxis.set_major_locator(MaxNLocator(nbins=o.get("n_ticks", 4)))
+        ax.yaxis.set_major_locator(MaxNLocator(nbins=o.get("n_ticks", 4)))
+
+        # Grid
+        if o.get("grid"):
+            ax.grid(True, linewidth=o.get("axis_width", 0.2) * mm_to_pt, alpha=0.3)
+
+        # Axis limits
+        if o.get("xlim"):
+            ax.set_xlim(o["xlim"])
+        if o.get("ylim"):
+            ax.set_ylim(o["ylim"])
+
+        # Spines
+        if o.get("hide_top_spine", True):
+            ax.spines["top"].set_visible(False)
+        if o.get("hide_right_spine", True):
+            ax.spines["right"].set_visible(False)
+
+        for spine in ax.spines.values():
+            spine.set_linewidth(o.get("axis_width", 0.2) * mm_to_pt)
+
+        # Annotations
+        for annot in o.get("annotations", []):
+            if annot.get("type") == "text":
+                ax.text(
+                    annot.get("x", 0.5),
+                    annot.get("y", 0.5),
+                    annot.get("text", ""),
+                    transform=ax.transAxes,
+                    fontsize=annot.get("fontsize", o.get("axis_fontsize", 7)),
+                )
+
+        fig.tight_layout()
+
+        # Draw before collecting bboxes so we have accurate positions
+        fig.canvas.draw()
+
+        # Draw hover/selection highlights for non-trace elements
+        self._draw_element_highlights(fig, ax)
+
+        # Store axes transform info for click-to-select
+        fig.canvas.draw()
+        ax_bbox = ax.get_position()
+        fig_width_px = int(fig_size[0] * preview_dpi)
+        fig_height_px = int(fig_size[1] * preview_dpi)
+
+        # Collect element bboxes for click detection (in figure pixel coordinates)
+        # We'll scale these later after resize
+        self._element_bboxes_raw = {}
+
+        # Title bbox
+        if ax.title.get_text():
+            try:
+                title_bbox = ax.title.get_window_extent(fig.canvas.get_renderer())
+                self._element_bboxes_raw["title"] = (
+                    title_bbox.x0,
+                    title_bbox.y0,
+                    title_bbox.x1,
+                    title_bbox.y1,
+                )
+            except Exception:
+                pass
+
+        # X label bbox
+        if ax.xaxis.label.get_text():
+            try:
+                xlabel_bbox = ax.xaxis.label.get_window_extent(
+                    fig.canvas.get_renderer()
+                )
+                self._element_bboxes_raw["xlabel"] = (
+                    xlabel_bbox.x0,
+                    xlabel_bbox.y0,
+                    xlabel_bbox.x1,
+                    xlabel_bbox.y1,
+                )
+            except Exception:
+                pass
+
+        # Y label bbox
+        if ax.yaxis.label.get_text():
+            try:
+                ylabel_bbox = ax.yaxis.label.get_window_extent(
+                    fig.canvas.get_renderer()
+                )
+                self._element_bboxes_raw["ylabel"] = (
+                    ylabel_bbox.x0,
+                    ylabel_bbox.y0,
+                    ylabel_bbox.x1,
+                    ylabel_bbox.y1,
+                )
+            except Exception:
+                pass
+
+        # Legend bbox
+        legend = ax.get_legend()
+        if legend:
+            try:
+                legend_bbox = legend.get_window_extent(fig.canvas.get_renderer())
+                self._element_bboxes_raw["legend"] = (
+                    legend_bbox.x0,
+                    legend_bbox.y0,
+                    legend_bbox.x1,
+                    legend_bbox.y1,
+                )
+            except Exception:
+                pass
+
+        # X axis (bottom spine area)
+        try:
+            xaxis_bbox = ax.spines["bottom"].get_window_extent(
+                fig.canvas.get_renderer()
+            )
+            # Expand bbox slightly for easier clicking
+            self._element_bboxes_raw["xaxis"] = (
+                xaxis_bbox.x0,
+                xaxis_bbox.y0 - 20,
+                xaxis_bbox.x1,
+                xaxis_bbox.y1 + 10,
+            )
+        except Exception:
+            pass
+
+        # Y axis (left spine area)
+        try:
+            yaxis_bbox = ax.spines["left"].get_window_extent(fig.canvas.get_renderer())
+            # Expand bbox slightly for easier clicking
+            self._element_bboxes_raw["yaxis"] = (
+                yaxis_bbox.x0 - 20,
+                yaxis_bbox.y0,
+                yaxis_bbox.x1 + 10,
+                yaxis_bbox.y1,
+            )
+        except Exception:
+            pass
+
+        # Convert to RGBA data for DearPyGui texture
+        buf = io.BytesIO()
+        fig.savefig(
+            buf,
+            format="png",
+            dpi=preview_dpi,
+            bbox_inches="tight",
+            facecolor="white",
+            edgecolor="none",
+        )
+        buf.seek(0)
+
+        # Load with PIL and convert to normalized RGBA
+        img = Image.open(buf).convert("RGBA")
+        width, height = img.size
+
+        # Resize to fit within max preview size while preserving aspect ratio
+        max_width, max_height = 800, 600
+        ratio = min(max_width / width, max_height / height)
+        new_width = int(width * ratio)
+        new_height = int(height * ratio)
+        img = img.resize((new_width, new_height), Image.LANCZOS)
+
+        # Store preview bounds for coordinate conversion (after resize)
+        x_offset = (max_width - new_width) // 2
+        y_offset = (max_height - new_height) // 2
+        self._preview_bounds = (x_offset, y_offset, new_width, new_height)
+
+        # Scale element bboxes to preview coordinates
+        # Note: matplotlib uses bottom-left origin, we need top-left for preview
+        self._element_bboxes = {}
+        for elem_type, raw_bbox in getattr(self, "_element_bboxes_raw", {}).items():
+            if raw_bbox is None:
+                continue
+            rx0, ry0, rx1, ry1 = raw_bbox
+            # Scale to resized image
+            sx0 = int(rx0 * ratio) + x_offset
+            sx1 = int(rx1 * ratio) + x_offset
+            # Flip Y coordinate (matplotlib origin is bottom, preview is top)
+            sy0 = new_height - int(ry1 * ratio) + y_offset
+            sy1 = new_height - int(ry0 * ratio) + y_offset
+            self._element_bboxes[elem_type] = (sx0, sy0, sx1, sy1)
+
+        # Store axes transform info (scaled to resized image)
+        # ax_bbox is in figure fraction coordinates
+        ax_x0 = int(ax_bbox.x0 * new_width)
+        ax_y0 = int((1 - ax_bbox.y1) * new_height)  # Flip y (0 at top)
+        ax_width = int(ax_bbox.width * new_width)
+        ax_height = int(ax_bbox.height * new_height)
+        xlim = ax.get_xlim()
+        ylim = ax.get_ylim()
+        self._axes_transform = (ax_x0, ax_y0, ax_width, ax_height, xlim, ylim)
+
+        # Create background - checkerboard for transparent, white otherwise
+        transparent = o.get("transparent", True)
+        if transparent:
+            # Create checkerboard pattern for transparency preview
+            padded = _create_checkerboard(max_width, max_height, square_size=10)
+        else:
+            padded = Image.new("RGBA", (max_width, max_height), (255, 255, 255, 255))
+
+        # Paste figure centered on background
+        padded.paste(img, (x_offset, y_offset), img)  # Use img as mask for alpha
+        img = padded
+        width, height = max_width, max_height
+
+        # Cache the base image (without highlights) for fast hover updates
+        self._cached_base_image = img.copy()
+        self._cache_dirty = False
+
+        # Convert to normalized float array for DearPyGui
+        img_array = np.array(img).astype(np.float32) / 255.0
+        img_data = img_array.flatten().tolist()
+
+        plt.close(fig)
+
+        # Update texture data (don't recreate texture, just update values)
+        dpg.set_value("preview_texture", img_data)
+
+        return img_data, width, height
+
+    def _draw_element_highlights(self, fig, ax):
+        """Draw selection highlights for non-trace elements (hover handled via PIL overlay)."""
+        from matplotlib.patches import FancyBboxPatch
+        import matplotlib.transforms as transforms
+
+        renderer = fig.canvas.get_renderer()
+
+        # Only draw selection highlights here (hover is done via fast PIL overlay)
+        selected_type = (
+            self._selected_element.get("type") if self._selected_element else None
+        )
+
+        # Skip if selecting traces (handled separately in _plot_from_csv)
+        if selected_type == "trace":
+            selected_type = None
+
+        def add_highlight_box(text_obj, color, alpha, linewidth=2):
+            """Add highlight rectangle around a text object (outline only)."""
+            try:
+                bbox = text_obj.get_window_extent(renderer)
+                # Convert to figure coordinates
+                fig_bbox = bbox.transformed(fig.transFigure.inverted())
+                # Add padding
+                padding = 0.01
+                rect = FancyBboxPatch(
+                    (fig_bbox.x0 - padding, fig_bbox.y0 - padding),
+                    fig_bbox.width + 2 * padding,
+                    fig_bbox.height + 2 * padding,
+                    boxstyle="round,pad=0.02,rounding_size=0.01",
+                    facecolor="none",
+                    edgecolor=color,
+                    alpha=0.7,
+                    linewidth=linewidth,
+                    transform=fig.transFigure,
+                    zorder=100,
+                )
+                fig.patches.append(rect)
+            except Exception:
+                pass
+
+        def add_spine_highlight(spine, color, alpha, linewidth=2):
+            """Add highlight to a spine/axis (outline only)."""
+            try:
+                bbox = spine.get_window_extent(renderer)
+                fig_bbox = bbox.transformed(fig.transFigure.inverted())
+                padding = 0.01
+                rect = FancyBboxPatch(
+                    (fig_bbox.x0 - padding, fig_bbox.y0 - padding),
+                    fig_bbox.width + 2 * padding,
+                    fig_bbox.height + 2 * padding,
+                    boxstyle="round,pad=0.01",
+                    facecolor="none",
+                    edgecolor=color,
+                    alpha=0.7,
+                    linewidth=linewidth,
+                    transform=fig.transFigure,
+                    zorder=100,
+                )
+                fig.patches.append(rect)
+            except Exception:
+                pass
+
+        # Map element types to matplotlib objects
+        element_map = {
+            "title": ax.title,
+            "xlabel": ax.xaxis.label,
+            "ylabel": ax.yaxis.label,
+        }
+
+        # Draw selection highlight (outline only, no fill)
+        select_color = "#FFC850"  # Soft warm yellow for outline
+        if selected_type in element_map:
+            add_highlight_box(
+                element_map[selected_type], select_color, 0.0, linewidth=2
+            )
+        elif selected_type == "xaxis":
+            add_spine_highlight(ax.spines["bottom"], select_color, 0.0, linewidth=2)
+        elif selected_type == "yaxis":
+            add_spine_highlight(ax.spines["left"], select_color, 0.0, linewidth=2)
+        elif selected_type == "legend":
+            legend = ax.get_legend()
+            if legend:
+                try:
+                    bbox = legend.get_window_extent(renderer)
+                    fig_bbox = bbox.transformed(fig.transFigure.inverted())
+                    padding = 0.01
+                    rect = FancyBboxPatch(
+                        (fig_bbox.x0 - padding, fig_bbox.y0 - padding),
+                        fig_bbox.width + 2 * padding,
+                        fig_bbox.height + 2 * padding,
+                        boxstyle="round,pad=0.02",
+                        facecolor="none",
+                        edgecolor=select_color,
+                        alpha=0.7,
+                        linewidth=2,
+                        transform=fig.transFigure,
+                        zorder=100,
+                    )
+                    fig.patches.append(rect)
+                except Exception:
+                    pass
+
+        # Note: Hover highlights are now drawn via fast PIL overlay in _update_hover_overlay()
+
+    def _plot_from_csv(self, ax, o, highlight_trace=None, hover_trace=None):
+        """Reconstruct plot from CSV data using trace info.
+
+        Parameters
+        ----------
+        ax : matplotlib.axes.Axes
+            The axes to plot on
+        o : dict
+            Current overrides containing trace info
+        highlight_trace : int, optional
+            Index of trace to highlight with selection effect (yellow glow)
+        hover_trace : int, optional
+            Index of trace to highlight with hover effect (cyan glow)
+        """
+        import pandas as pd
+        from ._defaults import _normalize_legend_loc
+
+        if not isinstance(self.csv_data, pd.DataFrame):
+            return
+
+        df = self.csv_data
+        linewidth = o.get("linewidth", 1.0)
+        legend_visible = o.get("legend_visible", True)
+        legend_fontsize = o.get("legend_fontsize", 6)
+        legend_frameon = o.get("legend_frameon", False)
+        legend_loc = _normalize_legend_loc(o.get("legend_loc", "best"))
+
+        traces = o.get("traces", [])
+
+        if traces:
+            for i, trace in enumerate(traces):
+                csv_cols = trace.get("csv_columns", {})
+                x_col = csv_cols.get("x")
+                y_col = csv_cols.get("y")
+
+                if x_col in df.columns and y_col in df.columns:
+                    trace_linewidth = trace.get("linewidth", linewidth)
+                    is_selected = highlight_trace is not None and i == highlight_trace
+                    is_hovered = (
+                        hover_trace is not None and i == hover_trace and not is_selected
+                    )
+
+                    # Draw selection glow (yellow, stronger)
+                    if is_selected:
+                        ax.plot(
+                            df[x_col],
+                            df[y_col],
+                            color="yellow",
+                            linewidth=trace_linewidth * 4,
+                            alpha=0.5,
+                            zorder=0,
+                        )
+                    # Draw hover glow (cyan, subtler)
+                    elif is_hovered:
+                        ax.plot(
+                            df[x_col],
+                            df[y_col],
+                            color="cyan",
+                            linewidth=trace_linewidth * 3,
+                            alpha=0.3,
+                            zorder=0,
+                        )
+
+                    ax.plot(
+                        df[x_col],
+                        df[y_col],
+                        label=trace.get("label", trace.get("id", "")),
+                        color=trace.get("color"),
+                        linestyle=trace.get("linestyle", "-"),
+                        linewidth=trace_linewidth
+                        * (1.5 if is_selected else (1.2 if is_hovered else 1.0)),
+                        marker=trace.get("marker", None),
+                        markersize=trace.get("markersize", 6),
+                        zorder=10 if is_selected else (5 if is_hovered else 1),
+                    )
+
+            if legend_visible and any(t.get("label") for t in traces):
+                ax.legend(
+                    fontsize=legend_fontsize, frameon=legend_frameon, loc=legend_loc
+                )
+        else:
+            # Fallback: parse column names
+            cols = df.columns.tolist()
+            trace_groups = {}
+
+            for col in cols:
+                if col.endswith("_x"):
+                    trace_id = col[:-2]
+                    y_col = trace_id + "_y"
+                    if y_col in cols:
+                        parts = trace_id.split("_")
+                        label = parts[2] if len(parts) > 2 else trace_id
+                        trace_groups[trace_id] = {
+                            "x_col": col,
+                            "y_col": y_col,
+                            "label": label,
+                        }
+
+            if trace_groups:
+                for trace_id, info in trace_groups.items():
+                    ax.plot(
+                        df[info["x_col"]],
+                        df[info["y_col"]],
+                        label=info["label"],
+                        linewidth=linewidth,
+                    )
+                if legend_visible:
+                    ax.legend(
+                        fontsize=legend_fontsize, frameon=legend_frameon, loc=legend_loc
+                    )
+            elif len(cols) >= 2:
+                x_col = cols[0]
+                for y_col in cols[1:]:
+                    try:
+                        ax.plot(
+                            df[x_col], df[y_col], label=str(y_col), linewidth=linewidth
+                        )
+                    except Exception:
+                        pass
+                if len(cols) > 2 and legend_visible:
+                    ax.legend(
+                        fontsize=legend_fontsize, frameon=legend_frameon, loc=legend_loc
+                    )
+
+    def _get_trace_labels(self):
+        """Get list of trace labels for selection combo."""
+        traces = self.current_overrides.get("traces", [])
+        if not traces:
+            return ["(no traces)"]
+        return [t.get("label", t.get("id", f"Trace {i}")) for i, t in enumerate(traces)]
+
+    def _get_all_element_labels(self):
+        """Get list of all selectable element labels."""
+        labels = []
+
+        # Fixed elements
+        labels.append("Title")
+        labels.append("X Label")
+        labels.append("Y Label")
+        labels.append("X Axis")
+        labels.append("Y Axis")
+        labels.append("Legend")
+
+        # Traces
+        traces = self.current_overrides.get("traces", [])
+        for i, t in enumerate(traces):
+            label = t.get("label", t.get("id", f"Trace {i}"))
+            labels.append(f"Trace: {label}")
+
+        return labels
+
+    def _on_preview_click(self, sender, app_data):
+        """Handle click on preview image to select element."""
+        import dearpygui.dearpygui as dpg
+
+        # Only handle left clicks
+        if app_data != 0:  # 0 = left button
+            return
+
+        # Get mouse position relative to viewport
+        mouse_pos = dpg.get_mouse_pos(local=False)
+
+        # Get preview image position and size
+        if not dpg.does_item_exist("preview_image"):
+            return
+
+        # Get the image item's position in the window
+        img_pos = dpg.get_item_pos("preview_image")
+        panel_pos = dpg.get_item_pos("preview_panel")
+
+        # Calculate click position relative to image
+        click_x = mouse_pos[0] - panel_pos[0] - img_pos[0]
+        click_y = mouse_pos[1] - panel_pos[1] - img_pos[1]
+
+        # Check if click is within image bounds (800x600)
+        max_width, max_height = 800, 600
+        if not (0 <= click_x <= max_width and 0 <= click_y <= max_height):
+            return
+
+        # First check if click is on a fixed element (title, labels, axes, legend)
+        element = self._find_clicked_element(click_x, click_y)
+
+        if element:
+            self._select_element(element, dpg)
+        else:
+            # Fall back to trace selection
+            trace_idx = self._find_nearest_trace(
+                click_x, click_y, max_width, max_height
+            )
+            if trace_idx is not None:
+                self._select_element({"type": "trace", "index": trace_idx}, dpg)
+
+    def _on_preview_hover(self, sender, app_data):
+        """Handle mouse move for hover effects on preview (optimized with caching)."""
+        import dearpygui.dearpygui as dpg
+        import time
+
+        # Throttle hover updates - reduced to 16ms (~60fps) since we use fast overlay
+        current_time = time.time()
+        if current_time - self._last_hover_check < 0.016:
+            return
+        self._last_hover_check = current_time
+
+        # Get mouse position relative to viewport
+        mouse_pos = dpg.get_mouse_pos(local=False)
+
+        # Get preview image position
+        if not dpg.does_item_exist("preview_image"):
+            return
+
+        img_pos = dpg.get_item_pos("preview_image")
+        panel_pos = dpg.get_item_pos("preview_panel")
+
+        # Calculate hover position relative to image
+        hover_x = mouse_pos[0] - panel_pos[0] - img_pos[0]
+        hover_y = mouse_pos[1] - panel_pos[1] - img_pos[1]
+
+        # Check if within image bounds
+        max_width, max_height = 800, 600
+        if not (0 <= hover_x <= max_width and 0 <= hover_y <= max_height):
+            if self._hovered_element is not None:
+                self._hovered_element = None
+                dpg.set_value("hover_text", "")
+                # Use fast overlay update instead of full redraw
+                self._update_hover_overlay(dpg)
+            return
+
+        # Find element under cursor
+        element = self._find_clicked_element(hover_x, hover_y)
+
+        if element is None:
+            # Check for trace hover
+            trace_idx = self._find_nearest_trace(
+                hover_x, hover_y, max_width, max_height
+            )
+            if trace_idx is not None:
+                element = {"type": "trace", "index": trace_idx}
+
+        # Check if hover changed
+        old_hover = self._hovered_element
+        if element != old_hover:
+            self._hovered_element = element
+            if element:
+                elem_type = element.get("type", "")
+                elem_idx = element.get("index")
+                if elem_type == "trace" and elem_idx is not None:
+                    traces = self.current_overrides.get("traces", [])
+                    if elem_idx < len(traces):
+                        label = traces[elem_idx].get("label", f"Trace {elem_idx}")
+                        dpg.set_value("hover_text", f"Hover: {label} (click to select)")
+                else:
+                    label = elem_type.replace("x", "X ").replace("y", "Y ").title()
+                    dpg.set_value("hover_text", f"Hover: {label} (click to select)")
+            else:
+                dpg.set_value("hover_text", "")
+
+            # Use fast overlay update for hover (no matplotlib re-render)
+            self._update_hover_overlay(dpg)
+
+    def _find_clicked_element(self, click_x, click_y):
+        """Find which element was clicked based on stored bboxes."""
+        if not self._element_bboxes:
+            return None
+
+        # Check each element bbox
+        for element_type, bbox in self._element_bboxes.items():
+            if bbox is None:
+                continue
+            x0, y0, x1, y1 = bbox
+            if x0 <= click_x <= x1 and y0 <= click_y <= y1:
+                return {"type": element_type, "index": None}
+
+        return None
+
+    def _select_element(self, element, dpg):
+        """Select an element and show appropriate controls."""
+        self._selected_element = element
+        elem_type = element.get("type")
+        elem_idx = element.get("index")
+
+        # Hide all control groups first
+        dpg.configure_item("trace_controls_group", show=False)
+        dpg.configure_item("text_controls_group", show=False)
+        dpg.configure_item("axis_controls_group", show=False)
+        dpg.configure_item("legend_controls_group", show=False)
+
+        # Update combo selection
+        if elem_type == "trace":
+            traces = self.current_overrides.get("traces", [])
+            if elem_idx is not None and elem_idx < len(traces):
+                trace = traces[elem_idx]
+                label = (
+                    f"Trace: {trace.get('label', trace.get('id', f'Trace {elem_idx}'))}"
+                )
+                dpg.set_value("element_selector_combo", label)
+
+                # Show trace controls and populate
+                dpg.configure_item("trace_controls_group", show=True)
+                self._selected_trace_index = elem_idx
+                dpg.set_value("trace_label_input", trace.get("label", ""))
+
+                color_hex = trace.get("color", "#0080bf")
+                try:
+                    r = int(color_hex[1:3], 16)
+                    g = int(color_hex[3:5], 16)
+                    b = int(color_hex[5:7], 16)
+                    dpg.set_value("trace_color_picker", [r, g, b])
+                except (ValueError, IndexError):
+                    dpg.set_value("trace_color_picker", [128, 128, 191])
+
+                dpg.set_value("trace_linewidth_slider", trace.get("linewidth", 1.0))
+                dpg.set_value("trace_linestyle_combo", trace.get("linestyle", "-"))
+                dpg.set_value("trace_marker_combo", trace.get("marker", "") or "")
+                dpg.set_value("trace_markersize_slider", trace.get("markersize", 6.0))
+
+                dpg.set_value(
+                    "selection_text",
+                    f"Selected: {trace.get('label', f'Trace {elem_idx}')}",
+                )
+
+        elif elem_type in ("title", "xlabel", "ylabel"):
+            dpg.set_value(
+                "element_selector_combo",
+                elem_type.replace("x", "X ").replace("y", "Y ").title(),
+            )
+            dpg.configure_item("text_controls_group", show=True)
+
+            o = self.current_overrides
+            if elem_type == "title":
+                dpg.set_value("element_text_input", o.get("title", ""))
+                dpg.set_value("element_fontsize_slider", o.get("title_fontsize", 8))
+            elif elem_type == "xlabel":
+                dpg.set_value("element_text_input", o.get("xlabel", ""))
+                dpg.set_value("element_fontsize_slider", o.get("axis_fontsize", 7))
+            elif elem_type == "ylabel":
+                dpg.set_value("element_text_input", o.get("ylabel", ""))
+                dpg.set_value("element_fontsize_slider", o.get("axis_fontsize", 7))
+
+            dpg.set_value("selection_text", f"Selected: {elem_type.title()}")
+
+        elif elem_type in ("xaxis", "yaxis"):
+            label = "X Axis" if elem_type == "xaxis" else "Y Axis"
+            dpg.set_value("element_selector_combo", label)
+            dpg.configure_item("axis_controls_group", show=True)
+
+            o = self.current_overrides
+            dpg.set_value("axis_linewidth_slider", o.get("axis_width", 0.2))
+            dpg.set_value("axis_tick_length_slider", o.get("tick_length", 0.8))
+            dpg.set_value("axis_tick_fontsize_slider", o.get("tick_fontsize", 7))
+
+            if elem_type == "xaxis":
+                dpg.set_value(
+                    "axis_show_spine_checkbox", not o.get("hide_bottom_spine", False)
+                )
+            else:
+                dpg.set_value(
+                    "axis_show_spine_checkbox", not o.get("hide_left_spine", False)
+                )
+
+            dpg.set_value("selection_text", f"Selected: {label}")
+
+        elif elem_type == "legend":
+            dpg.set_value("element_selector_combo", "Legend")
+            dpg.configure_item("legend_controls_group", show=True)
+
+            o = self.current_overrides
+            dpg.set_value("legend_visible_edit", o.get("legend_visible", True))
+            dpg.set_value("legend_frameon_edit", o.get("legend_frameon", False))
+            dpg.set_value("legend_loc_edit", o.get("legend_loc", "best"))
+            dpg.set_value("legend_fontsize_edit", o.get("legend_fontsize", 6))
+
+            dpg.set_value("selection_text", "Selected: Legend")
+
+        # Redraw with highlight
+        self._update_preview(dpg)
+
+    def _on_element_selected(self, sender, app_data):
+        """Handle element selection from combo box."""
+        import dearpygui.dearpygui as dpg
+
+        if app_data == "Title":
+            self._select_element({"type": "title", "index": None}, dpg)
+        elif app_data == "X Label":
+            self._select_element({"type": "xlabel", "index": None}, dpg)
+        elif app_data == "Y Label":
+            self._select_element({"type": "ylabel", "index": None}, dpg)
+        elif app_data == "X Axis":
+            self._select_element({"type": "xaxis", "index": None}, dpg)
+        elif app_data == "Y Axis":
+            self._select_element({"type": "yaxis", "index": None}, dpg)
+        elif app_data == "Legend":
+            self._select_element({"type": "legend", "index": None}, dpg)
+        elif app_data.startswith("Trace: "):
+            # Find trace index
+            trace_label = app_data[7:]  # Remove "Trace: " prefix
+            traces = self.current_overrides.get("traces", [])
+            for i, t in enumerate(traces):
+                if t.get("label", t.get("id", f"Trace {i}")) == trace_label:
+                    self._select_element({"type": "trace", "index": i}, dpg)
+                    break
+
+    def _on_text_element_change(self, sender, app_data, user_data=None):
+        """Handle changes to text element properties."""
+        import dearpygui.dearpygui as dpg
+
+        if self._selected_element is None:
+            return
+
+        elem_type = self._selected_element.get("type")
+        if elem_type not in ("title", "xlabel", "ylabel"):
+            return
+
+        text = dpg.get_value("element_text_input")
+        fontsize = dpg.get_value("element_fontsize_slider")
+
+        if elem_type == "title":
+            self.current_overrides["title"] = text
+            self.current_overrides["title_fontsize"] = fontsize
+        elif elem_type == "xlabel":
+            self.current_overrides["xlabel"] = text
+            self.current_overrides["axis_fontsize"] = fontsize
+        elif elem_type == "ylabel":
+            self.current_overrides["ylabel"] = text
+            self.current_overrides["axis_fontsize"] = fontsize
+
+        self._user_modified = True
+        self._update_preview(dpg)
+
+    def _on_axis_element_change(self, sender, app_data, user_data=None):
+        """Handle changes to axis element properties."""
+        import dearpygui.dearpygui as dpg
+
+        if self._selected_element is None:
+            return
+
+        elem_type = self._selected_element.get("type")
+        if elem_type not in ("xaxis", "yaxis"):
+            return
+
+        self.current_overrides["axis_width"] = dpg.get_value("axis_linewidth_slider")
+        self.current_overrides["tick_length"] = dpg.get_value("axis_tick_length_slider")
+        self.current_overrides["tick_fontsize"] = dpg.get_value(
+            "axis_tick_fontsize_slider"
+        )
+
+        show_spine = dpg.get_value("axis_show_spine_checkbox")
+        if elem_type == "xaxis":
+            self.current_overrides["hide_bottom_spine"] = not show_spine
+        else:
+            self.current_overrides["hide_left_spine"] = not show_spine
+
+        self._user_modified = True
+        self._update_preview(dpg)
+
+    def _on_legend_element_change(self, sender, app_data, user_data=None):
+        """Handle changes to legend element properties."""
+        import dearpygui.dearpygui as dpg
+
+        if self._selected_element is None:
+            return
+
+        elem_type = self._selected_element.get("type")
+        if elem_type != "legend":
+            return
+
+        self.current_overrides["legend_visible"] = dpg.get_value("legend_visible_edit")
+        self.current_overrides["legend_frameon"] = dpg.get_value("legend_frameon_edit")
+        self.current_overrides["legend_loc"] = dpg.get_value("legend_loc_edit")
+        self.current_overrides["legend_fontsize"] = dpg.get_value(
+            "legend_fontsize_edit"
+        )
+
+        self._user_modified = True
+        self._update_preview(dpg)
+
+    def _deselect_element(self, sender=None, app_data=None, user_data=None):
+        """Deselect the current element."""
+        import dearpygui.dearpygui as dpg
+
+        self._selected_element = None
+        self._selected_trace_index = None
+
+        # Hide all control groups
+        dpg.configure_item("trace_controls_group", show=False)
+        dpg.configure_item("text_controls_group", show=False)
+        dpg.configure_item("axis_controls_group", show=False)
+        dpg.configure_item("legend_controls_group", show=False)
+
+        dpg.set_value("selection_text", "")
+        dpg.set_value("element_selector_combo", "")
+        self._update_preview(dpg)
+
+    def _find_nearest_trace(self, click_x, click_y, preview_width, preview_height):
+        """Find the nearest trace to the click position."""
+        import pandas as pd
+        import numpy as np
+
+        if self.csv_data is None or not isinstance(self.csv_data, pd.DataFrame):
+            return None
+
+        traces = self.current_overrides.get("traces", [])
+        if not traces:
+            return None
+
+        # Get preview bounds from last render
+        if self._preview_bounds is None:
+            return None
+
+        x_offset, y_offset, fig_width, fig_height = self._preview_bounds
+
+        # Adjust click coordinates to figure space
+        fig_x = click_x - x_offset
+        fig_y = click_y - y_offset
+
+        # Check if click is within figure bounds
+        if not (0 <= fig_x <= fig_width and 0 <= fig_y <= fig_height):
+            return None
+
+        # Get axes transform info
+        if self._axes_transform is None:
+            return None
+
+        ax_x0, ax_y0, ax_width, ax_height, xlim, ylim = self._axes_transform
+
+        # Convert figure pixel to axes pixel
+        ax_pixel_x = fig_x - ax_x0
+        ax_pixel_y = fig_y - ax_y0
+
+        # Check if click is within axes bounds
+        if not (0 <= ax_pixel_x <= ax_width and 0 <= ax_pixel_y <= ax_height):
+            return None
+
+        # Convert axes pixel to data coordinates
+        # Note: y is flipped (0 at top in pixel space)
+        data_x = xlim[0] + (ax_pixel_x / ax_width) * (xlim[1] - xlim[0])
+        data_y = ylim[1] - (ax_pixel_y / ax_height) * (ylim[1] - ylim[0])
+
+        # Find nearest trace
+        df = self.csv_data
+        min_dist = float("inf")
+        nearest_idx = None
+
+        for i, trace in enumerate(traces):
+            csv_cols = trace.get("csv_columns", {})
+            x_col = csv_cols.get("x")
+            y_col = csv_cols.get("y")
+
+            if x_col not in df.columns or y_col not in df.columns:
+                continue
+
+            trace_x = df[x_col].dropna().values
+            trace_y = df[y_col].dropna().values
+
+            if len(trace_x) == 0:
+                continue
+
+            # Normalize coordinates for distance calculation
+            x_range = xlim[1] - xlim[0]
+            y_range = ylim[1] - ylim[0]
+
+            norm_click_x = (data_x - xlim[0]) / x_range if x_range > 0 else 0
+            norm_click_y = (data_y - ylim[0]) / y_range if y_range > 0 else 0
+
+            norm_trace_x = (trace_x - xlim[0]) / x_range if x_range > 0 else trace_x
+            norm_trace_y = (trace_y - ylim[0]) / y_range if y_range > 0 else trace_y
+
+            # Calculate distances to all points
+            distances = np.sqrt(
+                (norm_trace_x - norm_click_x) ** 2 + (norm_trace_y - norm_click_y) ** 2
+            )
+            min_trace_dist = np.min(distances)
+
+            if min_trace_dist < min_dist:
+                min_dist = min_trace_dist
+                nearest_idx = i
+
+        # Only select if close enough (threshold in normalized space)
+        if min_dist < 0.1:  # 10% of plot area
+            return nearest_idx
+
+        return None
+
+    def _on_trace_property_change(self, sender, app_data, user_data=None):
+        """Handle changes to selected trace properties."""
+        import dearpygui.dearpygui as dpg
+
+        if self._selected_trace_index is None:
+            return
+
+        traces = self.current_overrides.get("traces", [])
+        if self._selected_trace_index >= len(traces):
+            return
+
+        trace = traces[self._selected_trace_index]
+
+        # Update trace properties from widgets
+        trace["label"] = dpg.get_value("trace_label_input")
+
+        # Convert RGB to hex
+        color_rgb = dpg.get_value("trace_color_picker")
+        if color_rgb and len(color_rgb) >= 3:
+            r, g, b = int(color_rgb[0]), int(color_rgb[1]), int(color_rgb[2])
+            trace["color"] = f"#{r:02x}{g:02x}{b:02x}"
+
+        trace["linewidth"] = dpg.get_value("trace_linewidth_slider")
+        trace["linestyle"] = dpg.get_value("trace_linestyle_combo")
+
+        marker = dpg.get_value("trace_marker_combo")
+        trace["marker"] = marker if marker else None
+
+        trace["markersize"] = dpg.get_value("trace_markersize_slider")
+
+        self._user_modified = True
+        self._update_preview(dpg)
+
+    def _save_manual(self, sender=None, app_data=None, user_data=None):
+        """Save current overrides to .manual.json."""
+        import dearpygui.dearpygui as dpg
+        from ._edit import save_manual_overrides
+
+        try:
+            self._collect_overrides(dpg)
+            manual_path = save_manual_overrides(self.json_path, self.current_overrides)
+            dpg.set_value("status_text", f"Saved: {manual_path.name}")
+        except Exception as e:
+            dpg.set_value("status_text", f"Error: {str(e)}")
+
+    def _reset_overrides(self, sender=None, app_data=None, user_data=None):
+        """Reset to initial overrides."""
+        import dearpygui.dearpygui as dpg
+
+        self.current_overrides = copy.deepcopy(self._initial_overrides)
+        self._user_modified = False
+
+        # Update all widgets
+        dpg.set_value("title_input", self.current_overrides.get("title", ""))
+        dpg.set_value("xlabel_input", self.current_overrides.get("xlabel", ""))
+        dpg.set_value("ylabel_input", self.current_overrides.get("ylabel", ""))
+        dpg.set_value("linewidth_slider", self.current_overrides.get("linewidth", 1.0))
+        dpg.set_value("grid_checkbox", self.current_overrides.get("grid", False))
+        dpg.set_value(
+            "transparent_checkbox", self.current_overrides.get("transparent", True)
+        )
+
+        self._update_preview(dpg)
+        dpg.set_value("status_text", "Reset to original")
+
+    def _export_png(self, sender=None, app_data=None, user_data=None):
+        """Export current view to PNG."""
+        import dearpygui.dearpygui as dpg
+        import matplotlib
+
+        matplotlib.use("Agg")
+        import matplotlib.pyplot as plt
+
+        try:
+            self._collect_overrides(dpg)
+            output_path = self.json_path.with_suffix(".edited.png")
+
+            # Full resolution render
+            o = self.current_overrides
+            fig_size = o.get("fig_size", [3.15, 2.68])
+            dpi = o.get("dpi", 300)
+
+            fig, ax = plt.subplots(figsize=fig_size, dpi=dpi)
+
+            if self.csv_data is not None:
+                self._plot_from_csv(ax, o)
+
+            if o.get("title"):
+                ax.set_title(o["title"], fontsize=o.get("title_fontsize", 8))
+            if o.get("xlabel"):
+                ax.set_xlabel(o["xlabel"], fontsize=o.get("axis_fontsize", 7))
+            if o.get("ylabel"):
+                ax.set_ylabel(o["ylabel"], fontsize=o.get("axis_fontsize", 7))
+
+            fig.tight_layout()
+            fig.savefig(
+                output_path,
+                dpi=dpi,
+                bbox_inches="tight",
+                transparent=o.get("transparent", True),
+            )
+            plt.close(fig)
+
+            dpg.set_value("status_text", f"Exported: {output_path.name}")
+        except Exception as e:
+            dpg.set_value("status_text", f"Error: {str(e)}")
+
+
+# EOF