drawnui-react 0.1.0-preview.14 → 0.1.0-preview.16

package/SKIPPED.md

@@ -10,14 +10,15 @@ DrawnUi name and semantics; nothing here is a redesign, only an omission.
 | `UseCache` | partial | `None`, `Operations` / `OperationsFull` (SkPicture replay), `Image` (offscreen surface snapshot, GPU-backed on WebGL, nearest-sampled blit), `ImageDoubleBuffered` (`RenderObjectPrevious` kept and drawn when a new cache cannot be produced yet, `DrawPlaceholder(ctx)` hook when there is none; recording itself is synchronous — no background thread, same as DrawnUi.Blazor with `CanUseCacheDoubleBuffering = false`), `ImageComposite` / `ImageCompositeGPU` (per-child composite, see the `UseCache="ImageComposite"` row below). `GPU` resolves to `Image` and `ImageCompositeGPU` to `ImageComposite`: no separate GPU-only path. `Super.CacheEnabled`, `RenderObject`/`CachedObject`, `InvalidateCache`, `DestroyRenderingObject`, `Canvas.DisposeObject` (deleted after flush). Defaults per C#: `SkiaLabel`/`SkiaSvg` Operations, everything else None. Not ported: `CacheSharing`, `AllowCaching`, offscreen bake threads, cache validity by GRContext. |
 | Incremental invalidation | partial | `Measure` returns the previous size when `!NeedMeasure` and constraints+scale are unchanged; `Update()`/`InvalidateMeasure()` bubble up and stale every ancestor cache; `Repaint()` keeps caches. Arrange still runs per frame for the whole tree; no dirty regions, no `DirtyChildrenTracker`. Post-animators on a control nested INSIDE a cached ancestor are drawn only when that ancestor re-records. |
 | Gestures core: `Canvas.Gestures` (Disabled/Enabled/Lock), `ProcessGestures(args, apply)`, `ConsumeGestures`, `Tapped`/`ChildTapped`, `InputTransparent`, `BlockGesturesBelow`, `LockChildrenGestures`, `HitBoxAuto`/`HitIsInside`/`IsGestureForChild`, `SkiaGesturesParameters`/`GestureEventProcessingInfo`/`SkiaGesturesInfo`/`ControlTappedEventArgs` | ported | Pointer events -> per-pointer `OnTouchAction` state machine (port of DrawnUi.Blazor) -> Down/Panning/Tapped/Up, queued and processed at frame start. Tap slop = 16pt like AppoMobi TouchEffect. The control that consumes a gesture keeps receiving it until it lets go (DrawnUi `Canvas.HadInput`, one pointer here instead of C#'s set): without it a drag handle, a slider thumb or a held button stops getting `Panning` the moment the finger leaves its box, and a control that stops consuming hands routing straight back to the tree (a button whose press turns into a scroll pan). Every mouse button is delivered (`Event.Pointer`: `Button`, `ButtonNumber`, `DeviceType`, `PressedButtons`, the AppoMobi.Gestures PointerData): a right click is Down / Up / Tapped with `Button` "Right" plus a `ContextMenu`; handlers that must be primary-only check `e.Parameters.Event.Pointer?.Button`. |
-| Gestures: `LongPressing`, `Pointer` (hover), multi-touch pinch, `SoftLock`, `AddGestures` attached props, `OnGestures` delegate | skipped | The enum members exist for parity and are never produced; there is no pinch member at all. Ported instead of skipped: velocity (`Gestures.ts` fills `Distance.Velocity` per move, the scroll / snapping physics run on it) and transform-aware mapping — a child receives the point through the inverse `RenderTransformMatrix` (`TransformPointToLocalSpace`), so rotated / scaled / translated controls hit-test correctly. `ChildOffset` stays zero because that inverse matrix replaces the C# cache-offset math (`TranslateInputCoords`), not because transforms are missing. `Wheel` IS produced (`Canvas.onWheel`). |
+| Gestures: `LongPressing`, `Pointer` (routed as a gesture; hover itself is ported, see `ReceivesHover`), multi-touch pinch, `SoftLock`, `AddGestures` attached props, `OnGestures` delegate | skipped | The enum members exist for parity and are never produced; there is no pinch member at all. Ported instead of skipped: velocity (`Gestures.ts` fills `Distance.Velocity` per move, the scroll / snapping physics run on it) and transform-aware mapping — a child receives the point through the inverse `RenderTransformMatrix` (`TransformPointToLocalSpace`), so rotated / scaled / translated controls hit-test correctly. `ChildOffset` stays zero because that inverse matrix replaces the C# cache-offset math (`TranslateInputCoords`), not because transforms are missing. `Wheel` IS produced (`Canvas.onWheel`). |
 | C# multi-subscriber `event`s | changed shape | One callback per event prop (`Tapped={fn}`), same names. `Command*` (ICommand) variants not ported. |
 | `Opacity`, `TranslationX/Y`, `Rotation`, `ScaleX/Y` (+`Scale`), `SkewX/Y`, `AnchorX/Y`, `HasTransform`, `RenderTransformMatrix`, `TransformPointToLocalSpace` | ported | Same matrix order as C# `ApplyTransforms` (pivot → rotation → scale/skew → translation), opacity = `saveLayer` alpha over the subtree, gestures mapped through the inverse matrix (`IsGestureForChild`, child receives the local point), accessibility rect = transformed bounds. Animations: `AnimateAsync`, `AnimateRangeAsync`, `FadeToAsync`, `ScaleToAsync`, `TranslateToAsync`, `RotateToAsync` as Promises with `AbortSignal` (one running per kind, like the C# per-property cancellation). Not ported: `RotationX/Y/Z`, `TranslationZ`, `Perspective1/2`, `CameraAngle`, `LinkTransforms`, `AddTranslationX/Y`, `UseTranslation*` overrides, `CustomizeLayerPaint`, `SkipRenderingOutOfBounds`. |
 | `Left` / `Top` | ported (as a translate) | Same paint-time offset in points, but folded into the render matrix (a `canvas.translate`, hit-testing follows) for every control, cached or not; C# applies them only when blitting a cache. |
 | `AnimatedFramesRenderer` / `SkiaLottie` / `SkiaGif` | ported | `AutoPlay`, `Repeat`, `SpeedRatio`, `DefaultFrame` (-1 = last), `Start(delay)`/`Stop`/`Seek`, `IsPlaying`, `Started`/`Finished`, `PlayWhenAvailable`, `GetFrameAt`. Lottie on CanvasKit Skottie (needs the `full` build, +0.9 MB raw wasm): `Source` (URL / app path, JSON cached per source, in-flight dedup), `ColorTint` / `Colors` (C# `ApplyTint` JSON rewrite), `IsOn` + `DefaultFrameWhenOn` + `ApplyIsOnWhenNotPlaying`, `StopAtCurrentFrame`, `ProcessJson`, `GoToStart`/`GoToEnd`, `SetAnimation`, `LoadSource`, `CreateAnimation`, `TotalFrames`; `UseCache=ImageDoubleBuffered` re-recorded per frame. GIF on CanvasKit AnimatedImage: every frame decoded once (`GifAnimation`: `SeekFrame`, `GetFrameNumber`, `DurationMs`, `TotalFrames`), `Aspect` (AspectFitFill), alignment, `Success`/`Error`. Not ported: `SkiaGif.Display` inner SkiaImage (frames are drawn directly), custom-control ctor `SkiaGif(display)`, `SkiaLottie` Skottie property/slot editing, sound, `ReloadSource` sync file paths, `Dispose` wiring on unmount (no engine hook from the reconciler yet). |
 | `SkiaBackdrop` | ported | `Blur` (5), `Brightness` (gamma), `UseContext`, `BackgroundColor` tint, `HasEffects`, `GetImage`; children drawn first and blurred with the snapshot (C# order); `UseContext` snapshots the surface the pixels end up on (on-screen, or the nearest Image cache surface through its `Origin`), also while an Operations picture is being recorded, since caches record inline; after each paint the ancestors' caches are staled for the next frame (no frame requested) so content that changes beneath without invalidating this branch (an image loading later) is picked up by the next frame. Used by the shell popups/modals (`ShellDefaults.PopupsBackgroundBlur`). Not ported: `CacheSource`, the ghost mode. |
 | Disposal (`Dispose` / `OnDisposing`) | ported | The React renderer calls `Dispose()` when an element leaves the tree (`detachDeletedInstance`): caches, gradient shaders, running `*ToAsync` animations, overlay effects, the accessibility node, then the children (static and templated pool); `SkiaScroll`/`SnappingLayout` stop their animators, `SkiaSvg` drops its raster, `SkiaLottie`/`SkiaGif` free the Skottie animation / frames; `Canvas.Dispose` disposes the content. Not ported: `IsDisposing` staged disposal, `Disposing` event, `OnWillDisposeWithChildren`. |
-| `KeyboardManager` | ported | Window-level keydown / keyup capture listeners like `drawnui-keyboard.js`: `KeyDown` / `KeyUp` with the DOM `event.code` ("KeyA", "ArrowLeft"; C# maps the same codes to `InputKey`), `KeyChar` for printable keys without Ctrl / Alt / Meta, `IsShiftPressed` / `IsControlPressed` / `IsAltPressed`, `AttachToKeyboard` (idempotent, pointerdown pulls window focus inside iframes), `BlurExternalTextInput`; `Subscribe` / `Unsubscribe` instead of C# events. Not ported: `InputKey` enum (codes are strings). |
+| Hover: `ReceivesHover` (opt-in; on by default in SkiaButton, SkiaSlider, the toggles, SkiaRadioButton, SkiaCarousel, SkiaDrawer), `IsHovered`, `HoverChanged` (turns `ReceivesHover` on, as C# `OnHovered`) | ported | drawnui-cross 6m: every opted-in control under the mouse is hovered; nothing changes while a scroll, carousel or drawer moves its content, one check at the last pointer position when it stops and after an add / remove, a rebind, a hidden hovered control or an instant scroll jump; pointerleave clears at once; touch never hovers (`Canvas.Hover`, a `HoverManager`). Not ported: C# `SetHover`, `CheckHovered` / `OnHover` / `IsPointerOver` (no Pointer gestures are routed), SkiaSpinner / wheel picker (no such controls). |
+| `KeyboardManager` | ported | Window-level keydown / keyup capture listeners like `drawnui-keyboard.js`: `KeyDown` / `KeyUp` with the DOM `event.code` ("KeyA", "ArrowLeft"; C# maps the same codes to `InputKey`), `KeyChar` for printable keys without Ctrl / Alt / Meta, `IsShiftPressed` / `IsControlPressed` / `IsAltPressed`, `AttachToKeyboard` (idempotent, pointerdown pulls window focus inside iframes), `BlurExternalTextInput`, `IsOwnedByElement` / `IsInputMethodKey` (React additions: a handler acting on keys skips keys a focused DOM element or the input method owns, C# 845b26e9); `Subscribe` / `Unsubscribe` instead of C# events. Not ported: `InputKey` enum (codes are strings). |
 | `SkiaEditor` | partial | SkiaShape host with padding, content `SkiaLabel` (single-line: `HorizontalTextAlignment` Center / End get the field as the label's minimum width, so short text centers and long text still scrolls), placeholder label, caret (blinking 1 s, `CursorColor`, `CanShowCursor`) and selection overlay (`SelectionColor`) painted by the editor, single line (`MaxLines` 1, scrolls horizontally to the caret) / multiline (`MaxLines` != 1, `AutoHeight`) with own scroll offsets instead of the C# inner `SkiaScroll`; `Text` (line breaks normalized, spaces for single line), `PlaceholderText/Color/HorizontalAlignment`, `FontSize` (12) / `FontFamily` / `FontWeight` / `TextColor` / `TextGradient` / `LineHeight` / `Horizontal|VerticalTextAlignment`, `IsPassword` (bullets), `ReturnType` (Send submits multiline), `KeyboardType` / `IsSpellCheckEnabled` / `UseMarkdown` / `UseUnicode` accepted, `CursorPosition`, `SelectionLength`, `IsFocused` (one focused editor at a time), `ControlStyle` (C# `ApplyControlStyleVisuals` palettes over unset values), events `TextChanged` / `FocusChanged` / `CursorMoved` / `TextSubmitted`, `Submit` / `SelectAll` / `SetSelection` / `SelectWord` / `GetSelectedText` / `DeleteSelection` / `InsertAtCursor` / `CutSelection` / `CopySelection` / `PasteFromClipboard` (navigator.clipboard), the Blazor head stubs `StubTypeText` / `StubPressEnter` / `StubBackspace` / `StubDelete` (grapheme clusters via Intl.Segmenter) / `StubMoveCursor` / `StubSelectRange` / `StubSelectAll` / `HandleVerticalArrow`, Ctrl+A / C / X / V, Home / End, Escape blurs, tap places the caret, drag selects, long press selects a word, shift + tap extends. Keys come from `KeyboardManager` like the Blazor / Wasm heads; on top of that (not in DrawnUi.Blazor) a focused editor is mirrored by a hidden DOM textarea (`TextInputProxy`, `inputmode` from `KeyboardType`, `enterkeyhint` from `ReturnType`) so IME composition, the mobile soft keyboard, autocorrect and native paste / cut / undo reach the editor: every input event is diffed against the editor text and replayed through `StubSelectRange` + `StubTypeText` / `StubBackspace` / `StubPressEnter`; while the proxy holds DOM focus, Backspace / Delete / Enter / Ctrl+C / X / V key events are left to it. iOS may need a second tap for the keyboard (focus() runs on the next frame, outside the touch handler). Not ported: `SkiaCursor` control + `CursorGradient`, `SkiaEditorSelection` handles, `Superview.FocusedChild`, `CommandOn*`, `SkiaEditorDocument` (rich formatting), single-line Enter clearing focus (Blazor keeps it). |
 | `SkiaSprite` / `SkiaSpriteSet` | ported | Sprite: `Source` (sheets cached per source, `CachedSpriteSheets`), `Columns` / `Rows` / `MaxFrames`, `FramesPerSecond` (24), `FrameSequence` / `AnimationName` + `CreateAnimationSequence` / `RegisteredAnimations`, `CurrentFrame`, `TotalFrames` / `DurationMs` / `FrameDurationMs` / `FrameWidth` / `FrameHeight`, `ApplyPlacementConfig` (units-per-pixel, size, anchor, offset = C# SpriteFrameImage ResolveFrameMetrics), transparent frame borders trimmed per frame (pixels read once), nearest sampling, AspectFit of the frame, `DisplayRect`, `Success` / `Error`, the AnimatedFramesRenderer playback. Set: `State`, `Define(state, source, columns, rows, fps, repeat, autoPlay, placement)`, `CurrentSprite`, `OnChangeState` hook, hit box from the drawn frame. Not ported: `Display` as a separate SkiaImage child (`SpriteFrameImage`) and the standalone `SkiaSprite(display)` ctor, `RescalingQuality` other than None, `InflateAmount`, `ClearCache` / `RemoveFromCache` (SkiaImageManager owns the images), `SkiaSpriteSet.InvalidateInternal`. Code-behind subclasses (FastRepro `WarriorSprite`) mount through a ref + `AddSubView` and are disposed by the mounting effect. |
 | `IsClippedToBounds`, `ClipEffects` | ported | Clip to `DrawingRect` around content, children and post-animators; `ClipEffects=false` grows the clip by the aggregated effects margin so a child's shadow/glow can escape. Layouts aggregate their children's effects margins (C# `AggregatedEffectsMarginPixels`), cached per control and reset by `InvalidateMeasure`. Not ported: `Clipping` callback, `ClipWith`, `ClipFrom`, platform clips; C# currently ignores `ClipEffects` in its render path (always expands). |
@@ -61,7 +62,7 @@ DrawnUi name and semantics; nothing here is a redesign, only an omission.
 
 | Control | Status | Notes |
 |---|---|---|
-| `SkiaLayout` Absolute / Column / Row (+ `SkiaStack`, `SkiaRow`, `SkiaLayer`) | ported | `Spacing`, `Padding`, `Children`/`Views`, `AddSubView`/`RemoveSubView`/`InsertSubView`. |
+| `SkiaLayout` Absolute / Column / Row (+ `SkiaStack`, `SkiaRow`, `SkiaLayer`) | ported | `Spacing`, `Padding`, `Children`/`Views`, `AddSubView`/`RemoveSubView`/`InsertSubView`, `ClearChildren`, `IsChildrenItem`. Children changes follow C# `ChildrenCollectionSync` (insert / move / reset in collection order inside the slots app children occupy); React has no `ObservableCollection`: JSX children diffs and a new `Children` list are the collection actions. |
 | `SkiaLayout` templated (Column only): `ItemsSource` (array), `ItemTemplate` (factory `() => SkiaControl`), `RecyclingTemplate` Enabled/Disabled, `MeasureItemsStrategy` `MeasureAll` (default, per-item size) / `MeasureFirst` (explicit uniform, O(1) for 100k items), `ChildrenFactory` (ViewsAdapter pool: `GetOrCreateViewForIndex`, `ReleaseViewAt`), `FirstVisibleIndex`/`LastVisibleIndex`, `DebugString`, `ApplyItemsSource`, `VirtualisationInflated`, `BindingContext`/`ContextIndex` on every control, `SkiaDynamicDrawnCell.SetContent` | ported | Cells realized/bound/arranged/drawn only for the visible viewport (+inflation) each frame. |
 | `LoadMoreCommand` / `LoadMoreTopCommand` / `LoadMoreOffset` / `LoadMoreTopOffset` | ported | Callbacks instead of ICommand. Bottom fires once per content extent when within the offset of the end (or when the content underfills the viewport), re-arms when the content grows or the user moves away (>offset+100 pt, >2 s) — C# CheckNeedToLoadMore. Top arms only after the offset left the top edge, fires when it comes back. Not ported: opposite-direction cooldown (`IsOppositeLoadMoreBlocked`), `IInsideViewport.ShouldTriggerLoadMore`. |
 | Structure-preserving `ItemsSource` updates | ported (array diff) | C# listens to `ObservableCollection` Add/Insert; React apps replace the array, so the setter detects **append** (old is a prefix: measured heights kept, tail measured lazily) and **prepend** (old is a suffix: view indices shifted without rebinding, new head measured synchronously up to 200 items, `ItemsInsertedAtStart(px)` lets the `SkiaScroll` move its offset so visible rows stay put — C# head-insert rebase). and **reorder** (same items permuted, the C# `ObservableCollection.Move` case: contexts rebound, the index-keyed measured heights permuted with their items, nothing re-measured, extent and scroll offset unchanged). Any other change rebuilds the structure (heights re-measured, offset kept). Not ported: removals in place, `Replace`. |
@@ -81,7 +82,7 @@ DrawnUi name and semantics; nothing here is a redesign, only an omission.
 | `SkiaShape` (+ `SkiaFrame`) | partial | `BevelType` Bevel / Emboss + `Bevel` (`Depth`, `LightColor`, `ShadowColor`, `Opacity`; C# `PaintBevelEffect` edge paths for Rectangle, rounded Rectangle, Circle/Ellipse, Polygon, Path via ContourMeasure halves).  `Shadows` (`SkiaShadow` X/Y/Blur/Opacity/Color/ShadowOnly, plain literals accepted): fill painted once per shadow with a DropShadow image filter (C# `PaintWithShadowsInternal`), hollow shapes clip their outline away so only the outside shadow remains; caches record the effects margin (`3·Blur·scale ± offset`, C# `MergeShadowMargin`) via `ComputeEffectsMargin`/`ExpandedCacheRect`. Not ported: `PlatformShadow` (MAUI `Shadow` brush), `ExpandDirtyRegion`, bevel/emboss. `Type` Rectangle/Circle/Ellipse/Arc (`Value1` start, `Value2` sweep)/Polygon+Line (`Points` ratios)/Path (`PathData`, fitted + centered), `CornerRadius` (uniform or per-corner), `StrokeWidth` (points, negative = px) drawn inside the bounds, `StrokeColor`, `StrokeCap`, `ClipBackgroundColor`, children laid out inside the stroke and clipped to the shape, `CreateClip` = shape, `FillGradient` fill, `UseCache=Operations` default. Not ported: `Squricle`, `Custom`, `SmoothPoints`, `StrokePath` (dashes), `StrokeGradient`, `StrokeBlendMode`, sub-1px stroke compensation, `MeasuredStrokeAware*` exposure, `LayoutChildren` override hook. |
 | `SkiaButton` | partial | Now a `SkiaLayout` hosting a `SkiaShape` frame (`Tag="BtnShape"`) + `SkiaLabel` (`Tag="BtnText"`), sized from the label + Padding; `CornerRadius` (default 8), `StrokeColor`/`StrokeWidth`, `BackgroundColor`, text props, `ApplyEffect`, `Tapped`/`Down`/`Up`. Still no `ButtonStyle` looks, icons, `TextCase`, elevation, shimmer, custom templating through tags. |
 | `SnappingLayout` | ported | `Animated`, `RespondsToGestures`, `IgnoreWrongDirection`, `Bounces`, `RubberDamping`, `RubberEffect`, `AutoVelocityMultiplyPts`, `SnapDistanceRatio`, `SnapPoints`, `CurrentPosition`, `CurrentSnap`, `ContentOffsetBounds`, `IsUserPanning`/`IsUserFocused`, `InTransition`, `Scrolled`/`TransitionChanged`/`Stopped`, `ClampOffset` (rubber), `FindNearestAnchor`, `SelectNextAnchor` (dot product), `ScrollToNearestAnchor`, `ScrollToOffset` (spring `Spring(1+RubberDamping, 200, 0.5·(1+RubberDamping))` when `Bounces`, else 0.1–0.8 s from velocity). The settled state is reported when the snap animation stops (C# relies on `ApplyPosition` ticks). Not ported: `AnimatorSpring` reuse, `SnapDistanceRatio` for non-carousel layouts, hover. |
-| `UseCache="ImageComposite"` / `ImageCompositeGPU`, `Left` / `Top` | ported | ImageComposite keeps its offscreen surface across records; a child that calls `RepaintComposition` (transform / own repaint) is tracked as dirty by its composite ancestors (`TrackChildAsDirty`, `DirtyChildrenInternal`), the next record erases the dirty children's old + new transformed bounds plus the siblings they overlap and paints only those (`IsRenderingWithComposition`, layouts skip the rest); own content, a remeasure, a size / scale change record fully (`LastCompositeRecord` diagnostics). `Left` / `Top` on a cached control blit the cache at the offset without a matrix or save/restore (the translation is still set as `RenderTransformMatrix` so gestures / accessibility map through it); uncached controls keep the matrix path. Not ported: `ExpandDirtyRegion`, C# `CachedObject` surface reuse for plain `Image`. |
+| `UseCache="ImageComposite"` / `ImageCompositeGPU`, `Left` / `Top` | ported | ImageComposite keeps its offscreen surface across records; a change deeper than a direct child (a color through props or a color setter = `UpdateDraw`, or `RepaintComposition`) is erased and redrawn by its area (drawnui-cross 6m: the control as drawn before and now, through every ancestor's transform; an effect or a backdrop on the way draws the child whole; a rect change, more than `MaxCompositionAreas` 16 areas or more than `MaxCompositionShare` 0.5 of the composite records whole; `LastCompositeRecord.Areas` / `Changed`; children outside the areas are not traversed); a child that calls `RepaintComposition` (transform / own repaint) is tracked as dirty by its composite ancestors (`TrackChildAsDirty`, `DirtyChildrenInternal`), the next record erases the dirty children's old + new transformed bounds plus the siblings they overlap and paints only those (`IsRenderingWithComposition`, layouts skip the rest); own content, a remeasure, a size / scale change record fully (`LastCompositeRecord` diagnostics). `Left` / `Top` on a cached control blit the cache at the offset without a matrix or save/restore (the translation is still set as `RenderTransformMatrix` so gestures / accessibility map through it); uncached controls keep the matrix path. Not ported: `ExpandDirtyRegion`, C# `CachedObject` surface reuse for plain `Image`. |
 | `SkiaCarousel` | ported | Static `Children` or recycled `ItemsSource` + `ItemTemplate` cells (only visible + neighbour slides realized, `ReleaseExcept` for the looped non-contiguous set); `IsVertical`, `SidesOffset`, `Spacing`, `IsLooped` (virtual anchors -1/-2, wrap by `GoNext`/`GoPrev`/swipe at the borders, unbounded offset along the axis, edge slides drawn on the far side, `FixIndex` teleport after the wrap, `InterruptSnapping` strip shift), `PreloadNeighboors` (default true), `DynamicSize` (auto-sized axis follows the selected slide, re-measured on index change), `SwipeSpeed` (velocity ×SwipeSpeed/2, spring stiffness 200·SwipeSpeed, linear cap 0.25/speedK s, `SinOut`), `LinearSpeedMs` (one slide = LinearSpeedMs), `SelectedIndex` + `SelectedIndexChanged`, `LastIndex`, `MaxIndex`, `ChildrenTotal`/`ChildrenCount`, `IsAtStart`/`IsAtEnd`, `ScrollProgress`, `ScrollAmount`, `TransitionProgress`, `ItemAppearing`/`ItemDisappearing`, `Stopped`, `GoNext`/`GoPrev`/`ScrollTo(index, animate)`, C# gesture rules (velocity dead zone 100, clamp 500, snap-if-no-pan on Up, only the slides drawn on screen receive gestures). `IsRightToLeft` accepted (C# TODO). Not ported: `TransitionDirection`, `SafeIndex`, `ScrolledCommand`/`SelectedIndexChangedCommand`, `SelectedItem`, `CheckConstraints` exception, `OnTemplatesAvailable` background init, hover, pinch. |
 | Templated `Row` / `Wrap` / `Grid`, `Split`, `SkiaDecoratedGrid` | ported | `ItemsSource` + `ItemTemplate` on any layout type: Column stays the virtualized list. Row / Wrap / Grid / a split Column follow `RecyclingTemplate` (drawnui-cross 6b): Enabled measures every item on pooled views (C# measures the structure on one template instance) and binds views only to the slots drawn, their views go back to the pool when the slot leaves the viewport (`VirtualisationInflated` widens it), every slot draws under a cache (C# `GetOnScreenVisibleArea`); Disabled keeps one view per item, never rebound. Changing `RecyclingTemplate` rebuilds the cells. `Split` (column count for Wrap and for a Column, which then lays out like a wrap with fixed slots; a templated Grid places item i at (i % Split, i / Split), `Invert` column-major), `SplitAlign` (true: fixed slot width), `DynamicColumns` (a short last row spreads over the width). `SkiaDecoratedGrid`: `HorizontalLine` / `VerticalLine` gradients painted in `RowSpacing` / `ColumnSpacing` under the children (C# defaults). Not ported: `SplitSpace` (C# TODO), `SplitMax`, `MeasureItemsStrategy` for non-Column templated layouts (every item is measured once per structure). |
 | `AccessibilityTextSelectable` (React extension) | ported | Opt-in per control, off by default: a `SkiaLabel` with it renders its laid-out lines as real, transparent DOM text in the accessibility overlay (one span per line at the drawn position, the registered font aliases are also installed as CSS `FontFace`s so glyphs line up), `pointer-events` on, so the browser selects, copies and reads it like HTML; the wheel over such text is re-dispatched to the canvas. Pointer input over the text never reaches the drawn control, hence opt-in. Not in DrawnUi.Net. |

package/dist/controls/SkiaBackdrop.d.ts

@@ -8,6 +8,8 @@ import { SkiaLayout } from "./SkiaLayout";
  * on every frame it is drawn in; inside a cached parent it is re-recorded with that parent).
  */
 export declare class SkiaBackdrop extends SkiaLayout {
+    /** Samples what is drawn below: a composite above redraws it whole when something inside changes (drawnui-cross 6m). */
+    protected get SamplesContent(): boolean;
     Blur: number;
     Brightness: number;
     /** Snapshot the surface currently drawn into (true) or the on-screen surface (false). */

package/dist/controls/SkiaBackdrop.js

@@ -8,6 +8,8 @@ import { SkiaLayout } from "./SkiaLayout";
  * on every frame it is drawn in; inside a cached parent it is re-recorded with that parent).
  */
 export class SkiaBackdrop extends SkiaLayout {
+    /** Samples what is drawn below: a composite above redraws it whole when something inside changes (drawnui-cross 6m). */
+    get SamplesContent() { return true; }
     Blur = 5;
     Brightness = 1;
     /** Snapshot the surface currently drawn into (true) or the on-screen surface (false). */

package/dist/controls/SkiaButton.d.ts

@@ -10,6 +10,8 @@ import { type PrebuiltControlStyle, type ResolvedControlStyle } from "../core/Co
  * PanThreshold. Press feedback = ApplyEffect (ripple), no darkening.
  */
 export declare class SkiaButton extends SkiaLayout {
+    /** Takes mouse hover unless ReceivesHover is set false (C# ReceivesHoverByDefault). */
+    protected ReceivesHoverByDefault(): boolean;
     static PanThreshold: number;
     Text: string;
     /** Look of the default content (C# SkiaButton.ControlStyle): background, corners, font, minimum size when left unset. */

package/dist/controls/SkiaButton.js

@@ -10,6 +10,8 @@ import { ResolveControlStyle } from "../core/ControlStyle";
  * PanThreshold. Press feedback = ApplyEffect (ripple), no darkening.
  */
 export class SkiaButton extends SkiaLayout {
+    /** Takes mouse hover unless ReceivesHover is set false (C# ReceivesHoverByDefault). */
+    ReceivesHoverByDefault() { return true; }
     static PanThreshold = 5;
     Text = "";
     /** Look of the default content (C# SkiaButton.ControlStyle): background, corners, font, minimum size when left unset. */

package/dist/controls/SkiaCarousel.d.ts

@@ -15,6 +15,8 @@ export interface SnapPoint {
  * `DynamicSize` sizes an auto-sized carousel from the selected slide, `SwipeSpeed` / `LinearSpeedMs` tune the snap.
  */
 export declare class SkiaCarousel extends SnappingLayout {
+    /** Takes mouse hover unless ReceivesHover is set false (C# ReceivesHoverByDefault). */
+    protected ReceivesHoverByDefault(): boolean;
     IsVertical: boolean;
     /** Side padding in points so the previous/next slides peek in. */
     SidesOffset: number;

package/dist/controls/SkiaCarousel.js

@@ -11,6 +11,8 @@ import { SnappingLayout } from "./SnappingLayout";
  * `DynamicSize` sizes an auto-sized carousel from the selected slide, `SwipeSpeed` / `LinearSpeedMs` tune the snap.
  */
 export class SkiaCarousel extends SnappingLayout {
+    /** Takes mouse hover unless ReceivesHover is set false (C# ReceivesHoverByDefault). */
+    ReceivesHoverByDefault() { return true; }
     IsVertical = false;
     /** Side padding in points so the previous/next slides peek in. */
     SidesOffset = 0;

package/dist/controls/SkiaDrawer.d.ts

@@ -9,6 +9,8 @@ import { SnappingLayout } from "./SnappingLayout";
  * so it must be aligned to its edge by the parent (VerticalOptions="End" for FromBottom, etc.).
  */
 export declare class SkiaDrawer extends SnappingLayout {
+    /** Takes mouse hover unless ReceivesHover is set false (C# ReceivesHoverByDefault). */
+    protected ReceivesHoverByDefault(): boolean;
     Direction: DrawerDirection;
     /** Points that stay visible when closed. */
     HeaderSize: number;

package/dist/controls/SkiaDrawer.js

@@ -7,6 +7,8 @@ import { SnappingLayout } from "./SnappingLayout";
  * so it must be aligned to its edge by the parent (VerticalOptions="End" for FromBottom, etc.).
  */
 export class SkiaDrawer extends SnappingLayout {
+    /** Takes mouse hover unless ReceivesHover is set false (C# ReceivesHoverByDefault). */
+    ReceivesHoverByDefault() { return true; }
     Direction = "FromBottom";
     /** Points that stay visible when closed. */
     HeaderSize = 0;

package/dist/controls/SkiaEditor.js

@@ -73,7 +73,12 @@ export class SkiaEditor extends SkiaShape {
     stubSelectionStop = -1;
     selectionMovingEdge = -1;
     onKeyDown = (key, e) => this.OnKeyDown(key, e);
-    onKeyChar = (ch, e) => { e.preventDefault(); this.StubTypeText(ch); };
+    onKeyChar = (ch, e) => {
+        if (KeyboardManager.IsOwnedByElement(e) || KeyboardManager.IsInputMethodKey(e))
+            return; // a page control or the IME owns it
+        e.preventDefault();
+        this.StubTypeText(ch);
+    };
     selectionAnchor = -1;
     dragSelecting = false;
     styleApplied = {};
@@ -596,6 +601,10 @@ export class SkiaEditor extends SkiaShape {
     OnKeyDown(key, e) {
         const shift = KeyboardManager.IsShiftPressed, ctrl = KeyboardManager.IsControlPressed, alt = KeyboardManager.IsAltPressed;
         const handled = () => e.preventDefault();
+        // keys of another element (a page field or button, an overlay node) and of the input method are not the editor's:
+        // a composition keeps its arrows, Escape and Backspace (C# 845b26e9, GitHub #231)
+        if (KeyboardManager.IsInputMethodKey(e) || (KeyboardManager.IsOwnedByElement(e) && !TextInputProxy.IsProxyTarget(e.target)))
+            return;
         // with the hidden textarea focused these keys become input / clipboard events there and are applied from those
         if (TextInputProxy.IsActive(this) && TextInputProxy.IsProxyTarget(e.target) && (key === "Backspace" || key === "Delete" || key === "Enter" || key === "NumpadEnter" || (ctrl && (key === "KeyC" || key === "KeyX" || key === "KeyV"))))
             return;

package/dist/controls/SkiaLabel.d.ts

@@ -53,6 +53,8 @@ export declare class SkiaLabel extends SkiaControl {
     protected DefaultAccessibilityLabel(): string | undefined;
     constructor();
     private Set;
+    /** A property that changes only the look (a color): no layout change, see UpdateDraw. */
+    private SetLook;
     get Text(): string;
     set Text(v: string);
     get FontSize(): number;

package/dist/controls/SkiaLabel.js

@@ -43,12 +43,17 @@ export class SkiaLabel extends SkiaControl {
         this[key] = v;
         this.Update();
     } }
+    /** A property that changes only the look (a color): no layout change, see UpdateDraw. */
+    SetLook(key, v) { if (this[key] !== v) {
+        this[key] = v;
+        this.UpdateDraw();
+    } }
     get Text() { return this.text; }
     set Text(v) { this.Set("text", v); }
     get FontSize() { return this.fontSize; }
     set FontSize(v) { this.Set("fontSize", v); }
     get TextColor() { return this.textColor; }
-    set TextColor(v) { this.Set("textColor", v); }
+    set TextColor(v) { this.SetLook("textColor", v); }
     get FontFamily() { return this.fontFamily; }
     set FontFamily(v) { this.Set("fontFamily", v); }
     /**
@@ -85,8 +90,14 @@ export class SkiaLabel extends SkiaControl {
     InsertSubView(index, control) {
         if (!(control instanceof TextSpan))
             throw new Error("DrawnUi: SkiaLabel children must be <TextSpan>");
+        const at = control.Parent === this ? this.Spans.indexOf(control) : -1; // already a span: a move, never a 2nd copy
+        if (at >= 0) {
+            this.Spans.splice(at, 1);
+            if (at < index)
+                index--;
+        }
         control.Parent = this;
-        this.Spans.splice(index, 0, control);
+        this.Spans.splice(Math.min(Math.max(0, index), this.Spans.length), 0, control);
         this.Update();
     }
     RemoveSubView(control) {

package/dist/controls/SkiaLayout.d.ts

@@ -112,7 +112,22 @@ export declare class SkiaLayout extends SkiaControl {
     get Views(): readonly SkiaControl[];
     /** Settable children list like DrawnUi Children (ignored while templated). */
     get Children(): readonly SkiaControl[];
+    /**
+     * C# Children reset (ChildrenCollectionSync, 66a1eb02): the app's children the new list no longer holds are removed,
+     * the ones it gained are added, then all of them take the list's order inside the slots app children occupy, so the
+     * parts a control made itself keep their place.
+     */
     set Children(value: readonly SkiaControl[]);
+    /**
+     * C# Insert / Move of a Children collection (the reconciler's appendChild / insertBefore): `child` goes before
+     * `before` among the app's children, or last without it. A new child is attached at the end of the views and an
+     * append stops there; otherwise the app's children take their new order inside the slots they occupy.
+     */
+    InsertChild(child: SkiaControl, before?: SkiaControl): void;
+    /** C# OrderViews: the given children, in their order, inside the slots they occupy in the views; nothing else moves. */
+    private OrderChildren;
+    /** C# ClearChildren: removes every subview, the control's own parts included. */
+    ClearChildren(): void;
     private orderedViews?;
     /** Static children sorted by ZIndex (stable), computed once per change (C# GetOrderedSubviews). */
     protected GetOrderedSubviews(): readonly SkiaControl[];

package/dist/controls/SkiaLayout.js

@@ -359,11 +359,67 @@ export class SkiaLayout extends SkiaControl {
     get Views() { return this.IsTemplated ? this.ChildrenFactory.GetViewsInUse() : this.views; }
     /** Settable children list like DrawnUi Children (ignored while templated). */
     get Children() { return this.views; }
+    /**
+     * C# Children reset (ChildrenCollectionSync, 66a1eb02): the app's children the new list no longer holds are removed,
+     * the ones it gained are added, then all of them take the list's order inside the slots app children occupy, so the
+     * parts a control made itself keep their place.
+     */
     set Children(value) {
+        const keep = new Set(value);
+        for (const v of [...this.views])
+            if (v.IsChildrenItem && !keep.has(v))
+                this.RemoveSubView(v);
+        const inViews = new Set(this.views);
+        for (const v of value) {
+            v.IsChildrenItem = true;
+            if (!inViews.has(v))
+                this.AddSubView(v);
+        }
+        this.OrderChildren(value);
+    }
+    /**
+     * C# Insert / Move of a Children collection (the reconciler's appendChild / insertBefore): `child` goes before
+     * `before` among the app's children, or last without it. A new child is attached at the end of the views and an
+     * append stops there; otherwise the app's children take their new order inside the slots they occupy.
+     */
+    InsertChild(child, before) {
+        child.IsChildrenItem = true;
+        const attached = child.Parent === this && this.views.includes(child);
+        if (!attached)
+            this.AddSubView(child);
+        if (!attached && !before)
+            return;
+        const order = this.views.filter((v) => v.IsChildrenItem && v !== child);
+        const at = before ? order.indexOf(before) : -1;
+        order.splice(at < 0 ? order.length : at, 0, child);
+        this.OrderChildren(order);
+    }
+    /** C# OrderViews: the given children, in their order, inside the slots they occupy in the views; nothing else moves. */
+    OrderChildren(ordered) {
+        const inViews = new Set(this.views);
+        const present = ordered.filter((v) => inViews.delete(v));
+        if (present.length < 2)
+            return;
+        const isChild = new Set(present);
+        let next = 0, changed = false;
+        for (let i = 0; i < this.views.length && next < present.length; i++) {
+            if (!isChild.has(this.views[i]))
+                continue;
+            if (this.views[i] !== present[next]) {
+                this.views[i] = present[next];
+                changed = true;
+            }
+            next++;
+        }
+        if (changed) {
+            this.orderedViews = undefined;
+            this.InvalidateMeasure();
+        }
+    }
+    /** C# ClearChildren: removes every subview, the control's own parts included. */
+    ClearChildren() {
         for (const v of [...this.views])
             this.RemoveSubView(v);
-        for (const v of value)
-            this.AddSubView(v);
     }
     orderedViews;
     /** Static children sorted by ZIndex (stable), computed once per change (C# GetOrderedSubviews). */
@@ -390,10 +446,18 @@ export class SkiaLayout extends SkiaControl {
     }
     AddSubView(control) { this.InsertSubView(this.views.length, control); }
     InsertSubView(index, control) {
+        // already a child: a move (React reorders keyed children by inserting an existing one elsewhere), never a 2nd copy
+        const at = control.Parent === this ? this.views.indexOf(control) : -1;
+        if (at >= 0) {
+            this.views.splice(at, 1);
+            if (at < index)
+                index--;
+        }
         control.Parent = this;
-        this.views.splice(index, 0, control);
+        this.views.splice(Math.min(Math.max(0, index), this.views.length), 0, control);
         this.orderedViews = undefined;
         this.InvalidateMeasure();
+        this.Superview?.Hover?.RequestCheck(); // a popup / page under a still mouse
     }
     RemoveSubView(control) {
         const i = this.views.indexOf(control);
@@ -403,6 +467,7 @@ export class SkiaLayout extends SkiaControl {
         this.orderedViews = undefined;
         control.Parent = undefined;
         this.InvalidateMeasure();
+        this.Superview?.Hover?.RequestCheck();
     }
     // ---- measure ----
     MeasureAbsolute(widthConstraint, heightConstraint, scale) {
@@ -758,9 +823,13 @@ export class SkiaLayout extends SkiaControl {
             return;
         }
         const composing = this.IsRenderingWithComposition;
-        for (const v of this.GetOrderedSubviews())
-            if (!composing || this.DirtyChildrenInternal.has(v))
-                v.Render(ctx);
+        // inside a composite that redraws only some areas, a child entirely outside them is not even traversed
+        const culling = !composing && SkiaControl.CompositionCulling > 0;
+        for (const v of this.GetOrderedSubviews()) {
+            if (composing ? !this.DirtyChildrenInternal.has(v) : culling && v.IsVisible && v.OutsideCompositionClip(ctx.Context.Canvas))
+                continue;
+            v.Render(ctx);
+        }
     }
     GetCompositeChildren() { return this.IsTemplatedList || this.IsRecycledLayout ? [] : this.GetOrderedSubviews(); }
     drawnSlots = new Set();

package/dist/controls/SkiaProgress.js

@@ -33,9 +33,9 @@ export class SkiaProgress extends SkiaControl {
     set Max(v) { this.max = v; this.Update(); }
     /** Unset = per-style palette. */
     get TrackColor() { return this.trackColor ?? SkiaProgress.Palette(this.UsingControlStyle).track; }
-    set TrackColor(v) { this.trackColor = v; this.Update(); }
+    set TrackColor(v) { this.trackColor = v; this.UpdateDraw(); }
     get ProgressColor() { return this.progressColor ?? SkiaProgress.Palette(this.UsingControlStyle).progress; }
-    set ProgressColor(v) { this.progressColor = v; this.Update(); }
+    set ProgressColor(v) { this.progressColor = v; this.UpdateDraw(); }
     /** C# ResolvedTrackColor / ResolvedProgressColor / track heights per style. */
     static Palette(s) {
         switch (s) {

package/dist/controls/SkiaScroll.d.ts

@@ -156,6 +156,10 @@ export declare class SkiaScroll extends SkiaControl {
     set ViewportOffsetX(value: number);
     get ViewportOffsetY(): number;
     set ViewportOffsetY(value: number);
+    /** An offset set without a glide or a pan (a jump, a touchpad step): the controls under a still mouse changed. */
+    private OffsetJumped;
+    /** Hover waits while the content glides, flings, bounces or follows a pan (C# IsScrolling). */
+    MovesContent(): boolean;
     private readonly animatorFlingX;
     private readonly animatorFlingY;
     private readonly bounceX;

package/dist/controls/SkiaScroll.js

@@ -399,12 +399,19 @@ export class SkiaScroll extends SkiaControl {
     set ViewportOffsetX(value) { if (this.offsetX !== value) {
         this.offsetX = value;
         this.OnScrolled();
+        this.OffsetJumped();
     } }
     get ViewportOffsetY() { return this.offsetY; }
     set ViewportOffsetY(value) { if (this.offsetY !== value) {
         this.offsetY = value;
         this.OnScrolled();
+        this.OffsetJumped();
     } }
+    /** An offset set without a glide or a pan (a jump, a touchpad step): the controls under a still mouse changed. */
+    OffsetJumped() { if (!this.MovesContent())
+        this.Superview?.Hover?.RequestCheck(); }
+    /** Hover waits while the content glides, flings, bounces or follows a pan (C# IsScrolling). */
+    MovesContent() { return this.IsScrolling || this.IsUserPanning || !!this.draggedScrollBar; }
     animatorFlingX = new ScrollFlingAnimator(this);
     animatorFlingY = new ScrollFlingAnimator(this);
     bounceX = new SpringWithVelocityAnimator(this);
@@ -506,6 +513,7 @@ export class SkiaScroll extends SkiaControl {
     }
     InsertSubView(_index, control) { this.AddSubView(control); }
     RemoveSubView(control) {
+        this.Superview?.Hover?.RequestCheck();
         if (this.content === control)
             this.Content = undefined;
         else if (this.header === control)
@@ -626,6 +634,7 @@ export class SkiaScroll extends SkiaControl {
             }
     }
     Paint(ctx) {
+        this.Superview?.Hover?.RegisterMover(this);
         const c = this.content;
         if (!c)
             return;

package/dist/controls/SkiaSlider.d.ts

@@ -8,6 +8,8 @@ import { type Color, ScaledSize, Thickness } from "../core/Types";
  * Track, selected trail and thumbs are painted directly; the C# thumb-position math (SliderHeight = thumb box) is kept.
  */
 export declare class SkiaSlider extends SkiaControl {
+    /** Takes mouse hover unless ReceivesHover is set false (C# ReceivesHoverByDefault). */
+    protected ReceivesHoverByDefault(): boolean;
     static DefaultAccessibilityRole?: string;
     ControlStyle: PrebuiltControlStyle;
     Min: number;

package/dist/controls/SkiaSlider.js

@@ -9,6 +9,8 @@ import { SkiaShape } from "./SkiaShape";
  * Track, selected trail and thumbs are painted directly; the C# thumb-position math (SliderHeight = thumb box) is kept.
  */
 export class SkiaSlider extends SkiaControl {
+    /** Takes mouse hover unless ReceivesHover is set false (C# ReceivesHoverByDefault). */
+    ReceivesHoverByDefault() { return true; }
     static DefaultAccessibilityRole = "slider";
     ControlStyle = "Unset";
     Min = 0;
@@ -60,11 +62,11 @@ export class SkiaSlider extends SkiaControl {
     get SliderHeight() { return this.sliderHeight ?? this.Look().thumb + (this.EnableRange && this.UsingControlStyle !== "Unset" ? 8 : 0); }
     set SliderHeight(v) { this.sliderHeight = v; this.Update(); }
     get ThumbColor() { return this.thumbColor ?? this.Look().thumbColor; }
-    set ThumbColor(v) { this.thumbColor = v; this.Update(); }
+    set ThumbColor(v) { this.thumbColor = v; this.UpdateDraw(); }
     get TrackColor() { return this.trackColor ?? this.Look().track; }
-    set TrackColor(v) { this.trackColor = v; this.Update(); }
+    set TrackColor(v) { this.trackColor = v; this.UpdateDraw(); }
     get TrackSelectedColor() { return this.trackSelectedColor ?? this.Look().selected; }
-    set TrackSelectedColor(v) { this.trackSelectedColor = v; this.Update(); }
+    set TrackSelectedColor(v) { this.trackSelectedColor = v; this.UpdateDraw(); }
     /** C# style builders: thumb diameter, track height, palette, thumb shadow. */
     Look() {
         switch (this.UsingControlStyle) {

package/dist/controls/SkiaToggle.d.ts

@@ -10,6 +10,8 @@ import { SkiaLayout } from "./SkiaLayout";
  * take the style defaults (C# SetStyleDefault).
  */
 export declare abstract class SkiaToggle extends SkiaLayout {
+    /** Takes mouse hover unless ReceivesHover is set false (C# ReceivesHoverByDefault): switch, checkbox, radio button. */
+    protected ReceivesHoverByDefault(): boolean;
     private controlStyle;
     get ControlStyle(): PrebuiltControlStyle;
     set ControlStyle(v: PrebuiltControlStyle);

package/dist/controls/SkiaToggle.js

@@ -8,6 +8,8 @@ import { SkiaLayout } from "./SkiaLayout";
  * take the style defaults (C# SetStyleDefault).
  */
 export class SkiaToggle extends SkiaLayout {
+    /** Takes mouse hover unless ReceivesHover is set false (C# ReceivesHoverByDefault): switch, checkbox, radio button. */
+    ReceivesHoverByDefault() { return true; }
     controlStyle = "Unset";
     get ControlStyle() { return this.controlStyle; }
     set ControlStyle(v) {
@@ -83,7 +85,7 @@ export class SkiaToggle extends SkiaLayout {
     RebuildDefaultContent() {
         if (!this.contentCreated)
             return;
-        this.Children = [];
+        this.ClearChildren();
         for (const p of this.stylePinned)
             this[p] = -1;
         this.stylePinned = [];

package/dist/controls/SnappingLayout.d.ts

@@ -50,6 +50,8 @@ export declare abstract class SnappingLayout extends SkiaLayout {
     protected StopSnapAnimators(): void;
     /** C# SnappingLayout.Render: the transition state follows the position every frame. */
     Render(ctx: DrawingContext): void;
+    /** Hover waits while the content slides (C# InTransition) or follows a pan. */
+    MovesContent(): boolean;
     ClampOffset(x: number, y: number, rubber: boolean): SKPoint;
     /** C# GetContentOffsetBounds: the extent covered by the snap points. */
     protected BoundsFromSnapPoints(): SKRect;

package/dist/controls/SnappingLayout.js

@@ -80,9 +80,12 @@ export class SnappingLayout extends SkiaLayout {
     }
     /** C# SnappingLayout.Render: the transition state follows the position every frame. */
     Render(ctx) {
+        this.Superview?.Hover?.RegisterMover(this);
         super.Render(ctx);
         this.InTransition = !this.CheckTransitionEnded();
     }
+    /** Hover waits while the content slides (C# InTransition) or follows a pan. */
+    MovesContent() { return this.InTransition || this.IsUserPanning; }
     // ---- clamping ----
     ClampOffset(x, y, rubber) {
         const b = this.ContentOffsetBounds;

package/dist/core/Accessibility.d.ts

@@ -52,6 +52,12 @@ export declare const Aria: {
      * its current item, and the arrow keys move between its items.
      */
     readonly IsCompositeRole: (role?: string) => boolean;
+    /**
+     * Roles a user operates (C# Aria.IsInteractiveRole, as DrawnUi.Rust is_control_role): a node with one of them that
+     * cannot take input is read as disabled (aria-disabled). C# also lists listbox and scrollbar; here a listbox is an
+     * arrow-key group and groups are never disabled.
+     */
+    readonly IsInteractiveRole: (role?: string) => boolean;
 };
 /** One laid-out text line exposed for native selection (AccessibilityTextSelectable): CSS px relative to the node. */
 export interface AccessibilityTextLine {
@@ -72,6 +78,8 @@ export interface AccessibilityNode {
     Role: string;
     Rect: SKRect;
     CanInteract: boolean;
+    /** A role a user operates (Aria.IsInteractiveRole) that cannot take input: aria-disabled, no tab stop. */
+    Disabled: boolean;
     IsPressed?: boolean;
     Live?: string;
     Source: SkiaControl;