Widgets: Add [Rich]TextAreaWidget

include/Nazara/Core/StringExt.hpp

@@ -18,10 +18,13 @@ namespace Nz
 	struct UnicodeAware {};
 
 	// std::string is assumed to contains UTF-8
+	NAZARA_CORE_API std::size_t ComputeCharacterCount(const std::string_view& str);
+
 	NAZARA_CORE_API std::string FromUtf16String(const std::u16string_view& u16str);
 	NAZARA_CORE_API std::string FromUtf32String(const std::u32string_view& u32str);
 	NAZARA_CORE_API std::string FromWideString(const std::wstring_view& str);
 
+	NAZARA_CORE_API std::size_t GetCharacterPosition(const std::string_view& str, std::size_t characterIndex);
 	NAZARA_CORE_API std::string_view GetWord(const std::string_view& str, std::size_t wordIndex);
 	NAZARA_CORE_API std::string_view GetWord(const std::string_view& str, std::size_t wordIndex, UnicodeAware);
 

include/Nazara/Widgets.hpp

@@ -29,12 +29,16 @@
 #ifndef NAZARA_GLOBAL_WIDGETS_HPP
 #define NAZARA_GLOBAL_WIDGETS_HPP
 
+#include <Nazara/Widgets/AbstractTextAreaWidget.hpp>
 #include <Nazara/Widgets/BaseWidget.hpp>
 #include <Nazara/Widgets/ButtonWidget.hpp>
 #include <Nazara/Widgets/Canvas.hpp>
 #include <Nazara/Widgets/Config.hpp>
+#include <Nazara/Widgets/Enums.hpp>
 #include <Nazara/Widgets/ImageWidget.hpp>
 #include <Nazara/Widgets/LabelWidget.hpp>
+#include <Nazara/Widgets/RichTextAreaWidget.hpp>
+#include <Nazara/Widgets/TextAreaWidget.hpp>
 #include <Nazara/Widgets/Widgets.hpp>
 
 #endif // NAZARA_GLOBAL_WIDGETS_HPP

include/Nazara/Widgets/AbstractTextAreaWidget.hpp

@@ -0,0 +1,138 @@
+// Copyright (C) 2021 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
+// This file is part of the "Nazara Engine - Widgets module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_WIDGETS_ABSTRACTTEXTAREAWIDGET_HPP
+#define NAZARA_WIDGETS_ABSTRACTTEXTAREAWIDGET_HPP
+
+#include <Nazara/Graphics/TextSprite.hpp>
+#include <Nazara/Utility/AbstractTextDrawer.hpp>
+#include <Nazara/Widgets/BaseWidget.hpp>
+#include <Nazara/Widgets/Enums.hpp>
+#include <functional>
+#include <vector>
+
+namespace Nz
+{
+	class NAZARA_WIDGETS_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();
+
+			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 Vector2ui& GetCursorPosition() const;
+			inline Vector2ui GetCursorPosition(std::size_t glyphIndex) const;
+			inline EchoMode GetEchoMode() const;
+			inline std::size_t GetGlyphIndex() const;
+			inline std::size_t GetGlyphIndex(const Vector2ui& cursorPosition) const;
+			inline const std::string& GetText() const;
+
+			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 Vector2i& offset);
+
+			inline Vector2ui NormalizeCursorPosition(Vector2ui cursorPosition) const;
+
+			inline void SetCharacterFilter(CharacterFilter filter);
+			inline void SetCursorPosition(std::size_t glyphIndex);
+			inline void SetCursorPosition(Vector2ui cursorPosition);
+			inline void SetEchoMode(EchoMode echoMode);
+			inline void SetReadOnly(bool readOnly = true);
+			inline void SetSelection(Vector2ui fromPosition, Vector2ui toPosition);
+
+			inline void Write(const std::string& text);
+			inline void Write(const std::string& text, const Vector2ui& glyphPosition);
+			virtual void Write(const std::string& text, std::size_t glyphPosition) = 0;
+
+			AbstractTextAreaWidget& operator=(const AbstractTextAreaWidget&) = delete;
+			AbstractTextAreaWidget& operator=(AbstractTextAreaWidget&&) = default;
+
+			NazaraSignal(OnTextAreaCursorMove, const AbstractTextAreaWidget* /*textArea*/, 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*/, Vector2ui* /*start*/, Vector2ui* /*end*/);
+
+		protected:
+			virtual AbstractTextDrawer& GetTextDrawer() = 0;
+			virtual const 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 WindowEvent::KeyEvent& key) override;
+			void OnKeyReleased(const WindowEvent::KeyEvent& key) override;
+			void OnMouseButtonPress(int /*x*/, int /*y*/, Mouse::Button button) override;
+			void OnMouseButtonRelease(int /*x*/, int /*y*/, 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(Vector2ui cursorPosition);
+
+			void RefreshCursor();
+			virtual void UpdateDisplayText() = 0;
+			void UpdateTextSprite();
+
+			struct Cursor
+			{
+				std::shared_ptr<Sprite> sprite;
+				entt::entity entity;
+			};
+
+			std::shared_ptr<TextSprite> m_textSprite;
+			std::vector<Cursor> m_cursors;
+			CharacterFilter m_characterFilter;
+			EchoMode m_echoMode;
+			entt::entity m_textEntity;
+			Vector2ui m_cursorPositionBegin;
+			Vector2ui m_cursorPositionEnd;
+			Vector2ui m_selectionCursor;
+			bool m_isLineWrapEnabled;
+			bool m_isMouseButtonDown;
+			bool m_multiLineEnabled;
+			bool m_readOnly;
+			bool m_tabEnabled; // writes (Shift+)Tab character if set to true
+	};
+}
+
+#include <Nazara/Widgets/AbstractTextAreaWidget.inl>
+
+#endif // NAZARA_WIDGETS_ABSTRACTTEXTAREAWIDGET_HPP

include/Nazara/Widgets/AbstractTextAreaWidget.inl

@@ -0,0 +1,255 @@
+// Copyright (C) 2021 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
+// This file is part of the "Nazara Engine - Widgets module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/Widgets/AbstractTextAreaWidget.hpp>
+#include <Nazara/Widgets/Debug.hpp>
+
+namespace Nz
+{
+	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 Vector2ui& AbstractTextAreaWidget::GetCursorPosition() const
+	{
+		return m_cursorPositionBegin;
+	}
+
+	Vector2ui AbstractTextAreaWidget::GetCursorPosition(std::size_t glyphIndex) const
+	{
+		const 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);
+
+		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 Vector2ui& cursorPosition) const
+	{
+		const 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 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;
+			}
+		};
+
+		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 Vector2ui AbstractTextAreaWidget::NormalizeCursorPosition(Vector2ui cursorPosition) const
+	{
+		const 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)
+	{
+		Vector2ui position = GetCursorPosition(glyphIndex);
+		Vector2ui newPosition = position;
+
+		OnTextAreaCursorMove(this, &newPosition);
+
+		if (position == newPosition)
+			SetCursorPositionInternal(position);
+		else
+			SetCursorPositionInternal(GetGlyphIndex(newPosition));
+	}
+
+	inline void AbstractTextAreaWidget::SetCursorPosition(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(Vector2ui fromPosition, 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 std::string& text)
+	{
+		Write(text, GetGlyphIndex(m_cursorPositionBegin));
+	}
+
+	inline void AbstractTextAreaWidget::Write(const std::string& text, const Vector2ui& glyphPosition)
+	{
+		Write(text, GetGlyphIndex(glyphPosition));
+	}
+
+	void AbstractTextAreaWidget::SetCursorPositionInternal(std::size_t glyphIndex)
+	{
+		return SetCursorPositionInternal(GetCursorPosition(glyphIndex));
+	}
+
+	inline void AbstractTextAreaWidget::SetCursorPositionInternal(Vector2ui cursorPosition)
+	{
+		m_cursorPositionBegin = cursorPosition;
+		m_cursorPositionEnd = m_cursorPositionBegin;
+
+		RefreshCursor();
+	}
+}
+
+#include <Nazara/Widgets/DebugOff.hpp>

include/Nazara/Widgets/Enums.hpp

@@ -0,0 +1,37 @@
+// Copyright (C) 2021 Samy Bensaid
+// This file is part of the "Nazara Engine - Widgets module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_WIDGETS_ENUMS_HPP
+#define NAZARA_WIDGETS_ENUMS_HPP
+
+namespace Nz
+{
+	enum class BoxLayoutOrientation
+	{
+		Horizontal,
+		Vertical
+	};
+
+	enum class CheckboxState
+	{
+		Checked,
+		Tristate,
+		Unchecked,
+
+		Max = Unchecked
+	};
+
+	enum class EchoMode
+	{
+		Hidden,
+		HiddenExceptLast,
+		Normal,
+
+		Max = Normal
+	};
+}
+
+#endif // NAZARA_WIDGETS_ENUMS_HPP

include/Nazara/Widgets/RichTextAreaWidget.hpp

@@ -0,0 +1,68 @@
+// Copyright (C) 2021 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
+// This file is part of the "Nazara Engine - Widgets module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_WIDGETS_RICHTEXTAREAWIDGET_HPP
+#define NAZARA_WIDGETS_RICHTEXTAREAWIDGET_HPP
+
+#include <Nazara/Utility/RichTextDrawer.hpp>
+#include <Nazara/Widgets/AbstractTextAreaWidget.hpp>
+
+namespace Nz
+{
+	class NAZARA_WIDGETS_API RichTextAreaWidget : public AbstractTextAreaWidget
+	{
+		public:
+			RichTextAreaWidget(BaseWidget* parent);
+			RichTextAreaWidget(const RichTextAreaWidget&) = delete;
+			RichTextAreaWidget(RichTextAreaWidget&&) = default;
+			~RichTextAreaWidget() = default;
+
+			void AppendText(const std::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 Color& GetTextColor() const;
+			inline const std::shared_ptr<Font>& GetTextFont() const;
+			inline const Color& GetTextOutlineColor() const;
+			inline float GetTextOutlineThickness() const;
+			inline TextStyleFlags GetTextStyle() const;
+
+			inline void SetCharacterSize(unsigned int characterSize);
+			inline void SetCharacterSpacingOffset(float offset);
+			inline void SetLineSpacingOffset(float offset);
+			inline void SetTextColor(const Color& color);
+			inline void SetTextFont(std::shared_ptr<Font> font);
+			inline void SetTextOutlineColor(const Color& color);
+			inline void SetTextOutlineThickness(float thickness);
+			inline void SetTextStyle(TextStyleFlags style);
+
+			void Write(const std::string& text, std::size_t glyphPosition) override;
+
+			RichTextAreaWidget& operator=(const RichTextAreaWidget&) = delete;
+			RichTextAreaWidget& operator=(RichTextAreaWidget&&) = default;
+
+		private:
+			AbstractTextDrawer& GetTextDrawer() override;
+			const AbstractTextDrawer& GetTextDrawer() const override;
+
+			void HandleIndentation(bool add) override;
+			void HandleSelectionIndentation(bool add) override;
+			void HandleWordCursorMove(bool left) override;
+
+			void UpdateDisplayText() override;
+
+			RichTextDrawer m_drawer;
+	};
+}
+
+#include <Nazara/Widgets/RichTextAreaWidget.inl>
+
+#endif // NAZARA_WIDGETS_RICHTEXTAREAWIDGET_HPP

include/Nazara/Widgets/RichTextAreaWidget.inl

@@ -0,0 +1,91 @@
+// Copyright (C) 2021 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
+// This file is part of the "Nazara Engine - Widgets module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/Widgets/RichTextAreaWidget.hpp>
+#include <Nazara/Widgets/Debug.hpp>
+
+namespace Nz
+{
+	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 Color& RichTextAreaWidget::GetTextColor() const
+	{
+		return m_drawer.GetDefaultColor();
+	}
+
+	inline const std::shared_ptr<Font>& RichTextAreaWidget::GetTextFont() const
+	{
+		return m_drawer.GetDefaultFont();
+	}
+
+	inline const Color& RichTextAreaWidget::GetTextOutlineColor() const
+	{
+		return m_drawer.GetDefaultOutlineColor();
+	}
+
+	inline float RichTextAreaWidget::GetTextOutlineThickness() const
+	{
+		return m_drawer.GetDefaultOutlineThickness();
+	}
+
+	inline 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 Color& color)
+	{
+		m_drawer.SetDefaultColor(color);
+	}
+
+	inline void RichTextAreaWidget::SetTextFont(std::shared_ptr<Font> font)
+	{
+		m_drawer.SetDefaultFont(std::move(font));
+	}
+
+	inline void RichTextAreaWidget::SetTextOutlineColor(const Color& color)
+	{
+		m_drawer.SetDefaultOutlineColor(color);
+	}
+
+	inline void RichTextAreaWidget::SetTextOutlineThickness(float thickness)
+	{
+		m_drawer.SetDefaultOutlineThickness(thickness);
+	}
+
+	inline void RichTextAreaWidget::SetTextStyle(TextStyleFlags style)
+	{
+		m_drawer.SetDefaultStyle(style);
+	}
+}
+
+#include <Nazara/Widgets/DebugOff.hpp>

include/Nazara/Widgets/TextAreaWidget.hpp

@@ -0,0 +1,77 @@
+// Copyright (C) 2021 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
+// This file is part of the "Nazara Engine - Widgets module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_WIDGETS_TEXTAREAWIDGET_HPP
+#define NAZARA_WIDGETS_TEXTAREAWIDGET_HPP
+
+#include <Nazara/Utility/SimpleTextDrawer.hpp>
+#include <Nazara/Widgets/AbstractTextAreaWidget.hpp>
+
+namespace Nz
+{
+	class NAZARA_WIDGETS_API TextAreaWidget : public AbstractTextAreaWidget
+	{
+		public:
+			TextAreaWidget(BaseWidget* parent);
+			TextAreaWidget(const TextAreaWidget&) = delete;
+			TextAreaWidget(TextAreaWidget&&) = default;
+			~TextAreaWidget() = default;
+
+			void AppendText(const std::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 std::string& GetDisplayText() const;
+			inline float GetCharacterSpacingOffset() const;
+			inline float GetLineSpacingOffset() const;
+			inline const std::string& GetText() const;
+			inline const Color& GetTextColor() const;
+			inline const std::shared_ptr<Font>& GetTextFont() const;
+			inline const Color& GetTextOulineColor() const;
+			inline float GetTextOulineThickness() const;
+			inline TextStyleFlags GetTextStyle() const;
+
+			inline void SetCharacterSize(unsigned int characterSize);
+			inline void SetCharacterSpacingOffset(float offset);
+			inline void SetLineSpacingOffset(float offset);
+			inline void SetText(const std::string& text);
+			inline void SetTextColor(const Color& text);
+			inline void SetTextFont(std::shared_ptr<Font> font);
+			inline void SetTextOutlineColor(const Color& color);
+			inline void SetTextOutlineThickness(float thickness);
+			inline void SetTextStyle(TextStyleFlags style);
+
+			using AbstractTextAreaWidget::Write;
+			void Write(const std::string& text, std::size_t glyphPosition) override;
+
+			TextAreaWidget& operator=(const TextAreaWidget&) = delete;
+			TextAreaWidget& operator=(TextAreaWidget&&) = default;
+
+			NazaraSignal(OnTextChanged, const AbstractTextAreaWidget* /*textArea*/, const std::string& /*text*/);
+
+		private:
+			AbstractTextDrawer& GetTextDrawer() override;
+			const AbstractTextDrawer& GetTextDrawer() const override;
+
+			void HandleIndentation(bool add) override;
+			void HandleSelectionIndentation(bool add) override;
+			void HandleWordCursorMove(bool left) override;
+
+			void UpdateDisplayText() override;
+			void UpdateMinimumSize();
+
+			SimpleTextDrawer m_drawer;
+			std::string m_text;
+	};
+}
+
+#include <Nazara/Widgets/TextAreaWidget.inl>
+
+#endif // NAZARA_WIDGETS_TEXTAREAWIDGET_HPP

include/Nazara/Widgets/TextAreaWidget.inl

@@ -0,0 +1,127 @@
+// Copyright (C) 2021 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
+// This file is part of the "Nazara Engine - Widgets module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/Widgets/TextAreaWidget.hpp>
+#include <Nazara/Widgets/Debug.hpp>
+
+namespace Nz
+{
+	inline unsigned int TextAreaWidget::GetCharacterSize() const
+	{
+		return m_drawer.GetCharacterSize();
+	}
+
+	inline const std::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 std::string& TextAreaWidget::GetText() const
+	{
+		return m_text;
+	}
+
+	inline const Color& TextAreaWidget::GetTextColor() const
+	{
+		return m_drawer.GetColor();
+	}
+
+	inline const std::shared_ptr<Font>& TextAreaWidget::GetTextFont() const
+	{
+		return m_drawer.GetFont();
+	}
+
+	inline const Color& TextAreaWidget::GetTextOulineColor() const
+	{
+		return m_drawer.GetOutlineColor();
+	}
+
+	inline float TextAreaWidget::GetTextOulineThickness() const
+	{
+		return m_drawer.GetOutlineThickness();
+	}
+
+	inline 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 std::string& text)
+	{
+		m_text = text;
+		OnTextChanged(this, m_text);
+
+		UpdateDisplayText();
+	}
+
+	inline void TextAreaWidget::SetTextColor(const Color& text)
+	{
+		m_drawer.SetColor(text);
+
+		UpdateDisplayText();
+	}
+
+	inline void TextAreaWidget::SetTextFont(std::shared_ptr<Font> font)
+	{
+		m_drawer.SetFont(std::move(font));
+
+		UpdateDisplayText();
+	}
+
+	inline void TextAreaWidget::SetTextOutlineColor(const Color& color)
+	{
+		m_drawer.SetOutlineColor(color);
+
+		UpdateDisplayText();
+	}
+
+	inline void TextAreaWidget::SetTextOutlineThickness(float thickness)
+	{
+		m_drawer.SetOutlineThickness(thickness);
+
+		UpdateDisplayText();
+	}
+
+	inline void TextAreaWidget::SetTextStyle(TextStyleFlags style)
+	{
+		m_drawer.SetStyle(style);
+
+		UpdateDisplayText();
+	}
+}
+
+#include <Nazara/Widgets/DebugOff.hpp>