diff options
Diffstat (limited to 'src')
36 files changed, 2281 insertions, 1 deletions
diff --git a/src/plugins/accessible/accessible.pro b/src/plugins/accessible/accessible.pro new file mode 100644 index 0000000000..71165af784 --- /dev/null +++ b/src/plugins/accessible/accessible.pro @@ -0,0 +1,3 @@ +TEMPLATE = subdirs +SUBDIRS += quick +SUBDIRS += qtquick1 diff --git a/src/plugins/accessible/qtquick1/main.cpp b/src/plugins/accessible/qtquick1/main.cpp new file mode 100644 index 0000000000..5ace1a78a1 --- /dev/null +++ b/src/plugins/accessible/qtquick1/main.cpp @@ -0,0 +1,106 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDeclarative module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qdeclarativeaccessible.h" +#include "qaccessibledeclarativeview.h" +#include "qaccessibledeclarativeitem.h" + +#include <QtQuick1/qdeclarativeitem.h> +#include <QtWidgets/qgraphicsview.h> + +#include <qaccessibleplugin.h> +#include <qplugin.h> +#include <qvariant.h> +#include <qaccessible.h> + +#ifndef QT_NO_ACCESSIBILITY + +QT_BEGIN_NAMESPACE + +class AccessibleQtQuick1Factory : public QAccessiblePlugin +{ +public: + AccessibleQtQuick1Factory(); + + QStringList keys() const; + QAccessibleInterface *create(const QString &classname, QObject *object); +}; + +AccessibleQtQuick1Factory::AccessibleQtQuick1Factory() +{ +} + +QStringList AccessibleQtQuick1Factory::keys() const +{ + QStringList list; + list << QLatin1String("QDeclarativeView"); + list << QLatin1String("QDeclarativeItem"); + return list; +} + +QAccessibleInterface *AccessibleQtQuick1Factory::create(const QString &classname, QObject *object) +{ + if (classname == QLatin1String("QDeclarativeView")) { + QWidget *widget = qobject_cast<QWidget*>(object); + if (qobject_cast<QDeclarativeView *>(widget) != 0) + return new QAccessibleDeclarativeView(widget); + } else if (classname == QLatin1String("QDeclarativeItem")) { + QDeclarativeItem *item = qobject_cast<QDeclarativeItem *>(object); + if (!item->scene()) + return 0; + + QList<QGraphicsView *> views = item->scene()->views(); + if (views.isEmpty()) + return 0; + QGraphicsView *view = views.at(0); // Accessibility support for the first view only. + // (Not a problem for QDeclarative) + return new QAccessibleDeclarativeItem(item, view); + } + + return 0; +} + +Q_EXPORT_STATIC_PLUGIN(AccessibleQtQuick1Factory) +Q_EXPORT_PLUGIN2(qtaccessibleqtquick1, AccessibleQtQuick1Factory) + +QT_END_NAMESPACE + +#endif // QT_NO_ACCESSIBILITY diff --git a/src/plugins/accessible/qtquick1/qaccessibledeclarativeitem.cpp b/src/plugins/accessible/qtquick1/qaccessibledeclarativeitem.cpp new file mode 100644 index 0000000000..202023990b --- /dev/null +++ b/src/plugins/accessible/qtquick1/qaccessibledeclarativeitem.cpp @@ -0,0 +1,290 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDeclarative module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qaccessibledeclarativeitem.h" + +#include <QtQuick1/qdeclarativeitem.h> +#include <QtQuick1/private/qdeclarativeaccessibleattached_p.h> + +QT_BEGIN_NAMESPACE + +QAccessibleDeclarativeItem::QAccessibleDeclarativeItem(QGraphicsObject *item, QGraphicsView *view) + :QDeclarativeAccessible(item) + ,m_item(item) + ,m_view(view) +{ + +} + +int QAccessibleDeclarativeItem::childCount() const +{ + QList<QGraphicsItem *> children = m_item->childItems(); + return children.count(); +} + +QRect QAccessibleDeclarativeItem::rect() const +{ + QRectF sceneRect = m_item->sceneTransform().mapRect(m_item->boundingRect()); + QPoint pos = m_view->mapFromScene(m_view->mapToGlobal(sceneRect.topLeft().toPoint())); + QSize size = sceneRect.size().toSize(); + return QRect(pos, size); +} + +QRect QAccessibleDeclarativeItem::viewRect() const +{ + QPoint screenPos = m_view->mapToGlobal(m_view->pos()); + return QRect(screenPos, m_view->size()); +} + +bool QAccessibleDeclarativeItem::clipsChildren() const +{ + return static_cast<QDeclarativeItem *>(m_item)->clip(); +} + +static inline bool isAncestor(const QObject *ancestorCandidate, const QObject *child) +{ + while (child) { + if (child == ancestorCandidate) + return true; + child = child->parent(); + } + return false; +} + + +QAccessibleInterface *QAccessibleDeclarativeItem::parent() const +{ + QGraphicsItem *parent = m_item->parentItem(); + QGraphicsObject *parentObj = parent ? parent->toGraphicsObject() : 0; + if (parent && !parentObj) + qWarning("Can not make QGraphicsItems accessible"); + QAccessibleInterface *ancestor = (parentObj + ? new QAccessibleDeclarativeItem(parentObj, m_view) + : QAccessible::queryAccessibleInterface(m_view)); + return ancestor; +} + +QAccessibleInterface *QAccessibleDeclarativeItem::child(int index) const +{ + QList<QGraphicsItem *> children = m_item->childItems(); + + if (index >= children.count()) + return 0; + + QGraphicsItem *child = children.at(index); + QGraphicsObject *childObject = qobject_cast<QGraphicsObject *>(child); + if (!childObject) + return 0; + + return new QAccessibleDeclarativeItem(childObject, m_view); +} + +int QAccessibleDeclarativeItem::navigate(QAccessible::RelationFlag rel, int entry, QAccessibleInterface **target) const +{ + //qDebug() << "QAccessibleDeclarativeItem navigate" << rel << entry; + Q_ASSERT(entry >= 0); + + *target = 0; + if (entry == 0) { + *target = new QAccessibleDeclarativeItem(m_item->toGraphicsObject(), m_view); + return 0; + } + + switch (rel) { + case QAccessible::Child: { + QList<QGraphicsItem *> children = m_item->childItems(); + const int childIndex = entry - 1; + + if (childIndex >= children.count()) + return -1; + + QGraphicsItem *child = children.at(childIndex); + QGraphicsObject *childObject = qobject_cast<QGraphicsObject *>(child); + if (!childObject) + return -1; + + *target = new QAccessibleDeclarativeItem(childObject, m_view); + return 0; + break;} + case QAccessible::Ancestor: { + Q_ASSERT(entry >= 1); + QGraphicsItem *parent = m_item->parentItem(); + QGraphicsObject *parentObj = parent ? parent->toGraphicsObject() : 0; + if (parent && !parentObj) + qWarning("Can not make QGraphicsItems accessible"); + QAccessibleInterface *ancestor = (parentObj + ? new QAccessibleDeclarativeItem(parentObj, m_view) + : QAccessible::queryAccessibleInterface(m_view)); + if (entry == 1) { + *target = ancestor; + return 0; + } else if (entry > 1) { + int ret = ancestor->navigate(QAccessible::Ancestor, entry - 1, target); + delete ancestor; + return ret; + } + break;} + case QAccessible::Sibling: { + QAccessibleInterface *iface = 0; + if (navigate(QAccessible::Ancestor, 1, &iface) == 0) { + if (iface) { + int ret = iface->navigate(QAccessible::Child, entry, target); + delete iface; + return ret; + } + } + return -1; + break;} + case QAccessible::FocusChild: { + QGraphicsObject *focusObject = 0; + if (m_item->hasFocus()) { + focusObject = m_item->toGraphicsObject(); + } else { + if (QGraphicsItem *focusItem = m_view->scene()->focusItem()) { + if (m_item->isAncestorOf(focusItem)) { + focusObject = focusItem->toGraphicsObject(); + } + } + } + //qDebug() << "QAccessibleDeclarativeItem navigate QAccessible::FocusChild" << rel << entry; + if (focusObject) { + *target = new QAccessibleDeclarativeItem(focusObject, m_view); + return 0; + } + } + default: break; + } + + return -1; + +} + +int QAccessibleDeclarativeItem::indexOfChild(const QAccessibleInterface *iface) const +{ + // ### No QAccessibleInterfaces are created with a QGraphicsItem. + // However, we want to support QML, not QGraphicsView in general. + // And since the UI is written in QML, this means we can assume that *all* + // QGraphicsItems are actually QGraphicsObjects + + const QGraphicsObject *childObj = static_cast<QGraphicsObject*>(iface->object()); + if (m_item == childObj) + return 0; + + QList<QGraphicsItem*> kids = m_item->childItems(); + int index = kids.indexOf(const_cast<QGraphicsItem*>(static_cast<const QGraphicsItem*>(childObj))); + if (index != -1) { + ++index; + } + return index; +} + +QFlags<QAccessible::StateFlag> QAccessibleDeclarativeItem::state() const +{ + QAccessible::State state = QAccessible::Normal; + + if (m_item->hasFocus()) { + state |= QAccessible::Focused; + } + return state; +} + +QAccessible::Role QAccessibleDeclarativeItem::role() const +{ + // ### Workaround for setAccessibleRole() not working. + // Text items are special since they are defined + // entirely from C++ (setting the role from QML works.) +// if (qobject_cast<QDeclarative1Text*>(m_item)) +// return QAccessible::StaticText; + + QVariant v = QDeclarativeAccessibleAttached::property(m_item, "role"); + bool ok; + QAccessible::Role role = (QAccessible::Role)v.toInt(&ok); + if (!ok) // Not sure if this check is needed. + role = QAccessible::Pane; + return role; +} + +bool QAccessibleDeclarativeItem::isAccessible() const +{ + return true; +} + +QString QAccessibleDeclarativeItem::text(QAccessible::Text textType) const +{ + // handles generic behaviour not specific to an item + switch (textType) { + case QAccessible::Name: { + QVariant accessibleName = QDeclarativeAccessibleAttached::property(object(), "name"); + if (!accessibleName.isNull()) + return accessibleName.toString(); + break;} + case QAccessible::Description: { + QVariant accessibleDecription = QDeclarativeAccessibleAttached::property(object(), "description"); + if (!accessibleDecription.isNull()) + return accessibleDecription.toString(); + break;} + case QAccessible::Value: + case QAccessible::Help: + case QAccessible::Accelerator: + default: + break; + } + + // the following blocks handles item-specific behaviour + if (role() == QAccessible::EditableText) { + if (textType == QAccessible::Value) { + QVariant text = object()->property("text"); + return text.toString(); + } else if (textType == QAccessible::Name) { + return object()->objectName(); + } + } else { + if (textType == QAccessible::Name) { + QVariant text = object()->property("text"); + return text.toString(); + } + } + + + return QString(); +} + +QT_END_NAMESPACE diff --git a/src/plugins/accessible/qtquick1/qaccessibledeclarativeitem.h b/src/plugins/accessible/qtquick1/qaccessibledeclarativeitem.h new file mode 100644 index 0000000000..5582672aae --- /dev/null +++ b/src/plugins/accessible/qtquick1/qaccessibledeclarativeitem.h @@ -0,0 +1,80 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDeclarative module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QACCESSIBLEDECLARATIVEITEM_H +#define QACCESSIBLEDECLARATIVEITEM_H + +#include "qdeclarativeaccessible.h" + +#include <QtWidgets/qgraphicsview.h> +#include <QtWidgets/qgraphicsitem.h> + +QT_BEGIN_NAMESPACE + +class QAccessibleDeclarativeItem : public QDeclarativeAccessible +{ +public: + QAccessibleDeclarativeItem(QGraphicsObject *item, QGraphicsView *view); + + QRect rect() const; + QRect viewRect() const; + + bool clipsChildren() const; + + QAccessibleInterface *parent() const; + QAccessibleInterface *child(int index) const; + int childCount() const; + int navigate(QAccessible::RelationFlag rel, int entry, QAccessibleInterface **target) const; + int indexOfChild(const QAccessibleInterface *iface) const; + + QFlags<QAccessible::StateFlag> state() const; + QAccessible::Role role() const; + QString text(QAccessible::Text) const; + + virtual bool isAccessible() const; +private: + QGraphicsObject *m_item; + QGraphicsView *m_view; +}; + +QT_END_NAMESPACE + +#endif // QACCESSIBLEGRAPHICSVIEWIMPLEMENTATION_H diff --git a/src/plugins/accessible/qtquick1/qaccessibledeclarativeview.cpp b/src/plugins/accessible/qtquick1/qaccessibledeclarativeview.cpp new file mode 100644 index 0000000000..1aa4bef992 --- /dev/null +++ b/src/plugins/accessible/qtquick1/qaccessibledeclarativeview.cpp @@ -0,0 +1,97 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDeclarative module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qaccessibledeclarativeview.h" +#include "qdeclarativeaccessible.h" +#include "qaccessibledeclarativeitem.h" + + +#ifndef QT_NO_ACCESSIBILITY + +QT_BEGIN_NAMESPACE + +QAccessibleDeclarativeView::QAccessibleDeclarativeView(QWidget *widget) + :QAccessibleWidget(widget) +{ + m_view = static_cast<QDeclarativeView *>(widget); +} + +int QAccessibleDeclarativeView::childCount() const +{ + return 1; +} + +QAccessibleInterface *QAccessibleDeclarativeView::child(int index) const +{ + if (index == 0) { + QDeclarativeItem *declarativeRoot = m_view->accessibleRootItem(); + return new QAccessibleDeclarativeItem(declarativeRoot, m_view); + } + return 0; +} + +int QAccessibleDeclarativeView::navigate(QAccessible::RelationFlag rel, int entry, QAccessibleInterface **target) const +{ + if (rel == QAccessible::Child) { + *target = child(entry - 1); + return *target ? 0 : -1; + } + return QAccessibleWidget::navigate(rel, entry, target); +} + +QAccessibleInterface *QAccessibleDeclarativeView::childAt(int x, int y) const +{ + return child(0); // return the top-level QML item +} + +int QAccessibleDeclarativeView::indexOfChild(const QAccessibleInterface *iface) const +{ + if (iface) { + QDeclarativeItem *declarativeRoot = m_view->accessibleRootItem(); + if (declarativeRoot == iface->object()) + return 1; + } + return -1; +} + +QT_END_NAMESPACE + +#endif // QT_NO_ACCESSIBILITY diff --git a/src/plugins/accessible/qtquick1/qaccessibledeclarativeview.h b/src/plugins/accessible/qtquick1/qaccessibledeclarativeview.h new file mode 100644 index 0000000000..48833f932c --- /dev/null +++ b/src/plugins/accessible/qtquick1/qaccessibledeclarativeview.h @@ -0,0 +1,75 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDeclarative module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QACCESSIBLEDECLARATIVEVIEW_H +#define QACCESSIBLEDECLARATIVEVIEW_H + +#include <QtGui/qaccessible2.h> +#include <QtWidgets/qaccessiblewidget.h> + +#include <QtQuick1/qdeclarativeview.h> +#include <QtQuick1/qdeclarativeitem.h> +#include <QtWidgets/qwidget.h> + +QT_BEGIN_NAMESPACE + +#ifndef QT_NO_ACCESSIBILITY + +class QAccessibleDeclarativeView: public QAccessibleWidget +{ +public: + explicit QAccessibleDeclarativeView(QWidget *widget); + + QAccessibleInterface *child(int index) const; + int childCount() const; + int navigate(QAccessible::RelationFlag rel, int entry, QAccessibleInterface **target) const; + QAccessibleInterface *childAt(int x, int y) const; + int indexOfChild(const QAccessibleInterface *iface) const; + +private: + QDeclarativeView *m_view; +}; + +#endif // QT_NO_ACCESSIBILITY + +QT_END_NAMESPACE + +#endif // QACCESSIBLEDECLARATIVEVIEW_H diff --git a/src/plugins/accessible/qtquick1/qtquick1.pro b/src/plugins/accessible/qtquick1/qtquick1.pro new file mode 100644 index 0000000000..f4602e4420 --- /dev/null +++ b/src/plugins/accessible/qtquick1/qtquick1.pro @@ -0,0 +1,22 @@ +contains(QT_CONFIG, accessibility) { + +TARGET = qtaccessibleqtquick1 +load(qt_plugin) +include ($$PWD/../shared/qaccessiblebase.pri) + +QT += core-private gui-private widgets-private v8-private declarative-private qtquick1-private +DESTDIR = $$QT.gui.plugins/accessible + +QTDIR_build:REQUIRES += "contains(QT_CONFIG, accessibility)" + +DEFINES+=Q_ACCESSIBLE_QUICK_ITEM_ENABLE_DEBUG_DESCRIPTION + +SOURCES += \ + main.cpp \ + qaccessibledeclarativeview.cpp \ + qaccessibledeclarativeitem.cpp + +HEADERS += \ + qaccessibledeclarativeview.h \ + qaccessibledeclarativeitem.h +} diff --git a/src/plugins/accessible/quick/main.cpp b/src/plugins/accessible/quick/main.cpp new file mode 100644 index 0000000000..8b8285e450 --- /dev/null +++ b/src/plugins/accessible/quick/main.cpp @@ -0,0 +1,98 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDeclarative module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + +#include "qdeclarativeaccessible.h" +#include "qaccessiblequickview.h" +#include "qaccessiblequickitem.h" + +#include <QtQuick/QQuickView> +#include <QtQuick/QQuickItem> + +#include <qaccessibleplugin.h> +#include <qvariant.h> +#include <qplugin.h> +#include <qaccessible.h> + +#ifndef QT_NO_ACCESSIBILITY + +QT_BEGIN_NAMESPACE + +class AccessibleQuickFactory : public QAccessiblePlugin +{ +public: + AccessibleQuickFactory(); + + QStringList keys() const; + QAccessibleInterface *create(const QString &classname, QObject *object); +}; + +AccessibleQuickFactory::AccessibleQuickFactory() +{ +} + +QStringList AccessibleQuickFactory::keys() const +{ + QStringList list; + list << QLatin1String("QQuickView"); + list << QLatin1String("QQuickItem"); + return list; +} + +QAccessibleInterface *AccessibleQuickFactory::create(const QString &classname, QObject *object) +{ + if (classname == QLatin1String("QQuickView")) { + return new QAccessibleQuickView(qobject_cast<QQuickView *>(object)); // FIXME + } else if (classname == QLatin1String("QQuickItem")) { + QQuickItem * item = qobject_cast<QQuickItem *>(object); + Q_ASSERT(item); + return new QAccessibleQuickItem(item); + } + + return 0; +} + +Q_EXPORT_STATIC_PLUGIN(AccessibleQuickFactory) +Q_EXPORT_PLUGIN2(qtaccessiblequick, AccessibleQuickFactory) + +QT_END_NAMESPACE + +#endif // QT_NO_ACCESSIBILITY diff --git a/src/plugins/accessible/quick/qaccessiblequickitem.cpp b/src/plugins/accessible/quick/qaccessiblequickitem.cpp new file mode 100644 index 0000000000..7131e110d8 --- /dev/null +++ b/src/plugins/accessible/quick/qaccessiblequickitem.cpp @@ -0,0 +1,292 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDeclarative module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qaccessiblequickitem.h" +#include "QtQuick/private/qquickitem_p.h" +#include "QtQuick/private/qquicktext_p.h" +#include "QtQuick/private/qquickaccessibleattached_p.h" + +QT_BEGIN_NAMESPACE + +QAccessibleQuickItem::QAccessibleQuickItem(QQuickItem *item) + : QDeclarativeAccessible(item) + , m_item(item) +{ +} + +int QAccessibleQuickItem::childCount() const +{ + return childItems().count(); +} + +QRect QAccessibleQuickItem::rect() const +{ + // ### no canvas in some cases. + // ### Should we really check for 0 opacity? + if (!m_item->canvas() ||!m_item->isVisible() || qFuzzyIsNull(m_item->opacity())) { + return QRect(); + } + + QSizeF size = QSizeF(m_item->width(), m_item->height()); + // ### If the bounding rect fails, we first try the implicit size, then we go for the + // parent size. WE MIGHT HAVE TO REVISIT THESE FALLBACKS. + if (size.isEmpty()) { + size = QSizeF(m_item->implicitWidth(), m_item->implicitHeight()); + if (size.isEmpty()) + // ### Seems that the above fallback is not enough, fallback to use the parent size... + size = QSizeF(m_item->parentItem()->width(), m_item->parentItem()->height()); + } + + QRectF sceneRect = m_item->mapRectToScene(QRectF(QPointF(0, 0), size)); + QPoint screenPos = m_item->canvas()->mapToGlobal(sceneRect.topLeft().toPoint()); + + QRect r = QRect(screenPos, sceneRect.size().toSize()); + + if (!r.isValid()) { + qWarning() << m_item->metaObject()->className() << m_item->property("accessibleText") << r; + } + return r; +} + +QRect QAccessibleQuickItem::viewRect() const +{ + // ### no canvas in some cases. + if (!m_item->canvas()) { + return QRect(); + } + + QQuickCanvas *canvas = m_item->canvas(); + QPoint screenPos = canvas->mapToGlobal(QPoint(0,0)); + return QRect(screenPos, canvas->size()); +} + + +bool QAccessibleQuickItem::clipsChildren() const +{ + return static_cast<QQuickItem *>(m_item)->clip(); +} + + +QAccessibleInterface *QAccessibleQuickItem::parent() const +{ + QQuickItem *parent = m_item->parentItem(); + if (parent) { + QQuickCanvas *canvas = m_item->canvas(); + // Jump out to the scene widget if the parent is the root item. + // There are two root items, QQuickCanvas::rootItem and + // QQuickView::declarativeRoot. The former is the true root item, + // but is not a part of the accessibility tree. Check if we hit + // it here and return an interface for the scene instead. + if (parent == canvas->rootItem()) { + return QAccessible::queryAccessibleInterface(canvas); + } else { + QDeclarativeAccessible *ancestor = new QAccessibleQuickItem(parent); + return ancestor; + } + } + return 0; +} + +QAccessibleInterface *QAccessibleQuickItem::child(int index) const +{ + QList<QQuickItem *> children = childItems(); + + if (index < 0 || index >= children.count()) + return 0; + + QQuickItem *child = children.at(index); + if (!child) // FIXME can this happen? + return 0; + + return new QAccessibleQuickItem(child); +} + +int QAccessibleQuickItem::navigate(QAccessible::RelationFlag rel, int entry, QAccessibleInterface **target) const +{ + *target = 0; + if (entry == 0) { + *target = new QAccessibleQuickItem(m_item); + return 0; + } + + switch (rel) { + case QAccessible::Child: { // FIMXE + QList<QQuickItem *> children = childItems(); + const int childIndex = entry - 1; + + if (childIndex >= children.count()) + return -1; + + QQuickItem *child = children.at(childIndex); + if (!child) + return -1; + + *target = new QAccessibleQuickItem(child); + return 0; + break;} + case QAccessible::Ancestor: { // FIMXE + QQuickItem *parent = m_item->parentItem(); + if (parent) { + QDeclarativeAccessible *ancestor = new QAccessibleQuickItem(parent); + if (entry == 1) { + QQuickCanvas *canvas = m_item->canvas(); + // Jump out to the scene widget if the parent is the root item. + // There are two root items, QQuickCanvas::rootItem and + // QQuickView::declarativeRoot. The former is the true root item, + // but is not a part of the accessibility tree. Check if we hit + // it here and return an interface for the scene instead. + if (parent == canvas->rootItem()) { + *target = QAccessible::queryAccessibleInterface(canvas); + } else { + *target = ancestor; + } + return 0; + } else if (entry > 1) { + int ret = ancestor->navigate(QAccessible::Ancestor, entry - 1, target); + delete ancestor; + return ret; + } + } + return -1; + break;} + default: break; + } + + return -1; +} + +int QAccessibleQuickItem::indexOfChild(const QAccessibleInterface *iface) const +{ + QList<QQuickItem*> kids = childItems(); + int idx = kids.indexOf(static_cast<QQuickItem*>(iface->object())); + if (idx != -1) + ++idx; + return idx; +} + +QList<QQuickItem *> QAccessibleQuickItem::childItems() const +{ + if (role() == QAccessible::Button) + return QList<QQuickItem *>(); + return m_item->childItems(); +} + +QFlags<QAccessible::StateFlag> QAccessibleQuickItem::state() const +{ + QAccessible::State state = QAccessible::Normal; + + if (m_item->hasActiveFocus()) { + state |= QAccessible::Focused; + } + return state; +} + + +QAccessible::Role QAccessibleQuickItem::role() const +{ + // Workaround for setAccessibleRole() not working for + // Text items. Text items are special since they are defined + // entirely from C++ (setting the role from QML works.) + if (qobject_cast<QQuickText*>(const_cast<QQuickItem *>(m_item))) + return QAccessible::StaticText; + + QVariant v = QQuickAccessibleAttached::property(m_item, "role"); + bool ok; + QAccessible::Role role = (QAccessible::Role)v.toInt(&ok); + if (!ok) // Not sure if this check is needed. + role = QAccessible::Pane; + return role; +} + +bool QAccessibleQuickItem::isAccessible() const +{ + return m_item->d_func()->isAccessible; +} + +QString QAccessibleQuickItem::text(QAccessible::Text textType) const +{ + // handles generic behavior not specific to an item + switch (textType) { + case QAccessible::Name: { + QVariant accessibleName = QQuickAccessibleAttached::property(object(), "name"); + if (!accessibleName.isNull()) + return accessibleName.toString(); + break;} + case QAccessible::Description: { + QVariant accessibleDecription = QQuickAccessibleAttached::property(object(), "description"); + if (!accessibleDecription.isNull()) + return accessibleDecription.toString(); + break;} +#ifdef Q_ACCESSIBLE_QUICK_ITEM_ENABLE_DEBUG_DESCRIPTION + case QAccessible::DebugDescription: { + QString debugString; + debugString = QString::fromAscii(object()->metaObject()->className()) + QLatin1Char(' '); + debugString += isAccessible() ? QLatin1String("enabled") : QLatin1String("disabled"); + return debugString; + break; } +#endif + case QAccessible::Value: + case QAccessible::Help: + case QAccessible::Accelerator: + default: + break; + } + + // the following blocks handles item-specific behavior + if (role() == QAccessible::EditableText) { + if (textType == QAccessible::Value) { + QVariant text = object()->property("text"); + return text.toString(); + } else if (textType == QAccessible::Name) { + return object()->objectName(); + } + } else { + if (textType == QAccessible::Name) { + QVariant text = object()->property("text"); + return text.toString(); + } + } + + + return QString(); +} + +QT_END_NAMESPACE diff --git a/src/plugins/accessible/quick/qaccessiblequickitem.h b/src/plugins/accessible/quick/qaccessiblequickitem.h new file mode 100644 index 0000000000..9782f67731 --- /dev/null +++ b/src/plugins/accessible/quick/qaccessiblequickitem.h @@ -0,0 +1,83 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDeclarative module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QACCESSIBLEQUICKITEM_H +#define QACCESSIBLEQUICKITEM_H + +#include <QtQuick/QQuickItem> +#include <QtQuick/QQuickView> +#include "qdeclarativeaccessible.h" + +QT_BEGIN_NAMESPACE + +#ifndef QT_NO_ACCESSIBILITY + +class QAccessibleQuickItem : public QDeclarativeAccessible +{ +public: + QAccessibleQuickItem(QQuickItem *item); + + QRect rect() const; + QRect viewRect() const; + + bool clipsChildren() const; + + QAccessibleInterface *parent() const; + QAccessibleInterface *child(int index) const; + int childCount() const; + int navigate(QAccessible::RelationFlag rel, int entry, QAccessibleInterface **target) const; + int indexOfChild(const QAccessibleInterface *iface) const; + QList<QQuickItem *> childItems() const; + + QFlags<QAccessible::StateFlag> state() const; + QAccessible::Role role() const; + QString text(QAccessible::Text) const; + + bool isAccessible() const; +private: + QQuickItem *m_item; +}; + +#endif // QT_NO_ACCESSIBILITY + +QT_END_NAMESPACE + +#endif // QACCESSIBLEQUICKITEM_H diff --git a/src/plugins/accessible/quick/qaccessiblequickview.cpp b/src/plugins/accessible/quick/qaccessiblequickview.cpp new file mode 100644 index 0000000000..cd4b4937ec --- /dev/null +++ b/src/plugins/accessible/quick/qaccessiblequickview.cpp @@ -0,0 +1,137 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDeclarative module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qaccessiblequickview.h" + +#include <QtQuick/qquickitem.h> + +#include "qaccessiblequickitem.h" +#include "qdeclarativeaccessible.h" + +#ifndef QT_NO_ACCESSIBILITY + +QT_BEGIN_NAMESPACE + +QAccessibleQuickView::QAccessibleQuickView(QQuickView *object) + :QAccessibleObject(object) +{ + m_view = static_cast<QQuickView *>(object); +} + +int QAccessibleQuickView::childCount() const +{ + return m_view->rootItem() ? 1 : 0; +} + +QAccessibleInterface *QAccessibleQuickView::parent() const +{ + // FIXME: for now we assume to be a top level window... + return QAccessible::queryAccessibleInterface(qApp); +} + +QAccessibleInterface *QAccessibleQuickView::child(int index) const +{ + if (index == 0) { + QQuickItem *declarativeRoot = m_view->rootObject(); + return new QAccessibleQuickItem(declarativeRoot); + } + return 0; +} + +QAccessible::Role QAccessibleQuickView::role() const +{ + return QAccessible::Window; // FIXME +} + +QAccessible::State QAccessibleQuickView::state() const +{ + return QAccessible::Normal; // FIXME +} + +QRect QAccessibleQuickView::rect() const +{ + return QRect(m_view->x(), m_view->y(), m_view->width(), m_view->height()); +} + +int QAccessibleQuickView::navigate(QAccessible::RelationFlag rel, int entry, QAccessibleInterface **target) const +{ + switch (rel) { + case QAccessible::Child: + *target = child(entry - 1); + case QAccessible::Ancestor: + *target = parent(); + default: + *target = 0; + } + return *target ? 0 : -1; +} + +QString QAccessibleQuickView::text(QAccessible::Text text) const +{ +#ifdef Q_ACCESSIBLE_QUICK_ITEM_ENABLE_DEBUG_DESCRIPTION + if (text == QAccessible::DebugDescription) { + return QString::fromAscii(object()->metaObject()->className()) ; + } +#endif + return m_view->windowTitle(); +} + +QAccessibleInterface *QAccessibleQuickView::childAt(int x, int y) const +{ + Q_UNUSED(x); + Q_UNUSED(y); + return child(0); // return the top-level QML item +} + +int QAccessibleQuickView::indexOfChild(const QAccessibleInterface *iface) const +{ + if (iface) { + QQuickItem *declarativeRoot = m_view->rootObject(); + if (declarativeRoot == iface->object()) + return 1; + } + return -1; + +} + +QT_END_NAMESPACE + +#endif // QT_NO_ACCESSIBILITY diff --git a/src/plugins/accessible/quick/qaccessiblequickview.h b/src/plugins/accessible/quick/qaccessiblequickview.h new file mode 100644 index 0000000000..0b9b5d1f80 --- /dev/null +++ b/src/plugins/accessible/quick/qaccessiblequickview.h @@ -0,0 +1,78 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDeclarative module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QAccessibleQuickView_H +#define QAccessibleQuickView_H + +#include <QtGui/qaccessible2.h> +#include <QtGui/qaccessibleobject.h> +#include <QtQuick/qquickview.h> + +QT_BEGIN_NAMESPACE + +#ifndef QT_NO_ACCESSIBILITY + +class QAccessibleQuickView : public QAccessibleObject +{ +public: + QAccessibleQuickView(QQuickView *object); + + QAccessibleInterface *parent() const; + QAccessibleInterface *child(int index) const; + + QAccessible::Role role() const; + QAccessible::State state() const; + QRect rect() const; + + int childCount() const; + int navigate(QAccessible::RelationFlag rel, int entry, QAccessibleInterface **target) const; + int indexOfChild(const QAccessibleInterface *iface) const; + QString text(QAccessible::Text text) const; + QAccessibleInterface *childAt(int x, int y) const; +private: + QQuickView *m_view; +}; + +#endif // QT_NO_ACCESSIBILITY + +QT_END_NAMESPACE + +#endif // QAccessibleQuickView_H diff --git a/src/plugins/accessible/quick/quick.pro b/src/plugins/accessible/quick/quick.pro new file mode 100644 index 0000000000..97a1d50098 --- /dev/null +++ b/src/plugins/accessible/quick/quick.pro @@ -0,0 +1,23 @@ +contains(QT_CONFIG, accessibility) { + +TARGET = qtaccessiblequick +load(qt_plugin) +include ($$PWD/../shared/qaccessiblebase.pri) + +QT += core-private gui-private v8-private declarative-private quick-private +DESTDIR = $$QT.gui.plugins/accessible + +QTDIR_build:REQUIRES += "contains(QT_CONFIG, accessibility)" + +#DEFINES+=Q_ACCESSIBLE_QUICK_ITEM_ENABLE_DEBUG_DESCRIPTION + +SOURCES += \ + main.cpp \ + qaccessiblequickview.cpp \ + qaccessiblequickitem.cpp + +HEADERS += \ + qaccessiblequickview.h \ + qaccessiblequickitem.h +} + diff --git a/src/plugins/accessible/shared/qaccessiblebase.pri b/src/plugins/accessible/shared/qaccessiblebase.pri new file mode 100644 index 0000000000..8c82705443 --- /dev/null +++ b/src/plugins/accessible/shared/qaccessiblebase.pri @@ -0,0 +1,7 @@ +target.path += $$[QT_INSTALL_PLUGINS]/accessible +INSTALLS += target + +INCLUDEPATH += $$PWD +DEPENDPATH += $$PWD +SOURCES += $$PWD/qdeclarativeaccessible.cpp +HEADERS += $$PWD/qdeclarativeaccessible.h diff --git a/src/plugins/accessible/shared/qdeclarativeaccessible.cpp b/src/plugins/accessible/shared/qdeclarativeaccessible.cpp new file mode 100644 index 0000000000..abe73f24ea --- /dev/null +++ b/src/plugins/accessible/shared/qdeclarativeaccessible.cpp @@ -0,0 +1,172 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDeclarative module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include <qnamespace.h> +#include "qdeclarativeaccessible.h" + +#ifndef QT_NO_ACCESSIBILITY + +QT_BEGIN_NAMESPACE + + +QString Q_GUI_EXPORT qTextBeforeOffsetFromString(int offset, QAccessible2::BoundaryType boundaryType, + int *startOffset, int *endOffset, const QString& text); +QString Q_GUI_EXPORT qTextAtOffsetFromString(int offset, QAccessible2::BoundaryType boundaryType, + int *startOffset, int *endOffset, const QString& text); +QString Q_GUI_EXPORT qTextAfterOffsetFromString(int offset, QAccessible2::BoundaryType boundaryType, + int *startOffset, int *endOffset, const QString& text); + +QDeclarativeAccessible::QDeclarativeAccessible(QObject *object) + :QAccessibleObject(object) +{ +} + +QDeclarativeAccessible::~QDeclarativeAccessible() +{ +} + +QFlags<QAccessible::RelationFlag> QDeclarativeAccessible::relationTo(const QAccessibleInterface *) const +{ + return QAccessible::Unrelated; +} + +QAccessibleInterface *QDeclarativeAccessible::childAt(int x, int y) const +{ + // Look for children first. + // Start with the last child first, because children are ordered in paint order + // (which is opposite of hit test order) + + // If the item clips its children, we can return early if the coordinate is outside its rect + if (clipsChildren()) { + if (!rect().contains(x, y)) + return 0; + } + + for (int i = childCount() - 1; i >= 0; --i) { + QAccessibleInterface *childIface = child(i); + if (childIface && !(childIface->state() & QAccessible::Invisible)) { + if (childIface->rect().contains(x, y)) + return childIface; + } + } + return 0; +} + +QFlags<QAccessible::StateFlag> QDeclarativeAccessible::state() const +{ + QAccessible::State state;// = state(); + + //QRect viewRect(QPoint(0, 0), m_implementation->size()); + //QRect itemRect(m_item->scenePos().toPoint(), m_item->boundingRect().size().toSize()); + + QRect viewRect_ = viewRect(); + QRect itemRect = rect(); + + // qDebug() << "viewRect" << viewRect << "itemRect" << itemRect; + // error case: + if (viewRect_.isNull() || itemRect.isNull()) { + state |= QAccessible::Invisible; + } + + if (!viewRect_.intersects(itemRect)) { + state |= QAccessible::Offscreen; + // state |= QAccessible::Invisible; // no set at this point to ease development + } + + if (!object()->property("visible").toBool() || qFuzzyIsNull(object()->property("opacity").toDouble())) { + state |= QAccessible::Invisible; + } + + if ((role() == QAccessible::CheckBox || role() == QAccessible::RadioButton) && object()->property("checked").toBool()) { + state |= QAccessible::Checked; + } + + if (role() == QAccessible::EditableText) + state |= QAccessible::Focusable; + + //qDebug() << "state?" << m_item->property("state").toString() << m_item->property("status").toString() << m_item->property("visible").toString(); + + return state; +} + +QStringList QDeclarativeAccessible::actionNames() const +{ + QStringList actions; + switch (role()) { + case QAccessible::PushButton: + actions << QAccessibleActionInterface::pressAction(); + break; + case QAccessible::RadioButton: + case QAccessible::CheckBox: + actions << QAccessibleActionInterface::checkAction(); + break; + default: + break; + } + return actions; +} + +void QDeclarativeAccessible::doAction(const QString &actionName) +{ + if (role() == QAccessible::PushButton && actionName == QAccessibleActionInterface::pressAction()) { + QMetaObject::invokeMethod(object(), "accessibleAction"); + } + if ((role() == QAccessible::CheckBox || role() == QAccessible::RadioButton) && actionName == QAccessibleActionInterface::checkAction()) { + bool checked = object()->property("checked").toBool(); + object()->setProperty("checked", QVariant(!checked)); + } +} + +QStringList QDeclarativeAccessible::keyBindingsForAction(const QString &actionName) const +{ + Q_UNUSED(actionName) + return QStringList(); +} + +QVariant QDeclarativeAccessible::invokeMethod(QAccessible::Method method, const QVariantList&) +{ + Q_UNUSED(method) + return QVariant(); +} + +QT_END_NAMESPACE + +#endif // QT_NO_ACCESSIBILITY diff --git a/src/plugins/accessible/shared/qdeclarativeaccessible.h b/src/plugins/accessible/shared/qdeclarativeaccessible.h new file mode 100644 index 0000000000..16b61508c0 --- /dev/null +++ b/src/plugins/accessible/shared/qdeclarativeaccessible.h @@ -0,0 +1,98 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDeclarative module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QDECLARATIVEACCESSIBLE_H +#define QDECLARATIVEACCESSIBLE_H + +#include <QtGui/qaccessibleobject.h> +#include <QtGui/qaccessible2.h> +//#include <QtQuick1/qdeclarativeview.h> +//#include <QtQuick1/qdeclarativeitem.h> +#include <QtDeclarative/qdeclarativeproperty.h> + +//#include <private/qdeclarativeaccessible_p.h> + +QT_BEGIN_NAMESPACE + +#ifndef QT_NO_ACCESSIBILITY + +/* + -- Declarative Accessibility Overview. -- + + * Item interface classes: + QAccessibleDeclarativeItem for QtQuick1 + QAccessibleQuickItem for for QtQuick2 + Common base class: QDeclarativeAccessible + + * View interface classes. + + These are the root of the QML accessible tree and connects it to the widget hierarchy. + + QAccessbileDeclarativeView is the root for the QGraphicsView implementation + QAccessbileQuickView is the root for the SceneGraph implementation + +*/ +class QDeclarativeAccessible: public QAccessibleObject, public QAccessibleActionInterface +{ +public: + ~QDeclarativeAccessible(); + + virtual QRect viewRect() const = 0; + QFlags<QAccessible::RelationFlag> relationTo(const QAccessibleInterface*) const; + QAccessibleInterface *childAt(int, int) const; + QFlags<QAccessible::StateFlag> state() const; + QVariant invokeMethod(QAccessible::Method, const QVariantList &); + + QStringList actionNames() const; + void doAction(const QString &actionName); + QStringList keyBindingsForAction(const QString &actionName) const; + +protected: + virtual bool clipsChildren() const = 0; + // For subclasses, use instantiateObject factory method outside the class. + QDeclarativeAccessible(QObject *object); +}; + +#endif // QT_NO_ACCESSIBILITY + +QT_END_NAMESPACE + +#endif // QDECLARATIVEACCESSIBLE_H diff --git a/src/plugins/plugins.pro b/src/plugins/plugins.pro index 664a457608..ae42ba1ba4 100644 --- a/src/plugins/plugins.pro +++ b/src/plugins/plugins.pro @@ -1,2 +1,3 @@ TEMPLATE = subdirs SUBDIRS += qmltooling +SUBDIRS += accessible diff --git a/src/qtquick1/graphicsitems/graphicsitems.pri b/src/qtquick1/graphicsitems/graphicsitems.pri index 9904274023..d3125d0b66 100644 --- a/src/qtquick1/graphicsitems/graphicsitems.pri +++ b/src/qtquick1/graphicsitems/graphicsitems.pri @@ -2,6 +2,7 @@ INCLUDEPATH += $$PWD HEADERS += \ $$PWD/qdeclarativeitemsmodule_p.h \ + $$PWD/qdeclarativeaccessibleattached_p.h \ $$PWD/qdeclarativeanchors_p.h \ $$PWD/qdeclarativeanchors_p_p.h \ $$PWD/qdeclarativeevents_p_p.h \ @@ -59,6 +60,7 @@ HEADERS += \ SOURCES += \ $$PWD/qdeclarativeitemsmodule.cpp \ + $$PWD/qdeclarativeaccessibleattached.cpp \ $$PWD/qdeclarativeanchors.cpp \ $$PWD/qdeclarativeevents.cpp \ $$PWD/qdeclarativeflickable.cpp \ diff --git a/src/qtquick1/graphicsitems/qdeclarativeaccessibleattached.cpp b/src/qtquick1/graphicsitems/qdeclarativeaccessibleattached.cpp new file mode 100644 index 0000000000..c9d0645b01 --- /dev/null +++ b/src/qtquick1/graphicsitems/qdeclarativeaccessibleattached.cpp @@ -0,0 +1,76 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDeclarative module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qdeclarativeaccessibleattached_p.h" + +#ifndef QT_NO_ACCESSIBILITY + +#include "private/qdeclarativeitem_p.h" + +QT_BEGIN_NAMESPACE + + +QDeclarativeAccessibleAttached::QDeclarativeAccessibleAttached(QObject *parent) + : QObject(parent) +{ + Q_ASSERT(parent); + QDeclarativeItem *item = qobject_cast<QDeclarativeItem*>(parent); + if (!item) + return; + + // Enable accessibility for items with accessible content. This also + // enables accessibility for the ancestors of such items. + item->d_func()->setAccessibleFlagAndListener(); + QAccessible::updateAccessibility(item, 0, QAccessible::ObjectCreated); +} + +QDeclarativeAccessibleAttached::~QDeclarativeAccessibleAttached() +{ +} + +QDeclarativeAccessibleAttached *QDeclarativeAccessibleAttached::qmlAttachedProperties(QObject *obj) +{ + return new QDeclarativeAccessibleAttached(obj); +} + +QT_END_NAMESPACE + +#endif diff --git a/src/qtquick1/graphicsitems/qdeclarativeaccessibleattached_p.h b/src/qtquick1/graphicsitems/qdeclarativeaccessibleattached_p.h new file mode 100644 index 0000000000..8671c671b7 --- /dev/null +++ b/src/qtquick1/graphicsitems/qdeclarativeaccessibleattached_p.h @@ -0,0 +1,148 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDeclarative module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QQUICK1ACCESSIBLEATTACHED_H +#define QQUICK1ACCESSIBLEATTACHED_H + +#include <qdeclarativeitem.h> + +#include <QtCore/qobject.h> +#include <QtCore/qstring.h> + +#ifndef QT_NO_ACCESSIBILITY + +#include <private/qdeclarativeglobal_p.h> +#include <QtGui/qaccessible.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Declarative) + +class Q_QTQUICK1_EXPORT QDeclarativeAccessibleAttached : public QObject +{ + Q_OBJECT + Q_PROPERTY(QAccessible::Role role READ role WRITE setRole NOTIFY roleChanged) + Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged) + Q_PROPERTY(QString description READ description WRITE setDescription NOTIFY descriptionChanged) + +public: + Q_ENUMS(QAccessible::Role QAccessible::Event QAccessible::State) + + QDeclarativeAccessibleAttached(QObject *parent); + ~QDeclarativeAccessibleAttached(); + + QAccessible::Role role() const { return m_role; } + void setRole(QAccessible::Role role) + { + m_role = role; + emit roleChanged(); + // There is no way to signify role changes at the moment. + // QAccessible::updateAccessibility(parent(), 0, QAccessible::); + } + QString name() const { return m_name; } + void setName(const QString &name) + { + m_name = name; + emit nameChanged(); + QAccessible::updateAccessibility(parent(), 0, QAccessible::NameChanged); + } + + QString description() const { return m_description; } + void setDescription(const QString &description) + { + m_description = description; + emit descriptionChanged(); + QAccessible::updateAccessibility(parent(), 0, QAccessible::DescriptionChanged); + } + + // Factory function + static QDeclarativeAccessibleAttached *qmlAttachedProperties(QObject *); + + // Property getter + static QObject *attachedProperties(const QObject *obj) + { + return qmlAttachedPropertiesObject<QDeclarativeAccessibleAttached>(obj, false); + } + + static QVariant property(const QObject *object, const char *propertyName) + { + if (QObject *attachedObject = QDeclarativeAccessibleAttached::attachedProperties(object)) + return attachedObject->property(propertyName); + return QVariant(); + } + + static bool setProperty(QObject *object, const char *propertyName, const QVariant &value) + { + QObject *obj = qmlAttachedPropertiesObject<QDeclarativeAccessibleAttached>(object, true); + if (!obj) { + qWarning("cannot set property Accessible.%s of QObject %s", propertyName, object->metaObject()->className()); + return false; + } + return obj->setProperty(propertyName, value); + } + + +Q_SIGNALS: + void roleChanged(); + void nameChanged(); + void descriptionChanged(); +private: + QAccessible::Role m_role; + QString m_name; + QString m_description; +public: + using QObject::property; +}; + + +QT_END_NAMESPACE + +QML_DECLARE_TYPE(QDeclarativeAccessibleAttached) +QML_DECLARE_TYPEINFO(QDeclarativeAccessibleAttached, QML_HAS_ATTACHED_PROPERTIES) + +QT_END_HEADER + +#endif // QT_NO_ACCESSIBILITY + +#endif + diff --git a/src/qtquick1/graphicsitems/qdeclarativeitem.cpp b/src/qtquick1/graphicsitems/qdeclarativeitem.cpp index 1f57d53b7e..016dc94408 100644 --- a/src/qtquick1/graphicsitems/qdeclarativeitem.cpp +++ b/src/qtquick1/graphicsitems/qdeclarativeitem.cpp @@ -53,6 +53,8 @@ #include <QtQuick1/private/qdeclarativestategroup_p.h> #include <QtDeclarative/qdeclarativecomponent.h> #include <QtDeclarative/qdeclarativeinfo.h> +// ### Due to the workaround mentioned in accessibleRole() +#include <QtQuick1/private/qdeclarativetext_p.h> #include <QDebug> #include <QPen> @@ -64,6 +66,8 @@ #include <private/qv8engine_p.h> #include <QtWidgets/qgraphicstransform.h> #include <private/qlistmodelinterface_p.h> +#include <QAccessible> +#include <QtQuick1/private/qdeclarativeaccessibleattached_p.h> #include <float.h> @@ -1779,7 +1783,11 @@ QDeclarativeItem::~QDeclarativeItem() */ void QDeclarativeItem::setParentItem(QDeclarativeItem *parent) { + Q_D(QDeclarativeItem); QGraphicsObject::setParentItem(parent); + if (d->isAccessible && parentItem()) { + parentItem()->d_func()->setAccessibleFlagAndListener(); + } } /*! @@ -3022,6 +3030,25 @@ QDeclarativeItemPrivate::AnchorLines::AnchorLines(QGraphicsObject *q) baseline.anchorLine = QDeclarative1AnchorLine::Baseline; } +void QDeclarativeItemPrivate::setAccessibleFlagAndListener() +{ + Q_Q(QDeclarativeItem); + QDeclarativeItem *item = q; + while (item) { + if (item->d_func()->isAccessible) + break; // already set - grandparents should have the flag set as well. + +// if (qmlEngine(item) != 0) { +// item->d_func()->addItemChangeListener(QDeclarativeEnginePrivate::getAccessibilityUpdateManager(qmlEngine(item)), +// QDeclarativeItemPrivate::Geometry | QDeclarativeItemPrivate::Visibility | +// QDeclarativeItemPrivate::Opacity | QDeclarativeItemPrivate::Destroyed); +// } + + item->d_func()->isAccessible = true; + item = item->parentItem(); + } +} + QPointF QDeclarativeItemPrivate::computeTransformOrigin() const { Q_Q(const QDeclarativeItem); diff --git a/src/qtquick1/graphicsitems/qdeclarativeitem.h b/src/qtquick1/graphicsitems/qdeclarativeitem.h index c56b59125b..80c5e35ce4 100644 --- a/src/qtquick1/graphicsitems/qdeclarativeitem.h +++ b/src/qtquick1/graphicsitems/qdeclarativeitem.h @@ -50,6 +50,7 @@ #include <QtGui/qfont.h> #include <QtWidgets/qgraphicsitem.h> #include <QtWidgets/qgraphicstransform.h> +#include <QtGui/qaccessible.h> #include <QtWidgets/qaction.h> QT_BEGIN_HEADER @@ -198,6 +199,8 @@ protected: private: Q_DISABLE_COPY(QDeclarativeItem) Q_DECLARE_PRIVATE_D(QGraphicsItem::d_ptr.data(), QDeclarativeItem) + + friend class QDeclarativeAccessibleAttached; }; template<typename T> diff --git a/src/qtquick1/graphicsitems/qdeclarativeitem_p.h b/src/qtquick1/graphicsitems/qdeclarativeitem_p.h index 1dcafe55f4..b884c38b6a 100644 --- a/src/qtquick1/graphicsitems/qdeclarativeitem_p.h +++ b/src/qtquick1/graphicsitems/qdeclarativeitem_p.h @@ -71,6 +71,7 @@ #include <QtCore/qlist.h> #include <QtCore/qrect.h> #include <QtCore/qdebug.h> +#include <QtGui/qaccessible.h> #include <QtWidgets/private/qgraphicsitem_p.h> @@ -287,6 +288,7 @@ public: bool isMirrorImplicit:1; bool inheritMirrorFromParent:1; bool inheritMirrorFromItem:1; + bool isAccessible:1; QDeclarativeItemKeyFilter *keyHandler; @@ -298,6 +300,7 @@ public: QDeclarative1LayoutMirroringAttached* attachedLayoutDirection; bool hadSubFocusItem; + void setAccessibleFlagAndListener(); QPointF computeTransformOrigin() const; @@ -617,6 +620,7 @@ private: static const SigMap sigMap[]; }; + Q_DECLARE_OPERATORS_FOR_FLAGS(QDeclarativeItemPrivate::ChangeTypes); QT_END_NAMESPACE diff --git a/src/qtquick1/graphicsitems/qdeclarativeitemsmodule.cpp b/src/qtquick1/graphicsitems/qdeclarativeitemsmodule.cpp index 0a20b949b8..24ab4df4e2 100644 --- a/src/qtquick1/graphicsitems/qdeclarativeitemsmodule.cpp +++ b/src/qtquick1/graphicsitems/qdeclarativeitemsmodule.cpp @@ -76,6 +76,7 @@ #include "QtQuick1/private/qdeclarativegraphicswidget_p.h" #include "QtQuick1/private/qdeclarativeanchors_p.h" #include "QtQuick1/private/qdeclarativepincharea_p.h" +#include "QtQuick1/private/qdeclarativeaccessibleattached_p.h" static QDeclarativePrivate::AutoParentResult qgraphicsobject_autoParent(QObject *obj, QObject *parent) { @@ -199,6 +200,11 @@ void QDeclarative1ItemModule::defineModule(QDeclarativeQtQuick1Module::Module mo qmlRegisterRevision<QDeclarative1ImplicitSizePaintedItem,0>("QtQuick",1,0); qmlRegisterRevision<QDeclarative1ImplicitSizePaintedItem,1>("QtQuick",1,1); qmlRegisterUncreatableType<QDeclarative1LayoutMirroringAttached>("QtQuick",1,1,"LayoutMirroring", QDeclarative1LayoutMirroringAttached::tr("LayoutMirroring is only available via attached properties")); +#ifndef QT_NO_ACCESSIBILITY + qmlRegisterUncreatableType<QDeclarativeAccessibleAttached>("QtQuick",1,0,"Accessible",QDeclarativeAccessibleAttached::tr("Accessible is only available via attached properties")); + qmlRegisterUncreatableType<QDeclarativeAccessibleAttached>("QtQuick",1,1,"Accessible",QDeclarativeAccessibleAttached::tr("Accessible is only available via attached properties")); +#endif + } else if (module == QDeclarativeQtQuick1Module::Qt47) { #ifdef QT_NO_MOVIE qmlRegisterTypeNotAvailable("Qt",4,7,"AnimatedImage", diff --git a/src/qtquick1/util/qdeclarativeview.cpp b/src/qtquick1/util/qdeclarativeview.cpp index 8581947c06..55b8a772fa 100644 --- a/src/qtquick1/util/qdeclarativeview.cpp +++ b/src/qtquick1/util/qdeclarativeview.cpp @@ -743,4 +743,10 @@ void QDeclarativeView::paintEvent(QPaintEvent *event) } +QDeclarativeItem * QDeclarativeView::accessibleRootItem() const +{ + Q_D(const QDeclarativeView); + return d->declarativeItemRoot; +} + QT_END_NAMESPACE diff --git a/src/qtquick1/util/qdeclarativeview.h b/src/qtquick1/util/qdeclarativeview.h index 4249d26980..9780d7a413 100644 --- a/src/qtquick1/util/qdeclarativeview.h +++ b/src/qtquick1/util/qdeclarativeview.h @@ -57,6 +57,7 @@ class QGraphicsObject; class QDeclarativeEngine; class QDeclarativeContext; class QDeclarativeError; +class QDeclarativeItem; QT_MODULE(Declarative) @@ -113,6 +114,9 @@ protected: private: Q_DISABLE_COPY(QDeclarativeView) Q_DECLARE_PRIVATE(QDeclarativeView) +// Accessibility support: + friend class QAccessibleDeclarativeView; + QDeclarativeItem *accessibleRootItem() const; }; QT_END_NAMESPACE diff --git a/src/quick/items/items.pri b/src/quick/items/items.pri index 28a32fcc48..f02c769c3a 100644 --- a/src/quick/items/items.pri +++ b/src/quick/items/items.pri @@ -1,10 +1,11 @@ HEADERS += \ $$PWD/qquickevents_p_p.h \ - $$PWD/qquickitemchangelistener_p.h \ $$PWD/qquickanchors_p.h \ $$PWD/qquickanchors_p_p.h \ + $$PWD/qquickaccessibleattached_p.h \ $$PWD/qquickitem.h \ $$PWD/qquickitem_p.h \ + $$PWD/qquickitemchangelistener_p.h \ $$PWD/qquickrectangle_p.h \ $$PWD/qquickrectangle_p_p.h \ $$PWD/qquickcanvas.h \ @@ -116,6 +117,7 @@ SOURCES += \ $$PWD/qquickspriteengine.cpp \ $$PWD/qquicksprite.cpp \ $$PWD/qquickspriteimage.cpp \ + $$PWD/qquickaccessibleattached.cpp \ $$PWD/qquickdrag.cpp \ $$PWD/qquickdroparea.cpp \ $$PWD/qquickmultipointtoucharea.cpp \ diff --git a/src/quick/items/qquickaccessibleattached.cpp b/src/quick/items/qquickaccessibleattached.cpp new file mode 100644 index 0000000000..4fa3b87bf0 --- /dev/null +++ b/src/quick/items/qquickaccessibleattached.cpp @@ -0,0 +1,132 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDeclarative module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qquickaccessibleattached_p.h" + +#ifndef QT_NO_ACCESSIBILITY + +#include "private/qquickitem_p.h" + +QT_BEGIN_NAMESPACE + +/*! + \qmlclass Accessible QQuickAccessibleAttached + \inqmlmodule QtQuick 2 + \ingroup qml-basic-interaction-elements + \brief Attached property to enable accessibility of QML items. + + Items the user interacts with or that give information to the user + need to expose their information in a semantic way. + Then assistive tools can make use of that information to enable + users to interact with the application in various ways. + + This enables Qt Quick applications to be used with screen-readers for example. + + The most important properties to set are \l name and \l role. + + \sa Accessibility +*/ + +/*! + \qmlproperty string QtQuick2::Accessible::name + + This property sets an accessible name. + For a button for example, this should have a binding to its text. + In general this property should be set to a simple and concise + but human readable name. Do not include the type of control + you want to represent but just the name. +*/ + +/*! + \qmlproperty string QtQuick2::Accessible::description + + This property sets an accessible description. + Similar to the name it describes the item. The description + can be a little more verbose and tell what the item does, + for example the functionallity of the button it describes. +*/ + +/*! + \qmlproperty enumeration QtQuick2::Accessible::role + + This flags sets the semantic type of the widget. + A button for example would have "Button" as type. + The value must be one of \l QAccessible::Role . + Example: + \qml + Item { + id: myButton + Text { + id: label + // ... + } + Accessible.name: label.text + Accessible.role: Accessible.Button + } + \endqml +*/ + +QQuickAccessibleAttached::QQuickAccessibleAttached(QObject *parent) + : QObject(parent) +{ + Q_ASSERT(parent); + QQuickItem *item = qobject_cast<QQuickItem*>(parent); + if (!item) + return; + + // Enable accessibility for items with accessible content. This also + // enables accessibility for the ancestors of souch items. + item->d_func()->setAccessibleFlagAndListener(); + QAccessible::updateAccessibility(item, 0, QAccessible::ObjectCreated); +} + +QQuickAccessibleAttached::~QQuickAccessibleAttached() +{ +} + +QQuickAccessibleAttached *QQuickAccessibleAttached::qmlAttachedProperties(QObject *obj) +{ + return new QQuickAccessibleAttached(obj); +} + +QT_END_NAMESPACE + +#endif diff --git a/src/quick/items/qquickaccessibleattached_p.h b/src/quick/items/qquickaccessibleattached_p.h new file mode 100644 index 0000000000..184dc2116d --- /dev/null +++ b/src/quick/items/qquickaccessibleattached_p.h @@ -0,0 +1,153 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDeclarative module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QQUICKACCESSIBLEATTACHED_H +#define QQUICKACCESSIBLEATTACHED_H + +#include <QtQuick/qquickitem.h> + +#include <QtCore/qobject.h> +#include <QtCore/qstring.h> + +#ifndef QT_NO_ACCESSIBILITY + +#include <QtGui/qaccessible.h> +#include <private/qtquickglobal_p.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Declarative) + +class Q_QUICK_PRIVATE_EXPORT QQuickAccessibleAttached : public QObject +{ + Q_OBJECT + Q_PROPERTY(QAccessible::Role role READ role WRITE setRole NOTIFY roleChanged) + Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged) + Q_PROPERTY(QString description READ description WRITE setDescription NOTIFY descriptionChanged) + +public: + Q_ENUMS(QAccessible::Role QAccessible::Event QAccessible::State) + + QQuickAccessibleAttached(QObject *parent); + ~QQuickAccessibleAttached(); + + QAccessible::Role role() const { return m_role; } + void setRole(QAccessible::Role role) + { + if (role != m_role) { + m_role = role; + emit roleChanged(); + // There is no way to signify role changes at the moment. + // QAccessible::updateAccessibility(parent(), 0, QAccessible::); + } + } + QString name() const { return m_name; } + void setName(const QString &name) { + if (name != m_name) { + m_name = name; + emit nameChanged(); + QAccessible::updateAccessibility(parent(), 0, QAccessible::NameChanged); + } + } + + QString description() const { return m_description; } + void setDescription(const QString &description) + { + if (m_description != description) { + m_description = description; + emit descriptionChanged(); + QAccessible::updateAccessibility(parent(), 0, QAccessible::DescriptionChanged); + } + } + + // Factory function + static QQuickAccessibleAttached *qmlAttachedProperties(QObject *obj); + + // Property getter + static QObject *attachedProperties(const QObject *obj) + { + return qmlAttachedPropertiesObject<QQuickAccessibleAttached>(obj, false); + } + + static QVariant property(const QObject *object, const char *propertyName) + { + if (QObject *attachedObject = QQuickAccessibleAttached::attachedProperties(object)) + return attachedObject->property(propertyName); + return QVariant(); + } + + static bool setProperty(QObject *object, const char *propertyName, const QVariant &value) + { + QObject *obj = qmlAttachedPropertiesObject<QQuickAccessibleAttached>(object, true); + if (!obj) { + qWarning("cannot set property Accessible.%s of QObject %s", propertyName, object->metaObject()->className()); + return false; + } + return obj->setProperty(propertyName, value); + } + + +Q_SIGNALS: + void roleChanged(); + void nameChanged(); + void descriptionChanged(); +private: + QAccessible::Role m_role; + QString m_name; + QString m_description; + +public: + using QObject::property; +}; + + +QT_END_NAMESPACE + +QML_DECLARE_TYPE(QQuickAccessibleAttached) +QML_DECLARE_TYPEINFO(QQuickAccessibleAttached, QML_HAS_ATTACHED_PROPERTIES) + +QT_END_HEADER + +#endif // QT_NO_ACCESSIBILITY + +#endif diff --git a/src/quick/items/qquickcanvas.cpp b/src/quick/items/qquickcanvas.cpp index c827bfbb52..eab6292f22 100644 --- a/src/quick/items/qquickcanvas.cpp +++ b/src/quick/items/qquickcanvas.cpp @@ -116,6 +116,10 @@ private: bool m_eventSent; }; +QAccessibleInterface *QQuickCanvas::accessibleRoot() const +{ + return QAccessible::queryAccessibleInterface(const_cast<QQuickCanvas*>(this)); +} /* diff --git a/src/quick/items/qquickcanvas.h b/src/quick/items/qquickcanvas.h index d38ed97028..de82e8386e 100644 --- a/src/quick/items/qquickcanvas.h +++ b/src/quick/items/qquickcanvas.h @@ -97,6 +97,8 @@ public: QDeclarativeIncubationController *incubationController() const; + virtual QAccessibleInterface *accessibleRoot() const; + // Scene graph specific functions QSGTexture *createTextureFromImage(const QImage &image) const; QSGTexture *createTextureFromId(uint id, const QSize &size, CreateTextureOptions options = CreateTextureOption(0)) const; diff --git a/src/quick/items/qquickitem.cpp b/src/quick/items/qquickitem.cpp index c95ae1a9c3..e9dc737e8a 100644 --- a/src/quick/items/qquickitem.cpp +++ b/src/quick/items/qquickitem.cpp @@ -66,6 +66,7 @@ #include <private/qlistmodelinterface_p.h> #include <private/qquickitem_p.h> #include <private/qdeclarativeaccessors_p.h> +#include <QtQuick/private/qquickaccessibleattached_p.h> #include <float.h> @@ -1603,6 +1604,22 @@ void QQuickItemPrivate::setLayoutMirror(bool mirror) } } +void QQuickItemPrivate::setAccessibleFlagAndListener() +{ + Q_Q(QQuickItem); + QQuickItem *item = q; + while (item) { + if (item->d_func()->isAccessible) + break; // already set - grandparents should have the flag set as well. + + if (item->canvas() && item->canvas()->rootItem() == item) + break; // don't add a listener to the canvas root item + + item->d_func()->isAccessible = true; + item = item->d_func()->parentItem; + } +} + /*! \class QQuickItem \brief The QQuickItem class provides the most basic of all visual items in QML. @@ -1804,6 +1821,7 @@ QQuickItem::~QQuickItem() if (change.types & QQuickItemPrivate::Destroyed) change.listener->itemDestroyed(this); } + d->changeListeners.clear(); delete d->_anchorLines; d->_anchorLines = 0; delete d->_anchors; d->_anchors = 0; @@ -1913,6 +1931,10 @@ void QQuickItem::setParentItem(QQuickItem *parentItem) d->itemChange(ItemParentHasChanged, d->parentItem); d->parentNotifier.notify(); + if (d->isAccessible && d->parentItem) { + d->parentItem->d_func()->setAccessibleFlagAndListener(); + } + emit parentChanged(d->parentItem); } @@ -2251,6 +2273,7 @@ QQuickItemPrivate::QQuickItemPrivate() inheritedLayoutMirror(false), effectiveLayoutMirror(false), isMirrorImplicit(true), inheritMirrorFromParent(false), inheritMirrorFromItem(false), childrenDoNotOverlap(false), staticSubtreeGeometry(false), + isAccessible(false), canvas(0), parentItem(0), sortedChildItems(&childItems), @@ -2886,6 +2909,11 @@ void QQuickItem::updatePolish() { } +void QQuickItem::sendAccessibilityUpdate() +{ + Q_D(QQuickItem); +} + void QQuickItemPrivate::removeItemChangeListener(QQuickItemChangeListener *listener, ChangeTypes types) { ChangeListener change(listener, types); @@ -2931,6 +2959,7 @@ void QQuickItem::inputMethodEvent(QInputMethodEvent *event) void QQuickItem::focusInEvent(QFocusEvent *) { + QAccessible::updateAccessibility(this, 0, QAccessible::Focus); } void QQuickItem::focusOutEvent(QFocusEvent *) @@ -3895,6 +3924,9 @@ void QQuickItemPrivate::setEffectiveVisibleRecur(bool newEffectiveVisible) change.listener->itemVisibilityChanged(q); } + if (isAccessible) + QAccessible::updateAccessibility(q, 0, effectiveVisible ? QAccessible::ObjectShow : QAccessible::ObjectHide ); + emit q->visibleChanged(); } diff --git a/src/quick/items/qquickitem.h b/src/quick/items/qquickitem.h index ffc1017105..763fc59ac4 100644 --- a/src/quick/items/qquickitem.h +++ b/src/quick/items/qquickitem.h @@ -51,6 +51,7 @@ #include <QtCore/QList> #include <QtGui/qevent.h> #include <QtGui/qfont.h> +#include <QtGui/qaccessible.h> QT_BEGIN_HEADER @@ -393,6 +394,9 @@ protected: virtual QSGNode *updatePaintNode(QSGNode *, UpdatePaintNodeData *); virtual void updatePolish(); +protected Q_SLOTS: + void sendAccessibilityUpdate(); + protected: QQuickItem(QQuickItemPrivate &dd, QQuickItem *parent = 0); @@ -400,6 +404,8 @@ private: friend class QQuickCanvas; friend class QQuickCanvasPrivate; friend class QSGRenderer; + friend class QAccessibleQuickItem; + friend class QQuickAccessibleAttached; Q_DISABLE_COPY(QQuickItem) Q_DECLARE_PRIVATE(QQuickItem) }; diff --git a/src/quick/items/qquickitem_p.h b/src/quick/items/qquickitem_p.h index 6ed4a694a7..1a23ab1732 100644 --- a/src/quick/items/qquickitem_p.h +++ b/src/quick/items/qquickitem_p.h @@ -280,6 +280,7 @@ public: bool inheritMirrorFromItem:1; bool childrenDoNotOverlap:1; bool staticSubtreeGeometry:1; + bool isAccessible:1; QQuickCanvas *canvas; QSGContext *sceneGraphContext() const { Q_ASSERT(canvas); return static_cast<QQuickCanvasPrivate *>(QObjectPrivate::get(canvas))->context; } @@ -337,6 +338,8 @@ public: Qt::MouseButtons acceptedMouseButtons; Qt::InputMethodHints imHints; + void setAccessibleFlagAndListener(); + QPointF transformOriginPoint; virtual qreal getImplicitWidth() const; diff --git a/src/quick/items/qquickitemsmodule.cpp b/src/quick/items/qquickitemsmodule.cpp index 69b9caf940..b5eb611e78 100644 --- a/src/quick/items/qquickitemsmodule.cpp +++ b/src/quick/items/qquickitemsmodule.cpp @@ -82,6 +82,7 @@ #include "qquickdroparea_p.h" #include "qquickmultipointtoucharea_p.h" #include <private/qdeclarativemetatype_p.h> +#include <QtQuick/private/qquickaccessibleattached_p.h> static QDeclarativePrivate::AutoParentResult qquickitem_autoParent(QObject *obj, QObject *parent) { @@ -215,6 +216,10 @@ static void qt_quickitems_defineModule(const char *uri, int major, int minor) qmlRegisterType<QQuickMultiPointTouchArea>("QtQuick", 2, 0, "MultiPointTouchArea"); qmlRegisterType<QQuickTouchPoint>("QtQuick", 2, 0, "TouchPoint"); qmlRegisterType<QQuickGrabGestureEvent>(); + +#ifndef QT_NO_ACCESSIBILITY + qmlRegisterUncreatableType<QQuickAccessibleAttached>("QtQuick", 2, 0, "Accessible",QQuickAccessibleAttached::tr("Accessible is only available via attached properties")); +#endif } void QQuickItemsModule::defineModule() diff --git a/src/quick/items/qquicktext.cpp b/src/quick/items/qquicktext.cpp index 2a6be05851..5072bf1a58 100644 --- a/src/quick/items/qquicktext.cpp +++ b/src/quick/items/qquicktext.cpp @@ -1920,6 +1920,9 @@ void QQuickText::componentComplete() QQuickItem::componentComplete(); if (d->updateOnComponentComplete) d->updateLayout(); + + // Enable accessibility for text items. + d->setAccessibleFlagAndListener(); } |