qt-css-engine 0.1.2__tar.gz → 0.1.3__tar.gz

{qt_css_engine-0.1.2 → qt_css_engine-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qt-css-engine
-Version: 0.1.2
+Version: 0.1.3
 Summary: CSS transition animations for PyQt6/PySide6 — extends static QSS with transition and other properties
 Project-URL: Homepage, https://github.com/Video-Nomad/qt-css-engine
 Project-URL: Repository, https://github.com/Video-Nomad/qt-css-engine

{qt_css_engine-0.1.2 → qt_css_engine-0.1.3}/qt_css_engine/css_parser.py

@@ -30,10 +30,16 @@ def _classify_border_token(token: str) -> str:
     return "color"
 
 
+def _split_css_components(value: str) -> list[str]:
+    """Split a CSS value on top-level component boundaries, preserving function arguments."""
+    tokens = tinycss2.parse_component_value_list(value, skip_comments=True)
+    return [_serialize_value([tok]) for tok in tokens if tok.type != "whitespace"]
+
+
 def _expand_border(value: str) -> dict[str, str]:
     """Parse `border: <width> <style> <color>` (any token order) into component properties."""
     result: dict[str, str] = {}
-    for token in value.split():
+    for token in _split_css_components(value):
         kind = _classify_border_token(token)
         if kind == "width":
             result["border-width"] = token
@@ -55,7 +61,7 @@ def _expand_shorthand(prop: str, value: str) -> dict[str, str]:
     longhands = SHORTHAND_SIDES.get(prop)
     if not longhands:
         return {prop: value}
-    parts = value.split()
+    parts = _split_css_components(value)
     n = len(parts)
     if n == 1:
         expanded = [parts[0]] * 4

{qt_css_engine-0.1.2 → qt_css_engine-0.1.3}/qt_css_engine/engine.py

@@ -21,6 +21,7 @@ from .handlers import (
     GenericPropertyAnimation,
     OpacityAnimation,
     clamp_border_radius,
+    target_border_radius_box_size,
 )
 from .qt_compat.QtCore import QAbstractAnimation, QEasingCurve, QEvent, QObject, Qt, QTimer
 from .qt_compat.QtGui import QMouseEvent
@@ -565,7 +566,7 @@ class TransitionEngine(QObject):
         ctx = self._contexts.pop(wid, None)
         if ctx is None:
             return
-        event_logger.debug("On widget destroyed: %s", widget)
+        event_logger.debug("On widget destroyed: %s, %s", widget.__class__, wid)
         for timer in ctx.pending_delays.values():
             try:
                 timer.stop()
@@ -630,17 +631,70 @@ class TransitionEngine(QObject):
             target_transitions,
             all_animated_props,
         ) = self._collect_rule_state(widget, ctx)
-        needs_style_update = False
-        for prop in all_animated_props:
-            if self._apply_prop_animation(widget, ctx, prop, base_props, target_props, target_transitions, cause):
+        ctx.style_box_props = dict(target_props)
+        old_immediate = ctx.style_flush_immediate
+        ctx.style_flush_immediate = old_immediate or cause.is_class_driven
+        try:
+            needs_style_update = False
+            for prop in all_animated_props:
+                if self._apply_prop_animation(widget, ctx, prop, base_props, target_props, target_transitions, cause):
+                    needs_style_update = True
+            if self._cleanup_orphans(widget, ctx, all_animated_props, base_props):
                 needs_style_update = True
-        if self._cleanup_orphans(widget, ctx, all_animated_props, base_props):
-            needs_style_update = True
-        if needs_style_update:
-            event_logger.debug("Updating style: %s", widget)
-            widget.setStyleSheet(scoped_anim_style(widget, ctx.css_anim_props))
-            update_shadow_ancestor(widget)
-        self._apply_cursor(widget, ctx, target_props)
+            if needs_style_update:
+                event_logger.debug("Updating style: %s", widget)
+                self._flush_widget_style_now(widget, ctx)
+            self._apply_cursor(widget, ctx, target_props)
+        finally:
+            ctx.style_flush_immediate = old_immediate
+
+    def _schedule_style_flush(self, widget: QWidget, ctx: WidgetContext) -> None:
+        """Queue one stylesheet write for this widget after the current burst of animation ticks."""
+        if ctx.style_flush_immediate or ctx.class_anim_props:
+            self._flush_widget_style_now(widget, ctx)
+            return
+        if ctx.style_flush_pending:
+            return
+        ctx.style_flush_pending = True
+        wid = id(widget)
+        QTimer.singleShot(0, lambda: self._flush_scheduled_widget_style(widget, wid))
+
+    def _flush_scheduled_widget_style(self, widget: QWidget, wid: int) -> None:
+        ctx = self._contexts.get(wid)
+        if ctx is None or not ctx.style_flush_pending:
+            return
+        try:
+            self._flush_widget_style_now(widget, ctx)
+        except RuntimeError:
+            ctx.style_flush_pending = False
+
+    def _flush_widget_style_now(self, widget: QWidget, ctx: WidgetContext) -> None:
+        """Normalize interdependent inline props and apply them as one scoped stylesheet."""
+        ctx.style_flush_pending = False
+        self._normalize_dependent_anim_props(widget, ctx)
+        widget.setStyleSheet(scoped_anim_style(widget, ctx.css_anim_props))
+        update_shadow_ancestor(widget)
+
+    def _normalize_dependent_anim_props(self, widget: QWidget, ctx: WidgetContext) -> None:
+        """
+        Clamp radius values against the same pending box model that is about to be applied.
+
+        Overshooting easing curves can push radius beyond the target box's safe cap while
+        width/height/radius animations tick separately. Normalizing immediately before the
+        batched stylesheet write prevents Qt from seeing an invalid radius and snapping square.
+        """
+        props = ctx.css_anim_props
+        box_props = {**ctx.style_box_props, **props}
+        box_size = target_border_radius_box_size(widget, box_props)
+        for prop in BORDER_RADIUS_PROPS:
+            raw = props.get(prop)
+            parsed = parse_css_numeric(raw)
+            if parsed is None:
+                continue
+            value, unit = parsed
+            clamped = clamp_border_radius(widget, prop, max(0.0, value), unit, box_props, box_size)
+            if clamped != value:
+                props[prop] = f"{clamped:.3f}{unit}"
 
     def _collect_rule_state(
         self, widget: QWidget, ctx: WidgetContext
@@ -706,7 +760,8 @@ class TransitionEngine(QObject):
         if parsed is None:
             return False
         value, unit = parsed
-        return clamp_border_radius(widget, prop, max(0.0, value), unit, target_props) != value
+        box_size = target_border_radius_box_size(widget, target_props)
+        return clamp_border_radius(widget, prop, max(0.0, value), unit, target_props, box_size) != value
 
     def _apply_prop_animation(
         self,
@@ -909,13 +964,16 @@ class TransitionEngine(QObject):
         if not anim_obj:
             return False
 
+        box_size = target_border_radius_box_size(widget, target_props) if prop in BORDER_RADIUS_PROPS else None
         if is_natural_target and isinstance(anim_obj, GenericPropertyAnimation):
             anim_obj.update_box_props(target_props)
-            anim_obj.set_target(target_raw, clean_on_finish=True)
+            anim_obj.set_target(target_raw, clean_on_finish=True, box_size=box_size)
         else:
             if isinstance(anim_obj, GenericPropertyAnimation):
                 anim_obj.update_box_props(target_props)
-            anim_obj.set_target(target_raw)
+                anim_obj.set_target(target_raw, box_size=box_size)
+            else:
+                anim_obj.set_target(target_raw)
 
         # Negative transition-delay: start immediately but seek |delay| ms into the timeline,
         # as if the animation had already been running that long (CSS spec §transition-delay).
@@ -1351,13 +1409,14 @@ class TransitionEngine(QObject):
             return
         ctx = self._ctx(widget)
         base_props, target_props, target_transitions, all_animated_props = self._collect_rule_state(widget, ctx)
+        ctx.style_box_props = dict(target_props)
         if prop not in all_animated_props:
             return
         needs_update = self._apply_prop_animation(
             widget, ctx, prop, base_props, target_props, target_transitions, EvaluationCause.DELAY_FIRE
         )
         if needs_update:
-            widget.setStyleSheet(scoped_anim_style(widget, ctx.css_anim_props))
+            self._flush_widget_style_now(widget, ctx)
 
     def _snap_prop_or_effect(
         self,
@@ -1376,7 +1435,12 @@ class TransitionEngine(QObject):
             else:
                 if isinstance(anim_obj, GenericPropertyAnimation):
                     anim_obj.update_box_props(target_props)
-                anim_obj.snap_to(target_raw)
+                    if prop in BORDER_RADIUS_PROPS:
+                        anim_obj.snap_to(target_raw, target_border_radius_box_size(widget, target_props))
+                    else:
+                        anim_obj.snap_to(target_raw)
+                else:
+                    anim_obj.snap_to(target_raw)
             return not isinstance(anim_obj, (OpacityAnimation, BoxShadowHandle))
         if prop in EFFECT_PROPS:
             new_anim = self._create_animation_obj(widget, prop, target_raw, 0, QEasingCurve.Type.Linear, target_props)
@@ -1391,7 +1455,8 @@ class TransitionEngine(QObject):
         parsed = parse_css_numeric(target_raw)
         if parsed is not None:
             value, unit = parsed
-            clamped = clamp_border_radius(widget, prop, max(0.0, value), unit, target_props)
+            box_size = target_border_radius_box_size(widget, target_props)
+            clamped = clamp_border_radius(widget, prop, max(0.0, value), unit, target_props, box_size)
             if clamped != value and prop in NON_NEGATIVE_PROPS:
                 ctx.css_anim_props[prop] = f"{clamped:.3f}{unit}"
                 return True
@@ -1457,7 +1522,16 @@ class TransitionEngine(QObject):
         """Instantiate the correct Animation subclass for a CSS property."""
         ctx = self._ctx(widget)
         if "color" in prop:
-            return ColorAnimation(widget, prop, initial_raw, duration_ms, curve, self, ctx=ctx)
+            return ColorAnimation(
+                widget,
+                prop,
+                initial_raw,
+                duration_ms,
+                curve,
+                self,
+                ctx=ctx,
+                style_flush_callback=self._schedule_style_flush,
+            )
         if prop == "opacity":
             return OpacityAnimation(
                 widget,
@@ -1474,6 +1548,15 @@ class TransitionEngine(QObject):
             if parsed is not None:
                 start_val, unit = parsed
                 return GenericPropertyAnimation(
-                    widget, prop, start_val, duration_ms, curve, self, unit=unit, ctx=ctx, box_props=box_props
+                    widget,
+                    prop,
+                    start_val,
+                    duration_ms,
+                    curve,
+                    self,
+                    unit=unit,
+                    ctx=ctx,
+                    box_props=box_props,
+                    style_flush_callback=self._schedule_style_flush,
                 )
         return None

{qt_css_engine-0.1.2 → qt_css_engine-0.1.3}/qt_css_engine/handlers.py

@@ -1,4 +1,5 @@
 import math
+from collections.abc import Callable
 
 from qt_css_engine.constants import BORDER_RADIUS_PROPS, NON_NEGATIVE_PROPS, SIZE_PROPS
 
@@ -13,22 +14,113 @@ from .utils import (
     interpolate_oklab,
     lerp_shadow,
     margin_side_px,
+    padding_side_px,
     parse_box_shadow,
     parse_color,
     parse_css_numeric,
     parse_css_val,
     scoped_anim_style,
     shadow_as_transparent,
+    total_border_px,
     update_shadow_ancestor,
 )
 
 
+def _numeric_px(raw: str | None) -> float | None:
+    parsed = parse_css_numeric(raw)
+    if parsed is None:
+        return None
+    value, unit = parsed
+    if unit != "px":
+        return None
+    return max(0.0, value)
+
+
+def _axis_sides(axis: str) -> tuple[str, str]:
+    return ("left", "right") if axis == "width" else ("top", "bottom")
+
+
+def _axis_margin_px(props: dict[str, str], axis: str) -> int:
+    side_a, side_b = _axis_sides(axis)
+    return margin_side_px(props, side_a) + margin_side_px(props, side_b)
+
+
+def _axis_padding_px(props: dict[str, str], axis: str) -> int:
+    side_a, side_b = _axis_sides(axis)
+    return padding_side_px(props, side_a) + padding_side_px(props, side_b)
+
+
+def _axis_border_px(widget: QWidget, props: dict[str, str], axis: str) -> int:
+    side_a, side_b = _axis_sides(axis)
+    return total_border_px(widget, props, side_a) + total_border_px(widget, props, side_b)
+
+
+def _target_content_axis_px(
+    widget: QWidget,
+    props: dict[str, str],
+    axis: str,
+    current_margin_box_px: float,
+) -> float | None:
+    explicit = _numeric_px(props.get(axis))
+    if explicit is not None:
+        return explicit
+
+    min_px = _numeric_px(props.get(f"min-{axis}"))
+    max_px = _numeric_px(props.get(f"max-{axis}"))
+    if min_px is None and max_px is None:
+        return None
+
+    extras = _axis_margin_px(props, axis) + _axis_padding_px(props, axis) + _axis_border_px(widget, props, axis)
+    current_content = max(0.0, current_margin_box_px - extras)
+    target = current_content
+    if min_px is not None:
+        target = max(target, min_px)
+    if max_px is not None:
+        target = min(target, max_px)
+    return max(0.0, target)
+
+
+def _target_margin_box_axis_px(
+    widget: QWidget,
+    props: dict[str, str],
+    axis: str,
+    current_margin_box_px: float,
+) -> float | None:
+    content_px = _target_content_axis_px(widget, props, axis, current_margin_box_px)
+    if content_px is None:
+        return None
+    extras = _axis_margin_px(props, axis) + _axis_padding_px(props, axis) + _axis_border_px(widget, props, axis)
+    return content_px + extras
+
+
+def target_border_radius_box_size(widget: QWidget, box_props: dict[str, str]) -> tuple[float, float] | None:
+    """Return target margin-box size implied by target size props, if any."""
+    width = widget.width()
+    height = widget.height()
+    if width <= 0 or height <= 0:
+        hint = widget.sizeHint()
+        if width <= 0:
+            width = hint.width()
+        if height <= 0:
+            height = hint.height()
+
+    target_width = _target_margin_box_axis_px(widget, box_props, "width", float(width))
+    target_height = _target_margin_box_axis_px(widget, box_props, "height", float(height))
+    if target_width is None and target_height is None:
+        return None
+    return (
+        target_width if target_width is not None else float(width),
+        target_height if target_height is not None else float(height),
+    )
+
+
 def clamp_border_radius(
     widget: QWidget,
     prop: str,
     value: float,
     unit: str,
     box_props: dict[str, str] | None = None,
+    box_size: tuple[float, float] | None = None,
 ) -> float:
     """
     Clamp pixel border-radius values to Qt's maximum supported corner radius.
@@ -39,8 +131,11 @@ def clamp_border_radius(
     if unit != "px" or prop not in BORDER_RADIUS_PROPS:
         return value
     props = box_props or {}
-    width = widget.width()
-    height = widget.height()
+    if box_size is not None:
+        width, height = box_size
+    else:
+        width = widget.width()
+        height = widget.height()
     if width <= 0 or height <= 0:
         hint = widget.sizeHint()
         if width <= 0:
@@ -51,7 +146,7 @@ def clamp_border_radius(
     height -= margin_side_px(props, "top") + margin_side_px(props, "bottom")
     if width <= 0 or height <= 0:
         return value
-    return math.floor(min(value, min(width, height) / 2.0))
+    return float(math.floor(min(value, min(width, height) / 2.0)))
 
 
 class BoxShadowHandle(QObject):
@@ -189,11 +284,13 @@ class ColorAnimation(QObject):
         easing_curve: QEasingCurve | QEasingCurve.Type,
         parent: QObject | None = None,
         ctx: WidgetContext | None = None,
+        style_flush_callback: Callable[[QWidget, WidgetContext], None] | None = None,
     ) -> None:
         super().__init__(parent)
         self.widget = widget
         self.prop = prop
         self._ctx = ctx
+        self._style_flush_callback = style_flush_callback
         self.current_color = parse_color(initial_raw) if isinstance(initial_raw, str) else QColor(initial_raw)
         self.start_color = self.current_color
         self.end_color = self.current_color
@@ -213,17 +310,23 @@ class ColorAnimation(QObject):
         props: dict[str, str] = getattr(self.widget, "_css_anim_props", {})
         return props
 
+    def _request_style_flush(self, props: dict[str, str], *, update_shadow: bool = False) -> None:
+        if self._ctx is not None and self._style_flush_callback is not None:
+            self._style_flush_callback(self.widget, self._ctx)
+            return
+        self.widget.setStyleSheet(scoped_anim_style(self.widget, props))
+        if update_shadow:
+            update_shadow_ancestor(self.widget)
+
     def _on_tick(self, t: float) -> None:
-        """Write interpolated color to css_anim_props and refresh the widget stylesheet."""
+        """Write interpolated color to css_anim_props and request a stylesheet refresh."""
         if not is_qobject_alive(self.widget):
             self.anim.stop()
             return
         self.current_color = interpolate_oklab(self.start_color, self.end_color, t)
         props = self._props
         props[self.prop] = self.current_color.name(QColor.NameFormat.HexArgb)
-        self.widget.setStyleSheet(scoped_anim_style(self.widget, props))
-        if self.start_color.alpha() != 255 or self.end_color.alpha() != 255:
-            update_shadow_ancestor(self.widget)
+        self._request_style_flush(props, update_shadow=self.start_color.alpha() != 255 or self.end_color.alpha() != 255)
 
     def update_spec(self, duration_ms: int, easing_curve: QEasingCurve) -> None:
         """Update duration and easing curve without restarting the animation."""
@@ -299,14 +402,17 @@ class GenericPropertyAnimation(QObject):
         unit: str = "px",
         ctx: WidgetContext | None = None,
         box_props: dict[str, str] | None = None,
+        style_flush_callback: Callable[[QWidget, WidgetContext], None] | None = None,
     ) -> None:
         super().__init__(parent)
         self.widget = widget
         self.prop = prop
         self.unit = unit
         self._ctx = ctx
+        self._style_flush_callback = style_flush_callback
         self._box_props = dict(box_props or {})
         self.current_val = self._effective_anim_value(float(initial_val), unit)
+        self._target_box_size: tuple[float, float] | None = None
         # Captured at creation time (before any inline constraint is applied).
         # Used as the animation target when returning to natural/unconstrained state,
         # so we never call sizeHint() while min-width/max-width are still active.
@@ -317,6 +423,8 @@ class GenericPropertyAnimation(QObject):
         self.anim = QVariantAnimation(self)
         self.anim.setDuration(duration_ms)
         self.anim.setEasingCurve(easing_curve)
+        self.anim.setStartValue(self.current_val)
+        self.anim.setEndValue(self.current_val)
         self.anim.valueChanged.connect(self._on_tick)
         self.anim.finished.connect(self._on_finished)
 
@@ -332,6 +440,14 @@ class GenericPropertyAnimation(QObject):
         props: dict[str, str] = getattr(self.widget, "_css_anim_props", {})
         return props
 
+    def _request_style_flush(self, props: dict[str, str], *, update_shadow: bool = False) -> None:
+        if self._ctx is not None and self._style_flush_callback is not None:
+            self._style_flush_callback(self.widget, self._ctx)
+            return
+        self.widget.setStyleSheet(scoped_anim_style(self.widget, props))
+        if update_shadow:
+            update_shadow_ancestor(self.widget)
+
     def _effective_anim_value(self, value: float, unit: str | None = None) -> float:
         """Normalize values used as animation endpoints/current state for Qt-limited props."""
         resolved_unit = self.unit if unit is None else unit
@@ -339,26 +455,82 @@ class GenericPropertyAnimation(QObject):
             return clamp_border_radius(self.widget, self.prop, max(0.0, value), resolved_unit, self._box_props)
         return value
 
+    def _effective_target_value(
+        self,
+        value: float,
+        unit: str | None = None,
+        box_size: tuple[float, float] | None = None,
+    ) -> float:
+        """Normalize animation targets for Qt-limited props."""
+        resolved_unit = self.unit if unit is None else unit
+        if self.prop in BORDER_RADIUS_PROPS:
+            return clamp_border_radius(
+                self.widget,
+                self.prop,
+                max(0.0, value),
+                resolved_unit,
+                self._box_props,
+                box_size,
+            )
+        return value
+
     def update_box_props(self, box_props: dict[str, str]) -> None:
         """Update box-model props used for border-radius clamping."""
         self._box_props = dict(box_props)
 
-    def _on_tick(self, val: int | float) -> None:
-        """Write interpolated numeric value to css_anim_props and refresh the widget stylesheet."""
+    def _write_current_style_value_if_needed(self, target_raw: str, box_size: tuple[float, float] | None) -> None:
+        props = self._props
+        parsed_target = parse_css_numeric(target_raw)
+        target_needs_clamp = False
+        if parsed_target is not None and self.prop in BORDER_RADIUS_PROPS:
+            target_val, target_unit = parsed_target
+            target_needs_clamp = self._effective_target_value(target_val, target_unit, box_size) != target_val
+
+        written = max(0.0, self.current_val) if self.prop in NON_NEGATIVE_PROPS else self.current_val
+        written = clamp_border_radius(self.widget, self.prop, written, self.unit, self._box_props, box_size)
+        current_raw = props.get(self.prop)
+        current_parsed = parse_css_numeric(current_raw)
+        stored_matches = (
+            current_parsed is not None and current_parsed[1] == self.unit and abs(current_parsed[0] - written) < 1e-6
+        )
+        if stored_matches or (current_raw is None and not target_needs_clamp):
+            return
+        props[self.prop] = f"{written:.3f}{self.unit}"
+        self._request_style_flush(props, update_shadow=self.prop in SIZE_PROPS)
+
+    def _on_tick(self, val: int | float | None) -> None:
+        """Write interpolated numeric value to css_anim_props and request a stylesheet refresh."""
         if not is_qobject_alive(self.widget):
             self.anim.stop()
             return
-        self.current_val = self._effective_anim_value(float(val))
+        if val is None:
+            self.anim.stop()
+            return
+        final_box_size = (
+            self._target_box_size
+            if self.prop in BORDER_RADIUS_PROPS
+            and self._target_box_size is not None
+            and self.anim.currentTime() >= self.anim.duration()
+            else None
+        )
+        if final_box_size is not None:
+            self.current_val = self._effective_target_value(val, box_size=final_box_size)
+        else:
+            self.current_val = self._effective_anim_value(val)
         written = max(0.0, self.current_val) if self.prop in NON_NEGATIVE_PROPS else self.current_val
-        written = clamp_border_radius(self.widget, self.prop, written, self.unit, self._box_props)
+        written = clamp_border_radius(self.widget, self.prop, written, self.unit, self._box_props, final_box_size)
         props = self._props
         props[self.prop] = f"{written:.3f}{self.unit}"
-        self.widget.setStyleSheet(scoped_anim_style(self.widget, props))
-        if self.prop in SIZE_PROPS:
-            update_shadow_ancestor(self.widget)
+        self._request_style_flush(props, update_shadow=self.prop in SIZE_PROPS)
 
     def _on_finished(self) -> None:
         """Remove the inline size constraint when targeting the natural layout size."""
+        if self.prop in BORDER_RADIUS_PROPS and self._target_box_size is not None:
+            try:
+                self._on_tick(self.anim.endValue())
+            except RuntimeError:
+                pass
+        self._target_box_size = None
         if not self._clean_on_finish:
             return
         self._clean_on_finish = False
@@ -366,8 +538,7 @@ class GenericPropertyAnimation(QObject):
         if self.prop in props:
             del props[self.prop]
             try:
-                self.widget.setStyleSheet(scoped_anim_style(self.widget, props))
-                update_shadow_ancestor(self.widget)
+                self._request_style_flush(props, update_shadow=True)
             except RuntimeError:
                 pass
 
@@ -376,41 +547,58 @@ class GenericPropertyAnimation(QObject):
         self.anim.setDuration(duration_ms)
         self.anim.setEasingCurve(easing_curve)
 
-    def snap_to(self, value_raw: str) -> None:
+    def snap_to(self, value_raw: str, box_size: tuple[float, float] | None = None) -> None:
         """Instantly apply a CSS numeric value without animation."""
+        self._target_box_size = None
         self.anim.stop()
         self._clean_on_finish = False
         parsed = parse_css_numeric(value_raw)
         if parsed is not None:
             raw_val, unit = parsed
             self.unit = unit
-            self.current_val = self._effective_anim_value(raw_val, unit)
+            self.current_val = self._effective_target_value(raw_val, unit, box_size)
             self._anim_origin_val = self.current_val
             written = self.current_val
             if self.prop in BORDER_RADIUS_PROPS:
-                written = clamp_border_radius(self.widget, self.prop, max(0.0, written), self.unit, self._box_props)
+                written = clamp_border_radius(
+                    self.widget,
+                    self.prop,
+                    max(0.0, written),
+                    self.unit,
+                    self._box_props,
+                    box_size,
+                )
             self._props[self.prop] = f"{written:.3f}{self.unit}"
 
     def snap_to_natural(self) -> None:
         """Stop animation and remove this prop from css_anim_props (returns widget to natural layout)."""
+        self._target_box_size = None
         self.anim.stop()
         self._clean_on_finish = False
         props = self._props
         if self.prop in props:
             del props[self.prop]
 
-    def set_target(self, target_raw: str, clean_on_finish: bool = False) -> None:
+    def set_target(
+        self,
+        target_raw: str,
+        clean_on_finish: bool = False,
+        box_size: tuple[float, float] | None = None,
+    ) -> None:
         """Start or re-target the animation toward a new CSS numeric value."""
         parsed = parse_css_numeric(target_raw)
         if parsed is None:
             return
-        t_val = self._effective_anim_value(float(parsed[0]), parsed[1])
+        t_val = self._effective_target_value(parsed[0], parsed[1], box_size)
         is_running = self.anim.state() == self.anim.State.Running
         if is_running and t_val == self.anim.endValue():
             return
         if not is_running and abs(t_val - self.current_val) < 1e-6:
+            self._target_box_size = box_size
+            self._write_current_style_value_if_needed(target_raw, box_size)
             return
 
+        self._target_box_size = box_size
         # Specific for handling steps()
         is_steps = self.anim.easingCurve().type() == QEasingCurve.Type.Custom
         if is_steps and is_running and self._anim_origin_val is not None and abs(t_val - self._anim_origin_val) < 1e-6:
@@ -434,9 +622,9 @@ class GenericPropertyAnimation(QObject):
         self.anim.setStartValue(self.current_val)
         self.anim.setEndValue(t_val)
         self.anim.start()
-        # Explicitly tick so the initial value is immediately written to the scoped stylesheet
-        # TODO: test if needed
-        # self._on_tick(self.current_val)
+        # Force the start frame into the scoped stylesheet immediately. Qt may defer the
+        # first valueChanged tick, which lets freshly polished class styles flash through.
+        self._on_tick(self.current_val)
 
 
 class OpacityAnimation(QObject):

{qt_css_engine-0.1.2 → qt_css_engine-0.1.3}/qt_css_engine/types.py

@@ -76,6 +76,13 @@ class WidgetContext:
     clicked_anim_callbacks: dict[str, Callable[[], None]] = field(
         default_factory=lambda: dict[str, Callable[[], None]]()
     )
+    # Last target rule props seen during evaluation. Batched flushes merge these with
+    # css_anim_props so radius clamping can still see unchanged margin/border values.
+    style_box_props: dict[str, str] = field(default_factory=lambda: dict[str, str]())
+    # True while an inline stylesheet flush is queued for this widget.
+    style_flush_pending: bool = False
+    # True while class-change evaluation must synchronously restore inline animation styles.
+    style_flush_immediate: bool = False
 
 
 @dataclass

qt_css_engine-0.1.3/tests/conftest.py

@@ -0,0 +1,48 @@
+import gc
+import sys
+from collections.abc import Generator
+from typing import Any
+
+import pytest
+
+from qt_css_engine import TransitionEngine
+from qt_css_engine.qt_compat.QtCore import QCoreApplication, QEvent
+from qt_css_engine.qt_compat.QtWidgets import QApplication
+
+
+@pytest.fixture(scope="session")
+def _app() -> QApplication:  # type: ignore[reportUnusedFunction]
+    instance = QApplication.instance()
+    if instance is None:
+        instance = QApplication(sys.argv)
+    assert isinstance(instance, QApplication)
+    return instance
+
+
+@pytest.fixture(autouse=True)
+def cleanup_deferred_deletes(monkeypatch: pytest.MonkeyPatch) -> Generator[None]:
+    """
+    Prevents PySide6 test crashes by keeping the TransitionEngine alive while flushing
+    pending DeferredDelete events. This avoids a race condition where Shiboken garbage
+    collects the C++ parent engine before the event loop deletes its child animations.
+    """
+
+    engines_in_test: list[Any] = []
+    old_init = TransitionEngine.__init__
+
+    def new_init(self: Any, *args: Any, **kwargs: Any) -> None:
+        old_init(self, *args, **kwargs)
+        engines_in_test.append(self)
+
+    monkeypatch.setattr(TransitionEngine, "__init__", new_init)
+
+    yield
+
+    # Force processing of any pending DeferredDelete events while engines are still alive
+    QCoreApplication.sendPostedEvents(None, QEvent.Type.DeferredDelete)
+    # Process other events
+    QCoreApplication.processEvents()
+
+    # Clear references to allow GC
+    engines_in_test.clear()
+    gc.collect()

{qt_css_engine-0.1.2 → qt_css_engine-0.1.3}/tests/test_anim.py

@@ -1317,6 +1317,31 @@ def test_generic_border_radius_animation_clamped_to_half_min_side(_app: QApplica
     destroy(widget)
 
 
+def test_generic_border_radius_steps_reverse_keeps_qvariant_endpoints_float(_app: QApplication) -> None:
+    widget = QWidget()
+    widget.resize(100, 100)
+    ctx = WidgetContext()
+    anim = GenericPropertyAnimation(
+        widget,
+        "border-bottom-left-radius",
+        0.0,
+        100,
+        make_steps_curve(1, "jump-end"),
+        ctx=ctx,
+    )
+
+    anim.set_target("20px")
+    anim.anim.setCurrentTime(50)
+    anim.set_target("0px")
+    anim.anim.setCurrentTime(50)
+
+    assert isinstance(anim.anim.startValue(), float)
+    assert isinstance(anim.anim.endValue(), float)
+    assert anim.anim.currentValue() is not None
+
+    destroy(widget)
+
+
 def test_generic_border_radius_uses_size_hint_when_geometry_unset(_app: QApplication) -> None:
     widget = FixedHintWidget()
     widget.resize(0, 0)

{qt_css_engine-0.1.2 → qt_css_engine-0.1.3}/tests/test_css_parser.py

@@ -514,6 +514,32 @@ def test_border_shorthand_keyword_width() -> None:
     assert rule.properties["border-bottom-color"] == "blue"
 
 
+def test_border_shorthand_rgba_color() -> None:
+    css = ".box { border: 3px solid rgba(255, 0, 0, 0.5); }"
+    _, rules = extract_rules(css)
+    rule = get_rule(rules, ".box")
+    expected = "rgba(255, 0, 0, 0.5)"
+    assert rule.properties["border-top-width"] == "3px"
+    assert rule.properties["border-style"] == "solid"
+    assert rule.properties["border-top-color"] == expected
+    assert rule.properties["border-right-color"] == expected
+    assert rule.properties["border-bottom-color"] == expected
+    assert rule.properties["border-left-color"] == expected
+
+
+def test_border_color_shorthand_rgba_color() -> None:
+    css = ".box { border-color: rgba(255, 0, 0, 0.5); }"
+    _, rules = extract_rules(css)
+    rule = get_rule(rules, ".box")
+    expected = "rgba(255, 0, 0, 0.5)"
+    assert rule.properties == {
+        "border-top-color": expected,
+        "border-right-color": expected,
+        "border-bottom-color": expected,
+        "border-left-color": expected,
+    }
+
+
 def test_transition_border_expands_to_animatable_longhands() -> None:
     """transition: border should cover width sides + border-color, but NOT border-style."""
     css = ".box { transition: border 200ms ease; }"

{qt_css_engine-0.1.2 → qt_css_engine-0.1.3}/tests/test_engine_coverage.py

@@ -429,6 +429,49 @@ def test_transition_all_return_trip_engine_managed_props(_app: QApplication) ->
     destroy(widget)
 
 
+def test_class_change_initial_tick_flushes_inline_style_immediately(_app: QApplication) -> None:
+    engine = make_engine("""
+        .box { background-color: red; transition: background-color 300ms; }
+        .box.on { background-color: blue; }
+    """)
+    widget = TrackedWidget()
+    widget.setProperty("class", "box on")
+    ctx = engine._ctx(widget)
+    ctx.css_anim_props["background-color"] = "red"
+
+    count_before = widget.setStyleSheet_count
+    engine._evaluate_widget_state(widget, cause=EvaluationCause.CLASS_CHANGE)
+
+    assert widget.setStyleSheet_count > count_before
+    assert not ctx.style_flush_pending
+    assert ctx.css_anim_props["background-color"] == QColor("red").name(QColor.NameFormat.HexArgb)
+    destroy(widget)
+
+
+def test_class_change_numeric_initial_tick_flushes_start_size_immediately(_app: QApplication) -> None:
+    engine = make_engine("""
+        .box { width: 22px; transition: width 300ms; }
+        .box.focused { width: 50px; }
+    """)
+    widget = TrackedWidget()
+    widget.setProperty("class", "box")
+    widget.resize(22, 22)
+    ctx = engine._ctx(widget)
+
+    widget.setProperty("class", "box focused")
+    count_before = widget.setStyleSheet_count
+    engine._on_class_change(widget)
+
+    assert widget.setStyleSheet_count > count_before
+    assert not ctx.style_flush_pending
+    anim = _get_anim(engine, widget, "width")
+    assert isinstance(anim, GenericPropertyAnimation)
+    assert ctx.css_anim_props["width"] == f"{float(anim.anim.startValue()):.3f}px"
+    assert anim.anim.state() == QAbstractAnimation.State.Running
+    assert anim.anim.endValue() == pytest.approx(50.0)
+    destroy(widget)
+
+
 # ---------------------------------------------------------------------------
 # :focus animation end-to-end
 # ---------------------------------------------------------------------------
@@ -589,6 +632,148 @@ def test_border_radius_animation_target_clamped_to_half_min_side(_app: QApplicat
     destroy(widget)
 
 
+def test_border_radius_target_clamp_uses_target_min_max_size(_app: QApplication, qtbot: QtBot) -> None:
+    engine = make_engine("""
+        .ws-btn {
+            margin: 2px 4px;
+            min-width: 20px;
+            max-width: 20px;
+            min-height: 20px;
+            max-height: 20px;
+            border: 2px solid #5e666a;
+            border-radius: 13px;
+            transition: all 300ms ease;
+        }
+        .ws-btn:hover {
+            margin: 2px 4px;
+            min-width: 40px;
+            max-width: 40px;
+            min-height: 40px;
+            max-height: 40px;
+            border-radius: 99px;
+            border: 2px solid #a7c080;
+        }
+    """)
+    widget = QPushButton()
+    widget.setProperty("class", "ws-btn")
+    # Base margin-box: content 20 + border 4 + horizontal margin 8; height uses vertical margin 4.
+    widget.resize(32, 28)
+    hover_widget(engine, widget)
+
+    for corner in (
+        "border-top-left-radius",
+        "border-top-right-radius",
+        "border-bottom-right-radius",
+        "border-bottom-left-radius",
+    ):
+        anim = _get_anim(engine, widget, corner)
+        assert isinstance(anim, GenericPropertyAnimation)
+        assert anim.anim.endValue() == pytest.approx(22.0), f"{corner} should clamp against the 40px target size"
+
+    qtbot.wait(350)
+    ctx = engine._ctx(widget)
+    for corner in (
+        "border-top-left-radius",
+        "border-top-right-radius",
+        "border-bottom-right-radius",
+        "border-bottom-left-radius",
+    ):
+        assert ctx.css_anim_props.get(corner) == "22.000px", f"{corner} should finish at the target-size clamp"
+    destroy(widget)
+
+
+def test_batched_flush_clamps_overshooting_radius_against_pending_size(_app: QApplication) -> None:
+    engine = make_engine("""
+        .box {
+            width: 50px;
+            height: 50px;
+            border-radius: 13px;
+            transition: all 200ms cubic-bezier(0.175, 0.885, 0.32, 1.75);
+        }
+        .box:hover {
+            width: 40px;
+            height: 40px;
+            border-radius: 99px;
+        }
+    """)
+    widget = TrackedWidget()
+    widget.setProperty("class", "box")
+    widget.resize(50, 50)
+    hover_widget(engine, widget)
+
+    ctx = engine._ctx(widget)
+    radius_anim = _get_anim(engine, widget, "border-top-left-radius")
+    width_anim = _get_anim(engine, widget, "width")
+    height_anim = _get_anim(engine, widget, "height")
+    assert isinstance(radius_anim, GenericPropertyAnimation)
+    assert isinstance(width_anim, GenericPropertyAnimation)
+    assert isinstance(height_anim, GenericPropertyAnimation)
+
+    count_before = widget.setStyleSheet_count
+    radius_anim._on_tick(24.6)  # live 50px geometry allows this, but pending 40px target does not.
+    width_anim._on_tick(40.0)
+    height_anim._on_tick(40.0)
+
+    assert float(ctx.css_anim_props["border-top-left-radius"].removesuffix("px")) > 20.0
+    assert ctx.style_flush_pending
+
+    _app.processEvents()
+
+    assert widget.setStyleSheet_count == count_before + 1
+    assert ctx.css_anim_props["border-top-left-radius"] == "20.000px"
+    assert not ctx.style_flush_pending
+    destroy(widget)
+
+
+def test_class_change_noop_radius_rewrites_stale_larger_clamp(_app: QApplication) -> None:
+    engine = make_engine("""
+        .ws-btn {
+            margin: 2px 4px;
+            width: 22px;
+            height: 22px;
+            border: 2px solid #5e666a;
+            border-radius: 99px;
+            transition: all 200ms cubic-bezier(0.175, 0.885, 0.32, 1.75);
+        }
+        .ws-btn:hover {
+            width: 40px;
+            height: 40px;
+            border-radius: 99px;
+        }
+        .ws-btn.active_populated {
+            border-radius: 99px;
+        }
+        .ws-btn.focused_populated {
+            width: 50px;
+            border-radius: 99px;
+        }
+    """)
+    widget = QPushButton()
+    widget.setProperty("class", "ws-btn active_populated focused_populated")
+    widget.resize(50, 30)
+    ctx = engine._ctx(widget)
+    for corner in (
+        "border-top-left-radius",
+        "border-top-right-radius",
+        "border-bottom-right-radius",
+        "border-bottom-left-radius",
+    ):
+        ctx.css_anim_props[corner] = "22.000px"
+
+    widget.setProperty("class", "ws-btn active_populated")
+    engine._on_class_change(widget)
+
+    for corner in (
+        "border-top-left-radius",
+        "border-top-right-radius",
+        "border-bottom-right-radius",
+        "border-bottom-left-radius",
+    ):
+        assert ctx.css_anim_props[corner] == "13.000px"
+        assert ctx.active_animations[corner].anim.state() != QAbstractAnimation.State.Running
+    destroy(widget)
+
+
 def test_border_radius_sidebar_qframe_clamps_to_margin_box(_app: QApplication) -> None:
     css = """
         .sidebar {

qt_css_engine-0.1.2/tests/conftest.py

@@ -1,14 +0,0 @@
-import sys
-
-import pytest
-
-from qt_css_engine.qt_compat.QtWidgets import QApplication
-
-
-@pytest.fixture(scope="session")
-def _app() -> QApplication:  # type: ignore[reportUnusedFunction]
-    instance = QApplication.instance()
-    if instance is None:
-        instance = QApplication(sys.argv)
-    assert isinstance(instance, QApplication)
-    return instance