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

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

CGUIElement::CGUIElement()
{
        SetEntityType(Entity_GUIElement);
        Initialize();
        m_pParent = NULL;

        m_strElementType = "Element";
        m_iMaterialIndex = m_iTextureIndex = 1000;
        m_iMaterialShininess = 0;
        SetType(GUI_Element);
        m_pTexture = NULL;
        m_pMaterial = NULL;
}

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

void CGUIElement::Initialize()
{
        m_pGUI = NULL;
        m_dwFlags = 0;
        m_pMaterial = NULL;
        m_pTexture = NULL;

        m_TexCoord[0].x = 0;
        m_TexCoord[0].y = 1;

        m_TexCoord[1].x = 1;
        m_TexCoord[1].y = 1;

        m_TexCoord[2].x = 1;
        m_TexCoord[2].y = 0;

        m_TexCoord[3].x = 0;
        m_TexCoord[3].y = 0;

        m_bAutoCalc = m_bAllowSizeX = m_bAllowSizeY = m_bAllowMoveX = m_bAllowMoveY = true;
        m_bVisible = true;
}

int CGUIElement::Create(CGUIElement *pParent, tRect WidgetRect, CTexture *pTexture, CMaterial *pMaterial, bool bBorder)
{
        if(pParent == NULL)
                return 0;

        SetParent(pParent);
        SetRect(WidgetRect);

        if(m_pTexture == NULL && pTexture !=NULL)
                m_pTexture = pTexture;

        if(m_pMaterial == NULL && pMaterial !=NULL)
                m_pMaterial = pMaterial;

        if(GetGUI() !=NULL)
        {
                //if(bBorder && GetChild(GUI_Border) == NULL)
                //      push_back(GetGUI()->AddBorder());
        }

        return 1;
}

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

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

        pXMLElement = m_pXMLElement;

        pcValue = pXMLElement->Attribute("Rect");
        if(pcValue !=NULL)
        {
                sscanf(pcValue, "%d,%d,%d,%d", &m_Rect.left, &m_Rect.right, &m_Rect.top, &m_Rect.bottom);
                pcValue = NULL;
        }
        else
        {
                pcValue = pXMLElement->Attribute("XPos");
                if(pcValue !=NULL)
                {
                        m_Rect.left = atoi(pcValue);
                        pcValue = NULL;
                }
                else
                {
                        CGlobalLogger::GetSingleton().Write("\n\t\t!!!!!!!!!!General Error!!!!!!!!!!!!\n");
                        CGlobalLogger::GetSingleton().Write("Element (Type: %s, Name: %s, ID: %d) doesn't have Rectangle X Position in absence of \"Rect\" Attribute.", m_strElementType, GetName(), GetID());
                }

                pcValue = pXMLElement->Attribute("YPos");
                if(pcValue !=NULL)
                {
                        m_Rect.top = atoi(pcValue);
                        pcValue = NULL;
                }
                else
                {
                        CGlobalLogger::GetSingleton().Write("\n\t\t!!!!!!!!!!General Error!!!!!!!!!!!!\n");
                        CGlobalLogger::GetSingleton().Write("Element (Type: %s, Name: %s, ID: %d) doesn't have Rectangle Y Position in absence of \"Rect\" Attribute.", m_strElementType, GetName(), GetID());
                }

                pcValue = pXMLElement->Attribute("Width");
                if(pcValue !=NULL)
                {
                        m_Rect.right = m_Rect.left + atoi(pcValue);
                        pcValue = NULL;
                }
                else
                {
                        CGlobalLogger::GetSingleton().Write("\n\t\t!!!!!!!!!!General Error!!!!!!!!!!!!\n");
                        CGlobalLogger::GetSingleton().Write("Element (Type: %s, Name: %s, ID: %d) doesn't have Width Attribute in absence of \"Rect\" Attribute.", m_strElementType, GetName(), GetID());
                }

                pcValue = pXMLElement->Attribute("Height");
                if(pcValue !=NULL)
                {
                        m_Rect.bottom = m_Rect.top - atoi(pcValue);
                        pcValue = NULL;
                }
                else
                {
                        CGlobalLogger::GetSingleton().Write("\n\t\t!!!!!!!!!!General Error!!!!!!!!!!!!\n");
                        CGlobalLogger::GetSingleton().Write("Element (Type: %s, Name: %s, ID: %d) doesn't have Height Attribute in absence of \"Rect\" Attribute.", m_strElementType, GetName(), GetID());
                }
        }

        pcValue = pXMLElement->Attribute("MovementFlags");
        if(pcValue !=NULL)
        {
                int RestrictX = 0, RestrictY = 0;
                sscanf(pcValue, "%d,%d", &RestrictX, &RestrictY);

                if(RestrictX)
                {
                        m_bAllowMoveX = false;
                        m_dwFlags &= GUI_Flag_RestrictMovementX;
                }

                if(RestrictY)
                {
                        m_bAllowMoveY = false;
                        m_dwFlags &= GUI_Flag_RestrictMovementY;
                }

                pcValue = NULL;
        }

        pcValue = pXMLElement->Attribute("ResizeFlags");
        if(pcValue !=NULL)
        {
                int ResizeX = 0, ResizeY = 0;
                sscanf(pcValue, "%d,%d", &ResizeX, &ResizeY);

                if(ResizeX)
                {
                        m_bAllowSizeX = false;
                        m_dwFlags &= GUI_Flag_RestrictSizeX;
                }

                if(ResizeY)
                {
                        m_bAllowSizeY = false;
                        m_dwFlags &= GUI_Flag_RestrictSizeY;
                }

                pcValue = NULL;
        }

        pcValue = pXMLElement->Attribute("UV");
        if(pcValue !=NULL)
        {
                sscanf(pcValue, "(%f,%f),(%f,%f),(%f,%f),(%f,%f)", 
                        &m_TexCoord[0].x, &m_TexCoord[0].y,
                        &m_TexCoord[1].x, &m_TexCoord[1].y, 
                        &m_TexCoord[2].x, &m_TexCoord[2].y, 
                        &m_TexCoord[3].x, &m_TexCoord[3].y);

                pcValue = NULL;
        }

        CTexture *pNewTexture = CTextureManager::GetSingleton().LoadResource(m_pXMLElement, "");
        if(pNewTexture !=NULL)
                m_pTexture = pNewTexture;

        CMaterial *pNewMaterial = CMaterialManager::GetSingleton().LoadResource(m_pXMLElement, "");
        if(pNewMaterial !=NULL)
                m_pMaterial = pNewMaterial;

        // LoadXML widgets
        UINT WidgetCount = 0;
        TiXmlNode *pIterXMLNode = pXMLElement->FirstChild();
        while(pIterXMLNode !=NULL)
        {
                CGUIElement *NewWidget = NULL;
                if(stricmp(pIterXMLNode->pcValue(), "Element") == 0)
                        NewWidget = new CGUIElement;
                else if(stricmp(pIterXMLNode->pcValue(), "Border") == 0)
                        NewWidget = new CGUIBorder;
                else if(stricmp(pIterXMLNode->pcValue(), "Element") == 0)
                        NewWidget = new CGUIElement;
                else if(stricmp(pIterXMLNode->pcValue(), "Static") == 0)
                        NewWidget = new CGUIStatic;
                else if(stricmp(pIterXMLNode->pcValue(), "TextBox") == 0)
                        NewWidget = new CGUITextBox;
                else if(stricmp(pIterXMLNode->pcValue(), "Button") == 0)
                        NewWidget = new CGUIButton;
                else if(stricmp(pIterXMLNode->pcValue(), "ScrollBar") == 0)
                        NewWidget = new CGUIScrollBar;
                else if(stricmp(pIterXMLNode->pcValue(), "ProgressBar") == 0)
                        NewWidget = new CGUIProgressBar;
                else if(stricmp(pIterXMLNode->pcValue(), "DropList") == 0)
                        NewWidget = new CGUIDropList;
                else if(stricmp(pIterXMLNode->pcValue(), "RadioGroup") == 0)
                        NewWidget = new CGUIRadioGroup;
                else if(stricmp(pIterXMLNode->pcValue(), "ListBox") == 0)
                        NewWidget = new CGUIListBox;
                else if(stricmp(pIterXMLNode->pcValue(), "MenuEntry") == 0)
                        NewWidget = new CGUIMenuEntry;
                else if(stricmp(pIterXMLNode->pcValue(), "Menu") == 0)
                        NewWidget = new CGUIMenu;
                else if(stricmp(pIterXMLNode->pcValue(), "TabControl") == 0)
                        NewWidget = new CGUITabControl;
                else if(stricmp(pIterXMLNode->pcValue(), "Window") == 0)
                        NewWidget = new CGUIWindow;

                
                if(NewWidget !=NULL)
                {
                        NewWidget->SetParent(this);

                        if(NewWidget->LoadXML(pIterXMLNode, ""))
                        {
                                push_back(NewWidget);
                                WidgetCount++;
                        }
                }

                pIterXMLNode = pXMLElement->IterateChildren(pIterXMLNode);
        }

        Resize(m_Rect);
        return 1;       // All went OK, return 1
}

int CGUIElement::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("Element");

        // Parse our element' rectangle data
        if(GetParent() !=NULL)
        {
                if(GetParent()->GetType() !=GUI_Border)
                {
                        if(!(m_Rect.left == 0 && m_Rect.right == 0 && m_Rect.top == 0 && m_Rect.bottom == 0))
                        {
                                sprintf(Buf, "%i,%i,%i,%i", m_Rect.left, m_Rect.right, m_Rect.top, m_Rect.bottom);
                                pSaveXMLElement->SetAttribute("Rect", Buf);

                                memset(Buf, 0, sizeof(char) * 128);
                        }
                }
        }

        if(GetName() !="")
                pSaveXMLElement->SetAttribute("strName", GetName());

        pSaveXMLElement->SetAttribute("Visible", (int)Visible());

        if(GetID() !=0)
        {
                sprintf((char *)Buf, "%d", GetID());
                pSaveXMLElement->SetAttribute("uiID", Buf);

                memset(Buf, 0, sizeof(char) * 128);
        }

        memset(Buf, 0, sizeof(char) * 128);

        sprintf(Buf, "%d,%d", (int)!m_bAllowMoveX, (int)!m_bAllowMoveY);
        pSaveXMLElement->SetAttribute("MovementFlags", (char *)Buf);

        sprintf(Buf, "%d,%d", (int)!m_bAllowSizeX, (int)!m_bAllowSizeY);
        pSaveXMLElement->SetAttribute("ResizeFlags", (char *)Buf);

        memset(Buf, 0, sizeof(char) * 128);

#ifdef GUI_USE_ACTIVE_INACTIVE

        if(m_ActiveColor != GUI_DEFAULT_ACTIVE_COLOR)
        {
                sprintf(Buf, "%d,%d,%d", m_ActiveColor.r, m_ActiveColor.g, m_ActiveColor.b);
                pSaveXMLElement->SetAttribute("ActiveColor", Buf);
        }

        if(m_InactiveColor !=GUI_DEFAULT_INACTIVE_COLOR)
        {
                memset(Buf, 0, sizeof(char) * 128);
                sprintf(Buf, "%d,%d,%d", m_InactiveColor.r, m_InactiveColor.g, m_InactiveColor.b);
                pSaveXMLElement->SetAttribute("InactiveColor", Buf);
        }
#else
        if(m_pMaterial !=NULL)
                pSaveXMLElement->SetAttribute("MatByName", m_pMaterial->GetName());
#endif

        if(m_pTexture !=NULL)
                pSaveXMLElement->SetAttribute("TexByName", m_pTexture->GetName());

        if((m_TexCoord[0].x !=0 && m_TexCoord[0].y !=1) &&
                (m_TexCoord[1].x !=1 && m_TexCoord[1].y !=1) &&
                (m_TexCoord[2].x !=1 && m_TexCoord[2].y !=0) &&
                (m_TexCoord[3].x !=0 && m_TexCoord[3].y !=0))
        {
                sprintf(Buf, "(%f,%f),(%f,%f),(%f,%f),(%f,%f)", 
                        m_TexCoord[0].x, m_TexCoord[0].y,
                        m_TexCoord[1].x, m_TexCoord[1].y, 
                        m_TexCoord[2].x, m_TexCoord[2].y, 
                        m_TexCoord[3].x, m_TexCoord[3].y);

                pSaveXMLElement->SetAttribute("UV", Buf);

                memset(Buf, 0, sizeof(char) * 128);
        }

        CGUIElement *pIterElement = begin();
        set_ptr(pIterElement);

        while(pIterElement !=NULL)
        {
                TiXmlElement SaveChildXMLElement(pIterElement->m_strElementType);
                pIterElement->SaveXML(&SaveChildXMLElement, "");

                pSaveXMLElement->InsertEndChild(SaveChildXMLElement);
                pIterElement = next();
        }

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

                return iRetValue;
        }

        return 1;
}

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

        while(IterElement !=NULL)
        {
                if(IterElement->OnLMouseDown(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)     // process it if its not a GUI
        {
                if(PointInRect(GetRect(), x, y))        // If the click was inside the rectangle
                {
                        GetGUI()->SetActiveElement(this);       // Set this as an active element. This also calls PostMessage in AquireFocus
                        GetGUI()->Lock();
                        return 1;
                }
        }

        return 0;
}

int CGUIElement::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(PointInRect(GetRect(), x, y))
                {
                        GetGUI()->PostMessage(this, NULL, GUI_Message_AquireFocus);
                        return 1;
                }
        }

        return 0;
}

int CGUIElement::OnMouseMove(UINT x, UINT y)
{
        if(x == 0 && y == 0)
                return 0;

        int iRetValue = 0;
        CGUIElement *IterElement = end();
        set_ptr(IterElement);

        while(IterElement !=NULL)
        {
                iRetValue|=IterElement->OnMouseMove(x, y);
                IterElement = prev();
        }

        if(GetType() !=GUI)
        {
                if(Visible())
                {
                        // Move this element if it has a lmousedown flag
                        if(GetGUI()->IsLocked())
                        {
                                tVERTEX2d CursorPos = CInputEngine::GetSingleton().GetMouse()->GetCursorPos();
                                tVERTEX2d PrevCursorPos = CInputEngine::GetSingleton().GetMouse()->GetPrevCursorPos();

                                if(GetGUI()->GetActiveElement() == this)
                                {
                                        OnMove(CursorPos.x - PrevCursorPos.x, CursorPos.y - PrevCursorPos.y);
                                        return 1;
                                }
                        }

                        if(PointInRect(m_Rect, x, y))
                                iRetValue = 1;
                }
        }

        return iRetValue;
}


int CGUIElement::OnRMouseDown(UINT x, UINT y)
{

        return 0;
}

int CGUIElement::OnRMouseUp(UINT x, UINT y)
{

        return 0;
}

int CGUIElement::OnMove(UINT x, UINT y)
{
        if(GetType() == GUI)
                return 0;

        int mx = GUI_Message_Default, my = GUI_Message_Default;
        if(Visible())
        {       
                // Resize this element according to its restriction flags
                if(m_bAllowMoveX && (x !=0))
                {
                        m_Rect.left+= x;
                        m_Rect.right+= x;
                        mx = GUI_Message_MoveX;
                }

                if(m_bAllowMoveY && (y !=0))
                {
                        m_Rect.top+= y;
                        m_Rect.bottom+= y;
                        my = GUI_Message_MoveY;
                }
        }

        if(mx != GUI_Message_Default && my != GUI_Message_Default)
        {
                GetGUI()->PostMessage(this, NULL, GUI_Message_MoveXY, x, y);
                return GUI_Message_MoveXY;
        }
        else if(mx == GUI_Message_MoveX && my == GUI_Message_Default)
        {
                GetGUI()->PostMessage(this, NULL, GUI_Message_MoveX, x, 0);
                return GUI_Message_MoveX;
        }
        else if(my == GUI_Message_MoveY && mx == GUI_Message_Default)
        {
                GetGUI()->PostMessage(this, NULL, GUI_Message_MoveY, 0, y);
                return GUI_Message_MoveY;
        }

        return 0;
}

void CGUIElement::Draw()
{
        if(!Visible())
                return;

        int left = m_Rect.left;
        int right = m_Rect.right;
        int top = m_Rect.top;
        int bottom = m_Rect.bottom;

        if(m_pTexture == NULL)
        {
                glDisable(GL_TEXTURE_2D);

                if(m_pMaterial !=NULL)
                {
                        glDisable(GL_LIGHTING);
                        glColor4fv(m_pMaterial->GetAmbient().RGBA);
                        // m_pMaterial->Bind();
                }
                else
                {
                        glDisable(GL_LIGHTING);
                        glColor3d(255, 255, 255);
                }

                glBegin(GL_QUADS);
                glVertex3d(left, bottom, 0);
                glVertex3d(right, bottom, 0);
                glVertex3d(right, top, 0);
                glVertex3d(left, top, 0);
                glEnd();
        }
        else
        {
                m_pTexture->Bind();

                if(m_pMaterial !=NULL)
                {
                        glDisable(GL_LIGHTING);
                        glColor3f(m_pMaterial->GetAmbient().R / 255.0f, m_pMaterial->GetAmbient().G / 255.0f, m_pMaterial->GetAmbient().B / 255.0f);
                        // m_pMaterial->Bind();
                }
                else
                        glColor3d(1, 1, 1);


                if(m_pTexture->IsMasked())
                {
                        glAlphaFunc(GL_GREATER, 0.0f);
                        glEnable(GL_ALPHA_TEST);
                }

                glBegin(GL_QUADS);
                //                              Bottom Left                                                     Bottom Left
                glTexCoord2f(m_TexCoord[0].x, m_TexCoord[0].y); glVertex3d(left, bottom, 0);
                //                              Bottom Right is Bottom Left                     Bottom Right
                glTexCoord2f(m_TexCoord[1].x, m_TexCoord[1].y); glVertex3d(right, bottom, 0);
                //                              Top Right is Bottom Right                       Top Right
                glTexCoord2f(m_TexCoord[2].x, m_TexCoord[2].y); glVertex3d(right, top, 0);
                //                              Top Left is Top Right                           Top Left
                glTexCoord2f(m_TexCoord[3].x, m_TexCoord[3].y); glVertex3d(left, top, 0);
                glEnd();

                if(m_pTexture->IsMasked())
                        glDisable(GL_ALPHA_TEST);
        }

        CGUIElement *Iter = begin();
        set_ptr(Iter);

        while(Iter !=NULL)
        {
                Iter->Draw();
                Iter = next();
        }
}

int CGUIElement::OnKeyUp(UINT uiKey)
{

        return 1;
}

int CGUIElement::OnKeyDown(UINT uiKey)
{

        return 1;
}

int CGUIElement::Resize(tRect& NewRect)
{
        int ResizeX = 0, ResizeY = 0;
        if((NewRect.right - NewRect.left) >= GUI_MINIMUM_WIDTH)
        {
                if((NewRect.top - NewRect.bottom) >= GUI_MINIMUM_HEIGHT)
                {
                        if(m_bAllowSizeY)
                        {
                                m_Rect.top = NewRect.top;
                                m_Rect.bottom = NewRect.bottom;
                                ResizeY = GUI_Message_SizeY;
                        }
                }

                if(m_bAllowSizeX)
                {
                        m_Rect.left = NewRect.left;
                        m_Rect.right = NewRect.right;
                        ResizeX = GUI_Message_SizeX;
                }
        }



        if(GetType() == GUI)
                return 1;

        if(ResizeX && ResizeY)
        {
                GetGUI()->PostMessage(this, GetChild(GUI_Border), GUI_Message_SizeXY);
                return GUI_Message_SizeXY;
        }

        if(ResizeX == GUI_Message_SizeX && ResizeY == 0)
        {
                GetGUI()->PostMessage(this, GetChild(GUI_Border), GUI_Message_SizeX);
                return GUI_Message_SizeX;
        }

        else if(ResizeY == GUI_Message_SizeY && ResizeX == 0)
        {
                GetGUI()->PostMessage(this, GetChild(GUI_Border), GUI_Message_SizeY);
                return GUI_Message_SizeY;
        }

        return 0;
}

void CGUIElement::SetType(eGUIControlType eWidgetType)
{
        m_eControlType = eWidgetType;
}

eGUIControlType& CGUIElement::GetType()
{
        return m_eControlType;
}

CGUI *CGUIElement::GetGUI()
{
        if(GetParent() !=NULL)
        {
                if(GetParent()->GetType() == GUI)
                        return (CGUI *)GetParent();
                else
                        return GetParent()->GetGUI();
        }

        return NULL;
}

void CGUIElement::SetGUI(CGUI *Root)
{
        m_pGUI = Root;
}

void CGUIElement::SetParent(CGUIElement *Parent)
{
        m_pParent = Parent;
}

CGUIElement *CGUIElement::GetParent()
{
        return m_pParent;
}

void CGUIElement::ProcessMessage(tGUIMessage& Message)
{

}

void CGUIElement::ProcessMessages()
{
        tGUIMessage *pMessage = NULL;

        for (UINT i=0; i<GetGUI()->GetMessageCount(); i++)
        {
                pMessage = GetGUI()->GetMessage(i);
                if(pMessage->uiMessage !=-1)
                        ProcessMessage(*pMessage);
        }

        CGUIElement *pIterElement = begin();
        set_ptr(pIterElement);

        while(pIterElement !=NULL)
        {
                pIterElement->ProcessMessages();
                pIterElement = next();
        }
}

tRect& CGUIElement::GetRect()
{
        return m_Rect;
}

UINT CGUIElement::GetHeight()
{
        return (m_Rect.top - m_Rect.bottom);
}

UINT CGUIElement::GetWidth()
{
        return (m_Rect.right - m_Rect.left);
}

void CGUIElement::SetHeight(UINT Height)
{
        m_Rect.bottom = m_Rect.top - Height;
}

void CGUIElement::SetTexCoord(UINT uiIndex, float U, float V)
{
        if(uiIndex >=0 && uiIndex < 4)
        {
                m_TexCoord[uiIndex].x = U;
                m_TexCoord[uiIndex].y = V;
        }
}

tVERTEX2f& CGUIElement::GetTexCoord(UINT uiIndex)
{
        if(uiIndex >=0 && uiIndex < 4)
                return m_TexCoord[uiIndex];

        return tVERTEX2f(-1, -1);
}

CGUIElement *CGUIElement::GetChild(eGUIControlType eWidgetType)
{
        CGUIElement *pIterElement = begin();
        set_ptr(pIterElement);

        while(pIterElement !=NULL)
        {
                if(pIterElement->GetType() == eWidgetType)
                        return pIterElement;

                pIterElement = next();
        }

        return NULL;
}

CGUIElement *CGUIElement::GetChild(UINT uiIndex)
{
        if(uiIndex >=0 && uiIndex < GetChildCount())
                return at(uiIndex);

        return NULL;
}

UINT CGUIElement::GetChildCount()
{
        return size();
}

CTexture *CGUIElement::GetTexture()
{
        return m_pTexture;
}

void CGUIElement::SetTexture(CTexture *pTexture)
{
        m_pTexture = pTexture;
}

CMaterial *CGUIElement::GetMaterial()
{
        return m_pMaterial;
}

void CGUIElement::SetMaterial(CMaterial *pMaterial)
{
        m_pMaterial = pMaterial;
}

void CGUIElement::HideSiblings(int iDeep)
{
        CGUIElement *pIterElement = begin();
        set_ptr(pIterElement);

        while(pIterElement !=NULL)
        {
                pIterElement->Hide();

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

                pIterElement = next();
        }
}

void CGUIElement::ShowSiblings(int iDeep)
{
        CGUIElement *pIterElement = begin();
        set_ptr(pIterElement);

        while(pIterElement !=NULL)
        {
                if(iDeep > 0)
                {
                        pIterElement->Show();
                        pIterElement->ShowSiblings(iDeep - 1);
                }
                else if(iDeep == -1)
                {
                        pIterElement->Show();
                        pIterElement->ShowSiblings(iDeep);
                }
                else if(iDeep == 0)
                        return;

                pIterElement = next();
        }
}

void CGUIElement::Show()
{
        m_bVisible = true;
}

void CGUIElement::Hide()
{
        m_bVisible = false;
}

bool CGUIElement::Visible()
{
        return m_bVisible;
}

void CGUIElement::SetFlag(eGUIFlag eFlag, bool bSet)
{
        if(eFlag == GUI_Flag_RestrictMovementX)
                m_bAllowMoveX = !bSet;
        else if(eFlag == GUI_Flag_RestrictMovementY)
                m_bAllowMoveY = !bSet;
        else if(eFlag == GUI_Flag_RestrictSizeX)
                m_bAllowSizeX = !bSet;
        else if(eFlag == GUI_Flag_RestrictSizeY)
                m_bAllowSizeY = !bSet;
}

bool CGUIElement::IsFlagSet(eGUIFlag eFlag)
{
        if(eFlag == GUI_Flag_RestrictMovementX)
                return m_bAllowMoveX;
        else if(eFlag == GUI_Flag_RestrictMovementY)
                return m_bAllowMoveY;
        else if(eFlag == GUI_Flag_RestrictSizeX)
                return m_bAllowSizeX;
        else if(eFlag == GUI_Flag_RestrictSizeY)
                return m_bAllowSizeY;

        return false;
}

bool CGUIElement::IsChild(CGUIElement *pElement)
{
        CGUIElement *pIterElement = begin();
        set_ptr(pIterElement);

        while(pIterElement !=NULL)
        {
                if(pIterElement == pElement)
                        return true;

                pIterElement = next();
        }

        return false;
}

// Retrieves/Moves element in parent' list of elements up to specified order index
void CGUIElement::SetZOrder(UINT uiZOrder)
{
        CGUIElement *pParent = GetParent();
        if(pParent !=NULL)
        {
                if(uiZOrder >=0 && uiZOrder < pParent->size())
                        pParent->move_to(uiZOrder, this);
        }
}

unsigned int CGUIElement::GetZOrder()
{
        CGUIElement *parent = GetParent();
        if(parent == 0)
                return 0;
        else
        {
                for (UINT i=0; i<parent->GetChildCount(); i++)
                {
                        if(parent->GetChild(i) == this)
                                return i;
                }
        }
        return 1;
}

void CGUIElement::SetRect(tRect& NewRect)
{
        m_Rect = NewRect;
}

void CGUIElement::RemoveChild(CGUIElement *pChild)
{
        if(pChild == NULL)
                return;

        CGUIElement *pIterElement = begin();
        set_ptr(pIterElement);

        while(pIterElement !=NULL)
        {
                if(pIterElement == pChild)
                {
                        delete remove(pChild);
                        return;
                }

                pIterElement = next();
        }
}

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

        if(pvProperty == &m_iMaterialIndex)
        {
                m_iMaterialIndex = *(int *)pvNewValue;
                if(m_iMaterialIndex!= 1000)
                        m_pMaterial = CMaterialManager::GetSingleton().GetResource(m_iMaterialIndex);
                else
                        m_pMaterial = NULL;
        }

        if(pvProperty == &m_iTextureIndex)
        {
                m_iTextureIndex = *(int *)pvNewValue;
                if(m_iTextureIndex !=1000)
                        m_pTexture = CTextureManager::GetSingleton().GetResource(m_iTextureIndex);
                else
                        m_pTexture = NULL;

        }

        for (int i=0; i<4; i++)
        {
                if(pvProperty == &m_TexCoord[i].x)
                        m_TexCoord[i].x = *(float *)pvNewValue;
                else if(pvProperty == &m_TexCoord[i].y)
                        m_TexCoord[i].y = *(float *)pvNewValue;
        }

        if(pvProperty == &m_bAutoCalc)
                m_bAutoCalc = *(bool *)pvNewValue;

        if(pvProperty == &m_strRectangle)
        {
                if(!IsAutoCalc())
                {
                        tRect NewRect;
                        if(sscanf((*(CString *)pvNewValue), "%i,%i,%i,%i", &NewRect.left, &NewRect.top, &NewRect.right, &NewRect.bottom))
                        {
                                Resize(NewRect);
                                return true;
                        }
                        else
                                return false;
                }
        }

        if(pvProperty == &m_strFilename)
        {
                tRect BackupRect = m_Rect;

                Destroy();
                CString NewFilename = *(CString *)pvNewValue;
                
                if(LoadXML(NULL, GetFullPath(NewFilename)))
                {
                        m_strFilename = NewFilename;
                        Resize(BackupRect);
                }
        }

        m_bUpdateRequired = true;
        return bChangeOK;
}

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

        PropList.AddPropSeparator(this, "Element");
        PropList.AddPropString(this, "Type",  &m_strElementType, false)->SetComment("Control Type");

        PropList.AddPropCheck(this, "Auto. Param Calc.", &m_bAutoCalc);

        m_iChildren = size();
        PropList.AddPropInt(this, "Children", &m_iChildren, "", false)->SetComment("Children Count");

        PropList.AddPropCheck(this, "Visible", &m_bVisible)->SetComment("Element Visibility");

        m_strRectangle.Format("%d,%d,%d,%d", m_Rect.left, m_Rect.top, m_Rect.right, m_Rect.bottom);
        PropList.AddPropString(this, "Rectangle", &m_strRectangle, true)->SetComment("Element' Left, Top, Right and Bottom coordinates");

        PropList.AddPropCheck(this, "Size X", &m_bAllowSizeX)->SetComment("Can the element' width be changed");
        PropList.AddPropCheck(this, "Size Y", &m_bAllowSizeY)->SetComment("Can the element' height be changed");

        PropList.AddPropCheck(this, "Move X", &m_bAllowMoveX)->SetComment("Can the element' be moved horizontally");
        PropList.AddPropCheck(this, "Move Y", &m_bAllowMoveY)->SetComment("Can the element' be moved vertically");

#ifndef GUI_USE_ACTIVE_INACTIVE

        PropList.AddPropSeparator(this, "Material");
        EPropertyCombo *pMaterialCombo = (EPropertyCombo *)PropList.AddPropCombo(this, "From Database...", &m_iMaterialIndex)->SetComment("Material selection");
        pMaterialCombo->AddString("No Material...", 1000);

        for (int i=0; i<CMaterialManager::GetSingleton().size(); i++)
        {
                CMaterial *pMaterial = (CMaterial *)CMaterialManager::GetSingleton().at(i);

                if(m_pMaterial !=NULL && m_pMaterial == pMaterial)
                        m_iMaterialIndex = i;

                pMaterialCombo->AddString(pMaterial->GetName(), i);
        }

        if(m_pMaterial !=NULL)
        {
                m_MaterialAmbient = RGB(m_pMaterial->GetAmbient().R, m_pMaterial->GetAmbient().G, m_pMaterial->GetAmbient().B);
                m_MaterialDiffuse = RGB(m_pMaterial->GetDiffuse().R, m_pMaterial->GetDiffuse().G, m_pMaterial->GetDiffuse().B);
                m_MaterialSpecular = RGB(m_pMaterial->GetSpecular().R, m_pMaterial->GetSpecular().G, m_pMaterial->GetSpecular().B);
                m_MaterialEmissive = RGB(m_pMaterial->GetEmissive().R, m_pMaterial->GetEmissive().G, m_pMaterial->GetEmissive().B);

                m_iMaterialShininess = m_pMaterial->GetShininess();

                PropList.AddPropColor(this, "Ambient", &m_MaterialAmbient, false)->SetComment("Material' Ambient component");
                PropList.AddPropColor(this, "Diffuse", &m_MaterialDiffuse, false)->SetComment("Material' Diffuse component");
                PropList.AddPropColor(this, "Specular", &m_MaterialSpecular, false)->SetComment("Material' Specular component");
                PropList.AddPropColor(this, "Emissive", &m_MaterialEmissive, false)->SetComment("Material' Emissive component");
                PropList.AddPropInt(this, "Shininess", &m_iMaterialShininess, "", false)->SetComment("Material' Shininess");
        }
#elif
        PropList.AddPropSeparator(this, "Color(s)");
        PropList.AddPropColor(this, "Active", &m_ActiveColor, true)->SetComment("Element' Active color");
        PropList.AddPropColor(this, "Inactive", &m_InactiveColor, true)->SetComment("Element' Inactive color");
#endif

        PropList.AddPropSeparator(this, "Texture");
        EPropertyCombo *pTextureCombo = (EPropertyCombo *)PropList.AddPropCombo(this, "From Database...", &m_iTextureIndex);
        pTextureCombo->AddString("No Texture...", 1000);

        for (int i=0; i<CTextureManager::GetSingleton().size(); i++)
        {
                CTexture *pTexture = (CTexture *)CTextureManager::GetSingleton().at(i);

                pTextureCombo->AddString(pTexture->GetName(), i);

                if(m_pTexture !=NULL && m_pTexture == pTexture)
                        m_iTextureIndex = i;
        }

        if(m_pTexture !=NULL)
        {
                m_strTextureFilename = m_pTexture->GetTextureFilename();
                m_strTextureName = m_pTexture->GetName();

                PropList.AddPropString(this, "strFilename", &m_strTextureFilename, false)->SetComment("Texture' strFilename");

                PropList.AddTab("Texturing");
                PropList.AddPropSeparator(this, "Texture Mapping");

                PropList.AddPropSeparator(this, "Top Left");
                PropList.AddPropFloat(this, "0X", &m_TexCoord[3].x, "", 0, 100, true);
                PropList.AddPropFloat(this, "1Y", &m_TexCoord[3].y, "", 0, 100, true);

                PropList.AddPropSeparator(this, "Top Right");
                PropList.AddPropFloat(this, "0X", &m_TexCoord[2].x, "", 0, 100, true);
                PropList.AddPropFloat(this, "1Y", &m_TexCoord[2].y, "", 0, 100, true);

                PropList.AddPropSeparator(this, "Bottom Right");
                PropList.AddPropFloat(this, "0X", &m_TexCoord[1].x, "", 0, 100, true);
                PropList.AddPropFloat(this, "1Y", &m_TexCoord[1].y, "", 0, 100, true);

                PropList.AddPropSeparator(this, "Bottom Left");
                PropList.AddPropFloat(this, "0X", &m_TexCoord[0].x, "", 0, 100, true);
                PropList.AddPropFloat(this, "0Y", &m_TexCoord[0].y, "", 0, 100, true);
        }
}

bool CGUIElement::IsAutoCalc()
{
        return m_bAutoCalc;
}

void CGUIElement::SetAutoCalc(bool bAutoCalc)
{
        m_bAutoCalc = bAutoCalc;
}

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

bool CGUIElement::IsOfType(eEntityType eType)
{
        if(eType == Entity_GUIElement)
                return true;

        return CXMLResource::IsOfType(eType);
}

---