ui: implemented gui abstraction and dummy view

- added abstract class tree for gui elements.
- implemented concrete gui classes that wrap the qt specific content.
- implemented first DummyView which plays nice with the ViewManager.

review id = 12

src/app/CMakeLists.txt

@@ -1,8 +1,20 @@
 add_files(
 	APP_FILES
 
+	qt/element/QtArea.cpp
+	qt/element/QtArea.h
+	qt/element/QtCanvas.cpp
+	qt/element/QtCanvas.h
+	
+	qt/QtWidgetWrapper.cpp
+	qt/QtWidgetWrapper.h
 	qt/QtElementFactory.cpp
 	qt/QtElementFactory.h
+	qt/QtWindow.cpp
+	qt/QtWindow.h
+	
+	utility/utilityQt.cpp
+	utility/utilityQt.h
 	
 	includesWindows.h
 	main.cpp

src/app/main.cpp

@@ -2,21 +2,25 @@
 
 #include <QApplication>
 #include <QTextEdit>
+#include <qlayout.h>
+#include <qgroupbox.h>
 
 #include "Application.h"
 #include "includes.h"
+#include "qt/element/QtArea.h"
+#include "qt/element/QtCanvas.h"
 #include "qt/QtElementFactory.h"
+#include "qt/QtWindow.h"
 
 int main(int argv, char **args)
 {
 	QApplication qtApp(argv, args);
 	std::shared_ptr<GuiElementFactory> elementFactory = std::make_shared<QtElementFactory>();
 
-	std::shared_ptr<Application> app = Application::create(elementFactory);
-	app->loadProject();
+	std::shared_ptr<QtWindow> window = std::make_shared<QtWindow>();
 
-	QTextEdit textEdit;
-	textEdit.show();
+	std::shared_ptr<Application> app = Application::create(elementFactory, window);
+	app->loadProject();
 
 	return qtApp.exec();
 }

src/app/qt/QtElementFactory.cpp

@@ -1,5 +1,9 @@
 #include "qt/QtElementFactory.h"
 
+#include "qt/element/QtArea.h"
+#include "qt/element/QtCanvas.h"
+#include "qt/QtWindow.h"
+
 QtElementFactory::QtElementFactory()
 {
 }
@@ -7,3 +11,15 @@ QtElementFactory::QtElementFactory()
 QtElementFactory::~QtElementFactory()
 {
 }
+
+std::shared_ptr<GuiArea> QtElementFactory::createArea() const
+{
+	return std::make_shared<QtArea>();
+}
+
+std::shared_ptr<GuiCanvas> QtElementFactory::createCanvas(std::shared_ptr<GuiWindow> window) const
+{
+	std::shared_ptr<GuiCanvas> canvas = std::make_shared<QtCanvas>();
+	window->setCanvas(canvas);
+	return canvas;
+}

src/app/qt/QtElementFactory.h

@@ -3,11 +3,18 @@
 
 #include "gui/GuiElementFactory.h"
 
+class GuiArea;
+class GuiCanvas;
+class GuiWindow;
+
 class QtElementFactory: public GuiElementFactory
 {
 public:
 	QtElementFactory();
-	~QtElementFactory();
+	virtual ~QtElementFactory();
+
+	virtual std::shared_ptr<GuiArea> createArea() const;
+	virtual std::shared_ptr<GuiCanvas> createCanvas(std::shared_ptr<GuiWindow> window) const;
 };
 
 # endif // QT_ELEMENT_FACTORY_H

src/app/qt/QtWidgetWrapper.cpp

@@ -0,0 +1,38 @@
+#include "qt/QtWidgetWrapper.h"
+
+#include "gui/GuiElement.h"
+#include "utility/logging/logging.h"
+
+std::shared_ptr<QWidget> QtWidgetWrapper::getWidgetOfElement(std::shared_ptr<GuiElement> element)
+{
+	return getWidgetOfElement(element.get());
+}
+
+std::shared_ptr<QWidget> QtWidgetWrapper::getWidgetOfElement(GuiElement* element)
+{
+	std::shared_ptr<QWidget> widget;
+	std::shared_ptr<QtWidgetWrapper> qtWidgetWrapper = std::dynamic_pointer_cast<QtWidgetWrapper>(element->getWidgetWrapper());
+	if (!qtWidgetWrapper || qtWidgetWrapper.use_count() == 0)
+	{
+		LOG_ERROR("Trying to get the qt widget of non qt gui element.");
+	}
+	else
+	{
+		widget = qtWidgetWrapper->getWidget();
+	}
+	return widget;
+}
+
+QtWidgetWrapper::QtWidgetWrapper(std::shared_ptr<QWidget> widget)
+	: m_widget(widget)
+{
+}
+
+QtWidgetWrapper::~QtWidgetWrapper()
+{
+}
+
+std::shared_ptr<QWidget> QtWidgetWrapper::getWidget()
+{
+	return m_widget;
+}

src/app/qt/QtWidgetWrapper.h

@@ -0,0 +1,27 @@
+#ifndef QT_WIDGET_WRAPPER_H
+#define QT_WIDGET_WRAPPER_H
+
+#include <memory>
+
+#include <QtWidgets/qwidget.h>
+
+#include "gui/WidgetWrapper.h"
+
+class GuiElement;
+
+class QtWidgetWrapper: public WidgetWrapper
+{
+public:
+	static std::shared_ptr<QWidget> getWidgetOfElement(std::shared_ptr<GuiElement> element);
+	static std::shared_ptr<QWidget> getWidgetOfElement(GuiElement* element);
+
+	QtWidgetWrapper(std::shared_ptr<QWidget> widget);
+	virtual ~QtWidgetWrapper();
+
+	std::shared_ptr<QWidget> getWidget(); // not const because returned widget can be changed.
+
+private:
+	std::shared_ptr<QWidget> m_widget;
+};
+
+#endif // QT_WIDGET_WRAPPER_H

src/app/qt/QtWindow.cpp

@@ -0,0 +1,19 @@
+#include "qt/QtWindow.h"
+
+#include "gui/GuiCanvas.h"
+#include "QtWidgetWrapper.h"
+
+QtWindow::QtWindow()
+{
+	m_window.setObjectName("QtWindow");
+	m_window.show();
+}
+
+QtWindow::~QtWindow()
+{
+}
+
+void QtWindow::setCanvas(std::shared_ptr<GuiCanvas> canvas)
+{
+	m_window.setCentralWidget(QtWidgetWrapper::getWidgetOfElement(canvas).get());
+}

src/app/qt/QtWindow.h

@@ -0,0 +1,24 @@
+#ifndef QT_WINDOW_H
+#define QT_WINDOW_H
+
+#include <memory>
+
+#include <QtWidgets/QMainWindow>
+
+#include "gui/GuiWindow.h"
+
+class GuiCanvas;
+
+class QtWindow: public GuiWindow
+{
+public:
+	QtWindow();
+	~QtWindow();
+
+	void setCanvas(std::shared_ptr<GuiCanvas> canvas);
+
+private:
+	QMainWindow m_window;
+};
+
+# endif // QT_WINDOW_H

src/app/qt/element/QtArea.cpp

@@ -0,0 +1,43 @@
+#include "qt/element/QtArea.h"
+
+#include <qframe.h>
+
+#include "qt/QtWidgetWrapper.h"
+#include "utility/utilityQt.h"
+
+QtArea::QtArea()
+	: GuiArea(std::make_shared<QtWidgetWrapper>(std::make_shared<QFrame>()))
+{
+}
+
+QtArea::~QtArea()
+{
+}
+
+void QtArea::setPosition(Vec2i position)
+{
+}
+
+Vec2i QtArea::getPosition() const
+{
+	return Vec2i();
+}
+
+void QtArea::setSize(Vec2i size)
+{
+}
+
+Vec2i QtArea::getSize() const
+{
+	return Vec2i();
+}
+
+void QtArea::setBackgroundColor(Colori color)
+{
+	utility::setWidgetBackgroundColor(getWidget(), color);
+}
+
+std::shared_ptr<QWidget> QtArea::getWidget()
+{
+	return QtWidgetWrapper::getWidgetOfElement(this);
+}

src/app/qt/element/QtArea.h

@@ -0,0 +1,25 @@
+#ifndef QT_AREA_H
+#define QT_AREA_H
+
+#include <qwidget.h>
+
+#include "gui/GuiArea.h"
+
+class QtArea: public GuiArea
+{
+public:
+	QtArea();
+	virtual ~QtArea();
+
+	virtual void setPosition(Vec2i position);
+	virtual Vec2i getPosition() const;
+	virtual void setSize(Vec2i size);
+	virtual Vec2i getSize() const;
+
+	virtual void setBackgroundColor(Colori color);
+
+private:
+	std::shared_ptr<QWidget> getWidget();
+};
+
+# endif // QT_AREA_H

src/app/qt/element/QtCanvas.cpp

@@ -0,0 +1,59 @@
+#include "qt/element/QtCanvas.h"
+
+#include <qgroupbox.h>
+#include <qlayout.h>
+
+#include "qt/QtWidgetWrapper.h"
+#include "utility/utilityQt.h"
+
+QtCanvas::QtCanvas()
+	: GuiCanvas(std::make_shared<QtWidgetWrapper>(std::make_shared<QGroupBox>()))
+{
+	QBoxLayout *layout = new QBoxLayout(QBoxLayout::TopToBottom); // gets deleted by qt
+	getWidget()->setLayout(layout);
+}
+
+QtCanvas::~QtCanvas()
+{
+}
+
+void QtCanvas::addChild(std::shared_ptr<GuiElement> element)
+{
+	getWidget()->layout()->addWidget(QtWidgetWrapper::getWidgetOfElement(element).get());
+}
+
+void QtCanvas::removeChild(std::shared_ptr<GuiElement> element)
+{
+	std::shared_ptr<QWidget> widgetToRemove = QtWidgetWrapper::getWidgetOfElement(element);
+	getWidget()->layout()->removeWidget(widgetToRemove.get());
+	widgetToRemove->setGeometry(0, 0, 0, 0);
+}
+
+void QtCanvas::setPosition(Vec2i position)
+{
+}
+
+Vec2i QtCanvas::getPosition() const
+{
+	return Vec2i();
+}
+
+void QtCanvas::setSize(Vec2i size)
+{
+}
+
+Vec2i QtCanvas::getSize() const
+{
+	return Vec2i();
+}
+
+void QtCanvas::setBackgroundColor(Colori color)
+{
+	utility::setWidgetBackgroundColor(getWidget(), color);
+}
+
+std::shared_ptr<QWidget> QtCanvas::getWidget()
+{
+	return QtWidgetWrapper::getWidgetOfElement(this);
+}
+

src/app/qt/element/QtCanvas.h

@@ -0,0 +1,29 @@
+#ifndef QT_CANVAS_H
+#define QT_CANVAS_H
+
+#include <qwidget.h>
+#include <QtWidgets/QMainWindow>
+
+#include "gui/GuiCanvas.h"
+
+class QtCanvas: public GuiCanvas
+{
+public:
+	QtCanvas();
+	virtual ~QtCanvas();
+
+	virtual void addChild(std::shared_ptr<GuiElement> element);
+	virtual void removeChild(std::shared_ptr<GuiElement> element);
+
+	virtual void setPosition(Vec2i position);
+	virtual Vec2i getPosition() const;
+	virtual void setSize(Vec2i size);
+	virtual Vec2i getSize() const;
+
+	virtual void setBackgroundColor(Colori color);
+
+private:
+	std::shared_ptr<QWidget> getWidget();
+};
+
+# endif // QT_CANVAS_H

src/app/utility/utilityQt.cpp

@@ -0,0 +1,13 @@
+#include "utilityQt.h"
+
+namespace utility
+{
+	void setWidgetBackgroundColor(std::shared_ptr<QWidget> widget, const Colori& color)
+	{
+		QPalette palette = widget->palette();
+		palette.setColor(widget->backgroundRole(), QColor(color.r, color.g, color.b, color.a));
+		widget->setPalette(palette);
+		widget->setAutoFillBackground(true);
+	}
+}
+

src/app/utility/utilityQt.h

@@ -0,0 +1,14 @@
+#ifndef UTILITY_QT_H
+#define UTILITY_QT_H
+
+#include <memory>
+#include <qwidget.h>
+
+#include "utility/math/Color.h"
+
+namespace utility
+{
+	void setWidgetBackgroundColor(std::shared_ptr<QWidget> widget, const Colori& color);
+}
+
+# endif // UTILITY_QT_H

src/lib/Application.cpp

@@ -1,20 +1,24 @@
 #include "Application.h"
 
+#include "gui/GuiCanvas.h"
 #include "utility/logging/ConsoleLogger.h"
 #include "utility/logging/LogManager.h"
 
-std::shared_ptr<Application> Application::create(std::shared_ptr<GuiElementFactory> guiElementFactory)
+std::shared_ptr<Application> Application::create(std::shared_ptr<GuiElementFactory> guiElementFactory, std::shared_ptr<GuiWindow> window)
 {
+	std::shared_ptr<ConsoleLogger> consoleLogger = std::make_shared<ConsoleLogger>();
+	LogManager::getInstance()->addLogger(consoleLogger);
+
+	std::shared_ptr<GuiCanvas> canvas = guiElementFactory->createCanvas(window);
+	canvas->setBackgroundColor(255, 0, 0, 255);
+
 	std::shared_ptr<Application> ptr(new Application());
-	ptr->m_viewManager = std::make_shared<ViewManager>();
+	ptr->m_viewManager = std::make_shared<ViewManager>(canvas);
 	ptr->m_codeAccess = std::make_shared<CodeAccess>();
 	ptr->m_graphAccess = std::make_shared<GraphAccess>();
 	ptr->m_componentManager =
 		ComponentManager::create(ptr->m_viewManager, guiElementFactory, ptr->m_codeAccess, ptr->m_graphAccess);
 
-	std::shared_ptr<ConsoleLogger> consoleLogger = std::make_shared<ConsoleLogger>();
-	LogManager::getInstance()->addLogger(consoleLogger);
-
 	return ptr;
 }
 
@@ -28,6 +32,7 @@ Application::~Application()
 
 void Application::loadProject()
 {
+	m_componentManager->setup();
 	m_project = Project::create(m_codeAccess, m_graphAccess);
 
 	m_project->parseCode();

src/lib/Application.h

@@ -13,7 +13,7 @@
 class Application
 {
 public:
-	static std::shared_ptr<Application> create(std::shared_ptr<GuiElementFactory> guiElementFactory);
+	static std::shared_ptr<Application> create(std::shared_ptr<GuiElementFactory> guiElementFactory, std::shared_ptr<GuiWindow> window);
 
 	~Application();
 

src/lib/CMakeLists.txt

@@ -20,9 +20,11 @@ add_files(
 	component/controller/CodeController.h
 	component/controller/Controller.cpp
 	component/controller/Controller.h
+	component/controller/DummyController.cpp
+	component/controller/DummyController.h
 
-	component/view/CodeView.cpp
-	component/view/CodeView.h
+	component/view/DummyView.cpp
+	component/view/DummyView.h
 	component/view/View.cpp
 	component/view/View.h
 	component/view/ViewManager.cpp
@@ -67,10 +69,22 @@ add_files(
 	data/TextLocationLine.cpp
 	data/TextLocationLine.h
 
+	gui/GuiArea.cpp
+	gui/GuiArea.h
+	gui/GuiCanvas.cpp
+	gui/GuiCanvas.h
+	gui/GuiContainer.cpp
+	gui/GuiContainer.h
+	gui/GuiControl.cpp
+	gui/GuiControl.h
 	gui/GuiElement.cpp
 	gui/GuiElement.h
 	gui/GuiElementFactory.cpp
 	gui/GuiElementFactory.h
+	gui/GuiWindow.cpp
+	gui/GuiWindow.h
+	gui/WidgetWrapper.cpp
+	gui/WidgetWrapper.h
 
 	utility/logging/ConsoleLogger.cpp
 	utility/logging/ConsoleLogger.h
@@ -84,11 +98,14 @@ add_files(
 	utility/logging/LogManagerImplementation.cpp
 	utility/logging/LogManagerImplementation.h
 	utility/logging/LogMessage.h
-
+	
+	utility/math/Color.h
 	utility/math/Vector2.h
+	utility/math/Vector4.h
 
 	utility/ConfigManager.cpp
 	utility/ConfigManager.h
+	utility/Vector.h
 
 	Application.cpp
 	Application.h

src/lib/component/Component.cpp

@@ -1,8 +1,8 @@
 #include "component/Component.h"
 
-Component::Component(const std::shared_ptr<Controller>& controller, const std::shared_ptr<View>& view)
-: m_controller(controller)
-, m_view(view)
+Component::Component(std::shared_ptr<View> view, std::shared_ptr<Controller> controller)
+	: m_controller(controller)
+	, m_view(view)
 {
 }
 

src/lib/component/Component.h

@@ -9,7 +9,7 @@
 class Component
 {
 public:
-	Component(const std::shared_ptr<Controller>& controller, const std::shared_ptr<View>& view);
+	Component(std::shared_ptr<View> view, std::shared_ptr<Controller> controller);
 
 	~Component();
 

src/lib/component/ComponentFactory.cpp

@@ -1,10 +1,13 @@
 #include "component/ComponentFactory.h"
 
+#include "component/view/DummyView.h"
+#include "component/controller/DummyController.h"
+
 std::shared_ptr<ComponentFactory> ComponentFactory::create(
-	const std::shared_ptr<ViewManager>& viewManager,
-	const std::shared_ptr<GuiElementFactory>& guiElementFactory,
-	const std::shared_ptr<CodeAccess>& codeAccess,
-	const std::shared_ptr<GraphAccess>& graphAccess)
+	std::shared_ptr<ViewManager> viewManager,
+	std::shared_ptr<GuiElementFactory> guiElementFactory,
+	std::shared_ptr<CodeAccess> codeAccess,
+	std::shared_ptr<GraphAccess> graphAccess)
 {
 	std::shared_ptr<ComponentFactory> ptr(new ComponentFactory());
 	ptr->m_viewManger = viewManager;
@@ -14,10 +17,19 @@ std::shared_ptr<ComponentFactory> ComponentFactory::create(
 	return ptr;
 }
 
-ComponentFactory::ComponentFactory()
-{
-}
-
 ComponentFactory::~ComponentFactory()
 {
 }
+
+std::shared_ptr<Component> ComponentFactory::createDummyComponent()
+{
+	std::shared_ptr<View> view = std::make_shared<DummyView>(m_viewManger, m_guiElementFactory);
+	std::shared_ptr<Controller> controller = std::make_shared<DummyController>();
+
+	std::shared_ptr<Component> component = std::make_shared<Component>(view, controller);
+	return component;
+}
+
+ComponentFactory::ComponentFactory()
+{
+}

src/lib/component/ComponentFactory.h

@@ -13,13 +13,15 @@ class ComponentFactory
 {
 public:
 	static std::shared_ptr<ComponentFactory> create(
-		const std::shared_ptr<ViewManager>& viewManager,
-		const std::shared_ptr<GuiElementFactory>& guiElementFactory,
-		const std::shared_ptr<CodeAccess>& codeAccess,
-		const std::shared_ptr<GraphAccess>& graphAccess);
+		std::shared_ptr<ViewManager> viewManager,
+		std::shared_ptr<GuiElementFactory> guiElementFactory,
+		std::shared_ptr<CodeAccess> codeAccess,
+		std::shared_ptr<GraphAccess> graphAccess);
 
 	~ComponentFactory();
 
+	std::shared_ptr<Component> createDummyComponent();
+
 private:
 	ComponentFactory();
 	ComponentFactory(const ComponentFactory&);

src/lib/component/ComponentManager.cpp

@@ -1,16 +1,21 @@
 #include "component/ComponentManager.h"
 
 std::shared_ptr<ComponentManager> ComponentManager::create(
-	const std::shared_ptr<ViewManager>& viewManager,
-	const std::shared_ptr<GuiElementFactory>& guiElementFactory,
-	const std::shared_ptr<CodeAccess>& codeAccess,
-	const std::shared_ptr<GraphAccess>& graphAccess)
+	std::shared_ptr<ViewManager> viewManager,
+	std::shared_ptr<GuiElementFactory> guiElementFactory,
+	std::shared_ptr<CodeAccess> codeAccess,
+	std::shared_ptr<GraphAccess> graphAccess)
 {
 	std::shared_ptr<ComponentManager> ptr(new ComponentManager());
 	ptr->m_componentFactory = ComponentFactory::create(viewManager, guiElementFactory, codeAccess, graphAccess);
 	return ptr;
 }
 
+void ComponentManager::setup()
+{
+	m_components.push_back(m_componentFactory->createDummyComponent());
+}
+
 ComponentManager::ComponentManager()
 {
 }

src/lib/component/ComponentManager.h

@@ -15,13 +15,15 @@ class ComponentManager
 {
 public:
 	static std::shared_ptr<ComponentManager> create(
-		const std::shared_ptr<ViewManager>& viewManager,
-		const std::shared_ptr<GuiElementFactory>& guiElementFactory,
-		const std::shared_ptr<CodeAccess>& codeAccess,
-		const std::shared_ptr<GraphAccess>& graphAccess);
+		std::shared_ptr<ViewManager> viewManager,
+		std::shared_ptr<GuiElementFactory> guiElementFactory,
+		std::shared_ptr<CodeAccess> codeAccess,
+		std::shared_ptr<GraphAccess> graphAccess);
 
 	~ComponentManager();
 
+	void setup();
+
 private:
 	ComponentManager();
 	ComponentManager(const ComponentManager&);

src/lib/component/controller/DummyController.cpp

@@ -0,0 +1 @@
+#include "component/controller/DummyController.h"

src/lib/component/controller/DummyController.h

@@ -0,0 +1,11 @@
+#ifndef DUMMY_CONTROLLER_H
+#define DUMMY_CONTROLLER_H
+
+#include "component/controller/Controller.h"
+
+class DummyController: public Controller
+{
+};
+
+
+#endif // DUMMY_CONTROLLER_H

src/lib/component/view/CodeView.cpp

@@ -1,2 +0,0 @@
-#include "component/view/CodeView.h"
-

src/lib/component/view/CodeView.h

@@ -1,11 +0,0 @@
-#ifndef CODE_VIEW_H
-#define CODE_VIEW_H
-
-#include "component/view/View.h"
-
-class CodeView: public View
-{
-};
-
-
-#endif // CODE_VIEW_H

src/lib/component/view/DummyView.cpp

@@ -0,0 +1,15 @@
+#include "component/view/DummyView.h"
+
+#include "gui/GuiArea.h"
+#include "gui/GuiElementFactory.h"
+
+DummyView::DummyView(std::shared_ptr<ViewManager> viewManager, std::shared_ptr<GuiElementFactory> guiElementFactory)
+	: View(viewManager, guiElementFactory->createArea(), Vec2i(100, 100))
+	, m_guiElementFactory(guiElementFactory)
+{
+	getRootElement()->setBackgroundColor(0, 255, 0, 255);
+}
+
+DummyView::~DummyView()
+{
+}

src/lib/component/view/DummyView.h

@@ -0,0 +1,19 @@
+#ifndef DUMMY_VIEW_H
+#define DUMMY_VIEW_H
+
+#include "component/view/View.h"
+
+class GuiElementFactory;
+
+class DummyView: public View
+{
+public:
+	DummyView(std::shared_ptr<ViewManager> viewManager, std::shared_ptr<GuiElementFactory> guiElementFactory);
+	virtual ~DummyView();
+
+private:
+	std::shared_ptr<GuiElementFactory> m_guiElementFactory;
+};
+
+
+#endif // DUMMY_VIEW_H

src/lib/component/view/View.cpp

@@ -1,5 +1,35 @@
 #include "component/view/View.h"
+#include "component/view/ViewManager.h"
+
+View::View(std::shared_ptr<ViewManager> viewManager, std::shared_ptr<GuiElement> rootElement, const Vec2i& minSize)
+	: m_viewManager(viewManager)
+	, m_rootElement(rootElement)
+	, m_minSize(minSize)
+{
+	m_viewManager->addView(this);
+}
 
 View::~View()
 {
+	m_viewManager->removeView(this);
+}
+
+std::shared_ptr<GuiElement> View::getRootElement()
+{
+	return m_rootElement;
+}
+
+int View::getMinWidth() const
+{
+	return m_minSize.x;
+}
+
+int View::getMinHeight() const
+{
+	return m_minSize.y;
+}
+
+Vec2i View::getMinSize() const
+{
+	return m_minSize;
 }

src/lib/component/view/View.h

@@ -1,11 +1,29 @@
 #ifndef VIEW_H
 #define VIEW_H
 
+#include <memory>
+
+#include "utility/math/Vector2.h"
+
+class GuiElement;
+class ViewManager;
+
 class View
 {
 public:
+	View(std::shared_ptr<ViewManager> viewManager, std::shared_ptr<GuiElement> rootElement, const Vec2i& minSize);
 	virtual ~View();
+
+	std::shared_ptr<GuiElement> getRootElement();
+
+	int getMinWidth() const;
+	int getMinHeight() const;
+	Vec2i getMinSize() const;
+
+private:
+	std::shared_ptr<ViewManager> m_viewManager;
+	std::shared_ptr<GuiElement> m_rootElement;
+	Vec2i m_minSize;
 };
 
-
 #endif // VIEW_H

src/lib/component/view/ViewManager.cpp

@@ -1,9 +1,29 @@
 #include "component/view/ViewManager.h"
 
-ViewManager::ViewManager()
+#include "gui/GuiCanvas.h"
+#include "View.h"
+
+ViewManager::ViewManager(std::shared_ptr<GuiCanvas> canvas)
+	: m_canvas(canvas)
 {
 }
 
 ViewManager::~ViewManager()
 {
 }
+
+void ViewManager::addView(View* view)
+{
+	m_views.push_back(view);
+	m_canvas->addChild(view->getRootElement());
+}
+
+void ViewManager::removeView(View* view)
+{
+	std::vector<View*>::iterator it = std::find(m_views.begin(), m_views.end(), view);
+	if (it != m_views.end())
+	{
+		m_canvas->removeChild((*it)->getRootElement());
+		m_views.erase(it);
+	}
+}

src/lib/component/view/ViewManager.h

@@ -4,16 +4,21 @@
 #include <memory>
 #include <vector>
 
-#include "component/view/View.h"
+class GuiCanvas;
+class View;
 
 class ViewManager
 {
 public:
-	ViewManager();
+	ViewManager(std::shared_ptr<GuiCanvas> canvas);
 	~ViewManager();
 
+	void addView(View* view);
+	void removeView(View* view);
+
 private:
-	std::vector<std::shared_ptr<View> > m_views;
+	std::shared_ptr<GuiCanvas> m_canvas;
+	std::vector<View*> m_views;
 };
 
 

src/lib/gui/GuiArea.cpp

@@ -0,0 +1,10 @@
+#include "gui/GuiArea.h"
+
+GuiArea::GuiArea(std::shared_ptr<WidgetWrapper> widgetWrapper)
+	: GuiControl(widgetWrapper)
+{
+}
+
+GuiArea::~GuiArea()
+{
+}

src/lib/gui/GuiArea.h

@@ -0,0 +1,14 @@
+#ifndef GUI_AREA_H
+#define GUI_AREA_H
+
+#include "gui/GuiControl.h"
+
+class GuiArea: public GuiControl
+{
+public:
+	GuiArea(std::shared_ptr<WidgetWrapper> widgetWrapper);
+	virtual ~GuiArea();
+
+};
+
+#endif // GUI_AREA_H

src/lib/gui/GuiCanvas.cpp

@@ -0,0 +1,10 @@
+#include "gui/GuiCanvas.h"
+
+GuiCanvas::GuiCanvas(std::shared_ptr<WidgetWrapper> widgetWrapper)
+	: GuiContainer(widgetWrapper)
+{
+}
+
+GuiCanvas::~GuiCanvas()
+{
+}

src/lib/gui/GuiCanvas.h

@@ -0,0 +1,13 @@
+#ifndef GUI_CANVAS_H
+#define GUI_CANVAS_H
+
+#include "gui/GuiContainer.h"
+
+class GuiCanvas: public GuiContainer
+{
+public:
+	GuiCanvas(std::shared_ptr<WidgetWrapper> widgetWrapper);
+	virtual ~GuiCanvas();
+};
+
+#endif // GUI_CANVAS_H

src/lib/gui/GuiContainer.cpp

@@ -0,0 +1,10 @@
+#include "gui/GuiContainer.h"
+
+GuiContainer::GuiContainer(std::shared_ptr<WidgetWrapper> widgetWrapper)
+	: GuiElement(widgetWrapper)
+{
+}
+
+GuiContainer::~GuiContainer()
+{
+}

src/lib/gui/GuiContainer.h

@@ -0,0 +1,19 @@
+#ifndef GUI_CONTAINER_H
+#define GUI_CONTAINER_H
+
+#include <vector>
+
+#include "gui/GuiElement.h"
+
+class GuiContainer: public GuiElement
+{
+public:
+	GuiContainer(std::shared_ptr<WidgetWrapper> widgetWrapper);
+	virtual ~GuiContainer();
+
+	virtual void addChild(std::shared_ptr<GuiElement> element) = 0;
+	virtual void removeChild(std::shared_ptr<GuiElement> element) = 0;
+
+};
+
+#endif // GUI_CONTAINER_H

src/lib/gui/GuiControl.cpp

@@ -0,0 +1,10 @@
+#include "gui/GuiControl.h"
+
+GuiControl::GuiControl(std::shared_ptr<WidgetWrapper> widgetWrapper)
+	: GuiElement(widgetWrapper)
+{
+}
+
+GuiControl::~GuiControl()
+{
+}

src/lib/gui/GuiControl.h

@@ -0,0 +1,14 @@
+#ifndef GUI_CONTROL_H
+#define GUI_CONTROL_H
+
+#include "gui/GuiElement.h"
+
+class GuiControl: public GuiElement
+{
+public:
+	GuiControl(std::shared_ptr<WidgetWrapper> widgetWrapper);
+	virtual ~GuiControl();
+
+};
+
+#endif // GUI_CONTROL_H

src/lib/gui/GuiElement.cpp

@@ -1,5 +1,22 @@
 #include "gui/GuiElement.h"
 
+#include "gui/WidgetWrapper.h"
+
+GuiElement::GuiElement(std::shared_ptr<WidgetWrapper> widgetWrapper)
+	: m_widgetWrapper(widgetWrapper)
+{
+}
+
 GuiElement::~GuiElement()
 {
 }
+
+void GuiElement::setBackgroundColor(int r, int g, int b, int a)
+{
+	setBackgroundColor(Colori(r, g, b, a));
+}
+
+std::shared_ptr<WidgetWrapper> GuiElement::getWidgetWrapper()
+{
+	return m_widgetWrapper;
+}

src/lib/gui/GuiElement.h

@@ -1,11 +1,32 @@
 #ifndef GUI_ELEMENT_H
 #define GUI_ELEMENT_H
 
+#include <memory>
+
+#include "utility/math/Color.h"
+#include "utility/math/Vector2.h"
+
+class WidgetWrapper;
+
 class GuiElement
 {
 public:
+	GuiElement(std::shared_ptr<WidgetWrapper> widgetWrapper);
 	virtual ~GuiElement();
+
+	virtual void setPosition(Vec2i position) = 0;
+	virtual Vec2i getPosition() const = 0;
+	virtual void setSize(Vec2i size) = 0;
+	virtual Vec2i getSize() const = 0;
+
+	virtual void setBackgroundColor(Colori color) = 0;
+	void setBackgroundColor(int r, int g, int b, int a);
+
+//protected:
+	std::shared_ptr<WidgetWrapper> getWidgetWrapper();
+
+private:
+	std::shared_ptr<WidgetWrapper> m_widgetWrapper;
 };
 
-
 #endif // GUI_ELEMENT_H

src/lib/gui/GuiElementFactory.h

@@ -1,11 +1,19 @@
 #ifndef GUI_ELEMENT_FACTORY_H
 #define GUI_ELEMENT_FACTORY_H
 
+#include <memory>
+
+class GuiArea;
+class GuiCanvas;
+class GuiWindow;
+
 class GuiElementFactory
 {
 public:
 	virtual ~GuiElementFactory();
+
+	virtual std::shared_ptr<GuiArea> createArea() const = 0;
+	virtual std::shared_ptr<GuiCanvas> createCanvas(std::shared_ptr<GuiWindow> window) const = 0;
 };
 
-
 #endif // GUI_ELEMENT_FACTORY_H

src/lib/gui/GuiWindow.cpp

@@ -0,0 +1,11 @@
+#include "gui/GuiWindow.h"
+
+#include "gui/GuiCanvas.h"
+
+GuiWindow::GuiWindow()
+{
+}
+
+GuiWindow::~GuiWindow()
+{
+}

src/lib/gui/GuiWindow.h

@@ -0,0 +1,17 @@
+#ifndef GUI_WINDOW_H
+#define GUI_WINDOW_H
+
+#include <memory>
+
+class GuiCanvas;
+
+class GuiWindow
+{
+public:
+	GuiWindow();
+	virtual ~GuiWindow();
+
+	virtual void setCanvas(std::shared_ptr<GuiCanvas> canvas) = 0;
+};
+
+#endif // GUI_WINDOW_H

src/lib/gui/WidgetWrapper.cpp

@@ -0,0 +1,9 @@
+#include "gui/WidgetWrapper.h"
+
+WidgetWrapper::WidgetWrapper()
+{
+}
+
+WidgetWrapper::~WidgetWrapper()
+{
+}

src/lib/gui/WidgetWrapper.h

@@ -0,0 +1,11 @@
+#ifndef WIDGET_WRAPPER_H
+#define WIDGET_WRAPPER_H
+
+class WidgetWrapper
+{
+public:
+	WidgetWrapper();
+	virtual ~WidgetWrapper();
+};
+
+#endif // WIDGET_WRAPPER_H

src/lib/utility/Vector.h

@@ -0,0 +1,16 @@
+#ifndef VECTOR_H
+#define VECTOR_H
+
+struct Vec4i
+{
+	Vec4i(int x, int y, int z, int w)
+		: x(x)
+		, y(y)
+		, z(z)
+		, w(w)
+	{}
+
+	int x, y, z, w;
+};
+
+#endif // VECTOR_H

src/lib/utility/math/Color.h

@@ -0,0 +1,33 @@
+#ifndef COLOR_H
+#define COLOR_H
+
+template<class T>
+class Color
+{
+public:
+	Color();
+	Color(T r, T g, T b, T a);
+
+	T r, g, b, a;
+};
+
+template<class T>
+Color<T>::Color()
+	: r(0)
+	, g(0)
+	, b(0)
+	, a(0)
+{}
+
+template<class T>
+Color<T>::Color(T r, T g, T b, T a)
+	: r(r)
+	, g(g)
+	, b(b)
+	, a(a)
+{}
+
+typedef Color<float> Colorf;
+typedef Color<int> Colori;
+
+#endif // COLOR_H

src/lib/utility/math/Vector4.h

@@ -0,0 +1,32 @@
+#ifndef VECTOR_4_H
+#define VECTOR_4_H
+
+template<class T>
+class Vector4
+{
+public:
+	Vector4();
+	Vector4(T x, T y, T z, T w);
+
+	T x, y, z, w;
+};
+
+template<class T>
+Vector4<T>::Vector4()
+	: x(0)
+	, y(0)
+	, z(0)
+	, w(0)
+{}
+
+template<class T>
+Vector4<T>::Vector4(T x, T y, T z, T w)
+	: x(x)
+	, y(y)
+	, z(z)
+	, w(w)
+{}
+
+typedef Vector4<int> Vec4i;
+
+#endif // VECTOR_4_H