Mirror of roytam1's UXP fork just in case Moonchild and Tobin decide to go after him
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

1080 lines
24 KiB

/* -*- 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 "ProxyAccessible.h"
#include "mozilla/a11y/DocAccessibleParent.h"
#include "DocAccessible.h"
#include "mozilla/a11y/DocManager.h"
#include "mozilla/dom/Element.h"
#include "mozilla/dom/TabParent.h"
#include "mozilla/Unused.h"
#include "mozilla/a11y/Platform.h"
#include "RelationType.h"
#include "mozilla/a11y/Role.h"
#include "xpcAccessibleDocument.h"
namespace mozilla {
namespace a11y {
uint64_t
ProxyAccessible::State() const
{
uint64_t state = 0;
Unused << mDoc->SendState(mID, &state);
return state;
}
uint64_t
ProxyAccessible::NativeState() const
{
uint64_t state = 0;
Unused << mDoc->SendNativeState(mID, &state);
return state;
}
void
ProxyAccessible::Name(nsString& aName) const
{
Unused << mDoc->SendName(mID, &aName);
}
void
ProxyAccessible::Value(nsString& aValue) const
{
Unused << mDoc->SendValue(mID, &aValue);
}
void
ProxyAccessible::Help(nsString& aHelp) const
{
Unused << mDoc->SendHelp(mID, &aHelp);
}
void
ProxyAccessible::Description(nsString& aDesc) const
{
Unused << mDoc->SendDescription(mID, &aDesc);
}
void
ProxyAccessible::Attributes(nsTArray<Attribute> *aAttrs) const
{
Unused << mDoc->SendAttributes(mID, aAttrs);
}
nsTArray<ProxyAccessible*>
ProxyAccessible::RelationByType(RelationType aType) const
{
nsTArray<uint64_t> targetIDs;
Unused << mDoc->SendRelationByType(mID, static_cast<uint32_t>(aType),
&targetIDs);
size_t targetCount = targetIDs.Length();
nsTArray<ProxyAccessible*> targets(targetCount);
for (size_t i = 0; i < targetCount; i++)
if (ProxyAccessible* proxy = mDoc->GetAccessible(targetIDs[i]))
targets.AppendElement(proxy);
return Move(targets);
}
void
ProxyAccessible::Relations(nsTArray<RelationType>* aTypes,
nsTArray<nsTArray<ProxyAccessible*>>* aTargetSets)
const
{
nsTArray<RelationTargets> ipcRelations;
Unused << mDoc->SendRelations(mID, &ipcRelations);
size_t relationCount = ipcRelations.Length();
aTypes->SetCapacity(relationCount);
aTargetSets->SetCapacity(relationCount);
for (size_t i = 0; i < relationCount; i++) {
uint32_t type = ipcRelations[i].Type();
if (type > static_cast<uint32_t>(RelationType::LAST))
continue;
size_t targetCount = ipcRelations[i].Targets().Length();
nsTArray<ProxyAccessible*> targets(targetCount);
for (size_t j = 0; j < targetCount; j++)
if (ProxyAccessible* proxy = mDoc->GetAccessible(ipcRelations[i].Targets()[j]))
targets.AppendElement(proxy);
if (targets.IsEmpty())
continue;
aTargetSets->AppendElement(Move(targets));
aTypes->AppendElement(static_cast<RelationType>(type));
}
}
bool
ProxyAccessible::IsSearchbox() const
{
bool retVal = false;
Unused << mDoc->SendIsSearchbox(mID, &retVal);
return retVal;
}
nsIAtom*
ProxyAccessible::LandmarkRole() const
{
nsString landmark;
Unused << mDoc->SendLandmarkRole(mID, &landmark);
return NS_GetStaticAtom(landmark);
}
nsIAtom*
ProxyAccessible::ARIARoleAtom() const
{
nsString role;
Unused << mDoc->SendARIARoleAtom(mID, &role);
return NS_GetStaticAtom(role);
}
int32_t
ProxyAccessible::GetLevelInternal()
{
int32_t level = 0;
Unused << mDoc->SendGetLevelInternal(mID, &level);
return level;
}
void
ProxyAccessible::ScrollTo(uint32_t aScrollType)
{
Unused << mDoc->SendScrollTo(mID, aScrollType);
}
void
ProxyAccessible::ScrollToPoint(uint32_t aScrollType, int32_t aX, int32_t aY)
{
Unused << mDoc->SendScrollToPoint(mID, aScrollType, aX, aY);
}
int32_t
ProxyAccessible::CaretLineNumber()
{
int32_t line = -1;
Unused << mDoc->SendCaretOffset(mID, &line);
return line;
}
int32_t
ProxyAccessible::CaretOffset()
{
int32_t offset = 0;
Unused << mDoc->SendCaretOffset(mID, &offset);
return offset;
}
void
ProxyAccessible::SetCaretOffset(int32_t aOffset)
{
Unused << mDoc->SendSetCaretOffset(mID, aOffset);
}
int32_t
ProxyAccessible::CharacterCount()
{
int32_t count = 0;
Unused << mDoc->SendCharacterCount(mID, &count);
return count;
}
int32_t
ProxyAccessible::SelectionCount()
{
int32_t count = 0;
Unused << mDoc->SendSelectionCount(mID, &count);
return count;
}
bool
ProxyAccessible::TextSubstring(int32_t aStartOffset, int32_t aEndOfset,
nsString& aText) const
{
bool valid;
Unused << mDoc->SendTextSubstring(mID, aStartOffset, aEndOfset, &aText, &valid);
return valid;
}
void
ProxyAccessible::GetTextAfterOffset(int32_t aOffset,
AccessibleTextBoundary aBoundaryType,
nsString& aText, int32_t* aStartOffset,
int32_t* aEndOffset)
{
Unused << mDoc->SendGetTextAfterOffset(mID, aOffset, aBoundaryType,
&aText, aStartOffset, aEndOffset);
}
void
ProxyAccessible::GetTextAtOffset(int32_t aOffset,
AccessibleTextBoundary aBoundaryType,
nsString& aText, int32_t* aStartOffset,
int32_t* aEndOffset)
{
Unused << mDoc->SendGetTextAtOffset(mID, aOffset, aBoundaryType,
&aText, aStartOffset, aEndOffset);
}
void
ProxyAccessible::GetTextBeforeOffset(int32_t aOffset,
AccessibleTextBoundary aBoundaryType,
nsString& aText, int32_t* aStartOffset,
int32_t* aEndOffset)
{
Unused << mDoc->SendGetTextBeforeOffset(mID, aOffset, aBoundaryType,
&aText, aStartOffset, aEndOffset);
}
char16_t
ProxyAccessible::CharAt(int32_t aOffset)
{
uint16_t retval = 0;
Unused << mDoc->SendCharAt(mID, aOffset, &retval);
return static_cast<char16_t>(retval);
}
void
ProxyAccessible::TextAttributes(bool aIncludeDefAttrs,
int32_t aOffset,
nsTArray<Attribute>* aAttributes,
int32_t* aStartOffset,
int32_t* aEndOffset)
{
Unused << mDoc->SendTextAttributes(mID, aIncludeDefAttrs, aOffset,
aAttributes, aStartOffset, aEndOffset);
}
void
ProxyAccessible::DefaultTextAttributes(nsTArray<Attribute>* aAttrs)
{
Unused << mDoc->SendDefaultTextAttributes(mID, aAttrs);
}
nsIntRect
ProxyAccessible::TextBounds(int32_t aStartOffset, int32_t aEndOffset,
uint32_t aCoordType)
{
nsIntRect rect;
Unused <<
mDoc->SendTextBounds(mID, aStartOffset, aEndOffset, aCoordType, &rect);
return rect;
}
nsIntRect
ProxyAccessible::CharBounds(int32_t aOffset, uint32_t aCoordType)
{
nsIntRect rect;
Unused <<
mDoc->SendCharBounds(mID, aOffset, aCoordType, &rect);
return rect;
}
int32_t
ProxyAccessible::OffsetAtPoint(int32_t aX, int32_t aY, uint32_t aCoordType)
{
int32_t retVal = -1;
Unused << mDoc->SendOffsetAtPoint(mID, aX, aY, aCoordType, &retVal);
return retVal;
}
bool
ProxyAccessible::SelectionBoundsAt(int32_t aSelectionNum,
nsString& aData,
int32_t* aStartOffset,
int32_t* aEndOffset)
{
bool retVal = false;
Unused << mDoc->SendSelectionBoundsAt(mID, aSelectionNum, &retVal, &aData,
aStartOffset, aEndOffset);
return retVal;
}
bool
ProxyAccessible::SetSelectionBoundsAt(int32_t aSelectionNum,
int32_t aStartOffset,
int32_t aEndOffset)
{
bool retVal = false;
Unused << mDoc->SendSetSelectionBoundsAt(mID, aSelectionNum, aStartOffset,
aEndOffset, &retVal);
return retVal;
}
bool
ProxyAccessible::AddToSelection(int32_t aStartOffset,
int32_t aEndOffset)
{
bool retVal = false;
Unused << mDoc->SendAddToSelection(mID, aStartOffset, aEndOffset, &retVal);
return retVal;
}
bool
ProxyAccessible::RemoveFromSelection(int32_t aSelectionNum)
{
bool retVal = false;
Unused << mDoc->SendRemoveFromSelection(mID, aSelectionNum, &retVal);
return retVal;
}
void
ProxyAccessible::ScrollSubstringTo(int32_t aStartOffset, int32_t aEndOffset,
uint32_t aScrollType)
{
Unused << mDoc->SendScrollSubstringTo(mID, aStartOffset, aEndOffset, aScrollType);
}
void
ProxyAccessible::ScrollSubstringToPoint(int32_t aStartOffset,
int32_t aEndOffset,
uint32_t aCoordinateType,
int32_t aX, int32_t aY)
{
Unused << mDoc->SendScrollSubstringToPoint(mID, aStartOffset, aEndOffset,
aCoordinateType, aX, aY);
}
void
ProxyAccessible::Text(nsString* aText)
{
Unused << mDoc->SendText(mID, aText);
}
void
ProxyAccessible::ReplaceText(const nsString& aText)
{
Unused << mDoc->SendReplaceText(mID, aText);
}
bool
ProxyAccessible::InsertText(const nsString& aText, int32_t aPosition)
{
bool valid;
Unused << mDoc->SendInsertText(mID, aText, aPosition, &valid);
return valid;
}
bool
ProxyAccessible::CopyText(int32_t aStartPos, int32_t aEndPos)
{
bool valid;
Unused << mDoc->SendCopyText(mID, aStartPos, aEndPos, &valid);
return valid;
}
bool
ProxyAccessible::CutText(int32_t aStartPos, int32_t aEndPos)
{
bool valid;
Unused << mDoc->SendCutText(mID, aStartPos, aEndPos, &valid);
return valid;
}
bool
ProxyAccessible::DeleteText(int32_t aStartPos, int32_t aEndPos)
{
bool valid;
Unused << mDoc->SendDeleteText(mID, aStartPos, aEndPos, &valid);
return valid;
}
bool
ProxyAccessible::PasteText(int32_t aPosition)
{
bool valid;
Unused << mDoc->SendPasteText(mID, aPosition, &valid);
return valid;
}
nsIntPoint
ProxyAccessible::ImagePosition(uint32_t aCoordType)
{
nsIntPoint retVal;
Unused << mDoc->SendImagePosition(mID, aCoordType, &retVal);
return retVal;
}
nsIntSize
ProxyAccessible::ImageSize()
{
nsIntSize retVal;
Unused << mDoc->SendImageSize(mID, &retVal);
return retVal;
}
uint32_t
ProxyAccessible::StartOffset(bool* aOk)
{
uint32_t retVal = 0;
Unused << mDoc->SendStartOffset(mID, &retVal, aOk);
return retVal;
}
uint32_t
ProxyAccessible::EndOffset(bool* aOk)
{
uint32_t retVal = 0;
Unused << mDoc->SendEndOffset(mID, &retVal, aOk);
return retVal;
}
bool
ProxyAccessible::IsLinkValid()
{
bool retVal = false;
Unused << mDoc->SendIsLinkValid(mID, &retVal);
return retVal;
}
uint32_t
ProxyAccessible::AnchorCount(bool* aOk)
{
uint32_t retVal = 0;
Unused << mDoc->SendAnchorCount(mID, &retVal, aOk);
return retVal;
}
void
ProxyAccessible::AnchorURIAt(uint32_t aIndex, nsCString& aURI, bool* aOk)
{
Unused << mDoc->SendAnchorURIAt(mID, aIndex, &aURI, aOk);
}
ProxyAccessible*
ProxyAccessible::AnchorAt(uint32_t aIndex)
{
uint64_t id = 0;
bool ok = false;
Unused << mDoc->SendAnchorAt(mID, aIndex, &id, &ok);
return ok ? mDoc->GetAccessible(id) : nullptr;
}
uint32_t
ProxyAccessible::LinkCount()
{
uint32_t retVal = 0;
Unused << mDoc->SendLinkCount(mID, &retVal);
return retVal;
}
ProxyAccessible*
ProxyAccessible::LinkAt(const uint32_t& aIndex)
{
uint64_t linkID = 0;
bool ok = false;
Unused << mDoc->SendLinkAt(mID, aIndex, &linkID, &ok);
return ok ? mDoc->GetAccessible(linkID) : nullptr;
}
int32_t
ProxyAccessible::LinkIndexOf(ProxyAccessible* aLink)
{
int32_t retVal = -1;
if (aLink) {
Unused << mDoc->SendLinkIndexOf(mID, aLink->ID(), &retVal);
}
return retVal;
}
int32_t
ProxyAccessible::LinkIndexAtOffset(uint32_t aOffset)
{
int32_t retVal = -1;
Unused << mDoc->SendLinkIndexAtOffset(mID, aOffset, &retVal);
return retVal;
}
ProxyAccessible*
ProxyAccessible::TableOfACell()
{
uint64_t tableID = 0;
bool ok = false;
Unused << mDoc->SendTableOfACell(mID, &tableID, &ok);
return ok ? mDoc->GetAccessible(tableID) : nullptr;
}
uint32_t
ProxyAccessible::ColIdx()
{
uint32_t index = 0;
Unused << mDoc->SendColIdx(mID, &index);
return index;
}
uint32_t
ProxyAccessible::RowIdx()
{
uint32_t index = 0;
Unused << mDoc->SendRowIdx(mID, &index);
return index;
}
void
ProxyAccessible::GetColRowExtents(uint32_t* aColIdx, uint32_t* aRowIdx,
uint32_t* aColExtent, uint32_t* aRowExtent)
{
Unused << mDoc->SendGetColRowExtents(mID, aColIdx, aRowIdx, aColExtent, aRowExtent);
}
void
ProxyAccessible::GetPosition(uint32_t* aColIdx, uint32_t* aRowIdx)
{
Unused << mDoc->SendGetPosition(mID, aColIdx, aRowIdx);
}
uint32_t
ProxyAccessible::ColExtent()
{
uint32_t extent = 0;
Unused << mDoc->SendColExtent(mID, &extent);
return extent;
}
uint32_t
ProxyAccessible::RowExtent()
{
uint32_t extent = 0;
Unused << mDoc->SendRowExtent(mID, &extent);
return extent;
}
void
ProxyAccessible::ColHeaderCells(nsTArray<ProxyAccessible*>* aCells)
{
nsTArray<uint64_t> targetIDs;
Unused << mDoc->SendColHeaderCells(mID, &targetIDs);
size_t targetCount = targetIDs.Length();
for (size_t i = 0; i < targetCount; i++) {
aCells->AppendElement(mDoc->GetAccessible(targetIDs[i]));
}
}
void
ProxyAccessible::RowHeaderCells(nsTArray<ProxyAccessible*>* aCells)
{
nsTArray<uint64_t> targetIDs;
Unused << mDoc->SendRowHeaderCells(mID, &targetIDs);
size_t targetCount = targetIDs.Length();
for (size_t i = 0; i < targetCount; i++) {
aCells->AppendElement(mDoc->GetAccessible(targetIDs[i]));
}
}
bool
ProxyAccessible::IsCellSelected()
{
bool selected = false;
Unused << mDoc->SendIsCellSelected(mID, &selected);
return selected;
}
ProxyAccessible*
ProxyAccessible::TableCaption()
{
uint64_t captionID = 0;
bool ok = false;
Unused << mDoc->SendTableCaption(mID, &captionID, &ok);
return ok ? mDoc->GetAccessible(captionID) : nullptr;
}
void
ProxyAccessible::TableSummary(nsString& aSummary)
{
Unused << mDoc->SendTableSummary(mID, &aSummary);
}
uint32_t
ProxyAccessible::TableColumnCount()
{
uint32_t count = 0;
Unused << mDoc->SendTableColumnCount(mID, &count);
return count;
}
uint32_t
ProxyAccessible::TableRowCount()
{
uint32_t count = 0;
Unused << mDoc->SendTableRowCount(mID, &count);
return count;
}
ProxyAccessible*
ProxyAccessible::TableCellAt(uint32_t aRow, uint32_t aCol)
{
uint64_t cellID = 0;
bool ok = false;
Unused << mDoc->SendTableCellAt(mID, aRow, aCol, &cellID, &ok);
return ok ? mDoc->GetAccessible(cellID) : nullptr;
}
int32_t
ProxyAccessible::TableCellIndexAt(uint32_t aRow, uint32_t aCol)
{
int32_t index = 0;
Unused << mDoc->SendTableCellIndexAt(mID, aRow, aCol, &index);
return index;
}
int32_t
ProxyAccessible::TableColumnIndexAt(uint32_t aCellIndex)
{
int32_t index = 0;
Unused << mDoc->SendTableColumnIndexAt(mID, aCellIndex, &index);
return index;
}
int32_t
ProxyAccessible::TableRowIndexAt(uint32_t aCellIndex)
{
int32_t index = 0;
Unused << mDoc->SendTableRowIndexAt(mID, aCellIndex, &index);
return index;
}
void
ProxyAccessible::TableRowAndColumnIndicesAt(uint32_t aCellIndex,
int32_t* aRow, int32_t* aCol)
{
Unused << mDoc->SendTableRowAndColumnIndicesAt(mID, aCellIndex, aRow, aCol);
}
uint32_t
ProxyAccessible::TableColumnExtentAt(uint32_t aRow, uint32_t aCol)
{
uint32_t extent = 0;
Unused << mDoc->SendTableColumnExtentAt(mID, aRow, aCol, &extent);
return extent;
}
uint32_t
ProxyAccessible::TableRowExtentAt(uint32_t aRow, uint32_t aCol)
{
uint32_t extent = 0;
Unused << mDoc->SendTableRowExtentAt(mID, aRow, aCol, &extent);
return extent;
}
void
ProxyAccessible::TableColumnDescription(uint32_t aCol, nsString& aDescription)
{
Unused << mDoc->SendTableColumnDescription(mID, aCol, &aDescription);
}
void
ProxyAccessible::TableRowDescription(uint32_t aRow, nsString& aDescription)
{
Unused << mDoc->SendTableRowDescription(mID, aRow, &aDescription);
}
bool
ProxyAccessible::TableColumnSelected(uint32_t aCol)
{
bool selected = false;
Unused << mDoc->SendTableColumnSelected(mID, aCol, &selected);
return selected;
}
bool
ProxyAccessible::TableRowSelected(uint32_t aRow)
{
bool selected = false;
Unused << mDoc->SendTableRowSelected(mID, aRow, &selected);
return selected;
}
bool
ProxyAccessible::TableCellSelected(uint32_t aRow, uint32_t aCol)
{
bool selected = false;
Unused << mDoc->SendTableCellSelected(mID, aRow, aCol, &selected);
return selected;
}
uint32_t
ProxyAccessible::TableSelectedCellCount()
{
uint32_t count = 0;
Unused << mDoc->SendTableSelectedCellCount(mID, &count);
return count;
}
uint32_t
ProxyAccessible::TableSelectedColumnCount()
{
uint32_t count = 0;
Unused << mDoc->SendTableSelectedColumnCount(mID, &count);
return count;
}
uint32_t
ProxyAccessible::TableSelectedRowCount()
{
uint32_t count = 0;
Unused << mDoc->SendTableSelectedRowCount(mID, &count);
return count;
}
void
ProxyAccessible::TableSelectedCells(nsTArray<ProxyAccessible*>* aCellIDs)
{
AutoTArray<uint64_t, 30> cellIDs;
Unused << mDoc->SendTableSelectedCells(mID, &cellIDs);
aCellIDs->SetCapacity(cellIDs.Length());
for (uint32_t i = 0; i < cellIDs.Length(); ++i) {
aCellIDs->AppendElement(mDoc->GetAccessible(cellIDs[i]));
}
}
void
ProxyAccessible::TableSelectedCellIndices(nsTArray<uint32_t>* aCellIndices)
{
Unused << mDoc->SendTableSelectedCellIndices(mID, aCellIndices);
}
void
ProxyAccessible::TableSelectedColumnIndices(nsTArray<uint32_t>* aColumnIndices)
{
Unused << mDoc->SendTableSelectedColumnIndices(mID, aColumnIndices);
}
void
ProxyAccessible::TableSelectedRowIndices(nsTArray<uint32_t>* aRowIndices)
{
Unused << mDoc->SendTableSelectedRowIndices(mID, aRowIndices);
}
void
ProxyAccessible::TableSelectColumn(uint32_t aCol)
{
Unused << mDoc->SendTableSelectColumn(mID, aCol);
}
void
ProxyAccessible::TableSelectRow(uint32_t aRow)
{
Unused << mDoc->SendTableSelectRow(mID, aRow);
}
void
ProxyAccessible::TableUnselectColumn(uint32_t aCol)
{
Unused << mDoc->SendTableUnselectColumn(mID, aCol);
}
void
ProxyAccessible::TableUnselectRow(uint32_t aRow)
{
Unused << mDoc->SendTableUnselectRow(mID, aRow);
}
bool
ProxyAccessible::TableIsProbablyForLayout()
{
bool forLayout = false;
Unused << mDoc->SendTableIsProbablyForLayout(mID, &forLayout);
return forLayout;
}
ProxyAccessible*
ProxyAccessible::AtkTableColumnHeader(int32_t aCol)
{
uint64_t headerID = 0;
bool ok = false;
Unused << mDoc->SendAtkTableColumnHeader(mID, aCol, &headerID, &ok);
return ok ? mDoc->GetAccessible(headerID) : nullptr;
}
ProxyAccessible*
ProxyAccessible::AtkTableRowHeader(int32_t aRow)
{
uint64_t headerID = 0;
bool ok = false;
Unused << mDoc->SendAtkTableRowHeader(mID, aRow, &headerID, &ok);
return ok ? mDoc->GetAccessible(headerID) : nullptr;
}
void
ProxyAccessible::SelectedItems(nsTArray<ProxyAccessible*>* aSelectedItems)
{
AutoTArray<uint64_t, 10> itemIDs;
Unused << mDoc->SendSelectedItems(mID, &itemIDs);
aSelectedItems->SetCapacity(itemIDs.Length());
for (size_t i = 0; i < itemIDs.Length(); ++i) {
aSelectedItems->AppendElement(mDoc->GetAccessible(itemIDs[i]));
}
}
uint32_t
ProxyAccessible::SelectedItemCount()
{
uint32_t count = 0;
Unused << mDoc->SendSelectedItemCount(mID, &count);
return count;
}
ProxyAccessible*
ProxyAccessible::GetSelectedItem(uint32_t aIndex)
{
uint64_t selectedItemID = 0;
bool ok = false;
Unused << mDoc->SendGetSelectedItem(mID, aIndex, &selectedItemID, &ok);
return ok ? mDoc->GetAccessible(selectedItemID) : nullptr;
}
bool
ProxyAccessible::IsItemSelected(uint32_t aIndex)
{
bool selected = false;
Unused << mDoc->SendIsItemSelected(mID, aIndex, &selected);
return selected;
}
bool
ProxyAccessible::AddItemToSelection(uint32_t aIndex)
{
bool success = false;
Unused << mDoc->SendAddItemToSelection(mID, aIndex, &success);
return success;
}
bool
ProxyAccessible::RemoveItemFromSelection(uint32_t aIndex)
{
bool success = false;
Unused << mDoc->SendRemoveItemFromSelection(mID, aIndex, &success);
return success;
}
bool
ProxyAccessible::SelectAll()
{
bool success = false;
Unused << mDoc->SendSelectAll(mID, &success);
return success;
}
bool
ProxyAccessible::UnselectAll()
{
bool success = false;
Unused << mDoc->SendUnselectAll(mID, &success);
return success;
}
void
ProxyAccessible::TakeSelection()
{
Unused << mDoc->SendTakeSelection(mID);
}
void
ProxyAccessible::SetSelected(bool aSelect)
{
Unused << mDoc->SendSetSelected(mID, aSelect);
}
bool
ProxyAccessible::DoAction(uint8_t aIndex)
{
bool success = false;
Unused << mDoc->SendDoAction(mID, aIndex, &success);
return success;
}
uint8_t
ProxyAccessible::ActionCount()
{
uint8_t count = 0;
Unused << mDoc->SendActionCount(mID, &count);
return count;
}
void
ProxyAccessible::ActionDescriptionAt(uint8_t aIndex, nsString& aDescription)
{
Unused << mDoc->SendActionDescriptionAt(mID, aIndex, &aDescription);
}
void
ProxyAccessible::ActionNameAt(uint8_t aIndex, nsString& aName)
{
Unused << mDoc->SendActionNameAt(mID, aIndex, &aName);
}
KeyBinding
ProxyAccessible::AccessKey()
{
uint32_t key = 0;
uint32_t modifierMask = 0;
Unused << mDoc->SendAccessKey(mID, &key, &modifierMask);
return KeyBinding(key, modifierMask);
}
KeyBinding
ProxyAccessible::KeyboardShortcut()
{
uint32_t key = 0;
uint32_t modifierMask = 0;
Unused << mDoc->SendKeyboardShortcut(mID, &key, &modifierMask);
return KeyBinding(key, modifierMask);
}
void
ProxyAccessible::AtkKeyBinding(nsString& aBinding)
{
Unused << mDoc->SendAtkKeyBinding(mID, &aBinding);
}
double
ProxyAccessible::CurValue()
{
double val = UnspecifiedNaN<double>();
Unused << mDoc->SendCurValue(mID, &val);
return val;
}
bool
ProxyAccessible::SetCurValue(double aValue)
{
bool success = false;
Unused << mDoc->SendSetCurValue(mID, aValue, &success);
return success;
}
double
ProxyAccessible::MinValue()
{
double val = UnspecifiedNaN<double>();
Unused << mDoc->SendMinValue(mID, &val);
return val;
}
double
ProxyAccessible::MaxValue()
{
double val = UnspecifiedNaN<double>();
Unused << mDoc->SendMaxValue(mID, &val);
return val;
}
double
ProxyAccessible::Step()
{
double step = UnspecifiedNaN<double>();
Unused << mDoc->SendStep(mID, &step);
return step;
}
void
ProxyAccessible::TakeFocus()
{
Unused << mDoc->SendTakeFocus(mID);
}
ProxyAccessible*
ProxyAccessible::FocusedChild()
{
uint64_t childID = 0;
bool ok = false;
Unused << mDoc->SendFocusedChild(mID, &childID, &ok);
return ok ? mDoc->GetAccessible(childID) : nullptr;
}
ProxyAccessible*
ProxyAccessible::ChildAtPoint(int32_t aX, int32_t aY,
Accessible::EWhichChildAtPoint aWhichChild)
{
uint64_t childID = 0;
bool ok = false;
Unused << mDoc->SendAccessibleAtPoint(mID, aX, aY, false,
static_cast<uint32_t>(aWhichChild),
&childID, &ok);
return ok ? mDoc->GetAccessible(childID) : nullptr;
}
nsIntRect
ProxyAccessible::Bounds()
{
nsIntRect rect;
Unused << mDoc->SendExtents(mID, false,
&(rect.x), &(rect.y),
&(rect.width), &(rect.height));
return rect;
}
void
ProxyAccessible::Language(nsString& aLocale)
{
Unused << mDoc->SendLanguage(mID, &aLocale);
}
void
ProxyAccessible::DocType(nsString& aType)
{
Unused << mDoc->SendDocType(mID, &aType);
}
void
ProxyAccessible::Title(nsString& aTitle)
{
Unused << mDoc->SendTitle(mID, &aTitle);
}
void
ProxyAccessible::URL(nsString& aURL)
{
Unused << mDoc->SendURL(mID, &aURL);
}
void
ProxyAccessible::MimeType(nsString aMime)
{
Unused << mDoc->SendMimeType(mID, &aMime);
}
void
ProxyAccessible::URLDocTypeMimeType(nsString& aURL, nsString& aDocType,
nsString& aMimeType)
{
Unused << mDoc->SendURLDocTypeMimeType(mID, &aURL, &aDocType, &aMimeType);
}
ProxyAccessible*
ProxyAccessible::AccessibleAtPoint(int32_t aX, int32_t aY,
bool aNeedsScreenCoords)
{
uint64_t childID = 0;
bool ok = false;
Unused <<
mDoc->SendAccessibleAtPoint(mID, aX, aY, aNeedsScreenCoords,
static_cast<uint32_t>(Accessible::eDirectChild),
&childID, &ok);
return ok ? mDoc->GetAccessible(childID) : nullptr;
}
void
ProxyAccessible::Extents(bool aNeedsScreenCoords, int32_t* aX, int32_t* aY,
int32_t* aWidth, int32_t* aHeight)
{
Unused << mDoc->SendExtents(mID, aNeedsScreenCoords, aX, aY, aWidth, aHeight);
}
void
ProxyAccessible::DOMNodeID(nsString& aID)
{
Unused << mDoc->SendDOMNodeID(mID, &aID);
}
}
}