AccessibilityObject* AccessibilityObject::firstAccessibleObjectFromNode(const Node* node) { ASSERT(AXObjectCache::accessibilityEnabled()); if (!node) return 0; Document* document = node->document(); if (!document) return 0; AXObjectCache* cache = document->axObjectCache(); AccessibilityObject* accessibleObject = cache->getOrCreate(node->renderer()); while (accessibleObject && accessibleObject->accessibilityIsIgnored()) { node = node->traverseNextNode(); while (node && !node->renderer()) node = node->traverseNextSibling(); if (!node) return 0; accessibleObject = cache->getOrCreate(node->renderer()); } return accessibleObject; }
AccessibilityObject* AccessibilityObject::firstAccessibleObjectFromNode(const Node* node) { if (!node) return 0; Document* document = node->document(); if (!document) return 0; AXObjectCache* cache = document->axObjectCache(); AccessibilityObject* accessibleObject = cache->getOrCreate(node->renderer()); while (accessibleObject && accessibleObject->accessibilityIsIgnored()) { node = NodeTraversal::next(node); while (node && !node->renderer()) node = NodeTraversal::nextSkippingChildren(node); if (!node) return 0; accessibleObject = cache->getOrCreate(node->renderer()); } return accessibleObject; }
bool Scrollbar::scroll(ScrollDirection direction, ScrollGranularity granularity, float multiplier) { #if HAVE(ACCESSIBILITY) if (AXObjectCache::accessibilityEnabled()) { if (parent() && parent()->isFrameView()) { Document* document = static_cast<FrameView*>(parent())->frame()->document(); AXObjectCache* cache = document->axObjectCache(); AccessibilityScrollbar* axObject = static_cast<AccessibilityScrollbar*>(cache->getOrCreate(ScrollBarRole)); axObject->setScrollbar(this); cache->postNotification(axObject, document, AXObjectCache::AXValueChanged, true); } } #endif // Ignore perpendicular scrolls. if ((m_orientation == HorizontalScrollbar) ? (direction == ScrollUp || direction == ScrollDown) : (direction == ScrollLeft || direction == ScrollRight)) return false; float step = 0; switch (granularity) { case ScrollByLine: step = m_lineStep; break; case ScrollByPage: step = m_pageStep; break; case ScrollByDocument: step = m_totalSize; break; case ScrollByPixel: step = m_pixelStep; break; } if (direction == ScrollUp || direction == ScrollLeft) multiplier = -multiplier; if (client()) return client()->scroll(m_orientation, granularity, step, multiplier); return setCurrentPos(max(min(m_currentPos + (step * multiplier), static_cast<float>(m_totalSize - m_visibleSize)), 0.0f), NotFromScrollAnimator); }
void AccessibilityARIAGrid::addChildren() { ASSERT(!m_haveChildren); if (!isAccessibilityTable()) { AccessibilityRenderObject::addChildren(); return; } m_haveChildren = true; if (!m_renderer) return; AXObjectCache* axCache = m_renderer->document().axObjectCache(); // add only rows that are labeled as aria rows HashSet<AccessibilityObject*> appendedRows; unsigned columnCount = 0; for (RefPtr<AccessibilityObject> child = firstChild(); child; child = child->nextSibling()) addRowDescendant(child.get(), appendedRows, columnCount); // make the columns based on the number of columns in the first body for (unsigned i = 0; i < columnCount; ++i) { AccessibilityTableColumn* column = toAccessibilityTableColumn(axCache->getOrCreate(ColumnRole)); column->setColumnIndex((int)i); column->setParent(this); m_columns.append(column); if (!column->accessibilityIsIgnored()) m_children.append(column); } AccessibilityObject* headerContainerObject = headerContainer(); if (headerContainerObject && !headerContainerObject->accessibilityIsIgnored()) m_children.append(headerContainerObject); }
void AXObjectCache::textMarkerDataForVisiblePosition(TextMarkerData& textMarkerData, const VisiblePosition& visiblePos) { // This memory must be bzero'd so instances of TextMarkerData can be tested for byte-equivalence. // This also allows callers to check for failure by looking at textMarkerData upon return. memset(&textMarkerData, 0, sizeof(TextMarkerData)); if (visiblePos.isNull()) return; Position deepPos = visiblePos.deepEquivalent(); Node* domNode = deepPos.deprecatedNode(); ASSERT(domNode); if (!domNode) return; if (domNode->isHTMLElement()) { HTMLInputElement* inputElement = domNode->toInputElement(); if (inputElement && inputElement->isPasswordField()) return; } // find or create an accessibility object for this node AXObjectCache* cache = domNode->document()->axObjectCache(); RefPtr<AccessibilityObject> obj = cache->getOrCreate(domNode); textMarkerData.axID = obj.get()->axObjectID(); textMarkerData.node = domNode; textMarkerData.offset = deepPos.deprecatedEditingOffset(); textMarkerData.affinity = visiblePos.affinity(); cache->setNodeInUse(domNode); }
void FrameSelection::notifyAccessibilityForSelectionChange(const AXTextStateChangeIntent&) { if (!AXObjectCache::accessibilityEnabled()) return; if (!m_selection.start().isNotNull() || !m_selection.end().isNotNull()) return; RenderObject* focusedNode = m_selection.end().containerNode()->renderer(); AXObjectCache* cache = m_frame->document()->existingAXObjectCache(); if (!cache) return; AccessibilityObject* accessibilityObject = cache->getOrCreate(focusedNode); if (!accessibilityObject) return; int offset; RefPtr<AccessibilityObject> object = objectFocusedAndCaretOffsetUnignored(accessibilityObject, offset); if (!object) return; emitTextSelectionChange(object.get(), m_selection, offset); maybeEmitTextFocusChange(WTFMove(object)); }
void AccessibilityARIAGrid::addChildren() { ASSERT(!m_haveChildren); if (!isAccessibilityTable()) { AccessibilityRenderObject::addChildren(); return; } m_haveChildren = true; if (!m_renderer) return; AXObjectCache* axCache = m_renderer->document().axObjectCache(); // Add the children rows but be mindful in case there are footer sections in this table. HashSet<AccessibilityObject*> appendedRows; unsigned columnCount = 0; AccessibilityChildrenVector footerSections; for (RefPtr<AccessibilityObject> child = firstChild(); child; child = child->nextSibling()) { bool footerSection = false; if (RenderObject* childRenderer = child->renderer()) { if (childRenderer->isTableSection()) { if (RenderTableSection* childSection = toRenderTableSection(childRenderer)) { if (childSection == childSection->table()->footer()) { footerSections.append(child); footerSection = true; } } } } if (!footerSection) addRowDescendant(child.get(), appendedRows, columnCount); } for (const auto& footerSection : footerSections) addRowDescendant(footerSection.get(), appendedRows, columnCount); // make the columns based on the number of columns in the first body for (unsigned i = 0; i < columnCount; ++i) { AccessibilityTableColumn* column = toAccessibilityTableColumn(axCache->getOrCreate(ColumnRole)); column->setColumnIndex((int)i); column->setParent(this); m_columns.append(column); if (!column->accessibilityIsIgnored()) m_children.append(column); } AccessibilityObject* headerContainerObject = headerContainer(); if (headerContainerObject && !headerContainerObject->accessibilityIsIgnored()) m_children.append(headerContainerObject); }
AccessibilityScrollbar* AccessibilityScrollView::addChildScrollbar(Scrollbar* scrollbar) { if (!scrollbar) return nullptr; AXObjectCache* cache = axObjectCache(); if (!cache) return nullptr; auto& scrollBarObject = downcast<AccessibilityScrollbar>(*cache->getOrCreate(scrollbar)); scrollBarObject.setParent(this); m_children.append(&scrollBarObject); return &scrollBarObject; }
AccessibilityScrollbar* AccessibilityScrollView::addChildScrollbar(Scrollbar* scrollbar) { if (!scrollbar) return nullptr; AXObjectCache* cache = axObjectCache(); if (!cache) return nullptr; AccessibilityScrollbar* scrollBarObject = toAccessibilityScrollbar(cache->getOrCreate(scrollbar)); scrollBarObject->setParent(this); m_children.append(scrollBarObject); return scrollBarObject; }
void AccessibilityARIAGrid::addChildren() { ASSERT(!m_haveChildren); if (!isAccessibilityTable()) { AccessibilityRenderObject::addChildren(); return; } m_haveChildren = true; if (!m_renderer) return; AXObjectCache* axCache = m_renderer->document()->axObjectCache(); // add only rows that are labeled as aria rows HashSet<AccessibilityObject*> appendedRows; unsigned columnCount = 0; for (RefPtr<AccessibilityObject> child = firstChild(); child; child = child->nextSibling()) { if (!addTableCellChild(child.get(), appendedRows, columnCount)) { // in case the render tree doesn't match the expected ARIA hierarchy, look at the children if (!child->hasChildren()) child->addChildren(); // The children of this non-row will contain all non-ignored elements (recursing to find them). // This allows the table to dive arbitrarily deep to find the rows. AccessibilityChildrenVector children = child->children(); size_t length = children.size(); for (size_t i = 0; i < length; ++i) addTableCellChild(children[i].get(), appendedRows, columnCount); } } // make the columns based on the number of columns in the first body for (unsigned i = 0; i < columnCount; ++i) { AccessibilityTableColumn* column = static_cast<AccessibilityTableColumn*>(axCache->getOrCreate(ColumnRole)); column->setColumnIndex((int)i); column->setParent(this); m_columns.append(column); if (!column->accessibilityIsIgnored()) m_children.append(column); } AccessibilityObject* headerContainerObject = headerContainer(); if (headerContainerObject && !headerContainerObject->accessibilityIsIgnored()) m_children.append(headerContainerObject); }
AccessibilityObject* AccessibilityScrollView::parentObject() const { if (!is<FrameView>(m_scrollView)) return nullptr; AXObjectCache* cache = axObjectCache(); if (!cache) return nullptr; HTMLFrameOwnerElement* owner = downcast<FrameView>(*m_scrollView).frame().ownerElement(); if (owner && owner->renderer()) return cache->getOrCreate(owner); return nullptr; }
AccessibilityObject* AccessibilityScrollView::parentObject() const { if (!m_scrollView || !m_scrollView->isFrameView()) return nullptr; AXObjectCache* cache = axObjectCache(); if (!cache) return nullptr; HTMLFrameOwnerElement* owner = toFrameView(m_scrollView)->frame().ownerElement(); if (owner && owner->renderer()) return cache->getOrCreate(owner); return nullptr; }
void AccessibilityTable::addChildren() { if (!isAccessibilityTable()) { AccessibilityRenderObject::addChildren(); return; } ASSERT(!m_haveChildren); m_haveChildren = true; if (!m_renderer || !m_renderer->isTable()) return; RenderTable* table = toRenderTable(m_renderer); // Go through all the available sections to pull out the rows and add them as children. table->recalcSectionsIfNeeded(); unsigned maxColumnCount = 0; RenderTableSection* footer = table->footer(); for (RenderTableSection* tableSection = table->topSection(); tableSection; tableSection = table->sectionBelow(tableSection, SkipEmptySections)) { if (tableSection == footer) continue; addChildrenFromSection(tableSection, maxColumnCount); } // Process the footer last, in case it was ordered earlier in the DOM. if (footer) addChildrenFromSection(footer, maxColumnCount); AXObjectCache* axCache = m_renderer->document().axObjectCache(); // make the columns based on the number of columns in the first body unsigned length = maxColumnCount; for (unsigned i = 0; i < length; ++i) { AccessibilityTableColumn* column = toAccessibilityTableColumn(axCache->getOrCreate(ColumnRole)); column->setColumnIndex((int)i); column->setParent(this); m_columns.append(column); if (!column->accessibilityIsIgnored()) m_children.append(column); } AccessibilityObject* headerContainerObject = headerContainer(); if (headerContainerObject && !headerContainerObject->accessibilityIsIgnored()) m_children.append(headerContainerObject); }
void AccessibilitySlider::addChildren() { ASSERT(!m_haveChildren); m_haveChildren = true; AXObjectCache* cache = m_renderer->document()->axObjectCache(); AccessibilitySliderThumb* thumb = static_cast<AccessibilitySliderThumb*>(cache->getOrCreate(SliderThumbRole)); thumb->setParent(this); // Before actually adding the value indicator to the hierarchy, // allow the platform to make a final decision about it. if (thumb->accessibilityIsIgnored()) cache->remove(thumb->axObjectID()); else m_children.append(thumb); }
static void notifyAccessibilityStatus(WebKitWebFrame* frame, WebKitLoadStatus loadStatus) { if (loadStatus != WEBKIT_LOAD_PROVISIONAL && loadStatus != WEBKIT_LOAD_FAILED && loadStatus != WEBKIT_LOAD_FINISHED) return; WebKitWebFramePrivate* priv = frame->priv; if (!priv->coreFrame || !priv->coreFrame->document()) return; RenderView* contentRenderer = priv->coreFrame->contentRenderer(); if (!contentRenderer) return; AXObjectCache* axObjectCache = priv->coreFrame->document()->axObjectCache(); if (!axObjectCache) return; AccessibilityObject* coreAxObject = axObjectCache->getOrCreate(contentRenderer); if (!coreAxObject) return; AtkObject* axObject = coreAxObject->wrapper(); if (!axObject || !ATK_IS_DOCUMENT(axObject)) return; switch (loadStatus) { case WEBKIT_LOAD_PROVISIONAL: g_signal_emit_by_name(axObject, "state-change", "busy", true); if (core(frame)->loader()->loadType() == FrameLoadTypeReload) g_signal_emit_by_name(axObject, "reload"); break; case WEBKIT_LOAD_FAILED: g_signal_emit_by_name(axObject, "load-stopped"); g_signal_emit_by_name(axObject, "state-change", "busy", false); break; case WEBKIT_LOAD_FINISHED: g_signal_emit_by_name(axObject, "load-complete"); g_signal_emit_by_name(axObject, "state-change", "busy", false); default: break; } }
void AccessibilityMenuList::addChildren() { m_haveChildren = true; AXObjectCache* cache = m_renderer->document().axObjectCache(); AccessibilityObject* list = cache->getOrCreate(MenuListPopupRole); if (!list) return; toAccessibilityMockObject(list)->setParent(this); if (list->accessibilityIsIgnored()) { cache->remove(list->axObjectID()); return; } m_children.append(list); list->addChildren(); }
void AccessibilityMenuList::addChildren() { m_haveChildren = true; AXObjectCache* cache = m_renderer->document()->axObjectCache(); AccessibilityObject* list = cache->getOrCreate(MenuListPopupRole); if (!list) return; if (list->accessibilityPlatformIncludesObject() == IgnoreObject) { cache->remove(list->axObjectID()); return; } static_cast<AccessibilityMenuListPopup*>(list)->setMenuList(this); m_children.append(list); list->addChildren(); }
void AccessibilityTableCell::columnHeaders(AccessibilityChildrenVector& headers) { AccessibilityTable* parent = parentTable(); if (!parent) return; // Choose columnHeaders as the place where the "headers" attribute is reported. AXObjectCache* cache = axObjectCache(); Vector<Element*> elements; elementsFromAttribute(elements, headersAttr); for (auto& element : elements) { if (AccessibilityObject* object = cache->getOrCreate(element)) headers.append(object); } // If the headers attribute returned valid values, then do not further search for column headers. if (!headers.isEmpty()) return; std::pair<unsigned, unsigned> rowRange; rowIndexRange(rowRange); std::pair<unsigned, unsigned> colRange; columnIndexRange(colRange); for (unsigned row = 0; row < rowRange.first; row++) { AccessibilityTableCell* tableCell = parent->cellForColumnAndRow(colRange.first, row); if (tableCell == this || headers.contains(tableCell)) continue; std::pair<unsigned, unsigned> childRowRange; tableCell->rowIndexRange(childRowRange); const AtomicString& scope = tableCell->getAttribute(scopeAttr); if (scope == "col" || tableCell->isTableHeaderCell()) headers.append(tableCell); else if (scope == "colgroup" && isTableCellInSameColGroup(tableCell)) headers.append(tableCell); } }
void AccessibilityTable::addChildrenFromSection(RenderTableSection* tableSection, unsigned& maxColumnCount) { ASSERT(tableSection); if (!tableSection) return; AXObjectCache* axCache = m_renderer->document().axObjectCache(); HashSet<AccessibilityObject*> appendedRows; unsigned numRows = tableSection->numRows(); for (unsigned rowIndex = 0; rowIndex < numRows; ++rowIndex) { RenderTableRow* renderRow = tableSection->rowRendererAt(rowIndex); if (!renderRow) continue; AccessibilityObject* rowObject = axCache->getOrCreate(renderRow); if (!rowObject->isTableRow()) continue; AccessibilityTableRow* row = toAccessibilityTableRow(rowObject); // We need to check every cell for a new row, because cell spans // can cause us to miss rows if we just check the first column. if (appendedRows.contains(row)) continue; row->setRowIndex(static_cast<int>(m_rows.size())); m_rows.append(row); if (!row->accessibilityIsIgnored()) m_children.append(row); #if PLATFORM(GTK) || PLATFORM(EFL) else m_children.appendVector(row->children()); #endif appendedRows.add(row); } maxColumnCount = std::max(tableSection->numColumns(), maxColumnCount); }
void AccessibilityTable::addChildrenFromSection(RenderTableSection* tableSection, unsigned& maxColumnCount) { ASSERT(tableSection); if (!tableSection) return; AXObjectCache* axCache = m_renderer->document().axObjectCache(); HashSet<AccessibilityObject*> appendedRows; unsigned numRows = tableSection->numRows(); for (unsigned rowIndex = 0; rowIndex < numRows; ++rowIndex) { RenderTableRow* renderRow = tableSection->rowRendererAt(rowIndex); if (!renderRow) continue; AccessibilityObject& rowObject = *axCache->getOrCreate(renderRow); // If the row is anonymous, we should dive deeper into the descendants to try to find a valid row. if (renderRow->isAnonymous()) { Deque<AccessibilityObject*> queue; queue.append(&rowObject); while (!queue.isEmpty()) { AccessibilityObject* obj = queue.takeFirst(); if (obj->node() && is<AccessibilityTableRow>(*obj)) { addTableCellChild(obj, appendedRows, maxColumnCount); continue; } for (auto child = obj->firstChild(); child; child = child->nextSibling()) queue.append(child); } } else addTableCellChild(&rowObject, appendedRows, maxColumnCount); } maxColumnCount = std::max(tableSection->numColumns(), maxColumnCount); }
void AccessibilityTable::addChildren() { if (!isAccessibilityTable()) { AccessibilityRenderObject::addChildren(); return; } ASSERT(!m_haveChildren); m_haveChildren = true; if (!m_renderer || !m_renderer->isTable()) return; RenderTable* table = toRenderTable(m_renderer); AXObjectCache* axCache = m_renderer->document().axObjectCache(); // Go through all the available sections to pull out the rows and add them as children. table->recalcSectionsIfNeeded(); RenderTableSection* tableSection = table->topSection(); if (!tableSection) return; unsigned maxColumnCount = 0; while (tableSection) { HashSet<AccessibilityObject*> appendedRows; unsigned numRows = tableSection->numRows(); for (unsigned rowIndex = 0; rowIndex < numRows; ++rowIndex) { RenderTableRow* renderRow = tableSection->rowRendererAt(rowIndex); if (!renderRow) continue; AccessibilityObject* rowObject = axCache->getOrCreate(renderRow); if (!rowObject->isTableRow()) continue; AccessibilityTableRow* row = toAccessibilityTableRow(rowObject); // We need to check every cell for a new row, because cell spans // can cause us to miss rows if we just check the first column. if (appendedRows.contains(row)) continue; row->setRowIndex(static_cast<int>(m_rows.size())); m_rows.append(row); if (!row->accessibilityIsIgnored()) m_children.append(row); #if PLATFORM(GTK) || PLATFORM(EFL) else m_children.appendVector(row->children()); #endif appendedRows.add(row); } maxColumnCount = std::max(tableSection->numColumns(), maxColumnCount); tableSection = table->sectionBelow(tableSection, SkipEmptySections); } // make the columns based on the number of columns in the first body unsigned length = maxColumnCount; for (unsigned i = 0; i < length; ++i) { AccessibilityTableColumn* column = toAccessibilityTableColumn(axCache->getOrCreate(ColumnRole)); column->setColumnIndex((int)i); column->setParent(this); m_columns.append(column); if (!column->accessibilityIsIgnored()) m_children.append(column); } AccessibilityObject* headerContainerObject = headerContainer(); if (headerContainerObject && !headerContainerObject->accessibilityIsIgnored()) m_children.append(headerContainerObject); }
void AccessibilityTable::addChildren() { if (!isExposableThroughAccessibility()) { AccessibilityRenderObject::addChildren(); return; } ASSERT(!m_haveChildren); m_haveChildren = true; if (!is<RenderTable>(m_renderer)) return; RenderTable& table = downcast<RenderTable>(*m_renderer); // Go through all the available sections to pull out the rows and add them as children. table.recalcSectionsIfNeeded(); if (HTMLTableElement* tableElement = this->tableElement()) { if (HTMLTableCaptionElement* caption = tableElement->caption()) { AccessibilityObject* axCaption = axObjectCache()->getOrCreate(caption); if (axCaption && !axCaption->accessibilityIsIgnored()) m_children.append(axCaption); } } unsigned maxColumnCount = 0; RenderTableSection* footer = table.footer(); for (RenderTableSection* tableSection = table.topSection(); tableSection; tableSection = table.sectionBelow(tableSection, SkipEmptySections)) { if (tableSection == footer) continue; addChildrenFromSection(tableSection, maxColumnCount); } // Process the footer last, in case it was ordered earlier in the DOM. if (footer) addChildrenFromSection(footer, maxColumnCount); AXObjectCache* axCache = m_renderer->document().axObjectCache(); // make the columns based on the number of columns in the first body unsigned length = maxColumnCount; for (unsigned i = 0; i < length; ++i) { auto& column = downcast<AccessibilityTableColumn>(*axCache->getOrCreate(ColumnRole)); column.setColumnIndex((int)i); column.setParent(this); m_columns.append(&column); if (!column.accessibilityIsIgnored()) m_children.append(&column); } AccessibilityObject* headerContainerObject = headerContainer(); if (headerContainerObject && !headerContainerObject->accessibilityIsIgnored()) m_children.append(headerContainerObject); // Sometimes the cell gets the wrong role initially because it is created before the parent // determines whether it is an accessibility table. Iterate all the cells and allow them to // update their roles now that the table knows its status. // see bug: https://bugs.webkit.org/show_bug.cgi?id=147001 for (const auto& row : m_rows) { for (const auto& cell : row->children()) cell->updateAccessibilityRole(); } }
void AccessibilityTable::addChildren() { if (!isAccessibilityTable()) { AccessibilityRenderObject::addChildren(); return; } ASSERT(!m_haveChildren); m_haveChildren = true; if (!m_renderer || !m_renderer->isTable()) return; RenderTable* table = toRenderTable(m_renderer); AXObjectCache* axCache = m_renderer->document()->axObjectCache(); // go through all the available sections to pull out the rows // and add them as children // FIXME: This will skip a table with just a tfoot. Should fix by using RenderTable::topSection. RenderTableSection* tableSection = table->header(); if (!tableSection) tableSection = table->firstBody(); if (!tableSection) return; RenderTableSection* initialTableSection = tableSection; while (tableSection) { HashSet<AccessibilityObject*> appendedRows; unsigned numRows = tableSection->numRows(); unsigned numCols = tableSection->numColumns(); for (unsigned rowIndex = 0; rowIndex < numRows; ++rowIndex) { for (unsigned colIndex = 0; colIndex < numCols; ++colIndex) { RenderTableCell* cell = tableSection->primaryCellAt(rowIndex, colIndex); if (!cell) continue; AccessibilityObject* rowObject = axCache->getOrCreate(cell->parent()); if (!rowObject->isTableRow()) continue; AccessibilityTableRow* row = static_cast<AccessibilityTableRow*>(rowObject); // we need to check every cell for a new row, because cell spans // can cause us to mess rows if we just check the first column if (appendedRows.contains(row)) continue; row->setRowIndex((int)m_rows.size()); m_rows.append(row); if (!row->accessibilityIsIgnored()) m_children.append(row); #if PLATFORM(GTK) else m_children.append(row->children()); #endif appendedRows.add(row); } } tableSection = table->sectionBelow(tableSection, SkipEmptySections); } // make the columns based on the number of columns in the first body unsigned length = initialTableSection->numColumns(); for (unsigned i = 0; i < length; ++i) { AccessibilityTableColumn* column = static_cast<AccessibilityTableColumn*>(axCache->getOrCreate(ColumnRole)); column->setColumnIndex((int)i); column->setParent(this); m_columns.append(column); if (!column->accessibilityIsIgnored()) m_children.append(column); } AccessibilityObject* headerContainerObject = headerContainer(); if (headerContainerObject && !headerContainerObject->accessibilityIsIgnored()) m_children.append(headerContainerObject); }