ParaScriptingGlobal.h

//-----------------------------------------------------------------------------
// Copyright (C) 2004 - 2006 ParaEngine Dev Studio, All Rights Reserved.
// Date:    2005.4
// Description: API for global objects
//-----------------------------------------------------------------------------
#pragma once
#include "util/LogService.h"
#include "IAttributeFields.h"
#include <map>
#include <string>

struct lua_State;


#pragma region StackObjectPtr

namespace ParaScripting
{
    class ParaObject;
    class ParaUIObject;
    class ParaAttributeObject;

    template <typename _Ty>
    class StackObjectPtr
    {
    public:
        StackObjectPtr(_Ty* obj){
            if(obj!=0)
            {
                _Myptr = *obj;
            }
        }
        StackObjectPtr(_Ty const& obj):_Myptr(obj){}

        operator bool () const
        {
            return _Myptr.IsValid();
        }

        bool operator! () const
        {
            return !(_Myptr.IsValid());
        }

        _Ty& operator*() const
        {
            return (*get());
        }

        _Ty *operator->() const
        {   
            return (get());
        }

        _Ty *get() const
        {
            return (_Ty *)&(_Myptr);
        }
    private:
        _Ty _Myptr;
    };

    template <typename T>
    T* get_pointer(StackObjectPtr<T> const& pointer){ 
        return pointer.get();
    }
    
    template <typename T>
    T* get_pointer(T const& pointer){ 
        return (T*)(&pointer);
    }
} // namespace ParaScripting

namespace luabind
{
    using ParaScripting::get_pointer; // <ParaScripting::ParaCharacter>;
}

#pragma endregion StackObjectPtr

namespace ParaScripting
{
    using namespace std;
    using namespace luabind;
    using namespace ParaEngine;
    class ParaObjectNode
    {
    public:
        enum objecttype{number, string}
        oType;
        union
        {
            double dNumber;
        };
        std::string str; 

        ParaObjectNode(double n){
            oType = number;
            dNumber = n;
        };
        ParaObjectNode(const char* newstr){
            oType = string;
            this->str = newstr;
        };
    };

    typedef struct
    {
        bool operator() (const std::string& first, const std::string& second) const
        {
            return first.compare(second)<0;
        }
    } CStringCompare;

    typedef pair <const char *, ParaObjectNode> ParaObject_Pair;
    

    class ParaServiceLogger
    {
    public:
        ParaEngine::CServiceLogger_ptr m_logger_ptr;
        
        ParaServiceLogger(){};
        ParaServiceLogger(ParaEngine::CServiceLogger_ptr& logger);
        ~ParaServiceLogger(){};
    public:
        void log(int level, const object& message);

        int GetLevel();

        void SetLevel(const int level1);

        bool IsEnabledFor(int level);

        void SetAppendMode(bool bAppendToExistingFile);

        void SetLogFile(const char* sFileName);

        void SetForceFlush(bool bForceFlush);
    };

    class PE_CORE_DECL ParaGlobal
    {
    public:
        static void ExitApp();

        static void Exit(int nReturnCode);

        static void SelectAttributeObject(const ParaAttributeObject& obj);

        static void WriteToConsole(const char* strMessage);
        static void WriteToLogFile(const char* strMessage);

        static int GetLogPos();

        static const char* GetLog(int fromPos, int nCount);

        static ParaServiceLogger GetLogger(const object& name);
        static ParaServiceLogger GetLogger_(const char* name);

        static bool WriteToFile(const char* filename, const char* strMessage);
        static void SetGameStatus(const char* strState);
        static double GetGameTime();


        static std::string GetDateFormat(const object&  sFormat);

        static std::string GetTimeFormat(const object&  sFormat);

        static DWORD timeGetTime(); 

        static double getAccurateTime(); 

        static double random();

        static double GetSysDateTime(); 

        static std::string GenerateUniqueID();

        static void SaveObject(const char* strObjectName, const object& objObject);

        static object LoadObject(const object& strObjectName);
        static void SetGameLoop(const char* scriptName);
        static void SetGameLoopInterval(float fInterval);
        static bool CreateProcess(const char* lpApplicationName, const char* lpCommandLine, bool bWaitOnReturn);

        static bool ShellExecute(const char* lpOperation, const char* lpFile, const char* lpParameters, const char* lpDirectory, int nShowCmd);

        static bool OpenFileDialog(const object& inout);

        static bool WriteRegStr(const string& root_key, const string& sSubKey, const string& name, const string& value);
        
        static const char* ReadRegStr(const string& root_key, const string& sSubKey, const string& name);

        static bool WriteRegDWORD(const string& root_key, const string& sSubKey, const string& name, DWORD value);

        static DWORD ReadRegDWORD(const string& root_key, const string& sSubKey, const string& name);
    };

    class PE_CORE_DECL ParaAttributeObject
    {
    public:
        IAttributeFields::WeakPtr_type m_pAttribute;
        CAttributeClass* m_pAttClass;

        ParaAttributeObject():m_pAttribute(),m_pAttClass(NULL){};
        ParaAttributeObject(IAttributeFields * pAttribute, CAttributeClass* pAttClass);
        ParaAttributeObject(IAttributeFields * pAttribute);

        ParaAttributeObject GetAttributeObject();


        bool equals(const ParaAttributeObject& obj) const;
        
        ParaAttributeObject GetChild(const std::string& sName);
        ParaAttributeObject GetChildAt(int nIndex);
        ParaAttributeObject GetChildAt2(int nRowIndex, int nColumnIndex);
        int GetChildCount();
        int GetChildCount2(int nColumnIndex);
        int GetColumnCount();

        bool AddChild(ParaAttributeObject& obj);

        const ParaObject& QueryObject();
        const ParaUIObject& QueryUIObject();

        bool IsValid() const;

        int  GetClassID() const;
        const char* GetClassName() const;
        const char* GetClassName1() const;
        const char* GetClassDescription() const;

        void SetOrder(int order);
        int GetOrder();

        int GetFieldNum();
        const char* GetFieldName(int nIndex);

        int GetFieldIndex(const char*  sFieldname);

        const char* GetFieldType(int nIndex);
        bool IsFieldReadOnly(int nIndex);

        const char* GetFieldSchematics(int nIndex);
        const char* GetSchematicsType(int nIndex);

        void GetSchematicsMinMax(int nIndex, float fMinIn, float fMaxIn, float& fMin, float& fMax);

        object GetField(const char*  sFieldname, const object& output);

        object GetField2(const char* sFieldname, lua_State* L);
        const char* GetStringField(const char*  sFieldname);
        double GetValueField(const char*  sFieldname, int nIndex=0);
        
        void SetField(const char*  sFieldname, const object& input);
        void SetStringField(const char*  sFieldname, const char* input);
        void SetValueField(const char*  sFieldname, int nIndex, double value);
        
        void CallField(const char*  sFieldname);

        void PrintObject(const char* file);

        bool ResetField(int nFieldID);

        bool InvokeEditor(int nFieldID, const char* sParameters);


        // dynamic fields

        object GetDynamicField(const char*  sFieldname, const object& output);
        
        object GetDynamicField_(int nIndex, const object& output);

        object GetDynamicFieldImp(CDynamicAttributeField* pField, const object &output);

        const char* GetDynamicFieldNameByIndex(int nIndex);

        int GetDynamicFieldCount();

        int SetDynamicField(const char*  sFieldname, const object& input);
        int SetDynamicField_(int nFieldIndex, const object& input);

        int GetFieldKeyNums(const char*  sFieldname);
        void SetFieldKeyNums(const char*  sFieldname, int nKeyNum);

        void SetFieldKeyTime(const char*  sFieldname, int nKeyIndex, int nTime);
        int GetFieldKeyTime(const char*  sFieldname, int nKeyIndex);

        void SetFieldKeyValue(const char*  sFieldname, int nKeyIndex, const object& input);
        object GetFieldKeyValue(const char*  sFieldname, int nKeyIndex, const object& output);

        void RemoveAllDynamicFields();

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

    class PE_CORE_DECL ParaBootStrapper
    {
    public:
        static bool LoadFromFile(const char*  sXMLfile);
        static bool SaveToFile(const char* sXMLfile);

        static void LoadDefault();

        static const char* GetMainLoopFile();
        static void SetMainLoopFile(const char* sMainFile);
    };
}