GUIRoot.h

#pragma once
#include "GUIBase.h"
#include "GUIContainer.h"
#include "GUIScript.h"
#include "GUIToolTip.h"
#include "SpriteRenderer.h"
#include "util/mutex.h"
#include <vector>
#include <string>
#include <map>
namespace ParaEngine
{
    using namespace std;
#ifndef KEYBUFFER_SIZE
#define KEYBUFFER_SIZE          15 
#endif
    class CGUIIMEEditBox;
    class CGDIGraphics;
    class CTouchGesturePinch;
    struct  AssetEntity;
    typedef std::vector<MSG> GUIMsgEventList_type;
    struct TouchEvent;
    struct MouseEvent;
    struct AccelerometerEvent;
    class TouchEventSession;

    class CGUIRoot : public CGUIContainer
    {
    public:
        // implementation of IAttributeFields

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

        ATTRIBUTE_METHOD1(CGUIRoot, GetUIScale_s, Vector2*) { float x, y; cls->GetUIScale(&x, &y); p1->x = x; p1->y = y; return S_OK; }
        ATTRIBUTE_METHOD1(CGUIRoot, SetUIScale_s, Vector2)      { cls->SetUIScale(p1.x, p1.y); return S_OK; }

        ATTRIBUTE_METHOD1(CGUIRoot, GetBackBufferSize_s, Vector2*)  { cls->GetBackBufferSize(&(p1->x), &(p1->y)); return S_OK; }

        ATTRIBUTE_METHOD1(CGUIRoot, GetMousePosition_s, Vector2*)   { int x, y; cls->GetMousePosition(&x, &y); p1->x = (float)x; p1->y = (float)y; return S_OK; }
        ATTRIBUTE_METHOD1(CGUIRoot, SetMousePosition_s, Vector2)        { cls->SetMousePosition((int)(p1.x), (int)(p1.y)); return S_OK; }

        ATTRIBUTE_METHOD1(CGUIRoot, GetHasIMEFocus_s, bool*)    { *p1 = cls->HasIMEFocus(); return S_OK; }
        ATTRIBUTE_METHOD1(CGUIRoot, SetHasIMEFocus_s, bool) { cls->SetHasIMEFocus(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CGUIRoot, GetEnableIME_s, bool*)  { *p1 = cls->GetEnableIME(); return S_OK; }
        ATTRIBUTE_METHOD1(CGUIRoot, SetEnableIME_s, bool)   { cls->SetEnableIME(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CGUIRoot, GetUseSystemCursor_s, bool*)    { *p1 = cls->GetUseSystemCursor(); return S_OK; }
        ATTRIBUTE_METHOD1(CGUIRoot, SetUseSystemCursor_s, bool) { cls->SetUseSystemCursor(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CGUIRoot, GetFingerSizePixels_s, int*)    { *p1 = cls->GetFingerSizePixels(); return S_OK; }
        ATTRIBUTE_METHOD1(CGUIRoot, SetFingerSizePixels_s, int) { cls->SetFingerSizePixels(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CGUIRoot, GetFingerStepSizePixels_s, int*)    { *p1 = cls->GetFingerStepSizePixels(); return S_OK; }
        ATTRIBUTE_METHOD1(CGUIRoot, SetFingerStepSizePixels_s, int) { cls->SetFingerStepSizePixels(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CGUIRoot, SendKeyDownEvent_s, int) { cls->SendKeyDownEvent(p1); return S_OK; }
        ATTRIBUTE_METHOD1(CGUIRoot, SendKeyUpEvent_s, int) { cls->SendKeyUpEvent(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CGUIRoot, IsMouseButtonSwapped_s, bool*) { *p1 = cls->IsMouseButtonSwapped(); return S_OK; }
        ATTRIBUTE_METHOD1(CGUIRoot, SetMouseButtonSwapped_s, bool) { cls->SetMouseButtonSwapped(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CGUIRoot, SendInputMethodEvent_s, const char*) { cls->SendInputMethodEvent(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CGUIRoot, SetMinimumScreenSize_s, Vector2)        { cls->SetMinimumScreenSize((int)(p1.x), (int)(p1.y)); return S_OK; }
        
        ATTRIBUTE_METHOD1(CGUIRoot, IsMouseCaptured_s, bool*)   { *p1 = cls->IsMouseCaptured(); return S_OK; }
        ATTRIBUTE_METHOD1(CGUIRoot, SetCaptureMouse_s, bool)    { cls->SetCaptureMouse(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CGUIRoot, IsNonClient_s, bool*)   { *p1 = cls->IsNonClient(); return S_OK; }
        ATTRIBUTE_METHOD1(CGUIRoot, SetIsNonClient_s, bool) { cls->SetIsNonClient(p1); return S_OK; }
    public:
        ParaEngine::GUIState& GetGUIState() { return m_stateGUI; }
        CDirectMouse* GetMouse() { return m_pMouse; }
        CDirectKeyboard* GetKeyboard() { return m_pKeyboard; }
        void SetCaptureMouse(bool bCapture);
        bool IsMouseCaptured();
        
        bool PushEvent(const MSG& msg);
        bool handleTouchEvent(const TouchEvent& touch);
        bool handleNonClientTest(const MouseEvent& mouseEvent);
        bool handleAccelerometerEvent(const AccelerometerEvent& accelerator);
        bool handleGesturePinch(CTouchGesturePinch& pinch_gesture);
        void TranslateMousePointInTouchEvent(TouchEvent &touch);

        void SetUIScale(float fScalingX, float fScalingY, bool bEnsureMinimumScreenSize = true, bool bNotifySizeChange = true);

        void GetUIScale(float* pfScalingX = NULL, float* pfScalingY = NULL);

        void GetBackBufferSize(float* pWidth, float* pHeight);

        void SetMinimumScreenSize(int nWidth, int nHeight, bool bAutoUIScaling = true);


        bool UpdateViewport(int nLeft, int nTop, int nWidth, int nHeight, bool bForceUpdate = false);

        void PushTopLevelControl(CGUIContainer* pTopLevelControl);
        void RemoveTopLevelControl(CGUIContainer* pTopLevelControl);

        void ClearAllTopLevelControls();

        CGUIContainer* GetTopLevelControl(){ return m_TopLevelCtrls[0]; };

        CGUIBase* GetIMEFocus() const;
        void SetIMEFocus(CGUIBase* val);

        static void DeleteGUIObject(CGUIBase * pObj);

        static void PostDeleteGUIObject(CGUIBase * pObj);
        void AttachGUIElement(CGUIBase* pParent, CGUIBase* pChild);

        void DetachGUIElement(CGUIBase* pChild);

        int DestroyGUIElement(CGUIBase* pObj);

        int DestroyGUIElement(const char* sID);

        CGUIBase* GetUIObject(const char * strObjectName);
        CGUIBase* GetUIObject(const std::string& strObjectName);

        CGUIBase* GetUIObject(int nID);

        CGUIBase* GetUIObject(int x, int y);

        CGUIBase* GetDefaultObject(const char *strType);

        CGUIBase* GetUIKeyFocus();

        void SetUIKeyFocus(CGUIBase* control);

        CGUIBase* GetUIMouseFocus();

        void SetUIMouseFocus(CGUIBase* control);

        void UseDefaultMouseCursor(bool bUseDefaultMouseCursor);

        int HandleUserInput();

        void SendKeyDownEvent(int nVirtualkey);
        void SendKeyUpEvent(int nVirtualkey);
        void SendInputMethodEvent(const char* pStr);

        bool IsMouseButtonSwapped();
        void SetMouseButtonSwapped(bool bSwapped);

        bool DispatchKeyboardMsg(bool bKeyHandled);

        void DispatchTouchMouseEvent(bool &bMouseHandled);

        //virtual bool MsgProc(CGUIEvent *event=NULL);
        virtual bool MsgProc(MSG *event);
        virtual void Reset();

        virtual void DestroyChildren();

        void Clear();
        void Initialize();
        void    AdvanceGUI(float fElapsedTime);


        void    AddScript();

        HRESULT OneTimeGUIInit();
        LRESULT MsgProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, bool &bNoFurtherProcess);

        virtual HRESULT Render(GUIState* pGUIState, float fElapsedTime);
        virtual bool OnClick(int MouseState, int X, int Y);

        virtual HRESULT InitDeviceObjects();    // device independent
        HRESULT RestoreDeviceObjects(UINT nBkbufWidth, UINT nBkbufHeight); // device dependent
        virtual HRESULT InvalidateDeviceObjects();
        virtual HRESULT DeleteDeviceObjects();
        virtual int Release();
        virtual string ToScript(int option = 0);

        //to set whether the mouse cursor is in the client area of the program
        void SetMouseInClient(bool bMouseInClient);
        bool GetMouseInClient();
        bool CheckLoadCursor();

        void ActivateRoot();
        void InactivateRoot();
        bool IsActive();

        bool IsKeyboardProcessed();
        bool IsMouseProcessed();

        bool IsNonClient() const;
        void SetIsNonClient(bool val);

        void GetMousePosition(int* nX, int* nY) const;

        void SetMousePosition(int nX, int nY);

        int GetFingerSizePixels() const;
        void SetFingerSizePixels(int val);
        int GetFingerStepSizePixels() const;
        void SetFingerStepSizePixels(int val);

        Matrix4* Get3DViewProjMatrix(){ return &m_matViewProj; };
        void Set3DViewProjMatrix(const Matrix4& mat){ m_matViewProj = mat; };
#ifdef USE_DIRECTX_RENDERER
        DEVMODE *GetDisplayMode(){return &m_displaymode;}
#endif

        void AddToNameMap(const string& name, CGUIBase* pObj);
        void AddToIDMap(int nID, CGUIBase* pObj);

        std::map <string, CGUIBase*> m_namemap;
        std::map <int, CGUIBase*> m_idmap;

        //some static function and variables
        static CGUIRoot* GetInstance();
        static CGUIRoot* CreateInstance();
        static void DeleteInstance(CGUIRoot* pThis = NULL);

        void SetRenderImageCursor(bool bEnable);

        void SetUseSystemCursor(bool bUseSystem);

        bool GetUseSystemCursor();

        virtual const IType* GetType()const{ return m_type; }

        bool HasIMEFocus();
        void SetHasIMEFocus(bool bHasFocus);

        bool GetEnableIME();
        void SetEnableIME(bool bHasIME);

        void EnableClipCursor(bool bEnable);

        bool IsCursorClipped();

        CGUIBase* GetActiveWindow() const;
        void SetActiveWindow(CGUIBase* val);
    public:
        virtual ~CGUIRoot(void);

        //
        // interface of PaintDevice
        //
        virtual CPaintEngine * paintEngine() const;
        virtual int metric(PaintDeviceMetric metric) const;
        virtual float GetUIScalingX() const;
        virtual float GetUIScalingY() const;
        virtual float GetViewportLeft() const;
        virtual float GetViewportTop() const;

        /* get painter with default device. mostly used for text size calculation, etc. */
        CPainter* GetPainter();
    private:
        void Update3DObject(float fElapsedTime);

        void UpdateCursorPosition();

        void TranslateMousePos(int &inout_x, int &inout_y);

        void TranslateTouchEvent(const TouchEvent &touch);

        bool AutoLocateTouchClick(int ui_mouse_x, int ui_mouse_y, int &mouse_x, int &mouse_y);

    public:
        static DWORD WheelScrollLines;
        static DWORD KeyDelay;
        static DWORD KeyRepeat;
        static DWORD MouseDelay;
        static DWORD MouseRepeat;
        static DWORD MouseHover;
        static int MouseThreshold1;
        static int MouseThreshold2;
        static DWORD MouseAcceleration;
        static float MouseSpeed;

        //shall delete
        //list <MouseEvent> m_MouseEvents;

        GUIMsgEventList_type m_events;

        CDirectKeyboard*        m_pKeyboard;

        CDirectMouse*           m_pMouse;

        //  GUI_DRAG_AND_DROP       m_pDragObj;

        CGUIBase*           m_IMEFocus;


        CGUIScript              m_scripts;

        bool                    m_bDesign;
        bool                    m_bActive;
        CGUIToolTip*            m_tooltip;

        vector <CGUIContainer*> m_TopLevelCtrls;

    protected:
        static const IType* m_type;
        CGUIRoot(void);

        mutable CPaintEngine *engine;
        bool m_bIsCursorClipped;
        RECT m_rcOldClipRect;
        bool m_bMouseProcessed;
        bool m_bKeyboardProcessed;
        bool m_bMouseCaptured;
        IAttributeFields* m_pLastMouseDownObject;
#ifdef USE_DIRECTX_RENDERER
        DEVMODE m_displaymode;
#endif
        Matrix4 m_matViewProj;
        bool m_bMouseInClient;
        bool m_bWindowChanging;//when window moved or resize, it is set true;
        bool m_bRenderImageCursor;
        bool m_bUseSystemCursor;
        // delete queue id
        vector<int> m_deleteQueue;

        float m_fUIScalingX;
        float m_fUIScalingY;


        float m_fViewportLeft;
        float m_fViewportTop;
        float m_fViewportWidth;
        float m_fViewportHeight;

        float m_fMinScreenWidth;

        float m_fMinScreenHeight;

        bool m_bHasIMEFocus;
        bool m_bIsNonClient;
        int m_nFingerSizePixels;
        int m_nFingerStepSizePixels;
        int m_nLastTouchX, m_nLastTouchY;
        std::map<int, int> m_touch_id_to_ui_obj;

        ParaEngine::mutex m_mutex;
        CPainter* m_pPainter;
        GUIState    m_stateGUI;
        CGUIBase*  m_pActiveWindow;
        
        friend CGUIBase;
    };
}