IAttributeFields.h

#pragma once
#include "AttributeClassIDTable.h"
#include "AttributeField.h"
#include "AttributeClass.h"

#define Member_Offset(x, cls) (int)&(((cls *)0)->x)

#define ATTRIBUTE_DEFINE_CLASS(clsName) \
    virtual int GetAttributeClassID(){return IAttributeFields::GetAttributeClassID();}\
    virtual const char* GetAttributeClassName(){ static const char name[] = #clsName; return name; }

#define PROPERTY_FIELD(name, cls, member, datatype) \
    static void Set##name(cls* c, datatype v) {c->member = v;};\
    static datatype Get##name(cls* c) {return c->member;};

#define ATTRIBUTE_METHOD(clsName, name) static HRESULT name(clsName* cls)
#define ATTRIBUTE_METHOD1(clsName, name, dataType) static HRESULT name(clsName* cls, dataType p1)
#define ATTRIBUTE_METHOD2(clsName, name, dataType) static HRESULT name(clsName* cls, dataType p1,dataType p2)
#define ATTRIBUTE_METHOD3(clsName, name, dataType) static HRESULT name(clsName* cls, dataType p1,dataType p2,dataType p3)
#define ATTRIBUTE_METHOD4(clsName, name, dataType) static HRESULT name(clsName* cls, dataType p1,dataType p2,dataType p3,dataType p4)

#define ATTRIBUTE_SUPPORT_CREATE_FACTORY(classname)  \
    virtual CAttributeClass* CreateAttributeClass(){ \
        return new CAttributeClassImp<classname>(GetAttributeClassID(), GetAttributeClassName(), GetAttributeClassDescription()); \
    };\
    static classname * Create() { \
        classname * pObj = new classname(); \
        pObj->AddToAutoReleasePool();\
        return pObj;\
    };

namespace ParaEngine
{
    class CDynamicAttributesSet;
    class CDynamicAttributeField;

    class IAttributeFields : public IObject
    {
    public:
        typedef ParaEngine::weak_ptr<IObject, IAttributeFields> WeakPtr_type;
        IAttributeFields(void);
        virtual ~IAttributeFields(void);

    public:
        // implementation of IAttributeFields

        virtual int GetAttributeClassID();
        virtual const char* GetAttributeClassName(){ static const char name[] = "IAttributeFields"; return name; }
        virtual const char* GetAttributeClassDescription(){ static const char desc[] = ""; return desc; }
        
        virtual int InstallFields(CAttributeClass* pClass, bool bOverride);

        virtual int GetChildAttributeColumnCount();
        virtual int GetChildAttributeObjectCount(int nColumnIndex = 0);
        virtual IAttributeFields* GetChildAttributeObject(int nRowIndex, int nColumnIndex = 0);
        virtual IAttributeFields* GetChildAttributeObject(const std::string& sName);

        ATTRIBUTE_METHOD1(IAttributeFields, GetName_s, const char**)    { *p1 = cls->GetIdentifier().c_str(); return S_OK; }
        ATTRIBUTE_METHOD1(IAttributeFields, SetName_s, const char*) { cls->SetIdentifier(p1); return S_OK; }
        ATTRIBUTE_METHOD(IAttributeFields, PrintObject_s){ cls->PrintObject(); return S_OK; }
        ATTRIBUTE_METHOD(IAttributeFields, AddRef_s){ cls->addref(); return S_OK; }
        ATTRIBUTE_METHOD1(IAttributeFields, GetRefCount_s, int*)    { *p1 = cls->GetRefCount(); return S_OK; }

        ATTRIBUTE_METHOD1(IAttributeFields, SetTime_s, int) { cls->SetTime(p1); return S_OK; }
        ATTRIBUTE_METHOD1(IAttributeFields, GetTime_s, int*)    { *p1 = cls->GetTime(); return S_OK; }

        ATTRIBUTE_METHOD(IAttributeFields, Release_s){ cls->Release(); return S_OK; }
    public:
        //
        // implementation of the following virtual functions are optional
        //

        virtual const std::string& GetIdentifier();
        virtual void SetIdentifier(const std::string& sID);

        virtual bool IsModified(){ return false; };
        virtual void SetModified(bool bModified){};

        virtual bool ValidateFields(){ return true; };
        virtual string GetValidationMessage(){ return ""; };

        virtual bool ResetField(int nFieldID){ return false; };

        virtual bool InvokeEditor(int nFieldID, const std::string& sParameters){ return false; };

        virtual bool AddChildAttributeObject(IAttributeFields* pChild, int nRowIndex = -1, int nColumnIndex = 0);

        virtual void* QueryObjectByName(const std::string& sObjectType);

        virtual void* QueryObject(int nObjectType);

        virtual int GetTime();
        virtual void SetTime(int nTime);

        //
        // Dynamic field method
        //

        virtual CDynamicAttributeField* GetDynamicField(const std::string& sName);

        virtual CDynamicAttributeField* GetDynamicField(int nIndex);

        virtual const char* GetDynamicFieldNameByIndex(int nIndex);

        virtual int GetDynamicFieldCount();

        virtual int SetDynamicField(const std::string& sName, const CVariable& value);

        virtual int AddDynamicField(const std::string& sName, ATTRIBUTE_FIELDTYPE dwType);

        virtual void RemoveAllDynamicFields();

        virtual int SaveDynamicFieldsToString(std::string& output);

        virtual int LoadDynamicFieldsFromString(const std::string& input);
    public:
        CAttributeClass* GetAttributeClass();
        void PrintObject();

        static HRESULT GetAttributeClassID_s(IAttributeFields* cls, int* p1) { *p1 = cls->GetAttributeClassID(); return S_OK; }
        static HRESULT GetAttributeClassName_s(IAttributeFields* cls, const char** p1) { *p1 = cls->GetAttributeClassName(); return S_OK; }

        static bool OpenWithDefaultEditor(const char* sFilename, bool bWaitOnReturn = false);

    protected:
        virtual CAttributeClass* CreateAttributeClass();
        virtual CDynamicAttributesSet* GetDynamicAttributes(bool bCreateIfNotExist = false);
    private:
        CDynamicAttributesSet* m_pDynamicAttributes;
    };

    
}