PRUint64
nsXFormsEditableAccessible::NativeState()
{
PRUint64 state = nsXFormsAccessible::NativeState();
nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
PRBool isReadonly = PR_FALSE;
nsresult rv = sXFormsService->IsReadonly(DOMNode, &isReadonly);
NS_ENSURE_SUCCESS(rv, state);
if (!isReadonly) {
PRBool isRelevant = PR_FALSE;
rv = sXFormsService->IsRelevant(DOMNode, &isRelevant);
NS_ENSURE_SUCCESS(rv, state);
if (isRelevant) {
state |= states::EDITABLE | states::SELECTABLE_TEXT;
}
}
nsCOMPtr<nsIEditor> editor;
GetAssociatedEditor(getter_AddRefs(editor));
NS_ENSURE_TRUE(editor, state);
PRUint32 flags;
editor->GetFlags(&flags);
if (flags & nsIPlaintextEditor::eEditorSingleLineMask)
state |= states::SINGLE_LINE;
else
state |= states::MULTI_LINE;
return state;
}
nsresult
nsXFormsAccessible::GetBoundChildElementValue(const nsAString& aTagName,
nsAString& aValue)
{
NS_ENSURE_TRUE(sXFormsService, NS_ERROR_FAILURE);
if (IsDefunct())
return NS_ERROR_FAILURE;
nsINodeList* nodes = mContent->GetChildNodesList();
NS_ENSURE_STATE(nodes);
PRUint32 length;
nsresult rv = nodes->GetLength(&length);
NS_ENSURE_SUCCESS(rv, rv);
for (PRUint32 index = 0; index < length; index++) {
nsIContent* content = nodes->GetNodeAt(index);
if (content->NodeInfo()->Equals(aTagName) &&
content->NodeInfo()->NamespaceEquals(NS_LITERAL_STRING(NS_NAMESPACE_XFORMS))) {
nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(content));
return sXFormsService->GetValue(DOMNode, aValue);
}
}
aValue.Truncate();
return NS_OK;
}
NS_IMETHODIMP
nsXFormsAccessible::GetValue(nsAString& aValue)
{
NS_ENSURE_TRUE(sXFormsService, NS_ERROR_FAILURE);
nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
return sXFormsService->GetValue(DOMNode, aValue);
}
NS_IMETHODIMP
nsXULTabpanelAccessible::GetRelationByType(PRUint32 aRelationType,
nsIAccessibleRelation **aRelation)
{
nsresult rv = nsAccessibleWrap::GetRelationByType(aRelationType, aRelation);
NS_ENSURE_SUCCESS(rv, rv);
if (aRelationType != nsIAccessibleRelation::RELATION_LABELLED_BY)
return NS_OK;
// Expose 'LABELLED_BY' relation on tabpanel accessible for tab accessible.
nsCOMPtr<nsIDOMXULRelatedElement> tabpanelsElm =
do_QueryInterface(mContent->GetParent());
if (!tabpanelsElm)
return NS_OK;
nsCOMPtr<nsIDOMNode> DOMNode(GetDOMNode());
nsCOMPtr<nsIDOMNode> tabNode;
tabpanelsElm->GetRelatedElement(DOMNode, getter_AddRefs(tabNode));
if (!tabNode)
return NS_OK;
nsCOMPtr<nsIContent> tabContent(do_QueryInterface(tabNode));
return nsRelUtils::AddTargetFromContent(aRelationType, aRelation,
tabContent);
}
nsAccessible*
nsXFormsSelectableAccessible::GetSelectedItem(PRUint32 aIndex)
{
nsresult rv;
nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
if (mIsSelect1Element) {
if (aIndex != 0)
return nsnull;
nsCOMPtr<nsIDOMNode> itemDOMNode;
rv = sXFormsService->GetSelectedItemForSelect1(DOMNode,
getter_AddRefs(itemDOMNode));
if (NS_SUCCEEDED(rv) && itemDOMNode) {
nsCOMPtr<nsINode> itemNode(do_QueryInterface(itemDOMNode));
return GetAccService()->GetAccessibleInWeakShell(itemNode, mWeakShell);
}
return nsnull;
}
nsCOMPtr<nsIDOMNodeList> itemNodeList;
rv = sXFormsService->GetSelectedItemsForSelect(DOMNode,
getter_AddRefs(itemNodeList));
if (NS_FAILED(rv) || !itemNodeList)
return nsnull;
nsCOMPtr<nsIDOMNode> itemDOMNode;
itemNodeList->Item(aIndex, getter_AddRefs(itemDOMNode));
nsCOMPtr<nsINode> itemNode(do_QueryInterface(itemDOMNode));
return GetAccService()->GetAccessibleInWeakShell(itemNode, mWeakShell);
}
NS_IMETHODIMP
nsXFormsInputAccessible::DoAction(PRUint8 aIndex)
{
if (aIndex != eAction_Click)
return NS_ERROR_INVALID_ARG;
nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
return sXFormsService->Focus(DOMNode);
}
bool
nsXFormsSelectableAccessible::SelectAll()
{
if (mIsSelect1Element)
return false;
nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
sXFormsService->SelectAllItemsForSelect(DOMNode);
return true;
}
bool
nsXFormsSelectableAccessible::UnselectAll()
{
nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
if (mIsSelect1Element)
sXFormsService->SetSelectedItemForSelect1(DOMNode, nsnull);
sXFormsService->ClearSelectionForSelect(DOMNode);
return true;
}
already_AddRefed<nsIArray>
nsXFormsSelectableAccessible::SelectedItems()
{
nsCOMPtr<nsIMutableArray> selectedItems =
do_CreateInstance(NS_ARRAY_CONTRACTID);
if (!selectedItems)
return nsnull;
nsresult rv;
nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
if (mIsSelect1Element) {
nsCOMPtr<nsIDOMNode> itemDOMNode;
rv = sXFormsService->GetSelectedItemForSelect1(DOMNode,
getter_AddRefs(itemDOMNode));
if (NS_FAILED(rv) || !itemDOMNode)
return nsnull;
nsCOMPtr<nsINode> itemNode(do_QueryInterface(itemDOMNode));
nsIAccessible* item = GetAccService()->GetAccessibleInWeakShell(itemNode,
mWeakShell);
if (item)
selectedItems->AppendElement(item, PR_FALSE);
nsIMutableArray* items = nsnull;
selectedItems.forget(&items);
return items;
}
nsCOMPtr<nsIDOMNodeList> itemNodeList;
rv = sXFormsService->GetSelectedItemsForSelect(DOMNode,
getter_AddRefs(itemNodeList));
if (NS_FAILED(rv) || !itemNodeList)
return nsnull;
PRUint32 length = 0;
itemNodeList->GetLength(&length);
for (PRUint32 index = 0; index < length; index++) {
nsCOMPtr<nsIDOMNode> itemDOMNode;
itemNodeList->Item(index, getter_AddRefs(itemDOMNode));
if (!itemDOMNode)
return nsnull;
nsCOMPtr<nsINode> itemNode(do_QueryInterface(itemDOMNode));
nsIAccessible* item = GetAccService()->GetAccessibleInWeakShell(itemNode,
mWeakShell);
if (item)
selectedItems->AppendElement(item, PR_FALSE);
}
nsIMutableArray* items = nsnull;
selectedItems.forget(&items);
return items;
}
nsresult
nsTextEquivUtils::AppendTextEquivFromTextContent(nsIContent *aContent,
nsAString *aString)
{
if (aContent->IsNodeOfType(nsINode::eTEXT)) {
nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(aContent));
PRBool isHTMLBlock = PR_FALSE;
nsIContent *parentContent = aContent->GetParent();
if (parentContent) {
nsIFrame *frame = parentContent->GetPrimaryFrame();
if (frame) {
// If this text is inside a block level frame (as opposed to span
// level), we need to add spaces around that block's text, so we don't
// get words jammed together in final name.
const nsStyleDisplay* display = frame->GetStyleDisplay();
if (display->IsBlockOutside() ||
display->mDisplay == NS_STYLE_DISPLAY_TABLE_CELL) {
isHTMLBlock = PR_TRUE;
if (!aString->IsEmpty()) {
aString->Append(PRUnichar(' '));
}
}
}
}
if (aContent->TextLength() > 0) {
nsIFrame *frame = aContent->GetPrimaryFrame();
if (frame) {
nsresult rv = frame->GetRenderedText(aString);
NS_ENSURE_SUCCESS(rv, rv);
} else {
// If aContent is an object that is display: none, we have no a frame.
aContent->AppendTextTo(*aString);
}
if (isHTMLBlock && !aString->IsEmpty()) {
aString->Append(PRUnichar(' '));
}
}
return NS_OK;
}
if (aContent->IsHTML() &&
aContent->NodeInfo()->Equals(nsAccessibilityAtoms::br)) {
aString->AppendLiteral("\r\n");
return NS_OK;
}
return NS_OK_NO_NAME_CLAUSE_HANDLED;
}
NS_IMETHODIMP
nsXFormsRangeAccessible::GetCurrentValue(double *aCurrentValue)
{
NS_ENSURE_ARG_POINTER(aCurrentValue);
nsAutoString value;
nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
nsresult rv = sXFormsService->GetValue(DOMNode, value);
NS_ENSURE_SUCCESS(rv, rv);
PRInt32 error = NS_OK;
*aCurrentValue = value.ToDouble(&error);
return error;
}
PRUint64
nsXFormsInputBooleanAccessible::NativeState()
{
PRUint64 state = nsXFormsAccessible::NativeState();
nsAutoString value;
nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
nsresult rv = sXFormsService->GetValue(DOMNode, value);
NS_ENSURE_SUCCESS(rv, state);
if (value.EqualsLiteral("true"))
state |= states::CHECKED;
return state;
}
bool
nsXFormsSelectableAccessible::AddItemToSelection(PRUint32 aIndex)
{
nsCOMPtr<nsIDOMNode> itemDOMNode(do_QueryInterface(GetItemByIndex(&aIndex)));
if (!itemDOMNode)
return false;
nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
if (mIsSelect1Element)
sXFormsService->SetSelectedItemForSelect1(DOMNode, itemDOMNode);
else
sXFormsService->AddItemToSelectionForSelect(DOMNode, itemDOMNode);
return true;
}
PRUint64
nsXFormsSelectAccessible::NativeState()
{
PRUint64 state = nsXFormsContainerAccessible::NativeState();
PRUint32 isInRange = nsIXFormsUtilityService::STATE_NOT_A_RANGE;
nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
nsresult rv = sXFormsService->IsInRange(DOMNode, &isInRange);
NS_ENSURE_SUCCESS(rv, state);
if (isInRange == nsIXFormsUtilityService::STATE_OUT_OF_RANGE)
state |= states::INVALID;
return state;
}
NS_IMETHODIMP
nsHTMLLinkAccessible::GetValue(nsAString& aValue)
{
aValue.Truncate();
nsresult rv = nsHyperTextAccessible::GetValue(aValue);
NS_ENSURE_SUCCESS(rv, rv);
if (!aValue.IsEmpty())
return NS_OK;
nsCOMPtr<nsIPresShell> presShell(do_QueryReferent(mWeakShell));
nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
return presShell->GetLinkLocation(DOMNode, aValue);
}
nsresult
nsXFormsRangeAccessible::GetStateInternal(PRUint32 *aState,
PRUint32 *aExtraState)
{
nsresult rv = nsXFormsAccessible::GetStateInternal(aState, aExtraState);
NS_ENSURE_A11Y_SUCCESS(rv, rv);
PRUint32 isInRange = nsIXFormsUtilityService::STATE_NOT_A_RANGE;
nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
rv = sXFormsService->IsInRange(DOMNode, &isInRange);
NS_ENSURE_SUCCESS(rv, rv);
if (isInRange == nsIXFormsUtilityService::STATE_OUT_OF_RANGE)
*aState |= nsIAccessibleStates::STATE_INVALID;
return NS_OK;
}
nsresult
nsXFormsInputBooleanAccessible::GetStateInternal(PRUint32 *aState,
PRUint32 *aExtraState)
{
nsresult rv = nsXFormsAccessible::GetStateInternal(aState, aExtraState);
NS_ENSURE_A11Y_SUCCESS(rv, rv);
nsAutoString value;
nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
rv = sXFormsService->GetValue(DOMNode, value);
NS_ENSURE_SUCCESS(rv, rv);
if (value.EqualsLiteral("true"))
*aState |= nsIAccessibleStates::STATE_CHECKED;
return NS_OK;
}
PRUint64
nsXFormsSelectComboboxAccessible::NativeState()
{
PRUint64 state = nsXFormsSelectableAccessible::NativeState();
PRBool isOpen = PR_FALSE;
nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
nsresult rv = sXFormsService->IsDropmarkerOpen(DOMNode, &isOpen);
NS_ENSURE_SUCCESS(rv, state);
if (isOpen)
state |= states::EXPANDED;
else
state |= states::COLLAPSED;
return state | states::HASPOPUP | states::FOCUSABLE;
}
NS_IMETHODIMP
nsXFormsInputBooleanAccessible::GetActionName(PRUint8 aIndex, nsAString& aName)
{
if (aIndex != eAction_Click)
return NS_ERROR_INVALID_ARG;
nsAutoString value;
nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
nsresult rv = sXFormsService->GetValue(DOMNode, value);
NS_ENSURE_SUCCESS(rv, rv);
if (value.EqualsLiteral("true"))
aName.AssignLiteral("uncheck");
else
aName.AssignLiteral("check");
return NS_OK;
}
bool
nsXFormsSelectableAccessible::IsItemSelected(PRUint32 aIndex)
{
nsCOMPtr<nsIDOMNode> itemDOMNode(do_QueryInterface(GetItemByIndex(&aIndex)));
if (!itemDOMNode)
return false;
nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
if (mIsSelect1Element) {
nsCOMPtr<nsIDOMNode> selItemDOMNode;
sXFormsService->GetSelectedItemForSelect1(DOMNode,
getter_AddRefs(selItemDOMNode));
return selItemDOMNode == itemDOMNode;
}
PRBool isSelected = PR_FALSE;
sXFormsService->IsSelectItemSelected(DOMNode, itemDOMNode, &isSelected);
return isSelected;
}
nsresult
nsTextEquivUtils::AppendTextEquivFromContent(nsIAccessible *aInitiatorAcc,
nsIContent *aContent,
nsAString *aString)
{
// Prevent recursion which can cause infinite loops.
if (gInitiatorAcc)
return NS_OK;
gInitiatorAcc = aInitiatorAcc;
nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(aContent));
nsCOMPtr<nsIPresShell> shell = nsCoreUtils::GetPresShellFor(DOMNode);
if (!shell) {
NS_ASSERTION(PR_TRUE, "There is no presshell!");
gInitiatorAcc = nsnull;
return NS_ERROR_UNEXPECTED;
}
// If the given content is not visible or isn't accessible then go down
// through the DOM subtree otherwise go down through accessible subtree and
// calculate the flat string.
nsIFrame *frame = aContent->GetPrimaryFrame();
PRBool isVisible = frame && frame->GetStyleVisibility()->IsVisible();
nsresult rv = NS_ERROR_FAILURE;
PRBool goThroughDOMSubtree = PR_TRUE;
if (isVisible) {
nsAccessible *accessible =
GetAccService()->GetAccessibleInShell(DOMNode, shell);
if (accessible) {
rv = AppendFromAccessible(accessible, aString);
goThroughDOMSubtree = PR_FALSE;
}
}
if (goThroughDOMSubtree)
rv = AppendFromDOMNode(aContent, aString);
gInitiatorAcc = nsnull;
return rv;
}
bool
nsXFormsSelectableAccessible::RemoveItemFromSelection(PRUint32 aIndex)
{
nsCOMPtr<nsIDOMNode> itemDOMNode(do_QueryInterface(GetItemByIndex(&aIndex)));
if (!itemDOMNode)
return false;
nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
if (mIsSelect1Element) {
nsCOMPtr<nsIDOMNode> selItemDOMNode;
sXFormsService->GetSelectedItemForSelect1(DOMNode,
getter_AddRefs(selItemDOMNode));
if (selItemDOMNode == itemDOMNode)
sXFormsService->SetSelectedItemForSelect1(DOMNode, nsnull);
return true;
}
sXFormsService->RemoveItemFromSelectionForSelect(DOMNode, itemDOMNode);
return true;
}
PRUint64
nsXFormsAccessible::NativeState()
{
NS_ENSURE_TRUE(sXFormsService, 0);
nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
PRBool isRelevant = PR_FALSE;
nsresult rv = sXFormsService->IsRelevant(DOMNode, &isRelevant);
NS_ENSURE_SUCCESS(rv, 0);
PRBool isReadonly = PR_FALSE;
rv = sXFormsService->IsReadonly(DOMNode, &isReadonly);
NS_ENSURE_SUCCESS(rv, 0);
PRBool isRequired = PR_FALSE;
rv = sXFormsService->IsRequired(DOMNode, &isRequired);
NS_ENSURE_SUCCESS(rv, 0);
PRBool isValid = PR_FALSE;
rv = sXFormsService->IsValid(DOMNode, &isValid);
NS_ENSURE_SUCCESS(rv, 0);
PRUint64 states = nsHyperTextAccessibleWrap::NativeState();
if (!isRelevant)
states |= states::UNAVAILABLE;
if (isReadonly)
states |= states::READONLY;
if (isRequired)
states |= states::REQUIRED;
if (!isValid)
states |= states::INVALID;
return states;
}
nsresult
nsXFormsSelectComboboxAccessible::GetStateInternal(PRUint32 *aState,
PRUint32 *aExtraState)
{
nsresult rv = nsXFormsSelectableAccessible::GetStateInternal(aState,
aExtraState);
NS_ENSURE_A11Y_SUCCESS(rv, rv);
PRBool isOpen = PR_FALSE;
nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
rv = sXFormsService->IsDropmarkerOpen(DOMNode, &isOpen);
NS_ENSURE_SUCCESS(rv, rv);
if (isOpen)
*aState = nsIAccessibleStates::STATE_EXPANDED;
else
*aState = nsIAccessibleStates::STATE_COLLAPSED;
*aState |= nsIAccessibleStates::STATE_HASPOPUP |
nsIAccessibleStates::STATE_FOCUSABLE;
return NS_OK;
}
PRUint32
nsXFormsSelectableAccessible::SelectedItemCount()
{
nsresult rv;
nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
if (mIsSelect1Element) {
nsCOMPtr<nsIDOMNode> item;
rv = sXFormsService->GetSelectedItemForSelect1(DOMNode,
getter_AddRefs(item));
return NS_SUCCEEDED(rv) && item ? 1 : 0;
}
nsCOMPtr<nsIDOMNodeList> itemNodeList;
rv = sXFormsService->GetSelectedItemsForSelect(DOMNode,
getter_AddRefs(itemNodeList));
if (NS_FAILED(rv) || !itemNodeList)
return 0;
PRUint32 length = 0;
itemNodeList->GetLength(&length);
return length;
}
PRBool
nsXFormsSelectableItemAccessible::IsItemSelected()
{
nsresult rv;
nsINode* parent = mContent;
while ((parent = parent->GetNodeParent())) {
nsCOMPtr<nsIContent> content(do_QueryInterface(parent));
if (!content)
return PR_FALSE;
nsCOMPtr<nsINodeInfo> nodeinfo = content->NodeInfo();
if (!nodeinfo->NamespaceEquals(NS_LITERAL_STRING(NS_NAMESPACE_XFORMS)))
continue;
nsCOMPtr<nsIDOMNode> select(do_QueryInterface(parent));
if (!select)
continue;
nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
if (nodeinfo->Equals(nsAccessibilityAtoms::select)) {
PRBool isSelected = PR_FALSE;
rv = sXFormsService->IsSelectItemSelected(select, DOMNode, &isSelected);
return NS_SUCCEEDED(rv) && isSelected;
}
if (nodeinfo->Equals(nsAccessibilityAtoms::select1)) {
nsCOMPtr<nsIDOMNode> selitem;
rv = sXFormsService->GetSelectedItemForSelect1(select,
getter_AddRefs(selitem));
return NS_SUCCEEDED(rv) && (selitem == DOMNode);
}
}
return PR_FALSE;
}
NS_IMETHODIMP
nsXFormsEditableAccessible::GetAssociatedEditor(nsIEditor **aEditor)
{
nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
return sXFormsService->GetEditor(DOMNode, aEditor);
}
NS_IMETHODIMP
nsXFormsSelectableItemAccessible::GetValue(nsAString& aValue)
{
nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
return sXFormsService->GetValue(DOMNode, aValue);
}
