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

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

CGUIMenuEntry::CGUIMenuEntry()
{
        Initialize();
}

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

void CGUIMenuEntry::Initialize()
{
        SetType(GUI_MenuEntry);
        m_iHExpand = 0;
        m_iVExpand = 0;
        m_iCurSel = -1;
        m_strElementType = "MenuEntry";
        m_pExpandedChild = NULL;
}

int CGUIMenuEntry::Create(CGUIElement *pParent, tRect WidgetRect, CCustomFont *pFont, CTexture *pTexture, CMaterial *pMaterial, bool bBorder)
{
        if(!CGUIButton::Create(pParent, WidgetRect, pFont, pTexture, pMaterial, bBorder))
                return 0;

        if(GetType() == GUI_MenuEntry)
                RemoveChild(GetChild(GUI_Border));
        return 1;
}

void CGUIMenuEntry::SetExpand(int iHorizontal, int iVertical)
{
        m_iHExpand = iHorizontal;
        m_iVExpand = iVertical;
}

int CGUIMenuEntry::VExpand()
{
        return m_iVExpand;
}

int CGUIMenuEntry::HExpand()
{
        return m_iHExpand;
}

CGUIElement *CGUIMenuEntry::InsertItem(CString& strItemText, UINT uiInsertAfter)
{
        CGUIMenuEntry *pNewEntry = new CGUIMenuEntry();
        pNewEntry->Create(this, tRect());

        CFileDialog FileDialog(TRUE, NULL, NULL, OFN_HIDEREADONLY|OFN_FILEMUSTEXIST, "XML Files (*.xml)|*.xml|All Files (*.*)|*.*||", AfxGetMainWnd());
        if(FileDialog.DoModal() == IDOK)
        {
                if(pNewEntry->LoadXML(NULL, GetFullPath(FileDialog.GetPathName())))
                {
                        pNewEntry->SetText(strItemText);
                        pNewEntry->GetParent()->Resize(pNewEntry->GetParent()->GetRect());
                        pNewEntry->SetExpand(1, 0);

                        pNewEntry->SetFlag(GUI_Flag_RestrictMovementX, true);
                        pNewEntry->SetFlag(GUI_Flag_RestrictMovementY, true);
                        push_front(pNewEntry);

                        Resize(GetRect());
                        return pNewEntry;
                }
        }

        return NULL;
}

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

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

        pXMLElement = m_pXMLElement;

        pcValue = pXMLElement->Attribute("ExpandX");
        if(pcValue !=NULL)
        {
                if(stricmp(pcValue, "left") == 0)
                        m_iHExpand = -1;
                else if(stricmp(pcValue,"right") == 0)
                        m_iHExpand = 1;
                else
                {
                        m_iHExpand = atoi(pcValue);
                        SetAutoCalc(false);
                }

                pcValue = NULL;
        }
        else
        {
                CGlobalLogger::GetSingleton().Write("\t**********General Warning\t**********\n");
                CGlobalLogger::GetSingleton().Write("Menu Entry (Name: %s, ID: %d) doesn't have Horizontal Expansion Path (HExpand) Attribute specified. Assuming default...", GetName(), GetID());
        }

        pcValue = pXMLElement->Attribute("ExpandY");
        if(pcValue !=NULL)
        {
                if(stricmp(pcValue, "up") == 0)
                        m_iVExpand = 1;
                else if(stricmp(pcValue,"down") == 0)
                        m_iVExpand = -1;
                else
                {
                        m_iVExpand = atoi(pcValue);
                        SetAutoCalc(false);
                }

                pcValue = NULL;
        }
        else
        {
                CGlobalLogger::GetSingleton().Write("\t**********General Warning\t**********\n");
                CGlobalLogger::GetSingleton().Write("Menu Entry (Name: %s, ID: %d) doesn't have Vertical Expansion Path (VExpand) Attribute specified. Assuming default...", GetName(), GetID());
        }

        HideSiblings();
        HideSiblingsText();


        return iRetValue;
}

int CGUIMenuEntry::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("MenuEntry");

        if(m_iHExpand == -1)
                pSaveXMLElement->SetAttribute("ExpandX", "Left");
        else if(m_iHExpand == 1)
                pSaveXMLElement->SetAttribute("ExpandX", "Right");

        if(m_iVExpand == -1)
                pSaveXMLElement->SetAttribute("ExpandY", "Down");
        else if(m_iVExpand == 1)
                pSaveXMLElement->SetAttribute("ExpandY", "Up");

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

        if(pDataNode == NULL)
                SAFEDEL(pSaveXMLElement)

                return iRetValue;
}

void CGUIMenuEntry::HideSiblingsText(int iDeep)
{
        CGUIMenuEntry *pIterElement = (CGUIMenuEntry *)begin();
        set_ptr(pIterElement);

        while(pIterElement !=NULL)
        {
                if(pIterElement->GetType() == GUI_MenuEntry)
                {
                        pIterElement->HideText();

                        if(iDeep > 0)
                                pIterElement->HideSiblingsText(iDeep - 1);
                        else if(iDeep == -1)
                                pIterElement->HideSiblingsText(iDeep);
                        else if(iDeep == 0)
                                return;
                }

                pIterElement = (CGUIMenuEntry *)next();
        }
}

void CGUIMenuEntry::ShowSiblingsText(int iDeep)
{
        CGUIMenuEntry *pIterElement = (CGUIMenuEntry *)begin();
        set_ptr(pIterElement);

        while(pIterElement !=NULL)
        {
                if(pIterElement->GetType() == GUI_MenuEntry)
                {
                        if(iDeep > 0)
                        {
                                pIterElement->ShowText();
                                pIterElement->ShowSiblingsText(iDeep - 1);
                        }
                        else if(iDeep == -1)
                        {
                                pIterElement->ShowText();
                                pIterElement->ShowSiblingsText(iDeep);
                        }
                        else if(iDeep == 0)
                                return;
                }

                pIterElement = (CGUIMenuEntry *)next();
        }
}

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

        if(pvProperty == &m_iCurSel)
        {
                int TempNewValue = *(int *)pvNewValue;
                if(TempNewValue == 1000)
                {
                        CGUIElement *pNewItem = InsertItem(CString("New Entry"));
                        m_iCurSel = -1;
                        return false;
                }
        }

        if(pvProperty == &m_iHExpand)
        {
                m_iHExpand = *(int *)pvNewValue;
                GetParent()->Resize(GetRect());
        }

        if(pvProperty == &m_iVExpand)
        {
                m_iVExpand = *(int *)pvNewValue;
                GetParent()->Resize(GetRect());
        }

        return bChangeOK;
}

void CGUIMenuEntry::Expand()
{
        ShowSiblings(1);
        ShowSiblingsText(1);
}

void CGUIMenuEntry::Draw()
{
        CGUIMenuEntry *pIter = (CGUIMenuEntry *)begin();
        set_ptr(pIter);

        while(pIter !=NULL)
        {
                if(pIter->GetType() == GUI_MenuEntry)
                {
                        if(PointInRect(pIter->GetRect(),        CInputEngine::GetSingleton().GetMouse()->GetCursorPos().x,
                                                                                                CInputEngine::GetSingleton().GetMouse()->GetCursorPos().y))
                        {
                                if(pIter->GetChildCount() > 0)
                                {
                                        m_pExpandedChild = pIter;
                                        m_pExpandedChild->Expand();
                                }
                        }
                        else
                        {
                                if(pIter->PointInChildRects())
                                {
                                        m_pExpandedChild = pIter;
                                        m_pExpandedChild->Expand();
                                }
                                else
                                        pIter->Collapse();
                        }
                }

                pIter = (CGUIMenuEntry *)next();
        }

        CGUIButton::Draw();
}

int CGUIMenuEntry::Resize(tRect &NewRect)
{
        CGUIElement *pIter = begin();
        set_ptr(pIter);

        tRect Rect = NewRect;
        int iOffsetX = 0;
        int iOffsetY = 0;

        while(pIter !=NULL)
        {
                if(pIter->GetType() == GUI_MenuEntry || pIter->GetType() == GUI_Menu)
                {
                        tRect ChildRect;

                        CGUIMenuEntry *pChild = (CGUIMenuEntry *)pIter;
                        if(pChild->VExpand() < 0) // Down
                        {
                                if(pChild->IsAutoCalc())
                                        iOffsetY-= Rect.Height();
                                else
                                        iOffsetY+= pChild->VExpand();
                        }
                        else if(pChild->VExpand() > 0) // Up
                        {
                                if(pChild->IsAutoCalc())
                                        iOffsetY+= Rect.Height();
                                else
                                        iOffsetY+= pChild->VExpand();
                        }

                        if(pChild->HExpand() > 0) // Right
                        {
                                if(pChild->IsAutoCalc())
                                        iOffsetX+= Rect.Width();
                                else
                                        iOffsetX+= pChild->HExpand();
                        }
                        else if(pChild->HExpand() < 0)  // Left
                        {
                                if(pChild->IsAutoCalc())
                                        iOffsetX-= Rect.Width();
                                else
                                        iOffsetX-= pChild->HExpand();
                        }

                        ChildRect.left = Rect.left + iOffsetX;
                        ChildRect.right = ChildRect.left + Rect.Width();
                        ChildRect.top = iOffsetY + Rect.top;
                        ChildRect.bottom = ChildRect.top - Rect.Height();

                        pChild->Resize(ChildRect);
                }

                pIter = next();
        }

        return CGUIButton::Resize(NewRect);
}

void CGUIMenuEntry::Collapse()
{
        HideSiblings();
        HideSiblingsText();
}

const CGUIMenuEntry *CGUIMenuEntry::GetExpanded()
{
        return m_pExpandedChild;
}

void CGUIMenuEntry::ProcessMessage(tGUIMessage& Message)
{
        switch(Message.uiMessage)
        {               
        case GUI_Message_MoveX:
        case GUI_Message_MoveY:
        case GUI_Message_MoveXY:
                {
                        if(Message.pSender == GetParent())
                                Resize(GetRect());
                        break;
                }
        }
}

bool CGUIMenuEntry::IsOfType(eEntityType eType)
{
        if(eType == Entity_GUIMenuEntry)
                return true;

        return CGUIButton::IsOfType(eType);
}

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

        PropList.AddPropSeparator(this, "Menu (Entry)");
        EPropertyCombo *pSelectedCombo = PropList.AddPropCombo(this, "Selected", &m_iCurSel);
        pSelectedCombo->AddString("New Item...", 1000);

        int Count = 0;
        CGUIElement *pIter = begin();
        set_ptr(pIter);

        while(pIter !=NULL)
        {
                if(pIter->GetType() == GUI_Button)
                {
                        CString tmp;
                        tmp.Format("%d", Count);
                        pSelectedCombo->AddString(tmp, Count);
                        Count++;
                }

                pIter = next();
        }

        if(!IsAutoCalc())
        {
                PropList.AddPropInt(this, "H. Offset", &m_iHExpand)->SetComment("H. Offset");
                PropList.AddPropInt(this, "V. Offset", &m_iVExpand)->SetComment("V. Offset");
        }

        else
        {
                EPropertyCombo *pHExpandCombo = PropList.AddPropCombo(this, "H. Expand", &m_iHExpand);
                pHExpandCombo->AddString("Left", -1);
                pHExpandCombo->AddString("None", 0);
                pHExpandCombo->AddString("Right", 1);

                EPropertyCombo *pVExpandCombo = PropList.AddPropCombo(this, "V. Expand", &m_iVExpand);
                pVExpandCombo->AddString("Up", 1);
                pVExpandCombo->AddString("None", 0);
                pVExpandCombo->AddString("Down", -1);
        }
}

void CGUIMenuEntry::Destroy()
{

}

bool CGUIMenuEntry::PointInChildRects()
{
        UINT x = CInputEngine::GetSingleton().GetMouse()->GetCursorPos().x;
        UINT y = CInputEngine::GetSingleton().GetMouse()->GetCursorPos().y;
        
        CGUIElement *pIter = begin();
        set_ptr(pIter);

        while(pIter !=NULL)
        {
                if(pIter->GetType() == GUI_MenuEntry)
                {
                        if(PointInRect(pIter->GetRect(), x, y) && pIter->Visible())
                                return true;
                        else if(((CGUIMenuEntry *)pIter)->PointInChildRects())
                                return true;
                }

                pIter = next();
        }

        return false;
}

---