зеркало из https://github.com/mozilla/gecko-dev.git
481 строка
23 KiB
Plaintext
481 строка
23 KiB
Plaintext
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
|
|
#include "nsISupports.idl"
|
|
|
|
webidl Element;
|
|
webidl Node;
|
|
webidl Range;
|
|
|
|
[scriptable, builtinclass, uuid(4805e684-49b9-11d3-9ce4-ed60bd6cb5bc)]
|
|
interface nsITableEditor : nsISupports
|
|
{
|
|
const short eNoSearch = 0;
|
|
const short ePreviousColumn = 1;
|
|
const short ePreviousRow = 2;
|
|
|
|
/**
|
|
* insertTableCell() inserts <td> elements before or after a cell element
|
|
* containing first selection range. I.e., if the cell spans columns and
|
|
* aInsertPosition is true, new columns will be inserted after the
|
|
* right-most column which contains the cell. Note that this simply
|
|
* inserts <td> elements, i.e., colspan and rowspan around the cell
|
|
* containing selection are not modified. So, for example, adding a cell
|
|
* to rectangular table changes non-rectangular table. And if a cell
|
|
* containing selection is at left of row-spanning cell, it may be moved to
|
|
* right side of the row-spanning cell after inserting some cell elements
|
|
* before it. Similarly, colspan won't be adjusted for keeping table
|
|
* rectangle.
|
|
* If first selection range is not in table cell element, this does nothing
|
|
* without exception.
|
|
*
|
|
* @param aNumberOfCellssToInsert Number of cells to insert.
|
|
* @param aInsertAfterSelectedCell true if new cells should be inserted
|
|
* before current cell. Otherwise, will
|
|
* be inserted after the cell.
|
|
*/
|
|
[can_run_script]
|
|
void insertTableCell(in long aNumberOfColumnsToInsert,
|
|
in boolean aInsertAfterSelectedCell);
|
|
|
|
/**
|
|
* insertTableColumn() inserts columns before or after a cell element
|
|
* containing first selection range. I.e., if the cell spans columns and
|
|
* aInsertAfterSelectedCell is tre, new columns will be inserted after the
|
|
* right-most column which contains the cell. If first selection range is
|
|
* not in table cell element, this does nothing without exception.
|
|
*
|
|
* @param aNumberOfColumnsToInsert Number of columns to insert.
|
|
* @param aInsertAfterSelectedCell true if new columns will be inserted
|
|
* before current cell. Otherwise, will
|
|
* be inserted after the cell.
|
|
*/
|
|
[can_run_script]
|
|
void insertTableColumn(in long aNumberOfColumnsToInsert,
|
|
in boolean aInsertAfterSelectedCell);
|
|
|
|
/*
|
|
* insertTableRow() inserts <tr> elements before or after a <td> element
|
|
* containing first selection range. I.e., if the cell spans rows and
|
|
* aInsertAfterSelectedCell is true, new rows will be inserted after the
|
|
* bottom-most row which contains the cell. If first selection range is
|
|
* not in table cell element, this does nothing without exception.
|
|
*
|
|
* @param aNumberOfRowsToInsert Number of rows to insert.
|
|
* @param aInsertAfterSelectedCell true if new rows will be inserted
|
|
* before current cell. Otherwise, will
|
|
* be inserted after the cell.
|
|
*/
|
|
[can_run_script]
|
|
void insertTableRow(in long aNumberOfRowsToInsert,
|
|
in boolean aInsertAfterSelectedCell);
|
|
|
|
/** Delete table methods
|
|
* Delete starting at the selected cell or the
|
|
* cell (or table) enclosing the selection anchor
|
|
* The selection is collapsed and is left in the
|
|
* cell at the same row,col location as
|
|
* the previous selection anchor, if possible,
|
|
* else in the closest neighboring cell
|
|
*
|
|
* @param aNumber Number of items to insert/delete
|
|
*/
|
|
[can_run_script]
|
|
void deleteTable();
|
|
|
|
/**
|
|
* deleteTableCellContents() removes any contents in cell elements. If two
|
|
* or more cell elements are selected, this removes all selected cells'
|
|
* contents. Otherwise, this removes contents of a cell which contains
|
|
* first selection range. This does nothing without exception if selection
|
|
* is not in cell element.
|
|
*/
|
|
[can_run_script]
|
|
void deleteTableCellContents();
|
|
|
|
/**
|
|
* deleteTableCell() removes table cell elements. If two or more cell
|
|
* elements are selected, this removes all selected cell elements.
|
|
* Otherwise, this removes some cell elements starting from selected cell
|
|
* element or a cell containing first selection range. When this removes
|
|
* last cell element in <tr> or <table>, this removes the <tr> or the
|
|
* <table> too. Note that when removing a cell causes number of its row
|
|
* becomes less than the others, this method does NOT fill the place with
|
|
* rowspan nor colspan. This does nothing without exception if selection is
|
|
* not in cell element.
|
|
*
|
|
* @param aNumberOfCellsToDelete Number of cells to remove. This is ignored
|
|
* if 2 or more cells are selected.
|
|
*/
|
|
[can_run_script]
|
|
void deleteTableCell(in long aNumberOfCellsToDelete);
|
|
|
|
/**
|
|
* deleteTableColumn() removes cell elements which belong to same columns
|
|
* of selected cell elements.
|
|
* If only one cell element is selected or first selection range is
|
|
* in a cell, removes cell elements which belong to same column.
|
|
* If 2 or more cell elements are selected, removes cell elements which
|
|
* belong to any of all selected columns. In this case,
|
|
* aNumberOfColumnsToDelete is ignored.
|
|
* If there is no selection ranges, throws exception.
|
|
* If selection is not in a cell element, just does nothing without
|
|
* throwing exception.
|
|
* WARNING: This does not remove <col> nor <colgroup> elements.
|
|
*
|
|
* @param aNumberOfColumnsToDelete Number of columns to remove. This is
|
|
* ignored if 2 ore more cells are
|
|
* selected.
|
|
*/
|
|
[can_run_script]
|
|
void deleteTableColumn(in long aNumberOfColumnsToDelete);
|
|
|
|
/**
|
|
* deleteTableRow() removes <tr> elements.
|
|
* If only one cell element is selected or first selection range is
|
|
* in a cell, removes <tr> elements starting from a <tr> element
|
|
* containing the selected cell or first selection range.
|
|
* If 2 or more cell elements are selected, all <tr> elements
|
|
* which contains selected cell(s). In this case, aNumberOfRowsToDelete
|
|
* is ignored.
|
|
* If there is no selection ranges, throws exception.
|
|
* If selection is not in a cell element, just does nothing without
|
|
* throwing exception.
|
|
*
|
|
* @param aNumberOfRowsToDelete Number of rows to remove. This is ignored
|
|
* if 2 or more cells are selected.
|
|
*/
|
|
[can_run_script]
|
|
void deleteTableRow(in long aNumberOfRowsToDelete);
|
|
|
|
/** Table Selection methods
|
|
* Selecting a row or column actually
|
|
* selects all cells (not TR in the case of rows)
|
|
*/
|
|
[can_run_script]
|
|
void selectTableCell();
|
|
|
|
[can_run_script]
|
|
void selectTableRow();
|
|
[can_run_script]
|
|
void selectTableColumn();
|
|
[can_run_script]
|
|
void selectTable();
|
|
[can_run_script]
|
|
void selectAllTableCells();
|
|
|
|
/** Create a new TD or TH element, the opposite type of the supplied aSourceCell
|
|
* 1. Copy all attributes from aSourceCell to the new cell
|
|
* 2. Move all contents of aSourceCell to the new cell
|
|
* 3. Replace aSourceCell in the table with the new cell
|
|
*
|
|
* @param aSourceCell The cell to be replaced
|
|
* @return The new cell that replaces aSourceCell
|
|
*/
|
|
[can_run_script]
|
|
Element switchTableCellHeaderType(in Element aSourceCell);
|
|
|
|
/** Merges contents of all selected cells
|
|
* for selected cells that are adjacent,
|
|
* this will result in a larger cell with appropriate
|
|
* rowspan and colspan, and original cells are deleted
|
|
* The resulting cell is in the location of the
|
|
* cell at the upper-left corner of the adjacent
|
|
* block of selected cells
|
|
*
|
|
* @param aMergeNonContiguousContents:
|
|
* If true:
|
|
* Non-contiguous cells are not deleted,
|
|
* but their contents are still moved
|
|
* to the upper-left cell
|
|
* If false: contiguous cells are ignored
|
|
*
|
|
* If there are no selected cells,
|
|
* and selection or caret is in a cell,
|
|
* that cell and the one to the right
|
|
* are merged
|
|
*/
|
|
[can_run_script]
|
|
void joinTableCells(in boolean aMergeNonContiguousContents);
|
|
|
|
/** Split a cell that has rowspan and/or colspan > 0
|
|
* into cells such that all new cells have
|
|
* rowspan = 1 and colspan = 1
|
|
* All of the contents are not touched --
|
|
* they will appear to be in the upper-left cell
|
|
*/
|
|
[can_run_script]
|
|
void splitTableCell();
|
|
|
|
/** Scan through all rows and add cells as needed so
|
|
* all locations in the cellmap are occupied.
|
|
* Used after inserting single cells or pasting
|
|
* a collection of cells that extend past the
|
|
* previous size of the table
|
|
* If aTable is null, it uses table enclosing the selection anchor
|
|
* This doesn't doesn't change the selection,
|
|
* thus it can be used to fixup all tables
|
|
* in a page independent of the selection
|
|
*/
|
|
[can_run_script]
|
|
void normalizeTable(in Element aTable);
|
|
|
|
/**
|
|
* getCellIndexes() computes row index and column index of a table cell.
|
|
* Note that this depends on layout information. Therefore, all pending
|
|
* layout should've been flushed before calling this.
|
|
*
|
|
* @param aCellElement If not null, this computes indexes of the cell.
|
|
* If null, this computes indexes of a cell which
|
|
* contains anchor of Selection.
|
|
* @param aRowIndex Must be an object, whose .value will be set
|
|
* to row index of the cell. 0 is the first row.
|
|
* If rowspan is set to 2 or more, the start
|
|
* row index is used.
|
|
* @param aColumnIndex Must be an object, whose .value will be set
|
|
* to column index of the cell. 0 is the first
|
|
* column. If colspan is set to 2 or more, the
|
|
* start column index is used.
|
|
*/
|
|
void getCellIndexes(in Element aCellElement,
|
|
out long aRowIndex, out long aColumnIndex);
|
|
|
|
/**
|
|
* getTableSize() computes number of rows and columns.
|
|
* Note that this depends on layout information. Therefore, all pending
|
|
* layout should've been flushed before calling this.
|
|
*
|
|
* @param aTableOrElementInTable If a <table> element, this computes number
|
|
* of rows and columns of it.
|
|
* If another element and in a <table>, this
|
|
* computes number of rows and columns of
|
|
* the nearest ancestor <table> element.
|
|
* If element is not in <table> element,
|
|
* throwing an exception.
|
|
* If null, this looks for nearest ancestor
|
|
* <table> element containing anchor of
|
|
* Selection. If found, computes the number
|
|
* of rows and columns of the <table>.
|
|
* Otherwise, throwing an exception.
|
|
* @param aRowCount Number of *actual* row count.
|
|
* I.e., rowspan does NOT increase this value.
|
|
* @param aColumnCount Number of column count.
|
|
* I.e., if colspan is specified with bigger
|
|
* number than actual, the value is used
|
|
* as this.
|
|
*/
|
|
void getTableSize(in Element aTableOrElementInTable,
|
|
out long aRowCount, out long aColCount);
|
|
|
|
/**
|
|
* getCellAt() returns a <td> or <th> element in a <table> if there is a
|
|
* cell at the indexes.
|
|
*
|
|
* @param aTableElement If not null, must be a <table> element.
|
|
* If null, looks for the nearest ancestor <table>
|
|
* to look for a cell.
|
|
* @param aRowIndex Row index of the cell.
|
|
* @param aColumnIndex Column index of the cell.
|
|
* @return Returns a <td> or <th> element if there is.
|
|
* Otherwise, returns null without throwing
|
|
* exception.
|
|
* If aTableElement is not null and not a <table>
|
|
* element, throwing an exception.
|
|
* If aTableElement is null and anchor of Selection
|
|
* is not in any <table> element, throwing an
|
|
* exception.
|
|
*/
|
|
Element getCellAt(in Element aTableElement,
|
|
in long aRowIndex, in long aColumnIndex);
|
|
|
|
/**
|
|
* Get cell element and its various information from <table> element and
|
|
* indexes in it. If aTableElement is null, this looks for an ancestor
|
|
* <table> element of anchor of Selection. If there is no <table> element
|
|
* at that point, this throws exception. Note that this requires layout
|
|
* information. So, you need to flush the layout after changing the DOM
|
|
* tree.
|
|
* If there is no cell element at the indexes, this throws exception.
|
|
* XXX Perhaps, this is wrong behavior, this should return null without
|
|
* exception since the caller cannot distinguish whether the exception
|
|
* is caused by "not found" or other unexpected situation.
|
|
*
|
|
* @param aTableElement A <table> element. If this is null, this
|
|
* uses ancestor of anchor of Selection.
|
|
* @param aRowIndex Row index in aTableElement. Starting from 0.
|
|
* @param aColumnIndex Column index in aTableElement. Starting from
|
|
* 0.
|
|
* @param aCellElement [OUT] The cell element at the indexes.
|
|
* @param aStartRowIndex [OUT] First row index which contains
|
|
* aCellElement. E.g., if the cell's rowspan is
|
|
* not 1, this returns its first row index.
|
|
* I.e., this can be smaller than aRowIndex.
|
|
* @param aStartColumnIndex [OUT] First column index which contains the
|
|
* aCellElement. E.g., if the cell's colspan is
|
|
* larger than 1, this returns its first column
|
|
* index. I.e., this can be smaller than
|
|
* aColumIndex.
|
|
* @param aRowSpan [OUT] rowspan attribute value in most cases.
|
|
* If the specified value is invalid, this
|
|
* returns 1. Only when the document is written
|
|
* in HTML5 or later, this can be 0.
|
|
* @param aColSpan [OUT] colspan attribute value in most cases.
|
|
* If the specified value is invalid, this
|
|
* returns 1.
|
|
* @param aEffectiveRowSpan [OUT] Effective rowspan value at aRowIndex.
|
|
* This is same as:
|
|
* aRowSpan - (aRowIndex - aStartRowIndex)
|
|
* @param aEffectiveColSpan [OUT] Effective colspan value at aColumnIndex.
|
|
* This is same as:
|
|
* aColSpan - (aColumnIndex - aStartColumnIndex)
|
|
* @param aIsSelected [OUT] Returns true if aCellElement or its
|
|
* <tr> or <table> element is selected.
|
|
* Otherwise, e.g., aCellElement just contains
|
|
* selection range, returns false.
|
|
*/
|
|
void getCellDataAt(in Element aTableElement,
|
|
in long aRowIndex, in long aColumnIndex,
|
|
out Element aCellElement,
|
|
out long aStartRowIndex, out long aStartColumnIndex,
|
|
out long aRowSpan, out long aColSpan,
|
|
out long aEffectiveRowSpan, out long aEffectiveColSpan,
|
|
out boolean aIsSelected);
|
|
|
|
/**
|
|
* getFirstRow() returns first <tr> element in a <table> element.
|
|
*
|
|
* @param aTableOrElementInTable If a <table> element, returns its first
|
|
* <tr> element.
|
|
* If another element, looks for nearest
|
|
* ancestor <table> element first. Then,
|
|
* return its first <tr> element.
|
|
* @return <tr> element in the <table> element.
|
|
* If <table> element is not found, this
|
|
* throws an exception.
|
|
* If there is a <table> element but it
|
|
* does not have <tr> elements, returns
|
|
* null without throwing exception.
|
|
* Note that this may return anonymous <tr>
|
|
* element if <table> has one or more cells
|
|
* but <tr> element is not in the source.
|
|
*/
|
|
Element getFirstRow(in Element aTableElement);
|
|
|
|
/** Preferred direction to search for neighboring cell
|
|
* when trying to locate a cell to place caret in after
|
|
* a table editing action.
|
|
* Used for aDirection param in SetSelectionAfterTableEdit
|
|
*/
|
|
|
|
/**
|
|
* getSelectedOrParentTableElement() returns a <td>, <th>, <tr> or <table>.
|
|
* If first selection range selects a <td> or <th>, returns it. aTagName
|
|
* is set to "td" even if the result is a <th> and aCount is set to
|
|
* Selection.rangeCount.
|
|
* If first selection range does not select <td> nor <th>, but selection
|
|
* anchor refers <table>, returns it. aTagName is set to "table" and
|
|
* aCount is set to 1.
|
|
* If first selection range does not select <td> nor <th>, but selection
|
|
* anchor refers <tr>, returns it. aTagName is set to "tr" and aCount is
|
|
* set to 1.
|
|
* If first selection range does not select <td> nor <th>, but selection
|
|
* anchor refers <td> (not include <th>!), returns it. aTagName is set to
|
|
* "td" and aCount is set to 0.
|
|
* Otherwise, if container of selection anchor is in a <td> or <th>,
|
|
* returns it. aTagName is set to "td" but aCount is set to 0.
|
|
* Otherwise, returns null, aTagName is set to empty string and aCount is
|
|
* set to 0. I.e., does not throw exception even if a cell is not found.
|
|
* NOTE: Calling this resets internal counter of getFirstSelectedCell()
|
|
* and getNextSelectedCell(). I.e., getNextSelectedCell() will
|
|
* return second selected cell element.
|
|
*/
|
|
Element getSelectedOrParentTableElement(out AString aTagName,
|
|
out long aCount);
|
|
|
|
/** Generally used after GetSelectedOrParentTableElement
|
|
* to test if selected cells are complete rows or columns
|
|
*
|
|
* @param aElement Any table or cell element or any element
|
|
* inside a table
|
|
* Used to get enclosing table.
|
|
* If null, selection's anchorNode is used
|
|
*
|
|
* @return
|
|
* 0 aCellElement was not a cell
|
|
* (returned result = NS_ERROR_FAILURE)
|
|
* TableSelectionMode::Cell There are 1 or more cells selected but
|
|
* complete rows or columns are not selected
|
|
* TableSelectionMode::Row All cells are in 1 or more rows
|
|
* and in each row, all cells selected
|
|
* Note: This is the value if all rows
|
|
* (thus all cells) are selected
|
|
* TableSelectionMode::Column All cells are in 1 or more columns
|
|
* and in each column, all cells are selected
|
|
*/
|
|
uint32_t getSelectedCellsType(in Element aElement);
|
|
|
|
/**
|
|
* getFirstSelectedCell() returns a <td> or <th> element if first range of
|
|
* Selection selects only one table cell element (i.e., startContainer and
|
|
* endContainer are same <tr> element and startOffset + 1 equals endOffset).
|
|
* If first range of Selection does not select a table cell element, this
|
|
* returns null. However, if Selection has no range, this throws an
|
|
* exception.
|
|
*
|
|
* @param aFirstRangeOfSelection [OUT] Returns the first range of Selection
|
|
* only when this returns a <td> or <th>
|
|
* element. Otherwise, returns null.
|
|
* @return A <td> or <th> element if first range of
|
|
* Selection selects only one table cell
|
|
* element.
|
|
*/
|
|
Element getFirstSelectedCell(out Range aFirstRangeOfSelection);
|
|
|
|
/**
|
|
* getFirstSelectedCellInTable() returns a cell element, its row index and
|
|
* its column index if first range of Selection selects a cell. Note that
|
|
* that "selects a cell" means that the range container is a <tr> element
|
|
* and endOffset is startOffset + 1. So, even if first range of Selection
|
|
* is in a cell element, this treats the range does not select a cell.
|
|
* NOTE: Calling this resets internal counter of getFirstSelectedCell()
|
|
* and getNextSelectedCell(). I.e., getNextSelectedCell() will
|
|
* return second selected cell element.
|
|
*
|
|
* @param aRowIndex [OUT} Returns row index of the found cell. If not
|
|
* found, returns 0.
|
|
* @param aColumnIndex [OUT] Returns column index of the found cell. If
|
|
* not found, returns 0.
|
|
* @return The cell element which is selected by the first
|
|
* range of Selection. Even if this is not found,
|
|
* this returns null, not throwing exception.
|
|
*/
|
|
Element getFirstSelectedCellInTable(out long aRowIndex, out long aColIndex);
|
|
|
|
/**
|
|
* getNextSelectedCell() is a stateful method to retrieve selected table
|
|
* cell elements which are selected by 2nd or later ranges of Selection.
|
|
* When you call getFirstSelectedCell(), it resets internal counter of
|
|
* this method. Then, following calls of getNextSelectedCell() scans the
|
|
* remaining ranges of Selection. If a range selects a <td> or <th>
|
|
* element, returns the cell element. If a range selects an element but
|
|
* neither <td> nor <th> element, this ignores the range. If a range is
|
|
* in a text node, returns null without throwing exception, but stops
|
|
* scanning the remaining ranges even you call this again.
|
|
* Note that this may cross <table> boundaries since this method just
|
|
* scans all ranges of Selection. Therefore, returning cells which
|
|
* belong to different <table> elements.
|
|
*
|
|
* @param aNextSelectedCellRange [OUT] Returns null if this method returns
|
|
* null. Otherwise, i.e., found a range which
|
|
* selects a <td> or <th> element, returns the
|
|
* range.
|
|
* @return A <td> or <th> element if one of remaining
|
|
* ranges selects a <td> or <th> element unless
|
|
* this does not meet a range in a text node.
|
|
*/
|
|
Element getNextSelectedCell(out Range aNextSelectedCellRange);
|
|
};
|