drawnui-react 0.1.0-preview.1

package/dist/controls/SkiaLayout.d.ts

@@ -0,0 +1,163 @@
+import { type DrawingContext, SkiaControl } from "../core/SkiaControl";
+import { ViewsAdapter } from "../core/ViewsAdapter";
+import { type GridLength, type LayoutType, type MeasuringStrategy, type RecyclingTemplate, ScaledSize, type ShapeType, Thickness } from "../core/Types";
+import { SkiaGridStructure } from "./GridStructure";
+/**
+ * Mirrors DrawnUi SkiaLayout (Absolute / Column / Row / Wrap / Grid).
+ * Column/Row give children an infinite main axis (MAUI stack semantics: Fill on the main axis = auto-sized).
+ *
+ * Templated mode (ItemsSource + ItemTemplate) is a Column only: cells are created through the ViewsAdapter for
+ * the indexes inside the visible viewport (+ VirtualisationInflated), everything else is arithmetic —
+ * MeasureFirst measures one cell and assumes uniform size, MeasureAll measures every item once.
+ */
+export declare class SkiaLayout extends SkiaControl {
+    /** Layout type. SkiaShape redeclares it as ShapeType (any shape value lays out as Absolute), like the C# hidden Type. */
+    Type: LayoutType | ShapeType;
+    Spacing: number;
+    Padding: Thickness;
+    ColumnDefinitions?: string | GridLength[];
+    RowDefinitions?: string | GridLength[];
+    /** Track used for columns/rows a child references but no definition declares (C# default: Auto). */
+    DefaultColumnDefinition: GridLength;
+    DefaultRowDefinition: GridLength;
+    ColumnSpacing: number;
+    RowSpacing: number;
+    /** Structure computed by the last measure; cells are arranged from it. */
+    GridStructure?: SkiaGridStructure;
+    RecyclingTemplate: RecyclingTemplate;
+    /** Column count for Column / Wrap content and a templated Grid (0 = free flow); C# Split. */
+    Split: number;
+    /** Split > 0: every slot keeps the same width (true) or the cell keeps its measured width (C# SplitAlign). */
+    SplitAlign: boolean;
+    /** A short last row spreads over the whole width instead of keeping empty Split slots (C# DynamicColumns). */
+    DynamicColumns: boolean;
+    /** Templated Grid: fill column-major (top to bottom, then next column) instead of row-major (C# Invert). */
+    Invert: boolean;
+    MeasureItemsStrategy: MeasuringStrategy;
+    /** Realized views per item (Disabled) or a recycled pool for the visible range (Enabled). */
+    readonly ChildrenFactory: ViewsAdapter;
+    FirstVisibleIndex: number;
+    LastVisibleIndex: number;
+    private itemsSource?;
+    private itemTemplate?;
+    private structureDirty;
+    /** Per-item heights in pixels (MeasureAll) or a single uniform height (MeasureFirst). */
+    private itemHeights;
+    private uniformHeight;
+    private measuredWidthPx;
+    /** Items measured per idle slice before the estimate is refreshed (DrawnUi BackgroundMeasurementBatchSize). */
+    BackgroundMeasurementBatchSize: number;
+    /** Pixel heights of measured items (0 = not measured yet), any order: visible cells are measured on demand. */
+    private mvHeights;
+    /** mvPrefix[i] = offset of item i (inside padding, gaps included) for i <= mvMeasured; items 0..mvMeasured-1 are exact. */
+    private mvPrefix;
+    private mvMeasured;
+    private mvSum;
+    private mvCount;
+    private mvIdle;
+    /** Index of the last item measured by the background pass (DrawnUi LastMeasuredIndex); -1 = none. */
+    get LastMeasuredIndex(): number;
+    get ItemsSource(): readonly unknown[] | undefined;
+    set ItemsSource(value: readonly unknown[] | undefined);
+    /**
+     * Raised after items were inserted at the head and measured, with the inserted extent in pixels; SkiaScroll uses it to
+     * keep the visible rows where they are (DrawnUi head-insert rebase).
+     */
+    ItemsInsertedAtStart?: (sender: SkiaLayout, insertedPx: number) => void;
+    /**
+     * DrawnUi keeps the structure on ObservableCollection Add/Insert; React apps replace the array, so the relation is
+     * detected instead: same items appended (page loaded) or prepended (chat history) keep every measured height,
+     * anything else rebuilds. Returns false when a full rebuild is needed.
+     */
+    private ApplyIncrementalChange;
+    /** Factory creating one cell (DrawnUi DataTemplate). Cells receive the item as BindingContext. */
+    get ItemTemplate(): (() => SkiaControl) | undefined;
+    set ItemTemplate(value: (() => SkiaControl) | undefined);
+    get IsTemplated(): boolean;
+    /** The virtualized list case: a templated single-column Column. Templated Row / Wrap / Grid realize every item. */
+    private get IsTemplatedList();
+    /** Views taking part in the layout pass: static children, or every item of a templated Row / Wrap / Grid (C# non-list layouts are not virtualized). */
+    private LayoutViews;
+    /** Drops realized cells and rebuilds the structure (DrawnUi ApplyItemsSource). */
+    ApplyItemsSource(): void;
+    /** Diagnostics like DrawnUi DebugString: visible range, realized views, pool. */
+    get DebugString(): string;
+    /** A layout paints outside its box whatever its children paint outside theirs (C# aggregated effects margin). */
+    ComputeEffectsMargin(scale: number): Thickness;
+    private readonly views;
+    /** Read-only live children like DrawnUi Views: realized cells when templated, else static children. */
+    get Views(): readonly SkiaControl[];
+    /** Settable children list like DrawnUi Children (ignored while templated). */
+    get Children(): readonly SkiaControl[];
+    set Children(value: readonly SkiaControl[]);
+    private orderedViews?;
+    /** Static children sorted by ZIndex (stable), computed once per change (C# GetOrderedSubviews). */
+    protected GetOrderedSubviews(): readonly SkiaControl[];
+    InvalidateViewsOrder(): void;
+    protected GetGestureListeners(): readonly SkiaControl[];
+    protected DisposeChildren(): void;
+    AddSubView(control: SkiaControl): void;
+    InsertSubView(index: number, control: SkiaControl): void;
+    RemoveSubView(control: SkiaControl): void;
+    protected MeasureAbsolute(widthConstraint: number, heightConstraint: number, scale: number): ScaledSize;
+    /** Wrap rows computed by the last measure: [childIndex, x, y, w, h] in pixels relative to the padded box. */
+    private wrapSlots;
+    /** Wrap, or a Column with Split > 1 (C# lays a multi-column Column out like a wrap with fixed slots). */
+    private get IsWrapFlow();
+    /**
+     * Flow children left to right, wrapping when the row overflows; Spacing applies between items and rows.
+     * Split > 0: fixed column count with slot width (width - (Split - 1) * gap) / Split (`SplitAlign`), a new row every
+     * Split items; `DynamicColumns` lets a short last row spread over the width.
+     */
+    private MeasureWrap;
+    /** Port of C# MeasureGrid: build the structure in points, stretch the last track when the grid fills, remeasure at final cells. */
+    private MeasureGrid;
+    /** Templated Column: content = padding + sum of item heights + gaps; width = the constraint (cells fill). */
+    private MeasureTemplated;
+    private MvReset;
+    /** Average item stride (height + gap) from everything measured so far. */
+    private MvStride;
+    /** DrawnUi MeasureList estimate: exact prefix + average × remaining. */
+    private MvContentHeight;
+    /** Measures one item (binding it through the adapter); release = give the cell back to the pool right away. */
+    private MvMeasure;
+    /** Grows the exact prefix over every already-measured item that follows it. */
+    private MvExtendPrefix;
+    /** Background measurement in idle time (DrawnUi StartBackgroundMeasurement): time-sliced, then the estimate is refreshed once. */
+    private MvScheduleBackground;
+    /** Binds a cell to items[index] (through the adapter, so MeasureFirst's cell 0 stays realized) and measures it. */
+    private MeasureItem;
+    /** Pixel offset of item index from the top of the layout content (inside padding). */
+    GetItemOffsetPixels(index: number): number;
+    private ItemHeightPixels;
+    protected OnLayoutChanged(): void;
+    protected Paint(ctx: DrawingContext): void;
+    protected GetCompositeChildren(): readonly SkiaControl[];
+    /** Realizes, binds, arranges and draws only the cells intersecting the visible viewport (+ inflation). */
+    private PaintTemplated;
+    /**
+     * MeasureVisible frame: the first visible index comes from the exact prefix (binary search) or the estimate,
+     * then cells are laid out contiguously with their REAL measured heights (measured on demand, kept for the prefix).
+     */
+    private PaintMeasureVisible;
+}
+/** SkiaLayout Type=Column + HorizontalOptions=Fill (DrawnUi alias). */
+export declare class SkiaStack extends SkiaLayout {
+    constructor();
+}
+/** SkiaLayout Type=Row (DrawnUi alias). */
+export declare class SkiaRow extends SkiaLayout {
+    constructor();
+}
+/** SkiaLayout Type=Absolute + HorizontalOptions=Fill (DrawnUi alias). */
+export declare class SkiaLayer extends SkiaLayout {
+    constructor();
+}
+/** SkiaLayout Type=Grid + HorizontalOptions=Fill (DrawnUi alias): MAUI Grid alternative. */
+export declare class SkiaGrid extends SkiaLayout {
+    constructor();
+}
+/** SkiaLayout Type=Wrap + HorizontalOptions=Fill (DrawnUi alias): responsive flow of fixed-size children. */
+export declare class SkiaWrap extends SkiaLayout {
+    constructor();
+}