Initial commit of current work on Prime World Editor

Resource/script/CScriptTemplate.h

@@ -0,0 +1,141 @@
+#ifndef CSCRIPTTEMPLATE_H
+#define CSCRIPTTEMPLATE_H
+
+#include "EPropertyType.h"
+#include "EAttribType.h"
+#include <Common/CFourCC.h>
+#include <Common/types.h>
+#include <list>
+#include <vector>
+#include <tinyxml2.h>
+#include <Resource/CResource.h>
+
+class CMasterTemplate;
+
+/**
+ * CPropertyTemplate and CStructTemplate each define the layout of a single property/struct.
+ * The reason they're classes instead of structs is so their internal values can't be externally modified.
+ * CFileTemplate is a very simple subclass with one extra value - a file extension fourCC
+ */
+class CPropertyTemplate
+{
+    friend class CTemplateLoader;
+
+protected:
+    EPropertyType mPropType;
+    std::string mPropName;
+    u32 mPropID;
+public:
+    CPropertyTemplate(u32 ID) { mPropID = ID; }
+    CPropertyTemplate(EPropertyType type, std::string name, u32 ID) : mPropType(type), mPropName(name), mPropID(ID) {}
+
+    virtual EPropertyType Type() const { return mPropType; }
+    inline std::string Name() const { return mPropName; }
+    inline u32 PropertyID() const { return mPropID; }
+    inline void SetName(const std::string& Name) { mPropName = Name; }
+};
+
+class CFileTemplate : public CPropertyTemplate
+{
+    friend class CTemplateLoader;
+
+    CStringList mAcceptedExtensions;
+public:
+    CFileTemplate(u32 ID) : CPropertyTemplate(ID) { mPropType = eFileProperty; }
+
+    CFileTemplate(std::string name, u32 ID, const CStringList& extensions)
+        : CPropertyTemplate(ID) {
+        mPropType = eFileProperty; mPropName = name; mAcceptedExtensions = extensions;
+    }
+
+    EPropertyType Type() const { return eFileProperty; }
+    const CStringList& Extensions() const { return mAcceptedExtensions; }
+};
+
+class CStructTemplate : public CPropertyTemplate
+{
+    friend class CTemplateLoader;
+
+    bool mIsSingleProperty;
+    s32 mPropertyCount;
+    std::vector<CPropertyTemplate*> mProperties;
+public:
+    CStructTemplate();
+    ~CStructTemplate();
+
+    EPropertyType Type() const;
+    bool IsSingleProperty() const;
+    s32 TemplateCount() const;
+    u32 Count() const;
+    CPropertyTemplate* PropertyByIndex(u32 index);
+    CPropertyTemplate* PropertyByName(std::string name);
+    CPropertyTemplate* PropertyByID(u32 ID);
+    CStructTemplate* StructByIndex(u32 index);
+    CStructTemplate* StructByName(std::string name);
+    CStructTemplate* StructByID(u32 ID);
+   void DebugPrintProperties(std::string base);
+};
+
+/**
+ * CAttribTemplate defines editor attributes.
+ * They enable PWE to access and use object properties for use in the world editor.
+ */
+class CAttribTemplate
+{
+    friend class CTemplateLoader;
+
+    EAttribType AttribType;
+    std::string AttribTarget;
+    std::string ResFile;
+    u32 ExtraSettings;
+public:
+    CAttribTemplate() {}
+    EAttribType Type() const { return AttribType; }
+    std::string Target() const { return AttribTarget; }
+    std::string Resource() const { return ResFile; }
+    u32 Settings() const { return ExtraSettings; }
+};
+
+/**
+ * CScriptTemplate is a class that encases the data contained in one of the XML templates.
+ * It essentially sets the layout of any given script object.
+ *
+ * It contains any data that applies globally to every instance of the object, such as
+ *   property names, editor attribute properties, etc.
+ */
+class CScriptObject;
+
+class CScriptTemplate
+{
+    friend class CTemplateLoader;
+
+    CMasterTemplate *mpMaster;
+    CStructTemplate *mpBaseStruct;
+    std::list<CScriptObject*> mObjectList;
+    std::string mTemplateName;
+    std::vector<CAttribTemplate> mAttribs;
+    u32 mObjectID;
+    bool mVisible;
+
+public:
+    CScriptTemplate(CMasterTemplate *pMaster);
+    ~CScriptTemplate();
+
+    CMasterTemplate* MasterTemplate();
+    std::string TemplateName() const;
+    CStructTemplate* BaseStruct();
+    u32 AttribCount() const;
+    CAttribTemplate* Attrib(u32 index);
+    u32 ObjectID() const;
+    u32 NumObjects() const;
+    const std::list<CScriptObject*>& ObjectList() const;
+    void AddObject(CScriptObject *pObject);
+    void RemoveObject(CScriptObject *pObject);
+    void SortObjects();
+    void SetVisible(bool Visible);
+    bool IsVisible();
+
+    void DebugPrintProperties();
+};
+
+#endif // CSCRIPTTEMPLATE_H