@hailin-zheng/editor-core 1.0.10 → 1.0.14

package/src/med_editor/framework/impl/table/table-split-cell-patch.ts

@@ -1,98 +0,0 @@
-export interface ColumnPartOffset extends ColumnPart { offset: number }
-export interface ColumnPart { index: number, width: number }
-export interface ColumnPatch { type: 'modify' | 'insert', data: ColumnPart }
-export class ColumnPatchUtil {
-    static getPatchPacks(cols: Array<ColumnPart>, splitCols: Array<ColumnPart>): [Array<{ part: ColumnPartOffset, patchs: Array<ColumnPatch> }>, Array<Array<ColumnPart>>] {
-        const oldLinePointMap = this.getLinePointMap(cols);
-        //要分割的列坐标
-        const newLinePointMap = this.getLinePointMap(splitCols);
-        const resArray: Set<number> = new Set();
-        const allPointMap = oldLinePointMap.concat(newLinePointMap);
-        for (let i = 0; i < allPointMap.length; i++) {
-            const part = allPointMap[i];
-            resArray.add(part.offset);
-            resArray.add(part.offset + part.width);
-        }
-        const points = Array.from(resArray).sort((first, second) => first - second);
-        const patchs: Array<{ part: ColumnPartOffset, patchs: Array<ColumnPatch> }> = [];
-        //获取其他行的拆分补丁
-        for (let i = 0; i < points.length - 1; i++) {
-            const partStartOffset = points[i];
-            const partEndOffset = points[i + 1];
-            const joinPart = oldLinePointMap.find(item => {
-                const startOffset = item.offset;
-                const endOffset = item.offset + item.width;
-                return (
-                    (startOffset >= partStartOffset && startOffset < partEndOffset)
-                    ||
-                    (endOffset > partStartOffset && endOffset <= partEndOffset)
-                    ||
-                    (startOffset <= partStartOffset && endOffset >= partEndOffset)
-                )
-            });
-            if (joinPart) {
-                if (joinPart.offset === partStartOffset && joinPart.offset + joinPart.width === partEndOffset) {
-                    continue;
-                }
-                const patch = patchs.find(item => item.part === joinPart);
-                if (patch) {
-                    patch.patchs.push({ type: 'insert', data: { width: partEndOffset - partStartOffset, index: joinPart.index } })
-                } else {
-                    patchs.push({
-                        part: joinPart,
-                        patchs: [{ type: 'modify', data: { width: partEndOffset - partStartOffset, index: joinPart.index } }]
-                    })
-                }
-            }
-        }
-        //获取当前行的拆分补丁
-        const currRowPaths: Array<Array<ColumnPart>> = [];
-        const allColumnMap = this.getLinePointMap(this.getColumn(points));
-        for (let i = 0; i < newLinePointMap.length; i++) {
-            const partStartOffset = newLinePointMap[i].offset;
-            const partEndOffset = newLinePointMap[i].offset + newLinePointMap[i].width;
-            const joinParts = allColumnMap.filter(item => {
-                const startOffset = item.offset;
-                const endOffset = item.offset + item.width;
-                return (
-                    (startOffset >= partStartOffset && startOffset < partEndOffset)
-                    ||
-                    (endOffset > partStartOffset && endOffset <= partEndOffset)
-                    ||
-                    (startOffset <= partStartOffset && endOffset >= partEndOffset)
-                )
-            });
-            currRowPaths.push(joinParts);
-        }
-        return [patchs, currRowPaths];
-    }
-
-
-    private static getColumn(points: Array<number>): Array<ColumnPart> {
-        const items: Array<ColumnPart> = [];
-        for (let index = 0; index < points.length - 1; index++) {
-            items.push({ index, width: points[index + 1] - points[index] });
-        }
-        return items;
-    }
-
-    private static getSplitCols(width: number, cols: number): Array<ColumnPart> {
-        const items: Array<ColumnPart> = [];
-        for (let i = 0; i < cols; i++) {
-            items.push({ width: Math.floor(width / cols), index: i });
-        }
-        items[items.length - 1].width += width - items.reduce((prev, curr) => prev + curr.width, 0);
-        return items;
-    }
-
-    private static getLinePointMap(hMergeCols: Array<ColumnPart>): Array<ColumnPartOffset> {
-        const linePointMap: Array<ColumnPartOffset> = [];
-        let x = 0;
-        for (let i = 0; i < hMergeCols.length; i++) {
-            const col = hMergeCols[i];
-            linePointMap.push({ index: col.index, width: col.width, offset: x });
-            x += col.width;
-        }
-        return linePointMap;
-    }
-}

package/src/med_editor/framework/impl/table/table-split-cell.ts

@@ -1,475 +0,0 @@
-import { SelectionState } from "../../document-selection";
-import { ElementUtil } from "../../element-util";
-import { TableCellElement } from "./table-cell-impl";
-import { TableElement } from "./table-impl";
-import { TableRowElement } from "./table-row-impl";
-import { ColumnPart, ColumnPartOffset, ColumnPatch, ColumnPatchUtil } from "./table-split-cell-patch";
-import { TableUtil } from "./table-util";
-/**
- * 拆分单元格
- * 蜀道难，难于上青天；拆分单元格，头发秃，精神衰，眼睛昏，身体废。
- * 
- * 1.拆分为多列规则：不影响其他列宽度，将当前列宽度均分
- */
-export class TableSplitCell {
-    /**
-     * 
-     * 普通单元格可以任意拆分行和列
-     * 已合并的单元格，可以拆分任意数量的列；可以拆分的数量必须为合并单元格数量的约数
-     */
-    static splitCell(ss: SelectionState, rows: number, cols: number): void {
-        const focusCell = ElementUtil.getParentByType(ss.startControl, TableCellElement);
-        if (!focusCell) {
-            throw new Error('focusCell is null')
-        }
-        if (!focusCell.props.hMerge && !focusCell.props.vMerge) {
-            this.splitNormalCell(ss, rows, cols);
-        } else {
-            this.splitMergeCell(ss, rows, cols);
-        }
-        // else if (!focusCell.cellProps.hMerge) {
-        //     const { endColIndex } = this.horSplitHorNormalCell(ss, rows, cols);
-        //     this.verSplitVerMergeCell(ss, rows, endColIndex);
-        // }
-        // //当前单元格为横向合并单元格
-        // else {
-        //     const { endColIndex } = this.horSplitHorMergeCell(ss, rows, cols);
-        //     this.verSplitVerMergeCell(ss, rows, endColIndex);
-        // }
-    }
-
-
-    /**
-     * 拆分普通的单元格
-     */
-    private static splitNormalCell(ss: SelectionState, rows: number, cols: number): void {
-        rows = rows < 1 ? 1 : rows;
-        cols = cols < 1 ? 1 : cols;
-        if (rows === 1 && cols === 1) {
-            return;
-        }
-        const focusCell = ElementUtil.getParentByType(ss.startControl, TableCellElement);
-        const focusRow = ElementUtil.getParentByType(focusCell, TableRowElement);
-        const tb = ElementUtil.getParentByType(focusRow, TableElement);
-        if (!focusCell || !focusRow || !tb) {
-            throw new Error('focusCell | focusRow | tb is null');
-        }
-        const focusCellIndex = focusRow.getChildIndex(focusCell);
-        const focusRowIndex = focusRow.getIndex();
-        const cellWidth = tb.getCellWidth(focusCellIndex);
-        if (focusCell.props.hMerge || focusCell.props.vMerge) {
-            return;
-        }
-        //拆分为多列
-        if (cols > 1) {
-            const splitCellWidths = this.getSplitCols(cellWidth, cols);
-            tb.setCellWidth(focusCellIndex, splitCellWidths[0].width);
-            for (let i = 1; i < splitCellWidths.length; i++) {
-                tb.insertCol(focusCellIndex + i, splitCellWidths[i].width);
-            }
-            for (let i = 0; i < tb.length; i++) {
-                const row = tb.getChild(i) as TableRowElement;
-                //获取主单元格
-                const masterCell = row.getChild(focusCellIndex) as TableCellElement;
-                for (let j = 1; j < cols; j++) {
-                    const newCell = new TableCellElement();
-                    row.addChild(newCell, focusCellIndex + j);
-                    if (i < focusRowIndex || i > focusRowIndex) {
-                        //由普通单元格转向合并单元格
-                        if (!masterCell.props.hMerge) {
-                            masterCell.props.hMerge = 'restart';
-                        }
-                        newCell.props.hMerge = 'continue';
-                    }
-                }
-            }
-        }
-        if (rows > 1) {
-            for (let i = 1; i < rows; i++) {
-                const newRow = TableRowElement.createRow(tb.getColsCount());
-                tb.addChild(newRow, focusRowIndex + i)
-                for (let j = 0; j < newRow.length; j++) {
-                    const cell = newRow.getChild<TableCellElement>(j);
-                    const masterCell = focusRow.getChild<TableCellElement>(j)
-                    if (j < focusCellIndex || j > focusCellIndex + cols - 1)
-                        //紧挨上级的单元格存在横向合并
-                        if (masterCell.props.hMerge) {
-                            if (masterCell.props.hMerge === 'restart') {
-                                if (!masterCell.props.vMerge) {
-                                    masterCell.props.vMerge = 'restart'
-                                }
-                                cell.props.vMerge = 'continue';
-                            }
-                        } else {
-                            if (!masterCell.props.vMerge) {
-                                masterCell.props.vMerge = 'restart'
-                            }
-                            cell.props.vMerge = 'continue'
-                        }
-                }
-            }
-        }
-        tb.pubOnChange('self');
-        tb.refreshView();
-    }
-
-    /**
-     * 拆分合并的单元格
-     * @param ss 
-     * @param rows 
-     * @param cols 
-     */
-    static splitMergeCell(ss: SelectionState, rows: number, cols: number): void {
-        rows = rows < 1 ? 1 : rows;
-        cols = cols < 1 ? 1 : cols;
-        if (rows === 1 && cols === 1) {
-            return;
-        }
-        const focusCell = ElementUtil.getParentByType(ss.startControl, TableCellElement);
-        const focusRow = ElementUtil.getParentByType(focusCell, TableRowElement);
-        const tb = ElementUtil.getParentByType(focusRow, TableElement);
-        if (!focusCell || !focusRow || !tb) {
-            throw new Error('focusCell | focusRow | tb is null');
-        }
-        const focusCellIndex = focusRow.getChildIndex(focusCell);
-        const focusRowIndex = focusRow.getIndex();
-        const cellWidth = tb.getCellWidth(focusCellIndex);
-        if (!focusCell.props.hMerge && !focusCell.props.vMerge) {
-            return;
-        }
-        const mergeRows = this.getVMergeRowsCount(tb, focusRowIndex, focusCellIndex);
-        const mergeCols = this.getHMergeColsCount(tb, focusRowIndex, focusCellIndex);
-        //只有拆分的行数需要满足此条件
-        if (mergeRows > 1 && rows > 1) {
-            if (rows % mergeRows !== 0) {
-                throw new Error(`当前合并的行数为:${mergeRows},当前可拆分的行数是${mergeRows}的约数`)
-            }
-        }
-        //拆分的行数、列数等于合并的行数、列数
-        //执行还原
-        if (mergeCols === cols && mergeRows === rows) {
-            TableUtil.restoreCell(ss);
-            return;
-        }
-
-        if (mergeCols === 1) {
-            const { endColIndex } = this.horSplitHorNormalCell(ss, rows, cols);
-            this.verSplitVerMergeCell(ss, rows, endColIndex);
-        }
-        //当前单元格为横向合并单元格
-        else {
-            const { endColIndex } = this.horSplitHorMergeCell(ss, rows, cols);
-            this.verSplitVerMergeCell(ss, rows, endColIndex);
-        }
-    }
-
-    /**
-     * 拆分横向正常的单元格
-     * @param ss 
-     * @param rows 
-     * @param cols 
-     */
-    static horSplitHorNormalCell(ss: SelectionState, rows: number, cols: number): { startColIndex: number, endColIndex: number } {
-        const focusCell = ElementUtil.getParentByType(ss.startControl, TableCellElement);
-        const focusRow = ElementUtil.getParentByType(focusCell, TableRowElement);
-        const tb = ElementUtil.getParentByType(focusRow, TableElement);
-        if (!focusCell || !focusRow || !tb) {
-            throw new Error('focusCell | focusRow | tb is null');
-        }
-        const focusCellIndex = focusRow.getChildIndex(focusCell);
-        const focusRowIndex = focusRow.getIndex();
-        const cellWidth = tb.getCellWidth(focusCellIndex);
-        const splitCellWidths = this.getSplitCols(cellWidth, cols);
-        tb.setCellWidth(focusCellIndex, splitCellWidths[0].width);
-        for (let i = 1; i < splitCellWidths.length; i++) {
-            tb.insertCol(focusCellIndex + i, splitCellWidths[i].width);
-        }
-        const mergeRows = this.getVMergeRowsCount(tb, focusRowIndex, focusCellIndex);
-        rows = rows < mergeRows ? mergeRows : rows;
-        //向指定的列插入拆分单元格
-        if (cols > 1) {
-            for (let i = 0; i < tb.length; i++) {
-                const currRow = tb.getChild(i) as TableRowElement;
-                //获取主单元格
-                const masterCell = currRow.getChild(focusCellIndex) as TableCellElement;
-                for (let j = 1; j < cols; j++) {
-                    const newCell = new TableCellElement();
-                    currRow.addChild(newCell, focusCellIndex + j);
-                    if (i < focusRowIndex || i >= focusRowIndex + rows) {
-                        //由普通单元格转向合并单元格
-                        if (!masterCell.props.hMerge) {
-                            masterCell.props.hMerge = 'restart';
-                        }
-                        newCell.props.hMerge = 'continue';
-                    } else {
-                        newCell.props.vMerge = masterCell.props.vMerge;
-                    }
-                }
-            }
-        }
-        //在选中行下插入拆分行
-        //如果当前是普通单元格
-        if (!focusCell.props.vMerge) {
-            debugger
-            for (let i = 1; i < rows; i++) {
-                const newRow = TableRowElement.createRow(tb.getColsCount());
-                tb.addChild(newRow, focusRowIndex + i);
-            }
-        }
-        tb.pubOnChange('to-child');
-        tb.refreshView();
-        return {
-            startColIndex: focusCellIndex,
-            endColIndex: focusCellIndex + cols - 1
-        }
-    }
-
-    /**
-     * 横向拆分合并的单元格 
-     * @param ss 
-     * @param rows 
-     * @param cols 
-     */
-    static horSplitHorMergeCell(ss: SelectionState, rows: number, cols: number): { startColIndex: number, endColIndex: number } {
-        const focusCell = ElementUtil.getParentByType(ss.startControl, TableCellElement);
-        const focusRow = ElementUtil.getParentByType(focusCell, TableRowElement);
-        const tb = ElementUtil.getParentByType(focusRow, TableElement);
-        if (!focusCell || !focusRow || !tb) {
-            throw new Error('focusCell | focusRow | tb is null');
-        }
-        const focusCellIndex = focusRow.getChildIndex(focusCell);
-        const focusRowIndex = focusRow.getIndex();
-        const hMergeCols = this.getHMergeCols(tb, focusRowIndex, focusCellIndex, cols);
-        const colsWidth = hMergeCols.reduce((prev, curr) => prev + curr.width, 0)
-        const splitCols = this.getSplitCols(colsWidth, cols);
-        const [otherPacks, currPacks] = ColumnPatchUtil.getPatchPacks(hMergeCols, splitCols);
-        this.applyHorSplitColumnPatchPacks(tb, focusRowIndex, 1, otherPacks);
-        this.applyHorSplitColumnCurrPatchPacks(tb, focusRowIndex, focusCellIndex, rows, currPacks);
-        tb.pubOnChange('to-child');
-        tb.refreshView();
-        return {
-            startColIndex: focusCellIndex,
-            endColIndex: this.getPrepareNewColCounts(otherPacks, hMergeCols)
-        }
-    }
-
-    /**
-     * 获取需要新创建的列数量
-     */
-    private static getPrepareNewColCounts(packs: Array<{ part: ColumnPartOffset, patchs: Array<ColumnPatch> }>, hMergeCols: Array<ColumnPart>): number {
-        const lastColIndex = hMergeCols[hMergeCols.length - 1].index;
-        if (packs.length === 0) {
-            return lastColIndex;
-        }
-        const lastColPack = packs.find(pack => pack.part.index === lastColIndex);
-        if (!lastColPack) {
-            return lastColIndex;
-        }
-        return lastColIndex + lastColPack.patchs.filter(item => item.type === 'insert').length
-    }
-
-    /**
-     * 应用横向拆分单元格补丁
-     */
-    private static applyHorSplitColumnPatchPacks(tb: TableElement, focusRowIndex: number, splitRows: number, packs: Array<{ part: ColumnPartOffset, patchs: Array<ColumnPatch> }>): void {
-        for (let i = packs.length - 1; i >= 0; i--) {
-            const pack = packs[i];
-            const colIndex = pack.part.index;
-            for (let j = pack.patchs.length - 1; j >= 0; j--) {
-                const patch = pack.patchs[j];
-                if (patch.type === 'modify') {
-                    tb.setCellWidth(colIndex, patch.data.width);
-                } else if (patch.type === 'insert') {
-                    tb.insertCol(colIndex + 1, patch.data.width);
-                    //向指定的列插入拆分单元格
-                    for (let i = 0; i < tb.length; i++) {
-                        const currRow = tb.getChild(i) as TableRowElement;
-                        //获取主单元格
-                        const masterCell = currRow.getChild(colIndex) as TableCellElement;
-                        const newCell = new TableCellElement();
-                        currRow.addChild(newCell, colIndex + 1);
-                        if (!masterCell.props.hMerge) {
-                            masterCell.props.hMerge = 'restart';
-                        }
-                        newCell.props.hMerge = 'continue';
-                    }
-                }
-            }
-        }
-    }
-
-    /**
-     * 存在横向合并的单元格，进行单元格分拆，打补丁
-     * @param tb 
-     * @param focusRowIndex 
-     * @param focusColInex 
-     * @param splitRows 
-     * @param packs 
-     */
-    private static applyHorSplitColumnCurrPatchPacks(tb: TableElement, focusRowIndex: number, focusColInex: number, splitRows: number, packs: Array<Array<ColumnPart>>): void {
-        //获取当前列的合并行数
-        let vMergeRows = this.getVMergeRowsCount(tb, focusRowIndex, focusColInex);
-        vMergeRows = vMergeRows === 1 ? 0 : vMergeRows;
-        const startRow = tb.getChild(focusRowIndex) as TableRowElement;
-        const endRow = tb.getChild(focusRowIndex + vMergeRows - 1) as TableRowElement;
-        for (let i = 0; i < packs.length; i++) {
-            const mergeCols = packs[i];
-            if (mergeCols.length === 1) {
-                const startCell = startRow.getChild(focusColInex + mergeCols[0].index) as TableCellElement;
-                const endCell = endRow.getChild(focusColInex + mergeCols[0].index) as TableCellElement;
-                TableUtil.combineCells(tb, startCell, endCell);
-            } else {
-                // for (let j = 0; j < mergeCols.length; j++) {
-                //     const cell = focusRow.getChild(focusColInex + mergeCols[j].index) as TableCellElement;
-                //     cell.cellProps.hMerge = j === 0 ? 'restart' : 'continue';
-                // }
-                const startCell = startRow.getChild(focusColInex + mergeCols[0].index) as TableCellElement;
-                const endCell = endRow.getChild(focusColInex + mergeCols[mergeCols.length - 1].index) as TableCellElement;
-                TableUtil.combineCells(tb, startCell, endCell);
-            }
-        }
-    }
-
-
-    /**
-    * 纵向拆分合并的单元格
-    * 在指定行下插入复制行
-    * 存在
-    */
-    private static verSplitVerMergeCell(ss: SelectionState, rows: number, endColIndex: number): void {
-        if (rows === 1) {
-            return;
-        }
-        const focusCell = ElementUtil.getParentByType(ss.startControl, TableCellElement);
-        const focusRow = ElementUtil.getParentByType(focusCell, TableRowElement);
-        const tb = ElementUtil.getParentByType(focusRow, TableElement);
-        if (!focusCell || !focusRow || !tb) {
-            throw new Error('focusCell | focusRow | tb is null');
-        }
-        const focusCellIndex = focusRow.getChildIndex(focusCell);
-        const focusRowIndex = focusRow.getIndex();
-        let mergeRows = 0;
-        if (focusCell.props.vMerge === 'restart') {
-            mergeRows = this.getVMergeRowsCount(tb, focusRowIndex, focusCellIndex);
-            if (mergeRows % rows !== 0) {
-                throw new Error(`可拆分的行数必须是${mergeRows}的约数`);
-            }
-        }
-        //不存在合并行，则向下新增行
-        if (mergeRows === 0) {
-            for (let i = 0; i < rows - 1; i++) {
-                const newRow = new TableRowElement();
-                for (let i = 0; i < focusRow.length; i++) {
-                    const focusRowCell = focusRow.getChild(i) as TableCellElement;
-                    const cell = new TableCellElement();
-                    //其他列要纵向合并
-                    if (i < focusCellIndex || i > endColIndex) {
-                        if (!focusRowCell.props.vMerge) {
-                            focusRowCell.props.vMerge = 'restart';
-                        }
-                        cell.props.vMerge = 'continue';
-                    }
-                    cell.props.hMerge = focusRowCell.props.hMerge;
-                    newRow.addChild(cell);
-                }
-                tb.addChild(newRow, focusRowIndex + i + 1);
-            }
-        }
-        //存在合并行，则按照约数单个合并分拆为多个合并
-        else {
-            //拆分行和合并行相等，则执行还原
-            if (rows === mergeRows) {
-                for (let i = 0; i < mergeRows; i++) {
-                    const row = tb.getChild(focusRowIndex + i) as TableRowElement;
-                    for (let j = focusCellIndex; j <= endColIndex; j++) {
-                        const cell = row.getChild(j) as TableCellElement;
-                        cell.props.vMerge = null;
-                    }
-                }
-            } else {
-                for (let i = 0; i < mergeRows; i++) {
-                    if (i % rows === 0) {
-                        const row = tb.getChild(focusRowIndex + i) as TableRowElement;
-                        const cell = row.getChild(focusCellIndex) as TableCellElement;
-                        cell.props.vMerge = 'restart';
-                    }
-                }
-            }
-        }
-    }
-
-
-
-    private static getSplitCols(width: number, cols: number): Array<ColumnPart> {
-        const items: Array<ColumnPart> = [];
-        for (let i = 0; i < cols; i++) {
-            items.push({ width: Math.floor(width / cols), index: i });
-        }
-        items[items.length - 1].width += width - items.reduce((prev, curr) => prev + curr.width, 0);
-        return items;
-    }
-
-    /**
-     * 获取横向合并的列
-     * @param tb 
-     * @param currRowIndex 
-     * @param currColIndex 
-     * @param splitCols 
-     */
-    private static getHMergeCols(tb: TableElement, currRowIndex: number, currColIndex: number, splitCols: number): Array<ColumnPart> {
-        const row = tb.getChild(currRowIndex) as TableRowElement;
-        const items: Array<ColumnPart> = [{ width: tb.getCellWidth(currColIndex), index: currColIndex }];
-        for (let i = currColIndex + 1; i < tb.getColsCount(); i++) {
-            const cell = row.getChild(i) as TableCellElement;
-            if (cell.props.hMerge === 'continue') {
-                items.push({ width: tb.getCellWidth(i), index: i });
-            } else {
-                break;
-            }
-        }
-        return items;
-    }
-
-    /**
-     * 获取纵向合并的行数
-     * @param tb 
-     * @param currRowIndex 
-     */
-    private static getVMergeRowsCount(tb: TableElement, rowIndex: number, colIndex: number): number {
-        const startCell = <TableCellElement>(<TableRowElement>tb.getChild(rowIndex)).getChild(colIndex)
-        if (startCell.props.vMerge !== 'restart') {
-            return 1;
-        }
-        let i = 0;
-        for (i = rowIndex + 1; i < tb.length; i++) {
-            const row = tb.getChild(i) as TableRowElement;
-            const cell = row.getChild(colIndex) as TableCellElement;
-            if (cell.props.vMerge !== 'continue') {
-                return i - rowIndex;
-            }
-        }
-        return i - rowIndex;
-    }
-
-    /**
-     * 获取纵向合并的行数
-     * @param tb 
-     * @param currRowIndex 
-     */
-    private static getHMergeColsCount(tb: TableElement, rowIndex: number, colIndex: number): number {
-        const row = tb.getChild<TableRowElement>(rowIndex);
-        const startCell = row.getChild<TableCellElement>(colIndex)
-        if (startCell.props.hMerge !== 'restart') {
-            return 1;
-        }
-        let i = 0;
-        for (i = colIndex + 1; i < row.length; i++) {
-            const cell = row.getChild(i) as TableCellElement;
-            if (cell.props.hMerge !== 'continue') {
-                return i - colIndex;
-            }
-        }
-        return i - colIndex;
-    }
-
-}