@trebco/treb 37.0.0 → 37.0.1

package/build/treb-grid/src/render/tile_renderer.d.ts

@@ -0,0 +1,121 @@
+import type { ICellAddress, PreparedText, Cell, Size, CellStyle, Theme } from 'treb-base-types';
+import { Area } from 'treb-base-types';
+import type { Tile } from '../types/tile';
+import { BaseLayout, TileRange } from '../layout/base_layout';
+import type { DataModel, ViewModel } from 'treb-data-model';
+import type { GridOptions } from '../types/grid_options';
+interface FontSet {
+    base: string;
+    strong: string;
+    emphasis: string;
+    strong_emphasis: string;
+}
+interface RenderCellResult {
+    tile_overflow_bottom?: boolean;
+    tile_overflow_right?: boolean;
+    tile_overflow_left?: boolean;
+    width?: number;
+    height?: number;
+    left?: number;
+}
+interface OverflowRecord {
+    head: ICellAddress;
+    area: Area;
+    tile: Tile;
+}
+export declare class TileRenderer {
+    protected theme: Theme;
+    protected layout: BaseLayout;
+    protected model: DataModel;
+    protected view: ViewModel;
+    protected options: GridOptions;
+    protected readonly cell_edge_buffer = 4;
+    /**
+     * a record of cell overflows, also used for merges if they cross tile
+     * boundaries. on render, we check if an overflow(ed) cell is dirty; if
+     * so, this forces update of dependent cells.
+     */
+    protected overflow_areas: OverflowRecord[];
+    protected buffer_canvas: HTMLCanvasElement;
+    protected buffer_context: CanvasRenderingContext2D;
+    protected buffer_canvas_size: Size;
+    constructor(theme: Theme, layout: BaseLayout, model: DataModel, view: ViewModel, options: GridOptions);
+    /**
+     * we manage overflow blocks to simplify (more or less) rendering,
+     * but they break in the event of insert/delete row/column. we need
+     * to adjust, or perhaps flush, when we insert/delete columns.
+     *
+     */
+    FlushOverflows(): void;
+    /**
+     * new method for measuring text, intended to take into account
+     * indentation and wrapping, scale, and all the other stuff.
+     */
+    MeasureText(cell: Cell, current_width: number, override_scale?: number): {
+        width: number;
+        height: number;
+    };
+    /**
+     * when drawing to the buffered canvas, (1) ensure it's large enough,
+     * and (2) set transform as necessary (we may be overflowing to the left).
+     */
+    EnsureBuffer(width?: number, height?: number, offset?: number): void;
+    /**
+     * check all overflow areas. if any elements are dirty, mark all elements
+     * as dirty (FIXME: and remove the list?)
+     */
+    OverflowDirty(full_tile?: boolean): void;
+    /**
+     *
+     */
+    RenderCorner(): void;
+    /**
+     * unifying because headers and corner both render labels.
+     *
+     * @param context
+     * @param column
+     * @param end
+     */
+    RenderColumnLabels(context: CanvasRenderingContext2D, column: number, end: number): void;
+    RenderRowLabels(context: CanvasRenderingContext2D, row: number, end: number, block: number): void;
+    /**
+     */
+    RenderHeaders(tiles: TileRange, force?: boolean): void;
+    /**
+     *
+     * @param tile starting tile
+     * @param scale scale
+     * @param dx tile offset, in tiles
+     * @param dy tile offset, in tiles
+     * @param left (original) translation, in scaled pixels
+     * @param top (original) translation, in scaled pixels
+     * @param result buffer info
+     */
+    CopyToAdjacent(tile: Tile, scale: number, dx: -1 | 0 | 1, dy: -1 | 0 | 1, left: number, top: number, result: RenderCellResult): void;
+    /** render a tile */
+    Render(tile: Tile): void;
+    /**
+     * split and measure text. can be cached. there are actually two completely
+     * separate operations here, which we're consolidating for convenience (and
+     * because they never overlap).
+     *
+     * UPDATED returning a 2d array, where the first dimension represents lines
+     * and the second dimension represents components
+     */
+    protected PrepText(context: CanvasRenderingContext2D, fonts: FontSet, cell: Cell, cell_width: number): PreparedText;
+    protected ResolveColors(style: CellStyle): CellStyle;
+    protected RenderCellBorders(address: ICellAddress, context: CanvasRenderingContext2D, style: CellStyle, left?: number, top?: number, width?: number, height?: number): void;
+    /**
+     * paint background image, offset and tiled.
+     */
+    protected PaintBackgroundImage(context: CanvasRenderingContext2D, image: HTMLImageElement, left: number, top: number, width: number, height: number, render_left?: number, render_top?: number, offset?: number): void;
+    protected RenderCellBackground(note: boolean, address: ICellAddress, context: CanvasRenderingContext2D, style: CellStyle, width: number, height: number, cell_left?: number, cell_top?: number): void;
+    /**
+     * refactoring render to allow rendering to buffered canvas, in the
+     * case of tile overflow. this is problematic because as the code stands
+     * now, it paints before determining if there's an overflow. so we need
+     * to move some paint calls around.
+     */
+    protected RenderCell(tile: Tile, cell: Cell, context: CanvasRenderingContext2D, address: ICellAddress, width: number, height: number, cell_left?: number, cell_top?: number): RenderCellResult;
+}
+export {};