@mathjax/src
    Preparing search index...

    Interface CommonMtable<N, T, D, JX, WW, WF, WC, CC, VV, DD, FD, FC, R>

    The CommonMtable interface

    interface CommonMtable<
        N,
        T,
        D,
        JX extends CommonOutputJax<N, T, D, WW, WF, WC, CC, VV, DD, FD, FC>,
        WW extends CommonWrapper<N, T, D, JX, WW, WF, WC, CC, VV, DD, FD, FC>,
        WF extends
            CommonWrapperFactory<N, T, D, JX, WW, WF, WC, CC, VV, DD, FD, FC>,
        WC extends CommonWrapperClass<N, T, D, JX, WW, WF, WC, CC, VV, DD, FD, FC>,
        CC extends CharOptions,
        VV extends VariantData<CC>,
        DD extends DelimiterData,
        FD extends FontData<CC, VV, DD>,
        FC extends FontDataClass<CC, VV, DD>,
        R extends CommonMtr<N, T, D, JX, WW, WF, WC, CC, VV, DD, FD, FC>,
    > {
        _breakCount: number;
        bbox: BBox;
        bboxComputed: boolean;
        childNodes: WW[];
        cLines: number[];
        container: WW;
        containerI: number;
        cSpace: number[];
        cWidths: (string | number)[];
        data: TableData;
        dom: N[];
        factory: WF;
        fframe: boolean;
        fLine: number;
        font: FD;
        frame: boolean;
        fSpace: number[];
        hasLabels: boolean;
        isTop: boolean;
        lineBBox: LineBBox[];
        node: MmlNode;
        numCols: number;
        numRows: number;
        parent: WW;
        pWidth: number;
        pwidthCells: [WW, number][];
        removedStyles: StringMap;
        rLines: number[];
        rSpace: number[];
        stretch: DD;
        styleData: StyleData;
        styles: Styles;
        tableRows: R[];
        variant: string;
        get adaptor(): DOMAdaptor<N, T, D>;
        get breakCount(): number;
        get containerWidth(): number;
        get fixesPWidth(): boolean;
        get jax(): JX;
        get kind(): string;
        get linebreakOptions(): {
            inline: boolean;
            LinebreakVisitor: null;
            lineleading: number;
            width: string;
        };
        get linebreaks(): Linebreaks<
            N,
            T,
            D,
            CommonOutputJax<N, T, D, WW, WF, WC, CC, VV, DD, FD, FC>,
            WW,
            WF,
            WC,
            CC,
            VV,
            DD,
            FD,
            FC,
        >;
        get metrics(): Metrics;
        addEm(list: number[], n?: number): string[];
        addLeftBorders(bbox: BBox): void;
        addMiddleBorders(bbox: BBox): void;
        addRightBorders(bbox: BBox): void;
        adjustColumnWidths(width: number): void;
        adjustWideTable(): void;
        breakColumn(i: number, W: number, type: string): void;
        breakTop(mrow: WW, _child: WW): WW;
        breakToWidth(_W: number): void;
        canStretch(direction: string): boolean;
        computeBBox(bbox: BBox, recompute?: boolean): void;
        computeLineBBox(i: number): LineBBox;
        convertLengths(list: string[]): number[];
        copySkewIC(bbox: BBox): void;
        core(): WW;
        coreMO(): CommonMo<N, T, D, JX, WW, WF, WC, CC, VV, DD, FD, FC>;
        coreRScale(): number;
        createMo(
            text: string,
        ): CommonMo<N, T, D, JX, WW, WF, WC, CC, VV, DD, FD, FC>;
        em(m: number): string;
        embellishedBBox(i: number): LineBBox;
        explicitVariant(
            fontFamily: string,
            fontWeight: string,
            fontStyle: string,
        ): string;
        extendHD(i: number, H: number[], D: number[], M: number): void;
        findContainer(): void;
        getAlignmentRow(): [string, number];
        getAlignShift(): [string, number];
        getAlignX(W: number, bbox: BBox, align: string): number;
        getAlignY(
            H: number,
            D: number,
            h: number,
            d: number,
            align: string,
        ): number;
        getAttributeArray(name: string): string[];
        getBBox(save?: boolean): BBox;
        getBBoxHD(height: number): number[];
        getBBoxLR(): number[];
        getBreakNode(bbox: LineBBox): [WW, WW];
        getChildAlign(_i: number): string;
        getChildLineBBox(child: WW, i: number): LineBBox;
        getColumnAttributes(name: string, i?: number): string[];
        getColumnHalfSpacing(): number[];
        getColumnWidths(): ColumnWidths;
        getColumnWidthsAuto(swidths: string[]): ColumnWidths;
        getColumnWidthsFixed(swidths: string[], width: number): ColumnWidths;
        getColumnWidthsPercent(swidths: string[]): ColumnWidths;
        getComputedWidths(): number[];
        getEmHalfSpacing(
            fspace: number[],
            space: number[],
            scale?: number,
        ): string[];
        getEqualColumns(width: string): ColumnWidths;
        getEqualRowHeight(): number;
        getFrameSpacing(): number[];
        getLineBBox(i: number): LineBBox;
        getMathMLSpacing(): void;
        getOuterBBox(save?: boolean): BBox;
        getPadAlignShift(side: string): [number, string, number];
        getPercentageWidth(): void;
        getRowAttributes(name: string, i?: number): string[];
        getRowHalfSpacing(): number[];
        getRScale(): number;
        getScale(): void;
        getSpace(): void;
        getStyleData(): void;
        getStyles(): void;
        getTableData(): TableData;
        getTeXSpacing(isTop: boolean, hasSpacing: boolean): void;
        getText(): string;
        getUnbrokenHD(): [number, number];
        getVariant(): void;
        getVariantChar(variant: string, n: number): CharDataArray<CC>;
        getVerticalPosition(i: number, align: string): number;
        getWidth(): number;
        getWrapWidth(i: number): number;
        html(type: string, def?: OptionList, content?: (N | T)[]): N;
        invalidateBBox(bubble?: boolean): void;
        isTopEmbellished(): boolean;
        length2em(length: Property, size?: number, scale?: number): number;
        mmlNode(
            kind: string,
            properties?: PropertyList,
            children?: MmlNode[],
        ): MmlNode;
        mmlText(text: string): TextNode;
        naturalWidth(): number;
        percent(m: number): string;
        processIndent(
            indentalign: string,
            indentshift: string,
            align?: string,
            shift?: string,
            width?: number,
        ): [string, number];
        px(m: number, M?: number): string;
        recordPWidthCell(cell: WW, i: number): void;
        remapChars(chars: number[]): number[];
        setChildPWidths(recompute: boolean, w?: number, clear?: boolean): boolean;
        setColumnPWidths(): void;
        stretchColumn(i: number, W: number): void;
        stretchColumns(): void;
        stretchRows(): void;
        unicodeChars(text: string, name?: string): number[];
        updateHDW(
            cell: WW,
            i: number,
            j: number,
            align: string,
            H: number[],
            D: number[],
            W: number[],
            M: number,
        ): number;
        walkTree(func: (node: WW, data?: any) => void, data?: any): any;
        wrap<TT = WW>(node: MmlNode, parent?: WW): TT;
    }

    Type Parameters

    Hierarchy (View Summary)

    Index

    Properties

    _breakCount bbox bboxComputed childNodes cLines container containerI cSpace cWidths data dom factory fframe fLine font frame fSpace hasLabels isTop lineBBox node numCols numRows parent pWidth pwidthCells removedStyles rLines rSpace stretch styleData styles tableRows variant

    Accessors

    adaptor breakCount containerWidth fixesPWidth jax kind linebreakOptions linebreaks metrics

    Methods

    addEm addLeftBorders addMiddleBorders addRightBorders adjustColumnWidths adjustWideTable breakColumn breakTop breakToWidth canStretch computeBBox computeLineBBox convertLengths copySkewIC core coreMO coreRScale createMo em embellishedBBox explicitVariant extendHD findContainer getAlignmentRow getAlignShift getAlignX getAlignY getAttributeArray getBBox getBBoxHD getBBoxLR getBreakNode getChildAlign getChildLineBBox getColumnAttributes getColumnHalfSpacing getColumnWidths getColumnWidthsAuto getColumnWidthsFixed getColumnWidthsPercent getComputedWidths getEmHalfSpacing getEqualColumns getEqualRowHeight getFrameSpacing getLineBBox getMathMLSpacing getOuterBBox getPadAlignShift getPercentageWidth getRowAttributes getRowHalfSpacing getRScale getScale getSpace getStyleData getStyles getTableData getTeXSpacing getText getUnbrokenHD getVariant getVariantChar getVerticalPosition getWidth getWrapWidth html invalidateBBox isTopEmbellished length2em mmlNode mmlText naturalWidth percent processIndent px recordPWidthCell remapChars setChildPWidths setColumnPWidths stretchColumn stretchColumns stretchRows unicodeChars updateHDW walkTree wrap

    Properties

    Protected_breakCount

    _breakCount: number = -1

    The cached number of linebreaks

    bbox: BBox

    The bounding box for this node

    bboxComputed: boolean = false

    Whether the bounding box has been computed yet

    childNodes: WW[]

    The children of this node

    cLines: number[]

    The width of columns lines (or 0 if no line for the column)

    container: WW

    The parent node of this table (skipping non-parents and mrows)

    containerI: number

    The position of the table as a child node of its container

    cSpace: number[]

    The spacing between columns

    cWidths: (string | number)[]

    The column widths (or percentages, etc.)

    data: TableData

    The bounding box information for the table rows and columns

    dom: N[] = null

    The DOM tree generated for this wrapper

    factory: WF

    The factory used to create more wrappers

    fframe: boolean

    True if there is a frame or data-frame-styles

    fLine: number

    The size of the frame line (or 0 if none)

    font: FD = null

    Easy access to the font parameters

    frame: boolean

    True if there is a frame

    fSpace: number[]

    frame spacing on the left and right

    hasLabels: boolean

    True if there are labeled rows

    isTop: boolean

    True if this mtable is the top element, or in a top-most mrow

    lineBBox: LineBBox[] = []

    Sizes of lines into which the element is broken

    node: MmlNode
    numCols: number

    The number of columns in the table

    numRows: number

    The number of rows in the table

    parent: WW = null

    The parent of this node

    pWidth: number

    The full width of a percentage-width table

    pwidthCells: [WW, number][]

    The table cells that have percentage-width content and the column numbers for them

    removedStyles: StringMap = null

    Styles that must be handled directly by the wrappers (mostly having to do with fonts)

    rLines: number[]

    The width of row lines (or 0 if no lone for that row)

    rSpace: number[]

    The spacing between rows

    stretch: DD = ...

    Delimiter data for stretching this node (NOSTRETCH means not yet determined)

    styleData: StyleData = null

    The padding and border information from the style attribute

    styles: Styles = null

    The explicit styles set by the node

    tableRows: R[]

    The rows of the table

    variant: string = ''

    The mathvariant for this node

    Accessors

    • get breakCount(): number

      Returns number

      The number of breakpoints in the node

    • get containerWidth(): number

      Easy access to the container width

      Returns number

      The container width

    • get fixesPWidth(): boolean

      Returns boolean

      True if children with percentage widths should be resolved by this container

    • get linebreakOptions(): {
          inline: boolean;
          LinebreakVisitor: null;
          lineleading: number;
          width: string;
      }

      Easy access to the linebreak options

      Returns { inline: boolean; LinebreakVisitor: null; lineleading: number; width: string }

      The linebreak options

    Methods

    • Adds "em" to a list of dimensions, after dividing by n (defaults to 1).

      Parameters

      • list: number[]

        The array of dimensions (in em's)

      • Optionaln: number

        The number to divide each dimension by after converted

      Returns string[]

      The array of values with "em" added

    • For fixed-width tables, compute the column widths of all columns.

      Parameters

      • width: number

        The width of the table

      Returns void

    • Do linebreaking on the cells of a column

      Parameters

      • i: number

        The number of the column to break

      • W: number

        The width to break to

      • type: string

        The column width type (fit, auto, dimen, percentage)

      Returns void

    • Parameters

      • bbox: BBox

        The bounding box to modify (either this.bbox, or an empty one)

      • recompute: boolean = false

        True if we are recomputing due to changes in children that have percentage widths

      Returns void

    • Converts an array of dimensions (with arbitrary units) to an array of numbers representing the dimensions in units of em's.

      Parameters

      • list: string[]

        The array of dimensions to be turned into em's

      Returns number[]

      The array of values converted to em's

    • Set the CSS for a token element having an explicit font (rather than regular mathvariant).

      Parameters

      • fontFamily: string

        The font family to use

      • fontWeight: string

        The font weight to use

      • fontStyle: string

        The font style to use

      Returns string

      The explicit font marker

    • Extend the H and D of a row to cover the maximum height needed by top/bottom aligned items

      Parameters

      • i: number

        The row whose hight and depth should be adjusted

      • H: number[]

        The row heights

      • D: number[]

        The row depths

      • M: number

        The maximum height of top/bottom aligned items

      Returns void

    • Parameters

      • H: number

        The total height

      • D: number

        The total depth

      • h: number

        The height to be aligned

      • d: number

        The depth to be aligned

      • align: string

        How to align (top, bottom, center, axis, baseline)

      Returns number

      The y position of the aligned baseline

    • Parameters

      • name: string

        The name of the attribute to get as an array

      Returns string[]

      The array of values in the given attribute, split at spaces (after leading and trailing spaces are removed, and multiple spaces have been collapsed to one).

    • Return the wrapped node's bounding box, either the cached one, if it exists, or computed directly if not.

      Parameters

      • save: boolean = true

        Whether to cache the bbox or not (used for stretchy elements)

      Returns BBox

      The computed bounding box

    • Parameters

      • height: number

        The total height of the table

      Returns number[]

      The [height, depth] for the aligned table

    • Parameters

      • name: string

        The name of the attribute to get as an array

      • Optionali: number

        Return this many fewer than numCols entries

      Returns string[]

      The array of values in the given attribute, split at spaces, padded to the number of table columns (minus 1) by repeating the last entry

    • Determine the column widths that can be computed (and need to be set). The resulting arrays will have numbers for fixed-size arrays, strings for percentage sizes that can't be determined now, and null for stretchy columns tht will expand to fill the extra space. Depending on the width specified for the table, different column values can be determined.

      Returns ColumnWidths

      The array of widths

    • For tables with width="auto", auto and fit columns will end up being natural width, so don't need to set those explicitly.

      Parameters

      • swidths: string[]

        Strings giving the widths

      Returns ColumnWidths

      The array of widths

    • For tables with percentage widths, the 'fit' columns (or 'auto' columns if there are not 'fit' ones) will stretch automatically, but for 'auto' columns (when there are 'fit' ones), set the size to the natural size of the column.

      Parameters

      • swidths: string[]

        Strings giving the widths

      Returns ColumnWidths

      The array of widths

    • Parameters

      • fspace: number[]

        The frame spacing to use

      • space: number[]

        The array of spacing values to convert to strings

      • Optionalscale: number

        A scaling factor to use for the sizes

      Returns string[]

      The half-spacing as stings with units of "em" with frame spacing at the beginning and end

    • Get the bounding box for the i-th line (first and last may be part of a surrounding line). Get the bbox from the lineBBox cache, or compute it, as needed.

      Parameters

      • i: number

        The number of the segment whose sizes are to be obtained

      Returns LineBBox

      The bounding box of the specified segment

    • Return the wrapped node's bounding box that includes borders and padding

      Parameters

      • save: boolean = true

        Whether to cache the bbox or not (used for stretchy elements)

      Returns BBox

      The computed bounding box

    • Parameters

      • side: string

        The side for the labels

      Returns [number, string, number]

      The padding, alignment, and shift amounts

    • Parameters

      • name: string

        The name of the attribute to get as an array

      • Optionali: number

        Return this many fewer than numRows entries

      Returns string[]

      The array of values in the given attribute, split at spaces, padded to the number of table rows (minus 1) by repeating the last entry

    • Get the spacing using the TeX rules

      Parameters

      • isTop: boolean

        True when this is a top-level embellished operator

      • hasSpacing: boolean

        True when there is an explicit or inherited 'form' attribute

      Returns void

    • Parameters

      • i: number

        The row number (starting at 0)

      • align: string

        The alignment on that row

      Returns number

      The offest of the alignment position from the top of the table

    • Parameters

      • length: Property

        A dimension (giving number and units) or number to be converted to ems

      • size: number = 1

        The default size of the dimension (for percentage values)

      • scale: number = null

        The current scaling factor (to handle absolute units)

      Returns number

      The dimension converted to ems

    • Parameters

      • indentalign: string

        The indentalign to process

      • indentshift: string

        The indentshift to process

      • align: string = ''

        The default alignment for 'auto'

      • shift: string = ''

        The default indentshift for 'auto'

      • width: number = ...

        The container width for relative shifts

      Returns [string, number]

      The alignment and indentation shift (normal and last) for the Mo

    • Parameters

      • m: number

        A number of em's to be shown as pixels

      • M: number = -LENGTHS.BIGDIMEN

        The minimum number of pixels to allow

      Returns string

      The number with units of px

    • Recursively resolve any percentage widths in the child nodes using the given container width (or the child width, if none was passed). Overriden for mtables in order to compute the width.

      Parameters

      • recompute: boolean

        True if we are recomputing due to changes in children

      • w: number = null

        The width of the container (from which percentages are computed)

      • clear: boolean = true

        True if pwidth marker is to be cleared

      Returns boolean

      True if a percentage width was found

    • Handle horizontal stretching within the ith column

      Parameters

      • i: number

        The column number

      • W: number

        The computed width of the column (or null of not computed)

      Returns void

    • Parameters

      • text: string

        The text to turn into unicode locations

      • name: string = ...

        The name of the variant for the characters

      Returns number[]

      Array of numbers represeting the string's unicode character positions

    • Parameters

      • cell: WW

        The cell whose height, depth, and width are to be added into the H, D, W arrays

      • i: number

        The column number for the cell

      • j: number

        The row number for the cell

      • align: string

        The row alignment

      • H: number[]

        The maximum height for each of the rows

      • D: number[]

        The maximum depth for each of the rows

      • W: number[]

        The maximum width for each column

      • M: number

        The current height for items aligned top and bottom

      Returns number

      The updated value for M

    Settings

    Member Visibility

    On This Page

    Properties
    Accessors
    Methods
    addEmaddLeftBordersaddMiddleBordersaddRightBordersadjustColumnWidthsadjustWideTablebreakColumnbreakTopbreakToWidthcanStretchcomputeBBoxcomputeLineBBoxconvertLengthscopySkewICcorecoreMOcoreRScalecreateMoemembellishedBBoxexplicitVariantextendHDfindContainergetAlignmentRowgetAlignShiftgetAlignXgetAlignYgetAttributeArraygetBBoxgetBBoxHDgetBBoxLRgetBreakNodegetChildAligngetChildLineBBoxgetColumnAttributesgetColumnHalfSpacinggetColumnWidthsgetColumnWidthsAutogetColumnWidthsFixedgetColumnWidthsPercentgetComputedWidthsgetEmHalfSpacinggetEqualColumnsgetEqualRowHeightgetFrameSpacinggetLineBBoxgetMathMLSpacinggetOuterBBoxgetPadAlignShiftgetPercentageWidthgetRowAttributesgetRowHalfSpacinggetRScalegetScalegetSpacegetStyleDatagetStylesgetTableDatagetTeXSpacinggetTextgetUnbrokenHDgetVariantgetVariantChargetVerticalPositiongetWidthgetWrapWidthhtmlinvalidateBBoxisTopEmbellishedlength2emmmlNodemmlTextnaturalWidthpercentprocessIndentpxrecordPWidthCellremapCharssetChildPWidthssetColumnPWidthsstretchColumnstretchColumnsstretchRowsunicodeCharsupdateHDWwalkTreewrap