Move SDK include and source to base

2020-02-24 18:23:30 +01:00
parent f0d11aea72
commit b6b3ac9f31
149 changed files with 34 additions and 33 deletions
--- a/src/NazaraSDK/Widgets/AbstractTextAreaWidget.cpp
+++ b/src/NazaraSDK/Widgets/AbstractTextAreaWidget.cpp
@@ -0,0 +1,489 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Development Kit"
+// For conditions of distribution and use, see copyright notice in Prerequisites.hpp
+
+#include <NazaraSDK/Widgets/AbstractTextAreaWidget.hpp>
+#include <Nazara/Core/Unicode.hpp>
+#include <Nazara/Utility/Font.hpp>
+#include <NazaraSDK/Components/GraphicsComponent.hpp>
+#include <NazaraSDK/Components/NodeComponent.hpp>
+
+namespace Ndk
+{
+	namespace
+	{
+		constexpr float paddingWidth = 5.f;
+		constexpr float paddingHeight = 3.f;
+	}
+
+	AbstractTextAreaWidget::AbstractTextAreaWidget(BaseWidget* parent) :
+	BaseWidget(parent),
+	m_characterFilter(),
+	m_echoMode(EchoMode_Normal),
+	m_cursorPositionBegin(0U, 0U),
+	m_cursorPositionEnd(0U, 0U),
+	m_isLineWrapEnabled(false),
+	m_isMouseButtonDown(false),
+	m_multiLineEnabled(false),
+	m_readOnly(false),
+	m_tabEnabled(false)
+	{
+		m_textSprite = Nz::TextSprite::New();
+
+		m_textEntity = CreateEntity();
+		m_textEntity->AddComponent<GraphicsComponent>().Attach(m_textSprite);
+
+		auto& textNode = m_textEntity->AddComponent<NodeComponent>();
+		textNode.SetParent(this);
+		textNode.SetPosition(paddingWidth, paddingHeight);
+
+		m_cursorEntity = CreateEntity();
+		m_cursorEntity->AddComponent<GraphicsComponent>();
+		m_cursorEntity->AddComponent<NodeComponent>().SetParent(m_textEntity);
+		m_cursorEntity->GetComponent<NodeComponent>();
+		m_cursorEntity->Enable(false);
+
+		SetCursor(Nz::SystemCursor_Text);
+
+		EnableBackground(true);
+	}
+	
+	void AbstractTextAreaWidget::Clear()
+	{
+		Nz::AbstractTextDrawer& textDrawer = GetTextDrawer();
+
+		m_cursorPositionBegin.MakeZero();
+		m_cursorPositionEnd.MakeZero();
+		textDrawer.Clear();
+		m_textSprite->Update(textDrawer);
+		SetPreferredSize(Nz::Vector2f(m_textSprite->GetBoundingVolume().obb.localBox.GetLengths()));
+
+		RefreshCursor();
+	}
+
+	void AbstractTextAreaWidget::EnableLineWrap(bool enable)
+	{
+		if (m_isLineWrapEnabled != enable)
+		{
+			m_isLineWrapEnabled = enable;
+
+			Nz::AbstractTextDrawer& textDrawer = GetTextDrawer();
+
+			if (enable)
+				textDrawer.SetMaxLineWidth(GetWidth());
+			else
+				textDrawer.SetMaxLineWidth(std::numeric_limits<float>::infinity());
+
+			UpdateTextSprite();
+		}
+	}
+
+	Nz::Vector2ui AbstractTextAreaWidget::GetHoveredGlyph(float x, float y) const
+	{
+		const Nz::AbstractTextDrawer& textDrawer = GetTextDrawer();
+
+		auto& textNode = m_textEntity->GetComponent<Ndk::NodeComponent>();
+		Nz::Vector2f textPosition = Nz::Vector2f(textNode.GetPosition(Nz::CoordSys_Local));
+		x -= textPosition.x;
+		y -= textPosition.y;
+
+		std::size_t glyphCount = textDrawer.GetGlyphCount();
+		if (glyphCount > 0)
+		{
+			std::size_t lineCount = textDrawer.GetLineCount();
+			std::size_t line = 0U;
+			for (; line < lineCount - 1; ++line)
+			{
+				Nz::Rectf lineBounds = textDrawer.GetLine(line).bounds;
+				if (lineBounds.GetMaximum().y > y)
+					break;
+			}
+
+			std::size_t upperLimit = (line != lineCount - 1) ? textDrawer.GetLine(line + 1).glyphIndex : glyphCount + 1;
+
+			std::size_t firstLineGlyph = textDrawer.GetLine(line).glyphIndex;
+			std::size_t i = firstLineGlyph;
+			for (; i < upperLimit - 1; ++i)
+			{
+				Nz::Rectf bounds = textDrawer.GetGlyph(i).bounds;
+				if (x < bounds.x + bounds.width * 0.75f)
+					break;
+			}
+
+			return Nz::Vector2ui(Nz::Vector2<std::size_t>(i - firstLineGlyph, line));
+		}
+
+		return Nz::Vector2ui::Zero();
+	}
+
+	void AbstractTextAreaWidget::Layout()
+	{
+		BaseWidget::Layout();
+
+		if (m_isLineWrapEnabled)
+		{
+			Nz::AbstractTextDrawer& textDrawer = GetTextDrawer();
+
+			textDrawer.SetMaxLineWidth(GetWidth());
+			UpdateTextSprite();
+		}
+
+		RefreshCursor();
+	}
+
+	bool AbstractTextAreaWidget::IsFocusable() const
+	{
+		return !m_readOnly;
+	}
+
+	void AbstractTextAreaWidget::OnFocusLost()
+	{
+		m_cursorEntity->Disable();
+	}
+
+	void AbstractTextAreaWidget::OnFocusReceived()
+	{
+		if (!m_readOnly)
+			m_cursorEntity->Enable(true);
+	}
+
+	bool AbstractTextAreaWidget::OnKeyPressed(const Nz::WindowEvent::KeyEvent& key)
+	{
+		const Nz::AbstractTextDrawer& textDrawer = GetTextDrawer();
+
+		switch (key.code)
+		{
+			case Nz::Keyboard::Backspace:
+			{
+				bool ignoreDefaultAction = false;
+				OnTextAreaKeyBackspace(this, &ignoreDefaultAction);
+
+				std::size_t cursorGlyphEnd = GetGlyphIndex(m_cursorPositionEnd);
+
+				if (ignoreDefaultAction || cursorGlyphEnd == 0)
+					return true;
+
+				// When a text is selected, delete key does the same as delete and leave the character behind it
+				if (HasSelection())
+					EraseSelection();
+				else
+				{
+					MoveCursor(-1);
+					Erase(GetGlyphIndex(m_cursorPositionBegin));
+				}
+
+				return true;
+			}
+
+			case Nz::Keyboard::Delete:
+			{
+				if (HasSelection())
+					EraseSelection();
+				else
+					Erase(GetGlyphIndex(m_cursorPositionBegin));
+
+				return true;
+			}
+
+			case Nz::Keyboard::Down:
+			{
+				bool ignoreDefaultAction = false;
+				OnTextAreaKeyDown(this, &ignoreDefaultAction);
+
+				if (ignoreDefaultAction)
+					return true;
+
+				if (HasSelection())
+					SetCursorPosition(m_cursorPositionEnd);
+
+				MoveCursor({0, 1});
+				return true;
+			}
+
+			case Nz::Keyboard::End:
+			{
+				bool ignoreDefaultAction = false;
+				OnTextAreaKeyEnd(this, &ignoreDefaultAction);
+
+				if (ignoreDefaultAction)
+					return true;
+
+				std::size_t lineCount = textDrawer.GetLineCount();
+				if (key.control && lineCount > 0)
+					SetCursorPosition({ static_cast<unsigned int>(textDrawer.GetLineGlyphCount(lineCount - 1)), static_cast<unsigned int>(lineCount - 1) });
+				else
+					SetCursorPosition({ static_cast<unsigned int>(textDrawer.GetLineGlyphCount(m_cursorPositionEnd.y)), m_cursorPositionEnd.y });
+
+				return true;
+			}
+
+			case Nz::Keyboard::Home:
+			{
+				bool ignoreDefaultAction = false;
+				OnTextAreaKeyHome(this, &ignoreDefaultAction);
+
+				if (ignoreDefaultAction)
+					return true;
+
+				SetCursorPosition({ 0U, key.control ? 0U : m_cursorPositionEnd.y });
+				return true;
+			}
+
+			case Nz::Keyboard::Left:
+			{
+				bool ignoreDefaultAction = false;
+				OnTextAreaKeyLeft(this, &ignoreDefaultAction);
+
+				if (ignoreDefaultAction)
+					return true;
+
+				if (HasSelection())
+					SetCursorPosition(m_cursorPositionBegin);
+				else if (key.control)
+					HandleWordCursorMove(true);
+				else
+					MoveCursor(-1);
+
+				return true;
+			}
+
+			case Nz::Keyboard::Return:
+			{
+				bool ignoreDefaultAction = false;
+				OnTextAreaKeyReturn(this, &ignoreDefaultAction);
+
+				if (ignoreDefaultAction)
+					return true;
+
+				if (!m_multiLineEnabled)
+					break;
+
+				if (HasSelection())
+					EraseSelection();
+
+				Write(Nz::String('\n'));
+				return true;;
+			}
+
+			case Nz::Keyboard::Right:
+			{
+				bool ignoreDefaultAction = false;
+				OnTextAreaKeyRight(this, &ignoreDefaultAction);
+
+				if (ignoreDefaultAction)
+					return true;
+
+				if (HasSelection())
+					SetCursorPosition(m_cursorPositionEnd);
+				else if (key.control)
+					HandleWordCursorMove(false);
+				else
+					MoveCursor(1);
+
+				return true;
+			}
+
+			case Nz::Keyboard::Up:
+			{
+				bool ignoreDefaultAction = false;
+				OnTextAreaKeyUp(this, &ignoreDefaultAction);
+
+				if (ignoreDefaultAction)
+					return true;
+
+				if (HasSelection())
+					SetCursorPosition(m_cursorPositionBegin);
+
+				MoveCursor({0, -1});
+				return true;
+			}
+
+			case Nz::Keyboard::Tab:
+			{
+				if (!m_tabEnabled)
+					return false;
+
+				if (HasSelection())
+					HandleSelectionIndentation(!key.shift);
+				else
+					HandleIndentation(!key.shift);
+
+				return true;
+			}
+
+			default:
+				break;
+		}
+
+		return false;
+	}
+
+	void AbstractTextAreaWidget::OnKeyReleased(const Nz::WindowEvent::KeyEvent& /*key*/)
+	{
+	}
+
+	void AbstractTextAreaWidget::OnMouseButtonPress(int x, int y, Nz::Mouse::Button button)
+	{
+		if (button == Nz::Mouse::Left)
+		{
+			SetFocus();
+
+			Nz::Vector2ui hoveredGlyph = GetHoveredGlyph(float(x), float(y));
+
+			// Shift extends selection
+			if (Nz::Keyboard::IsKeyPressed(Nz::Keyboard::LShift) || Nz::Keyboard::IsKeyPressed(Nz::Keyboard::RShift))
+				SetSelection(hoveredGlyph, m_selectionCursor);
+			else
+			{
+				SetCursorPosition(hoveredGlyph);
+				m_selectionCursor = m_cursorPositionBegin;
+			}
+
+			m_isMouseButtonDown = true;
+		}
+	}
+
+	void AbstractTextAreaWidget::OnMouseButtonRelease(int, int, Nz::Mouse::Button button)
+	{
+		if (button == Nz::Mouse::Left)
+			m_isMouseButtonDown = false;
+	}
+
+	void AbstractTextAreaWidget::OnMouseEnter()
+	{
+		if (!Nz::Mouse::IsButtonPressed(Nz::Mouse::Left))
+			m_isMouseButtonDown = false;
+	}
+
+	void AbstractTextAreaWidget::OnMouseMoved(int x, int y, int deltaX, int deltaY)
+	{
+		if (m_isMouseButtonDown)
+			SetSelection(m_selectionCursor, GetHoveredGlyph(float(x), float(y)));
+	}
+
+	void AbstractTextAreaWidget::OnTextEntered(char32_t character, bool /*repeated*/)
+	{
+		if (m_readOnly)
+			return;
+
+		if (Nz::Unicode::GetCategory(character) == Nz::Unicode::Category_Other_Control || (m_characterFilter && !m_characterFilter(character)))
+			return;
+
+		if (HasSelection())
+			EraseSelection();
+
+		Write(Nz::String::Unicode(character));
+	}
+
+	void AbstractTextAreaWidget::RefreshCursor()
+	{
+		if (m_readOnly)
+			return;
+
+		const Nz::AbstractTextDrawer& textDrawer = GetTextDrawer();
+
+		auto GetGlyph = [&](const Nz::Vector2ui& glyphPosition, std::size_t* glyphIndex) -> const Nz::AbstractTextDrawer::Glyph*
+		{
+			if (glyphPosition.y >= textDrawer.GetLineCount())
+				return nullptr;
+
+			const auto& lineInfo = textDrawer.GetLine(glyphPosition.y);
+
+			std::size_t cursorGlyph = GetGlyphIndex({ glyphPosition.x, glyphPosition.y });
+			if (glyphIndex)
+				*glyphIndex = cursorGlyph;
+
+			std::size_t glyphCount = textDrawer.GetGlyphCount();
+			if (glyphCount > 0 && lineInfo.glyphIndex < cursorGlyph)
+			{
+				const auto& glyph = textDrawer.GetGlyph(std::min(cursorGlyph, glyphCount - 1));
+				return &glyph;
+			}
+			else
+				return nullptr;
+		};
+
+		// Move text so that cursor is always visible
+		const auto* lastGlyph = GetGlyph(m_cursorPositionEnd, nullptr);
+		float glyphPos = (lastGlyph) ? lastGlyph->bounds.x : 0.f;
+		float glyphWidth = (lastGlyph) ? lastGlyph->bounds.width : 0.f;
+
+		auto& node = m_textEntity->GetComponent<Ndk::NodeComponent>();
+		float textPosition = node.GetPosition(Nz::CoordSys_Local).x - paddingWidth;
+		float cursorPosition = glyphPos + textPosition;
+		float width = GetWidth();
+
+		if (width <= textDrawer.GetBounds().width)
+		{
+			if (cursorPosition + glyphWidth > width)
+				node.Move(width - cursorPosition - glyphWidth, 0.f);
+			else if (cursorPosition - glyphWidth < 0.f)
+				node.Move(-cursorPosition + glyphWidth, 0.f);
+		}
+		else
+			node.Move(-textPosition, 0.f); // Reset text position if we have enough room to show everything
+
+		// Show cursor/selection
+		std::size_t selectionLineCount = m_cursorPositionEnd.y - m_cursorPositionBegin.y + 1;
+		std::size_t oldSpriteCount = m_cursorSprites.size();
+		if (m_cursorSprites.size() != selectionLineCount)
+		{
+			m_cursorSprites.resize(m_cursorPositionEnd.y - m_cursorPositionBegin.y + 1);
+			for (std::size_t i = oldSpriteCount; i < m_cursorSprites.size(); ++i)
+			{
+				m_cursorSprites[i] = Nz::Sprite::New();
+				m_cursorSprites[i]->SetMaterial(Nz::Material::New("Translucent2D"));
+			}
+		}
+
+		GraphicsComponent& gfxComponent = m_cursorEntity->GetComponent<GraphicsComponent>();
+		gfxComponent.Clear();
+
+		for (unsigned int i = m_cursorPositionBegin.y; i <= m_cursorPositionEnd.y; ++i)
+		{
+			const auto& lineInfo = textDrawer.GetLine(i);
+
+			Nz::SpriteRef& cursorSprite = m_cursorSprites[i - m_cursorPositionBegin.y];
+			if (i == m_cursorPositionBegin.y || i == m_cursorPositionEnd.y)
+			{
+				auto GetGlyphPos = [&](const Nz::Vector2ui& glyphPosition)
+				{
+					std::size_t glyphIndex;
+					const auto* glyph = GetGlyph(glyphPosition, &glyphIndex);
+					if (glyph)
+					{
+						float position = glyph->bounds.x;
+						if (glyphIndex >= textDrawer.GetGlyphCount())
+							position += glyph->bounds.width;
+
+						return position;
+					}
+					else
+						return 0.f;
+				};
+
+				float beginX = (i == m_cursorPositionBegin.y) ? GetGlyphPos({ m_cursorPositionBegin.x, i }) : 0.f;
+				float endX = (i == m_cursorPositionEnd.y) ? GetGlyphPos({ m_cursorPositionEnd.x, i }) : lineInfo.bounds.width;
+				float spriteSize = std::max(endX - beginX, 1.f);
+
+				cursorSprite->SetColor((m_cursorPositionBegin == m_cursorPositionEnd) ? Nz::Color::Black : Nz::Color(0, 0, 0, 50));
+				cursorSprite->SetSize(spriteSize, lineInfo.bounds.height);
+
+				gfxComponent.Attach(cursorSprite, Nz::Matrix4f::Translate({ beginX, lineInfo.bounds.y, 0.f }));
+			}
+			else
+			{
+				cursorSprite->SetColor(Nz::Color(0, 0, 0, 50));
+				cursorSprite->SetSize(lineInfo.bounds.width, lineInfo.bounds.height);
+
+				gfxComponent.Attach(cursorSprite, Nz::Matrix4f::Translate({ 0.f, lineInfo.bounds.y, 0.f }));
+			}
+		}
+	}
+
+	void AbstractTextAreaWidget::UpdateTextSprite()
+	{
+		m_textSprite->Update(GetTextDrawer());
+		SetPreferredSize(Nz::Vector2f(m_textSprite->GetBoundingVolume().obb.localBox.GetLengths()));
+	}
+}
--- a/src/NazaraSDK/Widgets/BoxLayout.cpp
+++ b/src/NazaraSDK/Widgets/BoxLayout.cpp
@@ -0,0 +1,122 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Development Kit"
+// For conditions of distribution and use, see copyright notice in Prerequisites.hpp
+
+#include <NazaraSDK/Widgets/BoxLayout.hpp>
+#include <Nazara/Core/Log.hpp>
+#include <Nazara/Core/MemoryHelper.hpp>
+#include <cassert>
+
+namespace Ndk
+{
+	void BoxLayout::Layout()
+	{
+		std::size_t axis1, axis2;
+
+		switch (m_orientation)
+		{
+			case BoxLayoutOrientation_Horizontal:
+				axis1 = 0; //< x
+				axis2 = 1; //< y
+				break;
+
+			case BoxLayoutOrientation_Vertical:
+				axis1 = 1; //< y
+				axis2 = 0; //< x
+				break;
+
+			default:
+				assert(false);
+				break;
+		}
+
+		m_childInfos.clear();
+
+		// Handle size
+		ForEachWidgetChild([&](BaseWidget* child)
+		{
+			if (!child->IsVisible())
+				return;
+
+			m_childInfos.emplace_back();
+			auto& info = m_childInfos.back();
+			info.isConstrained = false;
+			info.maximumSize = child->GetMaximumSize()[axis1];
+			info.minimumSize = child->GetMinimumSize()[axis1];
+			info.size = info.minimumSize;
+			info.widget = child;
+		});
+
+		Nz::Vector2f layoutSize = GetSize();
+
+		float availableSpace = layoutSize[axis1] - m_spacing * (m_childInfos.size() - 1);
+		float remainingSize = availableSpace;
+		for (auto& info : m_childInfos)
+			remainingSize -= info.minimumSize;
+
+		// Okay this algorithm is FAR from perfect but I couldn't figure a way other than this one
+		std::size_t unconstrainedChildCount = m_childInfos.size();
+
+		bool hasUnconstrainedChilds = false;
+		for (std::size_t i = 0; i < m_childInfos.size(); ++i)
+		{
+			if (remainingSize <= 0.0001f)
+				break;
+
+			float evenSize = remainingSize / unconstrainedChildCount;
+
+			for (auto& info : m_childInfos)
+			{
+				if (info.isConstrained)
+					continue;
+
+				float previousSize = info.size;
+
+				info.size += evenSize;
+				if (info.size > info.maximumSize)
+				{
+					unconstrainedChildCount--;
+
+					evenSize += (info.size - info.maximumSize) / unconstrainedChildCount;
+					info.isConstrained = true;
+					info.size = info.maximumSize;
+				}
+				else
+					hasUnconstrainedChilds = true;
+
+				remainingSize -= info.size - previousSize;
+			}
+
+			if (!hasUnconstrainedChilds)
+				break;
+		}
+
+		float spacing = m_spacing + remainingSize / (m_childInfos.size() - 1);
+
+		for (auto& info : m_childInfos)
+		{
+			Nz::Vector2f newSize = info.widget->GetSize();
+			newSize[axis1] = info.size;
+
+			info.widget->Resize(newSize);
+		}
+
+		// Handle position
+		float cursor = 0.f;
+		bool first = true;
+		for (auto& info : m_childInfos)
+		{
+			if (first)
+				first = false;
+			else
+				cursor += spacing;
+
+			Nz::Vector2f position = Nz::Vector2f(0.f, 0.f);
+			position[axis1] = cursor;
+
+			info.widget->SetPosition(position);
+
+			cursor += info.size;
+		};
+	}
+}
--- a/src/NazaraSDK/Widgets/ButtonWidget.cpp
+++ b/src/NazaraSDK/Widgets/ButtonWidget.cpp
@@ -0,0 +1,126 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Development Kit"
+// For conditions of distribution and use, see copyright notice in Prerequisites.hpp
+
+#include <NazaraSDK/Widgets/ButtonWidget.hpp>
+#include <NazaraSDK/Components/GraphicsComponent.hpp>
+#include <NazaraSDK/Components/NodeComponent.hpp>
+
+namespace Ndk
+{
+	Nz::Color ButtonWidget::s_color { 74, 74, 74 };
+	Nz::Color ButtonWidget::s_cornerColor { 180, 180, 180 };
+	Nz::Color ButtonWidget::s_hoverColor { 128, 128, 128 };
+	Nz::Color ButtonWidget::s_hoverCornerColor { s_cornerColor };
+	Nz::Color ButtonWidget::s_pressColor { s_cornerColor };
+	Nz::Color ButtonWidget::s_pressCornerColor { s_color };
+
+	ButtonWidget::ButtonWidget(BaseWidget* parent) :
+	BaseWidget(parent),
+	m_color { s_color },
+	m_cornerColor { s_cornerColor },
+	m_hoverColor { s_hoverColor },
+	m_hoverCornerColor { s_hoverCornerColor },
+	m_pressColor { s_pressColor },
+	m_pressCornerColor { s_pressCornerColor }
+	{
+		m_gradientSprite = Nz::Sprite::New();
+		m_gradientSprite->SetColor(m_color);
+		m_gradientSprite->SetCornerColor(Nz::RectCorner_LeftBottom, m_cornerColor);
+		m_gradientSprite->SetCornerColor(Nz::RectCorner_RightBottom, m_cornerColor);
+		m_gradientSprite->SetMaterial(Nz::Material::New("Basic2D"));
+
+		m_gradientEntity = CreateEntity();
+		m_gradientEntity->AddComponent<NodeComponent>().SetParent(this);
+		m_gradientEntity->AddComponent<GraphicsComponent>().Attach(m_gradientSprite);
+
+		m_textSprite = Nz::TextSprite::New();
+
+		m_textEntity = CreateEntity();
+		m_textEntity->AddComponent<NodeComponent>().SetParent(this);
+		m_textEntity->AddComponent<GraphicsComponent>().Attach(m_textSprite, 1);
+
+		Layout();
+	}
+
+	const Nz::Color& ButtonWidget::GetDefaultColor()
+	{
+		return s_color;
+	}
+
+	const Nz::Color& ButtonWidget::GetDefaultCornerColor()
+	{
+		return s_cornerColor;
+	}
+
+	const Nz::Color& ButtonWidget::GetDefaultHoverColor()
+	{
+		return s_hoverColor;
+	}
+
+	const Nz::Color& ButtonWidget::GetDefaultHoverCornerColor()
+	{
+		return s_hoverCornerColor;
+	}
+
+	const Nz::Color& ButtonWidget::GetDefaultPressColor()
+	{
+		return s_pressColor;
+	}
+
+	const Nz::Color& ButtonWidget::GetDefaultPressCornerColor()
+	{
+		return s_pressCornerColor;
+	}
+
+	void ButtonWidget::Layout()
+	{
+		BaseWidget::Layout();
+
+		Nz::Vector2f size = GetSize();
+		m_gradientSprite->SetSize(size);
+
+		Nz::Boxf textBox = m_textEntity->GetComponent<GraphicsComponent>().GetAABB();
+		m_textEntity->GetComponent<NodeComponent>().SetPosition(size.x / 2.f - textBox.width / 2.f, size.y / 2.f - textBox.height / 2.f);
+	}
+
+	void ButtonWidget::OnMouseButtonPress(int /*x*/, int /*y*/, Nz::Mouse::Button button)
+	{
+		if (button == Nz::Mouse::Left)
+		{
+			m_gradientSprite->SetColor(m_pressColor);
+			m_gradientSprite->SetCornerColor(Nz::RectCorner_LeftBottom, m_pressCornerColor);
+			m_gradientSprite->SetCornerColor(Nz::RectCorner_RightBottom, m_pressCornerColor);
+			m_gradientSprite->SetTexture(m_pressTexture, false);
+		}
+	}
+
+	void ButtonWidget::OnMouseButtonRelease(int /*x*/, int /*y*/, Nz::Mouse::Button button)
+	{
+		if (button == Nz::Mouse::Left)
+		{
+			m_gradientSprite->SetColor(m_hoverColor);
+			m_gradientSprite->SetCornerColor(Nz::RectCorner_LeftBottom, m_hoverCornerColor);
+			m_gradientSprite->SetCornerColor(Nz::RectCorner_RightBottom, m_hoverCornerColor);
+			m_gradientSprite->SetTexture(m_hoverTexture, false);
+
+			OnButtonTrigger(this);
+		}
+	}
+
+	void ButtonWidget::OnMouseEnter()
+	{
+		m_gradientSprite->SetColor(m_hoverColor);
+		m_gradientSprite->SetCornerColor(Nz::RectCorner_LeftBottom, m_hoverCornerColor);
+		m_gradientSprite->SetCornerColor(Nz::RectCorner_RightBottom, m_hoverCornerColor);
+		m_gradientSprite->SetTexture(m_hoverTexture, false);
+	}
+
+	void ButtonWidget::OnMouseExit()
+	{
+		m_gradientSprite->SetColor(m_color);
+		m_gradientSprite->SetCornerColor(Nz::RectCorner_LeftBottom, m_cornerColor);
+		m_gradientSprite->SetCornerColor(Nz::RectCorner_RightBottom, m_cornerColor);
+		m_gradientSprite->SetTexture(m_texture, false);
+	}
+}
--- a/src/NazaraSDK/Widgets/CheckboxWidget.cpp
+++ b/src/NazaraSDK/Widgets/CheckboxWidget.cpp
@@ -0,0 +1,178 @@
+// Copyright (C) 2017 Samy Bensaid
+// This file is part of the "Nazara Development Kit"
+// For conditions of distribution and use, see copyright notice in Prerequisites.hpp
+
+#include <NazaraSDK/Widgets/CheckboxWidget.hpp>
+#include <NazaraSDK/Components/GraphicsComponent.hpp>
+#include <Nazara/Graphics/Material.hpp>
+#include <algorithm>
+
+namespace Ndk
+{
+	Nz::Color CheckboxWidget::s_backgroundColor { Nz::Color::White };
+	Nz::Color CheckboxWidget::s_disabledBackgroundColor { 201, 201, 201 };
+	Nz::Color CheckboxWidget::s_disabledBorderColor { 62, 62, 62 };
+	Nz::Color CheckboxWidget::s_borderColor { Nz::Color::Black };
+	float CheckboxWidget::s_borderScale { 16.f };
+
+	CheckboxWidget::CheckboxWidget(BaseWidget* parent) :
+	BaseWidget(parent),
+	m_adaptativeMargin { true },
+	m_checkboxEnabled { true },
+	m_tristateEnabled { false },
+	m_textMargin { 16.f },
+	m_state	{ CheckboxState_Unchecked }
+	{
+		m_checkboxBorderSprite = Nz::Sprite::New(Nz::Material::New("Basic2D"));
+		m_checkboxBackgroundSprite = Nz::Sprite::New(Nz::Material::New("Basic2D"));
+		m_checkboxContentSprite = Nz::Sprite::New(Nz::Material::New("Translucent2D"));
+		m_textSprite = Nz::TextSprite::New();
+
+		m_checkboxBorderEntity = CreateEntity();
+		m_checkboxBorderEntity->AddComponent<NodeComponent>().SetParent(this);
+		m_checkboxBorderEntity->AddComponent<GraphicsComponent>().Attach(m_checkboxBorderSprite);
+
+		m_checkboxBackgroundEntity = CreateEntity();
+		m_checkboxBackgroundEntity->AddComponent<NodeComponent>().SetParent(this);
+		m_checkboxBackgroundEntity->AddComponent<GraphicsComponent>().Attach(m_checkboxBackgroundSprite, 1);
+
+		m_checkboxContentEntity = CreateEntity();
+		m_checkboxContentEntity->AddComponent<NodeComponent>().SetParent(this);
+		m_checkboxContentEntity->AddComponent<GraphicsComponent>().Attach(m_checkboxContentSprite, 2);
+
+		m_textEntity = CreateEntity();
+		m_textEntity->AddComponent<NodeComponent>().SetParent(this);
+		m_textEntity->AddComponent<GraphicsComponent>().Attach(m_textSprite);
+
+		m_checkMark = Nz::TextureLibrary::Get("Ndk::CheckboxWidget::checkmark");
+
+		SetCheckboxSize({ 32.f, 32.f });
+		UpdateCheckbox();
+	}
+
+	bool CheckboxWidget::Initialize()
+	{
+		const Nz::UInt8 r_checkmark[] =
+		{
+			#include <NazaraSDK/Resources/checkmark.png.h>
+		};
+
+		Nz::TextureRef checkmarkTexture = Nz::Texture::LoadFromMemory(r_checkmark, sizeof(r_checkmark) / sizeof(r_checkmark[0]));
+		if (!checkmarkTexture)
+		{
+			NazaraError("Failed to load embedded checkmark");
+			return false;
+		}
+
+		Nz::TextureLibrary::Register("Ndk::CheckboxWidget::checkmark", std::move(checkmarkTexture));
+		return true;
+	}
+	
+	void CheckboxWidget::Uninitialize()
+	{
+		Nz::TextureLibrary::Unregister("Ndk::CheckboxWidget::checkmark");
+	}
+
+	void CheckboxWidget::SetState(CheckboxState state)
+	{
+		if (!m_checkboxEnabled)
+			return;
+
+		if (state == CheckboxState_Tristate)
+			m_tristateEnabled = true;
+
+		m_state = state;
+		UpdateCheckbox();
+	}
+
+	CheckboxState CheckboxWidget::SwitchToNextState()
+	{
+		if (!m_checkboxEnabled)
+			return m_state;
+
+		switch (m_state)
+		{
+			case CheckboxState_Unchecked:
+				SetState(CheckboxState_Checked);
+				break;
+
+			case CheckboxState_Checked:
+				SetState(m_tristateEnabled ? CheckboxState_Tristate : CheckboxState_Unchecked);
+				break;
+
+			case CheckboxState_Tristate:
+				SetState(CheckboxState_Unchecked);
+				break;
+		}
+
+		return m_state;
+	}
+
+	void CheckboxWidget::Layout()
+	{
+		BaseWidget::Layout();
+
+		Nz::Vector2f checkboxSize = GetCheckboxSize();
+		Nz::Vector2f borderSize = GetCheckboxBorderSize();
+
+		m_checkboxBackgroundEntity->GetComponent<NodeComponent>().SetPosition(borderSize);
+
+		Nz::Vector3f checkboxBox = m_checkboxContentSprite->GetBoundingVolume().obb.localBox.GetLengths();
+		m_checkboxContentEntity->GetComponent<NodeComponent>().SetPosition(checkboxSize.x / 2.f - checkboxBox.x / 2.f, checkboxSize.y / 2.f - checkboxBox.y / 2.f);
+
+		Nz::Vector3f textBox = m_textSprite->GetBoundingVolume().obb.localBox.GetLengths();
+		m_textEntity->GetComponent<NodeComponent>().SetPosition(checkboxSize.x + (m_adaptativeMargin ? checkboxSize.x / 2.f : m_textMargin), checkboxSize.y / 2.f - textBox.y / 2.f);
+	}
+
+	void CheckboxWidget::OnMouseButtonRelease(int x, int y, Nz::Mouse::Button button)
+	{
+		if (button == Nz::Mouse::Left && ContainsCheckbox(x, y) && IsCheckboxEnabled())
+		{
+			SwitchToNextState();
+			OnStateChanged(this);
+		}
+	}
+
+	void CheckboxWidget::UpdateCheckbox()
+	{
+		if (m_checkboxEnabled)
+		{
+			m_checkboxBorderSprite->SetColor(s_borderColor);
+			m_checkboxBackgroundSprite->SetColor(s_backgroundColor);
+		}
+		else
+		{
+			m_checkboxBorderSprite->SetColor(s_disabledBorderColor);
+			m_checkboxBackgroundSprite->SetColor(s_disabledBackgroundColor);
+		}
+
+
+		if (m_state == CheckboxState_Unchecked)
+		{
+			m_checkboxContentEntity->Enable(false);
+			return;
+		}
+		else if (m_state == CheckboxState_Checked)
+		{
+			m_checkboxContentEntity->Enable();
+			m_checkboxContentSprite->SetColor(Nz::Color::White);
+			m_checkboxContentSprite->SetTexture(m_checkMark, false);
+		}
+		else // Tristate
+		{
+			m_checkboxContentEntity->Enable();
+			m_checkboxContentSprite->SetColor(Nz::Color::Black);
+			m_checkboxContentSprite->SetTexture(Nz::TextureRef {});
+		}
+	}
+
+	void CheckboxWidget::UpdateSize()
+	{
+		Nz::Vector3f textSize = m_textSprite->GetBoundingVolume().obb.localBox.GetLengths();
+		Nz::Vector2f checkboxSize = GetCheckboxSize();
+
+		Nz::Vector2f finalSize { checkboxSize.x + (m_adaptativeMargin ? checkboxSize.x / 2.f : m_textMargin) + textSize.x, std::max(textSize.y, checkboxSize.y) };
+		SetMinimumSize(finalSize);
+		SetPreferredSize(finalSize);
+	}
+}
--- a/src/NazaraSDK/Widgets/ImageWidget.cpp
+++ b/src/NazaraSDK/Widgets/ImageWidget.cpp
@@ -0,0 +1,28 @@
+// Copyright (C) 2017 Samy Bensaid
+// This file is part of the "Nazara Development Kit"
+// For conditions of distribution and use, see copyright notice in Prerequisites.hpp
+
+#include <NazaraSDK/Widgets/ImageWidget.hpp>
+#include <NazaraSDK/Components/NodeComponent.hpp>
+#include <NazaraSDK/Components/GraphicsComponent.hpp>
+
+namespace Ndk
+{
+	ImageWidget::ImageWidget(BaseWidget* parent) :
+	BaseWidget(parent)
+	{
+		m_entity = CreateEntity();
+		m_entity->AddComponent<NodeComponent>().SetParent(this);
+		auto& gfx = m_entity->AddComponent<GraphicsComponent>();
+
+		m_sprite = Nz::Sprite::New();
+		gfx.Attach(m_sprite);
+	}
+
+	void ImageWidget::Layout()
+	{
+		BaseWidget::Layout();
+
+		m_sprite->SetSize(GetSize());
+	}
+}
--- a/src/NazaraSDK/Widgets/LabelWidget.cpp
+++ b/src/NazaraSDK/Widgets/LabelWidget.cpp
@@ -0,0 +1,22 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Development Kit"
+// For conditions of distribution and use, see copyright notice in Prerequisites.hpp
+
+#include <NazaraSDK/Widgets/LabelWidget.hpp>
+#include <NazaraSDK/Components/GraphicsComponent.hpp>
+#include <NazaraSDK/Components/NodeComponent.hpp>
+
+namespace Ndk
+{
+	LabelWidget::LabelWidget(BaseWidget* parent) :
+	BaseWidget(parent)
+	{
+		m_textSprite = Nz::TextSprite::New();
+
+		m_textEntity = CreateEntity();
+		m_textEntity->AddComponent<GraphicsComponent>().Attach(m_textSprite);
+		m_textEntity->AddComponent<NodeComponent>().SetParent(this);
+
+		Layout();
+	}
+}
--- a/src/NazaraSDK/Widgets/ProgressBarWidget.cpp
+++ b/src/NazaraSDK/Widgets/ProgressBarWidget.cpp
@@ -0,0 +1,100 @@
+// Copyright (C) 2017 Samy Bensaid
+// This file is part of the "Nazara Development Kit"
+// For conditions of distribution and use, see copyright notice in Prerequisites.hpp
+
+#include <NazaraSDK/Widgets/ProgressBarWidget.hpp>
+#include <NazaraSDK/Components/NodeComponent.hpp>
+#include <NazaraSDK/Components/GraphicsComponent.hpp>
+
+namespace Ndk
+{
+	float ProgressBarWidget::s_borderScale { 16.f };
+	Nz::Color ProgressBarWidget::s_borderColor { Nz::Color::Black };
+	Nz::Color ProgressBarWidget::s_barBackgroundColor { Nz::Color { 225, 225, 225 } };
+	Nz::Color ProgressBarWidget::s_barBackgroundCornerColor { Nz::Color { 255, 255, 255 } };
+	Nz::Color ProgressBarWidget::s_barColor { Nz::Color { 0, 225, 0 } };
+	Nz::Color ProgressBarWidget::s_barCornerColor { Nz::Color { 220, 255, 220 } };
+
+	ProgressBarWidget::ProgressBarWidget(BaseWidget* parent) :
+	BaseWidget(parent),
+	m_textColor { Nz::Color::Black },
+	m_textMargin { 16.f },
+	m_value { 0u }
+	{
+		m_borderSprite = Nz::Sprite::New(Nz::Material::New("Basic2D"));
+		m_barBackgroundSprite = Nz::Sprite::New(Nz::Material::New("Basic2D"));
+		m_barSprite = Nz::Sprite::New(Nz::Material::New("Basic2D"));
+
+		m_borderSprite->SetColor(s_borderColor);
+		SetBarBackgroundColor(s_barBackgroundColor, s_barBackgroundCornerColor);
+		SetBarColor(s_barColor, s_barCornerColor);
+
+
+		m_borderEntity = CreateEntity();
+		m_borderEntity->AddComponent<NodeComponent>().SetParent(this);
+		m_borderEntity->AddComponent<GraphicsComponent>().Attach(m_borderSprite);
+
+		m_barEntity = CreateEntity();
+		m_barEntity->AddComponent<NodeComponent>().SetParent(this);
+		GraphicsComponent& graphics = m_barEntity->AddComponent<GraphicsComponent>();
+
+		graphics.Attach(m_barBackgroundSprite, 1);
+		graphics.Attach(m_barSprite, 2);
+
+
+		m_textSprite = Nz::TextSprite::New();
+		m_textEntity = CreateEntity();
+
+		m_textEntity->AddComponent<NodeComponent>().SetParent(this);
+		m_textEntity->AddComponent<GraphicsComponent>().Attach(m_textSprite);
+
+		UpdateText();
+		Layout();
+	}
+
+
+	const Nz::Color& ProgressBarWidget::GetDefaultBarColor()
+	{
+		return s_barColor;
+	}
+
+	const Nz::Color& ProgressBarWidget::GetDefaultBarCornerColor()
+	{
+		return s_barCornerColor;
+	}
+
+	const Nz::Color& ProgressBarWidget::GetDefaultBarBackgroundColor()
+	{
+		return s_barBackgroundColor;
+	}
+
+	const Nz::Color& ProgressBarWidget::GetDefaultBarBackgroundCornerColor()
+	{
+		return s_barBackgroundCornerColor;
+	}
+
+
+	void ProgressBarWidget::Layout()
+	{
+		Nz::Vector2f size = GetSize();
+		Nz::Vector2f progressBarSize = size;
+
+		if (IsTextEnabled())
+		{
+			UpdateText();
+
+			Nz::Vector3f textSize = m_textSprite->GetBoundingVolume().obb.localBox.GetLengths();
+			m_textEntity->GetComponent<NodeComponent>().SetPosition(size.x - textSize.x, size.y / 2.f - textSize.y);
+
+			progressBarSize -= { textSize.x + m_textMargin, 0.f };
+		}
+
+		m_borderSprite->SetSize(progressBarSize);
+		Nz::Vector2f borderSize = GetProgressBarBorderSize();
+
+		m_barBackgroundSprite->SetSize(progressBarSize - (borderSize * 2.f));
+		m_barSprite->SetSize((progressBarSize.x - (borderSize.x * 2.f)) / 100.f * static_cast<float>(m_value), progressBarSize.y - (borderSize.y * 2.f));
+
+		m_barEntity->GetComponent<NodeComponent>().SetPosition(borderSize.x, borderSize.y);
+	}
+}
--- a/src/NazaraSDK/Widgets/RichTextAreaWidget.cpp
+++ b/src/NazaraSDK/Widgets/RichTextAreaWidget.cpp
@@ -0,0 +1,196 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Development Kit"
+// For conditions of distribution and use, see copyright notice in Prerequisites.hpp
+
+#include <NazaraSDK/Widgets/RichTextAreaWidget.hpp>
+
+namespace Ndk
+{
+	RichTextAreaWidget::RichTextAreaWidget(BaseWidget* parent) :
+	AbstractTextAreaWidget(parent)
+	{
+		Layout();
+	}
+	
+	void RichTextAreaWidget::AppendText(const Nz::String& text)
+	{
+		//m_text += text;
+		switch (m_echoMode)
+		{
+			case EchoMode_Normal:
+				m_drawer.AppendText(text);
+				break;
+
+			case EchoMode_Password:
+				m_drawer.AppendText(Nz::String(text.GetLength(), '*'));
+				break;
+
+			case EchoMode_PasswordExceptLast:
+			{
+				/*m_drawer.Clear();
+				std::size_t textLength = m_text.GetLength();
+				if (textLength >= 2)
+				{
+					std::size_t lastCharacterPosition = m_text.GetCharacterPosition(textLength - 2);
+					if (lastCharacterPosition != Nz::String::npos)
+						m_drawer.AppendText(Nz::String(textLength - 1, '*'));
+				}
+
+				if (textLength >= 1)
+					m_drawer.AppendText(m_text.SubString(m_text.GetCharacterPosition(textLength - 1)));*/
+
+				break;
+			}
+		}
+
+		UpdateTextSprite();
+
+		//OnTextChanged(this, m_text);
+	}
+
+	void RichTextAreaWidget::Clear()
+	{
+		AbstractTextAreaWidget::Clear();
+	}
+
+	void RichTextAreaWidget::Erase(std::size_t firstGlyph, std::size_t lastGlyph)
+	{
+		if (firstGlyph > lastGlyph)
+			std::swap(firstGlyph, lastGlyph);
+
+		std::size_t textLength = m_drawer.GetGlyphCount();
+		if (firstGlyph > textLength)
+			return;
+
+		std::size_t firstBlock = m_drawer.FindBlock(firstGlyph);
+		std::size_t lastBlock = m_drawer.FindBlock((lastGlyph > 0) ? lastGlyph - 1 : lastGlyph);
+		if (firstBlock == lastBlock)
+		{
+			const Nz::String& blockText = m_drawer.GetBlockText(firstBlock);
+			std::size_t blockFirstGlyph = m_drawer.GetBlockFirstGlyphIndex(firstBlock);
+
+			Nz::String newText;
+			if (firstGlyph > blockFirstGlyph)
+			{
+				std::size_t characterPosition = blockText.GetCharacterPosition(firstGlyph - blockFirstGlyph);
+				NazaraAssert(characterPosition != Nz::String::npos, "Invalid character position");
+
+				newText.Append(blockText.SubString(0, characterPosition - 1));
+			}
+
+			if (lastGlyph < textLength)
+				newText.Append(blockText.SubString(blockText.GetCharacterPosition(lastGlyph - blockFirstGlyph)));
+
+			if (!newText.IsEmpty())
+				m_drawer.SetBlockText(firstBlock, std::move(newText));
+			else
+				m_drawer.RemoveBlock(firstBlock);
+		}
+		else
+		{
+			const Nz::String& lastBlockText = m_drawer.GetBlockText(lastBlock);
+			std::size_t lastBlockGlyphIndex = m_drawer.GetBlockFirstGlyphIndex(lastBlock);
+
+			// First, update/delete last block
+			std::size_t lastCharPos = lastBlockText.GetCharacterPosition(lastGlyph - lastBlockGlyphIndex);
+			if (lastCharPos != Nz::String::npos)
+			{
+				Nz::String newText = lastBlockText.SubString(lastCharPos);
+				if (!newText.IsEmpty())
+					m_drawer.SetBlockText(lastBlock, std::move(newText));
+				else
+					m_drawer.RemoveBlock(lastBlock);
+			}
+
+			// And then remove all middle blocks, remove in reverse order because of index shifting
+			assert(lastBlock > 0);
+			for (std::size_t i = lastBlock - 1; i > firstBlock; --i)
+				m_drawer.RemoveBlock(i);
+
+			const Nz::String& firstBlockText = m_drawer.GetBlockText(firstBlock);
+			std::size_t firstBlockGlyphIndex = m_drawer.GetBlockFirstGlyphIndex(firstBlock);
+
+			// And finally update/delete first block
+			if (firstGlyph > firstBlockGlyphIndex)
+			{
+				std::size_t firstCharPos = firstBlockText.GetCharacterPosition(firstGlyph - firstBlockGlyphIndex - 1);
+				if (firstCharPos != Nz::String::npos)
+				{
+					Nz::String newText = firstBlockText.SubString(0, firstCharPos);
+					if (!newText.IsEmpty())
+						m_drawer.SetBlockText(firstBlock, std::move(newText));
+					else
+						m_drawer.RemoveBlock(firstBlock);
+				}
+			}
+			else
+				m_drawer.RemoveBlock(firstBlock);
+		}
+
+		UpdateDisplayText();
+	}
+
+	void RichTextAreaWidget::Write(const Nz::String& text, std::size_t glyphPosition)
+	{
+		if (m_drawer.HasBlocks())
+		{
+			auto block = m_drawer.GetBlock(m_drawer.FindBlock((glyphPosition > 0) ? glyphPosition - 1 : glyphPosition));
+			std::size_t firstGlyph = block.GetFirstGlyphIndex();
+			assert(glyphPosition >= firstGlyph);
+
+			Nz::String blockText = block.GetText();
+			std::size_t characterPosition = blockText.GetCharacterPosition(glyphPosition - firstGlyph);
+			blockText.Insert(characterPosition, text);
+
+			block.SetText(blockText);
+		}
+		else
+			m_drawer.AppendText(text);
+
+		SetCursorPosition(glyphPosition + text.GetLength());
+
+		UpdateDisplayText();
+	}
+
+	Nz::AbstractTextDrawer& RichTextAreaWidget::GetTextDrawer()
+	{
+		return m_drawer;
+	}
+
+	const Nz::AbstractTextDrawer& RichTextAreaWidget::GetTextDrawer() const
+	{
+		return m_drawer;
+	}
+
+	void RichTextAreaWidget::HandleIndentation(bool add)
+	{
+	}
+
+	void RichTextAreaWidget::HandleSelectionIndentation(bool add)
+	{
+	}
+
+	void RichTextAreaWidget::HandleWordCursorMove(bool left)
+	{
+	}
+
+	void RichTextAreaWidget::UpdateDisplayText()
+	{
+		/*m_drawer.Clear();
+		switch (m_echoMode)
+		{
+			case EchoMode_Normal:
+				m_drawer.AppendText(m_text);
+				break;
+
+			case EchoMode_Password:
+			case EchoMode_PasswordExceptLast:
+				m_drawer.AppendText(Nz::String(m_text.GetLength(), '*'));
+				break;
+		}*/
+
+		UpdateTextSprite();
+
+		SetCursorPosition(m_cursorPositionBegin); //< Refresh cursor position (prevent it from being outside of the text)
+	}
+}
--- a/src/NazaraSDK/Widgets/ScrollAreaWidget.cpp
+++ b/src/NazaraSDK/Widgets/ScrollAreaWidget.cpp
@@ -0,0 +1,198 @@
+// Copyright (C) 2019 Jérôme Leclercq
+// This file is part of the "Nazara Development Kit"
+// For conditions of distribution and use, see copyright notice in Prerequisites.hpp
+
+#include <NazaraSDK/Widgets/ScrollAreaWidget.hpp>
+#include <Nazara/Math/Algorithm.hpp>
+#include <NazaraSDK/Components/GraphicsComponent.hpp>
+#include <NazaraSDK/Components/NodeComponent.hpp>
+
+namespace Ndk
+{
+	namespace
+	{
+		constexpr float scrollbarPadding = 5.f;
+	}
+
+	ScrollAreaWidget::ScrollAreaWidget(BaseWidget* parent, BaseWidget* content) :
+	BaseWidget(parent),
+	m_content(content),
+	m_scrollbarStatus(ScrollBarStatus::None),
+	m_isScrollbarEnabled(true),
+	m_scrollRatio(0.f)
+	{
+		m_content->SetParent(this);
+		m_content->SetPosition(Nz::Vector3f::Zero());
+
+		m_scrollbarBackgroundSprite = Nz::Sprite::New();
+		m_scrollbarBackgroundSprite->SetColor(Nz::Color(62, 62, 62));
+
+		m_scrollbarBackgroundEntity = CreateEntity();
+		m_scrollbarBackgroundEntity->AddComponent<NodeComponent>().SetParent(this);
+		m_scrollbarBackgroundEntity->AddComponent<GraphicsComponent>().Attach(m_scrollbarBackgroundSprite, 1);
+
+		m_scrollbarSprite = Nz::Sprite::New();
+		m_scrollbarSprite->SetColor(Nz::Color(104, 104, 104));
+
+		m_scrollbarEntity = CreateEntity();
+		m_scrollbarEntity->AddComponent<NodeComponent>().SetParent(this);
+		m_scrollbarEntity->AddComponent<GraphicsComponent>().Attach(m_scrollbarSprite);
+
+		Resize(m_content->GetSize());
+	}
+
+	void ScrollAreaWidget::EnableScrollbar(bool enable)
+	{
+		if (m_isScrollbarEnabled != enable)
+		{
+			m_isScrollbarEnabled = enable;
+
+			bool isVisible = IsScrollbarVisible();
+			m_scrollbarEntity->Enable(isVisible);
+			m_scrollbarBackgroundEntity->Enable(isVisible);
+		}
+	}
+
+	void ScrollAreaWidget::ScrollToRatio(float ratio)
+	{
+		m_scrollRatio = Nz::Clamp(ratio, 0.f, 1.f);
+
+		float widgetHeight = GetHeight();
+		float maxHeight = widgetHeight - m_scrollbarSprite->GetSize().y - 2.f * scrollbarPadding;
+
+		auto& scrollbarNode = m_scrollbarEntity->GetComponent<Ndk::NodeComponent>();
+		scrollbarNode.SetPosition(Nz::Vector2f(scrollbarNode.GetPosition(Nz::CoordSys_Local).x, scrollbarPadding + m_scrollRatio * maxHeight));
+
+		float contentPosition = m_scrollRatio * (widgetHeight - m_content->GetHeight());
+
+		m_content->SetPosition(0.f, contentPosition);
+		m_content->SetRenderingRect(Nz::Rectf(-std::numeric_limits<float>::infinity(), -contentPosition, std::numeric_limits<float>::infinity(), widgetHeight));
+	}
+
+	Nz::Rectf ScrollAreaWidget::GetScrollbarRect() const
+	{
+		Nz::Vector2f scrollBarPosition = Nz::Vector2f(m_scrollbarEntity->GetComponent<Ndk::NodeComponent>().GetPosition(Nz::CoordSys_Local));
+		Nz::Vector2f scrollBarSize = m_scrollbarSprite->GetSize();
+		return Nz::Rectf(scrollBarPosition.x, scrollBarPosition.y, scrollBarSize.x, scrollBarSize.y);
+	}
+
+	void ScrollAreaWidget::Layout()
+	{
+		constexpr float scrollBarBackgroundWidth = 20.f;
+		constexpr float scrollBarWidth = scrollBarBackgroundWidth - 2.f * scrollbarPadding;
+
+		float areaHeight = GetHeight();
+		float contentHeight = m_content->GetHeight();
+
+		if (contentHeight > areaHeight)
+		{
+			m_hasScrollbar = true;
+
+			Nz::Vector2f contentSize(GetWidth() - scrollBarBackgroundWidth, contentHeight);
+			m_content->Resize(contentSize);
+
+			if (m_isScrollbarEnabled)
+			{
+				m_scrollbarEntity->Enable();
+				m_scrollbarBackgroundEntity->Enable();
+			}
+
+ 			float scrollBarHeight = std::max(std::floor(areaHeight * (areaHeight / contentHeight)), 20.f);
+
+			m_scrollbarBackgroundSprite->SetSize(scrollBarBackgroundWidth, areaHeight);
+			m_scrollbarSprite->SetSize(scrollBarWidth, scrollBarHeight);
+
+			m_scrollbarBackgroundEntity->GetComponent<Ndk::NodeComponent>().SetPosition(contentSize.x, 0.f);
+			m_scrollbarEntity->GetComponent<Ndk::NodeComponent>().SetPosition(contentSize.x + (scrollBarBackgroundWidth - scrollBarWidth) / 2.f, 0.f);
+
+			ScrollToRatio(m_scrollRatio);
+		}
+		else
+		{
+			m_hasScrollbar = false;
+
+			m_content->Resize(GetSize());
+
+			m_scrollbarEntity->Disable();
+			m_scrollbarBackgroundEntity->Disable();
+
+			ScrollToRatio(0.f);
+		}
+
+		BaseWidget::Layout();
+	}
+
+	void ScrollAreaWidget::OnMouseButtonPress(int x, int y, Nz::Mouse::Button button)
+	{
+		if (button != Nz::Mouse::Left)
+			return;
+
+		if (m_scrollbarStatus == ScrollBarStatus::Hovered)
+		{
+			UpdateScrollbarStatus(ScrollBarStatus::Grabbed);
+
+			auto& scrollbarNode = m_scrollbarEntity->GetComponent<Ndk::NodeComponent>();
+
+			m_grabbedDelta.Set(x, int(y - scrollbarNode.GetPosition(Nz::CoordSys_Local).y));
+		}
+	}
+
+	void ScrollAreaWidget::OnMouseButtonRelease(int x, int y, Nz::Mouse::Button button)
+	{
+		if (button != Nz::Mouse::Left)
+			return;
+
+		if (m_scrollbarStatus == ScrollBarStatus::Grabbed)
+		{
+			Nz::Rectf scrollBarRect = GetScrollbarRect();
+			UpdateScrollbarStatus((scrollBarRect.Contains(Nz::Vector2f(float(x), float(y)))) ? ScrollBarStatus::Hovered : ScrollBarStatus::None);
+		}
+	}
+
+	void ScrollAreaWidget::OnMouseExit()
+	{
+		//if (m_scrollbarStatus == ScrollBarStatus::Hovered)
+			UpdateScrollbarStatus(ScrollBarStatus::None);
+	}
+
+	void ScrollAreaWidget::OnMouseMoved(int x, int y, int /*deltaX*/, int /*deltaY*/)
+	{
+		if (m_scrollbarStatus == ScrollBarStatus::Grabbed)
+		{
+			float height = GetHeight();
+			float maxHeight = height - m_scrollbarSprite->GetSize().y;
+			float newHeight = Nz::Clamp(float(y - m_grabbedDelta.y), 0.f, maxHeight);
+
+			ScrollToHeight(newHeight / maxHeight * m_content->GetHeight());
+		}
+		else
+		{
+			Nz::Rectf scrollBarRect = GetScrollbarRect();
+			UpdateScrollbarStatus((scrollBarRect.Contains(Nz::Vector2f(float(x), float(y)))) ? ScrollBarStatus::Hovered : ScrollBarStatus::None);
+		}
+	}
+
+	void ScrollAreaWidget::OnMouseWheelMoved(int /*x*/, int /*y*/, float delta)
+	{
+		constexpr float scrollStep = 100.f;
+
+		ScrollToHeight(GetScrollHeight() - scrollStep * delta);
+	}
+
+	void ScrollAreaWidget::UpdateScrollbarStatus(ScrollBarStatus status)
+	{
+		if (m_scrollbarStatus != status)
+		{
+			Nz::Color newColor;
+			switch (status)
+			{
+				case ScrollBarStatus::Grabbed: newColor = Nz::Color(235, 235, 235); break;
+				case ScrollBarStatus::Hovered: newColor = Nz::Color(152, 152, 152); break;
+				case ScrollBarStatus::None:    newColor = Nz::Color(104, 104, 104); break;
+			}
+
+			m_scrollbarSprite->SetColor(newColor);
+			m_scrollbarStatus = status;
+		}
+	}
+}
--- a/src/NazaraSDK/Widgets/TextAreaWidget.cpp
+++ b/src/NazaraSDK/Widgets/TextAreaWidget.cpp
@@ -0,0 +1,253 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Development Kit"
+// For conditions of distribution and use, see copyright notice in Prerequisites.hpp
+
+#include <NazaraSDK/Widgets/TextAreaWidget.hpp>
+#include <Nazara/Core/Unicode.hpp>
+#include <Nazara/Utility/Font.hpp>
+#include <NazaraSDK/Components/GraphicsComponent.hpp>
+#include <NazaraSDK/Components/NodeComponent.hpp>
+
+namespace Ndk
+{
+	TextAreaWidget::TextAreaWidget(BaseWidget* parent) :
+	AbstractTextAreaWidget(parent)
+	{
+		SetCharacterSize(GetCharacterSize()); //< Actualize minimum / preferred size
+
+		Layout();
+	}
+	
+	void TextAreaWidget::AppendText(const Nz::String& text)
+	{
+		m_text += text;
+		switch (m_echoMode)
+		{
+			case EchoMode_Normal:
+				m_drawer.AppendText(text);
+				break;
+
+			case EchoMode_Password:
+				m_drawer.AppendText(Nz::String(text.GetLength(), '*'));
+				break;
+
+			case EchoMode_PasswordExceptLast:
+			{
+				m_drawer.Clear();
+				std::size_t textLength = m_text.GetLength();
+				if (textLength >= 2)
+				{
+					std::size_t lastCharacterPosition = m_text.GetCharacterPosition(textLength - 2);
+					if (lastCharacterPosition != Nz::String::npos)
+						m_drawer.AppendText(Nz::String(textLength - 1, '*'));
+				}
+
+				if (textLength >= 1)
+					m_drawer.AppendText(m_text.SubString(m_text.GetCharacterPosition(textLength - 1)));
+
+				break;
+			}
+		}
+
+		UpdateTextSprite();
+
+		OnTextChanged(this, m_text);
+	}
+
+	void TextAreaWidget::Clear()
+	{
+		AbstractTextAreaWidget::Clear();
+
+		m_text.Clear();
+		OnTextChanged(this, m_text);
+	}
+	
+	void TextAreaWidget::Erase(std::size_t firstGlyph, std::size_t lastGlyph)
+	{
+		if (firstGlyph > lastGlyph)
+			std::swap(firstGlyph, lastGlyph);
+
+		std::size_t textLength = m_text.GetLength();
+		if (firstGlyph > textLength)
+			return;
+
+		Nz::String newText;
+		if (firstGlyph > 0)
+		{
+			std::size_t characterPosition = m_text.GetCharacterPosition(firstGlyph);
+			NazaraAssert(characterPosition != Nz::String::npos, "Invalid character position");
+
+			newText.Append(m_text.SubString(0, characterPosition - 1));
+		}
+
+		if (lastGlyph < textLength)
+		{
+			std::size_t characterPosition = m_text.GetCharacterPosition(lastGlyph);
+			NazaraAssert(characterPosition != Nz::String::npos, "Invalid character position");
+
+			newText.Append(m_text.SubString(characterPosition));
+		}
+
+		SetText(newText);
+	}
+
+	void TextAreaWidget::Write(const Nz::String& text, std::size_t glyphPosition)
+	{
+		if (glyphPosition >= m_drawer.GetGlyphCount())
+		{
+			// It's faster to append than to insert in the middle
+			AppendText(text);
+			SetCursorPosition(m_drawer.GetGlyphCount());
+		}
+		else
+		{
+			m_text.Insert(m_text.GetCharacterPosition(glyphPosition), text);
+			SetText(m_text);
+
+			SetCursorPosition(glyphPosition + text.GetLength());
+		}
+	}
+
+	Nz::AbstractTextDrawer& TextAreaWidget::GetTextDrawer()
+	{
+		return m_drawer;
+	}
+
+	const Nz::AbstractTextDrawer& TextAreaWidget::GetTextDrawer() const
+	{
+		return m_drawer;
+	}
+
+	void TextAreaWidget::HandleIndentation(bool add)
+	{
+		if (add)
+			Write(Nz::String('\t'));
+		else
+		{
+			std::size_t currentGlyph = GetGlyphIndex(m_cursorPositionBegin);
+
+			if (currentGlyph > 0 && m_text[m_text.GetCharacterPosition(currentGlyph - 1U)] == '\t') // Check if previous glyph is a tab
+			{
+				Erase(currentGlyph - 1U);
+
+				if (m_cursorPositionBegin.x < static_cast<unsigned int>(m_drawer.GetLineGlyphCount(m_cursorPositionBegin.y)))
+					MoveCursor(-1);
+			}
+		}
+	}
+
+	void TextAreaWidget::HandleSelectionIndentation(bool add)
+	{
+		for (unsigned line = m_cursorPositionBegin.y; line <= m_cursorPositionEnd.y; ++line)
+		{
+			const Nz::Vector2ui cursorPositionBegin = m_cursorPositionBegin;
+			const Nz::Vector2ui cursorPositionEnd = m_cursorPositionEnd;
+
+			if (add)
+			{
+				Write(Nz::String('\t'), { 0U, line });
+				SetSelection(cursorPositionBegin + (cursorPositionBegin.y == line && cursorPositionBegin.x != 0U ? Nz::Vector2ui{ 1U, 0U } : Nz::Vector2ui{}),
+				             cursorPositionEnd + (cursorPositionEnd.y == line ? Nz::Vector2ui{ 1U, 0U } : Nz::Vector2ui{}));
+			}
+			else
+			{
+				if (m_drawer.GetLineGlyphCount(line) == 0)
+					continue;
+
+				std::size_t firstGlyph = GetGlyphIndex({ 0U, line });
+
+				if (m_text[m_text.GetCharacterPosition(firstGlyph)] == '\t')
+				{
+					Erase(firstGlyph);
+					SetSelection(cursorPositionBegin - (cursorPositionBegin.y == line && cursorPositionBegin.x != 0U ? Nz::Vector2ui{ 1U, 0U } : Nz::Vector2ui{}),
+					             cursorPositionEnd - (cursorPositionEnd.y == line && cursorPositionEnd.x != 0U ? Nz::Vector2ui{ 1U, 0U } : Nz::Vector2ui{}));
+				}
+			}
+		}
+	}
+
+	void TextAreaWidget::HandleWordCursorMove(bool left)
+	{
+		if (left)
+		{
+			std::size_t index = GetGlyphIndex(m_cursorPositionBegin);
+			if (index == 0)
+				return;
+
+			std::size_t spaceIndex = m_text.FindLast(' ', index - 2);
+			std::size_t endlIndex = m_text.FindLast('\n', index - 1);
+
+			if ((spaceIndex > endlIndex || endlIndex == Nz::String::npos) && spaceIndex != Nz::String::npos)
+				SetCursorPosition(spaceIndex + 1);
+			else if (endlIndex != Nz::String::npos)
+			{
+				if (index == endlIndex + 1)
+					SetCursorPosition(endlIndex);
+				else
+					SetCursorPosition(endlIndex + 1);
+			}
+			else
+				SetCursorPosition({ 0U, m_cursorPositionBegin.y });
+		}
+		else
+		{
+			std::size_t index = GetGlyphIndex(m_cursorPositionEnd);
+			std::size_t spaceIndex = m_text.Find(' ', index);
+			std::size_t endlIndex = m_text.Find('\n', index);
+
+			if (spaceIndex < endlIndex && spaceIndex != Nz::String::npos)
+			{
+				if (m_text.GetSize() > spaceIndex)
+					SetCursorPosition(spaceIndex + 1);
+				else
+					SetCursorPosition({ static_cast<unsigned int>(m_drawer.GetLineGlyphCount(m_cursorPositionEnd.y)), m_cursorPositionEnd.y });
+			}
+			else if (endlIndex != Nz::String::npos)
+			{
+				if (index == endlIndex)
+					SetCursorPosition(endlIndex + 1);
+				else
+					SetCursorPosition(endlIndex);
+			}
+			else
+				SetCursorPosition({ static_cast<unsigned int>(m_drawer.GetLineGlyphCount(m_cursorPositionEnd.y)), m_cursorPositionEnd.y });
+		}
+	}
+
+	void TextAreaWidget::UpdateDisplayText()
+	{
+		switch (m_echoMode)
+		{
+			case EchoMode_Normal:
+				m_drawer.SetText(m_text);
+				break;
+
+			case EchoMode_Password:
+			case EchoMode_PasswordExceptLast:
+				m_drawer.SetText(Nz::String(m_text.GetLength(), '*'));
+				break;
+		}
+
+		UpdateTextSprite();
+
+		SetCursorPosition(m_cursorPositionBegin); //< Refresh cursor position (prevent it from being outside of the text)
+	}
+
+	void TextAreaWidget::UpdateMinimumSize()
+	{
+		std::size_t fontCount = m_drawer.GetFontCount();
+		float lineHeight = 0;
+		int spaceAdvance = 0;
+		for (std::size_t i = 0; i < fontCount; ++i)
+		{
+			Nz::Font* font = m_drawer.GetFont(i);
+
+			const Nz::Font::SizeInfo& sizeInfo = font->GetSizeInfo(m_drawer.GetCharacterSize());
+			lineHeight = std::max(lineHeight, m_drawer.GetLineHeight());
+			spaceAdvance = std::max(spaceAdvance, sizeInfo.spaceAdvance);
+		}
+
+		Nz::Vector2f size = { float(spaceAdvance), lineHeight + 5.f };
+		SetMinimumSize(size);
+	}
+}