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

package/dist/core/Accessibility.js

@@ -26,6 +26,16 @@ export const Aria = {
         return role === "list" || role === "listbox" || role === "grid" || role === "toolbar" || role === "radiogroup"
             || role === "tablist" || role === "menu" || role === "menubar";
     },
+    /**
+     * 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.
+     */
+    IsInteractiveRole(role) {
+        return role === "button" || role === "link" || role === "checkbox" || role === "radio" || role === "switch"
+            || role === "slider" || role === "spinbutton" || role === "textbox" || role === "searchbox" || role === "combobox"
+            || role === "option" || role === "tab" || role === "menuitem" || role === "menuitemcheckbox" || role === "menuitemradio";
+    },
 };
 const asLayout = (c) => ("ChildrenFactory" in c && "Split" in c ? c : undefined);
 const asScroll = (c) => ("ScrollToIndex" in c && "ViewportOffsetY" in c ? c : undefined);
@@ -150,7 +160,7 @@ export class SkiaAccessibilityManager {
         const current = this.groupRequest?.Group === group ? this.groupRequest.Index : IndexOf(group, item);
         if (current < 0 || count < 1)
             return false;
-        const row = axis === "Both" ? RowLength(group, item) : 1;
+        const row = axis === "Both" ? RowLength(group) : 1;
         const vertical = axis !== "Horizontal";
         const page = () => PageSize(scroll, item, vertical) * row;
         let target, step;
@@ -282,7 +292,7 @@ export class SkiaAccessibilityManager {
     Rebuild(scale, canvasWidthPx, canvasHeightPx) {
         this.dirty = false;
         this.lastRebuild = performance.now();
-        const list = [];
+        let list = [];
         for (const n of this.nodes) {
             if (!n.Superview) {
                 this.nodes.delete(n);
@@ -304,9 +314,11 @@ export class SkiaAccessibilityManager {
                 Id: n.AccessibilityId, Label: n.AccessibilityLabel, Hint: n.AccessibilityHint, Role: n.AccessibilityRole,
                 Rect: new SKRect(px.Left / scale, px.Top / scale, px.Right / scale, px.Bottom / scale),
                 CanInteract: n.AccessibilityCanInteract, IsPressed: n.AccessibilityIsPressed, Live: n.AccessibilityLive, Source: n,
+                Disabled: !n.AccessibilityCanInteract && Aria.IsInteractiveRole(n.AccessibilityRole),
                 TextLines: n.AccessibilityTextSelectable ? n.GetAccessibilityTextLines(scale) : undefined,
             });
         }
+        list = SayNamesOnce(list);
         list.sort((a, b) => a.Rect.Top - b.Rect.Top || a.Rect.Left - b.Rect.Left);
         // reading order: nodes whose tops are within half the smaller height form one row, read left to right, so a row of
         // vertically centered controls of different heights keeps its visual order (C# RectComparer + LeftComparer)
@@ -334,7 +346,7 @@ export class SkiaAccessibilityManager {
             return false;
         for (let i = 0; i < a.length; i++) {
             const x = a[i], y = b[i];
-            if (x.Source !== y.Source || x.Label !== y.Label || x.Hint !== y.Hint || x.Role !== y.Role || x.CanInteract !== y.CanInteract
+            if (x.Source !== y.Source || x.Label !== y.Label || x.Hint !== y.Hint || x.Role !== y.Role || x.CanInteract !== y.CanInteract || x.Disabled !== y.Disabled
                 || x.IsPressed !== y.IsPressed || x.Live !== y.Live
                 || Math.abs(x.Rect.Left - y.Rect.Left) > 0.5 || Math.abs(x.Rect.Top - y.Rect.Top) > 0.5
                 || Math.abs(x.Rect.Right - y.Rect.Right) > 0.5 || Math.abs(x.Rect.Bottom - y.Rect.Bottom) > 0.5)
@@ -353,6 +365,30 @@ export class SkiaAccessibilityManager {
         return true;
     }
 }
+/**
+ * Each name is said once in the flat overlay (DrawnUi.Rust said_by_child): a text or a heading whose label repeats the
+ * label of the node it is in (its nearest ancestor node) is said by one of them. Under an interactive node (a card
+ * button) the child is left out, the button keeps its name; under any other node (a group card and its title) the
+ * node loses its name and the heading says it. Selectable text (TextLines) always stays.
+ */
+function SayNamesOnce(list) {
+    const bySource = new Map(list.map((x) => [x.Source, x]));
+    const said = new Set();
+    for (const x of list) {
+        if (!x.Label || x.TextLines || (x.Role !== Aria.RoleText && x.Role !== Aria.RoleHeading))
+            continue;
+        let owner;
+        for (let p = x.Source.Parent; p && !owner; p = p.Parent)
+            owner = bySource.get(p);
+        if (!owner || owner.Label !== x.Label)
+            continue;
+        if (owner.CanInteract)
+            said.add(x);
+        else
+            owner.Label = undefined;
+    }
+    return said.size ? list.filter((x) => !said.has(x)) : list;
+}
 // ---- group helpers (duck-typed layouts and scrolls) ----
 /** Children of a control (a layout's Views, a scroll's Content). */
 function ViewsOf(c) {
@@ -383,11 +419,18 @@ function AxisOf(group) {
     return "Both";
 }
 /** Items per row of a 2D group: Split when set, else the items sharing the row of `item`. */
-function RowLength(group, item) {
+/**
+ * Items per row of a 2D group: the Split, else the items on the row of the group's first item. C# counts the focused
+ * item's row, which the short last row of a wrap leaves short (Up from it skipped items); DrawnUi.Rust afef66f.
+ */
+function RowLength(group) {
     const l = asLayout(group);
     if (l && l.Split > 1)
         return l.Split;
-    const top = item.GetAccessibilityPixelRect();
+    const first = ItemAt(group, 0) ?? FirstRealized(group);
+    if (!first)
+        return 1;
+    const top = first.GetAccessibilityPixelRect();
     if (top.Height <= 0)
         return 1;
     const mid = (top.Top + top.Bottom) / 2;
@@ -416,6 +459,14 @@ function ItemAt(group, index) {
     }
     return index >= 0 && index < ViewsOf(group).length ? ViewsOf(group)[index] : undefined;
 }
+/** The realized item with the lowest index (item 0 of a scrolled recycled group may not be realized). */
+function FirstRealized(group) {
+    let best;
+    for (const v of ViewsOf(group))
+        if (!best || IndexOf(group, v) < IndexOf(group, best))
+            best = v;
+    return best;
+}
 /** Arranged on the canvas: realized and laid out (a templated layout keeps only the cells it draws in use). */
 function IsDrawn(control) {
     const r = control.GetAccessibilityPixelRect();

package/dist/core/Canvas.d.ts

@@ -2,6 +2,7 @@ import type { Surface } from "canvaskit-wasm";
 import type { DrawingContext, SkiaControl } from "./SkiaControl";
 import type { AnimatorBase } from "./Animators";
 import { SkiaAccessibilityManager } from "./Accessibility";
+import { HoverManager } from "./Hover";
 import { type Color, type RenderingModeType } from "./Types";
 import { ContextMenuEventArgs, type GesturesMode, SkiaGesturesParameters, TouchActionEventArgs } from "./Gestures";
 /**
@@ -37,6 +38,8 @@ export declare class Canvas {
     WasDrawn?: (sender: Canvas) => void;
     /** Registry + rate-limited snapshot of accessible controls, rendered by the DOM overlay (DrawnUi AccessibilityManager). */
     readonly AccessibilityManager: SkiaAccessibilityManager;
+    /** Mouse hover of the controls (drawnui-cross 6m): ReceivesHover / IsHovered / HoverChanged. */
+    readonly Hover: HoverManager;
     private content?;
     get Content(): SkiaControl | undefined;
     set Content(value: SkiaControl | undefined);
@@ -126,6 +129,8 @@ export declare class Canvas {
     private readonly previousTouchArgs;
     private readonly pendingGestures;
     private readonly onPointer;
+    /** The mouse left the canvas: hover ends at once, also while content moves. */
+    private readonly onPointerLeave;
     private readonly preventTouch;
     /** Gestures="Enabled": touch / pen pointers whose Down a control used (see OnTouchAction). */
     private readonly claimedTouches;

package/dist/core/Canvas.js

@@ -1,5 +1,6 @@
 import { Super } from "./Super";
 import { SkiaAccessibilityManager } from "./Accessibility";
+import { HoverManager } from "./Hover";
 import { Colors, SKRect } from "./Types";
 import { ContextMenuEventArgs, GestureEventProcessingInfo, PointerData, SKPoint, SkiaGesturesParameters, TouchActionEventArgs, } from "./Gestures";
 /**
@@ -35,6 +36,8 @@ export class Canvas {
     WasDrawn;
     /** Registry + rate-limited snapshot of accessible controls, rendered by the DOM overlay (DrawnUi AccessibilityManager). */
     AccessibilityManager = new SkiaAccessibilityManager();
+    /** Mouse hover of the controls (drawnui-cross 6m): ReceivesHover / IsHovered / HoverChanged. */
+    Hover = new HoverManager();
     content;
     get Content() { return this.content; }
     set Content(value) {
@@ -45,6 +48,7 @@ export class Canvas {
             value.Parent = undefined;
             value._superview = this;
         }
+        this.Hover.RequestCheck();
         this.Update();
     }
     surface;
@@ -201,6 +205,7 @@ export class Canvas {
             root.Render({ Context: { Canvas: canvas, Surface: this.surface }, Destination: new SKRect(0, 0, w, h), Scale: scale });
         }
         this.AccessibilityManager.OnFrameEnd(this.RenderingScale, this.Element.width, this.Element.height, () => this.Update());
+        this.Hover.AfterFrame(this.content, this.activeTouchIds.size > 0);
         const now = performance.now();
         this.FrameTime = now - started;
         this.FrameIndex++;
@@ -344,10 +349,14 @@ export class Canvas {
         if (!type)
             return;
         if (type === "Moved" && !this.activeTouchIds.has(e.pointerId)) {
+            if (e.pointerType === "touch")
+                return; // touch never hovers
             if (e.pointerType === "mouse")
                 this.UpdateCursor(e.offsetX, e.offsetY);
+            if (this.activeTouchIds.size === 0)
+                this.Hover.Move(this.content, e.offsetX * this.RenderingScale, e.offsetY * this.RenderingScale);
             return;
-        } // hover not ported (TouchActionResult.Pointer)
+        }
         if ((type === "Released" || type === "Cancelled") && !this.activeTouchIds.has(e.pointerId))
             return; // Up of a pointer that never pressed here
         // Capture so Up outside the element still arrives; throws for synthetic events (tests) — harmless.
@@ -377,6 +386,9 @@ export class Canvas {
             this.UpdateTouchAction();
         }
     };
+    /** The mouse left the canvas: hover ends at once, also while content moves. */
+    onPointerLeave = (e) => { if (e.pointerType !== "touch")
+        this.Hover.Leave(); };
     preventTouch = (e) => e.preventDefault();
     /** Gestures="Enabled": touch / pen pointers whose Down a control used (see OnTouchAction). */
     claimedTouches = new Set();
@@ -519,6 +531,7 @@ export class Canvas {
         el.style.userSelect = "none";
         for (const t of ["pointerdown", "pointermove", "pointerup", "pointercancel"])
             el.addEventListener(t, this.onPointer);
+        el.addEventListener("pointerleave", this.onPointerLeave);
         el.addEventListener("contextmenu", this.onContextMenu);
         el.addEventListener("wheel", this.onWheel, { passive: false });
         if (this.gestures === "Lock")
@@ -535,6 +548,7 @@ export class Canvas {
         el.style.userSelect = "";
         for (const t of ["pointerdown", "pointermove", "pointerup", "pointercancel"])
             el.removeEventListener(t, this.onPointer);
+        el.removeEventListener("pointerleave", this.onPointerLeave);
         el.removeEventListener("contextmenu", this.onContextMenu);
         el.removeEventListener("wheel", this.onWheel);
         el.removeEventListener("touchmove", this.preventTouch);

package/dist/core/Hover.d.ts

@@ -0,0 +1,37 @@
+import type { SkiaControl } from "./SkiaControl";
+/**
+ * DrawnUI hover (drawnui-cross 6m, C# DrawnView ReportHover / CommitHover): every control under the mouse that takes
+ * hover (`ReceivesHover`) is hovered, a card and the button inside it alike, as CSS :hover. Decided from the hit path
+ * of one pointer position, by the routing rules of ProcessGestures (visible, not InputTransparent, inside, children
+ * not locked, nothing below a control that blocks gestures below).
+ * While content moves under the pointer (a scroll glide, fling or pan, a carousel or drawer transition) hover is not
+ * tracked and what was hovered stays; one check at the last pointer position follows when it stops, and after
+ * controls are added or removed, a cell is rebound, a hovered control is hidden or a scroll jumps. Leaving the canvas
+ * clears hover at once. Touch never hovers. No allocation on frames where nothing changes.
+ */
+export declare class HoverManager {
+    /** The hovered controls, root first. */
+    readonly Hovered: SkiaControl[];
+    private readonly next;
+    private readonly path;
+    private readonly movers;
+    private hasPointer;
+    private x;
+    private y;
+    private paused;
+    private check;
+    /** The mouse (or a pen in range) moved to (x, y), canvas pixels, nothing pressed. */
+    Move(root: SkiaControl | undefined, x: number, y: number): void;
+    /** The pointer left the canvas: nothing is hovered, also while content moves. */
+    Leave(): void;
+    /** The controls under a still pointer may have changed: checked once at the end of the frame. */
+    RequestCheck(): void;
+    /** A control that moves its content (MovesContent) while drawn: hover waits while any of them moves. */
+    RegisterMover(control: SkiaControl): void;
+    /** End of a frame: pause while content moves, else run a pending check (at most one a frame, none while pressed). */
+    AfterFrame(root: SkiaControl | undefined, pressed: boolean): void;
+    private static Shown;
+    private Update;
+    /** `next` becomes the hovered set: the ones that left get HoverChanged(false), then the new ones (true). */
+    private Apply;
+}

package/dist/core/Hover.js

@@ -0,0 +1,118 @@
+import { SKPoint } from "./Gestures";
+/**
+ * DrawnUI hover (drawnui-cross 6m, C# DrawnView ReportHover / CommitHover): every control under the mouse that takes
+ * hover (`ReceivesHover`) is hovered, a card and the button inside it alike, as CSS :hover. Decided from the hit path
+ * of one pointer position, by the routing rules of ProcessGestures (visible, not InputTransparent, inside, children
+ * not locked, nothing below a control that blocks gestures below).
+ * While content moves under the pointer (a scroll glide, fling or pan, a carousel or drawer transition) hover is not
+ * tracked and what was hovered stays; one check at the last pointer position follows when it stops, and after
+ * controls are added or removed, a cell is rebound, a hovered control is hidden or a scroll jumps. Leaving the canvas
+ * clears hover at once. Touch never hovers. No allocation on frames where nothing changes.
+ */
+export class HoverManager {
+    /** The hovered controls, root first. */
+    Hovered = [];
+    next = [];
+    path = [];
+    movers = [];
+    hasPointer = false;
+    x = 0;
+    y = 0;
+    paused = false;
+    check = false;
+    /** The mouse (or a pen in range) moved to (x, y), canvas pixels, nothing pressed. */
+    Move(root, x, y) {
+        this.hasPointer = true;
+        this.x = x;
+        this.y = y;
+        if (this.paused)
+            return; // content moves under the pointer: what was hovered stays, one check when it stops
+        this.check = false;
+        this.Update(root);
+    }
+    /** The pointer left the canvas: nothing is hovered, also while content moves. */
+    Leave() {
+        this.hasPointer = false;
+        this.check = false;
+        this.next.length = 0;
+        this.Apply();
+    }
+    /** The controls under a still pointer may have changed: checked once at the end of the frame. */
+    RequestCheck() { if (this.hasPointer)
+        this.check = true; }
+    /** A control that moves its content (MovesContent) while drawn: hover waits while any of them moves. */
+    RegisterMover(control) { if (this.movers.indexOf(control) < 0)
+        this.movers.push(control); }
+    /** End of a frame: pause while content moves, else run a pending check (at most one a frame, none while pressed). */
+    AfterFrame(root, pressed) {
+        let moving = false;
+        for (let i = this.movers.length - 1; i >= 0; i--) {
+            const m = this.movers[i];
+            if (m.IsDisposed || !m.Superview) {
+                this.movers.splice(i, 1);
+                continue;
+            }
+            if (!moving && m.IsVisible && m.MovesContent())
+                moving = true;
+        }
+        if (moving) {
+            this.paused = true;
+            return;
+        }
+        if (this.paused) {
+            this.paused = false;
+            this.check = true;
+        }
+        // a hovered control (or an ancestor) hidden or removed under a still pointer stops being hovered
+        for (let i = 0; i < this.Hovered.length && !this.check; i++)
+            if (!HoverManager.Shown(this.Hovered[i]))
+                this.check = true;
+        if (!this.check)
+            return;
+        this.check = false;
+        if (!this.hasPointer || pressed)
+            return;
+        this.Update(root);
+    }
+    static Shown(control) {
+        if (control.IsDisposed || !control.Superview)
+            return false;
+        for (let c = control; c; c = c.Parent)
+            if (!c.IsVisible)
+                return false;
+        return true;
+    }
+    Update(root) {
+        const path = this.path, next = this.next;
+        path.length = 0;
+        next.length = 0;
+        if (root && root.IsVisible && !root.InputTransparent) {
+            const point = root.TransformPointToLocalSpace(new SKPoint(this.x, this.y));
+            if (root.HitIsInside(point.X, point.Y))
+                root.CollectHovered(point, path);
+        }
+        for (const c of path)
+            if (c.ReceivesHover)
+                next.push(c);
+        this.Apply();
+    }
+    /** `next` becomes the hovered set: the ones that left get HoverChanged(false), then the new ones (true). */
+    Apply() {
+        const now = this.Hovered, next = this.next;
+        if (now.length === next.length) {
+            let same = true;
+            for (let i = 0; i < now.length && same; i++)
+                same = now[i] === next[i];
+            if (same)
+                return;
+        }
+        const was = now.splice(0);
+        now.push(...next);
+        for (const c of was)
+            if (now.indexOf(c) < 0)
+                c.ApplyHover(false);
+        for (const c of now)
+            if (was.indexOf(c) < 0)
+                c.ApplyHover(true);
+    }
+}

package/dist/core/KeyboardManager.d.ts

@@ -20,6 +20,19 @@ export declare class KeyboardManager {
     static AttachToKeyboard(): void;
     static Subscribe(down: (key: InputKey, e: KeyboardEvent) => void, char: (ch: string, e: KeyboardEvent) => void, up?: (key: InputKey, e: KeyboardEvent) => void): void;
     static Unsubscribe(down: (key: InputKey, e: KeyboardEvent) => void, char: (ch: string, e: KeyboardEvent) => void, up?: (key: InputKey, e: KeyboardEvent) => void): void;
+    /**
+     * Hooks observe keys, they never take them from the element that owns them (C# 845b26e9, GitHub #231). True when a
+     * focused DOM element is the key's target: a page input, textarea, select, button, link or contenteditable, an
+     * accessibility overlay node, the drawn editor's hidden textarea. False when the key goes to the page itself (body,
+     * html) or the canvas. A handler that acts on keys (edits, moves, calls preventDefault) skips owned keys, except
+     * those of its own element.
+     */
+    static IsOwnedByElement(e: KeyboardEvent): boolean;
+    /**
+     * The key belongs to the input method (an IME composition, a soft keyboard): isComposing, keyCode 229, key "Process"
+     * or "Unidentified". Its result arrives as input events (TextInputProxy), never act on the key itself.
+     */
+    static IsInputMethodKey(e: KeyboardEvent): boolean;
     /** JS blurExternalTextInput: a page text input outside the canvas would keep receiving the keys. */
     static BlurExternalTextInput(): void;
 }

package/dist/core/KeyboardManager.js

@@ -45,6 +45,24 @@ export class KeyboardManager {
         if (up)
             KeyboardManager.keyUp.delete(up);
     }
+    /**
+     * Hooks observe keys, they never take them from the element that owns them (C# 845b26e9, GitHub #231). True when a
+     * focused DOM element is the key's target: a page input, textarea, select, button, link or contenteditable, an
+     * accessibility overlay node, the drawn editor's hidden textarea. False when the key goes to the page itself (body,
+     * html) or the canvas. A handler that acts on keys (edits, moves, calls preventDefault) skips owned keys, except
+     * those of its own element.
+     */
+    static IsOwnedByElement(e) {
+        const tag = e.target?.tagName;
+        return !!tag && tag !== "BODY" && tag !== "HTML" && tag !== "CANVAS";
+    }
+    /**
+     * The key belongs to the input method (an IME composition, a soft keyboard): isComposing, keyCode 229, key "Process"
+     * or "Unidentified". Its result arrives as input events (TextInputProxy), never act on the key itself.
+     */
+    static IsInputMethodKey(e) {
+        return e.isComposing || e.keyCode === 229 || e.key === "Process" || e.key === "Unidentified";
+    }
     /** JS blurExternalTextInput: a page text input outside the canvas would keep receiving the keys. */
     static BlurExternalTextInput() {
         const a = typeof document !== "undefined" ? document.activeElement : null;

package/dist/core/SkiaControl.d.ts

@@ -138,18 +138,43 @@ export declare class SkiaControl {
     private compositeSurface?;
     /** Own content or structure changed: the next composite record is a full one. */
     private compositeFull;
+    /** Where the kept composite surface starts relative to DrawingRect (the effects margin it was laid out with). */
+    private compositeInsetX;
+    private compositeInsetY;
     /** Canvas-pixel bounds this control covered when its parent last recorded it (composite erase region). */
     private lastCompositeBounds?;
-    /** What the last composite record did (diagnostics): "full" or "partial", the number of children re-recorded and which ones. */
+    /**
+     * What the last composite record did (diagnostics): "full" or "partial", the number of children re-recorded and which
+     * ones; Areas: the pixels erased and drawn again for changes deeper than a child (C# Areas), Changed: the controls
+     * those areas belong to (C# Changed).
+     */
     LastCompositeRecord: {
         Mode: "full" | "partial";
         Children: number;
         Dirty: readonly SkiaControl[];
+        Areas: readonly SKRect[];
+        Changed: readonly SkiaControl[];
     };
+    /** C# MaxCompositionAreas: more areas than this in one composite record draw it whole instead. */
+    static MaxCompositionAreas: number;
+    /** C# MaxCompositionShare: areas covering more than this share of a composite draw it whole instead. */
+    static MaxCompositionShare: number;
+    /**
+     * Changes deeper than a direct child since the last composite record (drawnui-cross 6m): the control, the direct child
+     * it is in, where it was drawn before the change (its own drawn bounds, as drawn) and its rect then.
+     */
+    private compositeDeep?;
+    /** Set while an UpdateDraw climbs: the ancestors re-measure but an ImageComposite among them keeps its partial record. */
+    private static drawOrigin;
+    /** Nonzero while a composite redraws only some areas: layouts skip children entirely outside the clip. */
+    static CompositionCulling: number;
     /** The children a composite record can re-record individually; layouts return their views. */
     protected GetCompositeChildren(): readonly SkiaControl[];
     /** C# TrackChildAsDirty (DirtyChildrenTracker): the child changed without a remeasure of this control. */
     TrackChildAsDirty(child: SkiaControl): void;
+    private static readonly rejectRect;
+    /** During a partial composite record: true when this control draws nothing inside the canvas clip (skipped whole). */
+    OutsideCompositionClip(canvas: SkCanvas): boolean;
     /** Drawn bounds in canvas pixels including transforms and effects margins (C# GetTransformedDirtyBounds). */
     GetTransformedDirtyBounds(): SKRect;
     /** Current cache, if any. */
@@ -160,6 +185,36 @@ export declare class SkiaControl {
     /** Consume every gesture that lands on this control so nothing below (z-order) receives it. */
     BlockGesturesBelow: boolean;
     LockChildrenGestures: LockTouch;
+    private receivesHover?;
+    /**
+     * Whether this control takes mouse hover: the canvas sets IsHovered while the mouse is over it. Opt-in: false by
+     * default, true by default only in the controls that always had hover (SkiaButton, SkiaSlider, the toggles,
+     * SkiaRadioButton, SkiaCarousel, SkiaDrawer), never because a control has a tap handler. A HoverChanged handler turns
+     * it on (C# fluent OnHovered) unless it is set.
+     */
+    get ReceivesHover(): boolean;
+    set ReceivesHover(value: boolean);
+    /** The value of ReceivesHover until it is set. */
+    protected ReceivesHoverByDefault(): boolean;
+    private isHovered;
+    /**
+     * True while the mouse is over this control and it takes hover. Every such control under the pointer is hovered at
+     * once (a card and the button inside it, as CSS :hover); it stays as it is while content moves under the pointer and
+     * is checked again when that stops. Touch never hovers.
+     */
+    get IsHovered(): boolean;
+    /** IsHovered changed: true when the mouse came over this control, false when it left (C# HoverChanged / OnHovered). */
+    HoverChanged?: (sender: SkiaControl, hovered: boolean) => void;
+    /** Set by the canvas's HoverManager. */
+    ApplyHover(on: boolean): void;
+    /** A scroll, carousel or drawer moving its content right now: hover waits until it stops (C# IsScrolling / InTransition). */
+    MovesContent(): boolean;
+    /**
+     * Hover hit path (HoverManager): this control is under the point (in its own space), its children under it follow,
+     * top-most first, by the routing rules of ProcessGestures. True when this subtree blocks gestures below it, so the
+     * controls under it get no hover (a popup over a list).
+     */
+    CollectHovered(point: SKPoint, into: SkiaControl[]): boolean;
     TouchEffectColor: Color;
     /** Plays a ripple (from the tap point) when Tapped fires. */
     AnimationTapped: SkiaTouchAnimation;
@@ -211,6 +266,11 @@ export declare class SkiaControl {
      * built in code-behind is styled on its first measure and keeps whatever the code already set.
      */
     ApplyInitialStyles(atConstruction?: boolean): void;
+    /**
+     * C# IsChildrenItem: added by the app (JSX children or the `Children` list), not a part the control made itself. A new
+     * `Children` list drops only these, so a control's own parts keep their place.
+     */
+    IsChildrenItem: boolean;
     AddSubView(_control: SkiaControl): void;
     InsertSubView(_index: number, control: SkiaControl): void;
     RemoveSubView(_control: SkiaControl): void;
@@ -416,6 +476,30 @@ export declare class SkiaControl {
      * cache holds its composited output, so those are staled before redrawing (DrawnUi RedrawCanvas + parent invalidation).
      */
     RepaintComposition(): void;
+    /**
+     * Update() for a change of how this control looks, not of its size (a color set through props, C# NeedDraw): the same
+     * re-measure and cache invalidation, but an ImageComposite above redraws only this control's area instead of
+     * recording whole (drawnui-cross 6m). The record still goes whole when the control's rect changed after all.
+     */
+    UpdateDraw(): void;
+    /**
+     * A change of this control that keeps its layout, to every ImageComposite above: a direct child is drawn again whole
+     * (C# TrackChildAsDirty), a deeper control by its area, read now as it was drawn (its last matrix and effects margin).
+     */
+    private ReportToComposites;
+    /** The matrix this control will be drawn with (Render), from its current properties; undefined when none. */
+    private CurrentMatrix;
+    /** Where this control will be drawn: its rect grown by its effects margin, through its current matrix. */
+    private DrawnBoundsNow;
+    private static MapRect;
+    /** Its output depends on all of its content (a visual effect; a backdrop samples below): a change inside redraws it whole. */
+    protected get SamplesContent(): boolean;
+    /**
+     * Where a deep change shows inside the composite (drawnui-cross 6m rule b): the control as drawn before and as drawn
+     * now, then through the transform of every ancestor up to the composite. undefined: draw the child whole (an effect
+     * or a backdrop on the way, the control gone from the child); null: the layout changed, record whole.
+     */
+    private static DeepArea;
     /**
      * DrawnUi IsParentIndependent: this control's size never changes the layout around it, so its own invalidation
      * stops here (ancestors composite again, nothing above re-measures). The parent re-measures it on draw when