qt-everywhere-src-5.14.1/qtbase/util/accessibilityinspector/accessibilityscenemanager.cpp - orbit - Git at Google

 /****************************************************************************
 **
 ** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the tools applications of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:GPL-EXCEPT$
 ** Commercial License Usage
 ** Licensees holding valid commercial Qt licenses may use this file in
 ** accordance with the commercial license agreement provided with the
 ** Software or, alternatively, in accordance with the terms contained in
 ** a written agreement between you and The Qt Company. For licensing terms
 ** and conditions see https://www.qt.io/terms-conditions. For further
 ** information use the contact form at https://www.qt.io/contact-us.
 **
 ** GNU General Public License Usage
 ** Alternatively, this file may be used under the terms of the GNU
 ** General Public License version 3 as published by the Free Software
 ** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
 ** included in the packaging of this file. Please review the following
 ** information to ensure the GNU General Public License requirements will
 ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
 **
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/

 #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(" ", QString::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;
 }
	/****************************************************************************
	**
	** Copyright (C) 2016 The Qt Company Ltd.
	** Contact: https://www.qt.io/licensing/
	**
	** This file is part of the tools applications of the Qt Toolkit.
	**
	** $QT_BEGIN_LICENSE:GPL-EXCEPT$
	** Commercial License Usage
	** Licensees holding valid commercial Qt licenses may use this file in
	** accordance with the commercial license agreement provided with the
	** Software or, alternatively, in accordance with the terms contained in
	** a written agreement between you and The Qt Company. For licensing terms
	** and conditions see https://www.qt.io/terms-conditions. For further
	** information use the contact form at https://www.qt.io/contact-us.
	**
	** GNU General Public License Usage
	** Alternatively, this file may be used under the terms of the GNU
	** General Public License version 3 as published by the Free Software
	** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
	** included in the packaging of this file. Please review the following
	** information to ensure the GNU General Public License requirements will
	** be met: https://www.gnu.org/licenses/gpl-3.0.html.
	**
	** $QT_END_LICENSE$
	**
	****************************************************************************/

	#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(" ", QString::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;
	}