Merge remote-tracking branch 'refs/remotes/origin/master' into culling

tests/Engine/Audio/AlgorithmAudio.cpp

@@ -7,13 +7,13 @@ TEST_CASE("MixToMono", "[AUDIO][ALGORITHM]")
 {
 	SECTION("Mix two channels together")
 	{
-		std::array<int, 4> input{ 1, 3, 5, 3 };
-		std::array<int, 2> output{ 0, 0 };
+		std::array<int, 4> input = { { 1, 3, 5, 3 } };
+		std::array<int, 2> output = { { 0, 0 } };
 
 		// Two channels and two frames !
 		Nz::MixToMono(input.data(), output.data(), 2, 2);
 
-		std::array<int, 2> theoric{ 2, 4 }; // It's the mean of the two channels
-		REQUIRE(output == theoric);
+		std::array<int, 2> theoric = { { 2, 4 } }; // It's the mean of the two channels
+		CHECK(output == theoric);
 	}
 }

tests/Engine/Core/AbstractHash.cpp

@@ -14,13 +14,13 @@ SCENARIO("AbstractHash", "[CORE][ABSTRACTHASH]")
 
 		WHEN("We introduce data")
 		{
-			std::array<Nz::UInt8, 4> array{ 0, 1, 2, 3 };
+			std::array<Nz::UInt8, 4> array{ { 0, 1, 2, 3 } };
 			SHA512->Append(array.data(), array.size());
 
 			THEN("We ask for the bytearray")
 			{
 				Nz::ByteArray byteArray = SHA512->End();
-				REQUIRE(byteArray.GetSize() == SHA512->GetDigestLength());
+				CHECK(byteArray.GetSize() == SHA512->GetDigestLength());
 			}
 		}
 	}

tests/Engine/Core/Bitset.cpp

@@ -11,8 +11,8 @@ SCENARIO("Bitset", "[CORE][BITSET]")
 
 		THEN("Capacity is 3 and size is 3")
 		{
-			REQUIRE(bitset.GetSize() == 3);
-			REQUIRE(bitset.GetCapacity() >= 3);
+			CHECK(bitset.GetSize() == 3);
+			CHECK(bitset.GetCapacity() >= 3);
 		}
 	}
 
@@ -25,11 +25,11 @@ SCENARIO("Bitset", "[CORE][BITSET]")
 		WHEN("We assign 'anotherData'")
 		{
 			defaultByte = anotherDataString;
-			REQUIRE(anotherData == defaultByte);
-			REQUIRE(defaultByte.GetSize() == 4);
-			REQUIRE(defaultByte.GetCapacity() >= 4);
-			REQUIRE(anotherData.GetSize() == 4);
-			REQUIRE(anotherData.GetCapacity() >= 4);
+			CHECK(anotherData == defaultByte);
+			CHECK(defaultByte.GetSize() == 4);
+			CHECK(defaultByte.GetCapacity() >= 4);
+			CHECK(anotherData.GetSize() == 4);
+			CHECK(anotherData.GetCapacity() >= 4);
 		}
 	}
 
@@ -43,17 +43,17 @@ SCENARIO("Bitset", "[CORE][BITSET]")
 
 			THEN("We get a copy")
 			{
-				REQUIRE(copyBitset == originalArray);
+				CHECK(copyBitset == originalArray);
 
 				AND_WHEN("We modify one")
 				{
-					for (auto i = 0; i < copyBitset.GetSize(); ++i)
+					for (std::size_t i = 0; i < copyBitset.GetSize(); ++i)
 						copyBitset[i] = false;
 
 					THEN("They are no more equal")
 					{
-						REQUIRE(copyBitset != originalArray);
-						REQUIRE(copyBitset == Nz::Bitset<>(3, false));
+						CHECK(copyBitset != originalArray);
+						CHECK(copyBitset == Nz::Bitset<>(3, false));
 					}
 				}
 			}

tests/Engine/Core/SparsePtr.cpp

@@ -7,40 +7,40 @@ SCENARIO("SparsePtr", "[CORE][SPARSEPTR]")
 {
 	GIVEN("A sparse pointer pointing to an array with a stride of 2")
 	{
-		std::array<int, 5> arrays{0, 1, 2, 3, 4};
+		std::array<int, 5> arrays = { {0, 1, 2, 3, 4} };
 		Nz::SparsePtr<int> sparsePtr(arrays.data(), 2 * sizeof(int));
 
 		WHEN("We use operators")
 		{
 			THEN("Operator[] with 2 should be 4")
 			{
-				REQUIRE(4 == sparsePtr[2]);
+				CHECK(4 == sparsePtr[2]);
 			}
 
 			THEN("Operator++ and Operator-- should be opposite")
 			{
 				++sparsePtr;
-				REQUIRE(2 == *sparsePtr);
+				CHECK(2 == *sparsePtr);
 				auto old = sparsePtr++;
-				REQUIRE(2 == *old);
-				REQUIRE(4 == *sparsePtr);
+				CHECK(2 == *old);
+				CHECK(4 == *sparsePtr);
 
 				--sparsePtr;
-				REQUIRE(2 == *sparsePtr);
+				CHECK(2 == *sparsePtr);
 				auto oldMinus = sparsePtr--;
-				REQUIRE(2 == *oldMinus);
-				REQUIRE(0 == *sparsePtr);
+				CHECK(2 == *oldMinus);
+				CHECK(0 == *sparsePtr);
 			}
 
 			THEN("Operator+ and operator-")
 			{
 				auto offsetTwo = sparsePtr + 2;
-				REQUIRE(4 == *offsetTwo);
+				CHECK(4 == *offsetTwo);
 
 				auto offsetZero = offsetTwo - 2;
-				REQUIRE(0 == *offsetZero);
+				CHECK(0 == *offsetZero);
 
-				REQUIRE((offsetTwo - offsetZero) == 2);
+				CHECK((offsetTwo - offsetZero) == 2);
 			}
 		}
 	}

tests/Engine/Graphics/ParticleGroup.cpp

@@ -32,13 +32,13 @@ class TestParticleEmitter : public Nz::ParticleEmitter
 	public:
 		~TestParticleEmitter() override = default;
 
-		void Emit(Nz::ParticleGroup& system, float elapsedTime) const override
+		void Emit(Nz::ParticleGroup& system, float /*elapsedTime*/) const override
 		{
 			system.GenerateParticles(GetEmissionCount());
 		}
 
 	private:
-		void SetupParticles(Nz::ParticleMapper& mapper, unsigned int count) const override
+		void SetupParticles(Nz::ParticleMapper& /*mapper*/, unsigned int /*count*/) const override
 		{
 		}
 };
@@ -49,7 +49,7 @@ class TestParticleGenerator : public Nz::ParticleGenerator
 		~TestParticleGenerator() override = default;
 
 		// Be aware that the interval is [startId, endId] and NOT [startId, endId)
-		void Generate(Nz::ParticleGroup& system, Nz::ParticleMapper& mapper, unsigned int startId, unsigned int endId) override
+		void Generate(Nz::ParticleGroup& /*system*/, Nz::ParticleMapper& mapper, unsigned int startId, unsigned int endId) override
 		{
 			Nz::SparsePtr<Nz::Vector3f> positionPtr = mapper.GetComponentPtr<Nz::Vector3f>(Nz::ParticleComponent_Position);
 			Nz::SparsePtr<Nz::Vector3f> velocityPtr = mapper.GetComponentPtr<Nz::Vector3f>(Nz::ParticleComponent_Velocity);

tests/Engine/Network/IpAddress.cpp

@@ -17,8 +17,8 @@ SCENARIO("IpAddress", "[NETWORK][IPADDRESS]")
 
 			THEN("It's the loop back")
 			{
-				REQUIRE(ipAddressV4.IsLoopback());
-				REQUIRE(ipAddressV6.IsLoopback());
+				CHECK(ipAddressV4.IsLoopback());
+				CHECK(ipAddressV6.IsLoopback());
 			}
 		}
 	}
@@ -31,7 +31,7 @@ SCENARIO("IpAddress", "[NETWORK][IPADDRESS]")
 
 			THEN("Result is not null")
 			{
-				REQUIRE(!hostnameInfos.empty());
+				CHECK_FALSE(hostnameInfos.empty());
 			}
 		}
 
@@ -40,7 +40,7 @@ SCENARIO("IpAddress", "[NETWORK][IPADDRESS]")
 			Nz::IpAddress google(8, 8, 8, 8);
 			THEN("Google (DNS) is 8.8.8.8")
 			{
-				REQUIRE(Nz::IpAddress::ResolveAddress(google) == "google-public-dns-a.google.com");
+				CHECK(Nz::IpAddress::ResolveAddress(google) == "google-public-dns-a.google.com");
 			}
 		}
 	}

tests/Engine/Network/SocketPoller.cpp

@@ -37,7 +37,7 @@ SCENARIO("SocketPoller", "[NETWORK][SOCKETPOLLER]")
 			{
 				Nz::SocketState state = clientToServer.Connect(serverIP);
 
-				REQUIRE(state != Nz::SocketState_NotConnected);
+				CHECK(state != Nz::SocketState_NotConnected);
 
 				AND_THEN("We wait on our selector, it should return true")
 				{
@@ -65,15 +65,15 @@ SCENARIO("SocketPoller", "[NETWORK][SOCKETPOLLER]")
 
 							REQUIRE(serverPoller.Wait(1000));
 
-							REQUIRE(serverPoller.IsReady(serverToClient));
+							CHECK(serverPoller.IsReady(serverToClient));
 
-							REQUIRE(serverToClient.Read(buffer.data(), buffer.size()) == sent);
+							CHECK(serverToClient.Read(buffer.data(), buffer.size()) == sent);
 
 							AND_THEN("Our selector should report no socket ready")
 							{
-								REQUIRE(!serverPoller.Wait(100));
+								REQUIRE_FALSE(serverPoller.Wait(100));
 
-								REQUIRE(!serverPoller.IsReady(serverToClient));
+								REQUIRE_FALSE(serverPoller.IsReady(serverToClient));
 							}
 						}
 					}

tests/Engine/Network/TCP.cpp

@@ -27,7 +27,7 @@ SCENARIO("TCP", "[NETWORK][TCP]")
 		REQUIRE(client.Connect(serverIP) == Nz::SocketState_Connecting);
 
 		Nz::IpAddress clientIP = client.GetRemoteAddress();
-		REQUIRE(clientIP.IsValid());
+		CHECK(clientIP.IsValid());
 
 		Nz::Thread::Sleep(100);
 
@@ -45,9 +45,11 @@ SCENARIO("TCP", "[NETWORK][TCP]")
 			{
 				Nz::NetPacket resultPacket;
 				REQUIRE(serverToClient.ReceivePacket(&resultPacket));
+
 				Nz::Vector3f result;
 				resultPacket >> result;
-				REQUIRE(result == vector123);
+
+				CHECK(result == vector123);
 			}
 		}
 	}

tests/Engine/Utility/EventHandler.cpp

@@ -0,0 +1,82 @@
+#include <Nazara/Graphics/ColorBackground.hpp>
+#include <Nazara/Renderer/RenderWindow.hpp>
+
+#include <NDK/Application.hpp>
+#include <NDK/StateMachine.hpp>
+#include <NDK/World.hpp>
+#include <NDK/Components/CameraComponent.hpp>
+#include <NDK/Components/NodeComponent.hpp>
+#include <NDK/Systems/RenderSystem.hpp>
+
+#include "EventHandler/StateContext.hpp"
+#include "EventHandler/StateFactory.hpp"
+
+#include <Catch/catch.hpp>
+
+Ndk::EntityHandle AddCamera(Ndk::World& world, Nz::RenderWindow& window);
+
+/*!
+	Known issues on Linux:
+
+		- There is no real double click event in X11
+		- Should always the key be repeated in key pressed mode ?
+		- No smooth wheel, only 1.f or -1.f
+		- Modify dimension of window updates position (which is not wrong)
+		- Text entered is never repeated
+*/
+
+SCENARIO("EventHandler", "[UTILITY][EVENTHANDLER][INTERACTIVE][.]")
+{
+	GIVEN("An application")
+	{
+		Ndk::Application& app = *Ndk::Application::Instance();
+		auto& window = app.AddWindow<Nz::RenderWindow>();
+		if (!window.Create(Nz::VideoMode(1024, 768, 32), "EventHandler"))
+		{
+			NazaraError("Failed to create window. See NazaraLog.log for further informations");
+			REQUIRE(false);
+		}
+		window.EnableVerticalSync(true);
+
+		auto& world = app.AddWorld();
+
+		auto camera = AddCamera(world, window);
+
+		StateContext context(window, world);
+
+		StateFactory::Initialize(context);
+		Ndk::StateMachine fsm(StateFactory::Get(EventStatus::Menu));
+
+		Nz::Clock elapsedTimeClock;
+		while (app.Run())
+		{
+			window.Display();
+			float elapsedTime = elapsedTimeClock.GetSeconds();
+			elapsedTimeClock.Restart();
+
+			if (!fsm.Update(elapsedTime))
+			{
+				NazaraError("Failed to update state machine.");
+				REQUIRE(false);
+			}
+		}
+
+		StateFactory::Uninitialize();
+		REQUIRE(true);
+	}
+}
+
+Ndk::EntityHandle AddCamera(Ndk::World& world, Nz::RenderWindow& window)
+{
+	Ndk::EntityHandle view = world.CreateEntity();
+	auto& node = view->AddComponent<Ndk::NodeComponent>();
+	node.SetPosition(Nz::Vector3f::Zero());
+	auto& cam = view->AddComponent<Ndk::CameraComponent>();
+	cam.SetProjectionType(Nz::ProjectionType_Orthogonal); // 2D
+	cam.SetTarget(&window);
+
+	world.GetSystem<Ndk::RenderSystem>().SetGlobalUp(Nz::Vector3f::Down());
+	world.GetSystem<Ndk::RenderSystem>().SetDefaultBackground(Nz::ColorBackground::New(Nz::Color::Black));
+
+	return view;
+}

tests/Engine/Utility/EventHandler/EventState.cpp

@@ -0,0 +1,106 @@
+#include "EventState.hpp"
+
+#include "StateContext.hpp"
+#include "StateFactory.hpp"
+
+#include <Nazara/Renderer/RenderWindow.hpp>
+#include <NDK/StateMachine.hpp>
+
+EventState::EventState(StateContext& context) :
+State(),
+m_context(context),
+m_text(context),
+m_count(0)
+{
+}
+
+void EventState::Enter(Ndk::StateMachine& fsm)
+{
+	m_text.SetVisible(true);
+	DrawMenu();
+
+	Nz::EventHandler& eventHandler = m_context.window.GetEventHandler();
+	m_keyPressedSlot.Connect(eventHandler.OnKeyPressed, [&] (const Nz::EventHandler*, const Nz::WindowEvent::KeyEvent& key)
+	{
+		if (key.code == Nz::Keyboard::Key::M && key.shift)
+		{
+			fsm.ChangeState(StateFactory::Get(EventStatus::Menu));
+		}
+	});
+
+	m_eventSlot.Connect(eventHandler.OnEvent, [&] (const Nz::EventHandler*, const Nz::WindowEvent& event)
+	{
+		AddEvent(event);
+		++m_count;
+	});
+}
+
+void EventState::Leave(Ndk::StateMachine& /*fsm*/)
+{
+	m_text.SetVisible(false);
+}
+
+bool EventState::Update(Ndk::StateMachine& /*fsm*/, float /*elapsedTime*/)
+{
+	return true;
+}
+
+void EventState::AddEvent(const Nz::WindowEvent& event)
+{
+	if (m_events.size() > 9)
+		m_events.pop_front();
+
+	m_events.push_back(Nz::String::Number(m_count) + " - " + ToString(event));
+
+	Nz::String content;
+	for (auto&& event : m_events)
+	{
+		content += event + "\n";
+	}
+	content += "\nM for Menu";
+	m_text.SetContent(content, 36);
+}
+
+void EventState::DrawMenu()
+{
+	m_text.SetContent("Do whathever you want, this text should change !\nM for Menu");
+}
+
+Nz::String EventState::ToString(const Nz::WindowEvent& event) const
+{
+	switch (event.type)
+	{
+		case Nz::WindowEventType_GainedFocus:
+			return "WindowEventType_GainedFocus";
+		case Nz::WindowEventType_LostFocus:
+			return "WindowEventType_LostFocus";
+		case Nz::WindowEventType_KeyPressed:
+			return "WindowEventType_KeyPressed";
+		case Nz::WindowEventType_KeyReleased:
+			return "WindowEventType_KeyReleased";
+		case Nz::WindowEventType_MouseButtonDoubleClicked:
+			return "WindowEventType_MouseButtonDoubleClicked";
+		case Nz::WindowEventType_MouseButtonPressed:
+			return "WindowEventType_MouseButtonPressed";
+		case Nz::WindowEventType_MouseButtonReleased:
+			return "WindowEventType_MouseButtonReleased";
+		case Nz::WindowEventType_MouseEntered:
+			return "WindowEventType_MouseEntered";
+		case Nz::WindowEventType_MouseLeft:
+			return "WindowEventType_MouseLeft";
+		case Nz::WindowEventType_MouseMoved:
+			return "WindowEventType_MouseMoved";
+		case Nz::WindowEventType_MouseWheelMoved:
+			return "WindowEventType_MouseWheelMoved";
+		case Nz::WindowEventType_Moved:
+			return "WindowEventType_Moved";
+		case Nz::WindowEventType_Quit:
+			return "WindowEventType_Quit";
+		case Nz::WindowEventType_Resized:
+			return "WindowEventType_Resized";
+		case Nz::WindowEventType_TextEntered:
+			return "WindowEventType_TextEntered";
+		default:
+			return "Not handled";
+	}
+}

tests/Engine/Utility/EventHandler/EventState.hpp

@@ -0,0 +1,36 @@
+#ifndef __EVENTSTATE_HPP__
+#define __EVENTSTATE_HPP__
+
+#include "Text.hpp"
+
+#include <Nazara/Utility/EventHandler.hpp>
+
+#include <NDK/State.hpp>
+
+#include <deque>
+
+class StateContext;
+
+class EventState : public Ndk::State
+{
+	public:
+		EventState(StateContext& stateContext);
+
+		void Enter(Ndk::StateMachine& fsm) override;
+		void Leave(Ndk::StateMachine& fsm) override;
+		bool Update(Ndk::StateMachine& fsm, float elapsedTime) override;
+
+	private:
+		void AddEvent(const Nz::WindowEvent& event);
+		void DrawMenu();
+		Nz::String ToString(const Nz::WindowEvent& event) const;
+
+		StateContext& m_context;
+		Text m_text;
+		std::deque<Nz::String> m_events;
+		int m_count;
+		NazaraSlot(Nz::EventHandler, OnEvent, m_eventSlot);
+		NazaraSlot(Nz::EventHandler, OnKeyPressed, m_keyPressedSlot);
+};
+
+#endif // __EVENTSTATE_HPP__

tests/Engine/Utility/EventHandler/FocusState.cpp

@@ -0,0 +1,54 @@
+#include "FocusState.hpp"
+
+#include "StateContext.hpp"
+#include "StateFactory.hpp"
+
+#include <Nazara/Renderer/RenderWindow.hpp>
+#include <NDK/StateMachine.hpp>
+
+FocusState::FocusState(StateContext& context) :
+State(),
+m_context(context),
+m_text(context)
+{
+}
+
+void FocusState::Enter(Ndk::StateMachine& fsm)
+{
+	m_text.SetVisible(true);
+	DrawMenu();
+
+	Nz::EventHandler& eventHandler = m_context.window.GetEventHandler();
+	m_keyPressedSlot.Connect(eventHandler.OnKeyPressed, [&] (const Nz::EventHandler*, const Nz::WindowEvent::KeyEvent& key)
+	{
+		if (key.code == Nz::Keyboard::Key::M && key.shift)
+		{
+			fsm.ChangeState(StateFactory::Get(EventStatus::Menu));
+		}
+	});
+
+	m_gainedFocusSlot.Connect(eventHandler.OnGainedFocus, [&] (const Nz::EventHandler*)
+	{
+		m_text.SetContent("GAINED\nM for Menu");
+	});
+
+	m_lostFocusSlot.Connect(eventHandler.OnLostFocus, [&] (const Nz::EventHandler*)
+	{
+		m_text.SetContent("LOST\nM for Menu");
+	});
+}
+
+void FocusState::Leave(Ndk::StateMachine& /*fsm*/)
+{
+	m_text.SetVisible(false);
+}
+
+bool FocusState::Update(Ndk::StateMachine& /*fsm*/, float /*elapsedTime*/)
+{
+	return true;
+}
+
+void FocusState::DrawMenu()
+{
+	m_text.SetContent("Click outside the windows, this text should change !\nM for Menu");
+}

tests/Engine/Utility/EventHandler/FocusState.hpp

@@ -0,0 +1,31 @@
+#ifndef __FOCUSSTATE_HPP__
+#define __FOCUSSTATE_HPP__
+
+#include "Text.hpp"
+
+#include <Nazara/Utility/EventHandler.hpp>
+
+#include <NDK/State.hpp>
+
+class StateContext;
+
+class FocusState : public Ndk::State
+{
+	public:
+		FocusState(StateContext& stateContext);
+
+		void Enter(Ndk::StateMachine& fsm) override;
+		void Leave(Ndk::StateMachine& fsm) override;
+		bool Update(Ndk::StateMachine& fsm, float elapsedTime) override;
+
+	private:
+		void DrawMenu();
+
+		StateContext& m_context;
+		Text m_text;
+		NazaraSlot(Nz::EventHandler, OnGainedFocus, m_gainedFocusSlot);
+		NazaraSlot(Nz::EventHandler, OnLostFocus, m_lostFocusSlot);
+		NazaraSlot(Nz::EventHandler, OnKeyPressed, m_keyPressedSlot);
+};
+
+#endif // __FOCUSSTATE_HPP__

tests/Engine/Utility/EventHandler/KeyState.cpp

@@ -0,0 +1,90 @@
+#include "KeyState.hpp"
+
+#include "StateContext.hpp"
+#include "StateFactory.hpp"
+
+#include <Nazara/Renderer/RenderWindow.hpp>
+#include <NDK/StateMachine.hpp>
+
+KeyState::KeyState(StateContext& context) :
+State(),
+m_context(context),
+m_text(context),
+m_keyStatus(KeyStatus::Pressed)
+{
+}
+
+void KeyState::Enter(Ndk::StateMachine& fsm)
+{
+	m_text.SetVisible(true);
+	DrawMenu();
+
+	Nz::EventHandler& eventHandler = m_context.window.GetEventHandler();
+	m_keyPressedSlot.Connect(eventHandler.OnKeyPressed, [&] (const Nz::EventHandler*, const Nz::WindowEvent::KeyEvent& key)
+	{
+		ManageInput(KeyStatus::Pressed, key, fsm);
+	});
+
+	m_keyReleasedSlot.Connect(eventHandler.OnKeyReleased, [&] (const Nz::EventHandler*, const Nz::WindowEvent::KeyEvent& key)
+	{
+		ManageInput(KeyStatus::Released, key, fsm);
+	});
+}
+
+void KeyState::Leave(Ndk::StateMachine& /*fsm*/)
+{
+	m_text.SetVisible(false);
+}
+
+bool KeyState::Update(Ndk::StateMachine& /*fsm*/, float /*elapsedTime*/)
+{
+	return true;
+}
+
+void KeyState::DrawMenu()
+{
+	m_text.SetContent("Clic on a key, this text should change !\nN for alternating event\nM for Menu");
+}
+
+void KeyState::ManageInput(KeyStatus isKeyPressed, const Nz::WindowEvent::KeyEvent& key, Ndk::StateMachine& fsm)
+{
+	if (key.code == Nz::Keyboard::Key::M && key.shift)
+		fsm.ChangeState(StateFactory::Get(EventStatus::Menu));
+	else if (key.code == Nz::Keyboard::Key::N && key.shift)
+	{
+		if (m_keyStatus == KeyStatus::Pressed)
+			m_keyStatus = KeyStatus::Released;
+		else
+			m_keyStatus = KeyStatus::Pressed;
+	}
+	else 
+	{
+		Nz::String content;
+		if (m_keyStatus == KeyStatus::Pressed)
+			content = "Pressed: ";
+		else
+			content = "Released: ";
+
+		Nz::String keyName = Nz::Keyboard::GetKeyName(key.code);
+		if (keyName.IsEmpty())
+		{
+			m_text.SetContent("Unknown\nM for Menu");
+		}
+		else
+		{
+			content += keyName;
+			if (key.alt)
+				content += " alt";
+			if (key.control)
+				content += " control";
+			if (key.repeated)
+				content += " repeated";
+			if (key.shift)
+				content += " shift";
+			if (key.system)
+				content += " system";
+			
+			m_text.SetContent(content + "\nM for Menu");
+		}
+	}
+}

tests/Engine/Utility/EventHandler/KeyState.hpp

@@ -0,0 +1,38 @@
+#ifndef __KEYSTATE_HPP__
+#define __KEYSTATE_HPP__
+
+#include "Text.hpp"
+
+#include <Nazara/Utility/EventHandler.hpp>
+
+#include <NDK/State.hpp>
+
+class StateContext;
+
+enum class KeyStatus
+{
+	Pressed,
+	Released
+};
+
+class KeyState : public Ndk::State
+{
+	public:
+		KeyState(StateContext& stateContext);
+
+		void Enter(Ndk::StateMachine& fsm) override;
+		void Leave(Ndk::StateMachine& fsm) override;
+		bool Update(Ndk::StateMachine& fsm, float elapsedTime) override;
+
+	private:
+		void DrawMenu();
+		void ManageInput(KeyStatus isKeyPressed, const Nz::WindowEvent::KeyEvent& key, Ndk::StateMachine& fsm);
+
+		StateContext& m_context;
+		Text m_text;
+		KeyStatus m_keyStatus;
+		NazaraSlot(Nz::EventHandler, OnKeyPressed, m_keyPressedSlot);
+		NazaraSlot(Nz::EventHandler, OnKeyReleased, m_keyReleasedSlot);
+};
+
+#endif // __KEYSTATE_HPP__

tests/Engine/Utility/EventHandler/MenuState.cpp

@@ -0,0 +1,50 @@
+#include "MenuState.hpp"
+
+#include "StateContext.hpp"
+#include "StateFactory.hpp"
+
+#include <Nazara/Renderer/RenderWindow.hpp>
+#include <NDK/StateMachine.hpp>
+
+MenuState::MenuState(StateContext& context) :
+State(),
+m_context(context),
+m_text(context),
+m_selectedNextState(-1)
+{
+}
+
+void MenuState::Enter(Ndk::StateMachine& /*fsm*/)
+{
+	m_text.SetVisible(true);
+	DrawMenu();
+
+	Nz::EventHandler& eventHandler = m_context.window.GetEventHandler();
+	m_keyPressedSlot.Connect(eventHandler.OnKeyPressed, [this] (const Nz::EventHandler*, const Nz::WindowEvent::KeyEvent& key)
+	{
+		if (key.code >= Nz::Keyboard::Key::A && key.code < (Nz::Keyboard::Key::A + static_cast<int>(EventStatus::Max) - 1))
+		{
+			m_selectedNextState = key.code - static_cast<int>(Nz::Keyboard::Key::A);
+		}
+	});
+}
+
+void MenuState::Leave(Ndk::StateMachine& /*fsm*/)
+{
+	m_text.SetVisible(false);
+	m_selectedNextState = -1;
+}
+
+bool MenuState::Update(Ndk::StateMachine& fsm, float /*elapsedTime*/)
+{
+	if (m_selectedNextState != -1) {
+		fsm.ChangeState(StateFactory::Get(m_selectedNextState + 1));
+	}
+
+	return true;
+}
+
+void MenuState::DrawMenu()
+{
+	m_text.SetContent("a. Event\nb. Focus\nc. Key\nd. Mouse click\ne. Mouse enter\nf. Mouse move\ng. Text enter\nh. Window modification");
+}

tests/Engine/Utility/EventHandler/MenuState.hpp

@@ -0,0 +1,30 @@
+#ifndef __MENUSTATE_HPP__
+#define __MENUSTATE_HPP__
+
+#include "Text.hpp"
+
+#include <Nazara/Utility/EventHandler.hpp>
+
+#include <NDK/State.hpp>
+
+class StateContext;
+
+class MenuState : public Ndk::State
+{
+	public:
+		MenuState(StateContext& stateContext);
+
+		void Enter(Ndk::StateMachine& fsm) override;
+		void Leave(Ndk::StateMachine& fsm) override;
+		bool Update(Ndk::StateMachine& fsm, float elapsedTime) override;
+
+	private:
+		void DrawMenu();
+
+		StateContext& m_context;
+		Text m_text;
+		NazaraSlot(Nz::EventHandler, OnKeyPressed, m_keyPressedSlot);
+		int m_selectedNextState;
+};
+
+#endif // __MENUSTATE_HPP__

tests/Engine/Utility/EventHandler/MouseClickState.cpp

@@ -0,0 +1,94 @@
+#include "MouseClickState.hpp"
+
+#include "StateContext.hpp"
+#include "StateFactory.hpp"
+
+#include <Nazara/Renderer/RenderWindow.hpp>
+#include <NDK/StateMachine.hpp>
+
+MouseClickState::MouseClickState(StateContext& context) :
+State(),
+m_context(context),
+m_text(context)
+{
+}
+
+void MouseClickState::Enter(Ndk::StateMachine& fsm)
+{
+	m_text.SetVisible(true);
+	DrawMenu();
+
+	Nz::EventHandler& eventHandler = m_context.window.GetEventHandler();
+	m_keyPressedSlot.Connect(eventHandler.OnKeyPressed, [&] (const Nz::EventHandler*, const Nz::WindowEvent::KeyEvent& key)
+	{
+		if (key.code == Nz::Keyboard::Key::M && key.shift)
+		{
+			fsm.ChangeState(StateFactory::Get(EventStatus::Menu));
+		}
+	});
+
+	m_mouseButtonDoubleClickedSlot.Connect(eventHandler.OnMouseButtonDoubleClicked, [&] (const Nz::EventHandler*, const Nz::WindowEvent::MouseButtonEvent& mouse)
+	{
+		ManageInput(MouseStatus::DoubleClick, mouse, fsm);
+	});
+
+	m_mouseButtonPressedSlot.Connect(eventHandler.OnMouseButtonPressed, [&] (const Nz::EventHandler*, const Nz::WindowEvent::MouseButtonEvent& mouse)
+	{
+		ManageInput(MouseStatus::Pressed, mouse, fsm);
+	});
+
+	m_mouseButtonReleasedSlot.Connect(eventHandler.OnMouseButtonReleased, [&] (const Nz::EventHandler*, const Nz::WindowEvent::MouseButtonEvent& mouse)
+	{
+		ManageInput(MouseStatus::Released, mouse, fsm);
+	});
+}
+
+void MouseClickState::Leave(Ndk::StateMachine& /*fsm*/)
+{
+	m_text.SetVisible(false);
+}
+
+bool MouseClickState::Update(Ndk::StateMachine& /*fsm*/, float /*elapsedTime*/)
+{
+	return true;
+}
+
+void MouseClickState::DrawMenu()
+{
+	m_text.SetContent("Click in the windows, this text should change !\nM for Menu");
+}
+
+void MouseClickState::ManageInput(MouseStatus mouseStatus, const Nz::WindowEvent::MouseButtonEvent& mouse, Ndk::StateMachine& fsm)
+{
+	Nz::String content;
+	if (mouseStatus == MouseStatus::Pressed)
+		content = "Pressed: ";
+	else if (mouseStatus == MouseStatus::Released)
+		content = "Released: ";
+	else
+		content = "Double clicked: ";
+
+	switch (mouse.button)
+	{
+		case Nz::Mouse::Left:
+			content += "Left";
+			break;
+		case Nz::Mouse::Middle:
+			content += "Middle";
+			break;
+		case Nz::Mouse::Right:
+			content += "Right";
+			break;
+		case Nz::Mouse::XButton1:
+			content += "XButton1";
+			break;
+		case Nz::Mouse::XButton2:
+			content += "XButton2";
+			break;
+		default:
+			content += "Unknown";
+			break;
+	}
+
+	m_text.SetContent(content + "\nM for Menu");
+}

tests/Engine/Utility/EventHandler/MouseClickState.hpp

@@ -0,0 +1,40 @@
+#ifndef __MOUSECLICKSTATE_HPP__
+#define __MOUSECLICKSTATE_HPP__
+
+#include "Text.hpp"
+
+#include <Nazara/Utility/EventHandler.hpp>
+
+#include <NDK/State.hpp>
+
+class StateContext;
+
+enum class MouseStatus
+{
+	DoubleClick,
+	Pressed,
+	Released
+};
+
+class MouseClickState : public Ndk::State
+{
+	public:
+		MouseClickState(StateContext& stateContext);
+
+		void Enter(Ndk::StateMachine& fsm) override;
+		void Leave(Ndk::StateMachine& fsm) override;
+		bool Update(Ndk::StateMachine& fsm, float elapsedTime) override;
+
+	private:
+		void DrawMenu();
+		void ManageInput(MouseStatus mouseStatus, const Nz::WindowEvent::MouseButtonEvent& mouse, Ndk::StateMachine& fsm);
+
+		StateContext& m_context;
+		Text m_text;
+		NazaraSlot(Nz::EventHandler, OnKeyPressed, m_keyPressedSlot);
+		NazaraSlot(Nz::EventHandler, OnMouseButtonDoubleClicked, m_mouseButtonDoubleClickedSlot);
+		NazaraSlot(Nz::EventHandler, OnMouseButtonPressed, m_mouseButtonPressedSlot);
+		NazaraSlot(Nz::EventHandler, OnMouseButtonReleased, m_mouseButtonReleasedSlot);
+};
+
+#endif // __MOUSECLICKSTATE_HPP__

tests/Engine/Utility/EventHandler/MouseEnterState.cpp

@@ -0,0 +1,54 @@
+#include "MouseEnterState.hpp"
+
+#include "StateContext.hpp"
+#include "StateFactory.hpp"
+
+#include <Nazara/Renderer/RenderWindow.hpp>
+#include <NDK/StateMachine.hpp>
+
+MouseEnterState::MouseEnterState(StateContext& context) :
+State(),
+m_context(context),
+m_text(context)
+{
+}
+
+void MouseEnterState::Enter(Ndk::StateMachine& fsm)
+{
+	m_text.SetVisible(true);
+	DrawMenu();
+
+	Nz::EventHandler& eventHandler = m_context.window.GetEventHandler();
+	m_keyPressedSlot.Connect(eventHandler.OnKeyPressed, [&] (const Nz::EventHandler*, const Nz::WindowEvent::KeyEvent& key)
+	{
+		if (key.code == Nz::Keyboard::Key::M && key.shift)
+		{
+			fsm.ChangeState(StateFactory::Get(EventStatus::Menu));
+		}
+	});
+
+	m_mouseEnteredSlot.Connect(eventHandler.OnMouseEntered, [&] (const Nz::EventHandler*)
+	{
+		m_text.SetContent("Entered\nM for Menu");
+	});
+
+	m_mouseLeftSlot.Connect(eventHandler.OnMouseLeft, [&] (const Nz::EventHandler*)
+	{
+		m_text.SetContent("Left\nM for Menu");
+	});
+}
+
+void MouseEnterState::Leave(Ndk::StateMachine& /*fsm*/)
+{
+	m_text.SetVisible(false);
+}
+
+bool MouseEnterState::Update(Ndk::StateMachine& /*fsm*/, float /*elapsedTime*/)
+{
+	return true;
+}
+
+void MouseEnterState::DrawMenu()
+{
+	m_text.SetContent("Move your mouse outside the windows, this text should change !\nM for Menu");
+}

tests/Engine/Utility/EventHandler/MouseEnterState.hpp

@@ -0,0 +1,31 @@
+#ifndef __MOUSEENTERSTATE_HPP__
+#define __MOUSEENTERSTATE_HPP__
+
+#include "Text.hpp"
+
+#include <Nazara/Utility/EventHandler.hpp>
+
+#include <NDK/State.hpp>
+
+class StateContext;
+
+class MouseEnterState : public Ndk::State
+{
+	public:
+		MouseEnterState(StateContext& stateContext);
+
+		void Enter(Ndk::StateMachine& fsm) override;
+		void Leave(Ndk::StateMachine& fsm) override;
+		bool Update(Ndk::StateMachine& fsm, float elapsedTime) override;
+
+	private:
+		void DrawMenu();
+
+		StateContext& m_context;
+		Text m_text;
+		NazaraSlot(Nz::EventHandler, OnKeyPressed, m_keyPressedSlot);
+		NazaraSlot(Nz::EventHandler, OnMouseEntered, m_mouseEnteredSlot);
+		NazaraSlot(Nz::EventHandler, OnMouseLeft, m_mouseLeftSlot);
+};
+
+#endif // __MOUSEENTERSTATE_HPP__

tests/Engine/Utility/EventHandler/MouseMoveState.cpp

@@ -0,0 +1,54 @@
+#include "MouseMoveState.hpp"
+
+#include "StateContext.hpp"
+#include "StateFactory.hpp"
+
+#include <Nazara/Renderer/RenderWindow.hpp>
+#include <NDK/StateMachine.hpp>
+
+MouseMoveState::MouseMoveState(StateContext& context) :
+State(),
+m_context(context),
+m_text(context)
+{
+}
+
+void MouseMoveState::Enter(Ndk::StateMachine& fsm)
+{
+	m_text.SetVisible(true);
+	DrawMenu();
+
+	Nz::EventHandler& eventHandler = m_context.window.GetEventHandler();
+	m_keyPressedSlot.Connect(eventHandler.OnKeyPressed, [&] (const Nz::EventHandler*, const Nz::WindowEvent::KeyEvent& key)
+	{
+		if (key.code == Nz::Keyboard::Key::M && key.shift)
+		{
+			fsm.ChangeState(StateFactory::Get(EventStatus::Menu));
+		}
+	});
+
+	m_mouseMovedSlot.Connect(eventHandler.OnMouseMoved, [&] (const Nz::EventHandler*, const Nz::WindowEvent::MouseMoveEvent& event)
+	{
+		m_text.SetContent("Position(" + Nz::String::Number(event.x) + ", " + Nz::String::Number(event.y) + ") delta: (" + Nz::String::Number(event.deltaX) + ", " + Nz::String::Number(event.deltaY) + ") \nM for Menu");
+	});
+
+	m_mouseWheelMovedSlot.Connect(eventHandler.OnMouseWheelMoved, [&] (const Nz::EventHandler*, const Nz::WindowEvent::MouseWheelEvent& event)
+	{
+		m_text.SetContent("Wheel delta: " + Nz::String::Number(event.delta) + "\nM for Menu");
+	});
+}
+
+void MouseMoveState::Leave(Ndk::StateMachine& /*fsm*/)
+{
+	m_text.SetVisible(false);
+}
+
+bool MouseMoveState::Update(Ndk::StateMachine& /*fsm*/, float /*elapsedTime*/)
+{
+	return true;
+}
+
+void MouseMoveState::DrawMenu()
+{
+	m_text.SetContent("Move your mouse or your wheel, this text should change !\nM for Menu");
+}

tests/Engine/Utility/EventHandler/MouseMoveState.hpp

@@ -0,0 +1,31 @@
+#ifndef __MOUSEMOVESTATE_HPP__
+#define __MOUSEMOVESTATE_HPP__
+
+#include "Text.hpp"
+
+#include <Nazara/Utility/EventHandler.hpp>
+
+#include <NDK/State.hpp>
+
+class StateContext;
+
+class MouseMoveState : public Ndk::State
+{
+	public:
+		MouseMoveState(StateContext& stateContext);
+
+		void Enter(Ndk::StateMachine& fsm) override;
+		void Leave(Ndk::StateMachine& fsm) override;
+		bool Update(Ndk::StateMachine& fsm, float elapsedTime) override;
+
+	private:
+		void DrawMenu();
+
+		StateContext& m_context;
+		Text m_text;
+		NazaraSlot(Nz::EventHandler, OnKeyPressed, m_keyPressedSlot);
+		NazaraSlot(Nz::EventHandler, OnMouseMoved, m_mouseMovedSlot);
+		NazaraSlot(Nz::EventHandler, OnMouseWheelMoved, m_mouseWheelMovedSlot);
+};
+
+#endif // __MOUSEMOVESTATE_HPP__

tests/Engine/Utility/EventHandler/StateContext.cpp

@@ -0,0 +1,7 @@
+#include "StateContext.hpp"
+
+StateContext::StateContext(Nz::RenderWindow& windowContext, Ndk::World& worldContext) :
+window(windowContext),
+world(worldContext)
+{
+}

tests/Engine/Utility/EventHandler/StateContext.hpp

@@ -0,0 +1,23 @@
+#ifndef __STATECONTEXT_HPP__
+#define __STATECONTEXT_HPP__
+
+namespace Ndk
+{
+	class World;
+}
+
+namespace Nz
+{
+	class RenderWindow;
+}
+
+class StateContext
+{
+	public:
+		StateContext(Nz::RenderWindow& window, Ndk::World& world);
+
+		Nz::RenderWindow& window;
+		Ndk::World& world;
+};
+
+#endif // __STATECONTEXT_HPP__

tests/Engine/Utility/EventHandler/StateFactory.cpp

@@ -0,0 +1,46 @@
+#include "StateFactory.hpp"
+
+#include "MenuState.hpp"
+#include "EventState.hpp"
+#include "FocusState.hpp"
+#include "KeyState.hpp"
+#include "MouseClickState.hpp"
+#include "MouseEnterState.hpp"
+#include "MouseMoveState.hpp"
+#include "TextEnterState.hpp"
+#include "WindowModificationState.hpp"
+
+std::shared_ptr<Ndk::State> StateFactory::Get(EventStatus state)
+{
+	return s_states[state];
+}
+
+std::shared_ptr<Ndk::State> StateFactory::Get(unsigned int state)
+{
+	NazaraAssert(state < s_states.size(), "State out of range");
+	auto it = s_states.begin();
+	std::advance(it, state);
+	return it->second;
+}
+
+bool StateFactory::Initialize(StateContext& context)
+{
+	s_states.emplace(std::make_pair(EventStatus::Menu, std::make_shared<MenuState>(context)));
+	s_states.emplace(std::make_pair(EventStatus::Event, std::make_shared<EventState>(context)));
+	s_states.emplace(std::make_pair(EventStatus::Focus, std::make_shared<FocusState>(context)));
+	s_states.emplace(std::make_pair(EventStatus::Key, std::make_shared<KeyState>(context)));
+	s_states.emplace(std::make_pair(EventStatus::MouseClick, std::make_shared<MouseClickState>(context)));
+	s_states.emplace(std::make_pair(EventStatus::MouseEnter, std::make_shared<MouseEnterState>(context)));
+	s_states.emplace(std::make_pair(EventStatus::MouseMove, std::make_shared<MouseMoveState>(context)));
+	s_states.emplace(std::make_pair(EventStatus::TextEnter, std::make_shared<TextEnterState>(context)));
+	s_states.emplace(std::make_pair(EventStatus::WindowModification, std::make_shared<WindowModificationState>(context)));
+
+	return true;
+}
+
+void StateFactory::Uninitialize()
+{
+	s_states.clear();
+}
+
+std::map<EventStatus, std::shared_ptr<Ndk::State>> StateFactory::s_states;

tests/Engine/Utility/EventHandler/StateFactory.hpp

@@ -0,0 +1,42 @@
+#ifndef __STATEFACTORY_HPP__
+#define __STATEFACTORY_HPP__
+
+#include <NDK/State.hpp>
+
+#include <map>
+#include <memory>
+
+class StateContext;
+
+enum class EventStatus
+{
+	Min = 0,
+	Menu,
+	Event,
+	Focus,
+	Key,
+	MouseClick,
+	MouseEnter,
+	MouseMove,
+	TextEnter,
+	WindowModification,
+	Max = WindowModification
+};
+
+class StateFactory
+{
+	public:
+
+		static std::shared_ptr<Ndk::State> Get(EventStatus state);
+		static std::shared_ptr<Ndk::State> Get(unsigned int state);
+
+		static bool Initialize(StateContext& stateContext);
+
+		static void Uninitialize();
+
+	private:
+
+		static std::map<EventStatus, std::shared_ptr<Ndk::State>> s_states;
+};
+
+#endif // __STATEFACTORY_HPP__

tests/Engine/Utility/EventHandler/Text.cpp

@@ -0,0 +1,35 @@
+#include "Text.hpp"
+
+#include <Nazara/Renderer/RenderWindow.hpp>
+#include <Nazara/Utility/SimpleTextDrawer.hpp>
+#include <NDK/StateMachine.hpp>
+#include <NDK/World.hpp>
+#include <NDK/Components/GraphicsComponent.hpp>
+#include <NDK/Components/NodeComponent.hpp>
+
+Text::Text(StateContext& stateContext) :
+m_context(stateContext)
+{
+	m_text = m_context.world.CreateEntity();
+	Ndk::NodeComponent& nodeComponent = m_text->AddComponent<Ndk::NodeComponent>();
+	Ndk::GraphicsComponent& graphicsComponent = m_text->AddComponent<Ndk::GraphicsComponent>();
+
+	m_textSprite = Nz::TextSprite::New();
+	graphicsComponent.Attach(m_textSprite);
+}
+
+Text::~Text()
+{
+	m_textSprite->Clear();
+	m_text->Kill();
+}
+
+void Text::SetContent(const Nz::String& string, unsigned int size)
+{
+	m_textSprite->Update(Nz::SimpleTextDrawer::Draw(string, size));
+}
+
+void Text::SetVisible(bool shouldBeVisible)
+{
+	m_text->Enable(shouldBeVisible);
+}

tests/Engine/Utility/EventHandler/Text.hpp

@@ -0,0 +1,23 @@
+#ifndef __TEXT_HPP__
+#define __TEXT_HPP__
+
+#include <Nazara/Graphics/TextSprite.hpp>
+#include <NDK/Entity.hpp>
+#include "StateContext.hpp"
+
+class Text
+{
+	public:
+		Text(StateContext& context);
+		~Text();
+
+		void SetContent(const Nz::String& string, unsigned int size = 36);
+		void SetVisible(bool shouldBeVisible = true);
+
+	private:
+		StateContext& m_context;
+		Ndk::EntityHandle m_text;
+		Nz::TextSpriteRef m_textSprite;
+};
+
+#endif // __TEXT_HPP__

tests/Engine/Utility/EventHandler/TextEnterState.cpp

@@ -0,0 +1,52 @@
+#include "TextEnterState.hpp"
+
+#include "StateContext.hpp"
+#include "StateFactory.hpp"
+
+#include <Nazara/Renderer/RenderWindow.hpp>
+#include <NDK/StateMachine.hpp>
+
+TextEnterState::TextEnterState(StateContext& context) :
+State(),
+m_context(context),
+m_text(context)
+{
+}
+
+void TextEnterState::Enter(Ndk::StateMachine& fsm)
+{
+	m_text.SetVisible(true);
+	DrawMenu();
+
+	Nz::EventHandler& eventHandler = m_context.window.GetEventHandler();
+	m_keyPressedSlot.Connect(eventHandler.OnKeyPressed, [&] (const Nz::EventHandler*, const Nz::WindowEvent::KeyEvent& key)
+	{
+		if (key.code == Nz::Keyboard::Key::M && key.shift)
+		{
+			fsm.ChangeState(StateFactory::Get(EventStatus::Menu));
+		}
+	});
+
+	m_textEnteredSlot.Connect(eventHandler.OnTextEntered, [&] (const Nz::EventHandler*, const Nz::WindowEvent::TextEvent& event)
+	{
+		Nz::String content = "Character: " + Nz::String::Unicode(event.character);
+		if (event.repeated)
+			content += " repeated";
+		m_text.SetContent(content + "\nM for Menu");
+	});
+}
+
+void TextEnterState::Leave(Ndk::StateMachine& /*fsm*/)
+{
+	m_text.SetVisible(false);
+}
+
+bool TextEnterState::Update(Ndk::StateMachine& /*fsm*/, float /*elapsedTime*/)
+{
+	return true;
+}
+
+void TextEnterState::DrawMenu()
+{
+	m_text.SetContent("Enter some text, this text should change !\nM for Menu");
+}

tests/Engine/Utility/EventHandler/TextEnterState.hpp

@@ -0,0 +1,30 @@
+#ifndef __TEXTENTERSTATE_HPP__
+#define __TEXTENTERSTATE_HPP__
+
+#include "Text.hpp"
+
+#include <Nazara/Utility/EventHandler.hpp>
+
+#include <NDK/State.hpp>
+
+class StateContext;
+
+class TextEnterState : public Ndk::State
+{
+	public:
+		TextEnterState(StateContext& stateContext);
+
+		void Enter(Ndk::StateMachine& fsm) override;
+		void Leave(Ndk::StateMachine& fsm) override;
+		bool Update(Ndk::StateMachine& fsm, float elapsedTime) override;
+
+	private:
+		void DrawMenu();
+
+		StateContext& m_context;
+		Text m_text;
+		NazaraSlot(Nz::EventHandler, OnKeyPressed, m_keyPressedSlot);
+		NazaraSlot(Nz::EventHandler, OnTextEntered, m_textEnteredSlot);
+};
+
+#endif // __TEXTENTERSTATE_HPP__

tests/Engine/Utility/EventHandler/WindowModificationState.cpp

@@ -0,0 +1,54 @@
+#include "WindowModificationState.hpp"
+
+#include "StateContext.hpp"
+#include "StateFactory.hpp"
+
+#include <Nazara/Renderer/RenderWindow.hpp>
+#include <NDK/StateMachine.hpp>
+
+WindowModificationState::WindowModificationState(StateContext& context) :
+State(),
+m_context(context),
+m_text(context)
+{
+}
+
+void WindowModificationState::Enter(Ndk::StateMachine& fsm)
+{
+	m_text.SetVisible(true);
+	DrawMenu();
+
+	Nz::EventHandler& eventHandler = m_context.window.GetEventHandler();
+	m_keyPressedSlot.Connect(eventHandler.OnKeyPressed, [&] (const Nz::EventHandler*, const Nz::WindowEvent::KeyEvent& key)
+	{
+		if (key.code == Nz::Keyboard::Key::M && key.shift)
+		{
+			fsm.ChangeState(StateFactory::Get(EventStatus::Menu));
+		}
+	});
+
+	m_movedSlot.Connect(eventHandler.OnMoved, [&] (const Nz::EventHandler*, const Nz::WindowEvent::PositionEvent& event)
+	{
+		m_text.SetContent("Position(" + Nz::String::Number(event.x) + ", " + Nz::String::Number(event.y) + ")\nM for Menu");
+	});
+
+	m_resizedSlot.Connect(eventHandler.OnResized, [&] (const Nz::EventHandler*, const Nz::WindowEvent::SizeEvent& event)
+	{
+		m_text.SetContent("Size(" + Nz::String::Number(event.width) + ", " + Nz::String::Number(event.height) + ")\nM for Menu");
+	});
+}
+
+void WindowModificationState::Leave(Ndk::StateMachine& /*fsm*/)
+{
+	m_text.SetVisible(false);
+}
+
+bool WindowModificationState::Update(Ndk::StateMachine& /*fsm*/, float /*elapsedTime*/)
+{
+	return true;
+}
+
+void WindowModificationState::DrawMenu()
+{
+	m_text.SetContent("Move the window or resize it, this text should change !\nM for Menu");
+}

tests/Engine/Utility/EventHandler/WindowModificationState.hpp

@@ -0,0 +1,31 @@
+#ifndef __WINDOWMODIFICATIONSTATE_HPP__
+#define __WINDOWMODIFICATIONSTATE_HPP__
+
+#include "Text.hpp"
+
+#include <Nazara/Utility/EventHandler.hpp>
+
+#include <NDK/State.hpp>
+
+class StateContext;
+
+class WindowModificationState : public Ndk::State
+{
+	public:
+		WindowModificationState(StateContext& stateContext);
+
+		void Enter(Ndk::StateMachine& fsm) override;
+		void Leave(Ndk::StateMachine& fsm) override;
+		bool Update(Ndk::StateMachine& fsm, float elapsedTime) override;
+
+	private:
+		void DrawMenu();
+
+		StateContext& m_context;
+		Text m_text;
+		NazaraSlot(Nz::EventHandler, OnKeyPressed, m_keyPressedSlot);
+		NazaraSlot(Nz::EventHandler, OnMoved, m_movedSlot);
+		NazaraSlot(Nz::EventHandler, OnResized, m_resizedSlot);
+};
+
+#endif // __WINDOWMODIFICATIONSTATE_HPP__