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

// GUIListBox.cpp: implementation of the CGUIListBox class.
//
#include "StdAfx.h"
#include "GUI.h"

// Construction/Destruction

CGUIListBox::CGUIListBox()
{
        Initialize();
}

CGUIListBox::~CGUIListBox()
{

}

void CGUIListBox::Initialize()
{
        m_iSpacing = 1;
        m_iListType = 0;
        m_iCurSel = -1;
        SetType(GUI_ListBox);

        m_strElementType = "ListBox";
}

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

        if(pDefaultEntryBtn !=NULL)
        {
                if(!IsChild(pDefaultEntryBtn))
                {
                        pDefaultEntryBtn->SetParent(this);
                        pDefaultEntryBtn->RemoveChild(pDefaultEntryBtn->GetChild(GUI_Border));

                        push_back(pDefaultEntryBtn);
                }
        }

        return Resize(WidgetRect);
}

int CGUIListBox::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;

        pcValue = pXMLElement->Attribute("CurSel");
        if(pcValue !=NULL)
        {
                SetCurSel(atoi(pcValue));
                pcValue = NULL;
        }
        else
        {
                CGlobalLogger::GetSingleton().Write("\t**********General Warning\t**********\n");
                CGlobalLogger::GetSingleton().Write("ListBox (Name: %s, ID: %d) doesn't have Current iSelection (CurSel) Attribute specified. Assuming default...", GetName(), GetID());
        }

        return iRetValue;
}

int CGUIListBox::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("ListBox");

        pSaveXMLElement->SetAttribute("Type", m_iListType);
        pSaveXMLElement->SetAttribute("CurSel", m_iCurSel);
        pSaveXMLElement->SetAttribute("Spacing", m_iSpacing);

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

        if(pDataNode == NULL)
                SAFEDEL(pSaveXMLElement)

        return iRetValue;
}

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

        while(pIter !=NULL)
        {
                if(pIter->GetChild(GUI_Border) !=NULL)
                        pIter->RemoveChild(pIter->GetChild(GUI_Border));

                pIter = next();
        }

        CGUIElement::Draw();
}

void CGUIListBox::ProcessMessage(tGUIMessage& Message)
{
        switch(Message.uiMessage)
        {
        case GUI_Message_ButtonPressed:
                {
                        if((Message.pSender == this) || IsChild(Message.pSender))       // If this button is a child of a listbox, do:
                        {
                                UINT Count = 0;; // Find it by count and set current selection (by index count)
                                for (UINT i=0; i<GetChildCount(); i++)
                                {
                                        CGUIElement *pElement = GetChild(i);
                                        if(pElement->GetType() == GUI_Button)
                                        {
                                                if(Message.pSender == pElement)
                                                {
                                                        SetCurSel(Count);
                                                        break;
                                                }
                                                Count++;
                                        }
                                }
                        }

                        break;
                }

                // Resize/move buttons if listbox was moved!
        case GUI_Message_MoveX:
        case GUI_Message_MoveY:
        case GUI_Message_MoveXY:
                {
                        if(Message.pSender == this)
                                Resize(GetRect());
                        break;
                }
        }
}

int CGUIListBox::Resize(tRect& NewRect)
{
        UINT iRetValue = CGUIElement::Resize(NewRect);

        UINT MaxWidth = 0;

        if(m_iListType == 1) // maximize listbox to maximum length entry in it
        {
                // Find longest text entry size
                for (UINT i=0; i<GetChildCount(); i++)
                {
                        UINT MaxWidth = 0;
                        tRect PrevRect = GetRect();

                        CGUIElement *pElement = GetChild(i);

                        if(pElement->GetType() == GUI_Button)
                        {
                                CGUIButton *pButton = (CGUIButton *)pElement;

                                if(pButton->GetFont() !=NULL)
                                {
                                        CBitmapFont *pBitmapFont = (CBitmapFont *)pButton->GetFont();
                                        for (UINT i=0; i<pButton->GetLineCount(); i++)
                                        {
                                                UINT LineLength = pButton->GetLineLength(i);
                                                if(LineLength > MaxWidth)
                                                        MaxWidth = LineLength;
                                        }
                                }
                        }
                }

                tRect CurrentRect = GetRect();
                tRect NewThisRect = CurrentRect;
                NewThisRect.right = NewThisRect.left + MaxWidth;
                SetRect(NewThisRect);
        }


        tRect PrevRect = GetRect();
        PrevRect.bottom = PrevRect.top;

        // Find longest text entry size
        for (UINT i=0; i<GetChildCount(); i++)
        {
                CGUIElement *pElement = GetChild(i);

                if(pElement->GetType() == GUI_Button)
                {
                        CGUIButton *pButton = (CGUIButton *)pElement;

                        if(pButton->GetFont() !=NULL)
                        {
                                CBitmapFont *pBitmapFont = (CBitmapFont *)pButton->GetFont();

                                tRect NewEntryRect;
                                NewEntryRect.left = GetRect().left;
                                NewEntryRect.right = GetRect().right;
                                NewEntryRect.top = PrevRect.bottom - m_iSpacing;
                                NewEntryRect.bottom = NewEntryRect.top - pBitmapFont->GetQuadHeight() - 1;

                                pButton->SetRect(NewEntryRect);
                                
                                if(((NewEntryRect.top > GetRect().bottom) && (NewEntryRect.bottom < GetRect().bottom)) || NewEntryRect.top <= GetRect().bottom)
                                {
                                        pButton->Hide();
                                        pButton->HideText();
                                }
                                else
                                {
                                        pButton->Show();
                                        pButton->ShowText();
                                }

                                PrevRect = NewEntryRect;
                        }
                }
        }

        return iRetValue;
}

void CGUIListBox::SetCurSel(int iSelection)
{
        if(iSelection >=0)
        {
                UINT Count = 0;
                CGUIElement *pIterElement = begin();
                set_ptr(pIterElement);

                while(pIterElement !=NULL)
                {
                        if(pIterElement->GetType() == GUI_Button)
                        {
                                if(Count == iSelection)
                                        ((CGUIButton *)pIterElement)->SetState(false, 1);
                                else
                                        ((CGUIButton *)pIterElement)->SetState(false, 0);

                                Count++;
                        }

                        pIterElement = next();
                }
        }
}

int CGUIListBox::GetCurSel()
{
        return m_iCurSel;
}

CGUIElement *CGUIListBox::InsertItem(CString& strItemText, UINT uiInsertAfter)
{
        CGUIButton *pNewEntry = new CGUIButton();
        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);
                        push_back(pNewEntry);

                        Resize(GetRect());

                        return pNewEntry;
                }
        }
        
        return NULL;
}

bool CGUIListBox::IsOfType(eEntityType eType)
{
        if(eType == Entity_GUIListBox)
                return true;

        return CGUIElement::IsOfType(eType);
}

bool CGUIListBox::PropertyChanging( const void* pvProperty , void* pvNewValue )
{
        bool bChangeOK = CGUIElement::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;
                }
                else
                        SetCurSel(TempNewValue);
        }

        return bChangeOK;
}

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

        PropList.AddTab("ListBox");
        PropList.AddPropInt(this, "Spacing", &m_iSpacing);

        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();
        }

        PropList.AddPropSeparator(this, "Adjustments");
        EPropertyCombo *pAdjustCombo = PropList.AddPropCombo(this, "Options", &m_iListType);
        pAdjustCombo->AddString("Same Width", 0);
        pAdjustCombo->AddString("Lengthiest", 1);
}

---