Source code
Revision control
Copy as Markdown
Other Tools
/* clang-format off */
/* -*- Mode: Objective-C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* clang-format on */
/* 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
#import "mozTableAccessible.h"
#import "nsCocoaUtils.h"
#import "MacUtils.h"
#include "AccIterator.h"
#include "LocalAccessible.h"
#include "mozilla/a11y/TableAccessible.h"
#include "mozilla/a11y/TableCellAccessible.h"
#include "nsAccessibilityService.h"
#include "nsIAccessiblePivot.h"
#include "XULTreeAccessible.h"
#include "Pivot.h"
#include "nsAccUtils.h"
#include "Relation.h"
using namespace mozilla;
using namespace mozilla::a11y;
@implementation mozColumnContainer
- (id)initWithIndex:(uint32_t)aIndex andParent:(mozAccessible*)aParent {
self = [super init];
mIndex = aIndex;
mParent = aParent;
return self;
}
- (NSString*)moxRole {
return NSAccessibilityColumnRole;
}
- (NSString*)moxRoleDescription {
return NSAccessibilityRoleDescription(NSAccessibilityColumnRole, nil);
}
- (mozAccessible*)moxParent {
return mParent;
}
- (NSArray*)moxUnignoredChildren {
if (mChildren) return mChildren;
mChildren = [[NSMutableArray alloc] init];
TableAccessible* table = [mParent geckoAccessible]->AsTable();
MOZ_ASSERT(table, "Got null table when fetching column children!");
uint32_t numRows = table->RowCount();
for (uint32_t j = 0; j < numRows; j++) {
Accessible* cell = table->CellAt(j, mIndex);
mozAccessible* nativeCell = cell ? GetNativeFromGeckoAccessible(cell) : nil;
if ([nativeCell isAccessibilityElement]) {
[mChildren addObject:nativeCell];
}
}
return mChildren;
}
- (void)dealloc {
NS_OBJC_BEGIN_TRY_IGNORE_BLOCK;
[self invalidateChildren];
[super dealloc];
NS_OBJC_END_TRY_IGNORE_BLOCK;
}
- (void)expire {
NS_OBJC_BEGIN_TRY_IGNORE_BLOCK;
[self invalidateChildren];
mParent = nil;
[super expire];
NS_OBJC_END_TRY_IGNORE_BLOCK;
}
- (BOOL)isExpired {
MOZ_ASSERT((mChildren == nil && mParent == nil) == mIsExpired);
return [super isExpired];
}
- (void)invalidateChildren {
NS_OBJC_BEGIN_TRY_IGNORE_BLOCK;
// make room for new children
if (mChildren) {
[mChildren release];
mChildren = nil;
}
NS_OBJC_END_TRY_IGNORE_BLOCK;
}
@end
@implementation mozTablePartAccessible
- (NSString*)moxTitle {
return @"";
}
- (NSString*)moxRole {
return [self isLayoutTablePart] ? NSAccessibilityGroupRole : [super moxRole];
}
- (BOOL)isLayoutTablePart {
mozAccessible* parent = (mozAccessible*)[self moxUnignoredParent];
if ([parent isKindOfClass:[mozTablePartAccessible class]]) {
return [(mozTablePartAccessible*)parent isLayoutTablePart];
} else if ([parent isKindOfClass:[mozOutlineAccessible class]]) {
return [(mozOutlineAccessible*)parent isLayoutTablePart];
}
return NO;
}
@end
@implementation mozTableAccessible
- (BOOL)isLayoutTablePart {
if (mGeckoAccessible->Role() == roles::TREE_TABLE) {
// tree tables are never layout tables, and we shouldn't
// query IsProbablyLayoutTable() on them, so we short
// circuit here
return false;
}
// For LocalAccessible and cached RemoteAccessible, we could use
// AsTable()->IsProbablyLayoutTable(). However, if the cache is enabled,
// that would build the table cache, which is pointless for layout tables on
// Mac because layout tables are AXGroups and do not expose table properties
// like AXRows, AXColumns, etc.
if (LocalAccessible* acc = mGeckoAccessible->AsLocal()) {
return acc->AsTable()->IsProbablyLayoutTable();
}
RemoteAccessible* proxy = mGeckoAccessible->AsRemote();
return proxy->TableIsProbablyForLayout();
}
- (void)handleAccessibleEvent:(uint32_t)eventType {
if (eventType == nsIAccessibleEvent::EVENT_REORDER ||
eventType == nsIAccessibleEvent::EVENT_OBJECT_ATTRIBUTE_CHANGED) {
[self invalidateColumns];
}
[super handleAccessibleEvent:eventType];
}
- (void)dealloc {
NS_OBJC_BEGIN_TRY_IGNORE_BLOCK;
[self invalidateColumns];
[super dealloc];
NS_OBJC_END_TRY_IGNORE_BLOCK;
}
- (void)expire {
[self invalidateColumns];
[super expire];
}
- (NSNumber*)moxRowCount {
MOZ_ASSERT(mGeckoAccessible);
return @(mGeckoAccessible->AsTable()->RowCount());
}
- (NSNumber*)moxColumnCount {
MOZ_ASSERT(mGeckoAccessible);
return @(mGeckoAccessible->AsTable()->ColCount());
}
- (NSArray*)moxRows {
// Create a new array with the list of table rows.
NSArray* children = [self moxChildren];
NSMutableArray* rows = [[[NSMutableArray alloc] init] autorelease];
for (mozAccessible* curr : children) {
if ([curr isKindOfClass:[mozTableRowAccessible class]]) {
[rows addObject:curr];
} else if ([[curr moxRole] isEqualToString:@"AXGroup"]) {
// Plain thead/tbody elements are removed from the core a11y tree and
// replaced with their subtree, but thead/tbody elements with click
// handlers are not -- they remain as groups. We need to expose any
// rows they contain as rows of the parent table.
[rows
addObjectsFromArray:[[curr moxChildren]
filteredArrayUsingPredicate:
[NSPredicate predicateWithBlock:^BOOL(
mozAccessible* child,
NSDictionary* bindings) {
return [child
isKindOfClass:[mozTableRowAccessible
class]];
}]]];
}
}
return rows;
}
- (NSArray*)moxColumns {
MOZ_ASSERT(mGeckoAccessible);
if (mColContainers) {
return mColContainers;
}
mColContainers = [[NSMutableArray alloc] init];
uint32_t numCols = 0;
numCols = mGeckoAccessible->AsTable()->ColCount();
for (uint32_t i = 0; i < numCols; i++) {
mozColumnContainer* container =
[[mozColumnContainer alloc] initWithIndex:i andParent:self];
[mColContainers addObject:container];
}
return mColContainers;
}
- (NSArray*)moxUnignoredChildren {
if (![self isLayoutTablePart]) {
return [[super moxUnignoredChildren]
arrayByAddingObjectsFromArray:[self moxColumns]];
}
return [super moxUnignoredChildren];
}
- (NSArray*)moxColumnHeaderUIElements {
MOZ_ASSERT(mGeckoAccessible);
uint32_t numCols = 0;
TableAccessible* table = nullptr;
table = mGeckoAccessible->AsTable();
numCols = table->ColCount();
NSMutableArray* colHeaders =
[[[NSMutableArray alloc] initWithCapacity:numCols] autorelease];
for (uint32_t i = 0; i < numCols; i++) {
Accessible* cell = table->CellAt(0, i);
if (cell && cell->Role() == roles::COLUMNHEADER) {
mozAccessible* colHeader = GetNativeFromGeckoAccessible(cell);
[colHeaders addObject:colHeader];
}
}
return colHeaders;
}
- (id)moxCellForColumnAndRow:(NSArray*)columnAndRow {
if (columnAndRow == nil || [columnAndRow count] != 2) {
return nil;
}
uint32_t col = [[columnAndRow objectAtIndex:0] unsignedIntValue];
uint32_t row = [[columnAndRow objectAtIndex:1] unsignedIntValue];
MOZ_ASSERT(mGeckoAccessible);
Accessible* cell = mGeckoAccessible->AsTable()->CellAt(row, col);
if (!cell) {
return nil;
}
return GetNativeFromGeckoAccessible(cell);
}
- (void)invalidateColumns {
NS_OBJC_BEGIN_TRY_IGNORE_BLOCK;
if (mColContainers) {
for (mozColumnContainer* col in mColContainers) {
[col expire];
}
[mColContainers release];
mColContainers = nil;
}
NS_OBJC_END_TRY_IGNORE_BLOCK;
}
@end
@interface mozTableRowAccessible ()
- (mozTableAccessible*)getTableParent;
@end
@implementation mozTableRowAccessible
- (mozTableAccessible*)getTableParent {
id tableParent = static_cast<mozTableAccessible*>(
[self moxFindAncestor:^BOOL(id curr, BOOL* stop) {
if ([curr isKindOfClass:[mozOutlineAccessible class]]) {
// Outline rows are a kind of table row, so it's possible
// we're trying to call getTableParent on an outline row here.
// Stop searching.
*stop = YES;
}
return [curr isKindOfClass:[mozTableAccessible class]];
}]);
return [tableParent isKindOfClass:[mozTableAccessible class]] ? tableParent
: nil;
}
- (void)handleAccessibleEvent:(uint32_t)eventType {
if (eventType == nsIAccessibleEvent::EVENT_REORDER) {
// It is possible for getTableParent to return nil if we're
// handling a reorder on an outilne row. Outlines don't have
// columns, so there's nothing to do here and this will no-op.
[[self getTableParent] invalidateColumns];
}
[super handleAccessibleEvent:eventType];
}
- (NSNumber*)moxIndex {
return @([[[self getTableParent] moxRows] indexOfObjectIdenticalTo:self]);
}
@end
@implementation mozTableCellAccessible
- (NSValue*)moxRowIndexRange {
MOZ_ASSERT(mGeckoAccessible);
TableCellAccessible* cell = mGeckoAccessible->AsTableCell();
return
[NSValue valueWithRange:NSMakeRange(cell->RowIdx(), cell->RowExtent())];
}
- (NSValue*)moxColumnIndexRange {
MOZ_ASSERT(mGeckoAccessible);
TableCellAccessible* cell = mGeckoAccessible->AsTableCell();
return
[NSValue valueWithRange:NSMakeRange(cell->ColIdx(), cell->ColExtent())];
}
- (NSArray*)moxRowHeaderUIElements {
MOZ_ASSERT(mGeckoAccessible);
TableCellAccessible* cell = mGeckoAccessible->AsTableCell();
AutoTArray<Accessible*, 10> headerCells;
if (cell) {
cell->RowHeaderCells(&headerCells);
}
return utils::ConvertToNSArray(headerCells);
}
- (NSArray*)moxColumnHeaderUIElements {
MOZ_ASSERT(mGeckoAccessible);
TableCellAccessible* cell = mGeckoAccessible->AsTableCell();
AutoTArray<Accessible*, 10> headerCells;
if (cell) {
cell->ColHeaderCells(&headerCells);
}
return utils::ConvertToNSArray(headerCells);
}
@end
/**
* This rule matches all accessibles with roles::OUTLINEITEM. If
* outlines are nested, it ignores the nested subtree and returns
* only items which are descendants of the primary outline.
*/
class OutlineRule : public PivotRule {
public:
uint16_t Match(Accessible* aAcc) override {
uint16_t result = nsIAccessibleTraversalRule::FILTER_IGNORE;
if (nsAccUtils::MustPrune(aAcc)) {
result |= nsIAccessibleTraversalRule::FILTER_IGNORE_SUBTREE;
}
if (![GetNativeFromGeckoAccessible(aAcc) isAccessibilityElement]) {
return result;
}
if (aAcc->Role() == roles::OUTLINE) {
// if the accessible is an outline, we ignore all children
result |= nsIAccessibleTraversalRule::FILTER_IGNORE_SUBTREE;
} else if (aAcc->Role() == roles::OUTLINEITEM) {
// if the accessible is not an outline item, we match here
result |= nsIAccessibleTraversalRule::FILTER_MATCH;
}
return result;
}
};
@implementation mozOutlineAccessible
- (BOOL)isLayoutTablePart {
return NO;
}
- (NSArray*)moxRows {
// Create a new array with the list of outline rows. We
// use pivot here to do a deep traversal of all rows nested
// in this outline, not just those which are direct
// children, since that's what VO expects.
NSMutableArray* allRows = [[[NSMutableArray alloc] init] autorelease];
Pivot p = Pivot(mGeckoAccessible);
OutlineRule rule = OutlineRule();
Accessible* firstChild = mGeckoAccessible->FirstChild();
Accessible* match = p.Next(firstChild, rule, true);
while (match) {
[allRows addObject:GetNativeFromGeckoAccessible(match)];
match = p.Next(match, rule);
}
return allRows;
}
- (NSArray*)moxColumns {
if (LocalAccessible* acc = mGeckoAccessible->AsLocal()) {
if (acc->IsContent() && acc->GetContent()->IsXULElement(nsGkAtoms::tree)) {
XULTreeAccessible* treeAcc = (XULTreeAccessible*)acc;
NSMutableArray* cols = [[[NSMutableArray alloc] init] autorelease];
// XUL trees store their columns in a group at the tree's first
// child. Here, we iterate over that group to get each column's
// native accessible and add it to our col array.
LocalAccessible* treeColumns = treeAcc->LocalChildAt(0);
if (treeColumns) {
uint32_t colCount = treeColumns->ChildCount();
for (uint32_t i = 0; i < colCount; i++) {
LocalAccessible* treeColumnItem = treeColumns->LocalChildAt(i);
[cols addObject:GetNativeFromGeckoAccessible(treeColumnItem)];
}
return cols;
}
}
}
// Webkit says we shouldn't expose any cols for aria-tree
// so we return an empty array here
return @[];
}
- (NSArray*)moxSelectedRows {
NSMutableArray* selectedRows = [[[NSMutableArray alloc] init] autorelease];
NSArray* allRows = [self moxRows];
for (mozAccessible* row in allRows) {
if ([row stateWithMask:states::SELECTED] != 0) {
[selectedRows addObject:row];
}
}
return selectedRows;
}
- (NSString*)moxOrientation {
return NSAccessibilityVerticalOrientationValue;
}
@end
@implementation mozOutlineRowAccessible
- (BOOL)isLayoutTablePart {
return NO;
}
- (NSNumber*)moxDisclosing {
return @([self stateWithMask:states::EXPANDED] != 0);
}
- (void)moxSetDisclosing:(NSNumber*)disclosing {
// VoiceOver requires this to be settable, but doesn't
// require it actually affect our disclosing state.
// We expose the attr as settable with this method
// but do nothing to actually set it.
return;
}
- (NSNumber*)moxExpanded {
return @([self stateWithMask:states::EXPANDED] != 0);
}
- (id)moxDisclosedByRow {
// According to webkit: this attr corresponds to the row
// that contains this row. It should be the same as the
// first parent that is a treeitem. If the parent is the tree
// itself, this should be nil. This is tricky for xul trees because
// all rows are direct children of the outline; they use
// relations to expose their heirarchy structure.
// first we check the relations to see if we're in a xul tree
// with weird row semantics
NSArray<mozAccessible*>* disclosingRows =
[self getRelationsByType:RelationType::NODE_CHILD_OF];
mozAccessible* disclosingRow = [disclosingRows firstObject];
if (disclosingRow) {
// if we find a row from our relation check,
// verify it isn't the outline itself and return
// appropriately
if ([[disclosingRow moxRole] isEqualToString:@"AXOutline"]) {
return nil;
}
return disclosingRow;
}
mozAccessible* parent = (mozAccessible*)[self moxUnignoredParent];
// otherwise, its likely we're in an aria tree, so we can use
// these role and subrole checks
if ([[parent moxRole] isEqualToString:@"AXOutline"]) {
return nil;
}
if ([[parent moxSubrole] isEqualToString:@"AXOutlineRow"]) {
disclosingRow = parent;
}
return nil;
}
- (NSNumber*)moxDisclosureLevel {
GroupPos groupPos = mGeckoAccessible->GroupPosition();
// mac expects 0-indexed levels, but groupPos.level is 1-indexed
// so we subtract 1 here for levels above 0
return groupPos.level > 0 ? @(groupPos.level - 1) : @(groupPos.level);
}
- (NSArray*)moxDisclosedRows {
// According to webkit: this attr corresponds to the rows
// that are considered inside this row. Again, this is weird for
// xul trees so we have to use relations first and then fall-back
// to the children filter for non-xul outlines.
// first we check the relations to see if we're in a xul tree
// with weird row semantics
if (NSArray* disclosedRows =
[self getRelationsByType:RelationType::NODE_PARENT_OF]) {
// if we find rows from our relation check, return them here
return disclosedRows;
}
// otherwise, filter our children for outline rows
return [[self moxChildren]
filteredArrayUsingPredicate:[NSPredicate predicateWithBlock:^BOOL(
mozAccessible* child,
NSDictionary* bindings) {
return [child isKindOfClass:[mozOutlineRowAccessible class]];
}]];
}
- (NSNumber*)moxIndex {
id<MOXAccessible> outline =
[self moxFindAncestor:^BOOL(id<MOXAccessible> moxAcc, BOOL* stop) {
return [[moxAcc moxRole] isEqualToString:@"AXOutline"];
}];
NSUInteger index = [[outline moxRows] indexOfObjectIdenticalTo:self];
return index == NSNotFound ? nil : @(index);
}
- (NSString*)moxLabel {
nsAutoString title;
mGeckoAccessible->Name(title);
// XXX: When parsing outlines built with ul/lu's, we
// include the bullet in this description even
// though webkit doesn't. Not all outlines are built with
// ul/lu's so we can't strip the first character here.
return nsCocoaUtils::ToNSString(title);
}
- (int)checkedValue {
uint64_t state = [self
stateWithMask:(states::CHECKABLE | states::CHECKED | states::MIXED)];
if (state & states::CHECKABLE) {
if (state & states::CHECKED) {
return kChecked;
}
if (state & states::MIXED) {
return kMixed;
}
return kUnchecked;
}
return kUncheckable;
}
- (id)moxValue {
int checkedValue = [self checkedValue];
return checkedValue >= 0 ? @(checkedValue) : nil;
}
- (void)stateChanged:(uint64_t)state isEnabled:(BOOL)enabled {
[super stateChanged:state isEnabled:enabled];
if (state & states::EXPANDED) {
// If the EXPANDED state is updated, fire appropriate events on the
// outline row.
[self moxPostNotification:(enabled
? NSAccessibilityRowExpandedNotification
: NSAccessibilityRowCollapsedNotification)];
}
if (state & (states::CHECKED | states::CHECKABLE | states::MIXED)) {
// If the MIXED, CHECKED or CHECKABLE state changes, update the value we
// expose for the row, which communicates checked status.
[self moxPostNotification:NSAccessibilityValueChangedNotification];
}
}
@end