mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-24 05:11:16 +00:00
ea71b3e52c
nsITableEditor::GetNextCellElement() is an XPCOM method but it's used internally a lot. So, HTMLEditor should implement it with non-virtual method and internal users should use the non-virtual method. Therefore, this patch creates HTMLEditor::GetNextSelectedTableCellElement(). Differential Revision: https://phabricator.services.mozilla.com/D4194 --HG-- extra : moz-landing-system : lando
363 lines
17 KiB
Plaintext
363 lines
17 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;
|
|
|
|
/* ------------ Table editing Methods -------------- */
|
|
|
|
/** Insert table methods
|
|
* Insert relative to the selected cell or the
|
|
* cell enclosing the selection anchor
|
|
* The selection is collapsed and is left in the new cell
|
|
* at the same row,col location as the original anchor cell
|
|
*
|
|
* @param aNumber Number of items to insert
|
|
* @param aAfter If TRUE, insert after the current cell,
|
|
* else insert before current cell
|
|
*/
|
|
void insertTableCell(in long aNumber, in boolean aAfter);
|
|
void insertTableColumn(in long aNumber, in boolean aAfter);
|
|
void insertTableRow(in long aNumber, in boolean aAfter);
|
|
|
|
/** 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 neigboring cell
|
|
*
|
|
* @param aNumber Number of items to insert/delete
|
|
*/
|
|
void deleteTable();
|
|
|
|
/** Delete just the cell contents
|
|
* This is what should happen when Delete key is used
|
|
* for selected cells, to minimize upsetting the table layout
|
|
*/
|
|
void deleteTableCellContents();
|
|
|
|
/** Delete cell elements as well as contents
|
|
* @param aNumber Number of contiguous cells, rows, or columns
|
|
*
|
|
* When there are more than 1 selected cells, aNumber is ignored.
|
|
* For Delete Rows or Columns, the complete columns or rows are
|
|
* determined by the selected cells. E.g., to delete 2 complete rows,
|
|
* user simply selects a cell in each, and they don't
|
|
* have to be contiguous.
|
|
*/
|
|
void deleteTableCell(in long aNumber);
|
|
void deleteTableColumn(in long aNumber);
|
|
void deleteTableRow(in long aNumber);
|
|
|
|
/** Table Selection methods
|
|
* Selecting a row or column actually
|
|
* selects all cells (not TR in the case of rows)
|
|
*/
|
|
void selectTableCell();
|
|
|
|
/** Select a rectangular block of cells:
|
|
* all cells falling within the row/column index of aStartCell
|
|
* to through the row/column index of the aEndCell
|
|
* aStartCell can be any location relative to aEndCell,
|
|
* as long as they are in the same table
|
|
* @param aStartCell starting cell in block
|
|
* @param aEndCell ending cell in block
|
|
*/
|
|
void selectBlockOfCells(in Element aStartCell,
|
|
in Element aEndCell);
|
|
|
|
void selectTableRow();
|
|
void selectTableColumn();
|
|
void selectTable();
|
|
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
|
|
*/
|
|
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
|
|
*/
|
|
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
|
|
*/
|
|
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
|
|
*/
|
|
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 a cell at cellmap grid coordinates and associated data
|
|
* A cell that spans across multiple cellmap locations will
|
|
* be returned multiple times, once for each location it occupies
|
|
* Examine the returned aStartRowIndex and aStartColIndex to see
|
|
* if it is in the same layout column or layout row:
|
|
* A "layout row" is all cells sharing the same top edge
|
|
* A "layout column" is all cells sharing the same left edge
|
|
* This is important to determine what to do when inserting or deleting a column or row
|
|
*
|
|
* @param aTable A table in the document
|
|
* @param aRowIndex, aColIndex The 0-based cellmap indexes
|
|
* returns values:
|
|
* @param aCell The cell at this cellmap location
|
|
* @param aStartRowIndex The row index where cell starts
|
|
* @param aStartColIndex The col index where cell starts
|
|
* @param aRowSpan May be 0 (to span down entire table) or number of cells spanned
|
|
* @param aColSpan May be 0 (to span across entire table) or number of cells spanned
|
|
* @param aActualRowSpan The actual number of cellmap locations (rows) spanned by the cell
|
|
* @param aActualColSpan The actual number of cellmap locations (columns) spanned by the cell
|
|
* @param aIsSelected
|
|
* @param
|
|
*
|
|
* (in C++ returns: NS_EDITOR_ELEMENT_NOT_FOUND if an element is not found
|
|
* passes NS_SUCCEEDED macro)
|
|
*/
|
|
void getCellDataAt(in Element aTable,
|
|
in long aRowIndex, in long aColIndex,
|
|
out Element aCell,
|
|
out long aStartRowIndex, out long aStartColIndex,
|
|
out long aRowSpan, out long aColSpan,
|
|
out long aActualRowSpan, out long aActualColSpan,
|
|
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
|
|
*/
|
|
|
|
/** Examine the current selection and find
|
|
* a selected TABLE, TD or TH, or TR element.
|
|
* or return the parent TD or TH if selection is inside a table cell
|
|
* Returns null if no table element is found.
|
|
*
|
|
* @param aTagName The tagname of returned element
|
|
* Note that "td" will be returned if name
|
|
* is actually "th"
|
|
* @param aCount How many table elements were selected
|
|
* This tells us if we have multiple cells selected
|
|
* (0 if element is a parent cell of selection)
|
|
* @return The table element (table, row, or first selected cell)
|
|
*
|
|
*/
|
|
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)
|
|
* TableSelection::Cell There are 1 or more cells selected but
|
|
* complete rows or columns are not selected
|
|
* TableSelection::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
|
|
* TableSelection::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);
|
|
|
|
/** Get first selected element in the table
|
|
* This is the upper-left-most selected cell in table,
|
|
* ignoring the order that the user selected them (order in the selection ranges)
|
|
* Assumes cell-selection model where each cell
|
|
* is in a separate range (selection parent node is table row)
|
|
* @param aCell Selected cell or null if ranges don't contain
|
|
* cell selections
|
|
* @param aRowIndex Optional: if not null, return row index of 1st cell
|
|
* @param aColIndex Optional: if not null, return column index of 1st cell
|
|
*
|
|
* Returns the DOM cell element
|
|
* (in C++: returns NS_EDITOR_ELEMENT_NOT_FOUND if an element is not found
|
|
* passes NS_SUCCEEDED macro)
|
|
*/
|
|
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);
|
|
};
|