Replace #include <NDK/ by #include <NazaraSDK/

SDK/include/NazaraSDK/Widgets/AbstractTextAreaWidget.hpp

@@ -0,0 +1,135 @@
+// 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
+
+#pragma once
+
+#ifndef NDK_WIDGETS_ABSTRACTTEXTAREAWIDGET_HPP
+#define NDK_WIDGETS_ABSTRACTTEXTAREAWIDGET_HPP
+
+#include <Nazara/Graphics/TextSprite.hpp>
+#include <Nazara/Utility/AbstractTextDrawer.hpp>
+#include <NazaraSDK/BaseWidget.hpp>
+#include <NazaraSDK/Widgets/Enums.hpp>
+#include <functional>
+#include <vector>
+
+namespace Ndk
+{
+	class NDK_API AbstractTextAreaWidget : public BaseWidget
+	{
+		public:
+			using CharacterFilter = std::function<bool(char32_t)>;
+
+			AbstractTextAreaWidget(BaseWidget* parent);
+			AbstractTextAreaWidget(const AbstractTextAreaWidget&) = delete;
+			AbstractTextAreaWidget(AbstractTextAreaWidget&&) = default;
+			~AbstractTextAreaWidget() = default;
+
+			virtual void Clear();
+
+			//virtual TextAreaWidget* Clone() const = 0;
+
+			void EnableLineWrap(bool enable = true);
+			inline void EnableMultiline(bool enable = true);
+			inline void EnableTabWriting(bool enable = true);
+
+			inline void Erase(std::size_t glyphPosition);
+			virtual void Erase(std::size_t firstGlyph, std::size_t lastGlyph) = 0;
+			inline void EraseSelection();
+
+			inline const CharacterFilter& GetCharacterFilter() const;
+			inline const Nz::Vector2ui& GetCursorPosition() const;
+			inline Nz::Vector2ui GetCursorPosition(std::size_t glyphIndex) const;
+			inline EchoMode GetEchoMode() const;
+			inline std::size_t GetGlyphIndex() const;
+			inline std::size_t GetGlyphIndex(const Nz::Vector2ui& cursorPosition) const;
+			inline const Nz::String& GetText() const;
+
+			Nz::Vector2ui GetHoveredGlyph(float x, float y) const;
+
+			inline bool HasSelection() const;
+
+			inline bool IsLineWrapEnabled() const;
+			inline bool IsMultilineEnabled() const;
+			inline bool IsReadOnly() const;
+			inline bool IsTabWritingEnabled() const;
+
+			inline void MoveCursor(int offset);
+			inline void MoveCursor(const Nz::Vector2i& offset);
+
+			inline Nz::Vector2ui NormalizeCursorPosition(Nz::Vector2ui cursorPosition) const;
+
+			inline void SetCharacterFilter(CharacterFilter filter);
+			inline void SetCursorPosition(std::size_t glyphIndex);
+			inline void SetCursorPosition(Nz::Vector2ui cursorPosition);
+			inline void SetEchoMode(EchoMode echoMode);
+			inline void SetReadOnly(bool readOnly = true);
+			inline void SetSelection(Nz::Vector2ui fromPosition, Nz::Vector2ui toPosition);
+
+			inline void Write(const Nz::String& text);
+			inline void Write(const Nz::String& text, const Nz::Vector2ui& glyphPosition);
+			virtual void Write(const Nz::String& text, std::size_t glyphPosition) = 0;
+
+			AbstractTextAreaWidget& operator=(const AbstractTextAreaWidget&) = delete;
+			AbstractTextAreaWidget& operator=(AbstractTextAreaWidget&&) = default;
+
+			NazaraSignal(OnTextAreaCursorMove, const AbstractTextAreaWidget* /*textArea*/, Nz::Vector2ui* /*newCursorPosition*/);
+			NazaraSignal(OnTextAreaKeyBackspace, const AbstractTextAreaWidget* /*textArea*/, bool* /*ignoreDefaultAction*/);
+			NazaraSignal(OnTextAreaKeyDown, const AbstractTextAreaWidget* /*textArea*/, bool* /*ignoreDefaultAction*/);
+			NazaraSignal(OnTextAreaKeyEnd, const AbstractTextAreaWidget* /*textArea*/, bool* /*ignoreDefaultAction*/);
+			NazaraSignal(OnTextAreaKeyHome, const AbstractTextAreaWidget* /*textArea*/, bool* /*ignoreDefaultAction*/);
+			NazaraSignal(OnTextAreaKeyLeft, const AbstractTextAreaWidget* /*textArea*/, bool* /*ignoreDefaultAction*/);
+			NazaraSignal(OnTextAreaKeyReturn, const AbstractTextAreaWidget* /*textArea*/, bool* /*ignoreDefaultAction*/);
+			NazaraSignal(OnTextAreaKeyRight, const AbstractTextAreaWidget* /*textArea*/, bool* /*ignoreDefaultAction*/);
+			NazaraSignal(OnTextAreaKeyUp, const AbstractTextAreaWidget* /*textArea*/, bool* /*ignoreDefaultAction*/);
+			NazaraSignal(OnTextAreaSelection, const AbstractTextAreaWidget* /*textArea*/, Nz::Vector2ui* /*start*/, Nz::Vector2ui* /*end*/);
+
+		protected:
+			virtual Nz::AbstractTextDrawer& GetTextDrawer() = 0;
+			virtual const Nz::AbstractTextDrawer& GetTextDrawer() const = 0;
+
+			void Layout() override;
+
+			virtual void HandleIndentation(bool add) = 0;
+			virtual void HandleSelectionIndentation(bool add) = 0;
+			virtual void HandleWordCursorMove(bool left) = 0;
+
+			bool IsFocusable() const override;
+			void OnFocusLost() override;
+			void OnFocusReceived() override;
+			bool OnKeyPressed(const Nz::WindowEvent::KeyEvent& key) override;
+			void OnKeyReleased(const Nz::WindowEvent::KeyEvent& key) override;
+			void OnMouseButtonPress(int /*x*/, int /*y*/, Nz::Mouse::Button button) override;
+			void OnMouseButtonRelease(int /*x*/, int /*y*/, Nz::Mouse::Button button) override;
+			void OnMouseEnter() override;
+			void OnMouseMoved(int x, int y, int deltaX, int deltaY) override;
+			void OnTextEntered(char32_t character, bool repeated) override;
+
+			inline void SetCursorPositionInternal(std::size_t glyphIndex);
+			inline void SetCursorPositionInternal(Nz::Vector2ui cursorPosition);
+
+			void RefreshCursor();
+			virtual void UpdateDisplayText() = 0;
+			void UpdateTextSprite();
+
+			CharacterFilter m_characterFilter;
+			EchoMode m_echoMode;
+			EntityHandle m_cursorEntity;
+			EntityHandle m_textEntity;
+			Nz::TextSpriteRef m_textSprite;
+			Nz::Vector2ui m_cursorPositionBegin;
+			Nz::Vector2ui m_cursorPositionEnd;
+			Nz::Vector2ui m_selectionCursor;
+			std::vector<Nz::SpriteRef> m_cursorSprites;
+			bool m_isLineWrapEnabled;
+			bool m_isMouseButtonDown;
+			bool m_multiLineEnabled;
+			bool m_readOnly;
+			bool m_tabEnabled; // writes (Shift+)Tab character if set to true
+	};
+}
+
+#include <NazaraSDK/Widgets/AbstractTextAreaWidget.inl>
+
+#endif // NDK_WIDGETS_ABSTRACTTEXTAREAWIDGET_HPP

SDK/include/NazaraSDK/Widgets/AbstractTextAreaWidget.inl

@@ -0,0 +1,252 @@
+// 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>
+
+namespace Ndk
+{
+	inline void AbstractTextAreaWidget::EnableMultiline(bool enable)
+	{
+		m_multiLineEnabled = enable;
+	}
+
+	inline void AbstractTextAreaWidget::EnableTabWriting(bool enable)
+	{
+		m_tabEnabled = enable;
+	}
+
+	inline void AbstractTextAreaWidget::Erase(std::size_t glyphPosition)
+	{
+		Erase(glyphPosition, glyphPosition + 1U);
+	}
+
+	inline void AbstractTextAreaWidget::EraseSelection()
+	{
+		if (!HasSelection())
+			return;
+
+		Erase(GetGlyphIndex(m_cursorPositionBegin), GetGlyphIndex(m_cursorPositionEnd));
+	}
+
+	inline const AbstractTextAreaWidget::CharacterFilter& AbstractTextAreaWidget::GetCharacterFilter() const
+	{
+		return m_characterFilter;
+	}
+
+	inline const Nz::Vector2ui& AbstractTextAreaWidget::GetCursorPosition() const
+	{
+		return m_cursorPositionBegin;
+	}
+
+	Nz::Vector2ui AbstractTextAreaWidget::GetCursorPosition(std::size_t glyphIndex) const
+	{
+		const Nz::AbstractTextDrawer& textDrawer = GetTextDrawer();
+
+		glyphIndex = std::min(glyphIndex, GetTextDrawer().GetGlyphCount());
+
+		std::size_t lineCount = textDrawer.GetLineCount();
+		std::size_t line = 0U;
+		for (std::size_t i = line + 1; i < lineCount; ++i)
+		{
+			if (textDrawer.GetLine(i).glyphIndex > glyphIndex)
+				break;
+
+			line = i;
+		}
+
+		const auto& lineInfo = textDrawer.GetLine(line);
+
+		Nz::Vector2ui cursorPos;
+		cursorPos.y = static_cast<unsigned int>(line);
+		cursorPos.x = static_cast<unsigned int>(glyphIndex - lineInfo.glyphIndex);
+
+		return cursorPos;
+	}
+
+	inline EchoMode AbstractTextAreaWidget::GetEchoMode() const
+	{
+		return m_echoMode;
+	}
+
+	inline std::size_t AbstractTextAreaWidget::GetGlyphIndex() const
+	{
+		return GetGlyphIndex(m_cursorPositionBegin);
+	}
+
+	inline std::size_t AbstractTextAreaWidget::GetGlyphIndex(const Nz::Vector2ui& cursorPosition) const
+	{
+		const Nz::AbstractTextDrawer& textDrawer = GetTextDrawer();
+
+		std::size_t glyphIndex = textDrawer.GetLine(cursorPosition.y).glyphIndex + cursorPosition.x;
+		if (textDrawer.GetLineCount() > cursorPosition.y + 1)
+			glyphIndex = std::min(glyphIndex, textDrawer.GetLine(cursorPosition.y + 1).glyphIndex - 1);
+		else
+			glyphIndex = std::min(glyphIndex, textDrawer.GetGlyphCount());
+
+		return glyphIndex;
+	}
+
+	inline bool AbstractTextAreaWidget::HasSelection() const
+	{
+		return m_cursorPositionBegin != m_cursorPositionEnd;
+	}
+
+	inline bool AbstractTextAreaWidget::IsLineWrapEnabled() const
+	{
+		return m_isLineWrapEnabled;
+	}
+
+	inline bool AbstractTextAreaWidget::IsMultilineEnabled() const
+	{
+		return m_multiLineEnabled;
+	}
+
+	inline bool AbstractTextAreaWidget::IsTabWritingEnabled() const
+	{
+		return m_tabEnabled;
+	}
+
+	inline bool AbstractTextAreaWidget::IsReadOnly() const
+	{
+		return m_readOnly;
+	}
+
+	inline void AbstractTextAreaWidget::MoveCursor(int offset)
+	{
+		std::size_t cursorGlyph = GetGlyphIndex(m_cursorPositionBegin);
+		if (offset >= 0)
+			SetCursorPosition(cursorGlyph + static_cast<std::size_t>(offset));
+		else
+		{
+			std::size_t nOffset = static_cast<std::size_t>(-offset);
+			if (nOffset >= cursorGlyph)
+				SetCursorPosition(0);
+			else
+				SetCursorPosition(cursorGlyph - nOffset);
+		}
+	}
+
+	inline void AbstractTextAreaWidget::MoveCursor(const Nz::Vector2i& offset)
+	{
+		auto ClampOffset = [] (unsigned int cursorPosition, int cursorOffset) -> unsigned int
+		{
+			if (cursorOffset >= 0)
+				return cursorPosition + cursorOffset;
+			else
+			{
+				unsigned int nOffset = static_cast<unsigned int>(-cursorOffset);
+				if (nOffset >= cursorPosition)
+					return 0;
+				else
+					return cursorPosition - nOffset;
+			}
+		};
+
+		Nz::Vector2ui cursorPosition = m_cursorPositionBegin;
+		cursorPosition.x = ClampOffset(static_cast<unsigned int>(cursorPosition.x), offset.x);
+		cursorPosition.y = ClampOffset(static_cast<unsigned int>(cursorPosition.y), offset.y);
+
+		SetCursorPosition(cursorPosition);
+	}
+
+	inline Nz::Vector2ui AbstractTextAreaWidget::NormalizeCursorPosition(Nz::Vector2ui cursorPosition) const
+	{
+		const Nz::AbstractTextDrawer& textDrawer = GetTextDrawer();
+
+		std::size_t lineCount = textDrawer.GetLineCount();
+		if (cursorPosition.y >= lineCount)
+			cursorPosition.y = static_cast<unsigned int>(lineCount - 1);
+
+		const auto& lineInfo = textDrawer.GetLine(cursorPosition.y);
+		if (cursorPosition.y + 1 < lineCount)
+		{
+			const auto& nextLineInfo = textDrawer.GetLine(cursorPosition.y + 1);
+			cursorPosition.x = std::min(cursorPosition.x, static_cast<unsigned int>(nextLineInfo.glyphIndex - lineInfo.glyphIndex - 1));
+		}
+
+		return cursorPosition;
+	}
+
+	inline void AbstractTextAreaWidget::SetCharacterFilter(CharacterFilter filter)
+	{
+		m_characterFilter = std::move(filter);
+	}
+
+	inline void AbstractTextAreaWidget::SetCursorPosition(std::size_t glyphIndex)
+	{
+		Nz::Vector2ui position = GetCursorPosition(glyphIndex);
+		Nz::Vector2ui newPosition = position;
+
+		OnTextAreaCursorMove(this, &newPosition);
+
+		if (position == newPosition)
+			SetCursorPositionInternal(position);
+		else
+			SetCursorPositionInternal(GetGlyphIndex(newPosition));
+	}
+
+	inline void AbstractTextAreaWidget::SetCursorPosition(Nz::Vector2ui cursorPosition)
+	{
+		OnTextAreaCursorMove(this, &cursorPosition);
+
+		return SetCursorPositionInternal(NormalizeCursorPosition(cursorPosition));
+	}
+
+	inline void AbstractTextAreaWidget::SetEchoMode(EchoMode echoMode)
+	{
+		m_echoMode = echoMode;
+
+		UpdateDisplayText();
+	}
+
+	inline void AbstractTextAreaWidget::SetReadOnly(bool readOnly)
+	{
+		m_readOnly = readOnly;
+		m_cursorEntity->Enable(!m_readOnly && HasFocus());
+	}
+
+	inline void AbstractTextAreaWidget::SetSelection(Nz::Vector2ui fromPosition, Nz::Vector2ui toPosition)
+	{
+		// Ensure begin is before end
+		if (toPosition.y < fromPosition.y || (toPosition.y == fromPosition.y && toPosition.x < fromPosition.x))
+			std::swap(fromPosition, toPosition);
+
+		if (m_cursorPositionBegin != fromPosition || m_cursorPositionEnd != toPosition)
+		{
+			OnTextAreaSelection(this, &fromPosition, &toPosition);
+
+			// Ensure begin is before end a second time (in case signal changed it)
+			if (toPosition.y < fromPosition.y || (toPosition.y == fromPosition.y && toPosition.x < fromPosition.x))
+				std::swap(fromPosition, toPosition);
+
+			m_cursorPositionBegin = NormalizeCursorPosition(fromPosition);
+			m_cursorPositionEnd = NormalizeCursorPosition(toPosition);
+
+			RefreshCursor();
+		}
+	}
+
+	inline void AbstractTextAreaWidget::Write(const Nz::String& text)
+	{
+		Write(text, GetGlyphIndex(m_cursorPositionBegin));
+	}
+
+	inline void AbstractTextAreaWidget::Write(const Nz::String& text, const Nz::Vector2ui& glyphPosition)
+	{
+		Write(text, GetGlyphIndex(glyphPosition));
+	}
+
+	void AbstractTextAreaWidget::SetCursorPositionInternal(std::size_t glyphIndex)
+	{
+		return SetCursorPositionInternal(GetCursorPosition(glyphIndex));
+	}
+
+	inline void AbstractTextAreaWidget::SetCursorPositionInternal(Nz::Vector2ui cursorPosition)
+	{
+		m_cursorPositionBegin = cursorPosition;
+		m_cursorPositionEnd = m_cursorPositionBegin;
+
+		RefreshCursor();
+	}
+}

SDK/include/NazaraSDK/Widgets/BoxLayout.hpp

@@ -0,0 +1,48 @@
+// 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
+
+#pragma once
+
+#ifndef NDK_WIDGETS_BOXLAYOUT_HPP
+#define NDK_WIDGETS_BOXLAYOUT_HPP
+
+#include <NazaraSDK/Prerequisites.hpp>
+#include <NazaraSDK/BaseWidget.hpp>
+#include <NazaraSDK/Widgets/Enums.hpp>
+#include <vector>
+
+namespace Ndk
+{
+	class NDK_API BoxLayout : public BaseWidget
+	{
+		public:
+			inline BoxLayout(BaseWidget* parent, BoxLayoutOrientation orientation);
+			BoxLayout(const BoxLayout&) = delete;
+			BoxLayout(BoxLayout&&) = default;
+			~BoxLayout() = default;
+
+			void Layout() override;
+
+			BoxLayout& operator=(const BoxLayout&) = delete;
+			BoxLayout& operator=(BoxLayout&&) = default;
+
+		private:
+			struct ChildInfo
+			{
+				BaseWidget* widget;
+				bool isConstrained;
+				float maximumSize;
+				float minimumSize;
+				float size;
+			};
+
+			std::vector<ChildInfo> m_childInfos;
+			BoxLayoutOrientation m_orientation;
+			float m_spacing;
+	};
+}
+
+#include <NazaraSDK/Widgets/BoxLayout.inl>
+
+#endif // NDK_WIDGETS_BOXLAYOUT_HPP

SDK/include/NazaraSDK/Widgets/BoxLayout.inl

@@ -0,0 +1,15 @@
+// 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>
+
+namespace Ndk
+{
+	BoxLayout::BoxLayout(BaseWidget* parent, BoxLayoutOrientation orientation) :
+	BaseWidget(parent),
+	m_orientation(orientation),
+	m_spacing(5.f)
+	{
+	}
+}

SDK/include/NazaraSDK/Widgets/ButtonWidget.hpp

@@ -0,0 +1,99 @@
+// 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
+
+#pragma once
+
+#ifndef NDK_WIDGETS_BUTTONWIDGET_HPP
+#define NDK_WIDGETS_BUTTONWIDGET_HPP
+
+#include <NazaraSDK/Prerequisites.hpp>
+#include <NazaraSDK/BaseWidget.hpp>
+#include <Nazara/Core/Color.hpp>
+#include <Nazara/Graphics/Sprite.hpp>
+#include <Nazara/Graphics/TextSprite.hpp>
+
+namespace Nz
+{
+	class AbstractTextDrawer;
+}
+
+namespace Ndk
+{
+	class NDK_API ButtonWidget : public BaseWidget
+	{
+		public:
+			ButtonWidget(BaseWidget* parent);
+			ButtonWidget(const ButtonWidget&) = delete;
+			ButtonWidget(ButtonWidget&&) = default;
+			~ButtonWidget() = default;
+
+			inline const Nz::Color& GetColor() const;
+			inline const Nz::Color& GetCornerColor() const;
+			inline const Nz::Color& GetHoverColor() const;
+			inline const Nz::Color& GetHoverCornerColor() const;
+			inline const Nz::Color& GetPressColor() const;
+			inline const Nz::Color& GetPressCornerColor() const;
+
+			inline const Nz::TextureRef& GetTexture() const;
+			inline const Nz::TextureRef& GetHoverTexture() const;
+			inline const Nz::TextureRef& GetPressTexture() const;
+
+			inline void SetColor(const Nz::Color& color, const Nz::Color& cornerColor);
+			inline void SetHoverColor(const Nz::Color& color, const Nz::Color& cornerColor);
+			inline void SetPressColor(const Nz::Color& color, const Nz::Color& cornerColor);
+
+			inline void SetTexture(const Nz::TextureRef& texture);
+			inline void SetHoverTexture(const Nz::TextureRef& texture);
+			inline void SetPressTexture(const Nz::TextureRef& texture);
+
+			inline void UpdateText(const Nz::AbstractTextDrawer& drawer);
+
+			ButtonWidget& operator=(const ButtonWidget&) = delete;
+			ButtonWidget& operator=(ButtonWidget&&) = default;
+
+			static const Nz::Color& GetDefaultColor();
+			static const Nz::Color& GetDefaultCornerColor();
+			static const Nz::Color& GetDefaultHoverColor();
+			static const Nz::Color& GetDefaultHoverCornerColor();
+			static const Nz::Color& GetDefaultPressColor();
+			static const Nz::Color& GetDefaultPressCornerColor();
+
+			NazaraSignal(OnButtonTrigger, const ButtonWidget* /*button*/);
+
+		private:
+			void Layout() override;
+
+			void OnMouseEnter() override;
+			void OnMouseButtonPress(int x, int y, Nz::Mouse::Button button) override;
+			void OnMouseButtonRelease(int x, int y, Nz::Mouse::Button button) override;
+			void OnMouseExit() override;
+
+			EntityHandle m_textEntity;
+			EntityHandle m_gradientEntity;
+			Nz::SpriteRef m_gradientSprite;
+			Nz::TextSpriteRef m_textSprite;
+
+			Nz::Color m_color;
+			Nz::Color m_cornerColor;
+			Nz::Color m_hoverColor;
+			Nz::Color m_hoverCornerColor;
+			Nz::Color m_pressColor;
+			Nz::Color m_pressCornerColor;
+
+			Nz::TextureRef m_texture;
+			Nz::TextureRef m_hoverTexture;
+			Nz::TextureRef m_pressTexture;
+
+			static Nz::Color s_color;
+			static Nz::Color s_cornerColor;
+			static Nz::Color s_hoverColor;
+			static Nz::Color s_hoverCornerColor;
+			static Nz::Color s_pressColor;
+			static Nz::Color s_pressCornerColor;
+	};
+}
+
+#include <NazaraSDK/Widgets/ButtonWidget.inl>
+
+#endif // NDK_WIDGETS_BUTTONWIDGET_HPP

SDK/include/NazaraSDK/Widgets/ButtonWidget.inl

@@ -0,0 +1,102 @@
+// 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>
+
+namespace Ndk
+{
+	inline const Nz::Color& ButtonWidget::GetColor() const
+	{
+		return m_color;
+	}
+
+	inline const Nz::Color& ButtonWidget::GetCornerColor() const
+	{
+		return m_cornerColor;
+	}
+
+	inline const Nz::Color& ButtonWidget::GetHoverColor() const
+	{
+		return m_hoverColor;
+	}
+
+	inline const Nz::Color& ButtonWidget::GetHoverCornerColor() const
+	{
+		return m_hoverCornerColor;
+	}
+
+	inline const Nz::Color& ButtonWidget::GetPressColor() const
+	{
+		return m_pressColor;
+	}
+
+	inline const Nz::Color& ButtonWidget::GetPressCornerColor() const
+	{
+		return m_pressCornerColor;
+	}
+
+	inline const Nz::TextureRef& ButtonWidget::GetTexture() const
+	{
+		return m_texture;
+	}
+
+	inline const Nz::TextureRef& ButtonWidget::GetHoverTexture() const
+	{
+		return m_hoverTexture;
+	}
+
+	inline const Nz::TextureRef& ButtonWidget::GetPressTexture() const
+	{
+		return m_pressTexture;
+	}
+
+	inline void ButtonWidget::SetColor(const Nz::Color& color, const Nz::Color& cornerColor)
+	{
+		m_color = color;
+		m_cornerColor = cornerColor;
+
+		m_gradientSprite->SetColor(m_color);
+		m_gradientSprite->SetCornerColor(Nz::RectCorner_LeftBottom, m_cornerColor);
+		m_gradientSprite->SetCornerColor(Nz::RectCorner_RightBottom, m_cornerColor);
+	}
+
+	inline void ButtonWidget::SetHoverColor(const Nz::Color& color, const Nz::Color& cornerColor)
+	{
+		m_hoverColor = color;
+		m_hoverCornerColor = cornerColor;
+	}
+
+	inline void ButtonWidget::SetPressColor(const Nz::Color& color, const Nz::Color& cornerColor)
+	{
+		m_pressColor = color;
+		m_pressCornerColor = cornerColor;
+	}
+
+	inline void ButtonWidget::SetTexture(const Nz::TextureRef& texture)
+	{
+		m_texture = texture;
+		m_gradientSprite->SetTexture(m_texture);
+	}
+
+	inline void ButtonWidget::SetHoverTexture(const Nz::TextureRef& texture)
+	{
+		m_hoverTexture = texture;
+	}
+
+	inline void ButtonWidget::SetPressTexture(const Nz::TextureRef& texture)
+	{
+		m_pressTexture = texture;
+	}
+
+	inline void ButtonWidget::UpdateText(const Nz::AbstractTextDrawer& drawer)
+	{
+		m_textSprite->Update(drawer);
+
+		Nz::Vector2f textSize = Nz::Vector2f(m_textSprite->GetBoundingVolume().obb.localBox.GetLengths());
+		SetMinimumSize(textSize);
+		SetPreferredSize(textSize + Nz::Vector2f(20.f, 10.f));
+
+		Layout();
+	}
+}

SDK/include/NazaraSDK/Widgets/CheckboxWidget.hpp

@@ -0,0 +1,105 @@
+// 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
+
+#pragma once
+
+#ifndef NDK_WIDGETS_CHECKBOXWIDGET_HPP
+#define NDK_WIDGETS_CHECKBOXWIDGET_HPP
+
+#include <NazaraSDK/Prerequisites.hpp>
+#include <NazaraSDK/BaseWidget.hpp>
+#include <NazaraSDK/Components/NodeComponent.hpp>
+#include <NazaraSDK/Widgets/Enums.hpp>
+#include <Nazara/Renderer/Texture.hpp>
+#include <Nazara/Graphics/Sprite.hpp>
+#include <Nazara/Graphics/TextSprite.hpp>
+#include <Nazara/Math/Vector2.hpp>
+
+namespace Nz
+{
+	class AbstractTextDrawer;
+}
+
+namespace Ndk
+{
+	class NDK_API CheckboxWidget : public BaseWidget
+	{
+		friend class Sdk;
+
+		public:
+			CheckboxWidget(BaseWidget* parent);
+			CheckboxWidget(const CheckboxWidget&) = delete;
+			CheckboxWidget(CheckboxWidget&&) = default;
+			~CheckboxWidget() = default;
+
+			//virtual CheckboxWidget* Clone() const = 0;
+
+			inline void EnableAdaptativeMargin(bool enable = true);
+			inline void EnableCheckbox(bool enable = true);
+			inline void EnableTristate(bool enable = true);
+
+			inline bool IsCheckboxEnabled() const;
+			inline bool IsMarginAdaptative() const;
+			inline bool IsTristateEnabled() const;
+
+			inline const Nz::Vector2f& GetCheckboxSize() const;
+			inline Nz::Vector2f GetCheckboxBorderSize() const;
+			inline CheckboxState GetState() const;
+			inline float GetTextMargin() const;
+
+			inline void SetCheckboxSize(const Nz::Vector2f& size);
+			CheckboxState SwitchToNextState();
+			void SetState(CheckboxState state);
+			inline void SetTextMargin(float margin);
+
+			inline void UpdateText(const Nz::AbstractTextDrawer& drawer);
+
+
+			CheckboxWidget& operator=(const CheckboxWidget&) = delete;
+			CheckboxWidget& operator=(CheckboxWidget&&) = default;
+
+			NazaraSignal(OnStateChanged, const CheckboxWidget* /*checkbox*/);
+
+		private:
+			static bool Initialize();
+			static void Uninitialize();
+
+			void Layout() override;
+			void UpdateCheckbox();
+			void UpdateSize();
+
+			void OnMouseButtonRelease(int x, int y, Nz::Mouse::Button button) override;
+			inline bool ContainsCheckbox(int x, int y) const;
+
+
+			EntityHandle m_checkboxBorderEntity;
+			EntityHandle m_checkboxBackgroundEntity;
+			EntityHandle m_checkboxContentEntity;
+			EntityHandle m_textEntity;
+
+			Nz::TextureRef m_checkMark;
+
+			Nz::SpriteRef m_checkboxContentSprite;
+			Nz::SpriteRef m_checkboxBorderSprite;
+			Nz::SpriteRef m_checkboxBackgroundSprite;
+			Nz::TextSpriteRef m_textSprite;
+
+			static Nz::Color s_backgroundColor;
+			static Nz::Color s_disabledBackgroundColor;
+			static Nz::Color s_disabledBorderColor;
+			static Nz::Color s_borderColor;
+
+			bool m_adaptativeMargin;
+			bool m_checkboxEnabled;
+			bool m_tristateEnabled;
+
+			static float s_borderScale;
+			float m_textMargin;
+			CheckboxState m_state;
+	};
+}
+
+#include <NazaraSDK/Widgets/CheckboxWidget.inl>
+
+#endif // NDK_WIDGETS_CHECKBOXWIDGET_HPP

SDK/include/NazaraSDK/Widgets/CheckboxWidget.inl

@@ -0,0 +1,94 @@
+// 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
+
+namespace Ndk
+{
+	inline void CheckboxWidget::EnableAdaptativeMargin(bool enable)
+	{
+		m_adaptativeMargin = enable;
+		Layout();
+	}
+
+	inline void CheckboxWidget::EnableCheckbox(bool enable)
+	{
+		m_checkboxEnabled = enable;
+		UpdateCheckbox();
+	}
+
+	inline void CheckboxWidget::EnableTristate(bool enable)
+	{
+		m_tristateEnabled = enable;
+
+		if (m_tristateEnabled && GetState() == CheckboxState_Tristate)
+			SetState(CheckboxState_Unchecked);
+	}
+
+	inline bool CheckboxWidget::IsCheckboxEnabled() const
+	{
+		return m_checkboxEnabled;
+	}
+
+	inline bool CheckboxWidget::IsMarginAdaptative() const
+	{
+		return m_adaptativeMargin;
+	}
+
+	inline bool CheckboxWidget::IsTristateEnabled() const
+	{
+		return m_tristateEnabled;
+	}
+
+	inline const Nz::Vector2f& CheckboxWidget::GetCheckboxSize() const
+	{
+		return m_checkboxBorderSprite->GetSize();
+	}
+
+	inline Nz::Vector2f CheckboxWidget::GetCheckboxBorderSize() const
+	{
+		return GetCheckboxSize() / s_borderScale;
+	}
+
+	inline CheckboxState CheckboxWidget::GetState() const
+	{
+		return m_state;
+	}
+
+	inline float CheckboxWidget::GetTextMargin() const
+	{
+		return m_textMargin;
+	}
+
+	inline void CheckboxWidget::SetCheckboxSize(const Nz::Vector2f& size)
+	{
+		m_checkboxBorderSprite->SetSize(size);
+		m_checkboxBackgroundSprite->SetSize(size - GetCheckboxBorderSize() * 2.f);
+		m_checkboxContentSprite->SetSize(GetCheckboxSize() - GetCheckboxBorderSize() * 2.f - Nz::Vector2f { 4.f, 4.f });
+
+		UpdateSize();
+		Layout();
+	}
+
+	inline void CheckboxWidget::SetTextMargin(float margin)
+	{
+		m_textMargin = margin;
+		Layout();
+	}
+
+	inline void CheckboxWidget::UpdateText(const Nz::AbstractTextDrawer& drawer)
+	{
+		m_textSprite->Update(drawer);
+
+		UpdateSize();
+		Layout();
+	}
+
+	inline bool CheckboxWidget::ContainsCheckbox(int x, int y) const
+	{
+		Nz::Vector2f checkboxSize = GetCheckboxSize();
+		Nz::Vector3f pos = m_checkboxBorderEntity->GetComponent<NodeComponent>().GetPosition(Nz::CoordSys_Local);
+
+		return x > pos.x && x < pos.x + checkboxSize.x &&
+		       y > pos.y && y < pos.y + checkboxSize.y;
+	}
+}

SDK/include/NazaraSDK/Widgets/Enums.hpp

@@ -0,0 +1,37 @@
+// 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
+
+#pragma once
+
+#ifndef NAZARA_ENUMS_SDK_HPP
+#define NAZARA_ENUMS_SDK_HPP
+
+namespace Ndk
+{
+	enum BoxLayoutOrientation
+	{
+		BoxLayoutOrientation_Horizontal,
+		BoxLayoutOrientation_Vertical
+	};
+
+	enum CheckboxState
+	{
+		CheckboxState_Checked,
+		CheckboxState_Tristate,
+		CheckboxState_Unchecked,
+
+		CheckboxState_Max = CheckboxState_Unchecked
+	};
+
+	enum EchoMode
+	{
+		EchoMode_Normal,
+		EchoMode_Password,
+		EchoMode_PasswordExceptLast,
+
+		EchoMode_Max = EchoMode_PasswordExceptLast
+	};
+}
+
+#endif // NAZARA_ENUMS_SDK_HPP

SDK/include/NazaraSDK/Widgets/ImageWidget.hpp

@@ -0,0 +1,51 @@
+// 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
+
+#pragma once
+
+#ifndef NDK_WIDGETS_IMAGEWIDGET_HPP
+#define NDK_WIDGETS_IMAGEWIDGET_HPP
+
+#include <NazaraSDK/Prerequisites.hpp>
+#include <NazaraSDK/BaseWidget.hpp>
+#include <NazaraSDK/Entity.hpp>
+#include <Nazara/Graphics/Sprite.hpp>
+#include <Nazara/Renderer/Texture.hpp>
+#include <Nazara/Math/Vector2.hpp>
+
+namespace Ndk
+{
+	class NDK_API ImageWidget : public BaseWidget
+	{
+		public:
+			ImageWidget(BaseWidget* parent);
+			ImageWidget(const ImageWidget&) = delete;
+			ImageWidget(ImageWidget&&) = default;
+			~ImageWidget() = default;
+
+			//virtual ImageWidget* Clone() const = 0;
+
+			inline const Nz::Color& GetColor() const;
+			inline const Nz::TextureRef& GetTexture() const;
+			inline const Nz::Rectf& GetTextureCoords() const;
+
+			inline void SetColor(const Nz::Color& color);
+			inline void SetTexture(const Nz::TextureRef& texture);
+			inline void SetTextureCoords(const Nz::Rectf& coords);
+			inline void SetTextureRect(const Nz::Rectui& rect);
+
+			ImageWidget& operator=(const ImageWidget&) = delete;
+			ImageWidget& operator=(ImageWidget&&) = default;
+
+		private:
+			void Layout() override;
+
+			Ndk::EntityHandle m_entity;
+			Nz::SpriteRef m_sprite;
+	};
+}
+
+#include <NazaraSDK/Widgets/ImageWidget.inl>
+
+#endif // NDK_WIDGETS_IMAGEWIDGET_HPP

SDK/include/NazaraSDK/Widgets/ImageWidget.inl

@@ -0,0 +1,47 @@
+// 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>
+
+namespace Ndk
+{
+	inline const Nz::Color& ImageWidget::GetColor() const
+	{
+		return m_sprite->GetColor();
+	}
+
+	inline const Nz::TextureRef& ImageWidget::GetTexture() const
+	{
+		return m_sprite->GetMaterial()->GetDiffuseMap();
+	}
+
+	inline const Nz::Rectf& ImageWidget::GetTextureCoords() const
+	{
+		return m_sprite->GetTextureCoords();
+	}
+
+	inline void ImageWidget::SetColor(const Nz::Color& color)
+	{
+		m_sprite->SetColor(color);
+	}
+
+	inline void ImageWidget::SetTexture(const Nz::TextureRef& texture)
+	{
+		m_sprite->SetTexture(texture, false);
+
+		Nz::Vector2f textureSize = Nz::Vector2f(Nz::Vector2ui(m_sprite->GetMaterial()->GetDiffuseMap()->GetSize()));
+		SetMinimumSize(textureSize);
+		SetPreferredSize(textureSize);
+	}
+
+	inline void ImageWidget::SetTextureCoords(const Nz::Rectf& coords)
+	{
+		m_sprite->SetTextureCoords(coords);
+	}
+
+	inline void ImageWidget::SetTextureRect(const Nz::Rectui& rect)
+	{
+		m_sprite->SetTextureRect(rect);
+	}
+}

SDK/include/NazaraSDK/Widgets/LabelWidget.hpp

@@ -0,0 +1,42 @@
+// 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
+
+#pragma once
+
+#ifndef NDK_WIDGETS_LABELWIDGET_HPP
+#define NDK_WIDGETS_LABELWIDGET_HPP
+
+#include <NazaraSDK/Prerequisites.hpp>
+#include <NazaraSDK/BaseWidget.hpp>
+#include <Nazara/Graphics/TextSprite.hpp>
+
+namespace Nz
+{
+	class AbstractTextDrawer;
+}
+
+namespace Ndk
+{
+	class NDK_API LabelWidget : public BaseWidget
+	{
+		public:
+			LabelWidget(BaseWidget* parent);
+			LabelWidget(const LabelWidget&) = delete;
+			LabelWidget(LabelWidget&&) = default;
+			~LabelWidget() = default;
+
+			inline void UpdateText(const Nz::AbstractTextDrawer& drawer);
+
+			LabelWidget& operator=(const LabelWidget&) = delete;
+			LabelWidget& operator=(LabelWidget&&) = default;
+
+		private:
+			EntityHandle m_textEntity;
+			Nz::TextSpriteRef m_textSprite;
+	};
+}
+
+#include <NazaraSDK/Widgets/LabelWidget.inl>
+
+#endif // NDK_WIDGETS_LABELWIDGET_HPP

SDK/include/NazaraSDK/Widgets/LabelWidget.inl

@@ -0,0 +1,17 @@
+// 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>
+
+namespace Ndk
+{
+	inline void LabelWidget::UpdateText(const Nz::AbstractTextDrawer& drawer)
+	{
+		m_textSprite->Update(drawer);
+
+		Nz::Vector2f size = Nz::Vector2f(m_textSprite->GetBoundingVolume().obb.localBox.GetLengths());
+		SetMinimumSize(size);
+		SetPreferredSize(size);
+	}
+}

SDK/include/NazaraSDK/Widgets/ProgressBarWidget.hpp

@@ -0,0 +1,101 @@
+// 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
+
+#pragma once
+
+#ifndef NDK_WIDGETS_PROGRESSBARWIDGET_HPP
+#define NDK_WIDGETS_PROGRESSBARWIDGET_HPP
+
+#include <NazaraSDK/Prerequisites.hpp>
+#include <NazaraSDK/BaseWidget.hpp>
+#include <Nazara/Core/Color.hpp>
+#include <Nazara/Graphics/Sprite.hpp>
+#include <Nazara/Graphics/TextSprite.hpp>
+#include <Nazara/Math/Vector2.hpp>
+#include <Nazara/Renderer/Texture.hpp>
+#include <Nazara/Utility/SimpleTextDrawer.hpp>
+
+namespace Ndk
+{
+	class NDK_API ProgressBarWidget : public BaseWidget
+	{
+		friend class Sdk;
+
+		public:
+			ProgressBarWidget(BaseWidget* parent);
+			ProgressBarWidget(const ProgressBarWidget&) = delete;
+			ProgressBarWidget(ProgressBarWidget&&) = default;
+			~ProgressBarWidget() = default;
+
+			//virtual ProgressBarWidget* Clone() const = 0;
+
+			inline void EnableText(bool enable = true);
+			inline void EnableBorder(bool enable = true);
+
+			inline bool IsTextEnabled() const;
+			inline bool IsBorderEnabled() const;
+
+
+			inline unsigned GetPercentageValue() const;
+			inline Nz::Vector2f GetProgressBarSize() const;
+			inline Nz::Vector2f GetProgressBarBorderSize() const;
+			inline float GetTextMargin() const;
+
+
+			inline const Nz::Color& GetBarBackgroundColor() const;
+			inline const Nz::Color& GetBarBackgroundCornerColor() const;
+			inline const Nz::Color& GetBarColor() const;
+			inline const Nz::Color& GetBarCornerColor() const;
+
+			inline const Nz::TextureRef& GetBarBackgroundTexture() const;
+			inline const Nz::TextureRef& GetBarTexture() const;
+
+			static const Nz::Color& GetDefaultBarColor();
+			static const Nz::Color& GetDefaultBarCornerColor();
+			static const Nz::Color& GetDefaultBarBackgroundColor();
+			static const Nz::Color& GetDefaultBarBackgroundCornerColor();
+
+
+			inline void SetBarBackgroundColor(const Nz::Color& globalColor, const Nz::Color& cornerColor);
+			inline void SetBarBackgroundTexture(Nz::TextureRef texture, bool resetColors = true);
+			inline void SetBarColor(const Nz::Color& globalColor, const Nz::Color& cornerColor);
+			inline void SetBarTexture(Nz::TextureRef texture, bool resetColors = true);
+
+
+			inline void SetPercentageValue(unsigned percentage);
+			inline void SetTextMargin(float margin);
+			inline void SetTextColor(const Nz::Color& color);
+
+			NazaraSignal(OnValueChanged, const ProgressBarWidget* /*progressBar*/);
+
+		private:
+			void Layout() override;
+			inline void UpdateText();
+
+
+			EntityHandle m_borderEntity;
+			EntityHandle m_barEntity;
+			EntityHandle m_textEntity;
+
+			static Nz::Color s_borderColor;
+			static Nz::Color s_barBackgroundColor;
+			static Nz::Color s_barBackgroundCornerColor;
+			static Nz::Color s_barColor;
+			static Nz::Color s_barCornerColor;
+			Nz::Color m_textColor;
+
+			Nz::SpriteRef m_borderSprite;
+			Nz::SpriteRef m_barBackgroundSprite;
+			Nz::SpriteRef m_barSprite;
+			Nz::TextSpriteRef m_textSprite;
+
+			static float s_borderScale;
+			float m_textMargin;
+			unsigned m_value;
+	};
+}
+
+#include <NazaraSDK/Widgets/ProgressBarWidget.inl>
+
+#endif // NDK_WIDGETS_PROGRESSBARWIDGET_HPP

SDK/include/NazaraSDK/Widgets/ProgressBarWidget.inl

@@ -0,0 +1,155 @@
+// 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
+
+namespace Ndk
+{
+	inline void ProgressBarWidget::EnableText(bool enable)
+	{
+		m_textEntity->Enable(enable);
+		Layout();
+	}
+
+	inline void ProgressBarWidget::EnableBorder(bool enable)
+	{
+		m_borderEntity->Enable(enable);
+	}
+
+	inline bool ProgressBarWidget::IsTextEnabled() const
+	{
+		return m_textEntity->IsEnabled();
+	}
+
+	inline bool ProgressBarWidget::IsBorderEnabled() const
+	{
+		return m_borderEntity->IsEnabled();
+	}
+
+
+	inline unsigned ProgressBarWidget::GetPercentageValue() const
+	{
+		return m_value;
+	}
+
+	inline Nz::Vector2f ProgressBarWidget::GetProgressBarSize() const
+	{
+		Nz::Vector3f progressBarSize = m_borderSprite->GetBoundingVolume().obb.localBox.GetLengths();
+
+		if (IsTextEnabled())
+		{
+			Nz::Vector3f textSize = m_textSprite->GetBoundingVolume().obb.localBox.GetLengths();
+			progressBarSize -= { textSize.x + m_textMargin, 0.f, 0.f };
+		}
+
+		return { progressBarSize.x, progressBarSize.y };
+	}
+
+	inline Nz::Vector2f ProgressBarWidget::GetProgressBarBorderSize() const
+	{
+		Nz::Vector2f barSize = GetProgressBarSize();
+		return { barSize.y / s_borderScale, barSize.y / s_borderScale };
+	}
+
+	inline float ProgressBarWidget::GetTextMargin() const
+	{
+		return m_textMargin;
+	}
+
+
+	inline const Nz::Color& ProgressBarWidget::GetBarBackgroundColor() const
+	{
+		return m_barBackgroundSprite->GetColor();
+	}
+
+	inline const Nz::Color& ProgressBarWidget::GetBarBackgroundCornerColor() const
+	{
+		return m_barBackgroundSprite->GetCornerColor(Nz::RectCorner_LeftTop);
+	}
+
+	inline const Nz::Color& ProgressBarWidget::GetBarColor() const
+	{
+		return m_barSprite->GetColor();
+	}
+
+	inline const Nz::Color& ProgressBarWidget::GetBarCornerColor() const
+	{
+		return m_barSprite->GetCornerColor(Nz::RectCorner_LeftTop);
+	}
+
+
+	inline const Nz::TextureRef& ProgressBarWidget::GetBarBackgroundTexture() const
+	{
+		return m_barBackgroundSprite->GetMaterial()->GetDiffuseMap();
+	}
+
+	inline const Nz::TextureRef& ProgressBarWidget::GetBarTexture() const
+	{
+		return m_barSprite->GetMaterial()->GetDiffuseMap();
+	}
+
+
+	inline void ProgressBarWidget::SetBarBackgroundColor(const Nz::Color& globalColor, const Nz::Color& cornerColor)
+	{
+		m_barBackgroundSprite->SetColor(globalColor);
+		m_barBackgroundSprite->SetCornerColor(Nz::RectCorner_LeftTop, cornerColor);
+		m_barBackgroundSprite->SetCornerColor(Nz::RectCorner_RightTop, cornerColor);
+		m_barBackgroundSprite->SetCornerColor(Nz::RectCorner_LeftBottom, globalColor);
+		m_barBackgroundSprite->SetCornerColor(Nz::RectCorner_RightBottom, globalColor);
+	}
+
+	inline void ProgressBarWidget::SetBarBackgroundTexture(Nz::TextureRef texture, bool resetColors)
+	{
+		m_barBackgroundSprite->SetTexture(texture, false);
+
+		if (resetColors)
+			SetBarBackgroundColor(Nz::Color::White, Nz::Color::White);
+	}
+
+	inline void ProgressBarWidget::SetBarColor(const Nz::Color& globalColor, const Nz::Color& cornerColor)
+	{
+		m_barSprite->SetColor(globalColor);
+		m_barSprite->SetCornerColor(Nz::RectCorner_LeftTop, cornerColor);
+		m_barSprite->SetCornerColor(Nz::RectCorner_RightTop, cornerColor);
+		m_barSprite->SetCornerColor(Nz::RectCorner_LeftBottom, globalColor);
+		m_barSprite->SetCornerColor(Nz::RectCorner_RightBottom, globalColor);
+	}
+
+	inline void ProgressBarWidget::SetBarTexture(Nz::TextureRef texture, bool resetColors)
+	{
+		m_barSprite->SetTexture(texture, false);
+
+		if (resetColors)
+			SetBarColor(Nz::Color::White, Nz::Color::White);
+	}
+
+
+	inline void ProgressBarWidget::SetPercentageValue(unsigned percentage)
+	{
+		m_value = percentage;
+		OnValueChanged(this);
+		Layout();
+	}
+
+	inline void ProgressBarWidget::SetTextMargin(float margin)
+	{
+		m_textMargin = margin;
+		
+		if (IsTextEnabled())
+			Layout();
+	}
+
+	inline void ProgressBarWidget::SetTextColor(const Nz::Color& color)
+	{
+		m_textColor = color;
+		UpdateText();
+	}
+
+	inline void ProgressBarWidget::UpdateText()
+	{
+		if (IsTextEnabled())
+		{
+			Nz::Vector2f size = GetSize();
+			m_textSprite->Update(Nz::SimpleTextDrawer::Draw(Nz::String::Number(m_value).Append('%'), static_cast<unsigned int>(std::min(size.x, size.y) / 2.f), 0u, m_textColor));
+		}
+	}
+}

SDK/include/NazaraSDK/Widgets/RichTextAreaWidget.hpp

@@ -0,0 +1,68 @@
+// 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
+
+#pragma once
+
+#ifndef NDK_WIDGETS_RICHTEXTAREAWIDGET_HPP
+#define NDK_WIDGETS_RICHTEXTAREAWIDGET_HPP
+
+#include <Nazara/Utility/RichTextDrawer.hpp>
+#include <NazaraSDK/Widgets/AbstractTextAreaWidget.hpp>
+
+namespace Ndk
+{
+	class NDK_API RichTextAreaWidget : public AbstractTextAreaWidget
+	{
+		public:
+			RichTextAreaWidget(BaseWidget* parent);
+			RichTextAreaWidget(const RichTextAreaWidget&) = delete;
+			RichTextAreaWidget(RichTextAreaWidget&&) = default;
+			~RichTextAreaWidget() = default;
+
+			void AppendText(const Nz::String& text);
+
+			void Clear() override;
+
+			void Erase(std::size_t firstGlyph, std::size_t lastGlyph) override;
+
+			inline unsigned int GetCharacterSize() const;
+			inline float GetCharacterSpacingOffset() const;
+			inline float GetLineSpacingOffset() const;
+			inline const Nz::Color& GetTextColor() const;
+			inline Nz::Font* GetTextFont() const;
+			inline const Nz::Color& GetTextOutlineColor() const;
+			inline float GetTextOutlineThickness() const;
+			inline Nz::TextStyleFlags GetTextStyle() const;
+
+			inline void SetCharacterSize(unsigned int characterSize);
+			inline void SetCharacterSpacingOffset(float offset);
+			inline void SetLineSpacingOffset(float offset);
+			inline void SetTextColor(const Nz::Color& color);
+			inline void SetTextFont(Nz::FontRef font);
+			inline void SetTextOutlineColor(const Nz::Color& color);
+			inline void SetTextOutlineThickness(float thickness);
+			inline void SetTextStyle(Nz::TextStyleFlags style);
+
+			void Write(const Nz::String& text, std::size_t glyphPosition) override;
+
+			RichTextAreaWidget& operator=(const RichTextAreaWidget&) = delete;
+			RichTextAreaWidget& operator=(RichTextAreaWidget&&) = default;
+
+		private:
+			Nz::AbstractTextDrawer& GetTextDrawer() override;
+			const Nz::AbstractTextDrawer& GetTextDrawer() const override;
+
+			void HandleIndentation(bool add) override;
+			void HandleSelectionIndentation(bool add) override;
+			void HandleWordCursorMove(bool left) override;
+
+			void UpdateDisplayText() override;
+
+			Nz::RichTextDrawer m_drawer;
+	};
+}
+
+#include <NazaraSDK/Widgets/RichTextAreaWidget.inl>
+
+#endif // NDK_WIDGETS_TEXTAREAWIDGET_HPP

SDK/include/NazaraSDK/Widgets/RichTextAreaWidget.inl

@@ -0,0 +1,88 @@
+// 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
+{
+	inline unsigned int RichTextAreaWidget::GetCharacterSize() const
+	{
+		return m_drawer.GetDefaultCharacterSize();
+	}
+
+	inline float RichTextAreaWidget::GetCharacterSpacingOffset() const
+	{
+		return m_drawer.GetDefaultCharacterSpacingOffset();
+	}
+
+	inline float RichTextAreaWidget::GetLineSpacingOffset() const
+	{
+		return m_drawer.GetDefaultLineSpacingOffset();
+	}
+
+	inline const Nz::Color& RichTextAreaWidget::GetTextColor() const
+	{
+		return m_drawer.GetDefaultColor();
+	}
+
+	inline Nz::Font* RichTextAreaWidget::GetTextFont() const
+	{
+		return m_drawer.GetDefaultFont();
+	}
+
+	inline const Nz::Color& RichTextAreaWidget::GetTextOutlineColor() const
+	{
+		return m_drawer.GetDefaultOutlineColor();
+	}
+
+	inline float RichTextAreaWidget::GetTextOutlineThickness() const
+	{
+		return m_drawer.GetDefaultOutlineThickness();
+	}
+
+	inline Nz::TextStyleFlags RichTextAreaWidget::GetTextStyle() const
+	{
+		return m_drawer.GetDefaultStyle();
+	}
+
+	inline void RichTextAreaWidget::SetCharacterSize(unsigned int characterSize)
+	{
+		m_drawer.SetDefaultCharacterSize(characterSize);
+	}
+
+	inline void RichTextAreaWidget::SetCharacterSpacingOffset(float offset)
+	{
+		m_drawer.SetDefaultCharacterSpacingOffset(offset);
+	}
+
+	inline void RichTextAreaWidget::SetLineSpacingOffset(float offset)
+	{
+		m_drawer.SetDefaultLineSpacingOffset(offset);
+	}
+
+	inline void RichTextAreaWidget::SetTextColor(const Nz::Color& color)
+	{
+		m_drawer.SetDefaultColor(color);
+	}
+
+	inline void RichTextAreaWidget::SetTextFont(Nz::FontRef font)
+	{
+		m_drawer.SetDefaultFont(std::move(font));
+	}
+
+	inline void RichTextAreaWidget::SetTextOutlineColor(const Nz::Color& color)
+	{
+		m_drawer.SetDefaultOutlineColor(color);
+	}
+
+	inline void RichTextAreaWidget::SetTextOutlineThickness(float thickness)
+	{
+		m_drawer.SetDefaultOutlineThickness(thickness);
+	}
+
+	inline void RichTextAreaWidget::SetTextStyle(Nz::TextStyleFlags style)
+	{
+		m_drawer.SetDefaultStyle(style);
+	}
+}

SDK/include/NazaraSDK/Widgets/ScrollAreaWidget.hpp

@@ -0,0 +1,74 @@
+// 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
+
+#pragma once
+
+#ifndef NDK_WIDGETS_SCROLLAREAWIDGET_HPP
+#define NDK_WIDGETS_SCROLLAREAWIDGET_HPP
+
+#include <NazaraSDK/Prerequisites.hpp>
+#include <NazaraSDK/BaseWidget.hpp>
+#include <Nazara/Graphics/TextSprite.hpp>
+
+namespace Ndk
+{
+	class NDK_API ScrollAreaWidget : public BaseWidget
+	{
+		public:
+			ScrollAreaWidget(BaseWidget* parent, BaseWidget* content);
+			ScrollAreaWidget(const ScrollAreaWidget&) = delete;
+			ScrollAreaWidget(ScrollAreaWidget&&) = default;
+			~ScrollAreaWidget() = default;
+
+			void EnableScrollbar(bool enable);
+
+			inline float GetScrollHeight() const;
+			inline float GetScrollRatio() const;
+
+			inline bool HasScrollbar() const;
+			inline bool IsScrollbarEnabled() const;
+			inline bool IsScrollbarVisible() const;
+
+			inline void ScrollToHeight(float height);
+			void ScrollToRatio(float ratio);
+
+			ScrollAreaWidget& operator=(const ScrollAreaWidget&) = delete;
+			ScrollAreaWidget& operator=(ScrollAreaWidget&&) = default;
+
+		private:
+			enum class ScrollBarStatus
+			{
+				Grabbed,
+				Hovered,
+				None
+			};
+
+			Nz::Rectf GetScrollbarRect() const;
+
+			void Layout() override;
+
+			void OnMouseButtonPress(int x, int y, Nz::Mouse::Button button) override;
+			void OnMouseButtonRelease(int x, int y, Nz::Mouse::Button button) override;
+			void OnMouseExit() override;
+			void OnMouseMoved(int x, int y, int deltaX, int deltaY) override;
+			void OnMouseWheelMoved(int x, int y, float delta) override;
+
+			void UpdateScrollbarStatus(ScrollBarStatus status);
+
+			BaseWidget* m_content;
+			EntityHandle m_scrollbarBackgroundEntity;
+			EntityHandle m_scrollbarEntity;
+			Nz::SpriteRef m_scrollbarBackgroundSprite;
+			Nz::SpriteRef m_scrollbarSprite;
+			Nz::Vector2i m_grabbedDelta;
+			ScrollBarStatus m_scrollbarStatus;
+			bool m_isScrollbarEnabled;
+			bool m_hasScrollbar;
+			float m_scrollRatio;
+	};
+}
+
+#include <NazaraSDK/Widgets/ScrollAreaWidget.inl>
+
+#endif // NDK_WIDGETS_SCROLLAREAWIDGET_HPP

SDK/include/NazaraSDK/Widgets/ScrollAreaWidget.inl

@@ -0,0 +1,39 @@
+// 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>
+
+namespace Ndk
+{
+	inline float ScrollAreaWidget::GetScrollHeight() const
+	{
+		return m_scrollRatio * m_content->GetHeight();
+	}
+
+	inline float ScrollAreaWidget::GetScrollRatio() const
+	{
+		return m_scrollRatio;
+	}
+
+	inline bool ScrollAreaWidget::HasScrollbar() const
+	{
+		return m_hasScrollbar;
+	}
+
+	inline bool ScrollAreaWidget::IsScrollbarEnabled() const
+	{
+		return m_isScrollbarEnabled;
+	}
+
+	inline bool ScrollAreaWidget::IsScrollbarVisible() const
+	{
+		return HasScrollbar() && IsScrollbarEnabled();
+	}
+
+	inline void ScrollAreaWidget::ScrollToHeight(float height)
+	{
+		float contentHeight = m_content->GetHeight();
+		ScrollToRatio(height / contentHeight);
+	}
+}

SDK/include/NazaraSDK/Widgets/TextAreaWidget.hpp

@@ -0,0 +1,77 @@
+// 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
+
+#pragma once
+
+#ifndef NDK_WIDGETS_TEXTAREAWIDGET_HPP
+#define NDK_WIDGETS_TEXTAREAWIDGET_HPP
+
+#include <Nazara/Utility/SimpleTextDrawer.hpp>
+#include <NazaraSDK/Widgets/AbstractTextAreaWidget.hpp>
+
+namespace Ndk
+{
+	class NDK_API TextAreaWidget : public AbstractTextAreaWidget
+	{
+		public:
+			TextAreaWidget(BaseWidget* parent);
+			TextAreaWidget(const TextAreaWidget&) = delete;
+			TextAreaWidget(TextAreaWidget&&) = default;
+			~TextAreaWidget() = default;
+
+			void AppendText(const Nz::String& text);
+
+			void Clear() override;
+
+			using AbstractTextAreaWidget::Erase;
+			void Erase(std::size_t firstGlyph, std::size_t lastGlyph) override;
+
+			inline unsigned int GetCharacterSize() const;
+			inline const Nz::String& GetDisplayText() const;
+			inline float GetCharacterSpacingOffset() const;
+			inline float GetLineSpacingOffset() const;
+			inline const Nz::String& GetText() const;
+			inline const Nz::Color& GetTextColor() const;
+			inline Nz::Font* GetTextFont() const;
+			inline const Nz::Color& GetTextOulineColor() const;
+			inline float GetTextOulineThickness() const;
+			inline Nz::TextStyleFlags GetTextStyle() const;
+
+			inline void SetCharacterSize(unsigned int characterSize);
+			inline void SetCharacterSpacingOffset(float offset);
+			inline void SetLineSpacingOffset(float offset);
+			inline void SetText(const Nz::String& text);
+			inline void SetTextColor(const Nz::Color& text);
+			inline void SetTextFont(Nz::FontRef font);
+			inline void SetTextOutlineColor(const Nz::Color& color);
+			inline void SetTextOutlineThickness(float thickness);
+			inline void SetTextStyle(Nz::TextStyleFlags style);
+
+			using AbstractTextAreaWidget::Write;
+			void Write(const Nz::String& text, std::size_t glyphPosition) override;
+
+			TextAreaWidget& operator=(const TextAreaWidget&) = delete;
+			TextAreaWidget& operator=(TextAreaWidget&&) = default;
+
+			NazaraSignal(OnTextChanged, const AbstractTextAreaWidget* /*textArea*/, const Nz::String& /*text*/);
+
+		private:
+			Nz::AbstractTextDrawer& GetTextDrawer() override;
+			const Nz::AbstractTextDrawer& GetTextDrawer() const override;
+
+			void HandleIndentation(bool add) override;
+			void HandleSelectionIndentation(bool add) override;
+			void HandleWordCursorMove(bool left) override;
+
+			void UpdateDisplayText() override;
+			void UpdateMinimumSize();
+
+			Nz::SimpleTextDrawer m_drawer;
+			Nz::String m_text;
+	};
+}
+
+#include <NazaraSDK/Widgets/TextAreaWidget.inl>
+
+#endif // NDK_WIDGETS_TEXTAREAWIDGET_HPP

SDK/include/NazaraSDK/Widgets/TextAreaWidget.inl

@@ -0,0 +1,124 @@
+// 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>
+
+namespace Ndk
+{
+	inline unsigned int TextAreaWidget::GetCharacterSize() const
+	{
+		return m_drawer.GetCharacterSize();
+	}
+
+	inline const Nz::String& TextAreaWidget::GetDisplayText() const
+	{
+		return m_drawer.GetText();
+	}
+
+	inline float TextAreaWidget::GetCharacterSpacingOffset() const
+	{
+		return m_drawer.GetCharacterSpacingOffset();
+	}
+
+	inline float TextAreaWidget::GetLineSpacingOffset() const
+	{
+		return m_drawer.GetLineSpacingOffset();
+	}
+
+	inline const Nz::String& TextAreaWidget::GetText() const
+	{
+		return m_text;
+	}
+
+	inline const Nz::Color& TextAreaWidget::GetTextColor() const
+	{
+		return m_drawer.GetColor();
+	}
+
+	inline Nz::Font* TextAreaWidget::GetTextFont() const
+	{
+		return m_drawer.GetFont();
+	}
+
+	inline const Nz::Color& TextAreaWidget::GetTextOulineColor() const
+	{
+		return m_drawer.GetOutlineColor();
+	}
+
+	inline float TextAreaWidget::GetTextOulineThickness() const
+	{
+		return m_drawer.GetOutlineThickness();
+	}
+
+	inline Nz::TextStyleFlags TextAreaWidget::GetTextStyle() const
+	{
+		return m_drawer.GetStyle();
+	}
+
+	inline void TextAreaWidget::SetCharacterSize(unsigned int characterSize)
+	{
+		m_drawer.SetCharacterSize(characterSize);
+
+		UpdateMinimumSize();
+		UpdateDisplayText();
+	}
+
+	inline void TextAreaWidget::SetCharacterSpacingOffset(float offset)
+	{
+		m_drawer.SetCharacterSpacingOffset(offset);
+
+		UpdateMinimumSize();
+		UpdateDisplayText();
+	}
+
+	inline void TextAreaWidget::SetLineSpacingOffset(float offset)
+	{
+		m_drawer.SetLineSpacingOffset(offset);
+
+		UpdateDisplayText();
+	}
+
+	inline void TextAreaWidget::SetText(const Nz::String& text)
+	{
+		m_text = text;
+		OnTextChanged(this, m_text);
+
+		UpdateDisplayText();
+	}
+
+	inline void TextAreaWidget::SetTextColor(const Nz::Color& text)
+	{
+		m_drawer.SetColor(text);
+
+		UpdateDisplayText();
+	}
+
+	inline void TextAreaWidget::SetTextFont(Nz::FontRef font)
+	{
+		m_drawer.SetFont(font);
+
+		UpdateDisplayText();
+	}
+
+	inline void TextAreaWidget::SetTextOutlineColor(const Nz::Color& color)
+	{
+		m_drawer.SetOutlineColor(color);
+
+		UpdateDisplayText();
+	}
+
+	inline void TextAreaWidget::SetTextOutlineThickness(float thickness)
+	{
+		m_drawer.SetOutlineThickness(thickness);
+
+		UpdateDisplayText();
+	}
+
+	inline void TextAreaWidget::SetTextStyle(Nz::TextStyleFlags style)
+	{
+		m_drawer.SetStyle(style);
+
+		UpdateDisplayText();
+	}
+}