drawnui-react 0.1.0-preview.1

package/dist/controls/SkiaCheckbox.js

@@ -0,0 +1,118 @@
+import { Colors, Thickness } from "../core/Types";
+import { SkiaShape } from "./SkiaShape";
+import { SkiaSvg } from "./SkiaSvg";
+import { SkiaToggle } from "./SkiaToggle";
+const SvgCupertinoCheck = '<svg width="800px" height="800px" viewBox="0 0 24 24" fill="none"><path d="M4 12.6111L8.92308 17.5L20 6.5" stroke="#000000" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/></svg>';
+const SvgMaterialCheck = '<svg width="800px" height="800px" viewBox="0 0 24 24" fill="none"><path d="M5 13L9 17L19 7" stroke="#000000" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/></svg>';
+const SvgWindowsCheck = '<svg width="800px" height="800px" viewBox="0 0 24 24" fill="none"><path d="M4 11.6L10 17.6L20 7.6" stroke="#000000" stroke-width="2.5" stroke-linecap="square" stroke-linejoin="round"/></svg>';
+/** Mirrors DrawnUi SkiaCheckbox: `FrameOff` outline, `FrameOn` filled frame with a `ViewCheckOn` mark, per-style looks. */
+export class SkiaCheckbox extends SkiaToggle {
+    static DefaultAccessibilityRole = "checkbox";
+    FrameOff;
+    FrameOn;
+    ViewCheckOn;
+    colorCheckOn;
+    static DefaultAccent = "#DC143C";
+    static DefaultOutline = "#8E959D";
+    /** Color of the check mark (inner square for the default look). */
+    get ColorCheckOn() { return this.colorCheckOn ?? (this.UsingControlStyle === "Unset" ? SkiaCheckbox.DefaultAccent : Colors.White); }
+    set ColorCheckOn(v) { this.colorCheckOn = v; this.ApplyProperties(); }
+    StyleDefault(name) {
+        const table = {
+            Unset: { ColorFrameOff: SkiaCheckbox.DefaultOutline, ColorFrameOn: SkiaCheckbox.DefaultAccent },
+            Cupertino: { ColorFrameOff: "#BFBFBF", ColorFrameOn: "#007AFF" },
+            Material: { ColorFrameOff: "#757575", ColorFrameOn: "#2196F3" },
+            Material3: { ColorFrameOff: "#49454F", ColorFrameOn: "#6750A4" },
+            Windows: { ColorFrameOff: "#999999", ColorFrameOn: "#0078D7" },
+        };
+        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";
+        off.Type = "Rectangle";
+        off.HorizontalOptions = "Fill";
+        off.VerticalOptions = "Fill";
+        const on = new SkiaShape();
+        on.Tag = "FrameOn";
+        on.Type = "Rectangle";
+        on.HorizontalOptions = "Fill";
+        on.VerticalOptions = "Fill";
+        let check;
+        const svg = (markup, margin) => { const v = new SkiaSvg(); v.Tag = "ViewCheckOn"; v.SvgString = markup; v.TintColor = Colors.White; v.Margin = new Thickness(margin); v.HorizontalOptions = "Fill"; v.VerticalOptions = "Fill"; return v; };
+        switch (this.usingStyle) {
+            case "Cupertino":
+                this.SetContentSize(22, 22);
+                off.StrokeWidth = 1.5;
+                off.CornerRadius = 4;
+                on.CornerRadius = 4;
+                check = svg(SvgCupertinoCheck, 2);
+                break;
+            case "Material":
+                this.SetContentSize(24, 24);
+                off.StrokeWidth = 2;
+                off.CornerRadius = 2;
+                on.CornerRadius = 2;
+                check = svg(SvgMaterialCheck, 2);
+                break;
+            case "Material3":
+                this.SetContentSize(18, 18);
+                off.StrokeWidth = 2;
+                off.CornerRadius = 2;
+                on.CornerRadius = 2;
+                check = svg(SvgMaterialCheck, 2);
+                break;
+            case "Windows":
+                this.SetContentSize(20, 20);
+                off.StrokeWidth = 1;
+                off.CornerRadius = 0;
+                on.CornerRadius = 0;
+                check = svg(SvgWindowsCheck, 1);
+                break;
+            default: {
+                this.SetContentSize(22, 22);
+                off.StrokeWidth = 1;
+                on.StrokeWidth = 1;
+                const sq = new SkiaShape();
+                sq.Tag = "ViewCheckOn";
+                sq.Type = "Rectangle";
+                sq.Margin = new Thickness(3);
+                sq.LockRatio = 1;
+                sq.HorizontalOptions = "Fill";
+                sq.VerticalOptions = "Fill";
+                sq.UseCache = "Operations";
+                check = sq;
+            }
+        }
+        on.AddSubView(check);
+        this.FrameOff = off;
+        this.FrameOn = on;
+        this.ViewCheckOn = check;
+        this.AddSubView(off);
+        this.AddSubView(on);
+    }
+    ApplyProperties() {
+        if (!this.contentCreated)
+            return;
+        const on = this.IsToggled;
+        this.FrameOff.StrokeColor = this.ColorFrameOff;
+        if (this.usingStyle === "Unset") {
+            this.FrameOn.StrokeColor = this.ColorFrameOn;
+            this.ViewCheckOn.BackgroundColor = this.ColorCheckOn;
+        }
+        else {
+            this.FrameOn.BackgroundColor = this.ColorFrameOn;
+            this.ViewCheckOn.TintColor = this.ColorCheckOn;
+        }
+        this.FrameOn.IsVisible = on;
+        this.ViewCheckOn.IsVisible = on;
+        this.FrameOff.IsVisible = !on;
+        this.Update();
+    }
+}

package/dist/controls/SkiaDecoratedGrid.d.ts

@@ -0,0 +1,15 @@
+import type { DrawingContext } from "../core/SkiaControl";
+import { type SkiaGradient } from "../core/Types";
+import { SkiaGrid } from "./SkiaLayout";
+/**
+ * Mirrors DrawnUi SkiaDecoratedGrid: a SkiaGrid painting separator lines in the spacing between its tracks,
+ * `VerticalLine` (a ColumnSpacing wide gradient between columns) and `HorizontalLine` (a RowSpacing tall gradient
+ * over black between rows), set either to undefined to skip. Lines draw under the children (C# ZIndex -1 overlay).
+ */
+export declare class SkiaDecoratedGrid extends SkiaGrid {
+    static readonly HorizontalGradient: SkiaGradient;
+    static readonly VerticalGradient: SkiaGradient;
+    HorizontalLine?: SkiaGradient;
+    VerticalLine?: SkiaGradient;
+    protected Paint(ctx: DrawingContext): void;
+}

package/dist/controls/SkiaDecoratedGrid.js

@@ -0,0 +1,46 @@
+import { Super } from "../core/Super";
+import { SKRect } from "../core/Types";
+import { SkiaGrid } from "./SkiaLayout";
+/**
+ * Mirrors DrawnUi SkiaDecoratedGrid: a SkiaGrid painting separator lines in the spacing between its tracks,
+ * `VerticalLine` (a ColumnSpacing wide gradient between columns) and `HorizontalLine` (a RowSpacing tall gradient
+ * over black between rows), set either to undefined to skip. Lines draw under the children (C# ZIndex -1 overlay).
+ */
+export class SkiaDecoratedGrid extends SkiaGrid {
+    static HorizontalGradient = { Type: "Linear", Colors: ["#00E8E3D7", "#78E8E3D7", "#78E8E3D7", "#00E8E3D7"], ColorPositions: [0, 0.1, 0.9, 1], StartXRatio: 0, StartYRatio: 0, EndXRatio: 1, EndYRatio: 0 };
+    static VerticalGradient = { Type: "Linear", Colors: ["#00E8E3D7", "#78E8E3D7", "#78E8E3D7", "#00E8E3D7"], ColorPositions: [0, 0.1, 0.9, 1], StartXRatio: 0, StartYRatio: 0, EndXRatio: 0, EndYRatio: 1 };
+    HorizontalLine = SkiaDecoratedGrid.HorizontalGradient;
+    VerticalLine = SkiaDecoratedGrid.VerticalGradient;
+    Paint(ctx) {
+        const g = this.GridStructure;
+        if (g) {
+            const CK = Super.CK, canvas = ctx.Context.Canvas, scale = ctx.Scale, p = this.Padding, r = this.DrawingRect;
+            const inner = new SKRect(r.Left + p.Left * scale, r.Top + p.Top * scale, r.Right - p.Right * scale, r.Bottom - p.Bottom * scale);
+            const paint = new CK.Paint();
+            paint.setAntiAlias(true);
+            if (this.VerticalLine && this.ColumnSpacing > 0) {
+                for (let col = 1; col < g.Columns.length; col++) {
+                    const x = inner.Left + (g.LeftEdgeOfColumn(col) - this.ColumnSpacing) * scale;
+                    const rect = new SKRect(x, inner.Top, x + this.ColumnSpacing * scale, inner.Bottom);
+                    paint.setShader(null);
+                    if (this.SetupGradient(paint, this.VerticalLine, rect))
+                        canvas.drawRect(CK.LTRBRect(rect.Left, rect.Top, rect.Right, rect.Bottom), paint);
+                }
+            }
+            if (this.HorizontalLine && this.RowSpacing > 0) {
+                for (let row = 1; row < g.Rows.length; row++) {
+                    const y = inner.Top + (g.TopEdgeOfRow(row) - this.RowSpacing) * scale;
+                    const rect = new SKRect(inner.Left, y, inner.Right, y + this.RowSpacing * scale);
+                    const skRect = CK.LTRBRect(rect.Left, rect.Top, rect.Right, rect.Bottom);
+                    paint.setShader(null);
+                    paint.setColor(CK.BLACK); // C#: a black SkiaShape under the gradient
+                    canvas.drawRect(skRect, paint);
+                    if (this.SetupGradient(paint, this.HorizontalLine, rect))
+                        canvas.drawRect(skRect, paint);
+                }
+            }
+            paint.delete();
+        }
+        super.Paint(ctx);
+    }
+}

package/dist/controls/SkiaDrawer.d.ts

@@ -0,0 +1,46 @@
+import type { SkiaControl } from "../core/SkiaControl";
+import { type GestureEventProcessingInfo, SKPoint, type SkiaGesturesParameters } from "../core/Gestures";
+import type { DrawerDirection } from "../core/Types";
+import { SnappingLayout } from "./SnappingLayout";
+/**
+ * Mirrors DrawnUi SkiaDrawer: a panel that slides from an edge (`Direction`), leaving `HeaderSize` points
+ * visible when closed (or travelling `AmplitudeSize`), dragged by gestures and snapped open/closed with
+ * velocity; `IsOpen` drives and reports the state. The drawer moves itself with TranslationX/Y (like C#),
+ * so it must be aligned to its edge by the parent (VerticalOptions="End" for FromBottom, etc.).
+ */
+export declare class SkiaDrawer extends SnappingLayout {
+    Direction: DrawerDirection;
+    /** Points that stay visible when closed. */
+    HeaderSize: number;
+    /** Travel distance override, points; -1 = size minus header. */
+    AmplitudeSize: number;
+    /** Close when a touch lands outside the drawer while open. */
+    AutoClose: boolean;
+    IsOpenChanged?: (sender: SkiaDrawer, isOpen: boolean) => void;
+    StateTransitionComplete?: (sender: SkiaDrawer, isOpen: boolean) => void;
+    private isOpen;
+    private lastSize;
+    private wasDrawn;
+    private panningOffset;
+    private childWasTapped;
+    private hadDown;
+    constructor();
+    get IsOpen(): boolean;
+    set IsOpen(v: boolean);
+    Open(): void;
+    Close(): void;
+    get Horizontal(): boolean;
+    /** C# GetOffsetToHide: translation that hides everything but the header. */
+    private OffsetToHide;
+    protected GetAutoVelocity(displacement: SKPoint): SKPoint;
+    /** C# ApplyOptions: SnapPoints = [open, hidden]; snap to the current IsOpen. */
+    private ApplyOptions;
+    protected OnLayoutChanged(): void;
+    ApplyPosition(position: SKPoint): void;
+    UpdateReportedPosition(): void;
+    /** IsOpen from the anchor the drawer rests on / travels to. */
+    private ReportFromSnap;
+    CheckTransitionEnded(): boolean;
+    ProcessGestures(args: SkiaGesturesParameters, apply: GestureEventProcessingInfo): SkiaControl | null;
+    protected DefaultAccessibilityLabel(): string | undefined;
+}

package/dist/controls/SkiaDrawer.js

@@ -0,0 +1,212 @@
+import { SKPoint } from "../core/Gestures";
+import { SnappingLayout } from "./SnappingLayout";
+/**
+ * Mirrors DrawnUi SkiaDrawer: a panel that slides from an edge (`Direction`), leaving `HeaderSize` points
+ * visible when closed (or travelling `AmplitudeSize`), dragged by gestures and snapped open/closed with
+ * velocity; `IsOpen` drives and reports the state. The drawer moves itself with TranslationX/Y (like C#),
+ * so it must be aligned to its edge by the parent (VerticalOptions="End" for FromBottom, etc.).
+ */
+export class SkiaDrawer extends SnappingLayout {
+    Direction = "FromBottom";
+    /** Points that stay visible when closed. */
+    HeaderSize = 0;
+    /** Travel distance override, points; -1 = size minus header. */
+    AmplitudeSize = -1;
+    /** Close when a touch lands outside the drawer while open. */
+    AutoClose = false;
+    IsOpenChanged;
+    StateTransitionComplete;
+    isOpen = false;
+    lastSize = { W: 0, H: 0 };
+    wasDrawn = false;
+    panningOffset = SKPoint.Empty;
+    childWasTapped = false;
+    hadDown = false;
+    constructor() { super(); this.HorizontalOptions = "Fill"; }
+    get IsOpen() { return this.isOpen; }
+    set IsOpen(v) {
+        if (this.isOpen === v)
+            return;
+        this.isOpen = v;
+        this.IsOpenChanged?.(this, v);
+        this.NotifyAccessibility();
+        if (this.SnapPoints.length === 2)
+            this.ScrollToOffset(v ? this.SnapPoints[0] : this.SnapPoints[1], SKPoint.Empty, this.Animated && this.wasDrawn);
+    }
+    Open() { this.IsOpen = true; }
+    Close() { this.IsOpen = false; }
+    get Horizontal() { return this.Direction === "FromLeft" || this.Direction === "FromRight"; }
+    /** C# GetOffsetToHide: translation that hides everything but the header. */
+    OffsetToHide() {
+        const w = this.DrawingRect.Width / this.RenderingScale, h = this.DrawingRect.Height / this.RenderingScale;
+        const travelH = this.AmplitudeSize >= 0 ? this.AmplitudeSize : h - this.HeaderSize;
+        const travelW = this.AmplitudeSize >= 0 ? this.AmplitudeSize : w - this.HeaderSize;
+        switch (this.Direction) {
+            case "FromLeft": return new SKPoint(-travelW, 0);
+            case "FromRight": return new SKPoint(travelW, 0);
+            case "FromTop": return new SKPoint(0, -travelH);
+            default: return new SKPoint(0, travelH);
+        }
+    }
+    GetAutoVelocity(displacement) {
+        const v = 1500;
+        return this.Horizontal ? new SKPoint(-v * Math.sign(displacement.X), 0) : new SKPoint(0, -v * Math.sign(displacement.Y));
+    }
+    /** C# ApplyOptions: SnapPoints = [open, hidden]; snap to the current IsOpen. */
+    ApplyOptions() {
+        const hide = this.OffsetToHide();
+        this.SnapPoints = [SKPoint.Empty, hide];
+        this.ContentOffsetBounds = this.BoundsFromSnapPoints();
+        this.CurrentSnap = new SKPoint(-1, -1);
+        this.ScrollToOffset(this.isOpen ? this.SnapPoints[0] : this.SnapPoints[1], SKPoint.Empty, this.Animated && this.wasDrawn);
+    }
+    OnLayoutChanged() {
+        super.OnLayoutChanged();
+        const w = this.DrawingRect.Width, h = this.DrawingRect.Height;
+        if (w !== this.lastSize.W || h !== this.lastSize.H) {
+            this.lastSize = { W: w, H: h };
+            this.ApplyOptions();
+        }
+        this.wasDrawn = true;
+    }
+    ApplyPosition(position) {
+        this.TranslationX = position.X;
+        this.TranslationY = position.Y;
+        super.ApplyPosition(position);
+        this.RepaintComposition();
+    }
+    UpdateReportedPosition() {
+        if (this.InTransition)
+            return;
+        this.ReportFromSnap();
+    }
+    /** IsOpen from the anchor the drawer rests on / travels to. */
+    ReportFromSnap() {
+        if (this.SnapPoints.length < 2)
+            return;
+        const hidden = this.SnapPoints[1];
+        const open = !(Math.abs(hidden.X - this.CurrentSnap.X) <= 1 && Math.abs(hidden.Y - this.CurrentSnap.Y) <= 1);
+        if (open !== this.isOpen) {
+            this.isOpen = open;
+            this.IsOpenChanged?.(this, open);
+            this.NotifyAccessibility();
+        }
+    }
+    CheckTransitionEnded() {
+        const ended = super.CheckTransitionEnded();
+        // the transition just ended: report the reached state first (a gesture-driven close has not been reported yet)
+        if (ended && this.InTransition) {
+            this.ReportFromSnap();
+            this.StateTransitionComplete?.(this, this.isOpen);
+        }
+        return ended;
+    }
+    // ---- gestures (port of C# SkiaDrawer.ProcessGestures, single pointer) ----
+    ProcessGestures(args, apply) {
+        const consumedDefault = this.BlockGesturesBelow ? this : null;
+        const scale = this.RenderingScale;
+        const e = args.Event;
+        // the drawer sits in a full-size layer: touches outside its (translated) box are not ours
+        const local = apply.MappedLocation;
+        const hit = this.HitIsInside(local.X + apply.ChildOffset.X, local.Y + apply.ChildOffset.Y);
+        if (!this.hadDown && args.Type !== "Up") {
+            if (!hit) {
+                if (this.AutoClose && this.isOpen && !this.InTransition)
+                    this.IsOpen = false;
+                return null;
+            }
+        }
+        let passed = false;
+        const passToChildren = () => { passed = true; return super.ProcessGestures(args, apply); };
+        let consumed = null;
+        if (args.Type === "Up" || args.Type === "Tapped" || !this.IsUserPanning || !this.RespondsToGestures) {
+            consumed = passToChildren();
+            if (consumed === this)
+                consumed = null;
+            if (consumed && args.Type !== "Up") {
+                if (args.Type === "Tapped")
+                    this.childWasTapped = true;
+                return consumed;
+            }
+        }
+        if (!this.RespondsToGestures)
+            return consumed;
+        const resetPan = () => {
+            this.IsUserFocused = true;
+            this.IsUserPanning = false;
+            this.childWasTapped = false;
+            this.StopSnapAnimators();
+            this.velocityAccumulator.Clear();
+            this.panningOffset = new SKPoint(this.TranslationX, this.TranslationY);
+        };
+        switch (args.Type) {
+            case "Tapped":
+            case "LongPressing":
+                consumed = this;
+                break;
+            case "Down":
+                this.hadDown = true;
+                resetPan();
+                break;
+            case "Panning": {
+                if (!this.hadDown)
+                    return consumedDefault;
+                const horizontal = this.Horizontal;
+                // dragging further open at the open edge: no rubber (C# lockBounce)
+                const openEdge = this.SnapPoints[0], atOpen = openEdge && Math.abs(this.CurrentPosition.X - openEdge.X) <= 1 && Math.abs(this.CurrentPosition.Y - openEdge.Y) <= 1;
+                const dx = e.Distance.Delta.X, dy = e.Distance.Delta.Y;
+                const lockBounce = !!atOpen && ((this.Direction === "FromLeft" && dx > 0) || (this.Direction === "FromRight" && dx < 0) || (this.Direction === "FromBottom" && dy < 0) || (this.Direction === "FromTop" && dy > 0));
+                if (!this.IsUserFocused) {
+                    resetPan();
+                    this.panningOffset = new SKPoint(this.panningOffset.X - dx / scale, this.panningOffset.Y - dy / scale);
+                }
+                let x = this.panningOffset.X + dx / scale, y = this.panningOffset.Y + dy / scale;
+                if (!this.IsUserPanning) {
+                    const tx = Math.abs(e.Distance.Total.X), ty = Math.abs(e.Distance.Total.Y);
+                    const mainHorizontal = tx > ty * 0.9, mainVertical = ty > tx * 0.9;
+                    if (this.IgnoreWrongDirection && ((horizontal && !mainHorizontal) || (!horizontal && !mainVertical)))
+                        break;
+                    if (horizontal ? tx < scale : ty < scale)
+                        break;
+                    this.IsUserPanning = true;
+                }
+                if (horizontal) {
+                    this.velocityAccumulator.CaptureVelocity(e.Distance.Velocity.X / scale, 0, args.ArrivedTimeNanos);
+                    y = 0;
+                }
+                else {
+                    this.velocityAccumulator.CaptureVelocity(0, e.Distance.Velocity.Y / scale, args.ArrivedTimeNanos);
+                    x = 0;
+                }
+                this.panningOffset = new SKPoint(x, y);
+                const clamped = this.ClampOffset(x, y, this.Bounces && !lockBounce);
+                if (!this.Bounces && lockBounce && Math.abs(clamped.X) <= 1 && Math.abs(clamped.Y) <= 1) {
+                    this.IsUserPanning = false;
+                    return null;
+                } // let a parent scroll take it
+                this.ApplyPosition(clamped);
+                consumed = this;
+                break;
+            }
+            case "Up": {
+                this.hadDown = false;
+                if (this.childWasTapped || !this.IsUserPanning)
+                    break;
+                const final = this.velocityAccumulator.CalculateFinalVelocity(3000);
+                const v = this.Horizontal ? new SKPoint(final.X, 0) : new SKPoint(0, final.Y);
+                this.CurrentSnap = this.CurrentPosition;
+                this.ScrollToNearestAnchor(this.CurrentPosition, v);
+                this.IsUserPanning = false;
+                this.IsUserFocused = false;
+                consumed = this;
+                break;
+            }
+        }
+        if (consumed || this.IsUserPanning)
+            return consumed ?? (args.Type !== "Up" ? this : consumedDefault);
+        if (!passed)
+            return passToChildren();
+        return consumedDefault;
+    }
+    DefaultAccessibilityLabel() { return this.isOpen ? "Drawer open" : "Drawer closed"; }
+}

package/dist/controls/SkiaDynamicDrawnCell.d.ts

@@ -0,0 +1,11 @@
+import { SkiaLayout } from "./SkiaLayout";
+/**
+ * Mirrors DrawnUi SkiaDynamicDrawnCell: base for recycled cells. Build the visuals once in the
+ * constructor, override SetContent(ctx) to push the bound item into them — it runs on every rebind.
+ */
+export declare class SkiaDynamicDrawnCell extends SkiaLayout {
+    constructor();
+    protected OnBindingContextChanged(): void;
+    /** Called with the item (BindingContext) whenever the cell is (re)bound. */
+    protected SetContent(_ctx: unknown): void;
+}

package/dist/controls/SkiaDynamicDrawnCell.js

@@ -0,0 +1,17 @@
+import { SkiaLayout } from "./SkiaLayout";
+/**
+ * Mirrors DrawnUi SkiaDynamicDrawnCell: base for recycled cells. Build the visuals once in the
+ * constructor, override SetContent(ctx) to push the bound item into them — it runs on every rebind.
+ */
+export class SkiaDynamicDrawnCell extends SkiaLayout {
+    constructor() {
+        super();
+        this.HorizontalOptions = "Fill";
+    }
+    OnBindingContextChanged() {
+        super.OnBindingContextChanged();
+        this.SetContent(this.BindingContext);
+    }
+    /** Called with the item (BindingContext) whenever the cell is (re)bound. */
+    SetContent(_ctx) { }
+}

package/dist/controls/SkiaEditor.d.ts

@@ -0,0 +1,163 @@
+import type { DrawingContext, SkiaControl } from "../core/SkiaControl";
+import { type GestureEventProcessingInfo, type SkiaGesturesParameters } from "../core/Gestures";
+import { type PrebuiltControlStyle } from "../core/ControlStyle";
+import { type Color, type DrawTextAlignment, type ReturnType, ScaledSize, type SkiaEditorKeyboard, type SkiaGradient, type TextAlignment } from "../core/Types";
+import { SkiaLabel } from "./SkiaLabel";
+import { SkiaShape } from "./SkiaShape";
+/**
+ * Mirrors DrawnUi SkiaEditor: a drawn text input. The text is a SkiaLabel inside a shape with padding, a
+ * placeholder label, a blinking caret and a selection overlay painted by the editor; single line
+ * (`MaxLines` 1, horizontal scrolling to the caret) or multiline (`MaxLines` != 1, `AutoHeight`). Keys come from
+ * the window-level `KeyboardManager` like the DrawnUi.Blazor / Wasm heads (no DOM text input: no IME, no mobile
+ * soft keyboard) and are applied by the same stub editing methods (`StubTypeText`, `StubBackspace`, arrows,
+ * Home / End, Ctrl+A / C / X / V). Taps place the caret, drags select, a long press selects the word, Enter submits
+ * (single line, or multiline with `ReturnType` Send).
+ */
+export declare class SkiaEditor extends SkiaShape {
+    /** The editor currently holding the keyboard, if any. */
+    static Focused?: SkiaEditor;
+    static DefaultAccessibilityRole?: string;
+    TextChanged?: (sender: SkiaEditor, text: string) => void;
+    FocusChanged?: (sender: SkiaEditor, focused: boolean) => void;
+    CursorMoved?: (sender: SkiaEditor) => void;
+    TextSubmitted?: (sender: SkiaEditor, text: string) => void;
+    private text;
+    private placeholderText;
+    PlaceholderColor: Color;
+    PlaceholderHorizontalAlignment: DrawTextAlignment;
+    private fontSize;
+    private fontFamily;
+    private fontWeight;
+    private textColor;
+    TextGradient?: SkiaGradient;
+    private lineHeight;
+    private horizontalTextAlignment;
+    private verticalTextAlignment;
+    private maxLines;
+    AutoHeight: boolean;
+    private isPassword;
+    /** Enter on a multiline editor: Send submits, anything else inserts a line break. */
+    ReturnType: ReturnType;
+    KeyboardType: SkiaEditorKeyboard;
+    private fontFamilyFallback;
+    /** Fallback font aliases for glyphs the main font lacks (symbols, emoji), forwarded to the text and placeholder labels. */
+    get FontFamilyFallback(): string;
+    set FontFamilyFallback(v: string);
+    IsSpellCheckEnabled: boolean;
+    /** Accepted for parity: the React label always renders unicode; markdown formatting while editing is not ported. */
+    UseMarkdown: boolean;
+    UseUnicode: boolean;
+    CursorColor: Color;
+    CanShowCursor: boolean;
+    SelectionColor: Color;
+    private cursorPosition;
+    private selectionLength;
+    private isFocused;
+    private controlStyle;
+    readonly Label: SkiaLabel;
+    private readonly placeholder;
+    private scrollX;
+    private scrollY;
+    private blink;
+    private caretVisible;
+    private subscribed;
+    private stubSelectionStop;
+    private selectionMovingEdge;
+    private readonly onKeyDown;
+    private readonly onKeyChar;
+    private selectionAnchor;
+    private dragSelecting;
+    private styleApplied;
+    private layoutVersion;
+    private boxes;
+    constructor();
+    get Text(): string;
+    set Text(v: string);
+    get PlaceholderText(): string;
+    set PlaceholderText(v: string);
+    get FontSize(): number;
+    set FontSize(v: number);
+    get FontFamily(): string;
+    set FontFamily(v: string);
+    get FontWeight(): number;
+    set FontWeight(v: number);
+    get TextColor(): Color;
+    set TextColor(v: Color);
+    get LineHeight(): number;
+    set LineHeight(v: number);
+    get HorizontalTextAlignment(): DrawTextAlignment;
+    set HorizontalTextAlignment(v: DrawTextAlignment);
+    get VerticalTextAlignment(): TextAlignment;
+    set VerticalTextAlignment(v: TextAlignment);
+    /** 1 = single line (default); anything else = multiline, -1 unbounded. */
+    get MaxLines(): number;
+    set MaxLines(v: number);
+    get IsPassword(): boolean;
+    set IsPassword(v: boolean);
+    get IsMultiline(): boolean;
+    get HasSelection(): boolean;
+    get ShouldSubmitOnEnter(): boolean;
+    /** Caret index (UTF-16 units) = the left edge of the selection when one exists. */
+    get CursorPosition(): number;
+    set CursorPosition(v: number);
+    get SelectionLength(): number;
+    set SelectionLength(v: number);
+    private OnCursorMoved;
+    get IsFocused(): boolean;
+    set IsFocused(v: boolean);
+    get ControlStyle(): PrebuiltControlStyle;
+    set ControlStyle(v: PrebuiltControlStyle);
+    /** C# ApplyControlStyleVisuals: background, corners, border, cursor per style, applied only over values the app has not changed. */
+    private ApplyControlStyleVisuals;
+    private static NormalizeLineBreaks;
+    /** C# UpdateLabel: pushes the editor's text props into the content and placeholder labels. */
+    UpdateLabel(): void;
+    /** Visual height of one line in points (C# GetSingleLineHeightPts). */
+    GetSingleLineHeightPts(): number;
+    private Inner;
+    protected MeasureAbsolute(w: number, h: number, scale: number): ScaledSize;
+    protected OnLayoutChanged(): void;
+    private ClampScroll;
+    /** Keeps the caret inside the padded box by scrolling the label (C#: SkiaScroll under the label). */
+    private ScrollToCaret;
+    private Boxes;
+    /** Rect of the caret before character `index` (label pixels), or undefined before the first layout. */
+    private CaretRectLabelPx;
+    /** C# GetCursorPosition: the text index nearest to a point in label pixels. */
+    private HitTestIndex;
+    private LabelPoint;
+    protected Paint(ctx: DrawingContext): void;
+    ProcessGestures(args: SkiaGesturesParameters, apply: GestureEventProcessingInfo): SkiaControl | null;
+    OnAccessibilityActivated(): void;
+    protected DefaultAccessibilityLabel(): string | undefined;
+    Submit(): void;
+    private ExecuteSubmit;
+    SelectAll(): void;
+    SetSelection(start: number, end: number): void;
+    /** Selects the word around a character index (C# SelectWord). */
+    SelectWord(index: number): void;
+    GetSelectedText(): string;
+    DeleteSelection(): void;
+    InsertAtCursor(value: string): void;
+    CutSelection(): void;
+    CopySelection(): void;
+    PasteFromClipboard(): void;
+    private ReplaceSelection;
+    private SetFocusNative;
+    private OnKeyDown;
+    StubTypeText(value: string): void;
+    StubPressEnter(splitLine?: boolean, shift?: boolean): void;
+    StubBackspace(count?: number): void;
+    StubDelete(count?: number): void;
+    /** Arrow / Home / End: the anchor stays, the moving edge follows (shift), or the selection collapses in the move direction. */
+    StubMoveCursor(delta: number, extendSelection?: boolean): void;
+    StubSelectRange(start: number, length: number): void;
+    StubSelectAll(): void;
+    /** Up / Down keep the caret x on the neighbouring line (C# HandleVerticalArrow). */
+    protected HandleVerticalArrow(up: boolean): void;
+    /** UTF-16 units of `count` grapheme clusters before the caret (C# CodeUnitsBeforeCaret). */
+    static CodeUnitsBeforeCaret(text: string, caret: number, count: number): number;
+    static CodeUnitsAfterCaret(text: string, caret: number, count: number): number;
+    private static Graphemes;
+    protected OnDisposing(): void;
+}