Improve form rendering and scoped flash handling

Author: trissim

src/pyqt_reactive/animation/flash_mixin.py

@@ -35,7 +35,27 @@
 from weakref import WeakValueDictionary
 import re
 from PyQt6.QtCore import QTimer, Qt, QRect, QRectF, QSize
-from PyQt6.QtWidgets import QWidget, QMainWindow, QDialog, QScrollArea, QCheckBox, QLabel, QStyle, QStyleOptionButton, QLineEdit, QSpinBox, QDoubleSpinBox, QComboBox, QPushButton, QToolButton, QTextEdit, QPlainTextEdit, QTreeWidget, QListWidget, QTableWidget
+from PyQt6.QtWidgets import (
+    QCheckBox,
+    QComboBox,
+    QDialog,
+    QDoubleSpinBox,
+    QLabel,
+    QLineEdit,
+    QListWidget,
+    QMainWindow,
+    QPlainTextEdit,
+    QPushButton,
+    QScrollArea,
+    QSpinBox,
+    QStyle,
+    QStyleOptionButton,
+    QTableWidget,
+    QTextEdit,
+    QToolButton,
+    QTreeWidget,
+    QWidget,
+)
 from PyQt6.QtGui import QColor, QPainter, QRegion, QPainterPath
 from PyQt6 import sip
 
@@ -322,7 +342,8 @@ class FlashElement:
     source_id: Optional[str] = None  # Unique identifier for deduplication (e.g., "groupbox:123", "list_item:scope_id")
     corner_radius: float = 0.0  # Rounded corners (0 = sharp, >0 = rounded)
     skip_overlay_paint: bool = False  # If True, overlay skips painting (element handles its own paint, e.g., list item delegate)
-    delegate_widget: Optional[QWidget] = None  # Widget whose viewport needs updating when skip_overlay_paint=True (e.g., QListWidget, QTreeWidget)
+    # Widget whose viewport needs updating when skip_overlay_paint=True.
+    delegate_widget: Optional[QWidget] = None
     get_model_index: Optional[Callable[[], Any]] = None  # Returns QModelIndex for targeted item updates (avoids full viewport repaint)
 
 
@@ -506,6 +527,43 @@ def _get_function_pane_title_widgets(groupbox: QWidget) -> List[QWidget]:
     return unique_widgets
 
 
+def _get_groupbox_title_mask_rects(groupbox: QWidget, window: QWidget) -> List[Tuple[QRect, bool]]:
+    """Return mask rects for visible QGroupBox title text painted by Qt styles."""
+    from PyQt6.QtWidgets import QGroupBox
+    from PyQt6.QtCore import QPoint
+
+    rects: List[Tuple[QRect, bool]] = []
+    for titled_group in groupbox.findChildren(QGroupBox):
+        title = titled_group.title()
+        if not title or not titled_group.isVisible() or not titled_group.isVisibleTo(window):
+            continue
+
+        metrics = titled_group.fontMetrics()
+        group_window_pos = window.mapFromGlobal(titled_group.mapToGlobal(QPoint(0, 0)))
+        stylesheet = titled_group.styleSheet()
+        left_padding = 6
+        extra_width = 8
+        if stylesheet:
+            import re
+            left_match = re.search(r"left\s*:\s*(\d+)", stylesheet)
+            if left_match:
+                left_padding = int(left_match.group(1))
+            padding_match = re.search(r"padding\s*:\s*0\s+(\d+)", stylesheet)
+            if padding_match:
+                extra_width = int(padding_match.group(1)) * 2
+
+        rects.append((
+            QRect(
+                group_window_pos.x() + left_padding,
+                group_window_pos.y(),
+                metrics.horizontalAdvance(title) + extra_width,
+                metrics.height() + 4,
+            ),
+            False,
+        ))
+    return rects
+
+
 def create_groupbox_element(
     key: str,
     groupbox: 'QGroupBox',
@@ -670,6 +728,8 @@ def get_child_rects(window: QWidget) -> List[Tuple[QRect, bool]]:
                     except Exception as e:
                         logger.warning(f"[FLASH INVERSE] Failed to mask function pane title widget: {e}")
 
+                exclusions.extend(_get_groupbox_title_mask_rects(groupbox, window))
+
                 logger.debug(f"[FLASH INVERSE] Total exclusions: {len(exclusions)}")
             except Exception as e:
                 logger.error(f"[FLASH INVERSE] Outer exception: {e}", exc_info=True)
@@ -725,6 +785,8 @@ def get_child_rects(window: QWidget) -> List[Tuple[QRect, bool]]:
             child_rect = get_child_mask_rect(child, window)
             child_rects.append((child_rect, _needs_square_checkbox_mask(child)))
 
+        child_rects.extend(_get_groupbox_title_mask_rects(groupbox, window))
+
         # DEBUG: Log groupbox position and first 2 child positions
         if child_rects:
             first_children = [f"({r.x()},{r.y()})" for r, _ in child_rects[:2]]

src/pyqt_reactive/forms/parameter_form_manager.py

@@ -109,7 +109,11 @@ def analyze_parameters(self, input: ParameterAnalysisInput) -> FormStructure:
 
         import logging
         logger = logging.getLogger(__name__)
-        logger.info(f"🔍 analyze_parameters: field_id={input.field_id}, param_type.keys()={list(input.param_type.keys())}")
+        logger.debug(
+            "analyze_parameters: field_id=%s param_type.keys()=%s",
+            input.field_id,
+            list(input.param_type.keys()),
+        )
 
         param_infos = []
         nested_forms = {}
@@ -359,7 +363,7 @@ def validate_field_path_mapping(self):
         context_fields = {f.name for f in dataclasses.fields(GlobalPipelineConfig)
                          if dataclasses.is_dataclass(f.type)}
 
-        print("Context fields:", context_fields)
+        logger.debug("Context fields: %s", context_fields)
         # Should include: well_filter_config, zarr_config, step_materialization_config, etc.
 
         # Verify form managers use these exact field names (no "nested_" prefix)

src/pyqt_reactive/forms/parameter_form_service.py

@@ -497,6 +497,42 @@ def _create_nested_container(manager: ParameterFormManager, param_info: Paramete
     return container
 
 
+def _create_inline_dataclass_container(
+    manager: ParameterFormManager,
+    param_info: ParameterInfo,
+    display_info: DisplayInfo,
+    field_ids: FieldIds,
+    current_value: Any,
+    unwrapped_type: Optional[Type],
+    layout=None,
+    CURRENT_LAYOUT=None,
+    QWidget=None,
+    GroupBoxWithHelp=None,
+    PyQt6ColorScheme=None,
+) -> Any:
+    """Create dataclass chrome for a registered inline dataclass editor."""
+    from pyqt_reactive.widgets.shared.clickable_help_components import (
+        InlineDataclassGroupBox,
+    )
+    from pyqt_reactive.theming.color_scheme import ColorScheme as PCS
+
+    color_scheme = manager.config.color_scheme or PCS()
+    root_manager = manager
+    while getattr(root_manager, '_parent_manager', None) is not None:
+        root_manager = root_manager._parent_manager
+    flash_key = f"{manager.field_id}.{param_info.name}" if manager.field_id else param_info.name
+    scope_accent_color = getattr(manager, '_scope_accent_color', None)
+
+    return InlineDataclassGroupBox(
+        title=display_info['field_label'],
+        help_target=unwrapped_type,
+        color_scheme=color_scheme,
+        scope_accent_color=scope_accent_color,
+        flash_key=flash_key,
+        flash_manager=root_manager,
+    )
+
+
 def _create_inline_dataclass_widget(
     manager: ParameterFormManager,
     param_info: ParameterInfo,
@@ -612,12 +648,12 @@ def _setup_optional_nested_layout(manager: ParameterFormManager, param_info: Par
     WidgetCreationType.INLINE_DATACLASS: WidgetCreationConfig(
         layout_type='GroupBoxWithHelp',
         is_nested=True,
-        create_container=_create_nested_container,
+        create_container=_create_inline_dataclass_container,
         setup_layout=None,
         create_main_widget=_create_inline_dataclass_widget,
         needs_label=False,
         needs_reset_button=False,
-        needs_unwrap_type=False,
+        needs_unwrap_type=True,
         is_optional=False,
     ),
 
@@ -982,29 +1018,39 @@ def create_widget_parametric(manager: ParameterFormManager, param_info: Paramete
                 unwrapped_type
             )
 
+    def on_widget_change(pname, value, mgr: ParameterFormManager = manager):
+        converted_value = mgr._convert_widget_value(value, pname)
+        event = FieldChangeEvent(pname, converted_value, mgr)
+        from objectstate import ObjectStateRegistry
+
+        if mgr.state and mgr.state._parent_state is not None:
+            with ObjectStateRegistry.atomic("edit func parameter"):
+                FieldChangeDispatcher.instance().dispatch(event)
+        else:
+            FieldChangeDispatcher.instance().dispatch(event)
+
     # Store widget and connect signals
     if config.is_nested:
-        # For nested, store the GroupBox/container
-        manager.widgets[param_info.name] = container
-        logger.debug(f"[CREATE_NESTED_DATACLASS] param_info.name={param_info.name}, stored container in manager.widgets")
+        if creation_type is WidgetCreationType.INLINE_DATACLASS:
+            container.set_value_widget(main_widget)
+            manager.widgets[param_info.name] = container
+            PyQt6WidgetEnhancer.connect_change_signal(
+                container,
+                param_info.name,
+                on_widget_change,
+            )
+            logger.debug(
+                "[CREATE_INLINE_DATACLASS] param_info.name=%s, stored inline container in manager.widgets",
+                param_info.name,
+            )
+        else:
+            # For nested, store the GroupBox/container
+            manager.widgets[param_info.name] = container
+            logger.debug(f"[CREATE_NESTED_DATACLASS] param_info.name={param_info.name}, stored container in manager.widgets")
     else:
         # For regular, store the main widget
         manager.widgets[param_info.name] = main_widget
 
-        # Connect widget changes to dispatcher
-        # NOTE: connect_change_signal calls callback(param_name, value)
-        def on_widget_change(pname, value, mgr: ParameterFormManager = manager):
-            converted_value = mgr._convert_widget_value(value, pname)
-            event = FieldChangeEvent(pname, converted_value, mgr)
-            # ATOMIC: If this manager's state has a parent (e.g., function in step),
-            # wrap dispatch in atomic to coalesce with parent step update
-            from objectstate import ObjectStateRegistry
-            if mgr.state and mgr.state._parent_state is not None:
-                with ObjectStateRegistry.atomic("edit func parameter"):
-                    FieldChangeDispatcher.instance().dispatch(event)
-            else:
-                FieldChangeDispatcher.instance().dispatch(event)
-
         PyQt6WidgetEnhancer.connect_change_signal(main_widget, param_info.name, on_widget_change)
 
         if manager.read_only:

src/pyqt_reactive/forms/widget_creation_config.py

@@ -5,13 +5,19 @@
 eliminating class-based abstractions while maintaining clean extensibility.
 """
 
+from types import UnionType
 from typing import Type, get_origin, get_args, Union
 from enum import Enum
 
 
+def is_union_type(param_type: Type) -> bool:
+    """Check whether a type annotation is a typing or PEP 604 union."""
+    return get_origin(param_type) in (Union, UnionType)
+
+
 def resolve_optional(param_type: Type) -> Type:
     """Resolve Optional[T] to T."""
-    if get_origin(param_type) is Union:
+    if is_union_type(param_type):
         args = get_args(param_type)
         if len(args) == 2 and type(None) in args:
             return next(arg for arg in args if arg is not type(None))
@@ -23,6 +29,18 @@ def is_enum(param_type: Type) -> bool:
     return isinstance(param_type, type) and issubclass(param_type, Enum)
 
 
+def enum_member_type(param_type: Type) -> Type | None:
+    """Return the enum member from a union annotation, if one is present."""
+    if is_enum(param_type):
+        return param_type
+    if not is_union_type(param_type):
+        return None
+    enum_args = [arg for arg in get_args(param_type) if is_enum(arg)]
+    if len(enum_args) == 1:
+        return enum_args[0]
+    return None
+
+
 def is_list_of_enums(param_type: Type) -> bool:
     """Check if type is List[Enum]."""
     return (get_origin(param_type) is list and

src/pyqt_reactive/forms/widget_creation_registry.py

@@ -16,7 +16,13 @@
 )
 from pyqt_reactive.widgets.enhanced_path_widget import EnhancedPathWidget
 from pyqt_reactive.theming.color_scheme import ColorScheme as PyQt6ColorScheme
-from pyqt_reactive.forms.widget_creation_registry import resolve_optional, is_enum, is_list_of_enums, get_enum_from_list
+from pyqt_reactive.forms.widget_creation_registry import (
+    enum_member_type,
+    resolve_optional,
+    is_enum,
+    is_list_of_enums,
+    get_enum_from_list,
+)
 from contextlib import contextmanager
 
 try:
@@ -280,6 +286,9 @@ def create_widget(self, param_name: str, param_type: Type, current_value: Any,
 
         with timer("            resolve_optional", threshold_ms=0.1):
             resolved_type = resolve_optional(param_type)
+            enum_type = enum_member_type(resolved_type)
+            if enum_type is not None:
+                resolved_type = enum_type
 
         # Handle direct List[Enum] types - create multi-selection checkbox group
         if is_list_of_enums(resolved_type):
@@ -981,6 +990,15 @@ def wrapped():
             PyQt6WidgetEnhancer._connect_checkbox_group_signals(widget, param_name, placeholder_aware_callback)
             return
 
+        from pyqt_reactive.protocols.widget_protocols import ChangeSignalEmitter
+        if isinstance(widget, ChangeSignalEmitter):
+            def emit_contract_value(value):
+                PyQt6WidgetEnhancer._clear_placeholder_state(widget)
+                callback(param_name, value)
+
+            widget.connect_change_signal(emit_contract_value)
+            return
+
         # Fallback to native PyQt6 signals
         connector = next(
             (connector for signal_name, connector in SIGNAL_CONNECTION_REGISTRY.items()
@@ -1030,7 +1048,12 @@ def handler(state):
                         selected = widget.get_value()
                         # Handle None (placeholder state) in logging
                         selected_str = "None (inherit from parent)" if selected is None else [v.name for v in selected]
-                        logger.info(f"🔘 Checkbox {cb.text()} changed to {state}, selected values: {selected_str}")
+                        logger.debug(
+                            "Checkbox %s changed to %s, selected values: %s",
+                            cb.text(),
+                            state,
+                            selected_str,
+                        )
 
                         callback(param_name, selected)
                     return handler

src/pyqt_reactive/forms/widget_strategies.py

@@ -68,37 +68,13 @@ def dispatch(self, event: FieldChangeEvent) -> None:
             # CRITICAL: Compute full dotted path for nested PFMs
             full_path = f"{source.field_id}.{event.field_name}" if source.field_id else event.field_name
             source.state.update_parameter(full_path, event.value)
+            source.sync_after_model_field_change(event.field_name, full_path)
             if DEBUG_DISPATCHER:
                 reset_note = " (reset to None)" if event.is_reset else ""
                 logger.info(f"  ✅ Updated state.parameters[{full_path}]{reset_note}")
 
-            # Update ProvenanceButton visibility after state change
-            # The button is in the groupbox title, not in source.widgets
-            from pyqt_reactive.widgets.shared.clickable_help_components import ProvenanceButton
-            from PyQt6.QtWidgets import QWidget
-            
             # 3. Refresh siblings that have the same field
             parent = source._parent_manager
-            
-            # Find the groupbox widget for this manager
-            groupbox = None
-            if parent:
-                for name, nested in parent.nested_managers.items():
-                    if nested is source:
-                        groupbox = parent.widgets.get(name)
-                        break
-            
-            # Update provenance button visibility
-            if source._parent_manager:
-                source._update_provenance_button_visibility()
-            
-            # Update groupbox dirty markers (title and Reset All button)
-            source._update_groupbox_dirty_markers()
-
-            # Update reset button styling for ALL reset buttons in this manager
-            from pyqt_reactive.utils.styling_utils import update_reset_button_styling
-            for field_name, reset_button in source.reset_buttons.items():
-                update_reset_button_styling(reset_button, source.state, source.field_id, field_name)
             if parent:
                 if DEBUG_DISPATCHER:
                     logger.info(f"  🔍 Looking for siblings with field '{event.field_name}' in {parent.field_id}")
@@ -143,9 +119,7 @@ def dispatch(self, event: FieldChangeEvent) -> None:
 
             # 3. Handle 'enabled' field styling
             if event.field_name == 'enabled':
-                source._enabled_field_styling_service.on_enabled_field_changed(
-                    source, 'enabled', event.value
-                )
+                source.sync_enabled_field_visuals(event.value)
                 if DEBUG_DISPATCHER:
                     logger.info(f"  ✅ Applied enabled styling")
 
@@ -231,4 +205,3 @@ def _refresh_single_field(self, manager: 'ParameterFormManager', field_name: str
             logger.info(f"      ✅ Refreshing placeholder for {manager.field_id}.{field_name}")
 
         manager._parameter_ops_service.refresh_single_placeholder(manager, field_name)
-