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

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

CGUIBorder::CGUIBorder()
{
        SetEntityType(Entity_GUIBorder);
        SetType(GUI_Border);
        Initialize();
}

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

void CGUIBorder::Initialize()
{
        m_iBorderWidth = 0;
        m_iBorderSpacing = 1;
        m_uiDragElement = -1;
        m_strElementType = "Border";
}

int CGUIBorder::Create(CGUIElement *pParent)
{
        if(pParent == NULL)
                return 0;
                
        return CGUIElement::Create(pParent, GetRect());
}

void CGUIBorder::Draw()
{
        CGUIElement::Draw();
}

int CGUIBorder::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("Width");
        if(pcValue !=NULL)
        {
                SetBorderWidth((UINT)atoi(pcValue));
                pcValue = NULL;
        }
        else
        {
                CGlobalLogger::GetSingleton().Write("\n\t\t**********General Warning**********\n");
                CGlobalLogger::GetSingleton().Write("Border (Name: %s, ID: %d) doesn't have Width Attribute (Width) specified. Assuming default...", GetName(), GetID());
        }

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

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

int CGUIBorder::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("Border");

        if(GetFilename() !="")
                pSaveXMLElement->SetAttribute("strFilename", GetRelPath(GetFilename()));

        if(pDataNode == NULL)
                SAFEDEL(pSaveXMLElement)

        return 1;
}

int CGUIBorder::Resize(tRect& NewRect)
{
        // Left
        tRect BorderRectangle[8];

        tRect RefRect;
        if(GetParent() !=NULL)
                RefRect = GetParent()->GetRect();
        else
                RefRect = NewRect;

        BorderRectangle[0].left = RefRect.left - m_iBorderWidth - m_iBorderSpacing;
        BorderRectangle[0].right = RefRect.left - m_iBorderSpacing;
        BorderRectangle[0].top = RefRect.top + m_iBorderSpacing;
        BorderRectangle[0].bottom = RefRect.bottom - m_iBorderSpacing;
        
        // Right
        BorderRectangle[1].left = RefRect.right + m_iBorderSpacing;
        BorderRectangle[1].right = RefRect.right + m_iBorderWidth + m_iBorderSpacing;
        BorderRectangle[1].top = RefRect.top + m_iBorderSpacing;
        BorderRectangle[1].bottom = RefRect.bottom - m_iBorderSpacing;
        
        // Top
        BorderRectangle[2].left = RefRect.left - m_iBorderSpacing;
        BorderRectangle[2].right = RefRect.right + m_iBorderSpacing;
        BorderRectangle[2].top = RefRect.top + m_iBorderWidth + m_iBorderSpacing;
        BorderRectangle[2].bottom = RefRect.top + m_iBorderSpacing;

        // Bottom
        BorderRectangle[3].left = RefRect.left - m_iBorderSpacing;
        BorderRectangle[3].right = RefRect.right + m_iBorderSpacing;
        BorderRectangle[3].top = RefRect.bottom - m_iBorderSpacing;
        BorderRectangle[3].bottom = RefRect.bottom - m_iBorderWidth - m_iBorderSpacing;

        // Top Left
        BorderRectangle[4].left = BorderRectangle[0].left;
        BorderRectangle[4].right = BorderRectangle[0].right;
        BorderRectangle[4].top = BorderRectangle[0].top + m_iBorderWidth;
        BorderRectangle[4].bottom = BorderRectangle[0].top;

        // Top Right
        BorderRectangle[5].left = BorderRectangle[1].left;
        BorderRectangle[5].right = BorderRectangle[1].right;
        BorderRectangle[5].top = BorderRectangle[1].top + m_iBorderWidth;
        BorderRectangle[5].bottom = BorderRectangle[1].top;

        // Bottom Left
        BorderRectangle[6].left = BorderRectangle[0].left;
        BorderRectangle[6].right = BorderRectangle[0].right;
        BorderRectangle[6].top = BorderRectangle[0].bottom;
        BorderRectangle[6].bottom = BorderRectangle[0].bottom - m_iBorderWidth;

        // Bottom right
        BorderRectangle[7].left = BorderRectangle[1].left;
        BorderRectangle[7].right = BorderRectangle[1].right;
        BorderRectangle[7].top = BorderRectangle[1].bottom;
        BorderRectangle[7].bottom = BorderRectangle[1].bottom - m_iBorderWidth;

        for (int i=0; i<8; i++)
        {
                if(at(i) !=NULL)
                        at(i)->SetRect(BorderRectangle[i]);
        }

        return 1;
}

int CGUIBorder::OnLMouseDown(UINT x, UINT y)
{
        // Figuring out over which element the mouse was pressed on.
        // If none, return 0, otherwise assign drag flag and return 1
        UINT Count = 0;
        CGUIElement *pIterElement = begin();
        set_ptr(pIterElement);

        while(pIterElement !=NULL)
        {
                if(pIterElement->GetType() == GUI_Element)
                {
                        if(pIterElement->OnLMouseDown(x, y) == 1)
                        {
                                m_uiDragElement = Count;
                                return 1;
                        }
                }

                Count++;
                pIterElement = next();
        }

        return CGUIElement::OnLMouseDown(x, y);
}

int CGUIBorder::OnLMouseUp(UINT x, UINT y)
{
        // None is being dragged now
        m_uiDragElement = -1;
        return CGUIElement::OnLMouseUp(x, y);
}

int CGUIBorder::OnMouseMove(UINT x, UINT y)
{
// Check if flag is on, and if it is:
        if(m_uiDragElement !=-1)
        {
                // Aquire dragged element pointer
                CGUIElement *pDragElement = at(m_uiDragElement);
                tRect oldRect = pDragElement->GetRect();
                tRect oldParentRect = GetParent()->GetRect();

                CGUIElement::OnMouseMove(x, y); // Do general movement of dragged element border (if there's any)
                // Now, let's check if parent can accept the actual movement of that dragged border element that is resizing it
                // Firstly, let's find the displacement of the rectangle...

                // Do a pre-test resize of parent
                tRect newRect = pDragElement->GetRect();
                tRect DiffRect;
                DiffRect.left = newRect.left - oldRect.left;
                DiffRect.right = newRect.right - oldRect.right;
                DiffRect.top = newRect.top - oldRect.top;
                DiffRect.bottom = newRect.bottom - oldRect.bottom;

                tRect newParentRect = oldParentRect;

                // Figure out which element was dragged
                
                // If it's left one, we decrease/increase left value of the parent rectangle
                if(m_uiDragElement == 0 || m_uiDragElement == 4 || m_uiDragElement == 6)        // User drags leftmost elements, this decreasing m_iLeft
                        newParentRect.left = GetParent()->GetRect().left + DiffRect.left;

                // If it is the right one, decrease/increase right value of the parent rectangle
                if(m_uiDragElement == 1 || m_uiDragElement == 5 || m_uiDragElement == 7)        // User drags rightmost elements, thus decreasing m_iRight
                        newParentRect.right = GetParent()->GetRect().right + DiffRect.right;

                // And so on..
                if(m_uiDragElement == 2 || m_uiDragElement == 4 || m_uiDragElement == 5)        // User drags topmost elements, thus increasing m_iTop
                        newParentRect.top = GetParent()->GetRect().top + DiffRect.top;

                // And so on..
                if(m_uiDragElement == 3 || m_uiDragElement == 6 || m_uiDragElement == 7)        // User drags topmost elements, thus decreasing m_iBottom
                        newParentRect.bottom = GetParent()->GetRect().bottom + DiffRect.bottom;

                // Resize parent using newly created rectangle
                if(!GetParent()->Resize(newParentRect))
                        return Resize(oldParentRect);
                else
                        return Resize(newParentRect);
        }
        
        return 0;
}

void CGUIBorder::SetBorderWidth(UINT uiWidth)
{
        m_iBorderWidth = uiWidth;
}

UINT CGUIBorder::GetBorderWidth()
{

        return m_iBorderWidth;
}

void CGUIBorder::SetBorderSpacing(UINT uiSpacing)
{
        m_iBorderSpacing = uiSpacing;
}

UINT CGUIBorder::GetBorderSpacing()
{
        return m_iBorderSpacing;
}
        
void CGUIBorder::ProcessMessage(tGUIMessage& Message)
{
        switch(Message.uiMessage)
        {
                case GUI_Message_MoveX:
                case GUI_Message_MoveY:
                case GUI_Message_MoveXY:
                case GUI_Message_SizeX:
                case GUI_Message_SizeY:
                case GUI_Message_SizeXY:
                {
                        if(Message.pSender == GetParent())
                                Resize(GetParent()->GetRect());

                        break;
                }
        }
}

bool CGUIBorder::IsOfType(eEntityType eType)
{
        if(eType == Entity_GUIBorder)
                return true;

        return CGUIElement::IsOfType(eType);
}

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

        return bChangeOK;
}

void CGUIBorder::GetProperties( EPropList& PropList )
{
        if(m_uiDragElement !=-1)
                GetChild(m_uiDragElement)->GetProperties(PropList);

        PropList.AddTab("Border");
        PropList.AddPropInt(this, "Width", &m_iBorderWidth, "", true)->SetComment("Border' Width");
        PropList.AddPropInt(this, "Spacing", &m_iBorderSpacing, "", true)->SetComment("Border' Spacing from parent element");
}

---