diff options
Diffstat (limited to 'accessible/generic')
30 files changed, 14334 insertions, 0 deletions
diff --git a/accessible/generic/ARIAGridAccessible-inl.h b/accessible/generic/ARIAGridAccessible-inl.h new file mode 100644 index 000000000..bb2bc9705 --- /dev/null +++ b/accessible/generic/ARIAGridAccessible-inl.h @@ -0,0 +1,39 @@ +/* -*- 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_ARIAGridAccessible_inl_h__ +#define mozilla_a11y_ARIAGridAccessible_inl_h__ + +#include "ARIAGridAccessible.h" + +#include "AccIterator.h" +#include "nsAccUtils.h" + +namespace mozilla { +namespace a11y { + +inline int32_t +ARIAGridCellAccessible::RowIndexFor(Accessible* aRow) const +{ + Accessible* table = nsAccUtils::TableFor(aRow); + if (table) { + int32_t rowIdx = 0; + Accessible* row = nullptr; + AccIterator rowIter(table, filters::GetRow); + while ((row = rowIter.Next()) && row != aRow) + rowIdx++; + + if (row) + return rowIdx; + } + + return -1; +} + +} // namespace a11y +} // namespace mozilla + +#endif diff --git a/accessible/generic/ARIAGridAccessible.cpp b/accessible/generic/ARIAGridAccessible.cpp new file mode 100644 index 000000000..48de9bbf0 --- /dev/null +++ b/accessible/generic/ARIAGridAccessible.cpp @@ -0,0 +1,702 @@ +/* -*- 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 "ARIAGridAccessible-inl.h" + +#include "Accessible-inl.h" +#include "AccIterator.h" +#include "nsAccUtils.h" +#include "Role.h" +#include "States.h" + +#include "nsIMutableArray.h" +#include "nsIPersistentProperties2.h" +#include "nsComponentManagerUtils.h" + +using namespace mozilla; +using namespace mozilla::a11y; + +//////////////////////////////////////////////////////////////////////////////// +// ARIAGridAccessible +//////////////////////////////////////////////////////////////////////////////// + + +//////////////////////////////////////////////////////////////////////////////// +// Constructor + +ARIAGridAccessible:: + ARIAGridAccessible(nsIContent* aContent, DocAccessible* aDoc) : + AccessibleWrap(aContent, aDoc) +{ +} + +NS_IMPL_ISUPPORTS_INHERITED0(ARIAGridAccessible, Accessible) + +//////////////////////////////////////////////////////////////////////////////// +// Table + +uint32_t +ARIAGridAccessible::ColCount() +{ + AccIterator rowIter(this, filters::GetRow); + Accessible* row = rowIter.Next(); + if (!row) + return 0; + + AccIterator cellIter(row, filters::GetCell); + Accessible* cell = nullptr; + + uint32_t colCount = 0; + while ((cell = cellIter.Next())) + colCount++; + + return colCount; +} + +uint32_t +ARIAGridAccessible::RowCount() +{ + uint32_t rowCount = 0; + AccIterator rowIter(this, filters::GetRow); + while (rowIter.Next()) + rowCount++; + + return rowCount; +} + +Accessible* +ARIAGridAccessible::CellAt(uint32_t aRowIndex, uint32_t aColumnIndex) +{ + Accessible* row = GetRowAt(aRowIndex); + if (!row) + return nullptr; + + return GetCellInRowAt(row, aColumnIndex); +} + +bool +ARIAGridAccessible::IsColSelected(uint32_t aColIdx) +{ + if (IsARIARole(nsGkAtoms::table)) + return false; + + AccIterator rowIter(this, filters::GetRow); + Accessible* row = rowIter.Next(); + if (!row) + return false; + + do { + if (!nsAccUtils::IsARIASelected(row)) { + Accessible* cell = GetCellInRowAt(row, aColIdx); + if (!cell || !nsAccUtils::IsARIASelected(cell)) + return false; + } + } while ((row = rowIter.Next())); + + return true; +} + +bool +ARIAGridAccessible::IsRowSelected(uint32_t aRowIdx) +{ + if (IsARIARole(nsGkAtoms::table)) + return false; + + Accessible* row = GetRowAt(aRowIdx); + if(!row) + return false; + + if (!nsAccUtils::IsARIASelected(row)) { + AccIterator cellIter(row, filters::GetCell); + Accessible* cell = nullptr; + while ((cell = cellIter.Next())) { + if (!nsAccUtils::IsARIASelected(cell)) + return false; + } + } + + return true; +} + +bool +ARIAGridAccessible::IsCellSelected(uint32_t aRowIdx, uint32_t aColIdx) +{ + if (IsARIARole(nsGkAtoms::table)) + return false; + + Accessible* row = GetRowAt(aRowIdx); + if(!row) + return false; + + if (!nsAccUtils::IsARIASelected(row)) { + Accessible* cell = GetCellInRowAt(row, aColIdx); + if (!cell || !nsAccUtils::IsARIASelected(cell)) + return false; + } + + return true; +} + +uint32_t +ARIAGridAccessible::SelectedCellCount() +{ + if (IsARIARole(nsGkAtoms::table)) + return 0; + + uint32_t count = 0, colCount = ColCount(); + + AccIterator rowIter(this, filters::GetRow); + Accessible* row = nullptr; + + while ((row = rowIter.Next())) { + if (nsAccUtils::IsARIASelected(row)) { + count += colCount; + continue; + } + + AccIterator cellIter(row, filters::GetCell); + Accessible* cell = nullptr; + + while ((cell = cellIter.Next())) { + if (nsAccUtils::IsARIASelected(cell)) + count++; + } + } + + return count; +} + +uint32_t +ARIAGridAccessible::SelectedColCount() +{ + if (IsARIARole(nsGkAtoms::table)) + return 0; + + uint32_t colCount = ColCount(); + if (!colCount) + return 0; + + AccIterator rowIter(this, filters::GetRow); + Accessible* row = rowIter.Next(); + if (!row) + return 0; + + nsTArray<bool> isColSelArray(colCount); + isColSelArray.AppendElements(colCount); + memset(isColSelArray.Elements(), true, colCount * sizeof(bool)); + + uint32_t selColCount = colCount; + do { + if (nsAccUtils::IsARIASelected(row)) + continue; + + AccIterator cellIter(row, filters::GetCell); + Accessible* cell = nullptr; + for (uint32_t colIdx = 0; + (cell = cellIter.Next()) && colIdx < colCount; colIdx++) + if (isColSelArray[colIdx] && !nsAccUtils::IsARIASelected(cell)) { + isColSelArray[colIdx] = false; + selColCount--; + } + } while ((row = rowIter.Next())); + + return selColCount; +} + +uint32_t +ARIAGridAccessible::SelectedRowCount() +{ + if (IsARIARole(nsGkAtoms::table)) + return 0; + + uint32_t count = 0; + + AccIterator rowIter(this, filters::GetRow); + Accessible* row = nullptr; + + while ((row = rowIter.Next())) { + if (nsAccUtils::IsARIASelected(row)) { + count++; + continue; + } + + AccIterator cellIter(row, filters::GetCell); + Accessible* cell = cellIter.Next(); + if (!cell) + continue; + + bool isRowSelected = true; + do { + if (!nsAccUtils::IsARIASelected(cell)) { + isRowSelected = false; + break; + } + } while ((cell = cellIter.Next())); + + if (isRowSelected) + count++; + } + + return count; +} + +void +ARIAGridAccessible::SelectedCells(nsTArray<Accessible*>* aCells) +{ + if (IsARIARole(nsGkAtoms::table)) + return; + + AccIterator rowIter(this, filters::GetRow); + + Accessible* row = nullptr; + while ((row = rowIter.Next())) { + AccIterator cellIter(row, filters::GetCell); + Accessible* cell = nullptr; + + if (nsAccUtils::IsARIASelected(row)) { + while ((cell = cellIter.Next())) + aCells->AppendElement(cell); + + continue; + } + + while ((cell = cellIter.Next())) { + if (nsAccUtils::IsARIASelected(cell)) + aCells->AppendElement(cell); + } + } +} + +void +ARIAGridAccessible::SelectedCellIndices(nsTArray<uint32_t>* aCells) +{ + if (IsARIARole(nsGkAtoms::table)) + return; + + uint32_t colCount = ColCount(); + + AccIterator rowIter(this, filters::GetRow); + Accessible* row = nullptr; + for (uint32_t rowIdx = 0; (row = rowIter.Next()); rowIdx++) { + if (nsAccUtils::IsARIASelected(row)) { + for (uint32_t colIdx = 0; colIdx < colCount; colIdx++) + aCells->AppendElement(rowIdx * colCount + colIdx); + + continue; + } + + AccIterator cellIter(row, filters::GetCell); + Accessible* cell = nullptr; + for (uint32_t colIdx = 0; (cell = cellIter.Next()); colIdx++) { + if (nsAccUtils::IsARIASelected(cell)) + aCells->AppendElement(rowIdx * colCount + colIdx); + } + } +} + +void +ARIAGridAccessible::SelectedColIndices(nsTArray<uint32_t>* aCols) +{ + if (IsARIARole(nsGkAtoms::table)) + return; + + uint32_t colCount = ColCount(); + if (!colCount) + return; + + AccIterator rowIter(this, filters::GetRow); + Accessible* row = rowIter.Next(); + if (!row) + return; + + nsTArray<bool> isColSelArray(colCount); + isColSelArray.AppendElements(colCount); + memset(isColSelArray.Elements(), true, colCount * sizeof(bool)); + + do { + if (nsAccUtils::IsARIASelected(row)) + continue; + + AccIterator cellIter(row, filters::GetCell); + Accessible* cell = nullptr; + for (uint32_t colIdx = 0; + (cell = cellIter.Next()) && colIdx < colCount; colIdx++) + if (isColSelArray[colIdx] && !nsAccUtils::IsARIASelected(cell)) { + isColSelArray[colIdx] = false; + } + } while ((row = rowIter.Next())); + + for (uint32_t colIdx = 0; colIdx < colCount; colIdx++) + if (isColSelArray[colIdx]) + aCols->AppendElement(colIdx); +} + +void +ARIAGridAccessible::SelectedRowIndices(nsTArray<uint32_t>* aRows) +{ + if (IsARIARole(nsGkAtoms::table)) + return; + + AccIterator rowIter(this, filters::GetRow); + Accessible* row = nullptr; + for (uint32_t rowIdx = 0; (row = rowIter.Next()); rowIdx++) { + if (nsAccUtils::IsARIASelected(row)) { + aRows->AppendElement(rowIdx); + continue; + } + + AccIterator cellIter(row, filters::GetCell); + Accessible* cell = cellIter.Next(); + if (!cell) + continue; + + bool isRowSelected = true; + do { + if (!nsAccUtils::IsARIASelected(cell)) { + isRowSelected = false; + break; + } + } while ((cell = cellIter.Next())); + + if (isRowSelected) + aRows->AppendElement(rowIdx); + } +} + +void +ARIAGridAccessible::SelectRow(uint32_t aRowIdx) +{ + if (IsARIARole(nsGkAtoms::table)) + return; + + AccIterator rowIter(this, filters::GetRow); + + Accessible* row = nullptr; + for (uint32_t rowIdx = 0; (row = rowIter.Next()); rowIdx++) { + DebugOnly<nsresult> rv = SetARIASelected(row, rowIdx == aRowIdx); + NS_ASSERTION(NS_SUCCEEDED(rv), "SetARIASelected() Shouldn't fail!"); + } +} + +void +ARIAGridAccessible::SelectCol(uint32_t aColIdx) +{ + if (IsARIARole(nsGkAtoms::table)) + return; + + AccIterator rowIter(this, filters::GetRow); + + Accessible* row = nullptr; + while ((row = rowIter.Next())) { + // Unselect all cells in the row. + DebugOnly<nsresult> rv = SetARIASelected(row, false); + NS_ASSERTION(NS_SUCCEEDED(rv), "SetARIASelected() Shouldn't fail!"); + + // Select cell at the column index. + Accessible* cell = GetCellInRowAt(row, aColIdx); + if (cell) + SetARIASelected(cell, true); + } +} + +void +ARIAGridAccessible::UnselectRow(uint32_t aRowIdx) +{ + if (IsARIARole(nsGkAtoms::table)) + return; + + Accessible* row = GetRowAt(aRowIdx); + if (row) + SetARIASelected(row, false); +} + +void +ARIAGridAccessible::UnselectCol(uint32_t aColIdx) +{ + if (IsARIARole(nsGkAtoms::table)) + return; + + AccIterator rowIter(this, filters::GetRow); + + Accessible* row = nullptr; + while ((row = rowIter.Next())) { + Accessible* cell = GetCellInRowAt(row, aColIdx); + if (cell) + SetARIASelected(cell, false); + } +} + +//////////////////////////////////////////////////////////////////////////////// +// Protected + +Accessible* +ARIAGridAccessible::GetRowAt(int32_t aRow) +{ + int32_t rowIdx = aRow; + + AccIterator rowIter(this, filters::GetRow); + + Accessible* row = rowIter.Next(); + while (rowIdx != 0 && (row = rowIter.Next())) + rowIdx--; + + return row; +} + +Accessible* +ARIAGridAccessible::GetCellInRowAt(Accessible* aRow, int32_t aColumn) +{ + int32_t colIdx = aColumn; + + AccIterator cellIter(aRow, filters::GetCell); + Accessible* cell = cellIter.Next(); + while (colIdx != 0 && (cell = cellIter.Next())) + colIdx--; + + return cell; +} + +nsresult +ARIAGridAccessible::SetARIASelected(Accessible* aAccessible, + bool aIsSelected, bool aNotify) +{ + if (IsARIARole(nsGkAtoms::table)) + return NS_OK; + + nsIContent *content = aAccessible->GetContent(); + NS_ENSURE_STATE(content); + + nsresult rv = NS_OK; + if (aIsSelected) + rv = content->SetAttr(kNameSpaceID_None, nsGkAtoms::aria_selected, + NS_LITERAL_STRING("true"), aNotify); + else + rv = content->SetAttr(kNameSpaceID_None, nsGkAtoms::aria_selected, + NS_LITERAL_STRING("false"), aNotify); + + NS_ENSURE_SUCCESS(rv, rv); + + // No "smart" select/unselect for internal call. + if (!aNotify) + return NS_OK; + + // If row or cell accessible was selected then we're able to not bother about + // selection of its cells or its row because our algorithm is row oriented, + // i.e. we check selection on row firstly and then on cells. + if (aIsSelected) + return NS_OK; + + roles::Role role = aAccessible->Role(); + + // If the given accessible is row that was unselected then remove + // aria-selected from cell accessible. + if (role == roles::ROW) { + AccIterator cellIter(aAccessible, filters::GetCell); + Accessible* cell = nullptr; + + while ((cell = cellIter.Next())) { + rv = SetARIASelected(cell, false, false); + NS_ENSURE_SUCCESS(rv, rv); + } + return NS_OK; + } + + // If the given accessible is cell that was unselected and its row is selected + // then remove aria-selected from row and put aria-selected on + // siblings cells. + if (role == roles::GRID_CELL || role == roles::ROWHEADER || + role == roles::COLUMNHEADER) { + Accessible* row = aAccessible->Parent(); + + if (row && row->Role() == roles::ROW && + nsAccUtils::IsARIASelected(row)) { + rv = SetARIASelected(row, false, false); + NS_ENSURE_SUCCESS(rv, rv); + + AccIterator cellIter(row, filters::GetCell); + Accessible* cell = nullptr; + while ((cell = cellIter.Next())) { + if (cell != aAccessible) { + rv = SetARIASelected(cell, true, false); + NS_ENSURE_SUCCESS(rv, rv); + } + } + } + } + + return NS_OK; +} + + +//////////////////////////////////////////////////////////////////////////////// +// ARIARowAccessible +//////////////////////////////////////////////////////////////////////////////// + +ARIARowAccessible:: + ARIARowAccessible(nsIContent* aContent, DocAccessible* aDoc) : + AccessibleWrap(aContent, aDoc) +{ + mGenericTypes |= eTableRow; +} + +NS_IMPL_ISUPPORTS_INHERITED0(ARIARowAccessible, Accessible) + +GroupPos +ARIARowAccessible::GroupPosition() +{ + int32_t count = 0, index = 0; + Accessible* table = nsAccUtils::TableFor(this); + if (table && nsCoreUtils::GetUIntAttr(table->GetContent(), + nsGkAtoms::aria_rowcount, &count) && + nsCoreUtils::GetUIntAttr(mContent, nsGkAtoms::aria_rowindex, &index)) { + return GroupPos(0, index, count); + } + + return AccessibleWrap::GroupPosition(); +} + + +//////////////////////////////////////////////////////////////////////////////// +// ARIAGridCellAccessible +//////////////////////////////////////////////////////////////////////////////// + + +//////////////////////////////////////////////////////////////////////////////// +// Constructor + +ARIAGridCellAccessible:: + ARIAGridCellAccessible(nsIContent* aContent, DocAccessible* aDoc) : + HyperTextAccessibleWrap(aContent, aDoc) +{ + mGenericTypes |= eTableCell; +} + +NS_IMPL_ISUPPORTS_INHERITED0(ARIAGridCellAccessible, HyperTextAccessible) + +//////////////////////////////////////////////////////////////////////////////// +// TableCell + +TableAccessible* +ARIAGridCellAccessible::Table() const +{ + Accessible* table = nsAccUtils::TableFor(Row()); + return table ? table->AsTable() : nullptr; +} + +uint32_t +ARIAGridCellAccessible::ColIdx() const +{ + Accessible* row = Row(); + if (!row) + return 0; + + int32_t indexInRow = IndexInParent(); + uint32_t colIdx = 0; + for (int32_t idx = 0; idx < indexInRow; idx++) { + Accessible* cell = row->GetChildAt(idx); + roles::Role role = cell->Role(); + if (role == roles::CELL || role == roles::GRID_CELL || + role == roles::ROWHEADER || role == roles::COLUMNHEADER) + colIdx++; + } + + return colIdx; +} + +uint32_t +ARIAGridCellAccessible::RowIdx() const +{ + return RowIndexFor(Row()); +} + +bool +ARIAGridCellAccessible::Selected() +{ + Accessible* row = Row(); + if (!row) + return false; + + return nsAccUtils::IsARIASelected(row) || nsAccUtils::IsARIASelected(this); +} + +//////////////////////////////////////////////////////////////////////////////// +// Accessible + +void +ARIAGridCellAccessible::ApplyARIAState(uint64_t* aState) const +{ + HyperTextAccessibleWrap::ApplyARIAState(aState); + + // Return if the gridcell has aria-selected="true". + if (*aState & states::SELECTED) + return; + + // Check aria-selected="true" on the row. + Accessible* row = Parent(); + if (!row || row->Role() != roles::ROW) + return; + + nsIContent *rowContent = row->GetContent(); + if (nsAccUtils::HasDefinedARIAToken(rowContent, + nsGkAtoms::aria_selected) && + !rowContent->AttrValueIs(kNameSpaceID_None, + nsGkAtoms::aria_selected, + nsGkAtoms::_false, eCaseMatters)) + *aState |= states::SELECTABLE | states::SELECTED; +} + +already_AddRefed<nsIPersistentProperties> +ARIAGridCellAccessible::NativeAttributes() +{ + nsCOMPtr<nsIPersistentProperties> attributes = + HyperTextAccessibleWrap::NativeAttributes(); + + // Expose "table-cell-index" attribute. + Accessible* thisRow = Row(); + if (!thisRow) + return attributes.forget(); + + int32_t colIdx = 0, colCount = 0; + uint32_t childCount = thisRow->ChildCount(); + for (uint32_t childIdx = 0; childIdx < childCount; childIdx++) { + Accessible* child = thisRow->GetChildAt(childIdx); + if (child == this) + colIdx = colCount; + + roles::Role role = child->Role(); + if (role == roles::CELL || role == roles::GRID_CELL || + role == roles::ROWHEADER || role == roles::COLUMNHEADER) + colCount++; + } + + int32_t rowIdx = RowIndexFor(thisRow); + + nsAutoString stringIdx; + stringIdx.AppendInt(rowIdx * colCount + colIdx); + nsAccUtils::SetAccAttr(attributes, nsGkAtoms::tableCellIndex, stringIdx); + +#ifdef DEBUG + nsAutoString unused; + attributes->SetStringProperty(NS_LITERAL_CSTRING("cppclass"), + NS_LITERAL_STRING("ARIAGridCellAccessible"), + unused); +#endif + + return attributes.forget(); +} + +GroupPos +ARIAGridCellAccessible::GroupPosition() +{ + int32_t count = 0, index = 0; + TableAccessible* table = Table(); + if (table && nsCoreUtils::GetUIntAttr(table->AsAccessible()->GetContent(), + nsGkAtoms::aria_colcount, &count) && + nsCoreUtils::GetUIntAttr(mContent, nsGkAtoms::aria_colindex, &index)) { + return GroupPos(0, index, count); + } + + return GroupPos(); +} diff --git a/accessible/generic/ARIAGridAccessible.h b/accessible/generic/ARIAGridAccessible.h new file mode 100644 index 000000000..c9a36cc6e --- /dev/null +++ b/accessible/generic/ARIAGridAccessible.h @@ -0,0 +1,138 @@ +/* -*- 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 MOZILLA_A11Y_ARIAGridAccessible_h_ +#define MOZILLA_A11Y_ARIAGridAccessible_h_ + +#include "HyperTextAccessibleWrap.h" +#include "TableAccessible.h" +#include "TableCellAccessible.h" + +namespace mozilla { +namespace a11y { + +/** + * Accessible for ARIA grid and treegrid. + */ +class ARIAGridAccessible : public AccessibleWrap, + public TableAccessible +{ +public: + ARIAGridAccessible(nsIContent* aContent, DocAccessible* aDoc); + + NS_DECL_ISUPPORTS_INHERITED + + // Accessible + virtual TableAccessible* AsTable() override { return this; } + + // TableAccessible + virtual uint32_t ColCount() override; + virtual uint32_t RowCount() override; + virtual Accessible* CellAt(uint32_t aRowIndex, uint32_t aColumnIndex) override; + virtual bool IsColSelected(uint32_t aColIdx) override; + virtual bool IsRowSelected(uint32_t aRowIdx) override; + virtual bool IsCellSelected(uint32_t aRowIdx, uint32_t aColIdx) override; + virtual uint32_t SelectedCellCount() override; + virtual uint32_t SelectedColCount() override; + virtual uint32_t SelectedRowCount() override; + virtual void SelectedCells(nsTArray<Accessible*>* aCells) override; + virtual void SelectedCellIndices(nsTArray<uint32_t>* aCells) override; + virtual void SelectedColIndices(nsTArray<uint32_t>* aCols) override; + virtual void SelectedRowIndices(nsTArray<uint32_t>* aRows) override; + virtual void SelectCol(uint32_t aColIdx) override; + virtual void SelectRow(uint32_t aRowIdx) override; + virtual void UnselectCol(uint32_t aColIdx) override; + virtual void UnselectRow(uint32_t aRowIdx) override; + virtual Accessible* AsAccessible() override { return this; } + +protected: + virtual ~ARIAGridAccessible() {} + + /** + * Return row accessible at the given row index. + */ + Accessible* GetRowAt(int32_t aRow); + + /** + * Return cell accessible at the given column index in the row. + */ + Accessible* GetCellInRowAt(Accessible* aRow, int32_t aColumn); + + /** + * Set aria-selected attribute value on DOM node of the given accessible. + * + * @param aAccessible [in] accessible + * @param aIsSelected [in] new value of aria-selected attribute + * @param aNotify [in, optional] specifies if DOM should be notified + * about attribute change (used internally). + */ + nsresult SetARIASelected(Accessible* aAccessible, bool aIsSelected, + bool aNotify = true); +}; + + +/** + * Accessible for ARIA row. + */ +class ARIARowAccessible : public AccessibleWrap +{ +public: + ARIARowAccessible(nsIContent* aContent, DocAccessible* aDoc); + + NS_DECL_ISUPPORTS_INHERITED + + // Accessible + virtual mozilla::a11y::GroupPos GroupPosition() override; + +protected: + virtual ~ARIARowAccessible() {} +}; + + +/** + * Accessible for ARIA gridcell and rowheader/columnheader. + */ +class ARIAGridCellAccessible : public HyperTextAccessibleWrap, + public TableCellAccessible +{ +public: + ARIAGridCellAccessible(nsIContent* aContent, DocAccessible* aDoc); + + NS_DECL_ISUPPORTS_INHERITED + + // Accessible + virtual TableCellAccessible* AsTableCell() override { return this; } + virtual void ApplyARIAState(uint64_t* aState) const override; + virtual already_AddRefed<nsIPersistentProperties> NativeAttributes() override; + virtual mozilla::a11y::GroupPos GroupPosition() override; + +protected: + virtual ~ARIAGridCellAccessible() {} + + /** + * Return a containing row. + */ + Accessible* Row() const + { + Accessible* row = Parent(); + return row && row->IsTableRow() ? row : nullptr; + } + + /** + * Return index of the given row. + */ + int32_t RowIndexFor(Accessible* aRow) const; + + // TableCellAccessible + virtual TableAccessible* Table() const override; + virtual uint32_t ColIdx() const override; + virtual uint32_t RowIdx() const override; + virtual bool Selected() override; +}; + +} // namespace a11y +} // namespace mozilla + +#endif diff --git a/accessible/generic/Accessible-inl.h b/accessible/generic/Accessible-inl.h new file mode 100644 index 000000000..f80056479 --- /dev/null +++ b/accessible/generic/Accessible-inl.h @@ -0,0 +1,135 @@ +/* -*- 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_Accessible_inl_h_ +#define mozilla_a11y_Accessible_inl_h_ + +#include "DocAccessible.h" +#include "ARIAMap.h" +#include "nsCoreUtils.h" + +#ifdef A11Y_LOG +#include "Logging.h" +#endif + +namespace mozilla { +namespace a11y { + +inline mozilla::a11y::role +Accessible::Role() +{ + const nsRoleMapEntry* roleMapEntry = ARIARoleMap(); + if (!roleMapEntry || roleMapEntry->roleRule != kUseMapRole) + return ARIATransformRole(NativeRole()); + + return ARIATransformRole(roleMapEntry->role); +} + +inline bool +Accessible::HasARIARole() const +{ + return mRoleMapEntryIndex != aria::NO_ROLE_MAP_ENTRY_INDEX; +} + +inline bool +Accessible::IsARIARole(nsIAtom* aARIARole) const +{ + const nsRoleMapEntry* roleMapEntry = ARIARoleMap(); + return roleMapEntry && roleMapEntry->Is(aARIARole); +} + +inline bool +Accessible::HasStrongARIARole() const +{ + const nsRoleMapEntry* roleMapEntry = ARIARoleMap(); + return roleMapEntry && roleMapEntry->roleRule == kUseMapRole; +} + +inline const nsRoleMapEntry* +Accessible::ARIARoleMap() const +{ + return aria::GetRoleMapFromIndex(mRoleMapEntryIndex); +} + +inline mozilla::a11y::role +Accessible::ARIARole() +{ + const nsRoleMapEntry* roleMapEntry = ARIARoleMap(); + if (!roleMapEntry || roleMapEntry->roleRule != kUseMapRole) + return mozilla::a11y::roles::NOTHING; + + return ARIATransformRole(roleMapEntry->role); +} + +inline void +Accessible::SetRoleMapEntry(const nsRoleMapEntry* aRoleMapEntry) +{ + mRoleMapEntryIndex = aria::GetIndexFromRoleMap(aRoleMapEntry); +} + +inline bool +Accessible::IsSearchbox() const +{ + const nsRoleMapEntry* roleMapEntry = ARIARoleMap(); + return (roleMapEntry && roleMapEntry->Is(nsGkAtoms::searchbox)) || + (mContent->IsHTMLElement(nsGkAtoms::input) && + mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type, + nsGkAtoms::textInputType, eCaseMatters)); +} + +inline bool +Accessible::HasGenericType(AccGenericType aType) const +{ + const nsRoleMapEntry* roleMapEntry = ARIARoleMap(); + return (mGenericTypes & aType) || + (roleMapEntry && roleMapEntry->IsOfType(aType)); +} + +inline bool +Accessible::HasNumericValue() const +{ + if (mStateFlags & eHasNumericValue) + return true; + + const nsRoleMapEntry* roleMapEntry = ARIARoleMap(); + return roleMapEntry && roleMapEntry->valueRule != eNoValue; +} + +inline void +Accessible::ScrollTo(uint32_t aHow) const +{ + if (mContent) + nsCoreUtils::ScrollTo(mDoc->PresShell(), mContent, aHow); +} + +inline bool +Accessible::InsertAfter(Accessible* aNewChild, Accessible* aRefChild) +{ + MOZ_ASSERT(aNewChild, "No new child to insert"); + + if (aRefChild && aRefChild->Parent() != this) { +#ifdef A11Y_LOG + logging::TreeInfo("broken accessible tree", 0, + "parent", this, "prev sibling parent", + aRefChild->Parent(), "child", aNewChild, nullptr); + if (logging::IsEnabled(logging::eVerbose)) { + logging::Tree("TREE", "Document tree", mDoc); + logging::DOMTree("TREE", "DOM document tree", mDoc); + } +#endif + MOZ_ASSERT_UNREACHABLE("Broken accessible tree"); + mDoc->UnbindFromDocument(aNewChild); + return false; + } + + return InsertChildAt(aRefChild ? aRefChild->IndexInParent() + 1 : 0, + aNewChild); +} + +} // namespace a11y +} // namespace mozilla + +#endif diff --git a/accessible/generic/Accessible.cpp b/accessible/generic/Accessible.cpp new file mode 100644 index 000000000..7ff2f8283 --- /dev/null +++ b/accessible/generic/Accessible.cpp @@ -0,0 +1,2856 @@ +/* -*- 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 "Accessible-inl.h" + +#include "nsIXBLAccessible.h" + +#include "EmbeddedObjCollector.h" +#include "AccGroupInfo.h" +#include "AccIterator.h" +#include "nsAccUtils.h" +#include "nsAccessibilityService.h" +#include "ApplicationAccessible.h" +#include "NotificationController.h" +#include "nsEventShell.h" +#include "nsTextEquivUtils.h" +#include "DocAccessibleChild.h" +#include "EventTree.h" +#include "Relation.h" +#include "Role.h" +#include "RootAccessible.h" +#include "States.h" +#include "StyleInfo.h" +#include "TableAccessible.h" +#include "TableCellAccessible.h" +#include "TreeWalker.h" + +#include "nsIDOMElement.h" +#include "nsIDOMNodeFilter.h" +#include "nsIDOMHTMLElement.h" +#include "nsIDOMKeyEvent.h" +#include "nsIDOMTreeWalker.h" +#include "nsIDOMXULButtonElement.h" +#include "nsIDOMXULDocument.h" +#include "nsIDOMXULElement.h" +#include "nsIDOMXULLabelElement.h" +#include "nsIDOMXULSelectCntrlEl.h" +#include "nsIDOMXULSelectCntrlItemEl.h" +#include "nsPIDOMWindow.h" + +#include "nsIDocument.h" +#include "nsIContent.h" +#include "nsIForm.h" +#include "nsIFormControl.h" + +#include "nsDeckFrame.h" +#include "nsLayoutUtils.h" +#include "nsIPresShell.h" +#include "nsIStringBundle.h" +#include "nsPresContext.h" +#include "nsIFrame.h" +#include "nsView.h" +#include "nsIDocShellTreeItem.h" +#include "nsIScrollableFrame.h" +#include "nsFocusManager.h" + +#include "nsXPIDLString.h" +#include "nsUnicharUtils.h" +#include "nsReadableUtils.h" +#include "prdtoa.h" +#include "nsIAtom.h" +#include "nsIURI.h" +#include "nsArrayUtils.h" +#include "nsIMutableArray.h" +#include "nsIObserverService.h" +#include "nsIServiceManager.h" +#include "nsWhitespaceTokenizer.h" +#include "nsAttrName.h" + +#ifdef DEBUG +#include "nsIDOMCharacterData.h" +#endif + +#include "mozilla/Assertions.h" +#include "mozilla/BasicEvents.h" +#include "mozilla/EventStates.h" +#include "mozilla/FloatingPoint.h" +#include "mozilla/MouseEvents.h" +#include "mozilla/Unused.h" +#include "mozilla/Preferences.h" +#include "mozilla/dom/CanvasRenderingContext2D.h" +#include "mozilla/dom/Element.h" +#include "mozilla/dom/HTMLCanvasElement.h" +#include "mozilla/dom/HTMLBodyElement.h" +#include "mozilla/dom/TreeWalker.h" + +using namespace mozilla; +using namespace mozilla::a11y; + + +//////////////////////////////////////////////////////////////////////////////// +// Accessible: nsISupports and cycle collection + +NS_IMPL_CYCLE_COLLECTION_CLASS(Accessible) +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(Accessible) + tmp->Shutdown(); +NS_IMPL_CYCLE_COLLECTION_UNLINK_END +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(Accessible) +NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mContent, mDoc) +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Accessible) + if (aIID.Equals(NS_GET_IID(Accessible))) + foundInterface = this; + else + NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, Accessible) +NS_INTERFACE_MAP_END + +NS_IMPL_CYCLE_COLLECTING_ADDREF(Accessible) +NS_IMPL_CYCLE_COLLECTING_RELEASE_WITH_DESTROY(Accessible, LastRelease()) + +Accessible::Accessible(nsIContent* aContent, DocAccessible* aDoc) : + mContent(aContent), mDoc(aDoc), + mParent(nullptr), mIndexInParent(-1), + mRoleMapEntryIndex(aria::NO_ROLE_MAP_ENTRY_INDEX), + mStateFlags(0), mContextFlags(0), mType(0), mGenericTypes(0), + mReorderEventTarget(false), mShowEventTarget(false), mHideEventTarget(false) +{ + mBits.groupInfo = nullptr; + mInt.mIndexOfEmbeddedChild = -1; +} + +Accessible::~Accessible() +{ + NS_ASSERTION(!mDoc, "LastRelease was never called!?!"); +} + +ENameValueFlag +Accessible::Name(nsString& aName) +{ + aName.Truncate(); + + if (!HasOwnContent()) + return eNameOK; + + ARIAName(aName); + if (!aName.IsEmpty()) + return eNameOK; + + nsCOMPtr<nsIXBLAccessible> xblAccessible(do_QueryInterface(mContent)); + if (xblAccessible) { + xblAccessible->GetAccessibleName(aName); + if (!aName.IsEmpty()) + return eNameOK; + } + + ENameValueFlag nameFlag = NativeName(aName); + if (!aName.IsEmpty()) + return nameFlag; + + // In the end get the name from tooltip. + if (mContent->IsHTMLElement()) { + if (mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::title, aName)) { + aName.CompressWhitespace(); + return eNameFromTooltip; + } + } else if (mContent->IsXULElement()) { + if (mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::tooltiptext, aName)) { + aName.CompressWhitespace(); + return eNameFromTooltip; + } + } else if (mContent->IsSVGElement()) { + // If user agents need to choose among multiple ‘desc’ or ‘title’ elements + // for processing, the user agent shall choose the first one. + for (nsIContent* childElm = mContent->GetFirstChild(); childElm; + childElm = childElm->GetNextSibling()) { + if (childElm->IsSVGElement(nsGkAtoms::desc)) { + nsTextEquivUtils::AppendTextEquivFromContent(this, childElm, &aName); + return eNameFromTooltip; + } + } + } + + if (nameFlag != eNoNameOnPurpose) + aName.SetIsVoid(true); + + return nameFlag; +} + +void +Accessible::Description(nsString& aDescription) +{ + // There are 4 conditions that make an accessible have no accDescription: + // 1. it's a text node; or + // 2. It has no DHTML describedby property + // 3. it doesn't have an accName; or + // 4. its title attribute already equals to its accName nsAutoString name; + + if (!HasOwnContent() || mContent->IsNodeOfType(nsINode::eTEXT)) + return; + + nsTextEquivUtils:: + GetTextEquivFromIDRefs(this, nsGkAtoms::aria_describedby, + aDescription); + + if (aDescription.IsEmpty()) { + NativeDescription(aDescription); + + if (aDescription.IsEmpty()) { + // Keep the Name() method logic. + if (mContent->IsHTMLElement()) { + mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::title, aDescription); + } else if (mContent->IsXULElement()) { + mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::tooltiptext, aDescription); + } else if (mContent->IsSVGElement()) { + for (nsIContent* childElm = mContent->GetFirstChild(); childElm; + childElm = childElm->GetNextSibling()) { + if (childElm->IsSVGElement(nsGkAtoms::desc)) { + nsTextEquivUtils::AppendTextEquivFromContent(this, childElm, + &aDescription); + break; + } + } + } + } + } + + if (!aDescription.IsEmpty()) { + aDescription.CompressWhitespace(); + nsAutoString name; + Name(name); + // Don't expose a description if it is the same as the name. + if (aDescription.Equals(name)) + aDescription.Truncate(); + } +} + +KeyBinding +Accessible::AccessKey() const +{ + if (!HasOwnContent()) + return KeyBinding(); + + uint32_t key = nsCoreUtils::GetAccessKeyFor(mContent); + if (!key && mContent->IsElement()) { + Accessible* label = nullptr; + + // Copy access key from label node. + if (mContent->IsHTMLElement()) { + // Unless it is labeled via an ancestor <label>, in which case that would + // be redundant. + HTMLLabelIterator iter(Document(), this, + HTMLLabelIterator::eSkipAncestorLabel); + label = iter.Next(); + + } else if (mContent->IsXULElement()) { + XULLabelIterator iter(Document(), mContent); + label = iter.Next(); + } + + if (label) + key = nsCoreUtils::GetAccessKeyFor(label->GetContent()); + } + + if (!key) + return KeyBinding(); + + // Get modifier mask. Use ui.key.generalAccessKey (unless it is -1). + switch (Preferences::GetInt("ui.key.generalAccessKey", -1)) { + case -1: + break; + case nsIDOMKeyEvent::DOM_VK_SHIFT: + return KeyBinding(key, KeyBinding::kShift); + case nsIDOMKeyEvent::DOM_VK_CONTROL: + return KeyBinding(key, KeyBinding::kControl); + case nsIDOMKeyEvent::DOM_VK_ALT: + return KeyBinding(key, KeyBinding::kAlt); + case nsIDOMKeyEvent::DOM_VK_META: + return KeyBinding(key, KeyBinding::kMeta); + default: + return KeyBinding(); + } + + // Determine the access modifier used in this context. + nsIDocument* document = mContent->GetUncomposedDoc(); + if (!document) + return KeyBinding(); + + nsCOMPtr<nsIDocShellTreeItem> treeItem(document->GetDocShell()); + if (!treeItem) + return KeyBinding(); + + nsresult rv = NS_ERROR_FAILURE; + int32_t modifierMask = 0; + switch (treeItem->ItemType()) { + case nsIDocShellTreeItem::typeChrome: + rv = Preferences::GetInt("ui.key.chromeAccess", &modifierMask); + break; + case nsIDocShellTreeItem::typeContent: + rv = Preferences::GetInt("ui.key.contentAccess", &modifierMask); + break; + } + + return NS_SUCCEEDED(rv) ? KeyBinding(key, modifierMask) : KeyBinding(); +} + +KeyBinding +Accessible::KeyboardShortcut() const +{ + return KeyBinding(); +} + +void +Accessible::TranslateString(const nsString& aKey, nsAString& aStringOut) +{ + nsCOMPtr<nsIStringBundleService> stringBundleService = + services::GetStringBundleService(); + if (!stringBundleService) + return; + + nsCOMPtr<nsIStringBundle> stringBundle; + stringBundleService->CreateBundle( + "chrome://global-platform/locale/accessible.properties", + getter_AddRefs(stringBundle)); + if (!stringBundle) + return; + + nsXPIDLString xsValue; + nsresult rv = stringBundle->GetStringFromName(aKey.get(), getter_Copies(xsValue)); + if (NS_SUCCEEDED(rv)) + aStringOut.Assign(xsValue); +} + +uint64_t +Accessible::VisibilityState() +{ + nsIFrame* frame = GetFrame(); + if (!frame) + return states::INVISIBLE; + + // Walk the parent frame chain to see if there's invisible parent or the frame + // is in background tab. + if (!frame->StyleVisibility()->IsVisible()) + return states::INVISIBLE; + + nsIFrame* curFrame = frame; + do { + nsView* view = curFrame->GetView(); + if (view && view->GetVisibility() == nsViewVisibility_kHide) + return states::INVISIBLE; + + if (nsLayoutUtils::IsPopup(curFrame)) + return 0; + + // Offscreen state for background tab content and invisible for not selected + // deck panel. + nsIFrame* parentFrame = curFrame->GetParent(); + nsDeckFrame* deckFrame = do_QueryFrame(parentFrame); + if (deckFrame && deckFrame->GetSelectedBox() != curFrame) { + if (deckFrame->GetContent()->IsXULElement(nsGkAtoms::tabpanels)) + return states::OFFSCREEN; + + NS_NOTREACHED("Children of not selected deck panel are not accessible."); + return states::INVISIBLE; + } + + // If contained by scrollable frame then check that at least 12 pixels + // around the object is visible, otherwise the object is offscreen. + nsIScrollableFrame* scrollableFrame = do_QueryFrame(parentFrame); + if (scrollableFrame) { + nsRect scrollPortRect = scrollableFrame->GetScrollPortRect(); + nsRect frameRect = nsLayoutUtils::TransformFrameRectToAncestor( + frame, frame->GetRectRelativeToSelf(), parentFrame); + if (!scrollPortRect.Contains(frameRect)) { + const nscoord kMinPixels = nsPresContext::CSSPixelsToAppUnits(12); + scrollPortRect.Deflate(kMinPixels, kMinPixels); + if (!scrollPortRect.Intersects(frameRect)) + return states::OFFSCREEN; + } + } + + if (!parentFrame) { + parentFrame = nsLayoutUtils::GetCrossDocParentFrame(curFrame); + if (parentFrame && !parentFrame->StyleVisibility()->IsVisible()) + return states::INVISIBLE; + } + + curFrame = parentFrame; + } while (curFrame); + + // Zero area rects can occur in the first frame of a multi-frame text flow, + // in which case the rendered text is not empty and the frame should not be + // marked invisible. + // XXX Can we just remove this check? Why do we need to mark empty + // text invisible? + if (frame->GetType() == nsGkAtoms::textFrame && + !(frame->GetStateBits() & NS_FRAME_OUT_OF_FLOW) && + frame->GetRect().IsEmpty()) { + nsIFrame::RenderedText text = frame->GetRenderedText(0, + UINT32_MAX, nsIFrame::TextOffsetType::OFFSETS_IN_CONTENT_TEXT, + nsIFrame::TrailingWhitespace::DONT_TRIM_TRAILING_WHITESPACE); + if (text.mString.IsEmpty()) { + return states::INVISIBLE; + } + } + + return 0; +} + +uint64_t +Accessible::NativeState() +{ + uint64_t state = 0; + + if (!IsInDocument()) + state |= states::STALE; + + if (HasOwnContent() && mContent->IsElement()) { + EventStates elementState = mContent->AsElement()->State(); + + if (elementState.HasState(NS_EVENT_STATE_INVALID)) + state |= states::INVALID; + + if (elementState.HasState(NS_EVENT_STATE_REQUIRED)) + state |= states::REQUIRED; + + state |= NativeInteractiveState(); + if (FocusMgr()->IsFocused(this)) + state |= states::FOCUSED; + } + + // Gather states::INVISIBLE and states::OFFSCREEN flags for this object. + state |= VisibilityState(); + + nsIFrame *frame = GetFrame(); + if (frame) { + if (frame->GetStateBits() & NS_FRAME_OUT_OF_FLOW) + state |= states::FLOATING; + + // XXX we should look at layout for non XUL box frames, but need to decide + // how that interacts with ARIA. + if (HasOwnContent() && mContent->IsXULElement() && frame->IsXULBoxFrame()) { + const nsStyleXUL* xulStyle = frame->StyleXUL(); + if (xulStyle && frame->IsXULBoxFrame()) { + // In XUL all boxes are either vertical or horizontal + if (xulStyle->mBoxOrient == StyleBoxOrient::Vertical) + state |= states::VERTICAL; + else + state |= states::HORIZONTAL; + } + } + } + + // Check if a XUL element has the popup attribute (an attached popup menu). + if (HasOwnContent() && mContent->IsXULElement() && + mContent->HasAttr(kNameSpaceID_None, nsGkAtoms::popup)) + state |= states::HASPOPUP; + + // Bypass the link states specialization for non links. + const nsRoleMapEntry* roleMapEntry = ARIARoleMap(); + if (!roleMapEntry || roleMapEntry->roleRule == kUseNativeRole || + roleMapEntry->role == roles::LINK) + state |= NativeLinkState(); + + return state; +} + +uint64_t +Accessible::NativeInteractiveState() const +{ + if (!mContent->IsElement()) + return 0; + + if (NativelyUnavailable()) + return states::UNAVAILABLE; + + nsIFrame* frame = GetFrame(); + if (frame && frame->IsFocusable()) + return states::FOCUSABLE; + + return 0; +} + +uint64_t +Accessible::NativeLinkState() const +{ + return 0; +} + +bool +Accessible::NativelyUnavailable() const +{ + if (mContent->IsHTMLElement()) + return mContent->AsElement()->State().HasState(NS_EVENT_STATE_DISABLED); + + return mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::disabled, + nsGkAtoms::_true, eCaseMatters); +} + +Accessible* +Accessible::FocusedChild() +{ + Accessible* focus = FocusMgr()->FocusedAccessible(); + if (focus && (focus == this || focus->Parent() == this)) + return focus; + + return nullptr; +} + +Accessible* +Accessible::ChildAtPoint(int32_t aX, int32_t aY, + EWhichChildAtPoint aWhichChild) +{ + // If we can't find the point in a child, we will return the fallback answer: + // we return |this| if the point is within it, otherwise nullptr. + Accessible* fallbackAnswer = nullptr; + nsIntRect rect = Bounds(); + if (aX >= rect.x && aX < rect.x + rect.width && + aY >= rect.y && aY < rect.y + rect.height) + fallbackAnswer = this; + + if (nsAccUtils::MustPrune(this)) // Do not dig any further + return fallbackAnswer; + + // Search an accessible at the given point starting from accessible document + // because containing block (see CSS2) for out of flow element (for example, + // absolutely positioned element) may be different from its DOM parent and + // therefore accessible for containing block may be different from accessible + // for DOM parent but GetFrameForPoint() should be called for containing block + // to get an out of flow element. + DocAccessible* accDocument = Document(); + NS_ENSURE_TRUE(accDocument, nullptr); + + nsIFrame* rootFrame = accDocument->GetFrame(); + NS_ENSURE_TRUE(rootFrame, nullptr); + + nsIFrame* startFrame = rootFrame; + + // Check whether the point is at popup content. + nsIWidget* rootWidget = rootFrame->GetView()->GetNearestWidget(nullptr); + NS_ENSURE_TRUE(rootWidget, nullptr); + + LayoutDeviceIntRect rootRect = rootWidget->GetScreenBounds(); + + WidgetMouseEvent dummyEvent(true, eMouseMove, rootWidget, + WidgetMouseEvent::eSynthesized); + dummyEvent.mRefPoint = LayoutDeviceIntPoint(aX - rootRect.x, aY - rootRect.y); + + nsIFrame* popupFrame = nsLayoutUtils:: + GetPopupFrameForEventCoordinates(accDocument->PresContext()->GetRootPresContext(), + &dummyEvent); + if (popupFrame) { + // If 'this' accessible is not inside the popup then ignore the popup when + // searching an accessible at point. + DocAccessible* popupDoc = + GetAccService()->GetDocAccessible(popupFrame->GetContent()->OwnerDoc()); + Accessible* popupAcc = + popupDoc->GetAccessibleOrContainer(popupFrame->GetContent()); + Accessible* popupChild = this; + while (popupChild && !popupChild->IsDoc() && popupChild != popupAcc) + popupChild = popupChild->Parent(); + + if (popupChild == popupAcc) + startFrame = popupFrame; + } + + nsPresContext* presContext = startFrame->PresContext(); + nsRect screenRect = startFrame->GetScreenRectInAppUnits(); + nsPoint offset(presContext->DevPixelsToAppUnits(aX) - screenRect.x, + presContext->DevPixelsToAppUnits(aY) - screenRect.y); + nsIFrame* foundFrame = nsLayoutUtils::GetFrameForPoint(startFrame, offset); + + nsIContent* content = nullptr; + if (!foundFrame || !(content = foundFrame->GetContent())) + return fallbackAnswer; + + // Get accessible for the node with the point or the first accessible in + // the DOM parent chain. + DocAccessible* contentDocAcc = GetAccService()-> + GetDocAccessible(content->OwnerDoc()); + + // contentDocAcc in some circumstances can be nullptr. See bug 729861 + NS_ASSERTION(contentDocAcc, "could not get the document accessible"); + if (!contentDocAcc) + return fallbackAnswer; + + Accessible* accessible = contentDocAcc->GetAccessibleOrContainer(content); + if (!accessible) + return fallbackAnswer; + + // Hurray! We have an accessible for the frame that layout gave us. + // Since DOM node of obtained accessible may be out of flow then we should + // ensure obtained accessible is a child of this accessible. + Accessible* child = accessible; + while (child != this) { + Accessible* parent = child->Parent(); + if (!parent) { + // Reached the top of the hierarchy. These bounds were inside an + // accessible that is not a descendant of this one. + return fallbackAnswer; + } + + // If we landed on a legitimate child of |this|, and we want the direct + // child, return it here. + if (parent == this && aWhichChild == eDirectChild) + return child; + + child = parent; + } + + // Manually walk through accessible children and see if the are within this + // point. Skip offscreen or invisible accessibles. This takes care of cases + // where layout won't walk into things for us, such as image map areas and + // sub documents (XXX: subdocuments should be handled by methods of + // OuterDocAccessibles). + uint32_t childCount = accessible->ChildCount(); + for (uint32_t childIdx = 0; childIdx < childCount; childIdx++) { + Accessible* child = accessible->GetChildAt(childIdx); + + nsIntRect childRect = child->Bounds(); + if (aX >= childRect.x && aX < childRect.x + childRect.width && + aY >= childRect.y && aY < childRect.y + childRect.height && + (child->State() & states::INVISIBLE) == 0) { + + if (aWhichChild == eDeepestChild) + return child->ChildAtPoint(aX, aY, eDeepestChild); + + return child; + } + } + + return accessible; +} + +nsRect +Accessible::RelativeBounds(nsIFrame** aBoundingFrame) const +{ + nsIFrame* frame = GetFrame(); + if (frame && mContent) { + bool* hasHitRegionRect = static_cast<bool*>(mContent->GetProperty(nsGkAtoms::hitregion)); + + if (hasHitRegionRect && mContent->IsElement()) { + // This is for canvas fallback content + // Find a canvas frame the found hit region is relative to. + nsIFrame* canvasFrame = frame->GetParent(); + if (canvasFrame) { + canvasFrame = nsLayoutUtils::GetClosestFrameOfType(canvasFrame, nsGkAtoms::HTMLCanvasFrame); + } + + // make the canvas the bounding frame + if (canvasFrame) { + *aBoundingFrame = canvasFrame; + dom::HTMLCanvasElement *canvas = + dom::HTMLCanvasElement::FromContent(canvasFrame->GetContent()); + + // get the bounding rect of the hit region + nsRect bounds; + if (canvas && canvas->CountContexts() && + canvas->GetContextAtIndex(0)->GetHitRegionRect(mContent->AsElement(), bounds)) { + return bounds; + } + } + } + + *aBoundingFrame = nsLayoutUtils::GetContainingBlockForClientRect(frame); + return nsLayoutUtils:: + GetAllInFlowRectsUnion(frame, *aBoundingFrame, + nsLayoutUtils::RECTS_ACCOUNT_FOR_TRANSFORMS); + } + + return nsRect(); +} + +nsIntRect +Accessible::Bounds() const +{ + nsIFrame* boundingFrame = nullptr; + nsRect unionRectTwips = RelativeBounds(&boundingFrame); + if (!boundingFrame) + return nsIntRect(); + + nsIntRect screenRect; + nsPresContext* presContext = mDoc->PresContext(); + screenRect.x = presContext->AppUnitsToDevPixels(unionRectTwips.x); + screenRect.y = presContext->AppUnitsToDevPixels(unionRectTwips.y); + screenRect.width = presContext->AppUnitsToDevPixels(unionRectTwips.width); + screenRect.height = presContext->AppUnitsToDevPixels(unionRectTwips.height); + + // We have the union of the rectangle, now we need to put it in absolute + // screen coords. + nsIntRect orgRectPixels = boundingFrame->GetScreenRectInAppUnits(). + ToNearestPixels(presContext->AppUnitsPerDevPixel()); + screenRect.x += orgRectPixels.x; + screenRect.y += orgRectPixels.y; + + return screenRect; +} + +void +Accessible::SetSelected(bool aSelect) +{ + if (!HasOwnContent()) + return; + + Accessible* select = nsAccUtils::GetSelectableContainer(this, State()); + if (select) { + if (select->State() & states::MULTISELECTABLE) { + if (ARIARoleMap()) { + if (aSelect) { + mContent->SetAttr(kNameSpaceID_None, nsGkAtoms::aria_selected, + NS_LITERAL_STRING("true"), true); + } else { + mContent->UnsetAttr(kNameSpaceID_None, nsGkAtoms::aria_selected, true); + } + } + return; + } + + if (aSelect) + TakeFocus(); + } +} + +void +Accessible::TakeSelection() +{ + Accessible* select = nsAccUtils::GetSelectableContainer(this, State()); + if (select) { + if (select->State() & states::MULTISELECTABLE) + select->UnselectAll(); + SetSelected(true); + } +} + +void +Accessible::TakeFocus() +{ + nsIFrame* frame = GetFrame(); + if (!frame) + return; + + nsIContent* focusContent = mContent; + + // If the accessible focus is managed by container widget then focus the + // widget and set the accessible as its current item. + if (!frame->IsFocusable()) { + Accessible* widget = ContainerWidget(); + if (widget && widget->AreItemsOperable()) { + nsIContent* widgetElm = widget->GetContent(); + nsIFrame* widgetFrame = widgetElm->GetPrimaryFrame(); + if (widgetFrame && widgetFrame->IsFocusable()) { + focusContent = widgetElm; + widget->SetCurrentItem(this); + } + } + } + + nsCOMPtr<nsIDOMElement> element(do_QueryInterface(focusContent)); + nsFocusManager* fm = nsFocusManager::GetFocusManager(); + if (fm) + fm->SetFocus(element, 0); +} + +void +Accessible::XULElmName(DocAccessible* aDocument, + nsIContent* aElm, nsString& aName) +{ + /** + * 3 main cases for XUL Controls to be labeled + * 1 - control contains label="foo" + * 2 - control has, as a child, a label element + * - label has either value="foo" or children + * 3 - non-child label contains control="controlID" + * - label has either value="foo" or children + * Once a label is found, the search is discontinued, so a control + * that has a label child as well as having a label external to + * the control that uses the control="controlID" syntax will use + * the child label for its Name. + */ + + // CASE #1 (via label attribute) -- great majority of the cases + nsCOMPtr<nsIDOMXULLabeledControlElement> labeledEl = do_QueryInterface(aElm); + if (labeledEl) { + labeledEl->GetLabel(aName); + } else { + nsCOMPtr<nsIDOMXULSelectControlItemElement> itemEl = do_QueryInterface(aElm); + if (itemEl) { + itemEl->GetLabel(aName); + } else { + nsCOMPtr<nsIDOMXULSelectControlElement> select = do_QueryInterface(aElm); + // Use label if this is not a select control element which + // uses label attribute to indicate which option is selected + if (!select) { + nsCOMPtr<nsIDOMXULElement> xulEl(do_QueryInterface(aElm)); + if (xulEl) + xulEl->GetAttribute(NS_LITERAL_STRING("label"), aName); + } + } + } + + // CASES #2 and #3 ------ label as a child or <label control="id" ... > </label> + if (aName.IsEmpty()) { + Accessible* labelAcc = nullptr; + XULLabelIterator iter(aDocument, aElm); + while ((labelAcc = iter.Next())) { + nsCOMPtr<nsIDOMXULLabelElement> xulLabel = + do_QueryInterface(labelAcc->GetContent()); + // Check if label's value attribute is used + if (xulLabel && NS_SUCCEEDED(xulLabel->GetValue(aName)) && aName.IsEmpty()) { + // If no value attribute, a non-empty label must contain + // children that define its text -- possibly using HTML + nsTextEquivUtils:: + AppendTextEquivFromContent(labelAcc, labelAcc->GetContent(), &aName); + } + } + } + + aName.CompressWhitespace(); + if (!aName.IsEmpty()) + return; + + // Can get text from title of <toolbaritem> if we're a child of a <toolbaritem> + nsIContent *bindingParent = aElm->GetBindingParent(); + nsIContent* parent = + bindingParent? bindingParent->GetParent() : aElm->GetParent(); + nsAutoString ancestorTitle; + while (parent) { + if (parent->IsXULElement(nsGkAtoms::toolbaritem) && + parent->GetAttr(kNameSpaceID_None, nsGkAtoms::title, ancestorTitle)) { + // Before returning this, check if the element itself has a tooltip: + if (aElm->GetAttr(kNameSpaceID_None, nsGkAtoms::tooltiptext, aName)) { + aName.CompressWhitespace(); + return; + } + + aName.Assign(ancestorTitle); + aName.CompressWhitespace(); + return; + } + parent = parent->GetParent(); + } +} + +nsresult +Accessible::HandleAccEvent(AccEvent* aEvent) +{ + NS_ENSURE_ARG_POINTER(aEvent); + + if (IPCAccessibilityActive() && Document()) { + DocAccessibleChild* ipcDoc = mDoc->IPCDoc(); + MOZ_ASSERT(ipcDoc); + if (ipcDoc) { + uint64_t id = aEvent->GetAccessible()->IsDoc() ? 0 : + reinterpret_cast<uintptr_t>(aEvent->GetAccessible()); + + switch(aEvent->GetEventType()) { + case nsIAccessibleEvent::EVENT_SHOW: + ipcDoc->ShowEvent(downcast_accEvent(aEvent)); + break; + + case nsIAccessibleEvent::EVENT_HIDE: + ipcDoc->SendHideEvent(id, aEvent->IsFromUserInput()); + break; + + case nsIAccessibleEvent::EVENT_REORDER: + // reorder events on the application acc aren't necessary to tell the parent + // about new top level documents. + if (!aEvent->GetAccessible()->IsApplication()) + ipcDoc->SendEvent(id, aEvent->GetEventType()); + break; + case nsIAccessibleEvent::EVENT_STATE_CHANGE: { + AccStateChangeEvent* event = downcast_accEvent(aEvent); + ipcDoc->SendStateChangeEvent(id, event->GetState(), + event->IsStateEnabled()); + break; + } + case nsIAccessibleEvent::EVENT_TEXT_CARET_MOVED: { + AccCaretMoveEvent* event = downcast_accEvent(aEvent); + ipcDoc->SendCaretMoveEvent(id, event->GetCaretOffset()); + break; + } + case nsIAccessibleEvent::EVENT_TEXT_INSERTED: + case nsIAccessibleEvent::EVENT_TEXT_REMOVED: { + AccTextChangeEvent* event = downcast_accEvent(aEvent); + ipcDoc->SendTextChangeEvent(id, event->ModifiedText(), + event->GetStartOffset(), + event->GetLength(), + event->IsTextInserted(), + event->IsFromUserInput()); + break; + } + case nsIAccessibleEvent::EVENT_SELECTION: + case nsIAccessibleEvent::EVENT_SELECTION_ADD: + case nsIAccessibleEvent::EVENT_SELECTION_REMOVE: { + AccSelChangeEvent* selEvent = downcast_accEvent(aEvent); + uint64_t widgetID = selEvent->Widget()->IsDoc() ? 0 : + reinterpret_cast<uintptr_t>(selEvent->Widget()); + ipcDoc->SendSelectionEvent(id, widgetID, aEvent->GetEventType()); + break; + } + default: + ipcDoc->SendEvent(id, aEvent->GetEventType()); + } + } + } + + if (nsCoreUtils::AccEventObserversExist()) { + nsCoreUtils::DispatchAccEvent(MakeXPCEvent(aEvent)); + } + + return NS_OK; +} + +already_AddRefed<nsIPersistentProperties> +Accessible::Attributes() +{ + nsCOMPtr<nsIPersistentProperties> attributes = NativeAttributes(); + if (!HasOwnContent() || !mContent->IsElement()) + return attributes.forget(); + + // 'xml-roles' attribute for landmark. + nsIAtom* landmark = LandmarkRole(); + if (landmark) { + nsAccUtils::SetAccAttr(attributes, nsGkAtoms::xmlroles, landmark); + + } else { + // 'xml-roles' attribute coming from ARIA. + nsAutoString xmlRoles; + if (mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::role, xmlRoles)) + nsAccUtils::SetAccAttr(attributes, nsGkAtoms::xmlroles, xmlRoles); + } + + // Expose object attributes from ARIA attributes. + nsAutoString unused; + aria::AttrIterator attribIter(mContent); + nsAutoString name, value; + while(attribIter.Next(name, value)) + attributes->SetStringProperty(NS_ConvertUTF16toUTF8(name), value, unused); + + if (IsARIAHidden()) { + nsAccUtils::SetAccAttr(attributes, nsGkAtoms::hidden, + NS_LITERAL_STRING("true")); + } + + // If there is no aria-live attribute then expose default value of 'live' + // object attribute used for ARIA role of this accessible. + const nsRoleMapEntry* roleMapEntry = ARIARoleMap(); + if (roleMapEntry) { + if (roleMapEntry->Is(nsGkAtoms::searchbox)) { + nsAccUtils::SetAccAttr(attributes, nsGkAtoms::textInputType, + NS_LITERAL_STRING("search")); + } + + nsAutoString live; + nsAccUtils::GetAccAttr(attributes, nsGkAtoms::live, live); + if (live.IsEmpty()) { + if (nsAccUtils::GetLiveAttrValue(roleMapEntry->liveAttRule, live)) + nsAccUtils::SetAccAttr(attributes, nsGkAtoms::live, live); + } + } + + return attributes.forget(); +} + +already_AddRefed<nsIPersistentProperties> +Accessible::NativeAttributes() +{ + nsCOMPtr<nsIPersistentProperties> attributes = + do_CreateInstance(NS_PERSISTENTPROPERTIES_CONTRACTID); + + nsAutoString unused; + + // We support values, so expose the string value as well, via the valuetext + // object attribute. We test for the value interface because we don't want + // to expose traditional Value() information such as URL's on links and + // documents, or text in an input. + if (HasNumericValue()) { + nsAutoString valuetext; + Value(valuetext); + attributes->SetStringProperty(NS_LITERAL_CSTRING("valuetext"), valuetext, + unused); + } + + // Expose checkable object attribute if the accessible has checkable state + if (State() & states::CHECKABLE) { + nsAccUtils::SetAccAttr(attributes, nsGkAtoms::checkable, + NS_LITERAL_STRING("true")); + } + + // Expose 'explicit-name' attribute. + nsAutoString name; + if (Name(name) != eNameFromSubtree && !name.IsVoid()) { + attributes->SetStringProperty(NS_LITERAL_CSTRING("explicit-name"), + NS_LITERAL_STRING("true"), unused); + } + + // Group attributes (level/setsize/posinset) + GroupPos groupPos = GroupPosition(); + nsAccUtils::SetAccGroupAttrs(attributes, groupPos.level, + groupPos.setSize, groupPos.posInSet); + + // If the accessible doesn't have own content (such as list item bullet or + // xul tree item) then don't calculate content based attributes. + if (!HasOwnContent()) + return attributes.forget(); + + nsEventShell::GetEventAttributes(GetNode(), attributes); + + // Get container-foo computed live region properties based on the closest + // container with the live region attribute. Inner nodes override outer nodes + // within the same document. The inner nodes can be used to override live + // region behavior on more general outer nodes. However, nodes in outer + // documents override nodes in inner documents: outer doc author may want to + // override properties on a widget they used in an iframe. + nsIContent* startContent = mContent; + while (startContent) { + nsIDocument* doc = startContent->GetComposedDoc(); + if (!doc) + break; + + nsAccUtils::SetLiveContainerAttributes(attributes, startContent, + doc->GetRootElement()); + + // Allow ARIA live region markup from outer documents to override + nsCOMPtr<nsIDocShellTreeItem> docShellTreeItem = doc->GetDocShell(); + if (!docShellTreeItem) + break; + + nsCOMPtr<nsIDocShellTreeItem> sameTypeParent; + docShellTreeItem->GetSameTypeParent(getter_AddRefs(sameTypeParent)); + if (!sameTypeParent || sameTypeParent == docShellTreeItem) + break; + + nsIDocument* parentDoc = doc->GetParentDocument(); + if (!parentDoc) + break; + + startContent = parentDoc->FindContentForSubDocument(doc); + } + + if (!mContent->IsElement()) + return attributes.forget(); + + nsAutoString id; + if (nsCoreUtils::GetID(mContent, id)) + attributes->SetStringProperty(NS_LITERAL_CSTRING("id"), id, unused); + + // Expose class because it may have useful microformat information. + nsAutoString _class; + if (mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::_class, _class)) + nsAccUtils::SetAccAttr(attributes, nsGkAtoms::_class, _class); + + // Expose tag. + nsAutoString tagName; + mContent->NodeInfo()->GetName(tagName); + nsAccUtils::SetAccAttr(attributes, nsGkAtoms::tag, tagName); + + // Expose draggable object attribute. + nsCOMPtr<nsIDOMHTMLElement> htmlElement = do_QueryInterface(mContent); + if (htmlElement) { + bool draggable = false; + htmlElement->GetDraggable(&draggable); + if (draggable) { + nsAccUtils::SetAccAttr(attributes, nsGkAtoms::draggable, + NS_LITERAL_STRING("true")); + } + } + + // Don't calculate CSS-based object attributes when no frame (i.e. + // the accessible is unattached from the tree). + if (!mContent->GetPrimaryFrame()) + return attributes.forget(); + + // CSS style based object attributes. + nsAutoString value; + StyleInfo styleInfo(mContent->AsElement(), mDoc->PresShell()); + + // Expose 'display' attribute. + styleInfo.Display(value); + nsAccUtils::SetAccAttr(attributes, nsGkAtoms::display, value); + + // Expose 'text-align' attribute. + styleInfo.TextAlign(value); + nsAccUtils::SetAccAttr(attributes, nsGkAtoms::textAlign, value); + + // Expose 'text-indent' attribute. + styleInfo.TextIndent(value); + nsAccUtils::SetAccAttr(attributes, nsGkAtoms::textIndent, value); + + // Expose 'margin-left' attribute. + styleInfo.MarginLeft(value); + nsAccUtils::SetAccAttr(attributes, nsGkAtoms::marginLeft, value); + + // Expose 'margin-right' attribute. + styleInfo.MarginRight(value); + nsAccUtils::SetAccAttr(attributes, nsGkAtoms::marginRight, value); + + // Expose 'margin-top' attribute. + styleInfo.MarginTop(value); + nsAccUtils::SetAccAttr(attributes, nsGkAtoms::marginTop, value); + + // Expose 'margin-bottom' attribute. + styleInfo.MarginBottom(value); + nsAccUtils::SetAccAttr(attributes, nsGkAtoms::marginBottom, value); + + return attributes.forget(); +} + +GroupPos +Accessible::GroupPosition() +{ + GroupPos groupPos; + if (!HasOwnContent()) + return groupPos; + + // Get group position from ARIA attributes. + nsCoreUtils::GetUIntAttr(mContent, nsGkAtoms::aria_level, &groupPos.level); + nsCoreUtils::GetUIntAttr(mContent, nsGkAtoms::aria_setsize, &groupPos.setSize); + nsCoreUtils::GetUIntAttr(mContent, nsGkAtoms::aria_posinset, &groupPos.posInSet); + + // If ARIA is missed and the accessible is visible then calculate group + // position from hierarchy. + if (State() & states::INVISIBLE) + return groupPos; + + // Calculate group level if ARIA is missed. + if (groupPos.level == 0) { + int32_t level = GetLevelInternal(); + if (level != 0) + groupPos.level = level; + } + + // Calculate position in group and group size if ARIA is missed. + if (groupPos.posInSet == 0 || groupPos.setSize == 0) { + int32_t posInSet = 0, setSize = 0; + GetPositionAndSizeInternal(&posInSet, &setSize); + if (posInSet != 0 && setSize != 0) { + if (groupPos.posInSet == 0) + groupPos.posInSet = posInSet; + + if (groupPos.setSize == 0) + groupPos.setSize = setSize; + } + } + + return groupPos; +} + +uint64_t +Accessible::State() +{ + if (IsDefunct()) + return states::DEFUNCT; + + uint64_t state = NativeState(); + // Apply ARIA states to be sure accessible states will be overridden. + ApplyARIAState(&state); + + // If this is an ARIA item of the selectable widget and if it's focused and + // not marked unselected explicitly (i.e. aria-selected="false") then expose + // it as selected to make ARIA widget authors life easier. + const nsRoleMapEntry* roleMapEntry = ARIARoleMap(); + if (roleMapEntry && !(state & states::SELECTED) && + !mContent->AttrValueIs(kNameSpaceID_None, + nsGkAtoms::aria_selected, + nsGkAtoms::_false, eCaseMatters)) { + // Special case for tabs: focused tab or focus inside related tab panel + // implies selected state. + if (roleMapEntry->role == roles::PAGETAB) { + if (state & states::FOCUSED) { + state |= states::SELECTED; + } else { + // If focus is in a child of the tab panel surely the tab is selected! + Relation rel = RelationByType(RelationType::LABEL_FOR); + Accessible* relTarget = nullptr; + while ((relTarget = rel.Next())) { + if (relTarget->Role() == roles::PROPERTYPAGE && + FocusMgr()->IsFocusWithin(relTarget)) + state |= states::SELECTED; + } + } + } else if (state & states::FOCUSED) { + Accessible* container = nsAccUtils::GetSelectableContainer(this, state); + if (container && + !nsAccUtils::HasDefinedARIAToken(container->GetContent(), + nsGkAtoms::aria_multiselectable)) { + state |= states::SELECTED; + } + } + } + + const uint32_t kExpandCollapseStates = states::COLLAPSED | states::EXPANDED; + if ((state & kExpandCollapseStates) == kExpandCollapseStates) { + // Cannot be both expanded and collapsed -- this happens in ARIA expanded + // combobox because of limitation of ARIAMap. + // XXX: Perhaps we will be able to make this less hacky if we support + // extended states in ARIAMap, e.g. derive COLLAPSED from + // EXPANDABLE && !EXPANDED. + state &= ~states::COLLAPSED; + } + + if (!(state & states::UNAVAILABLE)) { + state |= states::ENABLED | states::SENSITIVE; + + // If the object is a current item of container widget then mark it as + // ACTIVE. This allows screen reader virtual buffer modes to know which + // descendant is the current one that would get focus if the user navigates + // to the container widget. + Accessible* widget = ContainerWidget(); + if (widget && widget->CurrentItem() == this) + state |= states::ACTIVE; + } + + if ((state & states::COLLAPSED) || (state & states::EXPANDED)) + state |= states::EXPANDABLE; + + // For some reasons DOM node may have not a frame. We tract such accessibles + // as invisible. + nsIFrame *frame = GetFrame(); + if (!frame) + return state; + + if (frame->StyleEffects()->mOpacity == 1.0f && + !(state & states::INVISIBLE)) { + state |= states::OPAQUE1; + } + + return state; +} + +void +Accessible::ApplyARIAState(uint64_t* aState) const +{ + if (!mContent->IsElement()) + return; + + dom::Element* element = mContent->AsElement(); + + // Test for universal states first + *aState |= aria::UniversalStatesFor(element); + + const nsRoleMapEntry* roleMapEntry = ARIARoleMap(); + if (roleMapEntry) { + + // We only force the readonly bit off if we have a real mapping for the aria + // role. This preserves the ability for screen readers to use readonly + // (primarily on the document) as the hint for creating a virtual buffer. + if (roleMapEntry->role != roles::NOTHING) + *aState &= ~states::READONLY; + + if (mContent->HasID()) { + // If has a role & ID and aria-activedescendant on the container, assume + // focusable. + const Accessible* ancestor = this; + while ((ancestor = ancestor->Parent()) && !ancestor->IsDoc()) { + dom::Element* el = ancestor->Elm(); + if (el && + el->HasAttr(kNameSpaceID_None, nsGkAtoms::aria_activedescendant)) { + *aState |= states::FOCUSABLE; + break; + } + } + } + } + + if (*aState & states::FOCUSABLE) { + // Propogate aria-disabled from ancestors down to any focusable descendant. + const Accessible* ancestor = this; + while ((ancestor = ancestor->Parent()) && !ancestor->IsDoc()) { + dom::Element* el = ancestor->Elm(); + if (el && el->AttrValueIs(kNameSpaceID_None, nsGkAtoms::aria_disabled, + nsGkAtoms::_true, eCaseMatters)) { + *aState |= states::UNAVAILABLE; + break; + } + } + } + + // special case: A native button element whose role got transformed by ARIA to a toggle button + // Also applies to togglable button menus, like in the Dev Tools Web Console. + if (IsButton() || IsMenuButton()) + aria::MapToState(aria::eARIAPressed, element, aState); + + if (!roleMapEntry) + return; + + *aState |= roleMapEntry->state; + + if (aria::MapToState(roleMapEntry->attributeMap1, element, aState) && + aria::MapToState(roleMapEntry->attributeMap2, element, aState) && + aria::MapToState(roleMapEntry->attributeMap3, element, aState)) + aria::MapToState(roleMapEntry->attributeMap4, element, aState); + + // ARIA gridcell inherits editable/readonly states from the grid until it's + // overridden. + if ((roleMapEntry->Is(nsGkAtoms::gridcell) || + roleMapEntry->Is(nsGkAtoms::columnheader) || + roleMapEntry->Is(nsGkAtoms::rowheader)) && + !(*aState & (states::READONLY | states::EDITABLE))) { + const TableCellAccessible* cell = AsTableCell(); + if (cell) { + TableAccessible* table = cell->Table(); + if (table) { + Accessible* grid = table->AsAccessible(); + uint64_t gridState = 0; + grid->ApplyARIAState(&gridState); + *aState |= (gridState & (states::READONLY | states::EDITABLE)); + } + } + } +} + +void +Accessible::Value(nsString& aValue) +{ + const nsRoleMapEntry* roleMapEntry = ARIARoleMap(); + if (!roleMapEntry) + return; + + if (roleMapEntry->valueRule != eNoValue) { + // aria-valuenow is a number, and aria-valuetext is the optional text + // equivalent. For the string value, we will try the optional text + // equivalent first. + if (!mContent->GetAttr(kNameSpaceID_None, + nsGkAtoms::aria_valuetext, aValue)) { + mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::aria_valuenow, + aValue); + } + return; + } + + // Value of textbox is a textified subtree. + if (roleMapEntry->Is(nsGkAtoms::textbox)) { + nsTextEquivUtils::GetTextEquivFromSubtree(this, aValue); + return; + } + + // Value of combobox is a text of current or selected item. + if (roleMapEntry->Is(nsGkAtoms::combobox)) { + Accessible* option = CurrentItem(); + if (!option) { + uint32_t childCount = ChildCount(); + for (uint32_t idx = 0; idx < childCount; idx++) { + Accessible* child = mChildren.ElementAt(idx); + if (child->IsListControl()) { + option = child->GetSelectedItem(0); + break; + } + } + } + + if (option) + nsTextEquivUtils::GetTextEquivFromSubtree(option, aValue); + } +} + +double +Accessible::MaxValue() const +{ + return AttrNumericValue(nsGkAtoms::aria_valuemax); +} + +double +Accessible::MinValue() const +{ + return AttrNumericValue(nsGkAtoms::aria_valuemin); +} + +double +Accessible::Step() const +{ + return UnspecifiedNaN<double>(); // no mimimum increment (step) in ARIA. +} + +double +Accessible::CurValue() const +{ + return AttrNumericValue(nsGkAtoms::aria_valuenow); +} + +bool +Accessible::SetCurValue(double aValue) +{ + const nsRoleMapEntry* roleMapEntry = ARIARoleMap(); + if (!roleMapEntry || roleMapEntry->valueRule == eNoValue) + return false; + + const uint32_t kValueCannotChange = states::READONLY | states::UNAVAILABLE; + if (State() & kValueCannotChange) + return false; + + double checkValue = MinValue(); + if (!IsNaN(checkValue) && aValue < checkValue) + return false; + + checkValue = MaxValue(); + if (!IsNaN(checkValue) && aValue > checkValue) + return false; + + nsAutoString strValue; + strValue.AppendFloat(aValue); + + return NS_SUCCEEDED( + mContent->SetAttr(kNameSpaceID_None, nsGkAtoms::aria_valuenow, strValue, true)); +} + +role +Accessible::ARIATransformRole(role aRole) +{ + // XXX: these unfortunate exceptions don't fit into the ARIA table. This is + // where the accessible role depends on both the role and ARIA state. + if (aRole == roles::PUSHBUTTON) { + if (nsAccUtils::HasDefinedARIAToken(mContent, nsGkAtoms::aria_pressed)) { + // For simplicity, any existing pressed attribute except "" or "undefined" + // indicates a toggle. + return roles::TOGGLE_BUTTON; + } + + if (mContent->AttrValueIs(kNameSpaceID_None, + nsGkAtoms::aria_haspopup, + nsGkAtoms::_true, + eCaseMatters)) { + // For button with aria-haspopup="true". + return roles::BUTTONMENU; + } + + } else if (aRole == roles::LISTBOX) { + // A listbox inside of a combobox needs a special role because of ATK + // mapping to menu. + if (mParent && mParent->Role() == roles::COMBOBOX) { + return roles::COMBOBOX_LIST; + } else { + // Listbox is owned by a combobox + Relation rel = RelationByType(RelationType::NODE_CHILD_OF); + Accessible* targetAcc = nullptr; + while ((targetAcc = rel.Next())) + if (targetAcc->Role() == roles::COMBOBOX) + return roles::COMBOBOX_LIST; + } + + } else if (aRole == roles::OPTION) { + if (mParent && mParent->Role() == roles::COMBOBOX_LIST) + return roles::COMBOBOX_OPTION; + + } else if (aRole == roles::MENUITEM) { + // Menuitem has a submenu. + if (mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::aria_haspopup, + nsGkAtoms::_true, eCaseMatters)) { + return roles::PARENT_MENUITEM; + } + } + + return aRole; +} + +nsIAtom* +Accessible::LandmarkRole() const +{ + const nsRoleMapEntry* roleMapEntry = ARIARoleMap(); + return roleMapEntry && roleMapEntry->IsOfType(eLandmark) ? + *(roleMapEntry->roleAtom) : nullptr; +} + +role +Accessible::NativeRole() +{ + return roles::NOTHING; +} + +uint8_t +Accessible::ActionCount() +{ + return GetActionRule() == eNoAction ? 0 : 1; +} + +void +Accessible::ActionNameAt(uint8_t aIndex, nsAString& aName) +{ + aName.Truncate(); + + if (aIndex != 0) + return; + + uint32_t actionRule = GetActionRule(); + + switch (actionRule) { + case eActivateAction: + aName.AssignLiteral("activate"); + return; + + case eClickAction: + aName.AssignLiteral("click"); + return; + + case ePressAction: + aName.AssignLiteral("press"); + return; + + case eCheckUncheckAction: + { + uint64_t state = State(); + if (state & states::CHECKED) + aName.AssignLiteral("uncheck"); + else if (state & states::MIXED) + aName.AssignLiteral("cycle"); + else + aName.AssignLiteral("check"); + return; + } + + case eJumpAction: + aName.AssignLiteral("jump"); + return; + + case eOpenCloseAction: + if (State() & states::COLLAPSED) + aName.AssignLiteral("open"); + else + aName.AssignLiteral("close"); + return; + + case eSelectAction: + aName.AssignLiteral("select"); + return; + + case eSwitchAction: + aName.AssignLiteral("switch"); + return; + + case eSortAction: + aName.AssignLiteral("sort"); + return; + + case eExpandAction: + if (State() & states::COLLAPSED) + aName.AssignLiteral("expand"); + else + aName.AssignLiteral("collapse"); + return; + } +} + +bool +Accessible::DoAction(uint8_t aIndex) +{ + if (aIndex != 0) + return false; + + if (GetActionRule() != eNoAction) { + DoCommand(); + return true; + } + + return false; +} + +nsIContent* +Accessible::GetAtomicRegion() const +{ + nsIContent *loopContent = mContent; + nsAutoString atomic; + while (loopContent && !loopContent->GetAttr(kNameSpaceID_None, nsGkAtoms::aria_atomic, atomic)) + loopContent = loopContent->GetParent(); + + return atomic.EqualsLiteral("true") ? loopContent : nullptr; +} + +Relation +Accessible::RelationByType(RelationType aType) +{ + if (!HasOwnContent()) + return Relation(); + + const nsRoleMapEntry* roleMapEntry = ARIARoleMap(); + + // Relationships are defined on the same content node that the role would be + // defined on. + switch (aType) { + case RelationType::LABELLED_BY: { + Relation rel(new IDRefsIterator(mDoc, mContent, + nsGkAtoms::aria_labelledby)); + if (mContent->IsHTMLElement()) { + rel.AppendIter(new HTMLLabelIterator(Document(), this)); + } else if (mContent->IsXULElement()) { + rel.AppendIter(new XULLabelIterator(Document(), mContent)); + } + + return rel; + } + + case RelationType::LABEL_FOR: { + Relation rel(new RelatedAccIterator(Document(), mContent, + nsGkAtoms::aria_labelledby)); + if (mContent->IsXULElement(nsGkAtoms::label)) + rel.AppendIter(new IDRefsIterator(mDoc, mContent, nsGkAtoms::control)); + + return rel; + } + + case RelationType::DESCRIBED_BY: { + Relation rel(new IDRefsIterator(mDoc, mContent, + nsGkAtoms::aria_describedby)); + if (mContent->IsXULElement()) + rel.AppendIter(new XULDescriptionIterator(Document(), mContent)); + + return rel; + } + + case RelationType::DESCRIPTION_FOR: { + Relation rel(new RelatedAccIterator(Document(), mContent, + nsGkAtoms::aria_describedby)); + + // This affectively adds an optional control attribute to xul:description, + // which only affects accessibility, by allowing the description to be + // tied to a control. + if (mContent->IsXULElement(nsGkAtoms::description)) + rel.AppendIter(new IDRefsIterator(mDoc, mContent, + nsGkAtoms::control)); + + return rel; + } + + case RelationType::NODE_CHILD_OF: { + Relation rel; + // This is an ARIA tree or treegrid that doesn't use owns, so we need to + // get the parent the hard way. + if (roleMapEntry && (roleMapEntry->role == roles::OUTLINEITEM || + roleMapEntry->role == roles::LISTITEM || + roleMapEntry->role == roles::ROW)) { + rel.AppendTarget(GetGroupInfo()->ConceptualParent()); + } + + // If accessible is in its own Window, or is the root of a document, + // then we should provide NODE_CHILD_OF relation so that MSAA clients + // can easily get to true parent instead of getting to oleacc's + // ROLE_WINDOW accessible which will prevent us from going up further + // (because it is system generated and has no idea about the hierarchy + // above it). + nsIFrame *frame = GetFrame(); + if (frame) { + nsView *view = frame->GetView(); + if (view) { + nsIScrollableFrame *scrollFrame = do_QueryFrame(frame); + if (scrollFrame || view->GetWidget() || !frame->GetParent()) + rel.AppendTarget(Parent()); + } + } + + return rel; + } + + case RelationType::NODE_PARENT_OF: { + // ARIA tree or treegrid can do the hierarchy by @aria-level, ARIA trees + // also can be organized by groups. + if (roleMapEntry && + (roleMapEntry->role == roles::OUTLINEITEM || + roleMapEntry->role == roles::LISTITEM || + roleMapEntry->role == roles::ROW || + roleMapEntry->role == roles::OUTLINE || + roleMapEntry->role == roles::LIST || + roleMapEntry->role == roles::TREE_TABLE)) { + return Relation(new ItemIterator(this)); + } + + return Relation(); + } + + case RelationType::CONTROLLED_BY: + return Relation(new RelatedAccIterator(Document(), mContent, + nsGkAtoms::aria_controls)); + + case RelationType::CONTROLLER_FOR: { + Relation rel(new IDRefsIterator(mDoc, mContent, + nsGkAtoms::aria_controls)); + rel.AppendIter(new HTMLOutputIterator(Document(), mContent)); + return rel; + } + + case RelationType::FLOWS_TO: + return Relation(new IDRefsIterator(mDoc, mContent, + nsGkAtoms::aria_flowto)); + + case RelationType::FLOWS_FROM: + return Relation(new RelatedAccIterator(Document(), mContent, + nsGkAtoms::aria_flowto)); + + case RelationType::MEMBER_OF: + return Relation(mDoc, GetAtomicRegion()); + + case RelationType::SUBWINDOW_OF: + case RelationType::EMBEDS: + case RelationType::EMBEDDED_BY: + case RelationType::POPUP_FOR: + case RelationType::PARENT_WINDOW_OF: + return Relation(); + + case RelationType::DEFAULT_BUTTON: { + if (mContent->IsHTMLElement()) { + // HTML form controls implements nsIFormControl interface. + nsCOMPtr<nsIFormControl> control(do_QueryInterface(mContent)); + if (control) { + nsCOMPtr<nsIForm> form(do_QueryInterface(control->GetFormElement())); + if (form) { + nsCOMPtr<nsIContent> formContent = + do_QueryInterface(form->GetDefaultSubmitElement()); + return Relation(mDoc, formContent); + } + } + } else { + // In XUL, use first <button default="true" .../> in the document + nsCOMPtr<nsIDOMXULDocument> xulDoc = + do_QueryInterface(mContent->OwnerDoc()); + nsCOMPtr<nsIDOMXULButtonElement> buttonEl; + if (xulDoc) { + nsCOMPtr<nsIDOMNodeList> possibleDefaultButtons; + xulDoc->GetElementsByAttribute(NS_LITERAL_STRING("default"), + NS_LITERAL_STRING("true"), + getter_AddRefs(possibleDefaultButtons)); + if (possibleDefaultButtons) { + uint32_t length; + possibleDefaultButtons->GetLength(&length); + nsCOMPtr<nsIDOMNode> possibleButton; + // Check for button in list of default="true" elements + for (uint32_t count = 0; count < length && !buttonEl; count ++) { + possibleDefaultButtons->Item(count, getter_AddRefs(possibleButton)); + buttonEl = do_QueryInterface(possibleButton); + } + } + if (!buttonEl) { // Check for anonymous accept button in <dialog> + dom::Element* rootElm = mContent->OwnerDoc()->GetRootElement(); + if (rootElm) { + nsIContent* possibleButtonEl = rootElm->OwnerDoc()-> + GetAnonymousElementByAttribute(rootElm, nsGkAtoms::_default, + NS_LITERAL_STRING("true")); + buttonEl = do_QueryInterface(possibleButtonEl); + } + } + nsCOMPtr<nsIContent> relatedContent(do_QueryInterface(buttonEl)); + return Relation(mDoc, relatedContent); + } + } + return Relation(); + } + + case RelationType::CONTAINING_DOCUMENT: + return Relation(mDoc); + + case RelationType::CONTAINING_TAB_PANE: { + nsCOMPtr<nsIDocShell> docShell = + nsCoreUtils::GetDocShellFor(GetNode()); + if (docShell) { + // Walk up the parent chain without crossing the boundary at which item + // types change, preventing us from walking up out of tab content. + nsCOMPtr<nsIDocShellTreeItem> root; + docShell->GetSameTypeRootTreeItem(getter_AddRefs(root)); + if (root) { + // If the item type is typeContent, we assume we are in browser tab + // content. Note, this includes content such as about:addons, + // for consistency. + if (root->ItemType() == nsIDocShellTreeItem::typeContent) { + return Relation(nsAccUtils::GetDocAccessibleFor(root)); + } + } + } + return Relation(); + } + + case RelationType::CONTAINING_APPLICATION: + return Relation(ApplicationAcc()); + + case RelationType::DETAILS: + return Relation(new IDRefsIterator(mDoc, mContent, nsGkAtoms::aria_details)); + + case RelationType::DETAILS_FOR: + return Relation(new RelatedAccIterator(mDoc, mContent, nsGkAtoms::aria_details)); + + case RelationType::ERRORMSG: + return Relation(new IDRefsIterator(mDoc, mContent, nsGkAtoms::aria_errormessage)); + + case RelationType::ERRORMSG_FOR: + return Relation(new RelatedAccIterator(mDoc, mContent, nsGkAtoms::aria_errormessage)); + + default: + return Relation(); + } +} + +void +Accessible::GetNativeInterface(void** aNativeAccessible) +{ +} + +void +Accessible::DoCommand(nsIContent *aContent, uint32_t aActionIndex) +{ + class Runnable final : public mozilla::Runnable + { + public: + Runnable(Accessible* aAcc, nsIContent* aContent, uint32_t aIdx) : + mAcc(aAcc), mContent(aContent), mIdx(aIdx) { } + + NS_IMETHOD Run() override + { + if (mAcc) + mAcc->DispatchClickEvent(mContent, mIdx); + + return NS_OK; + } + + void Revoke() + { + mAcc = nullptr; + mContent = nullptr; + } + + private: + RefPtr<Accessible> mAcc; + nsCOMPtr<nsIContent> mContent; + uint32_t mIdx; + }; + + nsIContent* content = aContent ? aContent : mContent.get(); + nsCOMPtr<nsIRunnable> runnable = new Runnable(this, content, aActionIndex); + NS_DispatchToMainThread(runnable); +} + +void +Accessible::DispatchClickEvent(nsIContent *aContent, uint32_t aActionIndex) +{ + if (IsDefunct()) + return; + + nsCOMPtr<nsIPresShell> presShell = mDoc->PresShell(); + + // Scroll into view. + presShell->ScrollContentIntoView(aContent, + nsIPresShell::ScrollAxis(), + nsIPresShell::ScrollAxis(), + nsIPresShell::SCROLL_OVERFLOW_HIDDEN); + + nsWeakFrame frame = aContent->GetPrimaryFrame(); + if (!frame) + return; + + // Compute x and y coordinates. + nsPoint point; + nsCOMPtr<nsIWidget> widget = frame->GetNearestWidget(point); + if (!widget) + return; + + nsSize size = frame->GetSize(); + + RefPtr<nsPresContext> presContext = presShell->GetPresContext(); + int32_t x = presContext->AppUnitsToDevPixels(point.x + size.width / 2); + int32_t y = presContext->AppUnitsToDevPixels(point.y + size.height / 2); + + // Simulate a touch interaction by dispatching touch events with mouse events. + nsCoreUtils::DispatchTouchEvent(eTouchStart, x, y, aContent, frame, + presShell, widget); + nsCoreUtils::DispatchMouseEvent(eMouseDown, x, y, aContent, frame, + presShell, widget); + nsCoreUtils::DispatchTouchEvent(eTouchEnd, x, y, aContent, frame, + presShell, widget); + nsCoreUtils::DispatchMouseEvent(eMouseUp, x, y, aContent, frame, + presShell, widget); +} + +void +Accessible::ScrollToPoint(uint32_t aCoordinateType, int32_t aX, int32_t aY) +{ + nsIFrame* frame = GetFrame(); + if (!frame) + return; + + nsIntPoint coords = + nsAccUtils::ConvertToScreenCoords(aX, aY, aCoordinateType, this); + + nsIFrame* parentFrame = frame; + while ((parentFrame = parentFrame->GetParent())) + nsCoreUtils::ScrollFrameToPoint(parentFrame, frame, coords); +} + +void +Accessible::AppendTextTo(nsAString& aText, uint32_t aStartOffset, + uint32_t aLength) +{ + // Return text representation of non-text accessible within hypertext + // accessible. Text accessible overrides this method to return enclosed text. + if (aStartOffset != 0 || aLength == 0) + return; + + nsIFrame *frame = GetFrame(); + if (!frame) + return; + + NS_ASSERTION(mParent, + "Called on accessible unbound from tree. Result can be wrong."); + + if (frame->GetType() == nsGkAtoms::brFrame) { + aText += kForcedNewLineChar; + } else if (mParent && nsAccUtils::MustPrune(mParent)) { + // Expose the embedded object accessible as imaginary embedded object + // character if its parent hypertext accessible doesn't expose children to + // AT. + aText += kImaginaryEmbeddedObjectChar; + } else { + aText += kEmbeddedObjectChar; + } +} + +void +Accessible::Shutdown() +{ + // Mark the accessible as defunct, invalidate the child count and pointers to + // other accessibles, also make sure none of its children point to this parent + mStateFlags |= eIsDefunct; + + int32_t childCount = mChildren.Length(); + for (int32_t childIdx = 0; childIdx < childCount; childIdx++) { + mChildren.ElementAt(childIdx)->UnbindFromParent(); + } + mChildren.Clear(); + + mEmbeddedObjCollector = nullptr; + + if (mParent) + mParent->RemoveChild(this); + + mContent = nullptr; + mDoc = nullptr; + if (SelectionMgr() && SelectionMgr()->AccessibleWithCaret(nullptr) == this) + SelectionMgr()->ResetCaretOffset(); +} + +// Accessible protected +void +Accessible::ARIAName(nsString& aName) +{ + // aria-labelledby now takes precedence over aria-label + nsresult rv = nsTextEquivUtils:: + GetTextEquivFromIDRefs(this, nsGkAtoms::aria_labelledby, aName); + if (NS_SUCCEEDED(rv)) { + aName.CompressWhitespace(); + } + + if (aName.IsEmpty() && + mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::aria_label, aName)) { + aName.CompressWhitespace(); + } +} + +// Accessible protected +ENameValueFlag +Accessible::NativeName(nsString& aName) +{ + if (mContent->IsHTMLElement()) { + Accessible* label = nullptr; + HTMLLabelIterator iter(Document(), this); + while ((label = iter.Next())) { + nsTextEquivUtils::AppendTextEquivFromContent(this, label->GetContent(), + &aName); + aName.CompressWhitespace(); + } + + if (!aName.IsEmpty()) + return eNameOK; + + nsTextEquivUtils::GetNameFromSubtree(this, aName); + return aName.IsEmpty() ? eNameOK : eNameFromSubtree; + } + + if (mContent->IsXULElement()) { + XULElmName(mDoc, mContent, aName); + if (!aName.IsEmpty()) + return eNameOK; + + nsTextEquivUtils::GetNameFromSubtree(this, aName); + return aName.IsEmpty() ? eNameOK : eNameFromSubtree; + } + + if (mContent->IsSVGElement()) { + // If user agents need to choose among multiple ‘desc’ or ‘title’ elements + // for processing, the user agent shall choose the first one. + for (nsIContent* childElm = mContent->GetFirstChild(); childElm; + childElm = childElm->GetNextSibling()) { + if (childElm->IsSVGElement(nsGkAtoms::title)) { + nsTextEquivUtils::AppendTextEquivFromContent(this, childElm, &aName); + return eNameOK; + } + } + } + + return eNameOK; +} + +// Accessible protected +void +Accessible::NativeDescription(nsString& aDescription) +{ + bool isXUL = mContent->IsXULElement(); + if (isXUL) { + // Try XUL <description control="[id]">description text</description> + XULDescriptionIterator iter(Document(), mContent); + Accessible* descr = nullptr; + while ((descr = iter.Next())) { + nsTextEquivUtils::AppendTextEquivFromContent(this, descr->GetContent(), + &aDescription); + } + } +} + +// Accessible protected +void +Accessible::BindToParent(Accessible* aParent, uint32_t aIndexInParent) +{ + MOZ_ASSERT(aParent, "This method isn't used to set null parent"); + MOZ_ASSERT(!mParent, "The child was expected to be moved"); + +#ifdef A11Y_LOG + if (mParent) { + logging::TreeInfo("BindToParent: stealing accessible", 0, + "old parent", mParent, + "new parent", aParent, + "child", this, nullptr); + } +#endif + + mParent = aParent; + mIndexInParent = aIndexInParent; + + // Note: this is currently only used for richlistitems and their children. + if (mParent->HasNameDependentParent() || mParent->IsXULListItem()) + mContextFlags |= eHasNameDependentParent; + else + mContextFlags &= ~eHasNameDependentParent; + + if (mParent->IsARIAHidden() || aria::HasDefinedARIAHidden(mContent)) + SetARIAHidden(true); + + mContextFlags |= + static_cast<uint32_t>((mParent->IsAlert() || + mParent->IsInsideAlert())) & eInsideAlert; +} + +// Accessible protected +void +Accessible::UnbindFromParent() +{ + mParent = nullptr; + mIndexInParent = -1; + mInt.mIndexOfEmbeddedChild = -1; + if (IsProxy()) + MOZ_CRASH("this should never be called on proxy wrappers"); + + delete mBits.groupInfo; + mBits.groupInfo = nullptr; + mContextFlags &= ~eHasNameDependentParent & ~eInsideAlert; +} + +//////////////////////////////////////////////////////////////////////////////// +// Accessible public methods + +RootAccessible* +Accessible::RootAccessible() const +{ + nsCOMPtr<nsIDocShell> docShell = nsCoreUtils::GetDocShellFor(GetNode()); + NS_ASSERTION(docShell, "No docshell for mContent"); + if (!docShell) { + return nullptr; + } + + nsCOMPtr<nsIDocShellTreeItem> root; + docShell->GetRootTreeItem(getter_AddRefs(root)); + NS_ASSERTION(root, "No root content tree item"); + if (!root) { + return nullptr; + } + + DocAccessible* docAcc = nsAccUtils::GetDocAccessibleFor(root); + return docAcc ? docAcc->AsRoot() : nullptr; +} + +nsIFrame* +Accessible::GetFrame() const +{ + return mContent ? mContent->GetPrimaryFrame() : nullptr; +} + +nsINode* +Accessible::GetNode() const +{ + return mContent; +} + +void +Accessible::Language(nsAString& aLanguage) +{ + aLanguage.Truncate(); + + if (!mDoc) + return; + + nsCoreUtils::GetLanguageFor(mContent, nullptr, aLanguage); + if (aLanguage.IsEmpty()) { // Nothing found, so use document's language + mDoc->DocumentNode()->GetHeaderData(nsGkAtoms::headerContentLanguage, + aLanguage); + } +} + +bool +Accessible::InsertChildAt(uint32_t aIndex, Accessible* aChild) +{ + if (!aChild) + return false; + + if (aIndex == mChildren.Length()) { + if (!mChildren.AppendElement(aChild)) + return false; + + } else { + if (!mChildren.InsertElementAt(aIndex, aChild)) + return false; + + MOZ_ASSERT(mStateFlags & eKidsMutating, "Illicit children change"); + + for (uint32_t idx = aIndex + 1; idx < mChildren.Length(); idx++) { + mChildren[idx]->mIndexInParent = idx; + } + } + + if (aChild->IsText()) { + mStateFlags |= eHasTextKids; + } + + aChild->BindToParent(this, aIndex); + return true; +} + +bool +Accessible::RemoveChild(Accessible* aChild) +{ + if (!aChild) + return false; + + if (aChild->mParent != this || aChild->mIndexInParent == -1) + return false; + + MOZ_ASSERT((mStateFlags & eKidsMutating) || aChild->IsDefunct() || aChild->IsDoc(), + "Illicit children change"); + + int32_t index = static_cast<uint32_t>(aChild->mIndexInParent); + if (mChildren.SafeElementAt(index) != aChild) { + MOZ_ASSERT_UNREACHABLE("A wrong child index"); + index = mChildren.IndexOf(aChild); + if (index == -1) { + MOZ_ASSERT_UNREACHABLE("No child was found"); + return false; + } + } + + aChild->UnbindFromParent(); + mChildren.RemoveElementAt(index); + + for (uint32_t idx = index; idx < mChildren.Length(); idx++) { + mChildren[idx]->mIndexInParent = idx; + } + + return true; +} + +void +Accessible::MoveChild(uint32_t aNewIndex, Accessible* aChild) +{ + MOZ_ASSERT(aChild, "No child was given"); + MOZ_ASSERT(aChild->mParent == this, "A child from different subtree was given"); + MOZ_ASSERT(aChild->mIndexInParent != -1, "Unbound child was given"); + MOZ_ASSERT(static_cast<uint32_t>(aChild->mIndexInParent) != aNewIndex, + "No move, same index"); + MOZ_ASSERT(aNewIndex <= mChildren.Length(), "Wrong new index was given"); + + RefPtr<AccHideEvent> hideEvent = new AccHideEvent(aChild, false); + if (mDoc->Controller()->QueueMutationEvent(hideEvent)) { + aChild->SetHideEventTarget(true); + } + + mEmbeddedObjCollector = nullptr; + mChildren.RemoveElementAt(aChild->mIndexInParent); + + uint32_t startIdx = aNewIndex, endIdx = aChild->mIndexInParent; + + // If the child is moved after its current position. + if (static_cast<uint32_t>(aChild->mIndexInParent) < aNewIndex) { + startIdx = aChild->mIndexInParent; + if (aNewIndex == mChildren.Length() + 1) { + // The child is moved to the end. + mChildren.AppendElement(aChild); + endIdx = mChildren.Length() - 1; + } + else { + mChildren.InsertElementAt(aNewIndex - 1, aChild); + endIdx = aNewIndex; + } + } + else { + // The child is moved prior its current position. + mChildren.InsertElementAt(aNewIndex, aChild); + } + + for (uint32_t idx = startIdx; idx <= endIdx; idx++) { + mChildren[idx]->mIndexInParent = idx; + mChildren[idx]->mStateFlags |= eGroupInfoDirty; + mChildren[idx]->mInt.mIndexOfEmbeddedChild = -1; + } + + RefPtr<AccShowEvent> showEvent = new AccShowEvent(aChild); + DebugOnly<bool> added = mDoc->Controller()->QueueMutationEvent(showEvent); + MOZ_ASSERT(added); + aChild->SetShowEventTarget(true); +} + +Accessible* +Accessible::GetChildAt(uint32_t aIndex) const +{ + Accessible* child = mChildren.SafeElementAt(aIndex, nullptr); + if (!child) + return nullptr; + +#ifdef DEBUG + Accessible* realParent = child->mParent; + NS_ASSERTION(!realParent || realParent == this, + "Two accessibles have the same first child accessible!"); +#endif + + return child; +} + +uint32_t +Accessible::ChildCount() const +{ + return mChildren.Length(); +} + +int32_t +Accessible::IndexInParent() const +{ + return mIndexInParent; +} + +uint32_t +Accessible::EmbeddedChildCount() +{ + if (mStateFlags & eHasTextKids) { + if (!mEmbeddedObjCollector) + mEmbeddedObjCollector.reset(new EmbeddedObjCollector(this)); + return mEmbeddedObjCollector->Count(); + } + + return ChildCount(); +} + +Accessible* +Accessible::GetEmbeddedChildAt(uint32_t aIndex) +{ + if (mStateFlags & eHasTextKids) { + if (!mEmbeddedObjCollector) + mEmbeddedObjCollector.reset(new EmbeddedObjCollector(this)); + return mEmbeddedObjCollector.get() ? + mEmbeddedObjCollector->GetAccessibleAt(aIndex) : nullptr; + } + + return GetChildAt(aIndex); +} + +int32_t +Accessible::GetIndexOfEmbeddedChild(Accessible* aChild) +{ + if (mStateFlags & eHasTextKids) { + if (!mEmbeddedObjCollector) + mEmbeddedObjCollector.reset(new EmbeddedObjCollector(this)); + return mEmbeddedObjCollector.get() ? + mEmbeddedObjCollector->GetIndexAt(aChild) : -1; + } + + return GetIndexOf(aChild); +} + +//////////////////////////////////////////////////////////////////////////////// +// HyperLinkAccessible methods + +bool +Accessible::IsLink() +{ + // Every embedded accessible within hypertext accessible implements + // hyperlink interface. + return mParent && mParent->IsHyperText() && !IsText(); +} + +uint32_t +Accessible::StartOffset() +{ + NS_PRECONDITION(IsLink(), "StartOffset is called not on hyper link!"); + + HyperTextAccessible* hyperText = mParent ? mParent->AsHyperText() : nullptr; + return hyperText ? hyperText->GetChildOffset(this) : 0; +} + +uint32_t +Accessible::EndOffset() +{ + NS_PRECONDITION(IsLink(), "EndOffset is called on not hyper link!"); + + HyperTextAccessible* hyperText = mParent ? mParent->AsHyperText() : nullptr; + return hyperText ? (hyperText->GetChildOffset(this) + 1) : 0; +} + +uint32_t +Accessible::AnchorCount() +{ + NS_PRECONDITION(IsLink(), "AnchorCount is called on not hyper link!"); + return 1; +} + +Accessible* +Accessible::AnchorAt(uint32_t aAnchorIndex) +{ + NS_PRECONDITION(IsLink(), "GetAnchor is called on not hyper link!"); + return aAnchorIndex == 0 ? this : nullptr; +} + +already_AddRefed<nsIURI> +Accessible::AnchorURIAt(uint32_t aAnchorIndex) +{ + NS_PRECONDITION(IsLink(), "AnchorURIAt is called on not hyper link!"); + return nullptr; +} + +void +Accessible::ToTextPoint(HyperTextAccessible** aContainer, int32_t* aOffset, + bool aIsBefore) const +{ + if (IsHyperText()) { + *aContainer = const_cast<Accessible*>(this)->AsHyperText(); + *aOffset = aIsBefore ? 0 : (*aContainer)->CharacterCount(); + return; + } + + const Accessible* child = nullptr; + const Accessible* parent = this; + do { + child = parent; + parent = parent->Parent(); + } while (parent && !parent->IsHyperText()); + + if (parent) { + *aContainer = const_cast<Accessible*>(parent)->AsHyperText(); + *aOffset = (*aContainer)->GetChildOffset( + child->IndexInParent() + static_cast<int32_t>(!aIsBefore)); + } +} + + +//////////////////////////////////////////////////////////////////////////////// +// SelectAccessible + +void +Accessible::SelectedItems(nsTArray<Accessible*>* aItems) +{ + AccIterator iter(this, filters::GetSelected); + Accessible* selected = nullptr; + while ((selected = iter.Next())) + aItems->AppendElement(selected); +} + +uint32_t +Accessible::SelectedItemCount() +{ + uint32_t count = 0; + AccIterator iter(this, filters::GetSelected); + Accessible* selected = nullptr; + while ((selected = iter.Next())) + ++count; + + return count; +} + +Accessible* +Accessible::GetSelectedItem(uint32_t aIndex) +{ + AccIterator iter(this, filters::GetSelected); + Accessible* selected = nullptr; + + uint32_t index = 0; + while ((selected = iter.Next()) && index < aIndex) + index++; + + return selected; +} + +bool +Accessible::IsItemSelected(uint32_t aIndex) +{ + uint32_t index = 0; + AccIterator iter(this, filters::GetSelectable); + Accessible* selected = nullptr; + while ((selected = iter.Next()) && index < aIndex) + index++; + + return selected && + selected->State() & states::SELECTED; +} + +bool +Accessible::AddItemToSelection(uint32_t aIndex) +{ + uint32_t index = 0; + AccIterator iter(this, filters::GetSelectable); + Accessible* selected = nullptr; + while ((selected = iter.Next()) && index < aIndex) + index++; + + if (selected) + selected->SetSelected(true); + + return static_cast<bool>(selected); +} + +bool +Accessible::RemoveItemFromSelection(uint32_t aIndex) +{ + uint32_t index = 0; + AccIterator iter(this, filters::GetSelectable); + Accessible* selected = nullptr; + while ((selected = iter.Next()) && index < aIndex) + index++; + + if (selected) + selected->SetSelected(false); + + return static_cast<bool>(selected); +} + +bool +Accessible::SelectAll() +{ + bool success = false; + Accessible* selectable = nullptr; + + AccIterator iter(this, filters::GetSelectable); + while((selectable = iter.Next())) { + success = true; + selectable->SetSelected(true); + } + return success; +} + +bool +Accessible::UnselectAll() +{ + bool success = false; + Accessible* selected = nullptr; + + AccIterator iter(this, filters::GetSelected); + while ((selected = iter.Next())) { + success = true; + selected->SetSelected(false); + } + return success; +} + +//////////////////////////////////////////////////////////////////////////////// +// Widgets + +bool +Accessible::IsWidget() const +{ + return false; +} + +bool +Accessible::IsActiveWidget() const +{ + if (FocusMgr()->HasDOMFocus(mContent)) + return true; + + // If text entry of combobox widget has a focus then the combobox widget is + // active. + const nsRoleMapEntry* roleMapEntry = ARIARoleMap(); + if (roleMapEntry && roleMapEntry->Is(nsGkAtoms::combobox)) { + uint32_t childCount = ChildCount(); + for (uint32_t idx = 0; idx < childCount; idx++) { + Accessible* child = mChildren.ElementAt(idx); + if (child->Role() == roles::ENTRY) + return FocusMgr()->HasDOMFocus(child->GetContent()); + } + } + + return false; +} + +bool +Accessible::AreItemsOperable() const +{ + return HasOwnContent() && + mContent->HasAttr(kNameSpaceID_None, nsGkAtoms::aria_activedescendant); +} + +Accessible* +Accessible::CurrentItem() +{ + // Check for aria-activedescendant, which changes which element has focus. + // For activedescendant, the ARIA spec does not require that the user agent + // checks whether pointed node is actually a DOM descendant of the element + // with the aria-activedescendant attribute. + nsAutoString id; + if (HasOwnContent() && + mContent->GetAttr(kNameSpaceID_None, + nsGkAtoms::aria_activedescendant, id)) { + nsIDocument* DOMDoc = mContent->OwnerDoc(); + dom::Element* activeDescendantElm = DOMDoc->GetElementById(id); + if (activeDescendantElm) { + DocAccessible* document = Document(); + if (document) + return document->GetAccessible(activeDescendantElm); + } + } + return nullptr; +} + +void +Accessible::SetCurrentItem(Accessible* aItem) +{ + nsIAtom* id = aItem->GetContent()->GetID(); + if (id) { + nsAutoString idStr; + id->ToString(idStr); + mContent->SetAttr(kNameSpaceID_None, + nsGkAtoms::aria_activedescendant, idStr, true); + } +} + +Accessible* +Accessible::ContainerWidget() const +{ + if (HasARIARole() && mContent->HasID()) { + for (Accessible* parent = Parent(); parent; parent = parent->Parent()) { + nsIContent* parentContent = parent->GetContent(); + if (parentContent && + parentContent->HasAttr(kNameSpaceID_None, + nsGkAtoms::aria_activedescendant)) { + return parent; + } + + // Don't cross DOM document boundaries. + if (parent->IsDoc()) + break; + } + } + return nullptr; +} + +void +Accessible::SetARIAHidden(bool aIsDefined) +{ + if (aIsDefined) + mContextFlags |= eARIAHidden; + else + mContextFlags &= ~eARIAHidden; + + uint32_t length = mChildren.Length(); + for (uint32_t i = 0; i < length; i++) { + mChildren[i]->SetARIAHidden(aIsDefined); + } +} + +//////////////////////////////////////////////////////////////////////////////// +// Accessible protected methods + +void +Accessible::LastRelease() +{ + // First cleanup if needed... + if (mDoc) { + Shutdown(); + NS_ASSERTION(!mDoc, + "A Shutdown() impl forgot to call its parent's Shutdown?"); + } + // ... then die. + delete this; +} + +Accessible* +Accessible::GetSiblingAtOffset(int32_t aOffset, nsresult* aError) const +{ + if (!mParent || mIndexInParent == -1) { + if (aError) + *aError = NS_ERROR_UNEXPECTED; + + return nullptr; + } + + if (aError && + mIndexInParent + aOffset >= static_cast<int32_t>(mParent->ChildCount())) { + *aError = NS_OK; // fail peacefully + return nullptr; + } + + Accessible* child = mParent->GetChildAt(mIndexInParent + aOffset); + if (aError && !child) + *aError = NS_ERROR_UNEXPECTED; + + return child; +} + +double +Accessible::AttrNumericValue(nsIAtom* aAttr) const +{ + const nsRoleMapEntry* roleMapEntry = ARIARoleMap(); + if (!roleMapEntry || roleMapEntry->valueRule == eNoValue) + return UnspecifiedNaN<double>(); + + nsAutoString attrValue; + if (!mContent->GetAttr(kNameSpaceID_None, aAttr, attrValue)) + return UnspecifiedNaN<double>(); + + nsresult error = NS_OK; + double value = attrValue.ToDouble(&error); + return NS_FAILED(error) ? UnspecifiedNaN<double>() : value; +} + +uint32_t +Accessible::GetActionRule() const +{ + if (!HasOwnContent() || (InteractiveState() & states::UNAVAILABLE)) + return eNoAction; + + // Return "click" action on elements that have an attached popup menu. + if (mContent->IsXULElement()) + if (mContent->HasAttr(kNameSpaceID_None, nsGkAtoms::popup)) + return eClickAction; + + // Has registered 'click' event handler. + bool isOnclick = nsCoreUtils::HasClickListener(mContent); + + if (isOnclick) + return eClickAction; + + // Get an action based on ARIA role. + const nsRoleMapEntry* roleMapEntry = ARIARoleMap(); + if (roleMapEntry && + roleMapEntry->actionRule != eNoAction) + return roleMapEntry->actionRule; + + // Get an action based on ARIA attribute. + if (nsAccUtils::HasDefinedARIAToken(mContent, + nsGkAtoms::aria_expanded)) + return eExpandAction; + + return eNoAction; +} + +AccGroupInfo* +Accessible::GetGroupInfo() +{ + if (IsProxy()) + MOZ_CRASH("This should never be called on proxy wrappers"); + + if (mBits.groupInfo){ + if (HasDirtyGroupInfo()) { + mBits.groupInfo->Update(); + mStateFlags &= ~eGroupInfoDirty; + } + + return mBits.groupInfo; + } + + mBits.groupInfo = AccGroupInfo::CreateGroupInfo(this); + return mBits.groupInfo; +} + +void +Accessible::GetPositionAndSizeInternal(int32_t *aPosInSet, int32_t *aSetSize) +{ + AccGroupInfo* groupInfo = GetGroupInfo(); + if (groupInfo) { + *aPosInSet = groupInfo->PosInSet(); + *aSetSize = groupInfo->SetSize(); + } +} + +int32_t +Accessible::GetLevelInternal() +{ + int32_t level = nsAccUtils::GetDefaultLevel(this); + + if (!IsBoundToParent()) + return level; + + roles::Role role = Role(); + if (role == roles::OUTLINEITEM) { + // Always expose 'level' attribute for 'outlineitem' accessible. The number + // of nested 'grouping' accessibles containing 'outlineitem' accessible is + // its level. + level = 1; + + Accessible* parent = this; + while ((parent = parent->Parent())) { + roles::Role parentRole = parent->Role(); + + if (parentRole == roles::OUTLINE) + break; + if (parentRole == roles::GROUPING) + ++ level; + + } + + } else if (role == roles::LISTITEM) { + // Expose 'level' attribute on nested lists. We support two hierarchies: + // a) list -> listitem -> list -> listitem (nested list is a last child + // of listitem of the parent list); + // b) list -> listitem -> group -> listitem (nested listitems are contained + // by group that is a last child of the parent listitem). + + // Calculate 'level' attribute based on number of parent listitems. + level = 0; + Accessible* parent = this; + while ((parent = parent->Parent())) { + roles::Role parentRole = parent->Role(); + + if (parentRole == roles::LISTITEM) + ++ level; + else if (parentRole != roles::LIST && parentRole != roles::GROUPING) + break; + } + + if (level == 0) { + // If this listitem is on top of nested lists then expose 'level' + // attribute. + parent = Parent(); + uint32_t siblingCount = parent->ChildCount(); + for (uint32_t siblingIdx = 0; siblingIdx < siblingCount; siblingIdx++) { + Accessible* sibling = parent->GetChildAt(siblingIdx); + + Accessible* siblingChild = sibling->LastChild(); + if (siblingChild) { + roles::Role lastChildRole = siblingChild->Role(); + if (lastChildRole == roles::LIST || lastChildRole == roles::GROUPING) + return 1; + } + } + } else { + ++ level; // level is 1-index based + } + } + + return level; +} + +void +Accessible::StaticAsserts() const +{ + static_assert(eLastStateFlag <= (1 << kStateFlagsBits) - 1, + "Accessible::mStateFlags was oversized by eLastStateFlag!"); + static_assert(eLastAccType <= (1 << kTypeBits) - 1, + "Accessible::mType was oversized by eLastAccType!"); + static_assert(eLastContextFlag <= (1 << kContextFlagsBits) - 1, + "Accessible::mContextFlags was oversized by eLastContextFlag!"); + static_assert(eLastAccGenericType <= (1 << kGenericTypesBits) - 1, + "Accessible::mGenericType was oversized by eLastAccGenericType!"); +} + +//////////////////////////////////////////////////////////////////////////////// +// KeyBinding class + +// static +uint32_t +KeyBinding::AccelModifier() +{ + switch (WidgetInputEvent::AccelModifier()) { + case MODIFIER_ALT: + return kAlt; + case MODIFIER_CONTROL: + return kControl; + case MODIFIER_META: + return kMeta; + case MODIFIER_OS: + return kOS; + default: + MOZ_CRASH("Handle the new result of WidgetInputEvent::AccelModifier()"); + return 0; + } +} + +void +KeyBinding::ToPlatformFormat(nsAString& aValue) const +{ + nsCOMPtr<nsIStringBundle> keyStringBundle; + nsCOMPtr<nsIStringBundleService> stringBundleService = + mozilla::services::GetStringBundleService(); + if (stringBundleService) + stringBundleService->CreateBundle( + "chrome://global-platform/locale/platformKeys.properties", + getter_AddRefs(keyStringBundle)); + + if (!keyStringBundle) + return; + + nsAutoString separator; + keyStringBundle->GetStringFromName(u"MODIFIER_SEPARATOR", + getter_Copies(separator)); + + nsAutoString modifierName; + if (mModifierMask & kControl) { + keyStringBundle->GetStringFromName(u"VK_CONTROL", + getter_Copies(modifierName)); + + aValue.Append(modifierName); + aValue.Append(separator); + } + + if (mModifierMask & kAlt) { + keyStringBundle->GetStringFromName(u"VK_ALT", + getter_Copies(modifierName)); + + aValue.Append(modifierName); + aValue.Append(separator); + } + + if (mModifierMask & kShift) { + keyStringBundle->GetStringFromName(u"VK_SHIFT", + getter_Copies(modifierName)); + + aValue.Append(modifierName); + aValue.Append(separator); + } + + if (mModifierMask & kMeta) { + keyStringBundle->GetStringFromName(u"VK_META", + getter_Copies(modifierName)); + + aValue.Append(modifierName); + aValue.Append(separator); + } + + aValue.Append(mKey); +} + +void +KeyBinding::ToAtkFormat(nsAString& aValue) const +{ + nsAutoString modifierName; + if (mModifierMask & kControl) + aValue.AppendLiteral("<Control>"); + + if (mModifierMask & kAlt) + aValue.AppendLiteral("<Alt>"); + + if (mModifierMask & kShift) + aValue.AppendLiteral("<Shift>"); + + if (mModifierMask & kMeta) + aValue.AppendLiteral("<Meta>"); + + aValue.Append(mKey); +} diff --git a/accessible/generic/Accessible.h b/accessible/generic/Accessible.h new file mode 100644 index 000000000..eaf041920 --- /dev/null +++ b/accessible/generic/Accessible.h @@ -0,0 +1,1269 @@ +/* -*- 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 _Accessible_H_ +#define _Accessible_H_ + +#include "mozilla/a11y/AccTypes.h" +#include "mozilla/a11y/RelationType.h" +#include "mozilla/a11y/Role.h" +#include "mozilla/a11y/States.h" + +#include "mozilla/UniquePtr.h" + +#include "nsIContent.h" +#include "nsIContentInlines.h" +#include "nsString.h" +#include "nsTArray.h" +#include "nsRefPtrHashtable.h" +#include "nsRect.h" + +struct nsRoleMapEntry; + +struct nsRect; +class nsIFrame; +class nsIAtom; +class nsIPersistentProperties; + +namespace mozilla { +namespace a11y { + +class Accessible; +class AccEvent; +class AccGroupInfo; +class ApplicationAccessible; +class DocAccessible; +class EmbeddedObjCollector; +class EventTree; +class HTMLImageMapAccessible; +class HTMLLIAccessible; +class HyperTextAccessible; +class ImageAccessible; +class KeyBinding; +class OuterDocAccessible; +class ProxyAccessible; +class Relation; +class RootAccessible; +class TableAccessible; +class TableCellAccessible; +class TextLeafAccessible; +class XULLabelAccessible; +class XULTreeAccessible; + +#ifdef A11Y_LOG +namespace logging { + typedef const char* (*GetTreePrefix)(void* aData, Accessible*); + void Tree(const char* aTitle, const char* aMsgText, Accessible* aRoot, + GetTreePrefix aPrefixFunc, void* GetTreePrefixData); +}; +#endif + +/** + * Name type flags. + */ +enum ENameValueFlag { + /** + * Name either + * a) present (not empty): !name.IsEmpty() + * b) no name (was missed): name.IsVoid() + */ + eNameOK, + + /** + * Name was left empty by the author on purpose: + * name.IsEmpty() && !name.IsVoid(). + */ + eNoNameOnPurpose, + + /** + * Name was computed from the subtree. + */ + eNameFromSubtree, + + /** + * Tooltip was used as a name. + */ + eNameFromTooltip +}; + +/** + * Group position (level, position in set and set size). + */ +struct GroupPos +{ + GroupPos() : level(0), posInSet(0), setSize(0) { } + GroupPos(int32_t aLevel, int32_t aPosInSet, int32_t aSetSize) : + level(aLevel), posInSet(aPosInSet), setSize(aSetSize) { } + + int32_t level; + int32_t posInSet; + int32_t setSize; +}; + +/** + * An index type. Assert if out of range value was attempted to be used. + */ +class index_t +{ +public: + MOZ_IMPLICIT index_t(int32_t aVal) : mVal(aVal) {} + + operator uint32_t() const + { + MOZ_ASSERT(mVal >= 0, "Attempt to use wrong index!"); + return mVal; + } + + bool IsValid() const { return mVal >= 0; } + +private: + int32_t mVal; +}; + +typedef nsRefPtrHashtable<nsPtrHashKey<const void>, Accessible> + AccessibleHashtable; + + +#define NS_ACCESSIBLE_IMPL_IID \ +{ /* 133c8bf4-4913-4355-bd50-426bd1d6e1ad */ \ + 0x133c8bf4, \ + 0x4913, \ + 0x4355, \ + { 0xbd, 0x50, 0x42, 0x6b, 0xd1, 0xd6, 0xe1, 0xad } \ +} + +class Accessible : public nsISupports +{ +public: + Accessible(nsIContent* aContent, DocAccessible* aDoc); + + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_CLASS(Accessible) + + 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. + */ + virtual nsIFrame* GetFrame() const; + + /** + * Return DOM node associated with the accessible. + */ + virtual nsINode* GetNode() const; + inline already_AddRefed<nsIDOMNode> DOMNode() const + { + nsCOMPtr<nsIDOMNode> DOMNode = do_QueryInterface(GetNode()); + return DOMNode.forget(); + } + nsIContent* GetContent() const { return mContent; } + mozilla::dom::Element* Elm() const + { return mContent && mContent->IsElement() ? mContent->AsElement() : nullptr; } + + /** + * Return node type information of DOM node associated with the accessible. + */ + bool IsContent() const + { return GetNode() && GetNode()->IsNodeOfType(nsINode::eCONTENT); } + + /** + * Return the unique identifier of the accessible. + */ + void* UniqueID() { return static_cast<void*>(this); } + + /** + * Return language associated with the accessible. + */ + void Language(nsAString& aLocale); + + /** + * Get the description of this accessible. + */ + virtual void Description(nsString& aDescription); + + /** + * Get the value of this accessible. + */ + virtual void Value(nsString& aValue); + + /** + * Get help string for the accessible. + */ + void Help(nsString& aHelp) const { aHelp.Truncate(); } + + /** + * Get the name of this accessible. + * + * Note: aName.IsVoid() when name was left empty by the author on purpose. + * aName.IsEmpty() when the author missed name, AT can try to repair a name. + */ + virtual ENameValueFlag Name(nsString& aName); + + /** + * 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). + */ + mozilla::a11y::role Role(); + + /** + * Return true if ARIA role is specified on the element. + */ + bool HasARIARole() const; + bool IsARIARole(nsIAtom* aARIARole) const; + bool HasStrongARIARole() const; + + /** + * Retrun ARIA role map if any. + */ + const nsRoleMapEntry* ARIARoleMap() const; + + /** + * Return accessible role specified by ARIA (see constants in + * roles). + */ + mozilla::a11y::role ARIARole(); + + /** + * Return a landmark role if applied. + */ + virtual nsIAtom* LandmarkRole() const; + + /** + * Returns enumerated accessible role from native markup (see constants in + * Role.h). Doesn't take into account ARIA roles. + */ + virtual mozilla::a11y::role NativeRole(); + + /** + * Return all states of accessible (including ARIA states). + */ + virtual uint64_t State(); + + /** + * 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 if accessible is unavailable. + */ + bool Unavailable() const + { + uint64_t state = NativelyUnavailable() ? states::UNAVAILABLE : 0; + ApplyARIAState(&state); + return state & states::UNAVAILABLE; + } + + /** + * Return the states of accessible, not taking into account ARIA states. + * Use State() to get complete set of states. + */ + virtual uint64_t NativeState(); + + /** + * 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(); + + /** + * Return true if native unavailable state present. + */ + virtual bool NativelyUnavailable() const; + + /** + * Return object attributes for the accessible. + */ + virtual already_AddRefed<nsIPersistentProperties> Attributes(); + + /** + * Return group position (level, position in set and set size). + */ + virtual mozilla::a11y::GroupPos GroupPosition(); + + /** + * Used by ChildAtPoint() method to get direct or deepest child at point. + */ + enum EWhichChildAtPoint { + eDirectChild, + eDeepestChild + }; + + /** + * 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 Accessible* ChildAtPoint(int32_t aX, int32_t aY, + EWhichChildAtPoint aWhichChild); + + /** + * Return the focused child if any. + */ + virtual Accessible* FocusedChild(); + + /** + * Return calculated group level based on accessible hierarchy. + */ + virtual int32_t GetLevelInternal(); + + /** + * Calculate position in group and group size ('posinset' and 'setsize') based + * on accessible hierarchy. + * + * @param aPosInSet [out] accessible position in the group + * @param aSetSize [out] the group size + */ + virtual void GetPositionAndSizeInternal(int32_t *aPosInSet, + int32_t *aSetSize); + + /** + * Get the relation of the given type. + */ + virtual Relation RelationByType(RelationType aType); + + ////////////////////////////////////////////////////////////////////////////// + // 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(Accessible* aChild) + { return InsertChildAt(mChildren.Length(), aChild); } + virtual bool InsertChildAt(uint32_t aIndex, Accessible* 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(Accessible* aNewChild, Accessible* aRefChild); + + virtual bool RemoveChild(Accessible* aChild); + + /** + * Reallocates the child withing its parent. + */ + void MoveChild(uint32_t aNewIndex, Accessible* aChild); + + ////////////////////////////////////////////////////////////////////////////// + // Accessible tree traverse methods + + /** + * Return parent accessible. + */ + Accessible* Parent() const { return mParent; } + + /** + * Return child accessible at the given index. + */ + virtual Accessible* GetChildAt(uint32_t aIndex) const; + + /** + * Return child accessible count. + */ + virtual uint32_t ChildCount() const; + + /** + * Return index of the given child accessible. + */ + int32_t GetIndexOf(const Accessible* aChild) const + { return (aChild->mParent != this) ? -1 : aChild->IndexInParent(); } + + /** + * Return index in parent accessible. + */ + virtual int32_t IndexInParent() const; + + /** + * Return true if accessible has children; + */ + bool HasChildren() { return !!GetChildAt(0); } + + /** + * Return first/last/next/previous sibling of the accessible. + */ + inline Accessible* NextSibling() const + { return GetSiblingAtOffset(1); } + inline Accessible* PrevSibling() const + { return GetSiblingAtOffset(-1); } + inline Accessible* FirstChild() + { return GetChildAt(0); } + inline Accessible* LastChild() + { + uint32_t childCount = ChildCount(); + return childCount != 0 ? GetChildAt(childCount - 1) : nullptr; + } + + /** + * Return embedded accessible children count. + */ + uint32_t EmbeddedChildCount(); + + /** + * Return embedded accessible child at the given index. + */ + Accessible* GetEmbeddedChildAt(uint32_t aIndex); + + /** + * Return index of the given embedded accessible child. + */ + int32_t GetIndexOfEmbeddedChild(Accessible* aChild); + + /** + * 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(); } + Accessible* 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 true; } + + /** + * Returns text of accessible if accessible has text role otherwise empty + * string. + * + * @param aText [in] returned text of the accessible + * @param aStartOffset [in, optional] start offset inside of the accessible, + * if missed entire text is appended + * @param aLength [in, optional] required length of text, if missed + * then text form start offset till the end is appended + */ + virtual void AppendTextTo(nsAString& aText, uint32_t aStartOffset = 0, + uint32_t aLength = UINT32_MAX); + + /** + * Return boundaries in screen coordinates. + */ + virtual nsIntRect Bounds() const; + + /** + * Return boundaries rect relative the bounding frame. + */ + virtual nsRect RelativeBounds(nsIFrame** aRelativeFrame) const; + + /** + * Selects the accessible within its container if applicable. + */ + virtual void SetSelected(bool aSelect); + + /** + * Select the accessible within its container. + */ + void TakeSelection(); + + /** + * Focus the accessible. + */ + virtual void TakeFocus(); + + /** + * Scroll the accessible into view. + */ + void ScrollTo(uint32_t aHow) const; + + /** + * 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); + + ////////////////////////////////////////////////////////////////////////////// + // Downcasting and types + + inline bool IsAbbreviation() const + { + return mContent->IsAnyOfHTMLElements(nsGkAtoms::abbr, nsGkAtoms::acronym); + } + + bool IsAlert() const { return HasGenericType(eAlert); } + + bool IsApplication() const { return mType == eApplicationType; } + ApplicationAccessible* AsApplication(); + + bool IsAutoComplete() const { return HasGenericType(eAutoComplete); } + + bool IsAutoCompletePopup() const + { return HasGenericType(eAutoCompletePopup); } + + bool IsButton() const { return HasGenericType(eButton); } + + bool IsCombobox() const { return HasGenericType(eCombobox); } + + bool IsDoc() const { return HasGenericType(eDocument); } + DocAccessible* AsDoc(); + + bool IsGenericHyperText() const { return mType == eHyperTextType; } + bool IsHyperText() const { return HasGenericType(eHyperText); } + HyperTextAccessible* AsHyperText(); + + bool IsHTMLBr() const { return mType == eHTMLBRType; } + bool IsHTMLCaption() const { return mType == eHTMLCaptionType; } + bool IsHTMLCombobox() const { return mType == eHTMLComboboxType; } + bool IsHTMLFileInput() const { return mType == eHTMLFileInputType; } + + bool IsHTMLListItem() const { return mType == eHTMLLiType; } + HTMLLIAccessible* AsHTMLListItem(); + + bool IsHTMLOptGroup() const { return mType == eHTMLOptGroupType; } + + bool IsHTMLTable() const { return mType == eHTMLTableType; } + bool IsHTMLTableRow() const { return mType == eHTMLTableRowType; } + + bool IsImage() const { return mType == eImageType; } + ImageAccessible* AsImage(); + + bool IsImageMap() const { return mType == eImageMapType; } + HTMLImageMapAccessible* AsImageMap(); + + bool IsList() const { return HasGenericType(eList); } + + bool IsListControl() const { return HasGenericType(eListControl); } + + bool IsMenuButton() const { return HasGenericType(eMenuButton); } + + bool IsMenuPopup() const { return mType == eMenuPopupType; } + + bool IsProxy() const { return mType == eProxyType; } + ProxyAccessible* Proxy() const + { + MOZ_ASSERT(IsProxy()); + return mBits.proxy; + } + uint32_t ProxyInterfaces() const + { + MOZ_ASSERT(IsProxy()); + return mInt.mProxyInterfaces; + } + void SetProxyInterfaces(uint32_t aInterfaces) + { + MOZ_ASSERT(IsProxy()); + mInt.mProxyInterfaces = aInterfaces; + } + + bool IsOuterDoc() const { return mType == eOuterDocType; } + OuterDocAccessible* AsOuterDoc(); + + bool IsProgress() const { return mType == eProgressType; } + + bool IsRoot() const { return mType == eRootType; } + a11y::RootAccessible* AsRoot(); + + bool IsSearchbox() const; + + bool IsSelect() const { return HasGenericType(eSelect); } + + bool IsTable() const { return HasGenericType(eTable); } + virtual TableAccessible* AsTable() { return nullptr; } + + bool IsTableCell() const { return HasGenericType(eTableCell); } + virtual TableCellAccessible* AsTableCell() { return nullptr; } + const TableCellAccessible* AsTableCell() const + { return const_cast<Accessible*>(this)->AsTableCell(); } + + bool IsTableRow() const { return HasGenericType(eTableRow); } + + bool IsTextField() const { return mType == eHTMLTextFieldType; } + + bool IsText() const { return mGenericTypes & eText; } + + bool IsTextLeaf() const { return mType == eTextLeafType; } + TextLeafAccessible* AsTextLeaf(); + + bool IsXULLabel() const { return mType == eXULLabelType; } + XULLabelAccessible* AsXULLabel(); + + bool IsXULListItem() const { return mType == eXULListItemType; } + + bool IsXULTabpanels() const { return mType == eXULTabpanelsType; } + + bool IsXULTree() const { return mType == eXULTreeType; } + XULTreeAccessible* AsXULTree(); + + /** + * Return true if the accessible belongs to the given accessible type. + */ + bool HasGenericType(AccGenericType aType) const; + + ////////////////////////////////////////////////////////////////////////////// + // ActionAccessible + + /** + * Return the number of actions that can be performed on this accessible. + */ + virtual uint8_t ActionCount(); + + /** + * Return action name at given index. + */ + virtual void ActionNameAt(uint8_t aIndex, nsAString& aName); + + /** + * Default to localized action name. + */ + void ActionDescriptionAt(uint8_t aIndex, nsAString& aDescription) + { + nsAutoString name; + ActionNameAt(aIndex, name); + TranslateString(name, aDescription); + } + + /** + * Invoke the accessible action. + */ + virtual bool DoAction(uint8_t aIndex); + + /** + * Return access key, such as Alt+D. + */ + virtual KeyBinding AccessKey() const; + + /** + * 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(); + + /** + * Return the start offset of the link within the parent accessible. + */ + virtual uint32_t StartOffset(); + + /** + * Return the end offset of the link within the parent accessible. + */ + virtual uint32_t EndOffset(); + + /** + * Return true if the link is valid (e. g. points to a valid URL). + */ + inline bool IsLinkValid() + { + NS_PRECONDITION(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 Accessible* AnchorAt(uint32_t aAnchorIndex); + + /** + * Returns an anchor URI at the given index. + */ + virtual already_AddRefed<nsIURI> AnchorURIAt(uint32_t aAnchorIndex); + + /** + * Returns a text point for the accessible element. + */ + void ToTextPoint(HyperTextAccessible** aContainer, int32_t* aOffset, + bool aIsBefore = true) const; + + ////////////////////////////////////////////////////////////////////////////// + // SelectAccessible + + /** + * Return an array of selected items. + */ + virtual void SelectedItems(nsTArray<Accessible*>* aItems); + + /** + * Return the number of selected items. + */ + virtual uint32_t SelectedItemCount(); + + /** + * Return selected item at the given index. + */ + virtual Accessible* GetSelectedItem(uint32_t aIndex); + + /** + * Determine if item at the given index is selected. + */ + virtual bool IsItemSelected(uint32_t aIndex); + + /** + * Add item at the given index the selection. Return true if success. + */ + virtual bool AddItemToSelection(uint32_t aIndex); + + /** + * Remove item at the given index from the selection. Return if success. + */ + virtual bool RemoveItemFromSelection(uint32_t aIndex); + + /** + * Select all items. Return true if success. + */ + virtual bool SelectAll(); + + /** + * Unselect all items. Return true if success. + */ + virtual bool UnselectAll(); + + ////////////////////////////////////////////////////////////////////////////// + // Value (numeric value interface) + + virtual double MaxValue() const; + virtual double MinValue() const; + virtual double CurValue() const; + virtual double Step() const; + 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 Accessible* CurrentItem(); + + /** + * Set the current item of the widget. + */ + virtual void SetCurrentItem(Accessible* aItem); + + /** + * Return container widget this accessible belongs to. + */ + virtual Accessible* ContainerWidget() const; + + /** + * Return the localized string for the given key. + */ + static void TranslateString(const nsString& aKey, nsAString& aStringOut); + + /** + * Return true if the accessible is defunct. + */ + bool IsDefunct() const { return mStateFlags & eIsDefunct; } + + /** + * 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's group info needs to be updated. + */ + inline bool HasDirtyGroupInfo() const { return mStateFlags & eGroupInfoDirty; } + + /** + * Return true if the accessible has associated DOM content. + */ + bool HasOwnContent() const + { return mContent && !(mStateFlags & eSharedNode); } + + /** + * Return true if the accessible has a numeric value. + */ + bool HasNumericValue() const; + + /** + * Return true if the accessible state change is processed by handling proper + * DOM UI event, if otherwise then false. For example, HTMLCheckboxAccessible + * process nsIDocumentObserver::ContentStateChanged instead + * 'CheckboxStateChange' event. + */ + bool NeedsDOMUIEvent() const + { return !(mStateFlags & eIgnoreDOMUIEvent); } + + /** + * Get/set survivingInUpdate bit on child indicating that parent recollects + * its children. + */ + bool IsSurvivingInUpdate() const { return mStateFlags & eSurvivingInUpdate; } + void SetSurvivingInUpdate(bool aIsSurviving) + { + if (aIsSurviving) + mStateFlags |= eSurvivingInUpdate; + else + mStateFlags &= ~eSurvivingInUpdate; + } + + /** + * 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 doesn't allow accessible children from XBL + * anonymous subtree. + */ + bool NoXBLKids() const { return mStateFlags & eNoXBLKids; } + + /** + * 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 whose name depends on this + * accessible. + */ + bool HasNameDependentParent() const + { return mContextFlags & eHasNameDependentParent; } + + /** + * Return true if aria-hidden="true" is applied to the accessible or inherited + * from the parent. + */ + bool IsARIAHidden() const { return mContextFlags & eARIAHidden; } + void SetARIAHidden(bool aIsDefined); + + /** + * 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; } + +protected: + virtual ~Accessible(); + + /** + * 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); + + /** + * Return the accessible description provided by native markup. It doesn't take + * into account ARIA markup used to specify the description. + */ + virtual void NativeDescription(nsString& aDescription); + + /** + * Return object attributes provided by native markup. It doesn't take into + * account ARIA. + */ + virtual already_AddRefed<nsIPersistentProperties> NativeAttributes(); + + ////////////////////////////////////////////////////////////////////////////// + // Initializing, cache and tree traverse methods + + /** + * Destroy the object. + */ + void LastRelease(); + + /** + * Set accessible parent and index in parent. + */ + void BindToParent(Accessible* aParent, uint32_t aIndexInParent); + void UnbindFromParent(); + + /** + * Return sibling accessible at the given offset. + */ + virtual Accessible* GetSiblingAtOffset(int32_t aOffset, + nsresult *aError = nullptr) const; + + /** + * 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 + eHasNumericValue = 1 << 4, // accessible has a numeric value + eGroupInfoDirty = 1 << 5, // accessible needs to update group info + eKidsMutating = 1 << 6, // subtree is being mutated + eIgnoreDOMUIEvent = 1 << 7, // don't process DOM UI events for a11y events + eSurvivingInUpdate = 1 << 8, // parent drops children to recollect them + eRelocated = 1 << 9, // accessible was moved in tree + eNoXBLKids = 1 << 10, // accessible don't allows XBL children + eNoKidsFromDOM = 1 << 11, // accessible doesn't allow children from DOM + eHasTextKids = 1 << 12, // accessible have a text leaf in children + + eLastStateFlag = eNoKidsFromDOM + }; + + /** + * Flags used for contextual information about the accessible. + */ + enum ContextFlags { + eHasNameDependentParent = 1 << 0, // Parent's name depends on this accessible. + eARIAHidden = 1 << 1, + eInsideAlert = 1 << 2, + + eLastContextFlag = eInsideAlert + }; + +protected: + + ////////////////////////////////////////////////////////////////////////////// + // Miscellaneous helpers + + /** + * Return ARIA role (helper method). + */ + mozilla::a11y::role ARIATransformRole(mozilla::a11y::role aRole); + + ////////////////////////////////////////////////////////////////////////////// + // Name helpers + + /** + * Returns the accessible name specified by ARIA. + */ + void ARIAName(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); + + /** + * Dispatch click event. + */ + virtual void DispatchClickEvent(nsIContent *aContent, uint32_t aActionIndex); + + ////////////////////////////////////////////////////////////////////////////// + // 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(nsIAtom* aARIAAttr) const; + + /** + * Return the action rule based on ARIA enum constants EActionRule + * (see ARIAMap.h). Used by ActionCount() and ActionNameAt(). + */ + uint32_t GetActionRule() const; + + /** + * Return group info. + */ + AccGroupInfo* GetGroupInfo(); + + // Data Members + nsCOMPtr<nsIContent> mContent; + RefPtr<DocAccessible> mDoc; + + Accessible* mParent; + nsTArray<Accessible*> mChildren; + int32_t mIndexInParent; + + static const uint8_t kStateFlagsBits = 13; + static const uint8_t kContextFlagsBits = 3; + static const uint8_t kTypeBits = 6; + static const uint8_t kGenericTypesBits = 16; + + /** + * Non-NO_ROLE_MAP_ENTRY_INDEX indicates author-supplied role; + * possibly state & value as well + */ + uint8_t mRoleMapEntryIndex; + + /** + * Keep in sync with StateFlags, ContextFlags, and AccTypes. + */ + uint32_t mStateFlags : kStateFlagsBits; + uint32_t mContextFlags : kContextFlagsBits; + uint32_t mType : kTypeBits; + uint32_t mGenericTypes : kGenericTypesBits; + 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, + Accessible* aRoot, + logging::GetTreePrefix aPrefixFunc, + void* aGetTreePrefixData); +#endif + friend class DocAccessible; + friend class xpcAccessible; + friend class TreeMutation; + + UniquePtr<mozilla::a11y::EmbeddedObjCollector> mEmbeddedObjCollector; + union { + int32_t mIndexOfEmbeddedChild; + uint32_t mProxyInterfaces; + } mInt; + + friend class EmbeddedObjCollector; + + union + { + AccGroupInfo* groupInfo; + ProxyAccessible* proxy; + } mBits; + friend class AccGroupInfo; + +private: + Accessible() = delete; + Accessible(const Accessible&) = delete; + Accessible& operator =(const Accessible&) = delete; + +}; + +NS_DEFINE_STATIC_IID_ACCESSOR(Accessible, + NS_ACCESSIBLE_IMPL_IID) + + +/** + * Represent key binding associated with accessible (such as access key and + * global keyboard shortcuts). + */ +class KeyBinding +{ +public: + /** + * Modifier mask values. + */ + static const uint32_t kShift = 1; + static const uint32_t kControl = 2; + static const uint32_t kAlt = 4; + static const uint32_t kMeta = 8; + static const uint32_t kOS = 16; + + static uint32_t AccelModifier(); + + KeyBinding() : mKey(0), mModifierMask(0) {} + KeyBinding(uint32_t aKey, uint32_t aModifierMask) : + mKey(aKey), mModifierMask(aModifierMask) {} + + inline bool IsEmpty() const { return !mKey; } + inline uint32_t Key() const { return mKey; } + inline uint32_t ModifierMask() const { return mModifierMask; } + + enum Format { + ePlatformFormat, + eAtkFormat + }; + + /** + * Return formatted string for this key binding depending on the given format. + */ + inline void ToString(nsAString& aValue, + Format aFormat = ePlatformFormat) const + { + aValue.Truncate(); + AppendToString(aValue, aFormat); + } + inline void AppendToString(nsAString& aValue, + Format aFormat = ePlatformFormat) const + { + if (mKey) { + if (aFormat == ePlatformFormat) + ToPlatformFormat(aValue); + else + ToAtkFormat(aValue); + } + } + +private: + void ToPlatformFormat(nsAString& aValue) const; + void ToAtkFormat(nsAString& aValue) const; + + uint32_t mKey; + uint32_t mModifierMask; +}; + +} // namespace a11y +} // namespace mozilla + +#endif diff --git a/accessible/generic/ApplicationAccessible.cpp b/accessible/generic/ApplicationAccessible.cpp new file mode 100644 index 000000000..ae8ca27e3 --- /dev/null +++ b/accessible/generic/ApplicationAccessible.cpp @@ -0,0 +1,201 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:expandtab:shiftwidth=2:tabstop=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 "ApplicationAccessible.h" + +#include "nsAccessibilityService.h" +#include "nsAccUtils.h" +#include "Relation.h" +#include "Role.h" +#include "States.h" + +#include "nsIComponentManager.h" +#include "nsIDOMDocument.h" +#include "nsIWindowMediator.h" +#include "nsServiceManagerUtils.h" +#include "mozilla/Services.h" +#include "nsIStringBundle.h" + +using namespace mozilla::a11y; + +ApplicationAccessible::ApplicationAccessible() : + AccessibleWrap(nullptr, nullptr) +{ + mType = eApplicationType; + mAppInfo = do_GetService("@mozilla.org/xre/app-info;1"); + MOZ_ASSERT(mAppInfo, "no application info"); +} + +NS_IMPL_ISUPPORTS_INHERITED0(ApplicationAccessible, Accessible) + +//////////////////////////////////////////////////////////////////////////////// +// nsIAccessible + +ENameValueFlag +ApplicationAccessible::Name(nsString& aName) +{ + aName.Truncate(); + + nsCOMPtr<nsIStringBundleService> bundleService = + mozilla::services::GetStringBundleService(); + + NS_ASSERTION(bundleService, "String bundle service must be present!"); + if (!bundleService) + return eNameOK; + + nsCOMPtr<nsIStringBundle> bundle; + nsresult rv = bundleService->CreateBundle("chrome://branding/locale/brand.properties", + getter_AddRefs(bundle)); + if (NS_FAILED(rv)) + return eNameOK; + + nsXPIDLString appName; + rv = bundle->GetStringFromName(u"brandShortName", + getter_Copies(appName)); + if (NS_FAILED(rv) || appName.IsEmpty()) { + NS_WARNING("brandShortName not found, using default app name"); + appName.AssignLiteral("Gecko based application"); + } + + aName.Assign(appName); + return eNameOK; +} + +void +ApplicationAccessible::Description(nsString& aDescription) +{ + aDescription.Truncate(); +} + +void +ApplicationAccessible::Value(nsString& aValue) +{ + aValue.Truncate(); +} + +uint64_t +ApplicationAccessible::State() +{ + return IsDefunct() ? states::DEFUNCT : 0; +} + +already_AddRefed<nsIPersistentProperties> +ApplicationAccessible::NativeAttributes() +{ + return nullptr; +} + +GroupPos +ApplicationAccessible::GroupPosition() +{ + return GroupPos(); +} + +Accessible* +ApplicationAccessible::ChildAtPoint(int32_t aX, int32_t aY, + EWhichChildAtPoint aWhichChild) +{ + return nullptr; +} + +Accessible* +ApplicationAccessible::FocusedChild() +{ + Accessible* focus = FocusMgr()->FocusedAccessible(); + if (focus && focus->Parent() == this) + return focus; + + return nullptr; +} + +Relation +ApplicationAccessible::RelationByType(RelationType aRelationType) +{ + return Relation(); +} + +nsIntRect +ApplicationAccessible::Bounds() const +{ + return nsIntRect(); +} + +//////////////////////////////////////////////////////////////////////////////// +// Accessible public methods + +void +ApplicationAccessible::Shutdown() +{ + mAppInfo = nullptr; +} + +void +ApplicationAccessible::ApplyARIAState(uint64_t* aState) const +{ +} + +role +ApplicationAccessible::NativeRole() +{ + return roles::APP_ROOT; +} + +uint64_t +ApplicationAccessible::NativeState() +{ + return 0; +} + +KeyBinding +ApplicationAccessible::AccessKey() const +{ + return KeyBinding(); +} + +void +ApplicationAccessible::Init() +{ + // Basically children are kept updated by Append/RemoveChild method calls. + // However if there are open windows before accessibility was started + // then we need to make sure root accessibles for open windows are created so + // that all root accessibles are stored in application accessible children + // array. + + nsCOMPtr<nsIWindowMediator> windowMediator = + do_GetService(NS_WINDOWMEDIATOR_CONTRACTID); + + nsCOMPtr<nsISimpleEnumerator> windowEnumerator; + nsresult rv = windowMediator->GetEnumerator(nullptr, + getter_AddRefs(windowEnumerator)); + if (NS_FAILED(rv)) + return; + + bool hasMore = false; + windowEnumerator->HasMoreElements(&hasMore); + while (hasMore) { + nsCOMPtr<nsISupports> window; + windowEnumerator->GetNext(getter_AddRefs(window)); + nsCOMPtr<nsPIDOMWindowOuter> DOMWindow = do_QueryInterface(window); + if (DOMWindow) { + nsCOMPtr<nsIDocument> docNode = DOMWindow->GetDoc(); + if (docNode) { + GetAccService()->GetDocAccessible(docNode); // ensure creation + } + } + windowEnumerator->HasMoreElements(&hasMore); + } +} + +Accessible* +ApplicationAccessible::GetSiblingAtOffset(int32_t aOffset, + nsresult* aError) const +{ + if (aError) + *aError = NS_OK; // fail peacefully + + return nullptr; +} diff --git a/accessible/generic/ApplicationAccessible.h b/accessible/generic/ApplicationAccessible.h new file mode 100644 index 000000000..7609a86e2 --- /dev/null +++ b/accessible/generic/ApplicationAccessible.h @@ -0,0 +1,120 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:expandtab:shiftwidth=2:tabstop=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 mozilla_a11y_ApplicationAccessible_h__ +#define mozilla_a11y_ApplicationAccessible_h__ + +#include "AccessibleWrap.h" + +#include "nsIMutableArray.h" +#include "nsIXULAppInfo.h" + +namespace mozilla { +namespace a11y { + +/** + * ApplicationAccessible is for the whole application of Mozilla. + * Only one instance of ApplicationAccessible exists for one Mozilla instance. + * And this one should be created when Mozilla Startup (if accessibility + * feature has been enabled) and destroyed when Mozilla Shutdown. + * + * All the accessibility objects for toplevel windows are direct children of + * the ApplicationAccessible instance. + */ + +class ApplicationAccessible : public AccessibleWrap +{ +public: + + ApplicationAccessible(); + + NS_DECL_ISUPPORTS_INHERITED + + // Accessible + virtual void Shutdown() override; + virtual nsIntRect Bounds() const override; + virtual already_AddRefed<nsIPersistentProperties> NativeAttributes() override; + virtual GroupPos GroupPosition() override; + virtual ENameValueFlag Name(nsString& aName) override; + virtual void ApplyARIAState(uint64_t* aState) const override; + virtual void Description(nsString& aDescription) override; + virtual void Value(nsString& aValue) override; + virtual mozilla::a11y::role NativeRole() override; + virtual uint64_t State() override; + virtual uint64_t NativeState() override; + virtual Relation RelationByType(RelationType aType) override; + + virtual Accessible* ChildAtPoint(int32_t aX, int32_t aY, + EWhichChildAtPoint aWhichChild) override; + virtual Accessible* FocusedChild() override; + + // ActionAccessible + virtual KeyBinding AccessKey() const override; + + // ApplicationAccessible + void Init(); + + void AppName(nsAString& aName) const + { + MOZ_ASSERT(mAppInfo, "no application info"); + + if (mAppInfo) { + nsAutoCString cname; + mAppInfo->GetName(cname); + AppendUTF8toUTF16(cname, aName); + } + } + + void AppVersion(nsAString& aVersion) const + { + MOZ_ASSERT(mAppInfo, "no application info"); + + if (mAppInfo) { + nsAutoCString cversion; + mAppInfo->GetVersion(cversion); + AppendUTF8toUTF16(cversion, aVersion); + } + } + + void PlatformName(nsAString& aName) const + { + aName.AssignLiteral("Gecko"); + } + + void PlatformVersion(nsAString& aVersion) const + { + MOZ_ASSERT(mAppInfo, "no application info"); + + if (mAppInfo) { + nsAutoCString cversion; + mAppInfo->GetPlatformVersion(cversion); + AppendUTF8toUTF16(cversion, aVersion); + } + } + +protected: + virtual ~ApplicationAccessible() {} + + // Accessible + virtual Accessible* GetSiblingAtOffset(int32_t aOffset, + nsresult *aError = nullptr) const override; + +private: + nsCOMPtr<nsIXULAppInfo> mAppInfo; +}; + +inline ApplicationAccessible* +Accessible::AsApplication() +{ + return IsApplication() ? static_cast<ApplicationAccessible*>(this) : nullptr; +} + +} // namespace a11y +} // namespace mozilla + +#endif + diff --git a/accessible/generic/BaseAccessibles.cpp b/accessible/generic/BaseAccessibles.cpp new file mode 100644 index 000000000..bcb262a97 --- /dev/null +++ b/accessible/generic/BaseAccessibles.cpp @@ -0,0 +1,264 @@ +/* -*- 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 "BaseAccessibles.h" + +#include "Accessible-inl.h" +#include "HyperTextAccessibleWrap.h" +#include "nsAccessibilityService.h" +#include "nsAccUtils.h" +#include "nsCoreUtils.h" +#include "Role.h" +#include "States.h" +#include "nsIURI.h" + +using namespace mozilla::a11y; + +//////////////////////////////////////////////////////////////////////////////// +// LeafAccessible +//////////////////////////////////////////////////////////////////////////////// + +LeafAccessible:: + LeafAccessible(nsIContent* aContent, DocAccessible* aDoc) : + AccessibleWrap(aContent, aDoc) +{ + mStateFlags |= eNoKidsFromDOM; +} + +NS_IMPL_ISUPPORTS_INHERITED0(LeafAccessible, Accessible) + +//////////////////////////////////////////////////////////////////////////////// +// LeafAccessible: Accessible public + +Accessible* +LeafAccessible::ChildAtPoint(int32_t aX, int32_t aY, + EWhichChildAtPoint aWhichChild) +{ + // Don't walk into leaf accessibles. + return this; +} + +bool +LeafAccessible::InsertChildAt(uint32_t aIndex, Accessible* aChild) +{ + NS_NOTREACHED("InsertChildAt called on leaf accessible!"); + return false; +} + +bool +LeafAccessible::RemoveChild(Accessible* aChild) +{ + NS_NOTREACHED("RemoveChild called on leaf accessible!"); + return false; +} + +bool +LeafAccessible::IsAcceptableChild(nsIContent* aEl) const +{ + // No children for leaf accessible. + return false; +} + + +//////////////////////////////////////////////////////////////////////////////// +// LinkableAccessible +//////////////////////////////////////////////////////////////////////////////// + +NS_IMPL_ISUPPORTS_INHERITED0(LinkableAccessible, AccessibleWrap) + +//////////////////////////////////////////////////////////////////////////////// +// LinkableAccessible. nsIAccessible + +void +LinkableAccessible::TakeFocus() +{ + if (Accessible* actionAcc = ActionWalk()) { + actionAcc->TakeFocus(); + } else { + AccessibleWrap::TakeFocus(); + } +} + +uint64_t +LinkableAccessible::NativeLinkState() const +{ + bool isLink; + Accessible* actionAcc = + const_cast<LinkableAccessible*>(this)->ActionWalk(&isLink); + if (isLink) { + return states::LINKED | (actionAcc->LinkState() & states::TRAVERSED); + } + + return 0; +} + +void +LinkableAccessible::Value(nsString& aValue) +{ + aValue.Truncate(); + + Accessible::Value(aValue); + if (!aValue.IsEmpty()) { + return; + } + + bool isLink; + Accessible* actionAcc = ActionWalk(&isLink); + if (isLink) { + actionAcc->Value(aValue); + } +} + +uint8_t +LinkableAccessible::ActionCount() +{ + bool isLink, isOnclick, isLabelWithControl; + ActionWalk(&isLink, &isOnclick, &isLabelWithControl); + return (isLink || isOnclick || isLabelWithControl) ? 1 : 0; +} + +Accessible* +LinkableAccessible::ActionWalk(bool* aIsLink, bool* aIsOnclick, + bool* aIsLabelWithControl) +{ + if (aIsOnclick) { + *aIsOnclick = false; + } + if (aIsLink) { + *aIsLink = false; + } + if (aIsLabelWithControl) { + *aIsLabelWithControl = false; + } + + if (nsCoreUtils::HasClickListener(mContent)) { + if (aIsOnclick) { + *aIsOnclick = true; + } + return nullptr; + } + + // XXX: The logic looks broken since the click listener may be registered + // on non accessible node in parent chain but this node is skipped when tree + // is traversed. + Accessible* walkUpAcc = this; + while ((walkUpAcc = walkUpAcc->Parent()) && !walkUpAcc->IsDoc()) { + if (walkUpAcc->LinkState() & states::LINKED) { + if (aIsLink) { + *aIsLink = true; + } + return walkUpAcc; + } + + if (nsCoreUtils::HasClickListener(walkUpAcc->GetContent())) { + if (aIsOnclick) { + *aIsOnclick = true; + } + return walkUpAcc; + } + + if (nsCoreUtils::IsLabelWithControl(walkUpAcc->GetContent())) { + if (aIsLabelWithControl) { + *aIsLabelWithControl = true; + } + return walkUpAcc; + } + } + return nullptr; +} + +void +LinkableAccessible::ActionNameAt(uint8_t aIndex, nsAString& aName) +{ + aName.Truncate(); + + // Action 0 (default action): Jump to link + if (aIndex == eAction_Jump) { + bool isOnclick, isLink, isLabelWithControl; + ActionWalk(&isLink, &isOnclick, &isLabelWithControl); + if (isLink) { + aName.AssignLiteral("jump"); + } else if (isOnclick || isLabelWithControl) { + aName.AssignLiteral("click"); + } + } +} + +bool +LinkableAccessible::DoAction(uint8_t aIndex) +{ + if (aIndex != eAction_Jump) { + return false; + } + + if (Accessible* actionAcc = ActionWalk()) { + return actionAcc->DoAction(aIndex); + } + + return AccessibleWrap::DoAction(aIndex); +} + +KeyBinding +LinkableAccessible::AccessKey() const +{ + if (const Accessible* actionAcc = + const_cast<LinkableAccessible*>(this)->ActionWalk()) { + return actionAcc->AccessKey(); + } + + return Accessible::AccessKey(); +} + +//////////////////////////////////////////////////////////////////////////////// +// LinkableAccessible: HyperLinkAccessible + +already_AddRefed<nsIURI> +LinkableAccessible::AnchorURIAt(uint32_t aAnchorIndex) +{ + bool isLink; + Accessible* actionAcc = ActionWalk(&isLink); + if (isLink) { + NS_ASSERTION(actionAcc->IsLink(), "HyperLink isn't implemented."); + + if (actionAcc->IsLink()) { + return actionAcc->AnchorURIAt(aAnchorIndex); + } + } + + return nullptr; +} + + +//////////////////////////////////////////////////////////////////////////////// +// DummyAccessible +//////////////////////////////////////////////////////////////////////////////// + +uint64_t +DummyAccessible::NativeState() +{ + return 0; +} +uint64_t +DummyAccessible::NativeInteractiveState() const +{ + return 0; +} + +uint64_t +DummyAccessible::NativeLinkState() const +{ + return 0; +} + +bool +DummyAccessible::NativelyUnavailable() const +{ + return false; +} + +void +DummyAccessible::ApplyARIAState(uint64_t* aState) const +{ +} diff --git a/accessible/generic/BaseAccessibles.h b/accessible/generic/BaseAccessibles.h new file mode 100644 index 000000000..e4c71c423 --- /dev/null +++ b/accessible/generic/BaseAccessibles.h @@ -0,0 +1,132 @@ +/* -*- 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 mozilla_a11y_BaseAccessibles_h__ +#define mozilla_a11y_BaseAccessibles_h__ + +#include "AccessibleWrap.h" +#include "HyperTextAccessibleWrap.h" + +class nsIContent; + +/** + * This file contains a number of classes that are used as base + * classes for the different accessibility implementations of + * the HTML and XUL widget sets. --jgaunt + */ + +namespace mozilla { +namespace a11y { + +/** + * Leaf version of DOM Accessible -- has no children + */ +class LeafAccessible : public AccessibleWrap +{ +public: + + LeafAccessible(nsIContent* aContent, DocAccessible* aDoc); + + // nsISupports + NS_DECL_ISUPPORTS_INHERITED + + // Accessible + virtual Accessible* ChildAtPoint(int32_t aX, int32_t aY, + EWhichChildAtPoint aWhichChild) override; + virtual bool InsertChildAt(uint32_t aIndex, Accessible* aChild) override final; + virtual bool RemoveChild(Accessible* aChild) override final; + + virtual bool IsAcceptableChild(nsIContent* aEl) const override; + +protected: + virtual ~LeafAccessible() {} +}; + +/** + * Used for text or image accessible nodes contained by link accessibles or + * accessibles for nodes with registered click event handler. It knows how to + * report the state of the host link (traveled or not) and can activate (click) + * the host accessible programmatically. + */ +class LinkableAccessible : public AccessibleWrap +{ +public: + enum { eAction_Jump = 0 }; + + LinkableAccessible(nsIContent* aContent, DocAccessible* aDoc) : + AccessibleWrap(aContent, aDoc) + { + } + + NS_DECL_ISUPPORTS_INHERITED + + // Accessible + virtual void Value(nsString& aValue) override; + virtual uint64_t NativeLinkState() const override; + virtual void TakeFocus() override; + + // ActionAccessible + virtual uint8_t ActionCount() override; + virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) override; + virtual bool DoAction(uint8_t index) override; + virtual KeyBinding AccessKey() const override; + + // ActionAccessible helpers + Accessible* ActionWalk(bool* aIsLink = nullptr, + bool* aIsOnclick = nullptr, + bool* aIsLabelWithControl = nullptr); + // HyperLinkAccessible + virtual already_AddRefed<nsIURI> AnchorURIAt(uint32_t aAnchorIndex) override; + +protected: + virtual ~LinkableAccessible() {} + +}; + +/** + * A simple accessible that gets its enumerated role. + */ +template<a11y::role R> +class EnumRoleAccessible : public AccessibleWrap +{ +public: + EnumRoleAccessible(nsIContent* aContent, DocAccessible* aDoc) : + AccessibleWrap(aContent, aDoc) { } + + NS_IMETHOD QueryInterface(REFNSIID aIID, void** aPtr) override + { return Accessible::QueryInterface(aIID, aPtr); } + + // Accessible + virtual a11y::role NativeRole() override { return R; } + +protected: + virtual ~EnumRoleAccessible() { } +}; + + +/** + * A wrapper accessible around native accessible to connect it with + * crossplatform accessible tree. + */ +class DummyAccessible : public AccessibleWrap +{ +public: + explicit DummyAccessible(DocAccessible* aDocument = nullptr) : + AccessibleWrap(nullptr, aDocument) { } + + virtual uint64_t NativeState() override final; + virtual uint64_t NativeInteractiveState() const override final; + virtual uint64_t NativeLinkState() const override final; + virtual bool NativelyUnavailable() const override final; + virtual void ApplyARIAState(uint64_t* aState) const override final; + +protected: + virtual ~DummyAccessible() { } +}; + +} // namespace a11y +} // namespace mozilla + +#endif diff --git a/accessible/generic/DocAccessible-inl.h b/accessible/generic/DocAccessible-inl.h new file mode 100644 index 000000000..af660ff47 --- /dev/null +++ b/accessible/generic/DocAccessible-inl.h @@ -0,0 +1,189 @@ +/* -*- 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_DocAccessible_inl_h_ +#define mozilla_a11y_DocAccessible_inl_h_ + +#include "DocAccessible.h" +#include "nsAccessibilityService.h" +#include "nsAccessiblePivot.h" +#include "NotificationController.h" +#include "States.h" +#include "nsIScrollableFrame.h" +#include "nsIDocumentInlines.h" + +#ifdef A11Y_LOG +#include "Logging.h" +#endif + +namespace mozilla { +namespace a11y { + +inline Accessible* +DocAccessible::AccessibleOrTrueContainer(nsINode* aNode) const +{ + // HTML comboboxes have no-content list accessible as an intermediate + // containing all options. + Accessible* container = GetAccessibleOrContainer(aNode); + if (container && container->IsHTMLCombobox()) { + return container->FirstChild(); + } + return container; +} + +inline nsIAccessiblePivot* +DocAccessible::VirtualCursor() +{ + if (!mVirtualCursor) { + mVirtualCursor = new nsAccessiblePivot(this); + mVirtualCursor->AddObserver(this); + } + return mVirtualCursor; +} + +inline void +DocAccessible::FireDelayedEvent(AccEvent* aEvent) +{ +#ifdef A11Y_LOG + if (logging::IsEnabled(logging::eDocLoad)) + logging::DocLoadEventFired(aEvent); +#endif + + mNotificationController->QueueEvent(aEvent); +} + +inline void +DocAccessible::FireDelayedEvent(uint32_t aEventType, Accessible* aTarget) +{ + RefPtr<AccEvent> event = new AccEvent(aEventType, aTarget); + FireDelayedEvent(event); +} + +inline void +DocAccessible::BindChildDocument(DocAccessible* aDocument) +{ + mNotificationController->ScheduleChildDocBinding(aDocument); +} + +template<class Class, class Arg> +inline void +DocAccessible::HandleNotification(Class* aInstance, + typename TNotification<Class, Arg>::Callback aMethod, + Arg* aArg) +{ + if (mNotificationController) { + mNotificationController->HandleNotification<Class, Arg>(aInstance, + aMethod, aArg); + } +} + +inline void +DocAccessible::UpdateText(nsIContent* aTextNode) +{ + NS_ASSERTION(mNotificationController, "The document was shut down!"); + + // Ignore the notification if initial tree construction hasn't been done yet. + if (mNotificationController && HasLoadState(eTreeConstructed)) + mNotificationController->ScheduleTextUpdate(aTextNode); +} + +inline void +DocAccessible::AddScrollListener() +{ + // Delay scroll initializing until the document has a root frame. + if (!mPresShell->GetRootFrame()) + return; + + mDocFlags |= eScrollInitialized; + nsIScrollableFrame* sf = mPresShell->GetRootScrollFrameAsScrollable(); + if (sf) { + sf->AddScrollPositionListener(this); + +#ifdef A11Y_LOG + if (logging::IsEnabled(logging::eDocCreate)) + logging::Text("add scroll listener"); +#endif + } +} + +inline void +DocAccessible::RemoveScrollListener() +{ + nsIScrollableFrame* sf = mPresShell->GetRootScrollFrameAsScrollable(); + if (sf) + sf->RemoveScrollPositionListener(this); +} + +inline void +DocAccessible::NotifyOfLoad(uint32_t aLoadEventType) +{ + mLoadState |= eDOMLoaded; + mLoadEventType = aLoadEventType; + + // If the document is loaded completely then network activity was presumingly + // caused by file loading. Fire busy state change event. + if (HasLoadState(eCompletelyLoaded) && IsLoadEventTarget()) { + RefPtr<AccEvent> stateEvent = + new AccStateChangeEvent(this, states::BUSY, false); + FireDelayedEvent(stateEvent); + } +} + +inline void +DocAccessible::MaybeNotifyOfValueChange(Accessible* aAccessible) +{ + a11y::role role = aAccessible->Role(); + if (role == roles::ENTRY || role == roles::COMBOBOX) + FireDelayedEvent(nsIAccessibleEvent::EVENT_TEXT_VALUE_CHANGE, aAccessible); +} + +inline Accessible* +DocAccessible::GetAccessibleEvenIfNotInMapOrContainer(nsINode* aNode) const +{ + Accessible* acc = GetAccessibleEvenIfNotInMap(aNode); + return acc ? acc : GetContainerAccessible(aNode); +} + +inline void +DocAccessible::CreateSubtree(Accessible* aChild) +{ + // If a focused node has been shown then it could mean its frame was recreated + // while the node stays focused and we need to fire focus event on + // the accessible we just created. If the queue contains a focus event for + // this node already then it will be suppressed by this one. + Accessible* focusedAcc = nullptr; + CacheChildrenInSubtree(aChild, &focusedAcc); + +#ifdef A11Y_LOG + if (logging::IsEnabled(logging::eVerbose)) { + logging::Tree("TREE", "Created subtree", aChild); + } +#endif + + // Fire events for ARIA elements. + if (aChild->HasARIARole()) { + roles::Role role = aChild->ARIARole(); + if (role == roles::MENUPOPUP) { + FireDelayedEvent(nsIAccessibleEvent::EVENT_MENUPOPUP_START, aChild); + } + else if (role == roles::ALERT) { + FireDelayedEvent(nsIAccessibleEvent::EVENT_ALERT, aChild); + } + } + + // XXX: do we really want to send focus to focused DOM node not taking into + // account active item? + if (focusedAcc) { + FocusMgr()->DispatchFocusEvent(this, focusedAcc); + SelectionMgr()-> + SetControlSelectionListener(focusedAcc->GetNode()->AsElement()); + } +} + +} // namespace a11y +} // namespace mozilla + +#endif diff --git a/accessible/generic/DocAccessible.cpp b/accessible/generic/DocAccessible.cpp new file mode 100644 index 000000000..c89aa189b --- /dev/null +++ b/accessible/generic/DocAccessible.cpp @@ -0,0 +1,2387 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=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/. */ + +#include "Accessible-inl.h" +#include "AccIterator.h" +#include "DocAccessible-inl.h" +#include "DocAccessibleChild.h" +#include "HTMLImageMapAccessible.h" +#include "nsAccCache.h" +#include "nsAccessiblePivot.h" +#include "nsAccUtils.h" +#include "nsEventShell.h" +#include "nsTextEquivUtils.h" +#include "Role.h" +#include "RootAccessible.h" +#include "TreeWalker.h" +#include "xpcAccessibleDocument.h" + +#include "nsIMutableArray.h" +#include "nsICommandManager.h" +#include "nsIDocShell.h" +#include "nsIDocument.h" +#include "nsIDOMAttr.h" +#include "nsIDOMCharacterData.h" +#include "nsIDOMDocument.h" +#include "nsIDOMXULDocument.h" +#include "nsIDOMMutationEvent.h" +#include "nsPIDOMWindow.h" +#include "nsIDOMXULPopupElement.h" +#include "nsIEditingSession.h" +#include "nsIFrame.h" +#include "nsIInterfaceRequestorUtils.h" +#include "nsImageFrame.h" +#include "nsIPersistentProperties2.h" +#include "nsIPresShell.h" +#include "nsIServiceManager.h" +#include "nsViewManager.h" +#include "nsIScrollableFrame.h" +#include "nsUnicharUtils.h" +#include "nsIURI.h" +#include "nsIWebNavigation.h" +#include "nsFocusManager.h" +#include "mozilla/ArrayUtils.h" +#include "mozilla/Assertions.h" +#include "mozilla/EventStates.h" +#include "mozilla/dom/DocumentType.h" +#include "mozilla/dom/Element.h" + +#ifdef MOZ_XUL +#include "nsIXULDocument.h" +#endif + +using namespace mozilla; +using namespace mozilla::a11y; + +//////////////////////////////////////////////////////////////////////////////// +// Static member initialization + +static nsIAtom** kRelationAttrs[] = +{ + &nsGkAtoms::aria_labelledby, + &nsGkAtoms::aria_describedby, + &nsGkAtoms::aria_details, + &nsGkAtoms::aria_owns, + &nsGkAtoms::aria_controls, + &nsGkAtoms::aria_flowto, + &nsGkAtoms::aria_errormessage, + &nsGkAtoms::_for, + &nsGkAtoms::control +}; + +static const uint32_t kRelationAttrsLen = ArrayLength(kRelationAttrs); + +//////////////////////////////////////////////////////////////////////////////// +// Constructor/desctructor + +DocAccessible:: + DocAccessible(nsIDocument* aDocument, nsIPresShell* aPresShell) : + // XXX don't pass a document to the Accessible constructor so that we don't + // set mDoc until our vtable is fully setup. If we set mDoc before setting + // up the vtable we will call Accessible::AddRef() but not the overrides of + // it for subclasses. It is important to call those overrides to avoid + // confusing leak checking machinary. + HyperTextAccessibleWrap(nullptr, nullptr), + // XXX aaronl should we use an algorithm for the initial cache size? + mAccessibleCache(kDefaultCacheLength), + mNodeToAccessibleMap(kDefaultCacheLength), + mDocumentNode(aDocument), + mScrollPositionChangedTicks(0), + mLoadState(eTreeConstructionPending), mDocFlags(0), mLoadEventType(0), + mVirtualCursor(nullptr), + mPresShell(aPresShell), mIPCDoc(nullptr) +{ + mGenericTypes |= eDocument; + mStateFlags |= eNotNodeMapEntry; + mDoc = this; + + MOZ_ASSERT(mPresShell, "should have been given a pres shell"); + mPresShell->SetDocAccessible(this); + + // If this is a XUL Document, it should not implement nsHyperText + if (mDocumentNode && mDocumentNode->IsXULDocument()) + mGenericTypes &= ~eHyperText; +} + +DocAccessible::~DocAccessible() +{ + NS_ASSERTION(!mPresShell, "LastRelease was never called!?!"); +} + + +//////////////////////////////////////////////////////////////////////////////// +// nsISupports + +NS_IMPL_CYCLE_COLLECTION_CLASS(DocAccessible) + +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(DocAccessible, Accessible) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mNotificationController) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mVirtualCursor) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mChildDocuments) + for (auto iter = tmp->mDependentIDsHash.Iter(); !iter.Done(); iter.Next()) { + AttrRelProviderArray* providers = iter.UserData(); + + for (int32_t jdx = providers->Length() - 1; jdx >= 0; jdx--) { + NS_CYCLE_COLLECTION_NOTE_EDGE_NAME( + cb, "content of dependent ids hash entry of document accessible"); + + AttrRelProvider* provider = (*providers)[jdx]; + cb.NoteXPCOMChild(provider->mContent); + + NS_ASSERTION(provider->mContent->IsInUncomposedDoc(), + "Referred content is not in document!"); + } + } + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAccessibleCache) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAnchorJumpElm) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mInvalidationList) + for (auto it = tmp->mARIAOwnsHash.ConstIter(); !it.Done(); it.Next()) { + nsTArray<RefPtr<Accessible> >* ar = it.UserData(); + for (uint32_t i = 0; i < ar->Length(); i++) { + NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, + "mARIAOwnsHash entry item"); + cb.NoteXPCOMChild(ar->ElementAt(i)); + } + } +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(DocAccessible, Accessible) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mNotificationController) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mVirtualCursor) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mChildDocuments) + tmp->mDependentIDsHash.Clear(); + tmp->mNodeToAccessibleMap.Clear(); + NS_IMPL_CYCLE_COLLECTION_UNLINK(mAccessibleCache) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mAnchorJumpElm) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mInvalidationList) + tmp->mARIAOwnsHash.Clear(); +NS_IMPL_CYCLE_COLLECTION_UNLINK_END + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(DocAccessible) + NS_INTERFACE_MAP_ENTRY(nsIDocumentObserver) + NS_INTERFACE_MAP_ENTRY(nsIMutationObserver) + NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference) + NS_INTERFACE_MAP_ENTRY(nsIObserver) + NS_INTERFACE_MAP_ENTRY(nsIAccessiblePivotObserver) +NS_INTERFACE_MAP_END_INHERITING(HyperTextAccessible) + +NS_IMPL_ADDREF_INHERITED(DocAccessible, HyperTextAccessible) +NS_IMPL_RELEASE_INHERITED(DocAccessible, HyperTextAccessible) + +//////////////////////////////////////////////////////////////////////////////// +// nsIAccessible + +ENameValueFlag +DocAccessible::Name(nsString& aName) +{ + aName.Truncate(); + + if (mParent) { + mParent->Name(aName); // Allow owning iframe to override the name + } + if (aName.IsEmpty()) { + // Allow name via aria-labelledby or title attribute + Accessible::Name(aName); + } + if (aName.IsEmpty()) { + Title(aName); // Try title element + } + if (aName.IsEmpty()) { // Last resort: use URL + URL(aName); + } + + return eNameOK; +} + +// Accessible public method +role +DocAccessible::NativeRole() +{ + nsCOMPtr<nsIDocShell> docShell = nsCoreUtils::GetDocShellFor(mDocumentNode); + if (docShell) { + nsCOMPtr<nsIDocShellTreeItem> sameTypeRoot; + docShell->GetSameTypeRootTreeItem(getter_AddRefs(sameTypeRoot)); + int32_t itemType = docShell->ItemType(); + if (sameTypeRoot == docShell) { + // Root of content or chrome tree + if (itemType == nsIDocShellTreeItem::typeChrome) + return roles::CHROME_WINDOW; + + if (itemType == nsIDocShellTreeItem::typeContent) { +#ifdef MOZ_XUL + nsCOMPtr<nsIXULDocument> xulDoc(do_QueryInterface(mDocumentNode)); + if (xulDoc) + return roles::APPLICATION; +#endif + return roles::DOCUMENT; + } + } + else if (itemType == nsIDocShellTreeItem::typeContent) { + return roles::DOCUMENT; + } + } + + return roles::PANE; // Fall back; +} + +void +DocAccessible::Description(nsString& aDescription) +{ + if (mParent) + mParent->Description(aDescription); + + if (HasOwnContent() && aDescription.IsEmpty()) { + nsTextEquivUtils:: + GetTextEquivFromIDRefs(this, nsGkAtoms::aria_describedby, + aDescription); + } +} + +// Accessible public method +uint64_t +DocAccessible::NativeState() +{ + // Document is always focusable. + uint64_t state = states::FOCUSABLE; // keep in sync with NativeInteractiveState() impl + if (FocusMgr()->IsFocused(this)) + state |= states::FOCUSED; + + // Expose stale state until the document is ready (DOM is loaded and tree is + // constructed). + if (!HasLoadState(eReady)) + state |= states::STALE; + + // Expose state busy until the document and all its subdocuments is completely + // loaded. + if (!HasLoadState(eCompletelyLoaded)) + state |= states::BUSY; + + nsIFrame* frame = GetFrame(); + if (!frame || + !frame->IsVisibleConsideringAncestors(nsIFrame::VISIBILITY_CROSS_CHROME_CONTENT_BOUNDARY)) { + state |= states::INVISIBLE | states::OFFSCREEN; + } + + nsCOMPtr<nsIEditor> editor = GetEditor(); + state |= editor ? states::EDITABLE : states::READONLY; + + return state; +} + +uint64_t +DocAccessible::NativeInteractiveState() const +{ + // Document is always focusable. + return states::FOCUSABLE; +} + +bool +DocAccessible::NativelyUnavailable() const +{ + return false; +} + +// Accessible public method +void +DocAccessible::ApplyARIAState(uint64_t* aState) const +{ + // Grab states from content element. + if (mContent) + Accessible::ApplyARIAState(aState); + + // Allow iframe/frame etc. to have final state override via ARIA. + if (mParent) + mParent->ApplyARIAState(aState); +} + +already_AddRefed<nsIPersistentProperties> +DocAccessible::Attributes() +{ + nsCOMPtr<nsIPersistentProperties> attributes = + HyperTextAccessibleWrap::Attributes(); + + // No attributes if document is not attached to the tree or if it's a root + // document. + if (!mParent || IsRoot()) + return attributes.forget(); + + // Override ARIA object attributes from outerdoc. + aria::AttrIterator attribIter(mParent->GetContent()); + nsAutoString name, value, unused; + while(attribIter.Next(name, value)) + attributes->SetStringProperty(NS_ConvertUTF16toUTF8(name), value, unused); + + return attributes.forget(); +} + +Accessible* +DocAccessible::FocusedChild() +{ + // Return an accessible for the current global focus, which does not have to + // be contained within the current document. + return FocusMgr()->FocusedAccessible(); +} + +void +DocAccessible::TakeFocus() +{ + // Focus the document. + nsFocusManager* fm = nsFocusManager::GetFocusManager(); + nsCOMPtr<nsIDOMElement> newFocus; + fm->MoveFocus(mDocumentNode->GetWindow(), nullptr, + nsFocusManager::MOVEFOCUS_ROOT, 0, getter_AddRefs(newFocus)); +} + +// HyperTextAccessible method +already_AddRefed<nsIEditor> +DocAccessible::GetEditor() const +{ + // Check if document is editable (designMode="on" case). Otherwise check if + // the html:body (for HTML document case) or document element is editable. + if (!mDocumentNode->HasFlag(NODE_IS_EDITABLE) && + (!mContent || !mContent->HasFlag(NODE_IS_EDITABLE))) + return nullptr; + + nsCOMPtr<nsIDocShell> docShell = mDocumentNode->GetDocShell(); + if (!docShell) { + return nullptr; + } + + nsCOMPtr<nsIEditingSession> editingSession; + docShell->GetEditingSession(getter_AddRefs(editingSession)); + if (!editingSession) + return nullptr; // No editing session interface + + nsCOMPtr<nsIEditor> editor; + editingSession->GetEditorForWindow(mDocumentNode->GetWindow(), getter_AddRefs(editor)); + if (!editor) + return nullptr; + + bool isEditable = false; + editor->GetIsDocumentEditable(&isEditable); + if (isEditable) + return editor.forget(); + + return nullptr; +} + +// DocAccessible public method + +void +DocAccessible::URL(nsAString& aURL) const +{ + nsCOMPtr<nsISupports> container = mDocumentNode->GetContainer(); + nsCOMPtr<nsIWebNavigation> webNav(do_GetInterface(container)); + nsAutoCString theURL; + if (webNav) { + nsCOMPtr<nsIURI> pURI; + webNav->GetCurrentURI(getter_AddRefs(pURI)); + if (pURI) + pURI->GetSpec(theURL); + } + CopyUTF8toUTF16(theURL, aURL); +} + +void +DocAccessible::DocType(nsAString& aType) const +{ +#ifdef MOZ_XUL + nsCOMPtr<nsIXULDocument> xulDoc(do_QueryInterface(mDocumentNode)); + if (xulDoc) { + aType.AssignLiteral("window"); // doctype not implemented for XUL at time of writing - causes assertion + return; + } +#endif + dom::DocumentType* docType = mDocumentNode->GetDoctype(); + if (docType) + docType->GetPublicId(aType); +} + +//////////////////////////////////////////////////////////////////////////////// +// Accessible + +void +DocAccessible::Init() +{ +#ifdef A11Y_LOG + if (logging::IsEnabled(logging::eDocCreate)) + logging::DocCreate("document initialize", mDocumentNode, this); +#endif + + // Initialize notification controller. + mNotificationController = new NotificationController(this, mPresShell); + + // Mark the document accessible as loaded if its DOM document was loaded at + // this point (this can happen because a11y is started late or DOM document + // having no container was loaded. + if (mDocumentNode->GetReadyStateEnum() == nsIDocument::READYSTATE_COMPLETE) + mLoadState |= eDOMLoaded; + + AddEventListeners(); +} + +void +DocAccessible::Shutdown() +{ + if (!mPresShell) // already shutdown + return; + +#ifdef A11Y_LOG + if (logging::IsEnabled(logging::eDocDestroy)) + logging::DocDestroy("document shutdown", mDocumentNode, this); +#endif + + // Mark the document as shutdown before AT is notified about the document + // removal from its container (valid for root documents on ATK and due to + // some reason for MSAA, refer to bug 757392 for details). + mStateFlags |= eIsDefunct; + + if (mNotificationController) { + mNotificationController->Shutdown(); + mNotificationController = nullptr; + } + + RemoveEventListeners(); + + nsCOMPtr<nsIDocument> kungFuDeathGripDoc = mDocumentNode; + mDocumentNode = nullptr; + + if (mParent) { + DocAccessible* parentDocument = mParent->Document(); + if (parentDocument) + parentDocument->RemoveChildDocument(this); + + mParent->RemoveChild(this); + } + + // Walk the array backwards because child documents remove themselves from the + // array as they are shutdown. + int32_t childDocCount = mChildDocuments.Length(); + for (int32_t idx = childDocCount - 1; idx >= 0; idx--) + mChildDocuments[idx]->Shutdown(); + + mChildDocuments.Clear(); + + // XXX thinking about ordering? + if (mIPCDoc) { + MOZ_ASSERT(IPCAccessibilityActive()); + mIPCDoc->Shutdown(); + MOZ_ASSERT(!mIPCDoc); + } + + if (mVirtualCursor) { + mVirtualCursor->RemoveObserver(this); + mVirtualCursor = nullptr; + } + + mPresShell->SetDocAccessible(nullptr); + mPresShell = nullptr; // Avoid reentrancy + + mDependentIDsHash.Clear(); + mNodeToAccessibleMap.Clear(); + + for (auto iter = mAccessibleCache.Iter(); !iter.Done(); iter.Next()) { + Accessible* accessible = iter.Data(); + MOZ_ASSERT(accessible); + if (accessible && !accessible->IsDefunct()) { + // Unlink parent to avoid its cleaning overhead in shutdown. + accessible->mParent = nullptr; + accessible->Shutdown(); + } + iter.Remove(); + } + + HyperTextAccessibleWrap::Shutdown(); + + GetAccService()->NotifyOfDocumentShutdown(this, kungFuDeathGripDoc); +} + +nsIFrame* +DocAccessible::GetFrame() const +{ + nsIFrame* root = nullptr; + if (mPresShell) + root = mPresShell->GetRootFrame(); + + return root; +} + +// DocAccessible protected member +nsRect +DocAccessible::RelativeBounds(nsIFrame** aRelativeFrame) const +{ + *aRelativeFrame = GetFrame(); + + nsIDocument *document = mDocumentNode; + nsIDocument *parentDoc = nullptr; + + nsRect bounds; + while (document) { + nsIPresShell *presShell = document->GetShell(); + if (!presShell) + return nsRect(); + + nsRect scrollPort; + nsIScrollableFrame* sf = presShell->GetRootScrollFrameAsScrollableExternal(); + if (sf) { + scrollPort = sf->GetScrollPortRect(); + } else { + nsIFrame* rootFrame = presShell->GetRootFrame(); + if (!rootFrame) + return nsRect(); + + scrollPort = rootFrame->GetRect(); + } + + if (parentDoc) { // After first time thru loop + // XXXroc bogus code! scrollPort is relative to the viewport of + // this document, but we're intersecting rectangles derived from + // multiple documents and assuming they're all in the same coordinate + // system. See bug 514117. + bounds.IntersectRect(scrollPort, bounds); + } + else { // First time through loop + bounds = scrollPort; + } + + document = parentDoc = document->GetParentDocument(); + } + + return bounds; +} + +// DocAccessible protected member +nsresult +DocAccessible::AddEventListeners() +{ + nsCOMPtr<nsIDocShell> docShell(mDocumentNode->GetDocShell()); + + // We want to add a command observer only if the document is content and has + // an editor. + if (docShell->ItemType() == nsIDocShellTreeItem::typeContent) { + nsCOMPtr<nsICommandManager> commandManager = docShell->GetCommandManager(); + if (commandManager) + commandManager->AddCommandObserver(this, "obs_documentCreated"); + } + + SelectionMgr()->AddDocSelectionListener(mPresShell); + + // Add document observer. + mDocumentNode->AddObserver(this); + return NS_OK; +} + +// DocAccessible protected member +nsresult +DocAccessible::RemoveEventListeners() +{ + // Remove listeners associated with content documents + // Remove scroll position listener + RemoveScrollListener(); + + NS_ASSERTION(mDocumentNode, "No document during removal of listeners."); + + if (mDocumentNode) { + mDocumentNode->RemoveObserver(this); + + nsCOMPtr<nsIDocShell> docShell(mDocumentNode->GetDocShell()); + NS_ASSERTION(docShell, "doc should support nsIDocShellTreeItem."); + + if (docShell) { + if (docShell->ItemType() == nsIDocShellTreeItem::typeContent) { + nsCOMPtr<nsICommandManager> commandManager = docShell->GetCommandManager(); + if (commandManager) { + commandManager->RemoveCommandObserver(this, "obs_documentCreated"); + } + } + } + } + + if (mScrollWatchTimer) { + mScrollWatchTimer->Cancel(); + mScrollWatchTimer = nullptr; + NS_RELEASE_THIS(); // Kung fu death grip + } + + SelectionMgr()->RemoveDocSelectionListener(mPresShell); + return NS_OK; +} + +void +DocAccessible::ScrollTimerCallback(nsITimer* aTimer, void* aClosure) +{ + DocAccessible* docAcc = reinterpret_cast<DocAccessible*>(aClosure); + + if (docAcc && docAcc->mScrollPositionChangedTicks && + ++docAcc->mScrollPositionChangedTicks > 2) { + // Whenever scroll position changes, mScrollPositionChangeTicks gets reset to 1 + // We only want to fire accessibilty scroll event when scrolling stops or pauses + // Therefore, we wait for no scroll events to occur between 2 ticks of this timer + // That indicates a pause in scrolling, so we fire the accessibilty scroll event + nsEventShell::FireEvent(nsIAccessibleEvent::EVENT_SCROLLING_END, docAcc); + + docAcc->mScrollPositionChangedTicks = 0; + if (docAcc->mScrollWatchTimer) { + docAcc->mScrollWatchTimer->Cancel(); + docAcc->mScrollWatchTimer = nullptr; + NS_RELEASE(docAcc); // Release kung fu death grip + } + } +} + +//////////////////////////////////////////////////////////////////////////////// +// nsIScrollPositionListener + +void +DocAccessible::ScrollPositionDidChange(nscoord aX, nscoord aY) +{ + // Start new timer, if the timer cycles at least 1 full cycle without more scroll position changes, + // then the ::Notify() method will fire the accessibility event for scroll position changes + const uint32_t kScrollPosCheckWait = 50; + if (mScrollWatchTimer) { + mScrollWatchTimer->SetDelay(kScrollPosCheckWait); // Create new timer, to avoid leaks + } + else { + mScrollWatchTimer = do_CreateInstance("@mozilla.org/timer;1"); + if (mScrollWatchTimer) { + NS_ADDREF_THIS(); // Kung fu death grip + mScrollWatchTimer->InitWithFuncCallback(ScrollTimerCallback, this, + kScrollPosCheckWait, + nsITimer::TYPE_REPEATING_SLACK); + } + } + mScrollPositionChangedTicks = 1; +} + +//////////////////////////////////////////////////////////////////////////////// +// nsIObserver + +NS_IMETHODIMP +DocAccessible::Observe(nsISupports* aSubject, const char* aTopic, + const char16_t* aData) +{ + if (!nsCRT::strcmp(aTopic,"obs_documentCreated")) { + // State editable will now be set, readonly is now clear + // Normally we only fire delayed events created from the node, not an + // accessible object. See the AccStateChangeEvent constructor for details + // about this exceptional case. + RefPtr<AccEvent> event = + new AccStateChangeEvent(this, states::EDITABLE, true); + FireDelayedEvent(event); + } + + return NS_OK; +} + +//////////////////////////////////////////////////////////////////////////////// +// nsIAccessiblePivotObserver + +NS_IMETHODIMP +DocAccessible::OnPivotChanged(nsIAccessiblePivot* aPivot, + nsIAccessible* aOldAccessible, + int32_t aOldStart, int32_t aOldEnd, + PivotMoveReason aReason, + bool aIsFromUserInput) +{ + RefPtr<AccEvent> event = + new AccVCChangeEvent( + this, (aOldAccessible ? aOldAccessible->ToInternalAccessible() : nullptr), + aOldStart, aOldEnd, aReason, + aIsFromUserInput ? eFromUserInput : eNoUserInput); + nsEventShell::FireEvent(event); + + return NS_OK; +} + +//////////////////////////////////////////////////////////////////////////////// +// nsIDocumentObserver + +NS_IMPL_NSIDOCUMENTOBSERVER_CORE_STUB(DocAccessible) +NS_IMPL_NSIDOCUMENTOBSERVER_LOAD_STUB(DocAccessible) +NS_IMPL_NSIDOCUMENTOBSERVER_STYLE_STUB(DocAccessible) + +void +DocAccessible::AttributeWillChange(nsIDocument* aDocument, + dom::Element* aElement, + int32_t aNameSpaceID, + nsIAtom* aAttribute, int32_t aModType, + const nsAttrValue* aNewValue) +{ + Accessible* accessible = GetAccessible(aElement); + if (!accessible) { + if (aElement != mContent) + return; + + accessible = this; + } + + // Update dependent IDs cache. Take care of elements that are accessible + // because dependent IDs cache doesn't contain IDs from non accessible + // elements. + if (aModType != nsIDOMMutationEvent::ADDITION) + RemoveDependentIDsFor(accessible, aAttribute); + + if (aAttribute == nsGkAtoms::id) { + RelocateARIAOwnedIfNeeded(aElement); + } + + // Store the ARIA attribute old value so that it can be used after + // attribute change. Note, we assume there's no nested ARIA attribute + // changes. If this happens then we should end up with keeping a stack of + // old values. + + // XXX TODO: bugs 472142, 472143. + // Here we will want to cache whatever attribute values we are interested + // in, such as the existence of aria-pressed for button (so we know if we + // need to newly expose it as a toggle button) etc. + if (aAttribute == nsGkAtoms::aria_checked || + aAttribute == nsGkAtoms::aria_pressed) { + mARIAAttrOldValue = (aModType != nsIDOMMutationEvent::ADDITION) ? + nsAccUtils::GetARIAToken(aElement, aAttribute) : nullptr; + return; + } + + if (aAttribute == nsGkAtoms::aria_disabled || + aAttribute == nsGkAtoms::disabled) + mStateBitWasOn = accessible->Unavailable(); +} + +void +DocAccessible::NativeAnonymousChildListChange(nsIDocument* aDocument, + nsIContent* aContent, + bool aIsRemove) +{ +} + +void +DocAccessible::AttributeChanged(nsIDocument* aDocument, + dom::Element* aElement, + int32_t aNameSpaceID, nsIAtom* aAttribute, + int32_t aModType, + const nsAttrValue* aOldValue) +{ + NS_ASSERTION(!IsDefunct(), + "Attribute changed called on defunct document accessible!"); + + // Proceed even if the element is not accessible because element may become + // accessible if it gets certain attribute. + if (UpdateAccessibleOnAttrChange(aElement, aAttribute)) + return; + + // Ignore attribute change if the element doesn't have an accessible (at all + // or still) iff the element is not a root content of this document accessible + // (which is treated as attribute change on this document accessible). + // Note: we don't bail if all the content hasn't finished loading because + // these attributes are changing for a loaded part of the content. + Accessible* accessible = GetAccessible(aElement); + if (!accessible) { + if (mContent != aElement) + return; + + accessible = this; + } + + MOZ_ASSERT(accessible->IsBoundToParent() || accessible->IsDoc(), + "DOM attribute change on an accessible detached from the tree"); + + // Fire accessible events iff there's an accessible, otherwise we consider + // the accessible state wasn't changed, i.e. its state is initial state. + AttributeChangedImpl(accessible, aNameSpaceID, aAttribute); + + // Update dependent IDs cache. Take care of accessible elements because no + // accessible element means either the element is not accessible at all or + // its accessible will be created later. It doesn't make sense to keep + // dependent IDs for non accessible elements. For the second case we'll update + // dependent IDs cache when its accessible is created. + if (aModType == nsIDOMMutationEvent::MODIFICATION || + aModType == nsIDOMMutationEvent::ADDITION) { + AddDependentIDsFor(accessible, aAttribute); + } +} + +// DocAccessible protected member +void +DocAccessible::AttributeChangedImpl(Accessible* aAccessible, + int32_t aNameSpaceID, nsIAtom* aAttribute) +{ + // Fire accessible event after short timer, because we need to wait for + // DOM attribute & resulting layout to actually change. Otherwise, + // assistive technology will retrieve the wrong state/value/selection info. + + // XXX todo + // We still need to handle special HTML cases here + // For example, if an <img>'s usemap attribute is modified + // Otherwise it may just be a state change, for example an object changing + // its visibility + // + // XXX todo: report aria state changes for "undefined" literal value changes + // filed as bug 472142 + // + // XXX todo: invalidate accessible when aria state changes affect exposed role + // filed as bug 472143 + + // Universal boolean properties that don't require a role. Fire the state + // change when disabled or aria-disabled attribute is set. + // Note. Checking the XUL or HTML namespace would not seem to gain us + // anything, because disabled attribute really is going to mean the same + // thing in any namespace. + // Note. We use the attribute instead of the disabled state bit because + // ARIA's aria-disabled does not affect the disabled state bit. + if (aAttribute == nsGkAtoms::disabled || + aAttribute == nsGkAtoms::aria_disabled) { + // Do nothing if state wasn't changed (like @aria-disabled was removed but + // @disabled is still presented). + if (aAccessible->Unavailable() == mStateBitWasOn) + return; + + RefPtr<AccEvent> enabledChangeEvent = + new AccStateChangeEvent(aAccessible, states::ENABLED, mStateBitWasOn); + FireDelayedEvent(enabledChangeEvent); + + RefPtr<AccEvent> sensitiveChangeEvent = + new AccStateChangeEvent(aAccessible, states::SENSITIVE, mStateBitWasOn); + FireDelayedEvent(sensitiveChangeEvent); + return; + } + + // Check for namespaced ARIA attribute + if (aNameSpaceID == kNameSpaceID_None) { + // Check for hyphenated aria-foo property? + if (StringBeginsWith(nsDependentAtomString(aAttribute), + NS_LITERAL_STRING("aria-"))) { + ARIAAttributeChanged(aAccessible, aAttribute); + } + } + + // Fire name change and description change events. XXX: it's not complete and + // dupes the code logic of accessible name and description calculation, we do + // that for performance reasons. + if (aAttribute == nsGkAtoms::aria_label) { + FireDelayedEvent(nsIAccessibleEvent::EVENT_NAME_CHANGE, aAccessible); + return; + } + + if (aAttribute == nsGkAtoms::aria_describedby) { + FireDelayedEvent(nsIAccessibleEvent::EVENT_DESCRIPTION_CHANGE, aAccessible); + return; + } + + nsIContent* elm = aAccessible->GetContent(); + if (aAttribute == nsGkAtoms::aria_labelledby && + !elm->HasAttr(kNameSpaceID_None, nsGkAtoms::aria_label)) { + FireDelayedEvent(nsIAccessibleEvent::EVENT_NAME_CHANGE, aAccessible); + return; + } + + if (aAttribute == nsGkAtoms::alt && + !elm->HasAttr(kNameSpaceID_None, nsGkAtoms::aria_label) && + !elm->HasAttr(kNameSpaceID_None, nsGkAtoms::aria_labelledby)) { + FireDelayedEvent(nsIAccessibleEvent::EVENT_NAME_CHANGE, aAccessible); + return; + } + + if (aAttribute == nsGkAtoms::title) { + if (!elm->HasAttr(kNameSpaceID_None, nsGkAtoms::aria_label) && + !elm->HasAttr(kNameSpaceID_None, nsGkAtoms::aria_labelledby) && + !elm->HasAttr(kNameSpaceID_None, nsGkAtoms::alt)) { + FireDelayedEvent(nsIAccessibleEvent::EVENT_NAME_CHANGE, aAccessible); + return; + } + + if (!elm->HasAttr(kNameSpaceID_None, nsGkAtoms::aria_describedby)) + FireDelayedEvent(nsIAccessibleEvent::EVENT_DESCRIPTION_CHANGE, aAccessible); + + return; + } + + if (aAttribute == nsGkAtoms::aria_busy) { + bool isOn = elm->AttrValueIs(aNameSpaceID, aAttribute, nsGkAtoms::_true, + eCaseMatters); + RefPtr<AccEvent> event = + new AccStateChangeEvent(aAccessible, states::BUSY, isOn); + FireDelayedEvent(event); + return; + } + + if (aAttribute == nsGkAtoms::id) { + RelocateARIAOwnedIfNeeded(elm); + } + + // ARIA or XUL selection + if ((aAccessible->GetContent()->IsXULElement() && + aAttribute == nsGkAtoms::selected) || + aAttribute == nsGkAtoms::aria_selected) { + Accessible* widget = + nsAccUtils::GetSelectableContainer(aAccessible, aAccessible->State()); + if (widget) { + AccSelChangeEvent::SelChangeType selChangeType = + elm->AttrValueIs(aNameSpaceID, aAttribute, nsGkAtoms::_true, eCaseMatters) ? + AccSelChangeEvent::eSelectionAdd : AccSelChangeEvent::eSelectionRemove; + + RefPtr<AccEvent> event = + new AccSelChangeEvent(widget, aAccessible, selChangeType); + FireDelayedEvent(event); + } + + return; + } + + if (aAttribute == nsGkAtoms::contenteditable) { + RefPtr<AccEvent> editableChangeEvent = + new AccStateChangeEvent(aAccessible, states::EDITABLE); + FireDelayedEvent(editableChangeEvent); + return; + } + + if (aAttribute == nsGkAtoms::value) { + if (aAccessible->IsProgress()) + FireDelayedEvent(nsIAccessibleEvent::EVENT_VALUE_CHANGE, aAccessible); + } +} + +// DocAccessible protected member +void +DocAccessible::ARIAAttributeChanged(Accessible* aAccessible, nsIAtom* aAttribute) +{ + // Note: For universal/global ARIA states and properties we don't care if + // there is an ARIA role present or not. + + if (aAttribute == nsGkAtoms::aria_required) { + RefPtr<AccEvent> event = + new AccStateChangeEvent(aAccessible, states::REQUIRED); + FireDelayedEvent(event); + return; + } + + if (aAttribute == nsGkAtoms::aria_invalid) { + RefPtr<AccEvent> event = + new AccStateChangeEvent(aAccessible, states::INVALID); + FireDelayedEvent(event); + return; + } + + // The activedescendant universal property redirects accessible focus events + // to the element with the id that activedescendant points to. Make sure + // the tree up to date before processing. + if (aAttribute == nsGkAtoms::aria_activedescendant) { + mNotificationController->HandleNotification<DocAccessible, Accessible> + (this, &DocAccessible::ARIAActiveDescendantChanged, aAccessible); + + return; + } + + // We treat aria-expanded as a global ARIA state for historical reasons + if (aAttribute == nsGkAtoms::aria_expanded) { + RefPtr<AccEvent> event = + new AccStateChangeEvent(aAccessible, states::EXPANDED); + FireDelayedEvent(event); + return; + } + + // For aria attributes like drag and drop changes we fire a generic attribute + // change event; at least until native API comes up with a more meaningful event. + uint8_t attrFlags = aria::AttrCharacteristicsFor(aAttribute); + if (!(attrFlags & ATTR_BYPASSOBJ)) { + RefPtr<AccEvent> event = + new AccObjectAttrChangedEvent(aAccessible, aAttribute); + FireDelayedEvent(event); + } + + nsIContent* elm = aAccessible->GetContent(); + + // Update aria-hidden flag for the whole subtree iff aria-hidden is changed + // on the root, i.e. ignore any affiliated aria-hidden changes in the subtree + // of top aria-hidden. + if (aAttribute == nsGkAtoms::aria_hidden) { + bool isDefined = aria::HasDefinedARIAHidden(elm); + if (isDefined != aAccessible->IsARIAHidden() && + (!aAccessible->Parent() || !aAccessible->Parent()->IsARIAHidden())) { + aAccessible->SetARIAHidden(isDefined); + + RefPtr<AccEvent> event = + new AccObjectAttrChangedEvent(aAccessible, aAttribute); + FireDelayedEvent(event); + } + return; + } + + if (aAttribute == nsGkAtoms::aria_checked || + (aAccessible->IsButton() && + aAttribute == nsGkAtoms::aria_pressed)) { + const uint64_t kState = (aAttribute == nsGkAtoms::aria_checked) ? + states::CHECKED : states::PRESSED; + RefPtr<AccEvent> event = new AccStateChangeEvent(aAccessible, kState); + FireDelayedEvent(event); + + bool wasMixed = (mARIAAttrOldValue == nsGkAtoms::mixed); + bool isMixed = elm->AttrValueIs(kNameSpaceID_None, aAttribute, + nsGkAtoms::mixed, eCaseMatters); + if (isMixed != wasMixed) { + RefPtr<AccEvent> event = + new AccStateChangeEvent(aAccessible, states::MIXED, isMixed); + FireDelayedEvent(event); + } + return; + } + + if (aAttribute == nsGkAtoms::aria_readonly) { + RefPtr<AccEvent> event = + new AccStateChangeEvent(aAccessible, states::READONLY); + FireDelayedEvent(event); + return; + } + + // Fire text value change event whenever aria-valuetext is changed. + if (aAttribute == nsGkAtoms::aria_valuetext) { + FireDelayedEvent(nsIAccessibleEvent::EVENT_TEXT_VALUE_CHANGE, aAccessible); + return; + } + + // Fire numeric value change event when aria-valuenow is changed and + // aria-valuetext is empty + if (aAttribute == nsGkAtoms::aria_valuenow && + (!elm->HasAttr(kNameSpaceID_None, nsGkAtoms::aria_valuetext) || + elm->AttrValueIs(kNameSpaceID_None, nsGkAtoms::aria_valuetext, + nsGkAtoms::_empty, eCaseMatters))) { + FireDelayedEvent(nsIAccessibleEvent::EVENT_VALUE_CHANGE, aAccessible); + return; + } + + if (aAttribute == nsGkAtoms::aria_owns) { + mNotificationController->ScheduleRelocation(aAccessible); + } +} + +void +DocAccessible::ARIAActiveDescendantChanged(Accessible* aAccessible) +{ + nsIContent* elm = aAccessible->GetContent(); + if (elm && aAccessible->IsActiveWidget()) { + nsAutoString id; + if (elm->GetAttr(kNameSpaceID_None, nsGkAtoms::aria_activedescendant, id)) { + dom::Element* activeDescendantElm = elm->OwnerDoc()->GetElementById(id); + if (activeDescendantElm) { + Accessible* activeDescendant = GetAccessible(activeDescendantElm); + if (activeDescendant) { + FocusMgr()->ActiveItemChanged(activeDescendant, false); +#ifdef A11Y_LOG + if (logging::IsEnabled(logging::eFocus)) + logging::ActiveItemChangeCausedBy("ARIA activedescedant changed", + activeDescendant); +#endif + } + } + } + } +} + +void +DocAccessible::ContentAppended(nsIDocument* aDocument, + nsIContent* aContainer, + nsIContent* aFirstNewContent, + int32_t /* unused */) +{ +} + +void +DocAccessible::ContentStateChanged(nsIDocument* aDocument, + nsIContent* aContent, + EventStates aStateMask) +{ + Accessible* accessible = GetAccessible(aContent); + if (!accessible) + return; + + if (aStateMask.HasState(NS_EVENT_STATE_CHECKED)) { + Accessible* widget = accessible->ContainerWidget(); + if (widget && widget->IsSelect()) { + AccSelChangeEvent::SelChangeType selChangeType = + aContent->AsElement()->State().HasState(NS_EVENT_STATE_CHECKED) ? + AccSelChangeEvent::eSelectionAdd : AccSelChangeEvent::eSelectionRemove; + RefPtr<AccEvent> event = + new AccSelChangeEvent(widget, accessible, selChangeType); + FireDelayedEvent(event); + return; + } + + RefPtr<AccEvent> event = + new AccStateChangeEvent(accessible, states::CHECKED, + aContent->AsElement()->State().HasState(NS_EVENT_STATE_CHECKED)); + FireDelayedEvent(event); + } + + if (aStateMask.HasState(NS_EVENT_STATE_INVALID)) { + RefPtr<AccEvent> event = + new AccStateChangeEvent(accessible, states::INVALID, true); + FireDelayedEvent(event); + } + + if (aStateMask.HasState(NS_EVENT_STATE_VISITED)) { + RefPtr<AccEvent> event = + new AccStateChangeEvent(accessible, states::TRAVERSED, true); + FireDelayedEvent(event); + } +} + +void +DocAccessible::DocumentStatesChanged(nsIDocument* aDocument, + EventStates aStateMask) +{ +} + +void +DocAccessible::CharacterDataWillChange(nsIDocument* aDocument, + nsIContent* aContent, + CharacterDataChangeInfo* aInfo) +{ +} + +void +DocAccessible::CharacterDataChanged(nsIDocument* aDocument, + nsIContent* aContent, + CharacterDataChangeInfo* aInfo) +{ +} + +void +DocAccessible::ContentInserted(nsIDocument* aDocument, nsIContent* aContainer, + nsIContent* aChild, int32_t /* unused */) +{ +} + +void +DocAccessible::ContentRemoved(nsIDocument* aDocument, + nsIContent* aContainerNode, + nsIContent* aChildNode, int32_t /* unused */, + nsIContent* aPreviousSiblingNode) +{ +#ifdef A11Y_LOG + if (logging::IsEnabled(logging::eTree)) { + logging::MsgBegin("TREE", "DOM content removed; doc: %p", this); + logging::Node("container node", aContainerNode); + logging::Node("content node", aChildNode); + logging::MsgEnd(); + } +#endif + // This one and content removal notification from layout may result in + // double processing of same subtrees. If it pops up in profiling, then + // consider reusing a document node cache to reject these notifications early. + Accessible* container = GetAccessibleOrContainer(aContainerNode); + if (container) { + UpdateTreeOnRemoval(container, aChildNode); + } +} + +void +DocAccessible::ParentChainChanged(nsIContent* aContent) +{ +} + + +//////////////////////////////////////////////////////////////////////////////// +// Accessible + +#ifdef A11Y_LOG +nsresult +DocAccessible::HandleAccEvent(AccEvent* aEvent) +{ + if (logging::IsEnabled(logging::eDocLoad)) + logging::DocLoadEventHandled(aEvent); + + return HyperTextAccessible::HandleAccEvent(aEvent); +} +#endif + +//////////////////////////////////////////////////////////////////////////////// +// Public members + +void* +DocAccessible::GetNativeWindow() const +{ + if (!mPresShell) + return nullptr; + + nsViewManager* vm = mPresShell->GetViewManager(); + if (!vm) + return nullptr; + + nsCOMPtr<nsIWidget> widget; + vm->GetRootWidget(getter_AddRefs(widget)); + if (widget) + return widget->GetNativeData(NS_NATIVE_WINDOW); + + return nullptr; +} + +Accessible* +DocAccessible::GetAccessibleByUniqueIDInSubtree(void* aUniqueID) +{ + Accessible* child = GetAccessibleByUniqueID(aUniqueID); + if (child) + return child; + + uint32_t childDocCount = mChildDocuments.Length(); + for (uint32_t childDocIdx= 0; childDocIdx < childDocCount; childDocIdx++) { + DocAccessible* childDocument = mChildDocuments.ElementAt(childDocIdx); + child = childDocument->GetAccessibleByUniqueIDInSubtree(aUniqueID); + if (child) + return child; + } + + return nullptr; +} + +Accessible* +DocAccessible::GetAccessibleOrContainer(nsINode* aNode) const +{ + if (!aNode || !aNode->GetComposedDoc()) + return nullptr; + + nsINode* currNode = aNode; + Accessible* accessible = nullptr; + while (!(accessible = GetAccessible(currNode))) { + nsINode* parent = nullptr; + + // If this is a content node, try to get a flattened parent content node. + // This will smartly skip from the shadow root to the host element, + // over parentless document fragment + if (currNode->IsContent()) + parent = currNode->AsContent()->GetFlattenedTreeParent(); + + // Fallback to just get parent node, in case there is no parent content + // node. Or current node is not a content node. + if (!parent) + parent = currNode->GetParentNode(); + + if (!(currNode = parent)) break; + } + + return accessible; +} + +Accessible* +DocAccessible::GetAccessibleOrDescendant(nsINode* aNode) const +{ + Accessible* acc = GetAccessible(aNode); + if (acc) + return acc; + + acc = GetContainerAccessible(aNode); + if (acc) { + uint32_t childCnt = acc->ChildCount(); + for (uint32_t idx = 0; idx < childCnt; idx++) { + Accessible* child = acc->GetChildAt(idx); + for (nsIContent* elm = child->GetContent(); + elm && elm != acc->GetContent(); + elm = elm->GetFlattenedTreeParent()) { + if (elm == aNode) + return child; + } + } + } + + return nullptr; +} + +void +DocAccessible::BindToDocument(Accessible* aAccessible, + const nsRoleMapEntry* aRoleMapEntry) +{ + // Put into DOM node cache. + if (aAccessible->IsNodeMapEntry()) + mNodeToAccessibleMap.Put(aAccessible->GetNode(), aAccessible); + + // Put into unique ID cache. + mAccessibleCache.Put(aAccessible->UniqueID(), aAccessible); + + aAccessible->SetRoleMapEntry(aRoleMapEntry); + + AddDependentIDsFor(aAccessible); + + if (aAccessible->HasOwnContent()) { + nsIContent* el = aAccessible->GetContent(); + if (el->HasAttr(kNameSpaceID_None, nsGkAtoms::aria_owns)) { + mNotificationController->ScheduleRelocation(aAccessible); + } + } +} + +void +DocAccessible::UnbindFromDocument(Accessible* aAccessible) +{ + NS_ASSERTION(mAccessibleCache.GetWeak(aAccessible->UniqueID()), + "Unbinding the unbound accessible!"); + + // Fire focus event on accessible having DOM focus if active item was removed + // from the tree. + if (FocusMgr()->IsActiveItem(aAccessible)) { + FocusMgr()->ActiveItemChanged(nullptr); +#ifdef A11Y_LOG + if (logging::IsEnabled(logging::eFocus)) + logging::ActiveItemChangeCausedBy("tree shutdown", aAccessible); +#endif + } + + // Remove an accessible from node-to-accessible map if it exists there. + if (aAccessible->IsNodeMapEntry() && + mNodeToAccessibleMap.Get(aAccessible->GetNode()) == aAccessible) + mNodeToAccessibleMap.Remove(aAccessible->GetNode()); + + aAccessible->mStateFlags |= eIsNotInDocument; + + // Update XPCOM part. + xpcAccessibleDocument* xpcDoc = GetAccService()->GetCachedXPCDocument(this); + if (xpcDoc) + xpcDoc->NotifyOfShutdown(aAccessible); + + void* uniqueID = aAccessible->UniqueID(); + + NS_ASSERTION(!aAccessible->IsDefunct(), "Shutdown the shutdown accessible!"); + aAccessible->Shutdown(); + + mAccessibleCache.Remove(uniqueID); +} + +void +DocAccessible::ContentInserted(nsIContent* aContainerNode, + nsIContent* aStartChildNode, + nsIContent* aEndChildNode) +{ + // Ignore content insertions until we constructed accessible tree. Otherwise + // schedule tree update on content insertion after layout. + if (mNotificationController && HasLoadState(eTreeConstructed)) { + // Update the whole tree of this document accessible when the container is + // null (document element is inserted or removed). + Accessible* container = aContainerNode ? + AccessibleOrTrueContainer(aContainerNode) : this; + if (container) { + // Ignore notification if the container node is no longer in the DOM tree. + mNotificationController->ScheduleContentInsertion(container, + aStartChildNode, + aEndChildNode); + } + } +} + +void +DocAccessible::RecreateAccessible(nsIContent* aContent) +{ +#ifdef A11Y_LOG + if (logging::IsEnabled(logging::eTree)) { + logging::MsgBegin("TREE", "accessible recreated"); + logging::Node("content", aContent); + logging::MsgEnd(); + } +#endif + + // XXX: we shouldn't recreate whole accessible subtree, instead we should + // subclass hide and show events to handle them separately and implement their + // coalescence with normal hide and show events. Note, in this case they + // should be coalesced with normal show/hide events. + + nsIContent* parent = aContent->GetFlattenedTreeParent(); + ContentRemoved(parent, aContent); + ContentInserted(parent, aContent, aContent->GetNextSibling()); +} + +void +DocAccessible::ProcessInvalidationList() +{ + // Invalidate children of container accessible for each element in + // invalidation list. Allow invalidation list insertions while container + // children are recached. + for (uint32_t idx = 0; idx < mInvalidationList.Length(); idx++) { + nsIContent* content = mInvalidationList[idx]; + if (!HasAccessible(content) && content->HasID()) { + Accessible* container = GetContainerAccessible(content); + if (container) { + // Check if the node is a target of aria-owns, and if so, don't process + // it here and let DoARIAOwnsRelocation process it. + AttrRelProviderArray* list = + mDependentIDsHash.Get(nsDependentAtomString(content->GetID())); + bool shouldProcess = !!list; + if (shouldProcess) { + for (uint32_t idx = 0; idx < list->Length(); idx++) { + if (list->ElementAt(idx)->mRelAttr == nsGkAtoms::aria_owns) { + shouldProcess = false; + break; + } + } + + if (shouldProcess) { + ProcessContentInserted(container, content); + } + } + } + } + } + + mInvalidationList.Clear(); +} + +Accessible* +DocAccessible::GetAccessibleEvenIfNotInMap(nsINode* aNode) const +{ +if (!aNode->IsContent() || !aNode->AsContent()->IsHTMLElement(nsGkAtoms::area)) + return GetAccessible(aNode); + + // XXX Bug 135040, incorrect when multiple images use the same map. + nsIFrame* frame = aNode->AsContent()->GetPrimaryFrame(); + nsImageFrame* imageFrame = do_QueryFrame(frame); + if (imageFrame) { + Accessible* parent = GetAccessible(imageFrame->GetContent()); + if (parent) { + Accessible* area = + parent->AsImageMap()->GetChildAccessibleFor(aNode); + if (area) + return area; + + return nullptr; + } + } + + return GetAccessible(aNode); +} + +//////////////////////////////////////////////////////////////////////////////// +// Protected members + +void +DocAccessible::NotifyOfLoading(bool aIsReloading) +{ + // Mark the document accessible as loading, if it stays alive then we'll mark + // it as loaded when we receive proper notification. + mLoadState &= ~eDOMLoaded; + + if (!IsLoadEventTarget()) + return; + + if (aIsReloading) { + // Fire reload and state busy events on existing document accessible while + // event from user input flag can be calculated properly and accessible + // is alive. When new document gets loaded then this one is destroyed. + RefPtr<AccEvent> reloadEvent = + new AccEvent(nsIAccessibleEvent::EVENT_DOCUMENT_RELOAD, this); + nsEventShell::FireEvent(reloadEvent); + } + + // Fire state busy change event. Use delayed event since we don't care + // actually if event isn't delivered when the document goes away like a shot. + RefPtr<AccEvent> stateEvent = + new AccStateChangeEvent(this, states::BUSY, true); + FireDelayedEvent(stateEvent); +} + +void +DocAccessible::DoInitialUpdate() +{ + if (nsCoreUtils::IsTabDocument(mDocumentNode)) + mDocFlags |= eTabDocument; + + mLoadState |= eTreeConstructed; + + // Set up a root element and ARIA role mapping. + UpdateRootElIfNeeded(); + + // Build initial tree. + CacheChildrenInSubtree(this); +#ifdef A11Y_LOG + if (logging::IsEnabled(logging::eVerbose)) { + logging::Tree("TREE", "Initial subtree", this); + } +#endif + + // Fire reorder event after the document tree is constructed. Note, since + // this reorder event is processed by parent document then events targeted to + // this document may be fired prior to this reorder event. If this is + // a problem then consider to keep event processing per tab document. + if (!IsRoot()) { + RefPtr<AccReorderEvent> reorderEvent = new AccReorderEvent(Parent()); + ParentDocument()->FireDelayedEvent(reorderEvent); + } + + TreeMutation mt(this); + uint32_t childCount = ChildCount(); + for (uint32_t i = 0; i < childCount; i++) { + Accessible* child = GetChildAt(i); + mt.AfterInsertion(child); + } + mt.Done(); +} + +void +DocAccessible::ProcessLoad() +{ + mLoadState |= eCompletelyLoaded; + +#ifdef A11Y_LOG + if (logging::IsEnabled(logging::eDocLoad)) + logging::DocCompleteLoad(this, IsLoadEventTarget()); +#endif + + // Do not fire document complete/stop events for root chrome document + // accessibles and for frame/iframe documents because + // a) screen readers start working on focus event in the case of root chrome + // documents + // b) document load event on sub documents causes screen readers to act is if + // entire page is reloaded. + if (!IsLoadEventTarget()) + return; + + // Fire complete/load stopped if the load event type is given. + if (mLoadEventType) { + RefPtr<AccEvent> loadEvent = new AccEvent(mLoadEventType, this); + FireDelayedEvent(loadEvent); + + mLoadEventType = 0; + } + + // Fire busy state change event. + RefPtr<AccEvent> stateEvent = + new AccStateChangeEvent(this, states::BUSY, false); + FireDelayedEvent(stateEvent); +} + +void +DocAccessible::AddDependentIDsFor(Accessible* aRelProvider, nsIAtom* aRelAttr) +{ + dom::Element* relProviderEl = aRelProvider->Elm(); + if (!relProviderEl) + return; + + for (uint32_t idx = 0; idx < kRelationAttrsLen; idx++) { + nsIAtom* relAttr = *kRelationAttrs[idx]; + if (aRelAttr && aRelAttr != relAttr) + continue; + + if (relAttr == nsGkAtoms::_for) { + if (!relProviderEl->IsAnyOfHTMLElements(nsGkAtoms::label, + nsGkAtoms::output)) + continue; + + } else if (relAttr == nsGkAtoms::control) { + if (!relProviderEl->IsAnyOfXULElements(nsGkAtoms::label, + nsGkAtoms::description)) + continue; + } + + IDRefsIterator iter(this, relProviderEl, relAttr); + while (true) { + const nsDependentSubstring id = iter.NextID(); + if (id.IsEmpty()) + break; + + AttrRelProviderArray* providers = mDependentIDsHash.Get(id); + if (!providers) { + providers = new AttrRelProviderArray(); + if (providers) { + mDependentIDsHash.Put(id, providers); + } + } + + if (providers) { + AttrRelProvider* provider = + new AttrRelProvider(relAttr, relProviderEl); + if (provider) { + providers->AppendElement(provider); + + // We've got here during the children caching. If the referenced + // content is not accessible then store it to pend its container + // children invalidation (this happens immediately after the caching + // is finished). + nsIContent* dependentContent = iter.GetElem(id); + if (dependentContent) { + if (!HasAccessible(dependentContent)) { + mInvalidationList.AppendElement(dependentContent); + } + } + } + } + } + + // If the relation attribute is given then we don't have anything else to + // check. + if (aRelAttr) + break; + } + + // Make sure to schedule the tree update if needed. + mNotificationController->ScheduleProcessing(); +} + +void +DocAccessible::RemoveDependentIDsFor(Accessible* aRelProvider, + nsIAtom* aRelAttr) +{ + dom::Element* relProviderElm = aRelProvider->Elm(); + if (!relProviderElm) + return; + + for (uint32_t idx = 0; idx < kRelationAttrsLen; idx++) { + nsIAtom* relAttr = *kRelationAttrs[idx]; + if (aRelAttr && aRelAttr != *kRelationAttrs[idx]) + continue; + + IDRefsIterator iter(this, relProviderElm, relAttr); + while (true) { + const nsDependentSubstring id = iter.NextID(); + if (id.IsEmpty()) + break; + + AttrRelProviderArray* providers = mDependentIDsHash.Get(id); + if (providers) { + for (uint32_t jdx = 0; jdx < providers->Length(); ) { + AttrRelProvider* provider = (*providers)[jdx]; + if (provider->mRelAttr == relAttr && + provider->mContent == relProviderElm) + providers->RemoveElement(provider); + else + jdx++; + } + if (providers->Length() == 0) + mDependentIDsHash.Remove(id); + } + } + + // If the relation attribute is given then we don't have anything else to + // check. + if (aRelAttr) + break; + } +} + +bool +DocAccessible::UpdateAccessibleOnAttrChange(dom::Element* aElement, + nsIAtom* aAttribute) +{ + if (aAttribute == nsGkAtoms::role) { + // It is common for js libraries to set the role on the body element after + // the document has loaded. In this case we just update the role map entry. + if (mContent == aElement) { + SetRoleMapEntry(aria::GetRoleMap(aElement)); + if (mIPCDoc) { + mIPCDoc->SendRoleChangedEvent(Role()); + } + + return true; + } + + // Recreate the accessible when role is changed because we might require a + // different accessible class for the new role or the accessible may expose + // a different sets of interfaces (COM restriction). + RecreateAccessible(aElement); + + return true; + } + + if (aAttribute == nsGkAtoms::href) { + // Not worth the expense to ensure which namespace these are in. It doesn't + // kill use to recreate the accessible even if the attribute was used in + // the wrong namespace or an element that doesn't support it. + + // Make sure the accessible is recreated asynchronously to allow the content + // to handle the attribute change. + RecreateAccessible(aElement); + return true; + } + + if (aAttribute == nsGkAtoms::aria_multiselectable && + aElement->HasAttr(kNameSpaceID_None, nsGkAtoms::role)) { + // This affects whether the accessible supports SelectAccessible. + // COM says we cannot change what interfaces are supported on-the-fly, + // so invalidate this object. A new one will be created on demand. + RecreateAccessible(aElement); + + return true; + } + + return false; +} + +void +DocAccessible::UpdateRootElIfNeeded() +{ + dom::Element* rootEl = mDocumentNode->GetBodyElement(); + if (!rootEl) { + rootEl = mDocumentNode->GetRootElement(); + } + if (rootEl != mContent) { + mContent = rootEl; + SetRoleMapEntry(aria::GetRoleMap(rootEl)); + if (mIPCDoc) { + mIPCDoc->SendRoleChangedEvent(Role()); + } + } +} + +/** + * Content insertion helper. + */ +class InsertIterator final +{ +public: + InsertIterator(Accessible* aContext, + const nsTArray<nsCOMPtr<nsIContent> >* aNodes) : + mChild(nullptr), mChildBefore(nullptr), mWalker(aContext), + mNodes(aNodes), mNodesIdx(0) + { + MOZ_ASSERT(aContext, "No context"); + MOZ_ASSERT(aNodes, "No nodes to search for accessible elements"); + MOZ_COUNT_CTOR(InsertIterator); + } + ~InsertIterator() { MOZ_COUNT_DTOR(InsertIterator); } + + Accessible* Context() const { return mWalker.Context(); } + Accessible* Child() const { return mChild; } + Accessible* ChildBefore() const { return mChildBefore; } + DocAccessible* Document() const { return mWalker.Document(); } + + /** + * Iterates to a next accessible within the inserted content. + */ + bool Next(); + + void Rejected() + { + mChild = nullptr; + mChildBefore = nullptr; + } + +private: + Accessible* mChild; + Accessible* mChildBefore; + TreeWalker mWalker; + + const nsTArray<nsCOMPtr<nsIContent> >* mNodes; + uint32_t mNodesIdx; +}; + +bool +InsertIterator::Next() +{ + if (mNodesIdx > 0) { + Accessible* nextChild = mWalker.Next(); + if (nextChild) { + mChildBefore = mChild; + mChild = nextChild; + return true; + } + } + + while (mNodesIdx < mNodes->Length()) { + // Ignore nodes that are not contained by the container anymore. + + // The container might be changed, for example, because of the subsequent + // overlapping content insertion (i.e. other content was inserted between + // this inserted content and its container or the content was reinserted + // into different container of unrelated part of tree). To avoid a double + // processing of the content insertion ignore this insertion notification. + // Note, the inserted content might be not in tree at all at this point + // what means there's no container. Ignore the insertion too. + nsIContent* prevNode = mNodes->SafeElementAt(mNodesIdx - 1); + nsIContent* node = mNodes->ElementAt(mNodesIdx++); + Accessible* container = Document()->AccessibleOrTrueContainer(node); + if (container != Context()) { + continue; + } + + // HTML comboboxes have no-content list accessible as an intermediate + // containing all options. + if (container->IsHTMLCombobox()) { + container = container->FirstChild(); + } + + if (!container->IsAcceptableChild(node)) { + continue; + } + +#ifdef A11Y_LOG + logging::TreeInfo("traversing an inserted node", logging::eVerbose, + "container", container, "node", node); +#endif + + // If inserted nodes are siblings then just move the walker next. + if (mChild && prevNode && prevNode->GetNextSibling() == node) { + Accessible* nextChild = mWalker.Scope(node); + if (nextChild) { + mChildBefore = mChild; + mChild = nextChild; + return true; + } + } + else { + TreeWalker finder(container); + if (finder.Seek(node)) { + mChild = mWalker.Scope(node); + if (mChild) { + mChildBefore = finder.Prev(); + return true; + } + } + } + } + + return false; +} + +void +DocAccessible::ProcessContentInserted(Accessible* aContainer, + const nsTArray<nsCOMPtr<nsIContent> >* aNodes) +{ + // Process insertions if the container accessible is still in tree. + if (!aContainer->IsInDocument()) { + return; + } + + // If new root content has been inserted then update it. + if (aContainer == this) { + UpdateRootElIfNeeded(); + } + + InsertIterator iter(aContainer, aNodes); + if (!iter.Next()) { + return; + } + +#ifdef A11Y_LOG + logging::TreeInfo("children before insertion", logging::eVerbose, + aContainer); +#endif + + TreeMutation mt(aContainer); + do { + Accessible* parent = iter.Child()->Parent(); + if (parent) { + if (parent != aContainer) { +#ifdef A11Y_LOG + logging::TreeInfo("stealing accessible", 0, + "old parent", parent, "new parent", + aContainer, "child", iter.Child(), nullptr); +#endif + MOZ_ASSERT_UNREACHABLE("stealing accessible"); + continue; + } + +#ifdef A11Y_LOG + logging::TreeInfo("binding to same parent", logging::eVerbose, + "parent", aContainer, "child", iter.Child(), nullptr); +#endif + continue; + } + + if (aContainer->InsertAfter(iter.Child(), iter.ChildBefore())) { +#ifdef A11Y_LOG + logging::TreeInfo("accessible was inserted", 0, + "container", aContainer, "child", iter.Child(), nullptr); +#endif + + CreateSubtree(iter.Child()); + mt.AfterInsertion(iter.Child()); + continue; + } + + MOZ_ASSERT_UNREACHABLE("accessible was rejected"); + iter.Rejected(); + } while (iter.Next()); + + mt.Done(); + +#ifdef A11Y_LOG + logging::TreeInfo("children after insertion", logging::eVerbose, + aContainer); +#endif + + FireEventsOnInsertion(aContainer); +} + +void +DocAccessible::ProcessContentInserted(Accessible* aContainer, nsIContent* aNode) +{ + if (!aContainer->IsInDocument()) { + return; + } + +#ifdef A11Y_LOG + logging::TreeInfo("children before insertion", logging::eVerbose, aContainer); +#endif + +#ifdef A11Y_LOG + logging::TreeInfo("traversing an inserted node", logging::eVerbose, + "container", aContainer, "node", aNode); +#endif + + TreeWalker walker(aContainer); + if (aContainer->IsAcceptableChild(aNode) && walker.Seek(aNode)) { + Accessible* child = GetAccessible(aNode); + if (!child) { + child = GetAccService()->CreateAccessible(aNode, aContainer); + } + + if (child) { + TreeMutation mt(aContainer); + if (!aContainer->InsertAfter(child, walker.Prev())) { + return; + } + CreateSubtree(child); + mt.AfterInsertion(child); + mt.Done(); + + FireEventsOnInsertion(aContainer); + } + } + +#ifdef A11Y_LOG + logging::TreeInfo("children after insertion", logging::eVerbose, aContainer); +#endif +} + +void +DocAccessible::FireEventsOnInsertion(Accessible* aContainer) +{ + // Check to see if change occurred inside an alert, and fire an EVENT_ALERT + // if it did. + if (aContainer->IsAlert() || aContainer->IsInsideAlert()) { + Accessible* ancestor = aContainer; + do { + if (ancestor->IsAlert()) { + FireDelayedEvent(nsIAccessibleEvent::EVENT_ALERT, ancestor); + break; + } + } + while ((ancestor = ancestor->Parent())); + } +} + +void +DocAccessible::UpdateTreeOnRemoval(Accessible* aContainer, nsIContent* aChildNode) +{ + // If child node is not accessible then look for its accessible children. + Accessible* child = GetAccessible(aChildNode); +#ifdef A11Y_LOG + logging::TreeInfo("process content removal", 0, + "container", aContainer, "child", aChildNode); +#endif + + TreeMutation mt(aContainer); + if (child) { + RefPtr<Accessible> kungFuDeathGripChild(child); + mt.BeforeRemoval(child); + if (child->IsDefunct()) { + return; // event coalescence may kill us + } + + MOZ_ASSERT(aContainer == child->Parent(), "Wrong parent"); + aContainer->RemoveChild(child); + UncacheChildrenInSubtree(child); + mt.Done(); + return; + } + + TreeWalker walker(aContainer, aChildNode, TreeWalker::eWalkCache); + while (Accessible* child = walker.Next()) { + RefPtr<Accessible> kungFuDeathGripChild(child); + mt.BeforeRemoval(child); + if (child->IsDefunct()) { + return; // event coalescence may kill us + } + + MOZ_ASSERT(aContainer == child->Parent(), "Wrong parent"); + aContainer->RemoveChild(child); + UncacheChildrenInSubtree(child); + } + mt.Done(); +} + +bool +DocAccessible::RelocateARIAOwnedIfNeeded(nsIContent* aElement) +{ + if (!aElement->HasID()) + return false; + + AttrRelProviderArray* list = + mDependentIDsHash.Get(nsDependentAtomString(aElement->GetID())); + if (list) { + for (uint32_t idx = 0; idx < list->Length(); idx++) { + if (list->ElementAt(idx)->mRelAttr == nsGkAtoms::aria_owns) { + Accessible* owner = GetAccessible(list->ElementAt(idx)->mContent); + if (owner) { + mNotificationController->ScheduleRelocation(owner); + return true; + } + } + } + } + + return false; +} + +void +DocAccessible::ValidateARIAOwned() +{ + for (auto it = mARIAOwnsHash.Iter(); !it.Done(); it.Next()) { + Accessible* owner = it.Key(); + nsTArray<RefPtr<Accessible> >* children = it.UserData(); + + // Owner is about to die, put children back if applicable. + if (!mAccessibleCache.GetWeak(reinterpret_cast<void*>(owner)) || + !owner->IsInDocument()) { + PutChildrenBack(children, 0); + it.Remove(); + continue; + } + + for (uint32_t idx = 0; idx < children->Length(); idx++) { + Accessible* child = children->ElementAt(idx); + if (!child->IsInDocument()) { + children->RemoveElementAt(idx); + idx--; + continue; + } + + NS_ASSERTION(child->Parent(), "No parent for ARIA owned?"); + + // If DOM node doesn't have a frame anymore then shutdown its accessible. + if (child->Parent() && !child->GetFrame()) { + UpdateTreeOnRemoval(child->Parent(), child->GetContent()); + children->RemoveElementAt(idx); + idx--; + continue; + } + + NS_ASSERTION(child->Parent() == owner, + "Illigally stolen ARIA owned child!"); + } + + if (children->Length() == 0) { + it.Remove(); + } + } +} + +void +DocAccessible::DoARIAOwnsRelocation(Accessible* aOwner) +{ + MOZ_ASSERT(aOwner, "aOwner must be a valid pointer"); + MOZ_ASSERT(aOwner->Elm(), "aOwner->Elm() must be a valid pointer"); + +#ifdef A11Y_LOG + logging::TreeInfo("aria owns relocation", logging::eVerbose, aOwner); +#endif + + nsTArray<RefPtr<Accessible> >* owned = mARIAOwnsHash.LookupOrAdd(aOwner); + IDRefsIterator iter(this, aOwner->Elm(), nsGkAtoms::aria_owns); + uint32_t idx = 0; + while (nsIContent* childEl = iter.NextElem()) { + Accessible* child = GetAccessible(childEl); + auto insertIdx = aOwner->ChildCount() - owned->Length() + idx; + + // Make an attempt to create an accessible if it wasn't created yet. + if (!child) { + if (aOwner->IsAcceptableChild(childEl)) { + child = GetAccService()->CreateAccessible(childEl, aOwner); + if (child) { + TreeMutation imut(aOwner); + aOwner->InsertChildAt(insertIdx, child); + imut.AfterInsertion(child); + imut.Done(); + + child->SetRelocated(true); + owned->InsertElementAt(idx, child); + idx++; + + // Create subtree before adjusting the insertion index, since subtree + // creation may alter children in the container. + CreateSubtree(child); + FireEventsOnInsertion(aOwner); + } + } + continue; + } + +#ifdef A11Y_LOG + logging::TreeInfo("aria owns traversal", logging::eVerbose, + "candidate", child, nullptr); +#endif + + // Same child on same position, no change. + if (child->Parent() == aOwner && + child->IndexInParent() == static_cast<int32_t>(insertIdx)) { + MOZ_ASSERT(owned->ElementAt(idx) == child, "Not in sync!"); + idx++; + continue; + } + + MOZ_ASSERT(owned->SafeElementAt(idx) != child, "Already in place!"); + if (owned->IndexOf(child) < idx) { + continue; // ignore second entry of same ID + } + + // A new child is found, check for loops. + if (child->Parent() != aOwner) { + Accessible* parent = aOwner; + while (parent && parent != child && !parent->IsDoc()) { + parent = parent->Parent(); + } + // A referred child cannot be a parent of the owner. + if (parent == child) { + continue; + } + } + + if (MoveChild(child, aOwner, insertIdx)) { + child->SetRelocated(true); + MOZ_ASSERT(owned == mARIAOwnsHash.Get(aOwner)); + owned = mARIAOwnsHash.LookupOrAdd(aOwner); + owned->InsertElementAt(idx, child); + idx++; + } + } + + // Put back children that are not seized anymore. + PutChildrenBack(owned, idx); + if (owned->Length() == 0) { + mARIAOwnsHash.Remove(aOwner); + } +} + +void +DocAccessible::PutChildrenBack(nsTArray<RefPtr<Accessible> >* aChildren, + uint32_t aStartIdx) +{ + MOZ_ASSERT(aStartIdx <= aChildren->Length(), "Wrong removal index"); + + nsTArray<RefPtr<Accessible> > containers; + for (auto idx = aStartIdx; idx < aChildren->Length(); idx++) { + Accessible* child = aChildren->ElementAt(idx); + if (!child->IsInDocument()) { + continue; + } + + // Remove the child from the owner + Accessible* owner = child->Parent(); + if (!owner) { + NS_ERROR("Cannot put the child back. No parent, a broken tree."); + continue; + } + +#ifdef A11Y_LOG + logging::TreeInfo("aria owns put child back", 0, + "old parent", owner, "child", child, nullptr); +#endif + + // Unset relocated flag to find an insertion point for the child. + child->SetRelocated(false); + + int32_t idxInParent = -1; + Accessible* origContainer = GetContainerAccessible(child->GetContent()); + if (origContainer) { + TreeWalker walker(origContainer); + if (walker.Seek(child->GetContent())) { + Accessible* prevChild = walker.Prev(); + if (prevChild) { + idxInParent = prevChild->IndexInParent() + 1; + MOZ_ASSERT(origContainer == prevChild->Parent(), "Broken tree"); + origContainer = prevChild->Parent(); + } + else { + idxInParent = 0; + } + } + } + MoveChild(child, origContainer, idxInParent); + } + + aChildren->RemoveElementsAt(aStartIdx, aChildren->Length() - aStartIdx); +} + +bool +DocAccessible::MoveChild(Accessible* aChild, Accessible* aNewParent, + int32_t aIdxInParent) +{ + MOZ_ASSERT(aChild, "No child"); + MOZ_ASSERT(aChild->Parent(), "No parent"); + MOZ_ASSERT(aIdxInParent <= static_cast<int32_t>(aNewParent->ChildCount()), + "Wrong insertion point for a moving child"); + + Accessible* curParent = aChild->Parent(); + +#ifdef A11Y_LOG + logging::TreeInfo("move child", 0, + "old parent", curParent, "new parent", aNewParent, + "child", aChild, nullptr); +#endif + + // Forget aria-owns info in case of ARIA owned element. The caller is expected + // to update it if needed. + if (aChild->IsRelocated()) { + aChild->SetRelocated(false); + nsTArray<RefPtr<Accessible> >* children = mARIAOwnsHash.Get(curParent); + children->RemoveElement(aChild); + } + + NotificationController::MoveGuard mguard(mNotificationController); + + if (curParent == aNewParent) { + MOZ_ASSERT(aChild->IndexInParent() != aIdxInParent, "No move case"); + curParent->MoveChild(aIdxInParent, aChild); + +#ifdef A11Y_LOG + logging::TreeInfo("move child: parent tree after", + logging::eVerbose, curParent); +#endif + return true; + } + + if (!aNewParent->IsAcceptableChild(aChild->GetContent())) { + return false; + } + + TreeMutation rmut(curParent); + rmut.BeforeRemoval(aChild, TreeMutation::kNoShutdown); + curParent->RemoveChild(aChild); + rmut.Done(); + + // No insertion point for the child. + if (aIdxInParent == -1) { + return true; + } + + if (aIdxInParent > static_cast<int32_t>(aNewParent->ChildCount())) { + MOZ_ASSERT_UNREACHABLE("Wrong insertion point for a moving child"); + return true; + } + + TreeMutation imut(aNewParent); + aNewParent->InsertChildAt(aIdxInParent, aChild); + imut.AfterInsertion(aChild); + imut.Done(); + +#ifdef A11Y_LOG + logging::TreeInfo("move child: old parent tree after", + logging::eVerbose, curParent); + logging::TreeInfo("move child: new parent tree after", + logging::eVerbose, aNewParent); +#endif + + return true; +} + + +void +DocAccessible::CacheChildrenInSubtree(Accessible* aRoot, + Accessible** aFocusedAcc) +{ + // If the accessible is focused then report a focus event after all related + // mutation events. + if (aFocusedAcc && !*aFocusedAcc && + FocusMgr()->HasDOMFocus(aRoot->GetContent())) + *aFocusedAcc = aRoot; + + Accessible* root = aRoot->IsHTMLCombobox() ? aRoot->FirstChild() : aRoot; + if (root->KidsFromDOM()) { + TreeMutation mt(root, TreeMutation::kNoEvents); + TreeWalker walker(root); + while (Accessible* child = walker.Next()) { + if (child->IsBoundToParent()) { + MoveChild(child, root, root->ChildCount()); + continue; + } + + root->AppendChild(child); + mt.AfterInsertion(child); + + CacheChildrenInSubtree(child, aFocusedAcc); + } + mt.Done(); + } + + // Fire events for ARIA elements. + if (!aRoot->HasARIARole()) { + return; + } + + // XXX: we should delay document load complete event if the ARIA document + // has aria-busy. + roles::Role role = aRoot->ARIARole(); + if (!aRoot->IsDoc() && (role == roles::DIALOG || role == roles::DOCUMENT)) { + FireDelayedEvent(nsIAccessibleEvent::EVENT_DOCUMENT_LOAD_COMPLETE, aRoot); + } +} + +void +DocAccessible::UncacheChildrenInSubtree(Accessible* aRoot) +{ + aRoot->mStateFlags |= eIsNotInDocument; + RemoveDependentIDsFor(aRoot); + + uint32_t count = aRoot->ContentChildCount(); + for (uint32_t idx = 0; idx < count; idx++) { + Accessible* child = aRoot->ContentChildAt(idx); + + // Removing this accessible from the document doesn't mean anything about + // accessibles for subdocuments, so skip removing those from the tree. + if (!child->IsDoc()) { + UncacheChildrenInSubtree(child); + } + } + + if (aRoot->IsNodeMapEntry() && + mNodeToAccessibleMap.Get(aRoot->GetNode()) == aRoot) + mNodeToAccessibleMap.Remove(aRoot->GetNode()); +} + +void +DocAccessible::ShutdownChildrenInSubtree(Accessible* aAccessible) +{ + // Traverse through children and shutdown them before this accessible. When + // child gets shutdown then it removes itself from children array of its + //parent. Use jdx index to process the cases if child is not attached to the + // parent and as result doesn't remove itself from its children. + uint32_t count = aAccessible->ContentChildCount(); + for (uint32_t idx = 0, jdx = 0; idx < count; idx++) { + Accessible* child = aAccessible->ContentChildAt(jdx); + if (!child->IsBoundToParent()) { + NS_ERROR("Parent refers to a child, child doesn't refer to parent!"); + jdx++; + } + + // Don't cross document boundaries. The outerdoc shutdown takes care about + // its subdocument. + if (!child->IsDoc()) + ShutdownChildrenInSubtree(child); + } + + UnbindFromDocument(aAccessible); +} + +bool +DocAccessible::IsLoadEventTarget() const +{ + nsCOMPtr<nsIDocShellTreeItem> treeItem = mDocumentNode->GetDocShell(); + NS_ASSERTION(treeItem, "No document shell for document!"); + + nsCOMPtr<nsIDocShellTreeItem> parentTreeItem; + treeItem->GetParent(getter_AddRefs(parentTreeItem)); + + // Not a root document. + if (parentTreeItem) { + // Return true if it's either: + // a) tab document; + nsCOMPtr<nsIDocShellTreeItem> rootTreeItem; + treeItem->GetRootTreeItem(getter_AddRefs(rootTreeItem)); + if (parentTreeItem == rootTreeItem) + return true; + + // b) frame/iframe document and its parent document is not in loading state + // Note: we can get notifications while document is loading (and thus + // while there's no parent document yet). + DocAccessible* parentDoc = ParentDocument(); + return parentDoc && parentDoc->HasLoadState(eCompletelyLoaded); + } + + // It's content (not chrome) root document. + return (treeItem->ItemType() == nsIDocShellTreeItem::typeContent); +} diff --git a/accessible/generic/DocAccessible.h b/accessible/generic/DocAccessible.h new file mode 100644 index 000000000..4bc6f03f0 --- /dev/null +++ b/accessible/generic/DocAccessible.h @@ -0,0 +1,718 @@ +/* -*- 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 mozilla_a11y_DocAccessible_h__ +#define mozilla_a11y_DocAccessible_h__ + +#include "nsIAccessiblePivot.h" + +#include "HyperTextAccessibleWrap.h" +#include "AccEvent.h" + +#include "nsAutoPtr.h" +#include "nsClassHashtable.h" +#include "nsDataHashtable.h" +#include "nsIDocument.h" +#include "nsIDocumentObserver.h" +#include "nsIEditor.h" +#include "nsIObserver.h" +#include "nsIScrollPositionListener.h" +#include "nsITimer.h" +#include "nsIWeakReference.h" + +class nsAccessiblePivot; + +const uint32_t kDefaultCacheLength = 128; + +namespace mozilla { +namespace a11y { + +class DocManager; +class NotificationController; +class DocAccessibleChild; +class RelatedAccIterator; +template<class Class, class ... Args> +class TNotification; + +class DocAccessible : public HyperTextAccessibleWrap, + public nsIDocumentObserver, + public nsIObserver, + public nsIScrollPositionListener, + public nsSupportsWeakReference, + public nsIAccessiblePivotObserver +{ + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(DocAccessible, Accessible) + + NS_DECL_NSIOBSERVER + NS_DECL_NSIACCESSIBLEPIVOTOBSERVER + +public: + + DocAccessible(nsIDocument* aDocument, nsIPresShell* aPresShell); + + // nsIScrollPositionListener + virtual void ScrollPositionWillChange(nscoord aX, nscoord aY) override {} + virtual void ScrollPositionDidChange(nscoord aX, nscoord aY) override; + + // nsIDocumentObserver + NS_DECL_NSIDOCUMENTOBSERVER + + // Accessible + virtual void Init(); + virtual void Shutdown() override; + virtual nsIFrame* GetFrame() const override; + virtual nsINode* GetNode() const override { return mDocumentNode; } + nsIDocument* DocumentNode() const { return mDocumentNode; } + + virtual mozilla::a11y::ENameValueFlag Name(nsString& aName) override; + virtual void Description(nsString& aDescription) override; + virtual Accessible* FocusedChild() override; + virtual mozilla::a11y::role NativeRole() override; + virtual uint64_t NativeState() override; + virtual uint64_t NativeInteractiveState() const override; + virtual bool NativelyUnavailable() const override; + virtual void ApplyARIAState(uint64_t* aState) const override; + virtual already_AddRefed<nsIPersistentProperties> Attributes() override; + + virtual void TakeFocus() override; + +#ifdef A11Y_LOG + virtual nsresult HandleAccEvent(AccEvent* aEvent) override; +#endif + + virtual nsRect RelativeBounds(nsIFrame** aRelativeFrame) const override; + + // HyperTextAccessible + virtual already_AddRefed<nsIEditor> GetEditor() const override; + + // DocAccessible + + /** + * Return document URL. + */ + void URL(nsAString& aURL) const; + + /** + * Return DOM document title. + */ + void Title(nsString& aTitle) const { mDocumentNode->GetTitle(aTitle); } + + /** + * Return DOM document mime type. + */ + void MimeType(nsAString& aType) const { mDocumentNode->GetContentType(aType); } + + /** + * Return DOM document type. + */ + void DocType(nsAString& aType) const; + + /** + * Return virtual cursor associated with the document. + */ + nsIAccessiblePivot* VirtualCursor(); + + /** + * Return presentation shell for this document accessible. + */ + nsIPresShell* PresShell() const { return mPresShell; } + + /** + * Return the presentation shell's context. + */ + nsPresContext* PresContext() const { return mPresShell->GetPresContext(); } + + /** + * Return true if associated DOM document was loaded and isn't unloading. + */ + bool IsContentLoaded() const + { + // eDOMLoaded flag check is used for error pages as workaround to make this + // method return correct result since error pages do not receive 'pageshow' + // event and as consequence nsIDocument::IsShowing() returns false. + return mDocumentNode && mDocumentNode->IsVisible() && + (mDocumentNode->IsShowing() || HasLoadState(eDOMLoaded)); + } + + /** + * Document load states. + */ + enum LoadState { + // initial tree construction is pending + eTreeConstructionPending = 0, + // initial tree construction done + eTreeConstructed = 1, + // DOM document is loaded. + eDOMLoaded = 1 << 1, + // document is ready + eReady = eTreeConstructed | eDOMLoaded, + // document and all its subdocuments are ready + eCompletelyLoaded = eReady | 1 << 2 + }; + + /** + * Return true if the document has given document state. + */ + bool HasLoadState(LoadState aState) const + { return (mLoadState & static_cast<uint32_t>(aState)) == + static_cast<uint32_t>(aState); } + + /** + * Return a native window handler or pointer depending on platform. + */ + virtual void* GetNativeWindow() const; + + /** + * Return the parent document. + */ + DocAccessible* ParentDocument() const + { return mParent ? mParent->Document() : nullptr; } + + /** + * Return the child document count. + */ + uint32_t ChildDocumentCount() const + { return mChildDocuments.Length(); } + + /** + * Return the child document at the given index. + */ + DocAccessible* GetChildDocumentAt(uint32_t aIndex) const + { return mChildDocuments.SafeElementAt(aIndex, nullptr); } + + /** + * Fire accessible event asynchronously. + */ + void FireDelayedEvent(AccEvent* aEvent); + void FireDelayedEvent(uint32_t aEventType, Accessible* aTarget); + void FireEventsOnInsertion(Accessible* aContainer); + + /** + * Fire value change event on the given accessible if applicable. + */ + void MaybeNotifyOfValueChange(Accessible* aAccessible); + + /** + * Get/set the anchor jump. + */ + Accessible* AnchorJump() + { return GetAccessibleOrContainer(mAnchorJumpElm); } + + void SetAnchorJump(nsIContent* aTargetNode) + { mAnchorJumpElm = aTargetNode; } + + /** + * Bind the child document to the tree. + */ + void BindChildDocument(DocAccessible* aDocument); + + /** + * Process the generic notification. + * + * @note The caller must guarantee that the given instance still exists when + * notification is processed. + * @see NotificationController::HandleNotification + */ + template<class Class, class Arg> + void HandleNotification(Class* aInstance, + typename TNotification<Class, Arg>::Callback aMethod, + Arg* aArg); + + /** + * Return the cached accessible by the given DOM node if it's in subtree of + * this document accessible or the document accessible itself, otherwise null. + * + * @return the accessible object + */ + Accessible* GetAccessible(nsINode* aNode) const + { + return aNode == mDocumentNode ? + const_cast<DocAccessible*>(this) : mNodeToAccessibleMap.Get(aNode); + } + + /** + * Return an accessible for the given node even if the node is not in + * document's node map cache (like HTML area element). + * + * XXX: it should be really merged with GetAccessible(). + */ + Accessible* GetAccessibleEvenIfNotInMap(nsINode* aNode) const; + Accessible* GetAccessibleEvenIfNotInMapOrContainer(nsINode* aNode) const; + + /** + * Return whether the given DOM node has an accessible or not. + */ + bool HasAccessible(nsINode* aNode) const + { return GetAccessible(aNode); } + + /** + * Return the cached accessible by the given unique ID within this document. + * + * @note the unique ID matches with the uniqueID() of Accessible + * + * @param aUniqueID [in] the unique ID used to cache the node. + */ + Accessible* GetAccessibleByUniqueID(void* aUniqueID) + { + return UniqueID() == aUniqueID ? + this : mAccessibleCache.GetWeak(aUniqueID); + } + + /** + * Return the cached accessible by the given unique ID looking through + * this and nested documents. + */ + Accessible* GetAccessibleByUniqueIDInSubtree(void* aUniqueID); + + /** + * Return an accessible for the given DOM node or container accessible if + * the node is not accessible. + */ + Accessible* GetAccessibleOrContainer(nsINode* aNode) const; + + /** + * Return a container accessible for the given DOM node. + */ + Accessible* GetContainerAccessible(nsINode* aNode) const + { + return aNode ? GetAccessibleOrContainer(aNode->GetParentNode()) : nullptr; + } + + /** + * Return an accessible for the given node if any, or an immediate accessible + * container for it. + */ + Accessible* AccessibleOrTrueContainer(nsINode* aNode) const; + + /** + * Return an accessible for the given node or its first accessible descendant. + */ + Accessible* GetAccessibleOrDescendant(nsINode* aNode) const; + + /** + * Returns aria-owns seized child at the given index. + */ + Accessible* ARIAOwnedAt(Accessible* aParent, uint32_t aIndex) const + { + nsTArray<RefPtr<Accessible> >* children = mARIAOwnsHash.Get(aParent); + if (children) { + return children->SafeElementAt(aIndex); + } + return nullptr; + } + uint32_t ARIAOwnedCount(Accessible* aParent) const + { + nsTArray<RefPtr<Accessible> >* children = mARIAOwnsHash.Get(aParent); + return children ? children->Length() : 0; + } + + /** + * Return true if the given ID is referred by relation attribute. + * + * @note Different elements may share the same ID if they are hosted inside + * XBL bindings. Be careful the result of this method may be senseless + * while it's called for XUL elements (where XBL is used widely). + */ + bool IsDependentID(const nsAString& aID) const + { return mDependentIDsHash.Get(aID, nullptr); } + + /** + * Initialize the newly created accessible and put it into document caches. + * + * @param aAccessible [in] created accessible + * @param aRoleMapEntry [in] the role map entry role the ARIA role or nullptr + * if none + */ + void BindToDocument(Accessible* aAccessible, + const nsRoleMapEntry* aRoleMapEntry); + + /** + * Remove from document and shutdown the given accessible. + */ + void UnbindFromDocument(Accessible* aAccessible); + + /** + * Notify the document accessible that content was inserted. + */ + void ContentInserted(nsIContent* aContainerNode, + nsIContent* aStartChildNode, + nsIContent* aEndChildNode); + + /** + * Notify the document accessible that content was removed. + */ + void ContentRemoved(Accessible* aContainer, nsIContent* aChildNode) + { + // Update the whole tree of this document accessible when the container is + // null (document element is removed). + UpdateTreeOnRemoval((aContainer ? aContainer : this), aChildNode); + } + void ContentRemoved(nsIContent* aContainerNode, nsIContent* aChildNode) + { + ContentRemoved(GetAccessibleOrContainer(aContainerNode), aChildNode); + } + + /** + * Updates accessible tree when rendered text is changed. + */ + void UpdateText(nsIContent* aTextNode); + + /** + * Recreate an accessible, results in hide/show events pair. + */ + void RecreateAccessible(nsIContent* aContent); + + /** + * Schedule ARIA owned element relocation if needed. Return true if relocation + * was scheduled. + */ + bool RelocateARIAOwnedIfNeeded(nsIContent* aEl); + + /** + * Return a notification controller associated with the document. + */ + NotificationController* Controller() const { return mNotificationController; } + + /** + * If this document is in a content process return the object responsible for + * communicating with the main process for it. + */ + DocAccessibleChild* IPCDoc() const { return mIPCDoc; } + +protected: + virtual ~DocAccessible(); + + void LastRelease(); + + // DocAccessible + virtual nsresult AddEventListeners(); + virtual nsresult RemoveEventListeners(); + + /** + * Marks this document as loaded or loading. + */ + void NotifyOfLoad(uint32_t aLoadEventType); + void NotifyOfLoading(bool aIsReloading); + + friend class DocManager; + + /** + * Perform initial update (create accessible tree). + * Can be overridden by wrappers to prepare initialization work. + */ + virtual void DoInitialUpdate(); + + /** + * Updates root element and picks up ARIA role on it if any. + */ + void UpdateRootElIfNeeded(); + + /** + * Process document load notification, fire document load and state busy + * events if applicable. + */ + void ProcessLoad(); + + /** + * Add/remove scroll listeners, @see nsIScrollPositionListener interface. + */ + void AddScrollListener(); + void RemoveScrollListener(); + + /** + * Append the given document accessible to this document's child document + * accessibles. + */ + bool AppendChildDocument(DocAccessible* aChildDocument) + { + return mChildDocuments.AppendElement(aChildDocument); + } + + /** + * Remove the given document accessible from this document's child document + * accessibles. + */ + void RemoveChildDocument(DocAccessible* aChildDocument) + { + mChildDocuments.RemoveElement(aChildDocument); + } + + /** + * Add dependent IDs pointed by accessible element by relation attribute to + * cache. If the relation attribute is missed then all relation attributes + * are checked. + * + * @param aRelProvider [in] accessible that element has relation attribute + * @param aRelAttr [in, optional] relation attribute + */ + void AddDependentIDsFor(Accessible* aRelProvider, + nsIAtom* aRelAttr = nullptr); + + /** + * Remove dependent IDs pointed by accessible element by relation attribute + * from cache. If the relation attribute is absent then all relation + * attributes are checked. + * + * @param aRelProvider [in] accessible that element has relation attribute + * @param aRelAttr [in, optional] relation attribute + */ + void RemoveDependentIDsFor(Accessible* aRelProvider, + nsIAtom* aRelAttr = nullptr); + + /** + * Update or recreate an accessible depending on a changed attribute. + * + * @param aElement [in] the element the attribute was changed on + * @param aAttribute [in] the changed attribute + * @return true if an action was taken on the attribute change + */ + bool UpdateAccessibleOnAttrChange(mozilla::dom::Element* aElement, + nsIAtom* aAttribute); + + /** + * Fire accessible events when attribute is changed. + * + * @param aAccessible [in] accessible the DOM attribute is changed for + * @param aNameSpaceID [in] namespace of changed attribute + * @param aAttribute [in] changed attribute + */ + void AttributeChangedImpl(Accessible* aAccessible, + int32_t aNameSpaceID, nsIAtom* aAttribute); + + /** + * Fire accessible events when ARIA attribute is changed. + * + * @param aAccessible [in] accesislbe the DOM attribute is changed for + * @param aAttribute [in] changed attribute + */ + void ARIAAttributeChanged(Accessible* aAccessible, nsIAtom* aAttribute); + + /** + * Process ARIA active-descendant attribute change. + */ + void ARIAActiveDescendantChanged(Accessible* aAccessible); + + /** + * Update the accessible tree for inserted content. + */ + void ProcessContentInserted(Accessible* aContainer, + const nsTArray<nsCOMPtr<nsIContent> >* aInsertedContent); + void ProcessContentInserted(Accessible* aContainer, + nsIContent* aInsertedContent); + + /** + * Used to notify the document to make it process the invalidation list. + * + * While children are cached we may encounter the case there's no accessible + * for referred content by related accessible. Store these related nodes to + * invalidate their containers later. + */ + void ProcessInvalidationList(); + + /** + * Update the accessible tree for content removal. + */ + void UpdateTreeOnRemoval(Accessible* aContainer, nsIContent* aChildNode); + + /** + * Validates all aria-owns connections and updates the tree accordingly. + */ + void ValidateARIAOwned(); + + /** + * Steals or puts back accessible subtrees. + */ + void DoARIAOwnsRelocation(Accessible* aOwner); + + /** + * Moves children back under their original parents. + */ + void PutChildrenBack(nsTArray<RefPtr<Accessible> >* aChildren, + uint32_t aStartIdx); + + bool MoveChild(Accessible* aChild, Accessible* aNewParent, + int32_t aIdxInParent); + + /** + * Create accessible tree. + * + * @param aRoot [in] a root of subtree to create + * @param aFocusedAcc [in, optional] a focused accessible under created + * subtree if any + */ + void CacheChildrenInSubtree(Accessible* aRoot, + Accessible** aFocusedAcc = nullptr); + void CreateSubtree(Accessible* aRoot); + + /** + * Remove accessibles in subtree from node to accessible map. + */ + void UncacheChildrenInSubtree(Accessible* aRoot); + + /** + * Shutdown any cached accessible in the subtree. + * + * @param aAccessible [in] the root of the subrtee to invalidate accessible + * child/parent refs in + */ + void ShutdownChildrenInSubtree(Accessible* aAccessible); + + /** + * Return true if the document is a target of document loading events + * (for example, state busy change or document reload events). + * + * Rules: The root chrome document accessible is never an event target + * (for example, Firefox UI window). If the sub document is loaded within its + * parent document then the parent document is a target only (aka events + * coalescence). + */ + bool IsLoadEventTarget() const; + + /* + * Set the object responsible for communicating with the main process on + * behalf of this document. + */ + void SetIPCDoc(DocAccessibleChild* aIPCDoc) { mIPCDoc = aIPCDoc; } + + friend class DocAccessibleChildBase; + + /** + * Used to fire scrolling end event after page scroll. + * + * @param aTimer [in] the timer object + * @param aClosure [in] the document accessible where scrolling happens + */ + static void ScrollTimerCallback(nsITimer* aTimer, void* aClosure); + +protected: + + /** + * State and property flags, kept by mDocFlags. + */ + enum { + // Whether scroll listeners were added. + eScrollInitialized = 1 << 0, + + // Whether the document is a tab document. + eTabDocument = 1 << 1 + }; + + /** + * Cache of accessibles within this document accessible. + */ + AccessibleHashtable mAccessibleCache; + nsDataHashtable<nsPtrHashKey<const nsINode>, Accessible*> + mNodeToAccessibleMap; + + nsIDocument* mDocumentNode; + nsCOMPtr<nsITimer> mScrollWatchTimer; + uint16_t mScrollPositionChangedTicks; // Used for tracking scroll events + + /** + * Bit mask of document load states (@see LoadState). + */ + uint32_t mLoadState : 3; + + /** + * Bit mask of other states and props. + */ + uint32_t mDocFlags : 28; + + /** + * Type of document load event fired after the document is loaded completely. + */ + uint32_t mLoadEventType; + + /** + * Reference to anchor jump element. + */ + nsCOMPtr<nsIContent> mAnchorJumpElm; + + /** + * A generic state (see items below) before the attribute value was changed. + * @see AttributeWillChange and AttributeChanged notifications. + */ + union { + // ARIA attribute value + nsIAtom* mARIAAttrOldValue; + + // True if the accessible state bit was on + bool mStateBitWasOn; + }; + + nsTArray<RefPtr<DocAccessible> > mChildDocuments; + + /** + * The virtual cursor of the document. + */ + RefPtr<nsAccessiblePivot> mVirtualCursor; + + /** + * A storage class for pairing content with one of its relation attributes. + */ + class AttrRelProvider + { + public: + AttrRelProvider(nsIAtom* aRelAttr, nsIContent* aContent) : + mRelAttr(aRelAttr), mContent(aContent) { } + + nsIAtom* mRelAttr; + nsCOMPtr<nsIContent> mContent; + + private: + AttrRelProvider(); + AttrRelProvider(const AttrRelProvider&); + AttrRelProvider& operator =(const AttrRelProvider&); + }; + + /** + * The cache of IDs pointed by relation attributes. + */ + typedef nsTArray<nsAutoPtr<AttrRelProvider> > AttrRelProviderArray; + nsClassHashtable<nsStringHashKey, AttrRelProviderArray> + mDependentIDsHash; + + friend class RelatedAccIterator; + + /** + * Used for our caching algorithm. We store the list of nodes that should be + * invalidated. + * + * @see ProcessInvalidationList + */ + nsTArray<RefPtr<nsIContent>> mInvalidationList; + + /** + * Holds a list of aria-owns relocations. + */ + nsClassHashtable<nsPtrHashKey<Accessible>, nsTArray<RefPtr<Accessible> > > + mARIAOwnsHash; + + /** + * Used to process notification from core and accessible events. + */ + RefPtr<NotificationController> mNotificationController; + friend class EventTree; + friend class NotificationController; + +private: + + nsIPresShell* mPresShell; + + // Exclusively owned by IPDL so don't manually delete it! + DocAccessibleChild* mIPCDoc; +}; + +inline DocAccessible* +Accessible::AsDoc() +{ + return IsDoc() ? static_cast<DocAccessible*>(this) : nullptr; +} + +} // namespace a11y +} // namespace mozilla + +#endif diff --git a/accessible/generic/FormControlAccessible.cpp b/accessible/generic/FormControlAccessible.cpp new file mode 100644 index 000000000..0f2750070 --- /dev/null +++ b/accessible/generic/FormControlAccessible.cpp @@ -0,0 +1,193 @@ +/* -*- 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/. */ + +// NOTE: alphabetically ordered + +#include "FormControlAccessible.h" +#include "Role.h" + +#include "mozilla/FloatingPoint.h" +#include "nsIDOMHTMLFormElement.h" +#include "nsIDOMXULElement.h" +#include "nsIDOMXULControlElement.h" + +using namespace mozilla::a11y; + +//////////////////////////////////////////////////////////////////////////////// +// ProgressMeterAccessible +//////////////////////////////////////////////////////////////////////////////// + +template class mozilla::a11y::ProgressMeterAccessible<1>; +template class mozilla::a11y::ProgressMeterAccessible<100>; + +//////////////////////////////////////////////////////////////////////////////// +// Accessible + +template<int Max> +role +ProgressMeterAccessible<Max>::NativeRole() +{ + return roles::PROGRESSBAR; +} + +template<int Max> +uint64_t +ProgressMeterAccessible<Max>::NativeState() +{ + uint64_t state = LeafAccessible::NativeState(); + + // An undetermined progressbar (i.e. without a value) has a mixed state. + nsAutoString attrValue; + mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::value, attrValue); + + if (attrValue.IsEmpty()) + state |= states::MIXED; + + return state; +} + +//////////////////////////////////////////////////////////////////////////////// +// ProgressMeterAccessible<Max>: Widgets + +template<int Max> +bool +ProgressMeterAccessible<Max>::IsWidget() const +{ + return true; +} + +//////////////////////////////////////////////////////////////////////////////// +// ProgressMeterAccessible<Max>: Value + +template<int Max> +void +ProgressMeterAccessible<Max>::Value(nsString& aValue) +{ + LeafAccessible::Value(aValue); + if (!aValue.IsEmpty()) + return; + + double maxValue = MaxValue(); + if (IsNaN(maxValue) || maxValue == 0) + return; + + double curValue = CurValue(); + if (IsNaN(curValue)) + return; + + // Treat the current value bigger than maximum as 100%. + double percentValue = (curValue < maxValue) ? + (curValue / maxValue) * 100 : 100; + + aValue.AppendFloat(percentValue); + aValue.Append('%'); +} + +template<int Max> +double +ProgressMeterAccessible<Max>::MaxValue() const +{ + double value = LeafAccessible::MaxValue(); + if (!IsNaN(value)) + return value; + + nsAutoString strValue; + if (mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::max, strValue)) { + nsresult result = NS_OK; + value = strValue.ToDouble(&result); + if (NS_SUCCEEDED(result)) + return value; + } + + return Max; +} + +template<int Max> +double +ProgressMeterAccessible<Max>::MinValue() const +{ + double value = LeafAccessible::MinValue(); + return IsNaN(value) ? 0 : value; +} + +template<int Max> +double +ProgressMeterAccessible<Max>::Step() const +{ + double value = LeafAccessible::Step(); + return IsNaN(value) ? 0 : value; +} + +template<int Max> +double +ProgressMeterAccessible<Max>::CurValue() const +{ + double value = LeafAccessible::CurValue(); + if (!IsNaN(value)) + return value; + + nsAutoString attrValue; + if (!mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::value, attrValue)) + return UnspecifiedNaN<double>(); + + nsresult error = NS_OK; + value = attrValue.ToDouble(&error); + return NS_FAILED(error) ? UnspecifiedNaN<double>() : value; +} + +template<int Max> +bool +ProgressMeterAccessible<Max>::SetCurValue(double aValue) +{ + return false; // progress meters are readonly. +} + +//////////////////////////////////////////////////////////////////////////////// +// RadioButtonAccessible +//////////////////////////////////////////////////////////////////////////////// + +RadioButtonAccessible:: + RadioButtonAccessible(nsIContent* aContent, DocAccessible* aDoc) : + LeafAccessible(aContent, aDoc) +{ +} + +uint8_t +RadioButtonAccessible::ActionCount() +{ + return 1; +} + +void +RadioButtonAccessible::ActionNameAt(uint8_t aIndex, nsAString& aName) +{ + if (aIndex == eAction_Click) + aName.AssignLiteral("select"); +} + +bool +RadioButtonAccessible::DoAction(uint8_t aIndex) +{ + if (aIndex != eAction_Click) + return false; + + DoCommand(); + return true; +} + +role +RadioButtonAccessible::NativeRole() +{ + return roles::RADIOBUTTON; +} + +//////////////////////////////////////////////////////////////////////////////// +// RadioButtonAccessible: Widgets + +bool +RadioButtonAccessible::IsWidget() const +{ + return true; +} diff --git a/accessible/generic/FormControlAccessible.h b/accessible/generic/FormControlAccessible.h new file mode 100644 index 000000000..59844e553 --- /dev/null +++ b/accessible/generic/FormControlAccessible.h @@ -0,0 +1,76 @@ +/* -*- 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 MOZILLA_A11Y_FormControlAccessible_H_ +#define MOZILLA_A11Y_FormControlAccessible_H_ + +#include "BaseAccessibles.h" + +namespace mozilla { +namespace a11y { + +/** + * Generic class used for progress meters. + */ +template<int Max> +class ProgressMeterAccessible : public LeafAccessible +{ +public: + ProgressMeterAccessible(nsIContent* aContent, DocAccessible* aDoc) : + LeafAccessible(aContent, aDoc) + { + // Ignore 'ValueChange' DOM event in lieu of @value attribute change + // notifications. + mStateFlags |= eHasNumericValue | eIgnoreDOMUIEvent; + mType = eProgressType; + } + + // Accessible + virtual void Value(nsString& aValue) override; + virtual mozilla::a11y::role NativeRole() override; + virtual uint64_t NativeState() override; + + // Value + 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) override; + + // Widgets + virtual bool IsWidget() const override; + +protected: + virtual ~ProgressMeterAccessible() {} +}; + +/** + * Generic class used for radio buttons. + */ +class RadioButtonAccessible : public LeafAccessible +{ + +public: + RadioButtonAccessible(nsIContent* aContent, DocAccessible* aDoc); + + // Accessible + virtual mozilla::a11y::role NativeRole() override; + + // ActionAccessible + virtual uint8_t ActionCount() override; + virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) override; + virtual bool DoAction(uint8_t aIndex) override; + + enum { eAction_Click = 0 }; + + // Widgets + virtual bool IsWidget() const override; +}; + +} // namespace a11y +} // namespace mozilla + +#endif + diff --git a/accessible/generic/HyperTextAccessible-inl.h b/accessible/generic/HyperTextAccessible-inl.h new file mode 100644 index 000000000..1e8deac5d --- /dev/null +++ b/accessible/generic/HyperTextAccessible-inl.h @@ -0,0 +1,180 @@ +/* -*- 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 mozilla_a11y_HyperTextAccessible_inl_h__ +#define mozilla_a11y_HyperTextAccessible_inl_h__ + +#include "HyperTextAccessible.h" + +#include "nsAccUtils.h" + +#include "nsIClipboard.h" +#include "nsIEditor.h" +#include "nsIPersistentProperties2.h" +#include "nsIPlaintextEditor.h" +#include "nsFrameSelection.h" + +namespace mozilla { +namespace a11y { + +inline bool +HyperTextAccessible::IsValidOffset(int32_t aOffset) +{ + index_t offset = ConvertMagicOffset(aOffset); + return offset.IsValid() && offset <= CharacterCount(); +} + +inline bool +HyperTextAccessible::IsValidRange(int32_t aStartOffset, int32_t aEndOffset) +{ + index_t startOffset = ConvertMagicOffset(aStartOffset); + index_t endOffset = ConvertMagicOffset(aEndOffset); + return startOffset.IsValid() && endOffset.IsValid() && + startOffset <= endOffset && endOffset <= CharacterCount(); +} + +inline void +HyperTextAccessible::SetCaretOffset(int32_t aOffset) +{ + SetSelectionRange(aOffset, aOffset); + // XXX: Force cache refresh until a good solution for AT emulation of user + // input is implemented (AccessFu caret movement). + SelectionMgr()->UpdateCaretOffset(this, aOffset); +} + +inline bool +HyperTextAccessible::AddToSelection(int32_t aStartOffset, int32_t aEndOffset) +{ + dom::Selection* domSel = DOMSelection(); + return domSel && + SetSelectionBoundsAt(domSel->RangeCount(), aStartOffset, aEndOffset); +} + +inline void +HyperTextAccessible::ReplaceText(const nsAString& aText) +{ + // We need to call DeleteText() even if there is no contents because we need + // to ensure to move focus to the editor via SetSelectionRange() called in + // DeleteText(). + DeleteText(0, CharacterCount()); + + nsCOMPtr<nsIEditor> editor = GetEditor(); + nsCOMPtr<nsIPlaintextEditor> plaintextEditor(do_QueryInterface(editor)); + if (!plaintextEditor) { + return; + } + + // DeleteText() may cause inserting <br> element in some cases. Let's + // select all again and replace whole contents. + editor->SelectAll(); + + plaintextEditor->InsertText(aText); +} + +inline void +HyperTextAccessible::InsertText(const nsAString& aText, int32_t aPosition) +{ + nsCOMPtr<nsIEditor> editor = GetEditor(); + nsCOMPtr<nsIPlaintextEditor> peditor(do_QueryInterface(editor)); + if (peditor) { + SetSelectionRange(aPosition, aPosition); + peditor->InsertText(aText); + } +} + +inline void +HyperTextAccessible::CopyText(int32_t aStartPos, int32_t aEndPos) + { + nsCOMPtr<nsIEditor> editor = GetEditor(); + if (editor) { + SetSelectionRange(aStartPos, aEndPos); + editor->Copy(); + } + } + +inline void +HyperTextAccessible::CutText(int32_t aStartPos, int32_t aEndPos) + { + nsCOMPtr<nsIEditor> editor = GetEditor(); + if (editor) { + SetSelectionRange(aStartPos, aEndPos); + editor->Cut(); + } + } + +inline void +HyperTextAccessible::DeleteText(int32_t aStartPos, int32_t aEndPos) +{ + nsCOMPtr<nsIEditor> editor = GetEditor(); + if (editor) { + SetSelectionRange(aStartPos, aEndPos); + editor->DeleteSelection(nsIEditor::eNone, nsIEditor::eStrip); + } +} + +inline void +HyperTextAccessible::PasteText(int32_t aPosition) +{ + nsCOMPtr<nsIEditor> editor = GetEditor(); + if (editor) { + SetSelectionRange(aPosition, aPosition); + editor->Paste(nsIClipboard::kGlobalClipboard); + } +} + +inline index_t +HyperTextAccessible::ConvertMagicOffset(int32_t aOffset) const +{ + if (aOffset == nsIAccessibleText::TEXT_OFFSET_END_OF_TEXT) + return CharacterCount(); + + if (aOffset == nsIAccessibleText::TEXT_OFFSET_CARET) + return CaretOffset(); + + return aOffset; +} + +inline uint32_t +HyperTextAccessible::AdjustCaretOffset(uint32_t aOffset) const +{ + // It is the same character offset when the caret is visually at the very + // end of a line or the start of a new line (soft line break). Getting text + // at the line should provide the line with the visual caret, otherwise + // screen readers will announce the wrong line as the user presses up or + // down arrow and land at the end of a line. + if (aOffset > 0 && IsCaretAtEndOfLine()) + return aOffset - 1; + + return aOffset; +} + +inline bool +HyperTextAccessible::IsCaretAtEndOfLine() const +{ + RefPtr<nsFrameSelection> frameSelection = FrameSelection(); + return frameSelection && + frameSelection->GetHint() == CARET_ASSOCIATE_BEFORE; +} + +inline already_AddRefed<nsFrameSelection> +HyperTextAccessible::FrameSelection() const +{ + nsIFrame* frame = GetFrame(); + return frame ? frame->GetFrameSelection() : nullptr; +} + +inline dom::Selection* +HyperTextAccessible::DOMSelection() const +{ + RefPtr<nsFrameSelection> frameSelection = FrameSelection(); + return frameSelection ? frameSelection->GetSelection(SelectionType::eNormal) : + nullptr; +} + +} // namespace a11y +} // namespace mozilla + +#endif + diff --git a/accessible/generic/HyperTextAccessible.cpp b/accessible/generic/HyperTextAccessible.cpp new file mode 100644 index 000000000..059c27372 --- /dev/null +++ b/accessible/generic/HyperTextAccessible.cpp @@ -0,0 +1,2230 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=2 sw=2 et tw=78: */ +/* 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 "HyperTextAccessible-inl.h" + +#include "Accessible-inl.h" +#include "nsAccessibilityService.h" +#include "nsIAccessibleTypes.h" +#include "DocAccessible.h" +#include "HTMLListAccessible.h" +#include "Role.h" +#include "States.h" +#include "TextAttrs.h" +#include "TextRange.h" +#include "TreeWalker.h" + +#include "nsCaret.h" +#include "nsContentUtils.h" +#include "nsFocusManager.h" +#include "nsIDOMRange.h" +#include "nsIEditingSession.h" +#include "nsContainerFrame.h" +#include "nsFrameSelection.h" +#include "nsILineIterator.h" +#include "nsIInterfaceRequestorUtils.h" +#include "nsIPersistentProperties2.h" +#include "nsIScrollableFrame.h" +#include "nsIServiceManager.h" +#include "nsITextControlElement.h" +#include "nsIMathMLFrame.h" +#include "nsTextFragment.h" +#include "mozilla/BinarySearch.h" +#include "mozilla/dom/Element.h" +#include "mozilla/EventStates.h" +#include "mozilla/dom/Selection.h" +#include "mozilla/MathAlgorithms.h" +#include "gfxSkipChars.h" +#include <algorithm> + +using namespace mozilla; +using namespace mozilla::a11y; + +//////////////////////////////////////////////////////////////////////////////// +// HyperTextAccessible +//////////////////////////////////////////////////////////////////////////////// + +HyperTextAccessible:: + HyperTextAccessible(nsIContent* aNode, DocAccessible* aDoc) : + AccessibleWrap(aNode, aDoc) +{ + mType = eHyperTextType; + mGenericTypes |= eHyperText; +} + +NS_IMPL_ISUPPORTS_INHERITED0(HyperTextAccessible, Accessible) + +role +HyperTextAccessible::NativeRole() +{ + a11y::role r = GetAccService()->MarkupRole(mContent); + if (r != roles::NOTHING) + return r; + + nsIFrame* frame = GetFrame(); + if (frame && frame->GetType() == nsGkAtoms::inlineFrame) + return roles::TEXT; + + return roles::TEXT_CONTAINER; +} + +uint64_t +HyperTextAccessible::NativeState() +{ + uint64_t states = AccessibleWrap::NativeState(); + + if (mContent->AsElement()->State().HasState(NS_EVENT_STATE_MOZ_READWRITE)) { + states |= states::EDITABLE; + + } else if (mContent->IsHTMLElement(nsGkAtoms::article)) { + // We want <article> to behave like a document in terms of readonly state. + states |= states::READONLY; + } + + if (HasChildren()) + states |= states::SELECTABLE_TEXT; + + return states; +} + +nsIntRect +HyperTextAccessible::GetBoundsInFrame(nsIFrame* aFrame, + uint32_t aStartRenderedOffset, + uint32_t aEndRenderedOffset) +{ + nsPresContext* presContext = mDoc->PresContext(); + if (aFrame->GetType() != nsGkAtoms::textFrame) { + return aFrame->GetScreenRectInAppUnits(). + ToNearestPixels(presContext->AppUnitsPerDevPixel()); + } + + // Substring must be entirely within the same text node. + int32_t startContentOffset, endContentOffset; + nsresult rv = RenderedToContentOffset(aFrame, aStartRenderedOffset, &startContentOffset); + NS_ENSURE_SUCCESS(rv, nsIntRect()); + rv = RenderedToContentOffset(aFrame, aEndRenderedOffset, &endContentOffset); + NS_ENSURE_SUCCESS(rv, nsIntRect()); + + nsIFrame *frame; + int32_t startContentOffsetInFrame; + // Get the right frame continuation -- not really a child, but a sibling of + // the primary frame passed in + rv = aFrame->GetChildFrameContainingOffset(startContentOffset, false, + &startContentOffsetInFrame, &frame); + NS_ENSURE_SUCCESS(rv, nsIntRect()); + + nsRect screenRect; + while (frame && startContentOffset < endContentOffset) { + // Start with this frame's screen rect, which we will shrink based on + // the substring we care about within it. We will then add that frame to + // the total screenRect we are returning. + nsRect frameScreenRect = frame->GetScreenRectInAppUnits(); + + // Get the length of the substring in this frame that we want the bounds for + int32_t startFrameTextOffset, endFrameTextOffset; + frame->GetOffsets(startFrameTextOffset, endFrameTextOffset); + int32_t frameTotalTextLength = endFrameTextOffset - startFrameTextOffset; + int32_t seekLength = endContentOffset - startContentOffset; + int32_t frameSubStringLength = std::min(frameTotalTextLength - startContentOffsetInFrame, seekLength); + + // Add the point where the string starts to the frameScreenRect + nsPoint frameTextStartPoint; + rv = frame->GetPointFromOffset(startContentOffset, &frameTextStartPoint); + NS_ENSURE_SUCCESS(rv, nsIntRect()); + + // Use the point for the end offset to calculate the width + nsPoint frameTextEndPoint; + rv = frame->GetPointFromOffset(startContentOffset + frameSubStringLength, &frameTextEndPoint); + NS_ENSURE_SUCCESS(rv, nsIntRect()); + + frameScreenRect.x += std::min(frameTextStartPoint.x, frameTextEndPoint.x); + frameScreenRect.width = mozilla::Abs(frameTextStartPoint.x - frameTextEndPoint.x); + + screenRect.UnionRect(frameScreenRect, screenRect); + + // Get ready to loop back for next frame continuation + startContentOffset += frameSubStringLength; + startContentOffsetInFrame = 0; + frame = frame->GetNextContinuation(); + } + + return screenRect.ToNearestPixels(presContext->AppUnitsPerDevPixel()); +} + +void +HyperTextAccessible::TextSubstring(int32_t aStartOffset, int32_t aEndOffset, + nsAString& aText) +{ + aText.Truncate(); + + index_t startOffset = ConvertMagicOffset(aStartOffset); + index_t endOffset = ConvertMagicOffset(aEndOffset); + if (!startOffset.IsValid() || !endOffset.IsValid() || + startOffset > endOffset || endOffset > CharacterCount()) { + NS_ERROR("Wrong in offset"); + return; + } + + int32_t startChildIdx = GetChildIndexAtOffset(startOffset); + if (startChildIdx == -1) + return; + + int32_t endChildIdx = GetChildIndexAtOffset(endOffset); + if (endChildIdx == -1) + return; + + if (startChildIdx == endChildIdx) { + int32_t childOffset = GetChildOffset(startChildIdx); + if (childOffset == -1) + return; + + Accessible* child = GetChildAt(startChildIdx); + child->AppendTextTo(aText, startOffset - childOffset, + endOffset - startOffset); + return; + } + + int32_t startChildOffset = GetChildOffset(startChildIdx); + if (startChildOffset == -1) + return; + + Accessible* startChild = GetChildAt(startChildIdx); + startChild->AppendTextTo(aText, startOffset - startChildOffset); + + for (int32_t childIdx = startChildIdx + 1; childIdx < endChildIdx; childIdx++) { + Accessible* child = GetChildAt(childIdx); + child->AppendTextTo(aText); + } + + int32_t endChildOffset = GetChildOffset(endChildIdx); + if (endChildOffset == -1) + return; + + Accessible* endChild = GetChildAt(endChildIdx); + endChild->AppendTextTo(aText, 0, endOffset - endChildOffset); +} + +uint32_t +HyperTextAccessible::DOMPointToOffset(nsINode* aNode, int32_t aNodeOffset, + bool aIsEndOffset) const +{ + if (!aNode) + return 0; + + uint32_t offset = 0; + nsINode* findNode = nullptr; + + if (aNodeOffset == -1) { + findNode = aNode; + + } else if (aNode->IsNodeOfType(nsINode::eTEXT)) { + // For text nodes, aNodeOffset comes in as a character offset + // Text offset will be added at the end, if we find the offset in this hypertext + // We want the "skipped" offset into the text (rendered text without the extra whitespace) + nsIFrame* frame = aNode->AsContent()->GetPrimaryFrame(); + NS_ENSURE_TRUE(frame, 0); + + nsresult rv = ContentToRenderedOffset(frame, aNodeOffset, &offset); + NS_ENSURE_SUCCESS(rv, 0); + + findNode = aNode; + + } else { + // findNode could be null if aNodeOffset == # of child nodes, which means + // one of two things: + // 1) there are no children, and the passed-in node is not mContent -- use + // parentContent for the node to find + // 2) there are no children and the passed-in node is mContent, which means + // we're an empty nsIAccessibleText + // 3) there are children and we're at the end of the children + + findNode = aNode->GetChildAt(aNodeOffset); + if (!findNode) { + if (aNodeOffset == 0) { + if (aNode == GetNode()) { + // Case #1: this accessible has no children and thus has empty text, + // we can only be at hypertext offset 0. + return 0; + } + + // Case #2: there are no children, we're at this node. + findNode = aNode; + } else if (aNodeOffset == static_cast<int32_t>(aNode->GetChildCount())) { + // Case #3: we're after the last child, get next node to this one. + for (nsINode* tmpNode = aNode; + !findNode && tmpNode && tmpNode != mContent; + tmpNode = tmpNode->GetParent()) { + findNode = tmpNode->GetNextSibling(); + } + } + } + } + + // Get accessible for this findNode, or if that node isn't accessible, use the + // accessible for the next DOM node which has one (based on forward depth first search) + Accessible* descendant = nullptr; + if (findNode) { + nsCOMPtr<nsIContent> findContent(do_QueryInterface(findNode)); + if (findContent && findContent->IsHTMLElement() && + findContent->NodeInfo()->Equals(nsGkAtoms::br) && + findContent->AttrValueIs(kNameSpaceID_None, + nsGkAtoms::mozeditorbogusnode, + nsGkAtoms::_true, + eIgnoreCase)) { + // This <br> is the hacky "bogus node" used when there is no text in a control + return 0; + } + + descendant = mDoc->GetAccessible(findNode); + if (!descendant && findNode->IsContent()) { + Accessible* container = mDoc->GetContainerAccessible(findNode); + if (container) { + TreeWalker walker(container, findNode->AsContent(), + TreeWalker::eWalkContextTree); + descendant = walker.Next(); + if (!descendant) + descendant = container; + } + } + } + + return TransformOffset(descendant, offset, aIsEndOffset); +} + +uint32_t +HyperTextAccessible::TransformOffset(Accessible* aDescendant, + uint32_t aOffset, bool aIsEndOffset) const +{ + // From the descendant, go up and get the immediate child of this hypertext. + uint32_t offset = aOffset; + Accessible* descendant = aDescendant; + while (descendant) { + Accessible* parent = descendant->Parent(); + if (parent == this) + return GetChildOffset(descendant) + offset; + + // This offset no longer applies because the passed-in text object is not + // a child of the hypertext. This happens when there are nested hypertexts, + // e.g. <div>abc<h1>def</h1>ghi</div>. Thus we need to adjust the offset + // to make it relative the hypertext. + // If the end offset is not supposed to be inclusive and the original point + // is not at 0 offset then the returned offset should be after an embedded + // character the original point belongs to. + if (aIsEndOffset) + offset = (offset > 0 || descendant->IndexInParent() > 0) ? 1 : 0; + else + offset = 0; + + descendant = parent; + } + + // If the given a11y point cannot be mapped into offset relative this hypertext + // offset then return length as fallback value. + return CharacterCount(); +} + +/** + * GetElementAsContentOf() returns a content representing an element which is + * or includes aNode. + * + * XXX This method is enough to retrieve ::before or ::after pseudo element. + * So, if you want to use this for other purpose, you might need to check + * ancestors too. + */ +static nsIContent* GetElementAsContentOf(nsINode* aNode) +{ + if (aNode->IsElement()) { + return aNode->AsContent(); + } + nsIContent* parent = aNode->GetParent(); + return parent && parent->IsElement() ? parent : nullptr; +} + +bool +HyperTextAccessible::OffsetsToDOMRange(int32_t aStartOffset, int32_t aEndOffset, + nsRange* aRange) +{ + DOMPoint startPoint = OffsetToDOMPoint(aStartOffset); + if (!startPoint.node) + return false; + + // HyperTextAccessible manages pseudo elements generated by ::before or + // ::after. However, contents of them are not in the DOM tree normally. + // Therefore, they are not selectable and editable. So, when this creates + // a DOM range, it should not start from nor end in any pseudo contents. + + nsIContent* container = GetElementAsContentOf(startPoint.node); + DOMPoint startPointForDOMRange = + ClosestNotGeneratedDOMPoint(startPoint, container); + aRange->SetStart(startPointForDOMRange.node, startPointForDOMRange.idx); + + // If the caller wants collapsed range, let's collapse the range to its start. + if (aStartOffset == aEndOffset) { + aRange->Collapse(true); + return true; + } + + DOMPoint endPoint = OffsetToDOMPoint(aEndOffset); + if (!endPoint.node) + return false; + + if (startPoint.node != endPoint.node) { + container = GetElementAsContentOf(endPoint.node); + } + + DOMPoint endPointForDOMRange = + ClosestNotGeneratedDOMPoint(endPoint, container); + aRange->SetEnd(endPointForDOMRange.node, endPointForDOMRange.idx); + return true; +} + +DOMPoint +HyperTextAccessible::OffsetToDOMPoint(int32_t aOffset) +{ + // 0 offset is valid even if no children. In this case the associated editor + // is empty so return a DOM point for editor root element. + if (aOffset == 0) { + nsCOMPtr<nsIEditor> editor = GetEditor(); + if (editor) { + bool isEmpty = false; + editor->GetDocumentIsEmpty(&isEmpty); + if (isEmpty) { + nsCOMPtr<nsIDOMElement> editorRootElm; + editor->GetRootElement(getter_AddRefs(editorRootElm)); + + nsCOMPtr<nsINode> editorRoot(do_QueryInterface(editorRootElm)); + return DOMPoint(editorRoot, 0); + } + } + } + + int32_t childIdx = GetChildIndexAtOffset(aOffset); + if (childIdx == -1) + return DOMPoint(); + + Accessible* child = GetChildAt(childIdx); + int32_t innerOffset = aOffset - GetChildOffset(childIdx); + + // A text leaf case. + if (child->IsTextLeaf()) { + // The point is inside the text node. This is always true for any text leaf + // except a last child one. See assertion below. + if (aOffset < GetChildOffset(childIdx + 1)) { + nsIContent* content = child->GetContent(); + int32_t idx = 0; + if (NS_FAILED(RenderedToContentOffset(content->GetPrimaryFrame(), + innerOffset, &idx))) + return DOMPoint(); + + return DOMPoint(content, idx); + } + + // Set the DOM point right after the text node. + MOZ_ASSERT(static_cast<uint32_t>(aOffset) == CharacterCount()); + innerOffset = 1; + } + + // Case of embedded object. The point is either before or after the element. + NS_ASSERTION(innerOffset == 0 || innerOffset == 1, "A wrong inner offset!"); + nsINode* node = child->GetNode(); + nsINode* parentNode = node->GetParentNode(); + return parentNode ? + DOMPoint(parentNode, parentNode->IndexOf(node) + innerOffset) : + DOMPoint(); +} + +DOMPoint +HyperTextAccessible::ClosestNotGeneratedDOMPoint(const DOMPoint& aDOMPoint, + nsIContent* aElementContent) +{ + MOZ_ASSERT(aDOMPoint.node, "The node must not be null"); + + // ::before pseudo element + if (aElementContent && + aElementContent->IsGeneratedContentContainerForBefore()) { + MOZ_ASSERT(aElementContent->GetParent(), + "::before must have parent element"); + // The first child of its parent (i.e., immediately after the ::before) is + // good point for a DOM range. + return DOMPoint(aElementContent->GetParent(), 0); + } + + // ::after pseudo element + if (aElementContent && + aElementContent->IsGeneratedContentContainerForAfter()) { + MOZ_ASSERT(aElementContent->GetParent(), + "::after must have parent element"); + // The end of its parent (i.e., immediately before the ::after) is good + // point for a DOM range. + return DOMPoint(aElementContent->GetParent(), + aElementContent->GetParent()->GetChildCount()); + } + + return aDOMPoint; +} + +uint32_t +HyperTextAccessible::FindOffset(uint32_t aOffset, nsDirection aDirection, + nsSelectionAmount aAmount, + EWordMovementType aWordMovementType) +{ + NS_ASSERTION(aDirection == eDirPrevious || aAmount != eSelectBeginLine, + "eSelectBeginLine should only be used with eDirPrevious"); + + // Find a leaf accessible frame to start with. PeekOffset wants this. + HyperTextAccessible* text = this; + Accessible* child = nullptr; + int32_t innerOffset = aOffset; + + do { + int32_t childIdx = text->GetChildIndexAtOffset(innerOffset); + + // We can have an empty text leaf as our only child. Since empty text + // leaves are not accessible we then have no children, but 0 is a valid + // innerOffset. + if (childIdx == -1) { + NS_ASSERTION(innerOffset == 0 && !text->ChildCount(), "No childIdx?"); + return DOMPointToOffset(text->GetNode(), 0, aDirection == eDirNext); + } + + child = text->GetChildAt(childIdx); + + // HTML list items may need special processing because PeekOffset doesn't + // work with list bullets. + if (text->IsHTMLListItem()) { + HTMLLIAccessible* li = text->AsHTMLListItem(); + if (child == li->Bullet()) { + // XXX: the logic is broken for multichar bullets in moving by + // char/cluster/word cases. + if (text != this) { + return aDirection == eDirPrevious ? + TransformOffset(text, 0, false) : + TransformOffset(text, 1, true); + } + if (aDirection == eDirPrevious) + return 0; + + uint32_t nextOffset = GetChildOffset(1); + if (nextOffset == 0) + return 0; + + switch (aAmount) { + case eSelectLine: + case eSelectEndLine: + // Ask a text leaf next (if not empty) to the bullet for an offset + // since list item may be multiline. + return nextOffset < CharacterCount() ? + FindOffset(nextOffset, aDirection, aAmount, aWordMovementType) : + nextOffset; + + default: + return nextOffset; + } + } + } + + innerOffset -= text->GetChildOffset(childIdx); + + text = child->AsHyperText(); + } while (text); + + nsIFrame* childFrame = child->GetFrame(); + if (!childFrame) { + NS_ERROR("No child frame"); + return 0; + } + + int32_t innerContentOffset = innerOffset; + if (child->IsTextLeaf()) { + NS_ASSERTION(childFrame->GetType() == nsGkAtoms::textFrame, "Wrong frame!"); + RenderedToContentOffset(childFrame, innerOffset, &innerContentOffset); + } + + nsIFrame* frameAtOffset = childFrame; + int32_t unusedOffsetInFrame = 0; + childFrame->GetChildFrameContainingOffset(innerContentOffset, true, + &unusedOffsetInFrame, + &frameAtOffset); + + const bool kIsJumpLinesOk = true; // okay to jump lines + const bool kIsScrollViewAStop = false; // do not stop at scroll views + const bool kIsKeyboardSelect = true; // is keyboard selection + const bool kIsVisualBidi = false; // use visual order for bidi text + nsPeekOffsetStruct pos(aAmount, aDirection, innerContentOffset, + nsPoint(0, 0), kIsJumpLinesOk, kIsScrollViewAStop, + kIsKeyboardSelect, kIsVisualBidi, + false, aWordMovementType); + nsresult rv = frameAtOffset->PeekOffset(&pos); + + // PeekOffset fails on last/first lines of the text in certain cases. + if (NS_FAILED(rv) && aAmount == eSelectLine) { + pos.mAmount = (aDirection == eDirNext) ? eSelectEndLine : eSelectBeginLine; + frameAtOffset->PeekOffset(&pos); + } + if (!pos.mResultContent) { + NS_ERROR("No result content!"); + return 0; + } + + // Turn the resulting DOM point into an offset. + uint32_t hyperTextOffset = DOMPointToOffset(pos.mResultContent, + pos.mContentOffset, + aDirection == eDirNext); + + if (aDirection == eDirPrevious) { + // If we reached the end during search, this means we didn't find the DOM point + // and we're actually at the start of the paragraph + if (hyperTextOffset == CharacterCount()) + return 0; + + // PeekOffset stops right before bullet so return 0 to workaround it. + if (IsHTMLListItem() && aAmount == eSelectBeginLine && + hyperTextOffset > 0) { + Accessible* prevOffsetChild = GetChildAtOffset(hyperTextOffset - 1); + if (prevOffsetChild == AsHTMLListItem()->Bullet()) + return 0; + } + } + + return hyperTextOffset; +} + +uint32_t +HyperTextAccessible::FindLineBoundary(uint32_t aOffset, + EWhichLineBoundary aWhichLineBoundary) +{ + // Note: empty last line doesn't have own frame (a previous line contains '\n' + // character instead) thus when it makes a difference we need to process this + // case separately (otherwise operations are performed on previous line). + switch (aWhichLineBoundary) { + case ePrevLineBegin: { + // Fetch a previous line and move to its start (as arrow up and home keys + // were pressed). + if (IsEmptyLastLineOffset(aOffset)) + return FindOffset(aOffset, eDirPrevious, eSelectBeginLine); + + uint32_t tmpOffset = FindOffset(aOffset, eDirPrevious, eSelectLine); + return FindOffset(tmpOffset, eDirPrevious, eSelectBeginLine); + } + + case ePrevLineEnd: { + if (IsEmptyLastLineOffset(aOffset)) + return aOffset - 1; + + // If offset is at first line then return 0 (first line start). + uint32_t tmpOffset = FindOffset(aOffset, eDirPrevious, eSelectBeginLine); + if (tmpOffset == 0) + return 0; + + // Otherwise move to end of previous line (as arrow up and end keys were + // pressed). + tmpOffset = FindOffset(aOffset, eDirPrevious, eSelectLine); + return FindOffset(tmpOffset, eDirNext, eSelectEndLine); + } + + case eThisLineBegin: + if (IsEmptyLastLineOffset(aOffset)) + return aOffset; + + // Move to begin of the current line (as home key was pressed). + return FindOffset(aOffset, eDirPrevious, eSelectBeginLine); + + case eThisLineEnd: + if (IsEmptyLastLineOffset(aOffset)) + return aOffset; + + // Move to end of the current line (as end key was pressed). + return FindOffset(aOffset, eDirNext, eSelectEndLine); + + case eNextLineBegin: { + if (IsEmptyLastLineOffset(aOffset)) + return aOffset; + + // Move to begin of the next line if any (arrow down and home keys), + // otherwise end of the current line (arrow down only). + uint32_t tmpOffset = FindOffset(aOffset, eDirNext, eSelectLine); + if (tmpOffset == CharacterCount()) + return tmpOffset; + + return FindOffset(tmpOffset, eDirPrevious, eSelectBeginLine); + } + + case eNextLineEnd: { + if (IsEmptyLastLineOffset(aOffset)) + return aOffset; + + // Move to next line end (as down arrow and end key were pressed). + uint32_t tmpOffset = FindOffset(aOffset, eDirNext, eSelectLine); + if (tmpOffset == CharacterCount()) + return tmpOffset; + + return FindOffset(tmpOffset, eDirNext, eSelectEndLine); + } + } + + return 0; +} + +void +HyperTextAccessible::TextBeforeOffset(int32_t aOffset, + AccessibleTextBoundary aBoundaryType, + int32_t* aStartOffset, int32_t* aEndOffset, + nsAString& aText) +{ + *aStartOffset = *aEndOffset = 0; + aText.Truncate(); + + index_t convertedOffset = ConvertMagicOffset(aOffset); + if (!convertedOffset.IsValid() || convertedOffset > CharacterCount()) { + NS_ERROR("Wrong in offset!"); + return; + } + + uint32_t adjustedOffset = convertedOffset; + if (aOffset == nsIAccessibleText::TEXT_OFFSET_CARET) + adjustedOffset = AdjustCaretOffset(adjustedOffset); + + switch (aBoundaryType) { + case nsIAccessibleText::BOUNDARY_CHAR: + if (convertedOffset != 0) + CharAt(convertedOffset - 1, aText, aStartOffset, aEndOffset); + break; + + case nsIAccessibleText::BOUNDARY_WORD_START: { + // If the offset is a word start (except text length offset) then move + // backward to find a start offset (end offset is the given offset). + // Otherwise move backward twice to find both start and end offsets. + if (adjustedOffset == CharacterCount()) { + *aEndOffset = FindWordBoundary(adjustedOffset, eDirPrevious, eStartWord); + *aStartOffset = FindWordBoundary(*aEndOffset, eDirPrevious, eStartWord); + } else { + *aStartOffset = FindWordBoundary(adjustedOffset, eDirPrevious, eStartWord); + *aEndOffset = FindWordBoundary(*aStartOffset, eDirNext, eStartWord); + if (*aEndOffset != static_cast<int32_t>(adjustedOffset)) { + *aEndOffset = *aStartOffset; + *aStartOffset = FindWordBoundary(*aEndOffset, eDirPrevious, eStartWord); + } + } + TextSubstring(*aStartOffset, *aEndOffset, aText); + break; + } + + case nsIAccessibleText::BOUNDARY_WORD_END: { + // Move word backward twice to find start and end offsets. + *aEndOffset = FindWordBoundary(convertedOffset, eDirPrevious, eEndWord); + *aStartOffset = FindWordBoundary(*aEndOffset, eDirPrevious, eEndWord); + TextSubstring(*aStartOffset, *aEndOffset, aText); + break; + } + + case nsIAccessibleText::BOUNDARY_LINE_START: + *aStartOffset = FindLineBoundary(adjustedOffset, ePrevLineBegin); + *aEndOffset = FindLineBoundary(adjustedOffset, eThisLineBegin); + TextSubstring(*aStartOffset, *aEndOffset, aText); + break; + + case nsIAccessibleText::BOUNDARY_LINE_END: { + *aEndOffset = FindLineBoundary(adjustedOffset, ePrevLineEnd); + int32_t tmpOffset = *aEndOffset; + // Adjust offset if line is wrapped. + if (*aEndOffset != 0 && !IsLineEndCharAt(*aEndOffset)) + tmpOffset--; + + *aStartOffset = FindLineBoundary(tmpOffset, ePrevLineEnd); + TextSubstring(*aStartOffset, *aEndOffset, aText); + break; + } + } +} + +void +HyperTextAccessible::TextAtOffset(int32_t aOffset, + AccessibleTextBoundary aBoundaryType, + int32_t* aStartOffset, int32_t* aEndOffset, + nsAString& aText) +{ + *aStartOffset = *aEndOffset = 0; + aText.Truncate(); + + uint32_t adjustedOffset = ConvertMagicOffset(aOffset); + if (adjustedOffset == std::numeric_limits<uint32_t>::max()) { + NS_ERROR("Wrong given offset!"); + return; + } + + switch (aBoundaryType) { + case nsIAccessibleText::BOUNDARY_CHAR: + // Return no char if caret is at the end of wrapped line (case of no line + // end character). Returning a next line char is confusing for AT. + if (aOffset == nsIAccessibleText::TEXT_OFFSET_CARET && IsCaretAtEndOfLine()) + *aStartOffset = *aEndOffset = adjustedOffset; + else + CharAt(adjustedOffset, aText, aStartOffset, aEndOffset); + break; + + case nsIAccessibleText::BOUNDARY_WORD_START: + if (aOffset == nsIAccessibleText::TEXT_OFFSET_CARET) + adjustedOffset = AdjustCaretOffset(adjustedOffset); + + *aEndOffset = FindWordBoundary(adjustedOffset, eDirNext, eStartWord); + *aStartOffset = FindWordBoundary(*aEndOffset, eDirPrevious, eStartWord); + TextSubstring(*aStartOffset, *aEndOffset, aText); + break; + + case nsIAccessibleText::BOUNDARY_WORD_END: + // Ignore the spec and follow what WebKitGtk does because Orca expects it, + // i.e. return a next word at word end offset of the current word + // (WebKitGtk behavior) instead the current word (AKT spec). + *aEndOffset = FindWordBoundary(adjustedOffset, eDirNext, eEndWord); + *aStartOffset = FindWordBoundary(*aEndOffset, eDirPrevious, eEndWord); + TextSubstring(*aStartOffset, *aEndOffset, aText); + break; + + case nsIAccessibleText::BOUNDARY_LINE_START: + if (aOffset == nsIAccessibleText::TEXT_OFFSET_CARET) + adjustedOffset = AdjustCaretOffset(adjustedOffset); + + *aStartOffset = FindLineBoundary(adjustedOffset, eThisLineBegin); + *aEndOffset = FindLineBoundary(adjustedOffset, eNextLineBegin); + TextSubstring(*aStartOffset, *aEndOffset, aText); + break; + + case nsIAccessibleText::BOUNDARY_LINE_END: + if (aOffset == nsIAccessibleText::TEXT_OFFSET_CARET) + adjustedOffset = AdjustCaretOffset(adjustedOffset); + + // In contrast to word end boundary we follow the spec here. + *aStartOffset = FindLineBoundary(adjustedOffset, ePrevLineEnd); + *aEndOffset = FindLineBoundary(adjustedOffset, eThisLineEnd); + TextSubstring(*aStartOffset, *aEndOffset, aText); + break; + } +} + +void +HyperTextAccessible::TextAfterOffset(int32_t aOffset, + AccessibleTextBoundary aBoundaryType, + int32_t* aStartOffset, int32_t* aEndOffset, + nsAString& aText) +{ + *aStartOffset = *aEndOffset = 0; + aText.Truncate(); + + index_t convertedOffset = ConvertMagicOffset(aOffset); + if (!convertedOffset.IsValid() || convertedOffset > CharacterCount()) { + NS_ERROR("Wrong in offset!"); + return; + } + + uint32_t adjustedOffset = convertedOffset; + if (aOffset == nsIAccessibleText::TEXT_OFFSET_CARET) + adjustedOffset = AdjustCaretOffset(adjustedOffset); + + switch (aBoundaryType) { + case nsIAccessibleText::BOUNDARY_CHAR: + // If caret is at the end of wrapped line (case of no line end character) + // then char after the offset is a first char at next line. + if (adjustedOffset >= CharacterCount()) + *aStartOffset = *aEndOffset = CharacterCount(); + else + CharAt(adjustedOffset + 1, aText, aStartOffset, aEndOffset); + break; + + case nsIAccessibleText::BOUNDARY_WORD_START: + // Move word forward twice to find start and end offsets. + *aStartOffset = FindWordBoundary(adjustedOffset, eDirNext, eStartWord); + *aEndOffset = FindWordBoundary(*aStartOffset, eDirNext, eStartWord); + TextSubstring(*aStartOffset, *aEndOffset, aText); + break; + + case nsIAccessibleText::BOUNDARY_WORD_END: + // If the offset is a word end (except 0 offset) then move forward to find + // end offset (start offset is the given offset). Otherwise move forward + // twice to find both start and end offsets. + if (convertedOffset == 0) { + *aStartOffset = FindWordBoundary(convertedOffset, eDirNext, eEndWord); + *aEndOffset = FindWordBoundary(*aStartOffset, eDirNext, eEndWord); + } else { + *aEndOffset = FindWordBoundary(convertedOffset, eDirNext, eEndWord); + *aStartOffset = FindWordBoundary(*aEndOffset, eDirPrevious, eEndWord); + if (*aStartOffset != static_cast<int32_t>(convertedOffset)) { + *aStartOffset = *aEndOffset; + *aEndOffset = FindWordBoundary(*aStartOffset, eDirNext, eEndWord); + } + } + TextSubstring(*aStartOffset, *aEndOffset, aText); + break; + + case nsIAccessibleText::BOUNDARY_LINE_START: + *aStartOffset = FindLineBoundary(adjustedOffset, eNextLineBegin); + *aEndOffset = FindLineBoundary(*aStartOffset, eNextLineBegin); + TextSubstring(*aStartOffset, *aEndOffset, aText); + break; + + case nsIAccessibleText::BOUNDARY_LINE_END: + *aStartOffset = FindLineBoundary(adjustedOffset, eThisLineEnd); + *aEndOffset = FindLineBoundary(adjustedOffset, eNextLineEnd); + TextSubstring(*aStartOffset, *aEndOffset, aText); + break; + } +} + +already_AddRefed<nsIPersistentProperties> +HyperTextAccessible::TextAttributes(bool aIncludeDefAttrs, int32_t aOffset, + int32_t* aStartOffset, + int32_t* aEndOffset) +{ + // 1. Get each attribute and its ranges one after another. + // 2. As we get each new attribute, we pass the current start and end offsets + // as in/out parameters. In other words, as attributes are collected, + // the attribute range itself can only stay the same or get smaller. + + *aStartOffset = *aEndOffset = 0; + index_t offset = ConvertMagicOffset(aOffset); + if (!offset.IsValid() || offset > CharacterCount()) { + NS_ERROR("Wrong in offset!"); + return nullptr; + } + + nsCOMPtr<nsIPersistentProperties> attributes = + do_CreateInstance(NS_PERSISTENTPROPERTIES_CONTRACTID); + + Accessible* accAtOffset = GetChildAtOffset(offset); + if (!accAtOffset) { + // Offset 0 is correct offset when accessible has empty text. Include + // default attributes if they were requested, otherwise return empty set. + if (offset == 0) { + if (aIncludeDefAttrs) { + TextAttrsMgr textAttrsMgr(this); + textAttrsMgr.GetAttributes(attributes); + } + return attributes.forget(); + } + return nullptr; + } + + int32_t accAtOffsetIdx = accAtOffset->IndexInParent(); + uint32_t startOffset = GetChildOffset(accAtOffsetIdx); + uint32_t endOffset = GetChildOffset(accAtOffsetIdx + 1); + int32_t offsetInAcc = offset - startOffset; + + TextAttrsMgr textAttrsMgr(this, aIncludeDefAttrs, accAtOffset, + accAtOffsetIdx); + textAttrsMgr.GetAttributes(attributes, &startOffset, &endOffset); + + // Compute spelling attributes on text accessible only. + nsIFrame *offsetFrame = accAtOffset->GetFrame(); + if (offsetFrame && offsetFrame->GetType() == nsGkAtoms::textFrame) { + int32_t nodeOffset = 0; + RenderedToContentOffset(offsetFrame, offsetInAcc, &nodeOffset); + + // Set 'misspelled' text attribute. + GetSpellTextAttr(accAtOffset->GetNode(), nodeOffset, + &startOffset, &endOffset, attributes); + } + + *aStartOffset = startOffset; + *aEndOffset = endOffset; + return attributes.forget(); +} + +already_AddRefed<nsIPersistentProperties> +HyperTextAccessible::DefaultTextAttributes() +{ + nsCOMPtr<nsIPersistentProperties> attributes = + do_CreateInstance(NS_PERSISTENTPROPERTIES_CONTRACTID); + + TextAttrsMgr textAttrsMgr(this); + textAttrsMgr.GetAttributes(attributes); + return attributes.forget(); +} + +int32_t +HyperTextAccessible::GetLevelInternal() +{ + if (mContent->IsHTMLElement(nsGkAtoms::h1)) + return 1; + if (mContent->IsHTMLElement(nsGkAtoms::h2)) + return 2; + if (mContent->IsHTMLElement(nsGkAtoms::h3)) + return 3; + if (mContent->IsHTMLElement(nsGkAtoms::h4)) + return 4; + if (mContent->IsHTMLElement(nsGkAtoms::h5)) + return 5; + if (mContent->IsHTMLElement(nsGkAtoms::h6)) + return 6; + + return AccessibleWrap::GetLevelInternal(); +} + +void +HyperTextAccessible::SetMathMLXMLRoles(nsIPersistentProperties* aAttributes) +{ + // Add MathML xmlroles based on the position inside the parent. + Accessible* parent = Parent(); + if (parent) { + switch (parent->Role()) { + case roles::MATHML_CELL: + case roles::MATHML_ENCLOSED: + case roles::MATHML_ERROR: + case roles::MATHML_MATH: + case roles::MATHML_ROW: + case roles::MATHML_SQUARE_ROOT: + case roles::MATHML_STYLE: + if (Role() == roles::MATHML_OPERATOR) { + // This is an operator inside an <mrow> (or an inferred <mrow>). + // See http://www.w3.org/TR/MathML3/chapter3.html#presm.inferredmrow + // XXX We should probably do something similar for MATHML_FENCED, but + // operators do not appear in the accessible tree. See bug 1175747. + nsIMathMLFrame* mathMLFrame = do_QueryFrame(GetFrame()); + if (mathMLFrame) { + nsEmbellishData embellishData; + mathMLFrame->GetEmbellishData(embellishData); + if (NS_MATHML_EMBELLISH_IS_FENCE(embellishData.flags)) { + if (!PrevSibling()) { + nsAccUtils::SetAccAttr(aAttributes, nsGkAtoms::xmlroles, + nsGkAtoms::open_fence); + } else if (!NextSibling()) { + nsAccUtils::SetAccAttr(aAttributes, nsGkAtoms::xmlroles, + nsGkAtoms::close_fence); + } + } + if (NS_MATHML_EMBELLISH_IS_SEPARATOR(embellishData.flags)) { + nsAccUtils::SetAccAttr(aAttributes, nsGkAtoms::xmlroles, + nsGkAtoms::separator_); + } + } + } + break; + case roles::MATHML_FRACTION: + nsAccUtils::SetAccAttr(aAttributes, nsGkAtoms::xmlroles, + IndexInParent() == 0 ? + nsGkAtoms::numerator : + nsGkAtoms::denominator); + break; + case roles::MATHML_ROOT: + nsAccUtils::SetAccAttr(aAttributes, nsGkAtoms::xmlroles, + IndexInParent() == 0 ? nsGkAtoms::base : + nsGkAtoms::root_index); + break; + case roles::MATHML_SUB: + nsAccUtils::SetAccAttr(aAttributes, nsGkAtoms::xmlroles, + IndexInParent() == 0 ? nsGkAtoms::base : + nsGkAtoms::subscript); + break; + case roles::MATHML_SUP: + nsAccUtils::SetAccAttr(aAttributes, nsGkAtoms::xmlroles, + IndexInParent() == 0 ? nsGkAtoms::base : + nsGkAtoms::superscript); + break; + case roles::MATHML_SUB_SUP: { + int32_t index = IndexInParent(); + nsAccUtils::SetAccAttr(aAttributes, nsGkAtoms::xmlroles, + index == 0 ? nsGkAtoms::base : + (index == 1 ? nsGkAtoms::subscript : + nsGkAtoms::superscript)); + } break; + case roles::MATHML_UNDER: + nsAccUtils::SetAccAttr(aAttributes, nsGkAtoms::xmlroles, + IndexInParent() == 0 ? nsGkAtoms::base : + nsGkAtoms::underscript); + break; + case roles::MATHML_OVER: + nsAccUtils::SetAccAttr(aAttributes, nsGkAtoms::xmlroles, + IndexInParent() == 0 ? nsGkAtoms::base : + nsGkAtoms::overscript); + break; + case roles::MATHML_UNDER_OVER: { + int32_t index = IndexInParent(); + nsAccUtils::SetAccAttr(aAttributes, nsGkAtoms::xmlroles, + index == 0 ? nsGkAtoms::base : + (index == 1 ? nsGkAtoms::underscript : + nsGkAtoms::overscript)); + } break; + case roles::MATHML_MULTISCRIPTS: { + // Get the <multiscripts> base. + nsIContent* child; + bool baseFound = false; + for (child = parent->GetContent()->GetFirstChild(); child; + child = child->GetNextSibling()) { + if (child->IsMathMLElement()) { + baseFound = true; + break; + } + } + if (baseFound) { + nsIContent* content = GetContent(); + if (child == content) { + // We are the base. + nsAccUtils::SetAccAttr(aAttributes, nsGkAtoms::xmlroles, + nsGkAtoms::base); + } else { + // Browse the list of scripts to find us and determine our type. + bool postscript = true; + bool subscript = true; + for (child = child->GetNextSibling(); child; + child = child->GetNextSibling()) { + if (!child->IsMathMLElement()) + continue; + if (child->IsMathMLElement(nsGkAtoms::mprescripts_)) { + postscript = false; + subscript = true; + continue; + } + if (child == content) { + if (postscript) { + nsAccUtils::SetAccAttr(aAttributes, nsGkAtoms::xmlroles, + subscript ? + nsGkAtoms::subscript : + nsGkAtoms::superscript); + } else { + nsAccUtils::SetAccAttr(aAttributes, nsGkAtoms::xmlroles, + subscript ? + nsGkAtoms::presubscript : + nsGkAtoms::presuperscript); + } + break; + } + subscript = !subscript; + } + } + } + } break; + default: + break; + } + } +} + +already_AddRefed<nsIPersistentProperties> +HyperTextAccessible::NativeAttributes() +{ + nsCOMPtr<nsIPersistentProperties> attributes = + AccessibleWrap::NativeAttributes(); + + // 'formatting' attribute is deprecated, 'display' attribute should be + // instead. + nsIFrame *frame = GetFrame(); + if (frame && frame->GetType() == nsGkAtoms::blockFrame) { + nsAutoString unused; + attributes->SetStringProperty(NS_LITERAL_CSTRING("formatting"), + NS_LITERAL_STRING("block"), unused); + } + + if (FocusMgr()->IsFocused(this)) { + int32_t lineNumber = CaretLineNumber(); + if (lineNumber >= 1) { + nsAutoString strLineNumber; + strLineNumber.AppendInt(lineNumber); + nsAccUtils::SetAccAttr(attributes, nsGkAtoms::lineNumber, strLineNumber); + } + } + + if (HasOwnContent()) { + GetAccService()->MarkupAttributes(mContent, attributes); + if (mContent->IsMathMLElement()) + SetMathMLXMLRoles(attributes); + } + + return attributes.forget(); +} + +nsIAtom* +HyperTextAccessible::LandmarkRole() const +{ + if (!HasOwnContent()) + return nullptr; + + // For the html landmark elements we expose them like we do ARIA landmarks to + // make AT navigation schemes "just work". + if (mContent->IsHTMLElement(nsGkAtoms::nav)) { + return nsGkAtoms::navigation; + } + + if (mContent->IsAnyOfHTMLElements(nsGkAtoms::header, + nsGkAtoms::footer)) { + // Only map header and footer if they are not descendants of an article + // or section tag. + nsIContent* parent = mContent->GetParent(); + while (parent) { + if (parent->IsAnyOfHTMLElements(nsGkAtoms::article, nsGkAtoms::section)) { + break; + } + parent = parent->GetParent(); + } + + // No article or section elements found. + if (!parent) { + if (mContent->IsHTMLElement(nsGkAtoms::header)) { + return nsGkAtoms::banner; + } + + if (mContent->IsHTMLElement(nsGkAtoms::footer)) { + return nsGkAtoms::contentinfo; + } + } + return nullptr; + } + + if (mContent->IsHTMLElement(nsGkAtoms::aside)) { + return nsGkAtoms::complementary; + } + + if (mContent->IsHTMLElement(nsGkAtoms::main)) { + return nsGkAtoms::main; + } + + return nullptr; +} + +int32_t +HyperTextAccessible::OffsetAtPoint(int32_t aX, int32_t aY, uint32_t aCoordType) +{ + nsIFrame* hyperFrame = GetFrame(); + if (!hyperFrame) + return -1; + + nsIntPoint coords = nsAccUtils::ConvertToScreenCoords(aX, aY, aCoordType, + this); + + nsPresContext* presContext = mDoc->PresContext(); + nsPoint coordsInAppUnits = + ToAppUnits(coords, presContext->AppUnitsPerDevPixel()); + + nsRect frameScreenRect = hyperFrame->GetScreenRectInAppUnits(); + if (!frameScreenRect.Contains(coordsInAppUnits.x, coordsInAppUnits.y)) + return -1; // Not found + + nsPoint pointInHyperText(coordsInAppUnits.x - frameScreenRect.x, + coordsInAppUnits.y - frameScreenRect.y); + + // Go through the frames to check if each one has the point. + // When one does, add up the character offsets until we have a match + + // We have an point in an accessible child of this, now we need to add up the + // offsets before it to what we already have + int32_t offset = 0; + uint32_t childCount = ChildCount(); + for (uint32_t childIdx = 0; childIdx < childCount; childIdx++) { + Accessible* childAcc = mChildren[childIdx]; + + nsIFrame *primaryFrame = childAcc->GetFrame(); + NS_ENSURE_TRUE(primaryFrame, -1); + + nsIFrame *frame = primaryFrame; + while (frame) { + nsIContent *content = frame->GetContent(); + NS_ENSURE_TRUE(content, -1); + nsPoint pointInFrame = pointInHyperText - frame->GetOffsetTo(hyperFrame); + nsSize frameSize = frame->GetSize(); + if (pointInFrame.x < frameSize.width && pointInFrame.y < frameSize.height) { + // Finished + if (frame->GetType() == nsGkAtoms::textFrame) { + nsIFrame::ContentOffsets contentOffsets = + frame->GetContentOffsetsFromPointExternal(pointInFrame, nsIFrame::IGNORE_SELECTION_STYLE); + if (contentOffsets.IsNull() || contentOffsets.content != content) { + return -1; // Not found + } + uint32_t addToOffset; + nsresult rv = ContentToRenderedOffset(primaryFrame, + contentOffsets.offset, + &addToOffset); + NS_ENSURE_SUCCESS(rv, -1); + offset += addToOffset; + } + return offset; + } + frame = frame->GetNextContinuation(); + } + + offset += nsAccUtils::TextLength(childAcc); + } + + return -1; // Not found +} + +nsIntRect +HyperTextAccessible::TextBounds(int32_t aStartOffset, int32_t aEndOffset, + uint32_t aCoordType) +{ + index_t startOffset = ConvertMagicOffset(aStartOffset); + index_t endOffset = ConvertMagicOffset(aEndOffset); + if (!startOffset.IsValid() || !endOffset.IsValid() || + startOffset > endOffset || endOffset > CharacterCount()) { + NS_ERROR("Wrong in offset"); + return nsIntRect(); + } + + + int32_t childIdx = GetChildIndexAtOffset(startOffset); + if (childIdx == -1) + return nsIntRect(); + + nsIntRect bounds; + int32_t prevOffset = GetChildOffset(childIdx); + int32_t offset1 = startOffset - prevOffset; + + while (childIdx < static_cast<int32_t>(ChildCount())) { + nsIFrame* frame = GetChildAt(childIdx++)->GetFrame(); + if (!frame) { + NS_NOTREACHED("No frame for a child!"); + continue; + } + + int32_t nextOffset = GetChildOffset(childIdx); + if (nextOffset >= static_cast<int32_t>(endOffset)) { + bounds.UnionRect(bounds, GetBoundsInFrame(frame, offset1, + endOffset - prevOffset)); + break; + } + + bounds.UnionRect(bounds, GetBoundsInFrame(frame, offset1, + nextOffset - prevOffset)); + + prevOffset = nextOffset; + offset1 = 0; + } + + nsAccUtils::ConvertScreenCoordsTo(&bounds.x, &bounds.y, aCoordType, this); + return bounds; +} + +already_AddRefed<nsIEditor> +HyperTextAccessible::GetEditor() const +{ + if (!mContent->HasFlag(NODE_IS_EDITABLE)) { + // If we're inside an editable container, then return that container's editor + Accessible* ancestor = Parent(); + while (ancestor) { + HyperTextAccessible* hyperText = ancestor->AsHyperText(); + if (hyperText) { + // Recursion will stop at container doc because it has its own impl + // of GetEditor() + return hyperText->GetEditor(); + } + + ancestor = ancestor->Parent(); + } + + return nullptr; + } + + nsCOMPtr<nsIDocShell> docShell = nsCoreUtils::GetDocShellFor(mContent); + nsCOMPtr<nsIEditingSession> editingSession; + docShell->GetEditingSession(getter_AddRefs(editingSession)); + if (!editingSession) + return nullptr; // No editing session interface + + nsCOMPtr<nsIEditor> editor; + nsIDocument* docNode = mDoc->DocumentNode(); + editingSession->GetEditorForWindow(docNode->GetWindow(), + getter_AddRefs(editor)); + return editor.forget(); +} + +/** + * =================== Caret & Selection ====================== + */ + +nsresult +HyperTextAccessible::SetSelectionRange(int32_t aStartPos, int32_t aEndPos) +{ + // Before setting the selection range, we need to ensure that the editor + // is initialized. (See bug 804927.) + // Otherwise, it's possible that lazy editor initialization will override + // the selection we set here and leave the caret at the end of the text. + // By calling GetEditor here, we ensure that editor initialization is + // completed before we set the selection. + nsCOMPtr<nsIEditor> editor = GetEditor(); + + bool isFocusable = InteractiveState() & states::FOCUSABLE; + + // If accessible is focusable then focus it before setting the selection to + // neglect control's selection changes on focus if any (for example, inputs + // that do select all on focus). + // some input controls + if (isFocusable) + TakeFocus(); + + dom::Selection* domSel = DOMSelection(); + NS_ENSURE_STATE(domSel); + + // Set up the selection. + for (int32_t idx = domSel->RangeCount() - 1; idx > 0; idx--) + domSel->RemoveRange(domSel->GetRangeAt(idx)); + SetSelectionBoundsAt(0, aStartPos, aEndPos); + + // When selection is done, move the focus to the selection if accessible is + // not focusable. That happens when selection is set within hypertext + // accessible. + if (isFocusable) + return NS_OK; + + nsFocusManager* DOMFocusManager = nsFocusManager::GetFocusManager(); + if (DOMFocusManager) { + NS_ENSURE_TRUE(mDoc, NS_ERROR_FAILURE); + nsIDocument* docNode = mDoc->DocumentNode(); + NS_ENSURE_TRUE(docNode, NS_ERROR_FAILURE); + nsCOMPtr<nsPIDOMWindowOuter> window = docNode->GetWindow(); + nsCOMPtr<nsIDOMElement> result; + DOMFocusManager->MoveFocus(window, nullptr, nsIFocusManager::MOVEFOCUS_CARET, + nsIFocusManager::FLAG_BYMOVEFOCUS, getter_AddRefs(result)); + } + + return NS_OK; +} + +int32_t +HyperTextAccessible::CaretOffset() const +{ + // Not focused focusable accessible except document accessible doesn't have + // a caret. + if (!IsDoc() && !FocusMgr()->IsFocused(this) && + (InteractiveState() & states::FOCUSABLE)) { + return -1; + } + + // Check cached value. + int32_t caretOffset = -1; + HyperTextAccessible* text = SelectionMgr()->AccessibleWithCaret(&caretOffset); + + // Use cached value if it corresponds to this accessible. + if (caretOffset != -1) { + if (text == this) + return caretOffset; + + nsINode* textNode = text->GetNode(); + // Ignore offset if cached accessible isn't a text leaf. + if (nsCoreUtils::IsAncestorOf(GetNode(), textNode)) + return TransformOffset(text, + textNode->IsNodeOfType(nsINode::eTEXT) ? caretOffset : 0, false); + } + + // No caret if the focused node is not inside this DOM node and this DOM node + // is not inside of focused node. + FocusManager::FocusDisposition focusDisp = + FocusMgr()->IsInOrContainsFocus(this); + if (focusDisp == FocusManager::eNone) + return -1; + + // Turn the focus node and offset of the selection into caret hypretext + // offset. + dom::Selection* domSel = DOMSelection(); + NS_ENSURE_TRUE(domSel, -1); + + nsINode* focusNode = domSel->GetFocusNode(); + uint32_t focusOffset = domSel->FocusOffset(); + + // No caret if this DOM node is inside of focused node but the selection's + // focus point is not inside of this DOM node. + if (focusDisp == FocusManager::eContainedByFocus) { + nsINode* resultNode = + nsCoreUtils::GetDOMNodeFromDOMPoint(focusNode, focusOffset); + + nsINode* thisNode = GetNode(); + if (resultNode != thisNode && + !nsCoreUtils::IsAncestorOf(thisNode, resultNode)) + return -1; + } + + return DOMPointToOffset(focusNode, focusOffset); +} + +int32_t +HyperTextAccessible::CaretLineNumber() +{ + // Provide the line number for the caret, relative to the + // currently focused node. Use a 1-based index + RefPtr<nsFrameSelection> frameSelection = FrameSelection(); + if (!frameSelection) + return -1; + + dom::Selection* domSel = frameSelection->GetSelection(SelectionType::eNormal); + if (!domSel) + return - 1; + + nsINode* caretNode = domSel->GetFocusNode(); + if (!caretNode || !caretNode->IsContent()) + return -1; + + nsIContent* caretContent = caretNode->AsContent(); + if (!nsCoreUtils::IsAncestorOf(GetNode(), caretContent)) + return -1; + + int32_t returnOffsetUnused; + uint32_t caretOffset = domSel->FocusOffset(); + CaretAssociationHint hint = frameSelection->GetHint(); + nsIFrame *caretFrame = frameSelection->GetFrameForNodeOffset(caretContent, caretOffset, + hint, &returnOffsetUnused); + NS_ENSURE_TRUE(caretFrame, -1); + + int32_t lineNumber = 1; + nsAutoLineIterator lineIterForCaret; + nsIContent *hyperTextContent = IsContent() ? mContent.get() : nullptr; + while (caretFrame) { + if (hyperTextContent == caretFrame->GetContent()) { + return lineNumber; // Must be in a single line hyper text, there is no line iterator + } + nsContainerFrame *parentFrame = caretFrame->GetParent(); + if (!parentFrame) + break; + + // Add lines for the sibling frames before the caret + nsIFrame *sibling = parentFrame->PrincipalChildList().FirstChild(); + while (sibling && sibling != caretFrame) { + nsAutoLineIterator lineIterForSibling = sibling->GetLineIterator(); + if (lineIterForSibling) { + // For the frames before that grab all the lines + int32_t addLines = lineIterForSibling->GetNumLines(); + lineNumber += addLines; + } + sibling = sibling->GetNextSibling(); + } + + // Get the line number relative to the container with lines + if (!lineIterForCaret) { // Add the caret line just once + lineIterForCaret = parentFrame->GetLineIterator(); + if (lineIterForCaret) { + // Ancestor of caret + int32_t addLines = lineIterForCaret->FindLineContaining(caretFrame); + lineNumber += addLines; + } + } + + caretFrame = parentFrame; + } + + NS_NOTREACHED("DOM ancestry had this hypertext but frame ancestry didn't"); + return lineNumber; +} + +LayoutDeviceIntRect +HyperTextAccessible::GetCaretRect(nsIWidget** aWidget) +{ + *aWidget = nullptr; + + RefPtr<nsCaret> caret = mDoc->PresShell()->GetCaret(); + NS_ENSURE_TRUE(caret, LayoutDeviceIntRect()); + + bool isVisible = caret->IsVisible(); + if (!isVisible) + return LayoutDeviceIntRect(); + + nsRect rect; + nsIFrame* frame = caret->GetGeometry(&rect); + if (!frame || rect.IsEmpty()) + return LayoutDeviceIntRect(); + + nsPoint offset; + // Offset from widget origin to the frame origin, which includes chrome + // on the widget. + *aWidget = frame->GetNearestWidget(offset); + NS_ENSURE_TRUE(*aWidget, LayoutDeviceIntRect()); + rect.MoveBy(offset); + + LayoutDeviceIntRect caretRect = LayoutDeviceIntRect::FromUnknownRect( + rect.ToOutsidePixels(frame->PresContext()->AppUnitsPerDevPixel())); + // ((content screen origin) - (content offset in the widget)) = widget origin on the screen + caretRect.MoveBy((*aWidget)->WidgetToScreenOffset() - (*aWidget)->GetClientOffset()); + + // Correct for character size, so that caret always matches the size of + // the character. This is important for font size transitions, and is + // necessary because the Gecko caret uses the previous character's size as + // the user moves forward in the text by character. + nsIntRect charRect = CharBounds(CaretOffset(), + nsIAccessibleCoordinateType::COORDTYPE_SCREEN_RELATIVE); + if (!charRect.IsEmpty()) { + caretRect.height -= charRect.y - caretRect.y; + caretRect.y = charRect.y; + } + return caretRect; +} + +void +HyperTextAccessible::GetSelectionDOMRanges(SelectionType aSelectionType, + nsTArray<nsRange*>* aRanges) +{ + // Ignore selection if it is not visible. + RefPtr<nsFrameSelection> frameSelection = FrameSelection(); + if (!frameSelection || + frameSelection->GetDisplaySelection() <= nsISelectionController::SELECTION_HIDDEN) + return; + + dom::Selection* domSel = frameSelection->GetSelection(aSelectionType); + if (!domSel) + return; + + nsCOMPtr<nsINode> startNode = GetNode(); + + nsCOMPtr<nsIEditor> editor = GetEditor(); + if (editor) { + nsCOMPtr<nsIDOMElement> editorRoot; + editor->GetRootElement(getter_AddRefs(editorRoot)); + startNode = do_QueryInterface(editorRoot); + } + + if (!startNode) + return; + + uint32_t childCount = startNode->GetChildCount(); + nsresult rv = domSel-> + GetRangesForIntervalArray(startNode, 0, startNode, childCount, true, aRanges); + NS_ENSURE_SUCCESS_VOID(rv); + + // Remove collapsed ranges + uint32_t numRanges = aRanges->Length(); + for (uint32_t idx = 0; idx < numRanges; idx ++) { + if ((*aRanges)[idx]->Collapsed()) { + aRanges->RemoveElementAt(idx); + --numRanges; + --idx; + } + } +} + +int32_t +HyperTextAccessible::SelectionCount() +{ + nsTArray<nsRange*> ranges; + GetSelectionDOMRanges(SelectionType::eNormal, &ranges); + return ranges.Length(); +} + +bool +HyperTextAccessible::SelectionBoundsAt(int32_t aSelectionNum, + int32_t* aStartOffset, + int32_t* aEndOffset) +{ + *aStartOffset = *aEndOffset = 0; + + nsTArray<nsRange*> ranges; + GetSelectionDOMRanges(SelectionType::eNormal, &ranges); + + uint32_t rangeCount = ranges.Length(); + if (aSelectionNum < 0 || aSelectionNum >= static_cast<int32_t>(rangeCount)) + return false; + + nsRange* range = ranges[aSelectionNum]; + + // Get start and end points. + nsINode* startNode = range->GetStartParent(); + nsINode* endNode = range->GetEndParent(); + int32_t startOffset = range->StartOffset(), endOffset = range->EndOffset(); + + // Make sure start is before end, by swapping DOM points. This occurs when + // the user selects backwards in the text. + int32_t rangeCompare = nsContentUtils::ComparePoints(endNode, endOffset, + startNode, startOffset); + if (rangeCompare < 0) { + nsINode* tempNode = startNode; + startNode = endNode; + endNode = tempNode; + int32_t tempOffset = startOffset; + startOffset = endOffset; + endOffset = tempOffset; + } + + if (!nsContentUtils::ContentIsDescendantOf(startNode, mContent)) + *aStartOffset = 0; + else + *aStartOffset = DOMPointToOffset(startNode, startOffset); + + if (!nsContentUtils::ContentIsDescendantOf(endNode, mContent)) + *aEndOffset = CharacterCount(); + else + *aEndOffset = DOMPointToOffset(endNode, endOffset, true); + return true; +} + +bool +HyperTextAccessible::SetSelectionBoundsAt(int32_t aSelectionNum, + int32_t aStartOffset, + int32_t aEndOffset) +{ + index_t startOffset = ConvertMagicOffset(aStartOffset); + index_t endOffset = ConvertMagicOffset(aEndOffset); + if (!startOffset.IsValid() || !endOffset.IsValid() || + startOffset > endOffset || endOffset > CharacterCount()) { + NS_ERROR("Wrong in offset"); + return false; + } + + dom::Selection* domSel = DOMSelection(); + if (!domSel) + return false; + + RefPtr<nsRange> range; + uint32_t rangeCount = domSel->RangeCount(); + if (aSelectionNum == static_cast<int32_t>(rangeCount)) + range = new nsRange(mContent); + else + range = domSel->GetRangeAt(aSelectionNum); + + if (!range) + return false; + + if (!OffsetsToDOMRange(startOffset, endOffset, range)) + return false; + + // If new range was created then add it, otherwise notify selection listeners + // that existing selection range was changed. + if (aSelectionNum == static_cast<int32_t>(rangeCount)) + return NS_SUCCEEDED(domSel->AddRange(range)); + + domSel->RemoveRange(range); + return NS_SUCCEEDED(domSel->AddRange(range)); +} + +bool +HyperTextAccessible::RemoveFromSelection(int32_t aSelectionNum) +{ + dom::Selection* domSel = DOMSelection(); + if (!domSel) + return false; + + if (aSelectionNum < 0 || aSelectionNum >= static_cast<int32_t>(domSel->RangeCount())) + return false; + + domSel->RemoveRange(domSel->GetRangeAt(aSelectionNum)); + return true; +} + +void +HyperTextAccessible::ScrollSubstringTo(int32_t aStartOffset, int32_t aEndOffset, + uint32_t aScrollType) +{ + RefPtr<nsRange> range = new nsRange(mContent); + if (OffsetsToDOMRange(aStartOffset, aEndOffset, range)) + nsCoreUtils::ScrollSubstringTo(GetFrame(), range, aScrollType); +} + +void +HyperTextAccessible::ScrollSubstringToPoint(int32_t aStartOffset, + int32_t aEndOffset, + uint32_t aCoordinateType, + int32_t aX, int32_t aY) +{ + nsIFrame *frame = GetFrame(); + if (!frame) + return; + + nsIntPoint coords = nsAccUtils::ConvertToScreenCoords(aX, aY, aCoordinateType, + this); + + RefPtr<nsRange> range = new nsRange(mContent); + if (!OffsetsToDOMRange(aStartOffset, aEndOffset, range)) + return; + + nsPresContext* presContext = frame->PresContext(); + nsPoint coordsInAppUnits = + ToAppUnits(coords, presContext->AppUnitsPerDevPixel()); + + bool initialScrolled = false; + nsIFrame *parentFrame = frame; + while ((parentFrame = parentFrame->GetParent())) { + nsIScrollableFrame *scrollableFrame = do_QueryFrame(parentFrame); + if (scrollableFrame) { + if (!initialScrolled) { + // Scroll substring to the given point. Turn the point into percents + // relative scrollable area to use nsCoreUtils::ScrollSubstringTo. + nsRect frameRect = parentFrame->GetScreenRectInAppUnits(); + nscoord offsetPointX = coordsInAppUnits.x - frameRect.x; + nscoord offsetPointY = coordsInAppUnits.y - frameRect.y; + + nsSize size(parentFrame->GetSize()); + + // avoid divide by zero + size.width = size.width ? size.width : 1; + size.height = size.height ? size.height : 1; + + int16_t hPercent = offsetPointX * 100 / size.width; + int16_t vPercent = offsetPointY * 100 / size.height; + + nsresult rv = nsCoreUtils::ScrollSubstringTo(frame, range, + nsIPresShell::ScrollAxis(vPercent), + nsIPresShell::ScrollAxis(hPercent)); + if (NS_FAILED(rv)) + return; + + initialScrolled = true; + } else { + // Substring was scrolled to the given point already inside its closest + // scrollable area. If there are nested scrollable areas then make + // sure we scroll lower areas to the given point inside currently + // traversed scrollable area. + nsCoreUtils::ScrollFrameToPoint(parentFrame, frame, coords); + } + } + frame = parentFrame; + } +} + +void +HyperTextAccessible::EnclosingRange(a11y::TextRange& aRange) const +{ + if (IsTextField()) { + aRange.Set(mDoc, const_cast<HyperTextAccessible*>(this), 0, + const_cast<HyperTextAccessible*>(this), CharacterCount()); + } else { + aRange.Set(mDoc, mDoc, 0, mDoc, mDoc->CharacterCount()); + } +} + +void +HyperTextAccessible::SelectionRanges(nsTArray<a11y::TextRange>* aRanges) const +{ + MOZ_ASSERT(aRanges->Length() == 0, "TextRange array supposed to be empty"); + + dom::Selection* sel = DOMSelection(); + if (!sel) + return; + + aRanges->SetCapacity(sel->RangeCount()); + + for (uint32_t idx = 0; idx < sel->RangeCount(); idx++) { + nsRange* DOMRange = sel->GetRangeAt(idx); + HyperTextAccessible* startParent = + nsAccUtils::GetTextContainer(DOMRange->GetStartParent()); + HyperTextAccessible* endParent = + nsAccUtils::GetTextContainer(DOMRange->GetEndParent()); + if (!startParent || !endParent) + continue; + + int32_t startOffset = + startParent->DOMPointToOffset(DOMRange->GetStartParent(), + DOMRange->StartOffset(), false); + int32_t endOffset = + endParent->DOMPointToOffset(DOMRange->GetEndParent(), + DOMRange->EndOffset(), true); + + TextRange tr(IsTextField() ? const_cast<HyperTextAccessible*>(this) : mDoc, + startParent, startOffset, endParent, endOffset); + *(aRanges->AppendElement()) = Move(tr); + } +} + +void +HyperTextAccessible::VisibleRanges(nsTArray<a11y::TextRange>* aRanges) const +{ +} + +void +HyperTextAccessible::RangeByChild(Accessible* aChild, + a11y::TextRange& aRange) const +{ + HyperTextAccessible* ht = aChild->AsHyperText(); + if (ht) { + aRange.Set(mDoc, ht, 0, ht, ht->CharacterCount()); + return; + } + + Accessible* child = aChild; + Accessible* parent = nullptr; + while ((parent = child->Parent()) && !(ht = parent->AsHyperText())) + child = parent; + + // If no text then return collapsed text range, otherwise return a range + // containing the text enclosed by the given child. + if (ht) { + int32_t childIdx = child->IndexInParent(); + int32_t startOffset = ht->GetChildOffset(childIdx); + int32_t endOffset = child->IsTextLeaf() ? + ht->GetChildOffset(childIdx + 1) : startOffset; + aRange.Set(mDoc, ht, startOffset, ht, endOffset); + } +} + +void +HyperTextAccessible::RangeAtPoint(int32_t aX, int32_t aY, + a11y::TextRange& aRange) const +{ + Accessible* child = mDoc->ChildAtPoint(aX, aY, eDeepestChild); + if (!child) + return; + + Accessible* parent = nullptr; + while ((parent = child->Parent()) && !parent->IsHyperText()) + child = parent; + + // Return collapsed text range for the point. + if (parent) { + HyperTextAccessible* ht = parent->AsHyperText(); + int32_t offset = ht->GetChildOffset(child); + aRange.Set(mDoc, ht, offset, ht, offset); + } +} + +//////////////////////////////////////////////////////////////////////////////// +// Accessible public + +// Accessible protected +ENameValueFlag +HyperTextAccessible::NativeName(nsString& aName) +{ + // Check @alt attribute for invalid img elements. + bool hasImgAlt = false; + if (mContent->IsHTMLElement(nsGkAtoms::img)) { + hasImgAlt = mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::alt, aName); + if (!aName.IsEmpty()) + return eNameOK; + } + + ENameValueFlag nameFlag = AccessibleWrap::NativeName(aName); + if (!aName.IsEmpty()) + return nameFlag; + + // Get name from title attribute for HTML abbr and acronym elements making it + // a valid name from markup. Otherwise their name isn't picked up by recursive + // name computation algorithm. See NS_OK_NAME_FROM_TOOLTIP. + if (IsAbbreviation() && + mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::title, aName)) + aName.CompressWhitespace(); + + return hasImgAlt ? eNoNameOnPurpose : eNameOK; +} + +void +HyperTextAccessible::Shutdown() +{ + mOffsets.Clear(); + AccessibleWrap::Shutdown(); +} + +bool +HyperTextAccessible::RemoveChild(Accessible* aAccessible) +{ + int32_t childIndex = aAccessible->IndexInParent(); + int32_t count = mOffsets.Length() - childIndex; + if (count > 0) + mOffsets.RemoveElementsAt(childIndex, count); + + return AccessibleWrap::RemoveChild(aAccessible); +} + +bool +HyperTextAccessible::InsertChildAt(uint32_t aIndex, Accessible* aChild) +{ + int32_t count = mOffsets.Length() - aIndex; + if (count > 0 ) { + mOffsets.RemoveElementsAt(aIndex, count); + } + return AccessibleWrap::InsertChildAt(aIndex, aChild); +} + +Relation +HyperTextAccessible::RelationByType(RelationType aType) +{ + Relation rel = Accessible::RelationByType(aType); + + switch (aType) { + case RelationType::NODE_CHILD_OF: + if (HasOwnContent() && mContent->IsMathMLElement()) { + Accessible* parent = Parent(); + if (parent) { + nsIContent* parentContent = parent->GetContent(); + if (parentContent && + parentContent->IsMathMLElement(nsGkAtoms::mroot_)) { + // Add a relation pointing to the parent <mroot>. + rel.AppendTarget(parent); + } + } + } + break; + case RelationType::NODE_PARENT_OF: + if (HasOwnContent() && mContent->IsMathMLElement(nsGkAtoms::mroot_)) { + Accessible* base = GetChildAt(0); + Accessible* index = GetChildAt(1); + if (base && index) { + // Append the <mroot> children in the order index, base. + rel.AppendTarget(index); + rel.AppendTarget(base); + } + } + break; + default: + break; + } + + return rel; +} + +//////////////////////////////////////////////////////////////////////////////// +// HyperTextAccessible public static + +nsresult +HyperTextAccessible::ContentToRenderedOffset(nsIFrame* aFrame, int32_t aContentOffset, + uint32_t* aRenderedOffset) const +{ + if (!aFrame) { + // Current frame not rendered -- this can happen if text is set on + // something with display: none + *aRenderedOffset = 0; + return NS_OK; + } + + if (IsTextField()) { + *aRenderedOffset = aContentOffset; + return NS_OK; + } + + NS_ASSERTION(aFrame->GetType() == nsGkAtoms::textFrame, + "Need text frame for offset conversion"); + NS_ASSERTION(aFrame->GetPrevContinuation() == nullptr, + "Call on primary frame only"); + + nsIFrame::RenderedText text = aFrame->GetRenderedText(aContentOffset, + aContentOffset + 1, nsIFrame::TextOffsetType::OFFSETS_IN_CONTENT_TEXT, + nsIFrame::TrailingWhitespace::DONT_TRIM_TRAILING_WHITESPACE); + *aRenderedOffset = text.mOffsetWithinNodeRenderedText; + + return NS_OK; +} + +nsresult +HyperTextAccessible::RenderedToContentOffset(nsIFrame* aFrame, uint32_t aRenderedOffset, + int32_t* aContentOffset) const +{ + if (IsTextField()) { + *aContentOffset = aRenderedOffset; + return NS_OK; + } + + *aContentOffset = 0; + NS_ENSURE_TRUE(aFrame, NS_ERROR_FAILURE); + + NS_ASSERTION(aFrame->GetType() == nsGkAtoms::textFrame, + "Need text frame for offset conversion"); + NS_ASSERTION(aFrame->GetPrevContinuation() == nullptr, + "Call on primary frame only"); + + nsIFrame::RenderedText text = aFrame->GetRenderedText(aRenderedOffset, + aRenderedOffset + 1, nsIFrame::TextOffsetType::OFFSETS_IN_RENDERED_TEXT, + nsIFrame::TrailingWhitespace::DONT_TRIM_TRAILING_WHITESPACE); + *aContentOffset = text.mOffsetWithinNodeText; + + return NS_OK; +} + +//////////////////////////////////////////////////////////////////////////////// +// HyperTextAccessible public + +int32_t +HyperTextAccessible::GetChildOffset(uint32_t aChildIndex, + bool aInvalidateAfter) const +{ + if (aChildIndex == 0) { + if (aInvalidateAfter) + mOffsets.Clear(); + + return aChildIndex; + } + + int32_t count = mOffsets.Length() - aChildIndex; + if (count > 0) { + if (aInvalidateAfter) + mOffsets.RemoveElementsAt(aChildIndex, count); + + return mOffsets[aChildIndex - 1]; + } + + uint32_t lastOffset = mOffsets.IsEmpty() ? + 0 : mOffsets[mOffsets.Length() - 1]; + + while (mOffsets.Length() < aChildIndex) { + Accessible* child = mChildren[mOffsets.Length()]; + lastOffset += nsAccUtils::TextLength(child); + mOffsets.AppendElement(lastOffset); + } + + return mOffsets[aChildIndex - 1]; +} + +int32_t +HyperTextAccessible::GetChildIndexAtOffset(uint32_t aOffset) const +{ + uint32_t lastOffset = 0; + const uint32_t offsetCount = mOffsets.Length(); + + if (offsetCount > 0) { + lastOffset = mOffsets[offsetCount - 1]; + if (aOffset < lastOffset) { + size_t index; + if (BinarySearch(mOffsets, 0, offsetCount, aOffset, &index)) { + return (index < (offsetCount - 1)) ? index + 1 : index; + } + + return (index == offsetCount) ? -1 : index; + } + } + + uint32_t childCount = ChildCount(); + while (mOffsets.Length() < childCount) { + Accessible* child = GetChildAt(mOffsets.Length()); + lastOffset += nsAccUtils::TextLength(child); + mOffsets.AppendElement(lastOffset); + if (aOffset < lastOffset) + return mOffsets.Length() - 1; + } + + if (aOffset == lastOffset) + return mOffsets.Length() - 1; + + return -1; +} + +//////////////////////////////////////////////////////////////////////////////// +// HyperTextAccessible protected + +nsresult +HyperTextAccessible::GetDOMPointByFrameOffset(nsIFrame* aFrame, int32_t aOffset, + Accessible* aAccessible, + DOMPoint* aPoint) +{ + NS_ENSURE_ARG(aAccessible); + + if (!aFrame) { + // If the given frame is null then set offset after the DOM node of the + // given accessible. + NS_ASSERTION(!aAccessible->IsDoc(), + "Shouldn't be called on document accessible!"); + + nsIContent* content = aAccessible->GetContent(); + NS_ASSERTION(content, "Shouldn't operate on defunct accessible!"); + + nsIContent* parent = content->GetParent(); + + aPoint->idx = parent->IndexOf(content) + 1; + aPoint->node = parent; + + } else if (aFrame->GetType() == nsGkAtoms::textFrame) { + nsIContent* content = aFrame->GetContent(); + NS_ENSURE_STATE(content); + + nsIFrame *primaryFrame = content->GetPrimaryFrame(); + nsresult rv = RenderedToContentOffset(primaryFrame, aOffset, &(aPoint->idx)); + NS_ENSURE_SUCCESS(rv, rv); + + aPoint->node = content; + + } else { + nsIContent* content = aFrame->GetContent(); + NS_ENSURE_STATE(content); + + nsIContent* parent = content->GetParent(); + NS_ENSURE_STATE(parent); + + aPoint->idx = parent->IndexOf(content); + aPoint->node = parent; + } + + return NS_OK; +} + +// HyperTextAccessible +void +HyperTextAccessible::GetSpellTextAttr(nsINode* aNode, + int32_t aNodeOffset, + uint32_t* aStartOffset, + uint32_t* aEndOffset, + nsIPersistentProperties* aAttributes) +{ + RefPtr<nsFrameSelection> fs = FrameSelection(); + if (!fs) + return; + + dom::Selection* domSel = fs->GetSelection(SelectionType::eSpellCheck); + if (!domSel) + return; + + int32_t rangeCount = domSel->RangeCount(); + if (rangeCount <= 0) + return; + + uint32_t startOffset = 0, endOffset = 0; + for (int32_t idx = 0; idx < rangeCount; idx++) { + nsRange* range = domSel->GetRangeAt(idx); + if (range->Collapsed()) + continue; + + // See if the point comes after the range in which case we must continue in + // case there is another range after this one. + nsINode* endNode = range->GetEndParent(); + int32_t endNodeOffset = range->EndOffset(); + if (nsContentUtils::ComparePoints(aNode, aNodeOffset, + endNode, endNodeOffset) >= 0) + continue; + + // At this point our point is either in this range or before it but after + // the previous range. So we check to see if the range starts before the + // point in which case the point is in the missspelled range, otherwise it + // must be before the range and after the previous one if any. + nsINode* startNode = range->GetStartParent(); + int32_t startNodeOffset = range->StartOffset(); + if (nsContentUtils::ComparePoints(startNode, startNodeOffset, aNode, + aNodeOffset) <= 0) { + startOffset = DOMPointToOffset(startNode, startNodeOffset); + + endOffset = DOMPointToOffset(endNode, endNodeOffset); + + if (startOffset > *aStartOffset) + *aStartOffset = startOffset; + + if (endOffset < *aEndOffset) + *aEndOffset = endOffset; + + if (aAttributes) { + nsAccUtils::SetAccAttr(aAttributes, nsGkAtoms::invalid, + NS_LITERAL_STRING("spelling")); + } + + return; + } + + // This range came after the point. + endOffset = DOMPointToOffset(startNode, startNodeOffset); + + if (idx > 0) { + nsRange* prevRange = domSel->GetRangeAt(idx - 1); + startOffset = DOMPointToOffset(prevRange->GetEndParent(), + prevRange->EndOffset()); + } + + if (startOffset > *aStartOffset) + *aStartOffset = startOffset; + + if (endOffset < *aEndOffset) + *aEndOffset = endOffset; + + return; + } + + // We never found a range that ended after the point, therefore we know that + // the point is not in a range, that we do not need to compute an end offset, + // and that we should use the end offset of the last range to compute the + // start offset of the text attribute range. + nsRange* prevRange = domSel->GetRangeAt(rangeCount - 1); + startOffset = DOMPointToOffset(prevRange->GetEndParent(), + prevRange->EndOffset()); + + if (startOffset > *aStartOffset) + *aStartOffset = startOffset; +} + +bool +HyperTextAccessible::IsTextRole() +{ + const nsRoleMapEntry* roleMapEntry = ARIARoleMap(); + if (roleMapEntry && + (roleMapEntry->role == roles::GRAPHIC || + roleMapEntry->role == roles::IMAGE_MAP || + roleMapEntry->role == roles::SLIDER || + roleMapEntry->role == roles::PROGRESSBAR || + roleMapEntry->role == roles::SEPARATOR)) + return false; + + return true; +} diff --git a/accessible/generic/HyperTextAccessible.h b/accessible/generic/HyperTextAccessible.h new file mode 100644 index 000000000..78e73f042 --- /dev/null +++ b/accessible/generic/HyperTextAccessible.h @@ -0,0 +1,592 @@ +/* -*- 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 mozilla_a11y_HyperTextAccessible_h__ +#define mozilla_a11y_HyperTextAccessible_h__ + +#include "AccessibleWrap.h" +#include "nsIAccessibleText.h" +#include "nsIAccessibleTypes.h" +#include "nsDirection.h" +#include "WordMovementType.h" +#include "nsIFrame.h" + +#include "nsISelectionController.h" + +class nsFrameSelection; +class nsRange; +class nsIWidget; + +namespace mozilla { + +namespace dom { +class Selection; +} + +namespace a11y { + +class TextRange; + +struct DOMPoint { + DOMPoint() : node(nullptr), idx(0) { } + DOMPoint(nsINode* aNode, int32_t aIdx) : node(aNode), idx(aIdx) { } + + nsINode* node; + int32_t idx; +}; + +// This character marks where in the text returned via Text interface, +// that embedded object characters exist +const char16_t kEmbeddedObjectChar = 0xfffc; +const char16_t kImaginaryEmbeddedObjectChar = ' '; +const char16_t kForcedNewLineChar = '\n'; + +/** + * Special Accessible that knows how contain both text and embedded objects + */ +class HyperTextAccessible : public AccessibleWrap +{ +public: + HyperTextAccessible(nsIContent* aContent, DocAccessible* aDoc); + + NS_DECL_ISUPPORTS_INHERITED + + // Accessible + virtual nsIAtom* LandmarkRole() const override; + virtual int32_t GetLevelInternal() override; + virtual already_AddRefed<nsIPersistentProperties> NativeAttributes() override; + virtual mozilla::a11y::role NativeRole() override; + virtual uint64_t NativeState() override; + + virtual void Shutdown() override; + virtual bool RemoveChild(Accessible* aAccessible) override; + virtual bool InsertChildAt(uint32_t aIndex, Accessible* aChild) override; + virtual Relation RelationByType(RelationType aType) override; + + // HyperTextAccessible (static helper method) + + // Convert content offset to rendered text offset + nsresult ContentToRenderedOffset(nsIFrame *aFrame, int32_t aContentOffset, + uint32_t *aRenderedOffset) const; + + // Convert rendered text offset to content offset + nsresult RenderedToContentOffset(nsIFrame *aFrame, uint32_t aRenderedOffset, + int32_t *aContentOffset) const; + + ////////////////////////////////////////////////////////////////////////////// + // HyperLinkAccessible + + /** + * Return link count within this hypertext accessible. + */ + uint32_t LinkCount() + { return EmbeddedChildCount(); } + + /** + * Return link accessible at the given index. + */ + Accessible* LinkAt(uint32_t aIndex) + { + return GetEmbeddedChildAt(aIndex); + } + + /** + * Return index for the given link accessible. + */ + int32_t LinkIndexOf(Accessible* aLink) + { + return GetIndexOfEmbeddedChild(aLink); + } + + /** + * Return link accessible at the given text offset. + */ + int32_t LinkIndexAtOffset(uint32_t aOffset) + { + Accessible* child = GetChildAtOffset(aOffset); + return child ? LinkIndexOf(child) : -1; + } + + ////////////////////////////////////////////////////////////////////////////// + // HyperTextAccessible: DOM point to text offset conversions. + + /** + * Turn a DOM point (node and offset) into a character offset of this + * hypertext. Will look for closest match when the DOM node does not have + * an accessible object associated with it. Will return an offset for the end + * of the string if the node is not found. + * + * @param aNode [in] the node to look for + * @param aNodeOffset [in] the offset to look for + * if -1 just look directly for the node + * if >=0 and aNode is text, this represents a char offset + * if >=0 and aNode is not text, this represents a child node offset + * @param aIsEndOffset [in] if true, then then this offset is not inclusive. The character + * indicated by the offset returned is at [offset - 1]. This means + * if the passed-in offset is really in a descendant, then the offset returned + * will come just after the relevant embedded object characer. + * If false, then the offset is inclusive. The character indicated + * by the offset returned is at [offset]. If the passed-in offset in inside a + * descendant, then the returned offset will be on the relevant embedded object char. + */ + uint32_t DOMPointToOffset(nsINode* aNode, int32_t aNodeOffset, + bool aIsEndOffset = false) const; + + /** + * Transform the given a11y point into the offset relative this hypertext. + */ + uint32_t TransformOffset(Accessible* aDescendant, uint32_t aOffset, + bool aIsEndOffset) const; + + /** + * Convert start and end hypertext offsets into DOM range. Note that if + * aStartOffset and/or aEndOffset is in generated content such as ::before or + * ::after, the result range excludes the generated content. See also + * ClosestNotGeneratedDOMPoint() for more information. + * + * @param aStartOffset [in] the given start hypertext offset + * @param aEndOffset [in] the given end hypertext offset + * @param aRange [in, out] the range whose bounds to set + * @return true if conversion was successful + */ + bool OffsetsToDOMRange(int32_t aStartOffset, int32_t aEndOffset, + nsRange* aRange); + + /** + * Convert the given offset into DOM point. + * + * If offset is at text leaf then DOM point is (text node, offsetInTextNode), + * if before embedded object then (parent node, indexInParent), if after then + * (parent node, indexInParent + 1). + */ + DOMPoint OffsetToDOMPoint(int32_t aOffset); + + /** + * Return true if the used ARIA role (if any) allows the hypertext accessible + * to expose text interfaces. + */ + bool IsTextRole(); + + ////////////////////////////////////////////////////////////////////////////// + // TextAccessible + + /** + * Return character count within the hypertext accessible. + */ + uint32_t CharacterCount() const + { return GetChildOffset(ChildCount()); } + + /** + * Get a character at the given offset (don't support magic offsets). + */ + bool CharAt(int32_t aOffset, nsAString& aChar, + int32_t* aStartOffset = nullptr, int32_t* aEndOffset = nullptr) + { + NS_ASSERTION(!aStartOffset == !aEndOffset, + "Offsets should be both defined or both undefined!"); + + int32_t childIdx = GetChildIndexAtOffset(aOffset); + if (childIdx == -1) + return false; + + Accessible* child = GetChildAt(childIdx); + child->AppendTextTo(aChar, aOffset - GetChildOffset(childIdx), 1); + + if (aStartOffset && aEndOffset) { + *aStartOffset = aOffset; + *aEndOffset = aOffset + aChar.Length(); + } + return true; + } + + char16_t CharAt(int32_t aOffset) + { + nsAutoString charAtOffset; + CharAt(aOffset, charAtOffset); + return charAtOffset.CharAt(0); + } + + /** + * Return true if char at the given offset equals to given char. + */ + bool IsCharAt(int32_t aOffset, char16_t aChar) + { return CharAt(aOffset) == aChar; } + + /** + * Return true if terminal char is at the given offset. + */ + bool IsLineEndCharAt(int32_t aOffset) + { return IsCharAt(aOffset, '\n'); } + + /** + * Return text between given offsets. + */ + void TextSubstring(int32_t aStartOffset, int32_t aEndOffset, nsAString& aText); + + /** + * Return text before/at/after the given offset corresponding to + * the boundary type. + */ + void TextBeforeOffset(int32_t aOffset, AccessibleTextBoundary aBoundaryType, + int32_t* aStartOffset, int32_t* aEndOffset, + nsAString& aText); + void TextAtOffset(int32_t aOffset, AccessibleTextBoundary aBoundaryType, + int32_t* aStartOffset, int32_t* aEndOffset, + nsAString& aText); + void TextAfterOffset(int32_t aOffset, AccessibleTextBoundary aBoundaryType, + int32_t* aStartOffset, int32_t* aEndOffset, + nsAString& aText); + + /** + * Return text attributes for the given text range. + */ + already_AddRefed<nsIPersistentProperties> + TextAttributes(bool aIncludeDefAttrs, int32_t aOffset, + int32_t* aStartOffset, int32_t* aEndOffset); + + /** + * Return text attributes applied to the accessible. + */ + already_AddRefed<nsIPersistentProperties> DefaultTextAttributes(); + + /** + * Return text offset of the given child accessible within hypertext + * accessible. + * + * @param aChild [in] accessible child to get text offset for + * @param aInvalidateAfter [in, optional] indicates whether invalidate + * cached offsets for next siblings of the child + */ + int32_t GetChildOffset(const Accessible* aChild, + bool aInvalidateAfter = false) const + { + int32_t index = GetIndexOf(aChild); + return index == -1 ? -1 : GetChildOffset(index, aInvalidateAfter); + } + + /** + * Return text offset for the child accessible index. + */ + int32_t GetChildOffset(uint32_t aChildIndex, + bool aInvalidateAfter = false) const; + + /** + * Return child accessible at the given text offset. + * + * @param aOffset [in] the given text offset + */ + int32_t GetChildIndexAtOffset(uint32_t aOffset) const; + + /** + * Return child accessible at the given text offset. + * + * @param aOffset [in] the given text offset + */ + Accessible* GetChildAtOffset(uint32_t aOffset) const + { + return GetChildAt(GetChildIndexAtOffset(aOffset)); + } + + /** + * Return true if the given offset/range is valid. + */ + bool IsValidOffset(int32_t aOffset); + bool IsValidRange(int32_t aStartOffset, int32_t aEndOffset); + + /** + * Return an offset at the given point. + */ + int32_t OffsetAtPoint(int32_t aX, int32_t aY, uint32_t aCoordType); + + /** + * Return a rect of the given text range relative given coordinate system. + */ + nsIntRect TextBounds(int32_t aStartOffset, int32_t aEndOffset, + uint32_t aCoordType = nsIAccessibleCoordinateType::COORDTYPE_SCREEN_RELATIVE); + + /** + * Return a rect for character at given offset relative given coordinate + * system. + */ + nsIntRect CharBounds(int32_t aOffset, uint32_t aCoordType) + { + int32_t endOffset = aOffset == static_cast<int32_t>(CharacterCount()) ? + aOffset : aOffset + 1; + return TextBounds(aOffset, endOffset, aCoordType); + } + + /** + * Get/set caret offset, if no caret then -1. + */ + int32_t CaretOffset() const; + void SetCaretOffset(int32_t aOffset); + + /** + * Provide the line number for the caret. + * @return 1-based index for the line number with the caret + */ + int32_t CaretLineNumber(); + + /** + * Return the caret rect and the widget containing the caret within this + * text accessible. + * + * @param [out] the widget containing the caret + * @return the caret rect + */ + mozilla::LayoutDeviceIntRect GetCaretRect(nsIWidget** aWidget); + + /** + * Return selected regions count within the accessible. + */ + int32_t SelectionCount(); + + /** + * Return the start and end offset of the specified selection. + */ + bool SelectionBoundsAt(int32_t aSelectionNum, + int32_t* aStartOffset, int32_t* aEndOffset); + + /* + * Changes the start and end offset of the specified selection. + * @return true if succeeded + */ + bool SetSelectionBoundsAt(int32_t aSelectionNum, + int32_t aStartOffset, int32_t aEndOffset); + + /** + * Adds a selection bounded by the specified offsets. + * @return true if succeeded + */ + bool AddToSelection(int32_t aStartOffset, int32_t aEndOffset); + + /* + * Removes the specified selection. + * @return true if succeeded + */ + bool RemoveFromSelection(int32_t aSelectionNum); + + /** + * Scroll the given text range into view. + */ + void ScrollSubstringTo(int32_t aStartOffset, int32_t aEndOffset, + uint32_t aScrollType); + + /** + * Scroll the given text range to the given point. + */ + void ScrollSubstringToPoint(int32_t aStartOffset, + int32_t aEndOffset, + uint32_t aCoordinateType, + int32_t aX, int32_t aY); + + /** + * Return a range that encloses the text control or the document this + * accessible belongs to. + */ + void EnclosingRange(TextRange& aRange) const; + + /** + * Return an array of disjoint ranges for selected text within the text control + * or the document this accessible belongs to. + */ + void SelectionRanges(nsTArray<TextRange>* aRanges) const; + + /** + * Return an array of disjoint ranges of visible text within the text control + * or the document this accessible belongs to. + */ + void VisibleRanges(nsTArray<TextRange>* aRanges) const; + + /** + * Return a range containing the given accessible. + */ + void RangeByChild(Accessible* aChild, TextRange& aRange) const; + + /** + * Return a range containing an accessible at the given point. + */ + void RangeAtPoint(int32_t aX, int32_t aY, TextRange& aRange) const; + + ////////////////////////////////////////////////////////////////////////////// + // EditableTextAccessible + + void ReplaceText(const nsAString& aText); + void InsertText(const nsAString& aText, int32_t aPosition); + void CopyText(int32_t aStartPos, int32_t aEndPos); + void CutText(int32_t aStartPos, int32_t aEndPos); + void DeleteText(int32_t aStartPos, int32_t aEndPos); + void PasteText(int32_t aPosition); + + /** + * Return the editor associated with the accessible. + */ + virtual already_AddRefed<nsIEditor> GetEditor() const; + + /** + * Return DOM selection object for the accessible. + */ + dom::Selection* DOMSelection() const; + +protected: + virtual ~HyperTextAccessible() { } + + // Accessible + virtual ENameValueFlag NativeName(nsString& aName) override; + + // HyperTextAccessible + + /** + * Transform magic offset into text offset. + */ + index_t ConvertMagicOffset(int32_t aOffset) const; + + /** + * Adjust an offset the caret stays at to get a text by line boundary. + */ + uint32_t AdjustCaretOffset(uint32_t aOffset) const; + + /** + * Return true if caret is at end of line. + */ + bool IsCaretAtEndOfLine() const; + + /** + * Return true if the given offset points to terminal empty line if any. + */ + bool IsEmptyLastLineOffset(int32_t aOffset) + { + return aOffset == static_cast<int32_t>(CharacterCount()) && + IsLineEndCharAt(aOffset - 1); + } + + /** + * Return an offset of the found word boundary. + */ + uint32_t FindWordBoundary(uint32_t aOffset, nsDirection aDirection, + EWordMovementType aWordMovementType) + { + return FindOffset(aOffset, aDirection, eSelectWord, aWordMovementType); + } + + /** + * Used to get begin/end of previous/this/next line. Note: end of line + * is an offset right before '\n' character if any, the offset is right after + * '\n' character is begin of line. In case of wrap word breaks these offsets + * are equal. + */ + enum EWhichLineBoundary { + ePrevLineBegin, + ePrevLineEnd, + eThisLineBegin, + eThisLineEnd, + eNextLineBegin, + eNextLineEnd + }; + + /** + * Return an offset for requested line boundary. See constants above. + */ + uint32_t FindLineBoundary(uint32_t aOffset, + EWhichLineBoundary aWhichLineBoundary); + + /** + * Return an offset corresponding to the given direction and selection amount + * relative the given offset. A helper used to find word or line boundaries. + */ + uint32_t FindOffset(uint32_t aOffset, nsDirection aDirection, + nsSelectionAmount aAmount, + EWordMovementType aWordMovementType = eDefaultBehavior); + + /** + * Return the boundaries of the substring in case of textual frame or + * frame boundaries in case of non textual frame, offsets are ignored. + */ + nsIntRect GetBoundsInFrame(nsIFrame* aFrame, + uint32_t aStartRenderedOffset, + uint32_t aEndRenderedOffset); + + // Selection helpers + + /** + * Return frame selection object for the accessible. + */ + already_AddRefed<nsFrameSelection> FrameSelection() const; + + /** + * Return selection ranges within the accessible subtree. + */ + void GetSelectionDOMRanges(SelectionType aSelectionType, + nsTArray<nsRange*>* aRanges); + + nsresult SetSelectionRange(int32_t aStartPos, int32_t aEndPos); + + /** + * Convert the given DOM point to a DOM point in non-generated contents. + * + * If aDOMPoint is in ::before, the result is immediately after it. + * If aDOMPoint is in ::after, the result is immediately before it. + * + * @param aDOMPoint [in] A DOM node and an index of its child. This may + * be in a generated content such as ::before or + * ::after. + * @param aElementContent [in] An nsIContent representing an element of + * aDOMPoint.node. + * @return An DOM point which must not be in generated + * contents. + */ + DOMPoint ClosestNotGeneratedDOMPoint(const DOMPoint& aDOMPoint, + nsIContent* aElementContent); + + // Helpers + nsresult GetDOMPointByFrameOffset(nsIFrame* aFrame, int32_t aOffset, + Accessible* aAccessible, + mozilla::a11y::DOMPoint* aPoint); + + /** + * Set 'misspelled' text attribute and return range offsets where the + * attibute is stretched. If the text is not misspelled at the given offset + * then we expose only range offsets where text is not misspelled. The method + * is used by TextAttributes() method. + * + * @param aIncludeDefAttrs [in] points whether text attributes having default + * values of attributes should be included + * @param aSourceNode [in] the node we start to traverse from + * @param aStartOffset [in, out] the start offset + * @param aEndOffset [in, out] the end offset + * @param aAttributes [out, optional] result attributes + */ + void GetSpellTextAttr(nsINode* aNode, int32_t aNodeOffset, + uint32_t* aStartOffset, uint32_t* aEndOffset, + nsIPersistentProperties* aAttributes); + + /** + * Set xml-roles attributes for MathML elements. + * @param aAttributes + */ + void SetMathMLXMLRoles(nsIPersistentProperties* aAttributes); + +private: + /** + * End text offsets array. + */ + mutable nsTArray<uint32_t> mOffsets; +}; + + +//////////////////////////////////////////////////////////////////////////////// +// Accessible downcasting method + +inline HyperTextAccessible* +Accessible::AsHyperText() +{ + return IsHyperText() ? static_cast<HyperTextAccessible*>(this) : nullptr; +} + +} // namespace a11y +} // namespace mozilla + +#endif + diff --git a/accessible/generic/ImageAccessible.cpp b/accessible/generic/ImageAccessible.cpp new file mode 100644 index 000000000..c6556b04d --- /dev/null +++ b/accessible/generic/ImageAccessible.cpp @@ -0,0 +1,224 @@ +/* -*- 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 "ImageAccessible.h" + +#include "nsAccUtils.h" +#include "Role.h" +#include "AccIterator.h" +#include "States.h" + +#include "imgIContainer.h" +#include "imgIRequest.h" +#include "nsGenericHTMLElement.h" +#include "nsIDocument.h" +#include "nsIImageLoadingContent.h" +#include "nsIPresShell.h" +#include "nsIServiceManager.h" +#include "nsIDOMHTMLImageElement.h" +#include "nsIPersistentProperties2.h" +#include "nsPIDOMWindow.h" +#include "nsIURI.h" + +using namespace mozilla::a11y; + +//////////////////////////////////////////////////////////////////////////////// +// ImageAccessible +//////////////////////////////////////////////////////////////////////////////// + +ImageAccessible:: + ImageAccessible(nsIContent* aContent, DocAccessible* aDoc) : + LinkableAccessible(aContent, aDoc) +{ + mType = eImageType; +} + +ImageAccessible::~ImageAccessible() +{ +} + +//////////////////////////////////////////////////////////////////////////////// +// Accessible public + +uint64_t +ImageAccessible::NativeState() +{ + // The state is a bitfield, get our inherited state, then logically OR it with + // states::ANIMATED if this is an animated image. + + uint64_t state = LinkableAccessible::NativeState(); + + nsCOMPtr<nsIImageLoadingContent> content(do_QueryInterface(mContent)); + nsCOMPtr<imgIRequest> imageRequest; + + if (content) + content->GetRequest(nsIImageLoadingContent::CURRENT_REQUEST, + getter_AddRefs(imageRequest)); + + nsCOMPtr<imgIContainer> imgContainer; + if (imageRequest) + imageRequest->GetImage(getter_AddRefs(imgContainer)); + + if (imgContainer) { + bool animated; + imgContainer->GetAnimated(&animated); + if (animated) + state |= states::ANIMATED; + } + + return state; +} + +ENameValueFlag +ImageAccessible::NativeName(nsString& aName) +{ + bool hasAltAttrib = + mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::alt, aName); + if (!aName.IsEmpty()) + return eNameOK; + + ENameValueFlag nameFlag = Accessible::NativeName(aName); + if (!aName.IsEmpty()) + return nameFlag; + + // No accessible name but empty 'alt' attribute is present. If further name + // computation algorithm doesn't provide non empty name then it means + // an empty 'alt' attribute was used to indicate a decorative image (see + // Accessible::Name() method for details). + return hasAltAttrib ? eNoNameOnPurpose : eNameOK; +} + +role +ImageAccessible::NativeRole() +{ + return roles::GRAPHIC; +} + +//////////////////////////////////////////////////////////////////////////////// +// Accessible + +uint8_t +ImageAccessible::ActionCount() +{ + uint8_t actionCount = LinkableAccessible::ActionCount(); + return HasLongDesc() ? actionCount + 1 : actionCount; +} + +void +ImageAccessible::ActionNameAt(uint8_t aIndex, nsAString& aName) +{ + aName.Truncate(); + if (IsLongDescIndex(aIndex) && HasLongDesc()) + aName.AssignLiteral("showlongdesc"); + else + LinkableAccessible::ActionNameAt(aIndex, aName); +} + +bool +ImageAccessible::DoAction(uint8_t aIndex) +{ + // Get the long description uri and open in a new window. + if (!IsLongDescIndex(aIndex)) + return LinkableAccessible::DoAction(aIndex); + + nsCOMPtr<nsIURI> uri = GetLongDescURI(); + if (!uri) + return false; + + nsAutoCString utf8spec; + uri->GetSpec(utf8spec); + NS_ConvertUTF8toUTF16 spec(utf8spec); + + nsIDocument* document = mContent->OwnerDoc(); + nsCOMPtr<nsPIDOMWindowOuter> piWindow = document->GetWindow(); + if (!piWindow) + return false; + + nsCOMPtr<nsPIDOMWindowOuter> tmp; + return NS_SUCCEEDED(piWindow->Open(spec, EmptyString(), EmptyString(), + /* aLoadInfo = */ nullptr, + /* aForceNoOpener = */ false, + getter_AddRefs(tmp))); +} + +//////////////////////////////////////////////////////////////////////////////// +// ImageAccessible + +nsIntPoint +ImageAccessible::Position(uint32_t aCoordType) +{ + nsIntRect rect = Bounds(); + nsAccUtils::ConvertScreenCoordsTo(&rect.x, &rect.y, aCoordType, this); + return rect.TopLeft(); +} + +nsIntSize +ImageAccessible::Size() +{ + return Bounds().Size(); +} + +// Accessible +already_AddRefed<nsIPersistentProperties> +ImageAccessible::NativeAttributes() +{ + nsCOMPtr<nsIPersistentProperties> attributes = + LinkableAccessible::NativeAttributes(); + + nsAutoString src; + mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::src, src); + if (!src.IsEmpty()) + nsAccUtils::SetAccAttr(attributes, nsGkAtoms::src, src); + + return attributes.forget(); +} + +//////////////////////////////////////////////////////////////////////////////// +// Private methods + +already_AddRefed<nsIURI> +ImageAccessible::GetLongDescURI() const +{ + if (mContent->HasAttr(kNameSpaceID_None, nsGkAtoms::longdesc)) { + // To check if longdesc contains an invalid url. + nsAutoString longdesc; + mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::longdesc, longdesc); + if (longdesc.FindChar(' ') != -1 || longdesc.FindChar('\t') != -1 || + longdesc.FindChar('\r') != -1 || longdesc.FindChar('\n') != -1) { + return nullptr; + } + nsCOMPtr<nsIURI> baseURI = mContent->GetBaseURI(); + nsCOMPtr<nsIURI> uri; + nsContentUtils::NewURIWithDocumentCharset(getter_AddRefs(uri), longdesc, + mContent->OwnerDoc(), baseURI); + return uri.forget(); + } + + DocAccessible* document = Document(); + if (document) { + IDRefsIterator iter(document, mContent, nsGkAtoms::aria_describedby); + while (nsIContent* target = iter.NextElem()) { + if ((target->IsHTMLElement(nsGkAtoms::a) || + target->IsHTMLElement(nsGkAtoms::area)) && + target->HasAttr(kNameSpaceID_None, nsGkAtoms::href)) { + nsGenericHTMLElement* element = + nsGenericHTMLElement::FromContent(target); + + nsCOMPtr<nsIURI> uri; + element->GetURIAttr(nsGkAtoms::href, nullptr, getter_AddRefs(uri)); + return uri.forget(); + } + } + } + + return nullptr; +} + +bool +ImageAccessible::IsLongDescIndex(uint8_t aIndex) +{ + return aIndex == LinkableAccessible::ActionCount(); +} + diff --git a/accessible/generic/ImageAccessible.h b/accessible/generic/ImageAccessible.h new file mode 100644 index 000000000..f2324ae4c --- /dev/null +++ b/accessible/generic/ImageAccessible.h @@ -0,0 +1,87 @@ +/* -*- 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 mozilla_a11y_ImageAccessible_h__ +#define mozilla_a11y_ImageAccessible_h__ + +#include "BaseAccessibles.h" + +namespace mozilla { +namespace a11y { + +/* Accessible for supporting images + * supports: + * - gets name, role + * - support basic state + */ +class ImageAccessible : public LinkableAccessible +{ +public: + ImageAccessible(nsIContent* aContent, DocAccessible* aDoc); + + // Accessible + virtual a11y::role NativeRole() override; + virtual uint64_t NativeState() override; + virtual already_AddRefed<nsIPersistentProperties> NativeAttributes() override; + + // ActionAccessible + virtual uint8_t ActionCount() override; + virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) override; + virtual bool DoAction(uint8_t aIndex) override; + + // ImageAccessible + nsIntPoint Position(uint32_t aCoordType); + nsIntSize Size(); + +protected: + virtual ~ImageAccessible(); + + // Accessible + virtual ENameValueFlag NativeName(nsString& aName) override; + +private: + /** + * Return whether the element has a longdesc URI. + */ + bool HasLongDesc() const + { + nsCOMPtr<nsIURI> uri = GetLongDescURI(); + return uri; + } + + /** + * Return an URI for showlongdesc action if any. + */ + already_AddRefed<nsIURI> GetLongDescURI() const; + + /** + * Used by ActionNameAt and DoAction to ensure the index for opening the + * longdesc URL is valid. + * It is always assumed that the highest possible index opens the longdesc. + * This doesn't check that there is actually a longdesc, just that the index + * would be correct if there was one. + * + * @param aIndex The 0-based index to be tested. + * + * @returns true if index is valid for longdesc action. + */ + inline bool IsLongDescIndex(uint8_t aIndex); + +}; + +//////////////////////////////////////////////////////////////////////////////// +// Accessible downcasting method + +inline ImageAccessible* +Accessible::AsImage() +{ + return IsImage() ? static_cast<ImageAccessible*>(this) : nullptr; +} + +} // namespace a11y +} // namespace mozilla + +#endif + diff --git a/accessible/generic/OuterDocAccessible.cpp b/accessible/generic/OuterDocAccessible.cpp new file mode 100644 index 000000000..a63069355 --- /dev/null +++ b/accessible/generic/OuterDocAccessible.cpp @@ -0,0 +1,218 @@ +/* -*- 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 "OuterDocAccessible.h" + +#include "Accessible-inl.h" +#include "nsAccUtils.h" +#include "DocAccessible-inl.h" +#include "mozilla/a11y/DocAccessibleParent.h" +#include "mozilla/dom/TabParent.h" +#include "Role.h" +#include "States.h" + +#ifdef A11Y_LOG +#include "Logging.h" +#endif + +using namespace mozilla; +using namespace mozilla::a11y; + +//////////////////////////////////////////////////////////////////////////////// +// OuterDocAccessible +//////////////////////////////////////////////////////////////////////////////// + +OuterDocAccessible:: + OuterDocAccessible(nsIContent* aContent, DocAccessible* aDoc) : + AccessibleWrap(aContent, aDoc) +{ + mType = eOuterDocType; + + // Request document accessible for the content document to make sure it's + // created. It will appended to outerdoc accessible children asynchronously. + nsIDocument* outerDoc = mContent->GetUncomposedDoc(); + if (outerDoc) { + nsIDocument* innerDoc = outerDoc->GetSubDocumentFor(mContent); + if (innerDoc) + GetAccService()->GetDocAccessible(innerDoc); + } +} + +OuterDocAccessible::~OuterDocAccessible() +{ +} + +//////////////////////////////////////////////////////////////////////////////// +// nsISupports + +NS_IMPL_ISUPPORTS_INHERITED0(OuterDocAccessible, + Accessible) + +//////////////////////////////////////////////////////////////////////////////// +// Accessible public (DON'T add methods here) + +role +OuterDocAccessible::NativeRole() +{ + return roles::INTERNAL_FRAME; +} + +Accessible* +OuterDocAccessible::ChildAtPoint(int32_t aX, int32_t aY, + EWhichChildAtPoint aWhichChild) +{ + nsIntRect docRect = Bounds(); + if (aX < docRect.x || aX >= docRect.x + docRect.width || + aY < docRect.y || aY >= docRect.y + docRect.height) + return nullptr; + + // Always return the inner doc as direct child accessible unless bounds + // outside of it. + Accessible* child = GetChildAt(0); + NS_ENSURE_TRUE(child, nullptr); + + if (aWhichChild == eDeepestChild) + return child->ChildAtPoint(aX, aY, eDeepestChild); + return child; +} + +//////////////////////////////////////////////////////////////////////////////// +// Accessible public + +void +OuterDocAccessible::Shutdown() +{ +#ifdef A11Y_LOG + if (logging::IsEnabled(logging::eDocDestroy)) + logging::OuterDocDestroy(this); +#endif + + Accessible* child = mChildren.SafeElementAt(0, nullptr); + if (child) { +#ifdef A11Y_LOG + if (logging::IsEnabled(logging::eDocDestroy)) { + logging::DocDestroy("outerdoc's child document rebind is scheduled", + child->AsDoc()->DocumentNode()); + } +#endif + RemoveChild(child); + + // XXX: sometimes outerdoc accessible is shutdown because of layout style + // change however the presshell of underlying document isn't destroyed and + // the document doesn't get pagehide events. Schedule a document rebind + // to its parent document. Otherwise a document accessible may be lost if + // its outerdoc has being recreated (see bug 862863 for details). + if (!mDoc->IsDefunct()) { + mDoc->BindChildDocument(child->AsDoc()); + } + } + + AccessibleWrap::Shutdown(); +} + +bool +OuterDocAccessible::InsertChildAt(uint32_t aIdx, Accessible* aAccessible) +{ + MOZ_RELEASE_ASSERT(aAccessible->IsDoc(), + "OuterDocAccessible can have a document child only!"); + + // We keep showing the old document for a bit after creating the new one, + // and while building the new DOM and frame tree. That's done on purpose + // to avoid weird flashes of default background color. + // The old viewer will be destroyed after the new one is created. + // For a11y, it should be safe to shut down the old document now. + if (mChildren.Length()) + mChildren[0]->Shutdown(); + + if (!AccessibleWrap::InsertChildAt(0, aAccessible)) + return false; + +#ifdef A11Y_LOG + if (logging::IsEnabled(logging::eDocCreate)) { + logging::DocCreate("append document to outerdoc", + aAccessible->AsDoc()->DocumentNode()); + logging::Address("outerdoc", this); + } +#endif + + return true; +} + +bool +OuterDocAccessible::RemoveChild(Accessible* aAccessible) +{ + Accessible* child = mChildren.SafeElementAt(0, nullptr); + if (child != aAccessible) { + NS_ERROR("Wrong child to remove!"); + return false; + } + +#ifdef A11Y_LOG + if (logging::IsEnabled(logging::eDocDestroy)) { + logging::DocDestroy("remove document from outerdoc", + child->AsDoc()->DocumentNode(), child->AsDoc()); + logging::Address("outerdoc", this); + } +#endif + + bool wasRemoved = AccessibleWrap::RemoveChild(child); + + NS_ASSERTION(!mChildren.Length(), + "This child document of outerdoc accessible wasn't removed!"); + + return wasRemoved; +} + +bool +OuterDocAccessible::IsAcceptableChild(nsIContent* aEl) const +{ + // outer document accessible doesn't not participate in ordinal tree + // mutations. + return false; +} + +#if defined(XP_WIN) + +// On Windows e10s, since we don't cache in the chrome process, these next two +// functions must be implemented so that we properly cross the chrome-to-content +// boundary when traversing. + +uint32_t +OuterDocAccessible::ChildCount() const +{ + uint32_t result = mChildren.Length(); + if (!result && RemoteChildDoc()) { + result = 1; + } + return result; +} + +Accessible* +OuterDocAccessible::GetChildAt(uint32_t aIndex) const +{ + Accessible* result = AccessibleWrap::GetChildAt(aIndex); + if (result || aIndex) { + return result; + } + // If we are asking for child 0 and GetChildAt doesn't return anything, try + // to get the remote child doc and return that instead. + ProxyAccessible* remoteChild = RemoteChildDoc(); + if (!remoteChild) { + return nullptr; + } + return WrapperFor(remoteChild); +} + +#endif // defined(XP_WIN) + +ProxyAccessible* +OuterDocAccessible::RemoteChildDoc() const +{ + dom::TabParent* tab = dom::TabParent::GetFrom(GetContent()); + if (!tab) + return nullptr; + + return tab->GetTopLevelDocAccessible(); +} diff --git a/accessible/generic/OuterDocAccessible.h b/accessible/generic/OuterDocAccessible.h new file mode 100644 index 000000000..bfa02ba14 --- /dev/null +++ b/accessible/generic/OuterDocAccessible.h @@ -0,0 +1,61 @@ +/* -*- 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 MOZILLA_A11Y_OUTERDOCACCESSIBLE_H_ +#define MOZILLA_A11Y_OUTERDOCACCESSIBLE_H_ + +#include "AccessibleWrap.h" + +namespace mozilla { +namespace a11y { +class ProxyAccessible; + +/** + * Used for <browser>, <frame>, <iframe>, <page> or editor> elements. + * + * In these variable names, "outer" relates to the OuterDocAccessible as + * opposed to the DocAccessibleWrap which is "inner". The outer node is + * a something like tags listed above, whereas the inner node corresponds to + * the inner document root. + */ + +class OuterDocAccessible final : public AccessibleWrap +{ +public: + OuterDocAccessible(nsIContent* aContent, DocAccessible* aDoc); + + NS_DECL_ISUPPORTS_INHERITED + + ProxyAccessible* RemoteChildDoc() const; + + // Accessible + virtual void Shutdown() override; + virtual mozilla::a11y::role NativeRole() override; + virtual Accessible* ChildAtPoint(int32_t aX, int32_t aY, + EWhichChildAtPoint aWhichChild) override; + + virtual bool InsertChildAt(uint32_t aIdx, Accessible* aChild) override; + virtual bool RemoveChild(Accessible* aAccessible) override; + virtual bool IsAcceptableChild(nsIContent* aEl) const override; + +#if defined(XP_WIN) + virtual uint32_t ChildCount() const override; + virtual Accessible* GetChildAt(uint32_t aIndex) const override; +#endif // defined(XP_WIN) + +protected: + virtual ~OuterDocAccessible() override; +}; + +inline OuterDocAccessible* +Accessible::AsOuterDoc() +{ + return IsOuterDoc() ? static_cast<OuterDocAccessible*>(this) : nullptr; +} + +} // namespace a11y +} // namespace mozilla + +#endif diff --git a/accessible/generic/RootAccessible.cpp b/accessible/generic/RootAccessible.cpp new file mode 100644 index 000000000..5817f2da9 --- /dev/null +++ b/accessible/generic/RootAccessible.cpp @@ -0,0 +1,732 @@ +/* -*- 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 "RootAccessible.h" + +#include "mozilla/ArrayUtils.h" + +#define CreateEvent CreateEventA +#include "nsIDOMDocument.h" + +#include "Accessible-inl.h" +#include "DocAccessible-inl.h" +#include "nsAccessibilityService.h" +#include "nsAccUtils.h" +#include "nsCoreUtils.h" +#include "nsEventShell.h" +#include "Relation.h" +#include "Role.h" +#include "States.h" +#ifdef MOZ_XUL +#include "XULTreeAccessible.h" +#endif + +#include "mozilla/dom/Element.h" + +#include "nsIDocShellTreeItem.h" +#include "nsIDocShellTreeOwner.h" +#include "mozilla/dom/Event.h" +#include "mozilla/dom/EventTarget.h" +#include "nsIDOMCustomEvent.h" +#include "nsIDOMXULMultSelectCntrlEl.h" +#include "nsIDocument.h" +#include "nsIInterfaceRequestorUtils.h" +#include "nsIPropertyBag2.h" +#include "nsIServiceManager.h" +#include "nsPIDOMWindow.h" +#include "nsIWebBrowserChrome.h" +#include "nsReadableUtils.h" +#include "nsFocusManager.h" +#include "nsGlobalWindow.h" + +#ifdef MOZ_XUL +#include "nsIXULDocument.h" +#include "nsIXULWindow.h" +#endif + +using namespace mozilla; +using namespace mozilla::a11y; +using namespace mozilla::dom; + +//////////////////////////////////////////////////////////////////////////////// +// nsISupports + +NS_IMPL_ISUPPORTS_INHERITED0(RootAccessible, DocAccessible) + +//////////////////////////////////////////////////////////////////////////////// +// Constructor/destructor + +RootAccessible:: + RootAccessible(nsIDocument* aDocument, nsIPresShell* aPresShell) : + DocAccessibleWrap(aDocument, aPresShell) +{ + mType = eRootType; +} + +RootAccessible::~RootAccessible() +{ +} + +//////////////////////////////////////////////////////////////////////////////// +// Accessible + +ENameValueFlag +RootAccessible::Name(nsString& aName) +{ + aName.Truncate(); + + if (ARIARoleMap()) { + Accessible::Name(aName); + if (!aName.IsEmpty()) + return eNameOK; + } + + mDocumentNode->GetTitle(aName); + return eNameOK; +} + +role +RootAccessible::NativeRole() +{ + // If it's a <dialog> or <wizard>, use roles::DIALOG instead + dom::Element* rootElm = mDocumentNode->GetRootElement(); + if (rootElm && rootElm->IsAnyOfXULElements(nsGkAtoms::dialog, + nsGkAtoms::wizard)) + return roles::DIALOG; + + return DocAccessibleWrap::NativeRole(); +} + +// RootAccessible protected member +#ifdef MOZ_XUL +uint32_t +RootAccessible::GetChromeFlags() +{ + // Return the flag set for the top level window as defined + // by nsIWebBrowserChrome::CHROME_WINDOW_[FLAGNAME] + // Not simple: nsIXULWindow is not just a QI from nsIDOMWindow + nsCOMPtr<nsIDocShell> docShell = nsCoreUtils::GetDocShellFor(mDocumentNode); + NS_ENSURE_TRUE(docShell, 0); + nsCOMPtr<nsIDocShellTreeOwner> treeOwner; + docShell->GetTreeOwner(getter_AddRefs(treeOwner)); + NS_ENSURE_TRUE(treeOwner, 0); + nsCOMPtr<nsIXULWindow> xulWin(do_GetInterface(treeOwner)); + if (!xulWin) { + return 0; + } + uint32_t chromeFlags; + xulWin->GetChromeFlags(&chromeFlags); + return chromeFlags; +} +#endif + +uint64_t +RootAccessible::NativeState() +{ + uint64_t state = DocAccessibleWrap::NativeState(); + if (state & states::DEFUNCT) + return state; + +#ifdef MOZ_XUL + uint32_t chromeFlags = GetChromeFlags(); + if (chromeFlags & nsIWebBrowserChrome::CHROME_WINDOW_RESIZE) + state |= states::SIZEABLE; + // If it has a titlebar it's movable + // XXX unless it's minimized or maximized, but not sure + // how to detect that + if (chromeFlags & nsIWebBrowserChrome::CHROME_TITLEBAR) + state |= states::MOVEABLE; + if (chromeFlags & nsIWebBrowserChrome::CHROME_MODAL) + state |= states::MODAL; +#endif + + nsFocusManager* fm = nsFocusManager::GetFocusManager(); + if (fm && fm->GetActiveWindow() == mDocumentNode->GetWindow()) + state |= states::ACTIVE; + + return state; +} + +const char* const kEventTypes[] = { +#ifdef DEBUG_DRAGDROPSTART + // Capture mouse over events and fire fake DRAGDROPSTART event to simplify + // debugging a11y objects with event viewers. + "mouseover", +#endif + // Fired when list or tree selection changes. + "select", + // Fired when value changes immediately, wether or not focused changed. + "ValueChange", + "AlertActive", + "TreeRowCountChanged", + "TreeInvalidated", + // add ourself as a OpenStateChange listener (custom event fired in tree.xml) + "OpenStateChange", + // add ourself as a CheckboxStateChange listener (custom event fired in HTMLInputElement.cpp) + "CheckboxStateChange", + // add ourself as a RadioStateChange Listener ( custom event fired in in HTMLInputElement.cpp & radio.xml) + "RadioStateChange", + "popupshown", + "popuphiding", + "DOMMenuInactive", + "DOMMenuItemActive", + "DOMMenuItemInactive", + "DOMMenuBarActive", + "DOMMenuBarInactive" +}; + +nsresult +RootAccessible::AddEventListeners() +{ + // EventTarget interface allows to register event listeners to + // receive untrusted events (synthetic events generated by untrusted code). + // For example, XBL bindings implementations for elements that are hosted in + // non chrome document fire untrusted events. + nsCOMPtr<EventTarget> nstarget = mDocumentNode; + + if (nstarget) { + for (const char* const* e = kEventTypes, + * const* e_end = ArrayEnd(kEventTypes); + e < e_end; ++e) { + nsresult rv = nstarget->AddEventListener(NS_ConvertASCIItoUTF16(*e), + this, true, true, 2); + NS_ENSURE_SUCCESS(rv, rv); + } + } + + return DocAccessible::AddEventListeners(); +} + +nsresult +RootAccessible::RemoveEventListeners() +{ + nsCOMPtr<EventTarget> target = mDocumentNode; + if (target) { + for (const char* const* e = kEventTypes, + * const* e_end = ArrayEnd(kEventTypes); + e < e_end; ++e) { + nsresult rv = target->RemoveEventListener(NS_ConvertASCIItoUTF16(*e), this, true); + NS_ENSURE_SUCCESS(rv, rv); + } + } + + // Do this before removing clearing caret accessible, so that it can use + // shutdown the caret accessible's selection listener + DocAccessible::RemoveEventListeners(); + return NS_OK; +} + +//////////////////////////////////////////////////////////////////////////////// +// public + +void +RootAccessible::DocumentActivated(DocAccessible* aDocument) +{ +} + +//////////////////////////////////////////////////////////////////////////////// +// nsIDOMEventListener + +NS_IMETHODIMP +RootAccessible::HandleEvent(nsIDOMEvent* aDOMEvent) +{ + MOZ_ASSERT(aDOMEvent); + Event* event = aDOMEvent->InternalDOMEvent(); + nsCOMPtr<nsINode> origTargetNode = do_QueryInterface(event->GetOriginalTarget()); + if (!origTargetNode) + return NS_OK; + +#ifdef A11Y_LOG + if (logging::IsEnabled(logging::eDOMEvents)) { + nsAutoString eventType; + aDOMEvent->GetType(eventType); + logging::DOMEvent("handled", origTargetNode, eventType); + } +#endif + + DocAccessible* document = + GetAccService()->GetDocAccessible(origTargetNode->OwnerDoc()); + + if (document) { + // Root accessible exists longer than any of its descendant documents so + // that we are guaranteed notification is processed before root accessible + // is destroyed. + document->HandleNotification<RootAccessible, nsIDOMEvent> + (this, &RootAccessible::ProcessDOMEvent, aDOMEvent); + } + + return NS_OK; +} + +// RootAccessible protected +void +RootAccessible::ProcessDOMEvent(nsIDOMEvent* aDOMEvent) +{ + MOZ_ASSERT(aDOMEvent); + Event* event = aDOMEvent->InternalDOMEvent(); + nsCOMPtr<nsINode> origTargetNode = do_QueryInterface(event->GetOriginalTarget()); + + nsAutoString eventType; + aDOMEvent->GetType(eventType); + +#ifdef A11Y_LOG + if (logging::IsEnabled(logging::eDOMEvents)) + logging::DOMEvent("processed", origTargetNode, eventType); +#endif + + if (eventType.EqualsLiteral("popuphiding")) { + HandlePopupHidingEvent(origTargetNode); + return; + } + + DocAccessible* targetDocument = GetAccService()-> + GetDocAccessible(origTargetNode->OwnerDoc()); + NS_ASSERTION(targetDocument, "No document while accessible is in document?!"); + + Accessible* accessible = + targetDocument->GetAccessibleOrContainer(origTargetNode); + if (!accessible) + return; + +#ifdef MOZ_XUL + XULTreeAccessible* treeAcc = accessible->AsXULTree(); + if (treeAcc) { + if (eventType.EqualsLiteral("TreeRowCountChanged")) { + HandleTreeRowCountChangedEvent(aDOMEvent, treeAcc); + return; + } + + if (eventType.EqualsLiteral("TreeInvalidated")) { + HandleTreeInvalidatedEvent(aDOMEvent, treeAcc); + return; + } + } +#endif + + if (eventType.EqualsLiteral("RadioStateChange")) { + uint64_t state = accessible->State(); + bool isEnabled = (state & (states::CHECKED | states::SELECTED)) != 0; + + if (accessible->NeedsDOMUIEvent()) { + RefPtr<AccEvent> accEvent = + new AccStateChangeEvent(accessible, states::CHECKED, isEnabled); + nsEventShell::FireEvent(accEvent); + } + + if (isEnabled) { + FocusMgr()->ActiveItemChanged(accessible); +#ifdef A11Y_LOG + if (logging::IsEnabled(logging::eFocus)) + logging::ActiveItemChangeCausedBy("RadioStateChange", accessible); +#endif + } + + return; + } + + if (eventType.EqualsLiteral("CheckboxStateChange")) { + if (accessible->NeedsDOMUIEvent()) { + uint64_t state = accessible->State(); + bool isEnabled = !!(state & states::CHECKED); + + RefPtr<AccEvent> accEvent = + new AccStateChangeEvent(accessible, states::CHECKED, isEnabled); + nsEventShell::FireEvent(accEvent); + } + return; + } + + Accessible* treeItemAcc = nullptr; +#ifdef MOZ_XUL + // If it's a tree element, need the currently selected item. + if (treeAcc) { + treeItemAcc = accessible->CurrentItem(); + if (treeItemAcc) + accessible = treeItemAcc; + } + + if (treeItemAcc && eventType.EqualsLiteral("OpenStateChange")) { + uint64_t state = accessible->State(); + bool isEnabled = (state & states::EXPANDED) != 0; + + RefPtr<AccEvent> accEvent = + new AccStateChangeEvent(accessible, states::EXPANDED, isEnabled); + nsEventShell::FireEvent(accEvent); + return; + } + + nsINode* targetNode = accessible->GetNode(); + if (treeItemAcc && eventType.EqualsLiteral("select")) { + // XXX: We shouldn't be based on DOM select event which doesn't provide us + // any context info. We should integrate into nsTreeSelection instead. + // If multiselect tree, we should fire selectionadd or selection removed + if (FocusMgr()->HasDOMFocus(targetNode)) { + nsCOMPtr<nsIDOMXULMultiSelectControlElement> multiSel = + do_QueryInterface(targetNode); + nsAutoString selType; + multiSel->GetSelType(selType); + if (selType.IsEmpty() || !selType.EqualsLiteral("single")) { + // XXX: We need to fire EVENT_SELECTION_ADD and EVENT_SELECTION_REMOVE + // for each tree item. Perhaps each tree item will need to cache its + // selection state and fire an event after a DOM "select" event when + // that state changes. XULTreeAccessible::UpdateTreeSelection(); + nsEventShell::FireEvent(nsIAccessibleEvent::EVENT_SELECTION_WITHIN, + accessible); + return; + } + + RefPtr<AccSelChangeEvent> selChangeEvent = + new AccSelChangeEvent(treeAcc, treeItemAcc, + AccSelChangeEvent::eSelectionAdd); + nsEventShell::FireEvent(selChangeEvent); + return; + } + } + else +#endif + if (eventType.EqualsLiteral("AlertActive")) { + nsEventShell::FireEvent(nsIAccessibleEvent::EVENT_ALERT, accessible); + } + else if (eventType.EqualsLiteral("popupshown")) { + HandlePopupShownEvent(accessible); + } + else if (eventType.EqualsLiteral("DOMMenuInactive")) { + if (accessible->Role() == roles::MENUPOPUP) { + nsEventShell::FireEvent(nsIAccessibleEvent::EVENT_MENUPOPUP_END, + accessible); + } + } + else if (eventType.EqualsLiteral("DOMMenuItemActive")) { + FocusMgr()->ActiveItemChanged(accessible); +#ifdef A11Y_LOG + if (logging::IsEnabled(logging::eFocus)) + logging::ActiveItemChangeCausedBy("DOMMenuItemActive", accessible); +#endif + } + else if (eventType.EqualsLiteral("DOMMenuItemInactive")) { + // Process DOMMenuItemInactive event for autocomplete only because this is + // unique widget that may acquire focus from autocomplete popup while popup + // stays open and has no active item. In case of XUL tree autocomplete + // popup this event is fired for tree accessible. + Accessible* widget = + accessible->IsWidget() ? accessible : accessible->ContainerWidget(); + if (widget && widget->IsAutoCompletePopup()) { + FocusMgr()->ActiveItemChanged(nullptr); +#ifdef A11Y_LOG + if (logging::IsEnabled(logging::eFocus)) + logging::ActiveItemChangeCausedBy("DOMMenuItemInactive", accessible); +#endif + } + } + else if (eventType.EqualsLiteral("DOMMenuBarActive")) { // Always from user input + nsEventShell::FireEvent(nsIAccessibleEvent::EVENT_MENU_START, + accessible, eFromUserInput); + + // Notify of active item change when menubar gets active and if it has + // current item. This is a case of mouseover (set current menuitem) and + // mouse click (activate the menubar). If menubar doesn't have current item + // (can be a case of menubar activation from keyboard) then ignore this + // notification because later we'll receive DOMMenuItemActive event after + // current menuitem is set. + Accessible* activeItem = accessible->CurrentItem(); + if (activeItem) { + FocusMgr()->ActiveItemChanged(activeItem); +#ifdef A11Y_LOG + if (logging::IsEnabled(logging::eFocus)) + logging::ActiveItemChangeCausedBy("DOMMenuBarActive", accessible); +#endif + } + } + else if (eventType.EqualsLiteral("DOMMenuBarInactive")) { // Always from user input + nsEventShell::FireEvent(nsIAccessibleEvent::EVENT_MENU_END, + accessible, eFromUserInput); + + FocusMgr()->ActiveItemChanged(nullptr); +#ifdef A11Y_LOG + if (logging::IsEnabled(logging::eFocus)) + logging::ActiveItemChangeCausedBy("DOMMenuBarInactive", accessible); +#endif + } + else if (accessible->NeedsDOMUIEvent() && + eventType.EqualsLiteral("ValueChange")) { + uint32_t event = accessible->HasNumericValue() + ? nsIAccessibleEvent::EVENT_VALUE_CHANGE + : nsIAccessibleEvent::EVENT_TEXT_VALUE_CHANGE; + targetDocument->FireDelayedEvent(event, accessible); + } +#ifdef DEBUG_DRAGDROPSTART + else if (eventType.EqualsLiteral("mouseover")) { + nsEventShell::FireEvent(nsIAccessibleEvent::EVENT_DRAGDROP_START, + accessible); + } +#endif +} + + +//////////////////////////////////////////////////////////////////////////////// +// Accessible + +void +RootAccessible::Shutdown() +{ + // Called manually or by Accessible::LastRelease() + if (!PresShell()) + return; // Already shutdown + + DocAccessibleWrap::Shutdown(); +} + +Relation +RootAccessible::RelationByType(RelationType aType) +{ + if (!mDocumentNode || aType != RelationType::EMBEDS) + return DocAccessibleWrap::RelationByType(aType); + + if (nsPIDOMWindowOuter* rootWindow = mDocumentNode->GetWindow()) { + nsCOMPtr<nsPIDOMWindowOuter> contentWindow = nsGlobalWindow::Cast(rootWindow)->GetContent(); + if (contentWindow) { + nsCOMPtr<nsIDocument> contentDocumentNode = contentWindow->GetDoc(); + if (contentDocumentNode) { + DocAccessible* contentDocument = + GetAccService()->GetDocAccessible(contentDocumentNode); + if (contentDocument) + return Relation(contentDocument); + } + } + } + + return Relation(); +} + +//////////////////////////////////////////////////////////////////////////////// +// Protected members + +void +RootAccessible::HandlePopupShownEvent(Accessible* aAccessible) +{ + roles::Role role = aAccessible->Role(); + + if (role == roles::MENUPOPUP) { + // Don't fire menupopup events for combobox and autocomplete lists. + nsEventShell::FireEvent(nsIAccessibleEvent::EVENT_MENUPOPUP_START, + aAccessible); + return; + } + + if (role == roles::TOOLTIP) { + // There is a single <xul:tooltip> node which Mozilla moves around. + // The accessible for it stays the same no matter where it moves. + // AT's expect to get an EVENT_SHOW for the tooltip. + // In event callback the tooltip's accessible will be ready. + nsEventShell::FireEvent(nsIAccessibleEvent::EVENT_SHOW, aAccessible); + return; + } + + if (role == roles::COMBOBOX_LIST) { + // Fire expanded state change event for comboboxes and autocompeletes. + Accessible* combobox = aAccessible->Parent(); + if (!combobox) + return; + + roles::Role comboboxRole = combobox->Role(); + if (comboboxRole == roles::COMBOBOX || + comboboxRole == roles::AUTOCOMPLETE) { + RefPtr<AccEvent> event = + new AccStateChangeEvent(combobox, states::EXPANDED, true); + if (event) + nsEventShell::FireEvent(event); + } + } +} + +void +RootAccessible::HandlePopupHidingEvent(nsINode* aPopupNode) +{ + // Get popup accessible. There are cases when popup element isn't accessible + // but an underlying widget is and behaves like popup, an example is + // autocomplete popups. + DocAccessible* document = nsAccUtils::GetDocAccessibleFor(aPopupNode); + if (!document) + return; + + Accessible* popup = document->GetAccessible(aPopupNode); + if (!popup) { + Accessible* popupContainer = document->GetContainerAccessible(aPopupNode); + if (!popupContainer) + return; + + uint32_t childCount = popupContainer->ChildCount(); + for (uint32_t idx = 0; idx < childCount; idx++) { + Accessible* child = popupContainer->GetChildAt(idx); + if (child->IsAutoCompletePopup()) { + popup = child; + break; + } + } + + // No popup no events. Focus is managed by DOM. This is a case for + // menupopups of menus on Linux since there are no accessible for popups. + if (!popup) + return; + } + + // In case of autocompletes and comboboxes fire state change event for + // expanded state. Note, HTML form autocomplete isn't a subject of state + // change event because they aren't autocompletes strictly speaking. + // When popup closes (except nested popups and menus) then fire focus event to + // where it was. The focus event is expected even if popup didn't take a focus. + + static const uint32_t kNotifyOfFocus = 1; + static const uint32_t kNotifyOfState = 2; + uint32_t notifyOf = 0; + + // HTML select is target of popuphidding event. Otherwise get container + // widget. No container widget means this is either tooltip or menupopup. + // No events in the former case. + Accessible* widget = nullptr; + if (popup->IsCombobox()) { + widget = popup; + } else { + widget = popup->ContainerWidget(); + if (!widget) { + if (!popup->IsMenuPopup()) + return; + + widget = popup; + } + } + + if (popup->IsAutoCompletePopup()) { + // No focus event for autocomplete because it's managed by + // DOMMenuItemInactive events. + if (widget->IsAutoComplete()) + notifyOf = kNotifyOfState; + + } else if (widget->IsCombobox()) { + // Fire focus for active combobox, otherwise the focus is managed by DOM + // focus notifications. Always fire state change event. + if (widget->IsActiveWidget()) + notifyOf = kNotifyOfFocus; + notifyOf |= kNotifyOfState; + + } else if (widget->IsMenuButton()) { + // Can be a part of autocomplete. + Accessible* compositeWidget = widget->ContainerWidget(); + if (compositeWidget && compositeWidget->IsAutoComplete()) { + widget = compositeWidget; + notifyOf = kNotifyOfState; + } + + // Autocomplete (like searchbar) can be inactive when popup hiddens + notifyOf |= kNotifyOfFocus; + + } else if (widget == popup) { + // Top level context menus and alerts. + // Ignore submenus and menubar. When submenu is closed then sumbenu + // container menuitem takes a focus via DOMMenuItemActive notification. + // For menubars processing we listen DOMMenubarActive/Inactive + // notifications. + notifyOf = kNotifyOfFocus; + } + + // Restore focus to where it was. + if (notifyOf & kNotifyOfFocus) { + FocusMgr()->ActiveItemChanged(nullptr); +#ifdef A11Y_LOG + if (logging::IsEnabled(logging::eFocus)) + logging::ActiveItemChangeCausedBy("popuphiding", popup); +#endif + } + + // Fire expanded state change event. + if (notifyOf & kNotifyOfState) { + RefPtr<AccEvent> event = + new AccStateChangeEvent(widget, states::EXPANDED, false); + document->FireDelayedEvent(event); + } +} + +#ifdef MOZ_XUL +void +RootAccessible::HandleTreeRowCountChangedEvent(nsIDOMEvent* aEvent, + XULTreeAccessible* aAccessible) +{ + nsCOMPtr<nsIDOMCustomEvent> customEvent(do_QueryInterface(aEvent)); + if (!customEvent) + return; + + nsCOMPtr<nsIVariant> detailVariant; + customEvent->GetDetail(getter_AddRefs(detailVariant)); + if (!detailVariant) + return; + + nsCOMPtr<nsISupports> supports; + detailVariant->GetAsISupports(getter_AddRefs(supports)); + nsCOMPtr<nsIPropertyBag2> propBag(do_QueryInterface(supports)); + if (!propBag) + return; + + nsresult rv; + int32_t index, count; + rv = propBag->GetPropertyAsInt32(NS_LITERAL_STRING("index"), &index); + if (NS_FAILED(rv)) + return; + + rv = propBag->GetPropertyAsInt32(NS_LITERAL_STRING("count"), &count); + if (NS_FAILED(rv)) + return; + + aAccessible->InvalidateCache(index, count); +} + +void +RootAccessible::HandleTreeInvalidatedEvent(nsIDOMEvent* aEvent, + XULTreeAccessible* aAccessible) +{ + nsCOMPtr<nsIDOMCustomEvent> customEvent(do_QueryInterface(aEvent)); + if (!customEvent) + return; + + nsCOMPtr<nsIVariant> detailVariant; + customEvent->GetDetail(getter_AddRefs(detailVariant)); + if (!detailVariant) + return; + + nsCOMPtr<nsISupports> supports; + detailVariant->GetAsISupports(getter_AddRefs(supports)); + nsCOMPtr<nsIPropertyBag2> propBag(do_QueryInterface(supports)); + if (!propBag) + return; + + int32_t startRow = 0, endRow = -1, startCol = 0, endCol = -1; + propBag->GetPropertyAsInt32(NS_LITERAL_STRING("startrow"), + &startRow); + propBag->GetPropertyAsInt32(NS_LITERAL_STRING("endrow"), + &endRow); + propBag->GetPropertyAsInt32(NS_LITERAL_STRING("startcolumn"), + &startCol); + propBag->GetPropertyAsInt32(NS_LITERAL_STRING("endcolumn"), + &endCol); + + aAccessible->TreeViewInvalidated(startRow, endRow, startCol, endCol); +} +#endif + +ProxyAccessible* +RootAccessible::GetPrimaryRemoteTopLevelContentDoc() const +{ + nsCOMPtr<nsIDocShellTreeOwner> owner; + mDocumentNode->GetDocShell()->GetTreeOwner(getter_AddRefs(owner)); + NS_ENSURE_TRUE(owner, nullptr); + + nsCOMPtr<nsITabParent> tabParent; + owner->GetPrimaryTabParent(getter_AddRefs(tabParent)); + if (!tabParent) { + return nullptr; + } + + auto tab = static_cast<dom::TabParent*>(tabParent.get()); + return tab->GetTopLevelDocAccessible(); +} diff --git a/accessible/generic/RootAccessible.h b/accessible/generic/RootAccessible.h new file mode 100644 index 000000000..beb74cf4b --- /dev/null +++ b/accessible/generic/RootAccessible.h @@ -0,0 +1,92 @@ +/* -*- 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 mozilla_a11y_RootAccessible_h__ +#define mozilla_a11y_RootAccessible_h__ + +#include "HyperTextAccessible.h" +#include "DocAccessibleWrap.h" + +#include "nsIDOMEventListener.h" + +class nsIDocument; + +namespace mozilla { +namespace a11y { + +class RootAccessible : public DocAccessibleWrap, + public nsIDOMEventListener +{ + NS_DECL_ISUPPORTS_INHERITED + +public: + RootAccessible(nsIDocument* aDocument, nsIPresShell* aPresShell); + + // nsIDOMEventListener + NS_IMETHOD HandleEvent(nsIDOMEvent* aEvent) override; + + // Accessible + virtual void Shutdown() override; + virtual mozilla::a11y::ENameValueFlag Name(nsString& aName) override; + virtual Relation RelationByType(RelationType aType) override; + virtual mozilla::a11y::role NativeRole() override; + virtual uint64_t NativeState() override; + + // RootAccessible + + /** + * Notify that the sub document presshell was activated. + */ + virtual void DocumentActivated(DocAccessible* aDocument); + + /** + * Return the primary remote top level document if any. + */ + ProxyAccessible* GetPrimaryRemoteTopLevelContentDoc() const; + +protected: + virtual ~RootAccessible(); + + /** + * Add/remove DOM event listeners. + */ + virtual nsresult AddEventListeners() override; + virtual nsresult RemoveEventListeners() override; + + /** + * Process the DOM event. + */ + void ProcessDOMEvent(nsIDOMEvent* aEvent); + + /** + * Process "popupshown" event. Used by HandleEvent(). + */ + void HandlePopupShownEvent(Accessible* aAccessible); + + /* + * Process "popuphiding" event. Used by HandleEvent(). + */ + void HandlePopupHidingEvent(nsINode* aNode); + +#ifdef MOZ_XUL + void HandleTreeRowCountChangedEvent(nsIDOMEvent* aEvent, + XULTreeAccessible* aAccessible); + void HandleTreeInvalidatedEvent(nsIDOMEvent* aEvent, + XULTreeAccessible* aAccessible); + + uint32_t GetChromeFlags(); +#endif +}; + +inline RootAccessible* +Accessible::AsRoot() +{ + return IsRoot() ? static_cast<mozilla::a11y::RootAccessible*>(this) : nullptr; +} + +} // namespace a11y +} // namespace mozilla + +#endif diff --git a/accessible/generic/TableAccessible.h b/accessible/generic/TableAccessible.h new file mode 100644 index 000000000..fbb8393b6 --- /dev/null +++ b/accessible/generic/TableAccessible.h @@ -0,0 +1,187 @@ +/* -*- 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 TABLE_ACCESSIBLE_H +#define TABLE_ACCESSIBLE_H + +#include "nsString.h" +#include "nsTArray.h" + +namespace mozilla { +namespace a11y { + +class Accessible; + +/** + * Accessible table interface. + */ +class TableAccessible +{ +public: + + /** + * Return the caption accessible if any for this table. + */ + virtual Accessible* Caption() const { return nullptr; } + + /** + * Get the summary for this table. + */ + virtual void Summary(nsString& aSummary) { aSummary.Truncate(); } + + /** + * Return the number of columns in the table. + */ + virtual uint32_t ColCount() { return 0; } + + /** + * Return the number of rows in the table. + */ + virtual uint32_t RowCount() { return 0; } + + /** + * Return the accessible for the cell at the given row and column indices. + */ + virtual Accessible* CellAt(uint32_t aRowIdx, uint32_t aColIdx) { return nullptr; } + + /** + * Return the index of the cell at the given row and column. + */ + virtual int32_t CellIndexAt(uint32_t aRowIdx, uint32_t aColIdx) + { return ColCount() * aRowIdx + aColIdx; } + + /** + * Return the column index of the cell with the given index. + */ + virtual int32_t ColIndexAt(uint32_t aCellIdx) + { return aCellIdx % ColCount(); } + + /** + * Return the row index of the cell with the given index. + */ + virtual int32_t RowIndexAt(uint32_t aCellIdx) + { return aCellIdx / ColCount(); } + + /** + * Get the row and column indices for the cell at the given index. + */ + virtual void RowAndColIndicesAt(uint32_t aCellIdx, int32_t* aRowIdx, + int32_t* aColIdx) + { + uint32_t colCount = ColCount(); + *aRowIdx = aCellIdx / colCount; + *aColIdx = aCellIdx % colCount; + } + + /** + * Return the number of columns occupied by the cell at the given row and + * column indices. + */ + virtual uint32_t ColExtentAt(uint32_t aRowIdx, uint32_t aColIdx) { return 1; } + + /** + * Return the number of rows occupied by the cell at the given row and column + * indices. + */ + virtual uint32_t RowExtentAt(uint32_t aRowIdx, uint32_t aColIdx) { return 1; } + + /** + * Get the description of the given column. + */ + virtual void ColDescription(uint32_t aColIdx, nsString& aDescription) + { aDescription.Truncate(); } + + /** + * Get the description for the given row. + */ + virtual void RowDescription(uint32_t aRowIdx, nsString& aDescription) + { aDescription.Truncate(); } + + /** + * Return true if the given column is selected. + */ + virtual bool IsColSelected(uint32_t aColIdx) { return false; } + + /** + * Return true if the given row is selected. + */ + virtual bool IsRowSelected(uint32_t aRowIdx) { return false; } + + /** + * Return true if the given cell is selected. + */ + virtual bool IsCellSelected(uint32_t aRowIdx, uint32_t aColIdx) { return false; } + + /** + * Return the number of selected cells. + */ + virtual uint32_t SelectedCellCount() { return 0; } + + /** + * Return the number of selected columns. + */ + virtual uint32_t SelectedColCount() { return 0; } + + /** + * Return the number of selected rows. + */ + virtual uint32_t SelectedRowCount() { return 0; } + + /** + * Get the set of selected cells. + */ + virtual void SelectedCells(nsTArray<Accessible*>* aCells) = 0; + + /** + * Get the set of selected cell indices. + */ + virtual void SelectedCellIndices(nsTArray<uint32_t>* aCells) = 0; + + /** + * Get the set of selected column indices. + */ + virtual void SelectedColIndices(nsTArray<uint32_t>* aCols) = 0; + + /** + * Get the set of selected row indices. + */ + virtual void SelectedRowIndices(nsTArray<uint32_t>* aRows) = 0; + + /** + * Select the given column unselecting any other selected columns. + */ + virtual void SelectCol(uint32_t aColIdx) {} + + /** + * Select the given row unselecting all other previously selected rows. + */ + virtual void SelectRow(uint32_t aRowIdx) {} + + /** + * Unselect the given column leaving other selected columns selected. + */ + virtual void UnselectCol(uint32_t aColIdx) {} + + /** + * Unselect the given row leaving other selected rows selected. + */ + virtual void UnselectRow(uint32_t aRowIdx) {} + + /** + * Return true if the table is probably for layout. + */ + virtual bool IsProbablyLayoutTable() { return false; } + + /** + * Convert the table to an Accessible*. + */ + virtual Accessible* AsAccessible() = 0; +}; + +} // namespace a11y +} // namespace mozilla + +#endif diff --git a/accessible/generic/TableCellAccessible.cpp b/accessible/generic/TableCellAccessible.cpp new file mode 100644 index 000000000..3c840127c --- /dev/null +++ b/accessible/generic/TableCellAccessible.cpp @@ -0,0 +1,67 @@ +/* -*- 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/. */ + +#include "TableCellAccessible.h" + +#include "Accessible-inl.h" +#include "TableAccessible.h" + +using namespace mozilla; +using namespace mozilla::a11y; + +void +TableCellAccessible::RowHeaderCells(nsTArray<Accessible*>* aCells) +{ + uint32_t rowIdx = RowIdx(), colIdx = ColIdx(); + TableAccessible* table = Table(); + if (!table) + return; + + // Move to the left to find row header cells + for (uint32_t curColIdx = colIdx - 1; curColIdx < colIdx; curColIdx--) { + Accessible* cell = table->CellAt(rowIdx, curColIdx); + if (!cell) + continue; + + // CellAt should always return a TableCellAccessible (XXX Bug 587529) + TableCellAccessible* tableCell = cell->AsTableCell(); + NS_ASSERTION(tableCell, "cell should be a table cell!"); + if (!tableCell) + continue; + + // Avoid addding cells multiple times, if this cell spans more columns + // we'll get it later. + if (tableCell->ColIdx() == curColIdx && cell->Role() == roles::ROWHEADER) + aCells->AppendElement(cell); + } +} + +void +TableCellAccessible::ColHeaderCells(nsTArray<Accessible*>* aCells) +{ + uint32_t rowIdx = RowIdx(), colIdx = ColIdx(); + TableAccessible* table = Table(); + if (!table) + return; + + // Move up to find column header cells + for (uint32_t curRowIdx = rowIdx - 1; curRowIdx < rowIdx; curRowIdx--) { + Accessible* cell = table->CellAt(curRowIdx, colIdx); + if (!cell) + continue; + + // CellAt should always return a TableCellAccessible (XXX Bug 587529) + TableCellAccessible* tableCell = cell->AsTableCell(); + NS_ASSERTION(tableCell, "cell should be a table cell!"); + if (!tableCell) + continue; + + // Avoid addding cells multiple times, if this cell spans more rows + // we'll get it later. + if (tableCell->RowIdx() == curRowIdx && cell->Role() == roles::COLUMNHEADER) + aCells->AppendElement(cell); + } +} diff --git a/accessible/generic/TableCellAccessible.h b/accessible/generic/TableCellAccessible.h new file mode 100644 index 000000000..327552fe8 --- /dev/null +++ b/accessible/generic/TableCellAccessible.h @@ -0,0 +1,70 @@ +/* -*- 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_TableCellAccessible_h__ +#define mozilla_a11y_TableCellAccessible_h__ + +#include "nsTArray.h" +#include <stdint.h> + +namespace mozilla { +namespace a11y { + +class Accessible; +class TableAccessible; + +/** + * Abstract interface implemented by table cell accessibles. + */ +class TableCellAccessible +{ +public: + + /** + * Return the table this cell is in. + */ + virtual TableAccessible* Table() const = 0; + + /** + * Return the column of the table this cell is in. + */ + virtual uint32_t ColIdx() const = 0; + + /** + * Return the row of the table this cell is in. + */ + virtual uint32_t RowIdx() const = 0; + + /** + * Return the column extent of this cell. + */ + virtual uint32_t ColExtent() const { return 1; } + + /** + * Return the row extent of this cell. + */ + virtual uint32_t RowExtent() const { return 1; } + + /** + * Return the column header cells for this cell. + */ + virtual void ColHeaderCells(nsTArray<Accessible*>* aCells); + + /** + * Return the row header cells for this cell. + */ + virtual void RowHeaderCells(nsTArray<Accessible*>* aCells); + + /** + * Returns true if this cell is selected. + */ + virtual bool Selected() = 0; +}; + +} // namespace a11y +} // namespace mozilla + +#endif // mozilla_a11y_TableCellAccessible_h__ diff --git a/accessible/generic/TextLeafAccessible.cpp b/accessible/generic/TextLeafAccessible.cpp new file mode 100644 index 000000000..9808833e1 --- /dev/null +++ b/accessible/generic/TextLeafAccessible.cpp @@ -0,0 +1,54 @@ +/* -*- 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 "TextLeafAccessible.h" + +#include "nsAccUtils.h" +#include "DocAccessible.h" +#include "Role.h" + +using namespace mozilla::a11y; + +//////////////////////////////////////////////////////////////////////////////// +// TextLeafAccessible +//////////////////////////////////////////////////////////////////////////////// + +TextLeafAccessible:: + TextLeafAccessible(nsIContent* aContent, DocAccessible* aDoc) : + LinkableAccessible(aContent, aDoc) +{ + mType = eTextLeafType; + mGenericTypes |= eText; + mStateFlags |= eNoKidsFromDOM; +} + +TextLeafAccessible::~TextLeafAccessible() +{ +} + +role +TextLeafAccessible::NativeRole() +{ + nsIFrame* frame = GetFrame(); + if (frame && frame->IsGeneratedContentFrame()) + return roles::STATICTEXT; + + return roles::TEXT_LEAF; +} + +void +TextLeafAccessible::AppendTextTo(nsAString& aText, uint32_t aStartOffset, + uint32_t aLength) +{ + aText.Append(Substring(mText, aStartOffset, aLength)); +} + +ENameValueFlag +TextLeafAccessible::Name(nsString& aName) +{ + // Text node, ARIA can't be used. + aName = mText; + return eNameOK; +} diff --git a/accessible/generic/TextLeafAccessible.h b/accessible/generic/TextLeafAccessible.h new file mode 100644 index 000000000..555929fbf --- /dev/null +++ b/accessible/generic/TextLeafAccessible.h @@ -0,0 +1,51 @@ +/* -*- 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 mozilla_a11y_TextLeafAccessible_h__ +#define mozilla_a11y_TextLeafAccessible_h__ + +#include "BaseAccessibles.h" + +namespace mozilla { +namespace a11y { + +/** + * Generic class used for text nodes. + */ +class TextLeafAccessible : public LinkableAccessible +{ +public: + TextLeafAccessible(nsIContent* aContent, DocAccessible* aDoc); + virtual ~TextLeafAccessible(); + + // Accessible + virtual mozilla::a11y::role NativeRole() override; + virtual void AppendTextTo(nsAString& aText, uint32_t aStartOffset = 0, + uint32_t aLength = UINT32_MAX) override; + virtual ENameValueFlag Name(nsString& aName) override; + + // TextLeafAccessible + void SetText(const nsAString& aText) { mText = aText; } + const nsString& Text() const { return mText; } + +protected: + nsString mText; +}; + + +//////////////////////////////////////////////////////////////////////////////// +// Accessible downcast method + +inline TextLeafAccessible* +Accessible::AsTextLeaf() +{ + return IsTextLeaf() ? static_cast<TextLeafAccessible*>(this) : nullptr; +} + +} // namespace a11y +} // namespace mozilla + +#endif + diff --git a/accessible/generic/moz.build b/accessible/generic/moz.build new file mode 100644 index 000000000..a9e97acf0 --- /dev/null +++ b/accessible/generic/moz.build @@ -0,0 +1,70 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# 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/. + +EXPORTS.mozilla.a11y += [ + 'Accessible.h', + 'DocAccessible.h', + 'HyperTextAccessible.h', +] + +UNIFIED_SOURCES += [ + 'Accessible.cpp', + 'ApplicationAccessible.cpp', + 'ARIAGridAccessible.cpp', + 'BaseAccessibles.cpp', + 'DocAccessible.cpp', + 'FormControlAccessible.cpp', + 'HyperTextAccessible.cpp', + 'ImageAccessible.cpp', + 'OuterDocAccessible.cpp', + 'RootAccessible.cpp', + 'TableCellAccessible.cpp', + 'TextLeafAccessible.cpp', +] + +LOCAL_INCLUDES += [ + '/accessible/base', + '/accessible/html', + '/accessible/xpcom', + '/accessible/xul', + '/dom/base', + '/layout/generic', + '/layout/xul', +] + +if CONFIG['OS_ARCH'] == 'WINNT': + LOCAL_INCLUDES += [ + '/accessible/ipc/win', + ] +else: + LOCAL_INCLUDES += [ + '/accessible/ipc/other', + ] + +if 'gtk' in CONFIG['MOZ_WIDGET_TOOLKIT']: + LOCAL_INCLUDES += [ + '/accessible/atk', + ] +elif CONFIG['MOZ_WIDGET_TOOLKIT'] == 'windows': + LOCAL_INCLUDES += [ + '/accessible/windows/ia2', + '/accessible/windows/msaa', + ] +elif CONFIG['MOZ_WIDGET_TOOLKIT'] == 'cocoa': + LOCAL_INCLUDES += [ + '/accessible/mac', + ] +else: + LOCAL_INCLUDES += [ + '/accessible/other', + ] + +FINAL_LIBRARY = 'xul' + +include('/ipc/chromium/chromium-config.mozbuild') + +if CONFIG['GNU_CXX']: + CXXFLAGS += ['-Wno-error=shadow'] |