Display templates in a tree sturcture

mapeditor · Jun 12, 2017 · 908f143 · 908f143
1 parent 0c1ca01
commit 908f143
Show file tree

Hide file tree

Showing 9 changed files with 151 additions and 33 deletions.
diff --git a/src/libtiled/object.h b/src/libtiled/object.h
@@ -45,6 +45,8 @@ class TILEDSHARED_EXPORT Object
         MapType,
         TerrainType,
         TilesetType,
+        ObjectTemplateType,
+        TemplateGroupType,
         TileType
     };
 

diff --git a/src/libtiled/objecttemplate.cpp b/src/libtiled/objecttemplate.cpp
@@ -29,12 +29,22 @@
 
 #include "objecttemplate.h"
 
-ObjectTemplate::ObjectTemplate()
+#include "templategroup.h"
+
+namespace Tiled {
+
+ObjectTemplate::ObjectTemplate():
+    Object(ObjectTemplateType),
+    mTemplateGroup(nullptr)
 {
 }
 
 ObjectTemplate::ObjectTemplate(int id, QString name):
+    Object(ObjectTemplateType),
     mId(id),
-    mName(name)
+    mName(name),
+    mTemplateGroup(nullptr)
 {
 }
+
+} // namespace Tiled
diff --git a/src/libtiled/objecttemplate.h b/src/libtiled/objecttemplate.h
@@ -30,10 +30,13 @@
 #pragma once
 
 #include "mapobject.h"
+#include "object.h"
 
-using namespace Tiled;
+namespace Tiled {
 
-class TILEDSHARED_EXPORT ObjectTemplate
+class TemplateGroup;
+
+class TILEDSHARED_EXPORT ObjectTemplate : public Object
 {
 public:
     ObjectTemplate();
@@ -48,10 +51,14 @@ class TILEDSHARED_EXPORT ObjectTemplate
     const QString &name() const;
     void setName(const QString &name);
 
+    TemplateGroup *templateGroup() const;
+    void setTemplateGroup(TemplateGroup *templateGroup);
+
 private:
     MapObject *mObject;
     int mId;
     QString mName;
+    TemplateGroup *mTemplateGroup;
 };
 
 inline const MapObject *ObjectTemplate::object() const
@@ -74,3 +81,11 @@ inline const QString &ObjectTemplate::name() const
 
 inline void ObjectTemplate::setName(const QString &name)
 { mName = name; }
+
+inline TemplateGroup *ObjectTemplate::templateGroup() const
+{ return mTemplateGroup; }
+
+inline void ObjectTemplate::setTemplateGroup(TemplateGroup *templateGroup)
+{ mTemplateGroup = templateGroup; }
+
+} // namespace Tiled
diff --git a/src/libtiled/templategroup.cpp b/src/libtiled/templategroup.cpp
@@ -33,11 +33,13 @@
 
 using namespace Tiled;
 
-TemplateGroup::TemplateGroup()
+TemplateGroup::TemplateGroup():
+    Object(TemplateGroupType)
 {
 }
 
 TemplateGroup::TemplateGroup(QString name):
+    Object(TemplateGroupType),
     mName(name)
 {
 }
@@ -50,6 +52,7 @@ TemplateGroup::~TemplateGroup()
 void TemplateGroup::addTemplate(ObjectTemplate *objectTemplate)
 {
     mTemplates.append(objectTemplate);
+    objectTemplate->setTemplateGroup(this);
 }
 
 bool TemplateGroup::addTileset(const SharedTileset &tileset)

diff --git a/src/libtiled/templategroup.h b/src/libtiled/templategroup.h
@@ -30,15 +30,15 @@
 #pragma once
 
 #include "tiled_global.h"
-
 #include "objecttemplate.h"
+#include "object.h"
 
 namespace Tiled {
 
 class MapObject;
 class TemplateGroupFormat;
 
-class TILEDSHARED_EXPORT TemplateGroup
+class TILEDSHARED_EXPORT TemplateGroup : public Object
 {
 public:
     TemplateGroup();
@@ -59,6 +59,8 @@ class TILEDSHARED_EXPORT TemplateGroup
 
     int templateCount() const { return mTemplates.size(); }
 
+    ObjectTemplate *templateAt(int index) const { return mTemplates.at(index); }
+
 private:
     QList<ObjectTemplate*> mTemplates;
     QVector<SharedTileset> mTilesets;

diff --git a/src/tiled/objecttemplatemodel.cpp b/src/tiled/objecttemplatemodel.cpp
@@ -23,28 +23,89 @@
 
 #include "templategroup.h"
 
-ObjectTemplateModel::ObjectTemplateModel(const TemplateGroup *templateGroup, QObject *parent):
-    QAbstractListModel(parent),
-    mTemplateGroup(templateGroup)
+namespace Tiled {
+
+ObjectTemplateModel::ObjectTemplateModel(const QList<TemplateGroup*> &templateGroups, QObject *parent):
+    QAbstractItemModel(parent),
+    mTemplateGroups(templateGroups)
 {
 }
 
+QModelIndex ObjectTemplateModel::index(int row, int column,
+                                       const QModelIndex &parent) const
+{
+    if (parent == QModelIndex())
+        return createIndex(row, column, mTemplateGroups.at(row));
+
+    if (TemplateGroup *templateGroup = toTemplateGroup(parent)) {
+        if (row < templateGroup->templateCount())
+            return createIndex(row, column, templateGroup->templateAt(row));
+    }
+
+    return QModelIndex();
+}
+
+QModelIndex ObjectTemplateModel::parent(const QModelIndex &index) const
+{
+    if (ObjectTemplate *objectTemplate = toObjectTemplate(index)) {
+        auto templateGroup = objectTemplate->templateGroup();
+        return createIndex(mTemplateGroups.indexOf(templateGroup), 0, templateGroup);
+    }
+
+    return QModelIndex();
+}
+
 int ObjectTemplateModel::rowCount(const QModelIndex &parent) const
 {
-    return mTemplateGroup->templateCount();
+    if (!parent.isValid())
+        return mTemplateGroups.size();
+
+    if (TemplateGroup *templateGroup = toTemplateGroup(parent))
+        return templateGroup->templateCount();
+
+    return 0;
+}
+
+int ObjectTemplateModel::columnCount(const QModelIndex &parent) const
+{
+    Q_UNUSED(parent)
+    return 1;
 }
 
 QVariant ObjectTemplateModel::data(const QModelIndex &index, int role) const
+{
+    if (role == Qt::DisplayRole) {
+        if (TemplateGroup *templateGroup = toTemplateGroup(index))
+            return templateGroup->name();
+        else if (ObjectTemplate *objectTemplate = toObjectTemplate(index))
+            return objectTemplate->name();
+    }
+
+    return QVariant();
+}
+
+ObjectTemplate *ObjectTemplateModel::toObjectTemplate(const QModelIndex &index) const
+{
+    if (!index.isValid())
+        return nullptr;
+
+    Object *object = static_cast<Object*>(index.internalPointer());
+    if (object->typeId() == Object::ObjectTemplateType)
+        return static_cast<ObjectTemplate*>(object);
+
+    return nullptr;
+}
+
+TemplateGroup *ObjectTemplateModel::toTemplateGroup(const QModelIndex &index) const
 {
     if (!index.isValid())
-        return QVariant();
+        return nullptr;
 
-    if (index.row() >= mTemplateGroup->templateCount())
-        return QVariant();
+    Object *object = static_cast<Object*>(index.internalPointer());
+    if (object->typeId() == Object::TemplateGroupType)
+        return static_cast<TemplateGroup*>(object);
 
-    if (role == Qt::DisplayRole)
-        return mTemplateGroup->templates().at(index.row())->name();
-    else
-        return QVariant();
+    return nullptr;
 }
 
+} // namespace Tiled
diff --git a/src/tiled/objecttemplatemodel.h b/src/tiled/objecttemplatemodel.h
@@ -21,19 +21,32 @@
 
 #pragma once
 
-#include <QAbstractListModel>
+#include <QAbstractItemModel>
 #include <templategroup.h>
 
-class ObjectTemplateModel : public QAbstractListModel
+namespace Tiled {
+
+class ObjectTemplateModel : public QAbstractItemModel
 {
     Q_OBJECT
 
 public:
-    ObjectTemplateModel(const TemplateGroup *templateGroup, QObject *parent = 0);
+    ObjectTemplateModel(const QList<TemplateGroup *> &templateGroups, QObject *parent = nullptr);
+
+    QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const override;
+    QModelIndex parent(const QModelIndex &index) const override;
 
     int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+    int columnCount(const QModelIndex &parent = QModelIndex()) const override;
+
     QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
 
 private:
-    const TemplateGroup *mTemplateGroup;
+
+    const QList<TemplateGroup*> mTemplateGroups;
+    ObjectTemplate *toObjectTemplate(const QModelIndex &index) const;
+    TemplateGroup *toTemplateGroup(const QModelIndex &index) const;
 };
+
+
+} // namespace Tiled
diff --git a/src/tiled/templatesdock.cpp b/src/tiled/templatesdock.cpp
@@ -30,9 +30,9 @@
 using namespace Tiled;
 using namespace Tiled::Internal;
 
-TemplatesDock::TemplatesDock(QWidget *parent)
-    : QDockWidget(parent)
-    , mTemplatesView(new TemplatesView)
+TemplatesDock::TemplatesDock(QWidget *parent):
+    QDockWidget(parent),
+    mTemplatesView(new TemplatesView)
 {
     setObjectName(QLatin1String("TemplatesDock"));
 
@@ -64,20 +64,32 @@ void TemplatesDock::retranslateUi()
 }
 
 TemplatesView::TemplatesView(QWidget *parent)
-    : QListView(parent)
+    : QTreeView(parent)
 {
-    auto *templateGroup = new TemplateGroup(QLatin1String("Test Group"));
+    setUniformRowHeights(true);
+    setHeaderHidden(true);
+
+    auto *templateGroup1 = new TemplateGroup(QLatin1String("Test Group 1"));
     auto *objectTemplate1 = new ObjectTemplate(1, QLatin1String("Template 1"));
     auto *objectTemplate2 = new ObjectTemplate(2, QLatin1String("Template 2"));
-    templateGroup->addTemplate(objectTemplate1);
-    templateGroup->addTemplate(objectTemplate2);
+    templateGroup1->addTemplate(objectTemplate1);
+    templateGroup1->addTemplate(objectTemplate2);
+
+    auto *templateGroup2 = new TemplateGroup(QLatin1String("Test Group 2"));
+    auto *objectTemplate3 = new ObjectTemplate(1, QLatin1String("Template 3"));
+    auto *objectTemplate4 = new ObjectTemplate(2, QLatin1String("Template 4"));
+    templateGroup2->addTemplate(objectTemplate3);
+    templateGroup2->addTemplate(objectTemplate4);
+
+    QList<TemplateGroup*> templateGroups;
+    templateGroups.append(templateGroup1);
+    templateGroups.append(templateGroup2);
 
-    ObjectTemplateModel *objectTemplateModel = new ObjectTemplateModel(templateGroup);
+    ObjectTemplateModel *objectTemplateModel = new ObjectTemplateModel(templateGroups);
 
     setModel(objectTemplateModel);
 
     setSelectionBehavior(QAbstractItemView::SelectRows);
-    setSelectionMode(QAbstractItemView::ExtendedSelection);
 }
 
 QSize TemplatesView::sizeHint() const

diff --git a/src/tiled/templatesdock.h b/src/tiled/templatesdock.h
@@ -22,7 +22,7 @@
 #pragma once
 
 #include <QDockWidget>
-#include <QListView>
+#include <QTreeView>
 #include <QAction>
 
 class QAbstractProxyModel;
@@ -49,7 +49,7 @@ class TemplatesDock : public QDockWidget
     TemplatesView *mTemplatesView;
 };
 
-class TemplatesView : public QListView
+class TemplatesView : public QTreeView
 {
     Q_OBJECT