OP-642 Added code to create category items in tree. Changed some support methods to handle the the now arbitrary depth of the uavo tree. Removed several hard coded functions depending on tree only being two levels deep.

Changed implementation to use maps instead of lists to find tree items and meta items. This is probably much better performance wise, and the code gets much cleaner.
Changed the background highlight code to highlight all tree nodes that aren't TopTreeItem:s to enable category items to be highlighted.
Cleaned up some code.

ground/openpilotgcs/src/plugins/uavobjectbrowser/treeitem.cpp

@@ -129,21 +129,23 @@ void TreeItem::appendChild(TreeItem *child)
     child->setParentTree(this);
 }
 
-void TreeItem::insert(int index, TreeItem *child)
+void TreeItem::insertChild(TreeItem *child)
 {
+    int index = nameIndex(child->data(0).toString());
     m_children.insert(index, child);
     child->setParentTree(this);
 }
 
-TreeItem *TreeItem::child(int row)
+TreeItem *TreeItem::getChild(int index)
 {
-    return m_children.value(row);
+    return m_children.value(index);
 }
 
 int TreeItem::childCount() const
 {
     return m_children.count();
 }
+
 int TreeItem::row() const
 {
     if (m_parent)
@@ -224,3 +226,8 @@ QTime TreeItem::getHiglightExpires()
 {
     return m_highlightExpires;
 }
+
+QList<MetaObjectTreeItem *> TopTreeItem::getMetaObjectItems()
+{
+    return m_metaObjectTreeItemsPerObjectIds.values();
+}

ground/openpilotgcs/src/plugins/uavobjectbrowser/treeitem.h

@@ -33,6 +33,7 @@
 #include "uavobjectfield.h"
 #include <QtCore/QList>
 #include <QtCore/QLinkedList>
+#include <QtCore/QMap>
 #include <QtCore/QVariant>
 #include <QtCore/QTime>
 #include <QtCore/QTimer>
@@ -94,9 +95,9 @@ public:
     virtual ~TreeItem();
 
     void appendChild(TreeItem *child);
-    void insert(int index, TreeItem *child);
+    void insertChild(TreeItem *child);
 
-    TreeItem *child(int row);
+    TreeItem *getChild(int index);
     inline QList<TreeItem*> treeChildren() const { return m_children; }
     int childCount() const;
     int columnCount() const;
@@ -131,6 +132,24 @@ public:
 
     virtual void removeHighlight();
 
+    int nameIndex(QString name) {
+        for (int i = 0; i < childCount(); ++i) {
+            if (name < getChild(i)->data(0).toString())
+                return i;
+        }
+        return childCount();
+    }
+
+    TreeItem* findChildByName(QString name)
+    {
+        foreach (TreeItem* child, m_children) {
+            if (name == child->data(0).toString()) {
+                return child;
+            }
+        }
+        return 0;
+    }
+
 signals:
     void updateHighlight(TreeItem*);
 
@@ -152,6 +171,9 @@ private:
     static int m_highlightTimeMs;
 };
 
+class DataObjectTreeItem;
+class MetaObjectTreeItem;
+
 class TopTreeItem : public TreeItem
 {
 Q_OBJECT
@@ -159,19 +181,27 @@ public:
     TopTreeItem(const QList<QVariant> &data, TreeItem *parent = 0) : TreeItem(data, parent) { }
     TopTreeItem(const QVariant &data, TreeItem *parent = 0) : TreeItem(data, parent) { }
 
-    QList<quint32> objIds() { return m_objIds; }
-    void addObjId(quint32 objId) { m_objIds.append(objId); }
-    void insertObjId(int index, quint32 objId) { m_objIds.insert(index, objId); }
-    int nameIndex(QString name) {
-        for (int i = 0; i < childCount(); ++i) {
-            if (name < child(i)->data(0).toString())
-                return i;
-        }
-        return childCount();
+    void addObjectTreeItem(quint32 objectId, DataObjectTreeItem* oti) {
+        m_objectTreeItemsPerObjectIds[objectId] = oti;
     }
 
+    DataObjectTreeItem* findDataObjectTreeItemByObjectId(quint32 objectId) {
+        return m_objectTreeItemsPerObjectIds.contains(objectId) ? m_objectTreeItemsPerObjectIds[objectId] : 0;
+    }
+
+    void addMetaObjectTreeItem(quint32 objectId, MetaObjectTreeItem* oti) {
+        m_metaObjectTreeItemsPerObjectIds[objectId] = oti;
+    }
+
+    MetaObjectTreeItem* findMetaObjectTreeItemByObjectId(quint32 objectId) {
+        return m_metaObjectTreeItemsPerObjectIds.contains(objectId) ? m_metaObjectTreeItemsPerObjectIds[objectId] : 0;
+    }
+
+    QList<MetaObjectTreeItem*> getMetaObjectItems();
+
 private:
-    QList<quint32> m_objIds;
+    QMap<quint32, DataObjectTreeItem*> m_objectTreeItemsPerObjectIds;
+    QMap<quint32, MetaObjectTreeItem*> m_metaObjectTreeItemsPerObjectIds;
 };
 
 class ObjectTreeItem : public TreeItem

ground/openpilotgcs/src/plugins/uavobjectbrowser/uavobjectbrowserwidget.cpp

@@ -69,6 +69,7 @@ UAVObjectBrowserWidget::~UAVObjectBrowserWidget()
 
 void UAVObjectBrowserWidget::showMetaData(bool show)
 {
+    /*
     int topRowCount = m_model->rowCount(QModelIndex());
     for (int i = 0; i < topRowCount; ++i) {
         QModelIndex index = m_model->index(i, 0, QModelIndex());
@@ -77,6 +78,12 @@ void UAVObjectBrowserWidget::showMetaData(bool show)
             m_browser->treeView->setRowHidden(0, index.child(j,0), !show);
         }
     }
+    */
+    QList<QModelIndex> metaIndexes = m_model->getMetaDataIndexes();
+    foreach(QModelIndex index , metaIndexes)
+    {
+        m_browser->treeView->setRowHidden(index.row(), index.parent(), !show);
+    }
 }
 
 void UAVObjectBrowserWidget::sendUpdate()

ground/openpilotgcs/src/plugins/uavobjectbrowser/uavobjecttreemodel.cpp

@@ -90,33 +90,62 @@ void UAVObjectTreeModel::setupModelData(UAVObjectManager *objManager)
 void UAVObjectTreeModel::newObject(UAVObject *obj)
 {
     UAVDataObject *dobj = qobject_cast<UAVDataObject*>(obj);
-    if (dobj)
+    if (dobj) {
         addDataObject(dobj);
+    }
 }
 
 void UAVObjectTreeModel::addDataObject(UAVDataObject *obj)
 {
     TopTreeItem *root = obj->isSettings() ? m_settingsTree : m_nonSettingsTree;
-    if (root->objIds().contains(obj->getObjID())) {
-        int index = root->objIds().indexOf(obj->getObjID());
-        addInstance(obj, root->child(index));
+
+    TreeItem* parent = root;
+
+    if(obj->getCategory() != 0 && !obj->getCategory().isEmpty()) {
+        QStringList categoryPath = obj->getCategory().split('/');
+        parent = createCategoryItems(categoryPath, root);
+    }
+
+    ObjectTreeItem* existing = root->findDataObjectTreeItemByObjectId(obj->getObjID());
+    if (existing) {
+        addInstance(obj, existing);
     } else {
-        DataObjectTreeItem *data = new DataObjectTreeItem(obj->getName() + " (" + QString::number(obj->getNumBytes()) + " bytes)");
-        data->setHighlightManager(m_highlightManager);
-        connect(data, SIGNAL(updateHighlight(TreeItem*)), this, SLOT(updateHighlight(TreeItem*)));
-        int index = root->nameIndex(obj->getName());
-        root->insert(index, data);
-        root->insertObjId(index, obj->getObjID());
+        DataObjectTreeItem *dataTreeItem = new DataObjectTreeItem(obj->getName() + " (" + QString::number(obj->getNumBytes()) + " bytes)");
+        dataTreeItem->setHighlightManager(m_highlightManager);
+        connect(dataTreeItem, SIGNAL(updateHighlight(TreeItem*)), this, SLOT(updateHighlight(TreeItem*)));
+        parent->insertChild(dataTreeItem);
+        root->addObjectTreeItem(obj->getObjID(), dataTreeItem);
         UAVMetaObject *meta = obj->getMetaObject();
-        addMetaObject(meta, data);
-        addInstance(obj, data);
+        MetaObjectTreeItem* metaTreeItem = addMetaObject(meta, dataTreeItem);
+        root->addMetaObjectTreeItem(meta->getObjID(), metaTreeItem);
+        addInstance(obj, dataTreeItem);
     }
 }
 
-void UAVObjectTreeModel::addMetaObject(UAVMetaObject *obj, TreeItem *parent)
+TreeItem* UAVObjectTreeModel::createCategoryItems(QStringList categoryPath, TreeItem* root)
+{
+    TreeItem* parent = root;
+    foreach(QString category, categoryPath) {
+        TreeItem* existing = parent->findChildByName(category);
+        if(!existing) {
+            TreeItem* categoryItem = new TreeItem(category);
+            connect(categoryItem, SIGNAL(updateHighlight(TreeItem*)), this, SLOT(updateHighlight(TreeItem*)));
+            categoryItem->setHighlightManager(m_highlightManager);
+            parent->insertChild(categoryItem);
+            parent = categoryItem;
+        }
+        else {
+            parent = existing;
+        }
+    }
+    return parent;
+}
+
+MetaObjectTreeItem* UAVObjectTreeModel::addMetaObject(UAVMetaObject *obj, TreeItem *parent)
 {
     connect(obj, SIGNAL(objectUpdated(UAVObject*)), this, SLOT(highlightUpdatedObject(UAVObject*)));
     MetaObjectTreeItem *meta = new MetaObjectTreeItem(obj, tr("Meta Data"));
+
     meta->setHighlightManager(m_highlightManager);
     connect(meta, SIGNAL(updateHighlight(TreeItem*)), this, SLOT(updateHighlight(TreeItem*)));
     foreach (UAVObjectField *field, obj->getFields()) {
@@ -127,6 +156,7 @@ void UAVObjectTreeModel::addMetaObject(UAVMetaObject *obj, TreeItem *parent)
         }
     }
     parent->appendChild(meta);
+    return meta;
 }
 
 void UAVObjectTreeModel::addInstance(UAVObject *obj, TreeItem *parent)
@@ -153,7 +183,6 @@ void UAVObjectTreeModel::addInstance(UAVObject *obj, TreeItem *parent)
     }
 }
 
-
 void UAVObjectTreeModel::addArrayField(UAVObjectField *field, TreeItem *parent)
 {
     TreeItem *item = new ArrayFieldTreeItem(field->getName());
@@ -220,7 +249,7 @@ QModelIndex UAVObjectTreeModel::index(int row, int column, const QModelIndex &pa
     else
         parentItem = static_cast<TreeItem*>(parent.internalPointer());
 
-    TreeItem *childItem = parentItem->child(row);
+    TreeItem *childItem = parentItem->getChild(row);
     if (childItem)
         return createIndex(row, column, childItem);
     else
@@ -280,15 +309,31 @@ int UAVObjectTreeModel::columnCount(const QModelIndex &parent) const
         return m_rootItem->columnCount();
 }
 
+QList<QModelIndex> UAVObjectTreeModel::getMetaDataIndexes()
+{
+    QList<QModelIndex> metaIndexes;
+    foreach(MetaObjectTreeItem *metaItem , m_settingsTree->getMetaObjectItems())
+    {
+        metaIndexes.append(index(metaItem));
+    }
+
+    foreach(MetaObjectTreeItem *metaItem , m_nonSettingsTree->getMetaObjectItems())
+    {
+        metaIndexes.append(index(metaItem));
+    }
+    return metaIndexes;
+}
+
 QVariant UAVObjectTreeModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid())
-        return QVariant();
+        return QVariant();    
 
     if (index.column() == TreeItem::dataColumn && role == Qt::EditRole) {
         TreeItem *item = static_cast<TreeItem*>(index.internalPointer());
         return item->data(index.column());
     }
+
 //    if (role == Qt::DecorationRole)
 //        return QIcon(":/core/images/openpilot_logo_128.png");
 
@@ -300,16 +345,17 @@ QVariant UAVObjectTreeModel::data(const QModelIndex &index, int role) const
     TreeItem *item = static_cast<TreeItem*>(index.internalPointer());
 
     if (index.column() == 0 && role == Qt::BackgroundRole) {
-        ObjectTreeItem *objItem = dynamic_cast<ObjectTreeItem*>(item);
-        if (objItem && objItem->highlighted())
+        if (!dynamic_cast<TopTreeItem*>(item) && item->highlighted())
             return QVariant(m_recentlyUpdatedColor);
     }
+
     if (index.column() == TreeItem::dataColumn && role == Qt::BackgroundRole) {
         FieldTreeItem *fieldItem = dynamic_cast<FieldTreeItem*>(item);
         if (fieldItem && fieldItem->highlighted())
             return QVariant(m_recentlyUpdatedColor);
+
         if (fieldItem && fieldItem->changed())
-            return QVariant(m_manuallyChangedColor);
+            return QVariant(m_manuallyChangedColor);       
     }
 
     if (role != Qt::DisplayRole)
@@ -376,50 +422,29 @@ void UAVObjectTreeModel::highlightUpdatedObject(UAVObject *obj)
 
 ObjectTreeItem *UAVObjectTreeModel::findObjectTreeItem(UAVObject *object)
 {
-    UAVDataObject *dobj = qobject_cast<UAVDataObject*>(object);
-    UAVMetaObject *mobj = qobject_cast<UAVMetaObject*>(object);
-    Q_ASSERT(dobj || mobj);
-    if (dobj) {
-        return findDataObjectTreeItem(dobj);
+    UAVDataObject *dataObject = qobject_cast<UAVDataObject*>(object);
+    UAVMetaObject *metaObject = qobject_cast<UAVMetaObject*>(object);
+    Q_ASSERT(dataObject || metaObject);
+    if (dataObject) {
+        return findDataObjectTreeItem(dataObject);
     } else {
-        dobj = qobject_cast<UAVDataObject*>(mobj->getParentObject());
-        Q_ASSERT(dobj);
-        ObjectTreeItem *dItem = findDataObjectTreeItem(dobj);
-        Q_ASSERT(dItem);
-        Q_ASSERT(dItem->object());
-        if (!dItem->object()->isSingleInstance())
-            dItem = dynamic_cast<ObjectTreeItem*>(dItem->parent());
-        foreach (TreeItem *child, dItem->treeChildren()) {
-            MetaObjectTreeItem *mItem = dynamic_cast<MetaObjectTreeItem*>(child);
-            if (mItem && mItem->object()) {
-                Q_ASSERT(mItem->object() == mobj);
-                return mItem;
-            }
-        }
+        return findMetaObjectTreeItem(metaObject);
     }
-
     return 0;
 }
 
-DataObjectTreeItem *UAVObjectTreeModel::findDataObjectTreeItem(UAVDataObject *object)
+DataObjectTreeItem* UAVObjectTreeModel::findDataObjectTreeItem(UAVDataObject *obj)
 {
-    Q_ASSERT(object);
-    TopTreeItem *root = object->isSettings() ? m_settingsTree : m_nonSettingsTree;
-    foreach (TreeItem *child, root->treeChildren()) {
-        DataObjectTreeItem *dItem = dynamic_cast<DataObjectTreeItem*>(child);
-        if (dItem && dItem->object() && dItem->object()->isSingleInstance()) {
-            if(dItem->object() == object) {
-                return dItem;
-            }
-        } else {
-            foreach (TreeItem *c, dItem->treeChildren()) {
-                DataObjectTreeItem *d = dynamic_cast<DataObjectTreeItem*>(c);
-                if (d && d->object() == object)
-                    return d;
-            }
-        }
-    }
-    return 0;
+    TopTreeItem *root = obj->isSettings() ? m_settingsTree : m_nonSettingsTree;
+    return root->findDataObjectTreeItemByObjectId(obj->getObjID());
+}
+
+MetaObjectTreeItem* UAVObjectTreeModel::findMetaObjectTreeItem(UAVMetaObject *obj)
+{
+    UAVDataObject *dataObject = qobject_cast<UAVDataObject*>(obj->getParentObject());
+    Q_ASSERT(dataObject);
+    TopTreeItem *root = dataObject->isSettings() ? m_settingsTree : m_nonSettingsTree;
+    return root->findMetaObjectTreeItemByObjectId(obj->getObjID());
 }
 
 void UAVObjectTreeModel::updateHighlight(TreeItem *item)

ground/openpilotgcs/src/plugins/uavobjectbrowser/uavobjecttreemodel.h

@@ -31,6 +31,7 @@
 #include "treeitem.h"
 #include <QAbstractItemModel>
 #include <QtCore/QMap>
+#include <QtCore/QList>
 #include <QtGui/QColor>
 
 class TopTreeItem;
@@ -70,6 +71,8 @@ public:
     }
     void setOnlyHilightChangedValues(bool hilight) {m_onlyHilightChangedValues = hilight; }
 
+    QList<QModelIndex> getMetaDataIndexes();
+
 signals:
 
 public slots:
@@ -82,15 +85,19 @@ private slots:
 private:
     QModelIndex index(TreeItem *item);
     void addDataObject(UAVDataObject *obj);
-    void addMetaObject(UAVMetaObject *obj, TreeItem *parent);
+    MetaObjectTreeItem *addMetaObject(UAVMetaObject *obj, TreeItem *parent);
     void addArrayField(UAVObjectField *field, TreeItem *parent);
 
     void addSingleField(int index, UAVObjectField *field, TreeItem *parent);
     void addInstance(UAVObject *obj, TreeItem *parent);
+
+    TreeItem *createCategoryItems(QStringList categoryPath, TreeItem *root);
+
     QString updateMode(quint8 updateMode);
     void setupModelData(UAVObjectManager *objManager);
     ObjectTreeItem *findObjectTreeItem(UAVObject *obj);
     DataObjectTreeItem *findDataObjectTreeItem(UAVDataObject *obj);
+    MetaObjectTreeItem *findMetaObjectTreeItem(UAVMetaObject *obj);
 
     TreeItem *m_rootItem;
     TopTreeItem *m_settingsTree;