KotJohansson
/
UXP
mirror of https://github.com/roytam1/UXP
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Mirror of roytam1's UXP fork just in case Moonchild and Tobin decide to go after him
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2139 Commits
6 Branches
0 Tags
495 MiB
 
 
 
 
 
 
Tree: aea50f182f
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'aea50f182f'
${ noResults }
UXP/accessible/base/nsAccessibilityService.cpp

1872 lines
61 KiB
Raw Blame History

/* -*- 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 "nsAccessibilityService.h"
// NOTE: alphabetically ordered
#include "ApplicationAccessibleWrap.h"
#include "ARIAGridAccessibleWrap.h"
#include "ARIAMap.h"
#include "DocAccessible-inl.h"
#include "FocusManager.h"
#include "HTMLCanvasAccessible.h"
#include "HTMLElementAccessibles.h"
#include "HTMLImageMapAccessible.h"
#include "HTMLLinkAccessible.h"
#include "HTMLListAccessible.h"
#include "HTMLSelectAccessible.h"
#include "HTMLTableAccessibleWrap.h"
#include "HyperTextAccessibleWrap.h"
#include "RootAccessible.h"
#include "nsAccUtils.h"
#include "nsArrayUtils.h"
#include "nsAttrName.h"
#include "nsEventShell.h"
#include "nsIURI.h"
#include "OuterDocAccessible.h"
#include "Platform.h"
#include "Role.h"
#ifdef MOZ_ACCESSIBILITY_ATK
#include "RootAccessibleWrap.h"
#endif
#include "States.h"
#include "TextLeafAccessibleWrap.h"
#include "TreeWalker.h"
#include "xpcAccessibleApplication.h"
#include "xpcAccessibleDocument.h"
#ifdef MOZ_ACCESSIBILITY_ATK
#include "AtkSocketAccessible.h"
#endif
#ifdef XP_WIN
#include "mozilla/a11y/Compatibility.h"
#include "mozilla/dom/ContentChild.h"
#include "HTMLWin32ObjectAccessible.h"
#include "mozilla/StaticPtr.h"
#endif
#ifdef A11Y_LOG
#include "Logging.h"
#endif
#include "nsImageFrame.h"
#include "nsIObserverService.h"
#include "nsLayoutUtils.h"
#include "nsPluginFrame.h"
#include "nsSVGPathGeometryFrame.h"
#include "nsTreeBodyFrame.h"
#include "nsTreeColumns.h"
#include "nsTreeUtils.h"
#include "nsXBLPrototypeBinding.h"
#include "nsXBLBinding.h"
#include "mozilla/ArrayUtils.h"
#include "mozilla/dom/DOMStringList.h"
#include "mozilla/Preferences.h"
#include "mozilla/Services.h"
#include "nsDeckFrame.h"
#ifdef MOZ_XUL
#include "XULAlertAccessible.h"
#include "XULColorPickerAccessible.h"
#include "XULComboboxAccessible.h"
#include "XULElementAccessibles.h"
#include "XULFormControlAccessible.h"
#include "XULListboxAccessibleWrap.h"
#include "XULMenuAccessibleWrap.h"
#include "XULSliderAccessible.h"
#include "XULTabAccessible.h"
#include "XULTreeGridAccessibleWrap.h"
#endif
#if defined(XP_WIN) || defined(MOZ_ACCESSIBILITY_ATK)
#include "nsNPAPIPluginInstance.h"
#endif
using namespace mozilla;
using namespace mozilla::a11y;
using namespace mozilla::dom;
////////////////////////////////////////////////////////////////////////////////
// Statics
////////////////////////////////////////////////////////////////////////////////
/**
* Return true if the element must be accessible.
*/
static bool
MustBeAccessible(nsIContent* aContent, DocAccessible* aDocument)
{
if (aContent->GetPrimaryFrame()->IsFocusable())
return true;
uint32_t attrCount = aContent->GetAttrCount();
for (uint32_t attrIdx = 0; attrIdx < attrCount; attrIdx++) {
const nsAttrName* attr = aContent->GetAttrNameAt(attrIdx);
if (attr->NamespaceEquals(kNameSpaceID_None)) {
nsIAtom* attrAtom = attr->Atom();
nsDependentAtomString attrStr(attrAtom);
if (!StringBeginsWith(attrStr, NS_LITERAL_STRING("aria-")))
continue; // not ARIA
// A global state or a property and in case of token defined.
uint8_t attrFlags = aria::AttrCharacteristicsFor(attrAtom);
if ((attrFlags & ATTR_GLOBAL) && (!(attrFlags & ATTR_VALTOKEN) ||
nsAccUtils::HasDefinedARIAToken(aContent, attrAtom))) {
return true;
}
}
}
// If the given ID is referred by relation attribute then create an accessible
// for it.
nsAutoString id;
if (nsCoreUtils::GetID(aContent, id) && !id.IsEmpty())
return aDocument->IsDependentID(id);
return false;
}
////////////////////////////////////////////////////////////////////////////////
// Accessible constructors
static Accessible*
New_HTMLLink(nsIContent* aContent, Accessible* aContext)
{
// Only some roles truly enjoy life as HTMLLinkAccessibles, for details
// see closed bug 494807.
const nsRoleMapEntry* roleMapEntry = aria::GetRoleMap(aContent->AsElement());
if (roleMapEntry && roleMapEntry->role != roles::NOTHING &&
roleMapEntry->role != roles::LINK) {
return new HyperTextAccessibleWrap(aContent, aContext->Document());
}
return new HTMLLinkAccessible(aContent, aContext->Document());
}
static Accessible* New_HyperText(nsIContent* aContent, Accessible* aContext)
{ return new HyperTextAccessibleWrap(aContent, aContext->Document()); }
static Accessible* New_HTMLFigcaption(nsIContent* aContent, Accessible* aContext)
{ return new HTMLFigcaptionAccessible(aContent, aContext->Document()); }
static Accessible* New_HTMLFigure(nsIContent* aContent, Accessible* aContext)
{ return new HTMLFigureAccessible(aContent, aContext->Document()); }
static Accessible* New_HTMLLegend(nsIContent* aContent, Accessible* aContext)
{ return new HTMLLegendAccessible(aContent, aContext->Document()); }
static Accessible* New_HTMLOption(nsIContent* aContent, Accessible* aContext)
{ return new HTMLSelectOptionAccessible(aContent, aContext->Document()); }
static Accessible* New_HTMLOptgroup(nsIContent* aContent, Accessible* aContext)
{ return new HTMLSelectOptGroupAccessible(aContent, aContext->Document()); }
static Accessible* New_HTMLList(nsIContent* aContent, Accessible* aContext)
{ return new HTMLListAccessible(aContent, aContext->Document()); }
static Accessible*
New_HTMLListitem(nsIContent* aContent, Accessible* aContext)
{
// If list item is a child of accessible list then create an accessible for
// it unconditionally by tag name. nsBlockFrame creates the list item
// accessible for other elements styled as list items.
if (aContext->IsList() && aContext->GetContent() == aContent->GetParent())
return new HTMLLIAccessible(aContent, aContext->Document());
return nullptr;
}
static Accessible*
New_HTMLDefinition(nsIContent* aContent, Accessible* aContext)
{
if (aContext->IsList())
return new HyperTextAccessibleWrap(aContent, aContext->Document());
return nullptr;
}
static Accessible* New_HTMLLabel(nsIContent* aContent, Accessible* aContext)
{ return new HTMLLabelAccessible(aContent, aContext->Document()); }
static Accessible* New_HTMLOutput(nsIContent* aContent, Accessible* aContext)
{ return new HTMLOutputAccessible(aContent, aContext->Document()); }
static Accessible* New_HTMLProgress(nsIContent* aContent, Accessible* aContext)
{ return new HTMLProgressMeterAccessible(aContent, aContext->Document()); }
static Accessible* New_HTMLSummary(nsIContent* aContent, Accessible* aContext)
{ return new HTMLSummaryAccessible(aContent, aContext->Document()); }
static Accessible*
New_HTMLTableAccessible(nsIContent* aContent, Accessible* aContext)
{ return new HTMLTableAccessible(aContent, aContext->Document()); }
static Accessible*
New_HTMLTableRowAccessible(nsIContent* aContent, Accessible* aContext)
{ return new HTMLTableRowAccessible(aContent, aContext->Document()); }
static Accessible*
New_HTMLTableCellAccessible(nsIContent* aContent, Accessible* aContext)
{ return new HTMLTableCellAccessible(aContent, aContext->Document()); }
static Accessible*
New_HTMLTableHeaderCell(nsIContent* aContent, Accessible* aContext)
{
if (aContext->IsTableRow() && aContext->GetContent() == aContent->GetParent())
return new HTMLTableHeaderCellAccessibleWrap(aContent, aContext->Document());
return nullptr;
}
static Accessible*
New_HTMLTableHeaderCellIfScope(nsIContent* aContent, Accessible* aContext)
{
if (aContext->IsTableRow() && aContext->GetContent() == aContent->GetParent() &&
aContent->HasAttr(kNameSpaceID_None, nsGkAtoms::scope))
return new HTMLTableHeaderCellAccessibleWrap(aContent, aContext->Document());
return nullptr;
}
////////////////////////////////////////////////////////////////////////////////
// Markup maps array.
#define Attr(name, value) \
{ &nsGkAtoms::name, &nsGkAtoms::value }
#define AttrFromDOM(name, DOMAttrName) \
{ &nsGkAtoms::name, nullptr, &nsGkAtoms::DOMAttrName }
#define AttrFromDOMIf(name, DOMAttrName, DOMAttrValue) \
{ &nsGkAtoms::name, nullptr, &nsGkAtoms::DOMAttrName, &nsGkAtoms::DOMAttrValue }
#define MARKUPMAP(atom, new_func, r, ... ) \
{ &nsGkAtoms::atom, new_func, static_cast<a11y::role>(r), { __VA_ARGS__ } },
static const MarkupMapInfo sMarkupMapList[] = {
#include "MarkupMap.h"
};
#undef Attr
#undef AttrFromDOM
#undef AttrFromDOMIf
#undef MARKUPMAP
////////////////////////////////////////////////////////////////////////////////
// nsAccessibilityService
////////////////////////////////////////////////////////////////////////////////
nsAccessibilityService *nsAccessibilityService::gAccessibilityService = nullptr;
ApplicationAccessible* nsAccessibilityService::gApplicationAccessible = nullptr;
xpcAccessibleApplication* nsAccessibilityService::gXPCApplicationAccessible = nullptr;
uint32_t nsAccessibilityService::gConsumers = 0;
nsAccessibilityService::nsAccessibilityService() :
DocManager(), FocusManager(), mMarkupMaps(ArrayLength(sMarkupMapList))
{
}
nsAccessibilityService::~nsAccessibilityService()
{
NS_ASSERTION(IsShutdown(), "Accessibility wasn't shutdown!");
gAccessibilityService = nullptr;
}
////////////////////////////////////////////////////////////////////////////////
// nsIListenerChangeListener
NS_IMETHODIMP
nsAccessibilityService::ListenersChanged(nsIArray* aEventChanges)
{
uint32_t targetCount;
nsresult rv = aEventChanges->GetLength(&targetCount);
NS_ENSURE_SUCCESS(rv, rv);
for (uint32_t i = 0 ; i < targetCount ; i++) {
nsCOMPtr<nsIEventListenerChange> change = do_QueryElementAt(aEventChanges, i);
nsCOMPtr<nsIDOMEventTarget> target;
change->GetTarget(getter_AddRefs(target));
nsCOMPtr<nsIContent> node(do_QueryInterface(target));
if (!node || !node->IsHTMLElement()) {
continue;
}
nsCOMPtr<nsIArray> listenerNames;
change->GetChangedListenerNames(getter_AddRefs(listenerNames));
uint32_t changeCount;
rv = listenerNames->GetLength(&changeCount);
NS_ENSURE_SUCCESS(rv, rv);
for (uint32_t i = 0 ; i < changeCount ; i++) {
nsCOMPtr<nsIAtom> listenerName = do_QueryElementAt(listenerNames, i);
// We are only interested in event listener changes which may
// make an element accessible or inaccessible.
if (listenerName != nsGkAtoms::onclick &&
listenerName != nsGkAtoms::onmousedown &&
listenerName != nsGkAtoms::onmouseup) {
continue;
}
nsIDocument* ownerDoc = node->OwnerDoc();
DocAccessible* document = GetExistingDocAccessible(ownerDoc);
// Create an accessible for a inaccessible element having click event
// handler.
if (document && !document->HasAccessible(node) &&
nsCoreUtils::HasClickListener(node)) {
nsIContent* parentEl = node->GetFlattenedTreeParent();
if (parentEl) {
document->ContentInserted(parentEl, node, node->GetNextSibling());
}
break;
}
}
}
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
// nsISupports
NS_IMPL_ISUPPORTS_INHERITED(nsAccessibilityService,
DocManager,
nsIObserver,
nsIListenerChangeListener,
nsISelectionListener) // from SelectionManager
////////////////////////////////////////////////////////////////////////////////
// nsIObserver
NS_IMETHODIMP
nsAccessibilityService::Observe(nsISupports *aSubject, const char *aTopic,
const char16_t *aData)
{
if (!nsCRT::strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID))
Shutdown();
return NS_OK;
}
void
nsAccessibilityService::NotifyOfAnchorJumpTo(nsIContent* aTargetNode)
{
nsIDocument* documentNode = aTargetNode->GetUncomposedDoc();
if (documentNode) {
DocAccessible* document = GetDocAccessible(documentNode);
if (document)
document->SetAnchorJump(aTargetNode);
}
}
void
nsAccessibilityService::FireAccessibleEvent(uint32_t aEvent,
Accessible* aTarget)
{
nsEventShell::FireEvent(aEvent, aTarget);
}
Accessible*
nsAccessibilityService::GetRootDocumentAccessible(nsIPresShell* aPresShell,
bool aCanCreate)
{
nsIPresShell* ps = aPresShell;
nsIDocument* documentNode = aPresShell->GetDocument();
if (documentNode) {
nsCOMPtr<nsIDocShellTreeItem> treeItem(documentNode->GetDocShell());
if (treeItem) {
nsCOMPtr<nsIDocShellTreeItem> rootTreeItem;
treeItem->GetRootTreeItem(getter_AddRefs(rootTreeItem));
if (treeItem != rootTreeItem) {
nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(rootTreeItem));
ps = docShell->GetPresShell();
}
return aCanCreate ? GetDocAccessible(ps) : ps->GetDocAccessible();
}
}
return nullptr;
}
#ifdef XP_WIN
static StaticAutoPtr<nsTArray<nsCOMPtr<nsIContent> > > sPendingPlugins;
static StaticAutoPtr<nsTArray<nsCOMPtr<nsITimer> > > sPluginTimers;
class PluginTimerCallBack final : public nsITimerCallback
{
~PluginTimerCallBack() {}
public:
PluginTimerCallBack(nsIContent* aContent) : mContent(aContent) {}
NS_DECL_ISUPPORTS
NS_IMETHOD Notify(nsITimer* aTimer) final
{
if (!mContent->IsInUncomposedDoc())
return NS_OK;
nsIPresShell* ps = mContent->OwnerDoc()->GetShell();
if (ps) {
DocAccessible* doc = ps->GetDocAccessible();
if (doc) {
// Make sure that if we created an accessible for the plugin that wasn't
// a plugin accessible we remove it before creating the right accessible.
doc->RecreateAccessible(mContent);
sPluginTimers->RemoveElement(aTimer);
return NS_OK;
}
}
// We couldn't get a doc accessible so presumably the document went away.
// In this case don't leak our ref to the content or timer.
sPendingPlugins->RemoveElement(mContent);
sPluginTimers->RemoveElement(aTimer);
return NS_OK;
}
private:
nsCOMPtr<nsIContent> mContent;
};
NS_IMPL_ISUPPORTS(PluginTimerCallBack, nsITimerCallback)
#endif
already_AddRefed<Accessible>
nsAccessibilityService::CreatePluginAccessible(nsPluginFrame* aFrame,
nsIContent* aContent,
Accessible* aContext)
{
// nsPluginFrame means a plugin, so we need to use the accessibility support
// of the plugin.
if (aFrame->GetRect().IsEmpty())
return nullptr;
#if defined(XP_WIN) || defined(MOZ_ACCESSIBILITY_ATK)
RefPtr<nsNPAPIPluginInstance> pluginInstance;
if (NS_SUCCEEDED(aFrame->GetPluginInstance(getter_AddRefs(pluginInstance))) &&
pluginInstance) {
#ifdef XP_WIN
if (!sPendingPlugins->Contains(aContent) &&
(Preferences::GetBool("accessibility.delay_plugins") ||
Compatibility::IsJAWS() || Compatibility::IsWE())) {
nsCOMPtr<nsITimer> timer = do_CreateInstance(NS_TIMER_CONTRACTID);
RefPtr<PluginTimerCallBack> cb = new PluginTimerCallBack(aContent);
timer->InitWithCallback(cb, Preferences::GetUint("accessibility.delay_plugin_time"),
nsITimer::TYPE_ONE_SHOT);
sPluginTimers->AppendElement(timer);
sPendingPlugins->AppendElement(aContent);
return nullptr;
}
// We need to remove aContent from the pending plugins here to avoid
// reentrancy. When the timer fires it calls
// DocAccessible::ContentInserted() which does the work async.
sPendingPlugins->RemoveElement(aContent);
// Note: pluginPort will be null if windowless.
HWND pluginPort = nullptr;
aFrame->GetPluginPort(&pluginPort);
RefPtr<Accessible> accessible =
new HTMLWin32ObjectOwnerAccessible(aContent, aContext->Document(),
pluginPort);
return accessible.forget();
#elif MOZ_ACCESSIBILITY_ATK
if (!AtkSocketAccessible::gCanEmbed)
return nullptr;
// Note this calls into the plugin, so crazy things may happen and aFrame
// may go away.
nsCString plugId;
nsresult rv = pluginInstance->GetValueFromPlugin(
NPPVpluginNativeAccessibleAtkPlugId, &plugId);
if (NS_SUCCEEDED(rv) && !plugId.IsEmpty()) {
RefPtr<AtkSocketAccessible> socketAccessible =
new AtkSocketAccessible(aContent, aContext->Document(), plugId);
return socketAccessible.forget();
}
#endif
}
#endif
return nullptr;
}
void
nsAccessibilityService::DeckPanelSwitched(nsIPresShell* aPresShell,
nsIContent* aDeckNode,
nsIFrame* aPrevBoxFrame,
nsIFrame* aCurrentBoxFrame)
{
// Ignore tabpanels elements (a deck having an accessible) since their
// children are accessible not depending on selected tab.
DocAccessible* document = GetDocAccessible(aPresShell);
if (!document || document->HasAccessible(aDeckNode))
return;
if (aPrevBoxFrame) {
nsIContent* panelNode = aPrevBoxFrame->GetContent();
#ifdef A11Y_LOG
if (logging::IsEnabled(logging::eTree)) {
logging::MsgBegin("TREE", "deck panel unselected");
logging::Node("container", panelNode);
logging::Node("content", aDeckNode);
logging::MsgEnd();
}
#endif
document->ContentRemoved(aDeckNode, panelNode);
}
if (aCurrentBoxFrame) {
nsIContent* panelNode = aCurrentBoxFrame->GetContent();
#ifdef A11Y_LOG
if (logging::IsEnabled(logging::eTree)) {
logging::MsgBegin("TREE", "deck panel selected");
logging::Node("container", panelNode);
logging::Node("content", aDeckNode);
logging::MsgEnd();
}
#endif
document->ContentInserted(aDeckNode, panelNode, panelNode->GetNextSibling());
}
}
void
nsAccessibilityService::ContentRangeInserted(nsIPresShell* aPresShell,
nsIContent* aContainer,
nsIContent* aStartChild,
nsIContent* aEndChild)
{
DocAccessible* document = GetDocAccessible(aPresShell);
#ifdef A11Y_LOG
if (logging::IsEnabled(logging::eTree)) {
logging::MsgBegin("TREE", "content inserted; doc: %p", document);
logging::Node("container", aContainer);
for (nsIContent* child = aStartChild; child != aEndChild;
child = child->GetNextSibling()) {
logging::Node("content", child);
}
logging::MsgEnd();
logging::Stack();
}
#endif
if (document) {
document->ContentInserted(aContainer, aStartChild, aEndChild);
}
}
void
nsAccessibilityService::ContentRemoved(nsIPresShell* aPresShell,
nsIContent* aChildNode)
{
DocAccessible* document = GetDocAccessible(aPresShell);
#ifdef A11Y_LOG
if (logging::IsEnabled(logging::eTree)) {
logging::MsgBegin("TREE", "content removed; doc: %p", document);
logging::Node("container node", aChildNode->GetFlattenedTreeParent());
logging::Node("content node", aChildNode);
logging::MsgEnd();
}
#endif
if (document) {
// Flatten hierarchy may be broken at this point so we cannot get a true
// container by traversing up the DOM tree. Find a parent of first accessible
// from the subtree of the given DOM node, that'll be a container. If no
// accessibles in subtree then we don't care about the change.
Accessible* child = document->GetAccessible(aChildNode);
if (!child) {
Accessible* container = document->GetContainerAccessible(aChildNode);
a11y::TreeWalker walker(container ? container : document, aChildNode,
a11y::TreeWalker::eWalkCache);
child = walker.Next();
}
if (child) {
document->ContentRemoved(child->Parent(), aChildNode);
#ifdef A11Y_LOG
if (logging::IsEnabled(logging::eTree))
logging::AccessibleNNode("real container", child->Parent());
#endif
}
}
#ifdef A11Y_LOG
if (logging::IsEnabled(logging::eTree)) {
logging::MsgEnd();
logging::Stack();
}
#endif
}
void
nsAccessibilityService::UpdateText(nsIPresShell* aPresShell,
nsIContent* aContent)
{
DocAccessible* document = GetDocAccessible(aPresShell);
if (document)
document->UpdateText(aContent);
}
void
nsAccessibilityService::TreeViewChanged(nsIPresShell* aPresShell,
nsIContent* aContent,
nsITreeView* aView)
{
DocAccessible* document = GetDocAccessible(aPresShell);
if (document) {
Accessible* accessible = document->GetAccessible(aContent);
if (accessible) {
XULTreeAccessible* treeAcc = accessible->AsXULTree();
if (treeAcc)
treeAcc->TreeViewChanged(aView);
}
}
}
void
nsAccessibilityService::RangeValueChanged(nsIPresShell* aPresShell,
nsIContent* aContent)
{
DocAccessible* document = GetDocAccessible(aPresShell);
if (document) {
Accessible* accessible = document->GetAccessible(aContent);
if (accessible) {
document->FireDelayedEvent(nsIAccessibleEvent::EVENT_VALUE_CHANGE,
accessible);
}
}
}
void
nsAccessibilityService::UpdateListBullet(nsIPresShell* aPresShell,
nsIContent* aHTMLListItemContent,
bool aHasBullet)
{
DocAccessible* document = GetDocAccessible(aPresShell);
if (document) {
Accessible* accessible = document->GetAccessible(aHTMLListItemContent);
if (accessible) {
HTMLLIAccessible* listItem = accessible->AsHTMLListItem();
if (listItem)
listItem->UpdateBullet(aHasBullet);
}
}
}
void
nsAccessibilityService::UpdateImageMap(nsImageFrame* aImageFrame)
{
nsIPresShell* presShell = aImageFrame->PresContext()->PresShell();
DocAccessible* document = GetDocAccessible(presShell);
if (document) {
Accessible* accessible =
document->GetAccessible(aImageFrame->GetContent());
if (accessible) {
HTMLImageMapAccessible* imageMap = accessible->AsImageMap();
if (imageMap) {
imageMap->UpdateChildAreas();
return;
}
// If image map was initialized after we created an accessible (that'll
// be an image accessible) then recreate it.
RecreateAccessible(presShell, aImageFrame->GetContent());
}
}
}
void
nsAccessibilityService::UpdateLabelValue(nsIPresShell* aPresShell,
nsIContent* aLabelElm,
const nsString& aNewValue)
{
DocAccessible* document = GetDocAccessible(aPresShell);
if (document) {
Accessible* accessible = document->GetAccessible(aLabelElm);
if (accessible) {
XULLabelAccessible* xulLabel = accessible->AsXULLabel();
NS_ASSERTION(xulLabel,
"UpdateLabelValue was called for wrong accessible!");
if (xulLabel)
xulLabel->UpdateLabelValue(aNewValue);
}
}
}
void
nsAccessibilityService::PresShellActivated(nsIPresShell* aPresShell)
{
DocAccessible* document = aPresShell->GetDocAccessible();
if (document) {
RootAccessible* rootDocument = document->RootAccessible();
NS_ASSERTION(rootDocument, "Entirely broken tree: no root document!");
if (rootDocument)
rootDocument->DocumentActivated(document);
}
}
void
nsAccessibilityService::RecreateAccessible(nsIPresShell* aPresShell,
nsIContent* aContent)
{
DocAccessible* document = GetDocAccessible(aPresShell);
if (document)
document->RecreateAccessible(aContent);
}
void
nsAccessibilityService::GetStringRole(uint32_t aRole, nsAString& aString)
{
#define ROLE(geckoRole, stringRole, atkRole, \
macRole, msaaRole, ia2Role, nameRule) \
case roles::geckoRole: \
CopyUTF8toUTF16(stringRole, aString); \
return;
switch (aRole) {
#include "RoleMap.h"
default:
aString.AssignLiteral("unknown");
return;
}
#undef ROLE
}
void
nsAccessibilityService::GetStringStates(uint32_t aState, uint32_t aExtraState,
nsISupports **aStringStates)
{
RefPtr<DOMStringList> stringStates = new DOMStringList();
uint64_t state = nsAccUtils::To64State(aState, aExtraState);
// states
if (state & states::UNAVAILABLE) {
stringStates->Add(NS_LITERAL_STRING("unavailable"));
}
if (state & states::SELECTED) {
stringStates->Add(NS_LITERAL_STRING("selected"));
}
if (state & states::FOCUSED) {
stringStates->Add(NS_LITERAL_STRING("focused"));
}
if (state & states::PRESSED) {
stringStates->Add(NS_LITERAL_STRING("pressed"));
}
if (state & states::CHECKED) {
stringStates->Add(NS_LITERAL_STRING("checked"));
}
if (state & states::MIXED) {
stringStates->Add(NS_LITERAL_STRING("mixed"));
}
if (state & states::READONLY) {
stringStates->Add(NS_LITERAL_STRING("readonly"));
}
if (state & states::HOTTRACKED) {
stringStates->Add(NS_LITERAL_STRING("hottracked"));
}
if (state & states::DEFAULT) {
stringStates->Add(NS_LITERAL_STRING("default"));
}
if (state & states::EXPANDED) {
stringStates->Add(NS_LITERAL_STRING("expanded"));
}
if (state & states::COLLAPSED) {
stringStates->Add(NS_LITERAL_STRING("collapsed"));
}
if (state & states::BUSY) {
stringStates->Add(NS_LITERAL_STRING("busy"));
}
if (state & states::FLOATING) {
stringStates->Add(NS_LITERAL_STRING("floating"));
}
if (state & states::ANIMATED) {
stringStates->Add(NS_LITERAL_STRING("animated"));
}
if (state & states::INVISIBLE) {
stringStates->Add(NS_LITERAL_STRING("invisible"));
}
if (state & states::OFFSCREEN) {
stringStates->Add(NS_LITERAL_STRING("offscreen"));
}
if (state & states::SIZEABLE) {
stringStates->Add(NS_LITERAL_STRING("sizeable"));
}
if (state & states::MOVEABLE) {
stringStates->Add(NS_LITERAL_STRING("moveable"));
}
if (state & states::SELFVOICING) {
stringStates->Add(NS_LITERAL_STRING("selfvoicing"));
}
if (state & states::FOCUSABLE) {
stringStates->Add(NS_LITERAL_STRING("focusable"));
}
if (state & states::SELECTABLE) {
stringStates->Add(NS_LITERAL_STRING("selectable"));
}
if (state & states::LINKED) {
stringStates->Add(NS_LITERAL_STRING("linked"));
}
if (state & states::TRAVERSED) {
stringStates->Add(NS_LITERAL_STRING("traversed"));
}
if (state & states::MULTISELECTABLE) {
stringStates->Add(NS_LITERAL_STRING("multiselectable"));
}
if (state & states::EXTSELECTABLE) {
stringStates->Add(NS_LITERAL_STRING("extselectable"));
}
if (state & states::PROTECTED) {
stringStates->Add(NS_LITERAL_STRING("protected"));
}
if (state & states::HASPOPUP) {
stringStates->Add(NS_LITERAL_STRING("haspopup"));
}
if (state & states::REQUIRED) {
stringStates->Add(NS_LITERAL_STRING("required"));
}
if (state & states::ALERT) {
stringStates->Add(NS_LITERAL_STRING("alert"));
}
if (state & states::INVALID) {
stringStates->Add(NS_LITERAL_STRING("invalid"));
}
if (state & states::CHECKABLE) {
stringStates->Add(NS_LITERAL_STRING("checkable"));
}
// extraStates
if (state & states::SUPPORTS_AUTOCOMPLETION) {
stringStates->Add(NS_LITERAL_STRING("autocompletion"));
}
if (state & states::DEFUNCT) {
stringStates->Add(NS_LITERAL_STRING("defunct"));
}
if (state & states::SELECTABLE_TEXT) {
stringStates->Add(NS_LITERAL_STRING("selectable text"));
}
if (state & states::EDITABLE) {
stringStates->Add(NS_LITERAL_STRING("editable"));
}
if (state & states::ACTIVE) {
stringStates->Add(NS_LITERAL_STRING("active"));
}
if (state & states::MODAL) {
stringStates->Add(NS_LITERAL_STRING("modal"));
}
if (state & states::MULTI_LINE) {
stringStates->Add(NS_LITERAL_STRING("multi line"));
}
if (state & states::HORIZONTAL) {
stringStates->Add(NS_LITERAL_STRING("horizontal"));
}
if (state & states::OPAQUE1) {
stringStates->Add(NS_LITERAL_STRING("opaque"));
}
if (state & states::SINGLE_LINE) {
stringStates->Add(NS_LITERAL_STRING("single line"));
}
if (state & states::TRANSIENT) {
stringStates->Add(NS_LITERAL_STRING("transient"));
}
if (state & states::VERTICAL) {
stringStates->Add(NS_LITERAL_STRING("vertical"));
}
if (state & states::STALE) {
stringStates->Add(NS_LITERAL_STRING("stale"));
}
if (state & states::ENABLED) {
stringStates->Add(NS_LITERAL_STRING("enabled"));
}
if (state & states::SENSITIVE) {
stringStates->Add(NS_LITERAL_STRING("sensitive"));
}
if (state & states::EXPANDABLE) {
stringStates->Add(NS_LITERAL_STRING("expandable"));
}
//unknown states
if (!stringStates->Length()) {
stringStates->Add(NS_LITERAL_STRING("unknown"));
}
stringStates.forget(aStringStates);
}
void
nsAccessibilityService::GetStringEventType(uint32_t aEventType,
nsAString& aString)
{
NS_ASSERTION(nsIAccessibleEvent::EVENT_LAST_ENTRY == ArrayLength(kEventTypeNames),
"nsIAccessibleEvent constants are out of sync to kEventTypeNames");
if (aEventType >= ArrayLength(kEventTypeNames)) {
aString.AssignLiteral("unknown");
return;
}
CopyUTF8toUTF16(kEventTypeNames[aEventType], aString);
}
void
nsAccessibilityService::GetStringRelationType(uint32_t aRelationType,
nsAString& aString)
{
NS_ENSURE_TRUE_VOID(aRelationType <= static_cast<uint32_t>(RelationType::LAST));
#define RELATIONTYPE(geckoType, geckoTypeName, atkType, msaaType, ia2Type) \
case RelationType::geckoType: \
aString.AssignLiteral(geckoTypeName); \
return;
RelationType relationType = static_cast<RelationType>(aRelationType);
switch (relationType) {
#include "RelationTypeMap.h"
default:
aString.AssignLiteral("unknown");
return;
}
#undef RELATIONTYPE
}
////////////////////////////////////////////////////////////////////////////////
// nsAccessibilityService public
Accessible*
nsAccessibilityService::CreateAccessible(nsINode* aNode,
Accessible* aContext,
bool* aIsSubtreeHidden)
{
MOZ_ASSERT(aContext, "No context provided");
MOZ_ASSERT(aNode, "No node to create an accessible for");
MOZ_ASSERT(gConsumers, "No creation after shutdown");
if (aIsSubtreeHidden)
*aIsSubtreeHidden = false;
DocAccessible* document = aContext->Document();
MOZ_ASSERT(!document->GetAccessible(aNode),
"We already have an accessible for this node.");
if (aNode->IsNodeOfType(nsINode::eDOCUMENT)) {
// If it's document node then ask accessible document loader for
// document accessible, otherwise return null.
nsCOMPtr<nsIDocument> document(do_QueryInterface(aNode));
return GetDocAccessible(document);
}
// We have a content node.
if (!aNode->GetComposedDoc()) {
NS_WARNING("Creating accessible for node with no document");
return nullptr;
}
if (aNode->OwnerDoc() != document->DocumentNode()) {
NS_ERROR("Creating accessible for wrong document");
return nullptr;
}
if (!aNode->IsContent())
return nullptr;
nsIContent* content = aNode->AsContent();
nsIFrame* frame = content->GetPrimaryFrame();
// Check frame and its visibility. Note, hidden frame allows visible
// elements in subtree.
if (!frame || !frame->StyleVisibility()->IsVisible()) {
if (aIsSubtreeHidden && !frame)
*aIsSubtreeHidden = true;
return nullptr;
}
if (frame->GetContent() != content) {
// Not the main content for this frame. This happens because <area>
// elements return the image frame as their primary frame. The main content
// for the image frame is the image content. If the frame is not an image
// frame or the node is not an area element then null is returned.
// This setup will change when bug 135040 is fixed. Make sure we don't
// create area accessible here. Hopefully assertion below will handle that.
#ifdef DEBUG
nsImageFrame* imageFrame = do_QueryFrame(frame);
NS_ASSERTION(imageFrame && content->IsHTMLElement(nsGkAtoms::area),
"Unknown case of not main content for the frame!");
#endif
return nullptr;
}
#ifdef DEBUG
nsImageFrame* imageFrame = do_QueryFrame(frame);
NS_ASSERTION(!imageFrame || !content->IsHTMLElement(nsGkAtoms::area),
"Image map manages the area accessible creation!");
#endif
// Attempt to create an accessible based on what we know.
RefPtr<Accessible> newAcc;
// Create accessible for visible text frames.
if (content->IsNodeOfType(nsINode::eTEXT)) {
nsIFrame::RenderedText text = frame->GetRenderedText(0,
UINT32_MAX, nsIFrame::TextOffsetType::OFFSETS_IN_CONTENT_TEXT,
nsIFrame::TrailingWhitespace::DONT_TRIM_TRAILING_WHITESPACE);
// Ignore not rendered text nodes and whitespace text nodes between table
// cells.
if (text.mString.IsEmpty() ||
(aContext->IsTableRow() && nsCoreUtils::IsWhitespaceString(text.mString))) {
if (aIsSubtreeHidden)
*aIsSubtreeHidden = true;
return nullptr;
}
newAcc = CreateAccessibleByFrameType(frame, content, aContext);
document->BindToDocument(newAcc, nullptr);
newAcc->AsTextLeaf()->SetText(text.mString);
return newAcc;
}
if (content->IsHTMLElement(nsGkAtoms::map)) {
// Create hyper text accessible for HTML map if it is used to group links
// (see http://www.w3.org/TR/WCAG10-HTML-TECHS/#group-bypass). If the HTML
// map rect is empty then it is used for links grouping. Otherwise it should
// be used in conjunction with HTML image element and in this case we don't
// create any accessible for it and don't walk into it. The accessibles for
// HTML area (HTMLAreaAccessible) the map contains are attached as
// children of the appropriate accessible for HTML image
// (ImageAccessible).
if (nsLayoutUtils::GetAllInFlowRectsUnion(frame,
frame->GetParent()).IsEmpty()) {
if (aIsSubtreeHidden)
*aIsSubtreeHidden = true;
return nullptr;
}
newAcc = new HyperTextAccessibleWrap(content, document);
document->BindToDocument(newAcc, aria::GetRoleMap(content->AsElement()));
return newAcc;
}
const nsRoleMapEntry* roleMapEntry = aria::GetRoleMap(content->AsElement());
// If the element is focusable or global ARIA attribute is applied to it or
// it is referenced by ARIA relationship then treat role="presentation" on
// the element as the role is not there.
if (roleMapEntry &&
(roleMapEntry->Is(nsGkAtoms::presentation) ||
roleMapEntry->Is(nsGkAtoms::none))) {
if (!MustBeAccessible(content, document))
return nullptr;
roleMapEntry = nullptr;
}
if (!newAcc && content->IsHTMLElement()) { // HTML accessibles
bool isARIATablePart = roleMapEntry &&
(roleMapEntry->accTypes & (eTableCell | eTableRow | eTable));
if (!isARIATablePart ||
frame->AccessibleType() == eHTMLTableCellType ||
frame->AccessibleType() == eHTMLTableRowType ||
frame->AccessibleType() == eHTMLTableType) {
// Prefer to use markup to decide if and what kind of accessible to create,
const MarkupMapInfo* markupMap =
mMarkupMaps.Get(content->NodeInfo()->NameAtom());
if (markupMap && markupMap->new_func)
newAcc = markupMap->new_func(content, aContext);
if (!newAcc) // try by frame accessible type.
newAcc = CreateAccessibleByFrameType(frame, content, aContext);
}
// In case of ARIA grid or table use table-specific classes if it's not
// native table based.
if (isARIATablePart && (!newAcc || newAcc->IsGenericHyperText())) {
if ((roleMapEntry->accTypes & eTableCell)) {
if (aContext->IsTableRow())
newAcc = new ARIAGridCellAccessibleWrap(content, document);
} else if (roleMapEntry->IsOfType(eTableRow)) {
if (aContext->IsTable())
newAcc = new ARIARowAccessible(content, document);
} else if (roleMapEntry->IsOfType(eTable)) {
newAcc = new ARIAGridAccessibleWrap(content, document);
}
}
// If table has strong ARIA role then all table descendants shouldn't
// expose their native roles.
if (!roleMapEntry && newAcc && aContext->HasStrongARIARole()) {
if (frame->AccessibleType() == eHTMLTableRowType) {
const nsRoleMapEntry* contextRoleMap = aContext->ARIARoleMap();
if (!contextRoleMap->IsOfType(eTable))
roleMapEntry = &aria::gEmptyRoleMap;
} else if (frame->AccessibleType() == eHTMLTableCellType &&
aContext->ARIARoleMap() == &aria::gEmptyRoleMap) {
roleMapEntry = &aria::gEmptyRoleMap;
} else if (content->IsAnyOfHTMLElements(nsGkAtoms::dt,
nsGkAtoms::li,
nsGkAtoms::dd) ||
frame->AccessibleType() == eHTMLLiType) {
const nsRoleMapEntry* contextRoleMap = aContext->ARIARoleMap();
if (!contextRoleMap->IsOfType(eList))
roleMapEntry = &aria::gEmptyRoleMap;
}
}
}
// Accessible XBL types and deck stuff are used in XUL only currently.
if (!newAcc && content->IsXULElement()) {
// No accessible for not selected deck panel and its children.
if (!aContext->IsXULTabpanels()) {
nsDeckFrame* deckFrame = do_QueryFrame(frame->GetParent());
if (deckFrame && deckFrame->GetSelectedBox() != frame) {
if (aIsSubtreeHidden)
*aIsSubtreeHidden = true;
return nullptr;
}
}
// XBL bindings may use @role attribute to point the accessible type
// they belong to.
newAcc = CreateAccessibleByType(content, document);
// Any XUL box can be used as tabpanel, make sure we create a proper
// accessible for it.
if (!newAcc && aContext->IsXULTabpanels() &&
content->GetParent() == aContext->GetContent()) {
nsIAtom* frameType = frame->GetType();
if (frameType == nsGkAtoms::boxFrame ||
frameType == nsGkAtoms::scrollFrame) {
newAcc = new XULTabpanelAccessible(content, document);
}
}
}
if (!newAcc) {
if (content->IsSVGElement()) {
nsSVGPathGeometryFrame* pathGeometryFrame = do_QueryFrame(frame);
if (pathGeometryFrame) {
// A graphic elements: rect, circle, ellipse, line, path, polygon,
// polyline and image. A 'use' and 'text' graphic elements require
// special support.
newAcc = new EnumRoleAccessible<roles::GRAPHIC>(content, document);
} else if (content->IsSVGElement(nsGkAtoms::svg)) {
newAcc = new EnumRoleAccessible<roles::DIAGRAM>(content, document);
}
} else if (content->IsMathMLElement()) {
const MarkupMapInfo* markupMap =
mMarkupMaps.Get(content->NodeInfo()->NameAtom());
if (markupMap && markupMap->new_func)
newAcc = markupMap->new_func(content, aContext);
// Fall back to text when encountering Content MathML.
if (!newAcc && !content->IsAnyOfMathMLElements(nsGkAtoms::annotation_,
nsGkAtoms::annotation_xml_,
nsGkAtoms::mpadded_,
nsGkAtoms::mphantom_,
nsGkAtoms::maligngroup_,
nsGkAtoms::malignmark_,
nsGkAtoms::mspace_,
nsGkAtoms::semantics_)) {
newAcc = new HyperTextAccessible(content, document);
}
}
}
// If no accessible, see if we need to create a generic accessible because
// of some property that makes this object interesting
// We don't do this for <body>, <html>, <window>, <dialog> etc. which
// correspond to the doc accessible and will be created in any case
if (!newAcc && !content->IsHTMLElement(nsGkAtoms::body) &&
content->GetParent() &&
(roleMapEntry || MustBeAccessible(content, document) ||
(content->IsHTMLElement() &&
nsCoreUtils::HasClickListener(content)))) {
// This content is focusable or has an interesting dynamic content accessibility property.
// If it's interesting we need it in the accessibility hierarchy so that events or
// other accessibles can point to it, or so that it can hold a state, etc.
if (content->IsHTMLElement()) {
// Interesting HTML container which may have selectable text and/or embedded objects
newAcc = new HyperTextAccessibleWrap(content, document);
} else { // XUL, SVG, MathML etc.
// Interesting generic non-HTML container
newAcc = new AccessibleWrap(content, document);
}
}
if (newAcc) {
document->BindToDocument(newAcc, roleMapEntry);
}
return newAcc;
}
////////////////////////////////////////////////////////////////////////////////
// nsAccessibilityService private
bool
nsAccessibilityService::Init()
{
// Initialize accessible document manager.
if (!DocManager::Init())
return false;
// Add observers.
nsCOMPtr<nsIObserverService> observerService =
mozilla::services::GetObserverService();
if (!observerService)
return false;
observerService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false);
static const char16_t kInitIndicator[] = { '1', 0 };
observerService->NotifyObservers(nullptr, "a11y-init-or-shutdown", kInitIndicator);
// Subscribe to EventListenerService.
nsCOMPtr<nsIEventListenerService> eventListenerService =
do_GetService("@mozilla.org/eventlistenerservice;1");
if (!eventListenerService)
return false;
eventListenerService->AddListenerChangeListener(this);
for (uint32_t i = 0; i < ArrayLength(sMarkupMapList); i++)
mMarkupMaps.Put(*sMarkupMapList[i].tag, &sMarkupMapList[i]);
#ifdef A11Y_LOG
logging::CheckEnv();
#endif
gAccessibilityService = this;
NS_ADDREF(gAccessibilityService); // will release in Shutdown()
if (XRE_IsParentProcess()) {
gApplicationAccessible = new ApplicationAccessibleWrap();
} else {
#if defined(XP_WIN)
dom::ContentChild* contentChild = dom::ContentChild::GetSingleton();
MOZ_ASSERT(contentChild);
// If we were instantiated by the chrome process, GetMsaaID() will return
// a non-zero value and we may safely continue with initialization.
if (!contentChild->GetMsaaID()) {
// Since we were not instantiated by chrome, we need to synchronously
// obtain a MSAA content process id.
contentChild->SendGetA11yContentId();
}
#endif // defined(XP_WIN)
gApplicationAccessible = new ApplicationAccessible();
}
NS_ADDREF(gApplicationAccessible); // will release in Shutdown()
gApplicationAccessible->Init();
#ifdef XP_WIN
sPendingPlugins = new nsTArray<nsCOMPtr<nsIContent> >;
sPluginTimers = new nsTArray<nsCOMPtr<nsITimer> >;
#endif
// Now its safe to start platform accessibility.
if (XRE_IsParentProcess())
PlatformInit();
return true;
}
void
nsAccessibilityService::Shutdown()
{
// Application is going to be closed, shutdown accessibility and mark
// accessibility service as shutdown to prevent calls of its methods.
// Don't null accessibility service static member at this point to be safe
// if someone will try to operate with it.
MOZ_ASSERT(gConsumers, "Accessibility was shutdown already");
gConsumers = 0;
// Remove observers.
nsCOMPtr<nsIObserverService> observerService =
mozilla::services::GetObserverService();
if (observerService) {
observerService->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID);
static const char16_t kShutdownIndicator[] = { '0', 0 };
observerService->NotifyObservers(nullptr, "a11y-init-or-shutdown", kShutdownIndicator);
}
// Stop accessible document loader.
DocManager::Shutdown();
SelectionManager::Shutdown();
#ifdef XP_WIN
sPendingPlugins = nullptr;
uint32_t timerCount = sPluginTimers->Length();
for (uint32_t i = 0; i < timerCount; i++)
sPluginTimers->ElementAt(i)->Cancel();
sPluginTimers = nullptr;
#endif
if (XRE_IsParentProcess())
PlatformShutdown();
gApplicationAccessible->Shutdown();
NS_RELEASE(gApplicationAccessible);
gApplicationAccessible = nullptr;
NS_IF_RELEASE(gXPCApplicationAccessible);
gXPCApplicationAccessible = nullptr;
NS_RELEASE(gAccessibilityService);
gAccessibilityService = nullptr;
}
already_AddRefed<Accessible>
nsAccessibilityService::CreateAccessibleByType(nsIContent* aContent,
DocAccessible* aDoc)
{
nsAutoString role;
nsCoreUtils::XBLBindingRole(aContent, role);
if (role.IsEmpty() || role.EqualsLiteral("none"))
return nullptr;
if (role.EqualsLiteral("outerdoc")) {
RefPtr<Accessible> accessible = new OuterDocAccessible(aContent, aDoc);
return accessible.forget();
}
RefPtr<Accessible> accessible;
#ifdef MOZ_XUL
// XUL controls
if (role.EqualsLiteral("xul:alert")) {
accessible = new XULAlertAccessible(aContent, aDoc);
} else if (role.EqualsLiteral("xul:button")) {
accessible = new XULButtonAccessible(aContent, aDoc);
} else if (role.EqualsLiteral("xul:checkbox")) {
accessible = new XULCheckboxAccessible(aContent, aDoc);
} else if (role.EqualsLiteral("xul:colorpicker")) {
accessible = new XULColorPickerAccessible(aContent, aDoc);
} else if (role.EqualsLiteral("xul:colorpickertile")) {
accessible = new XULColorPickerTileAccessible(aContent, aDoc);
} else if (role.EqualsLiteral("xul:combobox")) {
accessible = new XULComboboxAccessible(aContent, aDoc);
} else if (role.EqualsLiteral("xul:tabpanels")) {
accessible = new XULTabpanelsAccessible(aContent, aDoc);
} else if (role.EqualsLiteral("xul:dropmarker")) {
accessible = new XULDropmarkerAccessible(aContent, aDoc);
} else if (role.EqualsLiteral("xul:groupbox")) {
accessible = new XULGroupboxAccessible(aContent, aDoc);
} else if (role.EqualsLiteral("xul:image")) {
if (aContent->HasAttr(kNameSpaceID_None, nsGkAtoms::onclick)) {
accessible = new XULToolbarButtonAccessible(aContent, aDoc);
} else {
// Don't include nameless images in accessible tree.
if (!aContent->HasAttr(kNameSpaceID_None,
nsGkAtoms::tooltiptext))
return nullptr;
accessible = new ImageAccessibleWrap(aContent, aDoc);
}
} else if (role.EqualsLiteral("xul:link")) {
accessible = new XULLinkAccessible(aContent, aDoc);
} else if (role.EqualsLiteral("xul:listbox")) {
accessible = new XULListboxAccessibleWrap(aContent, aDoc);
} else if (role.EqualsLiteral("xul:listcell")) {
// Only create cells if there's more than one per row.
nsIContent* listItem = aContent->GetParent();
if (!listItem)
return nullptr;
for (nsIContent* child = listItem->GetFirstChild(); child;
child = child->GetNextSibling()) {
if (child->IsXULElement(nsGkAtoms::listcell) && child != aContent) {
accessible = new XULListCellAccessibleWrap(aContent, aDoc);
break;
}
}
} else if (role.EqualsLiteral("xul:listhead")) {
accessible = new XULColumAccessible(aContent, aDoc);
} else if (role.EqualsLiteral("xul:listheader")) {
accessible = new XULColumnItemAccessible(aContent, aDoc);
} else if (role.EqualsLiteral("xul:listitem")) {
accessible = new XULListitemAccessible(aContent, aDoc);
} else if (role.EqualsLiteral("xul:menubar")) {
accessible = new XULMenubarAccessible(aContent, aDoc);
} else if (role.EqualsLiteral("xul:menulist")) {
accessible = new XULComboboxAccessible(aContent, aDoc);
} else if (role.EqualsLiteral("xul:menuitem")) {
accessible = new XULMenuitemAccessibleWrap(aContent, aDoc);
} else if (role.EqualsLiteral("xul:menupopup")) {
#ifdef MOZ_ACCESSIBILITY_ATK
// ATK considers this node to be redundant when within menubars, and it makes menu
// navigation with assistive technologies more difficult
// XXX In the future we will should this for consistency across the nsIAccessible
// implementations on each platform for a consistent scripting environment, but
// then strip out redundant accessibles in the AccessibleWrap class for each platform.
nsIContent *parent = aContent->GetParent();
if (parent && parent->IsXULElement(nsGkAtoms::menu))
return nullptr;
#endif
accessible = new XULMenupopupAccessible(aContent, aDoc);
} else if(role.EqualsLiteral("xul:menuseparator")) {
accessible = new XULMenuSeparatorAccessible(aContent, aDoc);
} else if(role.EqualsLiteral("xul:pane")) {
accessible = new EnumRoleAccessible<roles::PANE>(aContent, aDoc);
} else if (role.EqualsLiteral("xul:panel")) {
if (aContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::noautofocus,
nsGkAtoms::_true, eCaseMatters))
accessible = new XULAlertAccessible(aContent, aDoc);
else
accessible = new EnumRoleAccessible<roles::PANE>(aContent, aDoc);
} else if (role.EqualsLiteral("xul:progressmeter")) {
accessible = new XULProgressMeterAccessible(aContent, aDoc);
} else if (role.EqualsLiteral("xul:statusbar")) {
accessible = new XULStatusBarAccessible(aContent, aDoc);
} else if (role.EqualsLiteral("xul:scale")) {
accessible = new XULSliderAccessible(aContent, aDoc);
} else if (role.EqualsLiteral("xul:radiobutton")) {
accessible = new XULRadioButtonAccessible(aContent, aDoc);
} else if (role.EqualsLiteral("xul:radiogroup")) {
accessible = new XULRadioGroupAccessible(aContent, aDoc);
} else if (role.EqualsLiteral("xul:tab")) {
accessible = new XULTabAccessible(aContent, aDoc);
} else if (role.EqualsLiteral("xul:tabs")) {
accessible = new XULTabsAccessible(aContent, aDoc);
} else if (role.EqualsLiteral("xul:text")) {
accessible = new XULLabelAccessible(aContent, aDoc);
} else if (role.EqualsLiteral("xul:textbox")) {
accessible = new EnumRoleAccessible<roles::SECTION>(aContent, aDoc);
} else if (role.EqualsLiteral("xul:thumb")) {
accessible = new XULThumbAccessible(aContent, aDoc);
} else if (role.EqualsLiteral("xul:tree")) {
accessible = CreateAccessibleForXULTree(aContent, aDoc);
} else if (role.EqualsLiteral("xul:treecolumns")) {
accessible = new XULTreeColumAccessible(aContent, aDoc);
} else if (role.EqualsLiteral("xul:treecolumnitem")) {
accessible = new XULColumnItemAccessible(aContent, aDoc);
} else if (role.EqualsLiteral("xul:toolbar")) {
accessible = new XULToolbarAccessible(aContent, aDoc);
} else if (role.EqualsLiteral("xul:toolbarseparator")) {
accessible = new XULToolbarSeparatorAccessible(aContent, aDoc);
} else if (role.EqualsLiteral("xul:tooltip")) {
accessible = new XULTooltipAccessible(aContent, aDoc);
} else if (role.EqualsLiteral("xul:toolbarbutton")) {
accessible = new XULToolbarButtonAccessible(aContent, aDoc);
}
#endif // MOZ_XUL
return accessible.forget();
}
already_AddRefed<Accessible>
nsAccessibilityService::CreateAccessibleByFrameType(nsIFrame* aFrame,
nsIContent* aContent,
Accessible* aContext)
{
DocAccessible* document = aContext->Document();
RefPtr<Accessible> newAcc;
switch (aFrame->AccessibleType()) {
case eNoType:
return nullptr;
case eHTMLBRType:
newAcc = new HTMLBRAccessible(aContent, document);
break;
case eHTMLButtonType:
newAcc = new HTMLButtonAccessible(aContent, document);
break;
case eHTMLCanvasType:
newAcc = new HTMLCanvasAccessible(aContent, document);
break;
case eHTMLCaptionType:
if (aContext->IsTable() &&
aContext->GetContent() == aContent->GetParent()) {
newAcc = new HTMLCaptionAccessible(aContent, document);
}
break;
case eHTMLCheckboxType:
newAcc = new HTMLCheckboxAccessible(aContent, document);
break;
case eHTMLComboboxType:
newAcc = new HTMLComboboxAccessible(aContent, document);
break;
case eHTMLFileInputType:
newAcc = new HTMLFileInputAccessible(aContent, document);
break;
case eHTMLGroupboxType:
newAcc = new HTMLGroupboxAccessible(aContent, document);
break;
case eHTMLHRType:
newAcc = new HTMLHRAccessible(aContent, document);
break;
case eHTMLImageMapType:
newAcc = new HTMLImageMapAccessible(aContent, document);
break;
case eHTMLLiType:
if (aContext->IsList() &&
aContext->GetContent() == aContent->GetParent()) {
newAcc = new HTMLLIAccessible(aContent, document);
} else {
// Otherwise create a generic text accessible to avoid text jamming.
newAcc = new HyperTextAccessibleWrap(aContent, document);
}
break;
case eHTMLSelectListType:
newAcc = new HTMLSelectListAccessible(aContent, document);
break;
case eHTMLMediaType:
newAcc = new EnumRoleAccessible<roles::GROUPING>(aContent, document);
break;
case eHTMLRadioButtonType:
newAcc = new HTMLRadioButtonAccessible(aContent, document);
break;
case eHTMLRangeType:
newAcc = new HTMLRangeAccessible(aContent, document);
break;
case eHTMLSpinnerType:
newAcc = new HTMLSpinnerAccessible(aContent, document);
break;
case eHTMLTableType:
if (aContent->IsHTMLElement(nsGkAtoms::table))
newAcc = new HTMLTableAccessibleWrap(aContent, document);
else
newAcc = new HyperTextAccessibleWrap(aContent, document);
break;
case eHTMLTableCellType:
// Accessible HTML table cell should be a child of accessible HTML table
// or its row (CSS HTML tables are polite to the used markup at
// certain degree).
// Otherwise create a generic text accessible to avoid text jamming
// when reading by AT.
if (aContext->IsHTMLTableRow() || aContext->IsHTMLTable())
newAcc = new HTMLTableCellAccessibleWrap(aContent, document);
else
newAcc = new HyperTextAccessibleWrap(aContent, document);
break;
case eHTMLTableRowType: {
// Accessible HTML table row may be a child of tbody/tfoot/thead of
// accessible HTML table or a direct child of accessible of HTML table.
Accessible* table = aContext->IsTable() ? aContext : nullptr;
if (!table && aContext->Parent() && aContext->Parent()->IsTable())
table = aContext->Parent();
if (table) {
nsIContent* parentContent = aContent->GetParent();
nsIFrame* parentFrame = parentContent->GetPrimaryFrame();
if (parentFrame->GetType() != nsGkAtoms::tableWrapperFrame) {
parentContent = parentContent->GetParent();
parentFrame = parentContent->GetPrimaryFrame();
}
if (parentFrame->GetType() == nsGkAtoms::tableWrapperFrame &&
table->GetContent() == parentContent) {
newAcc = new HTMLTableRowAccessible(aContent, document);
}
}
break;
}
case eHTMLTextFieldType:
newAcc = new HTMLTextFieldAccessible(aContent, document);
break;
case eHyperTextType:
if (!aContent->IsAnyOfHTMLElements(nsGkAtoms::dt, nsGkAtoms::dd))
newAcc = new HyperTextAccessibleWrap(aContent, document);
break;
case eImageType:
newAcc = new ImageAccessibleWrap(aContent, document);
break;
case eOuterDocType:
newAcc = new OuterDocAccessible(aContent, document);
break;
case ePluginType: {
nsPluginFrame* pluginFrame = do_QueryFrame(aFrame);
newAcc = CreatePluginAccessible(pluginFrame, aContent, aContext);
break;
}
case eTextLeafType:
newAcc = new TextLeafAccessibleWrap(aContent, document);
break;
default:
MOZ_ASSERT(false);
break;
}
return newAcc.forget();
}
void
nsAccessibilityService::MarkupAttributes(const nsIContent* aContent,
nsIPersistentProperties* aAttributes) const
{
const mozilla::a11y::MarkupMapInfo* markupMap =
mMarkupMaps.Get(aContent->NodeInfo()->NameAtom());
if (!markupMap)
return;
for (uint32_t i = 0; i < ArrayLength(markupMap->attrs); i++) {
const MarkupAttrInfo* info = markupMap->attrs + i;
if (!info->name)
break;
if (info->DOMAttrName) {
if (info->DOMAttrValue) {
if (aContent->AttrValueIs(kNameSpaceID_None, *info->DOMAttrName,
*info->DOMAttrValue, eCaseMatters)) {
nsAccUtils::SetAccAttr(aAttributes, *info->name, *info->DOMAttrValue);
}
continue;
}
nsAutoString value;
aContent->GetAttr(kNameSpaceID_None, *info->DOMAttrName, value);
if (!value.IsEmpty())
nsAccUtils::SetAccAttr(aAttributes, *info->name, value);
continue;
}
nsAccUtils::SetAccAttr(aAttributes, *info->name, *info->value);
}
}
Accessible*
nsAccessibilityService::AddNativeRootAccessible(void* aAtkAccessible)
{
#ifdef MOZ_ACCESSIBILITY_ATK
ApplicationAccessible* applicationAcc = ApplicationAcc();
if (!applicationAcc)
return nullptr;
GtkWindowAccessible* nativeWnd =
new GtkWindowAccessible(static_cast<AtkObject*>(aAtkAccessible));
if (applicationAcc->AppendChild(nativeWnd))
return nativeWnd;
#endif
return nullptr;
}
void
nsAccessibilityService::RemoveNativeRootAccessible(Accessible* aAccessible)
{
#ifdef MOZ_ACCESSIBILITY_ATK
ApplicationAccessible* applicationAcc = ApplicationAcc();
if (applicationAcc)
applicationAcc->RemoveChild(aAccessible);
#endif
}
bool
nsAccessibilityService::HasAccessible(nsIDOMNode* aDOMNode)
{
nsCOMPtr<nsINode> node(do_QueryInterface(aDOMNode));
if (!node)
return false;
DocAccessible* document = GetDocAccessible(node->OwnerDoc());
if (!document)
return false;
return document->HasAccessible(node);
}
////////////////////////////////////////////////////////////////////////////////
// nsAccessibilityService private (DON'T put methods here)
#ifdef MOZ_XUL
already_AddRefed<Accessible>
nsAccessibilityService::CreateAccessibleForXULTree(nsIContent* aContent,
DocAccessible* aDoc)
{
nsIContent* child = nsTreeUtils::GetDescendantChild(aContent,
nsGkAtoms::treechildren);
if (!child)
return nullptr;
nsTreeBodyFrame* treeFrame = do_QueryFrame(child->GetPrimaryFrame());
if (!treeFrame)
return nullptr;
RefPtr<nsTreeColumns> treeCols = treeFrame->Columns();
int32_t count = 0;
treeCols->GetCount(&count);
// Outline of list accessible.
if (count == 1) {
RefPtr<Accessible> accessible =
new XULTreeAccessible(aContent, aDoc, treeFrame);
return accessible.forget();
}
// Table or tree table accessible.
RefPtr<Accessible> accessible =
new XULTreeGridAccessibleWrap(aContent, aDoc, treeFrame);
return accessible.forget();
}
#endif
nsAccessibilityService*
GetOrCreateAccService(uint32_t aNewConsumer)
{
if (!nsAccessibilityService::gAccessibilityService) {
RefPtr<nsAccessibilityService> service = new nsAccessibilityService();
if (!service->Init()) {
service->Shutdown();
return nullptr;
}
}
MOZ_ASSERT(nsAccessibilityService::gAccessibilityService,
"Accessible service is not initialized.");
nsAccessibilityService::gConsumers |= aNewConsumer;
return nsAccessibilityService::gAccessibilityService;
}
void
MaybeShutdownAccService(uint32_t aFormerConsumer)
{
nsAccessibilityService* accService =
nsAccessibilityService::gAccessibilityService;
if (!accService || accService->IsShutdown()) {
return;
}
if (nsCoreUtils::AccEventObserversExist() ||
xpcAccessibilityService::IsInUse()) {
// Still used by XPCOM
nsAccessibilityService::gConsumers =
(nsAccessibilityService::gConsumers & ~aFormerConsumer) |
nsAccessibilityService::eXPCOM;
return;
}
if (nsAccessibilityService::gConsumers & ~aFormerConsumer) {
nsAccessibilityService::gConsumers &= ~aFormerConsumer;
} else {
accService->Shutdown(); // Will unset all nsAccessibilityService::gConsumers
}
}
////////////////////////////////////////////////////////////////////////////////
// Services
////////////////////////////////////////////////////////////////////////////////
namespace mozilla {
namespace a11y {
FocusManager*
FocusMgr()
{
return nsAccessibilityService::gAccessibilityService;
}
SelectionManager*
SelectionMgr()
{
return nsAccessibilityService::gAccessibilityService;
}
ApplicationAccessible*
ApplicationAcc()
{
return nsAccessibilityService::gApplicationAccessible;
}
xpcAccessibleApplication*
XPCApplicationAcc()
{
if (!nsAccessibilityService::gXPCApplicationAccessible &&
nsAccessibilityService::gApplicationAccessible) {
nsAccessibilityService::gXPCApplicationAccessible =
new xpcAccessibleApplication(nsAccessibilityService::gApplicationAccessible);
NS_ADDREF(nsAccessibilityService::gXPCApplicationAccessible);
}
return nsAccessibilityService::gXPCApplicationAccessible;
}
EPlatformDisabledState
PlatformDisabledState()
{
static int disabledState = 0xff;
if (disabledState == 0xff) {
disabledState = Preferences::GetInt("accessibility.force_disabled", 0);
if (disabledState < ePlatformIsForceEnabled)
disabledState = ePlatformIsForceEnabled;
else if (disabledState > ePlatformIsDisabled)
disabledState = ePlatformIsDisabled;
}
return (EPlatformDisabledState)disabledState;
}
}
}