Files
vibemake-pcb-studio/common/tool/edit_table_tool_base.ts
T
likang 7e01147566
CI / typecheck + test + build (push) Has been cancelled
Initial commit: import VibeMake PCB Studio
2026-11-03 11:20:08 +08:00

757 lines
23 KiB
TypeScript

// SPDX-License-Identifier: GPL-3.0-or-later
// Copyright (C) 2026 ZiroEDA and contributors.
// Portions derived from KiCad, copyright The KiCad Developers. See NOTICE.md.
/**
* `EDIT_TABLE_TOOL_BASE<T_TABLE, T_TABLECELL, T_COMMIT>`
* (`include/tool/edit_table_tool_base.h`): the row, column and merge edits
* pcbnew's PCB_EDIT_TABLE_TOOL and eeschema's SCH_EDIT_TABLE_TOOL share.
*
* Upstream is a template mixed into each tool by multiple inheritance; here
* it is a class whose methods `applyMixins` copies onto the tool. Two things
* a template does that TypeScript cannot are the subclass's: `T_COMMIT
* commit( getToolMgr() )` is {@link makeCommit}, and `dynamic_cast<T_TABLECELL*>`
* is {@link asTableCell}.
*/
import type { EDA_ITEM } from '../eda_item.js';
import { STRUCT_DELETED } from '../eda_item_flags.js';
import type { VECTOR2I } from '@ziroeda/kimath/src/math/vector2.js';
import { KICAD_T } from '@ziroeda/core/typeinfo.js';
import { ACTIONS, EVENTS } from './actions.js';
import type { CONDITIONAL_MENU } from './conditional_menu.js';
import type { SELECTION } from './selection.js';
import { type SELECTION_CONDITION, SELECTION_CONDITIONS } from './selection_conditions.js';
import type { TOOL_EVENT } from './tool_event.js';
import type { TOOL_MANAGER } from './tool_manager.js';
/** What the base asks of a table cell (SCH_TABLECELL, PCB_TABLECELL). */
export interface EDIT_TABLECELL_LIKE extends EDA_ITEM {
GetRow(): number;
GetColumn(): number;
GetColSpan(): number;
GetRowSpan(): number;
SetColSpan(aSpan: number): void;
SetRowSpan(aSpan: number): void;
GetText(): string;
SetText(aText: string): void;
GetStart(): VECTOR2I;
SetEnd(aEnd: VECTOR2I): void;
SetAttributes(aSrc: never, aSetPosition: boolean): void;
GetStroke(): unknown;
SetStroke(aStroke: never): void;
GetFillMode(): unknown;
SetFillMode(aFill: never): void;
GetFillColor(): unknown;
SetFillColor(aColor: never): void;
}
/** What the base asks of a table (SCH_TABLE, PCB_TABLE). */
export interface EDIT_TABLE_LIKE<T_TABLECELL extends EDIT_TABLECELL_LIKE> extends EDA_ITEM {
GetPosition(): VECTOR2I;
SetPosition(aPos: VECTOR2I): void;
GetColCount(): number;
SetColCount(aCount: number): void;
GetRowCount(): number;
GetCell(aRow: number, aCol: number): T_TABLECELL | null;
GetCells(): T_TABLECELL[];
InsertCell(aIdx: number, aCell: T_TABLECELL): void;
DeleteMarkedCells(): void;
GetColWidth(aCol: number): number;
SetColWidth(aCol: number, aWidth: number): void;
GetRowHeight(aRow: number): number;
SetRowHeight(aRow: number, aHeight: number): void;
Normalize(): void;
}
/** What the base asks of a commit (SCH_COMMIT, BOARD_COMMIT). */
export interface EDIT_TABLE_COMMIT_LIKE {
Modify(aItem: EDA_ITEM, aScreen?: unknown): unknown;
Remove(aItem: EDA_ITEM, aScreen?: unknown): unknown;
Push(aMessage: string): void;
}
export abstract class EDIT_TABLE_TOOL_BASE<
T_TABLE extends EDIT_TABLE_LIKE<T_TABLECELL>,
T_TABLECELL extends EDIT_TABLECELL_LIKE,
T_COMMIT extends EDIT_TABLE_COMMIT_LIKE,
> {
protected addMenus(selToolMenu: CONDITIONAL_MENU): void {
const cellSelection: SELECTION_CONDITION = SELECTION_CONDITIONS.And(
SELECTION_CONDITIONS.MoreThan(0),
SELECTION_CONDITIONS.OnlyTypes([KICAD_T.SCH_TABLECELL_T, KICAD_T.PCB_TABLECELL_T]),
);
const cellBlockSelection = (sel: SELECTION): boolean => {
if (sel.Size() < 2) return false;
let colMin = Number.MAX_SAFE_INTEGER;
let colMax = 0;
let rowMin = Number.MAX_SAFE_INTEGER;
let rowMax = 0;
let selectedArea = 0;
for (const item of sel) {
const cell = this.asTableCell(item);
if (cell) {
colMin = Math.min(colMin, cell.GetColumn());
colMax = Math.max(colMax, cell.GetColumn() + cell.GetColSpan());
rowMin = Math.min(rowMin, cell.GetRow());
rowMax = Math.max(rowMax, cell.GetRow() + cell.GetRowSpan());
selectedArea += cell.GetColSpan() * cell.GetRowSpan();
}
}
return selectedArea === (colMax - colMin) * (rowMax - rowMin);
};
const mergedCellsSelection = (sel: SELECTION): boolean => {
for (const item of sel) {
const cell = this.asTableCell(item);
if (cell && (cell.GetColSpan() > 1 || cell.GetRowSpan() > 1)) return true;
}
return false;
};
const idle = SELECTION_CONDITIONS.And(cellSelection, SELECTION_CONDITIONS.Idle);
//
// Add editing actions to the selection tool menu
//
selToolMenu.AddSeparator(100);
selToolMenu.AddItem(ACTIONS.addRowAbove, idle, 100);
selToolMenu.AddItem(ACTIONS.addRowBelow, idle, 100);
selToolMenu.AddItem(ACTIONS.addColBefore, idle, 100);
selToolMenu.AddItem(ACTIONS.addColAfter, idle, 100);
selToolMenu.AddSeparator(100);
selToolMenu.AddItem(ACTIONS.deleteRows, idle, 100);
selToolMenu.AddItem(ACTIONS.deleteColumns, idle, 100);
selToolMenu.AddSeparator(100);
selToolMenu.AddItem(
ACTIONS.mergeCells,
SELECTION_CONDITIONS.And(cellSelection, cellBlockSelection),
100,
);
selToolMenu.AddItem(
ACTIONS.unmergeCells,
SELECTION_CONDITIONS.And(cellSelection, mergedCellsSelection),
100,
);
selToolMenu.AddSeparator(100);
selToolMenu.AddItem(ACTIONS.editTable, idle, 100);
selToolMenu.AddSeparator(100);
selToolMenu.AddItem(ACTIONS.exportTableCSV, idle, 100);
selToolMenu.AddSeparator(100);
}
protected doAddRowAbove(_aEvent: TOOL_EVENT): number {
const selection = this.getTableCellSelection();
let topmost: T_TABLECELL | null = null;
for (const item of selection) {
const cell = item as unknown as T_TABLECELL;
if (!topmost || cell.GetRow() < topmost.GetRow()) topmost = cell;
}
if (!topmost) return 0;
const row = topmost.GetRow();
const table = topmost.GetParent() as unknown as T_TABLE;
const commit = this.makeCommit();
const pos = table.GetPosition();
// Make a copy of the source row before things start moving around
const sources: T_TABLECELL[] = [];
for (let col = 0; col < table.GetColCount(); ++col) sources.push(table.GetCell(row, col)!);
commit.Modify(table, this.getScreen());
for (let col = 0; col < table.GetColCount(); ++col) {
const cell = this.copyCell(sources[col]!);
table.InsertCell(row * table.GetColCount(), cell);
}
for (let afterRow = table.GetRowCount() - 1; afterRow > row; afterRow--)
table.SetRowHeight(afterRow, table.GetRowHeight(afterRow - 1));
table.SetPosition(pos);
table.Normalize();
this.getToolMgr().PostEvent(EVENTS.SelectedEvent);
commit.Push('Add Row Above');
return 0;
}
protected doAddRowBelow(_aEvent: TOOL_EVENT): number {
const selection = this.getTableCellSelection();
let bottommost: T_TABLECELL | null = null;
if (selection.Empty()) return 0;
for (const item of selection) {
const cell = item as unknown as T_TABLECELL;
if (!bottommost || cell.GetRow() > bottommost.GetRow()) bottommost = cell;
}
if (!bottommost) return 0;
const row = bottommost.GetRow();
const table = bottommost.GetParent() as unknown as T_TABLE;
const commit = this.makeCommit();
const pos = table.GetPosition();
// Make a copy of the source row before things start moving around
const sources: T_TABLECELL[] = [];
for (let col = 0; col < table.GetColCount(); ++col) sources.push(table.GetCell(row, col)!);
commit.Modify(table, this.getScreen());
for (let col = 0; col < table.GetColCount(); ++col) {
const cell = this.copyCell(sources[col]!);
table.InsertCell((row + 1) * table.GetColCount(), cell);
}
for (let afterRow = table.GetRowCount() - 1; afterRow > row; afterRow--)
table.SetRowHeight(afterRow, table.GetRowHeight(afterRow - 1));
table.SetPosition(pos);
table.Normalize();
this.getToolMgr().PostEvent(EVENTS.SelectedEvent);
commit.Push('Add Row Below');
return 0;
}
protected doAddColumnBefore(_aEvent: TOOL_EVENT): number {
const selection = this.getTableCellSelection();
let leftmost: T_TABLECELL | null = null;
for (const item of selection) {
const cell = item as unknown as T_TABLECELL;
if (!leftmost || cell.GetColumn() < leftmost.GetColumn()) leftmost = cell;
}
if (!leftmost) return 0;
const col = leftmost.GetColumn();
const table = leftmost.GetParent() as unknown as T_TABLE;
const rowCount = table.GetRowCount();
const commit = this.makeCommit();
const pos = table.GetPosition();
// Make a copy of the source column before things start moving around
const sources: T_TABLECELL[] = [];
for (let row = 0; row < rowCount; ++row) sources.push(table.GetCell(row, col)!);
commit.Modify(table, this.getScreen());
table.SetColCount(table.GetColCount() + 1);
for (let row = 0; row < rowCount; ++row) {
const cell = this.copyCell(sources[row]!);
table.InsertCell(row * table.GetColCount() + col, cell);
}
for (let afterCol = table.GetColCount() - 1; afterCol > col; afterCol--)
table.SetColWidth(afterCol, table.GetColWidth(afterCol - 1));
table.SetPosition(pos);
table.Normalize();
this.getToolMgr().PostEvent(EVENTS.SelectedEvent);
commit.Push('Add Column Before');
return 0;
}
protected doAddColumnAfter(_aEvent: TOOL_EVENT): number {
const selection = this.getTableCellSelection();
let rightmost: T_TABLECELL | null = null;
for (const item of selection) {
const cell = item as unknown as T_TABLECELL;
if (!rightmost || cell.GetColumn() > rightmost.GetColumn()) rightmost = cell;
}
if (!rightmost) return 0;
const col = rightmost.GetColumn();
const table = rightmost.GetParent() as unknown as T_TABLE;
const rowCount = table.GetRowCount();
const commit = this.makeCommit();
const pos = table.GetPosition();
// Make a copy of the source column before things start moving around
const sources: T_TABLECELL[] = [];
for (let row = 0; row < rowCount; ++row) sources.push(table.GetCell(row, col)!);
commit.Modify(table, this.getScreen());
table.SetColCount(table.GetColCount() + 1);
for (let row = 0; row < rowCount; ++row) {
const cell = this.copyCell(sources[row]!);
table.InsertCell(row * table.GetColCount() + col + 1, cell);
}
for (let afterCol = table.GetColCount() - 1; afterCol > col; afterCol--)
table.SetColWidth(afterCol, table.GetColWidth(afterCol - 1));
table.SetPosition(pos);
table.Normalize();
this.getToolMgr().PostEvent(EVENTS.SelectedEvent);
commit.Push('Add Column After');
return 0;
}
protected doDeleteRows(_aEvent: TOOL_EVENT): number {
const selection = this.getTableCellSelection();
if (selection.Empty()) return 0;
const table = (selection.at(0) as unknown as T_TABLECELL).GetParent() as unknown as T_TABLE;
const deleted: number[] = [];
for (const cell of table.GetCells()) cell.ClearFlags(STRUCT_DELETED);
for (let row = 0; row < table.GetRowCount(); ++row) {
let deleteRow = false;
for (let col = 0; col < table.GetColCount(); ++col) {
if (table.GetCell(row, col)!.IsSelected()) {
deleteRow = true;
break;
}
}
if (deleteRow) {
for (let col = 0; col < table.GetColCount(); ++col)
table.GetCell(row, col)!.SetFlags(STRUCT_DELETED);
deleted.push(row);
}
}
const commit = this.makeCommit();
if (deleted.length === table.GetRowCount()) {
commit.Remove(table, this.getScreen());
} else {
commit.Modify(table, this.getScreen());
const pos = table.GetPosition();
// Save old row heights BEFORE deleting cells
const oldRowHeights = new Map<number, number>();
for (let row = 0; row < table.GetRowCount(); ++row)
oldRowHeights.set(row, table.GetRowHeight(row));
this.clearSelection();
table.DeleteMarkedCells();
for (let row = 0; row < table.GetRowCount(); ++row) {
let old_row = row;
for (const deletedRow of deleted) {
if (deletedRow <= old_row) old_row++;
}
// Use saved old heights instead of querying the modified table
const height = oldRowHeights.get(old_row) ?? 0;
table.SetRowHeight(row, height);
}
table.SetPosition(pos);
table.Normalize();
this.getToolMgr().PostEvent(EVENTS.SelectedEvent);
}
if (deleted.length > 1) commit.Push('Delete Rows');
else commit.Push('Delete Row');
return 0;
}
protected doDeleteColumns(_aEvent: TOOL_EVENT): number {
const selection = this.getTableCellSelection();
if (selection.Empty()) return 0;
const table = (selection.at(0) as unknown as T_TABLECELL).GetParent() as unknown as T_TABLE;
const deleted: number[] = [];
for (const cell of table.GetCells()) cell.ClearFlags(STRUCT_DELETED);
for (let col = 0; col < table.GetColCount(); ++col) {
let deleteColumn = false;
for (let row = 0; row < table.GetRowCount(); ++row) {
if (table.GetCell(row, col)!.IsSelected()) {
deleteColumn = true;
break;
}
}
if (deleteColumn) {
for (let row = 0; row < table.GetRowCount(); ++row)
table.GetCell(row, col)!.SetFlags(STRUCT_DELETED);
deleted.push(col);
}
}
const commit = this.makeCommit();
if (deleted.length === table.GetColCount()) {
commit.Remove(table, this.getScreen());
} else {
commit.Modify(table, this.getScreen());
const pos = table.GetPosition();
this.clearSelection();
table.DeleteMarkedCells();
table.SetColCount(table.GetColCount() - deleted.length);
for (let col = 0; col < table.GetColCount(); ++col) {
let old_col = col;
for (const deletedCol of deleted) {
if (deletedCol <= old_col) old_col++;
}
table.SetColWidth(col, table.GetColWidth(old_col));
}
table.SetPosition(pos);
table.Normalize();
this.getToolMgr().PostEvent(EVENTS.SelectedEvent);
}
if (deleted.length > 1) commit.Push('Delete Columns');
else commit.Push('Delete Column');
return 0;
}
protected doMergeCells(_aEvent: TOOL_EVENT): number {
const sel = this.getTableCellSelection();
if (sel.Empty()) return 0;
let colMin = Number.MAX_SAFE_INTEGER;
let colMax = 0;
let rowMin = Number.MAX_SAFE_INTEGER;
let rowMax = 0;
const commit = this.makeCommit();
const table = (sel.at(0) as unknown as T_TABLECELL).GetParent() as unknown as T_TABLE;
for (const item of sel) {
const cell = this.asTableCell(item);
if (cell) {
colMin = Math.min(colMin, cell.GetColumn());
colMax = Math.max(colMax, cell.GetColumn() + cell.GetColSpan());
rowMin = Math.min(rowMin, cell.GetRow());
rowMax = Math.max(rowMax, cell.GetRow() + cell.GetRowSpan());
}
}
let content = '';
const extents: VECTOR2I = { x: 0, y: 0 };
for (let row = rowMin; row < rowMax; ++row) {
extents.y += table.GetRowHeight(row);
extents.x = 0;
for (let col = colMin; col < colMax; ++col) {
extents.x += table.GetColWidth(col);
const cell = table.GetCell(row, col)!;
if (cell.GetText() !== '') {
if (content !== '') content += '\n';
content += cell.GetText();
}
commit.Modify(cell, this.getScreen());
cell.SetColSpan(0);
cell.SetRowSpan(0);
cell.SetText('');
}
}
const topLeft = table.GetCell(rowMin, colMin)!;
topLeft.SetColSpan(colMax - colMin);
topLeft.SetRowSpan(rowMax - rowMin);
topLeft.SetText(content);
const start = topLeft.GetStart();
topLeft.SetEnd({ x: start.x + extents.x, y: start.y + extents.y });
table.Normalize();
commit.Push('Merge Cells');
this.getToolMgr().PostEvent(EVENTS.SelectedEvent);
return 0;
}
protected doUnmergeCells(_aEvent: TOOL_EVENT): number {
const sel = this.getTableCellSelection();
if (sel.Empty()) return 0;
const commit = this.makeCommit();
const table = (sel.at(0) as unknown as T_TABLECELL).GetParent() as unknown as T_TABLE;
for (const item of sel) {
const cell = this.asTableCell(item);
if (cell) {
const rowSpan = cell.GetRowSpan();
const colSpan = cell.GetColSpan();
for (let row = cell.GetRow(); row < cell.GetRow() + rowSpan; ++row) {
for (let col = cell.GetColumn(); col < cell.GetColumn() + colSpan; ++col) {
const target = table.GetCell(row, col)!;
commit.Modify(target, this.getScreen());
target.SetColSpan(1);
target.SetRowSpan(1);
const start = target.GetStart();
target.SetEnd({
x: start.x + table.GetColWidth(col),
y: start.y + table.GetRowHeight(row),
});
}
}
}
}
table.Normalize();
commit.Push('Unmerge Cells');
this.getToolMgr().PostEvent(EVENTS.SelectedEvent);
return 0;
}
/**
* Get the bounding box of a cell block selection.
*
* @return the bounds (column and row max exclusive), or null when the
* selection is not a contiguous block; upstream's out-params and bool.
*/
getCellBlockBounds(
aSel: SELECTION,
): { colMin: number; colMax: number; rowMin: number; rowMax: number } | null {
if (aSel.Size() < 1) return null;
let colMin = Number.MAX_SAFE_INTEGER;
let colMax = 0;
let rowMin = Number.MAX_SAFE_INTEGER;
let rowMax = 0;
let selectedArea = 0;
for (const item of aSel) {
const cell = this.asTableCell(item);
if (cell) {
colMin = Math.min(colMin, cell.GetColumn());
colMax = Math.max(colMax, cell.GetColumn() + cell.GetColSpan());
rowMin = Math.min(rowMin, cell.GetRow());
rowMax = Math.max(rowMax, cell.GetRow() + cell.GetRowSpan());
selectedArea += cell.GetColSpan() * cell.GetRowSpan();
}
}
const bounds = { colMin, colMax, rowMin, rowMax };
// Check if selection is contiguous (for single cell, we allow it)
if (aSel.Size() === 1) return bounds;
return selectedArea === (colMax - colMin) * (rowMax - rowMin) ? bounds : null;
}
/**
* Validate if paste-into-cells is possible for the given selection.
*
* @return null when it is, else the message upstream puts in `aErrorMsg`.
*/
validatePasteIntoSelection(aSel: SELECTION): string | null {
if (aSel.Empty()) return 'No cells selected';
// Check if all selected items are table cells from the same table
let table: T_TABLE | null = null;
for (const item of aSel) {
const cell = this.asTableCell(item);
if (!cell) return 'Selection contains non-cell items';
if (!table) table = cell.GetParent() as unknown as T_TABLE;
else if ((cell.GetParent() as unknown) !== table)
return 'Selected cells are from different tables';
// Check for merged cells (block paste-into for now)
if (cell.GetColSpan() > 1 || cell.GetRowSpan() > 1) return 'Cannot paste into merged cells';
}
// Check if selection is contiguous
if (!this.getCellBlockBounds(aSel)) return 'Selected cells must form a contiguous block';
return null;
}
/**
* Paste text content from source table into selected cells.
*
* @return true if paste succeeded, false otherwise.
*/
pasteCellsIntoSelection(
aSel: SELECTION,
aSourceTable: T_TABLE | null,
aCommit: T_COMMIT,
): boolean {
if (!aSourceTable || aSel.Empty()) return false;
// Get target cell range
const bounds = this.getCellBlockBounds(aSel);
if (!bounds) return false;
const targetColMin = bounds.colMin;
const targetRowMin = bounds.rowMin;
const targetTable = (aSel.at(0) as unknown as T_TABLECELL).GetParent() as unknown as T_TABLE;
// Get source table dimensions
const sourceRows = aSourceTable.GetRowCount();
const sourceCols = aSourceTable.GetColCount();
const pasteEndRow = targetRowMin + sourceRows;
const pasteEndCol = targetColMin + sourceCols;
if (pasteEndRow > targetTable.GetRowCount() || pasteEndCol > targetTable.GetColCount()) {
const rowsToAdd = Math.max(0, pasteEndRow - targetTable.GetRowCount());
const colsToAdd = Math.max(0, pasteEndCol - targetTable.GetColCount());
const pos = targetTable.GetPosition();
aCommit.Modify(targetTable, this.getScreen());
for (let i = 0; i < rowsToAdd; ++i) {
const insertRow = targetTable.GetRowCount();
const clipboardRow = insertRow - targetRowMin;
const sources: T_TABLECELL[] = [];
for (let col = 0; col < aSourceTable.GetColCount(); ++col)
sources.push(aSourceTable.GetCell(clipboardRow, col)!);
for (let col = 0; col < targetTable.GetColCount(); ++col) {
const sourceCell = col < aSourceTable.GetColCount() ? sources[col]! : sources[0]!;
const cell = this.copyCell(sourceCell);
targetTable.InsertCell(insertRow * targetTable.GetColCount(), cell);
}
for (let afterRow = targetTable.GetRowCount() - 1; afterRow > insertRow; afterRow--)
targetTable.SetRowHeight(afterRow, targetTable.GetRowHeight(afterRow - 1));
targetTable.SetRowHeight(insertRow, aSourceTable.GetRowHeight(clipboardRow));
}
for (let i = 0; i < colsToAdd; ++i) {
const insertCol = targetTable.GetColCount();
const clipboardCol = insertCol - targetColMin;
const rowCount = targetTable.GetRowCount();
targetTable.SetColCount(targetTable.GetColCount() + 1);
const sources: T_TABLECELL[] = [];
for (let row = 0; row < aSourceTable.GetRowCount(); ++row)
sources.push(aSourceTable.GetCell(row, clipboardCol)!);
for (let row = 0; row < rowCount; ++row) {
const sourceCell = row < aSourceTable.GetRowCount() ? sources[row]! : sources[0]!;
const cell = this.copyCell(sourceCell);
targetTable.InsertCell(row * targetTable.GetColCount() + insertCol, cell);
}
for (let afterCol = targetTable.GetColCount() - 1; afterCol > insertCol; afterCol--)
targetTable.SetColWidth(afterCol, targetTable.GetColWidth(afterCol - 1));
targetTable.SetColWidth(insertCol, aSourceTable.GetColWidth(clipboardCol));
}
targetTable.SetPosition(pos);
targetTable.Normalize();
}
for (let srcRow = 0; srcRow < sourceRows; ++srcRow) {
for (let srcCol = 0; srcCol < sourceCols; ++srcCol) {
const destRow = targetRowMin + srcRow;
const destCol = targetColMin + srcCol;
if (destRow >= targetTable.GetRowCount() || destCol >= targetTable.GetColCount()) continue;
const sourceCell = aSourceTable.GetCell(srcRow, srcCol)!;
const targetCell = targetTable.GetCell(destRow, destCol)!;
aCommit.Modify(targetCell, this.getScreen());
targetCell.SetText(sourceCell.GetText());
targetCell.SetAttributes(sourceCell as never, false);
targetCell.SetStroke(sourceCell.GetStroke() as never);
targetCell.SetFillMode(sourceCell.GetFillMode() as never);
targetCell.SetFillColor(sourceCell.GetFillColor() as never);
}
}
targetTable.Normalize();
return true;
}
abstract getToolMgr(): TOOL_MANAGER;
abstract getScreen(): unknown;
abstract getTableCellSelection(): SELECTION;
abstract clearSelection(): void;
abstract copyCell(aSource: T_TABLECELL): T_TABLECELL;
/** `T_COMMIT commit( getToolMgr() )`. */
abstract makeCommit(): T_COMMIT;
/** `dynamic_cast<T_TABLECELL*>( aItem )`. */
abstract asTableCell(aItem: EDA_ITEM): T_TABLECELL | null;
}