Merge lp:~veebers/autopilot-qt/enable-datamodel-elements into lp:autopilot-qt

[Christopher Lee]

Remove QtNode and use DBusNode interface to extend the possible supported node types to include those that don't inherit from QObject.

Remove QtNode and replace with DBusNode Interface to extend the possible node types to those that don't inherit from QObject.

What was QtNode is now QObjectNode. We now also have QModelIndexNode, QTableWidgetItemNode and QTreeWidgetItemNode with room for more.

[Thomi Richards (thomir-deactivatedaccount)]

Generally looks good, but the diff is too large to really review properly - a few fixes needed.

review: Needs Fixing

=== modified file 'driver/dbus_object.cpp'
--- driver/dbus_object.cpp	2014-03-12 13:26:27 +0000
+++ driver/dbus_object.cpp	2014-06-20 04:04:19 +0000
@@ -23,15 +23,15 @@
 #include <QDBusConnection>
 #include <QThread>
 
-QtNode::Ptr GetNodeWithId(int object_id)
+DBusNode::Ptr GetNodeWithId(int object_id)
 {
     QString query = QString("//*[id=%1]").arg(object_id);
-    QList<QtNode::Ptr> objects = GetNodesThatMatchQuery(query);
+    QList<DBusNode::Ptr> objects = GetNodesThatMatchQuery(query);
 
     if (objects.isEmpty())
     {
         qWarning() << "No Object with with id" << object_id << "found in object tree.";
-        return QtNode::Ptr();
+        return DBusNode::Ptr();
     }
 
     return objects.at(0);
@@ -64,7 +64,8 @@
         return;
     }
 
-    QtNode::Ptr node = GetNodeWithId(object_id);
+    std::shared_ptr<const QObjectNode> node = std::dynamic_pointer_cast<const QObjectNode>(GetNodeWithId(object_id));
+
     if (! node)
     {
         qWarning() << "Unable to register signal interest.";
@@ -125,7 +126,7 @@
 
 void DBusObject::ListSignals(int object_id, const QDBusMessage& message)
 {
-    QtNode::Ptr node = GetNodeWithId(object_id);
+    std::shared_ptr<const QObjectNode> node = std::dynamic_pointer_cast<const QObjectNode>(GetNodeWithId(object_id));
     QDBusMessage reply = message.createReply();
     if (! node)
     {
@@ -163,7 +164,7 @@
 void DBusObject::ListMethods(int object_id, const QDBusMessage &message)
 {
     QDBusMessage reply = message.createReply();
-    QtNode::Ptr node = GetNodeWithId(object_id);
+    std::shared_ptr<const QObjectNode> node = std::dynamic_pointer_cast<const QObjectNode>(GetNodeWithId(object_id));
     if (! node)
     {
         qWarning() << "No Object found while listing methods.";
@@ -201,7 +202,7 @@
 {
     Q_UNUSED(message);
 
-    QtNode::Ptr node = GetNodeWithId(object_id);
+    std::shared_ptr<const QObjectNode> node = std::dynamic_pointer_cast<const QObjectNode>(GetNodeWithId(object_id));
     if (! node)
     {
         qWarning() << "No Object found.";
@@ -303,4 +304,3 @@
 
     QDBusConnection::sessionBus().send(msg);
 }
-

=== modified file 'driver/introspection.cpp'
--- driver/introspection.cpp	2014-03-12 13:26:27 +0000
+++ driver/introspection.cpp	2014-06-20 04:04:19 +0000
@@ -51,8 +51,8 @@
 QList<NodeIntrospectionData> Introspect(QString const& query_string)
 {
     QList<NodeIntrospectionData> state;
-    QList<QtNode::Ptr> node_list = GetNodesThatMatchQuery(query_string);
-    foreach (QtNode::Ptr obj, node_list)
+    QList<DBusNode::Ptr> node_list = GetNodesThatMatchQuery(query_string);
+    foreach (DBusNode::Ptr obj, node_list)
     {
         state.append(obj->GetIntrospectionData());
     }
@@ -62,7 +62,7 @@
 }
 
 
-QList<QtNode::Ptr> GetNodesThatMatchQuery(QString const& query_string)
+QList<DBusNode::Ptr> GetNodesThatMatchQuery(QString const& query_string)
 {
 #ifdef QT5_SUPPORT
     std::shared_ptr<RootNode> root = std::make_shared<RootNode>(QApplication::instance());
@@ -84,13 +84,13 @@
         root->AddChild((QObject*) widget);
     }
 #endif
-    QList<QtNode::Ptr> node_list;
+    QList<DBusNode::Ptr> node_list;
 
     xpathselect::NodeVector list = xpathselect::SelectNodes(root, query_string.toStdString());
     for (auto node : list)
     {
         // node may be our root node wrapper *or* an ordinary qobject wrapper
-        auto object_ptr = std::static_pointer_cast<const QtNode>(node);
+        auto object_ptr = std::static_pointer_cast<const DBusNode>(node);
         if (object_ptr)
         {
             node_list.append(object_ptr);

=== modified file 'driver/introspection.h'
--- driver/introspection.h	2014-03-12 13:26:27 +0000
+++ driver/introspection.h	2014-06-20 04:04:19 +0000
@@ -16,8 +16,8 @@
 /// Introspect 'obj' and return it's properties in a QVariantMap.
 QList<NodeIntrospectionData> Introspect(const QString& query_string);
 
-/// Get a list of QtNode pointers that match the given query.
-QList<QtNode::Ptr> GetNodesThatMatchQuery(QString const& query_string);
+/// Get a list of DBusNode pointers that match the given query.
+QList<DBusNode::Ptr> GetNodesThatMatchQuery(QString const& query_string);
 
 /// Return true if 't' is a type that we can marshall over DBus
 QVariant PackProperty(QVariant const& prop);

=== modified file 'driver/qtnode.cpp'
--- driver/qtnode.cpp	2014-03-12 13:26:27 +0000
+++ driver/qtnode.cpp	2014-06-20 04:04:19 +0000
@@ -17,6 +17,25 @@
 #endif
 #include <QDBusArgument>
 
+#include <QAbstractItemView>
+#include <QAbstractProxyModel>
+#include <QTableWidget>
+#include <QTreeView>
+#include <QTreeWidget>
+#include <QListView>
+
+const QByteArray AP_ID_NAME("_autopilot_id");
+
+void GetTableWidgetChildren(QObject* table_obj, xpathselect::NodeVector& children, DBusNode::Ptr parent);
+void GetTreeViewChildren(QObject* tree_obj, xpathselect::NodeVector& children, DBusNode::Ptr parent);
+void GetTreeWidgetChildren(QObject* tree_obj, xpathselect::NodeVector& children, DBusNode::Ptr parent);
+void GetListViewChildren(QObject* tree_obj, xpathselect::NodeVector& children, DBusNode::Ptr parent);
+
+void CollectAllIndexes(QModelIndex index, QAbstractItemModel *model, QModelIndexList &collection);
+QVariant SafePackProperty(QVariant const& prop);
+
+bool MatchProperty(const QVariantMap& packed_properties, const QString& name, QVariant& value);
+
 // Marshall the NodeIntrospectionData data into a D-Bus argument
  QDBusArgument &operator<<(QDBusArgument &argument, const NodeIntrospectionData &node_data)
  {
@@ -35,9 +54,169 @@
      return argument;
  }
 
-const QByteArray AP_ID_NAME("_autopilot_id");
-
-QtNode::QtNode(QObject *obj, QtNode::Ptr parent)
+void GetTableWidgetChildren(QObject *table_obj, xpathselect::NodeVector& children, DBusNode::Ptr parent)
+{
+    QTableWidget* table = qobject_cast<QTableWidget *>(table_obj);
+    if(! table) {
+        qDebug() << "Unable to cast object to QTableWidget (even though it apparently inherits from it)";
+    }
+
+    QList<QTableWidgetItem *> tablewidgetitems = table->findItems("*", Qt::MatchWildcard|Qt::MatchRecursive);
+    foreach (QTableWidgetItem *item, tablewidgetitems){
+        // std::make_shared<QTableWidgetItemNode>(item, this->shared_from_this())
+        children.push_back(
+            std::make_shared<QTableWidgetItemNode>(item, parent)
+            );
+    }
+}
+
+void CollectAllIndexes(QModelIndex index, QAbstractItemModel *model, QModelIndexList &collection)
+{
+    // Is there a decent way for me to determine infinite recursion.
+    // The interviews example breaks this code as it just continues creating new children.
+    for(int c=0; c < model->columnCount(index); ++c) {
+        for(int r=0; r < model->rowCount(index); ++r) {
+            QModelIndex new_index = model->index(r, c, index);
+            collection.push_back(new_index);
+            // actually the hashing should never be the same
+            if(qHash(new_index) != qHash(index)) {
+                CollectAllIndexes(new_index, model, collection);
+            }
+        }
+    }
+}
+
+// Pack property, but return a default blank if the packed property is invalid.
+QVariant SafePackProperty(QVariant const& prop)
+{
+    static QVariant blank_default = PackProperty("");
+
+    QVariant property_attempt = PackProperty(prop);
+    if(property_attempt.isValid())
+        return property_attempt;
+    else
+        return blank_default;
+}
+
+bool MatchProperty(const QVariantMap& packed_properties, const QString& name, QVariant& value)
+{
+    if (! packed_properties.contains(name))
+        return false;
+
+    // Because the properties are packed, we need the value, not the type.
+    QVariant object_value = qvariant_cast<QVariantList>(packed_properties[name]).at(1);
+    if (value.canConvert(object_value.type()))
+    {
+        value.convert(object_value.type());
+        return value == object_value;
+    }
+    return false;
+}
+
+
+void GetTreeViewChildren(QObject* tree_obj, xpathselect::NodeVector& children, DBusNode::Ptr parent)
+{
+    QTreeView* tree_view = qobject_cast<QTreeView *>(tree_obj);
+    if(! tree_view) {
+        qDebug() << "Unable to cast object to QTreeView (even though it apparently inherits from it)";
+        return;
+    }
+
+    QAbstractItemModel* abstract_model = tree_view->model();
+    if(! abstract_model)
+    {
+        qDebug() << "Unable to retrieve model for QTreeView";
+        return;
+    }
+
+    QModelIndexList all_of_them;
+    for(int c=0; c < abstract_model->columnCount(); ++c) {
+        for(int r=0; r < abstract_model->rowCount(); ++r) {
+            QModelIndex index = abstract_model->index(r, c);
+            all_of_them.push_back(index);
+            CollectAllIndexes(index, abstract_model, all_of_them);
+        }
+    }
+
+    foreach(QModelIndex index, all_of_them)
+    {
+        if(index.isValid())
+        {
+            children.push_back(
+                std::make_shared<QModelIndexNode>(
+                    index,
+                    tree_view,
+                    parent)
+                );
+        }
+    }
+}
+
+void GetTreeWidgetChildren(QObject* tree_obj, xpathselect::NodeVector& children, DBusNode::Ptr parent)
+{
+    QTreeWidget* tree_widget = qobject_cast<QTreeWidget *>(tree_obj);
+    if(! tree_widget) {
+        qDebug() << "Unable to cast object to QTreeWidget (even though it apparently inherits from it)";
+        return;
+    }
+
+    // Lets grab all the top-level elements, they can get their own childnren.
+    for(int i=0; i < tree_widget->topLevelItemCount(); ++i) {
+        children.push_back(
+            std::make_shared<QTreeWidgetItemNode>(
+                tree_widget->topLevelItem(i),
+                parent)
+            );
+    }
+}
+
+// This coul probably be wrapped up into an AbstractItemView as could
+// the above TreeView stuff
+void GetListViewChildren(QObject* list_obj, xpathselect::NodeVector& children, DBusNode::Ptr parent)
+{
+    QListView* list_view = qobject_cast<QListView *>(list_obj);
+    if(! list_view) {
+        qDebug() << "Unable to cast object to QTreeView (even though it apparently inherits from it)";
+        return;
+    }
+
+    QAbstractItemModel* abstract_model = list_view->model();
+
+    if(! abstract_model) {
+        qDebug() << "Unable to retrieve model for QTreeView";
+        return;
+    }
+
+    QModelIndexList all_of_them;
+    QModelIndex root_index = list_view->rootIndex();
+    if(root_index.isValid()) {
+        // The root item is the parent item to the view's toplevel items
+        CollectAllIndexes(root_index, abstract_model, all_of_them);
+    }
+    else {
+        for(int c=0; c < abstract_model->columnCount(); ++c) {
+            for(int r=0; r < abstract_model->rowCount(); ++r) {
+                QModelIndex index = abstract_model->index(r, c);
+                all_of_them.push_back(index);
+                CollectAllIndexes(index, abstract_model, all_of_them);
+            }
+        }
+    }
+
+    foreach(QModelIndex index, all_of_them) {
+        if(index.isValid())
+        {
+            children.push_back(
+                std::make_shared<QModelIndexNode>(
+                    index,
+                    list_view,
+                    parent)
+                );
+        }
+    }
+}
+
+QObjectNode::QObjectNode(QObject *obj, DBusNode::Ptr parent)
 : object_(obj)
 , parent_(parent)
 {
@@ -45,18 +224,18 @@
     full_path_ = parent_path + "/" + GetName();
 }
 
-QtNode::QtNode(QObject* obj)
+QObjectNode::QObjectNode(QObject* obj)
 : object_(obj)
 {
     full_path_ = "/" + GetName();
 }
 
-QObject* QtNode::getWrappedObject() const
+QObject* QObjectNode::getWrappedObject() const
 {
     return object_;
 }
 
-NodeIntrospectionData QtNode::GetIntrospectionData() const
+NodeIntrospectionData QObjectNode::GetIntrospectionData() const
 {
     NodeIntrospectionData data;
     data.object_path = QString::fromStdString(GetPath());
@@ -65,7 +244,7 @@
     return data;
 }
 
-std::string QtNode::GetName() const
+std::string QObjectNode::GetName() const
 {
     QString name = object_->metaObject()->className();
 
@@ -76,12 +255,12 @@
     return name.toStdString();
 }
 
-std::string QtNode::GetPath() const
+std::string QObjectNode::GetPath() const
 {
     return full_path_;
 }
 
-int32_t QtNode::GetId() const
+int32_t QObjectNode::GetId() const
 {
     // Note: This method is used to assign ids to both the root node (with a QApplication object) and
     // child nodes. This used to be separate code, but now that we export QApplication properties,
@@ -97,26 +276,16 @@
     return qvariant_cast<int32_t>(object_->property(AP_ID_NAME));
 }
 
-bool QtNode::MatchStringProperty(const std::string& name, const std::string& value) const
+bool QObjectNode::MatchStringProperty(const std::string& name, const std::string& value) const
 {
     QVariantMap properties = GetNodeProperties(object_);
 
     QString qname = QString::fromStdString(name);
-    if (! properties.contains(qname))
-        return false;
-
-    QVariant object_value = qvariant_cast<QVariantList>(properties[qname]).at(1);
-    QVariant check_value(QString::fromStdString(value));
-    if (check_value.canConvert(object_value.type()))
-    {
-        check_value.convert(object_value.type());
-        return check_value == object_value;
-    }
-
-    return false;
+    QVariant qvalue = QVariant(QString::fromStdString(value));
+    return MatchProperty(properties, qname, qvalue);
 }
 
-bool QtNode::MatchIntegerProperty(const std::string& name, int32_t value) const
+bool QObjectNode::MatchIntegerProperty(const std::string& name, int32_t value) const
 {
     if (name == "id")
         return value == GetId();
@@ -124,44 +293,42 @@
     QVariantMap properties = GetNodeProperties(object_);
 
     QString qname = QString::fromStdString(name);
-    if (! properties.contains(qname))
-        return false;
-
-    QVariant object_value = qvariant_cast<QVariantList>(properties[qname]).at(1);
-    QVariant check_value(value);
-    if (check_value.canConvert(object_value.type()))
-    {
-        check_value.convert(object_value.type());
-        return check_value == object_value;
-    }
-
-    return false;
+    QVariant qvalue = QVariant(value);
+    return MatchProperty(properties, qname, qvalue);
 }
 
-bool QtNode::MatchBooleanProperty(const std::string& name, bool value) const
+bool QObjectNode::MatchBooleanProperty(const std::string& name, bool value) const
 {
     QVariantMap properties = GetNodeProperties(object_);
 
     QString qname = QString::fromStdString(name);
-    if (! properties.contains(qname))
-        return false;
-
-    QVariant object_value = qvariant_cast<QVariantList>(properties[qname]).at(1);
-    QVariant check_value(value);
-
-    if (check_value.canConvert(object_value.type()))
-    {
-        check_value.convert(object_value.type());
-        return check_value == object_value;
-    }
-
-    return false;
+    QVariant qvalue = QVariant(value);
+    return MatchProperty(properties, qname, qvalue);
 }
 
-xpathselect::NodeVector QtNode::Children() const
+xpathselect::NodeVector QObjectNode::Children() const
 {
     xpathselect::NodeVector children;
 
+    // Do special children handling if needed.
+    // Because QTreeWidget inherits from QTreeView check for it first.
+    if(object_->inherits("QTableWidget"))
+    {
+        GetTableWidgetChildren(object_, children, shared_from_this());
+    }
+    else if(object_->inherits("QTreeWidget"))
+    {
+        GetTreeWidgetChildren(object_, children, shared_from_this());
+    }
+    else if(object_->inherits("QTreeView"))
+    {
+        GetTreeViewChildren(object_, children, shared_from_this());
+    }
+    else if(object_->inherits("QListView"))
+    {
+        GetListViewChildren(object_, children, shared_from_this());
+    }
+
 #ifdef QT5_SUPPORT
     // Qt5's hierarchy for QML has changed a bit:
     // - On top there's a QQuickView which holds all the QQuick items
@@ -170,21 +337,21 @@
 
     QQuickView *view = qobject_cast<QQuickView*>(object_);
     if (view && view->rootObject() != 0) {
-        children.push_back(std::make_shared<QtNode>(view->rootObject(), shared_from_this()));
+        children.push_back(std::make_shared<QObjectNode>(view->rootObject(), shared_from_this()));
     }
 
     QQuickItem* item = qobject_cast<QQuickItem*>(object_);
     if (item) {
         foreach (QQuickItem *childItem, item->childItems()) {
             if (childItem->parentItem() == item) {
-                children.push_back(std::make_shared<QtNode>(childItem, shared_from_this()));
+                children.push_back(std::make_shared<QObjectNode>(childItem, shared_from_this()));
             }
         }
     } else {
         foreach (QObject *child, object_->children())
         {
             if (child->parent() == object_)
-                children.push_back(std::make_shared<QtNode>(child, shared_from_this()));
+                children.push_back(std::make_shared<QObjectNode>(child, shared_from_this()));
         }
     }
 
@@ -192,7 +359,7 @@
     foreach (QObject *child, object_->children())
     {
         if (child->parent() == object_)
-            children.push_back(std::make_shared<QtNode>(child, shared_from_this()));
+            children.push_back(std::make_shared<QObjectNode>(child, shared_from_this()));
     }
 
     // If our wrapped object is a QGraphicsScene, we need to explicitly grab any child graphics
@@ -206,7 +373,7 @@
         {
             QGraphicsObject *obj = item->toGraphicsObject();
             if (obj && ! obj->parent())
-                children.push_back(std::make_shared<QtNode>(obj, shared_from_this()));
+                children.push_back(std::make_shared<QObjectNode>(obj, shared_from_this()));
         }
     }
 #endif
@@ -215,7 +382,333 @@
 }
 
 
-xpathselect::Node::Ptr QtNode::GetParent() const
-{
-    return parent_;
+xpathselect::Node::Ptr QObjectNode::GetParent() const
+{
+    return parent_;
+}
+
+// QModelIndexNode
+QModelIndexNode::QModelIndexNode(QModelIndex index, QAbstractItemView* parent_view, DBusNode::Ptr parent)
+    : index_(index)
+    , parent_view_(parent_view)
+    , parent_(parent)
+{
+    std::string parent_path = parent ? parent->GetPath() : "";
+    full_path_ = parent_path + "/" + GetName();
+}
+
+QModelIndexNode::QModelIndexNode(QModelIndex index, QAbstractItemView* parent_view)
+    : index_(index)
+    , parent_view_(parent_view)
+{
+    full_path_ = "/" + GetName();
+}
+
+NodeIntrospectionData QModelIndexNode::GetIntrospectionData() const
+{
+    NodeIntrospectionData data;
+    data.object_path = QString::fromStdString(GetPath());
+    data.state = GetProperties();
+    data.state["id"] = PackProperty(GetId());
+    return data;
+}
+
+QVariantMap QModelIndexNode::GetProperties() const
+{
+    QVariantMap properties;
+    const QAbstractItemModel* model = index_.model();
+    if(model)
+    {
+        // Make an attempt to store the 'text' of a node to be user friendly-ish.
+        QVariant text_property = PackProperty(model->data(index_));
+        if(text_property.isValid())
+            properties["text"] = text_property;
+        else
+            properties["text"] = PackProperty("");
+
+        // Include any Role data (mung the role name with added "Role")
+        const QHash<int, QByteArray> role_names = model->roleNames();
+        QMap<int, QVariant> item_data = model->itemData(index_);
+        foreach(int name, role_names.keys())
+        {
+            if(item_data.contains(name)) {
+                QVariant property = PackProperty(item_data[name]);
+                if(property.isValid())
+                    properties[role_names[name]+"Role"] = property;
+            }
+            else {
+                // Not sure if this should be set as blank or left.
+                properties[role_names[name]+"Role"] = PackProperty("");
+            }
+        }
+    }
+
+    QRect rect = parent_view_->visualRect(index_);
+    QRect global_rect(
+        parent_view_->viewport()->mapToGlobal(rect.topLeft()),
+        rect.size());
+    QRect viewport_contents = parent_view_->viewport()->contentsRect();
+    properties["onScreen"] = PackProperty(viewport_contents.contains(rect));
+    properties["globalRect"] = PackProperty(global_rect);
+
+    return properties;
+}
+
+xpathselect::Node::Ptr QModelIndexNode::GetParent() const
+{
+    return parent_;
+}
+
+std::string QModelIndexNode::GetName() const
+{
+    return "QModelIndex";
+}
+
+std::string QModelIndexNode::GetPath() const
+{
+    return full_path_;
+}
+
+int32_t QModelIndexNode::GetId() const
+{
+    // ahha, the rub. Need to use a hash here, but we might lose precision?
+    return qHash(index_);
+}
+
+bool QModelIndexNode::MatchStringProperty(const std::string& name, const std::string& value) const
+{
+    QVariantMap properties = GetProperties();
+    QString qname = QString::fromStdString(name);
+    QVariant qvalue = QVariant(QString::fromStdString(value));
+    return MatchProperty(properties, qname, qvalue);
+}
+
+bool QModelIndexNode::MatchIntegerProperty(const std::string& name, int32_t value) const
+{
+    if (name == "id")
+        return value == GetId();
+
+    QVariantMap properties = GetProperties();
+    QString qname = QString::fromStdString(name);
+    QVariant qvalue = QVariant(value);
+    return MatchProperty(properties, qname, qvalue);
+}
+
+bool QModelIndexNode::MatchBooleanProperty(const std::string& name, bool value) const
+{
+    QVariantMap properties = GetProperties();
+    QString qname = QString::fromStdString(name);
+    QVariant qvalue = QVariant(value);
+    return MatchProperty(properties, qname, qvalue);
+}
+
+xpathselect::NodeVector QModelIndexNode::Children() const
+{
+    // Doesn't have any children.
+    xpathselect::NodeVector children;
+    return children;
+}
+
+// QTableWidgetItemNode
+QTableWidgetItemNode::QTableWidgetItemNode(QTableWidgetItem *item, DBusNode::Ptr parent)
+    : item_(item)
+    , parent_(parent)
+{
+    std::string parent_path = parent ? parent->GetPath() : "";
+    full_path_ = parent_path + "/" + GetName();
+}
+
+QTableWidgetItemNode::QTableWidgetItemNode(QTableWidgetItem *item)
+    : item_(item)
+{
+    full_path_ = "/" + GetName();
+}
+
+NodeIntrospectionData QTableWidgetItemNode::GetIntrospectionData() const
+{
+    NodeIntrospectionData data;
+    data.object_path = QString::fromStdString(GetPath());
+    data.state = GetProperties();
+    data.state["id"] = PackProperty(GetId());
+    return data;
+}
+
+QVariantMap QTableWidgetItemNode::GetProperties() const
+{
+    QVariantMap properties;
+
+    QTableWidget* parent = item_->tableWidget();
+    QRect cellrect = parent->visualItemRect(item_);
+    QRect r = QRect(parent->mapToGlobal(cellrect.topLeft()), cellrect.size());
+    properties["globalRect"] = PackProperty(r);
+
+    properties["text"] = SafePackProperty(PackProperty(item_->text()));
+    properties["toolTip"] = SafePackProperty(PackProperty(item_->toolTip()));
+    // safePackProperty(item_->icon().isNull() ? PackProperty("") : PackProperty(item_->icon()));
+    properties["icon"] = SafePackProperty(PackProperty(item_->icon()));
+    properties["whatsThis"] = SafePackProperty(PackProperty(item_->whatsThis()));
+    properties["row"] = SafePackProperty(PackProperty(item_->row()));
+    properties["isSelected"] = SafePackProperty(PackProperty(item_->isSelected()));
+    properties["column"] = SafePackProperty(PackProperty(item_->column()));
+
+    return properties;
+}
+
+xpathselect::Node::Ptr QTableWidgetItemNode::GetParent() const
+{
+    return parent_;
+}
+
+std::string QTableWidgetItemNode::GetName() const
+{
+    return "QTableWidgetItem";
+}
+
+std::string QTableWidgetItemNode::GetPath() const
+{
+    return full_path_;
+}
+
+int32_t QTableWidgetItemNode::GetId() const
+{
+    return static_cast<int32_t>(reinterpret_cast<qptrdiff>(item_));
+}
+
+bool QTableWidgetItemNode::MatchStringProperty(const std::string& name, const std::string& value) const
+{
+    QVariantMap properties = GetProperties();
+    QString qname = QString::fromStdString(name);
+    QVariant qvalue = QVariant(QString::fromStdString(value));
+    return MatchProperty(properties, qname, qvalue);
+}
+
+bool QTableWidgetItemNode::MatchIntegerProperty(const std::string& name, int32_t value) const
+{
+    if (name == "id")
+        return value == GetId();
+
+    QVariantMap properties = GetProperties();
+    QString qname = QString::fromStdString(name);
+    QVariant qvalue = QVariant(value);
+    return MatchProperty(properties, qname, qvalue);
+}
+
+bool QTableWidgetItemNode::MatchBooleanProperty(const std::string& name, bool value) const
+{
+    QVariantMap properties = GetProperties();
+    QString qname = QString::fromStdString(name);
+    QVariant qvalue = QVariant(value);
+    return MatchProperty(properties, qname, qvalue);
+}
+
+xpathselect::NodeVector QTableWidgetItemNode::Children() const
+{
+    // Doesn't have any children.
+    xpathselect::NodeVector children;
+    return children;
+}
+
+// QTreeWidgetItemNode
+QTreeWidgetItemNode::QTreeWidgetItemNode(QTreeWidgetItem *item, DBusNode::Ptr parent)
+    : item_(item)
+    , parent_(parent)
+{
+    std::string parent_path = parent ? parent->GetPath() : "";
+    full_path_ = parent_path + "/" + GetName();
+}
+
+QTreeWidgetItemNode::QTreeWidgetItemNode(QTreeWidgetItem *item)
+    : item_(item)
+{
+    full_path_ = "/" + GetName();
+}
+
+NodeIntrospectionData QTreeWidgetItemNode::GetIntrospectionData() const
+{
+    NodeIntrospectionData data;
+    data.object_path = QString::fromStdString(GetPath());
+    data.state = GetProperties();
+    data.state["id"] = PackProperty(GetId());
+    return data;
+}
+
+QVariantMap QTreeWidgetItemNode::GetProperties() const
+{
+    QVariantMap properties;
+    QTreeWidget* parent = item_->treeWidget();
+    QRect cellrect = parent->visualItemRect(item_);
+    QRect r = QRect(parent->viewport()->mapToGlobal(cellrect.topLeft()), cellrect.size());
+    properties["globalRect"] = PackProperty(r);
+
+    properties["text"] = SafePackProperty(item_->text(0));
+    properties["columns"] = SafePackProperty(item_->columnCount());
+    properties["checkState"] = SafePackProperty(item_->checkState(0));
+
+    properties["isDisabled"] = SafePackProperty(item_->isDisabled());
+    properties["isExpanded"] = SafePackProperty(item_->isExpanded());
+    properties["isFirstColumnSpanned"] = SafePackProperty(item_->isFirstColumnSpanned());
+    properties["isHidden"] = SafePackProperty(item_->isHidden());
+    properties["isSelected"] = SafePackProperty(item_->isSelected());
+
+    return properties;
+}
+
+xpathselect::Node::Ptr QTreeWidgetItemNode::GetParent() const
+{
+    return parent_;
+}
+
+std::string QTreeWidgetItemNode::GetName() const
+{
+    return "QTreeWidgetItem";
+}
+
+std::string QTreeWidgetItemNode::GetPath() const
+{
+    return full_path_;
+}
+
+int32_t QTreeWidgetItemNode::GetId() const
+{
+    return static_cast<int32_t>(reinterpret_cast<qptrdiff>(item_));
+}
+
+bool QTreeWidgetItemNode::MatchStringProperty(const std::string& name, const std::string& value) const
+{
+    QVariantMap properties = GetProperties();
+    QString qname = QString::fromStdString(name);
+    QVariant qvalue = QVariant(QString::fromStdString(value));
+    return MatchProperty(properties, qname, qvalue);
+}
+
+bool QTreeWidgetItemNode::MatchIntegerProperty(const std::string& name, int32_t value) const
+{
+    if (name == "id")
+        return value == GetId();
+
+    QVariantMap properties = GetProperties();
+    QString qname = QString::fromStdString(name);
+    QVariant qvalue = QVariant(value);
+    return MatchProperty(properties, qname, qvalue);
+}
+
+bool QTreeWidgetItemNode::MatchBooleanProperty(const std::string& name, bool value) const
+{
+    QVariantMap properties = GetProperties();
+    QString qname = QString::fromStdString(name);
+    QVariant qvalue = QVariant(value);
+    return MatchProperty(properties, qname, qvalue);
+}
+
+xpathselect::NodeVector QTreeWidgetItemNode::Children() const
+{
+    xpathselect::NodeVector children;
+
+    for(int i=0; i < item_->childCount(); ++i) {
+        children.push_back(
+            std::make_shared<QTreeWidgetItemNode>(item_->child(i),shared_from_this())
+            );
+    }
+
+    return children;
 }

=== modified file 'driver/qtnode.h'
--- driver/qtnode.h	2014-03-12 13:26:27 +0000
+++ driver/qtnode.h	2014-06-20 04:04:19 +0000
@@ -6,6 +6,13 @@
 #include <QDBusArgument>
 #include <xpathselect/node.h>
 
+#include <QModelIndex>
+
+class QAbstractItemView;
+class QTableWidgetItem;
+class QTreeView;
+class QTreeWidgetItem;
+
 /// A simple data structure representing the state of a single node:
 struct NodeIntrospectionData
 {
@@ -19,25 +26,38 @@
 QDBusArgument &operator<<(QDBusArgument &argument, const NodeIntrospectionData &node_data);
 const QDBusArgument &operator>>(const QDBusArgument &argument, NodeIntrospectionData &node_data);
 
-/// Base class for all Qt-based object nodes.
+// Interface for Introspecting an object to query it's details.
+class DBusNode : public xpathselect::Node
+{
+public:
+    typedef std::shared_ptr<const DBusNode> Ptr;
+
+    DBusNode() {}
+    virtual ~DBusNode() {}
+
+    virtual NodeIntrospectionData GetIntrospectionData() const=0;
+};
+
+/// Specialist class for all QObject object nodes.
+/// This will cover a majority of what we use and we will only need to break
+/// out to specilist classes for a couple of minor (i.e. QModelIndex)
 ///
-/// QtNode wraps a single QObject pointer. It derives from xpathselect::Node and,
-/// like that class, is designed to be allocated on the heap and stored in a
-/// std::shared_ptr.
-class QtNode: public xpathselect::Node, public std::enable_shared_from_this<QtNode>
+/// QObjectNode wraps a single QObject pointer. It derives from
+/// xpathselect::Node (DBusNode) and, like that class, is designed to be
+/// allocated on the heap and stored in a std::shared_ptr.
+class QObjectNode : public DBusNode, public std::enable_shared_from_this<QObjectNode>
 {
 public:
-    typedef std::shared_ptr<const QtNode> Ptr;
-
-    QtNode(QObject* object, Ptr parent);
-    explicit QtNode(QObject* object);
+    QObjectNode(QObject* object, DBusNode::Ptr parent);
+    explicit QObjectNode(QObject* object);
 
     QObject* getWrappedObject() const;
+
+    // DBusNode
+    virtual NodeIntrospectionData GetIntrospectionData() const;
+
+    // xpathselect::Node
     xpathselect::Node::Ptr GetParent() const;
-
-    virtual NodeIntrospectionData GetIntrospectionData() const;
-
-
     virtual std::string GetName() const;
     virtual std::string GetPath() const;
     virtual int32_t GetId() const;
@@ -45,10 +65,93 @@
     virtual bool MatchIntegerProperty(const std::string& name, int32_t value) const;
     virtual bool MatchBooleanProperty(const std::string& name, bool value) const;
     virtual xpathselect::NodeVector Children() const;
+
 private:
     QObject *object_;
     std::string full_path_;
-    Ptr parent_;
+    DBusNode::Ptr parent_;
+};
+
+class QModelIndexNode : public DBusNode, public std::enable_shared_from_this<QModelIndexNode>
+{
+public:
+    QModelIndexNode(QModelIndex index, QAbstractItemView* parent_view, DBusNode::Ptr parent);
+    explicit QModelIndexNode(QModelIndex index, QAbstractItemView* parent_view);
+
+    // DBusNode
+    virtual NodeIntrospectionData GetIntrospectionData() const;
+
+    // xpathselect::Node
+    xpathselect::Node::Ptr GetParent() const;
+    virtual std::string GetName() const;
+    virtual std::string GetPath() const;
+    virtual int32_t GetId() const;
+    virtual bool MatchStringProperty(const std::string& name, const std::string& value) const;
+    virtual bool MatchIntegerProperty(const std::string& name, int32_t value) const;
+    virtual bool MatchBooleanProperty(const std::string& name, bool value) const;
+    virtual xpathselect::NodeVector Children() const;
+
+private:
+    QVariantMap GetProperties() const;
+
+    QModelIndex index_;
+    QAbstractItemView* parent_view_;
+    std::string full_path_;
+    DBusNode::Ptr parent_;
+};
+
+class QTableWidgetItemNode : public DBusNode, public std::enable_shared_from_this<QTableWidgetItemNode>
+{
+public:
+    QTableWidgetItemNode(QTableWidgetItem *item, DBusNode::Ptr parent);
+    explicit QTableWidgetItemNode(QTableWidgetItem *item);
+
+    // DBusNode
+    virtual NodeIntrospectionData GetIntrospectionData() const;
+
+    // xpathselect::Node
+    xpathselect::Node::Ptr GetParent() const;
+    virtual std::string GetName() const;
+    virtual std::string GetPath() const;
+    virtual int32_t GetId() const;
+    virtual bool MatchStringProperty(const std::string& name, const std::string& value) const;
+    virtual bool MatchIntegerProperty(const std::string& name, int32_t value) const;
+    virtual bool MatchBooleanProperty(const std::string& name, bool value) const;
+    virtual xpathselect::NodeVector Children() const;
+
+private:
+    QVariantMap GetProperties() const;
+
+    QTableWidgetItem *item_;
+    std::string full_path_;
+    DBusNode::Ptr parent_;
+};
+
+class QTreeWidgetItemNode : public DBusNode, public std::enable_shared_from_this<QTreeWidgetItemNode>
+{
+public:
+    QTreeWidgetItemNode(QTreeWidgetItem *item, DBusNode::Ptr parent);
+    explicit QTreeWidgetItemNode(QTreeWidgetItem *item);
+
+    // DBusNode
+    virtual NodeIntrospectionData GetIntrospectionData() const;
+
+    // xpathselect::Node
+    xpathselect::Node::Ptr GetParent() const;
+    virtual std::string GetName() const;
+    virtual std::string GetPath() const;
+    virtual int32_t GetId() const;
+    virtual bool MatchStringProperty(const std::string& name, const std::string& value) const;
+    virtual bool MatchIntegerProperty(const std::string& name, int32_t value) const;
+    virtual bool MatchBooleanProperty(const std::string& name, bool value) const;
+    virtual xpathselect::NodeVector Children() const;
+
+private:
+    QVariantMap GetProperties() const;
+
+    QTreeWidgetItem *item_;
+    std::string full_path_;
+    DBusNode::Ptr parent_;
 };
 
 #endif // QTNODE_H

=== modified file 'driver/rootnode.cpp'
--- driver/rootnode.cpp	2013-09-03 04:45:05 +0000
+++ driver/rootnode.cpp	2014-06-20 04:04:19 +0000
@@ -7,7 +7,7 @@
 #include <QDebug>
 
 RootNode::RootNode(QCoreApplication* application)
-    : QtNode(application)
+    : QObjectNode(application)
     , application_(application)
 {
 }
@@ -49,6 +49,6 @@
 {
     xpathselect::NodeVector children;
     foreach(QObject* child, children_)
-        children.push_back(std::make_shared<QtNode>(child, shared_from_this()));
+        children.push_back(std::make_shared<QObjectNode>(child, shared_from_this()));
     return children;
 }

=== modified file 'driver/rootnode.h'
--- driver/rootnode.h	2013-09-03 04:45:05 +0000
+++ driver/rootnode.h	2014-06-20 04:04:19 +0000
@@ -8,7 +8,7 @@
 class QObject;
 
 
-class RootNode: public QtNode
+class RootNode: public QObjectNode
 {
 public:
     RootNode(QCoreApplication* application);

=== modified file 'tests/unittests/tst_introspection.cpp'
--- tests/unittests/tst_introspection.cpp	2014-03-12 13:26:27 +0000
+++ tests/unittests/tst_introspection.cpp	2014-06-20 04:04:19 +0000
@@ -503,7 +503,7 @@
 
 void tst_Introspection::test_property_matching()
 {
-    QtNode n(m_object);
+    QObjectNode n(m_object);
 
     QVERIFY(n.MatchStringProperty("dynamicStringProperty", "testValue") == true);
     QVERIFY(n.MatchStringProperty("dynamicTestProperty", "testValue") == true);