2001-12-17 01:21:29 +00:00
|
|
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
2012-05-21 11:12:37 +00:00
|
|
|
/* 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/. */
|
2001-12-17 01:21:29 +00:00
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
#include "nsXULListboxAccessible.h"
|
|
|
|
|
2012-04-13 14:17:03 +00:00
|
|
|
#include "Accessible-inl.h"
|
2010-04-27 06:52:03 +00:00
|
|
|
#include "nsAccessibilityService.h"
|
|
|
|
#include "nsAccUtils.h"
|
2012-05-27 09:01:40 +00:00
|
|
|
#include "DocAccessible.h"
|
2012-01-12 03:07:35 +00:00
|
|
|
#include "Role.h"
|
|
|
|
#include "States.h"
|
2010-04-27 06:52:03 +00:00
|
|
|
|
2011-09-28 01:46:11 +00:00
|
|
|
#include "nsComponentManagerUtils.h"
|
|
|
|
#include "nsIAutoCompleteInput.h"
|
|
|
|
#include "nsIAutoCompletePopup.h"
|
|
|
|
#include "nsIDOMXULMenuListElement.h"
|
2008-03-06 04:14:10 +00:00
|
|
|
#include "nsIDOMXULMultSelectCntrlEl.h"
|
2011-08-11 13:29:50 +00:00
|
|
|
#include "nsIDOMNodeList.h"
|
2011-09-28 01:46:11 +00:00
|
|
|
#include "nsIDOMXULPopupElement.h"
|
|
|
|
#include "nsIDOMXULSelectCntrlItemEl.h"
|
2001-12-17 01:21:29 +00:00
|
|
|
|
2011-07-27 12:43:01 +00:00
|
|
|
using namespace mozilla::a11y;
|
|
|
|
|
2007-09-19 03:31:14 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
2012-05-29 01:18:45 +00:00
|
|
|
// nsXULColumAccessible
|
2009-09-11 01:07:56 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
2007-09-19 03:31:14 +00:00
|
|
|
|
2012-05-29 01:18:45 +00:00
|
|
|
nsXULColumAccessible::
|
|
|
|
nsXULColumAccessible(nsIContent* aContent, DocAccessible* aDoc) :
|
|
|
|
AccessibleWrap(aContent, aDoc)
|
2007-09-19 03:31:14 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2012-01-12 03:07:35 +00:00
|
|
|
role
|
2012-05-29 01:18:45 +00:00
|
|
|
nsXULColumAccessible::NativeRole()
|
2007-09-19 03:31:14 +00:00
|
|
|
{
|
2012-01-12 03:07:35 +00:00
|
|
|
return roles::LIST;
|
2007-09-19 03:31:14 +00:00
|
|
|
}
|
|
|
|
|
2011-04-09 23:38:06 +00:00
|
|
|
PRUint64
|
2012-05-29 01:18:45 +00:00
|
|
|
nsXULColumAccessible::NativeState()
|
2007-09-19 03:31:14 +00:00
|
|
|
{
|
2011-04-12 06:18:42 +00:00
|
|
|
return states::READONLY;
|
2007-09-19 03:31:14 +00:00
|
|
|
}
|
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
|
2007-09-19 03:31:14 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// nsXULColumnItemAccessible
|
2009-09-11 01:07:56 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
2007-09-19 03:31:14 +00:00
|
|
|
|
|
|
|
nsXULColumnItemAccessible::
|
2012-05-27 09:01:40 +00:00
|
|
|
nsXULColumnItemAccessible(nsIContent* aContent, DocAccessible* aDoc) :
|
2012-02-07 22:38:54 +00:00
|
|
|
nsLeafAccessible(aContent, aDoc)
|
2007-09-19 03:31:14 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2012-01-12 03:07:35 +00:00
|
|
|
role
|
2010-09-05 02:14:01 +00:00
|
|
|
nsXULColumnItemAccessible::NativeRole()
|
2007-09-19 03:31:14 +00:00
|
|
|
{
|
2012-01-12 03:07:35 +00:00
|
|
|
return roles::COLUMNHEADER;
|
2007-09-19 03:31:14 +00:00
|
|
|
}
|
|
|
|
|
2011-04-09 23:38:06 +00:00
|
|
|
PRUint64
|
|
|
|
nsXULColumnItemAccessible::NativeState()
|
2007-09-19 03:31:14 +00:00
|
|
|
{
|
2011-04-12 06:18:42 +00:00
|
|
|
return states::READONLY;
|
2007-09-19 03:31:14 +00:00
|
|
|
}
|
|
|
|
|
2011-06-05 19:35:43 +00:00
|
|
|
PRUint8
|
|
|
|
nsXULColumnItemAccessible::ActionCount()
|
2007-09-19 03:31:14 +00:00
|
|
|
{
|
2011-06-05 19:35:43 +00:00
|
|
|
return 1;
|
2007-09-19 03:31:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsXULColumnItemAccessible::GetActionName(PRUint8 aIndex, nsAString& aName)
|
|
|
|
{
|
|
|
|
if (aIndex != eAction_Click)
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
|
|
|
|
aName.AssignLiteral("click");
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsXULColumnItemAccessible::DoAction(PRUint8 aIndex)
|
|
|
|
{
|
|
|
|
if (aIndex != eAction_Click)
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
|
2010-01-25 15:09:25 +00:00
|
|
|
DoCommand();
|
|
|
|
return NS_OK;
|
2007-09-19 03:31:14 +00:00
|
|
|
}
|
2001-12-17 01:21:29 +00:00
|
|
|
|
2007-09-19 03:31:14 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// nsXULListboxAccessible
|
2009-09-11 01:07:56 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
2001-12-17 01:21:29 +00:00
|
|
|
|
2008-02-19 09:07:35 +00:00
|
|
|
nsXULListboxAccessible::
|
2012-05-27 09:01:40 +00:00
|
|
|
nsXULListboxAccessible(nsIContent* aContent, DocAccessible* aDoc) :
|
2012-03-28 00:53:58 +00:00
|
|
|
XULSelectControlAccessible(aContent, aDoc), xpcAccessibleTable(this)
|
2001-12-17 01:21:29 +00:00
|
|
|
{
|
2011-09-28 01:46:11 +00:00
|
|
|
nsIContent* parentContent = mContent->GetParent();
|
|
|
|
if (parentContent) {
|
|
|
|
nsCOMPtr<nsIAutoCompletePopup> autoCompletePopupElm =
|
|
|
|
do_QueryInterface(parentContent);
|
|
|
|
if (autoCompletePopupElm)
|
|
|
|
mFlags |= eAutoCompletePopupAccessible;
|
|
|
|
}
|
2001-12-17 01:21:29 +00:00
|
|
|
}
|
|
|
|
|
2001-01-01 00:12:15 +00:00
|
|
|
NS_IMPL_ADDREF_INHERITED(nsXULListboxAccessible, XULSelectControlAccessible)
|
|
|
|
NS_IMPL_RELEASE_INHERITED(nsXULListboxAccessible, XULSelectControlAccessible)
|
2008-02-19 09:07:35 +00:00
|
|
|
|
|
|
|
nsresult
|
|
|
|
nsXULListboxAccessible::QueryInterface(REFNSIID aIID, void** aInstancePtr)
|
|
|
|
{
|
2001-01-01 00:12:15 +00:00
|
|
|
nsresult rv = XULSelectControlAccessible::QueryInterface(aIID, aInstancePtr);
|
2008-02-19 09:07:35 +00:00
|
|
|
if (*aInstancePtr)
|
|
|
|
return rv;
|
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
if (aIID.Equals(NS_GET_IID(nsIAccessibleTable)) && IsMulticolumn()) {
|
2008-02-19 09:07:35 +00:00
|
|
|
*aInstancePtr = static_cast<nsIAccessibleTable*>(this);
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_ERROR_NO_INTERFACE;
|
|
|
|
}
|
|
|
|
|
2012-03-28 00:53:58 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//nsAccessNode
|
|
|
|
|
|
|
|
void
|
|
|
|
nsXULListboxAccessible::Shutdown()
|
|
|
|
{
|
|
|
|
mTable = nsnull;
|
|
|
|
XULSelectControlAccessible::Shutdown();
|
|
|
|
}
|
|
|
|
|
2011-09-29 06:19:26 +00:00
|
|
|
bool
|
2009-09-11 01:07:56 +00:00
|
|
|
nsXULListboxAccessible::IsMulticolumn()
|
2008-02-19 09:07:35 +00:00
|
|
|
{
|
|
|
|
PRInt32 numColumns = 0;
|
2009-09-11 01:07:56 +00:00
|
|
|
nsresult rv = GetColumnCount(&numColumns);
|
2008-02-19 09:07:35 +00:00
|
|
|
if (NS_FAILED(rv))
|
2011-10-17 14:59:28 +00:00
|
|
|
return false;
|
2009-09-11 01:07:56 +00:00
|
|
|
|
2008-02-19 09:07:35 +00:00
|
|
|
return numColumns > 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// nsXULListboxAccessible. nsIAccessible
|
|
|
|
|
2011-04-09 23:38:06 +00:00
|
|
|
PRUint64
|
|
|
|
nsXULListboxAccessible::NativeState()
|
2002-02-18 07:35:10 +00:00
|
|
|
{
|
2008-02-19 09:07:35 +00:00
|
|
|
// As a nsXULListboxAccessible we can have the following states:
|
2011-04-09 23:38:06 +00:00
|
|
|
// FOCUSED, READONLY, FOCUSABLE
|
2008-02-19 09:07:35 +00:00
|
|
|
|
2002-02-18 07:35:10 +00:00
|
|
|
// Get focus status from base class
|
2012-05-29 01:18:45 +00:00
|
|
|
PRUint64 states = Accessible::NativeState();
|
2002-02-18 07:35:10 +00:00
|
|
|
|
2010-06-11 08:23:18 +00:00
|
|
|
// see if we are multiple select if so set ourselves as such
|
|
|
|
|
2011-06-03 21:35:17 +00:00
|
|
|
if (mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::seltype,
|
|
|
|
nsGkAtoms::multiple, eCaseMatters)) {
|
2011-04-09 23:38:06 +00:00
|
|
|
states |= states::MULTISELECTABLE | states::EXTSELECTABLE;
|
2002-02-18 07:35:10 +00:00
|
|
|
}
|
|
|
|
|
2011-04-09 23:38:06 +00:00
|
|
|
return states;
|
2002-02-18 07:35:10 +00:00
|
|
|
}
|
|
|
|
|
2001-12-17 01:21:29 +00:00
|
|
|
/**
|
2004-06-02 04:06:28 +00:00
|
|
|
* Our value is the label of our ( first ) selected child.
|
2001-12-17 01:21:29 +00:00
|
|
|
*/
|
2012-04-09 09:48:41 +00:00
|
|
|
void
|
|
|
|
nsXULListboxAccessible::Value(nsString& aValue)
|
2001-12-17 01:21:29 +00:00
|
|
|
{
|
2012-04-09 09:48:41 +00:00
|
|
|
aValue.Truncate();
|
|
|
|
|
2010-06-11 08:23:18 +00:00
|
|
|
nsCOMPtr<nsIDOMXULSelectControlElement> select(do_QueryInterface(mContent));
|
2001-12-17 01:21:29 +00:00
|
|
|
if (select) {
|
|
|
|
nsCOMPtr<nsIDOMXULSelectControlItemElement> selectedItem;
|
|
|
|
select->GetSelectedItem(getter_AddRefs(selectedItem));
|
2002-06-14 01:47:26 +00:00
|
|
|
if (selectedItem)
|
2012-04-09 09:48:41 +00:00
|
|
|
selectedItem->GetLabel(aValue);
|
2001-12-17 01:21:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-01-12 03:07:35 +00:00
|
|
|
role
|
2010-09-05 02:14:01 +00:00
|
|
|
nsXULListboxAccessible::NativeRole()
|
2002-02-18 07:35:10 +00:00
|
|
|
{
|
2010-06-11 08:23:18 +00:00
|
|
|
// A richlistbox is used with the new autocomplete URL bar, and has a parent
|
|
|
|
// popup <panel>.
|
|
|
|
nsCOMPtr<nsIDOMXULPopupElement> xulPopup =
|
|
|
|
do_QueryInterface(mContent->GetParent());
|
2010-09-05 02:14:01 +00:00
|
|
|
if (xulPopup)
|
2012-01-12 03:07:35 +00:00
|
|
|
return roles::COMBOBOX_LIST;
|
2008-02-19 09:07:35 +00:00
|
|
|
|
2012-01-12 03:07:35 +00:00
|
|
|
return IsMulticolumn() ? roles::TABLE : roles::LISTBOX;
|
2002-02-18 07:35:10 +00:00
|
|
|
}
|
|
|
|
|
2008-02-19 09:07:35 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// nsXULListboxAccessible. nsIAccessibleTable
|
2002-02-18 07:35:10 +00:00
|
|
|
|
2012-04-19 21:32:11 +00:00
|
|
|
PRUint32
|
|
|
|
nsXULListboxAccessible::ColCount()
|
2008-02-19 09:07:35 +00:00
|
|
|
{
|
2010-06-11 08:23:18 +00:00
|
|
|
nsIContent* headContent = nsnull;
|
2011-12-07 07:20:17 +00:00
|
|
|
for (nsIContent* childContent = mContent->GetFirstChild(); childContent;
|
|
|
|
childContent = childContent->GetNextSibling()) {
|
2011-06-03 21:35:17 +00:00
|
|
|
if (childContent->NodeInfo()->Equals(nsGkAtoms::listcols,
|
2008-02-19 09:07:35 +00:00
|
|
|
kNameSpaceID_XUL)) {
|
|
|
|
headContent = childContent;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!headContent)
|
2012-04-19 21:32:11 +00:00
|
|
|
return 0;
|
2008-02-19 09:07:35 +00:00
|
|
|
|
|
|
|
PRUint32 columnCount = 0;
|
2011-12-07 07:20:17 +00:00
|
|
|
for (nsIContent* childContent = headContent->GetFirstChild(); childContent;
|
|
|
|
childContent = childContent->GetNextSibling()) {
|
2011-06-03 21:35:17 +00:00
|
|
|
if (childContent->NodeInfo()->Equals(nsGkAtoms::listcol,
|
2008-02-19 09:07:35 +00:00
|
|
|
kNameSpaceID_XUL)) {
|
|
|
|
columnCount++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-04-19 21:32:11 +00:00
|
|
|
return columnCount;
|
2008-02-19 09:07:35 +00:00
|
|
|
}
|
|
|
|
|
2012-04-19 21:32:11 +00:00
|
|
|
PRUint32
|
|
|
|
nsXULListboxAccessible::RowCount()
|
2008-02-19 09:07:35 +00:00
|
|
|
{
|
2010-06-11 08:23:18 +00:00
|
|
|
nsCOMPtr<nsIDOMXULSelectControlElement> element(do_QueryInterface(mContent));
|
2008-02-19 09:07:35 +00:00
|
|
|
|
|
|
|
PRUint32 itemCount = 0;
|
2012-04-19 21:32:11 +00:00
|
|
|
if(element)
|
|
|
|
element->GetItemCount(&itemCount);
|
2008-02-19 09:07:35 +00:00
|
|
|
|
2012-04-19 21:32:11 +00:00
|
|
|
return itemCount;
|
2008-02-19 09:07:35 +00:00
|
|
|
}
|
|
|
|
|
2012-05-29 01:18:45 +00:00
|
|
|
Accessible*
|
2012-05-22 16:41:01 +00:00
|
|
|
nsXULListboxAccessible::CellAt(PRUint32 aRowIndex, PRUint32 aColumnIndex)
|
|
|
|
{
|
2008-02-19 09:07:35 +00:00
|
|
|
nsCOMPtr<nsIDOMXULSelectControlElement> control =
|
2010-06-11 08:23:18 +00:00
|
|
|
do_QueryInterface(mContent);
|
2012-05-22 16:41:01 +00:00
|
|
|
NS_ENSURE_TRUE(control, nsnull);
|
2008-02-19 09:07:35 +00:00
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMXULSelectControlItemElement> item;
|
2012-05-22 16:41:01 +00:00
|
|
|
control->GetItemAtIndex(aRowIndex, getter_AddRefs(item));
|
|
|
|
if (!item)
|
|
|
|
return nsnull;
|
2008-02-19 09:07:35 +00:00
|
|
|
|
2010-06-11 08:23:18 +00:00
|
|
|
nsCOMPtr<nsIContent> itemContent(do_QueryInterface(item));
|
2012-05-22 16:41:01 +00:00
|
|
|
if (!itemContent)
|
|
|
|
return nsnull;
|
2008-02-19 09:07:35 +00:00
|
|
|
|
2012-05-29 01:18:45 +00:00
|
|
|
Accessible* row = mDoc->GetAccessible(itemContent);
|
2012-05-22 16:41:01 +00:00
|
|
|
NS_ENSURE_TRUE(row, nsnull);
|
2008-02-19 09:07:35 +00:00
|
|
|
|
2012-05-22 16:41:01 +00:00
|
|
|
return row->GetChildAt(aColumnIndex);
|
2008-02-19 09:07:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2009-09-11 01:07:56 +00:00
|
|
|
nsXULListboxAccessible::GetColumnIndexAt(PRInt32 aIndex, PRInt32 *aColumn)
|
2008-02-19 09:07:35 +00:00
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aColumn);
|
|
|
|
*aColumn = -1;
|
|
|
|
|
|
|
|
PRInt32 columnCount = 0;
|
2009-09-11 01:07:56 +00:00
|
|
|
nsresult rv = GetColumnCount(&columnCount);
|
2008-02-19 09:07:35 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
*aColumn = aIndex % columnCount;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2009-09-11 01:07:56 +00:00
|
|
|
nsXULListboxAccessible::GetRowIndexAt(PRInt32 aIndex, PRInt32 *aRow)
|
2008-02-19 09:07:35 +00:00
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aRow);
|
|
|
|
*aRow = -1;
|
|
|
|
|
|
|
|
PRInt32 columnCount = 0;
|
2009-09-11 01:07:56 +00:00
|
|
|
nsresult rv = GetColumnCount(&columnCount);
|
2008-02-19 09:07:35 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
*aRow = aIndex / columnCount;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2010-07-03 03:16:52 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsXULListboxAccessible::GetRowAndColumnIndicesAt(PRInt32 aCellIndex,
|
|
|
|
PRInt32* aRowIndex,
|
|
|
|
PRInt32* aColumnIndex)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aRowIndex);
|
|
|
|
*aRowIndex = -1;
|
|
|
|
NS_ENSURE_ARG_POINTER(aColumnIndex);
|
|
|
|
*aColumnIndex = -1;
|
|
|
|
|
|
|
|
if (IsDefunct())
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
PRInt32 columnCount = 0;
|
|
|
|
nsresult rv = GetColumnCount(&columnCount);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
*aColumnIndex = aCellIndex % columnCount;
|
|
|
|
*aRowIndex = aCellIndex / columnCount;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2008-02-19 09:07:35 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsXULListboxAccessible::GetColumnDescription(PRInt32 aColumn,
|
|
|
|
nsAString& aDescription)
|
|
|
|
{
|
2008-03-06 04:14:10 +00:00
|
|
|
aDescription.Truncate();
|
|
|
|
return NS_OK;
|
2008-02-19 09:07:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsXULListboxAccessible::GetRowDescription(PRInt32 aRow, nsAString& aDescription)
|
|
|
|
{
|
2008-03-06 04:14:10 +00:00
|
|
|
aDescription.Truncate();
|
|
|
|
return NS_OK;
|
2008-02-19 09:07:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-09-29 06:19:26 +00:00
|
|
|
nsXULListboxAccessible::IsColumnSelected(PRInt32 aColumn, bool *aIsSelected)
|
2008-02-19 09:07:35 +00:00
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aIsSelected);
|
2011-10-17 14:59:28 +00:00
|
|
|
*aIsSelected = false;
|
2008-02-19 09:07:35 +00:00
|
|
|
|
2008-03-06 04:14:10 +00:00
|
|
|
if (IsDefunct())
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMXULMultiSelectControlElement> control =
|
2010-06-11 08:23:18 +00:00
|
|
|
do_QueryInterface(mContent);
|
2008-03-06 04:14:10 +00:00
|
|
|
NS_ASSERTION(control,
|
|
|
|
"Doesn't implement nsIDOMXULMultiSelectControlElement.");
|
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
PRInt32 selectedrowCount = 0;
|
|
|
|
nsresult rv = control->GetSelectedCount(&selectedrowCount);
|
2008-03-06 04:14:10 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
PRInt32 rowCount = 0;
|
|
|
|
rv = GetRowCount(&rowCount);
|
2008-03-06 04:14:10 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
*aIsSelected = (selectedrowCount == rowCount);
|
2008-03-06 04:14:10 +00:00
|
|
|
return NS_OK;
|
2008-02-19 09:07:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2011-09-29 06:19:26 +00:00
|
|
|
nsXULListboxAccessible::IsRowSelected(PRInt32 aRow, bool *aIsSelected)
|
2008-02-19 09:07:35 +00:00
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aIsSelected);
|
2011-10-17 14:59:28 +00:00
|
|
|
*aIsSelected = false;
|
2008-02-19 09:07:35 +00:00
|
|
|
|
2008-03-06 04:14:10 +00:00
|
|
|
if (IsDefunct())
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMXULSelectControlElement> control =
|
2010-06-11 08:23:18 +00:00
|
|
|
do_QueryInterface(mContent);
|
2008-03-06 04:14:10 +00:00
|
|
|
NS_ASSERTION(control,
|
|
|
|
"Doesn't implement nsIDOMXULSelectControlElement.");
|
2012-05-30 00:51:08 +00:00
|
|
|
|
2008-03-06 04:14:10 +00:00
|
|
|
nsCOMPtr<nsIDOMXULSelectControlItemElement> item;
|
|
|
|
control->GetItemAtIndex(aRow, getter_AddRefs(item));
|
|
|
|
NS_ENSURE_TRUE(item, NS_ERROR_INVALID_ARG);
|
|
|
|
|
|
|
|
return item->GetSelected(aIsSelected);
|
2008-02-19 09:07:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2009-09-11 01:07:56 +00:00
|
|
|
nsXULListboxAccessible::IsCellSelected(PRInt32 aRowIndex, PRInt32 aColumnIndex,
|
2011-09-29 06:19:26 +00:00
|
|
|
bool *aIsSelected)
|
2008-02-19 09:07:35 +00:00
|
|
|
{
|
2009-09-11 01:07:56 +00:00
|
|
|
return IsRowSelected(aRowIndex, aIsSelected);
|
2008-02-19 09:07:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2009-09-11 01:07:56 +00:00
|
|
|
nsXULListboxAccessible::GetSelectedCellCount(PRUint32* aCount)
|
2008-02-19 09:07:35 +00:00
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aCount);
|
2008-03-06 04:14:10 +00:00
|
|
|
*aCount = 0;
|
2008-02-19 09:07:35 +00:00
|
|
|
|
2008-03-06 04:14:10 +00:00
|
|
|
nsCOMPtr<nsIDOMXULMultiSelectControlElement> control =
|
2010-06-11 08:23:18 +00:00
|
|
|
do_QueryInterface(mContent);
|
2008-03-06 04:14:10 +00:00
|
|
|
NS_ASSERTION(control,
|
|
|
|
"Doesn't implement nsIDOMXULMultiSelectControlElement.");
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMNodeList> selectedItems;
|
|
|
|
control->GetSelectedItems(getter_AddRefs(selectedItems));
|
|
|
|
if (!selectedItems)
|
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
PRUint32 selectedItemsCount = 0;
|
|
|
|
nsresult rv = selectedItems->GetLength(&selectedItemsCount);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
if (!selectedItemsCount)
|
|
|
|
return NS_OK;
|
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
PRInt32 columnCount = 0;
|
|
|
|
rv = GetColumnCount(&columnCount);
|
2008-03-06 04:14:10 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
*aCount = selectedItemsCount * columnCount;
|
2008-03-06 04:14:10 +00:00
|
|
|
return NS_OK;
|
2008-02-19 09:07:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2009-09-11 01:07:56 +00:00
|
|
|
nsXULListboxAccessible::GetSelectedColumnCount(PRUint32* aCount)
|
2008-02-19 09:07:35 +00:00
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aCount);
|
2008-03-06 04:14:10 +00:00
|
|
|
*aCount = 0;
|
2008-02-19 09:07:35 +00:00
|
|
|
|
2008-03-06 04:14:10 +00:00
|
|
|
if (IsDefunct())
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMXULMultiSelectControlElement> control =
|
2010-06-11 08:23:18 +00:00
|
|
|
do_QueryInterface(mContent);
|
2008-03-06 04:14:10 +00:00
|
|
|
NS_ASSERTION(control,
|
|
|
|
"Doesn't implement nsIDOMXULMultiSelectControlElement.");
|
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
PRInt32 selectedrowCount = 0;
|
|
|
|
nsresult rv = control->GetSelectedCount(&selectedrowCount);
|
2008-03-06 04:14:10 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
PRInt32 rowCount = 0;
|
|
|
|
rv = GetRowCount(&rowCount);
|
2008-03-06 04:14:10 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
if (selectedrowCount != rowCount)
|
2008-03-06 04:14:10 +00:00
|
|
|
return NS_OK;
|
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
PRInt32 columnCount = 0;
|
|
|
|
rv = GetColumnCount(&columnCount);
|
2008-03-06 04:14:10 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
*aCount = columnCount;
|
2008-03-06 04:14:10 +00:00
|
|
|
return NS_OK;
|
2008-02-19 09:07:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2009-09-11 01:07:56 +00:00
|
|
|
nsXULListboxAccessible::GetSelectedRowCount(PRUint32* aCount)
|
2008-02-19 09:07:35 +00:00
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aCount);
|
2008-03-06 04:14:10 +00:00
|
|
|
*aCount = 0;
|
2008-02-19 09:07:35 +00:00
|
|
|
|
2008-03-06 04:14:10 +00:00
|
|
|
if (IsDefunct())
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMXULMultiSelectControlElement> control =
|
2010-06-11 08:23:18 +00:00
|
|
|
do_QueryInterface(mContent);
|
2008-03-06 04:14:10 +00:00
|
|
|
NS_ASSERTION(control,
|
|
|
|
"Doesn't implement nsIDOMXULMultiSelectControlElement.");
|
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
PRInt32 selectedrowCount = 0;
|
|
|
|
nsresult rv = control->GetSelectedCount(&selectedrowCount);
|
2008-03-06 04:14:10 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
*aCount = selectedrowCount;
|
2008-03-06 04:14:10 +00:00
|
|
|
return NS_OK;
|
2008-02-19 09:07:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2009-09-11 01:07:56 +00:00
|
|
|
nsXULListboxAccessible::GetSelectedCells(nsIArray **aCells)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aCells);
|
|
|
|
*aCells = nsnull;
|
|
|
|
|
|
|
|
if (IsDefunct())
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
nsCOMPtr<nsIMutableArray> selCells =
|
|
|
|
do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMXULMultiSelectControlElement> control =
|
2010-06-11 08:23:18 +00:00
|
|
|
do_QueryInterface(mContent);
|
2009-09-11 01:07:56 +00:00
|
|
|
NS_ASSERTION(control,
|
|
|
|
"Doesn't implement nsIDOMXULMultiSelectControlElement.");
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMNodeList> selectedItems;
|
|
|
|
control->GetSelectedItems(getter_AddRefs(selectedItems));
|
|
|
|
if (!selectedItems)
|
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
PRUint32 selectedItemsCount = 0;
|
|
|
|
rv = selectedItems->GetLength(&selectedItemsCount);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2012-02-07 22:38:54 +00:00
|
|
|
NS_ENSURE_TRUE(mDoc, NS_ERROR_FAILURE);
|
2009-09-11 01:07:56 +00:00
|
|
|
PRUint32 index = 0;
|
|
|
|
for (; index < selectedItemsCount; index++) {
|
|
|
|
nsCOMPtr<nsIDOMNode> itemNode;
|
|
|
|
selectedItems->Item(index, getter_AddRefs(itemNode));
|
2010-06-11 08:23:18 +00:00
|
|
|
nsCOMPtr<nsIContent> itemContent(do_QueryInterface(itemNode));
|
2012-05-29 01:18:45 +00:00
|
|
|
Accessible* item = mDoc->GetAccessible(itemContent);
|
2009-09-11 01:07:56 +00:00
|
|
|
|
|
|
|
if (item) {
|
2012-05-25 10:53:45 +00:00
|
|
|
PRUint32 cellCount = item->ChildCount();
|
|
|
|
for (PRUint32 cellIdx = 0; cellIdx < cellCount; cellIdx++) {
|
2012-05-29 01:18:45 +00:00
|
|
|
Accessible* cell = mChildren[cellIdx];
|
2012-01-12 03:07:35 +00:00
|
|
|
if (cell->Role() == roles::CELL)
|
2011-10-17 14:59:28 +00:00
|
|
|
selCells->AppendElement(static_cast<nsIAccessible*>(cell), false);
|
2009-09-11 01:07:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_ADDREF(*aCells = selCells);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsXULListboxAccessible::GetSelectedCellIndices(PRUint32 *aNumCells,
|
|
|
|
PRInt32 **aCells)
|
2008-02-19 09:07:35 +00:00
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aNumCells);
|
2008-03-06 04:14:10 +00:00
|
|
|
*aNumCells = 0;
|
2008-02-19 09:07:35 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(aCells);
|
2008-03-06 04:14:10 +00:00
|
|
|
*aCells = nsnull;
|
2008-02-19 09:07:35 +00:00
|
|
|
|
2008-03-06 04:14:10 +00:00
|
|
|
if (IsDefunct())
|
|
|
|
return NS_ERROR_FAILURE;
|
2009-09-11 01:07:56 +00:00
|
|
|
|
2008-03-06 04:14:10 +00:00
|
|
|
nsCOMPtr<nsIDOMXULMultiSelectControlElement> control =
|
2010-06-11 08:23:18 +00:00
|
|
|
do_QueryInterface(mContent);
|
2008-03-06 04:14:10 +00:00
|
|
|
NS_ASSERTION(control,
|
|
|
|
"Doesn't implement nsIDOMXULMultiSelectControlElement.");
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMNodeList> selectedItems;
|
|
|
|
control->GetSelectedItems(getter_AddRefs(selectedItems));
|
|
|
|
if (!selectedItems)
|
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
PRUint32 selectedItemsCount = 0;
|
|
|
|
nsresult rv = selectedItems->GetLength(&selectedItemsCount);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
PRInt32 columnCount = 0;
|
|
|
|
rv = GetColumnCount(&columnCount);
|
2008-03-06 04:14:10 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
PRUint32 cellsCount = selectedItemsCount * columnCount;
|
2008-03-06 04:14:10 +00:00
|
|
|
|
|
|
|
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));
|
|
|
|
nsCOMPtr<nsIDOMXULSelectControlItemElement> item =
|
|
|
|
do_QueryInterface(itemNode);
|
|
|
|
|
|
|
|
if (item) {
|
|
|
|
PRInt32 itemIdx = -1;
|
|
|
|
control->GetIndexOfItem(item, &itemIdx);
|
|
|
|
if (itemIdx != -1) {
|
|
|
|
PRInt32 colIdx = 0;
|
2009-09-11 01:07:56 +00:00
|
|
|
for (; colIdx < columnCount; colIdx++)
|
|
|
|
cellsIdxArray[cellsIdx++] = itemIdx * columnCount + colIdx;
|
2008-03-06 04:14:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
*aNumCells = cellsCount;
|
|
|
|
*aCells = cellsIdxArray;
|
|
|
|
|
|
|
|
return NS_OK;
|
2008-02-19 09:07:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2009-09-11 01:07:56 +00:00
|
|
|
nsXULListboxAccessible::GetSelectedColumnIndices(PRUint32 *aNumColumns,
|
|
|
|
PRInt32 **aColumns)
|
2008-02-19 09:07:35 +00:00
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aNumColumns);
|
2008-03-06 04:14:10 +00:00
|
|
|
*aNumColumns = 0;
|
2008-02-19 09:07:35 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(aColumns);
|
2008-03-06 04:14:10 +00:00
|
|
|
*aColumns = nsnull;
|
2008-02-19 09:07:35 +00:00
|
|
|
|
2008-03-06 04:14:10 +00:00
|
|
|
if (IsDefunct())
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
PRUint32 columnCount = 0;
|
|
|
|
nsresult rv = GetSelectedColumnCount(&columnCount);
|
2008-03-06 04:14:10 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
if (!columnCount)
|
2008-03-06 04:14:10 +00:00
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
PRInt32 *colsIdxArray =
|
2009-09-11 01:07:56 +00:00
|
|
|
static_cast<PRInt32*>(nsMemory::Alloc((columnCount) * sizeof(PRInt32)));
|
2008-03-06 04:14:10 +00:00
|
|
|
NS_ENSURE_TRUE(colsIdxArray, NS_ERROR_OUT_OF_MEMORY);
|
|
|
|
|
|
|
|
PRUint32 colIdx = 0;
|
2009-09-11 01:07:56 +00:00
|
|
|
for (; colIdx < columnCount; colIdx++)
|
2008-03-06 04:14:10 +00:00
|
|
|
colsIdxArray[colIdx] = colIdx;
|
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
*aNumColumns = columnCount;
|
2008-03-06 04:14:10 +00:00
|
|
|
*aColumns = colsIdxArray;
|
|
|
|
|
|
|
|
return NS_OK;
|
2008-02-19 09:07:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2009-09-11 01:07:56 +00:00
|
|
|
nsXULListboxAccessible::GetSelectedRowIndices(PRUint32 *aNumRows,
|
|
|
|
PRInt32 **aRows)
|
2008-02-19 09:07:35 +00:00
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aNumRows);
|
2008-03-06 04:14:10 +00:00
|
|
|
*aNumRows = 0;
|
2008-02-19 09:07:35 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(aRows);
|
2008-03-06 04:14:10 +00:00
|
|
|
*aRows = nsnull;
|
2008-02-19 09:07:35 +00:00
|
|
|
|
2008-03-06 04:14:10 +00:00
|
|
|
if (IsDefunct())
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMXULMultiSelectControlElement> control =
|
2010-06-11 08:23:18 +00:00
|
|
|
do_QueryInterface(mContent);
|
2008-03-06 04:14:10 +00:00
|
|
|
NS_ASSERTION(control,
|
|
|
|
"Doesn't implement nsIDOMXULMultiSelectControlElement.");
|
2012-05-30 00:51:08 +00:00
|
|
|
|
2008-03-06 04:14:10 +00:00
|
|
|
nsCOMPtr<nsIDOMNodeList> selectedItems;
|
|
|
|
control->GetSelectedItems(getter_AddRefs(selectedItems));
|
|
|
|
if (!selectedItems)
|
|
|
|
return NS_OK;
|
2012-05-30 00:51:08 +00:00
|
|
|
|
2008-03-06 04:14:10 +00:00
|
|
|
PRUint32 selectedItemsCount = 0;
|
|
|
|
nsresult rv = selectedItems->GetLength(&selectedItemsCount);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
if (!selectedItemsCount)
|
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
PRInt32 *rowsIdxArray =
|
|
|
|
static_cast<PRInt32*>(nsMemory::Alloc((selectedItemsCount) * sizeof(PRInt32)));
|
|
|
|
NS_ENSURE_TRUE(rowsIdxArray, NS_ERROR_OUT_OF_MEMORY);
|
|
|
|
|
|
|
|
PRUint32 index = 0;
|
|
|
|
for (; index < selectedItemsCount; index++) {
|
|
|
|
nsCOMPtr<nsIDOMNode> itemNode;
|
|
|
|
selectedItems->Item(index, getter_AddRefs(itemNode));
|
|
|
|
nsCOMPtr<nsIDOMXULSelectControlItemElement> item =
|
|
|
|
do_QueryInterface(itemNode);
|
2012-05-30 00:51:08 +00:00
|
|
|
|
2008-03-06 04:14:10 +00:00
|
|
|
if (item) {
|
|
|
|
PRInt32 itemIdx = -1;
|
|
|
|
control->GetIndexOfItem(item, &itemIdx);
|
|
|
|
if (itemIdx != -1)
|
|
|
|
rowsIdxArray[index] = itemIdx;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
*aNumRows = selectedItemsCount;
|
|
|
|
*aRows = rowsIdxArray;
|
|
|
|
|
|
|
|
return NS_OK;
|
2008-02-19 09:07:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsXULListboxAccessible::SelectRow(PRInt32 aRow)
|
|
|
|
{
|
2008-03-06 04:14:10 +00:00
|
|
|
if (IsDefunct())
|
|
|
|
return NS_ERROR_FAILURE;
|
2012-05-30 00:51:08 +00:00
|
|
|
|
2008-03-06 04:14:10 +00:00
|
|
|
nsCOMPtr<nsIDOMXULMultiSelectControlElement> control =
|
2010-06-11 08:23:18 +00:00
|
|
|
do_QueryInterface(mContent);
|
2008-03-06 04:14:10 +00:00
|
|
|
NS_ASSERTION(control,
|
|
|
|
"Doesn't implement nsIDOMXULMultiSelectControlElement.");
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMXULSelectControlItemElement> item;
|
|
|
|
control->GetItemAtIndex(aRow, getter_AddRefs(item));
|
|
|
|
NS_ENSURE_TRUE(item, NS_ERROR_INVALID_ARG);
|
|
|
|
|
|
|
|
return control->SelectItem(item);
|
2008-02-19 09:07:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
nsXULListboxAccessible::SelectColumn(PRInt32 aColumn)
|
|
|
|
{
|
2008-03-06 04:14:10 +00:00
|
|
|
// xul:listbox and xul:richlistbox support row selection only.
|
|
|
|
return NS_OK;
|
2008-02-19 09:07:35 +00:00
|
|
|
}
|
|
|
|
|
2012-04-26 11:19:59 +00:00
|
|
|
void
|
|
|
|
nsXULListboxAccessible::UnselectRow(PRUint32 aRowIdx)
|
2008-02-19 09:07:35 +00:00
|
|
|
{
|
2008-03-06 04:14:10 +00:00
|
|
|
nsCOMPtr<nsIDOMXULMultiSelectControlElement> control =
|
2010-06-11 08:23:18 +00:00
|
|
|
do_QueryInterface(mContent);
|
2008-03-06 04:14:10 +00:00
|
|
|
NS_ASSERTION(control,
|
|
|
|
"Doesn't implement nsIDOMXULMultiSelectControlElement.");
|
|
|
|
|
2012-04-26 11:19:59 +00:00
|
|
|
if (control) {
|
|
|
|
nsCOMPtr<nsIDOMXULSelectControlItemElement> item;
|
|
|
|
control->GetItemAtIndex(aRowIdx, getter_AddRefs(item));
|
|
|
|
control->RemoveItemFromSelection(item);
|
|
|
|
}
|
2008-02-19 09:07:35 +00:00
|
|
|
}
|
|
|
|
|
2011-09-28 01:46:11 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// nsXULListboxAccessible: Widgets
|
|
|
|
|
|
|
|
bool
|
|
|
|
nsXULListboxAccessible::IsWidget() const
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
nsXULListboxAccessible::IsActiveWidget() const
|
|
|
|
{
|
|
|
|
if (IsAutoCompletePopup()) {
|
|
|
|
nsCOMPtr<nsIAutoCompletePopup> autoCompletePopupElm =
|
|
|
|
do_QueryInterface(mContent->GetParent());
|
|
|
|
|
|
|
|
if (autoCompletePopupElm) {
|
2011-09-29 06:19:26 +00:00
|
|
|
bool isOpen = false;
|
2011-09-28 01:46:11 +00:00
|
|
|
autoCompletePopupElm->GetPopupOpen(&isOpen);
|
|
|
|
return isOpen;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return FocusMgr()->HasDOMFocus(mContent);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
nsXULListboxAccessible::AreItemsOperable() const
|
|
|
|
{
|
|
|
|
if (IsAutoCompletePopup()) {
|
|
|
|
nsCOMPtr<nsIAutoCompletePopup> autoCompletePopupElm =
|
|
|
|
do_QueryInterface(mContent->GetParent());
|
|
|
|
|
|
|
|
if (autoCompletePopupElm) {
|
2011-09-29 06:19:26 +00:00
|
|
|
bool isOpen = false;
|
2011-09-28 01:46:11 +00:00
|
|
|
autoCompletePopupElm->GetPopupOpen(&isOpen);
|
|
|
|
return isOpen;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-05-29 01:18:45 +00:00
|
|
|
Accessible*
|
2011-09-28 01:46:11 +00:00
|
|
|
nsXULListboxAccessible::ContainerWidget() const
|
|
|
|
{
|
|
|
|
if (IsAutoCompletePopup()) {
|
|
|
|
// This works for XUL autocompletes. It doesn't work for HTML forms
|
|
|
|
// autocomplete because of potential crossprocess calls (when autocomplete
|
|
|
|
// lives in content process while popup lives in chrome process). If that's
|
|
|
|
// a problem then rethink Widgets interface.
|
|
|
|
nsCOMPtr<nsIDOMXULMenuListElement> menuListElm =
|
|
|
|
do_QueryInterface(mContent->GetParent());
|
|
|
|
if (menuListElm) {
|
|
|
|
nsCOMPtr<nsIDOMNode> inputElm;
|
|
|
|
menuListElm->GetInputField(getter_AddRefs(inputElm));
|
|
|
|
if (inputElm) {
|
|
|
|
nsCOMPtr<nsINode> inputNode = do_QueryInterface(inputElm);
|
|
|
|
if (inputNode) {
|
2012-05-29 01:18:45 +00:00
|
|
|
Accessible* input =
|
2012-02-15 19:22:17 +00:00
|
|
|
mDoc->GetAccessible(inputNode);
|
2011-09-28 01:46:11 +00:00
|
|
|
return input ? input->ContainerWidget() : nsnull;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nsnull;
|
|
|
|
}
|
|
|
|
|
2008-02-19 09:07:35 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// nsXULListitemAccessible
|
2009-09-11 01:07:56 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
2008-02-19 09:07:35 +00:00
|
|
|
|
|
|
|
nsXULListitemAccessible::
|
2012-05-27 09:01:40 +00:00
|
|
|
nsXULListitemAccessible(nsIContent* aContent, DocAccessible* aDoc) :
|
2012-02-07 22:38:54 +00:00
|
|
|
nsXULMenuitemAccessible(aContent, aDoc)
|
2002-02-18 07:35:10 +00:00
|
|
|
{
|
2010-06-11 08:23:18 +00:00
|
|
|
mIsCheckbox = mContent->AttrValueIs(kNameSpaceID_None,
|
2011-06-03 21:35:17 +00:00
|
|
|
nsGkAtoms::type,
|
|
|
|
nsGkAtoms::checkbox,
|
2010-06-11 08:23:18 +00:00
|
|
|
eCaseMatters);
|
2002-02-18 07:35:10 +00:00
|
|
|
}
|
|
|
|
|
2012-05-29 01:18:45 +00:00
|
|
|
NS_IMPL_ISUPPORTS_INHERITED0(nsXULListitemAccessible, Accessible)
|
2002-02-18 07:35:10 +00:00
|
|
|
|
2012-05-29 01:18:45 +00:00
|
|
|
Accessible*
|
2008-02-19 09:07:35 +00:00
|
|
|
nsXULListitemAccessible::GetListAccessible()
|
|
|
|
{
|
|
|
|
if (IsDefunct())
|
|
|
|
return nsnull;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMXULSelectControlItemElement> listItem =
|
2010-06-11 08:23:18 +00:00
|
|
|
do_QueryInterface(mContent);
|
2008-02-22 11:07:54 +00:00
|
|
|
if (!listItem)
|
|
|
|
return nsnull;
|
|
|
|
|
2008-02-19 09:07:35 +00:00
|
|
|
nsCOMPtr<nsIDOMXULSelectControlElement> list;
|
|
|
|
listItem->GetControl(getter_AddRefs(list));
|
2008-06-11 08:36:57 +00:00
|
|
|
|
2010-06-11 08:23:18 +00:00
|
|
|
nsCOMPtr<nsIContent> listContent(do_QueryInterface(list));
|
|
|
|
if (!listContent)
|
2008-02-19 09:07:35 +00:00
|
|
|
return nsnull;
|
|
|
|
|
2012-02-07 22:38:54 +00:00
|
|
|
return mDoc->GetAccessible(listContent);
|
2008-02-19 09:07:35 +00:00
|
|
|
}
|
|
|
|
|
2011-04-23 13:14:05 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
2012-05-29 01:18:45 +00:00
|
|
|
// nsXULListitemAccessible Accessible
|
2011-04-23 13:14:05 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
nsXULListitemAccessible::Description(nsString& aDesc)
|
|
|
|
{
|
2012-05-29 01:18:45 +00:00
|
|
|
AccessibleWrap::Description(aDesc);
|
2011-04-23 13:14:05 +00:00
|
|
|
}
|
|
|
|
|
2008-02-19 09:07:35 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// nsXULListitemAccessible. nsIAccessible
|
|
|
|
|
2002-02-18 07:35:10 +00:00
|
|
|
/**
|
|
|
|
* If there is a Listcell as a child ( not anonymous ) use it, otherwise
|
2003-07-31 08:09:39 +00:00
|
|
|
* default to getting the name from GetXULName
|
2002-02-18 07:35:10 +00:00
|
|
|
*/
|
2008-10-10 12:26:55 +00:00
|
|
|
nsresult
|
|
|
|
nsXULListitemAccessible::GetNameInternal(nsAString& aName)
|
2002-02-18 07:35:10 +00:00
|
|
|
{
|
2011-12-07 07:20:17 +00:00
|
|
|
nsIContent* childContent = mContent->GetFirstChild();
|
|
|
|
if (childContent) {
|
|
|
|
if (childContent->NodeInfo()->Equals(nsGkAtoms::listcell,
|
|
|
|
kNameSpaceID_XUL)) {
|
|
|
|
childContent->GetAttr(kNameSpaceID_None, nsGkAtoms::label, aName);
|
2010-06-11 08:23:18 +00:00
|
|
|
return NS_OK;
|
2002-02-18 07:35:10 +00:00
|
|
|
}
|
|
|
|
}
|
2008-08-24 16:45:56 +00:00
|
|
|
return GetXULName(aName);
|
2002-02-18 07:35:10 +00:00
|
|
|
}
|
|
|
|
|
2012-01-12 03:07:35 +00:00
|
|
|
role
|
2010-09-05 02:14:01 +00:00
|
|
|
nsXULListitemAccessible::NativeRole()
|
2002-02-18 07:35:10 +00:00
|
|
|
{
|
2012-05-29 01:18:45 +00:00
|
|
|
Accessible* list = GetListAccessible();
|
2010-09-05 02:14:01 +00:00
|
|
|
if (!list) {
|
|
|
|
NS_ERROR("No list accessible for listitem accessible!");
|
2012-01-12 03:07:35 +00:00
|
|
|
return roles::NOTHING;
|
2008-02-19 09:07:35 +00:00
|
|
|
}
|
|
|
|
|
2012-01-12 03:07:35 +00:00
|
|
|
if (list->Role() == roles::TABLE)
|
|
|
|
return roles::ROW;
|
2010-09-05 02:14:01 +00:00
|
|
|
|
2004-06-09 04:11:01 +00:00
|
|
|
if (mIsCheckbox)
|
2012-03-24 01:09:10 +00:00
|
|
|
return roles::CHECK_RICH_OPTION;
|
2010-09-05 02:14:01 +00:00
|
|
|
|
2012-01-12 03:07:35 +00:00
|
|
|
if (mParent && mParent->Role() == roles::COMBOBOX_LIST)
|
|
|
|
return roles::COMBOBOX_OPTION;
|
2010-09-05 02:14:01 +00:00
|
|
|
|
2012-01-12 03:07:35 +00:00
|
|
|
return roles::RICH_OPTION;
|
2002-02-18 07:35:10 +00:00
|
|
|
}
|
|
|
|
|
2011-04-09 23:38:06 +00:00
|
|
|
PRUint64
|
|
|
|
nsXULListitemAccessible::NativeState()
|
2002-02-18 07:35:10 +00:00
|
|
|
{
|
2011-04-12 06:18:42 +00:00
|
|
|
if (mIsCheckbox)
|
2011-04-09 23:38:06 +00:00
|
|
|
return nsXULMenuitemAccessible::NativeState();
|
2004-07-27 19:53:07 +00:00
|
|
|
|
2011-04-09 23:38:06 +00:00
|
|
|
PRUint64 states = states::FOCUSABLE | states::SELECTABLE;
|
2009-09-11 01:07:56 +00:00
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMXULSelectControlItemElement> listItem =
|
2010-06-11 08:23:18 +00:00
|
|
|
do_QueryInterface(mContent);
|
2009-09-11 01:07:56 +00:00
|
|
|
|
2002-02-18 07:35:10 +00:00
|
|
|
if (listItem) {
|
2011-09-29 06:19:26 +00:00
|
|
|
bool isSelected;
|
2002-02-18 07:35:10 +00:00
|
|
|
listItem->GetSelected(&isSelected);
|
|
|
|
if (isSelected)
|
2011-04-09 23:38:06 +00:00
|
|
|
states |= states::SELECTED;
|
2002-02-18 07:35:10 +00:00
|
|
|
|
2011-09-28 01:46:11 +00:00
|
|
|
if (FocusMgr()->IsFocused(this))
|
2011-04-09 23:38:06 +00:00
|
|
|
states |= states::FOCUSED;
|
2002-02-18 07:35:10 +00:00
|
|
|
}
|
|
|
|
|
2011-04-09 23:38:06 +00:00
|
|
|
return states;
|
2002-02-18 07:35:10 +00:00
|
|
|
}
|
|
|
|
|
2007-02-25 03:43:20 +00:00
|
|
|
NS_IMETHODIMP nsXULListitemAccessible::GetActionName(PRUint8 aIndex, nsAString& aName)
|
2004-06-09 04:11:01 +00:00
|
|
|
{
|
2007-02-25 03:43:20 +00:00
|
|
|
if (aIndex == eAction_Click && mIsCheckbox) {
|
2004-06-09 04:11:01 +00:00
|
|
|
// check or uncheck
|
2011-04-09 23:38:06 +00:00
|
|
|
PRUint64 states = NativeState();
|
2004-08-18 14:39:45 +00:00
|
|
|
|
2011-04-09 23:38:06 +00:00
|
|
|
if (states & states::CHECKED)
|
2007-02-25 03:43:20 +00:00
|
|
|
aName.AssignLiteral("uncheck");
|
2004-06-09 04:11:01 +00:00
|
|
|
else
|
2007-02-25 03:43:20 +00:00
|
|
|
aName.AssignLiteral("check");
|
2004-08-18 14:39:45 +00:00
|
|
|
|
2004-06-09 04:11:01 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
2007-02-09 02:03:08 +00:00
|
|
|
|
2011-09-29 06:19:26 +00:00
|
|
|
bool
|
2012-02-08 07:31:25 +00:00
|
|
|
nsXULListitemAccessible::CanHaveAnonChildren()
|
2007-05-01 06:03:08 +00:00
|
|
|
{
|
|
|
|
// That indicates we should walk anonymous children for listitems
|
2011-10-17 14:59:28 +00:00
|
|
|
return true;
|
2007-05-01 06:03:08 +00:00
|
|
|
}
|
|
|
|
|
2011-09-28 01:46:11 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// nsXULListitemAccessible: Widgets
|
|
|
|
|
2012-05-29 01:18:45 +00:00
|
|
|
Accessible*
|
2011-09-28 01:46:11 +00:00
|
|
|
nsXULListitemAccessible::ContainerWidget() const
|
|
|
|
{
|
|
|
|
return Parent();
|
|
|
|
}
|
|
|
|
|
2008-02-19 13:47:19 +00:00
|
|
|
|
2008-02-19 09:07:35 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// nsXULListCellAccessible
|
2009-09-11 01:07:56 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
2008-02-19 09:07:35 +00:00
|
|
|
nsXULListCellAccessible::
|
2012-05-27 09:01:40 +00:00
|
|
|
nsXULListCellAccessible(nsIContent* aContent, DocAccessible* aDoc) :
|
2012-05-31 08:04:41 +00:00
|
|
|
HyperTextAccessibleWrap(aContent, aDoc)
|
2008-02-19 09:07:35 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// nsISupports
|
2008-02-19 09:07:35 +00:00
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
NS_IMPL_ISUPPORTS_INHERITED1(nsXULListCellAccessible,
|
2012-05-31 08:04:41 +00:00
|
|
|
HyperTextAccessible,
|
2009-09-11 01:07:56 +00:00
|
|
|
nsIAccessibleTableCell)
|
2001-12-17 01:21:29 +00:00
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// nsXULListCellAccessible: nsIAccessibleTableCell implementation
|
2001-12-17 01:21:29 +00:00
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsXULListCellAccessible::GetTable(nsIAccessibleTable **aTable)
|
2001-12-17 01:21:29 +00:00
|
|
|
{
|
2009-09-11 01:07:56 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(aTable);
|
|
|
|
*aTable = nsnull;
|
2001-12-17 01:21:29 +00:00
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
if (IsDefunct())
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2012-05-29 01:18:45 +00:00
|
|
|
Accessible* thisRow = Parent();
|
2012-01-12 03:07:35 +00:00
|
|
|
if (!thisRow || thisRow->Role() != roles::ROW)
|
2009-09-11 01:07:56 +00:00
|
|
|
return NS_OK;
|
|
|
|
|
2012-05-29 01:18:45 +00:00
|
|
|
Accessible* table = thisRow->Parent();
|
2012-01-12 03:07:35 +00:00
|
|
|
if (!table || table->Role() != roles::TABLE)
|
2009-09-11 01:07:56 +00:00
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
CallQueryInterface(table, aTable);
|
|
|
|
return NS_OK;
|
2007-02-09 02:03:08 +00:00
|
|
|
}
|
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsXULListCellAccessible::GetColumnIndex(PRInt32 *aColumnIndex)
|
2002-06-12 05:16:30 +00:00
|
|
|
{
|
2009-09-11 01:07:56 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(aColumnIndex);
|
|
|
|
*aColumnIndex = -1;
|
|
|
|
|
|
|
|
if (IsDefunct())
|
2006-05-03 13:36:46 +00:00
|
|
|
return NS_ERROR_FAILURE;
|
2009-09-11 01:07:56 +00:00
|
|
|
|
2012-05-29 01:18:45 +00:00
|
|
|
Accessible* row = Parent();
|
2010-09-07 02:41:53 +00:00
|
|
|
if (!row)
|
|
|
|
return NS_OK;
|
2009-09-11 01:07:56 +00:00
|
|
|
|
2010-09-07 02:41:53 +00:00
|
|
|
*aColumnIndex = 0;
|
2009-09-11 01:07:56 +00:00
|
|
|
|
2011-06-13 09:08:40 +00:00
|
|
|
PRInt32 indexInRow = IndexInParent();
|
2010-09-07 02:41:53 +00:00
|
|
|
for (PRInt32 idx = 0; idx < indexInRow; idx++) {
|
2012-05-29 01:18:45 +00:00
|
|
|
Accessible* cell = row->GetChildAt(idx);
|
2012-01-12 03:07:35 +00:00
|
|
|
roles::Role role = cell->Role();
|
|
|
|
if (role == roles::CELL || role == roles::GRID_CELL ||
|
|
|
|
role == roles::ROWHEADER || role == roles::COLUMNHEADER)
|
2009-09-11 01:07:56 +00:00
|
|
|
(*aColumnIndex)++;
|
2006-05-03 13:36:46 +00:00
|
|
|
}
|
2009-09-11 01:07:56 +00:00
|
|
|
|
2002-06-12 05:16:30 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsXULListCellAccessible::GetRowIndex(PRInt32 *aRowIndex)
|
2002-06-12 05:16:30 +00:00
|
|
|
{
|
2009-09-11 01:07:56 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(aRowIndex);
|
|
|
|
*aRowIndex = -1;
|
2002-06-12 05:16:30 +00:00
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
if (IsDefunct())
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
2012-05-29 01:18:45 +00:00
|
|
|
Accessible* row = Parent();
|
2010-09-07 02:41:53 +00:00
|
|
|
if (!row)
|
|
|
|
return NS_OK;
|
2009-09-11 01:07:56 +00:00
|
|
|
|
2012-05-29 01:18:45 +00:00
|
|
|
Accessible* table = row->Parent();
|
2010-09-07 02:41:53 +00:00
|
|
|
if (!table)
|
|
|
|
return NS_OK;
|
2002-06-12 05:16:30 +00:00
|
|
|
|
2010-09-07 02:41:53 +00:00
|
|
|
*aRowIndex = 0;
|
|
|
|
|
2011-06-13 09:08:40 +00:00
|
|
|
PRInt32 indexInTable = row->IndexInParent();
|
2010-09-07 02:41:53 +00:00
|
|
|
for (PRInt32 idx = 0; idx < indexInTable; idx++) {
|
|
|
|
row = table->GetChildAt(idx);
|
2012-01-12 03:07:35 +00:00
|
|
|
if (row->Role() == roles::ROW)
|
2010-09-07 02:41:53 +00:00
|
|
|
(*aRowIndex)++;
|
2009-09-11 01:07:56 +00:00
|
|
|
}
|
2002-06-12 05:16:30 +00:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsXULListCellAccessible::GetColumnExtent(PRInt32 *aExtentCount)
|
2001-12-17 01:21:29 +00:00
|
|
|
{
|
2009-09-11 01:07:56 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(aExtentCount);
|
|
|
|
*aExtentCount = 0;
|
2004-06-02 04:06:28 +00:00
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
if (IsDefunct())
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
*aExtentCount = 1;
|
|
|
|
return NS_OK;
|
2001-12-17 01:21:29 +00:00
|
|
|
}
|
2005-04-05 11:11:57 +00:00
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsXULListCellAccessible::GetRowExtent(PRInt32 *aExtentCount)
|
2005-05-05 15:05:34 +00:00
|
|
|
{
|
2009-09-11 01:07:56 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(aExtentCount);
|
|
|
|
*aExtentCount = 0;
|
|
|
|
|
|
|
|
if (IsDefunct())
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
*aExtentCount = 1;
|
2005-05-05 15:05:34 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsXULListCellAccessible::GetColumnHeaderCells(nsIArray **aHeaderCells)
|
2006-07-26 19:38:25 +00:00
|
|
|
{
|
2009-09-11 01:07:56 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(aHeaderCells);
|
|
|
|
*aHeaderCells = nsnull;
|
2006-07-26 19:38:25 +00:00
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
if (IsDefunct())
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIAccessibleTable> table;
|
|
|
|
GetTable(getter_AddRefs(table));
|
2009-11-17 21:14:45 +00:00
|
|
|
NS_ENSURE_STATE(table); // we expect to be in a listbox (table)
|
2009-09-11 01:07:56 +00:00
|
|
|
|
|
|
|
// Get column header cell from XUL listhead.
|
2012-05-29 01:18:45 +00:00
|
|
|
Accessible* list = nsnull;
|
2010-05-18 14:03:56 +00:00
|
|
|
|
2012-05-29 01:18:45 +00:00
|
|
|
nsRefPtr<Accessible> tableAcc(do_QueryObject(table));
|
2012-05-25 10:53:45 +00:00
|
|
|
PRUint32 tableChildCount = tableAcc->ChildCount();
|
|
|
|
for (PRUint32 childIdx = 0; childIdx < tableChildCount; childIdx++) {
|
2012-05-29 01:18:45 +00:00
|
|
|
Accessible* child = tableAcc->GetChildAt(childIdx);
|
2012-01-12 03:07:35 +00:00
|
|
|
if (child->Role() == roles::LIST) {
|
2010-05-18 14:03:56 +00:00
|
|
|
list = child;
|
2009-09-11 01:07:56 +00:00
|
|
|
break;
|
2010-05-18 14:03:56 +00:00
|
|
|
}
|
2005-04-05 11:11:57 +00:00
|
|
|
}
|
2009-06-18 07:37:38 +00:00
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
if (list) {
|
|
|
|
PRInt32 colIdx = -1;
|
|
|
|
GetColumnIndex(&colIdx);
|
|
|
|
|
2010-05-18 14:03:56 +00:00
|
|
|
nsIAccessible *headerCell = list->GetChildAt(colIdx);
|
2009-09-11 01:07:56 +00:00
|
|
|
if (headerCell) {
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
nsCOMPtr<nsIMutableArray> headerCells =
|
|
|
|
do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
2011-10-17 14:59:28 +00:00
|
|
|
headerCells->AppendElement(headerCell, false);
|
2009-09-11 01:07:56 +00:00
|
|
|
NS_ADDREF(*aHeaderCells = headerCells);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// No column header cell from XUL markup, try to get it from ARIA markup.
|
|
|
|
return nsAccUtils::GetHeaderCellsFor(table, this,
|
|
|
|
nsAccUtils::eColumnHeaderCells,
|
|
|
|
aHeaderCells);
|
2005-04-05 11:11:57 +00:00
|
|
|
}
|
2006-07-26 19:38:25 +00:00
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
nsXULListCellAccessible::GetRowHeaderCells(nsIArray **aHeaderCells)
|
2007-01-11 20:07:36 +00:00
|
|
|
{
|
2009-09-11 01:07:56 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(aHeaderCells);
|
|
|
|
*aHeaderCells = nsnull;
|
|
|
|
|
|
|
|
if (IsDefunct())
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
nsCOMPtr<nsIAccessibleTable> table;
|
|
|
|
GetTable(getter_AddRefs(table));
|
2009-11-17 21:14:45 +00:00
|
|
|
NS_ENSURE_STATE(table); // we expect to be in a listbox (table)
|
2009-09-11 01:07:56 +00:00
|
|
|
|
|
|
|
// Calculate row header cells from ARIA markup.
|
|
|
|
return nsAccUtils::GetHeaderCellsFor(table, this,
|
|
|
|
nsAccUtils::eRowHeaderCells,
|
|
|
|
aHeaderCells);
|
2007-01-11 20:07:36 +00:00
|
|
|
}
|
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
NS_IMETHODIMP
|
2011-09-29 06:19:26 +00:00
|
|
|
nsXULListCellAccessible::IsSelected(bool *aIsSelected)
|
2007-01-11 20:07:36 +00:00
|
|
|
{
|
2009-09-11 01:07:56 +00:00
|
|
|
NS_ENSURE_ARG_POINTER(aIsSelected);
|
2011-10-17 14:59:28 +00:00
|
|
|
*aIsSelected = false;
|
2007-01-11 20:07:36 +00:00
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
if (IsDefunct())
|
2007-01-11 20:07:36 +00:00
|
|
|
return NS_ERROR_FAILURE;
|
2009-09-11 01:07:56 +00:00
|
|
|
|
|
|
|
nsCOMPtr<nsIAccessibleTable> table;
|
|
|
|
GetTable(getter_AddRefs(table));
|
2009-11-17 21:14:45 +00:00
|
|
|
NS_ENSURE_STATE(table); // we expect to be in a listbox (table)
|
2009-09-11 01:07:56 +00:00
|
|
|
|
|
|
|
PRInt32 rowIdx = -1;
|
|
|
|
GetRowIndex(&rowIdx);
|
|
|
|
|
|
|
|
return table->IsRowSelected(rowIdx, aIsSelected);
|
2007-01-11 20:07:36 +00:00
|
|
|
}
|
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
2012-05-29 01:18:45 +00:00
|
|
|
// nsXULListCellAccessible. Accessible implementation
|
2009-09-11 01:07:56 +00:00
|
|
|
|
2012-01-12 03:07:35 +00:00
|
|
|
role
|
2010-09-05 02:14:01 +00:00
|
|
|
nsXULListCellAccessible::NativeRole()
|
2007-01-11 20:07:36 +00:00
|
|
|
{
|
2012-01-12 03:07:35 +00:00
|
|
|
return roles::CELL;
|
2009-09-11 01:07:56 +00:00
|
|
|
}
|
2007-01-11 20:07:36 +00:00
|
|
|
|
2009-09-11 01:07:56 +00:00
|
|
|
nsresult
|
|
|
|
nsXULListCellAccessible::GetAttributesInternal(nsIPersistentProperties *aAttributes)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG_POINTER(aAttributes);
|
|
|
|
|
|
|
|
if (IsDefunct())
|
2007-01-11 20:07:36 +00:00
|
|
|
return NS_ERROR_FAILURE;
|
2009-09-11 01:07:56 +00:00
|
|
|
|
|
|
|
// "table-cell-index" attribute
|
|
|
|
nsCOMPtr<nsIAccessibleTable> table;
|
|
|
|
GetTable(getter_AddRefs(table));
|
2009-11-17 21:14:45 +00:00
|
|
|
NS_ENSURE_STATE(table); // we expect to be in a listbox (table)
|
2009-09-11 01:07:56 +00:00
|
|
|
|
|
|
|
PRInt32 rowIdx = -1;
|
|
|
|
GetRowIndex(&rowIdx);
|
|
|
|
PRInt32 colIdx = -1;
|
|
|
|
GetColumnIndex(&colIdx);
|
|
|
|
|
|
|
|
PRInt32 cellIdx = -1;
|
|
|
|
table->GetCellIndexAt(rowIdx, colIdx, &cellIdx);
|
|
|
|
|
|
|
|
nsAutoString stringIdx;
|
|
|
|
stringIdx.AppendInt(cellIdx);
|
2011-06-03 21:35:17 +00:00
|
|
|
nsAccUtils::SetAccAttr(aAttributes, nsGkAtoms::tableCellIndex,
|
2009-09-11 01:07:56 +00:00
|
|
|
stringIdx);
|
2007-01-11 20:07:36 +00:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|