Implemented reloading of worlds using an undo command

For consistency with the map and tileset reload, and because it is nice
to allow the user to undo the reload, in case it threw away changes they
did not want to lose.

src/tiled/editableworld.cpp

@@ -21,6 +21,7 @@
 
 #include "editableworld.h"
 
+#include "changeevents.h"
 #include "changeworld.h"
 #include "maprenderer.h"
 #include "scriptmanager.h"
@@ -144,6 +145,20 @@ QSharedPointer<Document> EditableWorld::createDocument()
     return nullptr;
 }
 
+void EditableWorld::documentChanged(const ChangeEvent &event)
+{
+    switch (event.type) {
+    case ChangeEvent::DocumentAboutToReload:
+        setObject(nullptr);
+        break;
+    case ChangeEvent::DocumentReloaded:
+        setObject(worldDocument()->world());
+        break;
+    default:
+        break;
+    }
+}
+
 } // namespace Tiled
 
 #include "moc_editableworld.cpp"

src/tiled/editableworld.h

@@ -61,6 +61,9 @@ class EditableWorld final : public EditableAsset
     Q_INVOKABLE void removeMap(EditableMap *map);
 
     QSharedPointer<Document> createDocument() override;
+
+private:
+    void documentChanged(const ChangeEvent &event);
 };
 
 inline World *EditableWorld::world() const

src/tiled/worlddocument.cpp

@@ -21,6 +21,7 @@
 
 #include "worlddocument.h"
 
+#include "changeevents.h"
 #include "editableworld.h"
 #include "worldmanager.h"
 
@@ -29,10 +30,30 @@
 
 namespace Tiled {
 
+class ReloadWorld : public QUndoCommand
+{
+public:
+    ReloadWorld(WorldDocument *worldDocument, std::unique_ptr<World> world)
+        : mWorldDocument(worldDocument)
+        , mWorld(std::move(world))
+    {
+        setText(QCoreApplication::translate("Undo Commands", "Reload World"));
+    }
+
+    void undo() override { mWorldDocument->swapWorld(mWorld); }
+    void redo() override { mWorldDocument->swapWorld(mWorld); }
+
+private:
+    WorldDocument *mWorldDocument;
+    std::unique_ptr<World> mWorld;
+};
+
+
 WorldDocument::WorldDocument(std::unique_ptr<World> world, QObject *parent)
     : Document(WorldDocumentType, world->fileName, parent)
     , mWorld(std::move(world))
 {
+    setCurrentObject(mWorld.get());
 }
 
 WorldDocument::~WorldDocument()
@@ -77,18 +98,17 @@ bool WorldDocument::reload(QString *error)
     if (!canReload())
         return false;
 
-    if (auto world = World::load(fileName(), error)) {
-        // todo: consider replacing the world using an undo command
-        mWorld->clearErrorsAndWarnings();
-        mWorld = std::move(world);
-        undoStack()->clear();
-        updateIsModified();
+    auto world = World::load(fileName(), error);
+    if (!world)
+        return false;
 
-        emit worldChanged();
-        return true;
-    }
+    undoStack()->push(new ReloadWorld(this, std::move(world)));
+    undoStack()->setClean();
 
-    return false;
+    mLastSaved = QFileInfo(fileName()).lastModified();
+    setChangedOnDisk(false);
+
+    return true;
 }
 
 WorldDocumentPtr WorldDocument::load(const QString &fileName, QString *error)
@@ -100,6 +120,22 @@ WorldDocumentPtr WorldDocument::load(const QString &fileName, QString *error)
     return WorldDocumentPtr::create(std::move(world));
 }
 
+void WorldDocument::swapWorld(std::unique_ptr<World> &other)
+{
+    setCurrentObject(nullptr);
+
+    emit changed(AboutToReloadEvent());
+
+    mWorld->clearErrorsAndWarnings();
+    mWorld.swap(other);
+    updateIsModified();
+
+    emit changed(ReloadEvent());
+
+    setCurrentObject(mWorld.get());
+    emit worldChanged();
+}
+
 std::unique_ptr<EditableAsset> WorldDocument::createEditable()
 {
     return std::make_unique<EditableWorld>(this, this);

src/tiled/worlddocument.h

@@ -69,6 +69,8 @@ class WorldDocument final : public Document
 
     World *world() const { return mWorld.get(); }
 
+    void swapWorld(std::unique_ptr<World> &other);
+
 signals:
     void worldChanged();