зеркало из https://github.com/mozilla/gecko-dev.git
1064 строки
31 KiB
C++
1064 строки
31 KiB
C++
/* -*- 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/. */
|
|
|
|
#ifndef _LocalAccessible_H_
|
|
#define _LocalAccessible_H_
|
|
|
|
#include "mozilla/ComputedStyle.h"
|
|
#include "mozilla/a11y/Accessible.h"
|
|
#include "mozilla/a11y/AccTypes.h"
|
|
#include "mozilla/a11y/RelationType.h"
|
|
#include "mozilla/a11y/States.h"
|
|
|
|
#include "mozilla/UniquePtr.h"
|
|
|
|
#include "nsIContent.h"
|
|
#include "nsTArray.h"
|
|
#include "nsRefPtrHashtable.h"
|
|
#include "nsRect.h"
|
|
|
|
struct nsRoleMapEntry;
|
|
|
|
class nsIFrame;
|
|
|
|
class nsAttrValue;
|
|
|
|
namespace mozilla::dom {
|
|
class Element;
|
|
}
|
|
|
|
namespace mozilla {
|
|
namespace a11y {
|
|
|
|
class LocalAccessible;
|
|
class AccAttributes;
|
|
class AccEvent;
|
|
class AccGroupInfo;
|
|
class ApplicationAccessible;
|
|
class CacheData;
|
|
class DocAccessible;
|
|
class EmbeddedObjCollector;
|
|
class EventTree;
|
|
class HTMLImageMapAccessible;
|
|
class HTMLLIAccessible;
|
|
class HTMLLinkAccessible;
|
|
class HyperTextAccessible;
|
|
class HyperTextAccessibleBase;
|
|
class ImageAccessible;
|
|
class KeyBinding;
|
|
class OuterDocAccessible;
|
|
class RemoteAccessible;
|
|
class Relation;
|
|
class RootAccessible;
|
|
class TableAccessible;
|
|
class TableAccessibleBase;
|
|
class TableCellAccessible;
|
|
class TableCellAccessibleBase;
|
|
class TextLeafAccessible;
|
|
class XULLabelAccessible;
|
|
class XULTreeAccessible;
|
|
|
|
enum class CacheUpdateType;
|
|
|
|
#ifdef A11Y_LOG
|
|
namespace logging {
|
|
typedef const char* (*GetTreePrefix)(void* aData, LocalAccessible*);
|
|
void Tree(const char* aTitle, const char* aMsgText, LocalAccessible* aRoot,
|
|
GetTreePrefix aPrefixFunc, void* GetTreePrefixData);
|
|
void TreeSize(const char* aTitle, const char* aMsgText, LocalAccessible* aRoot);
|
|
}; // namespace logging
|
|
#endif
|
|
|
|
typedef nsRefPtrHashtable<nsPtrHashKey<const void>, LocalAccessible>
|
|
AccessibleHashtable;
|
|
|
|
#define NS_ACCESSIBLE_IMPL_IID \
|
|
{ /* 133c8bf4-4913-4355-bd50-426bd1d6e1ad */ \
|
|
0x133c8bf4, 0x4913, 0x4355, { \
|
|
0xbd, 0x50, 0x42, 0x6b, 0xd1, 0xd6, 0xe1, 0xad \
|
|
} \
|
|
}
|
|
|
|
/**
|
|
* An accessibility tree node that originated in mDoc's content process.
|
|
*/
|
|
class LocalAccessible : public nsISupports, public Accessible {
|
|
public:
|
|
LocalAccessible(nsIContent* aContent, DocAccessible* aDoc);
|
|
|
|
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
|
|
NS_DECL_CYCLE_COLLECTION_CLASS(LocalAccessible)
|
|
|
|
NS_DECLARE_STATIC_IID_ACCESSOR(NS_ACCESSIBLE_IMPL_IID)
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// Public methods
|
|
|
|
/**
|
|
* Return the document accessible for this accessible.
|
|
*/
|
|
DocAccessible* Document() const { return mDoc; }
|
|
|
|
/**
|
|
* Return the root document accessible for this accessible.
|
|
*/
|
|
a11y::RootAccessible* RootAccessible() const;
|
|
|
|
/**
|
|
* Return frame for this accessible.
|
|
* Note that this will return null for display: contents. Also,
|
|
* DocAccessible::GetFrame can return null if the frame tree hasn't been
|
|
* created yet.
|
|
*/
|
|
virtual nsIFrame* GetFrame() const;
|
|
|
|
/**
|
|
* Return DOM node associated with the accessible.
|
|
*/
|
|
virtual nsINode* GetNode() const;
|
|
|
|
nsIContent* GetContent() const { return mContent; }
|
|
dom::Element* Elm() const;
|
|
|
|
/**
|
|
* Return node type information of DOM node associated with the accessible.
|
|
*/
|
|
bool IsContent() const { return GetNode() && GetNode()->IsContent(); }
|
|
|
|
/**
|
|
* Return the unique identifier of the accessible.
|
|
* ID() should be preferred, but this method still exists because many
|
|
* LocalAccessible callers expect a void*.
|
|
*/
|
|
void* UniqueID() { return static_cast<void*>(this); }
|
|
|
|
virtual uint64_t ID() const override {
|
|
return IsDoc() ? 0 : reinterpret_cast<uintptr_t>(this);
|
|
}
|
|
|
|
virtual void Language(nsAString& aLocale) override;
|
|
|
|
/**
|
|
* Get the description of this accessible.
|
|
*/
|
|
virtual void Description(nsString& aDescription) const override;
|
|
|
|
/**
|
|
* Get the value of this accessible.
|
|
*/
|
|
virtual void Value(nsString& aValue) const override;
|
|
|
|
/**
|
|
* Get help string for the accessible.
|
|
*/
|
|
void Help(nsString& aHelp) const { aHelp.Truncate(); }
|
|
|
|
/**
|
|
* Get the name of this accessible.
|
|
*/
|
|
virtual ENameValueFlag Name(nsString& aName) const override;
|
|
|
|
/**
|
|
* Maps ARIA state attributes to state of accessible. Note the given state
|
|
* argument should hold states for accessible before you pass it into this
|
|
* method.
|
|
*
|
|
* @param [in/out] where to fill the states into.
|
|
*/
|
|
virtual void ApplyARIAState(uint64_t* aState) const;
|
|
|
|
/**
|
|
* Return enumerated accessible role (see constants in Role.h).
|
|
*/
|
|
virtual mozilla::a11y::role Role() const override;
|
|
|
|
/**
|
|
* Return accessible role specified by ARIA (see constants in
|
|
* roles).
|
|
*/
|
|
mozilla::a11y::role ARIARole();
|
|
|
|
/**
|
|
* Returns enumerated accessible role from native markup (see constants in
|
|
* Role.h). Doesn't take into account ARIA roles.
|
|
*/
|
|
virtual mozilla::a11y::role NativeRole() const;
|
|
|
|
virtual uint64_t State() override;
|
|
|
|
/**
|
|
* Return interactive states present on the accessible
|
|
* (@see NativeInteractiveState).
|
|
*/
|
|
uint64_t InteractiveState() const {
|
|
uint64_t state = NativeInteractiveState();
|
|
ApplyARIAState(&state);
|
|
return state;
|
|
}
|
|
|
|
/**
|
|
* Return link states present on the accessible.
|
|
*/
|
|
uint64_t LinkState() const {
|
|
uint64_t state = NativeLinkState();
|
|
ApplyARIAState(&state);
|
|
return state;
|
|
}
|
|
|
|
/**
|
|
* Return the states of accessible, not taking into account ARIA states.
|
|
* Use State() to get complete set of states.
|
|
*/
|
|
virtual uint64_t NativeState() const;
|
|
|
|
/**
|
|
* Return native interactice state (unavailable, focusable or selectable).
|
|
*/
|
|
virtual uint64_t NativeInteractiveState() const;
|
|
|
|
/**
|
|
* Return native link states present on the accessible.
|
|
*/
|
|
virtual uint64_t NativeLinkState() const;
|
|
|
|
/**
|
|
* Return bit set of invisible and offscreen states.
|
|
*/
|
|
uint64_t VisibilityState() const;
|
|
|
|
/**
|
|
* Return true if native unavailable state present.
|
|
*/
|
|
virtual bool NativelyUnavailable() const;
|
|
|
|
virtual already_AddRefed<AccAttributes> Attributes() override;
|
|
|
|
/**
|
|
* Return direct or deepest child at the given point.
|
|
*
|
|
* @param aX [in] x coordinate relative screen
|
|
* @param aY [in] y coordinate relative screen
|
|
* @param aWhichChild [in] flag points if deepest or direct child
|
|
* should be returned
|
|
*/
|
|
virtual LocalAccessible* LocalChildAtPoint(int32_t aX, int32_t aY,
|
|
EWhichChildAtPoint aWhichChild);
|
|
|
|
/**
|
|
* Similar to LocalChildAtPoint but crosses process boundaries.
|
|
*/
|
|
virtual Accessible* ChildAtPoint(int32_t aX, int32_t aY,
|
|
EWhichChildAtPoint aWhichChild) override;
|
|
|
|
virtual Relation RelationByType(RelationType aType) const override;
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// Initializing methods
|
|
|
|
/**
|
|
* Shutdown this accessible object.
|
|
*/
|
|
virtual void Shutdown();
|
|
|
|
/**
|
|
* Set the ARIA role map entry for a new accessible.
|
|
*/
|
|
void SetRoleMapEntry(const nsRoleMapEntry* aRoleMapEntry);
|
|
|
|
/**
|
|
* Append/insert/remove a child. Return true if operation was successful.
|
|
*/
|
|
bool AppendChild(LocalAccessible* aChild) {
|
|
return InsertChildAt(mChildren.Length(), aChild);
|
|
}
|
|
virtual bool InsertChildAt(uint32_t aIndex, LocalAccessible* aChild);
|
|
|
|
/**
|
|
* Inserts a child after given sibling. If the child cannot be inserted,
|
|
* then the child is unbound from the document, and false is returned. Make
|
|
* sure to null out any references on the child object as it may be destroyed.
|
|
*/
|
|
bool InsertAfter(LocalAccessible* aNewChild, LocalAccessible* aRefChild);
|
|
|
|
virtual bool RemoveChild(LocalAccessible* aChild);
|
|
|
|
/**
|
|
* Reallocates the child within its parent.
|
|
*/
|
|
virtual void RelocateChild(uint32_t aNewIndex, LocalAccessible* aChild);
|
|
|
|
// Accessible hierarchy method overrides
|
|
|
|
virtual Accessible* Parent() const override { return LocalParent(); }
|
|
|
|
virtual Accessible* ChildAt(uint32_t aIndex) const override {
|
|
return LocalChildAt(aIndex);
|
|
}
|
|
|
|
virtual Accessible* NextSibling() const override {
|
|
return LocalNextSibling();
|
|
}
|
|
|
|
virtual Accessible* PrevSibling() const override {
|
|
return LocalPrevSibling();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// LocalAccessible tree traverse methods
|
|
|
|
/**
|
|
* Return parent accessible.
|
|
*/
|
|
LocalAccessible* LocalParent() const { return mParent; }
|
|
|
|
/**
|
|
* Return child accessible at the given index.
|
|
*/
|
|
virtual LocalAccessible* LocalChildAt(uint32_t aIndex) const;
|
|
|
|
/**
|
|
* Return child accessible count.
|
|
*/
|
|
virtual uint32_t ChildCount() const override;
|
|
|
|
/**
|
|
* Return index of the given child accessible.
|
|
*/
|
|
int32_t GetIndexOf(const LocalAccessible* aChild) const {
|
|
return (aChild->mParent != this) ? -1 : aChild->IndexInParent();
|
|
}
|
|
|
|
/**
|
|
* Return index in parent accessible.
|
|
*/
|
|
virtual int32_t IndexInParent() const override;
|
|
|
|
/**
|
|
* Return first/last/next/previous sibling of the accessible.
|
|
*/
|
|
inline LocalAccessible* LocalNextSibling() const {
|
|
return GetSiblingAtOffset(1);
|
|
}
|
|
inline LocalAccessible* LocalPrevSibling() const {
|
|
return GetSiblingAtOffset(-1);
|
|
}
|
|
inline LocalAccessible* LocalFirstChild() const { return LocalChildAt(0); }
|
|
inline LocalAccessible* LocalLastChild() const {
|
|
uint32_t childCount = ChildCount();
|
|
return childCount != 0 ? LocalChildAt(childCount - 1) : nullptr;
|
|
}
|
|
|
|
virtual uint32_t EmbeddedChildCount() override;
|
|
|
|
/**
|
|
* Return embedded accessible child at the given index.
|
|
*/
|
|
virtual LocalAccessible* EmbeddedChildAt(uint32_t aIndex) override;
|
|
|
|
virtual int32_t IndexOfEmbeddedChild(Accessible* aChild) override;
|
|
|
|
/**
|
|
* Return number of content children/content child at index. The content
|
|
* child is created from markup in contrast to it's never constructed by its
|
|
* parent accessible (like treeitem accessibles for XUL trees).
|
|
*/
|
|
uint32_t ContentChildCount() const { return mChildren.Length(); }
|
|
LocalAccessible* ContentChildAt(uint32_t aIndex) const {
|
|
return mChildren.ElementAt(aIndex);
|
|
}
|
|
|
|
/**
|
|
* Return true if the accessible is attached to tree.
|
|
*/
|
|
bool IsBoundToParent() const { return !!mParent; }
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// Miscellaneous methods
|
|
|
|
/**
|
|
* Handle accessible event, i.e. process it, notifies observers and fires
|
|
* platform specific event.
|
|
*/
|
|
virtual nsresult HandleAccEvent(AccEvent* aAccEvent);
|
|
|
|
/**
|
|
* Return true if the accessible is an acceptable child.
|
|
*/
|
|
virtual bool IsAcceptableChild(nsIContent* aEl) const {
|
|
return aEl &&
|
|
!aEl->IsAnyOfHTMLElements(nsGkAtoms::option, nsGkAtoms::optgroup);
|
|
}
|
|
|
|
virtual void AppendTextTo(nsAString& aText, uint32_t aStartOffset = 0,
|
|
uint32_t aLength = UINT32_MAX) override;
|
|
|
|
virtual nsRect BoundsInAppUnits() const override;
|
|
|
|
virtual LayoutDeviceIntRect Bounds() const override;
|
|
|
|
/**
|
|
* Return boundaries rect relative the bounding frame.
|
|
*/
|
|
virtual nsRect RelativeBounds(nsIFrame** aRelativeFrame) const;
|
|
|
|
/**
|
|
* Return boundaries rect relative to the frame of the parent accessible.
|
|
* The returned bounds are the same regardless of whether the parent is
|
|
* scrolled. This means the scroll position must be later subtracted to
|
|
* calculate absolute coordinates.
|
|
*/
|
|
virtual nsRect ParentRelativeBounds();
|
|
|
|
/**
|
|
* Selects the accessible within its container if applicable.
|
|
*/
|
|
virtual void SetSelected(bool aSelect) override;
|
|
|
|
/**
|
|
* Select the accessible within its container.
|
|
*/
|
|
virtual void TakeSelection() override;
|
|
|
|
/**
|
|
* Focus the accessible.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT_BOUNDARY virtual void TakeFocus() const override;
|
|
|
|
MOZ_CAN_RUN_SCRIPT
|
|
virtual void ScrollTo(uint32_t aHow) const override;
|
|
|
|
/**
|
|
* Scroll the accessible to the given point.
|
|
*/
|
|
void ScrollToPoint(uint32_t aCoordinateType, int32_t aX, int32_t aY);
|
|
|
|
/**
|
|
* Get a pointer to accessibility interface for this node, which is specific
|
|
* to the OS/accessibility toolkit we're running on.
|
|
*/
|
|
virtual void GetNativeInterface(void** aNativeAccessible);
|
|
|
|
virtual Maybe<int32_t> GetIntARIAAttr(nsAtom* aAttrName) const override;
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// Downcasting and types
|
|
|
|
inline bool IsAbbreviation() const {
|
|
return mContent &&
|
|
mContent->IsAnyOfHTMLElements(nsGkAtoms::abbr, nsGkAtoms::acronym);
|
|
}
|
|
|
|
ApplicationAccessible* AsApplication();
|
|
|
|
DocAccessible* AsDoc();
|
|
|
|
HyperTextAccessible* AsHyperText();
|
|
virtual HyperTextAccessibleBase* AsHyperTextBase() override;
|
|
|
|
HTMLLIAccessible* AsHTMLListItem();
|
|
|
|
HTMLLinkAccessible* AsHTMLLink();
|
|
|
|
ImageAccessible* AsImage();
|
|
|
|
HTMLImageMapAccessible* AsImageMap();
|
|
|
|
OuterDocAccessible* AsOuterDoc();
|
|
|
|
a11y::RootAccessible* AsRoot();
|
|
|
|
bool IsSearchbox() const;
|
|
|
|
virtual TableAccessible* AsTable() { return nullptr; }
|
|
|
|
virtual TableCellAccessible* AsTableCell() { return nullptr; }
|
|
const TableCellAccessible* AsTableCell() const {
|
|
return const_cast<LocalAccessible*>(this)->AsTableCell();
|
|
}
|
|
|
|
virtual TableAccessibleBase* AsTableBase() override;
|
|
virtual TableCellAccessibleBase* AsTableCellBase() override;
|
|
|
|
TextLeafAccessible* AsTextLeaf();
|
|
|
|
XULLabelAccessible* AsXULLabel();
|
|
|
|
XULTreeAccessible* AsXULTree();
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// ActionAccessible
|
|
|
|
virtual bool HasPrimaryAction() const override;
|
|
|
|
virtual uint8_t ActionCount() const override;
|
|
|
|
virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) override;
|
|
|
|
virtual bool DoAction(uint8_t aIndex) const override;
|
|
|
|
virtual KeyBinding AccessKey() const override;
|
|
|
|
/**
|
|
* Return global keyboard shortcut for default action, such as Ctrl+O for
|
|
* Open file menuitem.
|
|
*/
|
|
virtual KeyBinding KeyboardShortcut() const;
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// HyperLinkAccessible (any embedded object in text can implement HyperLink,
|
|
// which helps determine where it is located within containing text).
|
|
|
|
/**
|
|
* Return true if the accessible is hyper link accessible.
|
|
*/
|
|
virtual bool IsLink() const override;
|
|
|
|
/**
|
|
* Return true if the link is valid (e. g. points to a valid URL).
|
|
*/
|
|
inline bool IsLinkValid() {
|
|
MOZ_ASSERT(IsLink(), "IsLinkValid is called on not hyper link!");
|
|
|
|
// XXX In order to implement this we would need to follow every link
|
|
// Perhaps we can get information about invalid links from the cache
|
|
// In the mean time authors can use role="link" aria-invalid="true"
|
|
// to force it for links they internally know to be invalid
|
|
return (0 == (State() & mozilla::a11y::states::INVALID));
|
|
}
|
|
|
|
/**
|
|
* Return the number of anchors within the link.
|
|
*/
|
|
virtual uint32_t AnchorCount();
|
|
|
|
/**
|
|
* Returns an anchor accessible at the given index.
|
|
*/
|
|
virtual LocalAccessible* AnchorAt(uint32_t aAnchorIndex);
|
|
|
|
/**
|
|
* Returns an anchor URI at the given index.
|
|
*/
|
|
virtual already_AddRefed<nsIURI> AnchorURIAt(uint32_t aAnchorIndex) const;
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// SelectAccessible
|
|
|
|
/**
|
|
* Return an array of selected items.
|
|
*/
|
|
virtual void SelectedItems(nsTArray<Accessible*>* aItems) override;
|
|
|
|
/**
|
|
* Return the number of selected items.
|
|
*/
|
|
virtual uint32_t SelectedItemCount() override;
|
|
|
|
/**
|
|
* Return selected item at the given index.
|
|
*/
|
|
virtual Accessible* GetSelectedItem(uint32_t aIndex) override;
|
|
|
|
/**
|
|
* Determine if item at the given index is selected.
|
|
*/
|
|
virtual bool IsItemSelected(uint32_t aIndex) override;
|
|
|
|
/**
|
|
* Add item at the given index the selection. Return true if success.
|
|
*/
|
|
virtual bool AddItemToSelection(uint32_t aIndex) override;
|
|
|
|
/**
|
|
* Remove item at the given index from the selection. Return if success.
|
|
*/
|
|
virtual bool RemoveItemFromSelection(uint32_t aIndex) override;
|
|
|
|
/**
|
|
* Select all items. Return true if success.
|
|
*/
|
|
virtual bool SelectAll() override;
|
|
|
|
/**
|
|
* Unselect all items. Return true if success.
|
|
*/
|
|
virtual bool UnselectAll() override;
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// Value (numeric value interface)
|
|
|
|
virtual double MaxValue() const override;
|
|
virtual double MinValue() const override;
|
|
virtual double CurValue() const override;
|
|
virtual double Step() const override;
|
|
virtual bool SetCurValue(double aValue);
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// Widgets
|
|
|
|
/**
|
|
* Return true if accessible is a widget, i.e. control or accessible that
|
|
* manages its items. Note, being a widget the accessible may be a part of
|
|
* composite widget.
|
|
*/
|
|
virtual bool IsWidget() const;
|
|
|
|
/**
|
|
* Return true if the widget is active, i.e. has a focus within it.
|
|
*/
|
|
virtual bool IsActiveWidget() const;
|
|
|
|
/**
|
|
* Return true if the widget has items and items are operable by user and
|
|
* can be activated.
|
|
*/
|
|
virtual bool AreItemsOperable() const;
|
|
|
|
/**
|
|
* Return the current item of the widget, i.e. an item that has or will have
|
|
* keyboard focus when widget gets active.
|
|
*/
|
|
virtual LocalAccessible* CurrentItem() const;
|
|
|
|
/**
|
|
* Set the current item of the widget.
|
|
*/
|
|
virtual void SetCurrentItem(const LocalAccessible* aItem);
|
|
|
|
/**
|
|
* Return container widget this accessible belongs to.
|
|
*/
|
|
virtual LocalAccessible* ContainerWidget() const;
|
|
|
|
bool IsActiveDescendant(LocalAccessible** aWidget = nullptr) const;
|
|
|
|
/**
|
|
* Return true if the accessible is defunct.
|
|
*/
|
|
bool IsDefunct() const;
|
|
|
|
/**
|
|
* Return false if the accessible is no longer in the document.
|
|
*/
|
|
bool IsInDocument() const { return !(mStateFlags & eIsNotInDocument); }
|
|
|
|
/**
|
|
* Return true if the accessible should be contained by document node map.
|
|
*/
|
|
bool IsNodeMapEntry() const {
|
|
return HasOwnContent() && !(mStateFlags & eNotNodeMapEntry);
|
|
}
|
|
|
|
/**
|
|
* Return true if the accessible has associated DOM content.
|
|
*/
|
|
bool HasOwnContent() const {
|
|
return mContent && !(mStateFlags & eSharedNode);
|
|
}
|
|
|
|
/**
|
|
* Return true if native markup has a numeric value.
|
|
*/
|
|
bool NativeHasNumericValue() const;
|
|
|
|
/**
|
|
* Return true if ARIA specifies support for a numeric value.
|
|
*/
|
|
bool ARIAHasNumericValue() const;
|
|
|
|
/**
|
|
* Return true if the accessible has a numeric value.
|
|
*/
|
|
virtual bool HasNumericValue() const override;
|
|
|
|
/**
|
|
* Return true if the accessible state change is processed by handling proper
|
|
* DOM UI event, if otherwise then false. For example, CheckboxAccessible
|
|
* created for HTML:input@type="checkbox" will process
|
|
* nsIDocumentObserver::ElementStateChanged instead of 'CheckboxStateChange'
|
|
* event.
|
|
*/
|
|
bool NeedsDOMUIEvent() const { return !(mStateFlags & eIgnoreDOMUIEvent); }
|
|
|
|
/**
|
|
* Get/set repositioned bit indicating that the accessible was moved in
|
|
* the accessible tree, i.e. the accessible tree structure differs from DOM.
|
|
*/
|
|
bool IsRelocated() const { return mStateFlags & eRelocated; }
|
|
void SetRelocated(bool aRelocated) {
|
|
if (aRelocated) {
|
|
mStateFlags |= eRelocated;
|
|
} else {
|
|
mStateFlags &= ~eRelocated;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return true if the accessible allows accessible children from subtree of
|
|
* a DOM element of this accessible.
|
|
*/
|
|
bool KidsFromDOM() const { return !(mStateFlags & eNoKidsFromDOM); }
|
|
|
|
/**
|
|
* Return true if this accessible has a parent, relation or ancestor with a
|
|
* relation whose name depends on this accessible.
|
|
*/
|
|
bool HasNameDependent() const { return mContextFlags & eHasNameDependent; }
|
|
|
|
/**
|
|
* Return true if this accessible has a parent, relation or ancestor with a
|
|
* relation whose description depends on this accessible.
|
|
*/
|
|
bool HasDescriptionDependent() const {
|
|
return mContextFlags & eHasDescriptionDependent;
|
|
}
|
|
|
|
/**
|
|
* Return true if the element is inside an alert.
|
|
*/
|
|
bool IsInsideAlert() const { return mContextFlags & eInsideAlert; }
|
|
|
|
/**
|
|
* Return true if there is a pending reorder event for this accessible.
|
|
*/
|
|
bool ReorderEventTarget() const { return mReorderEventTarget; }
|
|
|
|
/**
|
|
* Return true if there is a pending show event for this accessible.
|
|
*/
|
|
bool ShowEventTarget() const { return mShowEventTarget; }
|
|
|
|
/**
|
|
* Return true if there is a pending hide event for this accessible.
|
|
*/
|
|
bool HideEventTarget() const { return mHideEventTarget; }
|
|
|
|
/**
|
|
* Set if there is a pending reorder event for this accessible.
|
|
*/
|
|
void SetReorderEventTarget(bool aTarget) { mReorderEventTarget = aTarget; }
|
|
|
|
/**
|
|
* Set if this accessible is a show event target.
|
|
*/
|
|
void SetShowEventTarget(bool aTarget) { mShowEventTarget = aTarget; }
|
|
|
|
/**
|
|
* Set if this accessible is a hide event target.
|
|
*/
|
|
void SetHideEventTarget(bool aTarget) { mHideEventTarget = aTarget; }
|
|
|
|
void Announce(const nsAString& aAnnouncement, uint16_t aPriority);
|
|
|
|
virtual bool IsRemote() const override { return false; }
|
|
|
|
already_AddRefed<AccAttributes> BundleFieldsForCache(
|
|
uint64_t aCacheDomain, CacheUpdateType aUpdateType);
|
|
|
|
/**
|
|
* Push fields to cache.
|
|
* aCacheDomain - describes which fields to bundle and ultimately send
|
|
* aUpdate - describes whether this is an initial or subsequent update
|
|
*/
|
|
void SendCache(uint64_t aCacheDomain, CacheUpdateType aUpdate);
|
|
|
|
void MaybeQueueCacheUpdateForStyleChanges();
|
|
|
|
virtual nsAtom* TagName() const override;
|
|
|
|
virtual already_AddRefed<nsAtom> DisplayStyle() const override;
|
|
|
|
virtual float Opacity() const override;
|
|
|
|
virtual void DOMNodeID(nsString& aID) const override;
|
|
|
|
virtual void LiveRegionAttributes(nsAString* aLive, nsAString* aRelevant,
|
|
Maybe<bool>* aAtomic,
|
|
nsAString* aBusy) const override;
|
|
|
|
virtual Maybe<bool> ARIASelected() const override;
|
|
|
|
protected:
|
|
virtual ~LocalAccessible();
|
|
|
|
/**
|
|
* Return the accessible name provided by native markup. It doesn't take
|
|
* into account ARIA markup used to specify the name.
|
|
*/
|
|
virtual mozilla::a11y::ENameValueFlag NativeName(nsString& aName) const;
|
|
|
|
/**
|
|
* Return the accessible description provided by native markup. It doesn't
|
|
* take into account ARIA markup used to specify the description.
|
|
*/
|
|
void NativeDescription(nsString& aDescription) const;
|
|
|
|
/**
|
|
* Return object attributes provided by native markup. It doesn't take into
|
|
* account ARIA.
|
|
*/
|
|
virtual already_AddRefed<AccAttributes> NativeAttributes();
|
|
|
|
/**
|
|
* The given attribute has the potential of changing the accessible's state.
|
|
* This is used to capture the state before the attribute change and compare
|
|
* it with the state after.
|
|
*/
|
|
virtual bool AttributeChangesState(nsAtom* aAttribute);
|
|
|
|
/**
|
|
* Notify accessible that a DOM attribute on its associated content has
|
|
* changed. This allows the accessible to update its state and emit any
|
|
* relevant events.
|
|
*/
|
|
virtual void DOMAttributeChanged(int32_t aNameSpaceID, nsAtom* aAttribute,
|
|
int32_t aModType,
|
|
const nsAttrValue* aOldValue,
|
|
uint64_t aOldState);
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// Initializing, cache and tree traverse methods
|
|
|
|
/**
|
|
* Destroy the object.
|
|
*/
|
|
void LastRelease();
|
|
|
|
/**
|
|
* Set accessible parent and index in parent.
|
|
*/
|
|
void BindToParent(LocalAccessible* aParent, uint32_t aIndexInParent);
|
|
void UnbindFromParent();
|
|
|
|
/**
|
|
* Return sibling accessible at the given offset.
|
|
*/
|
|
virtual LocalAccessible* GetSiblingAtOffset(int32_t aOffset,
|
|
nsresult* aError = nullptr) const;
|
|
|
|
void ModifySubtreeContextFlags(uint32_t aContextFlags, bool aAdd);
|
|
|
|
/**
|
|
* Flags used to describe the state of this accessible.
|
|
*/
|
|
enum StateFlags {
|
|
eIsDefunct = 1 << 0, // accessible is defunct
|
|
eIsNotInDocument = 1 << 1, // accessible is not in document
|
|
eSharedNode = 1 << 2, // accessible shares DOM node from another accessible
|
|
eNotNodeMapEntry = 1 << 3, // accessible shouldn't be in document node map
|
|
eGroupInfoDirty = 1 << 4, // accessible needs to update group info
|
|
eKidsMutating = 1 << 5, // subtree is being mutated
|
|
eIgnoreDOMUIEvent = 1 << 6, // don't process DOM UI events for a11y events
|
|
eRelocated = 1 << 7, // accessible was moved in tree
|
|
eNoKidsFromDOM = 1 << 8, // accessible doesn't allow children from DOM
|
|
eHasTextKids = 1 << 9, // accessible have a text leaf in children
|
|
eOldFrameHasValidTransformStyle =
|
|
1 << 10, // frame prior to most recent style change both has transform
|
|
// styling and supports transforms
|
|
|
|
eLastStateFlag = eOldFrameHasValidTransformStyle
|
|
};
|
|
|
|
/**
|
|
* Flags used for contextual information about the accessible.
|
|
*/
|
|
enum ContextFlags {
|
|
eHasNameDependent = 1 << 0, // See HasNameDependent().
|
|
eInsideAlert = 1 << 1,
|
|
eHasDescriptionDependent = 1 << 2, // See HasDescriptionDependent().
|
|
|
|
eLastContextFlag = eHasDescriptionDependent
|
|
};
|
|
|
|
protected:
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// Miscellaneous helpers
|
|
|
|
/**
|
|
* Return ARIA role (helper method).
|
|
*/
|
|
mozilla::a11y::role ARIATransformRole(mozilla::a11y::role aRole) const;
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// Name helpers
|
|
|
|
/**
|
|
* Returns the accessible name specified by ARIA.
|
|
*/
|
|
void ARIAName(nsString& aName) const;
|
|
|
|
/**
|
|
* Returns the accessible description specified by ARIA.
|
|
*/
|
|
void ARIADescription(nsString& aDescription) const;
|
|
|
|
/**
|
|
* Returns the accessible name specified for this control using XUL
|
|
* <label control="id" ...>.
|
|
*/
|
|
static void NameFromAssociatedXULLabel(DocAccessible* aDocument,
|
|
nsIContent* aElm, nsString& aName);
|
|
|
|
/**
|
|
* Return the name for XUL element.
|
|
*/
|
|
static void XULElmName(DocAccessible* aDocument, nsIContent* aElm,
|
|
nsString& aName);
|
|
|
|
// helper method to verify frames
|
|
static nsresult GetFullKeyName(const nsAString& aModifierName,
|
|
const nsAString& aKeyName,
|
|
nsAString& aStringOut);
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// Action helpers
|
|
|
|
/**
|
|
* Prepares click action that will be invoked in timeout.
|
|
*
|
|
* @note DoCommand() prepares an action in timeout because when action
|
|
* command opens a modal dialog/window, it won't return until the
|
|
* dialog/window is closed. If executing action command directly in
|
|
* nsIAccessible::DoAction() method, it will block AT tools (e.g. GOK) that
|
|
* invoke action of mozilla accessibles direclty (see bug 277888 for
|
|
* details).
|
|
*
|
|
* @param aContent [in, optional] element to click
|
|
* @param aActionIndex [in, optional] index of accessible action
|
|
*/
|
|
void DoCommand(nsIContent* aContent = nullptr,
|
|
uint32_t aActionIndex = 0) const;
|
|
|
|
/**
|
|
* Dispatch click event.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT
|
|
virtual void DispatchClickEvent(nsIContent* aContent,
|
|
uint32_t aActionIndex) const;
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// Helpers
|
|
|
|
/**
|
|
* Get the container node for an atomic region, defined by aria-atomic="true"
|
|
* @return the container node
|
|
*/
|
|
nsIContent* GetAtomicRegion() const;
|
|
|
|
/**
|
|
* Return numeric value of the given ARIA attribute, NaN if not applicable.
|
|
*
|
|
* @param aARIAProperty [in] the ARIA property we're using
|
|
* @return a numeric value
|
|
*/
|
|
double AttrNumericValue(nsAtom* aARIAAttr) const;
|
|
|
|
/**
|
|
* Return the action rule based on ARIA enum constants EActionRule
|
|
* (see ARIAMap.h). Used by ActionCount() and ActionNameAt().
|
|
*/
|
|
uint32_t GetActionRule() const;
|
|
|
|
virtual AccGroupInfo* GetGroupInfo() const override;
|
|
|
|
virtual AccGroupInfo* GetOrCreateGroupInfo() override;
|
|
|
|
virtual void ARIAGroupPosition(int32_t* aLevel, int32_t* aSetSize,
|
|
int32_t* aPosInSet) const override;
|
|
|
|
// Data Members
|
|
// mContent can be null in a DocAccessible if the document has no body or
|
|
// root element.
|
|
nsCOMPtr<nsIContent> mContent;
|
|
RefPtr<DocAccessible> mDoc;
|
|
|
|
LocalAccessible* mParent;
|
|
nsTArray<LocalAccessible*> mChildren;
|
|
int32_t mIndexInParent;
|
|
|
|
// These are used to determine whether to send cache updates.
|
|
Maybe<nsRect> mBounds;
|
|
int32_t mFirstLineStart;
|
|
|
|
/**
|
|
* Maintain a reference to the ComputedStyle of our frame so we can
|
|
* send cache updates when style changes are observed.
|
|
*
|
|
* This RefPtr is initialised in BundleFieldsForCache to the ComputedStyle
|
|
* for our initial frame.
|
|
* Style changes are observed in one of two ways:
|
|
* 1. Style changes on the same frame are observed in
|
|
* nsIFrame::DidSetComputedStyle.
|
|
* 2. Style changes for reconstructed frames are handled in
|
|
* DocAccessible::PruneOrInsertSubtree.
|
|
* In both cases, we call into MaybeQueueCacheUpdateForStyleChanges. There, we
|
|
* compare a11y-relevant properties in mOldComputedStyle with the current
|
|
* ComputedStyle fetched from GetFrame()->Style(). Finally, we send cache
|
|
* updates for attributes affected by the style change and update
|
|
* mOldComputedStyle to the style of our current frame.
|
|
*/
|
|
RefPtr<const ComputedStyle> mOldComputedStyle;
|
|
|
|
static const uint8_t kStateFlagsBits = 11;
|
|
static const uint8_t kContextFlagsBits = 3;
|
|
|
|
/**
|
|
* Keep in sync with StateFlags, ContextFlags, and AccTypes.
|
|
*/
|
|
mutable uint32_t mStateFlags : kStateFlagsBits;
|
|
uint32_t mContextFlags : kContextFlagsBits;
|
|
uint32_t mReorderEventTarget : 1;
|
|
uint32_t mShowEventTarget : 1;
|
|
uint32_t mHideEventTarget : 1;
|
|
|
|
void StaticAsserts() const;
|
|
|
|
#ifdef A11Y_LOG
|
|
friend void logging::Tree(const char* aTitle, const char* aMsgText,
|
|
LocalAccessible* aRoot,
|
|
logging::GetTreePrefix aPrefixFunc,
|
|
void* aGetTreePrefixData);
|
|
friend void logging::TreeSize(const char* aTitle, const char* aMsgText,
|
|
LocalAccessible* aRoot);
|
|
#endif
|
|
friend class DocAccessible;
|
|
friend class xpcAccessible;
|
|
friend class TreeMutation;
|
|
|
|
UniquePtr<mozilla::a11y::EmbeddedObjCollector> mEmbeddedObjCollector;
|
|
int32_t mIndexOfEmbeddedChild;
|
|
|
|
friend class EmbeddedObjCollector;
|
|
|
|
mutable AccGroupInfo* mGroupInfo;
|
|
friend class AccGroupInfo;
|
|
|
|
private:
|
|
LocalAccessible() = delete;
|
|
LocalAccessible(const LocalAccessible&) = delete;
|
|
LocalAccessible& operator=(const LocalAccessible&) = delete;
|
|
|
|
/**
|
|
* Traverses the accessible's parent chain in search of an accessible with
|
|
* a frame. Returns the frame when found. Includes special handling for
|
|
* OOP iframe docs and tab documents.
|
|
*/
|
|
nsIFrame* FindNearestAccessibleAncestorFrame();
|
|
};
|
|
|
|
NS_DEFINE_STATIC_IID_ACCESSOR(LocalAccessible, NS_ACCESSIBLE_IMPL_IID)
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// LocalAccessible downcasting method
|
|
|
|
inline LocalAccessible* Accessible::AsLocal() {
|
|
return IsLocal() ? static_cast<LocalAccessible*>(this) : nullptr;
|
|
}
|
|
|
|
} // namespace a11y
|
|
} // namespace mozilla
|
|
|
|
#endif
|