michael@0: /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
michael@0: /* This Source Code Form is subject to the terms of the Mozilla Public
michael@0:  * License, v. 2.0. If a copy of the MPL was not distributed with this
michael@0:  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
michael@0: 
michael@0: #include "Accessible-inl.h"
michael@0: 
michael@0: #include "nsIXBLAccessible.h"
michael@0: 
michael@0: #include "AccCollector.h"
michael@0: #include "AccGroupInfo.h"
michael@0: #include "AccIterator.h"
michael@0: #include "nsAccUtils.h"
michael@0: #include "nsAccessibleRelation.h"
michael@0: #include "nsAccessibilityService.h"
michael@0: #include "ApplicationAccessible.h"
michael@0: #include "nsCoreUtils.h"
michael@0: #include "nsIAccessibleRelation.h"
michael@0: #include "nsIAccessibleRole.h"
michael@0: #include "nsEventShell.h"
michael@0: #include "nsTextEquivUtils.h"
michael@0: #include "Relation.h"
michael@0: #include "Role.h"
michael@0: #include "RootAccessible.h"
michael@0: #include "States.h"
michael@0: #include "StyleInfo.h"
michael@0: #include "TableAccessible.h"
michael@0: #include "TableCellAccessible.h"
michael@0: #include "TreeWalker.h"
michael@0: 
michael@0: #include "nsIDOMElement.h"
michael@0: #include "nsIDOMNodeFilter.h"
michael@0: #include "nsIDOMHTMLElement.h"
michael@0: #include "nsIDOMKeyEvent.h"
michael@0: #include "nsIDOMTreeWalker.h"
michael@0: #include "nsIDOMXULButtonElement.h"
michael@0: #include "nsIDOMXULDocument.h"
michael@0: #include "nsIDOMXULElement.h"
michael@0: #include "nsIDOMXULLabelElement.h"
michael@0: #include "nsIDOMXULSelectCntrlEl.h"
michael@0: #include "nsIDOMXULSelectCntrlItemEl.h"
michael@0: #include "nsPIDOMWindow.h"
michael@0: 
michael@0: #include "nsIDocument.h"
michael@0: #include "nsIContent.h"
michael@0: #include "nsIForm.h"
michael@0: #include "nsIFormControl.h"
michael@0: 
michael@0: #include "nsDeckFrame.h"
michael@0: #include "nsLayoutUtils.h"
michael@0: #include "nsIPresShell.h"
michael@0: #include "nsIStringBundle.h"
michael@0: #include "nsPresContext.h"
michael@0: #include "nsIFrame.h"
michael@0: #include "nsView.h"
michael@0: #include "nsIDocShellTreeItem.h"
michael@0: #include "nsIScrollableFrame.h"
michael@0: #include "nsFocusManager.h"
michael@0: 
michael@0: #include "nsXPIDLString.h"
michael@0: #include "nsUnicharUtils.h"
michael@0: #include "nsReadableUtils.h"
michael@0: #include "prdtoa.h"
michael@0: #include "nsIAtom.h"
michael@0: #include "nsIURI.h"
michael@0: #include "nsArrayUtils.h"
michael@0: #include "nsIMutableArray.h"
michael@0: #include "nsIObserverService.h"
michael@0: #include "nsIServiceManager.h"
michael@0: #include "nsWhitespaceTokenizer.h"
michael@0: #include "nsAttrName.h"
michael@0: #include "nsNetUtil.h"
michael@0: 
michael@0: #ifdef DEBUG
michael@0: #include "nsIDOMCharacterData.h"
michael@0: #endif
michael@0: 
michael@0: #include "mozilla/Assertions.h"
michael@0: #include "mozilla/EventStates.h"
michael@0: #include "mozilla/FloatingPoint.h"
michael@0: #include "mozilla/MouseEvents.h"
michael@0: #include "mozilla/unused.h"
michael@0: #include "mozilla/Preferences.h"
michael@0: #include "mozilla/dom/Element.h"
michael@0: #include "mozilla/dom/TreeWalker.h"
michael@0: 
michael@0: using namespace mozilla;
michael@0: using namespace mozilla::a11y;
michael@0: 
michael@0: 
michael@0: ////////////////////////////////////////////////////////////////////////////////
michael@0: // Accessible: nsISupports and cycle collection
michael@0: 
michael@0: NS_IMPL_CYCLE_COLLECTION(Accessible,
michael@0:                          mContent, mParent, mChildren)
michael@0: 
michael@0: NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Accessible)
michael@0:   NS_INTERFACE_MAP_ENTRY(nsIAccessible)
michael@0:   if (aIID.Equals(NS_GET_IID(Accessible)))
michael@0:     foundInterface = static_cast<nsIAccessible*>(this);
michael@0:   else
michael@0:   NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAccessibleSelectable, IsSelect())
michael@0:   NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAccessibleValue, HasNumericValue())
michael@0:   NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAccessibleHyperLink, IsLink())
michael@0:   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIAccessible)
michael@0: NS_INTERFACE_MAP_END
michael@0: 
michael@0: NS_IMPL_CYCLE_COLLECTING_ADDREF(Accessible)
michael@0: NS_IMPL_CYCLE_COLLECTING_RELEASE_WITH_DESTROY(Accessible, LastRelease())
michael@0: 
michael@0: Accessible::Accessible(nsIContent* aContent, DocAccessible* aDoc) :
michael@0:   mContent(aContent), mDoc(aDoc),
michael@0:   mParent(nullptr), mIndexInParent(-1), mChildrenFlags(eChildrenUninitialized),
michael@0:   mStateFlags(0), mContextFlags(0), mType(0), mGenericTypes(0),
michael@0:   mIndexOfEmbeddedChild(-1), mRoleMapEntry(nullptr)
michael@0: {
michael@0: #ifdef NS_DEBUG_X
michael@0:    {
michael@0:      nsCOMPtr<nsIPresShell> shell(do_QueryReferent(aShell));
michael@0:      printf(">>> %p Created Acc - DOM: %p  PS: %p", 
michael@0:             (void*)static_cast<nsIAccessible*>(this), (void*)aNode,
michael@0:             (void*)shell.get());
michael@0:     nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
michael@0:     if (content) {
michael@0:       printf(" Con: %s@%p",
michael@0:              NS_ConvertUTF16toUTF8(content->NodeInfo()->QualifiedName()).get(),
michael@0:              (void *)content.get());
michael@0:       nsAutoString buf;
michael@0:       Name(buf);
michael@0:       printf(" Name:[%s]", NS_ConvertUTF16toUTF8(buf).get());
michael@0:      }
michael@0:      printf("\n");
michael@0:    }
michael@0: #endif
michael@0: }
michael@0: 
michael@0: Accessible::~Accessible()
michael@0: {
michael@0:   NS_ASSERTION(!mDoc, "LastRelease was never called!?!");
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetDocument(nsIAccessibleDocument** aDocument)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aDocument);
michael@0: 
michael@0:   NS_IF_ADDREF(*aDocument = Document());
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetDOMNode(nsIDOMNode** aDOMNode)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aDOMNode);
michael@0:   *aDOMNode = nullptr;
michael@0: 
michael@0:   nsINode *node = GetNode();
michael@0:   if (node)
michael@0:     CallQueryInterface(node, aDOMNode);
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetRootDocument(nsIAccessibleDocument** aRootDocument)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aRootDocument);
michael@0: 
michael@0:   NS_IF_ADDREF(*aRootDocument = RootAccessible());
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetLanguage(nsAString& aLanguage)
michael@0: {
michael@0:   Language(aLanguage);
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetName(nsAString& aName)
michael@0: {
michael@0:   aName.Truncate();
michael@0: 
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   nsAutoString name;
michael@0:   Name(name);
michael@0:   aName.Assign(name);
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: ENameValueFlag
michael@0: Accessible::Name(nsString& aName)
michael@0: {
michael@0:   aName.Truncate();
michael@0: 
michael@0:   if (!HasOwnContent())
michael@0:     return eNameOK;
michael@0: 
michael@0:   ARIAName(aName);
michael@0:   if (!aName.IsEmpty())
michael@0:     return eNameOK;
michael@0: 
michael@0:   nsCOMPtr<nsIXBLAccessible> xblAccessible(do_QueryInterface(mContent));
michael@0:   if (xblAccessible) {
michael@0:     xblAccessible->GetAccessibleName(aName);
michael@0:     if (!aName.IsEmpty())
michael@0:       return eNameOK;
michael@0:   }
michael@0: 
michael@0:   ENameValueFlag nameFlag = NativeName(aName);
michael@0:   if (!aName.IsEmpty())
michael@0:     return nameFlag;
michael@0: 
michael@0:   // In the end get the name from tooltip.
michael@0:   if (mContent->IsHTML()) {
michael@0:     if (mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::title, aName)) {
michael@0:       aName.CompressWhitespace();
michael@0:       return eNameFromTooltip;
michael@0:     }
michael@0:   } else if (mContent->IsXUL()) {
michael@0:     if (mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::tooltiptext, aName)) {
michael@0:       aName.CompressWhitespace();
michael@0:       return eNameFromTooltip;
michael@0:     }
michael@0:   } else if (mContent->IsSVG()) {
michael@0:     // If user agents need to choose among multiple ‘desc’ or ‘title’ elements
michael@0:     // for processing, the user agent shall choose the first one.
michael@0:     for (nsIContent* childElm = mContent->GetFirstChild(); childElm;
michael@0:          childElm = childElm->GetNextSibling()) {
michael@0:       if (childElm->IsSVG(nsGkAtoms::desc)) {
michael@0:         nsTextEquivUtils::AppendTextEquivFromContent(this, childElm, &aName);
michael@0:         return eNameFromTooltip;
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   if (nameFlag != eNoNameOnPurpose)
michael@0:     aName.SetIsVoid(true);
michael@0: 
michael@0:   return nameFlag;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetDescription(nsAString& aDescription)
michael@0: {
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   nsAutoString desc;
michael@0:   Description(desc);
michael@0:   aDescription.Assign(desc);
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: void
michael@0: Accessible::Description(nsString& aDescription)
michael@0: {
michael@0:   // There are 4 conditions that make an accessible have no accDescription:
michael@0:   // 1. it's a text node; or
michael@0:   // 2. It has no DHTML describedby property
michael@0:   // 3. it doesn't have an accName; or
michael@0:   // 4. its title attribute already equals to its accName nsAutoString name; 
michael@0: 
michael@0:   if (!HasOwnContent() || mContent->IsNodeOfType(nsINode::eTEXT))
michael@0:     return;
michael@0: 
michael@0:   nsTextEquivUtils::
michael@0:     GetTextEquivFromIDRefs(this, nsGkAtoms::aria_describedby,
michael@0:                            aDescription);
michael@0: 
michael@0:   if (aDescription.IsEmpty()) {
michael@0:     bool isXUL = mContent->IsXUL();
michael@0:     if (isXUL) {
michael@0:       // Try XUL <description control="[id]">description text</description>
michael@0:       XULDescriptionIterator iter(Document(), mContent);
michael@0:       Accessible* descr = nullptr;
michael@0:       while ((descr = iter.Next())) {
michael@0:         nsTextEquivUtils::AppendTextEquivFromContent(this, descr->GetContent(),
michael@0:                                                      &aDescription);
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     if (aDescription.IsEmpty()) {
michael@0:       // Keep the Name() method logic.
michael@0:       if (mContent->IsHTML()) {
michael@0:         mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::title, aDescription);
michael@0:       } else if (mContent->IsXUL()) {
michael@0:         mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::tooltiptext, aDescription);
michael@0:       } else if (mContent->IsSVG()) {
michael@0:         for (nsIContent* childElm = mContent->GetFirstChild(); childElm;
michael@0:              childElm = childElm->GetNextSibling()) {
michael@0:           if (childElm->IsSVG(nsGkAtoms::desc)) {
michael@0:             nsTextEquivUtils::AppendTextEquivFromContent(this, childElm,
michael@0:                                                          &aDescription);
michael@0:             break;
michael@0:           }
michael@0:         }
michael@0:       }
michael@0: 
michael@0:       if (!aDescription.IsEmpty()) {
michael@0:         nsAutoString name;
michael@0:         ENameValueFlag nameFlag = Name(name);
michael@0: 
michael@0:         // Don't use tooltip for a description if it was used for a name.
michael@0:         if (nameFlag == eNameFromTooltip)
michael@0:           aDescription.Truncate();
michael@0:       }
michael@0:     }
michael@0:   }
michael@0:   aDescription.CompressWhitespace();
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetAccessKey(nsAString& aAccessKey)
michael@0: {
michael@0:   aAccessKey.Truncate();
michael@0: 
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   AccessKey().ToString(aAccessKey);
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: KeyBinding
michael@0: Accessible::AccessKey() const
michael@0: {
michael@0:   if (!HasOwnContent())
michael@0:     return KeyBinding();
michael@0: 
michael@0:   uint32_t key = nsCoreUtils::GetAccessKeyFor(mContent);
michael@0:   if (!key && mContent->IsElement()) {
michael@0:     Accessible* label = nullptr;
michael@0: 
michael@0:     // Copy access key from label node.
michael@0:     if (mContent->IsHTML()) {
michael@0:       // Unless it is labeled via an ancestor <label>, in which case that would
michael@0:       // be redundant.
michael@0:       HTMLLabelIterator iter(Document(), this,
michael@0:                              HTMLLabelIterator::eSkipAncestorLabel);
michael@0:       label = iter.Next();
michael@0: 
michael@0:     } else if (mContent->IsXUL()) {
michael@0:       XULLabelIterator iter(Document(), mContent);
michael@0:       label = iter.Next();
michael@0:     }
michael@0: 
michael@0:     if (label)
michael@0:       key = nsCoreUtils::GetAccessKeyFor(label->GetContent());
michael@0:   }
michael@0: 
michael@0:   if (!key)
michael@0:     return KeyBinding();
michael@0: 
michael@0:   // Get modifier mask. Use ui.key.generalAccessKey (unless it is -1).
michael@0:   switch (Preferences::GetInt("ui.key.generalAccessKey", -1)) {
michael@0:   case -1:
michael@0:     break;
michael@0:   case nsIDOMKeyEvent::DOM_VK_SHIFT:
michael@0:     return KeyBinding(key, KeyBinding::kShift);
michael@0:   case nsIDOMKeyEvent::DOM_VK_CONTROL:
michael@0:     return KeyBinding(key, KeyBinding::kControl);
michael@0:   case nsIDOMKeyEvent::DOM_VK_ALT:
michael@0:     return KeyBinding(key, KeyBinding::kAlt);
michael@0:   case nsIDOMKeyEvent::DOM_VK_META:
michael@0:     return KeyBinding(key, KeyBinding::kMeta);
michael@0:   default:
michael@0:     return KeyBinding();
michael@0:   }
michael@0: 
michael@0:   // Determine the access modifier used in this context.
michael@0:   nsIDocument* document = mContent->GetCurrentDoc();
michael@0:   if (!document)
michael@0:     return KeyBinding();
michael@0: 
michael@0:   nsCOMPtr<nsIDocShellTreeItem> treeItem(document->GetDocShell());
michael@0:   if (!treeItem)
michael@0:     return KeyBinding();
michael@0: 
michael@0:   nsresult rv = NS_ERROR_FAILURE;
michael@0:   int32_t modifierMask = 0;
michael@0:   switch (treeItem->ItemType()) {
michael@0:     case nsIDocShellTreeItem::typeChrome:
michael@0:       rv = Preferences::GetInt("ui.key.chromeAccess", &modifierMask);
michael@0:       break;
michael@0:     case nsIDocShellTreeItem::typeContent:
michael@0:       rv = Preferences::GetInt("ui.key.contentAccess", &modifierMask);
michael@0:       break;
michael@0:   }
michael@0: 
michael@0:   return NS_SUCCEEDED(rv) ? KeyBinding(key, modifierMask) : KeyBinding();
michael@0: }
michael@0: 
michael@0: KeyBinding
michael@0: Accessible::KeyboardShortcut() const
michael@0: {
michael@0:   return KeyBinding();
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetParent(nsIAccessible** aParent)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aParent);
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   NS_IF_ADDREF(*aParent = Parent());
michael@0:   return *aParent ? NS_OK : NS_ERROR_FAILURE;
michael@0: }
michael@0: 
michael@0:   /* readonly attribute nsIAccessible nextSibling; */
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetNextSibling(nsIAccessible** aNextSibling)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aNextSibling);
michael@0:   *aNextSibling = nullptr;
michael@0: 
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   nsresult rv = NS_OK;
michael@0:   NS_IF_ADDREF(*aNextSibling = GetSiblingAtOffset(1, &rv));
michael@0:   return rv;
michael@0: }
michael@0: 
michael@0:   /* readonly attribute nsIAccessible previousSibling; */
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetPreviousSibling(nsIAccessible ** aPreviousSibling)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aPreviousSibling);
michael@0:   *aPreviousSibling = nullptr;
michael@0: 
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   nsresult rv = NS_OK;
michael@0:   NS_IF_ADDREF(*aPreviousSibling = GetSiblingAtOffset(-1, &rv));
michael@0:   return rv;
michael@0: }
michael@0: 
michael@0:   /* readonly attribute nsIAccessible firstChild; */
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetFirstChild(nsIAccessible** aFirstChild)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aFirstChild);
michael@0:   *aFirstChild = nullptr;
michael@0: 
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   NS_IF_ADDREF(*aFirstChild = FirstChild());
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0:   /* readonly attribute nsIAccessible lastChild; */
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetLastChild(nsIAccessible** aLastChild)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aLastChild);
michael@0:   *aLastChild = nullptr;
michael@0: 
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   NS_IF_ADDREF(*aLastChild = LastChild());
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetChildAt(int32_t aChildIndex, nsIAccessible** aChild)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aChild);
michael@0:   *aChild = nullptr;
michael@0: 
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   // If child index is negative, then return last child.
michael@0:   // XXX: do we really need this?
michael@0:   if (aChildIndex < 0)
michael@0:     aChildIndex = ChildCount() - 1;
michael@0: 
michael@0:   Accessible* child = GetChildAt(aChildIndex);
michael@0:   if (!child)
michael@0:     return NS_ERROR_INVALID_ARG;
michael@0: 
michael@0:   NS_ADDREF(*aChild = child);
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: // readonly attribute nsIArray children;
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetChildren(nsIArray** aOutChildren)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aOutChildren);
michael@0:   *aOutChildren = nullptr;
michael@0: 
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   nsresult rv = NS_OK;
michael@0:   nsCOMPtr<nsIMutableArray> children =
michael@0:     do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   uint32_t childCount = ChildCount();
michael@0:   for (uint32_t childIdx = 0; childIdx < childCount; childIdx++) {
michael@0:     nsIAccessible* child = GetChildAt(childIdx);
michael@0:     children->AppendElement(child, false);
michael@0:   }
michael@0: 
michael@0:   NS_ADDREF(*aOutChildren = children);
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: bool
michael@0: Accessible::CanHaveAnonChildren()
michael@0: {
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: /* readonly attribute long childCount; */
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetChildCount(int32_t* aChildCount)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aChildCount);
michael@0: 
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   *aChildCount = ChildCount();
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: /* readonly attribute long indexInParent; */
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetIndexInParent(int32_t* aIndexInParent)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aIndexInParent);
michael@0: 
michael@0:   *aIndexInParent = IndexInParent();
michael@0:   return *aIndexInParent != -1 ? NS_OK : NS_ERROR_FAILURE;
michael@0: }
michael@0: 
michael@0: void 
michael@0: Accessible::TranslateString(const nsString& aKey, nsAString& aStringOut)
michael@0: {
michael@0:   nsCOMPtr<nsIStringBundleService> stringBundleService =
michael@0:     services::GetStringBundleService();
michael@0:   if (!stringBundleService)
michael@0:     return;
michael@0: 
michael@0:   nsCOMPtr<nsIStringBundle> stringBundle;
michael@0:   stringBundleService->CreateBundle(
michael@0:     "chrome://global-platform/locale/accessible.properties", 
michael@0:     getter_AddRefs(stringBundle));
michael@0:   if (!stringBundle)
michael@0:     return;
michael@0: 
michael@0:   nsXPIDLString xsValue;
michael@0:   nsresult rv = stringBundle->GetStringFromName(aKey.get(), getter_Copies(xsValue));
michael@0:   if (NS_SUCCEEDED(rv))
michael@0:     aStringOut.Assign(xsValue);
michael@0: }
michael@0: 
michael@0: uint64_t
michael@0: Accessible::VisibilityState()
michael@0: {
michael@0:   nsIFrame* frame = GetFrame();
michael@0:   if (!frame)
michael@0:     return states::INVISIBLE;
michael@0: 
michael@0:   // Walk the parent frame chain to see if there's invisible parent or the frame
michael@0:   // is in background tab.
michael@0:   if (!frame->StyleVisibility()->IsVisible())
michael@0:     return states::INVISIBLE;
michael@0: 
michael@0:   nsIFrame* curFrame = frame;
michael@0:   do {
michael@0:     nsView* view = curFrame->GetView();
michael@0:     if (view && view->GetVisibility() == nsViewVisibility_kHide)
michael@0:       return states::INVISIBLE;
michael@0: 
michael@0:     if (nsLayoutUtils::IsPopup(curFrame))
michael@0:       return 0;
michael@0: 
michael@0:     // Offscreen state for background tab content and invisible for not selected
michael@0:     // deck panel.
michael@0:     nsIFrame* parentFrame = curFrame->GetParent();
michael@0:     nsDeckFrame* deckFrame = do_QueryFrame(parentFrame);
michael@0:     if (deckFrame && deckFrame->GetSelectedBox() != curFrame) {
michael@0:       if (deckFrame->GetContent()->IsXUL() &&
michael@0:           deckFrame->GetContent()->Tag() == nsGkAtoms::tabpanels)
michael@0:         return states::OFFSCREEN;
michael@0: 
michael@0:       NS_NOTREACHED("Children of not selected deck panel are not accessible.");
michael@0:       return states::INVISIBLE;
michael@0:     }
michael@0: 
michael@0:     // If contained by scrollable frame then check that at least 12 pixels
michael@0:     // around the object is visible, otherwise the object is offscreen.
michael@0:     nsIScrollableFrame* scrollableFrame = do_QueryFrame(parentFrame);
michael@0:     if (scrollableFrame) {
michael@0:       nsRect scrollPortRect = scrollableFrame->GetScrollPortRect();
michael@0:       nsRect frameRect = nsLayoutUtils::TransformFrameRectToAncestor(
michael@0:         frame, frame->GetRectRelativeToSelf(), parentFrame);
michael@0:       if (!scrollPortRect.Contains(frameRect)) {
michael@0:         const nscoord kMinPixels = nsPresContext::CSSPixelsToAppUnits(12);
michael@0:         scrollPortRect.Deflate(kMinPixels, kMinPixels);
michael@0:         if (!scrollPortRect.Intersects(frameRect))
michael@0:           return states::OFFSCREEN;
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     if (!parentFrame) {
michael@0:       parentFrame = nsLayoutUtils::GetCrossDocParentFrame(curFrame);
michael@0:       if (parentFrame && !parentFrame->StyleVisibility()->IsVisible())
michael@0:         return states::INVISIBLE;
michael@0:     }
michael@0: 
michael@0:     curFrame = parentFrame;
michael@0:   } while (curFrame);
michael@0: 
michael@0:   // Zero area rects can occur in the first frame of a multi-frame text flow,
michael@0:   // in which case the rendered text is not empty and the frame should not be
michael@0:   // marked invisible.
michael@0:   // XXX Can we just remove this check? Why do we need to mark empty
michael@0:   // text invisible?
michael@0:   if (frame->GetType() == nsGkAtoms::textFrame &&
michael@0:       !(frame->GetStateBits() & NS_FRAME_OUT_OF_FLOW) &&
michael@0:       frame->GetRect().IsEmpty()) {
michael@0:     nsAutoString renderedText;
michael@0:     frame->GetRenderedText(&renderedText, nullptr, nullptr, 0, 1);
michael@0:     if (renderedText.IsEmpty())
michael@0:       return states::INVISIBLE;
michael@0:   }
michael@0: 
michael@0:   return 0;
michael@0: }
michael@0: 
michael@0: uint64_t
michael@0: Accessible::NativeState()
michael@0: {
michael@0:   uint64_t state = 0;
michael@0: 
michael@0:   if (!IsInDocument())
michael@0:     state |= states::STALE;
michael@0: 
michael@0:   if (HasOwnContent() && mContent->IsElement()) {
michael@0:     EventStates elementState = mContent->AsElement()->State();
michael@0: 
michael@0:     if (elementState.HasState(NS_EVENT_STATE_INVALID))
michael@0:       state |= states::INVALID;
michael@0: 
michael@0:     if (elementState.HasState(NS_EVENT_STATE_REQUIRED))
michael@0:       state |= states::REQUIRED;
michael@0: 
michael@0:     state |= NativeInteractiveState();
michael@0:     if (FocusMgr()->IsFocused(this))
michael@0:       state |= states::FOCUSED;
michael@0:   }
michael@0: 
michael@0:   // Gather states::INVISIBLE and states::OFFSCREEN flags for this object.
michael@0:   state |= VisibilityState();
michael@0: 
michael@0:   nsIFrame *frame = GetFrame();
michael@0:   if (frame) {
michael@0:     if (frame->GetStateBits() & NS_FRAME_OUT_OF_FLOW)
michael@0:       state |= states::FLOATING;
michael@0: 
michael@0:     // XXX we should look at layout for non XUL box frames, but need to decide
michael@0:     // how that interacts with ARIA.
michael@0:     if (HasOwnContent() && mContent->IsXUL() && frame->IsBoxFrame()) {
michael@0:       const nsStyleXUL* xulStyle = frame->StyleXUL();
michael@0:       if (xulStyle && frame->IsBoxFrame()) {
michael@0:         // In XUL all boxes are either vertical or horizontal
michael@0:         if (xulStyle->mBoxOrient == NS_STYLE_BOX_ORIENT_VERTICAL)
michael@0:           state |= states::VERTICAL;
michael@0:         else
michael@0:           state |= states::HORIZONTAL;
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // Check if a XUL element has the popup attribute (an attached popup menu).
michael@0:   if (HasOwnContent() && mContent->IsXUL() &&
michael@0:       mContent->HasAttr(kNameSpaceID_None, nsGkAtoms::popup))
michael@0:     state |= states::HASPOPUP;
michael@0: 
michael@0:   // Bypass the link states specialization for non links.
michael@0:   if (!mRoleMapEntry || mRoleMapEntry->roleRule == kUseNativeRole ||
michael@0:       mRoleMapEntry->role == roles::LINK)
michael@0:     state |= NativeLinkState();
michael@0: 
michael@0:   return state;
michael@0: }
michael@0: 
michael@0: uint64_t
michael@0: Accessible::NativeInteractiveState() const
michael@0: {
michael@0:   if (!mContent->IsElement())
michael@0:     return 0;
michael@0: 
michael@0:   if (NativelyUnavailable())
michael@0:     return states::UNAVAILABLE;
michael@0: 
michael@0:   nsIFrame* frame = GetFrame();
michael@0:   if (frame && frame->IsFocusable())
michael@0:     return states::FOCUSABLE;
michael@0: 
michael@0:   return 0;
michael@0: }
michael@0: 
michael@0: uint64_t
michael@0: Accessible::NativeLinkState() const
michael@0: {
michael@0:   return 0;
michael@0: }
michael@0: 
michael@0: bool
michael@0: Accessible::NativelyUnavailable() const
michael@0: {
michael@0:   if (mContent->IsHTML())
michael@0:     return mContent->AsElement()->State().HasState(NS_EVENT_STATE_DISABLED);
michael@0: 
michael@0:   return mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::disabled,
michael@0:                                nsGkAtoms::_true, eCaseMatters);
michael@0: }
michael@0: 
michael@0:   /* readonly attribute boolean focusedChild; */
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetFocusedChild(nsIAccessible** aChild)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aChild);
michael@0:   *aChild = nullptr;
michael@0: 
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   NS_IF_ADDREF(*aChild = FocusedChild());
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: Accessible*
michael@0: Accessible::FocusedChild()
michael@0: {
michael@0:   Accessible* focus = FocusMgr()->FocusedAccessible();
michael@0:   if (focus && (focus == this || focus->Parent() == this))
michael@0:     return focus;
michael@0: 
michael@0:   return nullptr;
michael@0: }
michael@0: 
michael@0: Accessible*
michael@0: Accessible::ChildAtPoint(int32_t aX, int32_t aY,
michael@0:                          EWhichChildAtPoint aWhichChild)
michael@0: {
michael@0:   // If we can't find the point in a child, we will return the fallback answer:
michael@0:   // we return |this| if the point is within it, otherwise nullptr.
michael@0:   int32_t x = 0, y = 0, width = 0, height = 0;
michael@0:   nsresult rv = GetBounds(&x, &y, &width, &height);
michael@0:   NS_ENSURE_SUCCESS(rv, nullptr);
michael@0: 
michael@0:   Accessible* fallbackAnswer = nullptr;
michael@0:   if (aX >= x && aX < x + width && aY >= y && aY < y + height)
michael@0:     fallbackAnswer = this;
michael@0: 
michael@0:   if (nsAccUtils::MustPrune(this))  // Do not dig any further
michael@0:     return fallbackAnswer;
michael@0: 
michael@0:   // Search an accessible at the given point starting from accessible document
michael@0:   // because containing block (see CSS2) for out of flow element (for example,
michael@0:   // absolutely positioned element) may be different from its DOM parent and
michael@0:   // therefore accessible for containing block may be different from accessible
michael@0:   // for DOM parent but GetFrameForPoint() should be called for containing block
michael@0:   // to get an out of flow element.
michael@0:   DocAccessible* accDocument = Document();
michael@0:   NS_ENSURE_TRUE(accDocument, nullptr);
michael@0: 
michael@0:   nsIFrame* rootFrame = accDocument->GetFrame();
michael@0:   NS_ENSURE_TRUE(rootFrame, nullptr);
michael@0: 
michael@0:   nsIFrame* startFrame = rootFrame;
michael@0: 
michael@0:   // Check whether the point is at popup content.
michael@0:   nsIWidget* rootWidget = rootFrame->GetView()->GetNearestWidget(nullptr);
michael@0:   NS_ENSURE_TRUE(rootWidget, nullptr);
michael@0: 
michael@0:   nsIntRect rootRect;
michael@0:   rootWidget->GetScreenBounds(rootRect);
michael@0: 
michael@0:   WidgetMouseEvent dummyEvent(true, NS_MOUSE_MOVE, rootWidget,
michael@0:                               WidgetMouseEvent::eSynthesized);
michael@0:   dummyEvent.refPoint = LayoutDeviceIntPoint(aX - rootRect.x, aY - rootRect.y);
michael@0: 
michael@0:   nsIFrame* popupFrame = nsLayoutUtils::
michael@0:     GetPopupFrameForEventCoordinates(accDocument->PresContext()->GetRootPresContext(),
michael@0:                                      &dummyEvent);
michael@0:   if (popupFrame) {
michael@0:     // If 'this' accessible is not inside the popup then ignore the popup when
michael@0:     // searching an accessible at point.
michael@0:     DocAccessible* popupDoc =
michael@0:       GetAccService()->GetDocAccessible(popupFrame->GetContent()->OwnerDoc());
michael@0:     Accessible* popupAcc =
michael@0:       popupDoc->GetAccessibleOrContainer(popupFrame->GetContent());
michael@0:     Accessible* popupChild = this;
michael@0:     while (popupChild && !popupChild->IsDoc() && popupChild != popupAcc)
michael@0:       popupChild = popupChild->Parent();
michael@0: 
michael@0:     if (popupChild == popupAcc)
michael@0:       startFrame = popupFrame;
michael@0:   }
michael@0: 
michael@0:   nsPresContext* presContext = startFrame->PresContext();
michael@0:   nsRect screenRect = startFrame->GetScreenRectInAppUnits();
michael@0:     nsPoint offset(presContext->DevPixelsToAppUnits(aX) - screenRect.x,
michael@0:                    presContext->DevPixelsToAppUnits(aY) - screenRect.y);
michael@0:   nsIFrame* foundFrame = nsLayoutUtils::GetFrameForPoint(startFrame, offset);
michael@0: 
michael@0:   nsIContent* content = nullptr;
michael@0:   if (!foundFrame || !(content = foundFrame->GetContent()))
michael@0:     return fallbackAnswer;
michael@0: 
michael@0:   // Get accessible for the node with the point or the first accessible in
michael@0:   // the DOM parent chain.
michael@0:   DocAccessible* contentDocAcc = GetAccService()->
michael@0:     GetDocAccessible(content->OwnerDoc());
michael@0: 
michael@0:   // contentDocAcc in some circumstances can be nullptr. See bug 729861
michael@0:   NS_ASSERTION(contentDocAcc, "could not get the document accessible");
michael@0:   if (!contentDocAcc)
michael@0:     return fallbackAnswer;
michael@0: 
michael@0:   Accessible* accessible = contentDocAcc->GetAccessibleOrContainer(content);
michael@0:   if (!accessible)
michael@0:     return fallbackAnswer;
michael@0: 
michael@0:   // Hurray! We have an accessible for the frame that layout gave us.
michael@0:   // Since DOM node of obtained accessible may be out of flow then we should
michael@0:   // ensure obtained accessible is a child of this accessible.
michael@0:   Accessible* child = accessible;
michael@0:   while (child != this) {
michael@0:     Accessible* parent = child->Parent();
michael@0:     if (!parent) {
michael@0:       // Reached the top of the hierarchy. These bounds were inside an
michael@0:       // accessible that is not a descendant of this one.
michael@0:       return fallbackAnswer;
michael@0:     }
michael@0: 
michael@0:     // If we landed on a legitimate child of |this|, and we want the direct
michael@0:     // child, return it here.
michael@0:     if (parent == this && aWhichChild == eDirectChild)
michael@0:         return child;
michael@0: 
michael@0:     child = parent;
michael@0:   }
michael@0: 
michael@0:   // Manually walk through accessible children and see if the are within this
michael@0:   // point. Skip offscreen or invisible accessibles. This takes care of cases
michael@0:   // where layout won't walk into things for us, such as image map areas and
michael@0:   // sub documents (XXX: subdocuments should be handled by methods of
michael@0:   // OuterDocAccessibles).
michael@0:   uint32_t childCount = accessible->ChildCount();
michael@0:   for (uint32_t childIdx = 0; childIdx < childCount; childIdx++) {
michael@0:     Accessible* child = accessible->GetChildAt(childIdx);
michael@0: 
michael@0:     int32_t childX, childY, childWidth, childHeight;
michael@0:     child->GetBounds(&childX, &childY, &childWidth, &childHeight);
michael@0:     if (aX >= childX && aX < childX + childWidth &&
michael@0:         aY >= childY && aY < childY + childHeight &&
michael@0:         (child->State() & states::INVISIBLE) == 0) {
michael@0: 
michael@0:       if (aWhichChild == eDeepestChild)
michael@0:         return child->ChildAtPoint(aX, aY, eDeepestChild);
michael@0: 
michael@0:       return child;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return accessible;
michael@0: }
michael@0: 
michael@0: // nsIAccessible getChildAtPoint(in long x, in long y)
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetChildAtPoint(int32_t aX, int32_t aY,
michael@0:                             nsIAccessible** aAccessible)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aAccessible);
michael@0:   *aAccessible = nullptr;
michael@0: 
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   NS_IF_ADDREF(*aAccessible = ChildAtPoint(aX, aY, eDirectChild));
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: // nsIAccessible getDeepestChildAtPoint(in long x, in long y)
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetDeepestChildAtPoint(int32_t aX, int32_t aY,
michael@0:                                    nsIAccessible** aAccessible)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aAccessible);
michael@0:   *aAccessible = nullptr;
michael@0: 
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   NS_IF_ADDREF(*aAccessible = ChildAtPoint(aX, aY, eDeepestChild));
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: void
michael@0: Accessible::GetBoundsRect(nsRect& aTotalBounds, nsIFrame** aBoundingFrame)
michael@0: {
michael@0:   nsIFrame* frame = GetFrame();
michael@0:   if (frame && mContent) {
michael@0:     nsRect* hitRegionRect = static_cast<nsRect*>(mContent->GetProperty(nsGkAtoms::hitregion));
michael@0: 
michael@0:     if (hitRegionRect) {
michael@0:       // This is for canvas fallback content
michael@0:       // Find a canvas frame the found hit region is relative to.
michael@0:       nsIFrame* canvasFrame = frame->GetParent();
michael@0:       while (canvasFrame && (canvasFrame->GetType() != nsGkAtoms::HTMLCanvasFrame))
michael@0:         canvasFrame = canvasFrame->GetParent();
michael@0: 
michael@0:       // make the canvas the bounding frame
michael@0:       if (canvasFrame) {
michael@0:         *aBoundingFrame = canvasFrame;
michael@0: 
michael@0:         aTotalBounds = *hitRegionRect;
michael@0: 
michael@0:         return;
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     *aBoundingFrame = nsLayoutUtils::GetContainingBlockForClientRect(frame);
michael@0:     aTotalBounds = nsLayoutUtils::
michael@0:       GetAllInFlowRectsUnion(frame, *aBoundingFrame,
michael@0:                              nsLayoutUtils::RECTS_ACCOUNT_FOR_TRANSFORMS);
michael@0:   }
michael@0: }
michael@0: 
michael@0: /* void getBounds (out long x, out long y, out long width, out long height); */
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetBounds(int32_t* aX, int32_t* aY,
michael@0:                       int32_t* aWidth, int32_t* aHeight)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aX);
michael@0:   *aX = 0;
michael@0:   NS_ENSURE_ARG_POINTER(aY);
michael@0:   *aY = 0;
michael@0:   NS_ENSURE_ARG_POINTER(aWidth);
michael@0:   *aWidth = 0;
michael@0:   NS_ENSURE_ARG_POINTER(aHeight);
michael@0:   *aHeight = 0;
michael@0: 
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   // This routine will get the entire rectangle for all the frames in this node.
michael@0:   // -------------------------------------------------------------------------
michael@0:   //      Primary Frame for node
michael@0:   //  Another frame, same node                <- Example
michael@0:   //  Another frame, same node
michael@0: 
michael@0:   nsRect unionRectTwips;
michael@0:   nsIFrame* boundingFrame = nullptr;
michael@0:   GetBoundsRect(unionRectTwips, &boundingFrame);   // Unions up all primary frames for this node and all siblings after it
michael@0:   NS_ENSURE_STATE(boundingFrame);
michael@0: 
michael@0:   nsPresContext* presContext = mDoc->PresContext();
michael@0:   *aX = presContext->AppUnitsToDevPixels(unionRectTwips.x);
michael@0:   *aY = presContext->AppUnitsToDevPixels(unionRectTwips.y);
michael@0:   *aWidth = presContext->AppUnitsToDevPixels(unionRectTwips.width);
michael@0:   *aHeight = presContext->AppUnitsToDevPixels(unionRectTwips.height);
michael@0: 
michael@0:   // We have the union of the rectangle, now we need to put it in absolute screen coords
michael@0:   nsIntRect orgRectPixels = boundingFrame->GetScreenRectInAppUnits().
michael@0:     ToNearestPixels(presContext->AppUnitsPerDevPixel());
michael@0:   *aX += orgRectPixels.x;
michael@0:   *aY += orgRectPixels.y;
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: Accessible::SetSelected(bool aSelect)
michael@0: {
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   if (!HasOwnContent())
michael@0:     return NS_OK;
michael@0: 
michael@0:   Accessible* select = nsAccUtils::GetSelectableContainer(this, State());
michael@0:   if (select) {
michael@0:     if (select->State() & states::MULTISELECTABLE) {
michael@0:       if (mRoleMapEntry) {
michael@0:         if (aSelect) {
michael@0:           return mContent->SetAttr(kNameSpaceID_None,
michael@0:                                    nsGkAtoms::aria_selected,
michael@0:                                    NS_LITERAL_STRING("true"), true);
michael@0:         }
michael@0:         return mContent->UnsetAttr(kNameSpaceID_None,
michael@0:                                    nsGkAtoms::aria_selected, true);
michael@0:       }
michael@0: 
michael@0:       return NS_OK;
michael@0:     }
michael@0: 
michael@0:     return aSelect ? TakeFocus() : NS_ERROR_FAILURE;
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: Accessible::TakeSelection()
michael@0: {
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   Accessible* select = nsAccUtils::GetSelectableContainer(this, State());
michael@0:   if (select) {
michael@0:     if (select->State() & states::MULTISELECTABLE)
michael@0:       select->UnselectAll();
michael@0:     return SetSelected(true);
michael@0:   }
michael@0: 
michael@0:   return NS_ERROR_FAILURE;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: Accessible::TakeFocus()
michael@0: {
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   nsIFrame *frame = GetFrame();
michael@0:   NS_ENSURE_STATE(frame);
michael@0: 
michael@0:   nsIContent* focusContent = mContent;
michael@0: 
michael@0:   // If the accessible focus is managed by container widget then focus the
michael@0:   // widget and set the accessible as its current item.
michael@0:   if (!frame->IsFocusable()) {
michael@0:     Accessible* widget = ContainerWidget();
michael@0:     if (widget && widget->AreItemsOperable()) {
michael@0:       nsIContent* widgetElm = widget->GetContent();
michael@0:       nsIFrame* widgetFrame = widgetElm->GetPrimaryFrame();
michael@0:       if (widgetFrame && widgetFrame->IsFocusable()) {
michael@0:         focusContent = widgetElm;
michael@0:         widget->SetCurrentItem(this);
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIDOMElement> element(do_QueryInterface(focusContent));
michael@0:   nsFocusManager* fm = nsFocusManager::GetFocusManager();
michael@0:   if (fm)
michael@0:     fm->SetFocus(element, 0);
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: void
michael@0: Accessible::XULElmName(DocAccessible* aDocument,
michael@0:                        nsIContent* aElm, nsString& aName)
michael@0: {
michael@0:   /**
michael@0:    * 3 main cases for XUL Controls to be labeled
michael@0:    *   1 - control contains label="foo"
michael@0:    *   2 - control has, as a child, a label element
michael@0:    *        - label has either value="foo" or children
michael@0:    *   3 - non-child label contains control="controlID"
michael@0:    *        - label has either value="foo" or children
michael@0:    * Once a label is found, the search is discontinued, so a control
michael@0:    *  that has a label child as well as having a label external to
michael@0:    *  the control that uses the control="controlID" syntax will use
michael@0:    *  the child label for its Name.
michael@0:    */
michael@0: 
michael@0:   // CASE #1 (via label attribute) -- great majority of the cases
michael@0:   nsCOMPtr<nsIDOMXULLabeledControlElement> labeledEl = do_QueryInterface(aElm);
michael@0:   if (labeledEl) {
michael@0:     labeledEl->GetLabel(aName);
michael@0:   } else {
michael@0:     nsCOMPtr<nsIDOMXULSelectControlItemElement> itemEl = do_QueryInterface(aElm);
michael@0:     if (itemEl) {
michael@0:       itemEl->GetLabel(aName);
michael@0:     } else {
michael@0:       nsCOMPtr<nsIDOMXULSelectControlElement> select = do_QueryInterface(aElm);
michael@0:       // Use label if this is not a select control element which 
michael@0:       // uses label attribute to indicate which option is selected
michael@0:       if (!select) {
michael@0:         nsCOMPtr<nsIDOMXULElement> xulEl(do_QueryInterface(aElm));
michael@0:         if (xulEl)
michael@0:           xulEl->GetAttribute(NS_LITERAL_STRING("label"), aName);
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // CASES #2 and #3 ------ label as a child or <label control="id" ... > </label>
michael@0:   if (aName.IsEmpty()) {
michael@0:     Accessible* labelAcc = nullptr;
michael@0:     XULLabelIterator iter(aDocument, aElm);
michael@0:     while ((labelAcc = iter.Next())) {
michael@0:       nsCOMPtr<nsIDOMXULLabelElement> xulLabel =
michael@0:         do_QueryInterface(labelAcc->GetContent());
michael@0:       // Check if label's value attribute is used
michael@0:       if (xulLabel && NS_SUCCEEDED(xulLabel->GetValue(aName)) && aName.IsEmpty()) {
michael@0:         // If no value attribute, a non-empty label must contain
michael@0:         // children that define its text -- possibly using HTML
michael@0:         nsTextEquivUtils::
michael@0:           AppendTextEquivFromContent(labelAcc, labelAcc->GetContent(), &aName);
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   aName.CompressWhitespace();
michael@0:   if (!aName.IsEmpty())
michael@0:     return;
michael@0: 
michael@0:   // Can get text from title of <toolbaritem> if we're a child of a <toolbaritem>
michael@0:   nsIContent *bindingParent = aElm->GetBindingParent();
michael@0:   nsIContent* parent =
michael@0:     bindingParent? bindingParent->GetParent() : aElm->GetParent();
michael@0:   while (parent) {
michael@0:     if (parent->Tag() == nsGkAtoms::toolbaritem &&
michael@0:         parent->GetAttr(kNameSpaceID_None, nsGkAtoms::title, aName)) {
michael@0:       aName.CompressWhitespace();
michael@0:       return;
michael@0:     }
michael@0:     parent = parent->GetParent();
michael@0:   }
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: Accessible::HandleAccEvent(AccEvent* aEvent)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aEvent);
michael@0: 
michael@0:   nsCOMPtr<nsIObserverService> obsService = services::GetObserverService();
michael@0:   NS_ENSURE_TRUE(obsService, NS_ERROR_FAILURE);
michael@0: 
michael@0:   nsCOMPtr<nsISimpleEnumerator> observers;
michael@0:   obsService->EnumerateObservers(NS_ACCESSIBLE_EVENT_TOPIC,
michael@0:                                  getter_AddRefs(observers));
michael@0: 
michael@0:   NS_ENSURE_STATE(observers);
michael@0: 
michael@0:   bool hasObservers = false;
michael@0:   observers->HasMoreElements(&hasObservers);
michael@0:   if (hasObservers) {
michael@0:     nsCOMPtr<nsIAccessibleEvent> event = MakeXPCEvent(aEvent);
michael@0:     return obsService->NotifyObservers(event, NS_ACCESSIBLE_EVENT_TOPIC, nullptr);
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetRole(uint32_t *aRole)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aRole);
michael@0:   *aRole = nsIAccessibleRole::ROLE_NOTHING;
michael@0: 
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   *aRole = Role();
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetAttributes(nsIPersistentProperties** aAttributes)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aAttributes);
michael@0:   *aAttributes = nullptr;
michael@0: 
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   nsCOMPtr<nsIPersistentProperties> attributes = Attributes();
michael@0:   attributes.swap(*aAttributes);
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: already_AddRefed<nsIPersistentProperties>
michael@0: Accessible::Attributes()
michael@0: {
michael@0:   nsCOMPtr<nsIPersistentProperties> attributes = NativeAttributes();
michael@0:   if (!HasOwnContent() || !mContent->IsElement())
michael@0:     return attributes.forget();
michael@0: 
michael@0:   // 'xml-roles' attribute coming from ARIA.
michael@0:   nsAutoString xmlRoles, unused;
michael@0:   if (mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::role, xmlRoles)) {
michael@0:     attributes->SetStringProperty(NS_LITERAL_CSTRING("xml-roles"),
michael@0:                                   xmlRoles, unused);
michael@0:   }
michael@0: 
michael@0:   // Expose object attributes from ARIA attributes.
michael@0:   aria::AttrIterator attribIter(mContent);
michael@0:   nsAutoString name, value;
michael@0:   while(attribIter.Next(name, value))
michael@0:     attributes->SetStringProperty(NS_ConvertUTF16toUTF8(name), value, unused);
michael@0: 
michael@0:   // If there is no aria-live attribute then expose default value of 'live'
michael@0:   // object attribute used for ARIA role of this accessible.
michael@0:   if (mRoleMapEntry) {
michael@0:     nsAutoString live;
michael@0:     nsAccUtils::GetAccAttr(attributes, nsGkAtoms::live, live);
michael@0:     if (live.IsEmpty()) {
michael@0:       if (nsAccUtils::GetLiveAttrValue(mRoleMapEntry->liveAttRule, live))
michael@0:         nsAccUtils::SetAccAttr(attributes, nsGkAtoms::live, live);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return attributes.forget();
michael@0: }
michael@0: 
michael@0: already_AddRefed<nsIPersistentProperties>
michael@0: Accessible::NativeAttributes()
michael@0: {
michael@0:   nsCOMPtr<nsIPersistentProperties> attributes =
michael@0:     do_CreateInstance(NS_PERSISTENTPROPERTIES_CONTRACTID);
michael@0: 
michael@0:   nsAutoString unused;
michael@0: 
michael@0:   // We support values, so expose the string value as well, via the valuetext
michael@0:   // object attribute. We test for the value interface because we don't want
michael@0:   // to expose traditional Value() information such as URL's on links and
michael@0:   // documents, or text in an input.
michael@0:   if (HasNumericValue()) {
michael@0:     nsAutoString valuetext;
michael@0:     GetValue(valuetext);
michael@0:     attributes->SetStringProperty(NS_LITERAL_CSTRING("valuetext"), valuetext,
michael@0:                                   unused);
michael@0:   }
michael@0: 
michael@0:   // Expose checkable object attribute if the accessible has checkable state
michael@0:   if (State() & states::CHECKABLE) {
michael@0:     nsAccUtils::SetAccAttr(attributes, nsGkAtoms::checkable,
michael@0:                            NS_LITERAL_STRING("true"));
michael@0:   }
michael@0: 
michael@0:   // Expose 'explicit-name' attribute.
michael@0:   nsAutoString name;
michael@0:   if (Name(name) != eNameFromSubtree && !name.IsVoid()) {
michael@0:     attributes->SetStringProperty(NS_LITERAL_CSTRING("explicit-name"),
michael@0:                                   NS_LITERAL_STRING("true"), unused);
michael@0:   }
michael@0: 
michael@0:   // Group attributes (level/setsize/posinset)
michael@0:   GroupPos groupPos = GroupPosition();
michael@0:   nsAccUtils::SetAccGroupAttrs(attributes, groupPos.level,
michael@0:                                groupPos.setSize, groupPos.posInSet);
michael@0: 
michael@0:   // If the accessible doesn't have own content (such as list item bullet or
michael@0:   // xul tree item) then don't calculate content based attributes.
michael@0:   if (!HasOwnContent())
michael@0:     return attributes.forget();
michael@0: 
michael@0:   nsEventShell::GetEventAttributes(GetNode(), attributes);
michael@0: 
michael@0:   // Get container-foo computed live region properties based on the closest
michael@0:   // container with the live region attribute. Inner nodes override outer nodes
michael@0:   // within the same document. The inner nodes can be used to override live
michael@0:   // region behavior on more general outer nodes. However, nodes in outer
michael@0:   // documents override nodes in inner documents: outer doc author may want to
michael@0:   // override properties on a widget they used in an iframe.
michael@0:   nsIContent* startContent = mContent;
michael@0:   while (startContent) {
michael@0:     nsIDocument* doc = startContent->GetDocument();
michael@0:     if (!doc)
michael@0:       break;
michael@0: 
michael@0:     nsAccUtils::SetLiveContainerAttributes(attributes, startContent,
michael@0:                                            nsCoreUtils::GetRoleContent(doc));
michael@0: 
michael@0:     // Allow ARIA live region markup from outer documents to override
michael@0:     nsCOMPtr<nsIDocShellTreeItem> docShellTreeItem = doc->GetDocShell();
michael@0:     if (!docShellTreeItem)
michael@0:       break;
michael@0: 
michael@0:     nsCOMPtr<nsIDocShellTreeItem> sameTypeParent;
michael@0:     docShellTreeItem->GetSameTypeParent(getter_AddRefs(sameTypeParent));
michael@0:     if (!sameTypeParent || sameTypeParent == docShellTreeItem)
michael@0:       break;
michael@0: 
michael@0:     nsIDocument* parentDoc = doc->GetParentDocument();
michael@0:     if (!parentDoc)
michael@0:       break;
michael@0: 
michael@0:     startContent = parentDoc->FindContentForSubDocument(doc);
michael@0:   }
michael@0: 
michael@0:   if (!mContent->IsElement())
michael@0:     return attributes.forget();
michael@0: 
michael@0:   nsAutoString id;
michael@0:   if (nsCoreUtils::GetID(mContent, id))
michael@0:     attributes->SetStringProperty(NS_LITERAL_CSTRING("id"), id, unused);
michael@0: 
michael@0:   // Expose class because it may have useful microformat information.
michael@0:   nsAutoString _class;
michael@0:   if (mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::_class, _class))
michael@0:     nsAccUtils::SetAccAttr(attributes, nsGkAtoms::_class, _class);
michael@0: 
michael@0:   // Expose tag.
michael@0:   nsAutoString tagName;
michael@0:   mContent->NodeInfo()->GetName(tagName);
michael@0:   nsAccUtils::SetAccAttr(attributes, nsGkAtoms::tag, tagName);
michael@0: 
michael@0:   // Expose draggable object attribute.
michael@0:   nsCOMPtr<nsIDOMHTMLElement> htmlElement = do_QueryInterface(mContent);
michael@0:   if (htmlElement) {
michael@0:     bool draggable = false;
michael@0:     htmlElement->GetDraggable(&draggable);
michael@0:     if (draggable) {
michael@0:       nsAccUtils::SetAccAttr(attributes, nsGkAtoms::draggable,
michael@0:                              NS_LITERAL_STRING("true"));
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // Don't calculate CSS-based object attributes when no frame (i.e.
michael@0:   // the accessible is unattached from the tree).
michael@0:   if (!mContent->GetPrimaryFrame())
michael@0:     return attributes.forget();
michael@0: 
michael@0:   // CSS style based object attributes.
michael@0:   nsAutoString value;
michael@0:   StyleInfo styleInfo(mContent->AsElement(), mDoc->PresShell());
michael@0: 
michael@0:   // Expose 'display' attribute.
michael@0:   styleInfo.Display(value);
michael@0:   nsAccUtils::SetAccAttr(attributes, nsGkAtoms::display, value);
michael@0: 
michael@0:   // Expose 'text-align' attribute.
michael@0:   styleInfo.TextAlign(value);
michael@0:   nsAccUtils::SetAccAttr(attributes, nsGkAtoms::textAlign, value);
michael@0: 
michael@0:   // Expose 'text-indent' attribute.
michael@0:   styleInfo.TextIndent(value);
michael@0:   nsAccUtils::SetAccAttr(attributes, nsGkAtoms::textIndent, value);
michael@0: 
michael@0:   // Expose 'margin-left' attribute.
michael@0:   styleInfo.MarginLeft(value);
michael@0:   nsAccUtils::SetAccAttr(attributes, nsGkAtoms::marginLeft, value);
michael@0: 
michael@0:   // Expose 'margin-right' attribute.
michael@0:   styleInfo.MarginRight(value);
michael@0:   nsAccUtils::SetAccAttr(attributes, nsGkAtoms::marginRight, value);
michael@0: 
michael@0:   // Expose 'margin-top' attribute.
michael@0:   styleInfo.MarginTop(value);
michael@0:   nsAccUtils::SetAccAttr(attributes, nsGkAtoms::marginTop, value);
michael@0: 
michael@0:   // Expose 'margin-bottom' attribute.
michael@0:   styleInfo.MarginBottom(value);
michael@0:   nsAccUtils::SetAccAttr(attributes, nsGkAtoms::marginBottom, value);
michael@0: 
michael@0:   return attributes.forget();
michael@0: }
michael@0: 
michael@0: GroupPos
michael@0: Accessible::GroupPosition()
michael@0: {
michael@0:   GroupPos groupPos;
michael@0:   if (!HasOwnContent())
michael@0:     return groupPos;
michael@0: 
michael@0:   // Get group position from ARIA attributes.
michael@0:   nsCoreUtils::GetUIntAttr(mContent, nsGkAtoms::aria_level, &groupPos.level);
michael@0:   nsCoreUtils::GetUIntAttr(mContent, nsGkAtoms::aria_setsize, &groupPos.setSize);
michael@0:   nsCoreUtils::GetUIntAttr(mContent, nsGkAtoms::aria_posinset, &groupPos.posInSet);
michael@0: 
michael@0:   // If ARIA is missed and the accessible is visible then calculate group
michael@0:   // position from hierarchy.
michael@0:   if (State() & states::INVISIBLE)
michael@0:     return groupPos;
michael@0: 
michael@0:   // Calculate group level if ARIA is missed.
michael@0:   if (groupPos.level == 0) {
michael@0:     int32_t level = GetLevelInternal();
michael@0:     if (level != 0)
michael@0:       groupPos.level = level;
michael@0:   }
michael@0: 
michael@0:   // Calculate position in group and group size if ARIA is missed.
michael@0:   if (groupPos.posInSet == 0 || groupPos.setSize == 0) {
michael@0:     int32_t posInSet = 0, setSize = 0;
michael@0:     GetPositionAndSizeInternal(&posInSet, &setSize);
michael@0:     if (posInSet != 0 && setSize != 0) {
michael@0:       if (groupPos.posInSet == 0)
michael@0:         groupPos.posInSet = posInSet;
michael@0: 
michael@0:       if (groupPos.setSize == 0)
michael@0:         groupPos.setSize = setSize;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return groupPos;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: Accessible::ScriptableGroupPosition(int32_t* aGroupLevel,
michael@0:                                     int32_t* aSimilarItemsInGroup,
michael@0:                                     int32_t* aPositionInGroup)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aGroupLevel);
michael@0:   *aGroupLevel = 0;
michael@0: 
michael@0:   NS_ENSURE_ARG_POINTER(aSimilarItemsInGroup);
michael@0:   *aSimilarItemsInGroup = 0;
michael@0: 
michael@0:   NS_ENSURE_ARG_POINTER(aPositionInGroup);
michael@0:   *aPositionInGroup = 0;
michael@0: 
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   GroupPos groupPos = GroupPosition();
michael@0: 
michael@0:   *aGroupLevel = groupPos.level;
michael@0:   *aSimilarItemsInGroup = groupPos.setSize;
michael@0:   *aPositionInGroup = groupPos.posInSet;
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetState(uint32_t* aState, uint32_t* aExtraState)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aState);
michael@0: 
michael@0:   nsAccUtils::To32States(State(), aState, aExtraState);
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: uint64_t
michael@0: Accessible::State()
michael@0: {
michael@0:   if (IsDefunct())
michael@0:     return states::DEFUNCT;
michael@0: 
michael@0:   uint64_t state = NativeState();
michael@0:   // Apply ARIA states to be sure accessible states will be overridden.
michael@0:   ApplyARIAState(&state);
michael@0: 
michael@0:   // If this is an ARIA item of the selectable widget and if it's focused and
michael@0:   // not marked unselected explicitly (i.e. aria-selected="false") then expose
michael@0:   // it as selected to make ARIA widget authors life easier.
michael@0:   if (mRoleMapEntry && !(state & states::SELECTED) &&
michael@0:       !mContent->AttrValueIs(kNameSpaceID_None,
michael@0:                              nsGkAtoms::aria_selected,
michael@0:                              nsGkAtoms::_false, eCaseMatters)) {
michael@0:     // Special case for tabs: focused tab or focus inside related tab panel
michael@0:     // implies selected state.
michael@0:     if (mRoleMapEntry->role == roles::PAGETAB) {
michael@0:       if (state & states::FOCUSED) {
michael@0:         state |= states::SELECTED;
michael@0:       } else {
michael@0:         // If focus is in a child of the tab panel surely the tab is selected!
michael@0:         Relation rel = RelationByType(RelationType::LABEL_FOR);
michael@0:         Accessible* relTarget = nullptr;
michael@0:         while ((relTarget = rel.Next())) {
michael@0:           if (relTarget->Role() == roles::PROPERTYPAGE &&
michael@0:               FocusMgr()->IsFocusWithin(relTarget))
michael@0:             state |= states::SELECTED;
michael@0:         }
michael@0:       }
michael@0:     } else if (state & states::FOCUSED) {
michael@0:       Accessible* container = nsAccUtils::GetSelectableContainer(this, state);
michael@0:       if (container &&
michael@0:           !nsAccUtils::HasDefinedARIAToken(container->GetContent(),
michael@0:                                            nsGkAtoms::aria_multiselectable)) {
michael@0:         state |= states::SELECTED;
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   const uint32_t kExpandCollapseStates = states::COLLAPSED | states::EXPANDED;
michael@0:   if ((state & kExpandCollapseStates) == kExpandCollapseStates) {
michael@0:     // Cannot be both expanded and collapsed -- this happens in ARIA expanded
michael@0:     // combobox because of limitation of ARIAMap.
michael@0:     // XXX: Perhaps we will be able to make this less hacky if we support
michael@0:     // extended states in ARIAMap, e.g. derive COLLAPSED from
michael@0:     // EXPANDABLE && !EXPANDED.
michael@0:     state &= ~states::COLLAPSED;
michael@0:   }
michael@0: 
michael@0:   if (!(state & states::UNAVAILABLE)) {
michael@0:     state |= states::ENABLED | states::SENSITIVE;
michael@0: 
michael@0:     // If the object is a current item of container widget then mark it as
michael@0:     // ACTIVE. This allows screen reader virtual buffer modes to know which
michael@0:     // descendant is the current one that would get focus if the user navigates
michael@0:     // to the container widget.
michael@0:     Accessible* widget = ContainerWidget();
michael@0:     if (widget && widget->CurrentItem() == this)
michael@0:       state |= states::ACTIVE;
michael@0:   }
michael@0: 
michael@0:   if ((state & states::COLLAPSED) || (state & states::EXPANDED))
michael@0:     state |= states::EXPANDABLE;
michael@0: 
michael@0:   // For some reasons DOM node may have not a frame. We tract such accessibles
michael@0:   // as invisible.
michael@0:   nsIFrame *frame = GetFrame();
michael@0:   if (!frame)
michael@0:     return state;
michael@0: 
michael@0:   const nsStyleDisplay* display = frame->StyleDisplay();
michael@0:   if (display && display->mOpacity == 1.0f &&
michael@0:       !(state & states::INVISIBLE)) {
michael@0:     state |= states::OPAQUE1;
michael@0:   }
michael@0: 
michael@0:   return state;
michael@0: }
michael@0: 
michael@0: void
michael@0: Accessible::ApplyARIAState(uint64_t* aState) const
michael@0: {
michael@0:   if (!mContent->IsElement())
michael@0:     return;
michael@0: 
michael@0:   dom::Element* element = mContent->AsElement();
michael@0: 
michael@0:   // Test for universal states first
michael@0:   *aState |= aria::UniversalStatesFor(element);
michael@0: 
michael@0:   if (mRoleMapEntry) {
michael@0: 
michael@0:     // We only force the readonly bit off if we have a real mapping for the aria
michael@0:     // role. This preserves the ability for screen readers to use readonly
michael@0:     // (primarily on the document) as the hint for creating a virtual buffer.
michael@0:     if (mRoleMapEntry->role != roles::NOTHING)
michael@0:       *aState &= ~states::READONLY;
michael@0: 
michael@0:     if (mContent->HasAttr(kNameSpaceID_None, mContent->GetIDAttributeName())) {
michael@0:       // If has a role & ID and aria-activedescendant on the container, assume focusable
michael@0:       nsIContent *ancestorContent = mContent;
michael@0:       while ((ancestorContent = ancestorContent->GetParent()) != nullptr) {
michael@0:         if (ancestorContent->HasAttr(kNameSpaceID_None, nsGkAtoms::aria_activedescendant)) {
michael@0:             // ancestor has activedescendant property, this content could be active
michael@0:           *aState |= states::FOCUSABLE;
michael@0:           break;
michael@0:         }
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   if (*aState & states::FOCUSABLE) {
michael@0:     // Special case: aria-disabled propagates from ancestors down to any focusable descendant
michael@0:     nsIContent *ancestorContent = mContent;
michael@0:     while ((ancestorContent = ancestorContent->GetParent()) != nullptr) {
michael@0:       if (ancestorContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::aria_disabled,
michael@0:                                        nsGkAtoms::_true, eCaseMatters)) {
michael@0:           // ancestor has aria-disabled property, this is disabled
michael@0:         *aState |= states::UNAVAILABLE;
michael@0:         break;
michael@0:       }
michael@0:     }    
michael@0:   }
michael@0: 
michael@0:   // special case: A native button element whose role got transformed by ARIA to a toggle button
michael@0:   if (IsButton())
michael@0:     aria::MapToState(aria::eARIAPressed, element, aState);
michael@0: 
michael@0:   if (!mRoleMapEntry)
michael@0:     return;
michael@0: 
michael@0:   *aState |= mRoleMapEntry->state;
michael@0: 
michael@0:   if (aria::MapToState(mRoleMapEntry->attributeMap1, element, aState) &&
michael@0:       aria::MapToState(mRoleMapEntry->attributeMap2, element, aState))
michael@0:     aria::MapToState(mRoleMapEntry->attributeMap3, element, aState);
michael@0: 
michael@0:   // ARIA gridcell inherits editable/readonly states from the grid until it's
michael@0:   // overridden.
michael@0:   if ((mRoleMapEntry->Is(nsGkAtoms::gridcell) ||
michael@0:        mRoleMapEntry->Is(nsGkAtoms::columnheader) ||
michael@0:        mRoleMapEntry->Is(nsGkAtoms::rowheader)) &&
michael@0:       !(*aState & (states::READONLY | states::EDITABLE))) {
michael@0:     const TableCellAccessible* cell = AsTableCell();
michael@0:     if (cell) {
michael@0:       TableAccessible* table = cell->Table();
michael@0:       if (table) {
michael@0:         Accessible* grid = table->AsAccessible();
michael@0:         uint64_t gridState = 0;
michael@0:         grid->ApplyARIAState(&gridState);
michael@0:         *aState |= (gridState & (states::READONLY | states::EDITABLE));
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetValue(nsAString& aValue)
michael@0: {
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   nsAutoString value;
michael@0:   Value(value);
michael@0:   aValue.Assign(value);
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: void
michael@0: Accessible::Value(nsString& aValue)
michael@0: {
michael@0:   if (!mRoleMapEntry)
michael@0:     return;
michael@0: 
michael@0:   if (mRoleMapEntry->valueRule != eNoValue) {
michael@0:     // aria-valuenow is a number, and aria-valuetext is the optional text
michael@0:     // equivalent. For the string value, we will try the optional text
michael@0:     // equivalent first.
michael@0:     if (!mContent->GetAttr(kNameSpaceID_None,
michael@0:                            nsGkAtoms::aria_valuetext, aValue)) {
michael@0:       mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::aria_valuenow,
michael@0:                         aValue);
michael@0:     }
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   // Value of textbox is a textified subtree.
michael@0:   if (mRoleMapEntry->Is(nsGkAtoms::textbox)) {
michael@0:     nsTextEquivUtils::GetTextEquivFromSubtree(this, aValue);
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   // Value of combobox is a text of current or selected item.
michael@0:   if (mRoleMapEntry->Is(nsGkAtoms::combobox)) {
michael@0:     Accessible* option = CurrentItem();
michael@0:     if (!option) {
michael@0:       Accessible* listbox = nullptr;
michael@0:       IDRefsIterator iter(mDoc, mContent, nsGkAtoms::aria_owns);
michael@0:       while ((listbox = iter.Next()) && !listbox->IsListControl());
michael@0: 
michael@0:       if (!listbox) {
michael@0:         uint32_t childCount = ChildCount();
michael@0:         for (uint32_t idx = 0; idx < childCount; idx++) {
michael@0:           Accessible* child = mChildren.ElementAt(idx);
michael@0:           if (child->IsListControl())
michael@0:             listbox = child;
michael@0:         }
michael@0:       }
michael@0: 
michael@0:       if (listbox)
michael@0:         option = listbox->GetSelectedItem(0);
michael@0:     }
michael@0: 
michael@0:     if (option)
michael@0:       nsTextEquivUtils::GetTextEquivFromSubtree(option, aValue);
michael@0:   }
michael@0: }
michael@0: 
michael@0: double
michael@0: Accessible::MaxValue() const
michael@0: {
michael@0:   return AttrNumericValue(nsGkAtoms::aria_valuemax);
michael@0: }
michael@0: 
michael@0: double
michael@0: Accessible::MinValue() const
michael@0: {
michael@0:   return AttrNumericValue(nsGkAtoms::aria_valuemin);
michael@0: }
michael@0: 
michael@0: double
michael@0: Accessible::Step() const
michael@0: {
michael@0:   return UnspecifiedNaN<double>(); // no mimimum increment (step) in ARIA.
michael@0: }
michael@0: 
michael@0: double
michael@0: Accessible::CurValue() const
michael@0: {
michael@0:   return AttrNumericValue(nsGkAtoms::aria_valuenow);
michael@0: }
michael@0: 
michael@0: bool
michael@0: Accessible::SetCurValue(double aValue)
michael@0: {
michael@0:   if (!mRoleMapEntry || mRoleMapEntry->valueRule == eNoValue)
michael@0:     return false;
michael@0: 
michael@0:   const uint32_t kValueCannotChange = states::READONLY | states::UNAVAILABLE;
michael@0:   if (State() & kValueCannotChange)
michael@0:     return false;
michael@0: 
michael@0:   double checkValue = MinValue();
michael@0:   if (!IsNaN(checkValue) && aValue < checkValue)
michael@0:     return false;
michael@0: 
michael@0:   checkValue = MaxValue();
michael@0:   if (!IsNaN(checkValue) && aValue > checkValue)
michael@0:     return false;
michael@0: 
michael@0:   nsAutoString strValue;
michael@0:   strValue.AppendFloat(aValue);
michael@0: 
michael@0:   return NS_SUCCEEDED(
michael@0:     mContent->SetAttr(kNameSpaceID_None, nsGkAtoms::aria_valuenow, strValue, true));
michael@0: }
michael@0: 
michael@0: /* void setName (in DOMString name); */
michael@0: NS_IMETHODIMP
michael@0: Accessible::SetName(const nsAString& aName)
michael@0: {
michael@0:   return NS_ERROR_NOT_IMPLEMENTED;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetKeyboardShortcut(nsAString& aKeyBinding)
michael@0: {
michael@0:   aKeyBinding.Truncate();
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   KeyboardShortcut().ToString(aKeyBinding);
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: role
michael@0: Accessible::ARIATransformRole(role aRole)
michael@0: {
michael@0:   // XXX: these unfortunate exceptions don't fit into the ARIA table. This is
michael@0:   // where the accessible role depends on both the role and ARIA state.
michael@0:   if (aRole == roles::PUSHBUTTON) {
michael@0:     if (nsAccUtils::HasDefinedARIAToken(mContent, nsGkAtoms::aria_pressed)) {
michael@0:       // For simplicity, any existing pressed attribute except "" or "undefined"
michael@0:       // indicates a toggle.
michael@0:       return roles::TOGGLE_BUTTON;
michael@0:     }
michael@0: 
michael@0:     if (mContent->AttrValueIs(kNameSpaceID_None,
michael@0:                               nsGkAtoms::aria_haspopup,
michael@0:                               nsGkAtoms::_true,
michael@0:                               eCaseMatters)) {
michael@0:       // For button with aria-haspopup="true".
michael@0:       return roles::BUTTONMENU;
michael@0:     }
michael@0: 
michael@0:   } else if (aRole == roles::LISTBOX) {
michael@0:     // A listbox inside of a combobox needs a special role because of ATK
michael@0:     // mapping to menu.
michael@0:     if (mParent && mParent->Role() == roles::COMBOBOX) {
michael@0:       return roles::COMBOBOX_LIST;
michael@0: 
michael@0:       Relation rel = RelationByType(RelationType::NODE_CHILD_OF);
michael@0:       Accessible* targetAcc = nullptr;
michael@0:       while ((targetAcc = rel.Next()))
michael@0:         if (targetAcc->Role() == roles::COMBOBOX)
michael@0:           return roles::COMBOBOX_LIST;
michael@0:     }
michael@0: 
michael@0:   } else if (aRole == roles::OPTION) {
michael@0:     if (mParent && mParent->Role() == roles::COMBOBOX_LIST)
michael@0:       return roles::COMBOBOX_OPTION;
michael@0: 
michael@0:   } else if (aRole == roles::MENUITEM) {
michael@0:     // Menuitem has a submenu.
michael@0:     if (mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::aria_haspopup,
michael@0:                               nsGkAtoms::_true, eCaseMatters)) {
michael@0:       return roles::PARENT_MENUITEM;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return aRole;
michael@0: }
michael@0: 
michael@0: role
michael@0: Accessible::NativeRole()
michael@0: {
michael@0:   return roles::NOTHING;
michael@0: }
michael@0: 
michael@0: // readonly attribute uint8_t actionCount
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetActionCount(uint8_t* aActionCount)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aActionCount);
michael@0:   *aActionCount = 0;
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   *aActionCount = ActionCount();
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: uint8_t
michael@0: Accessible::ActionCount()
michael@0: {
michael@0:   return GetActionRule() == eNoAction ? 0 : 1;
michael@0: }
michael@0: 
michael@0: /* DOMString getAccActionName (in uint8_t index); */
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetActionName(uint8_t aIndex, nsAString& aName)
michael@0: {
michael@0:   aName.Truncate();
michael@0: 
michael@0:   if (aIndex != 0)
michael@0:     return NS_ERROR_INVALID_ARG;
michael@0: 
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   uint32_t actionRule = GetActionRule();
michael@0: 
michael@0:  switch (actionRule) {
michael@0:    case eActivateAction:
michael@0:      aName.AssignLiteral("activate");
michael@0:      return NS_OK;
michael@0: 
michael@0:    case eClickAction:
michael@0:      aName.AssignLiteral("click");
michael@0:      return NS_OK;
michael@0: 
michael@0:    case ePressAction:
michael@0:      aName.AssignLiteral("press");
michael@0:      return NS_OK;
michael@0: 
michael@0:    case eCheckUncheckAction:
michael@0:    {
michael@0:      uint64_t state = State();
michael@0:      if (state & states::CHECKED)
michael@0:        aName.AssignLiteral("uncheck");
michael@0:      else if (state & states::MIXED)
michael@0:        aName.AssignLiteral("cycle");
michael@0:      else
michael@0:        aName.AssignLiteral("check");
michael@0:      return NS_OK;
michael@0:    }
michael@0: 
michael@0:    case eJumpAction:
michael@0:      aName.AssignLiteral("jump");
michael@0:      return NS_OK;
michael@0: 
michael@0:    case eOpenCloseAction:
michael@0:      if (State() & states::COLLAPSED)
michael@0:        aName.AssignLiteral("open");
michael@0:      else
michael@0:        aName.AssignLiteral("close");
michael@0:      return NS_OK;
michael@0: 
michael@0:    case eSelectAction:
michael@0:      aName.AssignLiteral("select");
michael@0:      return NS_OK;
michael@0: 
michael@0:    case eSwitchAction:
michael@0:      aName.AssignLiteral("switch");
michael@0:      return NS_OK;
michael@0: 
michael@0:    case eSortAction:
michael@0:      aName.AssignLiteral("sort");
michael@0:      return NS_OK;
michael@0: 
michael@0:    case eExpandAction:
michael@0:      if (State() & states::COLLAPSED)
michael@0:        aName.AssignLiteral("expand");
michael@0:      else
michael@0:        aName.AssignLiteral("collapse");
michael@0:      return NS_OK;
michael@0:   }
michael@0: 
michael@0:   return NS_ERROR_INVALID_ARG;
michael@0: }
michael@0: 
michael@0: // AString getActionDescription(in uint8_t index)
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetActionDescription(uint8_t aIndex, nsAString& aDescription)
michael@0: {
michael@0:   // default to localized action name.
michael@0:   nsAutoString name;
michael@0:   nsresult rv = GetActionName(aIndex, name);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   TranslateString(name, aDescription);
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: // void doAction(in uint8_t index)
michael@0: NS_IMETHODIMP
michael@0: Accessible::DoAction(uint8_t aIndex)
michael@0: {
michael@0:   if (aIndex != 0)
michael@0:     return NS_ERROR_INVALID_ARG;
michael@0: 
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   if (GetActionRule() != eNoAction) {
michael@0:     DoCommand();
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   return NS_ERROR_INVALID_ARG;
michael@0: }
michael@0: 
michael@0: /* DOMString getHelp (); */
michael@0: NS_IMETHODIMP Accessible::GetHelp(nsAString& _retval)
michael@0: {
michael@0:   return NS_ERROR_NOT_IMPLEMENTED;
michael@0: }
michael@0: 
michael@0: nsIContent*
michael@0: Accessible::GetAtomicRegion() const
michael@0: {
michael@0:   nsIContent *loopContent = mContent;
michael@0:   nsAutoString atomic;
michael@0:   while (loopContent && !loopContent->GetAttr(kNameSpaceID_None, nsGkAtoms::aria_atomic, atomic))
michael@0:     loopContent = loopContent->GetParent();
michael@0: 
michael@0:   return atomic.EqualsLiteral("true") ? loopContent : nullptr;
michael@0: }
michael@0: 
michael@0: // nsIAccessible getRelationByType()
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetRelationByType(uint32_t aType, nsIAccessibleRelation** aRelation)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aRelation);
michael@0:   *aRelation = nullptr;
michael@0: 
michael@0:   NS_ENSURE_ARG(aType <= static_cast<uint32_t>(RelationType::LAST));
michael@0: 
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   Relation rel = RelationByType(static_cast<RelationType>(aType));
michael@0:   NS_ADDREF(*aRelation = new nsAccessibleRelation(aType, &rel));
michael@0:   return *aRelation ? NS_OK : NS_ERROR_FAILURE;
michael@0: }
michael@0: 
michael@0: Relation
michael@0: Accessible::RelationByType(RelationType aType)
michael@0: {
michael@0:   if (!HasOwnContent())
michael@0:     return Relation();
michael@0: 
michael@0:   // Relationships are defined on the same content node that the role would be
michael@0:   // defined on.
michael@0:   switch (aType) {
michael@0:     case RelationType::LABELLED_BY: {
michael@0:       Relation rel(new IDRefsIterator(mDoc, mContent,
michael@0:                                       nsGkAtoms::aria_labelledby));
michael@0:       if (mContent->IsHTML()) {
michael@0:         rel.AppendIter(new HTMLLabelIterator(Document(), this));
michael@0:       } else if (mContent->IsXUL()) {
michael@0:         rel.AppendIter(new XULLabelIterator(Document(), mContent));
michael@0:       }
michael@0: 
michael@0:       return rel;
michael@0:     }
michael@0: 
michael@0:     case RelationType::LABEL_FOR: {
michael@0:       Relation rel(new RelatedAccIterator(Document(), mContent,
michael@0:                                           nsGkAtoms::aria_labelledby));
michael@0:       if (mContent->Tag() == nsGkAtoms::label && mContent->IsXUL())
michael@0:         rel.AppendIter(new IDRefsIterator(mDoc, mContent, nsGkAtoms::control));
michael@0: 
michael@0:       return rel;
michael@0:     }
michael@0: 
michael@0:     case RelationType::DESCRIBED_BY: {
michael@0:       Relation rel(new IDRefsIterator(mDoc, mContent,
michael@0:                                       nsGkAtoms::aria_describedby));
michael@0:       if (mContent->IsXUL())
michael@0:         rel.AppendIter(new XULDescriptionIterator(Document(), mContent));
michael@0: 
michael@0:       return rel;
michael@0:     }
michael@0: 
michael@0:     case RelationType::DESCRIPTION_FOR: {
michael@0:       Relation rel(new RelatedAccIterator(Document(), mContent,
michael@0:                                           nsGkAtoms::aria_describedby));
michael@0: 
michael@0:       // This affectively adds an optional control attribute to xul:description,
michael@0:       // which only affects accessibility, by allowing the description to be
michael@0:       // tied to a control.
michael@0:       if (mContent->Tag() == nsGkAtoms::description &&
michael@0:           mContent->IsXUL())
michael@0:         rel.AppendIter(new IDRefsIterator(mDoc, mContent,
michael@0:                                           nsGkAtoms::control));
michael@0: 
michael@0:       return rel;
michael@0:     }
michael@0: 
michael@0:     case RelationType::NODE_CHILD_OF: {
michael@0:       Relation rel(new RelatedAccIterator(Document(), mContent,
michael@0:                                           nsGkAtoms::aria_owns));
michael@0: 
michael@0:       // This is an ARIA tree or treegrid that doesn't use owns, so we need to
michael@0:       // get the parent the hard way.
michael@0:       if (mRoleMapEntry && (mRoleMapEntry->role == roles::OUTLINEITEM ||
michael@0:                             mRoleMapEntry->role == roles::LISTITEM ||
michael@0:                             mRoleMapEntry->role == roles::ROW)) {
michael@0:         rel.AppendTarget(GetGroupInfo()->ConceptualParent());
michael@0:       }
michael@0: 
michael@0:       // If accessible is in its own Window, or is the root of a document,
michael@0:       // then we should provide NODE_CHILD_OF relation so that MSAA clients
michael@0:       // can easily get to true parent instead of getting to oleacc's
michael@0:       // ROLE_WINDOW accessible which will prevent us from going up further
michael@0:       // (because it is system generated and has no idea about the hierarchy
michael@0:       // above it).
michael@0:       nsIFrame *frame = GetFrame();
michael@0:       if (frame) {
michael@0:         nsView *view = frame->GetViewExternal();
michael@0:         if (view) {
michael@0:           nsIScrollableFrame *scrollFrame = do_QueryFrame(frame);
michael@0:           if (scrollFrame || view->GetWidget() || !frame->GetParent())
michael@0:             rel.AppendTarget(Parent());
michael@0:         }
michael@0:       }
michael@0: 
michael@0:       return rel;
michael@0:     }
michael@0: 
michael@0:     case RelationType::NODE_PARENT_OF: {
michael@0:       Relation rel(new IDRefsIterator(mDoc, mContent, nsGkAtoms::aria_owns));
michael@0: 
michael@0:       // ARIA tree or treegrid can do the hierarchy by @aria-level, ARIA trees
michael@0:       // also can be organized by groups.
michael@0:       if (mRoleMapEntry &&
michael@0:           (mRoleMapEntry->role == roles::OUTLINEITEM ||
michael@0:            mRoleMapEntry->role == roles::LISTITEM ||
michael@0:            mRoleMapEntry->role == roles::ROW ||
michael@0:            mRoleMapEntry->role == roles::OUTLINE ||
michael@0:            mRoleMapEntry->role == roles::LIST ||
michael@0:            mRoleMapEntry->role == roles::TREE_TABLE)) {
michael@0:         rel.AppendIter(new ItemIterator(this));
michael@0:       }
michael@0: 
michael@0:       return rel;
michael@0:     }
michael@0: 
michael@0:     case RelationType::CONTROLLED_BY:
michael@0:       return Relation(new RelatedAccIterator(Document(), mContent,
michael@0:                                              nsGkAtoms::aria_controls));
michael@0: 
michael@0:     case RelationType::CONTROLLER_FOR: {
michael@0:       Relation rel(new IDRefsIterator(mDoc, mContent,
michael@0:                                       nsGkAtoms::aria_controls));
michael@0:       rel.AppendIter(new HTMLOutputIterator(Document(), mContent));
michael@0:       return rel;
michael@0:     }
michael@0: 
michael@0:     case RelationType::FLOWS_TO:
michael@0:       return Relation(new IDRefsIterator(mDoc, mContent,
michael@0:                                          nsGkAtoms::aria_flowto));
michael@0: 
michael@0:     case RelationType::FLOWS_FROM:
michael@0:       return Relation(new RelatedAccIterator(Document(), mContent,
michael@0:                                              nsGkAtoms::aria_flowto));
michael@0: 
michael@0:     case RelationType::MEMBER_OF:
michael@0:           return Relation(mDoc, GetAtomicRegion());
michael@0: 
michael@0:     case RelationType::SUBWINDOW_OF:
michael@0:     case RelationType::EMBEDS:
michael@0:     case RelationType::EMBEDDED_BY:
michael@0:     case RelationType::POPUP_FOR:
michael@0:     case RelationType::PARENT_WINDOW_OF:
michael@0:       return Relation();
michael@0: 
michael@0:     case RelationType::DEFAULT_BUTTON: {
michael@0:       if (mContent->IsHTML()) {
michael@0:         // HTML form controls implements nsIFormControl interface.
michael@0:         nsCOMPtr<nsIFormControl> control(do_QueryInterface(mContent));
michael@0:         if (control) {
michael@0:           nsCOMPtr<nsIForm> form(do_QueryInterface(control->GetFormElement()));
michael@0:           if (form) {
michael@0:             nsCOMPtr<nsIContent> formContent =
michael@0:               do_QueryInterface(form->GetDefaultSubmitElement());
michael@0:             return Relation(mDoc, formContent);
michael@0:           }
michael@0:         }
michael@0:       } else {
michael@0:         // In XUL, use first <button default="true" .../> in the document
michael@0:         nsCOMPtr<nsIDOMXULDocument> xulDoc =
michael@0:           do_QueryInterface(mContent->OwnerDoc());
michael@0:         nsCOMPtr<nsIDOMXULButtonElement> buttonEl;
michael@0:         if (xulDoc) {
michael@0:           nsCOMPtr<nsIDOMNodeList> possibleDefaultButtons;
michael@0:           xulDoc->GetElementsByAttribute(NS_LITERAL_STRING("default"),
michael@0:                                          NS_LITERAL_STRING("true"),
michael@0:                                          getter_AddRefs(possibleDefaultButtons));
michael@0:           if (possibleDefaultButtons) {
michael@0:             uint32_t length;
michael@0:             possibleDefaultButtons->GetLength(&length);
michael@0:             nsCOMPtr<nsIDOMNode> possibleButton;
michael@0:             // Check for button in list of default="true" elements
michael@0:             for (uint32_t count = 0; count < length && !buttonEl; count ++) {
michael@0:               possibleDefaultButtons->Item(count, getter_AddRefs(possibleButton));
michael@0:               buttonEl = do_QueryInterface(possibleButton);
michael@0:             }
michael@0:           }
michael@0:           if (!buttonEl) { // Check for anonymous accept button in <dialog>
michael@0:             dom::Element* rootElm = mContent->OwnerDoc()->GetRootElement();
michael@0:             if (rootElm) {
michael@0:               nsIContent* possibleButtonEl = rootElm->OwnerDoc()->
michael@0:                 GetAnonymousElementByAttribute(rootElm, nsGkAtoms::_default,
michael@0:                                                NS_LITERAL_STRING("true"));
michael@0:               buttonEl = do_QueryInterface(possibleButtonEl);
michael@0:             }
michael@0:           }
michael@0:           nsCOMPtr<nsIContent> relatedContent(do_QueryInterface(buttonEl));
michael@0:           return Relation(mDoc, relatedContent);
michael@0:         }
michael@0:       }
michael@0:       return Relation();
michael@0:     }
michael@0: 
michael@0:     case RelationType::CONTAINING_DOCUMENT:
michael@0:       return Relation(mDoc);
michael@0: 
michael@0:     case RelationType::CONTAINING_TAB_PANE: {
michael@0:       nsCOMPtr<nsIDocShell> docShell =
michael@0:         nsCoreUtils::GetDocShellFor(GetNode());
michael@0:       if (docShell) {
michael@0:         // Walk up the parent chain without crossing the boundary at which item
michael@0:         // types change, preventing us from walking up out of tab content.
michael@0:         nsCOMPtr<nsIDocShellTreeItem> root;
michael@0:         docShell->GetSameTypeRootTreeItem(getter_AddRefs(root));
michael@0:         if (root) {
michael@0:           // If the item type is typeContent, we assume we are in browser tab
michael@0:           // content. Note, this includes content such as about:addons,
michael@0:           // for consistency.
michael@0:           if (root->ItemType() == nsIDocShellTreeItem::typeContent) {
michael@0:             return Relation(nsAccUtils::GetDocAccessibleFor(root));
michael@0:           }
michael@0:         }
michael@0:       }
michael@0:       return  Relation();
michael@0:     }
michael@0: 
michael@0:     case RelationType::CONTAINING_APPLICATION:
michael@0:       return Relation(ApplicationAcc());
michael@0: 
michael@0:     default:
michael@0:       return Relation();
michael@0:   }
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetRelations(nsIArray **aRelations)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aRelations);
michael@0:   *aRelations = nullptr;
michael@0: 
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   nsCOMPtr<nsIMutableArray> relations = do_CreateInstance(NS_ARRAY_CONTRACTID);
michael@0:   NS_ENSURE_TRUE(relations, NS_ERROR_OUT_OF_MEMORY);
michael@0: 
michael@0:   static const uint32_t relationTypes[] = {
michael@0:     nsIAccessibleRelation::RELATION_LABELLED_BY,
michael@0:     nsIAccessibleRelation::RELATION_LABEL_FOR,
michael@0:     nsIAccessibleRelation::RELATION_DESCRIBED_BY,
michael@0:     nsIAccessibleRelation::RELATION_DESCRIPTION_FOR,
michael@0:     nsIAccessibleRelation::RELATION_NODE_CHILD_OF,
michael@0:     nsIAccessibleRelation::RELATION_NODE_PARENT_OF,
michael@0:     nsIAccessibleRelation::RELATION_CONTROLLED_BY,
michael@0:     nsIAccessibleRelation::RELATION_CONTROLLER_FOR,
michael@0:     nsIAccessibleRelation::RELATION_FLOWS_TO,
michael@0:     nsIAccessibleRelation::RELATION_FLOWS_FROM,
michael@0:     nsIAccessibleRelation::RELATION_MEMBER_OF,
michael@0:     nsIAccessibleRelation::RELATION_SUBWINDOW_OF,
michael@0:     nsIAccessibleRelation::RELATION_EMBEDS,
michael@0:     nsIAccessibleRelation::RELATION_EMBEDDED_BY,
michael@0:     nsIAccessibleRelation::RELATION_POPUP_FOR,
michael@0:     nsIAccessibleRelation::RELATION_PARENT_WINDOW_OF,
michael@0:     nsIAccessibleRelation::RELATION_DEFAULT_BUTTON,
michael@0:     nsIAccessibleRelation::RELATION_CONTAINING_DOCUMENT,
michael@0:     nsIAccessibleRelation::RELATION_CONTAINING_TAB_PANE,
michael@0:     nsIAccessibleRelation::RELATION_CONTAINING_APPLICATION
michael@0:   };
michael@0: 
michael@0:   for (uint32_t idx = 0; idx < ArrayLength(relationTypes); idx++) {
michael@0:     nsCOMPtr<nsIAccessibleRelation> relation;
michael@0:     nsresult rv = GetRelationByType(relationTypes[idx], getter_AddRefs(relation));
michael@0: 
michael@0:     if (NS_SUCCEEDED(rv) && relation) {
michael@0:       uint32_t targets = 0;
michael@0:       relation->GetTargetsCount(&targets);
michael@0:       if (targets)
michael@0:         relations->AppendElement(relation, false);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   NS_ADDREF(*aRelations = relations);
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: /* void extendSelection (); */
michael@0: NS_IMETHODIMP Accessible::ExtendSelection()
michael@0: {
michael@0:   // XXX Should be implemented, but not high priority
michael@0:   return NS_ERROR_NOT_IMPLEMENTED;
michael@0: }
michael@0: 
michael@0: /* [noscript] void getNativeInterface(out voidPtr aOutAccessible); */
michael@0: NS_IMETHODIMP Accessible::GetNativeInterface(void **aOutAccessible)
michael@0: {
michael@0:   return NS_ERROR_NOT_IMPLEMENTED;
michael@0: }
michael@0: 
michael@0: void
michael@0: Accessible::DoCommand(nsIContent *aContent, uint32_t aActionIndex)
michael@0: {
michael@0:   class Runnable MOZ_FINAL : public nsRunnable
michael@0:   {
michael@0:   public:
michael@0:     Runnable(Accessible* aAcc, nsIContent* aContent, uint32_t aIdx) :
michael@0:       mAcc(aAcc), mContent(aContent), mIdx(aIdx) { }
michael@0: 
michael@0:     NS_IMETHOD Run()
michael@0:     {
michael@0:       if (mAcc)
michael@0:         mAcc->DispatchClickEvent(mContent, mIdx);
michael@0: 
michael@0:       return NS_OK;
michael@0:     }
michael@0: 
michael@0:     void Revoke()
michael@0:     {
michael@0:       mAcc = nullptr;
michael@0:       mContent = nullptr;
michael@0:     }
michael@0: 
michael@0:   private:
michael@0:     nsRefPtr<Accessible> mAcc;
michael@0:     nsCOMPtr<nsIContent> mContent;
michael@0:     uint32_t mIdx;
michael@0:   };
michael@0: 
michael@0:   nsIContent* content = aContent ? aContent : mContent.get();
michael@0:   nsCOMPtr<nsIRunnable> runnable = new Runnable(this, content, aActionIndex);
michael@0:   NS_DispatchToMainThread(runnable);
michael@0: }
michael@0: 
michael@0: void
michael@0: Accessible::DispatchClickEvent(nsIContent *aContent, uint32_t aActionIndex)
michael@0: {
michael@0:   if (IsDefunct())
michael@0:     return;
michael@0: 
michael@0:   nsCOMPtr<nsIPresShell> presShell = mDoc->PresShell();
michael@0: 
michael@0:   // Scroll into view.
michael@0:   presShell->ScrollContentIntoView(aContent,
michael@0:                                    nsIPresShell::ScrollAxis(),
michael@0:                                    nsIPresShell::ScrollAxis(),
michael@0:                                    nsIPresShell::SCROLL_OVERFLOW_HIDDEN);
michael@0: 
michael@0:   nsWeakFrame frame = aContent->GetPrimaryFrame();
michael@0:   if (!frame)
michael@0:     return;
michael@0: 
michael@0:   // Compute x and y coordinates.
michael@0:   nsPoint point;
michael@0:   nsCOMPtr<nsIWidget> widget = frame->GetNearestWidget(point);
michael@0:   if (!widget)
michael@0:     return;
michael@0: 
michael@0:   nsSize size = frame->GetSize();
michael@0: 
michael@0:   nsRefPtr<nsPresContext> presContext = presShell->GetPresContext();
michael@0:   int32_t x = presContext->AppUnitsToDevPixels(point.x + size.width / 2);
michael@0:   int32_t y = presContext->AppUnitsToDevPixels(point.y + size.height / 2);
michael@0: 
michael@0:   // Simulate a touch interaction by dispatching touch events with mouse events.
michael@0:   nsCoreUtils::DispatchTouchEvent(NS_TOUCH_START, x, y, aContent, frame, presShell, widget);
michael@0:   nsCoreUtils::DispatchMouseEvent(NS_MOUSE_BUTTON_DOWN, x, y, aContent, frame, presShell, widget);
michael@0:   nsCoreUtils::DispatchTouchEvent(NS_TOUCH_END, x, y, aContent, frame, presShell, widget);
michael@0:   nsCoreUtils::DispatchMouseEvent(NS_MOUSE_BUTTON_UP, x, y, aContent, frame, presShell, widget);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: Accessible::ScrollTo(uint32_t aHow)
michael@0: {
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   nsCoreUtils::ScrollTo(mDoc->PresShell(), mContent, aHow);
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: Accessible::ScrollToPoint(uint32_t aCoordinateType, int32_t aX, int32_t aY)
michael@0: {
michael@0:   nsIFrame *frame = GetFrame();
michael@0:   if (!frame)
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   nsIntPoint coords = nsAccUtils::ConvertToScreenCoords(aX, aY, aCoordinateType,
michael@0:                                                         this);
michael@0: 
michael@0:   nsIFrame *parentFrame = frame;
michael@0:   while ((parentFrame = parentFrame->GetParent()))
michael@0:     nsCoreUtils::ScrollFrameToPoint(parentFrame, frame, coords);
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: // nsIAccessibleHyperLink
michael@0: // Because of new-atk design, any embedded object in text can implement
michael@0: // nsIAccessibleHyperLink, which helps determine where it is located
michael@0: // within containing text
michael@0: 
michael@0: // readonly attribute long nsIAccessibleHyperLink::anchorCount
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetAnchorCount(int32_t *aAnchorCount)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aAnchorCount);
michael@0:   *aAnchorCount = 0;
michael@0: 
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   *aAnchorCount = AnchorCount();
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: // readonly attribute long nsIAccessibleHyperLink::startIndex
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetStartIndex(int32_t *aStartIndex)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aStartIndex);
michael@0:   *aStartIndex = 0;
michael@0: 
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   *aStartIndex = StartOffset();
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: // readonly attribute long nsIAccessibleHyperLink::endIndex
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetEndIndex(int32_t *aEndIndex)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aEndIndex);
michael@0:   *aEndIndex = 0;
michael@0: 
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   *aEndIndex = EndOffset();
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetURI(int32_t aIndex, nsIURI **aURI)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aURI);
michael@0: 
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   if (aIndex < 0 || aIndex >= static_cast<int32_t>(AnchorCount()))
michael@0:     return NS_ERROR_INVALID_ARG;
michael@0: 
michael@0:   nsRefPtr<nsIURI>(AnchorURIAt(aIndex)).forget(aURI);
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetAnchor(int32_t aIndex, nsIAccessible** aAccessible)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aAccessible);
michael@0:   *aAccessible = nullptr;
michael@0: 
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   if (aIndex < 0 || aIndex >= static_cast<int32_t>(AnchorCount()))
michael@0:     return NS_ERROR_INVALID_ARG;
michael@0: 
michael@0:   NS_IF_ADDREF(*aAccessible = AnchorAt(aIndex));
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: // readonly attribute boolean nsIAccessibleHyperLink::valid
michael@0: NS_IMETHODIMP
michael@0: Accessible::GetValid(bool *aValid)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aValid);
michael@0:   *aValid = false;
michael@0: 
michael@0:   if (IsDefunct())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   *aValid = IsLinkValid();
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: void
michael@0: Accessible::AppendTextTo(nsAString& aText, uint32_t aStartOffset,
michael@0:                          uint32_t aLength)
michael@0: {
michael@0:   // Return text representation of non-text accessible within hypertext
michael@0:   // accessible. Text accessible overrides this method to return enclosed text.
michael@0:   if (aStartOffset != 0 || aLength == 0)
michael@0:     return;
michael@0: 
michael@0:   nsIFrame *frame = GetFrame();
michael@0:   if (!frame)
michael@0:     return;
michael@0: 
michael@0:   NS_ASSERTION(mParent,
michael@0:                "Called on accessible unbound from tree. Result can be wrong.");
michael@0: 
michael@0:   if (frame->GetType() == nsGkAtoms::brFrame) {
michael@0:     aText += kForcedNewLineChar;
michael@0:   } else if (mParent && nsAccUtils::MustPrune(mParent)) {
michael@0:     // Expose the embedded object accessible as imaginary embedded object
michael@0:     // character if its parent hypertext accessible doesn't expose children to
michael@0:     // AT.
michael@0:     aText += kImaginaryEmbeddedObjectChar;
michael@0:   } else {
michael@0:     aText += kEmbeddedObjectChar;
michael@0:   }
michael@0: }
michael@0: 
michael@0: void
michael@0: Accessible::Shutdown()
michael@0: {
michael@0:   // Mark the accessible as defunct, invalidate the child count and pointers to 
michael@0:   // other accessibles, also make sure none of its children point to this parent
michael@0:   mStateFlags |= eIsDefunct;
michael@0: 
michael@0:   InvalidateChildren();
michael@0:   if (mParent)
michael@0:     mParent->RemoveChild(this);
michael@0: 
michael@0:   mContent = nullptr;
michael@0:   mDoc = nullptr;
michael@0: }
michael@0: 
michael@0: // Accessible protected
michael@0: void
michael@0: Accessible::ARIAName(nsString& aName)
michael@0: {
michael@0:   // aria-labelledby now takes precedence over aria-label
michael@0:   nsresult rv = nsTextEquivUtils::
michael@0:     GetTextEquivFromIDRefs(this, nsGkAtoms::aria_labelledby, aName);
michael@0:   if (NS_SUCCEEDED(rv)) {
michael@0:     aName.CompressWhitespace();
michael@0:   }
michael@0: 
michael@0:   if (aName.IsEmpty() &&
michael@0:       mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::aria_label, aName)) {
michael@0:     aName.CompressWhitespace();
michael@0:   }
michael@0: }
michael@0: 
michael@0: // Accessible protected
michael@0: ENameValueFlag
michael@0: Accessible::NativeName(nsString& aName)
michael@0: {
michael@0:   if (mContent->IsHTML()) {
michael@0:     Accessible* label = nullptr;
michael@0:     HTMLLabelIterator iter(Document(), this);
michael@0:     while ((label = iter.Next())) {
michael@0:       nsTextEquivUtils::AppendTextEquivFromContent(this, label->GetContent(),
michael@0:                                                    &aName);
michael@0:       aName.CompressWhitespace();
michael@0:     }
michael@0: 
michael@0:     if (!aName.IsEmpty())
michael@0:       return eNameOK;
michael@0: 
michael@0:     nsTextEquivUtils::GetNameFromSubtree(this, aName);
michael@0:     return aName.IsEmpty() ? eNameOK : eNameFromSubtree;
michael@0:   }
michael@0: 
michael@0:   if (mContent->IsXUL()) {
michael@0:     XULElmName(mDoc, mContent, aName);
michael@0:     if (!aName.IsEmpty())
michael@0:       return eNameOK;
michael@0: 
michael@0:     nsTextEquivUtils::GetNameFromSubtree(this, aName);
michael@0:     return aName.IsEmpty() ? eNameOK : eNameFromSubtree;
michael@0:   }
michael@0: 
michael@0:   if (mContent->IsSVG()) {
michael@0:     // If user agents need to choose among multiple ‘desc’ or ‘title’ elements
michael@0:     // for processing, the user agent shall choose the first one.
michael@0:     for (nsIContent* childElm = mContent->GetFirstChild(); childElm;
michael@0:          childElm = childElm->GetNextSibling()) {
michael@0:       if (childElm->IsSVG(nsGkAtoms::title)) {
michael@0:         nsTextEquivUtils::AppendTextEquivFromContent(this, childElm, &aName);
michael@0:         return eNameOK;
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return eNameOK;
michael@0: }
michael@0: 
michael@0: // Accessible protected
michael@0: void
michael@0: Accessible::BindToParent(Accessible* aParent, uint32_t aIndexInParent)
michael@0: {
michael@0:   NS_PRECONDITION(aParent, "This method isn't used to set null parent!");
michael@0: 
michael@0:   if (mParent) {
michael@0:     if (mParent != aParent) {
michael@0:       NS_ERROR("Adopting child!");
michael@0:       mParent->RemoveChild(this);
michael@0:       mParent->InvalidateChildrenGroupInfo();
michael@0:     } else {
michael@0:       NS_ERROR("Binding to the same parent!");
michael@0:       return;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   mParent = aParent;
michael@0:   mIndexInParent = aIndexInParent;
michael@0: 
michael@0:   mParent->InvalidateChildrenGroupInfo();
michael@0: 
michael@0:   // Note: this is currently only used for richlistitems and their children.
michael@0:   if (mParent->HasNameDependentParent() || mParent->IsXULListItem())
michael@0:     mContextFlags |= eHasNameDependentParent;
michael@0:   else
michael@0:     mContextFlags &= ~eHasNameDependentParent;
michael@0: }
michael@0: 
michael@0: // Accessible protected
michael@0: void
michael@0: Accessible::UnbindFromParent()
michael@0: {
michael@0:   mParent->InvalidateChildrenGroupInfo();
michael@0:   mParent = nullptr;
michael@0:   mIndexInParent = -1;
michael@0:   mIndexOfEmbeddedChild = -1;
michael@0:   mGroupInfo = nullptr;
michael@0:   mContextFlags &= ~eHasNameDependentParent;
michael@0: }
michael@0: 
michael@0: ////////////////////////////////////////////////////////////////////////////////
michael@0: // Accessible public methods
michael@0: 
michael@0: RootAccessible*
michael@0: Accessible::RootAccessible() const
michael@0: {
michael@0:   nsCOMPtr<nsIDocShell> docShell = nsCoreUtils::GetDocShellFor(GetNode());
michael@0:   NS_ASSERTION(docShell, "No docshell for mContent");
michael@0:   if (!docShell) {
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIDocShellTreeItem> root;
michael@0:   docShell->GetRootTreeItem(getter_AddRefs(root));
michael@0:   NS_ASSERTION(root, "No root content tree item");
michael@0:   if (!root) {
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   DocAccessible* docAcc = nsAccUtils::GetDocAccessibleFor(root);
michael@0:   return docAcc ? docAcc->AsRoot() : nullptr;
michael@0: }
michael@0: 
michael@0: nsIFrame*
michael@0: Accessible::GetFrame() const
michael@0: {
michael@0:   return mContent ? mContent->GetPrimaryFrame() : nullptr;
michael@0: }
michael@0: 
michael@0: nsINode*
michael@0: Accessible::GetNode() const
michael@0: {
michael@0:   return mContent;
michael@0: }
michael@0: 
michael@0: void
michael@0: Accessible::Language(nsAString& aLanguage)
michael@0: {
michael@0:   aLanguage.Truncate();
michael@0: 
michael@0:   if (!mDoc)
michael@0:     return;
michael@0: 
michael@0:   nsCoreUtils::GetLanguageFor(mContent, nullptr, aLanguage);
michael@0:   if (aLanguage.IsEmpty()) { // Nothing found, so use document's language
michael@0:     mDoc->DocumentNode()->GetHeaderData(nsGkAtoms::headerContentLanguage,
michael@0:                                         aLanguage);
michael@0:   }
michael@0: }
michael@0: 
michael@0: void
michael@0: Accessible::InvalidateChildren()
michael@0: {
michael@0:   int32_t childCount = mChildren.Length();
michael@0:   for (int32_t childIdx = 0; childIdx < childCount; childIdx++) {
michael@0:     Accessible* child = mChildren.ElementAt(childIdx);
michael@0:     child->UnbindFromParent();
michael@0:   }
michael@0: 
michael@0:   mEmbeddedObjCollector = nullptr;
michael@0:   mChildren.Clear();
michael@0:   SetChildrenFlag(eChildrenUninitialized);
michael@0: }
michael@0: 
michael@0: bool
michael@0: Accessible::InsertChildAt(uint32_t aIndex, Accessible* aChild)
michael@0: {
michael@0:   if (!aChild)
michael@0:     return false;
michael@0: 
michael@0:   if (aIndex == mChildren.Length()) {
michael@0:     if (!mChildren.AppendElement(aChild))
michael@0:       return false;
michael@0: 
michael@0:   } else {
michael@0:     if (!mChildren.InsertElementAt(aIndex, aChild))
michael@0:       return false;
michael@0: 
michael@0:     for (uint32_t idx = aIndex + 1; idx < mChildren.Length(); idx++) {
michael@0:       NS_ASSERTION(static_cast<uint32_t>(mChildren[idx]->mIndexInParent) == idx - 1,
michael@0:                    "Accessible child index doesn't match");
michael@0:       mChildren[idx]->mIndexInParent = idx;
michael@0:     }
michael@0: 
michael@0:     mEmbeddedObjCollector = nullptr;
michael@0:   }
michael@0: 
michael@0:   if (!nsAccUtils::IsEmbeddedObject(aChild))
michael@0:     SetChildrenFlag(eMixedChildren);
michael@0: 
michael@0:   aChild->BindToParent(this, aIndex);
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: bool
michael@0: Accessible::RemoveChild(Accessible* aChild)
michael@0: {
michael@0:   if (!aChild)
michael@0:     return false;
michael@0: 
michael@0:   if (aChild->mParent != this || aChild->mIndexInParent == -1)
michael@0:     return false;
michael@0: 
michael@0:   uint32_t index = static_cast<uint32_t>(aChild->mIndexInParent);
michael@0:   if (index >= mChildren.Length() || mChildren[index] != aChild) {
michael@0:     NS_ERROR("Child is bound to parent but parent hasn't this child at its index!");
michael@0:     aChild->UnbindFromParent();
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   for (uint32_t idx = index + 1; idx < mChildren.Length(); idx++) {
michael@0:     NS_ASSERTION(static_cast<uint32_t>(mChildren[idx]->mIndexInParent) == idx,
michael@0:                  "Accessible child index doesn't match");
michael@0:     mChildren[idx]->mIndexInParent = idx - 1;
michael@0:   }
michael@0: 
michael@0:   aChild->UnbindFromParent();
michael@0:   mChildren.RemoveElementAt(index);
michael@0:   mEmbeddedObjCollector = nullptr;
michael@0: 
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: Accessible*
michael@0: Accessible::GetChildAt(uint32_t aIndex) const
michael@0: {
michael@0:   Accessible* child = mChildren.SafeElementAt(aIndex, nullptr);
michael@0:   if (!child)
michael@0:     return nullptr;
michael@0: 
michael@0: #ifdef DEBUG
michael@0:   Accessible* realParent = child->mParent;
michael@0:   NS_ASSERTION(!realParent || realParent == this,
michael@0:                "Two accessibles have the same first child accessible!");
michael@0: #endif
michael@0: 
michael@0:   return child;
michael@0: }
michael@0: 
michael@0: uint32_t
michael@0: Accessible::ChildCount() const
michael@0: {
michael@0:   return mChildren.Length();
michael@0: }
michael@0: 
michael@0: int32_t
michael@0: Accessible::IndexInParent() const
michael@0: {
michael@0:   return mIndexInParent;
michael@0: }
michael@0: 
michael@0: uint32_t
michael@0: Accessible::EmbeddedChildCount()
michael@0: {
michael@0:   if (IsChildrenFlag(eMixedChildren)) {
michael@0:     if (!mEmbeddedObjCollector)
michael@0:       mEmbeddedObjCollector = new EmbeddedObjCollector(this);
michael@0:     return mEmbeddedObjCollector->Count();
michael@0:   }
michael@0: 
michael@0:   return ChildCount();
michael@0: }
michael@0: 
michael@0: Accessible*
michael@0: Accessible::GetEmbeddedChildAt(uint32_t aIndex)
michael@0: {
michael@0:   if (IsChildrenFlag(eMixedChildren)) {
michael@0:     if (!mEmbeddedObjCollector)
michael@0:       mEmbeddedObjCollector = new EmbeddedObjCollector(this);
michael@0:     return mEmbeddedObjCollector ?
michael@0:       mEmbeddedObjCollector->GetAccessibleAt(aIndex) : nullptr;
michael@0:   }
michael@0: 
michael@0:   return GetChildAt(aIndex);
michael@0: }
michael@0: 
michael@0: int32_t
michael@0: Accessible::GetIndexOfEmbeddedChild(Accessible* aChild)
michael@0: {
michael@0:   if (IsChildrenFlag(eMixedChildren)) {
michael@0:     if (!mEmbeddedObjCollector)
michael@0:       mEmbeddedObjCollector = new EmbeddedObjCollector(this);
michael@0:     return mEmbeddedObjCollector ?
michael@0:       mEmbeddedObjCollector->GetIndexAt(aChild) : -1;
michael@0:   }
michael@0: 
michael@0:   return GetIndexOf(aChild);
michael@0: }
michael@0: 
michael@0: ////////////////////////////////////////////////////////////////////////////////
michael@0: // HyperLinkAccessible methods
michael@0: 
michael@0: bool
michael@0: Accessible::IsLink()
michael@0: {
michael@0:   // Every embedded accessible within hypertext accessible implements
michael@0:   // hyperlink interface.
michael@0:   return mParent && mParent->IsHyperText() && nsAccUtils::IsEmbeddedObject(this);
michael@0: }
michael@0: 
michael@0: uint32_t
michael@0: Accessible::StartOffset()
michael@0: {
michael@0:   NS_PRECONDITION(IsLink(), "StartOffset is called not on hyper link!");
michael@0: 
michael@0:   HyperTextAccessible* hyperText = mParent ? mParent->AsHyperText() : nullptr;
michael@0:   return hyperText ? hyperText->GetChildOffset(this) : 0;
michael@0: }
michael@0: 
michael@0: uint32_t
michael@0: Accessible::EndOffset()
michael@0: {
michael@0:   NS_PRECONDITION(IsLink(), "EndOffset is called on not hyper link!");
michael@0: 
michael@0:   HyperTextAccessible* hyperText = mParent ? mParent->AsHyperText() : nullptr;
michael@0:   return hyperText ? (hyperText->GetChildOffset(this) + 1) : 0;
michael@0: }
michael@0: 
michael@0: uint32_t
michael@0: Accessible::AnchorCount()
michael@0: {
michael@0:   NS_PRECONDITION(IsLink(), "AnchorCount is called on not hyper link!");
michael@0:   return 1;
michael@0: }
michael@0: 
michael@0: Accessible*
michael@0: Accessible::AnchorAt(uint32_t aAnchorIndex)
michael@0: {
michael@0:   NS_PRECONDITION(IsLink(), "GetAnchor is called on not hyper link!");
michael@0:   return aAnchorIndex == 0 ? this : nullptr;
michael@0: }
michael@0: 
michael@0: already_AddRefed<nsIURI>
michael@0: Accessible::AnchorURIAt(uint32_t aAnchorIndex)
michael@0: {
michael@0:   NS_PRECONDITION(IsLink(), "AnchorURIAt is called on not hyper link!");
michael@0:   return nullptr;
michael@0: }
michael@0: 
michael@0: 
michael@0: ////////////////////////////////////////////////////////////////////////////////
michael@0: // SelectAccessible
michael@0: 
michael@0: already_AddRefed<nsIArray>
michael@0: Accessible::SelectedItems()
michael@0: {
michael@0:   nsCOMPtr<nsIMutableArray> selectedItems = do_CreateInstance(NS_ARRAY_CONTRACTID);
michael@0:   if (!selectedItems)
michael@0:     return nullptr;
michael@0: 
michael@0:   AccIterator iter(this, filters::GetSelected);
michael@0:   nsIAccessible* selected = nullptr;
michael@0:   while ((selected = iter.Next()))
michael@0:     selectedItems->AppendElement(selected, false);
michael@0: 
michael@0:   return selectedItems.forget();
michael@0: }
michael@0: 
michael@0: uint32_t
michael@0: Accessible::SelectedItemCount()
michael@0: {
michael@0:   uint32_t count = 0;
michael@0:   AccIterator iter(this, filters::GetSelected);
michael@0:   Accessible* selected = nullptr;
michael@0:   while ((selected = iter.Next()))
michael@0:     ++count;
michael@0: 
michael@0:   return count;
michael@0: }
michael@0: 
michael@0: Accessible*
michael@0: Accessible::GetSelectedItem(uint32_t aIndex)
michael@0: {
michael@0:   AccIterator iter(this, filters::GetSelected);
michael@0:   Accessible* selected = nullptr;
michael@0: 
michael@0:   uint32_t index = 0;
michael@0:   while ((selected = iter.Next()) && index < aIndex)
michael@0:     index++;
michael@0: 
michael@0:   return selected;
michael@0: }
michael@0: 
michael@0: bool
michael@0: Accessible::IsItemSelected(uint32_t aIndex)
michael@0: {
michael@0:   uint32_t index = 0;
michael@0:   AccIterator iter(this, filters::GetSelectable);
michael@0:   Accessible* selected = nullptr;
michael@0:   while ((selected = iter.Next()) && index < aIndex)
michael@0:     index++;
michael@0: 
michael@0:   return selected &&
michael@0:     selected->State() & states::SELECTED;
michael@0: }
michael@0: 
michael@0: bool
michael@0: Accessible::AddItemToSelection(uint32_t aIndex)
michael@0: {
michael@0:   uint32_t index = 0;
michael@0:   AccIterator iter(this, filters::GetSelectable);
michael@0:   Accessible* selected = nullptr;
michael@0:   while ((selected = iter.Next()) && index < aIndex)
michael@0:     index++;
michael@0: 
michael@0:   if (selected)
michael@0:     selected->SetSelected(true);
michael@0: 
michael@0:   return static_cast<bool>(selected);
michael@0: }
michael@0: 
michael@0: bool
michael@0: Accessible::RemoveItemFromSelection(uint32_t aIndex)
michael@0: {
michael@0:   uint32_t index = 0;
michael@0:   AccIterator iter(this, filters::GetSelectable);
michael@0:   Accessible* selected = nullptr;
michael@0:   while ((selected = iter.Next()) && index < aIndex)
michael@0:     index++;
michael@0: 
michael@0:   if (selected)
michael@0:     selected->SetSelected(false);
michael@0: 
michael@0:   return static_cast<bool>(selected);
michael@0: }
michael@0: 
michael@0: bool
michael@0: Accessible::SelectAll()
michael@0: {
michael@0:   bool success = false;
michael@0:   Accessible* selectable = nullptr;
michael@0: 
michael@0:   AccIterator iter(this, filters::GetSelectable);
michael@0:   while((selectable = iter.Next())) {
michael@0:     success = true;
michael@0:     selectable->SetSelected(true);
michael@0:   }
michael@0:   return success;
michael@0: }
michael@0: 
michael@0: bool
michael@0: Accessible::UnselectAll()
michael@0: {
michael@0:   bool success = false;
michael@0:   Accessible* selected = nullptr;
michael@0: 
michael@0:   AccIterator iter(this, filters::GetSelected);
michael@0:   while ((selected = iter.Next())) {
michael@0:     success = true;
michael@0:     selected->SetSelected(false);
michael@0:   }
michael@0:   return success;
michael@0: }
michael@0: 
michael@0: ////////////////////////////////////////////////////////////////////////////////
michael@0: // Widgets
michael@0: 
michael@0: bool
michael@0: Accessible::IsWidget() const
michael@0: {
michael@0:   return false;
michael@0: }
michael@0: 
michael@0: bool
michael@0: Accessible::IsActiveWidget() const
michael@0: {
michael@0:   if (FocusMgr()->HasDOMFocus(mContent))
michael@0:     return true;
michael@0: 
michael@0:   // If text entry of combobox widget has a focus then the combobox widget is
michael@0:   // active.
michael@0:   if (mRoleMapEntry && mRoleMapEntry->Is(nsGkAtoms::combobox)) {
michael@0:     uint32_t childCount = ChildCount();
michael@0:     for (uint32_t idx = 0; idx < childCount; idx++) {
michael@0:       Accessible* child = mChildren.ElementAt(idx);
michael@0:       if (child->Role() == roles::ENTRY)
michael@0:         return FocusMgr()->HasDOMFocus(child->GetContent());
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return false;
michael@0: }
michael@0: 
michael@0: bool
michael@0: Accessible::AreItemsOperable() const
michael@0: {
michael@0:   return HasOwnContent() &&
michael@0:     mContent->HasAttr(kNameSpaceID_None, nsGkAtoms::aria_activedescendant);
michael@0: }
michael@0: 
michael@0: Accessible*
michael@0: Accessible::CurrentItem()
michael@0: {
michael@0:   // Check for aria-activedescendant, which changes which element has focus.
michael@0:   // For activedescendant, the ARIA spec does not require that the user agent
michael@0:   // checks whether pointed node is actually a DOM descendant of the element
michael@0:   // with the aria-activedescendant attribute.
michael@0:   nsAutoString id;
michael@0:   if (HasOwnContent() &&
michael@0:       mContent->GetAttr(kNameSpaceID_None,
michael@0:                         nsGkAtoms::aria_activedescendant, id)) {
michael@0:     nsIDocument* DOMDoc = mContent->OwnerDoc();
michael@0:     dom::Element* activeDescendantElm = DOMDoc->GetElementById(id);
michael@0:     if (activeDescendantElm) {
michael@0:       DocAccessible* document = Document();
michael@0:       if (document)
michael@0:         return document->GetAccessible(activeDescendantElm);
michael@0:     }
michael@0:   }
michael@0:   return nullptr;
michael@0: }
michael@0: 
michael@0: void
michael@0: Accessible::SetCurrentItem(Accessible* aItem)
michael@0: {
michael@0:   nsIAtom* id = aItem->GetContent()->GetID();
michael@0:   if (id) {
michael@0:     nsAutoString idStr;
michael@0:     id->ToString(idStr);
michael@0:     mContent->SetAttr(kNameSpaceID_None,
michael@0:                       nsGkAtoms::aria_activedescendant, idStr, true);
michael@0:   }
michael@0: }
michael@0: 
michael@0: Accessible*
michael@0: Accessible::ContainerWidget() const
michael@0: {
michael@0:   if (HasARIARole() && mContent->HasID()) {
michael@0:     for (Accessible* parent = Parent(); parent; parent = parent->Parent()) {
michael@0:       nsIContent* parentContent = parent->GetContent();
michael@0:       if (parentContent &&
michael@0:         parentContent->HasAttr(kNameSpaceID_None,
michael@0:                                nsGkAtoms::aria_activedescendant)) {
michael@0:         return parent;
michael@0:       }
michael@0: 
michael@0:       // Don't cross DOM document boundaries.
michael@0:       if (parent->IsDoc())
michael@0:         break;
michael@0:     }
michael@0:   }
michael@0:   return nullptr;
michael@0: }
michael@0: 
michael@0: ////////////////////////////////////////////////////////////////////////////////
michael@0: // Accessible protected methods
michael@0: 
michael@0: void
michael@0: Accessible::LastRelease()
michael@0: {
michael@0:   // First cleanup if needed...
michael@0:   if (mDoc) {
michael@0:     Shutdown();
michael@0:     NS_ASSERTION(!mDoc,
michael@0:                  "A Shutdown() impl forgot to call its parent's Shutdown?");
michael@0:   }
michael@0:   // ... then die.
michael@0:   delete this;
michael@0: }
michael@0: 
michael@0: void
michael@0: Accessible::CacheChildren()
michael@0: {
michael@0:   DocAccessible* doc = Document();
michael@0:   NS_ENSURE_TRUE_VOID(doc);
michael@0: 
michael@0:   TreeWalker walker(this, mContent);
michael@0: 
michael@0:   Accessible* child = nullptr;
michael@0:   while ((child = walker.NextChild()) && AppendChild(child));
michael@0: }
michael@0: 
michael@0: void
michael@0: Accessible::TestChildCache(Accessible* aCachedChild) const
michael@0: {
michael@0: #ifdef DEBUG
michael@0:   int32_t childCount = mChildren.Length();
michael@0:   if (childCount == 0) {
michael@0:     NS_ASSERTION(IsChildrenFlag(eChildrenUninitialized),
michael@0:                  "No children but initialized!");
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   Accessible* child = nullptr;
michael@0:   for (int32_t childIdx = 0; childIdx < childCount; childIdx++) {
michael@0:     child = mChildren[childIdx];
michael@0:     if (child == aCachedChild)
michael@0:       break;
michael@0:   }
michael@0: 
michael@0:   NS_ASSERTION(child == aCachedChild,
michael@0:                "[TestChildCache] cached accessible wasn't found. Wrong accessible tree!");  
michael@0: #endif
michael@0: }
michael@0: 
michael@0: // Accessible public
michael@0: bool
michael@0: Accessible::EnsureChildren()
michael@0: {
michael@0:   if (IsDefunct()) {
michael@0:     SetChildrenFlag(eChildrenUninitialized);
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   if (!IsChildrenFlag(eChildrenUninitialized))
michael@0:     return false;
michael@0: 
michael@0:   // State is embedded children until text leaf accessible is appended.
michael@0:   SetChildrenFlag(eEmbeddedChildren); // Prevent reentry
michael@0: 
michael@0:   CacheChildren();
michael@0:   return false;
michael@0: }
michael@0: 
michael@0: Accessible*
michael@0: Accessible::GetSiblingAtOffset(int32_t aOffset, nsresult* aError) const
michael@0: {
michael@0:   if (!mParent || mIndexInParent == -1) {
michael@0:     if (aError)
michael@0:       *aError = NS_ERROR_UNEXPECTED;
michael@0: 
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   if (aError &&
michael@0:       mIndexInParent + aOffset >= static_cast<int32_t>(mParent->ChildCount())) {
michael@0:     *aError = NS_OK; // fail peacefully
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   Accessible* child = mParent->GetChildAt(mIndexInParent + aOffset);
michael@0:   if (aError && !child)
michael@0:     *aError = NS_ERROR_UNEXPECTED;
michael@0: 
michael@0:   return child;
michael@0: }
michael@0: 
michael@0: double
michael@0: Accessible::AttrNumericValue(nsIAtom* aAttr) const
michael@0: {
michael@0:   if (!mRoleMapEntry || mRoleMapEntry->valueRule == eNoValue)
michael@0:     return UnspecifiedNaN<double>();
michael@0: 
michael@0:   nsAutoString attrValue;
michael@0:   if (!mContent->GetAttr(kNameSpaceID_None, aAttr, attrValue))
michael@0:     return UnspecifiedNaN<double>();
michael@0: 
michael@0:   nsresult error = NS_OK;
michael@0:   double value = attrValue.ToDouble(&error);
michael@0:   return NS_FAILED(error) ? UnspecifiedNaN<double>() : value;
michael@0: }
michael@0: 
michael@0: uint32_t
michael@0: Accessible::GetActionRule()
michael@0: {
michael@0:   if (!HasOwnContent() || (InteractiveState() & states::UNAVAILABLE))
michael@0:     return eNoAction;
michael@0: 
michael@0:   // Return "click" action on elements that have an attached popup menu.
michael@0:   if (mContent->IsXUL())
michael@0:     if (mContent->HasAttr(kNameSpaceID_None, nsGkAtoms::popup))
michael@0:       return eClickAction;
michael@0: 
michael@0:   // Has registered 'click' event handler.
michael@0:   bool isOnclick = nsCoreUtils::HasClickListener(mContent);
michael@0: 
michael@0:   if (isOnclick)
michael@0:     return eClickAction;
michael@0:   
michael@0:   // Get an action based on ARIA role.
michael@0:   if (mRoleMapEntry &&
michael@0:       mRoleMapEntry->actionRule != eNoAction)
michael@0:     return mRoleMapEntry->actionRule;
michael@0: 
michael@0:   // Get an action based on ARIA attribute.
michael@0:   if (nsAccUtils::HasDefinedARIAToken(mContent,
michael@0:                                       nsGkAtoms::aria_expanded))
michael@0:     return eExpandAction;
michael@0: 
michael@0:   return eNoAction;
michael@0: }
michael@0: 
michael@0: AccGroupInfo*
michael@0: Accessible::GetGroupInfo()
michael@0: {
michael@0:   if (mGroupInfo){
michael@0:     if (HasDirtyGroupInfo()) {
michael@0:       mGroupInfo->Update();
michael@0:       SetDirtyGroupInfo(false);
michael@0:     }
michael@0: 
michael@0:     return mGroupInfo;
michael@0:   }
michael@0: 
michael@0:   mGroupInfo = AccGroupInfo::CreateGroupInfo(this);
michael@0:   return mGroupInfo;
michael@0: }
michael@0: 
michael@0: void
michael@0: Accessible::InvalidateChildrenGroupInfo()
michael@0: {
michael@0:   uint32_t length = mChildren.Length();
michael@0:   for (uint32_t i = 0; i < length; i++) {
michael@0:     Accessible* child = mChildren[i];
michael@0:     child->SetDirtyGroupInfo(true);
michael@0:   }
michael@0: }
michael@0: 
michael@0: void
michael@0: Accessible::GetPositionAndSizeInternal(int32_t *aPosInSet, int32_t *aSetSize)
michael@0: {
michael@0:   AccGroupInfo* groupInfo = GetGroupInfo();
michael@0:   if (groupInfo) {
michael@0:     *aPosInSet = groupInfo->PosInSet();
michael@0:     *aSetSize = groupInfo->SetSize();
michael@0:   }
michael@0: }
michael@0: 
michael@0: int32_t
michael@0: Accessible::GetLevelInternal()
michael@0: {
michael@0:   int32_t level = nsAccUtils::GetDefaultLevel(this);
michael@0: 
michael@0:   if (!IsBoundToParent())
michael@0:     return level;
michael@0: 
michael@0:   roles::Role role = Role();
michael@0:   if (role == roles::OUTLINEITEM) {
michael@0:     // Always expose 'level' attribute for 'outlineitem' accessible. The number
michael@0:     // of nested 'grouping' accessibles containing 'outlineitem' accessible is
michael@0:     // its level.
michael@0:     level = 1;
michael@0: 
michael@0:     Accessible* parent = this;
michael@0:     while ((parent = parent->Parent())) {
michael@0:       roles::Role parentRole = parent->Role();
michael@0: 
michael@0:       if (parentRole == roles::OUTLINE)
michael@0:         break;
michael@0:       if (parentRole == roles::GROUPING)
michael@0:         ++ level;
michael@0: 
michael@0:     }
michael@0: 
michael@0:   } else if (role == roles::LISTITEM) {
michael@0:     // Expose 'level' attribute on nested lists. We support two hierarchies:
michael@0:     // a) list -> listitem -> list -> listitem (nested list is a last child
michael@0:     //   of listitem of the parent list);
michael@0:     // b) list -> listitem -> group -> listitem (nested listitems are contained
michael@0:     //   by group that is a last child of the parent listitem).
michael@0: 
michael@0:     // Calculate 'level' attribute based on number of parent listitems.
michael@0:     level = 0;
michael@0:     Accessible* parent = this;
michael@0:     while ((parent = parent->Parent())) {
michael@0:       roles::Role parentRole = parent->Role();
michael@0: 
michael@0:       if (parentRole == roles::LISTITEM)
michael@0:         ++ level;
michael@0:       else if (parentRole != roles::LIST && parentRole != roles::GROUPING)
michael@0:         break;
michael@0:     }
michael@0: 
michael@0:     if (level == 0) {
michael@0:       // If this listitem is on top of nested lists then expose 'level'
michael@0:       // attribute.
michael@0:       parent = Parent();
michael@0:       uint32_t siblingCount = parent->ChildCount();
michael@0:       for (uint32_t siblingIdx = 0; siblingIdx < siblingCount; siblingIdx++) {
michael@0:         Accessible* sibling = parent->GetChildAt(siblingIdx);
michael@0: 
michael@0:         Accessible* siblingChild = sibling->LastChild();
michael@0:         if (siblingChild) {
michael@0:           roles::Role lastChildRole = siblingChild->Role();
michael@0:           if (lastChildRole == roles::LIST || lastChildRole == roles::GROUPING)
michael@0:             return 1;
michael@0:         }
michael@0:       }
michael@0:     } else {
michael@0:       ++ level; // level is 1-index based
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return level;
michael@0: }
michael@0: 
michael@0: void
michael@0: Accessible::StaticAsserts() const
michael@0: {
michael@0:   static_assert(eLastChildrenFlag <= (1 << kChildrenFlagsBits) - 1,
michael@0:                 "Accessible::mChildrenFlags was oversized by eLastChildrenFlag!");
michael@0:   static_assert(eLastStateFlag <= (1 << kStateFlagsBits) - 1,
michael@0:                 "Accessible::mStateFlags was oversized by eLastStateFlag!");
michael@0:   static_assert(eLastAccType <= (1 << kTypeBits) - 1,
michael@0:                 "Accessible::mType was oversized by eLastAccType!");
michael@0:   static_assert(eLastContextFlag <= (1 << kContextFlagsBits) - 1,
michael@0:                 "Accessible::mContextFlags was oversized by eLastContextFlag!");
michael@0:   static_assert(eLastAccGenericType <= (1 << kGenericTypesBits) - 1,
michael@0:                 "Accessible::mGenericType was oversized by eLastAccGenericType!");
michael@0: }
michael@0: 
michael@0: 
michael@0: ////////////////////////////////////////////////////////////////////////////////
michael@0: // KeyBinding class
michael@0: 
michael@0: void
michael@0: KeyBinding::ToPlatformFormat(nsAString& aValue) const
michael@0: {
michael@0:   nsCOMPtr<nsIStringBundle> keyStringBundle;
michael@0:   nsCOMPtr<nsIStringBundleService> stringBundleService =
michael@0:       mozilla::services::GetStringBundleService();
michael@0:   if (stringBundleService)
michael@0:     stringBundleService->CreateBundle(
michael@0:       "chrome://global-platform/locale/platformKeys.properties",
michael@0:       getter_AddRefs(keyStringBundle));
michael@0: 
michael@0:   if (!keyStringBundle)
michael@0:     return;
michael@0: 
michael@0:   nsAutoString separator;
michael@0:   keyStringBundle->GetStringFromName(MOZ_UTF16("MODIFIER_SEPARATOR"),
michael@0:                                      getter_Copies(separator));
michael@0: 
michael@0:   nsAutoString modifierName;
michael@0:   if (mModifierMask & kControl) {
michael@0:     keyStringBundle->GetStringFromName(MOZ_UTF16("VK_CONTROL"),
michael@0:                                        getter_Copies(modifierName));
michael@0: 
michael@0:     aValue.Append(modifierName);
michael@0:     aValue.Append(separator);
michael@0:   }
michael@0: 
michael@0:   if (mModifierMask & kAlt) {
michael@0:     keyStringBundle->GetStringFromName(MOZ_UTF16("VK_ALT"),
michael@0:                                        getter_Copies(modifierName));
michael@0: 
michael@0:     aValue.Append(modifierName);
michael@0:     aValue.Append(separator);
michael@0:   }
michael@0: 
michael@0:   if (mModifierMask & kShift) {
michael@0:     keyStringBundle->GetStringFromName(MOZ_UTF16("VK_SHIFT"),
michael@0:                                        getter_Copies(modifierName));
michael@0: 
michael@0:     aValue.Append(modifierName);
michael@0:     aValue.Append(separator);
michael@0:   }
michael@0: 
michael@0:   if (mModifierMask & kMeta) {
michael@0:     keyStringBundle->GetStringFromName(MOZ_UTF16("VK_META"),
michael@0:                                        getter_Copies(modifierName));
michael@0: 
michael@0:     aValue.Append(modifierName);
michael@0:     aValue.Append(separator);
michael@0:   }
michael@0: 
michael@0:   aValue.Append(mKey);
michael@0: }
michael@0: 
michael@0: void
michael@0: KeyBinding::ToAtkFormat(nsAString& aValue) const
michael@0: {
michael@0:   nsAutoString modifierName;
michael@0:   if (mModifierMask & kControl)
michael@0:     aValue.Append(NS_LITERAL_STRING("<Control>"));
michael@0: 
michael@0:   if (mModifierMask & kAlt)
michael@0:     aValue.Append(NS_LITERAL_STRING("<Alt>"));
michael@0: 
michael@0:   if (mModifierMask & kShift)
michael@0:     aValue.Append(NS_LITERAL_STRING("<Shift>"));
michael@0: 
michael@0:   if (mModifierMask & kMeta)
michael@0:       aValue.Append(NS_LITERAL_STRING("<Meta>"));
michael@0: 
michael@0:   aValue.Append(mKey);
michael@0: }
michael@0: