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

// GUIEditView.cpp : implementation of the CGUIEditorView class
//

#include "stdafx.h"
#include "GUIEditor.h"

#include "GUIEditorDoc.h"
#include "GUIEditorView.h"
#include ".\guieditorview.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

// CGUIEditorView

IMPLEMENT_DYNCREATE(CGUIEditorView, CView)

BEGIN_MESSAGE_MAP(CGUIEditorView, CView)
        //{{AFX_MSG_MAP(CGUIEditorView)
        ON_COMMAND(ID_FILE_PRINT_PREVIEW, OnFilePrintPreview)
        //}}AFX_MSG_MAP
        // Standard printing commands
        ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
        ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)
        ON_WM_CREATE()
        ON_WM_KEYDOWN()
        ON_WM_SIZE()
        ON_COMMAND(ID_RESOURCES_TEXTURES, OnResourcesTextures)
        ON_COMMAND(ID_RESOURCES_MATERIALS, OnResourcesMaterials)
        ON_WM_ERASEBKGND()
        ON_COMMAND(ID_RESOURCES_ANIMATIONS, OnResourcesAnimations)
        ON_COMMAND(ID_RESOURCES_FONTS, OnResourcesFonts)
        ON_COMMAND(ID_GUI_PROPERTIES, OnGuiProperties)
        ON_WM_DESTROY()
        ON_COMMAND(ID_ADD_ELEMENT, OnAddElement)
        ON_COMMAND(ID_ADD_STATIC, OnAddStatic)
        ON_COMMAND(ID_ADD_TEXTBOX, OnAddTextbox)
        ON_COMMAND(ID_ADD_BUTTON, OnAddButton)
        ON_COMMAND(ID_ADD_SCROLLBAR_HORIZONTAL, OnAddScrollbarHorizontal)
        ON_COMMAND(ID_ADD_SCROLLBAR_VERTICAL, OnAddScrollbarVertical)
        ON_COMMAND(ID_ADD_PROGRESSBAR_HORIZONTAL, OnAddProgressbarHorizontal)
        ON_COMMAND(ID_ADD_PROGRESSBAR_VERTICAL, OnAddProgressbarVertical)
        ON_COMMAND(ID_ADD_DROPLIST, OnAddDroplist)
        ON_COMMAND(ID_ADD_LISTBOX, OnAddListbox)
        ON_COMMAND(ID_ADD_MENU, OnAddMenu)
        ON_COMMAND(ID_ADD_TABCONTROL, OnAddTabcontrol)
        ON_COMMAND(ID_ADD_WINDOW, OnAddWindow)
        ON_COMMAND(ID_ADD_BORDER, OnAddBorder)
        ON_COMMAND(ID_REMOVE_BORDER, OnGuiRemoveBorder)
        ON_COMMAND(ID_FILE_SAVE_EX, OnFileSaveEx)
        ON_COMMAND(ID_FILE_SAVE_AS_EX, OnFileSaveAsEx)
        ON_COMMAND(ID_ADD_RADIOGROUP, OnAddRadiogroup)
END_MESSAGE_MAP()

// CGUIEditorView construction/destruction

CGUIEditorView::CGUIEditorView()
{

}

CGUIEditorView::~CGUIEditorView()
{
        m_lstSelection.erase(false);
}

BOOL CGUIEditorView::PreCreateWindow(CREATESTRUCT& cs)
{
        // TODO: Modify the Window class or styles here by modifying
        //  the CREATESTRUCT cs

        return CView::PreCreateWindow(cs);
}

// CGUIEditorView drawing

void CGUIEditorView::OnDraw(CDC* pDC)
{

}

void CGUIEditorView::RenderGLScene()
{
        glEnable(GL_TEXTURE_2D);// Enable Texture Mapping ( NEW )
        glShadeModel(GL_SMOOTH);// Enable Smooth Shading
        glClearColor(0.0f, 0.0f, 0.0f, 0.5f);// Black Background
        glClearDepth(1.0f);// Depth Buffer Setup
        glEnable(GL_DEPTH_TEST);// Enables Depth Testing
        glDepthFunc(GL_LEQUAL);// The Type Of Depth Testing To Do
        glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);// Really Nice Perspective Calculations

        // Device context for painting
        CGUIEditorDoc *pDoc = (CGUIEditorDoc *)GetDocument();
        ASSERT_VALID(pDoc);

        // Useful in multidoc templates
        HWND hWnd = GetSafeHwnd();
        HDC hDC = m_hDC;

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glLoadIdentity();

        int viewport[4];
        glGetIntegerv(GL_VIEWPORT, viewport);

        BeginOrtho();
        // Position / translation / scale

        if(pDoc !=NULL)
        {
                if(pDoc->GetGUI() !=NULL)
                {
                        pDoc->GetGUI()->Update();
                        pDoc->GetGUI()->Draw();
                }
        }

        EndOrtho();

        // Double buffer
        glFlush();
        SwapBuffers(m_hDC);
}

BOOL CGUIEditorView::OnPreparePrinting(CPrintInfo* pInfo)
{
        // default preparation
        return DoPreparePrinting(pInfo);
}

void CGUIEditorView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
        // TODO: add extra initialization before printing
}

void CGUIEditorView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
        // TODO: add cleanup after printing
}

// CGUIEditorView diagnostics

#ifdef _DEBUG
void CGUIEditorView::AssertValid() const
{
        CView::AssertValid();
}

void CGUIEditorView::Dump(CDumpContext& dc) const
{
        CView::Dump(dc);
}

CGUIEditorDoc* CGUIEditorView::GetDocument() // non-debug version is inline
{
        ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CGUIEditorDoc)));
        return (CGUIEditorDoc*)m_pDocument;
}
#endif //_DEBUG

CChildFrame *CGUIEditorView::GetActiveChild()
{
        CMDIFrameWnd* pParent = ((CMDIFrameWnd *)AfxGetMainWnd());
        return ((CChildFrame *)pParent->MDIGetActive());
}

void CGUIEditorView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
{
        switch(nChar)
        {
                case VK_DELETE:
                {
                        CGUIElement *pIter = GetFirstSelection();
                        while(pIter !=NULL)
                        {
                                pIter->GetParent()->RemoveChild(pIter);
                                pIter = GetNextSelection();
                        }

                        m_lstSelection.erase(false);
                        CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();
                        pMainFrame->SelectElement(NULL);

                        break;
                }

                case VK_LEFT:
                {
                        if(GetAsyncKeyState(VK_LSHIFT) < 0)
                        {
                                CGUIElement *pIter = GetFirstSelection();
                                while(pIter !=NULL)
                                {
                                        tRect Rect = pIter->GetRect();
                                        tRect NewRect(Rect.left - 1, Rect.right, Rect.top, Rect.bottom);
                                        pIter->Resize(NewRect);

                                        pIter = GetNextSelection();
                                }
                        }
                        else
                        {
                                CGUIElement *pIter = GetFirstSelection();
                                while(pIter !=NULL)
                                {
                                        tRect Rect = pIter->GetRect();
                                        tRect NewRect(Rect.left - 1, Rect.right - 1, Rect.top, Rect.bottom);
                                        pIter->Resize(NewRect);

                                        pIter = GetNextSelection();
                                }
                        }

                        if(GetAsyncKeyState(VK_CONTROL) < 0)
                        {
                                CGUIElement *pIter = GetFirstSelection();
                                while(pIter !=NULL)
                                {
                                        tRect Rect = pIter->GetRect();
                                        tRect NewRect(Rect.left + 1, Rect.right, Rect.top, Rect.bottom);
                                        pIter->Resize(NewRect);

                                        pIter = GetNextSelection();
                                }
                        }

                        InvalidateRect(NULL, TRUE);
                        break;
                }

                case VK_RIGHT:
                {
                        if(GetAsyncKeyState(VK_LSHIFT) < 0)
                        {
                                CGUIElement *pIter = GetFirstSelection();
                                while(pIter !=NULL)
                                {
                                        tRect Rect = pIter->GetRect();
                                        tRect NewRect(Rect.left, Rect.right + 1, Rect.top, Rect.bottom);
                                        pIter->Resize(NewRect);

                                        pIter = GetNextSelection();
                                }
                        }
                        else
                        {
                                CGUIElement *pIter = GetFirstSelection();
                                while(pIter !=NULL)
                                {
                                        tRect Rect = pIter->GetRect();
                                        tRect NewRect(Rect.left + 1, Rect.right + 1, Rect.top, Rect.bottom);
                                        pIter->Resize(NewRect);

                                        pIter = GetNextSelection();
                                }
                        }

                        if(GetAsyncKeyState(VK_CONTROL) < 0)
                        {
                                CGUIElement *pIter = GetFirstSelection();
                                while(pIter !=NULL)
                                {
                                        tRect Rect = pIter->GetRect();
                                        tRect NewRect(Rect.left, Rect.right - 1, Rect.top, Rect.bottom);
                                        pIter->Resize(NewRect);

                                        pIter = GetNextSelection();
                                }
                        }

                        InvalidateRect(NULL, TRUE);
                        break;
                }

                case VK_UP:
                {
                        if(GetAsyncKeyState(VK_LSHIFT) < 0)
                        {
                                CGUIElement *pIter = GetFirstSelection();
                                while(pIter !=NULL)
                                {
                                        tRect Rect = pIter->GetRect();
                                        tRect NewRect(Rect.left, Rect.right, Rect.top + 1, Rect.bottom);
                                        pIter->Resize(NewRect);

                                        pIter = GetNextSelection();
                                }
                        }
                        else
                        {
                                CGUIElement *pIter = GetFirstSelection();
                                while(pIter !=NULL)
                                {
                                        tRect Rect = pIter->GetRect();
                                        tRect NewRect(Rect.left, Rect.right, Rect.top + 1, Rect.bottom + 1);
                                        pIter->Resize(NewRect);

                                        pIter = GetNextSelection();
                                }
                        }

                        if(GetAsyncKeyState(VK_CONTROL) < 0)
                        {
                                CGUIElement *pIter = GetFirstSelection();
                                while(pIter !=NULL)
                                {
                                        tRect Rect = pIter->GetRect();
                                        tRect NewRect(Rect.left, Rect.right, Rect.top - 1, Rect.bottom);
                                        pIter->Resize(NewRect);

                                        pIter = GetNextSelection();
                                }
                        }

                        InvalidateRect(NULL, TRUE);
                        break;
                }

                case VK_DOWN:
                {
                        if(GetAsyncKeyState(VK_LSHIFT) < 0)
                        {
                                CGUIElement *pIter = GetFirstSelection();
                                while(pIter !=NULL)
                                {
                                        tRect Rect = pIter->GetRect();
                                        tRect NewRect(Rect.left, Rect.right, Rect.top, Rect.bottom - 1);
                                        pIter->Resize(NewRect);

                                        pIter = GetNextSelection();
                                }
                        }
                        else
                        {
                                CGUIElement *pIter = GetFirstSelection();
                                while(pIter !=NULL)
                                {
                                        tRect Rect = pIter->GetRect();
                                        tRect NewRect(Rect.left, Rect.right, Rect.top - 1, Rect.bottom - 1);
                                        pIter->Resize(NewRect);

                                        pIter = GetNextSelection();
                                }
                        }

                        if(GetAsyncKeyState(VK_CONTROL) < 0)
                        {
                                CGUIElement *pIter = GetFirstSelection();
                                while(pIter !=NULL)
                                {
                                        tRect Rect = pIter->GetRect();
                                        tRect NewRect(Rect.left, Rect.right, Rect.top, Rect.bottom + 1);
                                        pIter->Resize(NewRect);

                                        pIter = GetNextSelection();
                                }
                        }

                        InvalidateRect(NULL, TRUE);
                        break;
                }
        }
}

int CGUIEditorView::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
        if(CView::OnCreate(lpCreateStruct) == -1)
                return -1;

        m_hDC = this->GetDC()->GetSafeHdc();
        HWND hWnd = GetSafeHwnd();

        CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();

        pMainFrame->SetWindowPixelFormat(m_hDC);
        pMainFrame->CreateViewGLContext(m_hDC);

        return 1;
}

void CGUIEditorView::OnSize(UINT nType, int cx, int cy)
{
        CView::OnSize(nType, cx, cy);

        if(cx == 0 || cy == 0)
                return;

        HWND hWnd = GetSafeHwnd();
        HDC hDC = m_hDC;

        CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();
        if(pMainFrame->m_hRC == NULL)
                return;

        // Make the rendering context current
        glViewport(0, 0, cx, cy);                                                                                       // Reset The Current Viewport

        int Viewport[4];

        glMatrixMode(GL_PROJECTION);                                            // Select The Projection Matrix
        glPushMatrix();                                                                         // Store The Projection Matrix
        glLoadIdentity();                                                                       // Reset The Projection Matrix
        glGetIntegerv(GL_VIEWPORT, Viewport);
        glOrtho(0, Viewport[2], 0, Viewport[3], 0, 100);        // Set Up An Ortho Screen

        glMatrixMode(GL_MODELVIEW);     
}

BOOL CGUIEditorView::OnEraseBkgnd(CDC* pDC)
{
        // TODO: Add your message handler code here and/or call default

        return TRUE;
}

void CGUIEditorView::OnResourcesTextures()
{
        CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();
        pMainFrame->m_pResourceSettings = pMainFrame->m_pTextureSettings;

        pMainFrame->m_ResourceSettingsDlg.SetPropPointer(pMainFrame->m_pResourceSettings);
        pMainFrame->m_ResourceSettingsDlg.ShowWindow(SW_SHOW);
}

void CGUIEditorView::OnResourcesMaterials()
{
        CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();
        pMainFrame->m_pResourceSettings = pMainFrame->m_pMaterialSettings;

        pMainFrame->m_ResourceSettingsDlg.SetPropPointer(pMainFrame->m_pResourceSettings);
        pMainFrame->m_ResourceSettingsDlg.ShowWindow(SW_SHOW);
}

void CGUIEditorView::OnResourcesAnimations()
{
        CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();
        pMainFrame->m_pResourceSettings = pMainFrame->m_pAnimationSettings;

        pMainFrame->m_ResourceSettingsDlg.SetPropPointer(pMainFrame->m_pResourceSettings);
        pMainFrame->m_ResourceSettingsDlg.ShowWindow(SW_SHOW);
}

void CGUIEditorView::OnResourcesFonts()
{
        CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();
        pMainFrame->m_pResourceSettings = pMainFrame->m_pFontSettings;

        pMainFrame->m_ResourceSettingsDlg.SetPropPointer(pMainFrame->m_pResourceSettings);
        pMainFrame->m_ResourceSettingsDlg.ShowWindow(SW_SHOW);
}

void CGUIEditorView::OnGuiProperties()
{
        CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();
        pMainFrame->m_GUISettingsDlg.ShowWindow(SW_SHOW);
}

LRESULT CGUIEditorView::WindowProc(UINT uiMessage, WPARAM wParam, LPARAM lParam)
{
        switch(uiMessage)
        {
                case WM_LBUTTONDOWN:
                {
                        CInputEngine::GetSingleton().GetMouse()->SetKeyState(VK_LBUTTON, KEY_DOWN);
                        break;
                }

                case WM_LBUTTONUP:
                {
                        CInputEngine::GetSingleton().GetMouse()->SetKeyState(VK_LBUTTON, KEY_UP);

                        CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();
                        CGUIEditorDoc *pDoc = (CGUIEditorDoc *)GetDocument();
                        ASSERT_VALID(pDoc);

                        if(pMainFrame !=NULL)
                        {
                                if(pDoc !=NULL)
                                {
                                        if(pDoc->GetGUI() !=NULL)
                                        {
                                                pDoc->GetGUI()->Update();

                                                pMainFrame->m_pGUIElement = pDoc->GetGUI()->GetActiveElement();

                                                if(GetAsyncKeyState(VK_LSHIFT) < 0)
                                                        AddToSelection(pMainFrame->m_pGUIElement);
                                                else
                                                {
                                                        if(GetSelectionCount() >= 0)
                                                        {
                                                                ClearSelection();
                                                                AddToSelection(pMainFrame->m_pGUIElement);
                                                        }
                                                }

                                                if(pMainFrame->m_pGUIElement !=NULL)
                                                        pMainFrame->m_pGUIElement->m_bUpdateRequired = true;
                                        }
                                }
                        }

                        break;
                }

                case WM_RBUTTONDOWN:
                {
                        CInputEngine::GetSingleton().GetMouse()->SetKeyState(VK_RBUTTON, KEY_DOWN);
                        break;
                }

                case WM_RBUTTONUP:
                {
                        CInputEngine::GetSingleton().GetMouse()->SetKeyState(VK_RBUTTON, KEY_UP);
                }
        }

        return CView::WindowProc(uiMessage, wParam, lParam);
}

void CGUIEditorView::OnDestroy()
{
        CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();
        pMainFrame->m_pGUIElement = NULL;

        ::ReleaseDC(m_hWnd, m_hDC);
}

void CGUIEditorView::OnAddElement()
{
        CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();
        CGUIEditorDoc *pDoc = (CGUIEditorDoc *)GetDocument();
        ASSERT_VALID(pDoc);

        if(pMainFrame !=NULL)
        {
                if(pDoc !=NULL)
                {
                        if(pDoc->GetGUI() !=NULL)
                        {
                                tRect WidgetRect = GenerateRandomRect(20, 200, 20, 200);
                                CGUIElement *pNewElement = new CGUIElement;

                                pNewElement->Create(pDoc->GetGUI(), WidgetRect);
                                pDoc->GetGUI()->push_back(pNewElement);
                        }
                }
        }
}

void CGUIEditorView::OnAddStatic()
{
        CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();
        CGUIEditorDoc *pDoc = (CGUIEditorDoc *)GetDocument();
        ASSERT_VALID(pDoc);

        if(pMainFrame !=NULL)
        {
                if(pDoc !=NULL)
                {
                        if(pDoc->GetGUI() !=NULL)
                        {
                                tRect WidgetRect = GenerateRandomRect(40, 200, 20, 200);
                                CGUIStatic *pNewStatic = new CGUIStatic;

                                pNewStatic->Create(pDoc->GetGUI(), WidgetRect);
                                pDoc->GetGUI()->push_back(pNewStatic);
                        }
                }
        }
}

void CGUIEditorView::OnAddTextbox()
{
        CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();
        CGUIEditorDoc *pDoc = (CGUIEditorDoc *)GetDocument();
        ASSERT_VALID(pDoc);

        if(pMainFrame !=NULL)
        {
                if(pDoc !=NULL)
                {
                        if(pDoc->GetGUI() !=NULL)
                        {
                                tRect WidgetRect = GenerateRandomRect(20, 200, 20, 200);
                                CGUITextBox *pNewTextBox = new CGUITextBox;

                                pNewTextBox->Create(pDoc->GetGUI(), WidgetRect);
                                pDoc->GetGUI()->push_back(pNewTextBox);
                        }
                }
        }
}

void CGUIEditorView::OnAddButton()
{
        CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();
        CGUIEditorDoc *pDoc = (CGUIEditorDoc *)GetDocument();
        ASSERT_VALID(pDoc);

        if(pMainFrame !=NULL)
        {
                if(pDoc !=NULL)
                {
                        if(pDoc->GetGUI() !=NULL)
                        {
                                tRect WidgetRect = GenerateRandomRect(40, 200, 20, 40);
                                CGUIButton *pNewButton = new CGUIButton;

                                pNewButton->Create(pDoc->GetGUI(), WidgetRect);
                                pDoc->GetGUI()->push_back(pNewButton);
                        }
                }
        }
}

void CGUIEditorView::OnAddScrollbarHorizontal()
{
        CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();
        CGUIEditorDoc *pDoc = (CGUIEditorDoc *)GetDocument();
        ASSERT_VALID(pDoc);

        if(pMainFrame !=NULL)
        {
                if(pDoc !=NULL)
                {
                        if(pDoc->GetGUI() !=NULL)
                        {
                                tRect WidgetRect = GenerateRandomRect(100, 200, 20, 40);
                                CGUIScrollBar *pNewScrollBar = new CGUIScrollBar;

                                pNewScrollBar->Create(pDoc->GetGUI(), WidgetRect, GUI_HorizontalScrollBar);
                                pDoc->GetGUI()->push_back(pNewScrollBar);
                        }
                }
        }
}

void CGUIEditorView::OnAddScrollbarVertical()
{
        CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();
        CGUIEditorDoc *pDoc = (CGUIEditorDoc *)GetDocument();
        ASSERT_VALID(pDoc);

        if(pMainFrame !=NULL)
        {
                if(pDoc !=NULL)
                {
                        if(pDoc->GetGUI() !=NULL)
                        {
                                tRect WidgetRect = GenerateRandomRect(20, 40, 100, 200);
                                CGUIScrollBar *pNewScrollBar = new CGUIScrollBar;

                                pNewScrollBar->Create(pDoc->GetGUI(), WidgetRect, GUI_VerticalScrollBar);
                                pDoc->GetGUI()->push_back(pNewScrollBar);
                        }
                }
        }
}

void CGUIEditorView::OnAddProgressbarHorizontal()
{
        CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();
        CGUIEditorDoc *pDoc = (CGUIEditorDoc *)GetDocument();
        ASSERT_VALID(pDoc);

        if(pMainFrame !=NULL)
        {
                if(pDoc !=NULL)
                {
                        if(pDoc->GetGUI() !=NULL)
                        {
                                tRect WidgetRect = GenerateRandomRect(100, 200, 20, 40);
                                CGUIProgressBar *pNewProgressBar = new CGUIProgressBar;

                                pNewProgressBar->Create(pDoc->GetGUI(), WidgetRect, GUI_HorizontalProgressBar);
                                pDoc->GetGUI()->push_back(pNewProgressBar);
                        }
                }
        }
}

void CGUIEditorView::OnAddProgressbarVertical()
{
        CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();
        CGUIEditorDoc *pDoc = (CGUIEditorDoc *)GetDocument();
        ASSERT_VALID(pDoc);

        if(pMainFrame !=NULL)
        {
                if(pDoc !=NULL)
                {
                        if(pDoc->GetGUI() !=NULL)
                        {
                                tRect WidgetRect = GenerateRandomRect(20, 40, 100, 200);
                                CGUIProgressBar *pNewProgressBar = new CGUIProgressBar;

                                pNewProgressBar->Create(pDoc->GetGUI(), WidgetRect, GUI_VerticalProgressBar);
                                pDoc->GetGUI()->push_back(pNewProgressBar);
                        }
                }
        }
}

void CGUIEditorView::OnAddDroplist()
{
        CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();
        CGUIEditorDoc *pDoc = (CGUIEditorDoc *)GetDocument();
        ASSERT_VALID(pDoc);

        if(pMainFrame !=NULL)
        {
                if(pDoc !=NULL)
                {
                        if(pDoc->GetGUI() !=NULL)
                        {
                                tRect WidgetRect = GenerateRandomRect(40, 200, 20, 40);
                                CGUIDropList *pNewDropList = new CGUIDropList;

                                pNewDropList->Create(pDoc->GetGUI(), WidgetRect);
                                pDoc->GetGUI()->push_back(pNewDropList);
                        }
                }
        }
}

void CGUIEditorView::OnAddListbox()
{
        CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();
        CGUIEditorDoc *pDoc = (CGUIEditorDoc *)GetDocument();
        ASSERT_VALID(pDoc);

        if(pMainFrame !=NULL)
        {
                if(pDoc !=NULL)
                {
                        if(pDoc->GetGUI() !=NULL)
                        {
                                tRect WidgetRect = GenerateRandomRect(20, 200, 20, 200);
                                CGUIListBox *pNewListBox = new CGUIListBox;

                                pNewListBox->Create(pDoc->GetGUI(), WidgetRect);
                                pDoc->GetGUI()->push_back(pNewListBox);
                        }
                }
        }
}


void CGUIEditorView::OnAddRadiogroup()
{
        CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();
        CGUIEditorDoc *pDoc = (CGUIEditorDoc *)GetDocument();
        ASSERT_VALID(pDoc);

        if(pMainFrame !=NULL)
        {
                if(pDoc !=NULL)
                {
                        if(pDoc->GetGUI() !=NULL)
                        {
                                tRect WidgetRect = GenerateRandomRect(20, 200, 20, 200);
                                CGUIRadioGroup *pNewRadioGroup = new CGUIRadioGroup;

                                pNewRadioGroup->Create(pDoc->GetGUI(), WidgetRect);
                                pDoc->GetGUI()->push_back(pNewRadioGroup);
                        }
                }
        }
}

void CGUIEditorView::OnAddMenu()
{
        CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();
        CGUIEditorDoc *pDoc = (CGUIEditorDoc *)GetDocument();
        ASSERT_VALID(pDoc);

        if(pMainFrame !=NULL)
        {
                if(pDoc !=NULL)
                {
                        if(pDoc->GetGUI() !=NULL)
                        {
                                tRect WidgetRect = GenerateRandomRect(40, 200, 20, 40);
                                CGUIMenu *pNewMenu = new CGUIMenu;

                                pNewMenu->Create(pDoc->GetGUI(), WidgetRect);
                                pDoc->GetGUI()->push_back(pNewMenu);
                        }
                }
        }
}

void CGUIEditorView::OnAddTabcontrol()
{
        CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();
        CGUIEditorDoc *pDoc = (CGUIEditorDoc *)GetDocument();
        ASSERT_VALID(pDoc);

        if(pMainFrame !=NULL)
        {
                if(pDoc !=NULL)
                {
                        if(pDoc->GetGUI() !=NULL)
                        {
                                tRect WidgetRect = GenerateRandomRect(40, 200, 20, 200);
                                CGUITabControl *pNewTabControl = new CGUITabControl;

                                pNewTabControl->Create(pDoc->GetGUI(), WidgetRect);
                                pDoc->GetGUI()->push_back(pNewTabControl);
                        }
                }
        }
}

void CGUIEditorView::OnAddWindow()
{
        CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();
        CGUIEditorDoc *pDoc = (CGUIEditorDoc *)GetDocument();
        ASSERT_VALID(pDoc);

        if(pMainFrame !=NULL)
        {
                if(pDoc !=NULL)
                {
                        if(pDoc->GetGUI() !=NULL)
                        {
                                tRect WidgetRect = GenerateRandomRect(100, 200, 100, 200);
                                CGUIWindow *pNewWindow = new CGUIWindow;

                                pNewWindow->Create(pDoc->GetGUI(), WidgetRect);
                                pDoc->GetGUI()->push_back(pNewWindow);
                        }
                }
        }
}

void CGUIEditorView::OnAddBorder()
{
        CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();
        CGUIEditorDoc *pDoc = (CGUIEditorDoc *)GetDocument();
        ASSERT_VALID(pDoc);

        if(pMainFrame !=NULL)
        {
                if(pDoc !=NULL)
                {
                        if(pDoc->GetGUI() !=NULL)
                        {
                                if(pDoc->GetGUI()->GetActiveElement() !=NULL && pDoc->GetGUI()->GetActiveElement()->GetType() !=GUI)
                                {
                                        if(pDoc->GetGUI()->GetActiveElement()->GetChild(GUI_Border) !=NULL)
                                                return;
                                        else
                                        {
                                                CGUIBorder *pBorder = new CGUIBorder;
                                                pBorder->Create(pDoc->GetGUI()->GetActiveElement());
                                                if(pBorder->LoadXML(NULL, "Data/Editor/XML/Border/default_border.xml"))
                                                {
                                                        pDoc->GetGUI()->GetActiveElement()->push_back(pBorder);
                                                        pDoc->GetGUI()->GetActiveElement()->Resize(pDoc->GetGUI()->GetActiveElement()->GetRect());
                                                }
                                                else
                                                        SAFEDEL(pBorder)
                                        }
                                }
                        }
                }
        }
}

tRect CGUIEditorView::GenerateRandomRect(int MinWidth, int MaxWidth, int MinHeight, int MaxHeight)
{
        tRect RetRect;

        RetRect.left = Random(0, 300);
        RetRect.bottom = Random(0, 300);
        RetRect.right = RetRect.left + Random(MinWidth, MaxWidth);
        RetRect.top = RetRect.bottom + Random(MinHeight, MaxHeight);

        return RetRect;
}


void CGUIEditorView::OnGuiRemoveBorder()
{
        CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();
        CGUIEditorDoc *pDoc = (CGUIEditorDoc *)GetDocument();
        ASSERT_VALID(pDoc);

        if(pMainFrame !=NULL)
        {
                if(pDoc !=NULL)
                {
                        if(pDoc->GetGUI() !=NULL)
                        {
                                if(pDoc->GetGUI()->GetActiveElement() !=NULL && pDoc->GetGUI()->GetActiveElement()->GetType() !=GUI)
                                        pDoc->GetGUI()->GetActiveElement()->RemoveChild(pDoc->GetGUI()->GetActiveElement()->GetChild(GUI_Border));
                        }
                }
        }
}

void CGUIEditorView::OnFileSaveEx()
{

}

void CGUIEditorView::OnFileSaveAsEx()
{
        CMainFrame *pMainFrame = (CMainFrame *)AfxGetMainWnd();
        CGUIEditorDoc *pDoc = (CGUIEditorDoc *)GetDocument();
        ASSERT_VALID(pDoc);

        if(pMainFrame !=NULL)
        {
                if(pDoc !=NULL)
                {
                        if(pDoc->GetGUI() !=NULL)
                        {
                                CFileDialog FileDialog(TRUE, NULL, NULL, OFN_HIDEREADONLY|OFN_FILEMUSTEXIST, "XML Files (*.xml)|*.xml|All Files (*.*)|*.*||", AfxGetMainWnd());

                                if ( FileDialog.DoModal() == IDOK)
                                {
                                        if(pDoc->GetGUI() !=NULL)
                                                pDoc->GetGUI()->GetActiveElement()->SaveXML(NULL, FileDialog.GetPathName());
                                }
                        }
                }
        }
}

void CGUIEditorView::AddToSelection(CGUIElement *pElement)
{
        m_lstSelection.push_back(pElement);
}

void CGUIEditorView::ClearSelection()
{
        m_lstSelection.erase(false);
}

int CGUIEditorView::GetSelectionCount()
{
        return m_lstSelection.size();
}

CGUIElement *CGUIEditorView::GetFirstSelection()
{
        if(m_lstSelection.size() > 0)
        {
                m_lstSelection.set_ptr(m_lstSelection.begin());
                return m_lstSelection.begin();
        }

        return NULL;
}

CGUIElement *CGUIEditorView::GetNextSelection()
{
        return m_lstSelection.next();
}

---