/* 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/. */ #ifndef nsAccUtils_h_ #define nsAccUtils_h_ #include "mozilla/a11y/LocalAccessible.h" #include "mozilla/a11y/DocManager.h" #include "nsAccessibilityService.h" #include "nsCoreUtils.h" #include "nsIDocShell.h" #include "nsPoint.h" namespace mozilla { class PresShell; namespace dom { class Element; } namespace a11y { class HyperTextAccessible; class DocAccessible; class Attribute; class nsAccUtils { public: /** * Set group attributes ('level', 'setsize', 'posinset'). */ static void SetAccGroupAttrs(AccAttributes* aAttributes, int32_t aLevel, int32_t aSetSize, int32_t aPosInSet); static void SetAccGroupAttrs(AccAttributes* aAttributes, Accessible* aAcc); /** * Compute group level for nsIDOMXULContainerItemElement node. */ static int32_t GetLevelForXULContainerItem(nsIContent* aContent); /** * Set container-foo live region attributes for the given node. * * @param aAttributes where to store the attributes * @param aStartAcc Accessible to start from */ static void SetLiveContainerAttributes(AccAttributes* aAttributes, Accessible* aStartAcc); /** * Any ARIA property of type boolean or NMTOKEN is undefined if the ARIA * property is not present, or is "" or "undefined". Do not call * this method for properties of type string, decimal, IDREF or IDREFS. * * Return true if the ARIA property is defined, otherwise false */ static bool HasDefinedARIAToken(nsIContent* aContent, nsAtom* aAtom); static bool HasDefinedARIAToken(const AttrArray* aAttrs, nsAtom* aAtom); /** * If the given ARIA attribute has a specific known token value, return it. * If the specification demands for a fallback value for unknown attribute * values, return that. For all others, return a nullptr. */ static nsStaticAtom* NormalizeARIAToken(const AttrArray* aAttrs, nsAtom* aAttr); static nsStaticAtom* NormalizeARIAToken(mozilla::dom::Element* aElement, nsAtom* aAttr); /** * Return document accessible for the given DOM node. */ static DocAccessible* GetDocAccessibleFor(nsINode* aNode) { return GetAccService()->GetDocAccessible( nsCoreUtils::GetPresShellFor(aNode)); } /** * Return document accessible for the given docshell. */ static DocAccessible* GetDocAccessibleFor(nsIDocShellTreeItem* aContainer) { nsCOMPtr docShell(do_QueryInterface(aContainer)); return GetAccService()->GetDocAccessible(docShell->GetPresShell()); } /** * Return single or multi selectable container for the given item. * * @param aAccessible [in] the item accessible * @param aState [in] the state of the item accessible */ static Accessible* GetSelectableContainer(const Accessible* aAccessible, uint64_t aState); static LocalAccessible* GetSelectableContainer(LocalAccessible* aAccessible, uint64_t aState); /** * Return a text container accessible for the given node. */ static HyperTextAccessible* GetTextContainer(nsINode* aNode); static Accessible* TableFor(const Accessible* aRow); static LocalAccessible* TableFor(LocalAccessible* aRow); static const LocalAccessible* TableFor(const LocalAccessible* aAcc) { return TableFor(const_cast(aAcc)); } /** * Return true if the DOM node of a given accessible has a given attribute * with a value of "true". */ static bool IsDOMAttrTrue(const LocalAccessible* aAccessible, nsAtom* aAttr); /** * Return true if the DOM node of given accessible has aria-selected="true" * attribute. */ static inline bool IsARIASelected(const LocalAccessible* aAccessible) { return IsDOMAttrTrue(aAccessible, nsGkAtoms::aria_selected); } /** * Return true if the DOM node of given accessible has * aria-multiselectable="true" attribute. */ static inline bool IsARIAMultiSelectable(const LocalAccessible* aAccessible) { return IsDOMAttrTrue(aAccessible, nsGkAtoms::aria_multiselectable); } /** * Converts the given coordinates to coordinates relative screen. * * @param aX [in] the given x coord in dev pixels * @param aY [in] the given y coord in dev pixels * @param aCoordinateType [in] specifies coordinates origin (refer to * nsIAccessibleCoordinateType) * @param aAccessible [in] the accessible if coordinates are given * relative it. * @return converted coordinates */ static LayoutDeviceIntPoint ConvertToScreenCoords(int32_t aX, int32_t aY, uint32_t aCoordinateType, Accessible* aAccessible); /** * Converts the given coordinates relative screen to another coordinate * system. * * @param aX [in, out] the given x coord in dev pixels * @param aY [in, out] the given y coord in dev pixels * @param aCoordinateType [in] specifies coordinates origin (refer to * nsIAccessibleCoordinateType) * @param aAccessible [in] the accessible if coordinates are given * relative it */ static void ConvertScreenCoordsTo(int32_t* aX, int32_t* aY, uint32_t aCoordinateType, Accessible* aAccessible); /** * Returns screen-relative coordinates (in dev pixels) for the parent of the * given accessible. * * @param [in] aAccessible the accessible */ static LayoutDeviceIntPoint GetScreenCoordsForParent(Accessible* aAccessible); /** * Returns coordinates in device pixels relative screen for the top level * window. * * @param aAccessible the acc hosted in the window. */ static mozilla::LayoutDeviceIntPoint GetScreenCoordsForWindow( mozilla::a11y::Accessible* aAccessible); /** * Get the 'live' or 'container-live' object attribute value from the given * ELiveAttrRule constant. * * @param aRule [in] rule constant (see ELiveAttrRule in nsAccMap.h) * @param aValue [out] object attribute value * * @return true if object attribute should be exposed */ static bool GetLiveAttrValue(uint32_t aRule, nsAString& aValue); #ifdef DEBUG /** * Detect whether the given accessible object implements nsIAccessibleText, * when it is text or has text child node. */ static bool IsTextInterfaceSupportCorrect(LocalAccessible* aAccessible); #endif /** * Return text length of the given accessible, return 0 on failure. */ static uint32_t TextLength(Accessible* aAccessible); /** * Transform nsIAccessibleStates constants to internal state constant. */ static inline uint64_t To64State(uint32_t aState1, uint32_t aState2) { return static_cast(aState1) + (static_cast(aState2) << 31); } /** * Transform internal state constant to nsIAccessibleStates constants. */ static inline void To32States(uint64_t aState64, uint32_t* aState1, uint32_t* aState2) { *aState1 = aState64 & 0x7fffffff; if (aState2) *aState2 = static_cast(aState64 >> 31); } static uint32_t To32States(uint64_t aState, bool* aIsExtra) { uint32_t extraState = aState >> 31; *aIsExtra = !!extraState; return extraState ? extraState : aState; } /** * Return true if the given accessible can't have children. Used when exposing * to platform accessibility APIs, should the children be pruned off? */ static bool MustPrune(Accessible* aAccessible); /** * Get the live region setting (polite, etc.) for this Accessible. This does * not walk ancestors. It does account for implicit live regions as * determined from the ARIA role or markup tag name. */ static void GetLiveRegionSetting(Accessible* aAcc, nsAString& aLive); /** * If the given Accessible is inside a live region, return the root of the * live region. Otherwise, return null. */ static Accessible* GetLiveRegionRoot(Accessible* aAcc); /** * Get the document Accessible which owns a given Accessible. * This function is needed because there is no unified base class for local * and remote documents. * If aAcc is null, null will be returned. */ static Accessible* DocumentFor(Accessible* aAcc); /** * Get an Accessible in a given document by its unique id. * An Accessible's id can be obtained using Accessible::ID. * This function is needed because there is no unified base class for local * and remote documents. * If aDoc is nul, null will be returned. */ static Accessible* GetAccessibleByID(Accessible* aDoc, uint64_t aID); /** * Get the URL for a given document. * This function is needed because there is no unified base class for local * and remote documents. */ static void DocumentURL(Accessible* aDoc, nsAString& aURL); /** * Get the mime type for a given document. * This function is needed because there is no unified base class for local * and remote documents. */ static void DocumentMimeType(Accessible* aDoc, nsAString& aMimeType); /** * Accessors for element attributes that are aware of CustomElement ARIA * accessibility defaults. If the element does not have the provided * attribute defined directly on it, we will then attempt to fetch the * default instead. */ static const AttrArray* GetARIADefaults(dom::Element* aElement); static bool HasARIAAttr(dom::Element* aElement, const nsAtom* aName); static bool GetARIAAttr(dom::Element* aElement, const nsAtom* aName, nsAString& aResult); static const nsAttrValue* GetARIAAttr(dom::Element* aElement, const nsAtom* aName); static Maybe>> GetARIAElementsAttr( dom::Element* aElement, nsAtom* aName); static bool ARIAAttrValueIs(dom::Element* aElement, const nsAtom* aName, const nsAString& aValue, nsCaseTreatment aCaseSensitive); static bool ARIAAttrValueIs(dom::Element* aElement, const nsAtom* aName, const nsAtom* aValue, nsCaseTreatment aCaseSensitive); static int32_t FindARIAAttrValueIn(dom::Element* aElement, const nsAtom* aName, AttrArray::AttrValuesArray* aValues, nsCaseTreatment aCaseSensitive); static bool IsEditableARIACombobox(const LocalAccessible* aAccessible); /** * Return true if the CSS positioned target of an anchor is a valid details * related accessible. */ static bool IsValidDetailsTargetForAnchor(const Accessible* aDetails, const Accessible* aTarget); }; } // namespace a11y } // namespace mozilla #endif