The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

 /* This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 #include "nsAccUtils.h"

 #include "Accessible-inl.h"

 #include "ARIAMap.h"

 #include "nsAccessibilityService.h"

 #include "nsCoreUtils.h"

 #include "DocAccessible.h"

 #include "HyperTextAccessible.h"

 #include "nsIAccessibleTypes.h"

 #include "Role.h"

 #include "States.h"

 #include "TextLeafAccessible.h"

 #include "nsIDOMXULContainerElement.h"

 #include "nsIPersistentProperties2.h"

 #include "mozilla/dom/Element.h"

 using namespace mozilla;

 using namespace mozilla::a11y;

 void

 nsAccUtils::GetAccAttr(nsIPersistentProperties *aAttributes,

                        nsIAtom *aAttrName, nsAString& aAttrValue)

 {

   aAttrValue.Truncate();

   aAttributes->GetStringProperty(nsAtomCString(aAttrName), aAttrValue);

 }

 void

 nsAccUtils::SetAccAttr(nsIPersistentProperties *aAttributes,

                        nsIAtom *aAttrName, const nsAString& aAttrValue)

 {

   nsAutoString oldValue;

   nsAutoCString attrName;

   aAttributes->SetStringProperty(nsAtomCString(aAttrName), aAttrValue, oldValue);

 }

 void

 nsAccUtils::SetAccGroupAttrs(nsIPersistentProperties *aAttributes,

                              int32_t aLevel, int32_t aSetSize,

                              int32_t aPosInSet)

 {

   nsAutoString value;

   if (aLevel) {

     value.AppendInt(aLevel);

     SetAccAttr(aAttributes, nsGkAtoms::level, value);

   }

   if (aSetSize && aPosInSet) {

     value.Truncate();

     value.AppendInt(aPosInSet);

     SetAccAttr(aAttributes, nsGkAtoms::posinset, value);

     value.Truncate();

     value.AppendInt(aSetSize);

     SetAccAttr(aAttributes, nsGkAtoms::setsize, value);

   }

 }

 int32_t

 nsAccUtils::GetDefaultLevel(Accessible* aAccessible)

 {

   roles::Role role = aAccessible->Role();

   if (role == roles::OUTLINEITEM)

     return 1;

   if (role == roles::ROW) {

     Accessible* parent = aAccessible->Parent();

     // It is a row inside flatten treegrid. Group level is always 1 until it

     // is overriden by aria-level attribute.

     if (parent && parent->Role() == roles::TREE_TABLE) 

       return 1;

   }

   return 0;

 }

 int32_t

 nsAccUtils::GetARIAOrDefaultLevel(Accessible* aAccessible)

 {

   int32_t level = 0;

   nsCoreUtils::GetUIntAttr(aAccessible->GetContent(),

                            nsGkAtoms::aria_level, &level);

   if (level != 0)

     return level;

   return GetDefaultLevel(aAccessible);

 }

 int32_t

 nsAccUtils::GetLevelForXULContainerItem(nsIContent *aContent)

 {

   nsCOMPtr<nsIDOMXULContainerItemElement> item(do_QueryInterface(aContent));

   if (!item)

     return 0;

   nsCOMPtr<nsIDOMXULContainerElement> container;

   item->GetParentContainer(getter_AddRefs(container));

   if (!container)

     return 0;

   // Get level of the item.

   int32_t level = -1;

   while (container) {

     level++;

     nsCOMPtr<nsIDOMXULContainerElement> parentContainer;

     container->GetParentContainer(getter_AddRefs(parentContainer));

     parentContainer.swap(container);

   }

   return level;

 }

 void

 nsAccUtils::SetLiveContainerAttributes(nsIPersistentProperties *aAttributes,

                                        nsIContent *aStartContent,

                                        nsIContent *aTopContent)

 {

   nsAutoString live, relevant, busy;

   nsIContent *ancestor = aStartContent;

   while (ancestor) {

     // container-relevant attribute

     if (relevant.IsEmpty() &&

         HasDefinedARIAToken(ancestor, nsGkAtoms::aria_relevant) &&

         ancestor->GetAttr(kNameSpaceID_None, nsGkAtoms::aria_relevant, relevant))

       SetAccAttr(aAttributes, nsGkAtoms::containerRelevant, relevant);

     // container-live, and container-live-role attributes

     if (live.IsEmpty()) {

       nsRoleMapEntry* role = aria::GetRoleMap(ancestor);

       if (HasDefinedARIAToken(ancestor, nsGkAtoms::aria_live)) {

         ancestor->GetAttr(kNameSpaceID_None, nsGkAtoms::aria_live,

                           live);

       } else if (role) {

         GetLiveAttrValue(role->liveAttRule, live);

       }

       if (!live.IsEmpty()) {

         SetAccAttr(aAttributes, nsGkAtoms::containerLive, live);

         if (role) {

           SetAccAttr(aAttributes, nsGkAtoms::containerLiveRole,

                      role->ARIARoleString());

         }

       }

     }

     // container-atomic attribute

     if (ancestor->AttrValueIs(kNameSpaceID_None, nsGkAtoms::aria_atomic,

                               nsGkAtoms::_true, eCaseMatters)) {

       SetAccAttr(aAttributes, nsGkAtoms::containerAtomic,

                  NS_LITERAL_STRING("true"));

     }

     // container-busy attribute

     if (busy.IsEmpty() &&

         HasDefinedARIAToken(ancestor, nsGkAtoms::aria_busy) &&

         ancestor->GetAttr(kNameSpaceID_None, nsGkAtoms::aria_busy, busy))

       SetAccAttr(aAttributes, nsGkAtoms::containerBusy, busy);

     if (ancestor == aTopContent)

       break;

     ancestor = ancestor->GetParent();

     if (!ancestor)

       ancestor = aTopContent; // Use <body>/<frameset>

   }

 }

 bool

 nsAccUtils::HasDefinedARIAToken(nsIContent *aContent, nsIAtom *aAtom)

 {

   NS_ASSERTION(aContent, "aContent is null in call to HasDefinedARIAToken!");

   if (!aContent->HasAttr(kNameSpaceID_None, aAtom) ||

       aContent->AttrValueIs(kNameSpaceID_None, aAtom,

                             nsGkAtoms::_empty, eCaseMatters) ||

       aContent->AttrValueIs(kNameSpaceID_None, aAtom,

                             nsGkAtoms::_undefined, eCaseMatters)) {

         return false;

   }

   return true;

 }

 nsIAtom*

 nsAccUtils::GetARIAToken(dom::Element* aElement, nsIAtom* aAttr)

 {

   if (!HasDefinedARIAToken(aElement, aAttr))

     return nsGkAtoms::_empty;

   static nsIContent::AttrValuesArray tokens[] =

     { &nsGkAtoms::_false, &nsGkAtoms::_true,

       &nsGkAtoms::mixed, nullptr};

   int32_t idx = aElement->FindAttrValueIn(kNameSpaceID_None,

                                           aAttr, tokens, eCaseMatters);

   if (idx >= 0)

     return *(tokens[idx]);

   return nullptr;

 }

 Accessible*

 nsAccUtils::GetSelectableContainer(Accessible* aAccessible, uint64_t aState)

 {

   if (!aAccessible)

     return nullptr;

   if (!(aState & states::SELECTABLE))

     return nullptr;

   Accessible* parent = aAccessible;

   while ((parent = parent->Parent()) && !parent->IsSelect()) {

     if (parent->Role() == roles::PANE)

       return nullptr;

   }

   return parent;

 }

 bool

 nsAccUtils::IsARIASelected(Accessible* aAccessible)

 {

   return aAccessible->GetContent()->

     AttrValueIs(kNameSpaceID_None, nsGkAtoms::aria_selected,

                 nsGkAtoms::_true, eCaseMatters);

 }

 HyperTextAccessible*

 nsAccUtils::GetTextContainer(nsINode* aNode)

 {

   // Get text accessible containing the result node.

   DocAccessible* doc =

     GetAccService()->GetDocAccessible(aNode->OwnerDoc());

   Accessible* accessible =

     doc ? doc->GetAccessibleOrContainer(aNode) : nullptr;

   if (!accessible)

     return nullptr;

   do {

     HyperTextAccessible* textAcc = accessible->AsHyperText();

     if (textAcc)

       return textAcc;

     accessible = accessible->Parent();

   } while (accessible);

   return nullptr;

 }

 nsIntPoint

 nsAccUtils::ConvertToScreenCoords(int32_t aX, int32_t aY,

                                   uint32_t aCoordinateType,

                                   Accessible* aAccessible)

 {

   nsIntPoint coords(aX, aY);

   switch (aCoordinateType) {

     case nsIAccessibleCoordinateType::COORDTYPE_SCREEN_RELATIVE:

       break;

     case nsIAccessibleCoordinateType::COORDTYPE_WINDOW_RELATIVE:

     {

       coords += nsCoreUtils::GetScreenCoordsForWindow(aAccessible->GetNode());

       break;

     }

     case nsIAccessibleCoordinateType::COORDTYPE_PARENT_RELATIVE:

     {

       coords += GetScreenCoordsForParent(aAccessible);

       break;

     }

     default:

       NS_NOTREACHED("invalid coord type!");

   }

   return coords;

 }

 void

 nsAccUtils::ConvertScreenCoordsTo(int32_t *aX, int32_t *aY,

                                   uint32_t aCoordinateType,

                                   Accessible* aAccessible)

 {

   switch (aCoordinateType) {

     case nsIAccessibleCoordinateType::COORDTYPE_SCREEN_RELATIVE:

       break;

     case nsIAccessibleCoordinateType::COORDTYPE_WINDOW_RELATIVE:

     {

       nsIntPoint coords = nsCoreUtils::GetScreenCoordsForWindow(aAccessible->GetNode());

       *aX -= coords.x;

       *aY -= coords.y;

       break;

     }

     case nsIAccessibleCoordinateType::COORDTYPE_PARENT_RELATIVE:

     {

       nsIntPoint coords = GetScreenCoordsForParent(aAccessible);

       *aX -= coords.x;

       *aY -= coords.y;

       break;

     }

     default:

     NS_NOTREACHED("invalid coord type!");

   }

 }

 nsIntPoint

 nsAccUtils::GetScreenCoordsForParent(Accessible* aAccessible)

 {

   Accessible* parent = aAccessible->Parent();

   if (!parent)

     return nsIntPoint(0, 0);

   nsIFrame *parentFrame = parent->GetFrame();

   if (!parentFrame)

     return nsIntPoint(0, 0);

   nsRect rect = parentFrame->GetScreenRectInAppUnits();

   return nsPoint(rect.x, rect.y).

     ToNearestPixels(parentFrame->PresContext()->AppUnitsPerDevPixel());

 }

 bool

 nsAccUtils::GetLiveAttrValue(uint32_t aRule, nsAString& aValue)

 {

   switch (aRule) {

     case eOffLiveAttr:

       aValue = NS_LITERAL_STRING("off");

       return true;

     case ePoliteLiveAttr:

       aValue = NS_LITERAL_STRING("polite");

       return true;

   }

   return false;

 }

 #ifdef DEBUG

 bool

 nsAccUtils::IsTextInterfaceSupportCorrect(Accessible* aAccessible)

 {

   // Don't test for accessible docs, it makes us create accessibles too

   // early and fire mutation events before we need to

   if (aAccessible->IsDoc())

     return true;

   bool foundText = false;

   uint32_t childCount = aAccessible->ChildCount();

   for (uint32_t childIdx = 0; childIdx < childCount; childIdx++) {

     Accessible* child = aAccessible->GetChildAt(childIdx);

     if (!IsEmbeddedObject(child)) {

       foundText = true;

       break;

     }

   }

   if (foundText) {

     // found text child node

     nsCOMPtr<nsIAccessibleText> text = do_QueryObject(aAccessible);

     if (!text)

       return false;

   }

   return true;

 }

 #endif

 uint32_t

 nsAccUtils::TextLength(Accessible* aAccessible)

 {

   if (IsEmbeddedObject(aAccessible))

     return 1;

   TextLeafAccessible* textLeaf = aAccessible->AsTextLeaf();

   if (textLeaf)

     return textLeaf->Text().Length();

   // For list bullets (or anything other accessible which would compute its own

   // text. They don't have their own frame.

   // XXX In the future, list bullets may have frame and anon content, so 

   // we should be able to remove this at that point

   nsAutoString text;

   aAccessible->AppendTextTo(text); // Get all the text

   return text.Length();

 }

 bool

 nsAccUtils::MustPrune(Accessible* aAccessible)

 { 

   roles::Role role = aAccessible->Role();

   // Don't prune the tree for certain roles if the tree is more complex than

   // a single text leaf.

   return

     (role == roles::MENUITEM ||

      role == roles::COMBOBOX_OPTION ||

      role == roles::OPTION ||

      role == roles::ENTRY ||

      role == roles::FLAT_EQUATION ||

      role == roles::PASSWORD_TEXT ||

      role == roles::PUSHBUTTON ||

      role == roles::TOGGLE_BUTTON ||

      role == roles::GRAPHIC ||

      role == roles::SLIDER ||

      role == roles::PROGRESSBAR ||

      role == roles::SEPARATOR) &&

     aAccessible->ContentChildCount() == 1 &&

     aAccessible->ContentChildAt(0)->IsTextLeaf();

 }