D:/Programming/GUI Editor (Source)/GUI.cpp

#include "StdAfx.h"
#include "GUI.h"

CGUI::CGUI()
{
        SetEntityType(Entity_GUI);
        Initialize();
}

CGUI::~CGUI()
{
        Destroy();
}

void CGUI::Initialize()
{
        m_dwFlags = 0;
        m_pActiveElement = NULL;
        SetType(GUI);
        m_bSelectInvisible = true;
        
        Unlock();

        m_strElementType = "GUI";
}

int CGUI::PostMessage(CGUIElement *pSender, CGUIElement *pReceiver, eGUIMessage eMessage, DWORD lParam, DWORD wParam, UINT uiTimeoutMs)
{
        return m_EventHandler.PostMessage(pSender, pReceiver, eMessage, lParam, wParam, uiTimeoutMs);
}

int CGUI::Create()
{
        //Resize(tRect(0, 800, 600, 0));
        return 1;
}

int CGUI::LoadXML(TiXmlNode *pDataNode, CString strFilename)
{
        TiXmlElement* pXMLElement = NULL;
        const char *pcValue = NULL;

        int iRetValue = CGUIElement::LoadXML(pDataNode, strFilename);   // LoadXML the data of derivative
        if(iRetValue !=1)
                return iRetValue;
        
        pXMLElement = m_pXMLElement;

        return 1;
}

int CGUI::SaveXML(TiXmlNode *pDataNode, CString strFilename)
{
        // Nowhere to save!                     Nothing to save!
        if(pDataNode == NULL && strFilename == "")
                return -1;

        char Buf[128] = "";
        TiXmlElement *pSaveXMLElement = NULL;

        if(pDataNode != NULL)
                pSaveXMLElement = pDataNode->ToElement();
        else
                pSaveXMLElement = new TiXmlElement("GUI");

        int iRetValue = CGUIElement::SaveXML(pSaveXMLElement, strFilename);

        if(pDataNode == NULL && strFilename !="")
        {
                TiXmlDocument SaveDoc;
                SaveDoc.InsertEndChild(*pSaveXMLElement);
                int iRetValue = SaveDoc.SaveFile(strFilename);
                SAFEDEL(pSaveXMLElement)

                return iRetValue;
        }

        if(pDataNode == NULL)
                SAFEDEL(pSaveXMLElement)

        return iRetValue;
}

void CGUI::Update()
{
        bool LMouseButtonDown = CInputEngine::GetSingleton().GetMouse()->IsButtonDown(VK_LBUTTON);
        bool LMouseButtonUp = CInputEngine::GetSingleton().GetMouse()->IsButtonUp(VK_LBUTTON);

        if(LMouseButtonDown && (IsLocked() == false))
                OnLMouseDown(   CInputEngine::GetSingleton().GetMouse()->GetCursorPos().x,
                                                CInputEngine::GetSingleton().GetMouse()->GetCursorPos().y);
        else if(LMouseButtonUp && (IsLocked() == true))
        {
                OnLMouseUp(             CInputEngine::GetSingleton().GetMouse()->GetCursorPos().x,
                                                CInputEngine::GetSingleton().GetMouse()->GetCursorPos().y);

                Unlock();
        }

        tVERTEX2d MousePos = CInputEngine::GetSingleton().GetMouse()->GetCursorPos();
        tVERTEX2d PrevMousePos = CInputEngine::GetSingleton().GetMouse()->GetPrevCursorPos();

        if(((MousePos.x - PrevMousePos.x) !=0) || ((MousePos.y - PrevMousePos.y) !=0))
                OnMouseMove(MousePos.x, MousePos.y);

        ProcessMessages();
        m_EventHandler.Flush();
}

void CGUI::Draw()
{
        CGUIElement::Draw();
}

void CGUI::SetActiveElement(CGUIElement *pElement)
{
        m_pActiveElement = pElement;
}

CGUIElement *CGUI::GetActiveElement()
{
        return m_pActiveElement;
}

tGUIMessage *CGUI::GetMessage(UINT uiMessage)
{
        return m_EventHandler.GetMessage(uiMessage);
}

UINT CGUI::GetMessageCount()
{
        return m_EventHandler.GetMessageCount();
}

void CGUI::Destroy()
{
        CGUIElement::Destroy();
        m_EventHandler.Destroy();
}

void CGUI::ProcessMessage(tGUIMessage& Message)
{
        switch(Message.uiMessage)
        {
                case GUI_Message_AquireFocus:
                        if(!Message.pSender->Visible())
                        {
                                if(IsInvisibleSelectable())
                                        SetActiveElement(Message.pSender);
                        }
                        else
                                SetActiveElement(Message.pSender);
                break;
        }
}

void CGUI::ProcessMessages()
{
        for (UINT i=0; i<m_EventHandler.GetMessageCount(); i++)
                ProcessMessage(*m_EventHandler.GetMessage(i));

        CGUIElement *pIterElement = begin();
        set_ptr(pIterElement);

        while(pIterElement !=NULL)
        {
                pIterElement->ProcessMessages();
                pIterElement = next();
        }
}

bool CGUI::PropertyChanging( const void* pvProperty , void* pvNewValue )
{
        bool bChangeOK = CGUIElement::PropertyChanging(pvProperty, pvNewValue);

        return bChangeOK;
}

void CGUI::GetProperties( EPropList& PropList )
{
        CGUIElement::GetProperties(PropList);

        PropList.AddTab("GUI");
        PropList.AddPropCheck(this, "Select Invis.", &m_bSelectInvisible);
}

void CGUI::SelectInvisible(bool bShow)
{
        m_bSelectInvisible = Show;
}

bool CGUI::IsInvisibleSelectable()
{
        return m_bSelectInvisible;
}

int CGUI::OnLMouseDown(UINT x, UINT y)
{
        int iRetValue = CGUIElement::OnLMouseDown(x, y);
        if(iRetValue == 0)
                Lock();

        return iRetValue;
}

int CGUI::OnLMouseUp(UINT x, UINT y)
{
        int iRetValue = CGUIElement::OnLMouseUp(x, y);

        if(iRetValue == 0)
                SetActiveElement(this);

        return iRetValue;
}

bool CGUI::IsOfType(eEntityType eType)
{
        if(eType == Entity_GUI)
                return true;

        return CGUIElement::IsOfType(eType);
}

bool PointInRect(tRect& Rect, int X, int Y)
{
        bool GoodX = (X >= Rect.left) & (X <= Rect.right);
        bool GoodY = (Y >= Rect.bottom) & (Y <= Rect.top);

        return GoodX & GoodY;
}

---