Scripting: Added tiled.load to load assets without opening an editor

src/libtiled/object.h

@@ -165,6 +165,8 @@ class TILEDSHARED_EXPORT Object
     static void setPropertyTypes(const SharedPropertyTypes &propertyTypes);
     static const PropertyTypes &propertyTypes();
 
+    QObject *editable() const { return mEditable; }
+
 private:
     const TypeId mTypeId;
     QString mClassName;

src/tiled/document.cpp

@@ -64,19 +64,6 @@ Document::~Document()
         manager->unregisterDocument(this);
 }
 
-EditableAsset *Document::editable()
-{
-    if (!mEditable)
-        mEditable = createEditable();
-    return mEditable.get();
-}
-
-void Document::setEditable(std::unique_ptr<EditableAsset> editable)
-{
-    mEditable = std::move(editable);
-    mEditable->setDocument(this);
-}
-
 void Document::setFileName(const QString &fileName)
 {
     if (mFileName == fileName)

src/tiled/document.h

@@ -28,8 +28,6 @@
 #include <QString>
 #include <QVariant>
 
-#include <memory>
-
 class QUndoStack;
 
 namespace Tiled {
@@ -97,8 +95,7 @@ class Document : public QObject,
     QUndoStack *undoStack() const;
     bool isModified() const;
 
-    EditableAsset *editable();
-    void setEditable(std::unique_ptr<EditableAsset> editable);
+    virtual EditableAsset *editable() = 0;
 
     Object *currentObject() const { return mCurrentObject; }
     void setCurrentObject(Object *object);
@@ -154,7 +151,6 @@ class Document : public QObject,
     void ignoreBrokenLinksChanged(bool ignoreBrokenLinks);
 
 protected:
-    virtual std::unique_ptr<EditableAsset> createEditable() = 0;
     virtual bool isModifiedImpl() const;
 
     void updateIsModified();
@@ -168,8 +164,6 @@ class Document : public QObject,
     Object *mCurrentObject = nullptr;   /**< Current properties object. */
     Document *mCurrentObjectDocument = nullptr;
 
-    std::unique_ptr<EditableAsset> mEditable;
-
 private:
     void currentObjectDocumentChanged(const ChangeEvent &change);
     void currentObjectDocumentDestroyed();

src/tiled/editableasset.cpp

@@ -33,6 +33,13 @@ EditableAsset::EditableAsset(Object *object, QObject *parent)
 {
 }
 
+EditableAsset::~EditableAsset()
+{
+    // Prevent owned object from trying to delete us again
+    if (mDocument)
+        setObject(nullptr);
+}
+
 QString EditableAsset::fileName() const
 {
     if (document())
@@ -134,7 +141,7 @@ void EditableAsset::setDocument(Document *document)
                 this, &EditableAsset::modifiedChanged);
     }
 
-    mDocument = document;
+    mDocument = document->sharedFromThis();
 }
 
 } // namespace Tiled

src/tiled/editableasset.h

@@ -21,6 +21,7 @@
 #pragma once
 
 #include "editableobject.h"
+#include "document.h"
 
 #include <QJSValue>
 #include <QSharedPointer>
@@ -58,6 +59,7 @@ class EditableAsset : public EditableObject
 
 public:
     EditableAsset(Object *object, QObject *parent = nullptr);
+    ~EditableAsset() override;
 
     QString fileName() const;
     bool isReadOnly() const override = 0;
@@ -92,15 +94,13 @@ public slots:
     virtual void setDocument(Document *document);
 
 private:
-    friend class Document;
-
-    Document *mDocument = nullptr;
+    DocumentPtr mDocument;
 };
 
 
 inline Document *EditableAsset::document() const
 {
-    return mDocument;
+    return mDocument.get();
 }
 
 } // namespace Tiled

src/tiled/editablemap.cpp

@@ -49,14 +49,12 @@
 namespace Tiled {
 
 EditableMap::EditableMap(QObject *parent)
-    : EditableAsset(new Map(), parent)
+    : EditableMap(std::make_unique<Map>(), parent)
 {
-    mDetachedMap.reset(map());
 }
 
 EditableMap::EditableMap(MapDocument *mapDocument, QObject *parent)
     : EditableAsset(mapDocument->map(), parent)
-    , mSelectedArea(new EditableSelectedArea(mapDocument, this))
 {
     setDocument(mapDocument);
 }
@@ -661,15 +659,26 @@ void EditableMap::setSelectedObjects(const QList<QObject *> &objects)
 QSharedPointer<Document> EditableMap::createDocument()
 {
     Q_ASSERT(mDetachedMap);
+    Q_ASSERT(!document());
 
     auto document = MapDocumentPtr::create(std::move(mDetachedMap));
-    document->setEditable(std::unique_ptr<EditableAsset>(this));
+    setDocument(document.data());
 
-    mSelectedArea = new EditableSelectedArea(document.data(), this);
+    return document;
+}
+
+EditableMap *EditableMap::get(MapDocument *mapDocument)
+{
+    if (!mapDocument)
+        return nullptr;
 
-    moveOwnershipToCpp();
+    auto editable = EditableMap::find(mapDocument->map());
+    if (editable)
+        return editable;
 
-    return document;
+    editable = new EditableMap(mapDocument);
+    // editable->moveOwnershipToCpp();
+    return editable;
 }
 
 void EditableMap::setDocument(Document *document)
@@ -682,6 +691,8 @@ void EditableMap::setDocument(Document *document)
     EditableAsset::setDocument(document);
 
     if (auto doc = mapDocument()) {
+        mSelectedArea = new EditableSelectedArea(mapDocument(), this);
+
         connect(doc, &Document::fileNameChanged, this, &EditableAsset::fileNameChanged);
         connect(doc, &Document::changed, this, &EditableMap::documentChanged);
         connect(doc, &MapDocument::layerAdded, this, &EditableMap::attachLayer);
@@ -692,6 +703,8 @@ void EditableMap::setDocument(Document *document)
         connect(doc, &MapDocument::selectedObjectsChanged, this, &EditableMap::selectedObjectsChanged);
 
         connect(doc, &MapDocument::regionEdited, this, &EditableMap::onRegionEdited);
+    } else {
+        delete mSelectedArea;
     }
 }
 

src/tiled/editablemap.h

@@ -202,6 +202,9 @@ class EditableMap final : public EditableAsset
 
     QSharedPointer<Document> createDocument() override;
 
+    static EditableMap *find(Map *map);
+    static EditableMap *get(MapDocument *mapDocument);
+
 signals:
     void currentLayerChanged();
     void selectedLayersChanged();
@@ -383,4 +386,9 @@ inline MapDocument *EditableMap::mapDocument() const
     return static_cast<MapDocument*>(document());
 }
 
+inline EditableMap *EditableMap::find(Map *map)
+{
+    return static_cast<EditableMap*>(EditableObject::find(map));
+}
+
 } // namespace Tiled

src/tiled/editableobject.h

@@ -169,7 +169,7 @@ inline void EditableObject::setAsset(EditableAsset *asset)
 
 inline EditableObject *EditableObject::find(Object *object)
 {
-    return object ? static_cast<EditableObject*>(object->mEditable.data())
+    return object ? static_cast<EditableObject*>(object->editable())
                   : nullptr;
 }
 

src/tiled/editableproject.cpp

@@ -63,6 +63,18 @@ QSharedPointer<Document> EditableProject::createDocument()
     return nullptr;
 }
 
+EditableProject *EditableProject::get(ProjectDocument *projectDocument)
+{
+    if (!projectDocument)
+        return nullptr;
+
+    auto editable = find(&projectDocument->project());
+    if (editable)
+        return editable;
+
+    return new EditableProject(projectDocument);
+}
+
 } // namespace Tiled
 
 #include "moc_editableproject.cpp"

src/tiled/editableproject.h

@@ -53,11 +53,19 @@ class EditableProject final : public EditableAsset
     Project *project() const;
 
     QSharedPointer<Document> createDocument() override;
+
+    static EditableProject *find(Project *project);
+    static EditableProject *get(ProjectDocument *projectDocument);
 };
 
 inline Project *EditableProject::project() const
 {
     return static_cast<Project*>(object());
 }
 
+inline EditableProject *EditableProject::find(Project *project)
+{
+    return static_cast<EditableProject*>(EditableObject::find(project));
+}
+
 } // namespace Tiled

src/tiled/editabletileset.cpp

@@ -226,13 +226,13 @@ EditableTileset *EditableTileset::get(Tileset *tileset)
     if (!tileset)
         return nullptr;
 
-    if (auto document = TilesetDocument::findDocumentForTileset(tileset->sharedFromThis()))
-        return document->editable();
-
     auto editable = EditableTileset::find(tileset);
     if (editable)
         return editable;
 
+    if (auto document = TilesetDocument::findDocumentForTileset(tileset->sharedFromThis()))
+        return new EditableTileset(document);
+
     editable = new EditableTileset(tileset);
     editable->moveOwnershipToCpp();
     return editable;
@@ -508,6 +508,18 @@ void EditableTileset::wangSetRemoved(WangSet *wangSet)
     detachWangSets({ wangSet });
 }
 
+void EditableTileset::setDocument(TilesetDocument *tilesetDocument)
+{
+    EditableAsset::setDocument(tilesetDocument);
+
+    connect(tilesetDocument, &Document::fileNameChanged, this, &EditableAsset::fileNameChanged);
+    connect(tilesetDocument, &TilesetDocument::tilesAdded, this, &EditableTileset::attachTiles);
+    connect(tilesetDocument, &TilesetDocument::tilesRemoved, this, &EditableTileset::detachTiles);
+    connect(tilesetDocument, &TilesetDocument::tileObjectGroupChanged, this, &EditableTileset::tileObjectGroupChanged);
+    connect(tilesetDocument->wangSetModel(), &TilesetWangSetModel::wangSetAdded, this, &EditableTileset::wangSetAdded);
+    connect(tilesetDocument->wangSetModel(), &TilesetWangSetModel::wangSetRemoved, this, &EditableTileset::wangSetRemoved);
+}
+
 } // namespace Tiled
 
 #include "moc_editabletileset.cpp"

src/tiled/editabletileset.h

@@ -203,6 +203,9 @@ public slots:
     void wangSetAdded(Tileset *tileset, int index);
     void wangSetRemoved(WangSet *wangSet);
 
+    friend class TilesetDocument;
+    void setDocument(TilesetDocument *tilesetDocument);
+
     bool mReadOnly = false;
     SharedTileset mTileset;
 };

src/tiled/editableworld.cpp

@@ -34,6 +34,7 @@ namespace Tiled {
 EditableWorld::EditableWorld(WorldDocument *worldDocument, QObject *parent)
     : EditableAsset(nullptr, parent)
 {
+    setDocument(worldDocument);
     setObject(worldDocument->world());
     setDocument(worldDocument);
 }
@@ -159,6 +160,18 @@ void EditableWorld::documentChanged(const ChangeEvent &event)
     }
 }
 
+EditableWorld *EditableWorld::get(WorldDocument *worldDocument)
+{
+    if (!worldDocument)
+        return nullptr;
+
+    auto editable = find(worldDocument->world());
+    if (editable)
+        return editable;
+
+    return new EditableWorld(worldDocument);
+}
+
 } // namespace Tiled
 
 #include "moc_editableworld.cpp"

src/tiled/editableworld.h

@@ -62,6 +62,9 @@ class EditableWorld final : public EditableAsset
 
     QSharedPointer<Document> createDocument() override;
 
+    static EditableWorld *find(World *world);
+    static EditableWorld *get(WorldDocument *worldDocument);
+
 private:
     void documentChanged(const ChangeEvent &event);
 };
@@ -71,6 +74,11 @@ inline World *EditableWorld::world() const
     return static_cast<World*>(object());
 }
 
+inline EditableWorld *EditableWorld::find(World *world)
+{
+    return static_cast<EditableWorld*>(EditableObject::find(world));
+}
+
 inline WorldDocument *EditableWorld::worldDocument() const
 {
     return static_cast<WorldDocument*>(document());

src/tiled/mapdocument.cpp

@@ -134,11 +134,6 @@ MapDocument::~MapDocument()
 {
     // Clear any previously found issues in this document
     IssuesModel::instance().removeIssuesWithContext(this);
-
-    // Needs to be deleted before the Map instance is deleted, because it may
-    // cause script values to detach from the map, in which case they'll need
-    // to be able to copy the data.
-    mEditable.reset();
 }
 
 bool MapDocument::save(const QString &fileName, QString *error)
@@ -291,9 +286,9 @@ QString MapDocument::displayName() const
     return displayName;
 }
 
-std::unique_ptr<EditableAsset> MapDocument::createEditable()
+EditableAsset *MapDocument::editable()
 {
-    return std::make_unique<EditableMap>(this, this);
+    return EditableMap::get(this);
 }
 
 /**

src/tiled/mapdocument.h

@@ -95,6 +95,8 @@ class TILED_EDITOR_EXPORT MapDocument final : public Document
     bool canReload() const override;
     bool reload(QString *error);
 
+    EditableAsset *editable() override;
+
     /**
      * Loads a map and returns a MapDocument instance on success. Returns null
      * on error and sets the \a error message.
@@ -382,7 +384,6 @@ public slots:
     void deselectObjects(const QList<MapObject*> &objects);
 
 protected:
-    std::unique_ptr<EditableAsset> createEditable() override;
 
 private:
     void onChanged(const ChangeEvent &change);