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

package/dist/core/Hover.js

@@ -0,0 +1,134 @@
+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 = [];
+    /** The controls under the pointer at the last hit test, root first, and the pointer in each one's own space. */
+    Path = [];
+    PathX = [];
+    PathY = [];
+    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. The hit path is taken also while
+     * hover waits (the cursor follows it), hover changes only when nothing moves.
+     */
+    Move(root, x, y) {
+        this.hasPointer = true;
+        this.x = x;
+        this.y = y;
+        this.HitTest(root);
+        if (this.paused)
+            return; // content moves under the pointer: what was hovered stays, one check when it stops
+        this.check = false;
+        this.Apply(true);
+    }
+    /** Fills Path with the controls under the pointer by the routing rules of ProcessGestures. */
+    HitTest(root) {
+        const path = this.Path;
+        path.length = 0;
+        this.PathX.length = 0;
+        this.PathY.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, this.PathX, this.PathY);
+        }
+    }
+    /** The pointer left the canvas: nothing is hovered, also while content moves. */
+    Leave() {
+        this.hasPointer = false;
+        this.check = false;
+        this.Path.length = 0;
+        this.PathX.length = 0;
+        this.PathY.length = 0;
+        this.Apply(false);
+    }
+    /** 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.HitTest(root);
+        this.Apply(true);
+    }
+    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;
+    }
+    /**
+     * The hovered set becomes the controls of the hit path that take hover (`fromPath`), or none: the ones that left get
+     * HoverChanged(false), then the new ones (true).
+     */
+    Apply(fromPath) {
+        const now = this.Hovered, next = this.next;
+        next.length = 0;
+        if (fromPath)
+            for (const c of this.Path)
+                if (c.ReceivesHover)
+                    next.push(c);
+        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/ScrollAnimators.js

@@ -1,6 +1,7 @@
 // Mirrors DrawnUi scrolling physics: DecelerationTimingParameters + ScrollFlingAnimator (fling),
 // Spring + SpringTimingParameters + SpringWithVelocityAnimator (bounce), VelocityAccumulator, RubberBandUtils.
 import { SkiaValueAnimator } from "./Animators";
+import { VelocityTrail } from "./Gestures";
 /** UIKit-style exponential deceleration: value(t) = v0 * (rate^(1000 t) - 1) / k, k = 1000 ln(rate). */
 export class DecelerationTimingParameters {
     InitialValue;
@@ -201,6 +202,14 @@ export class VelocityAccumulator {
     Clear() { this.samples.length = 0; }
     CaptureVelocity(x, y, arrivedTimeNanos = 0) {
         const time = arrivedTimeNanos > 0 ? arrivedTimeNanos / 1e6 : performance.now();
+        // a move in the same burst as the last one replaces it: the first move of a burst carries only part of the burst's
+        // distance (DrawnUi.Rust VelocityAccumulator, 6d525f7)
+        const last = this.samples[this.samples.length - 1];
+        if (last && time - last.time < VelocityTrail.BurstMs) {
+            last.X = x;
+            last.Y = y;
+            return;
+        }
         if (this.samples.length === VelocityAccumulator.MaxSampleSize)
             this.samples.shift();
         this.samples.push({ X: x, Y: y, time });

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;
     /** 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;
+    /** Its cache must be recorded before it can be drawn (none, dirty, another type, scale, size or GPU context). */
+    private CacheStale;
+    /** Its rect grown by its effects margin, through the matrix it is drawn with, lies outside the canvas clip. */
+    private OutsideClip;
     /** 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[], xs?: number[], ys?: number[]): 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;
@@ -272,6 +332,8 @@ export declare class SkiaControl {
      * host's pointer cursor. Default: the control as a whole (AccessibilityCanInteract); SkiaLabel adds its tappable spans.
      */
     WantsPointerCursor(_x: number, _y: number): boolean;
+    /** A range control's value for screen readers (slider, progress); undefined for everything else (drawnui-cross 6c). */
+    get AccessibilityValue(): import("./Accessibility").AccessibilityValue | undefined;
     /** aria-pressed for toggles; undefined = not a toggle. */
     get AccessibilityIsPressed(): boolean | undefined;
     set AccessibilityIsPressed(v: boolean | undefined);
@@ -411,11 +473,45 @@ export declare class SkiaControl {
     Update(): void;
     /** Redraw without remeasure and WITHOUT dropping caches (position/overlay changes). */
     Repaint(): void;
+    /**
+     * A parent (not the control itself) is hidden: a change here asks for no frame and the latest state shows when the
+     * parent is shown again (C# 329f6c44 HiddenUpdateTests, DrawnUi.Rust hidden_updates). The control's own visibility
+     * change still draws: it is the one that hides or shows it.
+     */
+    UnderHiddenParent(): boolean;
+    /** The control or a parent is hidden: its animators pause until it shows again. */
+    HiddenInTree(): boolean;
+    /** The control an invalidation started at while it climbs (InvalidateMeasure): a hidden parent of it wakes no frame. */
+    private static invalidateOrigin;
     /**
      * Transform / Opacity changed: this control's own cache is still valid (content unchanged) but every ancestor
      * 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