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

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

CGUIStatic::CGUIStatic()
{
        SetEntityType(Entity_GUIStatic);
        SetType(GUI_Static);
        Initialize();
}

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

void CGUIStatic::Initialize()
{
        m_iHorizontalAlign = 0;
        m_iVerticalAlign = 0;
        m_strText = "";
        m_TextPos = tVERTEX2d(0, 0);
        m_strFontName = "";
        m_strFontFilename = "";
        m_iFontIndex = 0;
        m_pFont = NULL;
        m_bTextVisible = true;

        m_strElementType = "Static";
}

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

        if(pFont !=NULL && m_pFont == NULL)
                m_pFont = pFont;

        return 1;
}

int CGUIStatic::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("Text");
        if(pcValue !=NULL)
        {
                m_strText = CString(pcValue);
                pcValue = NULL;
        }

        pcValue = pXMLElement->Attribute("VAlign");
        if(pcValue !=NULL)
        {
                if(stricmp(pcValue, "top") == 0)
                        m_iVerticalAlign = Vertical_Align_Top;
                else if(stricmp(pcValue, "center") == 0)
                        m_iVerticalAlign = Vertical_Align_Center;
                else if(stricmp(pcValue, "bottom") == 0)
                        m_iVerticalAlign = Vertical_Align_Bottom;

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

        pcValue = pXMLElement->Attribute("HAlign");
        if(pcValue !=NULL)
        {
                if(stricmp(pcValue, "left") == 0)
                        m_iHorizontalAlign = Horizontal_Align_Left;
                else if(stricmp(pcValue, "center") == 0)
                        m_iHorizontalAlign = Horizontal_Align_Center;
                else if(stricmp(pcValue, "right") == 0)
                        m_iHorizontalAlign = Horizontal_Align_Right;

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

        CCustomFont *pNewFont = CFontManager::GetSingleton().LoadResource(pXMLElement, "");
        if(pNewFont !=NULL)
                m_pFont = pNewFont;
        else
        {
                CGlobalLogger::GetSingleton().Write("\t**********General Warning\t**********\n");
                CGlobalLogger::GetSingleton().Write("Static Control (Name: %s, ID: %d) doesn't have Font Attribute (FontByName, FontByID) specified. Assuming default...", GetName(), GetID());
        }

        return 1;       // All went OK, return 1
}

int CGUIStatic::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("Static");

        if(m_pFont !=NULL)
                pSaveXMLElement->SetAttribute("FontByName", m_pFont->GetName());

        if(m_strText !="")
                pSaveXMLElement->SetAttribute("Text", m_strText);

        if(m_iHorizontalAlign == Horizontal_Align_Left)
                pSaveXMLElement->SetAttribute("HAlign", "Left");
        else if(m_iHorizontalAlign == Horizontal_Align_Center)
                pSaveXMLElement->SetAttribute("HAlign", "Center");
        else if(m_iHorizontalAlign == Horizontal_Align_Right)
                pSaveXMLElement->SetAttribute("HAlign", "Right");

        if(m_iVerticalAlign == Vertical_Align_Top)
                pSaveXMLElement->SetAttribute("VAlign", "Top");
        else if(m_iVerticalAlign == Horizontal_Align_Center)
                pSaveXMLElement->SetAttribute("VAlign", "Center");
        else if(m_iVerticalAlign == Vertical_Align_Bottom)
                pSaveXMLElement->SetAttribute("VAlign", "Bottom");

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

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

                return iRetValue;
        }

        return iRetValue;
}

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

        return iRetValue;
}

void CGUIStatic::Draw()
{
        CGUIElement::Draw();
        
        if(m_bTextVisible)
                DrawText();
}

void CGUIStatic::DrawText()
{
        if(m_strText == "" || m_pFont == NULL)
                return;

        if(m_pFont->GetFontType() == Bitmap_Font)
        {
                CBitmapFont *pBitmapFont = (CBitmapFont *)m_pFont;

                for (int i=0; i<GetLineCount(); i++)
                {
                        CString Line = "";

                        UINT TextWidth = GetLineLength(i) * pBitmapFont->GetQuadLength();

                        if(TextWidth >=GetWidth())
                                Line = CString(GetLine(i, GetWidth() / pBitmapFont->GetQuadLength()));
                        else
                                Line = GetLine(i, GetLineLength(i));

                        // This part is the most important one:
                        // Here we are aquiring alignment units (x & y)
                        int AlignXPixels = 0, AlignYPixels = 0;

                        int MaxWidthCharacters = (GetWidth() / pBitmapFont->GetQuadLength()) + 1;
                        int MaxHeightCharacters = (GetHeight() / pBitmapFont->GetQuadHeight()) + 1;

                        // If horizontal alignment is 'left'(0), there is no displacement for text then (alignx = 0)
                        if(m_iHorizontalAlign == Horizontal_Align_Left)
                                AlignXPixels = 0;

                        // If horizontal alignment is for center, then we calculate the displacement as:
                        // alignx = (Total Control Width - (Number Of Chars In Line * Character Width) / 2)
                        // because we want text to be in horizontal center of the control
                        if(m_iHorizontalAlign == Horizontal_Align_Center)
                                AlignXPixels = (GetWidth()- (Line.GetLength() * pBitmapFont->GetQuadLength())) / 2;

                        // If horizontal alignment is right, the displacement is:
                        // alignx = Total Control Width - (Number Of Chars * Character Width)
                        // because we want text to be on the right - e.g rightmost character will be right near
                        // right side of control
                        if(m_iHorizontalAlign == Horizontal_Align_Right)
                                AlignXPixels = GetWidth() - (Line.GetLength() * pBitmapFont->GetQuadLength());

                        // If the vertical alignment is top(0), we do not displace text down at all
                        if(m_iVerticalAlign == Vertical_Align_Top)
                                AlignYPixels = 0;

                        // If the vertical alignment is middle(1), we displace each Line by:
                        // aligny = (Total Number of Lines - Line Count) / 2 * Character Height
                        // If the total lines visible is 1, or there's only 1 Line, the align is in pixels, not lines
                        if(m_iVerticalAlign == Vertical_Align_Center)
                        {
                                UINT LineCount = GetLineCount();
                                UINT FontHeight = pBitmapFont->GetQuadHeight();
                                UINT TextHeight = LineCount * FontHeight;
                                if(TextHeight >=GetHeight())    // If there is more lines of text that total height of static, do not align
                                        break;
                                else
                                        AlignYPixels = (GetHeight() - TextHeight) / 2;

                                // A one Line text, align in pixels!
                                //if((GetHeight() > pBitmapFont->GetQuadHeight()) && (GetHeight() <= 2*pBitmapFont->GetQuadHeight()))
                                //AlignYPixels = (GetHeight() - pBitmapFont->GetQuadHeight()) / 2;
                                //else // More than one Line, align in lines!
                                //      AlignYPixels = ((MaxHeightCharacters - GetLineCount()) / 2) * pBitmapFont->GetQuadHeight();
                        }

                        // If the vertical alignment is bottom(2), we displace each Line by:
                        // aligny = (Total Number of Lines - Line Count) * Character Height
                        if(m_iVerticalAlign == Vertical_Align_Bottom)
                                AlignYPixels = (MaxHeightCharacters - GetLineCount()) * pBitmapFont->GetQuadHeight();

                        // Now we align each Line by assigning text position
                        m_TextPos.x = GetRect().left + AlignXPixels;
                        m_TextPos.y = GetRect().top - (i+1)*pBitmapFont->GetQuadHeight() - AlignYPixels;

                        // Ensure that we don't print text that's outside control (top & bottom side check)
                        if((m_TextPos.y) >= GetRect().bottom && (m_TextPos.y + pBitmapFont->GetQuadHeight()) <= GetRect().top)
                        {
                                pBitmapFont->SetTextPos(m_TextPos.x, m_TextPos.y);
                                pBitmapFont->Draw(Line.GetBuffer());
                        }
                }
        }
}

void CGUIStatic::SetText(CString& strText)
{
        m_strText = strText;
}


CString& CGUIStatic::GetText()
{
        return m_strText;
}

UINT CGUIStatic::GetLineLength(UINT uiIndex)
{
        UINT uiLineNumber = 0;
        UINT uiCharacterCount = 0;

        for (UINT i=0; i<m_strText.GetLength(); i++)
        {
                if(m_strText.GetAt(i) == '\n')
                        uiLineNumber++;

                if(uiIndex == uiLineNumber)
                {
                        if(m_strText.GetAt(i) !='\n')
                                uiCharacterCount++;
                }

                if(uiCharacterCount > 0 && m_strText.GetAt(i) == '\n')
                        return uiCharacterCount;
        }

        return uiCharacterCount;
}

const CCustomFont *CGUIStatic::GetFont()
{
        return m_pFont;
}

void CGUIStatic::SetFont(CBitmapFont *pFont)
{
        m_pFont = pFont;
}

UINT CGUIStatic::GetTextLength()
{
        return m_strText.GetLength();
}

UINT CGUIStatic::GetLineCount()
{
        UINT LineCount = 0;
        for (UINT i=0; i<m_strText.GetLength(); i++)
        {
                if(m_strText.GetAt(i) == '\n')
                        LineCount++;
        }

        return LineCount + 1;
}

CString CGUIStatic::GetLine(UINT uiLine, UINT uiCharacterCount)
{
        UINT uiLineIndex = 0;
        UINT LineLength = GetLineLength(uiLine);

        UINT CharPtr = 0;
        char buf[256] = "";
        for (UINT i=0; i<m_strText.GetLength(); i++)
        {
                if(m_strText.GetAt(i) == '\n')
                        uiLineIndex++;

                if(uiLineIndex == uiLine)
                {
                        CharPtr = i;
                        break;
                }
        }

        if(uiLineIndex !=0)
                CharPtr+=uiLineIndex;

        UINT Count = 0;
        for (UINT j=CharPtr; j<CharPtr + uiCharacterCount; j++)
        {
                buf[Count] = m_strText.GetAt(j);
                Count++;
        }

        return CString(buf);
}

void CGUIStatic::ShowText()
{
        m_bTextVisible = true;
}

void CGUIStatic::HideText()
{
        m_bTextVisible = false;
}

bool CGUIStatic::IsOfType(eEntityType eType)
{
        if(eType == Entity_GUIStatic)
                return true;

        return CGUIElement::IsOfType(eType);
}

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

        if(pvProperty == &m_iFontIndex)
        {
                if(m_iFontIndex !=1000)
                {
                        m_iFontIndex = *(int *)pvNewValue;
                        m_pFont = CFontManager::GetSingleton().GetResource(m_iFontIndex);
                }
        }

        return bChangeOK;
}

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

        PropList.AddTab("Static/Textbox");
        PropList.AddPropSeparator(this, "Font");
        EPropertyCombo *pFontCombo = (EPropertyCombo *)PropList.AddPropCombo(this, "From Database...", &m_iFontIndex)->SetComment("Font selection");
        for (int i=0; i<CFontManager::GetSingleton().size(); i++)
        {
                CCustomFont *pFont = (CCustomFont *)CFontManager::GetSingleton().at(i);
                pFontCombo->AddString(pFont->GetName(), i);
        }
        if(m_iFontIndex > 0)
        {
                PropList.AddPropString(this, "strFilename", &m_strFontFilename, false)->SetComment("Font' strFilename");
                PropList.AddPropString(this, "strName", &m_strFontName, false)->SetComment("Font' name");

        }
        else
        {
                PropList.AddPropFile(this, "strFilename", &m_strFontFilename, "XML Files (*.xml)|*.xml|All Files (*.*)|*.*||")->SetComment("Font' strFilename");
                PropList.AddPropString(this, "strName", &m_strFontName, true)->SetComment("Font' name");
        }

        EPropertyCombo *pHAlignCombo = PropList.AddPropCombo(this, "H. Align", &m_iHorizontalAlign);
        pHAlignCombo->AddString("Left");
        pHAlignCombo->AddString("Center");
        pHAlignCombo->AddString("Right");

        EPropertyCombo *pVAlignCombo = PropList.AddPropCombo(this, "V. Align", &m_iVerticalAlign);
        pVAlignCombo->AddString("Top");
        pVAlignCombo->AddString("Middle");
        pVAlignCombo->AddString("bottom");
        
        PropList.AddPropCheck(this, "Show Text", &m_bTextVisible);
        PropList.AddPropTextblock(this, "Text", &m_strText, true);
}

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

---