Save the last export target and format in the map/tileset file

Saving this information in the file allows the export to be repeated
without prompt even after restarting Tiled. This is supported for both
TMX and JSON formats.

At the same time, the export format is now remembered by its short name
rather than a smart pointer, which makes sure that when the right format
can still be picked after loading/unloading a plugin or changing an
export script.

The fallback to TMX or TSX formats has also been removed, since it would
only cause problems to silently export in these formats when a
previously used format can't be found.

The export target is stored with a relative path, so that the setting
may be generally useful also when the file is shared.

Issue #1610

src/libtiled/fileformat.h

@@ -138,4 +138,12 @@ class FormatHelper
     QMap<QString, Format*> mFormatByNameFilter;
 };
 
+template<typename Format>
+Format *findFileFormat(const QString &shortName, FileFormat::Capabilities capabilities = FileFormat::Write)
+{
+    return PluginManager::find<Format>([&](Format *format) {
+        return format->hasCapabilities(capabilities) && format->shortName() == shortName;
+    });
+}
+
 } // namespace Tiled

src/libtiled/logginginterface.cpp

@@ -134,22 +134,22 @@ std::function<void (const SelectTile &)> SelectTile::activated;
 
 
 JumpToTile::JumpToTile(const Map *map, QPoint tilePos, const Layer *layer)
-    : mapFile(map->fileName())
+    : mapFile(map->fileName)
     , tilePos(tilePos)
     , layerId(layer ? layer->id() : -1)
 {
     Q_ASSERT(!mapFile.isEmpty());
 }
 
 JumpToObject::JumpToObject(const MapObject *object)
-    : mapFile(object->objectGroup()->map()->fileName())
+    : mapFile(object->objectGroup()->map()->fileName)
     , objectId(object->id())
 {
     Q_ASSERT(!mapFile.isEmpty());
 }
 
 SelectLayer::SelectLayer(const Layer *layer)
-    : mapFile(layer->map()->fileName())
+    : mapFile(layer->map()->fileName)
     , layerId(layer->id())
 {
     Q_ASSERT(!mapFile.isEmpty());

src/libtiled/map.cpp

@@ -334,7 +334,9 @@ bool Map::isTilesetUsed(const Tileset *tileset) const
 Map *Map::clone() const
 {
     Map *o = new Map(mOrientation, mWidth, mHeight, mTileWidth, mTileHeight, mInfinite);
-    o->mFileName = mFileName;
+    o->fileName = fileName;
+    o->exportFileName = exportFileName;
+    o->exportFormat = exportFormat;
     o->mRenderOrder = mRenderOrder;
     o->mHexSideLength = mHexSideLength;
     o->mStaggerAxis = mStaggerAxis;

src/libtiled/map.h

@@ -80,6 +80,10 @@ class TILEDSHARED_EXPORT Map : public Object
     };
 
 public:
+    QString fileName;
+    QString exportFileName;
+    QString exportFormat;
+
     /**
      * The orientation of the map determines how it should be rendered. An
      * Orthogonal map is using rectangular tiles that are aligned on a
@@ -158,9 +162,6 @@ class TILEDSHARED_EXPORT Map : public Object
 
     ~Map();
 
-    QString fileName() const { return mFileName; }
-    void setFileName(const QString &fileName) { mFileName = fileName; }
-
     /**
      * Returns the orientation of the map.
      */
@@ -483,7 +484,6 @@ class TILEDSHARED_EXPORT Map : public Object
 
     void recomputeDrawMargins() const;
 
-    QString mFileName;
     Orientation mOrientation;
     RenderOrder mRenderOrder;
     int mCompressionLevel;

src/libtiled/mapformat.cpp

@@ -47,7 +47,7 @@ std::unique_ptr<Map> readMap(const QString &fileName, QString *error)
         }
 
         if (map)
-            map->setFileName(fileName);
+            map->fileName = fileName;
 
         return map;
     }
@@ -64,7 +64,7 @@ std::unique_ptr<Map> readMap(const QString &fileName, QString *error)
     }
 
     if (map)
-        map->setFileName(fileName);
+        map->fileName = fileName;
 
     return map;
 }

src/libtiled/mapreader.cpp

@@ -84,8 +84,10 @@ class MapReaderPrivate
     void readUnknownElement();
 
     std::unique_ptr<Map> readMap();
+    void readMapEditorSettings(Map &map);
 
     SharedTileset readTileset();
+    void readTilesetEditorSettings(Tileset &tileset);
     void readTilesetTile(Tileset &tileset);
     void readTilesetGrid(Tileset &tileset);
     void readTilesetImage(Tileset &tileset);
@@ -293,7 +295,9 @@ std::unique_ptr<Map> MapReaderPrivate::readMap()
         mMap->setBackgroundColor(QColor(bgColorString.toString()));
 
     while (xml.readNextStartElement()) {
-        if (std::unique_ptr<Layer> layer = tryReadLayer())
+        if (xml.name() == QLatin1String("editorsettings"))
+            readMapEditorSettings(*mMap);
+        else if (std::unique_ptr<Layer> layer = tryReadLayer())
             mMap->addLayer(std::move(layer));
         else if (xml.name() == QLatin1String("properties"))
             mMap->mergeProperties(readProperties());
@@ -334,6 +338,24 @@ std::unique_ptr<Map> MapReaderPrivate::readMap()
     return std::move(mMap);
 }
 
+void MapReaderPrivate::readMapEditorSettings(Map &map)
+{
+    Q_ASSERT(xml.isStartElement() && xml.name() == QLatin1String("editorsettings"));
+
+    while (xml.readNextStartElement()) {
+        if (xml.name() == QLatin1String("export")) {
+            const QXmlStreamAttributes atts = xml.attributes();
+
+            map.exportFileName = QDir::cleanPath(mPath.filePath(atts.value(QLatin1String("target")).toString()));
+            map.exportFormat = atts.value(QLatin1String("format")).toString();
+
+            xml.skipCurrentElement();
+        } else {
+            readUnknownElement();
+        }
+    }
+}
+
 SharedTileset MapReaderPrivate::readTileset()
 {
     Q_ASSERT(xml.isStartElement() && xml.name() == QLatin1String("tileset"));
@@ -368,7 +390,9 @@ SharedTileset MapReaderPrivate::readTileset()
                 tileset->setBackgroundColor(QColor(bgColorString.toString()));
 
             while (xml.readNextStartElement()) {
-                if (xml.name() == QLatin1String("tile")) {
+                if (xml.name() == QLatin1String("editorsettings")) {
+                    readTilesetEditorSettings(*tileset);
+                } else if (xml.name() == QLatin1String("tile")) {
                     readTilesetTile(*tileset);
                 } else if (xml.name() == QLatin1String("tileoffset")) {
                     const QXmlStreamAttributes oa = xml.attributes();
@@ -419,6 +443,24 @@ SharedTileset MapReaderPrivate::readTileset()
     return tileset;
 }
 
+void MapReaderPrivate::readTilesetEditorSettings(Tileset &tileset)
+{
+    Q_ASSERT(xml.isStartElement() && xml.name() == QLatin1String("editorsettings"));
+
+    while (xml.readNextStartElement()) {
+        if (xml.name() == QLatin1String("export")) {
+            const QXmlStreamAttributes atts = xml.attributes();
+
+            tileset.exportFileName = QDir::cleanPath(mPath.filePath(atts.value(QLatin1String("target")).toString()));
+            tileset.exportFormat = atts.value(QLatin1String("format")).toString();
+
+            xml.skipCurrentElement();
+        } else {
+            readUnknownElement();
+        }
+    }
+}
+
 void MapReaderPrivate::readTilesetTile(Tileset &tileset)
 {
     Q_ASSERT(xml.isStartElement() && xml.name() == QLatin1String("tile"));

src/libtiled/maptovariantconverter.cpp

@@ -47,7 +47,7 @@ static QString colorToString(const QColor &color)
 
 QVariant MapToVariantConverter::toVariant(const Map &map, const QDir &mapDir)
 {
-    mMapDir = mapDir;
+    mDir = mapDir;
     mGidMapper.clear();
 
     QVariantMap mapVariant;
@@ -66,6 +66,17 @@ QVariant MapToVariantConverter::toVariant(const Map &map, const QDir &mapDir)
     mapVariant[QLatin1String("nextobjectid")] = map.nextObjectId();
     mapVariant[QLatin1String("compressionlevel")] = map.compressionLevel();
 
+    if (!map.exportFileName.isEmpty() || !map.exportFormat.isEmpty()) {
+        QVariantMap editorSettingsVariant;
+
+        QVariantMap exportVariant;
+        exportVariant[QLatin1String("target")] = mDir.relativeFilePath(map.exportFileName);
+        exportVariant[QLatin1String("format")] = map.exportFormat;
+        editorSettingsVariant[QLatin1String("export")] = exportVariant;
+
+        mapVariant[QLatin1String("editorsettings")] = editorSettingsVariant;
+    }
+
     addProperties(mapVariant, map.properties());
 
     if (map.orientation() == Map::Hexagonal) {
@@ -102,14 +113,14 @@ QVariant MapToVariantConverter::toVariant(const Map &map, const QDir &mapDir)
 QVariant MapToVariantConverter::toVariant(const Tileset &tileset,
                                           const QDir &directory)
 {
-    mMapDir = directory;
+    mDir = directory;
     return toVariant(tileset, 0);
 }
 
 QVariant MapToVariantConverter::toVariant(const ObjectTemplate &objectTemplate,
                                           const QDir &directory)
 {
-    mMapDir = directory;
+    mDir = directory;
     QVariantMap objectTemplateVariant;
 
     objectTemplateVariant[QLatin1String("type")] = QLatin1String("template");
@@ -136,7 +147,7 @@ QVariant MapToVariantConverter::toVariant(const Tileset &tileset,
 
         const QString &fileName = tileset.fileName();
         if (!fileName.isEmpty()) {
-            QString source = mMapDir.relativeFilePath(fileName);
+            QString source = mDir.relativeFilePath(fileName);
             tilesetVariant[QLatin1String("source")] = source;
 
             // Tileset is external, so no need to write any of the stuff below
@@ -159,6 +170,20 @@ QVariant MapToVariantConverter::toVariant(const Tileset &tileset,
     tilesetVariant[QLatin1String("tilecount")] = tileset.tileCount();
     tilesetVariant[QLatin1String("columns")] = tileset.columnCount();
 
+    // Write editor settings when saving external tilesets
+    if (firstGid == 0) {
+        if (!tileset.exportFileName.isEmpty() || !tileset.exportFormat.isEmpty()) {
+            QVariantMap editorSettingsVariant;
+
+            QVariantMap exportVariant;
+            exportVariant[QLatin1String("target")] = mDir.relativeFilePath(tileset.exportFileName);
+            exportVariant[QLatin1String("format")] = tileset.exportFormat;
+            editorSettingsVariant[QLatin1String("export")] = exportVariant;
+
+            tilesetVariant[QLatin1String("editorsettings")] = editorSettingsVariant;
+        }
+    }
+
     const QColor bgColor = tileset.backgroundColor();
     if (bgColor.isValid())
         tilesetVariant[QLatin1String("backgroundcolor")] = colorToString(bgColor);
@@ -184,7 +209,7 @@ QVariant MapToVariantConverter::toVariant(const Tileset &tileset,
     // Write the image element
     const QUrl &imageSource = tileset.imageSource();
     if (!imageSource.isEmpty()) {
-        const QString rel = toFileReference(imageSource, mMapDir);
+        const QString rel = toFileReference(imageSource, mDir);
 
         tilesetVariant[QLatin1String("image")] = rel;
 
@@ -231,7 +256,7 @@ QVariant MapToVariantConverter::toVariant(const Tileset &tileset,
         if (tile->probability() != 1.0)
             tileVariant[QLatin1String("probability")] = tile->probability();
         if (!tile->imageSource().isEmpty()) {
-            const QString rel = toFileReference(tile->imageSource(), mMapDir);
+            const QString rel = toFileReference(tile->imageSource(), mDir);
             tileVariant[QLatin1String("image")] = rel;
 
             const QSize tileSize = tile->size();
@@ -308,7 +333,7 @@ QVariant MapToVariantConverter::toVariant(const Properties &properties) const
     Properties::const_iterator it = properties.constBegin();
     Properties::const_iterator it_end = properties.constEnd();
     for (; it != it_end; ++it) {
-        const QVariant value = toExportValue(it.value(), mMapDir);
+        const QVariant value = toExportValue(it.value(), mDir);
         variantMap[it.key()] = value;
     }
 
@@ -508,7 +533,7 @@ QVariant MapToVariantConverter::toVariant(const MapObject &object) const
     addProperties(objectVariant, object.properties());
 
     if (const ObjectTemplate *objectTemplate = object.objectTemplate()) {
-        QString relativeFileName = mMapDir.relativeFilePath(objectTemplate->fileName());
+        QString relativeFileName = mDir.relativeFilePath(objectTemplate->fileName());
         objectVariant[QLatin1String("template")] = relativeFileName;
     }
 
@@ -646,7 +671,7 @@ QVariant MapToVariantConverter::toVariant(const ImageLayer &imageLayer) const
 
     addLayerAttributes(imageLayerVariant, imageLayer);
 
-    const QString rel = toFileReference(imageLayer.imageSource(), mMapDir);
+    const QString rel = toFileReference(imageLayer.imageSource(), mDir);
     imageLayerVariant[QLatin1String("image")] = rel;
 
     const QColor transColor = imageLayer.transparentColor();
@@ -737,7 +762,7 @@ void MapToVariantConverter::addProperties(QVariantMap &variantMap,
         Properties::const_iterator it_end = properties.constEnd();
         for (; it != it_end; ++it) {
             int type = it.value().userType();
-            const QVariant value = toExportValue(it.value(), mMapDir);
+            const QVariant value = toExportValue(it.value(), mDir);
 
             propertiesMap[it.key()] = value;
             propertyTypesMap[it.key()] = typeToName(type);
@@ -752,7 +777,7 @@ void MapToVariantConverter::addProperties(QVariantMap &variantMap,
         Properties::const_iterator it_end = properties.constEnd();
         for (; it != it_end; ++it) {
             int type = it.value().userType();
-            const QVariant value = toExportValue(it.value(), mMapDir);
+            const QVariant value = toExportValue(it.value(), mDir);
 
             QVariantMap propertyVariantMap;
             propertyVariantMap[QLatin1String("name")] = it.key();

src/libtiled/maptovariantconverter.h

@@ -88,7 +88,7 @@ class TILEDSHARED_EXPORT MapToVariantConverter
                        const Properties &properties) const;
 
     int mVersion;
-    QDir mMapDir;
+    QDir mDir;
     GidMapper mGidMapper;
 };