import type { ICellAddress, PreparedText, Cell, Size, CellStyle, Theme } from '../../../treb-base-types/src/index';
import { Area } from '../../../treb-base-types/src/index';
import type { Tile } from '../types/tile';
import { BaseLayout, TileRange } from '../layout/base_layout';
import type { DataModel, ViewModel } from '../../../treb-data-model/src/index';
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 {};