qt 6.5.1 original

util/accessibilityinspector/accessibilityinspector.cpp

@@ -0,0 +1,133 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include "accessibilityinspector.h"
+
+#include "screenreader.h"
+#include "optionswidget.h"
+#include "accessibilityscenemanager.h"
+
+#include <QtDeclarative/QtDeclarative>
+
+void MouseInterceptingGraphicsScene::mousePressEvent(QGraphicsSceneMouseEvent *event)
+{
+    emit mousePressed(event->scenePos().toPoint());
+    QGraphicsScene::mousePressEvent(event);
+}
+
+void MouseInterceptingGraphicsScene::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
+{
+    emit mouseDobleClicked();
+    QGraphicsScene::mouseDoubleClickEvent(event);
+}
+
+AccessibilitySceneManager *sceneManager = 0;
+QAccessible::UpdateHandler previousUpdateHandler = 0;
+bool updateHandlerRecursion = false;
+void accessibilityUpdateHandler(QAccessibleEvent *event)
+{
+    if (updateHandlerRecursion)
+        return;
+
+    updateHandlerRecursion = true;
+
+    if (sceneManager) {
+        sceneManager->handleUpdate(event);
+
+        //qDebug() << "update";
+    }
+
+    if (previousUpdateHandler) // call prev just to be sure.
+        previousUpdateHandler(event);
+
+    updateHandlerRecursion = false;
+}
+
+AccessibilityInspector::AccessibilityInspector(QObject *parent) :
+    QObject(parent)
+{
+}
+
+AccessibilityInspector::~AccessibilityInspector()
+{
+    delete optionsWidget;
+    delete accessibilityScene;
+    delete accessibilityView;
+    delete accessibilityTreeScene;
+    delete accessibilityTreeView;
+    delete screenReader;
+}
+
+void AccessibilityInspector::inspectWindow(QWindow *window)
+{
+    qDebug() << "AccessibilityInspector::inspectWindow()" << window;
+    if (window->parent() || window->transientParent())
+        return;
+
+    optionsWidget = new OptionsWidget();
+
+    accessibilityScene = new MouseInterceptingGraphicsScene();
+
+    accessibilityView = new QGraphicsView();
+    accessibilityView->setScene(accessibilityScene);
+    accessibilityView->resize(640, 480);
+    accessibilityView->scale(1.3, 1.3);
+
+    accessibilityTreeScene = new QGraphicsScene();
+
+    accessibilityTreeView = new QGraphicsView();
+    accessibilityTreeView->setScene(accessibilityTreeScene);
+    accessibilityTreeView->resize(640, 480);
+
+    sceneManager = new AccessibilitySceneManager();
+    QObject::connect(optionsWidget, SIGNAL(optionsChanged()), sceneManager, SLOT(updateAccessibilitySceneItemFlags()));
+    QObject::connect(optionsWidget, SIGNAL(refreshClicked()), sceneManager, SLOT(populateAccessibilityScene()));
+    QObject::connect(optionsWidget, SIGNAL(refreshClicked()), sceneManager, SLOT(populateAccessibilityTreeScene()));
+    QObject::connect(optionsWidget, SIGNAL(scaleChanged(int)), sceneManager, SLOT(changeScale(int)));
+
+    sceneManager->setOptionsWidget(optionsWidget);
+    sceneManager->setRootWindow(window);
+    sceneManager->setScene(accessibilityScene);
+    sceneManager->setView(accessibilityView);
+    sceneManager->setTreeScene(accessibilityTreeScene);
+    sceneManager->setTreeView(accessibilityTreeView);
+
+    screenReader = new ScreenReader;
+    QObject::connect(accessibilityScene, SIGNAL(mousePressed(QPoint)), screenReader, SLOT(touchPoint(QPoint)));
+    QObject::connect(accessibilityScene, SIGNAL(mouseDobleClicked()), screenReader, SLOT(activate()));
+    QObject::connect(screenReader, SIGNAL(selected(QObject*)), sceneManager, SLOT(setSelected(QObject*)));
+    screenReader->setRootObject(window);
+    screenReader->setOptionsWidget(optionsWidget);
+
+    previousUpdateHandler = QAccessible::installUpdateHandler(accessibilityUpdateHandler);
+
+    QTimer::singleShot(100, sceneManager, SLOT(populateAccessibilityScene()));
+    QTimer::singleShot(100, sceneManager, SLOT(populateAccessibilityTreeScene()));
+
+    QSettings settings;
+    accessibilityView->restoreGeometry(settings.value("accessiblityGeometry").toByteArray());
+    accessibilityView->setObjectName(QLatin1String("accessibilityInspectorView"));
+    accessibilityView->show();
+
+
+    accessibilityTreeView->restoreGeometry(settings.value("treeGeometry").toByteArray());
+    accessibilityTreeView->setObjectName(QLatin1String("accessibilityInspectorTreeView"));
+    accessibilityTreeView->show();
+    optionsWidget->restoreGeometry(settings.value("optionsGeometry").toByteArray());
+    optionsWidget->setObjectName(QLatin1String("accessibilityInspectorOptions"));
+    optionsWidget->show();
+}
+
+void AccessibilityInspector::saveWindowGeometry()
+{
+    QSettings settings;
+    settings.setValue("accessiblityGeometry", accessibilityView->saveGeometry());
+    settings.setValue("treeGeometry", accessibilityTreeView->saveGeometry());
+    settings.setValue("optionsGeometry", optionsWidget->saveGeometry());
+}
+
+QString translateRole(QAccessible::Role role)
+{
+    return qAccessibleRoleString(role);
+}
+

util/accessibilityinspector/accessibilityinspector.h

@@ -0,0 +1,49 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#ifndef ACCESSIBILITYINSPECTOR_H
+#define ACCESSIBILITYINSPECTOR_H
+
+#include <QObject>
+#include <qgraphicsscene.h>
+#include <QAccessible>
+
+QString translateRole(QAccessible::Role role);
+
+class OptionsWidget;
+class MouseInterceptingGraphicsScene;
+class QGraphicsView;
+class QGraphicsScene;
+class AccessibilitySceneManager;
+class ScreenReader;
+class AccessibilityInspector : public QObject
+{
+    Q_OBJECT
+public:
+    explicit AccessibilityInspector(QObject *parent = nullptr);
+    ~AccessibilityInspector();
+    void inspectWindow(QWindow *window);
+    void saveWindowGeometry();
+signals:
+
+private:
+    OptionsWidget *optionsWidget;
+    MouseInterceptingGraphicsScene *accessibilityScene;
+    QGraphicsView *accessibilityView;
+    QGraphicsScene *accessibilityTreeScene;
+    QGraphicsView *accessibilityTreeView;
+    ScreenReader *screenReader;
+};
+
+class MouseInterceptingGraphicsScene : public QGraphicsScene
+{
+Q_OBJECT
+protected:
+    virtual void mousePressEvent(QGraphicsSceneMouseEvent *event);
+    virtual void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event);
+signals:
+    void mousePressed(const QPoint point);
+    void mouseDobleClicked();
+};
+
+#endif // ACCESSIBILITYINSPECTOR_H

util/accessibilityinspector/accessibilityinspector.pri

@@ -0,0 +1,19 @@
+QT += declarative
+INCLUDEPATH += $$PWD
+
+# DEFINES += ACCESSIBILITYINSPECTOR_NO_UITOOLS
+# QT += uitools
+
+HEADERS += \
+    $$PWD/screenreader.h \
+    $$PWD/optionswidget.h \
+    $$PWD/accessibilityscenemanager.h \
+    $$PWD/accessibilityinspector.h
+SOURCES += \
+    $$PWD/optionswidget.cpp \
+    $$PWD/accessibilityscenemanager.cpp \
+    $$PWD/screenreader.cpp \
+    $$PWD/accessibilityinspector.cpp
+
+
+

util/accessibilityinspector/accessibilityinspector.pro

@@ -0,0 +1,5 @@
+include (accessibilityinspector.pri)
+
+SOURCES += main.cpp \
+
+CONFIG += console

util/accessibilityinspector/accessibilityscenemanager.cpp

@@ -0,0 +1,444 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include "accessibilityscenemanager.h"
+
+AccessibilitySceneManager::AccessibilitySceneManager()
+{
+    m_window = 0;
+    m_view = 0;
+    m_scene = 0;
+    m_rootItem = 0;
+    m_optionsWidget = 0;
+    m_selectedObject = 0;
+}
+
+void AccessibilitySceneManager::populateAccessibilityScene()
+{
+    m_scene->clear();
+    m_graphicsItems.clear();
+
+    QAccessibleInterface * rootInterface = m_window->accessibleRoot();
+    if (!rootInterface)
+        return;
+
+    populateAccessibilityScene(rootInterface, m_scene);
+}
+
+void AccessibilitySceneManager::updateAccessibilitySceneItemFlags()
+{
+    qDebug() << "update";
+    foreach (QObject *object, m_graphicsItems.keys()) {
+        if (!object)
+            continue;
+        QAccessibleInterface *interface = QAccessible::queryAccessibleInterface(object);
+        if (!interface)
+            continue;
+        updateItemFlags(m_graphicsItems.value(object), interface);
+    }
+}
+
+void AccessibilitySceneManager::populateAccessibilityTreeScene()
+{
+    m_treeScene->clear();
+    QAccessibleInterface * rootInterface = m_window->accessibleRoot();
+    if (!rootInterface) {
+        qWarning("QWindow::accessibleRoot returned 0");
+        return;
+    }
+
+    populateAccessibilityTreeScene(rootInterface);
+}
+
+void AccessibilitySceneManager::handleUpdate(QAccessibleEvent *event)
+{
+    QObject *object = event->object();
+    QAccessible::Event type = event->type();
+
+    QAccessibleInterface *interface = QAccessible::queryAccessibleInterface(object);
+    if (!interface)
+        return;
+
+    QString name = interface->text(QAccessible::Name);
+
+    if (type == QAccessible::ObjectCreated) {
+  //      qDebug() << "ObjectCreated" << object << name;
+        populateAccessibilityScene(interface, m_scene);
+    }
+
+    QGraphicsRectItem *item = m_graphicsItems.value(object);
+
+    if (!item) {
+//        qDebug() << "populateAccessibilityScene failed for" << object;
+        return;
+    }
+
+    if (type == QAccessible::LocationChanged) {
+
+        //if (name.startsWith("List"))
+            qDebug() << "locationChange" << object << name << interface->rect();
+
+        updateItem(item, interface);
+        for (int i = 0; i < interface->childCount(); ++i) {
+           QAccessibleInterface *child = interface->child(i);
+           if (child) {
+               updateItem(m_graphicsItems.value(child->object()), child);
+            }
+        }
+
+    } else if (type == QAccessible::ObjectDestroyed) {
+//        qDebug() << "ObjectDestroyed" << object << name;
+        delete m_graphicsItems.value(object);
+        m_graphicsItems.remove(object);
+        m_animatedObjects.remove(object);
+        if (object == m_selectedObject) {
+            m_selectedObject = 0;
+        }
+    } else if (type == QAccessible::ObjectHide) {
+//        qDebug() << "ObjectCreated Hide" << object;
+        updateItemFlags(item, interface);
+    } else if (type == QAccessible::ObjectShow) {
+//        qDebug() << "ObjectCreated Show" << object;
+        updateItemFlags(item, interface);
+    } else if (type == QAccessible::ScrollingStart) {
+        qDebug() << "ObjectCreated ScrollingStart" << object;
+        for (int i = 0; i < interface->childCount(); ++i) {
+            QAccessibleInterface *child = interface->child(i);
+            if (child) {
+                m_animatedObjects.insert(child->object());
+            }
+        }
+    } else if (type == QAccessible::ScrollingEnd) {
+        // qDebug() << "ObjectCreated ScrollingEnd" << object;
+        foreach (QObject *object, m_animatedObjects) {
+            updateItem(m_graphicsItems.value(object), interface);
+        }
+        m_animatedObjects.clear();
+
+    } else {
+//        qDebug() << "other update" << object;
+    }
+}
+
+void AccessibilitySceneManager::setSelected(QObject *object)
+{
+    m_scene->update(); // scedule update
+
+    // clear existing selection
+    if (m_selectedObject) {
+        QObject *previousSelectedObject = m_selectedObject;
+        m_selectedObject = 0;
+        updateItem(previousSelectedObject);
+    }
+
+    m_selectedObject = object;
+    updateItem(object);
+
+    populateAccessibilityTreeScene();
+}
+
+void AccessibilitySceneManager::changeScale(int)
+{
+    // No QGraphicsView::setScale :(
+
+    //m_view->scale(scale / 10.0, scale / 10.0);
+    //if (m_rootItem)
+    //    m_view->ensureVisible(m_rootItem);
+}
+
+void AccessibilitySceneManager::updateItems(QObject *root)
+{
+    QAccessibleInterface *interface = QAccessible::queryAccessibleInterface(root);
+    if (!interface)
+        return;
+    updateItem(m_graphicsItems.value(root), interface);
+
+    for (int i = 0; i < interface->childCount(); ++i) {
+        QAccessibleInterface *child = interface->child(i);
+        updateItems(child->object());
+    }
+}
+
+void AccessibilitySceneManager::updateItem(QObject *object)
+{
+    if (!object)
+        return;
+
+    QAccessibleInterface *interface = QAccessible::queryAccessibleInterface(object);
+    if (!interface)
+        return;
+
+    updateItem(m_graphicsItems.value(object), interface);
+}
+
+void AccessibilitySceneManager::updateItem(QGraphicsRectItem *item, QAccessibleInterface *interface)
+{
+    if (!item)
+        return;
+
+    QRect rect = interface->rect();
+    item->setPos(rect.topLeft());
+    item->setRect(QRect(QPoint(0,0), rect.size()));
+
+    updateItemFlags(item, interface);
+}
+
+void AccessibilitySceneManager::updateItemFlags(QGraphicsRectItem *item, QAccessibleInterface *interface)
+{
+  //  qDebug() << "udpateItemFlags" << interface << interface->object();
+
+    bool shouldShow = true;
+
+    if (m_optionsWidget->hideInvisibleItems()) {
+        if (isHidden(interface)) {
+            shouldShow = false;
+        }
+    }
+
+    if (m_optionsWidget->hideOffscreenItems()) {
+        if (interface->state().offscreen) {
+            shouldShow = false;
+        }
+    }
+
+    if (m_optionsWidget->hidePaneItems()) {
+        if (interface->role() & QAccessible::Pane) {
+            shouldShow = false;
+        }
+    }
+
+    if (m_optionsWidget->hideNullObjectItems()) {
+        if (interface->object() == 0) {
+            shouldShow = false;
+        }
+    }
+
+    if (m_optionsWidget->hideNullRectItems()) {
+        if (interface->rect().isNull()) {
+            shouldShow = false;
+        }
+    }
+
+    item->setVisible(shouldShow);
+
+    if (interface->object() && interface->object() == m_selectedObject)
+        item->setBrush(QColor(Qt::yellow));
+    else
+        item->setBrush(QColor(Qt::white));
+
+    m_view->update();
+}
+
+QGraphicsRectItem * AccessibilitySceneManager::processInterface(QAccessibleInterface * interface, QGraphicsScene *scene)
+{
+    // Process this interface
+
+    QGraphicsRectItem * item = new QGraphicsRectItem();
+    scene->addItem(item);
+    if (!m_rootItem)
+        m_rootItem = item;
+
+    QString name = interface->text(QAccessible::Name);
+    QString description; // = interface->text(QAccessibleInterface::Description, child);
+    QString role = translateRole(interface->role());
+    int childCount = interface->childCount();
+
+    /* qDebug() << "name:" << name << "local pos" <<
+               interface->rect(0) << "description" << description << "childCount" << childCount;
+*/
+
+    updateItem(item, interface);
+
+    QGraphicsSimpleTextItem * textItem = new QGraphicsSimpleTextItem();
+    textItem->setParentItem(item);
+    textItem->setPos(QPoint(5, 5));
+
+    QString text;
+    text.append("Name: " + name + " ");
+    if (!description.isEmpty())
+        text.append("Description: " + description + " ");
+    text.append("Role: " + role + " ");
+    if (childCount > 0)
+        text.append("ChildCount: " + QString::number(childCount) + " ");
+    textItem->setText(text);
+
+    QFont font;
+    font.setPointSize(10);
+ //   font.setPointSize(14);
+    textItem->setFont(font);
+
+    return item;
+}
+
+void AccessibilitySceneManager::populateAccessibilityScene(QAccessibleInterface * interface, QGraphicsScene *scene)
+{
+    if (!interface)
+        return;
+
+    QGraphicsRectItem *item = processInterface(interface, scene);
+
+    QObject *object = interface->object();
+    if (object) {
+        m_graphicsItems.insert(object, item);
+    }
+
+    for (int i = 0; i < interface->childCount(); ++i) {
+        QAccessibleInterface *child = interface->child(i);
+        updateItems(child->object());
+        populateAccessibilityScene(child, scene);
+    }
+}
+
+AccessibilitySceneManager::TreeItem AccessibilitySceneManager::computeLevels(QAccessibleInterface * interface, int level)
+{
+    if (interface == 0)
+        return TreeItem();
+
+    TreeItem currentLevel;
+
+    int usedChildren = 0;
+    for (int i = 0; i < interface->childCount(); ++i) {
+        QAccessibleInterface *child = interface->child(i);
+        if (child != 0) {
+            ++usedChildren;
+            TreeItem childLevel = computeLevels(child, level + 1);
+            currentLevel.children.append(childLevel);
+            currentLevel.width += childLevel.width + m_treeItemHorizontalPadding;
+        }
+    }
+
+    // leaf node case
+    if (usedChildren == 0) {
+        currentLevel.width = m_treeItemWidth + m_treeItemHorizontalPadding;
+    }
+
+    // capture information:
+    currentLevel.name = interface->text(QAccessible::Name);
+    currentLevel.description += interface->text(QAccessible::DebugDescription);
+    currentLevel.role = translateRole(interface->role());
+    currentLevel.rect = interface->rect();
+    currentLevel.state = interface->state();
+    currentLevel.object = interface->object();
+
+    return currentLevel;
+}
+
+void AccessibilitySceneManager::populateAccessibilityTreeScene(QAccessibleInterface * interface)
+{
+    if (!interface)
+        return;
+
+    // set some layout metrics:
+    m_treeItemWidth = 90;
+    m_treeItemHorizontalPadding = 10;
+    m_treeItemHeight = 60;
+    m_treeItemVerticalPadding = 30;
+
+    // We want to draw the accessibility hiearchy as a vertical
+    // tree, growing from the root node at the top.
+
+    // First, figure out the number of levels and the width of each level:
+    m_rootTreeItem = computeLevels(interface, 0);
+
+    // create graphics items for each tree item
+    addGraphicsItems(m_rootTreeItem, 0, 0);
+}
+
+void AccessibilitySceneManager::addGraphicsItems(AccessibilitySceneManager::TreeItem item, int row, int xPos)
+{
+    //qDebug() << "add graphics item" << row << item.name << item.role << xPos << item.width << item.children.count();
+
+    int yPos = row * (m_treeItemHeight + m_treeItemVerticalPadding);
+
+    // Process this interface
+    QGraphicsRectItem * graphicsItem = new QGraphicsRectItem();
+    graphicsItem->setPos(xPos, yPos);
+    graphicsItem->setRect(0, 0, m_treeItemWidth, m_treeItemHeight);
+    graphicsItem->setFlag(QGraphicsItem::ItemClipsChildrenToShape);
+
+    if (item.object && item.object == m_selectedObject)
+        graphicsItem->setBrush(QColor(Qt::yellow));
+    else
+        graphicsItem->setBrush(QColor(Qt::white));
+
+    if (item.state.offscreen) {
+        QPen linePen;
+        linePen.setStyle(Qt::DashLine);
+        graphicsItem->setPen(linePen);
+    }
+
+    m_treeScene->addItem(graphicsItem);
+
+    QGraphicsTextItem * textItem = new QGraphicsTextItem();
+    textItem->setParentItem(graphicsItem);
+    textItem->setPos(QPoint(0, 0));
+
+    QFont font;
+    font.setPointSize(8);
+    textItem->setFont(font);
+
+    QString text;
+    text += item.name + "\n";
+    text += item.role + "\n";
+    text += item.description.split(QLatin1Char(' '), Qt::SkipEmptyParts).join("\n") + "\n";
+    text += "P:" + QString::number(item.rect.x()) + " " + QString::number(item.rect.y()) + " ";
+    text += "S:" + QString::number(item.rect.width()) + " " + QString::number(item.rect.height()) + "\n";
+
+    textItem->setPlainText(text);
+
+    // recurse to children
+    int childIndex = 0;
+    int childCount = item.children.count();
+    int segmentSize = item.width / qMax(1, childCount);
+    int segmentCenterOffset = segmentSize / 2;
+    int segmentsStart = xPos - (item.width / 2);
+    foreach (TreeItem child, item.children) {
+        // spread the children out, covering the width, centered on xPos
+        int segmentPosition = segmentsStart + (segmentSize * childIndex) + segmentCenterOffset;
+        addGraphicsItems(child, row + 1, segmentPosition);
+        ++childIndex;
+    }
+
+    // add lines from parents to kids
+    int boxBottom = yPos + m_treeItemHeight;
+    int boxMiddleX = xPos + m_treeItemWidth / 2;
+    int yBottomMiddle = boxBottom + m_treeItemVerticalPadding / 2;
+    int boxTop = yPos;
+    int yTopMiddle = boxTop - m_treeItemVerticalPadding / 2;
+
+    if (row > 0) {
+        QGraphicsLineItem *childVerticalStem = new QGraphicsLineItem();
+        childVerticalStem->setLine(boxMiddleX, yTopMiddle, boxMiddleX, boxTop);
+        m_treeScene->addItem(childVerticalStem);
+    }
+
+    if (childCount > 0) {
+        QGraphicsLineItem *parentVerticalStem = new QGraphicsLineItem();
+        parentVerticalStem->setLine(boxMiddleX, boxBottom, boxMiddleX, yBottomMiddle);
+        m_treeScene->addItem(parentVerticalStem);
+    }
+
+    if (childCount > 1) {
+        QGraphicsLineItem *horizontalStem = new QGraphicsLineItem();
+        // match the end points with the horizontal lines
+        int lineStartX = segmentsStart + segmentCenterOffset + m_treeItemWidth / 2;
+        int lineStopX = segmentsStart + segmentSize * (childCount -1) + segmentCenterOffset + m_treeItemWidth / 2;
+        horizontalStem->setLine(lineStartX, yBottomMiddle, lineStopX , yBottomMiddle);
+        m_treeScene->addItem(horizontalStem);
+    }
+}
+
+bool AccessibilitySceneManager::isHidden(QAccessibleInterface *interface)
+{
+    QAccessibleInterface *current = interface;
+    while (current) {
+
+        if (current->state().invisible) {
+            return true;
+        }
+
+        current = current->parent();
+    }
+
+    return false;
+}

util/accessibilityinspector/accessibilityscenemanager.h

@@ -0,0 +1,79 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#ifndef ACCESSIBILITYSCENEMANAGER_H
+#define ACCESSIBILITYSCENEMANAGER_H
+
+#include <QtGui>
+
+#include "optionswidget.h"
+
+QString translateRole(QAccessible::Role role);
+class AccessibilitySceneManager : public QObject
+{
+Q_OBJECT
+public:
+    AccessibilitySceneManager();
+    void setRootWindow(QWindow * window) { m_window = window; }
+    void setView(QGraphicsView *view) { m_view = view; }
+    void setScene(QGraphicsScene *scene) { m_scene = scene; }
+    void setTreeView(QGraphicsView *treeView) { m_treeView = treeView; }
+    void setTreeScene(QGraphicsScene *treeScene) { m_treeScene = treeScene; }
+
+    void setOptionsWidget(OptionsWidget *optionsWidget) { m_optionsWidget = optionsWidget; }
+public slots:
+    void populateAccessibilityScene();
+    void updateAccessibilitySceneItemFlags();
+    void populateAccessibilityTreeScene();
+    void handleUpdate(QAccessibleEvent *event);
+    void setSelected(QObject *object);
+
+    void changeScale(int scale);
+private:
+    void updateItems(QObject *root);
+    void updateItem(QObject *object);
+    void updateItem(QGraphicsRectItem *item, QAccessibleInterface *interface);
+    void updateItemFlags(QGraphicsRectItem *item, QAccessibleInterface *interface);
+
+    void populateAccessibilityScene(QAccessibleInterface * interface, QGraphicsScene *scene);
+    QGraphicsRectItem * processInterface(QAccessibleInterface * interface, QGraphicsScene *scene);
+
+    struct TreeItem;
+    TreeItem computeLevels(QAccessibleInterface * interface, int level);
+    void populateAccessibilityTreeScene(QAccessibleInterface * interface);
+    void addGraphicsItems(TreeItem item, int row, int xPos);
+
+    bool isHidden(QAccessibleInterface *interface);
+
+    QWindow *m_window;
+    QGraphicsView *m_view;
+    QGraphicsScene *m_scene;
+    QGraphicsView *m_treeView;
+    QGraphicsScene *m_treeScene;
+    QGraphicsItem *m_rootItem;
+    OptionsWidget *m_optionsWidget;
+    QObject *m_selectedObject;
+
+    QHash<QObject *, QGraphicsRectItem*> m_graphicsItems;
+    QSet<QObject *> m_animatedObjects;
+
+    struct TreeItem {
+        QList<TreeItem> children;
+        int width;
+        QString name;
+        QString role;
+        QString description;
+        QRect rect;
+        QAccessible::State state;
+        QObject *object;
+        TreeItem() : width(0) {}
+    };
+
+    TreeItem m_rootTreeItem;
+    int m_treeItemWidth;
+    int m_treeItemHorizontalPadding;
+    int m_treeItemHeight;
+    int m_treeItemVerticalPadding;
+};
+
+#endif // ACCESSIBILITYSCENEMANAGER_H

util/accessibilityinspector/main.cpp

@@ -0,0 +1,81 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include <QtGui>
+#include <QtDeclarative/QtDeclarative>
+#include <QtUiTools/QtUiTools>
+
+#include "accessibilityinspector.h"
+
+int main(int argc, char **argv)
+{
+    QApplication app(argc, argv);
+
+    if (app.arguments().count() < 2) {
+        qDebug() << "Usage: accessebilityInspector [ ui-file | qml-file ] [Option]";
+        qDebug() << "Option:";
+#ifdef QT_ACCESSIBILITY_INSPECTOR_SCENE_GRAPH
+        qDebug() << "-qtquick1: Use QDeclarativeView instead of QSGView for rendering QML files";
+#endif
+        return 0;
+    }
+
+    QString fileName = app.arguments().at(1);
+    QString mode;
+    if (app.arguments().count() > 2) {
+        mode = app.arguments().at(2);
+    }
+
+    QWidget *window;
+
+    if (fileName.endsWith(".ui")) {
+        QUiLoader loader;
+        QFile file(fileName);
+        file.open(QFile::ReadOnly);
+        window = loader.load(&file, 0);
+    } else if (fileName.endsWith(".qml")){
+        QUrl fileUrl;
+        if (fileName.startsWith(":")) { // detect resources.
+            QString name = fileName;
+            name.remove(0, 2); // reomve ":/"
+            fileUrl.setUrl(QLatin1String("qrc:/") + name);
+        } else {
+            fileUrl = QUrl::fromLocalFile(fileName);
+        }
+
+#ifdef QT_ACCESSIBILITY_INSPECTOR_SCENE_GRAPH
+        if (mode == QLatin1String("-qtquick1"))
+#endif
+        {
+            QDeclarativeView * declarativeView = new QDeclarativeView();
+            declarativeView->setSource(fileUrl);
+            window = declarativeView;
+        }
+#ifdef QT_ACCESSIBILITY_INSPECTOR_SCENE_GRAPH
+        else {
+            QSGView * sceneGraphView = new QSGView();
+            sceneGraphView->setSource(fileUrl);
+            window = sceneGraphView;
+        }
+#endif
+    } else {
+        qDebug() << "Error: don't know what to do with" << fileName;
+    }
+
+    AccessibilityInspector *accessibilityInspector = new AccessibilityInspector();
+
+    accessibilityInspector->inspectWindow(window);
+
+    window->move(50, 50);
+    window->show();
+
+    int ret = app.exec();
+
+    accessibilityInspector->saveWindowGeometry();
+    delete accessibilityInspector;
+
+    return ret;
+
+
+}
+

util/accessibilityinspector/optionswidget.cpp

@@ -0,0 +1,5 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include "optionswidget.h"
+

util/accessibilityinspector/optionswidget.h

@@ -0,0 +1,95 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#ifndef OPTIONSWIDGET_H
+#define OPTIONSWIDGET_H
+
+#include <QtGui>
+#include <QtWidgets>
+
+class OptionsWidget : public QWidget
+{
+Q_OBJECT
+public:
+    OptionsWidget()
+        :QWidget()
+    {
+        QVBoxLayout *m_layout = new QVBoxLayout;
+
+        m_refresh = new QPushButton(this);
+        m_refresh->setText(QLatin1String("Refresh"));
+        m_layout->addWidget(m_refresh);
+        connect(m_refresh, SIGNAL(clicked()), SIGNAL(refreshClicked()));
+
+        m_hideInvisibleItems = new QCheckBox(this);
+        m_layout->addWidget(m_hideInvisibleItems);
+        m_hideInvisibleItems->setText("Hide Invisible Items");
+        m_hideInvisibleItems->setChecked(true);
+        connect(m_hideInvisibleItems, SIGNAL(toggled(bool)), SIGNAL(optionsChanged()));
+
+        m_hideOffscreenItems = new QCheckBox(this);
+        m_layout->addWidget(m_hideOffscreenItems);
+        m_hideOffscreenItems->setText("Hide Offscreen Items");
+        m_hideOffscreenItems->setChecked(true);
+        connect(m_hideOffscreenItems, SIGNAL(toggled(bool)), SIGNAL(optionsChanged()));
+
+        m_hidePaneItems = new QCheckBox(this);
+        m_layout->addWidget(m_hidePaneItems);
+        m_hidePaneItems->setText("Hide Items with the Pane role");
+        m_hidePaneItems->setChecked(true);
+        connect(m_hidePaneItems, SIGNAL(toggled(bool)), SIGNAL(optionsChanged()));
+
+        m_hideNullObjectItems = new QCheckBox(this);
+        m_layout->addWidget(m_hideNullObjectItems);
+        m_hideNullObjectItems->setText("Hide Items with a null QObject pointer");
+        m_hideNullObjectItems->setChecked(true);
+        connect(m_hideNullObjectItems, SIGNAL(toggled(bool)), SIGNAL(optionsChanged()));
+
+        m_hideNullRectItems = new QCheckBox(this);
+        m_layout->addWidget(m_hideNullRectItems);
+        m_hideNullRectItems->setText("Hide Items with a null rect");
+        m_hideNullRectItems->setChecked(true);
+        connect(m_hideNullRectItems, SIGNAL(toggled(bool)), SIGNAL(optionsChanged()));
+
+        m_enableTextToSpeach = new QCheckBox(this);
+        m_layout->addWidget(m_enableTextToSpeach);
+        m_enableTextToSpeach->setText("Enable Text To Speech");
+        m_enableTextToSpeach->setChecked(false);
+        connect(m_enableTextToSpeach, SIGNAL(toggled(bool)), SIGNAL(optionsChanged()));
+
+
+        m_scale = new QSlider(Qt::Horizontal);
+//        m_layout->addWidget(m_scale);
+        m_scale->setRange(5, 30);
+        m_scale->setValue(1);
+        connect(m_scale, SIGNAL(valueChanged(int)), SIGNAL(scaleChanged(int)));
+
+        this->setLayout(m_layout);
+    }
+
+    bool hideInvisibleItems() { return m_hideInvisibleItems->isChecked(); }
+    bool hideOffscreenItems() { return m_hideOffscreenItems->isChecked(); }
+    bool hidePaneItems() { return m_hidePaneItems->isChecked(); }
+    bool hideNullObjectItems() { return m_hideNullObjectItems->isChecked(); }
+    bool hideNullRectItems() { return m_hideNullRectItems->isChecked(); }
+    bool enableTextToSpeach() { return m_enableTextToSpeach->isChecked(); }
+signals:
+    void optionsChanged();
+    void refreshClicked();
+    void scaleChanged(int);
+
+private:
+    QVBoxLayout *m_layout;
+
+    QPushButton *m_refresh;
+    QCheckBox *m_hideInvisibleItems;
+    QCheckBox *m_hideOffscreenItems;
+    QCheckBox *m_hidePaneItems;
+    QCheckBox *m_hideNullObjectItems;
+    QCheckBox *m_hideNullRectItems;
+    QCheckBox *m_enableTextToSpeach;
+    QSlider *m_scale;
+};
+
+
+#endif // OPTIONSWIDGET_H

util/accessibilityinspector/screenreader.cpp

@@ -0,0 +1,99 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include "screenreader.h"
+#include "optionswidget.h"
+#include "accessibilityscenemanager.h"
+#include <QtGui>
+
+ScreenReader::ScreenReader(QObject *parent) :
+    QObject(parent)
+{
+    m_selectedInterface = 0;
+    m_rootInterface = 0;
+    bool activateCalled = false;
+}
+
+ScreenReader::~ScreenReader()
+{
+}
+
+void ScreenReader::setRootObject(QObject *rootObject)
+{
+    m_rootInterface = QAccessible::queryAccessibleInterface(rootObject);
+}
+
+void ScreenReader::setOptionsWidget(OptionsWidget *optionsWidget)
+{
+    m_optionsWidget = optionsWidget;
+}
+
+void ScreenReader::touchPoint(const QPoint &point)
+{
+    qDebug() << "touch" << point;
+    // Wait and see if this touch is the start of a double-tap
+    // (activate will then be called and cancel the touch processing)
+    m_activateCalled = false;
+    m_currentTouchPoint = point;
+    QTimer::singleShot(200, this, SLOT(processTouchPoint()));
+}
+
+void ScreenReader::processTouchPoint()
+{
+    if (m_activateCalled) {
+        return;
+    }
+
+    if (m_rootInterface == 0) {
+        return;
+    }
+
+    QAccessibleInterface * currentInterface = m_rootInterface;
+
+    int hit = -2;
+    int guardCounter = 0;
+    const int guardMax = 40;
+    while (currentInterface != 0) {
+        ++guardCounter;
+        if (guardCounter > guardMax) {
+            qDebug() << "touchPoint exit recursion overflow";
+            return; // outside
+        }
+
+        QAccessibleInterface * hit = currentInterface->childAt(m_currentTouchPoint.x(), m_currentTouchPoint.y());
+        if (!hit)
+            break;
+        currentInterface = hit;
+    }
+
+    m_selectedInterface = currentInterface;
+    if (m_selectedInterface->object())
+        emit selected(m_selectedInterface->object());
+    if (m_optionsWidget->enableTextToSpeach())
+        speak(m_selectedInterface->text(QAccessible::Name)
+              /*+ "," + translateRole(m_selectedInterface->role(0)) */);
+
+//    qDebug() << "touchPoint exit found" << m_selectedInterface->text(QAccessible::Name, 0) << m_selectedInterface->object() << m_selectedInterface->rect(0);
+}
+
+void ScreenReader::activate()
+{
+    qDebug() << "ScreenReader::activate";
+    m_activateCalled = true;
+    if (m_selectedInterface) {
+        m_selectedInterface->actionInterface()->doAction(QAccessibleActionInterface::pressAction());
+    }
+}
+
+void ScreenReader::speak(const QString &text, const QString &/*voice*/)
+{
+    QFile f("festivalspeachhack");
+    f.open(QIODevice::WriteOnly);
+    f.write(text.toLocal8Bit());
+    f.close();
+
+    QProcess *process = new QProcess;
+    process->start("/usr/bin/festival", QStringList() << "--tts" << "festivalspeachhack");
+}
+
+

util/accessibilityinspector/screenreader.h

@@ -0,0 +1,46 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+
+#ifndef SCREENREADER_H
+#define SCREENREADER_H
+
+#include <QObject>
+#include <QAccessible>
+#include <QAccessibleBridge>
+
+/*
+    A Simple screen reader for touch-based user interfaces.
+
+    Requires a text-to-speach backend. Currently implemented
+    using festival on unix.
+*/
+class OptionsWidget;
+class ScreenReader : public QObject
+{
+    Q_OBJECT
+public:
+    explicit ScreenReader(QObject *parent = nullptr);
+    ~ScreenReader();
+
+    void setRootObject(QObject *rootObject);
+    void setOptionsWidget(OptionsWidget *optionsWidget);
+public slots:
+    void touchPoint(const QPoint &point);
+    void activate();
+protected slots:
+    void processTouchPoint();
+signals:
+    void selected(QObject *object);
+
+protected:
+    void speak(const QString &text, const QString &voice = QString());
+private:
+    QAccessibleInterface *m_selectedInterface;
+    QAccessibleInterface *m_rootInterface;
+    OptionsWidget *m_optionsWidget;
+    QPoint m_currentTouchPoint;
+    bool m_activateCalled;
+};
+
+#endif // SCREENREADER_H