Add scripting for custom property types

src/libtiled/propertytype.cpp

@@ -524,6 +524,22 @@ void PropertyTypes::mergeObjectTypes(const QVector<ObjectType> &objectTypes)
     }
 }
 
+/**
+ * Returns the index of the type of the given name, or -1 if no such type is
+ * found.
+ */
+int PropertyTypes::findIndexByName(const QString &name) const
+{
+    if (name.isEmpty())
+        return -1;
+
+    for (int i = 0; i < mTypes.count(); i++)
+        if (mTypes[i]->name == name)
+            return i;
+
+    return -1;
+}
+
 /**
  * Returns a pointer to the PropertyType matching the given \a typeId, or
  * nullptr if it can't be found.

src/libtiled/propertytype.h

@@ -199,6 +199,8 @@ class TILEDSHARED_EXPORT PropertyTypes
     void merge(PropertyTypes types);
     void mergeObjectTypes(const QVector<ObjectType> &objectTypes);
 
+    int findIndexByName(const QString &name) const;
+
     const PropertyType *findTypeById(int typeId) const;
     const PropertyType *findTypeByName(const QString &name, int usageFlags = ClassPropertyType::AnyUsage) const;
     const PropertyType *findPropertyValueType(const QString &name) const;

src/tiled/editableproject.cpp

@@ -21,7 +21,9 @@
 
 #include "editableproject.h"
 
+#include "preferences.h"
 #include "projectdocument.h"
+#include "projectmanager.h"
 
 namespace Tiled {
 
@@ -31,6 +33,11 @@ EditableProject::EditableProject(ProjectDocument *projectDocument, QObject *pare
     setDocument(projectDocument);
 }
 
+bool EditableProject::isReadOnly() const
+{
+    return false;
+}
+
 QString EditableProject::extensionsPath() const
 {
     return project()->mExtensionsPath;
@@ -51,9 +58,12 @@ QStringList EditableProject::folders() const
     return project()->folders();
 }
 
-bool EditableProject::isReadOnly() const
+QVector<ScriptPropertyType *>EditableProject::propertyTypes() const
 {
-    return false;
+    QVector<ScriptPropertyType*> scriptTypes;
+    for (const PropertyType *type : *project()->propertyTypes())
+        scriptTypes.append(toScriptType(type));
+    return scriptTypes;
 }
 
 QSharedPointer<Document> EditableProject::createDocument()
@@ -63,6 +73,48 @@ QSharedPointer<Document> EditableProject::createDocument()
     return nullptr;
 }
 
+ScriptPropertyType *EditableProject::toScriptType(const PropertyType *type) const
+{
+    if (!type)
+        return nullptr;
+
+    switch (type->type) {
+    case PropertyType::PT_Invalid:
+        break;
+    case PropertyType::PT_Class:
+        return new ScriptClassPropertyType(static_cast<const ClassPropertyType *>(type));
+    case PropertyType::PT_Enum:
+        return new ScriptEnumPropertyType(static_cast<const EnumPropertyType *>(type));
+    }
+
+    return nullptr;
+}
+
+ScriptPropertyType *EditableProject::findTypeByName(const QString &name)
+{
+    const PropertyType *type = project()->propertyTypes()->findTypeByName(name);
+    return toScriptType(type);
+}
+
+void EditableProject::removeTypeByName(const QString &name)
+{
+    int index = project()->propertyTypes()->findIndexByName(name);
+    if (index < 0)
+        return
+
+    // TODO the type isn't actually being deleted even when index >= 0
+    project()->propertyTypes()->removeAt(index);
+    applyPropertyChanges();
+}
+
+void EditableProject::applyPropertyChanges()
+{
+    emit Preferences::instance()->propertyTypesChanged();
+
+    Project &project = ProjectManager::instance()->project();
+    project.save();
+}
+
 } // namespace Tiled
 
 #include "moc_editableproject.cpp"

src/tiled/editableproject.h

@@ -23,6 +23,7 @@
 
 #include "editableasset.h"
 #include "project.h"
+#include "scriptpropertytype.h"
 
 #include <QObject>
 
@@ -38,6 +39,7 @@ class EditableProject final : public EditableAsset
     Q_PROPERTY(QString automappingRulesFile READ automappingRulesFile)
     Q_PROPERTY(QString fileName READ fileName)
     Q_PROPERTY(QStringList folders READ folders)
+    Q_PROPERTY(QVector<ScriptPropertyType *> propertyTypes READ propertyTypes)
 
 public:
     EditableProject(ProjectDocument *projectDocument, QObject *parent = nullptr);
@@ -49,10 +51,18 @@ class EditableProject final : public EditableAsset
     QString automappingRulesFile() const;
     QString fileName() const;
     QStringList folders() const;
+    QVector<ScriptPropertyType*> propertyTypes() const;
 
     Project *project() const;
 
     QSharedPointer<Document> createDocument() override;
+
+    Q_INVOKABLE void removeTypeByName(const QString &name);
+    Q_INVOKABLE ScriptPropertyType *findTypeByName(const QString &name);
+
+private:
+    ScriptPropertyType *toScriptType(const PropertyType *type) const;
+    void applyPropertyChanges();
 };
 
 inline Project *EditableProject::project() const

src/tiled/libtilededitor.qbs

@@ -463,6 +463,8 @@ DynamicLibrary {
         "scriptmodule.h",
         "scriptprocess.cpp",
         "scriptprocess.h",
+        "scriptpropertytype.cpp",
+        "scriptpropertytype.h",
         "selectionrectangle.cpp",
         "selectionrectangle.h",
         "selectsametiletool.cpp",

src/tiled/scriptmanager.cpp

@@ -49,6 +49,7 @@
 #include "scriptimage.h"
 #include "scriptmodule.h"
 #include "scriptprocess.h"
+#include "scriptpropertytype.h"
 #include "tilecollisiondock.h"
 #include "tilelayer.h"
 #include "tilelayeredit.h"
@@ -414,6 +415,7 @@ void ScriptManager::initialize()
     registerFileInfo(engine);
     registerGeometry(engine);
     registerProcess(engine);
+    registerPropertyTypes(engine);
     loadExtensions();
 }
 

src/tiled/scriptpropertytype.cpp

@@ -0,0 +1,40 @@
+/*
+ * scriptpropertytype.cpp
+ * Copyright 2024, chris <[email protected]>
+ *
+ * This file is part of Tiled.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "scriptpropertytype.h"
+
+namespace Tiled {
+
+const QString &ScriptPropertyType::name() const
+{
+    return mType->name;
+}
+
+void registerPropertyTypes(QJSEngine *jsEngine)
+{
+    jsEngine->globalObject().setProperty(QStringLiteral("EnumPropertyType"),
+                                         jsEngine->newQMetaObject<ScriptEnumPropertyType>());
+    jsEngine->globalObject().setProperty(QStringLiteral("ClassPropertyType"),
+                                         jsEngine->newQMetaObject<ScriptClassPropertyType>());
+}
+
+} // namespace Tiled
+
+#include "moc_scriptpropertytype.cpp"

src/tiled/scriptpropertytype.h

@@ -0,0 +1,131 @@
+/*
+ * scriptpropertytype.h
+ * Copyright 2024, chris <[email protected]>
+ *
+ * This file is part of Tiled.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "propertytype.h"
+
+#include <QJSEngine>
+#include <QList>
+#include <QObject>
+
+namespace Tiled {
+/**
+ * Scripting engine wrapper for PropertyType
+ */
+class ScriptPropertyType : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QString name READ name)
+    Q_PROPERTY(bool isClass READ isClass)
+    Q_PROPERTY(bool isEnum READ isEnum)
+    Q_PROPERTY(QVariant defaultValue READ defaultValue)
+
+public:
+    ScriptPropertyType(const PropertyType *propertyType)
+        : mType(propertyType)
+    {}
+
+    const QString &name() const;
+    bool isClass() const { return mType->isClass(); }
+    bool isEnum() const { return mType->isEnum(); }
+    QVariant defaultValue() { return mType->defaultValue(); }
+
+private:
+    const PropertyType *mType;
+};
+
+class ScriptEnumPropertyType : public ScriptPropertyType
+{
+    Q_OBJECT
+
+    Q_PROPERTY(StorageType storageType READ storageType)
+    Q_PROPERTY(QStringList values READ values)
+
+public:
+    ScriptEnumPropertyType(const EnumPropertyType *propertyType)
+        : ScriptPropertyType(propertyType)
+        , mEnumType(propertyType)
+    {}
+    // copied from propertytype.h
+    enum StorageType {
+        StringValue,
+        IntValue
+    };
+    Q_ENUM(StorageType);
+
+    StorageType storageType() const { return static_cast<StorageType>(mEnumType->storageType); }
+    QStringList values() const { return mEnumType->values; }
+
+private:
+    const EnumPropertyType *mEnumType;
+};
+
+class ScriptClassPropertyType : public ScriptPropertyType
+{
+    Q_OBJECT
+    Q_PROPERTY(QColor color READ color)
+    Q_PROPERTY(QVariantMap members READ members)
+    Q_PROPERTY(bool drawFill READ drawFill)
+    Q_PROPERTY(int usageFlags READ usageFlags)
+
+public:
+    ScriptClassPropertyType(const ClassPropertyType *propertyType)
+        : ScriptPropertyType(propertyType)
+        , mClassType(propertyType)
+    {}
+
+    // TODO: a way to avoid duplicating this again? 
+    enum ClassUsageFlag {
+        PropertyValueType   = 0x001,
+
+        // Keep values synchronized with Object::TypeId
+        LayerClass          = 0x002,
+        MapObjectClass      = 0x004,
+        MapClass            = 0x008,
+        TilesetClass        = 0x010,
+        TileClass           = 0x020,
+        WangSetClass        = 0x040,
+        WangColorClass      = 0x080,
+        ProjectClass        = 0x100,
+        AnyUsage            = 0xFFF,
+        AnyObjectClass      = AnyUsage & ~PropertyValueType,
+    };
+    Q_ENUM(ClassUsageFlag)
+
+    QColor color() const { return mClassType->color; }
+    // TODO: " No viable overloaded '=' "
+    // void setColor(QColor &value) { mClassType->color = value; }
+    QVariantMap members() const {return mClassType->members; }
+    bool drawFill() const { return mClassType->drawFill; }
+    // void setDrawFill(bool value) { mClassType->drawFill = value; }
+    int usageFlags() const { return mClassType->usageFlags; }
+    //void setUsageFlags(int value) { mClassType->setUsageFlags(value); }
+
+private:
+    const ClassPropertyType *mClassType;
+};
+
+
+void registerPropertyTypes(QJSEngine *jsEngine);
+
+} // namespace Tiled
+
+Q_DECLARE_METATYPE(Tiled::ScriptPropertyType*)