drawnui-react 0.1.0-preview.2 → 0.1.0-preview.21

package/dist/controls/GridStructure.js

@@ -88,7 +88,7 @@ export class SkiaGridStructure {
     spans = new Map();
     explicitWidth;
     explicitHeight;
-    constructor(grid, widthConstraint, heightConstraint, scale) {
+    constructor(grid, widthConstraint, heightConstraint, scale, children = grid.Views) {
         this.grid = grid;
         this.widthConstraint = widthConstraint;
         this.heightConstraint = heightConstraint;
@@ -99,7 +99,7 @@ export class SkiaGridStructure {
         this.explicitHeight = grid.HeightRequest;
         this.Rows = this.InitializeTracks(grid.RowDefinitions, grid.DefaultRowDefinition);
         this.Columns = this.InitializeTracks(grid.ColumnDefinitions, grid.DefaultColumnDefinition);
-        this.children = grid.Views.filter((v) => v.IsVisible);
+        this.children = children.filter((v) => v.IsVisible);
         this.InitializeCells();
         this.MeasureCells();
     }
@@ -294,7 +294,20 @@ export class SkiaGridStructure {
     ResolveStarRows(heightConstraint) {
         this.ResolveStars(this.Rows, heightConstraint - this.GridHeight(), (c) => c.IsRowSpanStar, (v) => v.MeasuredSize.Units.Height);
     }
+    /**
+     * C# SizesAutoRow: the child decides the height of its single Auto row, so it is measured with the height that row
+     * could still grow to, not with the row's current size (drawnui-cross 6p).
+     */
+    SizesAutoRow(cell) { return cell.RowSpan === 1 && this.Rows[cell.Row].IsAuto; }
+    static NeedFillY(child) { return child.VerticalOptions === "Fill" && child.HeightRequest < 0; }
+    /**
+     * C# HeightOnAutoRow: the height the single Auto row could still grow to, unbounded for a vertical Fill child (which
+     * would take the whole constraint). The row's size so far came from a first pass at the grid's whole width, so a
+     * label wrapping in a star column was measured against its one-line height.
+     */
+    HeightOnAutoRow(cell, child) { return SkiaGridStructure.NeedFillY(child) ? Infinity : this.AvailableHeight(cell); }
     MeasureKnownCells() {
+        let autoRowGrew = false;
         for (const cell of this.cells) {
             if (!cell.NeedsKnownMeasurePass)
                 continue;
@@ -307,12 +320,30 @@ export class SkiaGridStructure {
                 continue;
             const child = this.children[cell.ViewIndex];
             const rect = this.GetCellBoundsFor(child);
-            this.MeasurePx(child, rect.Width, rect.Height);
+            if (child.IsVisible && this.SizesAutoRow(cell)) {
+                // the row grows to the child at its real width, within the room the grid has left
+                let grown = this.MeasurePx(child, rect.Width, this.HeightOnAutoRow(cell, child)).Height;
+                const available = this.AvailableHeight(cell);
+                if (isFinite(available) && grown > available)
+                    grown = available;
+                if (grown > this.Rows[cell.Row].Size) {
+                    this.Rows[cell.Row].Update(grown);
+                    autoRowGrew = true;
+                }
+            }
+            else
+                this.MeasurePx(child, rect.Width, rect.Height);
             if (cell.IsColumnSpanStar && cell.ColumnSpan > 1)
                 this.TrackSpan({ Key: `c${cell.Column}:${cell.ColumnSpan}`, Start: cell.Column, Length: cell.ColumnSpan, IsColumn: true, Requested: rect.Width });
             if (cell.IsRowSpanStar && cell.RowSpan > 1)
                 this.TrackSpan({ Key: `r${cell.Row}:${cell.RowSpan}`, Start: cell.Row, Length: cell.RowSpan, IsColumn: false, Requested: rect.Height });
         }
+        if (autoRowGrew) {
+            // star rows were resolved against the smaller Auto rows: they get what is left now, nothing when Auto took it all
+            SkiaGridStructure.ZeroOutStars(this.Rows);
+            if (this.heightConstraint - this.GridHeight() > 0)
+                this.ResolveStarRows(this.heightConstraint);
+        }
     }
     AvailableWidth(cell) {
         let w = 0, absolute = true;
@@ -390,10 +421,15 @@ export class SkiaGridStructure {
     RemeasureChildrenAtFinalCells() {
         for (const cell of this.cells) {
             const child = this.children[cell.ViewIndex];
+            if (!child.IsVisible)
+                continue;
             const rect = this.GetCellBoundsFor(child);
             if (rect.Width <= 0 || rect.Height <= 0)
                 continue;
-            const m = this.MeasurePx(child, rect.Width, rect.Height);
+            // on an Auto row a child that is not Fill vertically keeps the height the row can grow to, as in
+            // MeasureKnownCells: the same request returns at once, and wrapped text is not cut to the row
+            const height = this.SizesAutoRow(cell) && !SkiaGridStructure.NeedFillY(child) ? Math.max(rect.Height, this.AvailableHeight(cell)) : rect.Height;
+            const m = this.MeasurePx(child, rect.Width, height);
             if (cell.ColumnSpan === 1 && this.Columns[cell.Column].IsAuto && m.Width > this.Columns[cell.Column].Size)
                 this.Columns[cell.Column].Update(m.Width);
             if (cell.RowSpan === 1 && this.Rows[cell.Row].IsAuto && m.Height > this.Rows[cell.Row].Size)

package/dist/controls/SkiaBackdrop.d.ts

@@ -4,10 +4,14 @@ import { SkiaLayout } from "./SkiaLayout";
 /**
  * Mirrors DrawnUi SkiaBackdrop: draws what is already painted beneath its box through `Blur` (points, default 5)
  * and `Brightness` (gamma, 1 = unchanged), tinted by `BackgroundColor`; children draw first and are blurred too.
- * The snapshot comes from the surface being drawn (`UseContext`) or the on-screen surface. Not cached (re-blurs
- * on every frame it is drawn in; inside a cached parent it is re-recorded with that parent).
+ * The snapshot comes from the surface being drawn (`UseContext`, the area it covers there through every ancestor
+ * transform) or the on-screen surface. Not cached (re-blurs on every frame it is drawn in); picture-cached ancestors
+ * draw live once it is inside them (HostsBackdrop); inside an Image-cached ancestor it copies that cache's surface
+ * (right when what shows through the glass is inside that cache, wrong when it should show content outside it).
  */
 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). */
@@ -21,5 +25,7 @@ export declare class SkiaBackdrop extends SkiaLayout {
     protected PaintBackground(_ctx: DrawingContext): void;
     protected PaintsBackgroundWithoutColor(): boolean;
     protected Paint(ctx: DrawingContext): void;
+    /** C# StopPictureCachesAbove: the picture-cached ancestors draw live from the next frame, which this asks for. */
+    protected StopPictureCachesAbove(): void;
     protected OnDisposing(): void;
 }

package/dist/controls/SkiaBackdrop.js

@@ -4,10 +4,14 @@ import { SkiaLayout } from "./SkiaLayout";
 /**
  * Mirrors DrawnUi SkiaBackdrop: draws what is already painted beneath its box through `Blur` (points, default 5)
  * and `Brightness` (gamma, 1 = unchanged), tinted by `BackgroundColor`; children draw first and are blurred too.
- * The snapshot comes from the surface being drawn (`UseContext`) or the on-screen surface. Not cached (re-blurs
- * on every frame it is drawn in; inside a cached parent it is re-recorded with that parent).
+ * The snapshot comes from the surface being drawn (`UseContext`, the area it covers there through every ancestor
+ * transform) or the on-screen surface. Not cached (re-blurs on every frame it is drawn in); picture-cached ancestors
+ * draw live once it is inside them (HostsBackdrop); inside an Image-cached ancestor it copies that cache's surface
+ * (right when what shows through the glass is inside that cache, wrong when it should show content outside it).
  */
 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). */
@@ -38,16 +42,36 @@ export class SkiaBackdrop extends SkiaLayout {
         }
         if (!this.HasEffects)
             return;
+        // C# StopPictureCachesAbove: a screen copy recorded into an ancestor's picture would be replayed frozen; this frame
+        // draws no copy, the picture-cached ancestors draw live from the next frame on (HostsBackdrop)
+        if (ctx.Context.Recording) {
+            this.StopPictureCachesAbove();
+            return;
+        }
         // C# UseContext: snapshot the surface the pixels end up on — the on-screen surface or the nearest Image cache
-        // surface (Origin = its top-left in canvas pixels). Content beneath is already there because caches are recorded
-        // inline while the parent paints, so this also works while an Operations picture is being recorded.
+        // surface. Copied where the backdrop really is on that surface: its rect through the canvas matrix (ancestor
+        // scale, move, rotation, 3D, the cache origin), rounded out, clamped to the surface, and drawn back 1:1 with the
+        // matrix undone, clipped to the backdrop's own (maybe turned) rect: the blur stays the same on screen while an
+        // ancestor scales (C# 6fd3bae3). The global surface (UseContext false) is copied at the layout rect.
         const surface = this.UseContext ? ctx.Context.Surface : this.Superview?.Surface;
         if (!surface)
             return;
         surface.flush();
-        const origin = this.UseContext ? ctx.Context.Origin : undefined;
-        const ox = origin?.X ?? 0, oy = origin?.Y ?? 0;
-        const l = Math.floor(d.Left - ox), t = Math.floor(d.Top - oy), r = Math.ceil(d.Right - ox), b = Math.ceil(d.Bottom - oy);
+        let l = Math.floor(d.Left), t = Math.floor(d.Top), r = Math.ceil(d.Right), b = Math.ceil(d.Bottom);
+        let device = null;
+        if (this.UseContext) {
+            const m = canvas.getTotalMatrix();
+            const p = CK.Matrix.mapPoints(m, [d.Left, d.Top, d.Right, d.Top, d.Right, d.Bottom, d.Left, d.Bottom]);
+            l = Math.max(0, Math.floor(Math.min(p[0], p[2], p[4], p[6])));
+            t = Math.max(0, Math.floor(Math.min(p[1], p[3], p[5], p[7])));
+            r = Math.min(surface.width(), Math.ceil(Math.max(p[0], p[2], p[4], p[6])));
+            b = Math.min(surface.height(), Math.ceil(Math.max(p[1], p[3], p[5], p[7])));
+            if (r <= l || b <= t)
+                return;
+            device = CK.Matrix.invert(m);
+            if (!device)
+                return;
+        }
         // whole-surface snapshot, sub-rect on draw: a bounded snapshot of a GPU surface is not origin-safe in CanvasKit
         const image = surface.makeImageSnapshot();
         if (!image)
@@ -61,7 +85,13 @@ export class SkiaBackdrop extends SkiaLayout {
             paint.setColorFilter(gamma);
         const saved = canvas.save();
         canvas.clipRect(CK.LTRBRect(d.Left, d.Top, d.Right, d.Bottom), CK.ClipOp.Intersect, true);
-        canvas.drawImageRectOptions(image, CK.LTRBRect(l, t, r, b), CK.LTRBRect(d.Left, d.Top, d.Right, d.Bottom), CK.FilterMode.Linear, CK.MipmapMode.None, paint);
+        if (device) {
+            canvas.concat(device);
+            canvas.drawImageRectOptions(image, CK.LTRBRect(l, t, r, b), CK.LTRBRect(l, t, r, b), CK.FilterMode.Nearest, CK.MipmapMode.None, paint);
+        }
+        else {
+            canvas.drawImageRectOptions(image, CK.LTRBRect(l, t, r, b), CK.LTRBRect(d.Left, d.Top, d.Right, d.Bottom), CK.FilterMode.Linear, CK.MipmapMode.None, paint);
+        }
         canvas.restoreToCount(saved);
         blur?.delete();
         gamma?.delete();
@@ -76,5 +106,15 @@ export class SkiaBackdrop extends SkiaLayout {
             p = p.Parent;
         } });
     }
+    /** C# StopPictureCachesAbove: the picture-cached ancestors draw live from the next frame, which this asks for. */
+    StopPictureCachesAbove() {
+        for (let p = this.Parent; p; p = p.Parent) {
+            if (p.UsingCacheType === "Operations") {
+                p.HostsBackdrop = true;
+                p.InvalidateCache();
+            }
+        }
+        queueMicrotask(() => this.Update());
+    }
     OnDisposing() { this.snapshot?.delete(); this.snapshot = undefined; }
 }

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. */
@@ -24,7 +26,17 @@ export declare class SkiaButton extends SkiaLayout {
     StrokeColor: Color;
     StrokeWidth: number;
     IsPressed: boolean;
-    IsDisabled: boolean;
+    private respondsToGestures;
+    /**
+     * False switches the button off for the user: taps, presses and keyboard activation do nothing (no Tapped, Down, Up),
+     * a tap on it does not reach controls under it, and screen readers report it disabled. Code can still change it.
+     * Same property as on toggles, sliders, scrolls and drawers (drawnui-cross 6w). Default true.
+     */
+    get RespondsToGestures(): boolean;
+    set RespondsToGestures(v: boolean);
+    /** @deprecated The opposite of RespondsToGestures, which every control uses: set `RespondsToGestures = false`. */
+    get IsDisabled(): boolean;
+    set IsDisabled(v: boolean);
     LockPanning: boolean;
     /** Touch feedback played on Down (DrawnUi SkiaButton.ApplyEffect). */
     ApplyEffect: SkiaTouchAnimation;
@@ -41,10 +53,15 @@ export declare class SkiaButton extends SkiaLayout {
     static DefaultAccessibilityRole?: string;
     protected DefaultAccessibilityLabel(): string | undefined;
     protected DefaultAccessibilityCanInteract(): boolean;
+    /** With RespondsToGestures = false the button ignores taps, keyboard navigation skips it and it is reported disabled. */
+    protected AcceptsInput(): boolean;
     /** The button's own BackgroundColor/CornerRadius/Stroke are the frame's; the button itself paints nothing. */
     protected PaintBackground(): void;
     get UsingControlStyle(): ResolvedControlStyle;
-    /** C# Create*StyleContent defaults: accent, corner radius, font size/weight, minimum content size. */
+    /**
+     * C# Create*StyleContent defaults: accent, corner radius, font size/weight, minimum content size.
+     * Every C# style calls SetDefaultMinimumContentSize(100, minH), so the width floor is 100 everywhere.
+     */
     private static Look;
     protected MeasureAbsolute(w: number, h: number, scale: number): ScaledSize;
     /** The frame sits under the padding box: arrange children in the full rect, the label centered inside padding. */

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. */
@@ -24,7 +26,20 @@ export class SkiaButton extends SkiaLayout {
     StrokeColor = Colors.Transparent;
     StrokeWidth = 0;
     IsPressed = false;
-    IsDisabled = false;
+    respondsToGestures = true;
+    /**
+     * False switches the button off for the user: taps, presses and keyboard activation do nothing (no Tapped, Down, Up),
+     * a tap on it does not reach controls under it, and screen readers report it disabled. Code can still change it.
+     * Same property as on toggles, sliders, scrolls and drawers (drawnui-cross 6w). Default true.
+     */
+    get RespondsToGestures() { return this.respondsToGestures; }
+    set RespondsToGestures(v) { if (this.respondsToGestures !== v) {
+        this.respondsToGestures = v;
+        this.NotifyAccessibility();
+    } }
+    /** @deprecated The opposite of RespondsToGestures, which every control uses: set `RespondsToGestures = false`. */
+    get IsDisabled() { return !this.respondsToGestures; }
+    set IsDisabled(v) { this.RespondsToGestures = !v; }
     LockPanning = false;
     /** Touch feedback played on Down (DrawnUi SkiaButton.ApplyEffect). */
     ApplyEffect = "Ripple"; // C# default
@@ -49,22 +64,32 @@ export class SkiaButton extends SkiaLayout {
         this.label.VerticalOptions = "Center";
         this.AddSubView(this.frame);
         this.AddSubView(this.label);
+        // C# ButtonLabel is styled when the button builds its content, and ApplyProperties then overwrites FontFamily with
+        // the button's own (empty by default) value, which the style no longer touches. Same order here: style the caption
+        // now, MeasureAbsolute below pushes SkiaButton.FontFamily over it every measure.
+        this.frame.ApplyInitialStyles(true);
+        this.label.ApplyInitialStyles(true);
     }
     /** Set to `Aria.RoleButton` to expose every button (React extension). */
     static DefaultAccessibilityRole;
     DefaultAccessibilityLabel() { return this.Text || undefined; }
-    DefaultAccessibilityCanInteract() { return !this.IsDisabled; }
+    DefaultAccessibilityCanInteract() { return this.respondsToGestures; }
+    /** With RespondsToGestures = false the button ignores taps, keyboard navigation skips it and it is reported disabled. */
+    AcceptsInput() { return this.respondsToGestures; }
     /** The button's own BackgroundColor/CornerRadius/Stroke are the frame's; the button itself paints nothing. */
     PaintBackground() { }
     get UsingControlStyle() { return ResolveControlStyle(this.ControlStyle); }
-    /** C# Create*StyleContent defaults: accent, corner radius, font size/weight, minimum content size. */
+    /**
+     * C# Create*StyleContent defaults: accent, corner radius, font size/weight, minimum content size.
+     * Every C# style calls SetDefaultMinimumContentSize(100, minH), so the width floor is 100 everywhere.
+     */
     static Look(s) {
         switch (s) {
-            case "Cupertino": return { bg: "#007AFF", radius: 8, font: 17, weight: 600, minH: 36, shadow: new SkiaShadow({ X: 0, Y: 1, Blur: 2, Opacity: 0.2, Color: Colors.Black }) };
-            case "Material": return { bg: "#2196F3", radius: 4, font: 14, weight: 0, minH: 40, shadow: new SkiaShadow({ X: 0, Y: 2, Blur: 4, Opacity: 0.3, Color: Colors.Black }) };
-            case "Material3": return { bg: "#6750A4", radius: 20, font: 14, weight: 0, minH: 40 };
-            case "Windows": return { bg: "#0078D7", radius: 4, font: 15, weight: 500, minH: 32, shadow: new SkiaShadow({ X: 0, Y: 1, Blur: 1, Opacity: 0.2, Color: Colors.Black }) };
-            default: return { bg: "#DC143C", radius: 8, font: 15, weight: 0, minH: 41 };
+            case "Cupertino": return { bg: "#007AFF", radius: 8, font: 17, weight: 600, minW: 100, minH: 36, shadow: new SkiaShadow({ X: 0, Y: 1, Blur: 2, Opacity: 0.2, Color: Colors.Black }) };
+            case "Material": return { bg: "#2196F3", radius: 4, font: 14, weight: 0, minW: 100, minH: 40, shadow: new SkiaShadow({ X: 0, Y: 2, Blur: 4, Opacity: 0.3, Color: Colors.Black }) };
+            case "Material3": return { bg: "#6750A4", radius: 20, font: 14, weight: 0, minW: 100, minH: 40 };
+            case "Windows": return { bg: "#0078D7", radius: 4, font: 15, weight: 500, minW: 100, minH: 32, shadow: new SkiaShadow({ X: 0, Y: 1, Blur: 1, Opacity: 0.2, Color: Colors.Black }) };
+            default: return { bg: "#DC143C", radius: 8, font: 15, weight: 0, minW: 100, minH: 41 };
         }
     }
     MeasureAbsolute(w, h, scale) {
@@ -75,7 +100,12 @@ export class SkiaButton extends SkiaLayout {
         this.frame.StrokeWidth = this.StrokeWidth;
         if (this.frame.Shadows[0] !== look.shadow)
             this.frame.Shadows = look.shadow ? [look.shadow] : [];
-        if (this.MinimumHeightRequest < 0 && this.UsingControlStyle !== "Unset")
+        // C# SetDefaultMinimumContentSize(100, minH) from the style builder: a style default only where the app left the
+        // size unset, skipped on a Fill axis. C# adds Margins because it compares the minimum against a margin-inclusive
+        // size; here Measure applies it to the margin-excluded size and adds the margin after, so the plain value is used.
+        if (this.WidthRequest < 0 && this.MinimumWidthRequest < 0 && this.HorizontalOptions !== "Fill")
+            this.MinimumWidthRequest = look.minW;
+        if (this.HeightRequest < 0 && this.MinimumHeightRequest < 0 && this.VerticalOptions !== "Fill")
             this.MinimumHeightRequest = look.minH;
         this.label.Text = this.Text;
         this.label.TextColor = this.TextColor;
@@ -113,8 +143,8 @@ export class SkiaButton extends SkiaLayout {
         this.Repaint();
     }
     ProcessGestures(args, apply) {
-        if (this.IsDisabled)
-            return null;
+        if (!this.respondsToGestures)
+            return this.BlockedGestureResult(args); // no press, no Down / Up / Tapped; a tap on it stops here
         const point = args.Event.Location;
         if (args.Type === "Down") {
             this.IsPressed = true;

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;
@@ -99,7 +101,7 @@ export declare class SkiaCarousel extends SnappingLayout {
     private GetVirtualSnapPoints;
     protected GetVirtualAnchor(current: SKPoint): SnapPoint;
     protected FindNearestAnchorInternal(current: SKPoint, velocity: SKPoint): SKPoint;
-    /** C# SkiaCarousel.ScrollToNearestAnchor: velocity below 100 counts as none; looped snaps around virtual anchors. */
+    /** C# SkiaCarousel.ScrollToNearestAnchor: velocity below SnapVelocityThreshold counts as none; looped snaps around virtual anchors. */
     ScrollToNearestAnchor(location: SKPoint, velocity: SKPoint): void;
     /** C# SkiaCarousel.SelectNextAnchor: base choice, plus a wrap to the virtual anchor at the strip borders when looped. */
     SelectNextAnchor(origin: SKPoint, velocity: SKPoint): SKPoint;
@@ -127,6 +129,12 @@ export declare class SkiaCarousel extends SnappingLayout {
     /** C# RenderViewsList: position every slide, draw the visible ones (+ neighbours when PreloadNeighboors), release the rest. */
     protected Paint(ctx: DrawingContext): void;
     private SlideRect;
+    /**
+     * Whether the slide at `index` takes part in hit-testing for the frame being rendered (C# IsSlideHitTestable).
+     * Every slide drawn on screen does by default; a carousel whose slides share one rect (SkiaShaderCarousel) narrows
+     * this to the slide the user actually sees.
+     */
+    protected IsSlideHitTestable(_index: number): boolean;
     protected GetGestureListeners(): readonly SkiaControl[];
     ProcessGestures(args: SkiaGesturesParameters, apply: GestureEventProcessingInfo): SkiaControl | null;
     protected DefaultAccessibilityLabel(): string | undefined;

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;
@@ -230,9 +232,10 @@ export class SkiaCarousel extends SnappingLayout {
         }
         return super.FindNearestAnchorInternal(current, velocity);
     }
-    /** C# SkiaCarousel.ScrollToNearestAnchor: velocity below 100 counts as none; looped snaps around virtual anchors. */
+    /** C# SkiaCarousel.ScrollToNearestAnchor: velocity below SnapVelocityThreshold counts as none; looped snaps around virtual anchors. */
     ScrollToNearestAnchor(location, velocity) {
-        velocity = new SKPoint(Math.abs(velocity.X) < 100 ? 0 : velocity.X, Math.abs(velocity.Y) < 100 ? 0 : velocity.Y);
+        const t = this.SnapVelocityThreshold;
+        velocity = new SKPoint(Math.abs(velocity.X) < t ? 0 : velocity.X, Math.abs(velocity.Y) < t ? 0 : velocity.Y);
         if (this.ApplyLoopedLogic) {
             const origin = this.FindNearestAnchorInternal(location, velocity);
             const target = this.SelectNextAnchor(origin, velocity);
@@ -504,7 +507,7 @@ export class SkiaCarousel extends SnappingLayout {
                 view.Measure(inner.Width, inner.Height, scale); // recycled cells carry new content
             view.Arrange(this.SlideRect(inner, this.SlideOffset(cell.offset), scale), view.WidthRequest, view.HeightRequest, scale);
             view.Render(ctx);
-            if (cell.visible)
+            if (cell.visible && this.IsSlideHitTestable(cell.index))
                 visible.push(view);
         }
         this.visibleViews = visible;
@@ -514,6 +517,12 @@ export class SkiaCarousel extends SnappingLayout {
             ? SKRect.Create(inner.Left, inner.Top + offset.Y * scale, inner.Width, inner.Height)
             : SKRect.Create(inner.Left + offset.X * scale, inner.Top, inner.Width, inner.Height);
     }
+    /**
+     * Whether the slide at `index` takes part in hit-testing for the frame being rendered (C# IsSlideHitTestable).
+     * Every slide drawn on screen does by default; a carousel whose slides share one rect (SkiaShaderCarousel) narrows
+     * this to the slide the user actually sees.
+     */
+    IsSlideHitTestable(_index) { return true; }
     GetGestureListeners() { return this.visibleViews; }
     // ---- gestures (port of C# SkiaCarousel.ProcessGestures) ----
     ProcessGestures(args, apply) {
@@ -555,6 +564,10 @@ export class SkiaCarousel extends SnappingLayout {
                 if (!this.IsUserPanning) {
                     const movex = Math.abs(e.Distance.Total.X), movey = Math.abs(e.Distance.Total.Y);
                     const along = this.IsVertical ? movey : movex, across = this.IsVertical ? movex : movey;
+                    // a first move too short to tell the direction decides nothing yet (a 1 CSS px move at devicePixelRatio 2):
+                    // marking it wrong kept the whole drag dead until the next press (DrawnUi.Rust c6b22e3; C# decides on every move)
+                    if (along < scale * 2 && across < scale * 2)
+                        return consumedDefault;
                     if (along < scale * 2 || across > along) {
                         this.wrongDirection = true;
                         return consumedDefault;

package/dist/controls/SkiaCheckbox.d.ts

@@ -15,7 +15,6 @@ export declare class SkiaCheckbox extends SkiaToggle {
     get ColorCheckOn(): Color;
     set ColorCheckOn(v: Color);
     protected StyleDefault(name: "ColorThumbOn" | "ColorFrameOn" | "ColorThumbOff" | "ColorFrameOff"): Color | undefined;
-    private SetContentSize;
     protected CreateDefaultContent(): void;
     ApplyProperties(): void;
 }

package/dist/controls/SkiaCheckbox.js

@@ -27,12 +27,6 @@ export class SkiaCheckbox extends SkiaToggle {
         };
         return table[this.UsingControlStyle]?.[name];
     }
-    SetContentSize(w, h) {
-        if (this.WidthRequest < 0)
-            this.WidthRequest = w;
-        if (this.HeightRequest < 0)
-            this.HeightRequest = h;
-    }
     CreateDefaultContent() {
         const off = new SkiaShape();
         off.Tag = "FrameOff";

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.d.ts

@@ -58,7 +58,8 @@ export declare class SkiaEditor extends SkiaShape {
     private readonly placeholder;
     private scrollX;
     private scrollY;
-    private blink;
+    /** The caret blinks on a timer, asleep between blinks: no frame runs while it waits (DrawnUi.Rust editor_rules). */
+    private blinkTimer;
     private caretVisible;
     private subscribed;
     private stubSelectionStop;
@@ -102,6 +103,9 @@ export declare class SkiaEditor extends SkiaShape {
     set CursorPosition(v: number);
     get SelectionLength(): number;
     set SelectionLength(v: number);
+    /** Shows the caret for a full half second, then blinks every 500 ms. */
+    private StartBlink;
+    private StopBlink;
     private OnCursorMoved;
     get IsFocused(): boolean;
     set IsFocused(v: boolean);
@@ -128,7 +132,14 @@ export declare class SkiaEditor extends SkiaShape {
     private LabelPoint;
     protected Paint(ctx: DrawingContext): void;
     ProcessGestures(args: SkiaGesturesParameters, apply: GestureEventProcessingInfo): SkiaControl | null;
+    /** A text field is a Tab stop by default, like a native text box, with no Tapped handler needed. */
+    protected DefaultAccessibilityCanInteract(): boolean;
+    /** Keyboard navigation reached the field (Tab) or left it: take the caret and the input sink like a native text box, or release them. */
+    OnAccessibilityFocused(focused: boolean): void;
+    /** Enter / Space on the field while it has no caret start editing; while editing they are text. */
     OnAccessibilityActivated(): void;
+    /** While editing, arrows, Home / End and PageUp / PageDown belong to the text: they never move a surrounding group. */
+    OnAccessibilityKey(_key: string): boolean;
     protected DefaultAccessibilityLabel(): string | undefined;
     Submit(): void;
     private ExecuteSubmit;