зеркало из https://github.com/mozilla/gecko-dev.git
433 строки
13 KiB
C++
433 строки
13 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=2 et sw=2 tw=80: */
|
|
/* 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 mozilla_a11y_RemoteAccessibleBase_h
|
|
#define mozilla_a11y_RemoteAccessibleBase_h
|
|
|
|
#include "mozilla/a11y/Accessible.h"
|
|
#include "mozilla/a11y/CacheConstants.h"
|
|
#include "mozilla/a11y/HyperTextAccessibleBase.h"
|
|
#include "mozilla/a11y/Role.h"
|
|
#include "AccAttributes.h"
|
|
#include "nsIAccessibleText.h"
|
|
#include "nsIAccessibleTypes.h"
|
|
#include "nsTArray.h"
|
|
#include "nsRect.h"
|
|
#include "LocalAccessible.h"
|
|
|
|
namespace mozilla {
|
|
namespace a11y {
|
|
|
|
class Attribute;
|
|
class DocAccessibleParent;
|
|
class RemoteAccessible;
|
|
enum class RelationType;
|
|
|
|
template <class Derived>
|
|
class RemoteAccessibleBase : public Accessible, public HyperTextAccessibleBase {
|
|
public:
|
|
virtual ~RemoteAccessibleBase() { MOZ_ASSERT(!mWrapper); }
|
|
|
|
virtual bool IsRemote() const override { return true; }
|
|
|
|
void AddChildAt(uint32_t aIdx, Derived* aChild) {
|
|
mChildren.InsertElementAt(aIdx, aChild);
|
|
if (IsHyperText()) {
|
|
InvalidateCachedHyperTextOffsets();
|
|
}
|
|
}
|
|
|
|
virtual uint32_t ChildCount() const override { return mChildren.Length(); }
|
|
Derived* RemoteChildAt(uint32_t aIdx) const {
|
|
return mChildren.SafeElementAt(aIdx);
|
|
}
|
|
Derived* RemoteFirstChild() const {
|
|
return mChildren.Length() ? mChildren[0] : nullptr;
|
|
}
|
|
Derived* RemoteLastChild() const {
|
|
return mChildren.Length() ? mChildren[mChildren.Length() - 1] : nullptr;
|
|
}
|
|
Derived* RemotePrevSibling() const {
|
|
if (IsDoc()) {
|
|
// The normal code path doesn't work for documents because the parent
|
|
// might be a local OuterDoc, but IndexInParent() will return 1.
|
|
// A document is always a single child of an OuterDoc anyway.
|
|
return nullptr;
|
|
}
|
|
int32_t idx = IndexInParent();
|
|
if (idx == -1) {
|
|
return nullptr; // No parent.
|
|
}
|
|
return idx > 0 ? RemoteParent()->mChildren[idx - 1] : nullptr;
|
|
}
|
|
Derived* RemoteNextSibling() const {
|
|
if (IsDoc()) {
|
|
// The normal code path doesn't work for documents because the parent
|
|
// might be a local OuterDoc, but IndexInParent() will return 1.
|
|
// A document is always a single child of an OuterDoc anyway.
|
|
return nullptr;
|
|
}
|
|
int32_t idx = IndexInParent();
|
|
if (idx == -1) {
|
|
return nullptr; // No parent.
|
|
}
|
|
MOZ_ASSERT(idx >= 0);
|
|
size_t newIdx = idx + 1;
|
|
return newIdx < RemoteParent()->mChildren.Length()
|
|
? RemoteParent()->mChildren[newIdx]
|
|
: nullptr;
|
|
}
|
|
|
|
// Accessible hierarchy method overrides
|
|
|
|
virtual Accessible* Parent() const override { return RemoteParent(); }
|
|
|
|
virtual Accessible* ChildAt(uint32_t aIndex) const override {
|
|
return RemoteChildAt(aIndex);
|
|
}
|
|
|
|
virtual Accessible* NextSibling() const override {
|
|
return RemoteNextSibling();
|
|
}
|
|
|
|
virtual Accessible* PrevSibling() const override {
|
|
return RemotePrevSibling();
|
|
}
|
|
|
|
// XXX evaluate if this is fast enough.
|
|
virtual int32_t IndexInParent() const override {
|
|
Derived* parent = RemoteParent();
|
|
if (!parent) {
|
|
return -1;
|
|
}
|
|
return parent->mChildren.IndexOf(static_cast<const Derived*>(this));
|
|
}
|
|
virtual uint32_t EmbeddedChildCount() override;
|
|
virtual int32_t IndexOfEmbeddedChild(Accessible* aChild) override;
|
|
virtual Accessible* EmbeddedChildAt(uint32_t aChildIdx) override;
|
|
|
|
void Shutdown();
|
|
|
|
void SetChildDoc(DocAccessibleParent* aChildDoc);
|
|
void ClearChildDoc(DocAccessibleParent* aChildDoc);
|
|
|
|
/**
|
|
* Remove The given child.
|
|
*/
|
|
void RemoveChild(Derived* aChild) {
|
|
mChildren.RemoveElement(aChild);
|
|
if (IsHyperText()) {
|
|
InvalidateCachedHyperTextOffsets();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return the proxy for the parent of the wrapped accessible.
|
|
*/
|
|
Derived* RemoteParent() const;
|
|
|
|
LocalAccessible* OuterDocOfRemoteBrowser() const;
|
|
|
|
/**
|
|
* Get the role of the accessible we're proxying.
|
|
*/
|
|
virtual role Role() const override { return mRole; }
|
|
|
|
/**
|
|
* Return true if this is an embedded object.
|
|
*/
|
|
bool IsEmbeddedObject() const { return !IsText(); }
|
|
|
|
virtual bool IsLink() const override {
|
|
if (IsHTMLLink()) {
|
|
// XXX: HTML links always return true for IsLink.
|
|
return true;
|
|
}
|
|
|
|
if (IsText()) {
|
|
return false;
|
|
}
|
|
|
|
if (Accessible* parent = Parent()) {
|
|
return parent->IsHyperText();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
virtual bool HasNumericValue() const override {
|
|
// XXX: We combine the aria and native "has numeric value" field
|
|
// when we serialize the local accessible into eNumericValue.
|
|
return HasGenericType(eNumericValue);
|
|
}
|
|
|
|
// Methods that potentially access a cache.
|
|
|
|
virtual ENameValueFlag Name(nsString& aName) const override;
|
|
virtual void Description(nsString& aDescription) const override;
|
|
virtual void Value(nsString& aValue) const override;
|
|
|
|
virtual double CurValue() const override;
|
|
virtual double MinValue() const override;
|
|
virtual double MaxValue() const override;
|
|
virtual double Step() const override;
|
|
|
|
virtual Accessible* ChildAtPoint(
|
|
int32_t aX, int32_t aY,
|
|
LocalAccessible::EWhichChildAtPoint aWhichChild) override;
|
|
|
|
virtual LayoutDeviceIntRect Bounds() const override;
|
|
|
|
virtual nsRect BoundsInAppUnits() const override;
|
|
|
|
virtual Relation RelationByType(RelationType aType) const override;
|
|
|
|
virtual uint64_t State() override;
|
|
|
|
virtual already_AddRefed<AccAttributes> Attributes() override;
|
|
|
|
virtual nsAtom* TagName() const override;
|
|
|
|
virtual already_AddRefed<nsAtom> DisplayStyle() const override;
|
|
|
|
virtual Maybe<float> Opacity() const override;
|
|
|
|
virtual void LiveRegionAttributes(nsAString* aLive, nsAString* aRelevant,
|
|
Maybe<bool>* aAtomic,
|
|
nsAString* aBusy) 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;
|
|
|
|
virtual void SelectionRanges(nsTArray<TextRange>* aRanges) const override;
|
|
|
|
virtual Maybe<int32_t> GetIntARIAAttr(nsAtom* aAttrName) const override;
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// SelectAccessible
|
|
|
|
virtual void SelectedItems(nsTArray<Accessible*>* aItems) override;
|
|
|
|
virtual uint32_t SelectedItemCount() override;
|
|
|
|
virtual Accessible* GetSelectedItem(uint32_t aIndex) override;
|
|
|
|
virtual bool IsItemSelected(uint32_t aIndex) override;
|
|
|
|
virtual bool AddItemToSelection(uint32_t aIndex) override;
|
|
|
|
virtual bool RemoveItemFromSelection(uint32_t aIndex) override;
|
|
|
|
virtual bool SelectAll() override;
|
|
|
|
virtual bool UnselectAll() override;
|
|
|
|
virtual void TakeSelection() override;
|
|
|
|
virtual void SetSelected(bool aSelect) override;
|
|
|
|
// Methods that interact with content.
|
|
|
|
virtual void TakeFocus() const override;
|
|
virtual void ScrollTo(uint32_t aHow) const override;
|
|
virtual void SetCaretOffset(int32_t aOffset) override;
|
|
|
|
/**
|
|
* Allow the platform to store a pointers worth of data on us.
|
|
*/
|
|
uintptr_t GetWrapper() const { return mWrapper; }
|
|
void SetWrapper(uintptr_t aWrapper) { mWrapper = aWrapper; }
|
|
|
|
virtual uint64_t ID() const override { return mID; }
|
|
|
|
/**
|
|
* Return the document containing this proxy, or the proxy itself if it is a
|
|
* document.
|
|
*/
|
|
DocAccessibleParent* Document() const { return mDoc; }
|
|
|
|
DocAccessibleParent* AsDoc() const { return IsDoc() ? mDoc : nullptr; }
|
|
|
|
void ApplyCache(CacheUpdateType aUpdateType, AccAttributes* aFields) {
|
|
const nsTArray<bool> relUpdatesNeeded = PreProcessRelations(aFields);
|
|
if (aUpdateType == CacheUpdateType::Initial) {
|
|
mCachedFields = aFields;
|
|
} else {
|
|
if (!mCachedFields) {
|
|
// The fields cache can be uninitialized if there were no cache-worthy
|
|
// fields in the initial cache push.
|
|
// We don't do a simple assign because we don't want to store the
|
|
// DeleteEntry entries.
|
|
mCachedFields = new AccAttributes();
|
|
}
|
|
mCachedFields->Update(aFields);
|
|
}
|
|
|
|
if (IsTextLeaf()) {
|
|
Derived* parent = RemoteParent();
|
|
if (parent && parent->IsHyperText()) {
|
|
parent->InvalidateCachedHyperTextOffsets();
|
|
}
|
|
}
|
|
|
|
PostProcessRelations(relUpdatesNeeded);
|
|
}
|
|
|
|
void UpdateStateCache(uint64_t aState, bool aEnabled) {
|
|
if (aState & kRemoteCalculatedStates) {
|
|
return;
|
|
}
|
|
uint64_t state = 0;
|
|
if (mCachedFields) {
|
|
if (auto oldState =
|
|
mCachedFields->GetAttribute<uint64_t>(nsGkAtoms::state)) {
|
|
state = *oldState;
|
|
}
|
|
} else {
|
|
mCachedFields = new AccAttributes();
|
|
}
|
|
if (aEnabled) {
|
|
state |= aState;
|
|
} else {
|
|
state &= ~aState;
|
|
}
|
|
mCachedFields->SetAttribute(nsGkAtoms::state, state);
|
|
}
|
|
|
|
void InvalidateGroupInfo();
|
|
|
|
virtual void AppendTextTo(nsAString& aText, uint32_t aStartOffset = 0,
|
|
uint32_t aLength = UINT32_MAX) override;
|
|
|
|
virtual bool TableIsProbablyForLayout();
|
|
|
|
/**
|
|
* Iterates through each atom in kRelationTypeAtoms, checking to see
|
|
* if it is present in aFields. If it is present (or if aFields contains
|
|
* a DeleteEntry() for this atom) and mCachedFields is initialized,
|
|
* fetches the old rel targets and removes their existing reverse relations
|
|
* stored in mReverseRelations.
|
|
* Returns an array of bools where the ith array entry corresponds
|
|
* to whether or not the rel at the ith entry of kRelationTypeAtoms
|
|
* requires a post-processing update.
|
|
*/
|
|
nsTArray<bool> PreProcessRelations(AccAttributes* aFields);
|
|
|
|
/**
|
|
* Takes in the array returned from PreProcessRelations.
|
|
* For each entry requiring an update, fetches the new relation
|
|
* targets stored in mCachedFields and appropriately
|
|
* updates their reverse relations in mReverseRelations.
|
|
*/
|
|
void PostProcessRelations(const nsTArray<bool>& aToUpdate);
|
|
|
|
uint32_t GetCachedTextLength();
|
|
Maybe<const nsTArray<int32_t>&> GetCachedTextLines();
|
|
Maybe<nsTArray<nsRect>> GetCachedCharData();
|
|
RefPtr<const AccAttributes> GetCachedTextAttributes();
|
|
RefPtr<const AccAttributes> GetCachedARIAAttributes() const;
|
|
|
|
virtual HyperTextAccessibleBase* AsHyperTextBase() override {
|
|
return IsHyperText() ? static_cast<HyperTextAccessibleBase*>(this)
|
|
: nullptr;
|
|
}
|
|
|
|
virtual TableAccessibleBase* AsTableBase() override;
|
|
virtual TableCellAccessibleBase* AsTableCellBase() override;
|
|
|
|
virtual void DOMNodeID(nsString& aID) const override;
|
|
|
|
// HyperTextAccessibleBase
|
|
virtual already_AddRefed<AccAttributes> DefaultTextAttributes() override;
|
|
|
|
virtual void InvalidateCachedHyperTextOffsets() override {
|
|
if (mCachedFields) {
|
|
mCachedFields->Remove(nsGkAtoms::offset);
|
|
}
|
|
}
|
|
|
|
protected:
|
|
RemoteAccessibleBase(uint64_t aID, Derived* aParent,
|
|
DocAccessibleParent* aDoc, role aRole, AccType aType,
|
|
AccGenericType aGenericTypes, uint8_t aRoleMapEntryIndex)
|
|
: Accessible(aType, aGenericTypes, aRoleMapEntryIndex),
|
|
mParent(aParent->ID()),
|
|
mDoc(aDoc),
|
|
mWrapper(0),
|
|
mID(aID),
|
|
mCachedFields(nullptr),
|
|
mRole(aRole) {}
|
|
|
|
explicit RemoteAccessibleBase(DocAccessibleParent* aThisAsDoc)
|
|
: Accessible(),
|
|
mParent(kNoParent),
|
|
mDoc(aThisAsDoc),
|
|
mWrapper(0),
|
|
mID(0),
|
|
mCachedFields(nullptr),
|
|
mRole(roles::DOCUMENT) {
|
|
mGenericTypes = eDocument | eHyperText;
|
|
}
|
|
|
|
protected:
|
|
void SetParent(Derived* aParent);
|
|
Maybe<nsRect> RetrieveCachedBounds() const;
|
|
bool ApplyTransform(nsRect& aBounds) const;
|
|
void ApplyScrollOffset(nsRect& aBounds) const;
|
|
void ApplyCrossProcOffset(nsRect& aBounds) const;
|
|
LayoutDeviceIntRect BoundsWithOffset(Maybe<nsRect> aOffset) const;
|
|
|
|
virtual void ARIAGroupPosition(int32_t* aLevel, int32_t* aSetSize,
|
|
int32_t* aPosInSet) const override;
|
|
|
|
virtual AccGroupInfo* GetGroupInfo() const override;
|
|
|
|
virtual AccGroupInfo* GetOrCreateGroupInfo() override;
|
|
|
|
virtual bool HasPrimaryAction() const override;
|
|
|
|
nsAtom* GetPrimaryAction() const;
|
|
|
|
virtual const nsTArray<int32_t>& GetCachedHyperTextOffsets() const override;
|
|
|
|
private:
|
|
uintptr_t mParent;
|
|
static const uintptr_t kNoParent = UINTPTR_MAX;
|
|
|
|
friend Derived;
|
|
friend DocAccessibleParent;
|
|
friend TextLeafPoint;
|
|
friend HyperTextAccessibleBase;
|
|
friend class xpcAccessible;
|
|
friend class CachedTableCellAccessible;
|
|
|
|
nsTArray<Derived*> mChildren;
|
|
DocAccessibleParent* mDoc;
|
|
uintptr_t mWrapper;
|
|
uint64_t mID;
|
|
|
|
protected:
|
|
virtual const Accessible* Acc() const override { return this; }
|
|
|
|
RefPtr<AccAttributes> mCachedFields;
|
|
|
|
// XXX DocAccessibleParent gets to change this to change the role of
|
|
// documents.
|
|
role mRole : 27;
|
|
};
|
|
|
|
extern template class RemoteAccessibleBase<RemoteAccessible>;
|
|
|
|
} // namespace a11y
|
|
} // namespace mozilla
|
|
|
|
#endif
|