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

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

CGUIButton::CGUIButton()
{
        SetEntityType(Entity_GUIButton);
        SetType(GUI_Button);
        Initialize();
}

CGUIButton::~CGUIButton()
{
        SAFEDEL_ARRAY(m_pButtonStates)
        Destroy();
}

void CGUIButton::Initialize()
{
        m_pButtonStates = NULL;
        m_iuStateCount = 0;
        m_iCurrentState = 0;
        m_bLoopState = false;

        m_iNormalStateIndex = m_iMouseOverStateIndex = m_iMouseDownStateIndex = m_iDisabledStateIndex = 1000;
        m_iCurrentState = 0;

        m_strElementType = "Button";
}

int CGUIButton::Create(CGUIElement *pParent, tRect WidgetRect, CCustomFont *pFont, CTexture *pTexture, CMaterial *pMaterial, bool bBorder)
{
        return CGUIStatic::Create(pParent, WidgetRect, pFont, pTexture, pMaterial, bBorder);
}

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

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

        pXMLElement = m_pXMLElement;

        LoadButtonStates(pXMLElement);
        return 1;       // All went OK, return 1
}

int CGUIButton::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("Button");

        SaveButtonStates(pSaveXMLElement);

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

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

                return iRetValue;
        }

        return iRetValue;
}

int CGUIButton::SaveButtonStates(TiXmlNode *pDataNode)
{
        if(pDataNode == NULL)
                return -1;

        for (int i=0; i<m_iuStateCount; i++)
        {
                TiXmlElement *pStateXMLElement = new TiXmlElement("State");
                SaveStateEvents(pStateXMLElement, &m_pButtonStates[i]);

                pDataNode->InsertEndChild(*pStateXMLElement);
                SAFEDEL(pStateXMLElement)
        }
        return 1;
}

int CGUIButton::SaveStateEvents(TiXmlNode *pDataNode, tButtonState *uiState)
{
        if(pDataNode == NULL || uiState == NULL)
                return -1;

        for (int i=0; i<uiState->m_iEventCount; i++)
        {
                TiXmlElement *pEventXMLElement = new TiXmlElement("Event");
                if(uiState->m_pEventAnimations[i] !=NULL)
                        pEventXMLElement->SetAttribute("AnimByName", uiState->m_pEventAnimations[i]->GetName());

                pDataNode->InsertEndChild(*pEventXMLElement);
                SAFEDEL(pEventXMLElement)
        }
        return 1;
}


void CGUIButton::Draw()
{
        CTextureFrameAnimation *pAnimation = GetCurrentAnimation();
        if(pAnimation !=NULL)
        {
                CTexture *pTexture = pAnimation->GetTexture();
                if(pTexture !=NULL)
                {
                        SetTexture(pTexture);

                        m_TexCoord[0].x = (float)pAnimation->GetCurrentFrame()->left / (float)pTexture->GetWidth();
                        m_TexCoord[1].x = (float)pAnimation->GetCurrentFrame()->right / (float)pTexture->GetWidth();
                        m_TexCoord[2].x = (float)pAnimation->GetCurrentFrame()->right / (float)pTexture->GetWidth();
                        m_TexCoord[3].x = (float)pAnimation->GetCurrentFrame()->left / (float)pTexture->GetWidth();

                        //if(pAnimation->GetCurrentFrame()->m_iBottom != pTexture->GetHeight())
                        //{
                        m_TexCoord[0].y = 1.0f - ((float)pAnimation->GetCurrentFrame()->bottom / (float)pTexture->GetHeight());
                        m_TexCoord[1].y = 1.0f - ((float)pAnimation->GetCurrentFrame()->bottom / (float)pTexture->GetHeight());
                        m_TexCoord[2].y = 1.0f - ((float)pAnimation->GetCurrentFrame()->top / (float)pTexture->GetHeight());
                        m_TexCoord[3].y = 1.0f - ((float)pAnimation->GetCurrentFrame()->top / (float)pTexture->GetHeight());
                }

                pAnimation->Animate(100);
        }

        CGUIStatic::Draw();
}

CTextureFrameAnimation *CGUIButton::GetEventAnimation(UINT uiEventIndex)
{
        // Basically, goes through all events and states and finds one appropriate
        // for current config of 'm_iButtonState' and 'event' variables
        // and if finds one, returns its animation
        if(m_pButtonStates !=NULL)
        {
                if(uiEventIndex >= 0 && uiEventIndex < m_pButtonStates[GetState()].m_iEventCount)
                        return m_pButtonStates[GetState()].m_pEventAnimations[uiEventIndex];
        }

        return NULL;    
}


UINT CGUIButton::GetState()
{
        return m_iCurrentState;
}

void CGUIButton::SetState(bool bLoopAnimation, UINT uiState)
{
        if(uiState >=0 && uiState < m_iuStateCount)
                m_iCurrentState = uiState;

        m_bLoopState = bLoopAnimation;
}

CTextureFrameAnimation *CGUIButton::GetCurrentAnimation()
{
        UINT EventType = 0; 
        // If no mouse over this button and its not pressed

        // uiState 0 - NORMAL state
        // A button MUST have a normal state!
        // There must be no change of flags when a button is disabled!
        // Normal (not mouseover)
        if(PointInRect(
                GetRect(),
                CInputEngine::GetSingleton().GetMouse()->GetCursorPos().x, 
                CInputEngine::GetSingleton().GetMouse()->GetCursorPos().y) && 
                CInputEngine::GetSingleton().GetMouse()->IsButtonDown(VK_LBUTTON) == false)             // Only mouseover
        {
                if(GetEventAnimation(Button_MouseOver) !=NULL)
                        return GetEventAnimation(Button_MouseOver);
        }
        else if(PointInRect(
                GetRect(),
                CInputEngine::GetSingleton().GetMouse()->GetCursorPos().x,
                CInputEngine::GetSingleton().GetMouse()->GetCursorPos().y) && 
                CInputEngine::GetSingleton().GetMouse()->IsButtonDown(VK_LBUTTON))              // LMouseDown
        {
                if(GetEventAnimation(Button_MouseDown) !=NULL)
                        return GetEventAnimation(Button_MouseDown);
        }

        return GetEventAnimation(Button_Default);
}

bool CGUIButton::LoadButtonStates(TiXmlNode *pButtonXMLNode)
{
        UINT StateCount = 0;

        if(pButtonXMLNode == NULL)
                return false;

        TiXmlNode *pIterXMLNode = pButtonXMLNode->FirstChild();
        while(pIterXMLNode !=NULL)
        {
                if(stricmp(pIterXMLNode->pcValue(), "state") == 0)
                        StateCount++;

                pIterXMLNode = pButtonXMLNode->IterateChildren(pIterXMLNode);
        }

        if(StateCount !=0)
        {
                SAFEDEL_ARRAY(m_pButtonStates)
                m_iuStateCount = StateCount;
        }
        else
        {
                CGlobalLogger::GetSingleton().Write("\t**********General Warning\t**********\n");
                CGlobalLogger::GetSingleton().Write("Button (Name: %s, ID: %d) has 0 States (uiState XML Node(s)).", GetName(), GetID());

                return true;
        }

        if(m_iuStateCount > 0)
        {
                UINT Count = 0;
                m_pButtonStates = new tButtonState[m_iuStateCount];

                pIterXMLNode = pButtonXMLNode->FirstChild();
                while(pIterXMLNode !=NULL)
                {
                        if(stricmp(pIterXMLNode->pcValue(), "state") == 0)
                        {
                                if(!LoadStateEvents(&m_pButtonStates[Count], pIterXMLNode))
                                {
                                        CGlobalLogger::GetSingleton().Write("\n\t\t!!!!!!!!!!General Error!!!!!!!!!!!!\n");
                                        CGlobalLogger::GetSingleton().Write("Button (Name: %s, ID: %d) cannot parse uiState(%d) events. Check syntax.", GetName(), GetID(), Count);

                                        return false;
                                }
                        }

                        pIterXMLNode = pButtonXMLNode->IterateChildren(pIterXMLNode);
                        Count++;
                }
        }

        return true;
}

bool CGUIButton::LoadStateEvents(tButtonState *uiState, TiXmlNode *pStateXMLNode)
{
        if(uiState == NULL || pStateXMLNode == NULL)
                return false;

        UINT EventCount = 0;

        TiXmlNode *pIterXMLNode = pStateXMLNode->FirstChild();
        while(pIterXMLNode !=NULL)
        {
                if(stricmp(pIterXMLNode->pcValue(), "event") == 0)
                        EventCount++;

                pIterXMLNode = pStateXMLNode->IterateChildren(pIterXMLNode);
        }

        UINT uiIndex = 0;
        uiState->m_iEventCount = EventCount;
        if(EventCount > 0)
        {
                uiState->m_pEventAnimations = new CTextureFrameAnimation*[EventCount];
                for (int i=0; i<EventCount; i++)
                        uiState->m_pEventAnimations[i] = NULL;

                pIterXMLNode = pStateXMLNode->FirstChild();
                while(pIterXMLNode !=NULL)
                {
                        CAnimation *pAnimation = CAnimationManager::GetSingleton().LoadResource(pIterXMLNode, "");
                        if(pAnimation !=NULL)
                        {
                                if(pAnimation->GetEntityType() == Entity_TextureFrameAnimation)
                                {
                                        uiState->m_pEventAnimations[uiIndex] = (CTextureFrameAnimation *)pAnimation;
                                        uiIndex++;
                                }
                        }
                        else
                                uiState->m_pEventAnimations[uiIndex] = NULL;

                        pIterXMLNode = pStateXMLNode->IterateChildren(pIterXMLNode);
                }
        }

        return true;
}

int CGUIButton::OnLMouseUp(UINT x, UINT y)
{
        CGUIElement *IterElement = end();
        set_ptr(IterElement);

        while(IterElement !=NULL)
        {
                if(IterElement->OnLMouseUp(x, y))       // If one element finds use to the mouse_down event, do not let others to use it
                        return 1;
                IterElement = prev();
        }

        if(GetType() !=GUI)
        {
                if(Visible())
                {
                        if(PointInRect(GetRect(), x, y))
                        {
                                if(GetGUI()->GetActiveElement() == this) // if mouse was down initially on this element
                                {
                                        if(m_iuStateCount > 0)
                                        {
                                                // Progress in button states
                                                if(m_iCurrentState == (m_iuStateCount - 1))
                                                {
                                                        if(m_bLoopState)
                                                                m_iCurrentState = 0;
                                                }
                                                else
                                                        m_iCurrentState++;
                                        }

                                        // Broadcast the 'pressed' message
                                        GetGUI()->PostMessage(this, NULL, GUI_Message_ButtonPressed);
                                }
                                return CGUIStatic::OnLMouseUp(x, y);
                        }
                }
        }

        return CGUIStatic::OnLMouseUp(x, y);
}

bool CGUIButton::PropertyChanging( const void* pvProperty , void* pvNewValue )
{
        bool bChangeOK = CGUIStatic::PropertyChanging(pvProperty, pvNewValue);
        if(pvProperty == &m_iNormalStateIndex)
        {
                if(m_iuStateCount > 0 && m_pButtonStates[m_iCurrentState].m_iEventCount > 0)
                {
                        m_iNormalStateIndex = *(int *)pvNewValue;
                        if(m_iNormalStateIndex == 1000)
                                m_pButtonStates[m_iCurrentState].m_pEventAnimations[Button_Default] = NULL;
                        else
                                m_pButtonStates[m_iCurrentState].m_pEventAnimations[Button_Default] = (CTextureFrameAnimation *)CAnimationManager::GetSingleton().GetResource(m_iNormalStateIndex);
                }
        }

        if(pvProperty == &m_iMouseOverStateIndex)
        {
                if(m_iuStateCount > 0 && m_pButtonStates[m_iCurrentState].m_iEventCount > 1)
                {
                        m_iMouseOverStateIndex = *(int *)pvNewValue;
                        if(m_iMouseOverStateIndex == 1000)
                                m_pButtonStates[m_iCurrentState].m_pEventAnimations[Button_MouseOver] = NULL;
                        else
                                m_pButtonStates[m_iCurrentState].m_pEventAnimations[Button_MouseOver] = (CTextureFrameAnimation *)CAnimationManager::GetSingleton().GetResource(m_iMouseOverStateIndex);
                }
        }

        if(pvProperty == &m_iMouseDownStateIndex)
        {
                if(m_iuStateCount > 0 && m_pButtonStates[m_iCurrentState].m_iEventCount > 2)
                {
                        m_iMouseDownStateIndex = *(int *)pvNewValue;
                        if(m_iMouseDownStateIndex == 1000)
                                m_pButtonStates[m_iCurrentState].m_pEventAnimations[Button_MouseDown] = NULL;
                        else
                                m_pButtonStates[m_iCurrentState].m_pEventAnimations[Button_MouseDown] = (CTextureFrameAnimation *)CAnimationManager::GetSingleton().GetResource(m_iMouseDownStateIndex);
                }
        }

        if(pvProperty == &m_iDisabledStateIndex)
        {
                if(m_iuStateCount > 0 && m_pButtonStates[m_iCurrentState].m_iEventCount > 3)
                {
                        m_iDisabledStateIndex = *(int *)pvNewValue;
                        if(m_iDisabledStateIndex == 1000)
                                m_pButtonStates[m_iCurrentState].m_pEventAnimations[Button_Disabled] = NULL;
                        else
                                m_pButtonStates[m_iCurrentState].m_pEventAnimations[Button_Disabled] = (CTextureFrameAnimation *)CAnimationManager::GetSingleton().GetResource(m_iDisabledStateIndex);
                }
        }

        if(pvProperty == &m_iCurrentState)
        {
                int TempVal = *(int *)pvNewValue;

                if(TempVal >= 1000)
                {
                        int TempStateCount = m_iuStateCount;
                        if(TempVal == 1000)
                                TempStateCount++;
                        else if(TempVal == 2000)
                                TempStateCount--;

                        Destroy();
                        Initialize();

                        m_iuStateCount = TempStateCount;
                        m_iCurrentState = 0;
                        if(m_iuStateCount == 0)
                                m_pButtonStates = NULL;
                        else
                        {
                                m_pButtonStates = new tButtonState[m_iuStateCount];

                                for (int j=0; j<m_iuStateCount; j++)
                                {
                                        m_pButtonStates[j].m_pEventAnimations = new CTextureFrameAnimation*[3];
                                        m_pButtonStates[j].m_iEventCount = 3;

                                        for (int i=0; i<3; i++)
                                                m_pButtonStates[j].m_pEventAnimations[i] = NULL;
                                }
                        }

                        m_iCurrentState = 0;
                        m_pTexture = NULL;

                        bChangeOK = false;
                }
                else
                {
                        m_iCurrentState = *(int *)pvNewValue;
                        bChangeOK = true;
                }
        }

        if(pvProperty == &m_pButtonStates[m_iCurrentState].m_iEventCount)
        {
                int TempVal = *(int *)pvNewValue;
                if(TempVal >= 1000)
                {
                        delete[] m_pButtonStates[m_iCurrentState].m_pEventAnimations;
                        m_pButtonStates[m_iCurrentState].m_pEventAnimations = new CTextureFrameAnimation*[TempVal - 1000];

                        for (int i=0; i<(TempVal - 1000); i++)
                                m_pButtonStates[m_iCurrentState].m_pEventAnimations[i] = NULL;

                        m_pButtonStates[m_iCurrentState].m_iEventCount = TempVal - 1000;

                        m_iNormalStateIndex = m_iMouseOverStateIndex = m_iMouseDownStateIndex = m_iDisabledStateIndex = 1000;
                        m_iCurrentState = 0;

                        bChangeOK = false;
                }
        }

        return bChangeOK;
}

void CGUIButton::GetProperties( EPropList& PropList )
{
        CGUIStatic::GetProperties(PropList);

        PropList.AddTab("Button");
        EPropertyCombo *pStateCombo = PropList.AddPropCombo(this, "State", &m_iCurrentState);
        pStateCombo->AddString("Add uiState...", 1000);

        for (int i=0; i<m_iuStateCount; i++)
        {
                CString uiState;
                uiState.Format("State #%d", i);
                pStateCombo->AddString(uiState, i);
        }
        if(m_pButtonStates !=NULL)
        {
                pStateCombo->AddString("Remove State...", 2000);

                PropList.AddPropSeparator(this, "Button Events");
                EPropertyCombo *pEventCombo = PropList.AddPropCombo(this, "Events", &m_pButtonStates[m_iCurrentState].m_iEventCount);

                if(m_pButtonStates[m_iCurrentState].m_iEventCount < 4)
                {
                        if(m_pButtonStates[m_iCurrentState].m_iEventCount < 3)
                        {
                                if(m_pButtonStates[m_iCurrentState].m_iEventCount < 2)
                                {
                                        if(m_pButtonStates[m_iCurrentState].m_iEventCount < 1)
                                                pEventCombo->AddString("Add Normal Event", 1001);

                                        pEventCombo->AddString("Add Mouse Over Event", 1002);
                                }

                                pEventCombo->AddString("Add Mouse Down Event", 1003);
                        }

                        pEventCombo->AddString("Add Disabled Event", 1004);
                }

                if(m_pButtonStates[m_iCurrentState].m_pEventAnimations[Button_Default] == NULL)
                        m_iNormalStateIndex = 1000;

                if(m_pButtonStates[m_iCurrentState].m_pEventAnimations[Button_MouseOver] == NULL)
                        m_iMouseOverStateIndex = 1000;

                if(m_pButtonStates[m_iCurrentState].m_pEventAnimations[Button_MouseDown] == NULL)
                        m_iMouseDownStateIndex = 1000;

                if(m_pButtonStates[m_iCurrentState].m_pEventAnimations[Button_Disabled] == NULL)
                        m_iDisabledStateIndex = 1000;


                for (int i=0; i<m_pButtonStates[m_iCurrentState].m_iEventCount; i++)
                {
                        CString Event;
                        Event.Format("%d", i);
                        pEventCombo->AddString(Event, 1000 + i);
                }

                if(m_iuStateCount > 0 && m_pButtonStates[m_iCurrentState].m_iEventCount > 0)
                {
                        EPropertyCombo *pNormalCombo = PropList.AddPropCombo(this, "Normal", &m_iNormalStateIndex);
                        pNormalCombo->AddString("None", 1000);

                        for (int i=0; i<CAnimationManager::GetSingleton().size(); i++)
                        {
                                CAnimation *pAnimation = (CAnimation *)CAnimationManager::GetSingleton().at(i);
                                if(pAnimation->GetEntityType() == Entity_TextureFrameAnimation)
                                        pNormalCombo->AddString(pAnimation->GetName(), i);

                                if(GetEventAnimation(Button_Default) !=NULL && GetEventAnimation(Button_Default) == pAnimation)
                                        m_iNormalStateIndex = i;
                        }
                }

                if(m_iuStateCount > 0 && m_pButtonStates[m_iCurrentState].m_iEventCount > 1)
                {
                        EPropertyCombo *pMouseOverCombo = PropList.AddPropCombo(this, "Mouse Over", &m_iMouseOverStateIndex);
                        pMouseOverCombo->AddString("None", 1000);

                        for (int i=0; i<CAnimationManager::GetSingleton().size(); i++)
                        {
                                CAnimation *pAnimation = (CAnimation *)CAnimationManager::GetSingleton().at(i);
                                if(pAnimation->GetEntityType() == Entity_TextureFrameAnimation)
                                        pMouseOverCombo->AddString(pAnimation->GetName(), i);

                                if(GetEventAnimation(Button_MouseOver) !=NULL && GetEventAnimation(Button_MouseOver) == pAnimation)
                                        m_iMouseOverStateIndex = i;
                        }
                }

                if(m_iuStateCount > 0 && m_pButtonStates[m_iCurrentState].m_iEventCount > 2)
                {
                        EPropertyCombo *pMouseDownCombo = PropList.AddPropCombo(this, "Mouse Down", &m_iMouseDownStateIndex);
                        pMouseDownCombo->AddString("None", 1000);

                        for (int i=0; i<CAnimationManager::GetSingleton().size(); i++)
                        {
                                CAnimation *pAnimation = (CAnimation *)CAnimationManager::GetSingleton().at(i);
                                if(pAnimation->GetEntityType() == Entity_TextureFrameAnimation)
                                        pMouseDownCombo->AddString(pAnimation->GetName(), i);

                                if(GetEventAnimation(Button_MouseDown) !=NULL && GetEventAnimation(Button_MouseDown) == pAnimation)
                                        m_iMouseDownStateIndex = i;
                        }
                }


                if(m_iuStateCount > 0 && m_pButtonStates[m_iCurrentState].m_iEventCount > 3)
                {
                        EPropertyCombo *pDisabledCombo = PropList.AddPropCombo(this, "Disabled", &m_iDisabledStateIndex);
                        pDisabledCombo->AddString("None", 1000);

                        for (int i=0; i<CAnimationManager::GetSingleton().size(); i++)
                        {
                                CAnimation *pAnimation = (CAnimation *)CAnimationManager::GetSingleton().at(i);
                                if(pAnimation->GetEntityType() == Entity_TextureFrameAnimation)
                                        pDisabledCombo->AddString(pAnimation->GetName(), i);

                                if(GetEventAnimation(Button_Disabled) !=NULL && GetEventAnimation(Button_Disabled) == pAnimation)
                                        m_iDisabledStateIndex = i;
                        }
                }
        }
}

void CGUIButton::Destroy()
{
        CGUIStatic::Destroy();
}

bool CGUIButton::IsOfType(eEntityType eType)
{
        if(eType == Entity_GUIButton)
                return true;

        return CGUIStatic::IsOfType(eType);
}

---