/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the QtGui module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qaccessible.h"
#ifndef QT_NO_ACCESSIBILITY
#include "qaccessible_mac_p.h"
#include "qhash.h"
#include "qset.h"
#include "qpointer.h"
#include "qapplication.h"
#include "qmainwindow.h"
#include "qtextdocument.h"
#include "qdebug.h"
#include "qabstractslider.h"
#include "qsplitter.h"
#include "qtabwidget.h"
#include "qlistview.h"
#include "qtableview.h"
#include "qdockwidget.h"
#include <private/qt_mac_p.h>
#include <private/qwidget_p.h>
#include <CoreFoundation/CoreFoundation.h>
QT_BEGIN_NAMESPACE
/*
Set up platform defines. There is a one-to-one correspondence between the
Carbon and Cocoa roles and attributes, but the prefix and type changes.
*/
#ifdef QT_MAC_USE_COCOA
typedef NSString * const QAXRoleType;
#define QAXApplicationRole NSAccessibilityApplicationRole
#define QAXButtonRole NSAccessibilityButtonRole
#define QAXCancelAction NSAccessibilityCancelAction
#define QAXCheckBoxRole NSAccessibilityCheckBoxRole
#define QAXChildrenAttribute NSAccessibilityChildrenAttribute
#define QAXCloseButtonAttribute NSAccessibilityCloseButtonAttribute
#define QAXCloseButtonAttribute NSAccessibilityCloseButtonAttribute
#define QAXColumnRole NSAccessibilityColumnRole
#define QAXConfirmAction NSAccessibilityConfirmAction
#define QAXContentsAttribute NSAccessibilityContentsAttribute
#define QAXDecrementAction NSAccessibilityDecrementAction
#define QAXDecrementArrowSubrole NSAccessibilityDecrementArrowSubrole
#define QAXDecrementPageSubrole NSAccessibilityDecrementPageSubrole
#define QAXDescriptionAttribute NSAccessibilityDescriptionAttribute
#define QAXEnabledAttribute NSAccessibilityEnabledAttribute
#define QAXExpandedAttribute NSAccessibilityExpandedAttribute
#define QAXFocusedAttribute NSAccessibilityFocusedAttribute
#define QAXFocusedUIElementChangedNotification NSAccessibilityFocusedUIElementChangedNotification
#define QAXFocusedWindowChangedNotification NSAccessibilityFocusedWindowChangedNotification
#define QAXGroupRole NSAccessibilityGroupRole
#define QAXGrowAreaAttribute NSAccessibilityGrowAreaAttribute
#define QAXGrowAreaRole NSAccessibilityGrowAreaRole
#define QAXHelpAttribute NSAccessibilityHelpAttribute
#define QAXHorizontalOrientationValue NSAccessibilityHorizontalOrientationValue
#define QAXHorizontalScrollBarAttribute NSAccessibilityHorizontalScrollBarAttribute
#define QAXIncrementAction NSAccessibilityIncrementAction
#define QAXIncrementArrowSubrole NSAccessibilityIncrementArrowSubrole
#define QAXIncrementPageSubrole NSAccessibilityIncrementPageSubrole
#define QAXIncrementorRole NSAccessibilityIncrementorRole
#define QAXLinkedUIElementsAttribute NSAccessibilityLinkedUIElementsAttribute
#define QAXListRole NSAccessibilityListRole
#define QAXMainAttribute NSAccessibilityMainAttribute
#define QAXMaxValueAttribute NSAccessibilityMaxValueAttribute
#define QAXMenuBarRole NSAccessibilityMenuBarRole
#define QAXMenuButtonRole NSAccessibilityMenuButtonRole
#define QAXMenuClosedNotification NSAccessibilityMenuClosedNotification
#define QAXMenuItemRole NSAccessibilityMenuItemRole
#define QAXMenuOpenedNotification NSAccessibilityMenuOpenedNotification
#define QAXMenuRole NSAccessibilityMenuRole
#define QAXMinValueAttribute NSAccessibilityMinValueAttribute
#define QAXMinimizeButtonAttribute NSAccessibilityMinimizeButtonAttribute
#define QAXMinimizedAttribute NSAccessibilityMinimizedAttribute
#define QAXNextContentsAttribute NSAccessibilityNextContentsAttribute
#define QAXOrientationAttribute NSAccessibilityOrientationAttribute
#define QAXParentAttribute NSAccessibilityParentAttribute
#define QAXPickAction NSAccessibilityPickAction
#define QAXPopUpButtonRole NSAccessibilityPopUpButtonRole
#define QAXPositionAttribute NSAccessibilityPositionAttribute
#define QAXPressAction NSAccessibilityPressAction
#define QAXPreviousContentsAttribute NSAccessibilityPreviousContentsAttribute
#define QAXProgressIndicatorRole NSAccessibilityProgressIndicatorRole
#define QAXRadioButtonRole NSAccessibilityRadioButtonRole
#define QAXRoleAttribute NSAccessibilityRoleAttribute
#define QAXRoleDescriptionAttribute NSAccessibilityRoleDescriptionAttribute
#define QAXRowRole NSAccessibilityRowRole
#define QAXRowsAttribute NSAccessibilityRowsAttribute
#define QAXScrollAreaRole NSAccessibilityScrollAreaRole
#define QAXScrollBarRole NSAccessibilityScrollBarRole
#define QAXSelectedAttribute NSAccessibilitySelectedAttribute
#define QAXSelectedChildrenAttribute NSAccessibilitySelectedChildrenAttribute
#define QAXSelectedRowsAttribute NSAccessibilitySelectedRowsAttribute
#define QAXSizeAttribute NSAccessibilitySizeAttribute
#define QAXSliderRole NSAccessibilitySliderRole
#define QAXSplitGroupRole NSAccessibilitySplitGroupRole
#define QAXSplitterRole NSAccessibilitySplitterRole
#define QAXSplittersAttribute NSAccessibilitySplittersAttribute
#define QAXStaticTextRole NSAccessibilityStaticTextRole
#define QAXSubroleAttribute NSAccessibilitySubroleAttribute
#define QAXSubroleAttribute NSAccessibilitySubroleAttribute
#define QAXTabGroupRole NSAccessibilityTabGroupRole
#define QAXTableRole NSAccessibilityTableRole
#define QAXTabsAttribute NSAccessibilityTabsAttribute
#define QAXTextFieldRole NSAccessibilityTextFieldRole
#define QAXTitleAttribute NSAccessibilityTitleAttribute
#define QAXTitleUIElementAttribute NSAccessibilityTitleUIElementAttribute
#define QAXToolbarButtonAttribute NSAccessibilityToolbarButtonAttribute
#define QAXToolbarRole NSAccessibilityToolbarRole
#define QAXTopLevelUIElementAttribute NSAccessibilityTopLevelUIElementAttribute
#define QAXUnknownRole NSAccessibilityUnknownRole
#define QAXValueAttribute NSAccessibilityValueAttribute
#define QAXValueChangedNotification NSAccessibilityValueChangedNotification
#define QAXValueIndicatorRole NSAccessibilityValueIndicatorRole
#define QAXVerticalOrientationValue NSAccessibilityVerticalOrientationValue
#define QAXVerticalScrollBarAttribute NSAccessibilityVerticalScrollBarAttribute
#define QAXVisibleRowsAttribute NSAccessibilityVisibleRowsAttribute
#define QAXWindowAttribute NSAccessibilityWindowAttribute
#define QAXWindowCreatedNotification NSAccessibilityWindowCreatedNotification
#define QAXWindowMovedNotification NSAccessibilityWindowMovedNotification
#define QAXWindowRole NSAccessibilityWindowRole
#define QAXZoomButtonAttribute NSAccessibilityZoomButtonAttribute
#else
typedef CFStringRef const QAXRoleType;
#define QAXApplicationRole kAXApplicationRole
#define QAXButtonRole kAXButtonRole
#define QAXCancelAction kAXCancelAction
#define QAXCheckBoxRole kAXCheckBoxRole
#define QAXChildrenAttribute kAXChildrenAttribute
#define QAXCloseButtonAttribute kAXCloseButtonAttribute
#define QAXColumnRole kAXColumnRole
#define QAXConfirmAction kAXConfirmAction
#define QAXContentsAttribute kAXContentsAttribute
#define QAXDecrementAction kAXDecrementAction
#define QAXDecrementArrowSubrole kAXDecrementArrowSubrole
#define QAXDecrementPageSubrole kAXDecrementPageSubrole
#define QAXDescriptionAttribute kAXDescriptionAttribute
#define QAXEnabledAttribute kAXEnabledAttribute
#define QAXExpandedAttribute kAXExpandedAttribute
#define QAXFocusedAttribute kAXFocusedAttribute
#define QAXFocusedUIElementChangedNotification kAXFocusedUIElementChangedNotification
#define QAXFocusedWindowChangedNotification kAXFocusedWindowChangedNotification
#define QAXGroupRole kAXGroupRole
#define QAXGrowAreaAttribute kAXGrowAreaAttribute
#define QAXGrowAreaRole kAXGrowAreaRole
#define QAXHelpAttribute kAXHelpAttribute
#define QAXHorizontalOrientationValue kAXHorizontalOrientationValue
#define QAXHorizontalScrollBarAttribute kAXHorizontalScrollBarAttribute
#define QAXIncrementAction kAXIncrementAction
#define QAXIncrementArrowSubrole kAXIncrementArrowSubrole
#define QAXIncrementPageSubrole kAXIncrementPageSubrole
#define QAXIncrementorRole kAXIncrementorRole
#define QAXLinkedUIElementsAttribute kAXLinkedUIElementsAttribute
#define QAXListRole kAXListRole
#define QAXMainAttribute kAXMainAttribute
#define QAXMaxValueAttribute kAXMaxValueAttribute
#define QAXMenuBarRole kAXMenuBarRole
#define QAXMenuButtonRole kAXMenuButtonRole
#define QAXMenuClosedNotification kAXMenuClosedNotification
#define QAXMenuItemRole kAXMenuItemRole
#define QAXMenuOpenedNotification kAXMenuOpenedNotification
#define QAXMenuRole kAXMenuRole
#define QAXMinValueAttribute kAXMinValueAttribute
#define QAXMinimizeButtonAttribute kAXMinimizeButtonAttribute
#define QAXMinimizedAttribute kAXMinimizedAttribute
#define QAXNextContentsAttribute kAXNextContentsAttribute
#define QAXOrientationAttribute kAXOrientationAttribute
#define QAXParentAttribute kAXParentAttribute
#define QAXPickAction kAXPickAction
#define QAXPopUpButtonRole kAXPopUpButtonRole
#define QAXPositionAttribute kAXPositionAttribute
#define QAXPressAction kAXPressAction
#define QAXPreviousContentsAttribute kAXPreviousContentsAttribute
#define QAXProgressIndicatorRole kAXProgressIndicatorRole
#define QAXRadioButtonRole kAXRadioButtonRole
#define QAXRoleAttribute kAXRoleAttribute
#define QAXRoleDescriptionAttribute kAXRoleDescriptionAttribute
#define QAXRowRole kAXRowRole
#define QAXRowsAttribute kAXRowsAttribute
#define QAXScrollAreaRole kAXScrollAreaRole
#define QAXScrollBarRole kAXScrollBarRole
#define QAXSelectedAttribute kAXSelectedAttribute
#define QAXSelectedChildrenAttribute kAXSelectedChildrenAttribute
#define QAXSelectedRowsAttribute kAXSelectedRowsAttribute
#define QAXSizeAttribute kAXSizeAttribute
#define QAXSliderRole kAXSliderRole
#define QAXSplitGroupRole kAXSplitGroupRole
#define QAXSplitterRole kAXSplitterRole
#define QAXSplittersAttribute kAXSplittersAttribute
#define QAXStaticTextRole kAXStaticTextRole
#define QAXSubroleAttribute kAXSubroleAttribute
#define QAXTabGroupRole kAXTabGroupRole
#define QAXTableRole kAXTableRole
#define QAXTabsAttribute kAXTabsAttribute
#define QAXTextFieldRole kAXTextFieldRole
#define QAXTitleAttribute kAXTitleAttribute
#define QAXTitleUIElementAttribute kAXTitleUIElementAttribute
#define QAXToolbarButtonAttribute kAXToolbarButtonAttribute
#define QAXToolbarRole kAXToolbarRole
#define QAXTopLevelUIElementAttribute kAXTopLevelUIElementAttribute
#define QAXUnknownRole kAXUnknownRole
#define QAXValueAttribute kAXValueAttribute
#define QAXValueChangedNotification kAXValueChangedNotification
#define QAXValueIndicatorRole kAXValueIndicatorRole
#define QAXVerticalOrientationValue kAXVerticalOrientationValue
#define QAXVerticalScrollBarAttribute kAXVerticalScrollBarAttribute
#define QAXVisibleRowsAttribute kAXVisibleRowsAttribute
#define QAXWindowAttribute kAXWindowAttribute
#define QAXWindowCreatedNotification kAXWindowCreatedNotification
#define QAXWindowMovedNotification kAXWindowMovedNotification
#define QAXWindowRole kAXWindowRole
#define QAXZoomButtonAttribute kAXZoomButtonAttribute
#endif
/*****************************************************************************
Externals
*****************************************************************************/
extern bool qt_mac_is_macsheet(const QWidget *w); //qwidget_mac.cpp
extern bool qt_mac_is_macdrawer(const QWidget *w); //qwidget_mac.cpp
/*****************************************************************************
QAccessible Bindings
*****************************************************************************/
//hardcoded bindings between control info and (known) QWidgets
struct QAccessibleTextBinding {
int qt;
QAXRoleType mac;
bool settable;
} text_bindings[][10] = {
{ { QAccessible::MenuItem, QAXMenuItemRole, false },
{ -1, 0, false }
},
{ { QAccessible::MenuBar, QAXMenuBarRole, false },
{ -1, 0, false }
},
{ { QAccessible::ScrollBar, QAXScrollBarRole, false },
{ -1, 0, false }
},
{ { QAccessible::Grip, QAXGrowAreaRole, false },
{ -1, 0, false }
},
{ { QAccessible::Window, QAXWindowRole, false },
{ -1, 0, false }
},
{ { QAccessible::Dialog, QAXWindowRole, false },
{ -1, 0, false }
},
{ { QAccessible::AlertMessage, QAXWindowRole, false },
{ -1, 0, false }
},
{ { QAccessible::ToolTip, QAXWindowRole, false },
{ -1, 0, false }
},
{ { QAccessible::HelpBalloon, QAXWindowRole, false },
{ -1, 0, false }
},
{ { QAccessible::PopupMenu, QAXMenuRole, false },
{ -1, 0, false }
},
{ { QAccessible::Application, QAXApplicationRole, false },
{ -1, 0, false }
},
{ { QAccessible::Pane, QAXGroupRole, false },
{ -1, 0, false }
},
{ { QAccessible::Grouping, QAXGroupRole, false },
{ -1, 0, false }
},
{ { QAccessible::Separator, QAXSplitterRole, false },
{ -1, 0, false }
},
{ { QAccessible::ToolBar, QAXToolbarRole, false },
{ -1, 0, false }
},
{ { QAccessible::PageTab, QAXRadioButtonRole, false },
{ -1, 0, false }
},
{ { QAccessible::ButtonMenu, QAXMenuButtonRole, false },
{ -1, 0, false }
},
{ { QAccessible::ButtonDropDown, QAXPopUpButtonRole, false },
{ -1, 0, false }
},
{ { QAccessible::SpinBox, QAXIncrementorRole, false },
{ -1, 0, false }
},
{ { QAccessible::Slider, QAXSliderRole, false },
{ -1, 0, false }
},
{ { QAccessible::ProgressBar, QAXProgressIndicatorRole, false },
{ -1, 0, false }
},
{ { QAccessible::ComboBox, QAXPopUpButtonRole, false },
{ -1, 0, false }
},
{ { QAccessible::RadioButton, QAXRadioButtonRole, false },
{ -1, 0, false }
},
{ { QAccessible::CheckBox, QAXCheckBoxRole, false },
{ -1, 0, false }
},
{ { QAccessible::StaticText, QAXStaticTextRole, false },
{ QAccessible::Name, QAXValueAttribute, false },
{ -1, 0, false }
},
{ { QAccessible::Table, QAXTableRole, false },
{ -1, 0, false }
},
{ { QAccessible::StatusBar, QAXStaticTextRole, false },
{ -1, 0, false }
},
{ { QAccessible::Column, QAXColumnRole, false },
{ -1, 0, false }
},
{ { QAccessible::ColumnHeader, QAXColumnRole, false },
{ -1, 0, false }
},
{ { QAccessible::Row, QAXRowRole, false },
{ -1, 0, false }
},
{ { QAccessible::RowHeader, QAXRowRole, false },
{ -1, 0, false }
},
{ { QAccessible::Cell, QAXTextFieldRole, false },
{ -1, 0, false }
},
{ { QAccessible::PushButton, QAXButtonRole, false },
{ -1, 0, false }
},
{ { QAccessible::EditableText, QAXTextFieldRole, true },
{ -1, 0, false }
},
{ { QAccessible::Link, QAXTextFieldRole, false },
{ -1, 0, false }
},
{ { QAccessible::Indicator, QAXValueIndicatorRole, false },
{ -1, 0, false }
},
{ { QAccessible::Splitter, QAXSplitGroupRole, false },
{ -1, 0, false }
},
{ { QAccessible::List, QAXListRole, false },
{ -1, 0, false }
},
{ { QAccessible::ListItem, QAXStaticTextRole, false },
{ -1, 0, false }
},
{ { QAccessible::Cell, QAXStaticTextRole, false },
{ -1, 0, false }
},
{ { -1, 0, false } }
};
class QAInterface;
static CFStringRef macRole(const QAInterface &interface);
QDebug operator<<(QDebug debug, const QAInterface &interface)
{
if (interface.isValid() == false)
debug << "invalid interface";
else
debug << interface.object() << "id" << interface.id() << "role" << hex << interface.role();
return debug;
}
// The root of the Qt accessible hiearchy.
static QObject *rootObject = 0;
bool QAInterface::operator==(const QAInterface &other) const
{
if (isValid() == false || other.isValid() == false)
return (isValid() && other.isValid());
// walk up the parent chain, comparing child indexes, until we reach
// an interface that has a QObject.
QAInterface currentThis = *this;
QAInterface currentOther = other;
while (currentThis.object() == 0) {
if (currentOther.object() != 0)
return false;
// fail if the child indexes in the two hirearchies don't match.
if (currentThis.parent().indexOfChild(currentThis) !=
currentOther.parent().indexOfChild(currentOther))
return false;
currentThis = currentThis.parent();
currentOther = currentOther.parent();
}
return (currentThis.object() == currentOther.object() && currentThis.id() == currentOther.id());
}
bool QAInterface::operator!=(const QAInterface &other) const
{
return !operator==(other);
}
uint qHash(const QAInterface &item)
{
if (item.isValid())
return qHash(item.object()) + qHash(item.id());
else
return qHash(item.cachedObject()) + qHash(item.id());
}
QAInterface QAInterface::navigate(RelationFlag relation, int entry) const
{
if (!checkValid())
return QAInterface();
// On a QAccessibleInterface that handles its own children we can short-circut
// the navigation if this QAInterface refers to one of the children:
if (child != 0) {
// The Ancestor interface will always be the same QAccessibleInterface with
// a child value of 0.
if (relation == QAccessible::Ancestor)
return QAInterface(*this, 0);
// The child hiearchy is only one level deep, so navigating to a child
// of a child is not possible.
if (relation == QAccessible::Child) {
return QAInterface();
}
}
QAccessibleInterface *child_iface = 0;
const int status = base.interface->navigate(relation, entry, &child_iface);
if (status == -1)
return QAInterface(); // not found;
// Check if target is a child of this interface.
if (!child_iface) {
return QAInterface(*this, status);
} else {
// Target is child_iface or a child of that (status decides).
return QAInterface(child_iface, status);
}
}
QAElement::QAElement()
:elementRef(0)
{}
QAElement::QAElement(AXUIElementRef elementRef)
:elementRef(elementRef)
{
if (elementRef != 0) {
CFRetain(elementRef);
CFRetain(object());
}
}
QAElement::QAElement(const QAElement &element)
:elementRef(element.elementRef)
{
if (elementRef != 0) {
CFRetain(elementRef);
CFRetain(object());
}
}
QAElement::QAElement(HIObjectRef object, int child)
{
#ifndef QT_MAC_USE_COCOA
if (object == 0) {
elementRef = 0; // Create invalid QAElement.
} else {
elementRef = AXUIElementCreateWithHIObjectAndIdentifier(object, child);
CFRetain(object);
}
#else
Q_UNUSED(object);
Q_UNUSED(child);
#endif
}
QAElement::~QAElement()
{
if (elementRef != 0) {
CFRelease(object());
CFRelease(elementRef);
}
}
void QAElement::operator=(const QAElement &other)
{
if (*this == other)
return;
if (elementRef != 0) {
CFRelease(object());
CFRelease(elementRef);
}
elementRef = other.elementRef;
if (elementRef != 0) {
CFRetain(elementRef);
CFRetain(object());
}
}
bool QAElement::operator==(const QAElement &other) const
{
if (elementRef == 0 || other.elementRef == 0)
return (elementRef == other.elementRef);
return CFEqual(elementRef, other.elementRef);
}
uint qHash(QAElement element)
{
return qHash(element.object()) + qHash(element.id());
}
#ifndef QT_MAC_USE_COCOA
static QInterfaceFactory *createFactory(const QAInterface &interface);
#endif
Q_GLOBAL_STATIC(QAccessibleHierarchyManager, accessibleHierarchyManager);
/*
Reomves all accessibility info accosiated with the sender object.
*/
void QAccessibleHierarchyManager::objectDestroyed(QObject *object)
{
HIObjectRef hiObject = qobjectHiobjectHash.value(object);
delete qobjectElementHash.value(object);
qobjectElementHash.remove(object);
hiobjectInterfaceHash.remove(hiObject);
}
/*
Removes all stored items.
*/
void QAccessibleHierarchyManager::reset()
{
qDeleteAll(qobjectElementHash);
qobjectElementHash.clear();
hiobjectInterfaceHash.clear();
qobjectHiobjectHash.clear();
}
QAccessibleHierarchyManager *QAccessibleHierarchyManager::instance()
{
return accessibleHierarchyManager();
}
#ifndef QT_MAC_USE_COCOA
static bool isItemView(const QAInterface &interface)
{
QObject *object = interface.object();
return (interface.role() == QAccessible::List || interface.role() == QAccessible::Table
|| (object && qobject_cast<QAbstractItemView *>(interface.object()))
|| (object && object->objectName() == QLatin1String("qt_scrollarea_viewport")
&& qobject_cast<QAbstractItemView *>(object->parent())));
}
#endif
static bool isTabWidget(const QAInterface &interface)
{
if (QObject *object = interface.object())
return (object->inherits("QTabWidget") && interface.id() == 0);
return false;
}
static bool isStandaloneTabBar(const QAInterface &interface)
{
QObject *object = interface.object();
if (interface.role() == QAccessible::PageTabList && object)
return (qobject_cast<QTabWidget *>(object->parent()) == 0);
return false;
}
static bool isEmbeddedTabBar(const QAInterface &interface)
{
QObject *object = interface.object();
if (interface.role() == QAccessible::PageTabList && object)
return (qobject_cast<QTabWidget *>(object->parent()));
return false;
}
/*
Decides if a QAInterface is interesting from an accessibility users point of view.
*/
bool isItInteresting(const QAInterface &interface)
{
// Mac accessibility does not have an attribute that corresponds to the Invisible/Offscreen
// state, so we disable the interface here.
const QAccessible::State state = interface.state();
if (state & QAccessible::Invisible ||
state & QAccessible::Offscreen )
return false;
const QAccessible::Role role = interface.role();
if (QObject * const object = interface.object()) {
const QString className = QLatin1String(object->metaObject()->className());
// VoiceOver focusing on tool tips can be confusing. The contents of the
// tool tip is avalible through the description attribute anyway, so
// we disable accessibility for tool tips.
if (className == QLatin1String("QTipLabel"))
return false;
// Hide TabBars that has a QTabWidget parent (the tab widget handles the accessibility)
if (isEmbeddedTabBar(interface))
return false;
// Hide docked dockwidgets. ### causes infinitie loop in the apple accessibility code.
/* if (QDockWidget *dockWidget = qobject_cast<QDockWidget *>(object)) {
if (dockWidget->isFloating() == false)
return false;
}
*/
}
// Client is a generic role returned by plain QWidgets or other
// widgets that does not have separate QAccessible interface, such
// as the TabWidget. Return false unless macRole gives the interface
// a special role.
if (role == QAccessible::Client && macRole(interface) == CFStringRef(QAXUnknownRole))
return false;
// Some roles are not interesting:
if (role == QAccessible::Border || // QFrame
role == QAccessible::Application || // We use the system-provided application element.
role == QAccessible::MenuItem) // The system also provides the menu items.
return false;
// It is probably better to access the toolbar buttons directly than having
// to navigate through the toolbar.
if (role == QAccessible::ToolBar)
return false;
return true;
}
QAElement QAccessibleHierarchyManager::registerInterface(QObject *object, int child)
{
#ifndef QT_MAC_USE_COCOA
return registerInterface(QAInterface(QAccessible::queryAccessibleInterface(object), child));
#else
Q_UNUSED(object);
Q_UNUSED(child);
return QAElement();
#endif
}
/*
Creates a QAXUIelement that corresponds to the given QAInterface.
*/
QAElement QAccessibleHierarchyManager::registerInterface(const QAInterface &interface)
{
#ifndef QT_MAC_USE_COCOA
if (interface.isValid() == false)
return QAElement();
QAInterface objectInterface = interface.objectInterface();
QObject * qobject = objectInterface.object();
HIObjectRef hiobject = objectInterface.hiObject();
if (qobject == 0 || hiobject == 0)
return QAElement();
if (qobjectElementHash.contains(qobject) == false) {
registerInterface(qobject, hiobject, createFactory(interface));
HIObjectSetAccessibilityIgnored(hiobject, !isItInteresting(interface));
}
return QAElement(hiobject, interface.id());
#else
Q_UNUSED(interface);
return QAElement();
#endif
}
#ifndef QT_MAC_USE_COCOA
#include "qaccessible_mac_carbon.cpp"
#endif
void QAccessibleHierarchyManager::registerInterface(QObject * qobject, HIObjectRef hiobject, QInterfaceFactory *interfaceFactory)
{
#ifndef QT_MAC_USE_COCOA
if (qobjectElementHash.contains(qobject) == false) {
qobjectElementHash.insert(qobject, interfaceFactory);
qobjectHiobjectHash.insert(qobject, hiobject);
connect(qobject, SIGNAL(destroyed(QObject *)), SLOT(objectDestroyed(QObject *)));
}
if (hiobjectInterfaceHash.contains(hiobject) == false) {
hiobjectInterfaceHash.insert(hiobject, interfaceFactory);
installAcessibilityEventHandler(hiobject);
}
#else
Q_UNUSED(qobject);
Q_UNUSED(hiobject);
Q_UNUSED(interfaceFactory);
#endif
}
void QAccessibleHierarchyManager::registerChildren(const QAInterface &interface)
{
QObject * const object = interface.object();
if (object == 0)
return;
QInterfaceFactory *interfaceFactory = qobjectElementHash.value(object);
if (interfaceFactory == 0)
return;
interfaceFactory->registerChildren();
}
QAInterface QAccessibleHierarchyManager::lookup(const AXUIElementRef &element)
{
if (element == 0)
return QAInterface();
#ifndef QT_MAC_USE_COCOA
HIObjectRef hiObject = AXUIElementGetHIObject(element);
QInterfaceFactory *factory = hiobjectInterfaceHash.value(hiObject);
if (factory == 0) {
return QAInterface();
}
UInt64 id;
AXUIElementGetIdentifier(element, &id);
return factory->interface(id);
#else
return QAInterface();
#endif;
}
QAInterface QAccessibleHierarchyManager::lookup(const QAElement &element)
{
return lookup(element.element());
}
QAElement QAccessibleHierarchyManager::lookup(const QAInterface &interface)
{
if (interface.isValid() == false)
return QAElement();
QInterfaceFactory *factory = qobjectElementHash.value(interface.objectInterface().object());
if (factory == 0)
return QAElement();
return factory->element(interface);
}
QAElement QAccessibleHierarchyManager::lookup(QObject * const object, int id)
{
QInterfaceFactory *factory = qobjectElementHash.value(object);
if (factory == 0)
return QAElement();
return factory->element(id);
}
/*
Standard interface mapping, return the stored interface
or HIObjectRef, and there is an one-to-one mapping between
the identifier and child.
*/
class QStandardInterfaceFactory : public QInterfaceFactory
{
public:
QStandardInterfaceFactory(const QAInterface &interface)
: m_interface(interface), object(interface.hiObject())
{
CFRetain(object);
}
~QStandardInterfaceFactory()
{
CFRelease(object);
}
QAInterface interface(UInt64 identifier)
{
const int child = identifier;
return QAInterface(m_interface, child);
}
QAElement element(int id)
{
return QAElement(object, id);
}
QAElement element(const QAInterface &interface)
{
if (interface.object() == 0)
return QAElement();
return QAElement(object, interface.id());
}
void registerChildren()
{
const int childCount = m_interface.childCount();
for (int i = 1; i <= childCount; ++i) {
accessibleHierarchyManager()->registerInterface(m_interface.navigate(QAccessible::Child, i));
}
}
private:
QAInterface m_interface;
HIObjectRef object;
};
/*
Interface mapping where that creates one HIObject for each interface child.
*/
class QMultipleHIObjectFactory : public QInterfaceFactory
{
public:
QMultipleHIObjectFactory(const QAInterface &interface)
: m_interface(interface)
{ }
~QMultipleHIObjectFactory()
{
foreach (HIObjectRef object, objects) {
CFRelease(object);
}
}
QAInterface interface(UInt64 identifier)
{
const int child = identifier;
return QAInterface(m_interface, child);
}
QAElement element(int child)
{
if (child == 0)
return QAElement(m_interface.hiObject(), 0);
if (child > objects.count())
return QAElement();
return QAElement(objects.at(child - 1), child);
}
void registerChildren()
{
#ifndef QT_MAC_USE_COCOA
const int childCount = m_interface.childCount();
for (int i = 1; i <= childCount; ++i) {
HIObjectRef hiobject;
HIObjectCreate(kObjectQtAccessibility, 0, &hiobject);
objects.append(hiobject);
accessibleHierarchyManager()->registerInterface(m_interface.object(), hiobject, this);
HIObjectSetAccessibilityIgnored(hiobject, !isItInteresting(m_interface.navigate(QAccessible::Child, i)));
}
#endif
}
private:
QAInterface m_interface;
QList<HIObjectRef> objects;
};
class QItemViewInterfaceFactory : public QInterfaceFactory
{
public:
QItemViewInterfaceFactory(const QAInterface &interface)
: m_interface(interface), object(interface.hiObject())
{
CFRetain(object);
columnCount = 0;
if (QTableView * tableView = qobject_cast<QTableView *>(interface.parent().object())) {
if (tableView->model())
columnCount = tableView->model()->columnCount();
if (tableView->verticalHeader())
++columnCount;
}
}
~QItemViewInterfaceFactory()
{
CFRelease(object);
}
QAInterface interface(UInt64 identifier)
{
if (identifier == 0)
return m_interface;
if (m_interface.role() == QAccessible::List)
return m_interface.childAt(identifier);
if (m_interface.role() == QAccessible::Table) {
const int index = identifier;
if (index == 0)
return m_interface; // return the item view interface.
const int rowIndex = (index - 1) / (columnCount + 1);
const int cellIndex = (index - 1) % (columnCount + 1);
/*
qDebug() << "index" << index;
qDebug() << "rowIndex" << rowIndex;
qDebug() << "cellIndex" << cellIndex;
*/
const QAInterface rowInterface = m_interface.childAt(rowIndex + 1);
if ((cellIndex) == 0) // Is it a row?
return rowInterface;
else {
return rowInterface.childAt(cellIndex);
}
}
return QAInterface();
}
QAElement element(int id)
{
if (id != 0) {
return QAElement();
}
return QAElement(object, 0);
}
QAElement element(const QAInterface &interface)
{
if (interface.object() && interface.object() == m_interface.object()) {
return QAElement(object, 0);
} else if (m_interface.role() == QAccessible::List) {
if (interface.parent().object() && interface.parent().object() == m_interface.object())
return QAElement(object, m_interface.indexOfChild(interface));
} else if (m_interface.role() == QAccessible::Table) {
QAInterface currentInterface = interface;
int index = 0;
while (currentInterface.isValid() && currentInterface.object() == 0) {
const QAInterface parentInterface = currentInterface.parent();
/*
qDebug() << "current index" << index;
qDebug() << "current interface" << interface;
qDebug() << "parent interface" << parentInterface;
qDebug() << "grandparent interface" << parentInterface.parent();
qDebug() << "childCount" << interface.childCount();
qDebug() << "index of child" << parentInterface.indexOfChild(currentInterface);
*/
index += ((parentInterface.indexOfChild(currentInterface) - 1) * (currentInterface.childCount() + 1)) + 1;
currentInterface = parentInterface;
// qDebug() << "new current interface" << currentInterface;
}
if (currentInterface.object() == m_interface.object())
return QAElement(object, index);
}
return QAElement();
}
void registerChildren()
{
// Item view child interfraces don't have their own qobjects, so there is nothing to register here.
}
private:
QAInterface m_interface;
HIObjectRef object;
int columnCount; // for table views;
};
#ifndef QT_MAC_USE_COCOA
static bool managesChildren(const QAInterface &interface)
{
return (interface.childCount() > 0 && interface.childAt(1).id() > 0);
}
static QInterfaceFactory *createFactory(const QAInterface &interface)
{
if (isItemView(interface)) {
return new QItemViewInterfaceFactory(interface);
} if (managesChildren(interface)) {
return new QMultipleHIObjectFactory(interface);
}
return new QStandardInterfaceFactory(interface);
}
#endif
QList<QAElement> lookup(const QList<QAInterface> &interfaces)
{
QList<QAElement> elements;
foreach (const QAInterface &interface, interfaces)
if (interface.isValid()) {
const QAElement element = accessibleHierarchyManager()->lookup(interface);
if (element.isValid())
elements.append(element);
}
return elements;
}
// Debug output helpers:
/*
static QString nameForEventKind(UInt32 kind)
{
switch(kind) {
case kEventAccessibleGetChildAtPoint: return QString("GetChildAtPoint"); break;
case kEventAccessibleGetAllAttributeNames: return QString("GetAllAttributeNames"); break;
case kEventAccessibleGetNamedAttribute: return QString("GetNamedAttribute"); break;
case kEventAccessibleSetNamedAttribute: return QString("SetNamedAttribute"); break;
case kEventAccessibleGetAllActionNames: return QString("GetAllActionNames"); break;
case kEventAccessibleGetFocusedChild: return QString("GetFocusedChild"); break;
default:
return QString("Unknown accessibility event type: %1").arg(kind);
break;
};
}
*/
#ifndef QT_MAC_USE_COCOA
static bool qt_mac_append_cf_uniq(CFMutableArrayRef array, CFTypeRef value)
{
if (value == 0)
return false;
CFRange range;
range.location = 0;
range.length = CFArrayGetCount(array);
if(!CFArrayContainsValue(array, range, value)) {
CFArrayAppendValue(array, value);
return true;
}
return false;
}
static OSStatus setAttributeValue(EventRef event, const QList<QAElement> &elements)
{
CFMutableArrayRef array = CFArrayCreateMutable(0, 0, &kCFTypeArrayCallBacks);
foreach (const QAElement &element, elements) {
if (element.isValid())
CFArrayAppendValue(array, element.element());
}
const OSStatus err = SetEventParameter(event, kEventParamAccessibleAttributeValue,
typeCFTypeRef, sizeof(array), &array);
CFRelease(array);
return err;
}
#endif //QT_MAC_USE_COCOA
/*
Gets the AccessibleObject parameter from an event.
*/
static inline AXUIElementRef getAccessibleObjectParameter(EventRef event)
{
AXUIElementRef element;
GetEventParameter(event, kEventParamAccessibleObject, typeCFTypeRef, 0,
sizeof(element), 0, &element);
return element;
}
/*
The application event handler makes sure that all top-level qt windows are registered
before any accessibility events are handeled.
*/
#ifndef QT_MAC_USE_COCOA
static OSStatus applicationEventHandler(EventHandlerCallRef next_ref, EventRef event, void *)
{
QAInterface rootInterface(QAccessible::queryAccessibleInterface(rootObject ? rootObject : qApp), 0);
accessibleHierarchyManager()->registerChildren(rootInterface);
return CallNextEventHandler(next_ref, event);
}
/*
Returns the value for element by combining the QAccessibility::Checked and
QAccessibility::Mixed flags into an int value that the Mac accessibilty
system understands. This works for check boxes, radio buttons, and the like.
The return values are:
0: unchecked
1: checked
2: undecided
*/
static int buttonValue(QAInterface element)
{
const QAccessible::State state = element.state();
if (state & QAccessible::Mixed)
return 2;
else if(state & QAccessible::Checked)
return 1;
else
return 0;
}
static QString getValue(const QAInterface &interface)
{
const QAccessible::Role role = interface.role();
if (role == QAccessible::RadioButton || role == QAccessible::CheckBox)
return QString::number(buttonValue(interface));
else
return interface.text(QAccessible::Value);
}
#endif //QT_MAC_USE_COCOA
/*
Translates a QAccessible::Role into a mac accessibility role.
*/
static CFStringRef macRole(const QAInterface &interface)
{
const QAccessible::Role qtRole = interface.role();
// qDebug() << "role for" << interface.object() << "interface role" << hex << qtRole;
// Qt accessibility: QAccessible::Splitter contains QAccessible::Grip.
// Mac accessibility: AXSplitGroup contains AXSplitter.
if (qtRole == QAccessible::Grip) {
const QAInterface parent = interface.parent();
if (parent.isValid() && parent.role() == QAccessible::Splitter)
return CFStringRef(QAXSplitterRole);
}
// Tab widgets and standalone tab bars get the kAXTabGroupRole. Accessibility
// for tab bars emebedded in a tab widget is handled by the tab widget.
if (isTabWidget(interface) || isStandaloneTabBar(interface))
return kAXTabGroupRole;
if (QObject *object = interface.object()) {
// ### The interface for an abstract scroll area returns the generic "Client"
// role, so we have to to an extra detect on the QObject here.
if (object->inherits("QAbstractScrollArea") && interface.id() == 0)
return CFStringRef(QAXScrollAreaRole);
if (object->inherits("QDockWidget"))
return CFStringRef(QAXUnknownRole);
}
int i = 0;
int testRole = text_bindings[i][0].qt;
while (testRole != -1) {
if (testRole == qtRole)
return CFStringRef(text_bindings[i][0].mac);
++i;
testRole = text_bindings[i][0].qt;
}
// qDebug() << "got unknown role!" << interface << interface.parent();
return CFStringRef(QAXUnknownRole);
}
/*
Translates a QAccessible::Role and an attribute name into a QAccessible::Text, taking into
account execptions listed in text_bindings.
*/
#ifndef QT_MAC_USE_COCOA
static int textForRoleAndAttribute(QAccessible::Role role, CFStringRef attribute)
{
// Search for exception, return it if found.
int testRole = text_bindings[0][0].qt;
int i = 0;
while (testRole != -1) {
if (testRole == role) {
int j = 1;
int qtRole = text_bindings[i][j].qt;
CFStringRef testAttribute = CFStringRef(text_bindings[i][j].mac);
while (qtRole != -1) {
if (CFStringCompare(attribute, testAttribute, 0) == kCFCompareEqualTo) {
return (QAccessible::Text)qtRole;
}
++j;
testAttribute = CFStringRef(text_bindings[i][j].mac); /// ### custom compare
qtRole = text_bindings[i][j].qt; /// ### custom compare
}
break;
}
++i;
testRole = text_bindings[i][0].qt;
}
// Return default mappping
if (CFStringCompare(attribute, CFStringRef(QAXTitleAttribute), 0) == kCFCompareEqualTo)
return QAccessible::Name;
else if (CFStringCompare(attribute, CFStringRef(QAXValueAttribute), 0) == kCFCompareEqualTo)
return QAccessible::Value;
else if (CFStringCompare(attribute, CFStringRef(QAXHelpAttribute), 0) == kCFCompareEqualTo)
return QAccessible::Help;
else if (CFStringCompare(attribute, CFStringRef(QAXDescriptionAttribute), 0) == kCFCompareEqualTo)
return QAccessible::Description;
else
return -1;
}
/*
Returns the subrole string constant for the interface if it has one,
else returns an empty string.
*/
static QCFString subrole(const QAInterface &interface)
{
const QAInterface parent = interface.parent();
if (parent.isValid() == false)
return QCFString();
if (parent.role() == QAccessible::ScrollBar) {
QCFString subrole;
switch(interface.id()) {
case 1: subrole = CFStringRef(QAXDecrementArrowSubrole); break;
case 2: subrole = CFStringRef(QAXDecrementPageSubrole); break;
case 4: subrole = CFStringRef(QAXIncrementPageSubrole); break;
case 5: subrole = CFStringRef(QAXIncrementArrowSubrole); break;
default:
break;
}
return subrole;
}
return QCFString();
}
// Gets the scroll bar orientation by asking the QAbstractSlider object directly.
static Qt::Orientation scrollBarOrientation(const QAInterface &scrollBar)
{
QObject *const object = scrollBar.object();
if (QAbstractSlider * const sliderObject = qobject_cast<QAbstractSlider * const>(object))
return sliderObject->orientation();
return Qt::Vertical; // D'oh! The interface wasn't a scroll bar.
}
static QAInterface scrollAreaGetScrollBarInterface(const QAInterface &scrollArea, Qt::Orientation orientation)
{
if (macRole(scrollArea) != CFStringRef(CFStringRef(QAXScrollAreaRole)))
return QAInterface();
// Child 1 is the contents widget, 2 and 3 are the scroll bar containers wich contains possible scroll bars.
for (int i = 2; i <= 3; ++i) {
QAInterface scrollBarContainer = scrollArea.childAt(i);
for (int i = 1; i <= scrollBarContainer.childCount(); ++i) {
QAInterface scrollBar = scrollBarContainer.childAt(i);
if (scrollBar.isValid() &&
scrollBar.role() == QAccessible::ScrollBar &&
scrollBarOrientation(scrollBar) == orientation)
return scrollBar;
}
}
return QAInterface();
}
static bool scrollAreaHasScrollBar(const QAInterface &scrollArea, Qt::Orientation orientation)
{
return scrollAreaGetScrollBarInterface(scrollArea, orientation).isValid();
}
static QAElement scrollAreaGetScrollBar(const QAInterface &scrollArea, Qt::Orientation orientation)
{
return accessibleHierarchyManager()->lookup(scrollAreaGetScrollBarInterface(scrollArea, orientation));
}
static QAElement scrollAreaGetContents(const QAInterface &scrollArea)
{
// Child 1 is the contents widget,
return accessibleHierarchyManager()->lookup(scrollArea.navigate(QAccessible::Child, 1));
}
static QAElement tabWidgetGetContents(const QAInterface &interface)
{
// A kAXTabGroup has a kAXContents attribute, which consists of the
// ui elements for the current tab page. Get the current tab page
// from the QStackedWidget, where the current visible page can
// be found at index 1.
QAInterface stackedWidget = interface.childAt(1);
accessibleHierarchyManager()->registerChildren(stackedWidget);
QAInterface tabPageInterface = stackedWidget.childAt(1);
return accessibleHierarchyManager()->lookup(tabPageInterface);
}
static QList<QAElement> tabBarGetTabs(const QAInterface &interface)
{
// Get the tabs by searching for children with the "PageTab" role.
// This filters out the left/right navigation buttons.
accessibleHierarchyManager()->registerChildren(interface);
QList<QAElement> tabs;
const int numChildren = interface.childCount();
for (int i = 1; i < numChildren + 1; ++i) {
QAInterface child = interface.navigate(QAccessible::Child, i);
if (child.isValid() && child.role() == QAccessible::PageTab) {
tabs.append(accessibleHierarchyManager()->lookup(child));
}
}
return tabs;
}
static QList<QAElement> tabWidgetGetTabs(const QAInterface &interface)
{
// Each QTabWidget has two children, a QStackedWidget and a QTabBar.
// Get the tabs from the QTabBar.
return tabBarGetTabs(interface.childAt(2));
}
static QList<QAElement> tabWidgetGetChildren(const QAInterface &interface)
{
// The children for a kAXTabGroup should consist of the tabs and the
// contents of the current open tab page.
QList<QAElement> children = tabWidgetGetTabs(interface);
children += tabWidgetGetContents(interface);
return children;
}
#endif //QT_MAC_USE_COCOA
/*
Returns the label (buddy) interface for interface, or 0 if it has none.
*/
/*
static QAInterface findLabel(const QAInterface &interface)
{
return interface.navigate(QAccessible::Label, 1);
}
*/
/*
Returns a list of interfaces this interface labels, or an empty list if it doesn't label any.
*/
/*
static QList<QAInterface> findLabelled(const QAInterface &interface)
{
QList<QAInterface> interfaceList;
int count = 1;
const QAInterface labelled = interface.navigate(QAccessible::Labelled, count);
while (labelled.isValid()) {
interfaceList.append(labelled);
++count;
}
return interfaceList;
}
*/
/*
Tests if the given QAInterface has data for a mac attribute.
*/
#ifndef QT_MAC_USE_COCOA
static bool supportsAttribute(CFStringRef attribute, const QAInterface &interface)
{
const int text = textForRoleAndAttribute(interface.role(), attribute);
// Special case: Static texts don't have a title.
if (interface.role() == QAccessible::StaticText && attribute == CFStringRef(QAXTitleAttribute))
return false;
// Return true if we the attribute matched a QAccessible::Role and we get text for that role from the interface.
if (text != -1) {
if (text == QAccessible::Value) // Special case for Value, see getValue()
return !getValue(interface).isEmpty();
else
return !interface.text((QAccessible::Text)text).isEmpty();
}
if (CFStringCompare(attribute, CFStringRef(QAXChildrenAttribute), 0) == kCFCompareEqualTo) {
if (interface.childCount() > 0)
return true;
}
if (CFStringCompare(attribute, CFStringRef(QAXSubroleAttribute), 0) == kCFCompareEqualTo) {
return (subrole(interface) != QCFString());
}
return false;
}
static void appendIfSupported(CFMutableArrayRef array, CFStringRef attribute, const QAInterface &interface)
{
if (supportsAttribute(attribute, interface))
qt_mac_append_cf_uniq(array, attribute);
}
/*
Returns the names of the attributes the give QAInterface supports.
*/
static OSStatus getAllAttributeNames(EventRef event, const QAInterface &interface, EventHandlerCallRef next_ref)
{
// Call system event handler.
OSStatus err = CallNextEventHandler(next_ref, event);
if(err != noErr && err != eventNotHandledErr)
return err;
CFMutableArrayRef attrs = 0;
GetEventParameter(event, kEventParamAccessibleAttributeNames, typeCFMutableArrayRef, 0,
sizeof(attrs), 0, &attrs);
if (!attrs)
return eventNotHandledErr;
// Append attribute names that are always supported.
qt_mac_append_cf_uniq(attrs, CFStringRef(QAXPositionAttribute));
qt_mac_append_cf_uniq(attrs, CFStringRef(QAXSizeAttribute));
qt_mac_append_cf_uniq(attrs, CFStringRef(QAXRoleAttribute));
qt_mac_append_cf_uniq(attrs, CFStringRef(QAXEnabledAttribute));
qt_mac_append_cf_uniq(attrs, CFStringRef(QAXWindowAttribute));
qt_mac_append_cf_uniq(attrs, CFStringRef(QAXTopLevelUIElementAttribute));
// Append these names if the QInterafceItem returns any data for them.
appendIfSupported(attrs, CFStringRef(QAXTitleAttribute), interface);
appendIfSupported(attrs, CFStringRef(QAXValueAttribute), interface);
appendIfSupported(attrs, CFStringRef(QAXDescriptionAttribute), interface);
appendIfSupported(attrs, CFStringRef(QAXLinkedUIElementsAttribute), interface);
appendIfSupported(attrs, CFStringRef(QAXHelpAttribute), interface);
appendIfSupported(attrs, CFStringRef(QAXTitleUIElementAttribute), interface);
appendIfSupported(attrs, CFStringRef(QAXChildrenAttribute), interface);
appendIfSupported(attrs, CFStringRef(QAXSubroleAttribute), interface);
// Append attribute names based on the interaface role.
switch (interface.role()) {
case QAccessible::Window:
qt_mac_append_cf_uniq(attrs, CFStringRef(QAXMainAttribute));
qt_mac_append_cf_uniq(attrs, CFStringRef(QAXMinimizedAttribute));
qt_mac_append_cf_uniq(attrs, CFStringRef(QAXCloseButtonAttribute));
qt_mac_append_cf_uniq(attrs, CFStringRef(QAXZoomButtonAttribute));
qt_mac_append_cf_uniq(attrs, CFStringRef(QAXMinimizeButtonAttribute));
qt_mac_append_cf_uniq(attrs, CFStringRef(QAXToolbarButtonAttribute));
qt_mac_append_cf_uniq(attrs, CFStringRef(QAXGrowAreaAttribute));
break;
case QAccessible::RadioButton:
case QAccessible::CheckBox:
qt_mac_append_cf_uniq(attrs, CFStringRef(QAXMinValueAttribute));
qt_mac_append_cf_uniq(attrs, CFStringRef(QAXMaxValueAttribute));
break;
case QAccessible::ScrollBar:
qt_mac_append_cf_uniq(attrs, CFStringRef(QAXOrientationAttribute));
break;
case QAccessible::Splitter:
qt_mac_append_cf_uniq(attrs, CFStringRef(QAXSplittersAttribute));
break;
case QAccessible::Table:
qt_mac_append_cf_uniq(attrs, CFStringRef(QAXRowsAttribute));
qt_mac_append_cf_uniq(attrs, CFStringRef(QAXVisibleRowsAttribute));
qt_mac_append_cf_uniq(attrs, CFStringRef(QAXSelectedRowsAttribute));
break;
default:
break;
}
// Append attribute names based on the mac accessibility role.
const QCFString mac_role = macRole(interface);
if (mac_role == CFStringRef(QAXSplitterRole)) {
qt_mac_append_cf_uniq(attrs, CFStringRef(QAXPreviousContentsAttribute));
qt_mac_append_cf_uniq(attrs, CFStringRef(QAXNextContentsAttribute));
qt_mac_append_cf_uniq(attrs, CFStringRef(QAXOrientationAttribute));
} else if (mac_role == CFStringRef(QAXScrollAreaRole)) {
if (scrollAreaHasScrollBar(interface, Qt::Horizontal))
qt_mac_append_cf_uniq(attrs, CFStringRef(QAXHorizontalScrollBarAttribute));
if (scrollAreaHasScrollBar(interface, Qt::Vertical))
qt_mac_append_cf_uniq(attrs, CFStringRef(QAXVerticalScrollBarAttribute));
qt_mac_append_cf_uniq(attrs, CFStringRef(QAXContentsAttribute));
} else if (mac_role == CFStringRef(QAXTabGroupRole)) {
qt_mac_append_cf_uniq(attrs, CFStringRef(QAXTabsAttribute));
// Only tab widgets can have the contents attribute, there is no way of getting
// the contents from a QTabBar.
if (isTabWidget(interface))
qt_mac_append_cf_uniq(attrs, CFStringRef(QAXContentsAttribute));
}
return noErr;
}
static void handleStringAttribute(EventRef event, QAccessible::Text text, const QAInterface &interface)
{
QString str = interface.text(text);
if (str.isEmpty())
return;
// Remove any html markup from the text string, or VoiceOver will read the html tags.
static QTextDocument document;
document.setHtml(str);
str = document.toPlainText();
CFStringRef cfstr = QCFString::toCFStringRef(str);
SetEventParameter(event, kEventParamAccessibleAttributeValue, typeCFStringRef, sizeof(cfstr), &cfstr);
}
/*
Handles the parent attribute for a interface.
There are basically three cases here:
1. interface is a HIView and has only HIView children.
2. interface is a HIView but has children that is not a HIView
3. interface is not a HIView.
*/
static OSStatus handleChildrenAttribute(EventHandlerCallRef next_ref, EventRef event, QAInterface &interface)
{
// Add the children for this interface to the global QAccessibelHierachyManager.
accessibleHierarchyManager()->registerChildren(interface);
if (isTabWidget(interface)) {
QList<QAElement> children = tabWidgetGetChildren(interface);
const int childCount = children.count();
CFMutableArrayRef array = 0;
array = CFArrayCreateMutable(0, 0, &kCFTypeArrayCallBacks);
for (int i = 0; i < childCount; ++i) {
qt_mac_append_cf_uniq(array, children.at(i).element());
}
OSStatus err;
err = SetEventParameter(event, kEventParamAccessibleAttributeValue, typeCFArrayRef, sizeof(array), &array);
if (err != noErr)
qWarning("Qt:Internal error (%s:%d)", __FILE__, __LINE__);
return noErr;
}
const QList<QAElement> children = lookup(interface.children());
const int childCount = children.count();
OSStatus err = eventNotHandledErr;
if (interface.isHIView())
err = CallNextEventHandler(next_ref, event);
CFMutableArrayRef array = 0;
int arraySize = 0;
if (err == noErr) {
CFTypeRef obj = 0;
err = GetEventParameter(event, kEventParamAccessibleAttributeValue, typeCFTypeRef, NULL , sizeof(obj), NULL, &obj);
if (err == noErr && obj != 0) {
array = (CFMutableArrayRef)obj;
arraySize = CFArrayGetCount(array);
}
}
if (array) {
CFArrayRemoveAllValues(array);
for (int i = 0; i < childCount; ++i) {
qt_mac_append_cf_uniq(array, children.at(i).element());
}
} else {
array = CFArrayCreateMutable(0, 0, &kCFTypeArrayCallBacks);
for (int i = 0; i < childCount; ++i) {
qt_mac_append_cf_uniq(array, children.at(i).element());
}
err = SetEventParameter(event, kEventParamAccessibleAttributeValue, typeCFArrayRef, sizeof(array), &array);
if (err != noErr)
qWarning("Qt:Internal error (%s:%d)", __FILE__, __LINE__);
}
return noErr;
}
/*
*/
static OSStatus handleParentAttribute(EventHandlerCallRef next_ref, EventRef event, const QAInterface &interface)
{
OSStatus err = eventNotHandledErr;
if (interface.isHIView()) {
err = CallNextEventHandler(next_ref, event);
}
if (err == noErr)
return err;
const QAInterface parentInterface = interface.navigate(QAccessible::Ancestor, 1);
const QAElement parentElement = accessibleHierarchyManager()->lookup(parentInterface);
if (parentElement.isValid() == false)
return eventNotHandledErr;
AXUIElementRef elementRef = parentElement.element();
SetEventParameter(event, kEventParamAccessibleAttributeValue, typeCFTypeRef, sizeof(elementRef), &elementRef);
return noErr;
}
#endif
struct IsWindowTest
{
static inline bool test(const QAInterface &interface)
{
return (interface.role() == QAccessible::Window);
}
};
struct IsWindowAndNotDrawerOrSheetTest
{
static inline bool test(const QAInterface &interface)
{
QWidget * const widget = qobject_cast<QWidget*>(interface.object());
return (interface.role() == QAccessible::Window &&
widget && widget->isWindow() &&
!qt_mac_is_macdrawer(widget) &&
!qt_mac_is_macsheet(widget));
}
};
/*
Navigates up the iterfaces ancestor hierachy until a QAccessibleInterface that
passes the Test is found. If we reach a interface that is a HIView we stop the
search and call AXUIElementCopyAttributeValue.
*/
template <typename TestType>
OSStatus navigateAncestors(EventHandlerCallRef next_ref, EventRef event, const QAInterface &interface, CFStringRef attribute)
{
if (interface.isHIView())
return CallNextEventHandler(next_ref, event);
QAInterface current = interface;
QAElement element;
while (current.isValid()) {
if (TestType::test(interface)) {
element = accessibleHierarchyManager()->lookup(current);
break;
}
// If we reach an InterfaceItem that is a HiView we can hand of the search to
// the system event handler. This is the common case.
if (current.isHIView()) {
CFTypeRef value = 0;
const QAElement currentElement = accessibleHierarchyManager()->lookup(current);
AXError err = AXUIElementCopyAttributeValue(currentElement.element(), attribute, &value);
AXUIElementRef newElement = (AXUIElementRef)value;
if (err == noErr)
element = QAElement(newElement);
if (newElement != 0)
CFRelease(newElement);
break;
}
QAInterface next = current.parent();
if (next.isValid() == false)
break;
if (next == current)
break;
current = next;
}
if (element.isValid() == false)
return eventNotHandledErr;
AXUIElementRef elementRef = element.element();
SetEventParameter(event, kEventParamAccessibleAttributeValue, typeCFTypeRef,
sizeof(elementRef), &elementRef);
return noErr;
}
/*
Returns the top-level window for an interface, which is the closest ancestor interface that
has the Window role, but is not a sheet or a drawer.
*/
#ifndef QT_MAC_USE_COCOA
static OSStatus handleWindowAttribute(EventHandlerCallRef next_ref, EventRef event, const QAInterface &interface)
{
return navigateAncestors<IsWindowAndNotDrawerOrSheetTest>(next_ref, event, interface, CFStringRef(QAXWindowAttribute));
}
/*
Returns the top-level window for an interface, which is the closest ancestor interface that
has the Window role. (Can also be a sheet or a drawer)
*/
static OSStatus handleTopLevelUIElementAttribute(EventHandlerCallRef next_ref, EventRef event, const QAInterface &interface)
{
return navigateAncestors<IsWindowTest>(next_ref, event, interface, CFStringRef(QAXTopLevelUIElementAttribute));
}
/*
Returns the tab buttons for an interface.
*/
static OSStatus handleTabsAttribute(EventHandlerCallRef next_ref, EventRef event, QAInterface &interface)
{
Q_UNUSED(next_ref);
if (isTabWidget(interface))
return setAttributeValue(event, tabWidgetGetTabs(interface));
else
return setAttributeValue(event, tabBarGetTabs(interface));
}
static OSStatus handlePositionAttribute(EventHandlerCallRef, EventRef event, const QAInterface &interface)
{
QPoint qpoint(interface.rect().topLeft());
HIPoint point;
point.x = qpoint.x();
point.y = qpoint.y();
SetEventParameter(event, kEventParamAccessibleAttributeValue, typeHIPoint, sizeof(point), &point);
return noErr;
}
static OSStatus handleSizeAttribute(EventHandlerCallRef, EventRef event, const QAInterface &interface)
{
QSize qSize(interface.rect().size());
HISize size;
size.width = qSize.width();
size.height = qSize.height();
SetEventParameter(event, kEventParamAccessibleAttributeValue, typeHISize, sizeof(size), &size);
return noErr;
}
static OSStatus handleSubroleAttribute(EventHandlerCallRef, EventRef event, const QAInterface &interface)
{
const QCFString role = subrole(interface);
CFStringRef rolestr = (CFStringRef)role;
SetEventParameter(event, kEventParamAccessibleAttributeValue, typeCFTypeRef, sizeof(rolestr), &rolestr);
return noErr;
}
static OSStatus handleOrientationAttribute(EventHandlerCallRef next_ref, EventRef event, const QAInterface &interface)
{
QObject *const object = interface.object();
Qt::Orientation orientation;
if (interface.role() == QAccessible::ScrollBar) {
orientation = scrollBarOrientation(interface);
} else if (QSplitterHandle * const splitter = qobject_cast<QSplitterHandle * const>(object)) {
// Qt reports the layout orientation, but we want the splitter handle orientation.
orientation = (splitter->orientation() == Qt::Horizontal) ? Qt::Vertical : Qt::Horizontal;
} else {
return CallNextEventHandler(next_ref, event);
}
const CFStringRef orientationString = (orientation == Qt::Vertical)
? CFStringRef(QAXVerticalOrientationValue) : CFStringRef(QAXHorizontalOrientationValue);
SetEventParameter(event, kEventParamAccessibleAttributeValue, typeCFStringRef, sizeof(orientationString), &orientationString);
return noErr;
}
/*
Figures out the next or previous contents for a splitter.
*/
static OSStatus handleSplitterContentsAttribute(EventHandlerCallRef next_ref, EventRef event, const QAInterface &interface, QCFString nextOrPrev)
{
if (interface.isValid() == false || interface.role() != QAccessible::Grip)
return eventNotHandledErr;
const QAInterface parent = interface.parent();
if (parent.isValid() == false)
return CallNextEventHandler(next_ref, event);
if (parent.role() != QAccessible::Splitter)
return CallNextEventHandler(next_ref, event);
const QSplitter * const splitter = qobject_cast<const QSplitter * const>(parent.object());
if (splitter == 0)
return CallNextEventHandler(next_ref, event);
QWidget * const splitterHandle = qobject_cast<QWidget * const>(interface.object());
const int splitterHandleIndex = splitter->indexOf(splitterHandle);
const int widgetIndex = (nextOrPrev == QCFString(CFStringRef(QAXPreviousContentsAttribute))) ? splitterHandleIndex - 1 : splitterHandleIndex;
const QAElement contentsElement = accessibleHierarchyManager()->lookup(splitter->widget(widgetIndex), 0);
return setAttributeValue(event, QList<QAElement>() << contentsElement);
}
/*
Creates a list of all splitter handles the splitter contains.
*/
static OSStatus handleSplittersAttribute(EventHandlerCallRef next_ref, EventRef event, QAInterface &interface)
{
const QSplitter * const splitter = qobject_cast<const QSplitter * const>(interface.object());
if (splitter == 0)
return CallNextEventHandler(next_ref, event);
accessibleHierarchyManager()->registerChildren(interface);
QList<QAElement> handles;
const int visibleSplitterCount = splitter->count() -1; // skip first handle, it's always invisible.
for (int i = 0; i < visibleSplitterCount; ++i)
handles.append(accessibleHierarchyManager()->lookup(splitter->handle(i + 1), 0));
return setAttributeValue(event, handles);
}
// This handler gets the scroll bars for a scroll area
static OSStatus handleScrollBarAttribute(EventHandlerCallRef next_ref, EventRef event, QAInterface &scrollArea, Qt::Orientation orientation)
{
QAElement scrollBar = scrollAreaGetScrollBar(scrollArea, orientation);
if (scrollBar.isValid() == false)
return CallNextEventHandler(next_ref, event);
AXUIElementRef elementRef = scrollBar.element();
SetEventParameter(event, kEventParamAccessibleAttributeValue, typeCFTypeRef, sizeof(elementRef), &elementRef);
return noErr;
}
// This handler gets the contents for a scroll area or tab widget.
static OSStatus handleContentsAttribute(EventHandlerCallRef next_ref, EventRef event, QAInterface &interface)
{
const QCFString mac_role = macRole(interface);
QAElement contents;
if (mac_role == kAXTabGroupRole) {
contents = tabWidgetGetContents(interface);
} else {
contents = scrollAreaGetContents(interface);
if (contents.isValid() == false)
return CallNextEventHandler(next_ref, event);
}
return setAttributeValue(event, QList<QAElement>() << contents);
}
static OSStatus handleRowsAttribute(EventHandlerCallRef, EventRef event, QAInterface &tableView)
{
QList<QAElement> rows = lookup(tableView.children());
// kill the first row which is the horizontal header.
rows.removeAt(0);
return setAttributeValue(event, rows);
}
static OSStatus handleVisibleRowsAttribute(EventHandlerCallRef, EventRef event, QAInterface &tableView)
{
QList<QAElement> visibleRows;
QList<QAInterface> rows = tableView.children();
// kill the first row which is the horizontal header.
rows.removeAt(0);
foreach (const QAInterface &interface, rows)
if ((interface.state() & QAccessible::Invisible) == false)
visibleRows.append(accessibleHierarchyManager()->lookup(interface));
return setAttributeValue(event, visibleRows);
}
static OSStatus handleSelectedRowsAttribute(EventHandlerCallRef, EventRef event, QAInterface &tableView)
{
QList<QAElement> selectedRows;
foreach (const QAInterface &interface, tableView.children())
if ((interface.state() & QAccessible::Selected))
selectedRows.append(accessibleHierarchyManager()->lookup(interface));
return setAttributeValue(event, selectedRows);
}
static OSStatus getNamedAttribute(EventHandlerCallRef next_ref, EventRef event, QAInterface &interface)
{
CFStringRef var;
GetEventParameter(event, kEventParamAccessibleAttributeName, typeCFStringRef, 0,
sizeof(var), 0, &var);
if (CFStringCompare(var, CFStringRef(QAXChildrenAttribute), 0) == kCFCompareEqualTo) {
return handleChildrenAttribute(next_ref, event, interface);
} else if(CFStringCompare(var, CFStringRef(QAXTopLevelUIElementAttribute), 0) == kCFCompareEqualTo) {
return handleTopLevelUIElementAttribute(next_ref, event, interface);
} else if(CFStringCompare(var, CFStringRef(QAXWindowAttribute), 0) == kCFCompareEqualTo) {
return handleWindowAttribute(next_ref, event, interface);
} else if(CFStringCompare(var, CFStringRef(QAXParentAttribute), 0) == kCFCompareEqualTo) {
return handleParentAttribute(next_ref, event, interface);
} else if (CFStringCompare(var, CFStringRef(QAXPositionAttribute), 0) == kCFCompareEqualTo) {
return handlePositionAttribute(next_ref, event, interface);
} else if (CFStringCompare(var, CFStringRef(QAXSizeAttribute), 0) == kCFCompareEqualTo) {
return handleSizeAttribute(next_ref, event, interface);
} else if (CFStringCompare(var, CFStringRef(QAXRoleAttribute), 0) == kCFCompareEqualTo) {
CFStringRef role = macRole(interface);
// ###
// QWidget * const widget = qobject_cast<QWidget *>(interface.object());
// if (role == CFStringRef(QAXUnknownRole) && widget && widget->isWindow())
// role = CFStringRef(QAXWindowRole);
SetEventParameter(event, kEventParamAccessibleAttributeValue, typeCFStringRef,
sizeof(role), &role);
} else if (CFStringCompare(var, CFStringRef(QAXEnabledAttribute), 0) == kCFCompareEqualTo) {
Boolean val = !((interface.state() & QAccessible::Unavailable))
&& !((interface.state() & QAccessible::Invisible));
SetEventParameter(event, kEventParamAccessibleAttributeValue, typeBoolean,
sizeof(val), &val);
} else if (CFStringCompare(var, CFStringRef(QAXExpandedAttribute), 0) == kCFCompareEqualTo) {
Boolean val = (interface.state() & QAccessible::Expanded);
SetEventParameter(event, kEventParamAccessibleAttributeValue, typeBoolean,
sizeof(val), &val);
} else if (CFStringCompare(var, CFStringRef(QAXSelectedAttribute), 0) == kCFCompareEqualTo) {
Boolean val = (interface.state() & QAccessible::Selection);
SetEventParameter(event, kEventParamAccessibleAttributeValue, typeBoolean,
sizeof(val), &val);
} else if (CFStringCompare(var, CFStringRef(QAXFocusedAttribute), 0) == kCFCompareEqualTo) {
Boolean val = (interface.state() & QAccessible::Focus);
SetEventParameter(event, kEventParamAccessibleAttributeValue, typeBoolean,
sizeof(val), &val);
} else if (CFStringCompare(var, CFStringRef(QAXSelectedChildrenAttribute), 0) == kCFCompareEqualTo) {
const int cc = interface.childCount();
QList<QAElement> selected;
for (int i = 1; i <= cc; ++i) {
const QAInterface child_iface = interface.navigate(QAccessible::Child, i);
if (child_iface.isValid() && child_iface.state() & QAccessible::Selected)
selected.append(accessibleHierarchyManager()->lookup(child_iface));
}
return setAttributeValue(event, selected);
} else if (CFStringCompare(var, CFStringRef(QAXCloseButtonAttribute), 0) == kCFCompareEqualTo) {
if(interface.object() && interface.object()->isWidgetType()) {
Boolean val = true; //do we want to add a WState for this?
SetEventParameter(event, kEventParamAccessibleAttributeValue, typeBoolean,
sizeof(val), &val);
}
} else if (CFStringCompare(var, CFStringRef(QAXZoomButtonAttribute), 0) == kCFCompareEqualTo) {
if(interface.object() && interface.object()->isWidgetType()) {
QWidget *widget = (QWidget*)interface.object();
Boolean val = (widget->windowFlags() & Qt::WindowMaximizeButtonHint);
SetEventParameter(event, kEventParamAccessibleAttributeValue, typeBoolean,
sizeof(val), &val);
}
} else if (CFStringCompare(var, CFStringRef(QAXMinimizeButtonAttribute), 0) == kCFCompareEqualTo) {
if(interface.object() && interface.object()->isWidgetType()) {
QWidget *widget = (QWidget*)interface.object();
Boolean val = (widget->windowFlags() & Qt::WindowMinimizeButtonHint);
SetEventParameter(event, kEventParamAccessibleAttributeValue, typeBoolean,
sizeof(val), &val);
}
} else if (CFStringCompare(var, CFStringRef(QAXToolbarButtonAttribute), 0) == kCFCompareEqualTo) {
if(interface.object() && interface.object()->isWidgetType()) {
QWidget *widget = (QWidget*)interface.object();
Boolean val = qobject_cast<QMainWindow *>(widget) != 0;
SetEventParameter(event, kEventParamAccessibleAttributeValue, typeBoolean,
sizeof(val), &val);
}
} else if (CFStringCompare(var, CFStringRef(QAXGrowAreaAttribute), 0) == kCFCompareEqualTo) {
if(interface.object() && interface.object()->isWidgetType()) {
Boolean val = true; //do we want to add a WState for this?
SetEventParameter(event, kEventParamAccessibleAttributeValue, typeBoolean,
sizeof(val), &val);
}
} else if (CFStringCompare(var, CFStringRef(QAXMinimizedAttribute), 0) == kCFCompareEqualTo) {
if (interface.object() && interface.object()->isWidgetType()) {
QWidget *widget = (QWidget*)interface.object();
Boolean val = (widget->windowState() & Qt::WindowMinimized);
SetEventParameter(event, kEventParamAccessibleAttributeValue, typeBoolean,
sizeof(val), &val);
}
} else if (CFStringCompare(var, CFStringRef(QAXSubroleAttribute), 0) == kCFCompareEqualTo) {
return handleSubroleAttribute(next_ref, event, interface);
} else if (CFStringCompare(var, CFStringRef(QAXRoleDescriptionAttribute), 0) == kCFCompareEqualTo) {
#if !defined(QT_MAC_USE_COCOA)
if (HICopyAccessibilityRoleDescription) {
const CFStringRef roleDescription = HICopyAccessibilityRoleDescription(macRole(interface), 0);
SetEventParameter(event, kEventParamAccessibleAttributeValue, typeCFStringRef,
sizeof(roleDescription), &roleDescription);
} else
#endif
{
// Just use Qt::Description on 10.3
handleStringAttribute(event, QAccessible::Description, interface);
}
} else if (CFStringCompare(var, CFStringRef(QAXTitleAttribute), 0) == kCFCompareEqualTo) {
const QAccessible::Role role = interface.role();
const QAccessible::Text text = (QAccessible::Text)textForRoleAndAttribute(role, var);
handleStringAttribute(event, text, interface);
} else if (CFStringCompare(var, CFStringRef(QAXValueAttribute), 0) == kCFCompareEqualTo) {
const QAccessible::Role role = interface.role();
const QAccessible::Text text = (QAccessible::Text)textForRoleAndAttribute(role, var);
if (role == QAccessible::CheckBox || role == QAccessible::RadioButton) {
int value = buttonValue(interface);
SetEventParameter(event, kEventParamAccessibleAttributeValue, typeUInt32, sizeof(value), &value);
} else {
handleStringAttribute(event, text, interface);
}
} else if (CFStringCompare(var, CFStringRef(QAXDescriptionAttribute), 0) == kCFCompareEqualTo) {
const QAccessible::Role role = interface.role();
const QAccessible::Text text = (QAccessible::Text)textForRoleAndAttribute(role, var);
handleStringAttribute(event, text, interface);
} else if (CFStringCompare(var, CFStringRef(QAXLinkedUIElementsAttribute), 0) == kCFCompareEqualTo) {
return CallNextEventHandler(next_ref, event);
} else if (CFStringCompare(var, CFStringRef(QAXHelpAttribute), 0) == kCFCompareEqualTo) {
const QAccessible::Role role = interface.role();
const QAccessible::Text text = (QAccessible::Text)textForRoleAndAttribute(role, var);
handleStringAttribute(event, text, interface);
} else if (CFStringCompare(var, kAXTitleUIElementAttribute, 0) == kCFCompareEqualTo) {
return CallNextEventHandler(next_ref, event);
} else if (CFStringCompare(var, CFStringRef(QAXTabsAttribute), 0) == kCFCompareEqualTo) {
return handleTabsAttribute(next_ref, event, interface);
} else if (CFStringCompare(var, CFStringRef(QAXMinValueAttribute), 0) == kCFCompareEqualTo) {
// tabs we first go to the tab bar which is child #2.
QAInterface tabBarInterface = interface.childAt(2);
return handleTabsAttribute(next_ref, event, tabBarInterface);
} else if (CFStringCompare(var, CFStringRef(QAXMinValueAttribute), 0) == kCFCompareEqualTo) {
if (interface.role() == QAccessible::RadioButton || interface.role() == QAccessible::CheckBox) {
uint value = 0;
SetEventParameter(event, kEventParamAccessibleAttributeValue, typeUInt32, sizeof(value), &value);
} else {
return CallNextEventHandler(next_ref, event);
}
} else if (CFStringCompare(var, CFStringRef(QAXMaxValueAttribute), 0) == kCFCompareEqualTo) {
if (interface.role() == QAccessible::RadioButton || interface.role() == QAccessible::CheckBox) {
uint value = 2;
SetEventParameter(event, kEventParamAccessibleAttributeValue, typeUInt32, sizeof(value), &value);
} else {
return CallNextEventHandler(next_ref, event);
}
} else if (CFStringCompare(var, CFStringRef(QAXOrientationAttribute), 0) == kCFCompareEqualTo) {
return handleOrientationAttribute(next_ref, event, interface);
} else if (CFStringCompare(var, CFStringRef(QAXPreviousContentsAttribute), 0) == kCFCompareEqualTo) {
return handleSplitterContentsAttribute(next_ref, event, interface, CFStringRef(QAXPreviousContentsAttribute));
} else if (CFStringCompare(var, CFStringRef(QAXNextContentsAttribute), 0) == kCFCompareEqualTo) {
return handleSplitterContentsAttribute(next_ref, event, interface, CFStringRef(QAXNextContentsAttribute));
} else if (CFStringCompare(var, CFStringRef(QAXSplittersAttribute), 0) == kCFCompareEqualTo) {
return handleSplittersAttribute(next_ref, event, interface);
} else if (CFStringCompare(var, CFStringRef(QAXHorizontalScrollBarAttribute), 0) == kCFCompareEqualTo) {
return handleScrollBarAttribute(next_ref, event, interface, Qt::Horizontal);
} else if (CFStringCompare(var, CFStringRef(QAXVerticalScrollBarAttribute), 0) == kCFCompareEqualTo) {
return handleScrollBarAttribute(next_ref, event, interface, Qt::Vertical);
} else if (CFStringCompare(var, CFStringRef(QAXContentsAttribute), 0) == kCFCompareEqualTo) {
return handleContentsAttribute(next_ref, event, interface);
} else if (CFStringCompare(var, CFStringRef(QAXRowsAttribute), 0) == kCFCompareEqualTo) {
return handleRowsAttribute(next_ref, event, interface);
} else if (CFStringCompare(var, CFStringRef(QAXVisibleRowsAttribute), 0) == kCFCompareEqualTo) {
return handleVisibleRowsAttribute(next_ref, event, interface);
} else if (CFStringCompare(var, CFStringRef(QAXSelectedRowsAttribute), 0) == kCFCompareEqualTo) {
return handleSelectedRowsAttribute(next_ref, event, interface);
} else {
return CallNextEventHandler(next_ref, event);
}
return noErr;
}
static OSStatus isNamedAttributeSettable(EventRef event, const QAInterface &interface)
{
CFStringRef var;
GetEventParameter(event, kEventParamAccessibleAttributeName, typeCFStringRef, 0,
sizeof(var), 0, &var);
Boolean settable = false;
if (CFStringCompare(var, CFStringRef(QAXFocusedAttribute), 0) == kCFCompareEqualTo) {
settable = true;
} else {
for (int r = 0; text_bindings[r][0].qt != -1; r++) {
if(interface.role() == (QAccessible::Role)text_bindings[r][0].qt) {
for (int a = 1; text_bindings[r][a].qt != -1; a++) {
if (CFStringCompare(var, CFStringRef(text_bindings[r][a].mac), 0) == kCFCompareEqualTo) {
settable = text_bindings[r][a].settable;
break;
}
}
}
}
}
SetEventParameter(event, kEventParamAccessibleAttributeSettable, typeBoolean,
sizeof(settable), &settable);
return noErr;
}
static OSStatus getChildAtPoint(EventHandlerCallRef next_ref, EventRef event, QAInterface &interface)
{
Q_UNUSED(next_ref);
if (interface.isValid() == false)
return eventNotHandledErr;
// Add the children for this interface to the global QAccessibelHierachyManager.
accessibleHierarchyManager()->registerChildren(interface);
Point where;
GetEventParameter(event, kEventParamMouseLocation, typeQDPoint, 0, sizeof(where), 0, &where);
const QAInterface childInterface = interface.childAt(where.h, where.v);
if (childInterface.isValid() == false || childInterface == interface)
return eventNotHandledErr;
const QAElement element = accessibleHierarchyManager()->lookup(childInterface);
if (element.isValid() == false)
return eventNotHandledErr;
AXUIElementRef elementRef = element.element();
CFRetain(elementRef);
SetEventParameter(event, kEventParamAccessibleChild, typeCFTypeRef,
sizeof(elementRef), &elementRef);
return noErr;
}
/*
Returns a list of actions the given interface supports.
Currently implemented by getting the interface role and deciding based on that.
*/
static QList<QAccessible::Action> supportedPredefinedActions(const QAInterface &interface)
{
QList<QAccessible::Action> actions;
switch (interface.role()) {
default:
// Most things can be pressed.
actions.append(QAccessible::Press);
break;
}
return actions;
}
/*
Translates a predefined QAccessible::Action to a Mac action constant.
Returns an empty string if the Qt Action has no mac equivalent.
*/
static QCFString translateAction(const QAccessible::Action action)
{
switch (action) {
case QAccessible::Press:
return CFStringRef(QAXPressAction);
break;
case QAccessible::Increase:
return CFStringRef(QAXIncrementAction);
break;
case QAccessible::Decrease:
return CFStringRef(QAXDecrementAction);
break;
case QAccessible::Accept:
return CFStringRef(QAXConfirmAction);
break;
case QAccessible::Select:
return CFStringRef(QAXPickAction);
break;
case QAccessible::Cancel:
return CFStringRef(QAXCancelAction);
break;
default:
return QCFString();
break;
}
}
/*
Translates between a Mac action constant and a QAccessible::Action.
Returns QAccessible::Default action if there is no Qt predefined equivalent.
*/
static QAccessible::Action translateAction(const CFStringRef actionName)
{
if(CFStringCompare(actionName, CFStringRef(QAXPressAction), 0) == kCFCompareEqualTo) {
return QAccessible::Press;
} else if(CFStringCompare(actionName, CFStringRef(QAXIncrementAction), 0) == kCFCompareEqualTo) {
return QAccessible::Increase;
} else if(CFStringCompare(actionName, CFStringRef(QAXDecrementAction), 0) == kCFCompareEqualTo) {
return QAccessible::Decrease;
} else if(CFStringCompare(actionName, CFStringRef(QAXConfirmAction), 0) == kCFCompareEqualTo) {
return QAccessible::Accept;
} else if(CFStringCompare(actionName, CFStringRef(QAXPickAction), 0) == kCFCompareEqualTo) {
return QAccessible::Select;
} else if(CFStringCompare(actionName, CFStringRef(QAXCancelAction), 0) == kCFCompareEqualTo) {
return QAccessible::Cancel;
} else {
return QAccessible::DefaultAction;
}
}
#endif // QT_MAC_USE_COCOA
/*
Copies the translated names all supported actions for an interface into the kEventParamAccessibleActionNames
event parameter.
*/
#ifndef QT_MAC_USE_COCOA
static OSStatus getAllActionNames(EventHandlerCallRef next_ref, EventRef event, const QAInterface &interface)
{
Q_UNUSED(next_ref);
CFMutableArrayRef actions = 0;
GetEventParameter(event, kEventParamAccessibleActionNames, typeCFMutableArrayRef, 0,
sizeof(actions), 0, &actions);
// Add supported predefined actions.
const QList<QAccessible::Action> predefinedActions = supportedPredefinedActions(interface);
for (int i = 0; i < predefinedActions.count(); ++i) {
const QCFString action = translateAction(predefinedActions.at(i));
if (action != QCFString())
qt_mac_append_cf_uniq(actions, action);
}
// Add user actions
const int actionCount = interface.userActionCount();
for (int i = 0; i < actionCount; ++i) {
const QString actionName = interface.actionText(i, QAccessible::Name);
qt_mac_append_cf_uniq(actions, QCFString::toCFStringRef(actionName));
}
return noErr;
}
#endif
/*
Handles the perforNamedAction event.
*/
#ifndef QT_MAC_USE_COCOA
static OSStatus performNamedAction(EventHandlerCallRef next_ref, EventRef event, const QAInterface& interface)
{
Q_UNUSED(next_ref);
CFStringRef act;
GetEventParameter(event, kEventParamAccessibleActionName, typeCFStringRef, 0,
sizeof(act), 0, &act);
const QAccessible::Action action = translateAction(act);
// Perform built-in action
if (action != QAccessible::DefaultAction) {
interface.doAction(action, QVariantList());
return noErr;
}
// Search for user-defined actions and perform it if found.
const int actCount = interface.userActionCount();
const QString qAct = QCFString::toQString(act);
for(int i = 0; i < actCount; i++) {
if(interface.actionText(i, QAccessible::Name) == qAct) {
interface.doAction(i, QVariantList());
break;
}
}
return noErr;
}
static OSStatus setNamedAttribute(EventHandlerCallRef next_ref, EventRef event, const QAInterface &interface)
{
Q_UNUSED(next_ref);
Q_UNUSED(event);
CFStringRef var;
GetEventParameter(event, kEventParamAccessibleAttributeName, typeCFStringRef, 0,
sizeof(var), 0, &var);
if(CFStringCompare(var, CFStringRef(QAXFocusedAttribute), 0) == kCFCompareEqualTo) {
CFTypeRef val;
if(GetEventParameter(event, kEventParamAccessibleAttributeValue, typeCFTypeRef, 0,
sizeof(val), 0, &val) == noErr) {
if(CFGetTypeID(val) == CFBooleanGetTypeID() &&
CFEqual(static_cast<CFBooleanRef>(val), kCFBooleanTrue)) {
interface.doAction(QAccessible::SetFocus);
}
}
} else {
bool found = false;
for(int r = 0; text_bindings[r][0].qt != -1; r++) {
if(interface.role() == (QAccessible::Role)text_bindings[r][0].qt) {
for(int a = 1; text_bindings[r][a].qt != -1; a++) {
if(CFStringCompare(var, CFStringRef(text_bindings[r][a].mac), 0) == kCFCompareEqualTo) {
if(!text_bindings[r][a].settable) {
} else {
CFTypeRef val;
if(GetEventParameter(event, kEventParamAccessibleAttributeValue, typeCFTypeRef, 0,
sizeof(val), 0, &val) == noErr) {
if(CFGetTypeID(val) == CFStringGetTypeID())
interface.setText((QAccessible::Text)text_bindings[r][a].qt,
QCFString::toQString(static_cast<CFStringRef>(val)));
}
}
found = true;
break;
}
}
break;
}
}
}
return noErr;
}
/*
This is the main accessibility event handler.
*/
static OSStatus accessibilityEventHandler(EventHandlerCallRef next_ref, EventRef event, void *data)
{
Q_UNUSED(data)
// Return if this event is not a AccessibleGetNamedAttribute event.
const UInt32 eclass = GetEventClass(event);
if (eclass != kEventClassAccessibility)
return eventNotHandledErr;
// Get the AXUIElementRef and QAInterface pointer
AXUIElementRef element = 0;
GetEventParameter(event, kEventParamAccessibleObject, typeCFTypeRef, 0, sizeof(element), 0, &element);
QAInterface interface = accessibleHierarchyManager()->lookup(element);
if (interface.isValid() == false)
return eventNotHandledErr;
const UInt32 ekind = GetEventKind(event);
OSStatus status = noErr;
switch (ekind) {
case kEventAccessibleGetAllAttributeNames:
status = getAllAttributeNames(event, interface, next_ref);
break;
case kEventAccessibleGetNamedAttribute:
status = getNamedAttribute(next_ref, event, interface);
break;
case kEventAccessibleIsNamedAttributeSettable:
status = isNamedAttributeSettable(event, interface);
break;
case kEventAccessibleGetChildAtPoint:
status = getChildAtPoint(next_ref, event, interface);
break;
case kEventAccessibleGetAllActionNames:
status = getAllActionNames(next_ref, event, interface);
break;
case kEventAccessibleGetFocusedChild:
status = CallNextEventHandler(next_ref, event);
break;
case kEventAccessibleSetNamedAttribute:
status = setNamedAttribute(next_ref, event, interface);
break;
case kEventAccessiblePerformNamedAction:
status = performNamedAction(next_ref, event, interface);
break;
default:
status = CallNextEventHandler(next_ref, event);
break;
};
return status;
}
#endif
void QAccessible::initialize()
{
#ifndef QT_MAC_USE_COCOA
registerQtAccessibilityHIObjectSubclass();
installApplicationEventhandler();
#endif
}
// Sets thre root object for the application
void QAccessible::setRootObject(QObject *object)
{
// Call installed root object handler if we have one
if (rootObjectHandler) {
rootObjectHandler(object);
return;
}
rootObject = object;
}
void QAccessible::cleanup()
{
accessibleHierarchyManager()->reset();
#ifndef QT_MAC_USE_COCOA
removeEventhandler(applicationEventHandlerUPP);
removeEventhandler(objectCreateEventHandlerUPP);
removeEventhandler(accessibilityEventHandlerUPP);
#endif
}
void QAccessible::updateAccessibility(QObject *object, int child, Event reason)
{
// Call installed update handler if we have one.
if (updateHandler) {
updateHandler(object, child, reason);
return;
}
#ifndef QT_MAC_USE_COCOA
// Return if the mac accessibility is not enabled.
if(!AXAPIEnabled())
return;
// Work around crash, disable accessiblity for focus frames.
if (qstrcmp(object->metaObject()->className(), "QFocusFrame") == 0)
return;
// qDebug() << "updateAccessibility" << object << child << hex << reason;
if (reason == ObjectShow) {
QAInterface interface = QAInterface(QAccessible::queryAccessibleInterface(object), child);
accessibleHierarchyManager()->registerInterface(interface);
}
const QAElement element = accessibleHierarchyManager()->lookup(object, child);
if (element.isValid() == false)
return;
CFStringRef notification = 0;
if(object && object->isWidgetType() && reason == ObjectCreated) {
notification = CFStringRef(QAXWindowCreatedNotification);
} else if(reason == ValueChanged) {
notification = CFStringRef(QAXValueChangedNotification);
} else if(reason == MenuStart) {
notification = CFStringRef(QAXMenuOpenedNotification);
} else if(reason == MenuEnd) {
notification = CFStringRef(QAXMenuClosedNotification);
} else if(reason == LocationChanged) {
notification = CFStringRef(QAXWindowMovedNotification);
} else if(reason == ObjectShow || reason == ObjectHide ) {
// When a widget is deleted we get a ObjectHide before the destroyed(QObject *)
// signal is emitted (which makes sense). However, at this point we are in the
// middle of the QWidget destructor which means that we have to be careful when
// using the widget pointer. Since we can't control what the accessibilty interfaces
// does when navigate() is called below we ignore the hide update in this case.
// (the widget will be deleted soon anyway.)
extern QWidgetPrivate * qt_widget_private(QWidget *);
if (QWidget *widget = qobject_cast<QWidget*>(object)) {
if (qt_widget_private(widget)->data.in_destructor)
return;
// Check widget parent as well, special case for preventing crash
// when the viewport() of an abstract scroll area is hidden when
// the QWidget destructor hides all its children.
QWidget *parentWidget = widget->parentWidget();
if (parentWidget && qt_widget_private(parentWidget)->data.in_destructor)
return;
}
// There is no equivalent Mac notification for ObjectShow/Hide, so we call HIObjectSetAccessibilityIgnored
// and isItIntersting which will mark the HIObject accociated with the element as ignored if the
// QAccessible::Invisible state bit is set.
QAInterface interface = accessibleHierarchyManager()->lookup(element);
if (interface.isValid()) {
HIObjectSetAccessibilityIgnored(element.object(), !isItInteresting(interface));
}
// If the interface manages its own children, also check if we should ignore those.
if (isItemView(interface) == false && managesChildren(interface)) {
for (int i = 1; i <= interface.childCount(); ++i) {
QAInterface childInterface = interface.navigate(QAccessible::Child, i);
if (childInterface.isValid() && childInterface.isHIView() == false) {
const QAElement element = accessibleHierarchyManager()->lookup(childInterface);
if (element.isValid()) {
HIObjectSetAccessibilityIgnored(element.object(), !isItInteresting(childInterface));
}
}
}
}
} else if(reason == Focus) {
if(object && object->isWidgetType()) {
QWidget *w = static_cast<QWidget*>(object);
if(w->isWindow())
notification = CFStringRef(QAXFocusedWindowChangedNotification);
else
notification = CFStringRef(QAXFocusedUIElementChangedNotification);
}
}
if (!notification)
return;
AXNotificationHIObjectNotify(notification, element.object(), element.id());
#endif
}
QT_END_NAMESPACE
#endif // QT_NO_ACCESSIBILITY