Struct xpcom::interfaces::nsIAccessibleTable

#[repr(C)]
pub struct nsIAccessibleTable { /* fields omitted */ }

interface nsIAccessibleTable : nsISupports

Methods

impl nsIAccessibleTable

pub fn coerce<T: nsIAccessibleTableCoerce>(&self) -> &T

Cast this nsIAccessibleTable to one of its base interfaces.

impl nsIAccessibleTable

pub unsafe fn GetCaption(&self, aCaption: *mut *const nsIAccessible) -> nsresult

/**
   * Return the caption accessible for the table. For example, html:caption
   * element of html:table element.
   */

readonly attribute nsIAccessible caption;

pub unsafe fn GetSummary(&self, aSummary: &mut nsAString) -> nsresult

/**
   * Return summary description for the table. For example, @summary attribute
   * on html:table element.
   */

readonly attribute AString summary;

pub unsafe fn GetColumnCount(&self, aColumnCount: *mut int32_t) -> nsresult

/**
   * Return columns count in the table.
   */

readonly attribute long columnCount;

pub unsafe fn GetRowCount(&self, aRowCount: *mut int32_t) -> nsresult

/**
   * Return rows count in the table.
   */

readonly attribute long rowCount;

pub unsafe fn GetCellAt(
    &self,
    rowIndex: int32_t,
    columnIndex: int32_t,
    _retval: *mut *const nsIAccessible
) -> nsresult

/**
   * Return the accessible object at the specified row and column in the table.
   * If both row and column index are valid then the corresponding accessible
   * object is returned that represents the requested cell regardless of whether
   * the cell is currently visible (on the screen).
   *
   * @param  rowIndex     [in] the row index to retrieve the cell at
   * @param  columnIndex  [in] the column index to retrieve the cell at
   */

nsIAccessible getCellAt (in long rowIndex, in long columnIndex);

pub unsafe fn GetCellIndexAt(
    &self,
    rowIndex: int32_t,
    columnIndex: int32_t,
    _retval: *mut int32_t
) -> nsresult

/**
   * Translate the given row and column indices into the corresponding cell
   * index.
   *
   * @param  rowIndex    [in] the row index to return cell index at
   * @param  columnIndex [in] the column index to return cell index at
   */

long getCellIndexAt (in long rowIndex, in long columnIndex);

pub unsafe fn GetColumnIndexAt(
    &self,
    cellIndex: int32_t,
    _retval: *mut int32_t
) -> nsresult

/**
   * Translate the given cell index into the corresponding column index.
   *
   * @param  cellIndex  [in] index of the table cell to return column index for
   */

long getColumnIndexAt (in long cellIndex);

pub unsafe fn GetRowIndexAt(
    &self,
    cellIndex: int32_t,
    _retval: *mut int32_t
) -> nsresult

/**
   * Translate the given cell index into the corresponding row index.
   *
   * @param cellIndex  [in] index of the table cell to return row index for
   */

long getRowIndexAt (in long cellIndex);

pub unsafe fn GetRowAndColumnIndicesAt(
    &self,
    cellIndex: int32_t,
    rowIndex: *mut int32_t,
    columnIndex: *mut int32_t
) -> nsresult

/**
   * Translate the given cell index into the corresponding row and column
   * indices.
   *
   * @param cellIndex    [in] cell index to return row and column indices for
   * @param rowIndex     [out] row index at the given cell index
   * @param columnIndex  [out] column index at the given cell index
   */

void getRowAndColumnIndicesAt (in long cellIndex, out long rowIndex, out long columnIndex);

pub unsafe fn GetColumnExtentAt(
    &self,
    row: int32_t,
    column: int32_t,
    _retval: *mut int32_t
) -> nsresult

/**
   * Return the number of columns occupied by the accessible cell at
   * the specified row and column in the table. The result differs from 1 if
   * the specified cell spans multiple columns.
   *
   * @param  row     [in] row index of the cell to return the column extent for
   * @param  column  [in] column index of the cell to return the column extent
   *                  for
   */

long getColumnExtentAt (in long row, in long column);

pub unsafe fn GetRowExtentAt(
    &self,
    row: int32_t,
    column: int32_t,
    _retval: *mut int32_t
) -> nsresult

/**
   * Return the number of rows occupied by the accessible cell at the specified
   * row and column in the table. The result differs from 1 if the specified
   * cell spans multiple rows.
   *
   * @param  row     [in] row index of the cell to return the column extent for
   * @param  column  [in] column index of the cell to return the column extent
   *                  for
   */

long getRowExtentAt (in long row, in long column);

pub unsafe fn GetColumnDescription(
    &self,
    columnIndex: int32_t,
    _retval: &mut nsAString
) -> nsresult

/**
   * Return the description text of the specified column in the table.
   *
   * @param  columnIndex  [in] the column index to retrieve description for
   */

AString getColumnDescription (in long columnIndex);

pub unsafe fn GetRowDescription(
    &self,
    rowIndex: int32_t,
    _retval: &mut nsAString
) -> nsresult

/**
   * Return the description text of the specified row in the table.
   *
   * @param  rowIndex  [in] the row index to retrieve description for
   */

AString getRowDescription (in long rowIndex);

pub unsafe fn IsColumnSelected(
    &self,
    columnIndex: int32_t,
    _retval: *mut bool
) -> nsresult

/**
   * Return a boolean value indicating whether the specified column is
   * selected, i.e. all cells within the column are selected.
   *
   * @param  columnIndex  [in] the column index to determine if it's selected
   */

boolean isColumnSelected (in long columnIndex);

pub unsafe fn IsRowSelected(
    &self,
    rowIndex: int32_t,
    _retval: *mut bool
) -> nsresult

/**
   * Return a boolean value indicating whether the specified row is selected,
   * i.e. all cells within the row are selected.
   *
   * @param  rowIndex  [in] the row index to determine whether it's selected
   */

boolean isRowSelected (in long rowIndex);

pub unsafe fn IsCellSelected(
    &self,
    rowIndex: int32_t,
    columnIndex: int32_t,
    _retval: *mut bool
) -> nsresult

/**
   * Return a boolean value indicating whether the specified cell is selected.
   *
   * @param  rowIndex     [in] the row index of the cell
   * @param  columnIndex  [in] the column index of the cell
   */

boolean isCellSelected (in long rowIndex, in long columnIndex);

pub unsafe fn GetSelectedCellCount(
    &self,
    aSelectedCellCount: *mut uint32_t
) -> nsresult

/**
   * Return the total number of selected cells.
   */

readonly attribute unsigned long selectedCellCount;

pub unsafe fn GetSelectedColumnCount(
    &self,
    aSelectedColumnCount: *mut uint32_t
) -> nsresult

/**
   * Return the total number of selected columns.
   */

readonly attribute unsigned long selectedColumnCount;

pub unsafe fn GetSelectedRowCount(
    &self,
    aSelectedRowCount: *mut uint32_t
) -> nsresult

/**
   * Return the total number of selected rows.
   */

readonly attribute unsigned long selectedRowCount;

pub unsafe fn GetSelectedCells(
    &self,
    aSelectedCells: *mut *const nsIArray
) -> nsresult

/**
   * Return an array of selected cells.
   */

readonly attribute nsIArray selectedCells;

pub unsafe fn GetSelectedCellIndices(
    &self,
    cellsArraySize: *mut uint32_t,
    cellsArray: *mut *mut int32_t
) -> nsresult

/**
   * Return an array of cell indices currently selected.
   *
   * @param  cellsArraySize  [in] length of array
   * @param  cellsArray      [in] array of indexes of selected cells
   */

void getSelectedCellIndices (out unsigned long cellsArraySize, [array, size_is (cellsArraySize), retval] out long cellsArray);

pub unsafe fn GetSelectedColumnIndices(
    &self,
    columnsArraySize: *mut uint32_t,
    columnsArray: *mut *mut int32_t
) -> nsresult

/**
   * Return an array of column indices currently selected.
   *
   * @param  columnsArraySize  [in] length of array
   * @param  columnsArray      [in] array of indices of selected columns
   */

void getSelectedColumnIndices (out unsigned long columnsArraySize, [array, size_is (columnsArraySize), retval] out long columnsArray);

pub unsafe fn GetSelectedRowIndices(
    &self,
    rowsArraySize: *mut uint32_t,
    rowsArray: *mut *mut int32_t
) -> nsresult

/**
   * Return an array of row indices currently selected.
   *
   * @param  rowsArraySize  [in] Length of array
   * @param  rowsArray      [in] array of indices of selected rows
   */

void getSelectedRowIndices (out unsigned long rowsArraySize, [array, size_is (rowsArraySize), retval] out long rowsArray);

pub unsafe fn SelectRow(&self, rowIndex: int32_t) -> nsresult

/**
   * Select a row and unselects all previously selected rows.
   *
   * @param  rowIndex  [in] the row index to select
   */

void selectRow (in long rowIndex);

pub unsafe fn SelectColumn(&self, columnIndex: int32_t) -> nsresult

/**
   * Select a column and unselects all previously selected columns.
   *
   * @param  columnIndex  [in] the column index to select
   */

void selectColumn (in long columnIndex);

pub unsafe fn UnselectRow(&self, rowIndex: int32_t) -> nsresult

/**
   * Unselect the given row, leaving other selected rows selected (if any).
   *
   * @param  rowIndex  [in] the row index to select
  */

void unselectRow (in long rowIndex);

pub unsafe fn UnselectColumn(&self, columnIndex: int32_t) -> nsresult

/**
   * Unselect the given column, leaving other selected columns selected (if any).
   *
   * @param  columnIndex  [in] the column index to select
   */

void unselectColumn (in long columnIndex);

pub unsafe fn IsProbablyForLayout(&self, _retval: *mut bool) -> nsresult

/**
   * Use heuristics to determine if table is most likely used for layout.
   */

boolean isProbablyForLayout ();

Methods from Deref<Target = nsISupports>

pub fn coerce<T: nsISupportsCoerce>(&self) -> &T

Cast this nsISupports to one of its base interfaces.

pub unsafe fn QueryInterface(
    &self,
    uuid: &nsIID,
    result: *mut *mut c_void
) -> nsresult

void QueryInterface (in nsIIDRef uuid, [iid_is (uuid), retval] out nsQIResult result);

pub unsafe fn AddRef(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt AddRef ();

pub unsafe fn Release(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt Release ();

Trait Implementations

impl XpCom for nsIAccessibleTable

const IID: nsIID

IID: nsIID = nsID(3406559161, 4478, 16610, [158, 70, 24, 156, 61, 67, 206, 74])

fn query_interface<T: XpCom>(&self) -> Option<RefPtr<T>>

Perform a QueryInterface call on this object, attempting to dynamically cast it to the requested interface type. Returns Some(RefPtr) if the cast succeeded, and None otherwise.

impl RefCounted for nsIAccessibleTable

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIAccessibleTable

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.