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

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

CGUIMenu::CGUIMenu()
{
        Initialize();
}

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

void CGUIMenu::Initialize()
{
        SetType(GUI_Menu);
        m_strElementType = "Menu";
}

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

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

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

        pXMLElement = m_pXMLElement;

        return Resize(GetRect());
}

int CGUIMenu::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("Menu");

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

        if(pDataNode == NULL)
                SAFEDEL(pSaveXMLElement)

        return iRetValue;
}

void CGUIMenu::Draw()
{
        if(GetChild(GUI_Border) !=NULL)
        {
                GetChild(GUI_Border)->Show();
                GetChild(GUI_Border)->ShowSiblings();
        }

        CGUIMenuEntry::Draw();
}

void CGUIMenu::ProcessMessage(tGUIMessage& Message)
{
        switch(Message.uiMessage)
        {               
                case GUI_Message_ButtonPressed:
                {
                        if(Message.pSender == this)
                        {
                                if(GetChildCount() > 0)
                                {
                                        if(GetChild(GUI_MenuEntry) !=NULL)
                                        {
                                                if(GetChild(GUI_MenuEntry)->Visible())
                                                        Collapse();
                                                else
                                                        Expand();
                                        }
                                }
                        }
                        break;
                }
                case GUI_Message_MoveX:
                case GUI_Message_MoveY:
                case GUI_Message_MoveXY:
                {
                        if(Message.pSender == this)
                                Resize(GetRect());
                        break;
                }
        }
}

bool CGUIMenu::IsOfType(eEntityType eType)
{
        if(eType == Entity_GUIMenu)
                return true;

        return CGUIMenuEntry::IsOfType(eType);
}

bool CGUIMenu::PropertyChanging( const void* pvProperty , void* pvNewValue )
{
        bool bChangeOK = CGUIMenuEntry::PropertyChanging(pvProperty, pvNewValue);
        
        return bChangeOK;
}

void CGUIMenu::GetProperties( EPropList& PropList )
{
        CGUIMenuEntry::GetProperties(PropList);
}

/*
OK, so how we are going to do it?
With OnLMouseDown we are going to catch the expansion of the root element
and with OnMouseOver we are going to expand the Child it's floating over
When a Child K of parent P is expanded, and a mouse is floating over some other Child N of parent P,
the Child K is collapsed (and all his sub-children that may be expanded) and Child N is expanded instead.
How are we going to track the children that are expanded currently?
Well, each time a Child is expanded, it's added to the list of m_piListExp
*/

---