Add basic broken links support for template groups

src/libtiled/map.cpp

@@ -298,6 +298,26 @@ bool Map::addTemplateGroup(TemplateGroup *templateGroup)
     return true;
 }
 
+QList<Tiled::MapObject *> Map::replaceTemplateGroup(TemplateGroup *oldTemplateGroup, TemplateGroup *newTemplateGroup)
+{
+    Q_ASSERT(oldTemplateGroup != newTemplateGroup);
+
+    QList<MapObject*> changedObjects;
+    const int index = mTemplateGroups.indexOf(oldTemplateGroup);
+    for (auto group : objectGroups()) {
+        for (auto o : group->objects()){
+            if (o->templateRef().templateGroup == oldTemplateGroup) {
+                o->setTemplateRef({newTemplateGroup, o->templateRef().templateId});
+                o->syncWithTemplate();
+                changedObjects.append(o);
+            }
+        }
+    }
+
+    mTemplateGroups.replace(index, newTemplateGroup);
+    return changedObjects;
+}
+
 void Map::initializeObjectIds(ObjectGroup &objectGroup)
 {
     for (MapObject *o : objectGroup) {

src/libtiled/map.h

@@ -41,6 +41,7 @@
 
 namespace Tiled {
 
+class MapObject;
 class Tile;
 class ObjectGroup;
 class TemplateGroup;
@@ -347,6 +348,11 @@ class TILEDSHARED_EXPORT Map : public Object
 
     bool addTemplateGroup(TemplateGroup *templateGroup);
 
+    /**
+     * Returns a list of MapObjects to be updated in the map scene
+     */
+    QList<MapObject*> replaceTemplateGroup(TemplateGroup *oldTemplateGroup, TemplateGroup *templateGroup);
+
     /**
      * Returns the background color of this map.
      */

src/libtiled/templatemanager.h

@@ -39,6 +39,7 @@ class TILEDSHARED_EXPORT TemplateManager : public QObject
     TemplateGroup *loadTemplateGroup(const QString &fileName, QString *error);
 
     void setTemplateGroups(TemplateGroups templateGroups);
+    void addTemplateGroup(TemplateGroup *templateGroup);
 
 private:
     Q_DISABLE_COPY(TemplateManager)
@@ -53,4 +54,7 @@ class TILEDSHARED_EXPORT TemplateManager : public QObject
 inline void TemplateManager::setTemplateGroups(TemplateGroups templateGroups)
 { mTemplateGroups = templateGroups; }
 
+inline void TemplateManager::addTemplateGroup(TemplateGroup *templateGroup)
+{ mTemplateGroups.append(templateGroup); }
+
 } // namespace Tiled::Internal

src/tiled/brokenlinks.cpp

@@ -24,8 +24,11 @@
 #include "documentmanager.h"
 #include "map.h"
 #include "mapdocument.h"
+#include "objecttemplatemodel.h"
 #include "preferences.h"
 #include "replacetileset.h"
+#include "templatesdock.h"
+#include "templatemanager.h"
 #include "tmxmapformat.h"
 #include "tile.h"
 #include "tilesetchanges.h"
@@ -60,6 +63,8 @@ QString BrokenLink::filePath() const
         return _tileset->fileName();
     case TilesetTileImageSource:
         return _tile->imageSource();
+    case TemplateGroupReference:
+        return _templateGroup->fileName();
     }
 
     return QString();
@@ -73,11 +78,17 @@ Tileset *BrokenLink::tileset() const
         return _tileset;
     case TilesetTileImageSource:
         return _tile->tileset();
+    case TemplateGroupReference:
+        return nullptr;
     }
 
     return nullptr;
 }
 
+TemplateGroup *BrokenLink::templateGroup() const
+{
+    return type == TemplateGroupReference ? _templateGroup : nullptr;
+}
 
 BrokenLinksModel::BrokenLinksModel(QObject *parent)
     : QAbstractListModel(parent)
@@ -109,6 +120,9 @@ void BrokenLinksModel::setDocument(Document *document)
             connect(mapDocument, &MapDocument::tilesetRemoved,
                     this, &BrokenLinksModel::tilesetRemoved);
 
+            connect(mapDocument, &MapDocument::templateGroupReplaced,
+                    this, &BrokenLinksModel::templateGroupReplaced);
+
             for (const SharedTileset &tileset : mapDocument->map()->tilesets())
                 connectToTileset(tileset);
 
@@ -150,6 +164,15 @@ void BrokenLinksModel::refresh()
             }
         };
 
+        auto processTemplateGroup = [this](TemplateGroup *templateGroup) {
+            if (!templateGroup->loaded()) {
+                BrokenLink link;
+                link.type = TemplateGroupReference;
+                link._templateGroup = templateGroup;
+                mBrokenLinks.append(link);
+            }
+        };
+
         if (auto mapDocument = qobject_cast<MapDocument*>(mDocument)) {
             for (const SharedTileset &tileset : mapDocument->map()->tilesets()) {
                 if (!tileset->fileName().isEmpty() && !tileset->loaded()) {
@@ -161,8 +184,19 @@ void BrokenLinksModel::refresh()
                     processTileset(tileset);
                 }
             }
+
+            for (TemplateGroup *templateGroup : mapDocument->map()->templateGroups()) {
+                if (!templateGroup->fileName().isEmpty() && !templateGroup->loaded()) {
+                    BrokenLink link;
+                    link.type = TemplateGroupReference;
+                    link._templateGroup = templateGroup;
+                    mBrokenLinks.append(link);
+                }
+            }
         } else if (auto tilesetDocument = qobject_cast<TilesetDocument*>(mDocument)) {
             processTileset(tilesetDocument->tileset());
+        } else if (auto templateGroupDocument = qobject_cast<TemplateGroupDocument*>(mDocument)) {
+            processTemplateGroup(templateGroupDocument->templateGroup());
         }
     }
 
@@ -202,6 +236,8 @@ QVariant BrokenLinksModel::data(const QModelIndex &index, int role) const
                 return tr("Tileset image");
             case TilesetTileImageSource:
                 return tr("Tile image");
+            case TemplateGroupReference:
+                return tr("Template group");
             }
             break;
         }
@@ -283,6 +319,14 @@ void BrokenLinksModel::tilesetReplaced(int index, Tileset *newTileset, Tileset *
     refresh();
 }
 
+void BrokenLinksModel::templateGroupReplaced(int index, TemplateGroup *templateGroup, TemplateGroup *oldTemplateGroup)
+{
+    Q_UNUSED(index)
+    Q_UNUSED(templateGroup)
+    delete oldTemplateGroup;
+    refresh();
+}
+
 void BrokenLinksModel::connectToTileset(const SharedTileset &tileset)
 {
     auto tilesetDocument = DocumentManager::instance()->findTilesetDocument(tileset);
@@ -420,6 +464,8 @@ void BrokenLinksWidget::selectionChanged()
             else
                 mLocateButton->setText(tr("Open Tileset..."));
             break;
+        case Tiled::Internal::TemplateGroupReference:
+            mLocateButton->setText(tr("Locate File..."));
         }
     }
 }
@@ -444,6 +490,9 @@ void BrokenLinksWidget::tryFixLinks(const QVector<BrokenLink> &links)
                 return;
             }
         }
+        if (link.type == TemplateGroupReference) {
+            return;
+        }
     }
 
     // todo: fix caption after string freeze (and the text on the button)
@@ -563,6 +612,39 @@ void BrokenLinksWidget::tryFixLink(const BrokenLink &link)
 
         prefs->setLastPath(Preferences::ExternalTileset,
                            QFileInfo(fileName).path());
+    } else if (link.type == TemplateGroupReference) {
+        QString filter = TtxTemplateGroupFormat::instance()->nameFilter();
+
+        Preferences *prefs = Preferences::instance();
+        QString start = prefs->lastPath(Preferences::TemplateDocumentsFile);
+
+        QString fileName = QFileDialog::getOpenFileName(this, tr("Locate Template Group"),
+                                                        start,
+                                                        filter);
+
+        if (fileName.isEmpty())
+            return;
+
+        TemplateGroup *templateGroup = TemplateManager::instance()->findTemplateGroup(fileName);
+
+        QString error;
+
+        if (!templateGroup || !templateGroup->loaded()) {
+            templateGroup = Tiled::readTemplateGroup(fileName, &error);
+
+            if (!templateGroup) {
+                QMessageBox::critical(window(), tr("Error Reading Template Group"), error);
+                return;
+            }
+
+            auto groupDocument = new TemplateGroupDocument(templateGroup, fileName);
+            ObjectTemplateModel::instance()->addDocument(groupDocument);
+        }
+
+        MapDocument *mapDocument = static_cast<MapDocument*>(document);
+        int index = mapDocument->map()->templateGroups().indexOf(link._templateGroup);
+        if (index != -1)
+            mapDocument->replaceTemplateGroup(index, templateGroup);
     }
 }
 

src/tiled/brokenlinks.h

@@ -36,6 +36,7 @@ namespace Tiled {
 
 class Tile;
 class Tileset;
+class TemplateGroup;
 
 namespace Internal {
 
@@ -46,6 +47,7 @@ enum BrokenLinkType {
     MapTilesetReference,
     TilesetTileImageSource,
     TilesetImageSource,
+    TemplateGroupReference,
 };
 
 struct BrokenLink {
@@ -54,10 +56,12 @@ struct BrokenLink {
     union {
         Tileset *_tileset;
         Tile *_tile;
+        TemplateGroup *_templateGroup;
     };
 
     QString filePath() const;
     Tileset *tileset() const;
+    TemplateGroup *templateGroup() const;
 };
 
 
@@ -92,6 +96,7 @@ private slots:
     void tilesetAdded(int index, Tileset *tileset);
     void tilesetRemoved(Tileset *tileset);
     void tilesetReplaced(int index, Tileset *newTileset, Tileset *oldTileset);
+    void templateGroupReplaced(int index, TemplateGroup *templateGroup, TemplateGroup *oldTemplateGroup);
 
 private:
     void connectToTileset(const SharedTileset &tileset);

src/tiled/mapdocument.cpp

@@ -54,14 +54,15 @@
 #include "resizetilelayer.h"
 #include "rotatemapobject.h"
 #include "staggeredrenderer.h"
+#include "templategroup.h"
+#include "templategroupdocument.h"
 #include "terrain.h"
 #include "terrainmodel.h"
 #include "tile.h"
 #include "tilelayer.h"
 #include "tilesetdocument.h"
 #include "tilesetmanager.h"
 #include "tmxmapformat.h"
-#include "templategroupdocument.h"
 
 #include <QFileInfo>
 #include <QRect>
@@ -670,6 +671,17 @@ SharedTileset MapDocument::replaceTileset(int index, const SharedTileset &tilese
     return oldTileset;
 }
 
+void MapDocument::replaceTemplateGroup(int index, TemplateGroup *templateGroup)
+{
+    TemplateGroup *oldTemplateGroup = mMap->templateGroups().at(index);
+    auto changedObjects = mMap->replaceTemplateGroup(oldTemplateGroup, templateGroup);
+
+    // Update the objects in the map scene
+    emit(objectsChanged(changedObjects));
+
+    emit templateGroupReplaced(index, templateGroup, oldTemplateGroup);
+}
+
 void MapDocument::setSelectedArea(const QRegion &selection)
 {
     if (mSelectedArea != selection) {

src/tiled/mapdocument.h

@@ -44,6 +44,7 @@ class MapObject;
 class MapRenderer;
 class MapFormat;
 class Terrain;
+class TemplateGroup;
 class Tile;
 
 namespace Internal {
@@ -150,6 +151,8 @@ class MapDocument : public Document
     void removeTilesetAt(int index);
     SharedTileset replaceTileset(int index, const SharedTileset &tileset);
 
+    void replaceTemplateGroup(int index, TemplateGroup *templateGroup);
+
     void duplicateObjects(const QList<MapObject*> &objects);
     void removeObjects(const QList<MapObject*> &objects);
     void moveObjectsToGroup(const QList<MapObject*> &objects,
@@ -273,6 +276,7 @@ class MapDocument : public Document
     void tilesetAboutToBeRemoved(int index);
     void tilesetRemoved(Tileset *tileset);
     void tilesetReplaced(int index, Tileset *tileset, Tileset *oldTileset);
+    void templateGroupReplaced(int index, TemplateGroup *templateGroup, TemplateGroup *oldTemplateGroup);
 
     void objectsAdded(const QList<MapObject*> &objects);
     void objectsInserted(ObjectGroup *objectGroup, int first, int last);

src/tiled/objecttemplatemodel.cpp

@@ -22,6 +22,7 @@
 #include "objecttemplatemodel.h"
 
 #include "templategroup.h"
+#include "templatemanager.h"
 #include "tmxmapformat.h"
 
 #include <QFileInfo>
@@ -52,6 +53,12 @@ void ObjectTemplateModel::setTemplateDocuments(const TemplateDocuments &template
     qDeleteAll(mTemplateDocuments);
     mTemplateDocuments = templateDocuments;
     endResetModel();
+
+    TemplateGroups templateGroups;
+    for (auto document : templateDocuments)
+        templateGroups.append(document->templateGroup());
+
+    TemplateManager::instance()->setTemplateGroups(templateGroups);
 }
 
 ObjectTemplateModel::ObjectTemplateModel(QObject *parent):
@@ -141,6 +148,19 @@ bool ObjectTemplateModel::addNewDocument(TemplateGroupDocument *document)
     mTemplateDocuments.append(document);
     endInsertRows();
 
+    TemplateManager::instance()->addTemplateGroup(document->templateGroup());
+
+    return true;
+}
+
+bool ObjectTemplateModel::addDocument(TemplateGroupDocument *document)
+{
+    beginInsertRows(QModelIndex(), mTemplateDocuments.size(), mTemplateDocuments.size());
+    mTemplateDocuments.append(document);
+    endInsertRows();
+
+    TemplateManager::instance()->addTemplateGroup(document->templateGroup());
+
     return true;
 }
 

src/tiled/templatesdock.cpp

@@ -82,15 +82,6 @@ TemplatesDock::TemplatesDock(QWidget *parent):
             mTemplatesView, &TemplatesView::applyTemplateGroups);
     connect(mTemplatesView->model(), &ObjectTemplateModel::rowsInserted,
             mTemplatesView, &TemplatesView::applyTemplateGroups);
-
-    auto manager = TemplateManager::instance();
-
-    TemplateGroups templateGroups;
-
-    for (auto document : templateDocuments)
-        templateGroups.append(document->templateGroup());
-
-    manager->setTemplateGroups(templateGroups);
 }
 
 TemplatesDock::~TemplatesDock()