Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-17 23:35:34 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 765512 - decomtaminate GetSelected (Cell / Column / Row) Indices() on accessible tables, r=tbsaunde

Browse Source
This commit is contained in:
Mark Capella 2012-06-23 18:34:44 -04:00
parent 0cac5c86e4
commit 0f515c37e2
11 changed files with 270 additions and 509 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

221
accessible/src/generic/ARIAGridAccessible.cpp
View File

@ -248,9 +248,35 @@ ARIAGridAccessible::SelectedCellCount()
PRUint32
ARIAGridAccessible::SelectedColCount()
{
PRUint32 colCount = 0;
GetSelectedColumnsArray(&colCount);
return colCount;
PRUint32 colCount = ColCount();
if (!colCount)
return 0;
AccIterator rowIter(this, filters::GetRow);
Accessible* row = rowIter.Next();
if (!row)
return 0;
nsTArray<bool> isColSelArray(colCount);
isColSelArray.AppendElements(colCount);
memset(isColSelArray.Elements(), true, colCount * sizeof(bool));
PRUint32 selColCount = colCount;
do {
if (nsAccUtils::IsARIASelected(row))
continue;
AccIterator cellIter(row, filters::GetCell);
Accessible* cell = nsnull;
for (PRUint32 colIdx = 0;
(cell = cellIter.Next()) && colIdx < colCount; colIdx++)
if (isColSelArray[colIdx] && !nsAccUtils::IsARIASelected(cell)) {
isColSelArray[colIdx] = false;
selColCount--;
}
} while ((row = rowIter.Next()));
return selColCount;
}
PRUint32
@ -325,92 +351,72 @@ ARIAGridAccessible::GetSelectedCells(nsIArray** aCells)
return NS_OK;
}
NS_IMETHODIMP
ARIAGridAccessible::GetSelectedCellIndices(PRUint32* aCellsCount,
PRInt32** aCells)
void
ARIAGridAccessible::SelectedCellIndices(nsTArray<PRUint32>* aCells)
{
NS_ENSURE_ARG_POINTER(aCellsCount);
*aCellsCount = 0;
NS_ENSURE_ARG_POINTER(aCells);
*aCells = nsnull;
if (IsDefunct())
return NS_ERROR_FAILURE;
PRInt32 rowCount = 0;
GetRowCount(&rowCount);
PRInt32 colCount = 0;
GetColumnCount(&colCount);
nsTArray<PRInt32> selCells(rowCount * colCount);
PRUint32 rowCount = RowCount(), colCount = ColCount();
AccIterator rowIter(this, filters::GetRow);
Accessible* row = nsnull;
for (PRInt32 rowIdx = 0; (row = rowIter.Next()); rowIdx++) {
for (PRUint32 rowIdx = 0; (row = rowIter.Next()); rowIdx++) {
if (nsAccUtils::IsARIASelected(row)) {
for (PRInt32 colIdx = 0; colIdx < colCount; colIdx++)
selCells.AppendElement(rowIdx * colCount + colIdx);
for (PRUint32 colIdx = 0; colIdx < colCount; colIdx++)
aCells->AppendElement(rowIdx * colCount + colIdx);
continue;
}
AccIterator cellIter(row, filters::GetCell);
Accessible* cell = nsnull;
for (PRInt32 colIdx = 0; (cell = cellIter.Next()); colIdx++) {
for (PRUint32 colIdx = 0; (cell = cellIter.Next()); colIdx++) {
if (nsAccUtils::IsARIASelected(cell))
selCells.AppendElement(rowIdx * colCount + colIdx);
aCells->AppendElement(rowIdx * colCount + colIdx);
}
}
PRUint32 selCellsCount = selCells.Length();
if (!selCellsCount)
return NS_OK;
*aCells = static_cast<PRInt32*>(
nsMemory::Clone(selCells.Elements(), selCellsCount * sizeof(PRInt32)));
NS_ENSURE_TRUE(*aCells, NS_ERROR_OUT_OF_MEMORY);
*aCellsCount = selCellsCount;
return NS_OK;
}
NS_IMETHODIMP
ARIAGridAccessible::GetSelectedColumnIndices(PRUint32* aColumnCount,
PRInt32** aColumns)
void
ARIAGridAccessible::SelectedColIndices(nsTArray<PRUint32>* aCols)
{
NS_ENSURE_ARG_POINTER(aColumns);
return GetSelectedColumnsArray(aColumnCount, aColumns);
}
NS_IMETHODIMP
ARIAGridAccessible::GetSelectedRowIndices(PRUint32* aRowCount,
PRInt32** aRows)
{
NS_ENSURE_ARG_POINTER(aRowCount);
*aRowCount = 0;
NS_ENSURE_ARG_POINTER(aRows);
*aRows = nsnull;
if (IsDefunct())
return NS_ERROR_FAILURE;
PRInt32 rowCount = 0;
GetRowCount(&rowCount);
if (!rowCount)
return NS_OK;
nsTArray<PRInt32> selRows(rowCount);
PRUint32 colCount = ColCount();
if (!colCount)
return;
AccIterator rowIter(this, filters::GetRow);
Accessible* row = rowIter.Next();
if (!row)
return;
nsTArray<bool> isColSelArray(colCount);
isColSelArray.AppendElements(colCount);
memset(isColSelArray.Elements(), true, colCount * sizeof(bool));
do {
if (nsAccUtils::IsARIASelected(row))
continue;
AccIterator cellIter(row, filters::GetCell);
Accessible* cell = nsnull;
for (PRUint32 colIdx = 0;
(cell = cellIter.Next()) && colIdx < colCount; colIdx++)
if (isColSelArray[colIdx] && !nsAccUtils::IsARIASelected(cell)) {
isColSelArray[colIdx] = false;
}
} while ((row = rowIter.Next()));
for (PRUint32 colIdx = 0; colIdx < colCount; colIdx++)
if (isColSelArray[colIdx])
aCols->AppendElement(colIdx);
}
void
ARIAGridAccessible::SelectedRowIndices(nsTArray<PRUint32>* aRows)
{
AccIterator rowIter(this, filters::GetRow);
Accessible* row = nsnull;
for (PRInt32 rowIdx = 0; (row = rowIter.Next()); rowIdx++) {
for (PRUint32 rowIdx = 0; (row = rowIter.Next()); rowIdx++) {
if (nsAccUtils::IsARIASelected(row)) {
selRows.AppendElement(rowIdx);
aRows->AppendElement(rowIdx);
continue;
}
@ -428,19 +434,8 @@ ARIAGridAccessible::GetSelectedRowIndices(PRUint32* aRowCount,
} while ((cell = cellIter.Next()));
if (isRowSelected)
selRows.AppendElement(rowIdx);
aRows->AppendElement(rowIdx);
}
PRUint32 selrowCount = selRows.Length();
if (!selrowCount)
return NS_OK;
*aRows = static_cast<PRInt32*>(
nsMemory::Clone(selRows.Elements(), selrowCount * sizeof(PRInt32)));
NS_ENSURE_TRUE(*aRows, NS_ERROR_OUT_OF_MEMORY);
*aRowCount = selrowCount;
return NS_OK;
}
void
@ -615,74 +610,6 @@ ARIAGridAccessible::SetARIASelected(Accessible* aAccessible,
return NS_OK;
}
nsresult
ARIAGridAccessible::GetSelectedColumnsArray(PRUint32* aColumnCount,
PRInt32** aColumns)
{
NS_ENSURE_ARG_POINTER(aColumnCount);
*aColumnCount = 0;
if (aColumns)
*aColumns = nsnull;
if (IsDefunct())
return NS_ERROR_FAILURE;
AccIterator rowIter(this, filters::GetRow);
Accessible* row = rowIter.Next();
if (!row)
return NS_OK;
PRInt32 colCount = 0;
GetColumnCount(&colCount);
if (!colCount)
return NS_OK;
PRInt32 selColCount = colCount;
nsTArray<bool> isColSelArray(selColCount);
isColSelArray.AppendElements(selColCount);
for (PRInt32 i = 0; i < selColCount; i++)
isColSelArray[i] = true;
do {
if (nsAccUtils::IsARIASelected(row))
continue;
PRInt32 colIdx = 0;
AccIterator cellIter(row, filters::GetCell);
Accessible* cell = nsnull;
for (colIdx = 0; (cell = cellIter.Next()); colIdx++) {
if (isColSelArray.SafeElementAt(colIdx, false) &&
!nsAccUtils::IsARIASelected(cell)) {
isColSelArray[colIdx] = false;
selColCount--;
}
}
} while ((row = rowIter.Next()));
if (!selColCount)
return NS_OK;
if (!aColumns) {
*aColumnCount = selColCount;
return NS_OK;
}
*aColumns = static_cast<PRInt32*>(
nsMemory::Alloc(selColCount * sizeof(PRInt32)));
NS_ENSURE_TRUE(*aColumns, NS_ERROR_OUT_OF_MEMORY);
*aColumnCount = selColCount;
for (PRInt32 colIdx = 0, idx = 0; colIdx < colCount; colIdx++) {
if (isColSelArray[colIdx])
(*aColumns)[idx++] = colIdx;
}
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
// ARIAGridCellAccessible
////////////////////////////////////////////////////////////////////////////////

9
accessible/src/generic/ARIAGridAccessible.h
View File

@ -48,6 +48,9 @@ public:
virtual PRUint32 SelectedCellCount();
virtual PRUint32 SelectedColCount();
virtual PRUint32 SelectedRowCount();
virtual void SelectedCellIndices(nsTArray<PRUint32>* aCells);
virtual void SelectedColIndices(nsTArray<PRUint32>* aCols);
virtual void SelectedRowIndices(nsTArray<PRUint32>* aRows);
virtual void SelectCol(PRUint32 aColIdx);
virtual void SelectRow(PRUint32 aRowIdx);
virtual void UnselectCol(PRUint32 aColIdx);
@ -84,12 +87,6 @@ protected:
*/
nsresult SetARIASelected(Accessible* aAccessible, bool aIsSelected,
bool aNotify = true);
/**
* Helper method for GetSelectedColumnCount and GetSelectedColumns.
*/
nsresult GetSelectedColumnsArray(PRUint32 *acolumnCount,
PRInt32 **aColumns = nsnull);
};

9
accessible/src/generic/TableAccessible.h
View File

@ -129,15 +129,20 @@ public:
*/
virtual void SelectedCells(nsTArray<Accessible*>* aCells) {}
/**
* Get the set of selected cell indices.
*/
virtual void SelectedCellIndices(nsTArray<PRUint32>* aCells) = 0;
/**
* Get the set of selected column indices.
*/
virtual void SelectedColIndices(nsTArray<PRUint32>* aCols) {}
virtual void SelectedColIndices(nsTArray<PRUint32>* aCols) = 0;
/**
* Get the set of selected row indices.
*/
virtual void SelectedRowIndices(nsTArray<PRUint32>* aRows) {}
virtual void SelectedRowIndices(nsTArray<PRUint32>* aRows) = 0;
/**
* Select the given column unselecting any other selected columns.

164
accessible/src/html/HTMLTableAccessible.cpp
View File

@ -660,158 +660,52 @@ HTMLTableAccessible::GetSelectedCells(nsIArray** aCells)
return NS_OK;
}
NS_IMETHODIMP
HTMLTableAccessible::GetSelectedCellIndices(PRUint32* aNumCells,
PRInt32** aCells)
void
HTMLTableAccessible::SelectedCellIndices(nsTArray<PRUint32>* aCells)
{
NS_ENSURE_ARG_POINTER(aNumCells);
*aNumCells = 0;
NS_ENSURE_ARG_POINTER(aCells);
*aCells = nsnull;
PRInt32 rowCount = 0;
nsresult rv = GetRowCount(&rowCount);
NS_ENSURE_SUCCESS(rv, rv);
PRInt32 columnCount = 0;
rv = GetColumnCount(&columnCount);
NS_ENSURE_SUCCESS(rv, rv);
nsITableLayout *tableLayout = GetTableLayout();
NS_ENSURE_STATE(tableLayout);
if (!tableLayout)
return;
PRUint32 rowCount = RowCount(), colCount = ColCount();
nsCOMPtr<nsIDOMElement> domElement;
PRInt32 startRowIndex = 0, startColIndex = 0,
rowSpan, colSpan, actualRowSpan, actualColSpan;
bool isSelected = false;
PRInt32 cellsCount = columnCount * rowCount;
nsAutoArrayPtr<bool> states(new bool[cellsCount]);
NS_ENSURE_TRUE(states, NS_ERROR_OUT_OF_MEMORY);
for (PRUint32 rowIdx = 0; rowIdx < rowCount; rowIdx++) {
for (PRUint32 colIdx = 0; colIdx < colCount; colIdx++) {
nsresult rv = tableLayout->GetCellDataAt(rowIdx, colIdx,
*getter_AddRefs(domElement),
startRowIndex, startColIndex,
rowSpan, colSpan,
actualRowSpan, actualColSpan,
isSelected);
PRInt32 rowIndex, index;
for (rowIndex = 0, index = 0; rowIndex < rowCount; rowIndex++) {
PRInt32 columnIndex;
for (columnIndex = 0; columnIndex < columnCount; columnIndex++, index++) {
rv = tableLayout->GetCellDataAt(rowIndex, columnIndex,
*getter_AddRefs(domElement),
startRowIndex, startColIndex,
rowSpan, colSpan,
actualRowSpan, actualColSpan,
isSelected);
if (NS_SUCCEEDED(rv) && startRowIndex == rowIndex &&
startColIndex == columnIndex && isSelected) {
states[index] = true;
(*aNumCells)++;
} else {
states[index] = false;
}
if (NS_SUCCEEDED(rv) && startRowIndex == rowIdx &&
startColIndex == colIdx && isSelected)
aCells->AppendElement(CellIndexAt(rowIdx, colIdx));
}
}
PRInt32 *cellsArray =
static_cast<PRInt32*>(nsMemory::Alloc((*aNumCells) * sizeof(PRInt32)));
NS_ENSURE_TRUE(cellsArray, NS_ERROR_OUT_OF_MEMORY);
PRInt32 curr = 0;
for (rowIndex = 0, index = 0; rowIndex < rowCount; rowIndex++) {
PRInt32 columnIndex;
for (columnIndex = 0; columnIndex < columnCount; columnIndex++, index++) {
if (states[index]) {
PRInt32 cellIndex = -1;
GetCellIndexAt(rowIndex, columnIndex, &cellIndex);
cellsArray[curr++] = cellIndex;
}
}
}
*aCells = cellsArray;
return NS_OK;
}
NS_IMETHODIMP
HTMLTableAccessible::GetSelectedColumnIndices(PRUint32* aNumColumns,
PRInt32** aColumns)
void
HTMLTableAccessible::SelectedColIndices(nsTArray<PRUint32>* aCols)
{
nsresult rv = NS_OK;
PRInt32 columnCount;
rv = GetColumnCount(&columnCount);
NS_ENSURE_SUCCESS(rv, rv);
bool *states = new bool[columnCount];
NS_ENSURE_TRUE(states, NS_ERROR_OUT_OF_MEMORY);
*aNumColumns = 0;
PRInt32 index;
for (index = 0; index < columnCount; index++) {
rv = IsColumnSelected(index, &states[index]);
NS_ENSURE_SUCCESS(rv, rv);
if (states[index]) {
(*aNumColumns)++;
}
}
PRInt32 *outArray = (PRInt32 *)nsMemory::Alloc((*aNumColumns) * sizeof(PRInt32));
if (!outArray) {
delete []states;
return NS_ERROR_OUT_OF_MEMORY;
}
PRInt32 curr = 0;
for (index = 0; index < columnCount; index++) {
if (states[index]) {
outArray[curr++] = index;
}
}
delete []states;
*aColumns = outArray;
return rv;
PRUint32 colCount = ColCount();
for (PRUint32 colIdx = 0; colIdx < colCount; colIdx++)
if (IsColSelected(colIdx))
aCols->AppendElement(colIdx);
}
NS_IMETHODIMP
HTMLTableAccessible::GetSelectedRowIndices(PRUint32* aNumRows,
PRInt32** aRows)
void
HTMLTableAccessible::SelectedRowIndices(nsTArray<PRUint32>* aRows)
{
nsresult rv = NS_OK;
PRInt32 rowCount;
rv = GetRowCount(&rowCount);
NS_ENSURE_SUCCESS(rv, rv);
bool *states = new bool[rowCount];
NS_ENSURE_TRUE(states, NS_ERROR_OUT_OF_MEMORY);
*aNumRows = 0;
PRInt32 index;
for (index = 0; index < rowCount; index++) {
rv = IsRowSelected(index, &states[index]);
NS_ENSURE_SUCCESS(rv, rv);
if (states[index]) {
(*aNumRows)++;
}
}
PRInt32 *outArray = (PRInt32 *)nsMemory::Alloc((*aNumRows) * sizeof(PRInt32));
if (!outArray) {
delete []states;
return NS_ERROR_OUT_OF_MEMORY;
}
PRInt32 curr = 0;
for (index = 0; index < rowCount; index++) {
if (states[index]) {
outArray[curr++] = index;
}
}
delete []states;
*aRows = outArray;
return rv;
PRUint32 rowCount = RowCount();
for (PRUint32 rowIdx = 0; rowIdx < rowCount; rowIdx++)
if (IsRowSelected(rowIdx))
aRows->AppendElement(rowIdx);
}
Accessible*

3
accessible/src/html/HTMLTableAccessible.h
View File

@ -112,6 +112,9 @@ public:
virtual PRUint32 SelectedCellCount();
virtual PRUint32 SelectedColCount();
virtual PRUint32 SelectedRowCount();
virtual void SelectedCellIndices(nsTArray<PRUint32>* aCells);
virtual void SelectedColIndices(nsTArray<PRUint32>* aCols);
virtual void SelectedRowIndices(nsTArray<PRUint32>* aRows);
virtual void SelectCol(PRUint32 aColIdx);
virtual void SelectRow(PRUint32 aRowIdx);
virtual void UnselectCol(PRUint32 aColIdx);

81
accessible/src/xpcom/xpcAccessibleTable.cpp
View File

@ -9,6 +9,8 @@
#include "Accessible.h"
#include "TableAccessible.h"
static const PRUint32 XPC_TABLE_DEFAULT_SIZE = 40;
nsresult
xpcAccessibleTable::GetCaption(nsIAccessible** aCaption)
{
@ -241,6 +243,81 @@ xpcAccessibleTable::GetSelectedRowCount(PRUint32* aSelectedRowCount)
return NS_OK;
}
nsresult
xpcAccessibleTable::GetSelectedCellIndices(PRUint32* aCellsArraySize,
PRInt32** aCellsArray)
{
NS_ENSURE_ARG_POINTER(aCellsArraySize);
*aCellsArraySize = 0;
NS_ENSURE_ARG_POINTER(aCellsArray);
*aCellsArray = 0;
if (!mTable)
return NS_ERROR_FAILURE;
nsAutoTArray<PRUint32, XPC_TABLE_DEFAULT_SIZE> cellsArray;
mTable->SelectedCellIndices(&cellsArray);
*aCellsArraySize = cellsArray.Length();
*aCellsArray = static_cast<PRInt32*>
(moz_xmalloc(*aCellsArraySize * sizeof(PRInt32)));
memcpy(*aCellsArray, cellsArray.Elements(),
*aCellsArraySize * sizeof(PRInt32));
return NS_OK;
}
nsresult
xpcAccessibleTable::GetSelectedColumnIndices(PRUint32* aColsArraySize,
PRInt32** aColsArray)
{
NS_ENSURE_ARG_POINTER(aColsArraySize);
*aColsArraySize = 0;
NS_ENSURE_ARG_POINTER(aColsArray);
*aColsArray = 0;
if (!mTable)
return NS_ERROR_FAILURE;
nsAutoTArray<PRUint32, XPC_TABLE_DEFAULT_SIZE> colsArray;
mTable->SelectedColIndices(&colsArray);
*aColsArraySize = colsArray.Length();
*aColsArray = static_cast<PRInt32*>
(moz_xmalloc(*aColsArraySize * sizeof(PRInt32)));
memcpy(*aColsArray, colsArray.Elements(),
*aColsArraySize * sizeof(PRInt32));
return NS_OK;
}
nsresult
xpcAccessibleTable::GetSelectedRowIndices(PRUint32* aRowsArraySize,
PRInt32** aRowsArray)
{
NS_ENSURE_ARG_POINTER(aRowsArraySize);
*aRowsArraySize = 0;
NS_ENSURE_ARG_POINTER(aRowsArray);
*aRowsArray = 0;
if (!mTable)
return NS_ERROR_FAILURE;
nsAutoTArray<PRUint32, XPC_TABLE_DEFAULT_SIZE> rowsArray;
mTable->SelectedRowIndices(&rowsArray);
*aRowsArraySize = rowsArray.Length();
*aRowsArray = static_cast<PRInt32*>
(moz_xmalloc(*aRowsArraySize * sizeof(PRInt32)));
memcpy(*aRowsArray, rowsArray.Elements(),
*aRowsArraySize * sizeof(PRInt32));
return NS_OK;
}
nsresult
xpcAccessibleTable::GetSummary(nsAString& aSummary)
{
@ -298,7 +375,7 @@ xpcAccessibleTable::UnselectColumn(PRInt32 aColIdx)
if (!mTable)
return NS_ERROR_FAILURE;
if (aColIdx < 0 || aColIdx >= mTable->ColCount())
if (aColIdx < 0 || static_cast<PRUint32>(aColIdx) >= mTable->ColCount())
return NS_ERROR_INVALID_ARG;
mTable->UnselectCol(aColIdx);
@ -311,7 +388,7 @@ xpcAccessibleTable::UnselectRow(PRInt32 aRowIdx)
if (!mTable)
return NS_ERROR_FAILURE;
if (aRowIdx < 0 || aRowIdx >= mTable->RowCount())
if (aRowIdx < 0 || static_cast<PRUint32>(aRowIdx) >= mTable->RowCount())
return NS_ERROR_INVALID_ARG;
mTable->UnselectRow(aRowIdx);

18
accessible/src/xpcom/xpcAccessibleTable.h
View File

@ -42,6 +42,12 @@ public:
nsresult GetSelectedCellCount(PRUint32* aSelectedCellCount);
nsresult GetSelectedColumnCount(PRUint32* aSelectedColumnCount);
nsresult GetSelectedRowCount(PRUint32* aSelectedRowCount);
nsresult GetSelectedCellIndices(PRUint32* aCellsArraySize,
PRInt32** aCellsArray);
nsresult GetSelectedColumnIndices(PRUint32* aColsArraySize,
PRInt32** aColsArray);
nsresult GetSelectedRowIndices(PRUint32* aRowsArraySize,
PRInt32** aRowsArray);
nsresult SelectColumn(PRInt32 aColIdx);
nsresult SelectRow(PRInt32 aRowIdx);
nsresult UnselectColumn(PRInt32 aColIdx);
@ -89,9 +95,15 @@ protected:
NS_SCRIPTABLE NS_IMETHOD GetSelectedRowCount(PRUint32* aSelectedRowCount) \
{ return xpcAccessibleTable::GetSelectedRowCount(aSelectedRowCount); } \
NS_SCRIPTABLE NS_IMETHOD GetSelectedCells(nsIArray * *aSelectedCells); \
NS_SCRIPTABLE NS_IMETHOD GetSelectedCellIndices(PRUint32 *cellsArraySize NS_OUTPARAM, PRInt32 **cellsArray NS_OUTPARAM); \
NS_SCRIPTABLE NS_IMETHOD GetSelectedColumnIndices(PRUint32 *rowsArraySize NS_OUTPARAM, PRInt32 **rowsArray NS_OUTPARAM); \
NS_SCRIPTABLE NS_IMETHOD GetSelectedRowIndices(PRUint32 *rowsArraySize NS_OUTPARAM, PRInt32 **rowsArray NS_OUTPARAM); \
NS_SCRIPTABLE NS_IMETHOD GetSelectedCellIndices(PRUint32* cellsArraySize NS_OUTPARAM, \
PRInt32** cellsArray NS_OUTPARAM) \
{ return xpcAccessibleTable::GetSelectedCellIndices(cellsArraySize, cellsArray); } \
NS_SCRIPTABLE NS_IMETHOD GetSelectedColumnIndices(PRUint32* colsArraySize NS_OUTPARAM, \
PRInt32** colsArray NS_OUTPARAM) \
{ return xpcAccessibleTable::GetSelectedColumnIndices(colsArraySize, colsArray); } \
NS_SCRIPTABLE NS_IMETHOD GetSelectedRowIndices(PRUint32* rowsArraySize NS_OUTPARAM, \
PRInt32** rowsArray NS_OUTPARAM) \
{ return xpcAccessibleTable::GetSelectedRowIndices(rowsArraySize, rowsArray); } \
NS_SCRIPTABLE NS_IMETHOD SelectRow(PRInt32 aRowIdx) \
{ return xpcAccessibleTable::SelectRow(aRowIdx); } \
NS_SCRIPTABLE NS_IMETHOD SelectColumn(PRInt32 aColIdx) \

126
accessible/src/xul/XULListboxAccessible.cpp
View File

@ -454,18 +454,9 @@ XULListboxAccessible::GetSelectedCells(nsIArray** aCells)
return NS_OK;
}
NS_IMETHODIMP
XULListboxAccessible::GetSelectedCellIndices(PRUint32* aNumCells,
PRInt32** aCells)
void
XULListboxAccessible::SelectedCellIndices(nsTArray<PRUint32>* aCells)
{
NS_ENSURE_ARG_POINTER(aNumCells);
*aNumCells = 0;
NS_ENSURE_ARG_POINTER(aCells);
*aCells = nsnull;
if (IsDefunct())
return NS_ERROR_FAILURE;
nsCOMPtr<nsIDOMXULMultiSelectControlElement> control =
do_QueryInterface(mContent);
NS_ASSERTION(control,
@ -474,91 +465,47 @@ XULListboxAccessible::GetSelectedCellIndices(PRUint32* aNumCells,
nsCOMPtr<nsIDOMNodeList> selectedItems;
control->GetSelectedItems(getter_AddRefs(selectedItems));
if (!selectedItems)
return NS_OK;
return;
PRUint32 selectedItemsCount = 0;
nsresult rv = selectedItems->GetLength(&selectedItemsCount);
NS_ENSURE_SUCCESS(rv, rv);
NS_ASSERTION(NS_SUCCEEDED(rv), "GetLength() Shouldn't fail!");
PRInt32 columnCount = 0;
rv = GetColumnCount(&columnCount);
NS_ENSURE_SUCCESS(rv, rv);
PRUint32 colCount = ColCount();
aCells->SetCapacity(selectedItemsCount * colCount);
aCells->AppendElements(selectedItemsCount * colCount);
PRUint32 cellsCount = selectedItemsCount * columnCount;
for (PRUint32 selItemsIdx = 0, cellsIdx = 0;
selItemsIdx < selectedItemsCount; selItemsIdx++) {
PRInt32 *cellsIdxArray =
static_cast<PRInt32*>(nsMemory::Alloc((cellsCount) * sizeof(PRInt32)));
NS_ENSURE_TRUE(cellsIdxArray, NS_ERROR_OUT_OF_MEMORY);
PRUint32 index = 0, cellsIdx = 0;
for (; index < selectedItemsCount; index++) {
nsCOMPtr<nsIDOMNode> itemNode;
selectedItems->Item(index, getter_AddRefs(itemNode));
selectedItems->Item(selItemsIdx, getter_AddRefs(itemNode));
nsCOMPtr<nsIDOMXULSelectControlItemElement> item =
do_QueryInterface(itemNode);
if (item) {
PRInt32 itemIdx = -1;
control->GetIndexOfItem(item, &itemIdx);
if (itemIdx != -1) {
PRInt32 colIdx = 0;
for (; colIdx < columnCount; colIdx++)
cellsIdxArray[cellsIdx++] = itemIdx * columnCount + colIdx;
}
if (itemIdx >= 0)
for (PRUint32 colIdx = 0; colIdx < colCount; colIdx++, cellsIdx++)
aCells->ElementAt(cellsIdx) = itemIdx * colCount + colIdx;
}
}
*aNumCells = cellsCount;
*aCells = cellsIdxArray;
return NS_OK;
}
NS_IMETHODIMP
XULListboxAccessible::GetSelectedColumnIndices(PRUint32* aNumColumns,
PRInt32** aColumns)
void
XULListboxAccessible::SelectedColIndices(nsTArray<PRUint32>* aCols)
{
NS_ENSURE_ARG_POINTER(aNumColumns);
*aNumColumns = 0;
NS_ENSURE_ARG_POINTER(aColumns);
*aColumns = nsnull;
PRUint32 selColCount = SelectedColCount();
aCols->SetCapacity(selColCount);
if (IsDefunct())
return NS_ERROR_FAILURE;
PRUint32 columnCount = 0;
nsresult rv = GetSelectedColumnCount(&columnCount);
NS_ENSURE_SUCCESS(rv, rv);
if (!columnCount)
return NS_OK;
PRInt32 *colsIdxArray =
static_cast<PRInt32*>(nsMemory::Alloc((columnCount) * sizeof(PRInt32)));
NS_ENSURE_TRUE(colsIdxArray, NS_ERROR_OUT_OF_MEMORY);
PRUint32 colIdx = 0;
for (; colIdx < columnCount; colIdx++)
colsIdxArray[colIdx] = colIdx;
*aNumColumns = columnCount;
*aColumns = colsIdxArray;
return NS_OK;
for (PRUint32 colIdx = 0; colIdx < selColCount; colIdx++)
aCols->AppendElement(colIdx);
}
NS_IMETHODIMP
XULListboxAccessible::GetSelectedRowIndices(PRUint32* aNumRows,
PRInt32** aRows)
void
XULListboxAccessible::SelectedRowIndices(nsTArray<PRUint32>* aRows)
{
NS_ENSURE_ARG_POINTER(aNumRows);
*aNumRows = 0;
NS_ENSURE_ARG_POINTER(aRows);
*aRows = nsnull;
if (IsDefunct())
return NS_ERROR_FAILURE;
nsCOMPtr<nsIDOMXULMultiSelectControlElement> control =
do_QueryInterface(mContent);
NS_ASSERTION(control,
@ -567,38 +514,31 @@ XULListboxAccessible::GetSelectedRowIndices(PRUint32* aNumRows,
nsCOMPtr<nsIDOMNodeList> selectedItems;
control->GetSelectedItems(getter_AddRefs(selectedItems));
if (!selectedItems)
return NS_OK;
return;
PRUint32 selectedItemsCount = 0;
nsresult rv = selectedItems->GetLength(&selectedItemsCount);
NS_ENSURE_SUCCESS(rv, rv);
PRUint32 rowCount = 0;
nsresult rv = selectedItems->GetLength(&rowCount);
NS_ASSERTION(NS_SUCCEEDED(rv), "GetLength() Shouldn't fail!");
if (!selectedItemsCount)
return NS_OK;
if (!rowCount)
return;
PRInt32 *rowsIdxArray =
static_cast<PRInt32*>(nsMemory::Alloc((selectedItemsCount) * sizeof(PRInt32)));
NS_ENSURE_TRUE(rowsIdxArray, NS_ERROR_OUT_OF_MEMORY);
aRows->SetCapacity(rowCount);
aRows->AppendElements(rowCount);
PRUint32 index = 0;
for (; index < selectedItemsCount; index++) {
for (PRUint32 rowIdx = 0; rowIdx < rowCount; rowIdx++) {
nsCOMPtr<nsIDOMNode> itemNode;
selectedItems->Item(index, getter_AddRefs(itemNode));
selectedItems->Item(rowIdx, getter_AddRefs(itemNode));
nsCOMPtr<nsIDOMXULSelectControlItemElement> item =
do_QueryInterface(itemNode);
if (item) {
PRInt32 itemIdx = -1;
control->GetIndexOfItem(item, &itemIdx);
if (itemIdx != -1)
rowsIdxArray[index] = itemIdx;
if (itemIdx >= 0)
aRows->ElementAt(rowIdx) = itemIdx;
}
}
*aNumRows = selectedItemsCount;
*aRows = rowsIdxArray;
return NS_OK;
}
void

3
accessible/src/xul/XULListboxAccessible.h
View File

@ -82,6 +82,9 @@ public:
virtual PRUint32 SelectedCellCount();
virtual PRUint32 SelectedColCount();
virtual PRUint32 SelectedRowCount();
virtual void SelectedCellIndices(nsTArray<PRUint32>* aCells);
virtual void SelectedColIndices(nsTArray<PRUint32>* aCols);
virtual void SelectedRowIndices(nsTArray<PRUint32>* aRows);
virtual void SelectRow(PRUint32 aRowIdx);
virtual void UnselectRow(PRUint32 aRowIdx);

142
accessible/src/xul/XULTreeGridAccessible.cpp
View File

@ -129,136 +129,36 @@ XULTreeGridAccessible::GetSelectedCells(nsIArray** aCells)
return NS_OK;
}
NS_IMETHODIMP
XULTreeGridAccessible::GetSelectedCellIndices(PRUint32* aCellsCount,
PRInt32** aCells)
void
XULTreeGridAccessible::SelectedCellIndices(nsTArray<PRUint32>* aCells)
{
NS_ENSURE_ARG_POINTER(aCellsCount);
*aCellsCount = 0;
NS_ENSURE_ARG_POINTER(aCells);
*aCells = nsnull;
PRUint32 colCount = ColCount(), rowCount = RowCount();
if (!mTreeView)
return NS_OK;
PRInt32 selectedrowCount = 0;
nsresult rv = GetSelectionCount(&selectedrowCount);
NS_ENSURE_SUCCESS(rv, rv);
PRInt32 columnCount = 0;
rv = GetColumnCount(&columnCount);
NS_ENSURE_SUCCESS(rv, rv);
PRInt32 selectedCellCount = selectedrowCount * columnCount;
PRInt32* outArray = static_cast<PRInt32*>(
nsMemory::Alloc(selectedCellCount * sizeof(PRInt32)));
NS_ENSURE_TRUE(outArray, NS_ERROR_OUT_OF_MEMORY);
nsCOMPtr<nsITreeSelection> selection;
rv = mTreeView->GetSelection(getter_AddRefs(selection));
NS_ENSURE_SUCCESS(rv, rv);
PRInt32 rowCount = 0;
rv = GetRowCount(&rowCount);
NS_ENSURE_SUCCESS(rv, rv);
bool isSelected;
for (PRInt32 rowIdx = 0, arrayIdx = 0; rowIdx < rowCount; rowIdx++) {
selection->IsSelected(rowIdx, &isSelected);
if (isSelected) {
for (PRInt32 colIdx = 0; colIdx < columnCount; colIdx++)
outArray[arrayIdx++] = rowIdx * columnCount + colIdx;
}
}
*aCellsCount = selectedCellCount;
*aCells = outArray;
return NS_OK;
for (PRUint32 rowIdx = 0; rowIdx < rowCount; rowIdx++)
if (IsRowSelected(rowIdx))
for (PRUint32 colIdx = 0; colIdx < colCount; colIdx++)
aCells->AppendElement(rowIdx * colCount + colIdx);
}
NS_IMETHODIMP
XULTreeGridAccessible::GetSelectedColumnIndices(PRUint32* acolumnCount,
PRInt32** aColumns)
void
XULTreeGridAccessible::SelectedColIndices(nsTArray<PRUint32>* aCols)
{
NS_ENSURE_ARG_POINTER(acolumnCount);
*acolumnCount = 0;
NS_ENSURE_ARG_POINTER(aColumns);
*aColumns = nsnull;
if (RowCount() != SelectedRowCount())
return;
if (IsDefunct())
return NS_ERROR_FAILURE;
// If all the row has been selected, then all the columns are selected.
// Because we can't select a column alone.
PRInt32 rowCount = 0;
nsresult rv = GetRowCount(&rowCount);
NS_ENSURE_SUCCESS(rv, rv);
PRInt32 selectedrowCount = 0;
rv = GetSelectionCount(&selectedrowCount);
NS_ENSURE_SUCCESS(rv, rv);
if (rowCount != selectedrowCount)
return NS_OK;
PRInt32 columnCount = 0;
rv = GetColumnCount(&columnCount);
NS_ENSURE_SUCCESS(rv, rv);
PRInt32* outArray = static_cast<PRInt32*>(
nsMemory::Alloc(columnCount * sizeof(PRInt32)));
NS_ENSURE_TRUE(outArray, NS_ERROR_OUT_OF_MEMORY);
for (PRInt32 colIdx = 0; colIdx < columnCount; colIdx++)
outArray[colIdx] = colIdx;
*acolumnCount = columnCount;
*aColumns = outArray;
return NS_OK;
PRUint32 colCount = ColCount();
aCols->SetCapacity(colCount);
for (PRUint32 colIdx = 0; colIdx < colCount; colIdx++)
aCols->AppendElement(colIdx);
}
NS_IMETHODIMP
XULTreeGridAccessible::GetSelectedRowIndices(PRUint32* arowCount,
PRInt32** aRows)
void
XULTreeGridAccessible::SelectedRowIndices(nsTArray<PRUint32>* aRows)
{
NS_ENSURE_ARG_POINTER(arowCount);
*arowCount = 0;
NS_ENSURE_ARG_POINTER(aRows);
*aRows = nsnull;
if (IsDefunct())
return NS_ERROR_FAILURE;
if (!mTreeView)
return NS_OK;
PRInt32 selectedrowCount = 0;
nsresult rv = GetSelectionCount(&selectedrowCount);
NS_ENSURE_SUCCESS(rv, rv);
PRInt32* outArray = static_cast<PRInt32*>(
nsMemory::Alloc(selectedrowCount * sizeof(PRInt32)));
NS_ENSURE_TRUE(outArray, NS_ERROR_OUT_OF_MEMORY);
nsCOMPtr<nsITreeSelection> selection;
rv = mTreeView->GetSelection(getter_AddRefs(selection));
NS_ENSURE_SUCCESS(rv, rv);
PRInt32 rowCount = 0;
rv = GetRowCount(&rowCount);
NS_ENSURE_SUCCESS(rv, rv);
bool isSelected;
for (PRInt32 rowIdx = 0, arrayIdx = 0; rowIdx < rowCount; rowIdx++) {
selection->IsSelected(rowIdx, &isSelected);
if (isSelected)
outArray[arrayIdx++] = rowIdx;
}
*arowCount = selectedrowCount;
*aRows = outArray;
return NS_OK;
PRUint32 rowCount = RowCount();
for (PRUint32 rowIdx = 0; rowIdx < rowCount; rowIdx++)
if (IsRowSelected(rowIdx))
aRows->AppendElement(rowIdx);
}
Accessible*

3
accessible/src/xul/XULTreeGridAccessible.h
View File

@ -41,6 +41,9 @@ public:
virtual PRUint32 SelectedCellCount();
virtual PRUint32 SelectedColCount();
virtual PRUint32 SelectedRowCount();
virtual void SelectedCellIndices(nsTArray<PRUint32>* aCells);
virtual void SelectedColIndices(nsTArray<PRUint32>* aCols);
virtual void SelectedRowIndices(nsTArray<PRUint32>* aRows);
virtual void SelectRow(PRUint32 aRowIdx);
virtual void UnselectRow(PRUint32 aRowIdx);