Fixed some issues related to template reloading

* Delay template reload by 500 ms, to avoid issues where the file that
  changed hasn't been fully written yet.

* Don't report error when reloading template, when the template file
  didn't load in the first place. This is currently often the case, when
  it was just a file that we tried to load as a template before.

* Make sure that when a template file changed, that we don't reload it
  when we we're the ones that saved it.

* Fixed the Template Editor to refresh its dummy object when the file
  was changed externally.

Closes mapeditor#2836

src/libtiled/objecttemplate.cpp

@@ -31,6 +31,8 @@
 
 #include "objecttemplateformat.h"
 
+#include <QFileInfo>
+
 namespace Tiled {
 
 ObjectTemplate::ObjectTemplate()
@@ -88,4 +90,18 @@ ObjectTemplateFormat *ObjectTemplate::format() const
     return mFormat;
 }
 
+bool ObjectTemplate::save()
+{
+    if (!mFormat)
+        return false;
+    if (mFileName.isEmpty())
+        return false;
+
+    const bool result = mFormat->write(this, mFileName);
+
+    mLastSaved = QFileInfo(mFileName).lastModified();
+
+    return result;
+}
+
 } // namespace Tiled

src/libtiled/objecttemplate.h

@@ -32,6 +32,7 @@
 #include "mapobject.h"
 #include "tileset.h"
 
+#include <QDateTime>
 #include <QPointer>
 
 #include <memory>
@@ -57,13 +58,17 @@ class TILEDSHARED_EXPORT ObjectTemplate : public Object
     void setFormat(ObjectTemplateFormat *format);
     ObjectTemplateFormat *format() const;
 
+    bool save();
+    QDateTime lastSaved() const;
+
     const SharedTileset &tileset() const;
 
 private:
     QString mFileName;
     QPointer<ObjectTemplateFormat> mFormat;
     std::unique_ptr<MapObject> mObject;
     SharedTileset mTileset;
+    QDateTime mLastSaved;
 };
 
 inline const MapObject *ObjectTemplate::object() const
@@ -75,6 +80,9 @@ inline const QString &ObjectTemplate::fileName() const
 inline void ObjectTemplate::setFileName(const QString &fileName)
 { mFileName = fileName; }
 
+inline QDateTime ObjectTemplate::lastSaved() const
+{ return mLastSaved; }
+
 inline const SharedTileset &ObjectTemplate::tileset() const
 { return mTileset; }
 

src/libtiled/templatemanager.cpp

@@ -28,6 +28,7 @@
 #include "logginginterface.h"
 
 #include <QFile>
+#include <QFileInfo>
 
 using namespace Tiled;
 
@@ -51,8 +52,8 @@ TemplateManager::TemplateManager(QObject *parent)
     : QObject(parent),
       mWatcher(new FileSystemWatcher(this))
 {
-    connect(mWatcher, &FileSystemWatcher::fileChanged,
-            this, &TemplateManager::fileChanged);
+    connect(mWatcher, &FileSystemWatcher::pathsChanged,
+            this, &TemplateManager::pathsChanged);
 }
 
 TemplateManager::~TemplateManager()
@@ -83,19 +84,26 @@ ObjectTemplate *TemplateManager::loadObjectTemplate(const QString &fileName, QSt
     return objectTemplate;
 }
 
-void TemplateManager::fileChanged(const QString &fileName)
+void TemplateManager::pathsChanged(const QStringList &paths)
 {
-    ObjectTemplate *objectTemplate = findObjectTemplate(fileName);
-
-    // Most likely the file was removed.
-    if (!objectTemplate)
-        return;
-
-    auto newTemplate = readObjectTemplate(fileName);
-    if (newTemplate) {
-        objectTemplate->setObject(newTemplate->object());
-        emit objectTemplateChanged(objectTemplate);
-    } else {
-        ERROR(tr("Unable to reload template file: %1").arg(fileName));
+    for (const QString &fileName : paths) {
+        ObjectTemplate *objectTemplate = findObjectTemplate(fileName);
+
+        // Most likely the file was removed.
+        if (!objectTemplate)
+            continue;
+
+        // Check whether we were the ones saving this file.
+        if (objectTemplate->lastSaved() == QFileInfo(fileName).lastModified())
+            continue;
+
+        auto newTemplate = readObjectTemplate(fileName);
+        if (newTemplate) {
+            objectTemplate->setObject(newTemplate->object());
+            objectTemplate->setFormat(newTemplate->format());
+            emit objectTemplateChanged(objectTemplate);
+        } else if (objectTemplate->object()) {  // only report error if it had loaded fine before
+            ERROR(tr("Unable to reload template file: %1").arg(fileName));
+        }
     }
 }

src/libtiled/templatemanager.h

@@ -58,7 +58,7 @@ class TILEDSHARED_EXPORT TemplateManager : public QObject
     TemplateManager(QObject *parent = nullptr);
     ~TemplateManager();
 
-    void fileChanged(const QString &fileName);
+    void pathsChanged(const QStringList &paths);
 
     QHash<QString, ObjectTemplate*> mObjectTemplates;
     FileSystemWatcher *mWatcher;

src/tiled/templatesdock.cpp

@@ -56,6 +56,7 @@ using namespace Tiled;
 // This references created dummy documents, to make sure they are shared if the
 // same template is open in the MapEditor and the TilesetEditor.
 QHash<ObjectTemplate*, QWeakPointer<MapDocument>> TemplatesDock::ourDummyDocuments;
+bool TemplatesDock::ourEmittingChanged;
 
 TemplatesDock::TemplatesDock(QWidget *parent)
     : QDockWidget(parent)
@@ -138,6 +139,9 @@ TemplatesDock::TemplatesDock(QWidget *parent)
     connect(mToolManager, &ToolManager::selectedToolChanged,
             mMapScene, &MapScene::setSelectedTool);
 
+    connect(TemplateManager::instance(), &TemplateManager::objectTemplateChanged,
+            this, &TemplatesDock::objectTemplateChanged);
+
     setFocusPolicy(Qt::ClickFocus);
     mMapView->setFocusProxy(this);
 }
@@ -213,20 +217,26 @@ void TemplatesDock::setTemplate(ObjectTemplate *objectTemplate)
         return;
 
     mObjectTemplate = objectTemplate;
+    refreshDummyObject();
+
+    emit currentTemplateChanged(mObjectTemplate);
+}
 
+void TemplatesDock::refreshDummyObject()
+{
     mMapScene->setSelectedTool(nullptr);
     MapDocumentPtr previousDocument = mDummyMapDocument;
 
-    mMapView->setEnabled(objectTemplate);
+    mMapView->setEnabled(mObjectTemplate);
 
-    if (objectTemplate && objectTemplate->object()) {
-        mDummyMapDocument = ourDummyDocuments.value(objectTemplate);
+    if (mObjectTemplate && mObjectTemplate->object()) {
+        mDummyMapDocument = ourDummyDocuments.value(mObjectTemplate);
 
         if (!mDummyMapDocument) {
             Map::Orientation orientation = Map::Orthogonal;
             std::unique_ptr<Map> map { new Map(orientation, 1, 1, 1, 1) };
 
-            MapObject *dummyObject = objectTemplate->object()->clone();
+            MapObject *dummyObject = mObjectTemplate->object()->clone();
             dummyObject->markAsTemplateBase();
 
             if (Tileset *tileset = dummyObject->cell().tileset()) {
@@ -245,7 +255,7 @@ void TemplatesDock::setTemplate(ObjectTemplate *objectTemplate)
             mDummyMapDocument->setAllowHidingObjects(false);
             mDummyMapDocument->switchCurrentLayer(objectGroup);
 
-            ourDummyDocuments.insert(objectTemplate, mDummyMapDocument);
+            ourDummyDocuments.insert(mObjectTemplate, mDummyMapDocument);
         }
 
         mDummyMapDocument->setCurrentObject(dummyObject());
@@ -269,8 +279,6 @@ void TemplatesDock::setTemplate(ObjectTemplate *objectTemplate)
 
     if (previousDocument)
         previousDocument->undoStack()->disconnect(this);
-
-    emit currentTemplateChanged(mObjectTemplate);
 }
 
 void TemplatesDock::checkTileset()
@@ -308,6 +316,18 @@ void TemplatesDock::checkTileset()
     }
 }
 
+void TemplatesDock::objectTemplateChanged(ObjectTemplate *objectTemplate)
+{
+    if (ourEmittingChanged)
+        return;
+
+    // Apparently the template was changed externally
+    ourDummyDocuments.remove(objectTemplate);
+
+    if (mObjectTemplate == objectTemplate)
+        refreshDummyObject();
+}
+
 void TemplatesDock::undo()
 {
     if (mDummyMapDocument) {
@@ -329,15 +349,16 @@ void TemplatesDock::applyChanges()
     mObjectTemplate->setObject(dummyObject());
 
     // Write out the template file
-    mObjectTemplate->format()->write(mObjectTemplate,
-                                     mObjectTemplate->fileName());
+    mObjectTemplate->save();
 
     mUndoAction->setEnabled(mDummyMapDocument->undoStack()->canUndo());
     mRedoAction->setEnabled(mDummyMapDocument->undoStack()->canRedo());
 
     checkTileset();
 
+    ourEmittingChanged = true;
     emit TemplateManager::instance()->objectTemplateChanged(mObjectTemplate);
+    ourEmittingChanged = false;
 }
 
 void TemplatesDock::focusInEvent(QFocusEvent *event)

src/tiled/templatesdock.h

@@ -72,8 +72,11 @@ public slots:
 
 private:
     void setTemplate(ObjectTemplate *objectTemplate);
+    void refreshDummyObject();
     void checkTileset();
 
+    void objectTemplateChanged(ObjectTemplate *objectTemplate);
+
     void undo();
     void redo();
     void applyChanges();
@@ -96,6 +99,7 @@ public slots:
     ToolManager *mToolManager;
 
     static QHash<ObjectTemplate*, QWeakPointer<MapDocument>> ourDummyDocuments;
+    static bool ourEmittingChanged;
 };
 
 inline void TemplatesDock::setPropertiesDock(PropertiesDock *propertiesDock)