Merge pull request #40 from Gawaboumga/NDK

Ndk: Update
Former-commit-id: ba98b0e1b29d43111cbb21987f7c14385cfed4ed

build/scripts/modules/core.lua

@@ -15,3 +15,8 @@ MODULE.OsFiles.Posix = {
 	"../src/Nazara/Core/Posix/**.hpp",
 	"../src/Nazara/Core/Posix/**.cpp"
 }
+
+MODULE.OsLibraries.Posix = {
+	"dl",
+	"pthread"
+}

build/scripts/modules/renderer.lua

@@ -24,3 +24,8 @@ MODULE.OsLibraries.Windows = {
 	"opengl32",
 	"winmm"
 }
+
+MODULE.OsLibraries.Posix = {
+	"GL",
+	"X11"
+}

build/scripts/modules/utility.lua

@@ -20,3 +20,13 @@ MODULE.OsLibraries.Windows = {
 	"gdi32"
 }
 
+MODULE.OsLibraries.Posix = {
+	"X11",
+	"xcb",
+	"xcb-cursor",
+	"xcb-ewmh",
+	"xcb-icccm",
+	"xcb-keysyms",
+	"xcb-randr"
+}
+

include/Nazara/Prerequesites.hpp

@@ -116,6 +116,7 @@
 	#endif
 #elif defined(__linux__) || defined(__unix__)
 	#define NAZARA_PLATFORM_LINUX
+	#define NAZARA_PLATFORM_GLX
 	#define NAZARA_PLATFORM_POSIX
 	#define NAZARA_PLATFORM_X11
 

include/Nazara/Renderer/OpenGL.hpp

@@ -21,10 +21,10 @@
 #include <GL3/glext.h>
 #if defined(NAZARA_PLATFORM_WINDOWS)
 	#include <GL3/wglext.h>
-#elif defined(NAZARA_PLATFORM_LINUX)
+#elif defined(NAZARA_PLATFORM_GLX)
 namespace GLX
 {
-	#include <GL3/glx.h>
+	#include <GL/glx.h> // Defined in a namespace to avoid conflict
 }
 	#include <GL3/glxext.h>
 #endif
@@ -329,7 +329,7 @@ NAZARA_RENDERER_API extern PFNWGLCREATECONTEXTATTRIBSARBPROC wglCreateContextAtt
 NAZARA_RENDERER_API extern PFNWGLGETEXTENSIONSSTRINGARBPROC  wglGetExtensionsStringARB;
 NAZARA_RENDERER_API extern PFNWGLGETEXTENSIONSSTRINGEXTPROC  wglGetExtensionsStringEXT;
 NAZARA_RENDERER_API extern PFNWGLSWAPINTERVALEXTPROC         wglSwapInterval;
-#elif defined(NAZARA_PLATFORM_LINUX)
+#elif defined(NAZARA_PLATFORM_GLX)
 NAZARA_RENDERER_API extern GLX::PFNGLXCREATECONTEXTATTRIBSARBPROC glXCreateContextAttribs;
 NAZARA_RENDERER_API extern GLX::PFNGLXSWAPINTERVALEXTPROC         glXSwapIntervalEXT;
 NAZARA_RENDERER_API extern GLX::PFNGLXSWAPINTERVALMESAPROC        NzglXSwapIntervalMESA;

include/Nazara/Utility/WindowHandle.hpp

@@ -8,14 +8,16 @@
 #define NAZARA_WINDOWHANDLE_HPP
 
 #include <Nazara/Prerequesites.hpp>
+#if defined(NAZARA_PLATFORM_X11)
+#include <xcb/xcb.h>
+#endif
 
 namespace Nz
 {
 	#if defined(NAZARA_PLATFORM_WINDOWS)
 	// http://msdn.microsoft.com/en-us/library/aa383751(v=vs.85).aspx
 	typedef void* WindowHandle;
-	#elif defined(NAZARA_PLATFORM_LINUX)
+	#elif defined(NAZARA_PLATFORM_X11)
-	#include <xcb/xcb.h>
 	// http://en.wikipedia.org/wiki/Xlib#Data_types
 	using WindowHandle = xcb_window_t;
 	#else

src/Nazara/Audio/Debug/NewOverload.cpp

@@ -10,22 +10,22 @@
 
 void* operator new(std::size_t size)
 {
-	return NzMemoryManager::Allocate(size, false);
+	return Nz::MemoryManager::Allocate(size, false);
 }
 
 void* operator new[](std::size_t size)
 {
-	return NzMemoryManager::Allocate(size, true);
+	return Nz::MemoryManager::Allocate(size, true);
 }
 
 void operator delete(void* pointer) noexcept
 {
-	NzMemoryManager::Free(pointer, false);
+	Nz::MemoryManager::Free(pointer, false);
 }
 
 void operator delete[](void* pointer) noexcept
 {
-	NzMemoryManager::Free(pointer, true);
+	Nz::MemoryManager::Free(pointer, true);
 }
 
 #endif // NAZARA_AUDIO_MANAGE_MEMORY

src/Nazara/Core/Posix/ClockImpl.cpp

@@ -8,21 +8,24 @@
 #include <sys/time.h>
 #include <Nazara/Core/Debug.hpp>
 
-bool NzClockImplInitializeHighPrecision()
+namespace Nz
 {
+	bool ClockImplInitializeHighPrecision()
+	{
 		return true; // No initialization needed
-}
+	}
 
-nzUInt64 NzClockImplGetMicroseconds()
+	UInt64 ClockImplGetElapsedMicroseconds()
-{
+	{
 		timeval clock;
 		gettimeofday(&clock, nullptr);
-	return static_cast<nzUInt64>(clock.tv_sec*1000000 + clock.tv_usec);
+		return static_cast<UInt64>(clock.tv_sec*1000000 + clock.tv_usec);
-}
+	}
 
-nzUInt64 NzClockImplGetMilliseconds()
+	UInt64 ClockImplGetElapsedMilliseconds()
-{
+	{
 		timeval clock;
 		gettimeofday(&clock, nullptr);
-	return static_cast<nzUInt64>(clock.tv_sec*1000 + (clock.tv_usec/1000));
+		return static_cast<UInt64>(clock.tv_sec*1000 + (clock.tv_usec/1000));
+	}
 }

src/Nazara/Core/Posix/ClockImpl.hpp

@@ -9,8 +9,11 @@
 
 #include <Nazara/Prerequesites.hpp>
 
-bool NzClockImplInitializeHighPrecision();
+namespace Nz
-nzUInt64 NzClockImplGetMicroseconds();
+{
-nzUInt64 NzClockImplGetMilliseconds();
+	bool ClockImplInitializeHighPrecision();
+	UInt64 ClockImplGetElapsedMicroseconds();
+	UInt64 ClockImplGetElapsedMilliseconds();
+}
 
 #endif // NAZARA_CLOCKIMPL_POSIX_HPP

src/Nazara/Core/Posix/ConditionVariableImpl.cpp

@@ -6,33 +6,35 @@
 #include <Nazara/Core/Posix/MutexImpl.hpp>
 #include <Nazara/Core/Debug.hpp>
 
-NzConditionVariableImpl::NzConditionVariableImpl()
+namespace Nz
 {
+	ConditionVariableImpl::ConditionVariableImpl()
+	{
 		pthread_cond_init(&m_cv, nullptr);
-}
+	}
 
-NzConditionVariableImpl::~NzConditionVariableImpl()
+	ConditionVariableImpl::~ConditionVariableImpl()
-{
+	{
 		pthread_cond_destroy(&m_cv);
-}
+	}
 
-void NzConditionVariableImpl::Signal()
+	void ConditionVariableImpl::Signal()
-{
+	{
 		pthread_cond_signal(&m_cv);
-}
+	}
 
-void NzConditionVariableImpl::SignalAll()
+	void ConditionVariableImpl::SignalAll()
-{
+	{
 		pthread_cond_broadcast(&m_cv);
-}
+	}
 
-void NzConditionVariableImpl::Wait(NzMutexImpl* mutex)
+	void ConditionVariableImpl::Wait(MutexImpl* mutex)
-{
+	{
 		pthread_cond_wait(&m_cv, &mutex->m_handle);
-}
+	}
 
-bool NzConditionVariableImpl::Wait(NzMutexImpl* mutex, nzUInt32 timeout)
+	bool ConditionVariableImpl::Wait(MutexImpl* mutex, UInt32 timeout)
-{
+	{
 		// get the current time
 		timeval tv;
 		gettimeofday(&tv, nullptr);
@@ -44,4 +46,5 @@ bool NzConditionVariableImpl::Wait(NzMutexImpl* mutex, nzUInt32 timeout)
 		ti.tv_nsec %= 1000000000;
 
 		return pthread_cond_timedwait(&m_cv,&mutex->m_handle, &ti) != 0;
+	}
 }

src/Nazara/Core/Posix/ConditionVariableImpl.hpp

@@ -14,22 +14,25 @@
 #include <unistd.h>
 #include <sys/time.h>
 
-class NzMutexImpl;
+namespace Nz
-
-class NzConditionVariableImpl
 {
+	class MutexImpl;
+
+	class ConditionVariableImpl
+	{
 		public:
-		NzConditionVariableImpl();
+			ConditionVariableImpl();
-		~NzConditionVariableImpl();
+			~ConditionVariableImpl();
 
 			void Signal();
 			void SignalAll();
 
-		void Wait(NzMutexImpl* mutex);
+			void Wait(MutexImpl* mutex);
-		bool Wait(NzMutexImpl* mutex, nzUInt32 timeout);
+			bool Wait(MutexImpl* mutex, UInt32 timeout);
 
 		private:
 			pthread_cond_t m_cv;
-};
+	};
+}
 
 #endif // NAZARA_CONDITIONVARIABLEIMPL_HPP

src/Nazara/Core/Posix/DirectoryImpl.cpp

@@ -9,95 +9,98 @@
 #include <errno.h>
 #include <sys/param.h>
 
-NzDirectoryImpl::NzDirectoryImpl(const NzDirectory* parent)
+namespace Nz
 {
+	DirectoryImpl::DirectoryImpl(const Directory* parent)
+	{
 		NazaraUnused(parent);
-}
+	}
 
-void NzDirectoryImpl::Close()
+	void DirectoryImpl::Close()
-{
+	{
 		closedir(m_handle);
-}
+	}
 
-NzString NzDirectoryImpl::GetResultName() const
+	String DirectoryImpl::GetResultName() const
-{
+	{
 		return m_result->d_name;
-}
+	}
 
-nzUInt64 NzDirectoryImpl::GetResultSize() const
+	UInt64 DirectoryImpl::GetResultSize() const
-{
+	{
 		struct stat64 resulststat;
 		stat64(m_result->d_name, &resulststat);
 
-	return static_cast<nzUInt64>(resulststat.st_size);
+		return static_cast<UInt64>(resulststat.st_size);
-}
+	}
 
-bool NzDirectoryImpl::IsResultDirectory() const
+	bool DirectoryImpl::IsResultDirectory() const
-{
+	{
 		struct stat64 filestats;
 		if (stat64(m_result->d_name, &filestats) == -1) // error
 			return false;
 
 		return S_ISDIR(filestats.st_mode);
-}
+	}
 
-bool NzDirectoryImpl::NextResult()
+	bool DirectoryImpl::NextResult()
-{
+	{
 		if ((m_result = readdir64(m_handle)))
 			return true;
 		else
 		{
 			if (errno != ENOENT)
-			NazaraError("Unable to get next result: " + NzError::GetLastSystemError());
+				NazaraError("Unable to get next result: " + Error::GetLastSystemError());
 
 			return false;
 		}
-}
+	}
 
-bool NzDirectoryImpl::Open(const NzString& dirPath)
+	bool DirectoryImpl::Open(const String& dirPath)
-{
+	{
 		m_handle = opendir(dirPath.GetConstBuffer());
 		if (!m_handle)
 		{
-		NazaraError("Unable to open directory: " + NzError::GetLastSystemError());
+			NazaraError("Unable to open directory: " + Error::GetLastSystemError());
 			return false;
 		}
 
 		return true;
-}
+	}
 
-bool NzDirectoryImpl::Create(const NzString& dirPath)
+	bool DirectoryImpl::Create(const String& dirPath)
-{
+	{
 		mode_t permissions; // TODO: check permissions
 
 		return mkdir(dirPath.GetConstBuffer(), permissions) != -1;;
-}
+	}
 
-bool NzDirectoryImpl::Exists(const NzString& dirPath)
+	bool DirectoryImpl::Exists(const String& dirPath)
-{
+	{
 		struct stat64 filestats;
 		if (stat64(dirPath.GetConstBuffer(), &filestats) == -1) // error
 			return false;
 
 		return S_ISDIR(filestats.st_mode) || S_ISREG(filestats.st_mode);
-}
+	}
 
-NzString NzDirectoryImpl::GetCurrent()
+	String DirectoryImpl::GetCurrent()
-{
+	{
-	NzString currentPath;
+		String currentPath;
 
 		char path[MAXPATHLEN];
 		if (getcwd(path, MAXPATHLEN))
 			currentPath = path;
 		else
-		NazaraError("Unable to get current directory: " + NzError::GetLastSystemError()); // Bug: initialisation -> if no path for log !
+			NazaraError("Unable to get current directory: " + Error::GetLastSystemError()); // Bug: initialisation -> if no path for log !
 
 		return currentPath;
-}
+	}
 
-bool NzDirectoryImpl::Remove(const NzString& dirPath)
+	bool DirectoryImpl::Remove(const String& dirPath)
-{
+	{
 		bool success = rmdir(dirPath.GetConstBuffer()) != -1;
 
 		return success;
+	}
 }

src/Nazara/Core/Posix/DirectoryImpl.hpp

@@ -8,40 +8,47 @@
 #define NAZARA_DIRECTORYIMPL_HPP
 
 #include <Nazara/Prerequesites.hpp>
-#include <Nazara/Core/NonCopyable.hpp>
 #include <dirent.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 
-class NzDirectory;
+namespace Nz
-class NzString;
-
-class NzDirectoryImpl : NzNonCopyable
 {
+	class Directory;
+	class String;
+
+	class DirectoryImpl
+	{
 		public:
-		NzDirectoryImpl(const NzDirectory* parent);
+			DirectoryImpl(const Directory* parent);
-		~NzDirectoryImpl() = default;
+			DirectoryImpl(const DirectoryImpl&) = delete;
+			DirectoryImpl(DirectoryImpl&&) = delete; ///TODO
+			~DirectoryImpl() = default;
 
 			void Close();
 
-		NzString GetResultName() const;
+			String GetResultName() const;
-		nzUInt64 GetResultSize() const;
+			UInt64 GetResultSize() const;
 
 			bool IsResultDirectory() const;
 
 			bool NextResult();
 
-		bool Open(const NzString& dirPath);
+			bool Open(const String& dirPath);
 
-		static bool Create(const NzString& dirPath);
+			DirectoryImpl& operator=(const DirectoryImpl&) = delete;
-		static bool Exists(const NzString& dirPath);
+			DirectoryImpl& operator=(DirectoryImpl&&) = delete; ///TODO
-		static NzString GetCurrent();
+
-		static bool Remove(const NzString& dirPath);
+			static bool Create(const String& dirPath);
+			static bool Exists(const String& dirPath);
+			static String GetCurrent();
+			static bool Remove(const String& dirPath);
 
 		private:
 			DIR* m_handle;
 			dirent64* m_result;
-};
+	};
+}
 
 #endif // NAZARA_DIRECTORYIMPL_HPP

src/Nazara/Core/Posix/DynLibImpl.cpp

@@ -8,13 +8,15 @@
 #include <Nazara/Core/String.hpp>
 #include <Nazara/Core/Debug.hpp>
 
-NzDynLibImpl::NzDynLibImpl(NzDynLib* parent)
+namespace Nz
 {
+	DynLibImpl::DynLibImpl(DynLib* parent)
+	{
 		NazaraUnused(parent);
-}
+	}
 
-NzDynLibFunc NzDynLibImpl::GetSymbol(const NzString& symbol, NzString* errorMessage) const
+	DynLibFunc DynLibImpl::GetSymbol(const String& symbol, String* errorMessage) const
-{
+	{
 		/*
 			Il n'est pas standard de cast un pointeur d'objet vers un pointeur de fonction.
 			Nous devons donc utiliser des techniques diaboliques venant du malin lui-même.. :D
@@ -23,7 +25,7 @@ NzDynLibFunc NzDynLibImpl::GetSymbol(const NzString& symbol, NzString* errorMess
 		*/
 		union
 		{
-		NzDynLibFunc func;
+			DynLibFunc func;
 			void* pointer;
 		} converter;
 
@@ -34,14 +36,14 @@ NzDynLibFunc NzDynLibImpl::GetSymbol(const NzString& symbol, NzString* errorMess
 			*errorMessage = dlerror();
 
 		return converter.func;
-}
+	}
 
-bool NzDynLibImpl::Load(const NzString& libraryPath, NzString* errorMessage)
+	bool DynLibImpl::Load(const String& libraryPath, String* errorMessage)
-{
+	{
-	NzString path = libraryPath;
+		String path = libraryPath;
 
 		unsigned int pos = path.FindLast(".so");
-	if (pos == NzString::npos || (path.GetLength() > pos+3 && path[pos+3] != '.'))
+		if (pos == String::npos || (path.GetLength() > pos+3 && path[pos+3] != '.'))
 			path += ".so";
 
 		dlerror(); // Clear error flag
@@ -54,9 +56,10 @@ bool NzDynLibImpl::Load(const NzString& libraryPath, NzString* errorMessage)
 			*errorMessage = dlerror();
 			return false;
 		}
-}
+	}
 
-void NzDynLibImpl::Unload()
+	void DynLibImpl::Unload()
-{
+	{
 		dlclose(m_handle);
+	}
 }

src/Nazara/Core/Posix/DynLibImpl.hpp

@@ -8,23 +8,25 @@
 #define NAZARA_DYNLIBIMPL_HPP
 
 #include <Nazara/Core/DynLib.hpp>
-#include <Nazara/Core/NonCopyable.hpp>
 #include <dlfcn.h>
 
-class NzString;
+namespace Nz
-
-class NzDynLibImpl : NzNonCopyable
 {
-	public:
+	class String;
-		NzDynLibImpl(NzDynLib* m_parent);
-		~NzDynLibImpl() = default;
 
-		NzDynLibFunc GetSymbol(const NzString& symbol, NzString* errorMessage) const;
+	class DynLibImpl
-		bool Load(const NzString& libraryPath, NzString* errorMessage);
+	{
+		public:
+			DynLibImpl(DynLib* m_parent);
+			~DynLibImpl() = default;
+
+			DynLibFunc GetSymbol(const String& symbol, String* errorMessage) const;
+			bool Load(const String& libraryPath, String* errorMessage);
 			void Unload();
 
 		private:
 			void* m_handle;
-};
+	};
+}
 
 #endif // NAZARA_DYNLIBIMPL_HPP

src/Nazara/Core/Posix/FileImpl.cpp

@@ -7,85 +7,87 @@
 #include <cstdio>
 #include <Nazara/Core/Debug.hpp>
 
-NzFileImpl::NzFileImpl(const NzFile* parent) :
+namespace Nz
-m_endOfFile(false),
-m_endOfFileUpdated(true)
 {
+	FileImpl::FileImpl(const File* parent) :
+	m_endOfFile(false),
+	m_endOfFileUpdated(true)
+	{
 		NazaraUnused(parent);
-}
+	}
 
-void NzFileImpl::Close()
+	void FileImpl::Close()
-{
+	{
 		close(m_fileDescriptor);
-}
+	}
 
-bool NzFileImpl::EndOfFile() const
+	bool FileImpl::EndOfFile() const
-{
+	{
 		if (!m_endOfFileUpdated)
 		{
 			struct stat64 fileSize;
 			if (fstat64(m_fileDescriptor, &fileSize) == -1)
 				fileSize.st_size = 0;
 
-		m_endOfFile = (GetCursorPos() >= static_cast<nzUInt64>(fileSize.st_size));
+			m_endOfFile = (GetCursorPos() >= static_cast<UInt64>(fileSize.st_size));
 			m_endOfFileUpdated = true;
 		}
 
 		return m_endOfFile;
-}
+	}
 
-void NzFileImpl::Flush()
+	void FileImpl::Flush()
-{
+	{
 		if (fsync(m_fileDescriptor) == -1)
-		NazaraError("Unable to flush file: " + NzError::GetLastSystemError());
+			NazaraError("Unable to flush file: " + Error::GetLastSystemError());
-}
+	}
 
-nzUInt64 NzFileImpl::GetCursorPos() const
+	UInt64 FileImpl::GetCursorPos() const
-{
+	{
 		off64_t position = lseek64(m_fileDescriptor, 0, SEEK_CUR);
-	return static_cast<nzUInt64>(position);
+		return static_cast<UInt64>(position);
-}
+	}
 
-bool NzFileImpl::Open(const NzString& filePath, unsigned int mode)
+	bool FileImpl::Open(const String& filePath, unsigned int mode)
-{
+	{
 		int flags;
 		mode_t permissions = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
 
-	if (mode & nzOpenMode_ReadOnly)
+		if (mode & OpenMode_ReadOnly)
 			flags = O_RDONLY;
-	else if (mode & nzOpenMode_ReadWrite)
+		else if (mode & OpenMode_ReadWrite)
 		{
 			flags = O_CREAT | O_RDWR;
 
-		if (mode & nzOpenMode_Append)
+			if (mode & OpenMode_Append)
 				flags |= O_APPEND;
 
-		if (mode & nzOpenMode_Truncate)
+			if (mode & OpenMode_Truncate)
 				flags |= O_TRUNC;
 		}
-	else if (mode & nzOpenMode_WriteOnly)
+		else if (mode & OpenMode_WriteOnly)
 		{
 			flags = O_CREAT | O_WRONLY;
 
-		if (mode & nzOpenMode_Append)
+			if (mode & OpenMode_Append)
 				flags |= O_APPEND;
 
-		if (mode & nzOpenMode_Truncate)
+			if (mode & OpenMode_Truncate)
 				flags |= O_TRUNC;
 		}
 		else
 			return false;
 
-///TODO: lock
+	///TODO: lock
-//	if ((mode & nzOpenMode_Lock) == 0)
+	//	if ((mode & OpenMode_Lock) == 0)
-//		shareMode |= FILE_SHARE_WRITE;
+	//		shareMode |= FILE_SHARE_WRITE;
 
 		m_fileDescriptor = open64(filePath.GetConstBuffer(), flags, permissions);
 		return m_fileDescriptor != -1;
-}
+	}
 
-std::size_t NzFileImpl::Read(void* buffer, std::size_t size)
+	std::size_t FileImpl::Read(void* buffer, std::size_t size)
-{
+	{
 		ssize_t bytes;
 		if ((bytes = read(m_fileDescriptor, buffer, size)) != -1)
 		{
@@ -96,37 +98,37 @@ std::size_t NzFileImpl::Read(void* buffer, std::size_t size)
 		}
 		else
 			return 0;
-}
+	}
 
-bool NzFileImpl::SetCursorPos(nzCursorPosition pos, nzInt64 offset)
+	bool FileImpl::SetCursorPos(CursorPosition pos, Int64 offset)
-{
+	{
 		int moveMethod;
 		switch (pos)
 		{
-		case nzCursorPosition_AtBegin:
+			case CursorPosition_AtBegin:
 				moveMethod = SEEK_SET;
 				break;
 
-		case nzCursorPosition_AtCurrent:
+			case CursorPosition_AtCurrent:
 				moveMethod = SEEK_CUR;
 				break;
 
-		case nzCursorPosition_AtEnd:
+			case CursorPosition_AtEnd:
 				moveMethod = SEEK_END;
 				break;
 
 			default:
-			NazaraInternalError("Cursor position not handled (0x" + NzString::Number(pos, 16) + ')');
+				NazaraInternalError("Cursor position not handled (0x" + String::Number(pos, 16) + ')');
 				return false;
 		}
 
 		m_endOfFileUpdated = false;
 
 		return lseek64(m_fileDescriptor, offset, moveMethod) != -1;
-}
+	}
 
-std::size_t NzFileImpl::Write(const void* buffer, std::size_t size)
+	std::size_t FileImpl::Write(const void* buffer, std::size_t size)
-{
+	{
 		lockf64(m_fileDescriptor, F_LOCK, size);
 		ssize_t written = write(m_fileDescriptor, buffer, size);
 		lockf64(m_fileDescriptor, F_ULOCK, size);
@@ -134,14 +136,14 @@ std::size_t NzFileImpl::Write(const void* buffer, std::size_t size)
 		m_endOfFileUpdated = false;
 
 		return written;
-}
+	}
 
-bool NzFileImpl::Copy(const NzString& sourcePath, const NzString& targetPath)
+	bool FileImpl::Copy(const String& sourcePath, const String& targetPath)
-{
+	{
 		int fd1 = open64(sourcePath.GetConstBuffer(), O_RDONLY);
 		if (fd1 == -1)
 		{
-		NazaraError("Fail to open input file (" + sourcePath + "): " + NzError::GetLastSystemError());
+			NazaraError("Fail to open input file (" + sourcePath + "): " + Error::GetLastSystemError());
 			return false;
 		}
 
@@ -149,7 +151,7 @@ bool NzFileImpl::Copy(const NzString& sourcePath, const NzString& targetPath)
 		int fd2 = open64(targetPath.GetConstBuffer(), O_WRONLY | O_TRUNC, permissions);
 		if (fd2 == -1)
 		{
-		NazaraError("Fail to open output file (" + targetPath + "): " + NzError::GetLastSystemError()); // TODO: more info ?
+			NazaraError("Fail to open output file (" + targetPath + "): " + Error::GetLastSystemError()); // TODO: more info ?
 			close(fd1);
 			return false;
 		}
@@ -163,7 +165,7 @@ bool NzFileImpl::Copy(const NzString& sourcePath, const NzString& targetPath)
 			{
 				close(fd1);
 				close(fd2);
-			NazaraError("An error occured from copy : " + NzError::GetLastSystemError());
+				NazaraError("An error occured from copy : " + Error::GetLastSystemError());
 				return false;
 			}
 			write(fd2,buffer,bytes);
@@ -173,70 +175,71 @@ bool NzFileImpl::Copy(const NzString& sourcePath, const NzString& targetPath)
 		close(fd1);
 		close(fd2);
 		return true;
-}
+	}
 
-bool NzFileImpl::Delete(const NzString& filePath)
+	bool FileImpl::Delete(const String& filePath)
-{
+	{
 		bool success = unlink(filePath.GetConstBuffer()) != -1;
 
 		if (success)
 			return true;
 		else
 		{
-		NazaraError("Failed to delete file (" + filePath + "): " + NzError::GetLastSystemError());
+			NazaraError("Failed to delete file (" + filePath + "): " + Error::GetLastSystemError());
 			return false;
 		}
-}
+	}
 
-bool NzFileImpl::Exists(const NzString& filePath)
+	bool FileImpl::Exists(const String& filePath)
-{
+	{
 		const char* path = filePath.GetConstBuffer();
 		if (access(path, F_OK) != -1)
 			return true;
 
 		return false;
-}
+	}
 
-time_t NzFileImpl::GetCreationTime(const NzString& filePath)
+	time_t FileImpl::GetCreationTime(const String& filePath)
-{
+	{
 		NazaraWarning("Posix has no creation time information");
 
 		return 0;
-}
+	}
 
-time_t NzFileImpl::GetLastAccessTime(const NzString& filePath)
+	time_t FileImpl::GetLastAccessTime(const String& filePath)
-{
+	{
 		struct stat64 stats;
 		stat64(filePath.GetConstBuffer(), &stats);
 
 		return stats.st_atime;
-}
+	}
 
-time_t NzFileImpl::GetLastWriteTime(const NzString& filePath)
+	time_t FileImpl::GetLastWriteTime(const String& filePath)
-{
+	{
 		struct stat64 stats;
 		stat64(filePath.GetConstBuffer(), &stats);
 
 		return stats.st_mtime;
-}
+	}
 
-nzUInt64 NzFileImpl::GetSize(const NzString& filePath)
+	UInt64 FileImpl::GetSize(const String& filePath)
-{
+	{
 		struct stat64 stats;
 		stat64(filePath.GetConstBuffer(), &stats);
 
-	return static_cast<nzUInt64>(stats.st_size);
+		return static_cast<UInt64>(stats.st_size);
-}
+	}
 
-bool NzFileImpl::Rename(const NzString& sourcePath, const NzString& targetPath)
+	bool FileImpl::Rename(const String& sourcePath, const String& targetPath)
-{
+	{
 		bool success = std::rename(sourcePath.GetConstBuffer(), targetPath.GetConstBuffer()) != -1;
 
 		if (success)
 			return true;
 		else
 		{
-		NazaraError("Unable to rename file: " + NzError::GetLastSystemError());
+			NazaraError("Unable to rename file: " + Error::GetLastSystemError());
 			return false;
 		}
+	}
 }

src/Nazara/Core/Posix/FileImpl.hpp

@@ -13,44 +13,51 @@
 
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Core/File.hpp>
-#include <Nazara/Core/NonCopyable.hpp>
 #include <ctime>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 
-class NzFile;
+namespace Nz
-class NzString;
-
-class NzFileImpl : NzNonCopyable
 {
+	class File;
+	class String;
+
+	class FileImpl
+	{
 		public:
-		NzFileImpl(const NzFile* parent);
+			FileImpl(const File* parent);
-		~NzFileImpl() = default;
+			FileImpl(const FileImpl&) = delete;
+			FileImpl(FileImpl&&) = delete; ///TODO
+			~FileImpl() = default;
 
 			void Close();
 			bool EndOfFile() const;
 			void Flush();
-		nzUInt64 GetCursorPos() const;
+			UInt64 GetCursorPos() const;
-		bool Open(const NzString& filePath, unsigned int mode);
+			bool Open(const String& filePath, unsigned int mode);
 			std::size_t Read(void* buffer, std::size_t size);
-		bool SetCursorPos(nzCursorPosition pos, nzInt64 offset);
+			bool SetCursorPos(CursorPosition pos, Int64 offset);
 			std::size_t Write(const void* buffer, std::size_t size);
 
-		static bool Copy(const NzString& sourcePath, const NzString& targetPath);
+			FileImpl& operator=(const FileImpl&) = delete;
-		static bool Delete(const NzString& filePath);
+			FileImpl& operator=(FileImpl&&) = delete; ///TODO
-		static bool Exists(const NzString& filePath);
+
-		static time_t GetCreationTime(const NzString& filePath);
+			static bool Copy(const String& sourcePath, const String& targetPath);
-		static time_t GetLastAccessTime(const NzString& filePath);
+			static bool Delete(const String& filePath);
-		static time_t GetLastWriteTime(const NzString& filePath);
+			static bool Exists(const String& filePath);
-		static nzUInt64 GetSize(const NzString& filePath);
+			static time_t GetCreationTime(const String& filePath);
-		static bool Rename(const NzString& sourcePath, const NzString& targetPath);
+			static time_t GetLastAccessTime(const String& filePath);
+			static time_t GetLastWriteTime(const String& filePath);
+			static UInt64 GetSize(const String& filePath);
+			static bool Rename(const String& sourcePath, const String& targetPath);
 
 		private:
 			int m_fileDescriptor;
 			mutable bool m_endOfFile;
 			mutable bool m_endOfFileUpdated;
-};
+	};
+}
 
 #endif // NAZARA_FILEIMPL_HPP

src/Nazara/Core/Posix/HardwareInfoImpl.cpp

@@ -6,37 +6,39 @@
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Core/Debug.hpp>
 
-void NzHardwareInfoImpl::Cpuid(nzUInt32 functionId, nzUInt32 subFunctionId, nzUInt32 registers[4])
+namespace Nz
 {
-#if defined(NAZARA_COMPILER_CLANG) || defined(NAZARA_COMPILER_GCC) || defined(NAZARA_COMPILER_INTEL)
+	void HardwareInfoImpl::Cpuid(UInt32 functionId, UInt32 subFunctionId, UInt32 registers[4])
+	{
+	#if defined(NAZARA_COMPILER_CLANG) || defined(NAZARA_COMPILER_GCC) || defined(NAZARA_COMPILER_INTEL)
 		// Source: http://stackoverflow.com/questions/1666093/cpuid-implementations-in-c
 		asm volatile ("cpuid" // Besoin d'être volatile ?
 					  : "=a" (registers[0]), "=b" (registers[1]), "=c" (registers[2]), "=d" (registers[3]) // output
 					  : "a" (functionId), "c" (subFunctionId));                                // input
-#else
+	#else
 		NazaraInternalError("Cpuid has been called although it is not supported");
-#endif
+	#endif
-}
+	}
 
-unsigned int NzHardwareInfoImpl::GetProcessorCount()
+	unsigned int HardwareInfoImpl::GetProcessorCount()
-{
+	{
 		// Plus simple (et plus portable) que de passer par le CPUID
 		return sysconf(_SC_NPROCESSORS_CONF);
-}
+	}
 
-nzUInt64 NzHardwareInfoImpl::GetTotalMemory()
+	UInt64 HardwareInfoImpl::GetTotalMemory()
-{
+	{
-	nzUInt64 pages = sysconf(_SC_PHYS_PAGES);
+		UInt64 pages = sysconf(_SC_PHYS_PAGES);
-	nzUInt64 page_size = sysconf(_SC_PAGE_SIZE);
+		UInt64 page_size = sysconf(_SC_PAGE_SIZE);
 
 		return pages * page_size;
-}
+	}
 
-bool NzHardwareInfoImpl::IsCpuidSupported()
+	bool HardwareInfoImpl::IsCpuidSupported()
-{
+	{
-#ifdef NAZARA_PLATFORM_x64
+	#ifdef NAZARA_PLATFORM_x64
 		return true; // Toujours supporté sur un processeur 64 bits
-#else
+	#else
 		#if defined(NAZARA_COMPILER_CLANG) || defined(NAZARA_COMPILER_GCC) || defined(NAZARA_COMPILER_INTEL)
 		int supported;
 		asm volatile ("	pushfl\n"
@@ -59,5 +61,6 @@ bool NzHardwareInfoImpl::IsCpuidSupported()
 		#else
 		return false;
 		#endif
-#endif
+	#endif
+	}
 }

src/Nazara/Core/Posix/HardwareInfoImpl.hpp

@@ -10,13 +10,16 @@
 #include <Nazara/Prerequesites.hpp>
 #include <unistd.h>
 
-class NzHardwareInfoImpl
+namespace Nz
 {
+	class HardwareInfoImpl
+	{
 		public:
-		static void Cpuid(nzUInt32 functionId, nzUInt32 subFunctionId, nzUInt32 registers[4]);
+			static void Cpuid(UInt32 functionId, UInt32 subFunctionId, UInt32 registers[4]);
 			static unsigned int GetProcessorCount();
-		static nzUInt64 GetTotalMemory();
+			static UInt64 GetTotalMemory();
 			static bool IsCpuidSupported();
-};
+	};
+}
 
 #endif // NAZARA_HARDWAREINFOIMPL_POSIX_HPP

src/Nazara/Core/Posix/MutexImpl.cpp

@@ -5,31 +5,34 @@
 #include <Nazara/Core/Posix/MutexImpl.hpp>
 #include <Nazara/Core/Debug.hpp>
 
-NzMutexImpl::NzMutexImpl()
+namespace Nz
 {
+	MutexImpl::MutexImpl()
+	{
 		pthread_mutexattr_t attr;
 		pthread_mutexattr_init(&attr);
 		pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
 
 		pthread_mutex_init(&m_handle, &attr);
-}
+	}
 
-NzMutexImpl::~NzMutexImpl()
+	MutexImpl::~MutexImpl()
-{
+	{
 		pthread_mutex_destroy(&m_handle);
-}
+	}
 
-void NzMutexImpl::Lock()
+	void MutexImpl::Lock()
-{
+	{
 		pthread_mutex_lock(&m_handle);
-}
+	}
 
-bool NzMutexImpl::TryLock()
+	bool MutexImpl::TryLock()
-{
+	{
 		return pthread_mutex_trylock(&m_handle) == 0;
-}
+	}
 
-void NzMutexImpl::Unlock()
+	void MutexImpl::Unlock()
-{
+	{
 		pthread_mutex_unlock(&m_handle);
+	}
 }

src/Nazara/Core/Posix/MutexImpl.hpp

@@ -9,13 +9,15 @@
 
 #include <pthread.h>
 
-class NzMutexImpl
+namespace Nz
 {
-	friend class NzConditionVariableImpl;
+	class MutexImpl
+	{
+		friend class ConditionVariableImpl;
 
 		public:
-		NzMutexImpl();
+			MutexImpl();
-		~NzMutexImpl();
+			~MutexImpl();
 
 			void Lock();
 			bool TryLock();
@@ -23,6 +25,7 @@ class NzMutexImpl
 
 		private:
 			pthread_mutex_t m_handle;
-};
+	};
+}
 
 #endif // NAZARA_MUTEXIMPL_HPP

src/Nazara/Core/Posix/SemaphoreImpl.cpp

@@ -9,46 +9,48 @@
 #include <sys/time.h>
 #include <Nazara/Core/Debug.hpp>
 
-NzSemaphoreImpl::NzSemaphoreImpl(unsigned int count)
+namespace Nz
 {
+	SemaphoreImpl::SemaphoreImpl(unsigned int count)
+	{
 		if(sem_init(&m_semaphore, 0, count) != 0)
-		NazaraError("Failed to create semaphore: " + NzError::GetLastSystemError());
+			NazaraError("Failed to create semaphore: " + Error::GetLastSystemError());
-}
+	}
 
-NzSemaphoreImpl::~NzSemaphoreImpl()
+	SemaphoreImpl::~SemaphoreImpl()
-{
+	{
 		sem_destroy(&m_semaphore);
-}
+	}
 
-unsigned int NzSemaphoreImpl::GetCount() const
+	unsigned int SemaphoreImpl::GetCount() const
-{
+	{
 		int count=0;
 		sem_getvalue(const_cast<sem_t*>(&m_semaphore), &count);
 		return static_cast<unsigned int>(count);
-}
+	}
 
-void NzSemaphoreImpl::Post()
+	void SemaphoreImpl::Post()
-{
+	{
 		#if NAZARA_CORE_SAFE
 		if (sem_post(&m_semaphore)==-1)
-		NazaraError("Failed to release semaphore: " + NzError::GetLastSystemError());
+			NazaraError("Failed to release semaphore: " + Error::GetLastSystemError());
 		#else
 		sem_post(&m_semaphore);
 		#endif
-}
+	}
 
-void NzSemaphoreImpl::Wait()
+	void SemaphoreImpl::Wait()
-{
+	{
 		#if NAZARA_CORE_SAFE
 		if (sem_wait(&m_semaphore) == -1 )
-		NazaraError("Failed to wait for semaphore: " + NzError::GetLastSystemError());
+			NazaraError("Failed to wait for semaphore: " + Error::GetLastSystemError());
 		#else
 		sem_wait(&m_semaphore);
 		#endif
-}
+	}
 
-bool NzSemaphoreImpl::Wait(nzUInt32 timeout)
+	bool SemaphoreImpl::Wait(UInt32 timeout)
-{
+	{
 		timeval tv;
 		gettimeofday(&tv, nullptr);
 
@@ -60,7 +62,7 @@ bool NzSemaphoreImpl::Wait(nzUInt32 timeout)
 		#if NAZARA_CORE_SAFE
 		if (sem_timedwait(&m_semaphore, &ti) != 0)
 		{
-		NazaraError("Failed to wait for semaphore: " + NzError::GetLastSystemError());
+			NazaraError("Failed to wait for semaphore: " + Error::GetLastSystemError());
 			return false;
 		}
 
@@ -68,4 +70,5 @@ bool NzSemaphoreImpl::Wait(nzUInt32 timeout)
 		#else
 			return sem_timedwait(&m_semaphore, &ti) != 0;
 		#endif
+	}
 }

src/Nazara/Core/Posix/SemaphoreImpl.hpp

@@ -10,19 +10,22 @@
 #include <Nazara/Prerequesites.hpp>
 #include <semaphore.h>
 
-class NzSemaphoreImpl
+namespace Nz
 {
+	class SemaphoreImpl
+	{
 		public:
-		NzSemaphoreImpl(unsigned int count);
+			SemaphoreImpl(unsigned int count);
-		~NzSemaphoreImpl();
+			~SemaphoreImpl();
 
 			unsigned int GetCount() const;
 			void Post();
 			void Wait();
-		bool Wait(nzUInt32 timeout);
+			bool Wait(UInt32 timeout);
 
 		private:
 			sem_t m_semaphore;
-};
+	};
+}
 
 #endif // NAZARA_SEMAPHOREIMPL_HPP

src/Nazara/Core/Posix/TaskSchedulerImpl.cpp

@@ -7,8 +7,10 @@
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Core/Debug.hpp>
 
-bool NzTaskSchedulerImpl::Initialize(unsigned int workerCount)
+namespace Nz
 {
+	bool TaskSchedulerImpl::Initialize(unsigned int workerCount)
+	{
 		if (IsInitialized())
 			return true; // Déjà initialisé
 
@@ -42,15 +44,15 @@ bool NzTaskSchedulerImpl::Initialize(unsigned int workerCount)
 		pthread_barrier_wait(&s_barrier); // On attend que les enfants soient bien créés.
 
 		return true;
-}
+	}
 
-bool NzTaskSchedulerImpl::IsInitialized()
+	bool TaskSchedulerImpl::IsInitialized()
-{
+	{
 		return s_workerCount > 0;
-}
+	}
 
-void NzTaskSchedulerImpl::Run(NzFunctor** tasks, unsigned int count)
+	void TaskSchedulerImpl::Run(Functor** tasks, unsigned int count)
-{
+	{
 		// On s'assure que des tâches ne sont pas déjà en cours
 		Wait();
 
@@ -62,10 +64,10 @@ void NzTaskSchedulerImpl::Run(NzFunctor** tasks, unsigned int count)
 
 		pthread_cond_signal(&s_cvNotEmpty);
 		pthread_mutex_unlock(&s_mutexQueue);
-}
+	}
 
-void NzTaskSchedulerImpl::Uninitialize()
+	void TaskSchedulerImpl::Uninitialize()
-{
+	{
 		#ifdef NAZARA_CORE_SAFE
 		if (s_workerCount == 0)
 		{
@@ -77,7 +79,7 @@ void NzTaskSchedulerImpl::Uninitialize()
 		// On réveille les threads pour qu'ils sortent de la boucle et terminent.
 		pthread_mutex_lock(&s_mutexQueue);
 		// On commence par vider la queue et demander qu'ils s'arrêtent.
-	std::queue<NzFunctor*> emptyQueue;
+		std::queue<Functor*> emptyQueue;
 		std::swap(s_tasks, emptyQueue);
 		s_shouldFinish = true;
 		pthread_cond_broadcast(&s_cvNotEmpty);
@@ -94,10 +96,10 @@ void NzTaskSchedulerImpl::Uninitialize()
 		pthread_mutex_destroy(&s_mutexQueue);
 
 		s_workerCount = 0;
-}
+	}
 
-void NzTaskSchedulerImpl::WaitForTasks()
+	void TaskSchedulerImpl::WaitForTasks()
-{
+	{
 		#ifdef NAZARA_CORE_SAFE
 		if (s_workerCount == 0)
 		{
@@ -107,11 +109,11 @@ void NzTaskSchedulerImpl::WaitForTasks()
 		#endif
 
 		Wait();
-}
+	}
 
-NzFunctor* NzTaskSchedulerImpl::PopQueue()
+	Functor* TaskSchedulerImpl::PopQueue()
-{
+	{
-	NzFunctor* task = nullptr;
+		Functor* task = nullptr;
 
 		pthread_mutex_lock(&s_mutexQueue);
 
@@ -124,10 +126,10 @@ NzFunctor* NzTaskSchedulerImpl::PopQueue()
 		pthread_mutex_unlock(&s_mutexQueue);
 
 		return task;
-}
+	}
 
-void NzTaskSchedulerImpl::Wait()
+	void TaskSchedulerImpl::Wait()
-{
+	{
 		if (s_isDone)
 			return;
 
@@ -138,17 +140,17 @@ void NzTaskSchedulerImpl::Wait()
 		pthread_mutex_unlock(&s_mutexQueue);
 
 		s_isDone = true;
-}
+	}
 
-void* NzTaskSchedulerImpl::WorkerProc(void* /*userdata*/)
+	void* TaskSchedulerImpl::WorkerProc(void* /*userdata*/)
-{
+	{
 		// On s'assure que tous les threads soient correctement lancés.
 		pthread_barrier_wait(&s_barrier);
 
 		// On quitte s'il doit terminer.
 		while (!s_shouldFinish)
 		{
-		NzFunctor* task = PopQueue();
+			Functor* task = PopQueue();
 
 			if (task)
 			{
@@ -177,16 +179,17 @@ void* NzTaskSchedulerImpl::WorkerProc(void* /*userdata*/)
 		}
 
 		return nullptr;
+	}
+
+	std::queue<Functor*> TaskSchedulerImpl::s_tasks;
+	std::unique_ptr<pthread_t[]> TaskSchedulerImpl::s_threads;
+	std::atomic<bool> TaskSchedulerImpl::s_isDone;
+	std::atomic<bool> TaskSchedulerImpl::s_isWaiting;
+	std::atomic<bool> TaskSchedulerImpl::s_shouldFinish;
+	unsigned int TaskSchedulerImpl::s_workerCount;
+
+	pthread_mutex_t TaskSchedulerImpl::s_mutexQueue;
+	pthread_cond_t TaskSchedulerImpl::s_cvEmpty;
+	pthread_cond_t TaskSchedulerImpl::s_cvNotEmpty;
+	pthread_barrier_t TaskSchedulerImpl::s_barrier;
 }
-
-std::queue<NzFunctor*> NzTaskSchedulerImpl::s_tasks;
-std::unique_ptr<pthread_t[]> NzTaskSchedulerImpl::s_threads;
-std::atomic<bool> NzTaskSchedulerImpl::s_isDone;
-std::atomic<bool> NzTaskSchedulerImpl::s_isWaiting;
-std::atomic<bool> NzTaskSchedulerImpl::s_shouldFinish;
-unsigned int NzTaskSchedulerImpl::s_workerCount;
-
-pthread_mutex_t NzTaskSchedulerImpl::s_mutexQueue;
-pthread_cond_t NzTaskSchedulerImpl::s_cvEmpty;
-pthread_cond_t NzTaskSchedulerImpl::s_cvNotEmpty;
-pthread_barrier_t NzTaskSchedulerImpl::s_barrier;

src/Nazara/Core/Posix/TaskSchedulerImpl.hpp

@@ -14,24 +14,26 @@
 #include <pthread.h>
 #include <queue>
 
-class NzTaskSchedulerImpl
+namespace Nz
 {
+	class TaskSchedulerImpl
+	{
 		public:
-		NzTaskSchedulerImpl() = delete;
+			TaskSchedulerImpl() = delete;
-		~NzTaskSchedulerImpl() = delete;
+			~TaskSchedulerImpl() = delete;
 
 			static bool Initialize(unsigned int workerCount);
 			static bool IsInitialized();
-		static void Run(NzFunctor** tasks, unsigned int count);
+			static void Run(Functor** tasks, unsigned int count);
 			static void Uninitialize();
 			static void WaitForTasks();
 
 		private:
-		static NzFunctor* PopQueue();
+			static Functor* PopQueue();
 			static void Wait();
 			static void* WorkerProc(void* userdata);
 
-		static std::queue<NzFunctor*> s_tasks;
+			static std::queue<Functor*> s_tasks;
 			static std::unique_ptr<pthread_t[]> s_threads;
 			static std::atomic<bool> s_isDone;
 			static std::atomic<bool> s_isWaiting;
@@ -42,6 +44,7 @@ class NzTaskSchedulerImpl
 			static pthread_cond_t s_cvEmpty;
 			static pthread_cond_t s_cvNotEmpty;
 			static pthread_barrier_t s_barrier;
-};
+	};
+}
 
 #endif // NAZARA_TASKSCHEDULERIMPL_HPP

src/Nazara/Core/Posix/ThreadImpl.cpp

@@ -9,34 +9,36 @@
 #include <sys/time.h>
 #include <Nazara/Core/Debug.hpp>
 
-NzThreadImpl::NzThreadImpl(NzFunctor* functor)
+namespace Nz
 {
-    int error = pthread_create(&m_handle, nullptr, &NzThreadImpl::ThreadProc, functor);
+	ThreadImpl::ThreadImpl(Functor* functor)
+	{
+		int error = pthread_create(&m_handle, nullptr, &ThreadImpl::ThreadProc, functor);
 		if (error != 0)
-		NazaraInternalError("Failed to create thread: " + NzError::GetLastSystemError());
+			NazaraInternalError("Failed to create thread: " + Error::GetLastSystemError());
-}
+	}
 
-void NzThreadImpl::Detach()
+	void ThreadImpl::Detach()
-{
+	{
 		pthread_detach(m_handle);
-}
+	}
 
-void NzThreadImpl::Join()
+	void ThreadImpl::Join()
-{
+	{
 		pthread_join(m_handle, nullptr);
-}
+	}
 
-void* NzThreadImpl::ThreadProc(void* userdata)
+	void* ThreadImpl::ThreadProc(void* userdata)
-{
+	{
-	NzFunctor* func = static_cast<NzFunctor*>(userdata);
+		Functor* func = static_cast<Functor*>(userdata);
 		func->Run();
 		delete func;
 
 		return nullptr;
-}
+	}
 
-void NzThreadImpl::Sleep(nzUInt32 time)
+	void ThreadImpl::Sleep(UInt32 time)
-{
+	{
 		// code from SFML2 Unix SleepImpl.cpp source https://github.com/LaurentGomila/SFML/blob/master/src/SFML/System/Unix/SleepImpl.cpp
 
 		// usleep is not reliable enough (it might block the
@@ -69,4 +71,5 @@ void NzThreadImpl::Sleep(nzUInt32 time)
 		// destroy the mutex and condition
 		pthread_cond_destroy(&condition);
 		pthread_mutex_destroy(&mutex);
+	}
 }

src/Nazara/Core/Posix/ThreadImpl.hpp

@@ -10,22 +10,25 @@
 #include <Nazara/Prerequesites.hpp>
 #include <pthread.h>
 
-struct NzFunctor;
+namespace Nz
-
-class NzThreadImpl
 {
+	struct Functor;
+
+	class ThreadImpl
+	{
 		public:
-		NzThreadImpl(NzFunctor* threadFunc);
+			ThreadImpl(Functor* threadFunc);
 
 			void Detach();
 			void Join();
 
-		static void Sleep(nzUInt32 time);
+			static void Sleep(UInt32 time);
 
 		private:
 			static void* ThreadProc(void* userdata);
 
 			pthread_t m_handle;
-};
+	};
+}
 
 #endif // NAZARA_THREADIMPL_HPP

src/Nazara/Graphics/Debug/NewOverload.cpp

@@ -10,22 +10,22 @@
 
 void* operator new(std::size_t size)
 {
-	return NzMemoryManager::Allocate(size, false);
+	return Nz::MemoryManager::Allocate(size, false);
 }
 
 void* operator new[](std::size_t size)
 {
-	return NzMemoryManager::Allocate(size, true);
+	return Nz::MemoryManager::Allocate(size, true);
 }
 
 void operator delete(void* pointer) noexcept
 {
-	NzMemoryManager::Free(pointer, false);
+	Nz::MemoryManager::Free(pointer, false);
 }
 
 void operator delete[](void* pointer) noexcept
 {
-	NzMemoryManager::Free(pointer, true);
+	Nz::MemoryManager::Free(pointer, true);
 }
 
 #endif // NAZARA_GRAPHICS_MANAGE_MEMORY

src/Nazara/Graphics/ForwardRenderTechnique.cpp

@@ -689,7 +689,7 @@ namespace Nz
 				// On envoie les lumières directionnelles s'il y a (Les mêmes pour tous)
 				if (shaderUniforms->hasLightUniforms)
 				{
-					lightCount = std::min(m_renderQueue.directionalLights.size(), NazaraSuffixMacro(NAZARA_GRAPHICS_MAX_LIGHT_PER_PASS, U));
+					lightCount = std::min(m_renderQueue.directionalLights.size(), static_cast<decltype(m_renderQueue.directionalLights.size())>(NAZARA_GRAPHICS_MAX_LIGHT_PER_PASS));
 
 					for (unsigned int i = 0; i < lightCount; ++i)
 						SendLightUniforms(shader, shaderUniforms->lightUniforms, i, shaderUniforms->lightOffset * i);

src/Nazara/Lua/Debug/NewOverload.cpp

@@ -10,22 +10,22 @@
 
 void* operator new(std::size_t size)
 {
-	return NzMemoryManager::Allocate(size, false);
+	return Nz::MemoryManager::Allocate(size, false);
 }
 
 void* operator new[](std::size_t size)
 {
-	return NzMemoryManager::Allocate(size, true);
+	return Nz::MemoryManager::Allocate(size, true);
 }
 
 void operator delete(void* pointer) noexcept
 {
-	NzMemoryManager::Free(pointer, false);
+	Nz::MemoryManager::Free(pointer, false);
 }
 
 void operator delete[](void* pointer) noexcept
 {
-	NzMemoryManager::Free(pointer, true);
+	Nz::MemoryManager::Free(pointer, true);
 }
 
 #endif // NAZARA_LUA_MANAGE_MEMORY

src/Nazara/Noise/Debug/NewOverload.cpp

@@ -10,22 +10,22 @@
 
 void* operator new(std::size_t size)
 {
-	return NzMemoryManager::Allocate(size, false);
+	return Nz::MemoryManager::Allocate(size, false);
 }
 
 void* operator new[](std::size_t size)
 {
-	return NzMemoryManager::Allocate(size, true);
+	return Nz::MemoryManager::Allocate(size, true);
 }
 
 void operator delete(void* pointer) noexcept
 {
-	NzMemoryManager::Free(pointer, false);
+	Nz::MemoryManager::Free(pointer, false);
 }
 
 void operator delete[](void* pointer) noexcept
 {
-	NzMemoryManager::Free(pointer, true);
+	Nz::MemoryManager::Free(pointer, true);
 }
 
 #endif // NAZARA_NOISE_MANAGE_MEMORY

src/Nazara/Physics/Debug/NewOverload.cpp

@@ -10,22 +10,22 @@
 
 void* operator new(std::size_t size)
 {
-	return NzMemoryManager::Allocate(size, false);
+	return Nz::MemoryManager::Allocate(size, false);
 }
 
 void* operator new[](std::size_t size)
 {
-	return NzMemoryManager::Allocate(size, true);
+	return Nz::MemoryManager::Allocate(size, true);
 }
 
 void operator delete(void* pointer) noexcept
 {
-	NzMemoryManager::Free(pointer, false);
+	Nz::MemoryManager::Free(pointer, false);
 }
 
 void operator delete[](void* pointer) noexcept
 {
-	NzMemoryManager::Free(pointer, true);
+	Nz::MemoryManager::Free(pointer, true);
 }
 
 #endif // NAZARA_PHYSICS_MANAGE_MEMORY

src/Nazara/Renderer/Context.cpp

@@ -14,7 +14,7 @@
 
 #if defined(NAZARA_PLATFORM_WINDOWS)
 	#include <Nazara/Renderer/Win32/ContextImpl.hpp>
-#elif defined(NAZARA_PLATFORM_LINUX)
+#elif defined(NAZARA_PLATFORM_GLX)
 	#include <Nazara/Renderer/GLX/ContextImpl.hpp>
 	#define CALLBACK
 #else

src/Nazara/Renderer/Debug/NewOverload.cpp

@@ -10,22 +10,22 @@
 
 void* operator new(std::size_t size)
 {
-	return NzMemoryManager::Allocate(size, false);
+	return Nz::MemoryManager::Allocate(size, false);
 }
 
 void* operator new[](std::size_t size)
 {
-	return NzMemoryManager::Allocate(size, true);
+	return Nz::MemoryManager::Allocate(size, true);
 }
 
 void operator delete(void* pointer) noexcept
 {
-	NzMemoryManager::Free(pointer, false);
+	Nz::MemoryManager::Free(pointer, false);
 }
 
 void operator delete[](void* pointer) noexcept
 {
-	NzMemoryManager::Free(pointer, true);
+	Nz::MemoryManager::Free(pointer, true);
 }
 
 #endif // NAZARA_RENDERER_MANAGE_MEMORY

src/Nazara/Renderer/GLX/ContextImpl.cpp

@@ -12,8 +12,10 @@
 
 using namespace GLX;
 
-namespace
+namespace Nz
 {
+	namespace
+	{
 		Display* m_display;
 		int m_sharedDisplay = 0;
 
@@ -23,22 +25,22 @@ namespace
 			ctxErrorOccurred = true;
 			return 0;
 		}
-}
+	}
 
-NzContextImpl::NzContextImpl() :
+	ContextImpl::ContextImpl() :
-m_colormap(0),
+	m_colormap(0),
-m_context(0),
+	m_context(0),
-m_window(0),
+	m_window(0),
-m_ownsWindow(false)
+	m_ownsWindow(false)
-{
+	{
 		if (m_sharedDisplay == 0)
 			m_display = XOpenDisplay(nullptr);
 
 		++m_sharedDisplay;
-}
+	}
 
-NzContextImpl::~NzContextImpl()
+	ContextImpl::~ContextImpl()
-{
+	{
 		Destroy();
 
 		if (--m_sharedDisplay == 0)
@@ -46,17 +48,17 @@ NzContextImpl::~NzContextImpl()
 			XCloseDisplay(m_display);
 			m_display = nullptr;
 		}
-}
+	}
 
-bool NzContextImpl::Activate()
+	bool ContextImpl::Activate()
-{
+	{
 		return glXMakeCurrent(m_display, m_window, m_context) == true;
-}
+	}
 
-bool NzContextImpl::Create(NzContextParameters& parameters)
+	bool ContextImpl::Create(ContextParameters& parameters)
-{
+	{
 		// En cas d'exception, la ressource sera quand même libérée
-	NzCallOnExit onExit([this] ()
+		CallOnExit onExit([this] ()
 		{
 			Destroy();
 		});
@@ -249,10 +251,10 @@ bool NzContextImpl::Create(NzContextParameters& parameters)
 		onExit.Reset();
 
 		return true;
-}
+	}
 
-void NzContextImpl::Destroy()
+	void ContextImpl::Destroy()
-{
+	{
 		// Destroy the context
 		if (m_context)
 		{
@@ -271,10 +273,10 @@ void NzContextImpl::Destroy()
 			m_window = 0;
 			XFlush(m_display);
 		}
-}
+	}
 
-void NzContextImpl::EnableVerticalSync(bool enabled)
+	void ContextImpl::EnableVerticalSync(bool enabled)
-{
+	{
 		if (glXSwapIntervalEXT)
 			glXSwapIntervalEXT(m_display, glXGetCurrentDrawable(), enabled ? 1 : 0);
 		else if (NzglXSwapIntervalMESA)
@@ -283,15 +285,16 @@ void NzContextImpl::EnableVerticalSync(bool enabled)
 			glXSwapIntervalSGI(enabled ? 1 : 0);
 		else
 			NazaraError("Vertical sync not supported");
-}
+	}
 
-void NzContextImpl::SwapBuffers()
+	void ContextImpl::SwapBuffers()
-{
+	{
 		if (m_window)
 			glXSwapBuffers(m_display, m_window);
-}
+	}
 
-bool NzContextImpl::Desactivate()
+	bool ContextImpl::Desactivate()
-{
+	{
 		return glXMakeCurrent(m_display, None, nullptr) == true;
+	}
 }

src/Nazara/Renderer/GLX/ContextImpl.hpp

@@ -9,17 +9,19 @@
 
 #include <Nazara/Renderer/OpenGL.hpp>
 
-class NzContextParameters;
+namespace Nz
-
-class NzContextImpl
 {
+	class ContextParameters;
+
+	class ContextImpl
+	{
 		public:
-		NzContextImpl();
+			ContextImpl();
-		~NzContextImpl();
+			~ContextImpl();
 
 			bool Activate();
 
-		bool Create(NzContextParameters& parameters);
+			bool Create(ContextParameters& parameters);
 
 			void Destroy();
 
@@ -34,6 +36,7 @@ class NzContextImpl
 			GLX::GLXContext m_context;
 			GLX::Window m_window;
 			bool m_ownsWindow;
-};
+	};
+}
 
 #endif // NAZARA_CONTEXTIMPL_HPP

src/Nazara/Renderer/OpenGL.cpp

@@ -9,6 +9,9 @@
 #include <Nazara/Math/Algorithm.hpp>
 #include <Nazara/Renderer/Context.hpp>
 #include <Nazara/Renderer/RenderTarget.hpp>
+#if defined(NAZARA_PLATFORM_GLX)
+#include <Nazara/Utility/X11/Display.hpp>
+#endif // NAZARA_PLATFORM_GLX
 #include <cstring>
 #include <set>
 #include <sstream>
@@ -30,7 +33,7 @@ namespace Nz
 			OpenGLFunc entry = reinterpret_cast<OpenGLFunc>(wglGetProcAddress(name));
 			if (!entry) // wglGetProcAddress ne fonctionne pas sur les fonctions OpenGL <= 1.1
 				entry = reinterpret_cast<OpenGLFunc>(GetProcAddress(openGLlibrary, name));
-			#elif defined(NAZARA_PLATFORM_LINUX)
+			#elif defined(NAZARA_PLATFORM_GLX)
 			OpenGLFunc entry = reinterpret_cast<OpenGLFunc>(GLX::glXGetProcAddress(reinterpret_cast<const unsigned char*>(name)));
 			#else
 			#error OS not handled
@@ -716,6 +719,15 @@ namespace Nz
 		if (s_initialized)
 			return true;
 
+		#if defined(NAZARA_PLATFORM_GLX)
+		Initializer<X11> display;
+		if (!display)
+		{
+			NazaraError("Failed to load display library");
+			return false;
+		}
+		#endif
+
 		if (!LoadLibrary())
 		{
 			NazaraError("Failed to load OpenGL library");
@@ -1004,7 +1016,7 @@ namespace Nz
 		wglGetExtensionsStringARB = reinterpret_cast<PFNWGLGETEXTENSIONSSTRINGARBPROC>(LoadEntry("wglGetExtensionsStringARB", false));
 		wglGetExtensionsStringEXT = reinterpret_cast<PFNWGLGETEXTENSIONSSTRINGEXTPROC>(LoadEntry("wglGetExtensionsStringEXT", false));
 		wglSwapInterval = reinterpret_cast<PFNWGLSWAPINTERVALEXTPROC>(LoadEntry("wglSwapIntervalEXT", false));
-		#elif defined(NAZARA_PLATFORM_LINUX)
+		#elif defined(NAZARA_PLATFORM_GLX)
 		glXSwapIntervalEXT = reinterpret_cast<GLX::PFNGLXSWAPINTERVALEXTPROC>(LoadEntry("glXSwapIntervalEXT", false));
 		NzglXSwapIntervalMESA = reinterpret_cast<GLX::PFNGLXSWAPINTERVALMESAPROC>(LoadEntry("glXSwapIntervalMESA", false));
 		glXSwapIntervalSGI = reinterpret_cast<GLX::PFNGLXSWAPINTERVALSGIPROC>(LoadEntry("glXSwapIntervalSGI", false));
@@ -2242,7 +2254,7 @@ PFNWGLCREATECONTEXTATTRIBSARBPROC wglCreateContextAttribs    = nullptr;
 PFNWGLGETEXTENSIONSSTRINGARBPROC  wglGetExtensionsStringARB  = nullptr;
 PFNWGLGETEXTENSIONSSTRINGEXTPROC  wglGetExtensionsStringEXT  = nullptr;
 PFNWGLSWAPINTERVALEXTPROC         wglSwapInterval            = nullptr;
-#elif defined(NAZARA_PLATFORM_LINUX)
+#elif defined(NAZARA_PLATFORM_GLX)
 GLX::PFNGLXCREATECONTEXTATTRIBSARBPROC glXCreateContextAttribs = nullptr;
 GLX::PFNGLXSWAPINTERVALEXTPROC         glXSwapIntervalEXT      = nullptr;
 GLX::PFNGLXSWAPINTERVALMESAPROC        NzglXSwapIntervalMESA   = nullptr;

src/Nazara/Utility/Debug/NewOverload.cpp

@@ -10,22 +10,22 @@
 
 void* operator new(std::size_t size)
 {
-	return NzMemoryManager::Allocate(size, false);
+	return Nz::MemoryManager::Allocate(size, false);
 }
 
 void* operator new[](std::size_t size)
 {
-	return NzMemoryManager::Allocate(size, true);
+	return Nz::MemoryManager::Allocate(size, true);
 }
 
 void operator delete(void* pointer) noexcept
 {
-	NzMemoryManager::Free(pointer, false);
+	Nz::MemoryManager::Free(pointer, false);
 }
 
 void operator delete[](void* pointer) noexcept
 {
-	NzMemoryManager::Free(pointer, true);
+	Nz::MemoryManager::Free(pointer, true);
 }
 
 #endif // NAZARA_UTILITY_MANAGE_MEMORY

src/Nazara/Utility/X11/CursorImpl.cpp

@@ -12,10 +12,12 @@
 #include <xcb/xcb_renderutil.h>
 #include <Nazara/Utility/Debug.hpp>
 
-bool NzCursorImpl::Create(const NzImage& cursor, int hotSpotX, int hotSpotY)
+namespace Nz
 {
-	NzImage cursorImage(cursor); // Vive le COW
+	bool CursorImpl::Create(const Image& cursor, int hotSpotX, int hotSpotY)
-	if (!cursorImage.Convert(nzPixelFormat_BGRA8))
+	{
+		Image cursorImage(cursor); // Vive le COW
+		if (!cursorImage.Convert(Nz::PixelFormatType_BGRA8))
 		{
 			NazaraError("Failed to convert cursor to BGRA8");
 			return false;
@@ -24,12 +26,12 @@ bool NzCursorImpl::Create(const NzImage& cursor, int hotSpotX, int hotSpotY)
 		auto width = cursorImage.GetWidth();
 		auto height = cursorImage.GetHeight();
 
-	NzScopedXCBConnection connection;
+		ScopedXCBConnection connection;
 
 		xcb_screen_t* screen = X11::XCBDefaultScreen(connection);
 
-	NzScopedXCB<xcb_generic_error_t> error(nullptr);
+		ScopedXCB<xcb_generic_error_t> error(nullptr);
-	NzScopedXCB<xcb_render_query_pict_formats_reply_t> formatsReply = xcb_render_query_pict_formats_reply(
+		ScopedXCB<xcb_render_query_pict_formats_reply_t> formatsReply = xcb_render_query_pict_formats_reply(
 			connection,
 			xcb_render_query_pict_formats(connection),
 			&error);
@@ -79,13 +81,13 @@ bool NzCursorImpl::Create(const NzImage& cursor, int hotSpotX, int hotSpotY)
 
 		xcb_render_picture_t pic = XCB_NONE;
 
-	NzCallOnExit onExit([&](){
+		CallOnExit onExit([&](){
 			xcb_image_destroy(xi);
 			if (pic != XCB_NONE)
 				xcb_render_free_picture(connection, pic);
 		});
 
-	NzXCBPixmap pix(connection);
+		XCBPixmap pix(connection);
 		if (!pix.Create(32, screen->root, width, height))
 		{
 			NazaraError("Failed to create pixmap for cursor");
@@ -108,7 +110,7 @@ bool NzCursorImpl::Create(const NzImage& cursor, int hotSpotX, int hotSpotY)
 			return false;
 		}
 
-	NzXCBGContext gc(connection);
+		XCBGContext gc(connection);
 		if (!gc.Create(pix, 0, nullptr))
 		{
 			NazaraError("Failed to create gcontext for cursor");
@@ -145,17 +147,18 @@ bool NzCursorImpl::Create(const NzImage& cursor, int hotSpotX, int hotSpotY)
 		}
 
 		return true;
-}
+	}
 
-void NzCursorImpl::Destroy()
+	void CursorImpl::Destroy()
-{
+	{
-	NzScopedXCBConnection connection;
+		ScopedXCBConnection connection;
 
 		xcb_free_cursor(connection, m_cursor);
 		m_cursor = 0;
-}
+	}
 
-xcb_cursor_t NzCursorImpl::GetCursor()
+	xcb_cursor_t CursorImpl::GetCursor()
-{
+	{
 		return m_cursor;
+	}
 }

src/Nazara/Utility/X11/CursorImpl.hpp

@@ -7,20 +7,24 @@
 #ifndef NAZARA_CURSORIMPL_HPP
 #define NAZARA_CURSORIMPL_HPP
 
+#include <Nazara/Prerequesites.hpp>
 #include <xcb/xcb_cursor.h>
 
-class NzImage;
+namespace Nz
-
-class NzCursorImpl
 {
+	class Image;
+
+	class CursorImpl
+	{
 		public:
-		bool Create(const NzImage& image, int hotSpotX, int hotSpotY);
+			bool Create(const Image& image, int hotSpotX, int hotSpotY);
 			void Destroy();
 
 			xcb_cursor_t GetCursor();
 
 		private:
 			xcb_cursor_t m_cursor;
-};
+	};
+}
 
 #endif // NAZARA_CURSORIMPL_HPP

src/Nazara/Utility/X11/Display.cpp

@@ -4,32 +4,34 @@
 
 #include <Nazara/Utility/X11/Display.hpp>
 #include <Nazara/Core/Error.hpp>
+#include <Nazara/Core/Log.hpp>
+#include <Nazara/Core/String.hpp>
 #include <xcb/xcb_keysyms.h>
 #include <map>
 #include <Nazara/Utility/Debug.hpp>
 
-namespace
+namespace Nz
 {
+	namespace
+	{
 		// The shared display and its reference counter
 		xcb_connection_t* sharedConnection = nullptr;
 		int screen_nbr = 0;
 		unsigned int referenceCountConnection = 0;
 
-	xcb_key_symbols_t* sharedkeySymbol;
+		xcb_key_symbols_t* sharedkeySymbol = nullptr;
 		unsigned int referenceCountKeySymbol = 0;
 
-	xcb_ewmh_connection_t* sharedEwmhConnection;
+		xcb_ewmh_connection_t* sharedEwmhConnection = nullptr;
 		unsigned int referenceCountEwmhConnection = 0;
 
-	using AtomMap = std::map<std::string, xcb_atom_t>;
+		using AtomMap = std::map<String, xcb_atom_t>;
 		AtomMap atoms;
-}
+	}
 
-namespace X11
+	bool X11::CheckCookie(xcb_connection_t* connection, xcb_void_cookie_t cookie)
-{
-	bool CheckCookie(xcb_connection_t* connection, xcb_void_cookie_t cookie)
 	{
-		NzScopedXCB<xcb_generic_error_t> error(xcb_request_check(
+		ScopedXCB<xcb_generic_error_t> error(xcb_request_check(
 			connection,
 			cookie
 		));
@@ -40,36 +42,36 @@ namespace X11
 			return true;
 	}
 
-	void CloseConnection(xcb_connection_t* connection)
+	void X11::CloseConnection(xcb_connection_t* connection)
 	{
 		NazaraAssert(connection == sharedConnection, "The model is meant for one connection to X11 server");
 		--referenceCountConnection;
 	}
 
-	void CloseEWMHConnection(xcb_ewmh_connection_t* ewmh_connection)
+	void X11::CloseEWMHConnection(xcb_ewmh_connection_t* ewmh_connection)
 	{
 		NazaraAssert(ewmh_connection == sharedEwmhConnection, "The model is meant for one connection to X11 server");
 		--referenceCountEwmhConnection;
 	}
 
-	xcb_atom_t GetAtom(const std::string& name, bool onlyIfExists)
+	xcb_atom_t X11::GetAtom(const String& name, bool onlyIfExists)
 	{
 		AtomMap::const_iterator iter = atoms.find(name);
 
 		if (iter != atoms.end())
 			return iter->second;
 
-		NzScopedXCB<xcb_generic_error_t> error(nullptr);
+		ScopedXCB<xcb_generic_error_t> error(nullptr);
 
 		xcb_connection_t* connection = OpenConnection();
 
-		NzScopedXCB<xcb_intern_atom_reply_t> reply(xcb_intern_atom_reply(
+		ScopedXCB<xcb_intern_atom_reply_t> reply(xcb_intern_atom_reply(
 			connection,
 			xcb_intern_atom(
 				connection,
 				onlyIfExists,
-				name.size(),
+				name.GetSize(),
-				name.c_str()
+				name.GetConstBuffer()
 			),
 			&error
 		));
@@ -87,8 +89,16 @@ namespace X11
 		return reply->atom;
 	}
 
-	void Initialize()
+	bool X11::Initialize()
 	{
+		if (IsInitialized())
+		{
+			s_moduleReferenceCounter++;
+			return true; // Déjà initialisé
+		}
+
+		s_moduleReferenceCounter++;
+
 		NazaraAssert(referenceCountConnection == 0, "Initialize should be called before anything");
 		NazaraAssert(referenceCountKeySymbol == 0, "Initialize should be called before anything");
 		NazaraAssert(referenceCountEwmhConnection == 0, "Initialize should be called before anything");
@@ -125,9 +135,17 @@ namespace X11
 
 			OpenEWMHConnection(sharedConnection);
 		}
+
+		NazaraNotice("Initialized: Utility module");
+		return true;
 	}
 
-	xcb_key_symbols_t* XCBKeySymbolsAlloc(xcb_connection_t* connection)
+	bool X11::IsInitialized()
+	{
+		return s_moduleReferenceCounter != 0;
+	}
+
+	xcb_key_symbols_t* X11::XCBKeySymbolsAlloc(xcb_connection_t* connection)
 	{
 		NazaraAssert(connection == sharedConnection, "The model is meant for one connection to X11 server");
 
@@ -135,20 +153,20 @@ namespace X11
 		return sharedkeySymbol;
 	}
 
-	void XCBKeySymbolsFree(xcb_key_symbols_t* keySymbols)
+	void X11::XCBKeySymbolsFree(xcb_key_symbols_t* keySymbols)
 	{
 		NazaraAssert(keySymbols == sharedkeySymbol, "The model is meant for one connection to X11 server");
 
 		--referenceCountKeySymbol;
 	}
 
-	xcb_connection_t* OpenConnection()
+	xcb_connection_t* X11::OpenConnection()
 	{
 		++referenceCountConnection;
 		return sharedConnection;
 	}
 
-	xcb_ewmh_connection_t* OpenEWMHConnection(xcb_connection_t* connection)
+	xcb_ewmh_connection_t* X11::OpenEWMHConnection(xcb_connection_t* connection)
 	{
 		NazaraAssert(connection == sharedConnection, "The model is meant for one connection to X11 server");
 
@@ -156,8 +174,19 @@ namespace X11
 		return sharedEwmhConnection;
 	}
 
-	void Uninitialize()
+	void X11::Uninitialize()
 	{
+		if (s_moduleReferenceCounter != 1)
+		{
+			// Le module est soit encore utilisé, soit pas initialisé
+			if (s_moduleReferenceCounter > 1)
+				s_moduleReferenceCounter--;
+
+			return;
+		}
+
+		s_moduleReferenceCounter = 0;
+
 		{
 			NazaraAssert(referenceCountEwmhConnection == 1, "Uninitialize should be called after anything or a close is missing");
 			CloseEWMHConnection(sharedEwmhConnection);
@@ -179,9 +208,11 @@ namespace X11
 
 			xcb_disconnect(sharedConnection);
 		}
+
+		NazaraNotice("Uninitialized: Display module");
 	}
 
-	xcb_window_t XCBDefaultRootWindow(xcb_connection_t* connection)
+	xcb_window_t X11::XCBDefaultRootWindow(xcb_connection_t* connection)
 	{
 		NazaraAssert(connection == sharedConnection, "The model is meant for one connection to X11 server");
 		xcb_screen_t* screen = XCBDefaultScreen(connection);
@@ -190,19 +221,19 @@ namespace X11
 		return XCB_NONE;
 	}
 
-	xcb_screen_t* XCBDefaultScreen(xcb_connection_t* connection)
+	xcb_screen_t* X11::XCBDefaultScreen(xcb_connection_t* connection)
 	{
 		NazaraAssert(connection == sharedConnection, "The model is meant for one connection to X11 server");
 		return XCBScreenOfDisplay(connection, screen_nbr);
 	}
 
-	int XCBScreen(xcb_connection_t* connection)
+	int X11::XCBScreen(xcb_connection_t* connection)
 	{
 		NazaraAssert(connection == sharedConnection, "The model is meant for one connection to X11 server");
 		return screen_nbr;
 	}
 
-	xcb_screen_t* XCBScreenOfDisplay(xcb_connection_t* connection, int screen_nbr)
+	xcb_screen_t* X11::XCBScreenOfDisplay(xcb_connection_t* connection, int screen_nbr)
 	{
 		NazaraAssert(connection == sharedConnection, "The model is meant for one connection to X11 server");
 		xcb_screen_iterator_t iter = xcb_setup_roots_iterator(xcb_get_setup(connection));
@@ -215,4 +246,6 @@ namespace X11
 
 		return nullptr;
 	}
+
+	unsigned int X11::s_moduleReferenceCounter = 0;
 }

src/Nazara/Utility/X11/Display.hpp

@@ -7,35 +7,47 @@
 #ifndef NAZARA_X11DISPLAY_HPP
 #define NAZARA_X11DISPLAY_HPP
 
+#include <Nazara/Prerequesites.hpp>
 #include <Nazara/Utility/WindowHandle.hpp>
 #include <Nazara/Utility/X11/ScopedXCB.hpp>
-#include <xcb/xcb_ewmh.h>
-#include <string>
 
 typedef struct _XCBKeySymbols xcb_key_symbols_t;
 
-namespace X11
+namespace Nz
 {
-	bool CheckCookie(xcb_connection_t* connection, xcb_void_cookie_t cookie);
+	class String;
-	void CloseConnection(xcb_connection_t* connection);
-	void CloseEWMHConnection(xcb_ewmh_connection_t* ewmh_connection);
 
-	xcb_atom_t GetAtom(const std::string& name, bool onlyIfExists = false);
+	class X11
+	{
+		public:
+			X11() = delete;
+			~X11() = delete;
 
-	void Initialize();
+			static bool CheckCookie(xcb_connection_t* connection, xcb_void_cookie_t cookie);
+			static void CloseConnection(xcb_connection_t* connection);
+			static void CloseEWMHConnection(xcb_ewmh_connection_t* ewmh_connection);
 
-	xcb_key_symbols_t* XCBKeySymbolsAlloc(xcb_connection_t* connection);
+			static xcb_atom_t GetAtom(const String& name, bool onlyIfExists = false);
-	void XCBKeySymbolsFree(xcb_key_symbols_t* keySymbols);
 
-	xcb_connection_t* OpenConnection();
+			static bool Initialize();
-	xcb_ewmh_connection_t* OpenEWMHConnection(xcb_connection_t* connection);
+			static bool IsInitialized();
 
-	void Uninitialize();
+			static xcb_key_symbols_t* XCBKeySymbolsAlloc(xcb_connection_t* connection);
+			static void XCBKeySymbolsFree(xcb_key_symbols_t* keySymbols);
 
-	xcb_screen_t* XCBDefaultScreen(xcb_connection_t* connection);
+			static xcb_connection_t* OpenConnection();
-	xcb_window_t XCBDefaultRootWindow(xcb_connection_t* connection);
+			static xcb_ewmh_connection_t* OpenEWMHConnection(xcb_connection_t* connection);
-	int XCBScreen(xcb_connection_t* connection);
+
-	xcb_screen_t* XCBScreenOfDisplay(xcb_connection_t* connection, int screen_nbr);
+			static void Uninitialize();
+
+			static xcb_screen_t* XCBDefaultScreen(xcb_connection_t* connection);
+			static xcb_window_t XCBDefaultRootWindow(xcb_connection_t* connection);
+			static int XCBScreen(xcb_connection_t* connection);
+			static xcb_screen_t* XCBScreenOfDisplay(xcb_connection_t* connection, int screen_nbr);
+
+		private:
+			static unsigned int s_moduleReferenceCounter;
+	};
 }
 
 #endif // NAZARA_X11DISPLAY_HPP

src/Nazara/Utility/X11/IconImpl.cpp

@@ -10,18 +10,20 @@
 #include <Nazara/Utility/X11/Display.hpp>
 #include <Nazara/Utility/Debug.hpp>
 
-NzIconImpl::NzIconImpl()
+namespace Nz
 {
-	NzScopedXCBConnection connection;
+	IconImpl::IconImpl()
+	{
+		ScopedXCBConnection connection;
 
 		m_iconPixmap.Connect(connection);
 		m_maskPixmap.Connect(connection);
-}
+	}
 
-bool NzIconImpl::Create(const NzImage& icon)
+	bool IconImpl::Create(const Image& icon)
-{
+	{
-	NzImage iconImage(icon); // Vive le COW
+		Image iconImage(icon); // Vive le COW
-	if (!iconImage.Convert(nzPixelFormat_BGRA8))
+		if (!iconImage.Convert(Nz::PixelFormatType_BGRA8))
 		{
 			NazaraError("Failed to convert icon to BGRA8");
 			return false;
@@ -30,7 +32,7 @@ bool NzIconImpl::Create(const NzImage& icon)
 		auto width = iconImage.GetWidth();
 		auto height = iconImage.GetHeight();
 
-	NzScopedXCBConnection connection;
+		ScopedXCBConnection connection;
 
 		xcb_screen_t* screen = X11::XCBDefaultScreen(connection);
 
@@ -44,11 +46,11 @@ bool NzIconImpl::Create(const NzImage& icon)
 			return false;
 		}
 
-	NzCallOnExit onExit([this](){
+		CallOnExit onExit([this](){
 			Destroy();
 		});
 
-	NzXCBGContext iconGC(connection);
+		XCBGContext iconGC(connection);
 
 		if (!iconGC.Create(
 			m_iconPixmap,
@@ -82,7 +84,7 @@ bool NzIconImpl::Create(const NzImage& icon)
 
 		// Create the mask pixmap (must have 1 bit depth)
 		std::size_t pitch = (width + 7) / 8;
-	static std::vector<nzUInt8> maskPixels(pitch * height, 0);
+		static std::vector<UInt8> maskPixels(pitch * height, 0);
 		for (std::size_t j = 0; j < height; ++j)
 		{
 			for (std::size_t i = 0; i < pitch; ++i)
@@ -91,7 +93,7 @@ bool NzIconImpl::Create(const NzImage& icon)
 				{
 					if (i * 8 + k < width)
 					{
-					nzUInt8 opacity = (iconImage.GetConstPixels()[(i * 8 + k + j * width) * 4 + 3] > 0) ? 1 : 0;
+						UInt8 opacity = (iconImage.GetConstPixels()[(i * 8 + k + j * width) * 4 + 3] > 0) ? 1 : 0;
 						maskPixels[i + j * pitch] |= (opacity << k);
 					}
 				}
@@ -115,20 +117,21 @@ bool NzIconImpl::Create(const NzImage& icon)
 		onExit.Reset();
 
 		return true;
-}
+	}
 
-void NzIconImpl::Destroy()
+	void IconImpl::Destroy()
-{
+	{
 		m_iconPixmap.Destroy();
 		m_maskPixmap.Destroy();
-}
+	}
 
-xcb_pixmap_t NzIconImpl::GetIcon()
+	xcb_pixmap_t IconImpl::GetIcon()
-{
+	{
 		return m_iconPixmap;
-}
+	}
 
-xcb_pixmap_t NzIconImpl::GetMask()
+	xcb_pixmap_t IconImpl::GetMask()
-{
+	{
 		return m_maskPixmap;
+	}
 }

src/Nazara/Utility/X11/IconImpl.hpp

@@ -7,24 +7,28 @@
 #ifndef NAZARA_ICONIMPL_HPP
 #define NAZARA_ICONIMPL_HPP
 
+#include <Nazara/Prerequesites.hpp>
 #include <Nazara/Utility/X11/ScopedXCB.hpp>
 
-class NzImage;
+namespace Nz
-
-class NzIconImpl
 {
-	public:
+	class Image;
-		NzIconImpl();
 
-		bool Create(const NzImage& image);
+	class IconImpl
+	{
+		public:
+			IconImpl();
+
+			bool Create(const Image& image);
 			void Destroy();
 
 			xcb_pixmap_t GetIcon();
 			xcb_pixmap_t GetMask();
 
 		private:
-		NzXCBPixmap m_iconPixmap;
+			XCBPixmap m_iconPixmap;
-		NzXCBPixmap m_maskPixmap;
+			XCBPixmap m_maskPixmap;
-};
+	};
+}
 
 #endif // NAZARA_ICONIMPL_HPP

src/Nazara/Utility/X11/InputImpl.cpp

@@ -12,180 +12,181 @@
 #include <xcb/xcb_keysyms.h>
 #include <Nazara/Utility/Debug.hpp>
 
-namespace
+namespace Nz
 {
-
+	namespace
-	KeySym GetKeySym(NzKeyboard::Key key)
+	{
+		KeySym GetKeySym(Keyboard::Key key)
 		{
 			// X11 keysym correspondant
 			KeySym keysym = 0;
 			switch (key)
 			{
 				// Lettres
-			case NzKeyboard::A: keysym = XK_A; break;
+				case Keyboard::A: keysym = XK_A; break;
-			case NzKeyboard::B: keysym = XK_B; break;
+				case Keyboard::B: keysym = XK_B; break;
-			case NzKeyboard::C: keysym = XK_C; break;
+				case Keyboard::C: keysym = XK_C; break;
-			case NzKeyboard::D: keysym = XK_D; break;
+				case Keyboard::D: keysym = XK_D; break;
-			case NzKeyboard::E: keysym = XK_E; break;
+				case Keyboard::E: keysym = XK_E; break;
-			case NzKeyboard::F: keysym = XK_F; break;
+				case Keyboard::F: keysym = XK_F; break;
-			case NzKeyboard::G: keysym = XK_G; break;
+				case Keyboard::G: keysym = XK_G; break;
-			case NzKeyboard::H: keysym = XK_H; break;
+				case Keyboard::H: keysym = XK_H; break;
-			case NzKeyboard::I: keysym = XK_I; break;
+				case Keyboard::I: keysym = XK_I; break;
-			case NzKeyboard::J: keysym = XK_J; break;
+				case Keyboard::J: keysym = XK_J; break;
-			case NzKeyboard::K: keysym = XK_K; break;
+				case Keyboard::K: keysym = XK_K; break;
-			case NzKeyboard::L: keysym = XK_L; break;
+				case Keyboard::L: keysym = XK_L; break;
-			case NzKeyboard::M: keysym = XK_M; break;
+				case Keyboard::M: keysym = XK_M; break;
-			case NzKeyboard::N: keysym = XK_N; break;
+				case Keyboard::N: keysym = XK_N; break;
-			case NzKeyboard::O: keysym = XK_O; break;
+				case Keyboard::O: keysym = XK_O; break;
-			case NzKeyboard::P: keysym = XK_P; break;
+				case Keyboard::P: keysym = XK_P; break;
-			case NzKeyboard::Q: keysym = XK_Q; break;
+				case Keyboard::Q: keysym = XK_Q; break;
-			case NzKeyboard::R: keysym = XK_R; break;
+				case Keyboard::R: keysym = XK_R; break;
-			case NzKeyboard::S: keysym = XK_S; break;
+				case Keyboard::S: keysym = XK_S; break;
-			case NzKeyboard::T: keysym = XK_T; break;
+				case Keyboard::T: keysym = XK_T; break;
-			case NzKeyboard::U: keysym = XK_U; break;
+				case Keyboard::U: keysym = XK_U; break;
-			case NzKeyboard::V: keysym = XK_V; break;
+				case Keyboard::V: keysym = XK_V; break;
-			case NzKeyboard::W: keysym = XK_W; break;
+				case Keyboard::W: keysym = XK_W; break;
-			case NzKeyboard::X: keysym = XK_X; break;
+				case Keyboard::X: keysym = XK_X; break;
-			case NzKeyboard::Y: keysym = XK_Y; break;
+				case Keyboard::Y: keysym = XK_Y; break;
-			case NzKeyboard::Z: keysym = XK_Z; break;
+				case Keyboard::Z: keysym = XK_Z; break;
 
 				// Touches de fonction
-			case NzKeyboard::F1: keysym = XK_F1; break;
+				case Keyboard::F1: keysym = XK_F1; break;
-			case NzKeyboard::F2: keysym = XK_F2; break;
+				case Keyboard::F2: keysym = XK_F2; break;
-			case NzKeyboard::F3: keysym = XK_F3; break;
+				case Keyboard::F3: keysym = XK_F3; break;
-			case NzKeyboard::F4: keysym = XK_F4; break;
+				case Keyboard::F4: keysym = XK_F4; break;
-			case NzKeyboard::F5: keysym = XK_F5; break;
+				case Keyboard::F5: keysym = XK_F5; break;
-			case NzKeyboard::F6: keysym = XK_F6; break;
+				case Keyboard::F6: keysym = XK_F6; break;
-			case NzKeyboard::F7: keysym = XK_F7; break;
+				case Keyboard::F7: keysym = XK_F7; break;
-			case NzKeyboard::F8: keysym = XK_F8; break;
+				case Keyboard::F8: keysym = XK_F8; break;
-			case NzKeyboard::F9: keysym = XK_F9; break;
+				case Keyboard::F9: keysym = XK_F9; break;
-			case NzKeyboard::F10: keysym = XK_F10; break;
+				case Keyboard::F10: keysym = XK_F10; break;
-			case NzKeyboard::F11: keysym = XK_F11; break;
+				case Keyboard::F11: keysym = XK_F11; break;
-			case NzKeyboard::F12: keysym = XK_F12; break;
+				case Keyboard::F12: keysym = XK_F12; break;
-			case NzKeyboard::F13: keysym = XK_F13; break;
+				case Keyboard::F13: keysym = XK_F13; break;
-			case NzKeyboard::F14: keysym = XK_F14; break;
+				case Keyboard::F14: keysym = XK_F14; break;
-			case NzKeyboard::F15: keysym = XK_F15; break;
+				case Keyboard::F15: keysym = XK_F15; break;
 
 				// Flèches directionnelles
-			case NzKeyboard::Down: keysym = XK_Down; break;
+				case Keyboard::Down: keysym = XK_Down; break;
-			case NzKeyboard::Left: keysym = XK_Left; break;
+				case Keyboard::Left: keysym = XK_Left; break;
-			case NzKeyboard::Right: keysym = XK_Right; break;
+				case Keyboard::Right: keysym = XK_Right; break;
-			case NzKeyboard::Up: keysym = XK_Up; break;
+				case Keyboard::Up: keysym = XK_Up; break;
 
 				// Pavé numérique
-			case NzKeyboard::Add: keysym = XK_KP_Add; break;
+				case Keyboard::Add: keysym = XK_KP_Add; break;
-			case NzKeyboard::Decimal: keysym = XK_KP_Decimal; break;
+				case Keyboard::Decimal: keysym = XK_KP_Decimal; break;
-			case NzKeyboard::Divide: keysym = XK_KP_Divide; break;
+				case Keyboard::Divide: keysym = XK_KP_Divide; break;
-			case NzKeyboard::Multiply: keysym = XK_KP_Multiply; break;
+				case Keyboard::Multiply: keysym = XK_KP_Multiply; break;
-			case NzKeyboard::Numpad0: keysym = XK_KP_0; break;
+				case Keyboard::Numpad0: keysym = XK_KP_0; break;
-			case NzKeyboard::Numpad1: keysym = XK_KP_1; break;
+				case Keyboard::Numpad1: keysym = XK_KP_1; break;
-			case NzKeyboard::Numpad2: keysym = XK_KP_2; break;
+				case Keyboard::Numpad2: keysym = XK_KP_2; break;
-			case NzKeyboard::Numpad3: keysym = XK_KP_3; break;
+				case Keyboard::Numpad3: keysym = XK_KP_3; break;
-			case NzKeyboard::Numpad4: keysym = XK_KP_4; break;
+				case Keyboard::Numpad4: keysym = XK_KP_4; break;
-			case NzKeyboard::Numpad5: keysym = XK_KP_5; break;
+				case Keyboard::Numpad5: keysym = XK_KP_5; break;
-			case NzKeyboard::Numpad6: keysym = XK_KP_6; break;
+				case Keyboard::Numpad6: keysym = XK_KP_6; break;
-			case NzKeyboard::Numpad7: keysym = XK_KP_7; break;
+				case Keyboard::Numpad7: keysym = XK_KP_7; break;
-			case NzKeyboard::Numpad8: keysym = XK_KP_8; break;
+				case Keyboard::Numpad8: keysym = XK_KP_8; break;
-			case NzKeyboard::Numpad9: keysym = XK_KP_9; break;
+				case Keyboard::Numpad9: keysym = XK_KP_9; break;
-			case NzKeyboard::Subtract: keysym = XK_KP_Subtract; break;
+				case Keyboard::Subtract: keysym = XK_KP_Subtract; break;
 
 				// Divers
-			case NzKeyboard::Backslash: keysym = XK_backslash; break;
+				case Keyboard::Backslash: keysym = XK_backslash; break;
-			case NzKeyboard::Backspace: keysym = XK_BackSpace; break;
+				case Keyboard::Backspace: keysym = XK_BackSpace; break;
-			case NzKeyboard::Clear: keysym = XK_Clear; break;
+				case Keyboard::Clear: keysym = XK_Clear; break;
-			case NzKeyboard::Comma: keysym = XK_comma; break;
+				case Keyboard::Comma: keysym = XK_comma; break;
-			case NzKeyboard::Dash: keysym = XK_minus; break;
+				case Keyboard::Dash: keysym = XK_minus; break;
-			case NzKeyboard::Delete: keysym = XK_Delete; break;
+				case Keyboard::Delete: keysym = XK_Delete; break;
-			case NzKeyboard::End: keysym = XK_End; break;
+				case Keyboard::End: keysym = XK_End; break;
-			case NzKeyboard::Equal: keysym = XK_equal; break;
+				case Keyboard::Equal: keysym = XK_equal; break;
-			case NzKeyboard::Escape: keysym = XK_Escape; break;
+				case Keyboard::Escape: keysym = XK_Escape; break;
-			case NzKeyboard::Home: keysym = XK_Home; break;
+				case Keyboard::Home: keysym = XK_Home; break;
-			case NzKeyboard::Insert: keysym = XK_Insert; break;
+				case Keyboard::Insert: keysym = XK_Insert; break;
-			case NzKeyboard::LAlt: keysym = XK_Alt_L; break;
+				case Keyboard::LAlt: keysym = XK_Alt_L; break;
-			case NzKeyboard::LBracket: keysym = XK_bracketleft; break;
+				case Keyboard::LBracket: keysym = XK_bracketleft; break;
-			case NzKeyboard::LControl: keysym = XK_Control_L; break;
+				case Keyboard::LControl: keysym = XK_Control_L; break;
-			case NzKeyboard::LShift: keysym = XK_Shift_L; break;
+				case Keyboard::LShift: keysym = XK_Shift_L; break;
-			case NzKeyboard::LSystem: keysym = XK_Super_L; break;
+				case Keyboard::LSystem: keysym = XK_Super_L; break;
-			case NzKeyboard::Num0: keysym = XK_0; break;
+				case Keyboard::Num0: keysym = XK_0; break;
-			case NzKeyboard::Num1: keysym = XK_1; break;
+				case Keyboard::Num1: keysym = XK_1; break;
-			case NzKeyboard::Num2: keysym = XK_2; break;
+				case Keyboard::Num2: keysym = XK_2; break;
-			case NzKeyboard::Num3: keysym = XK_3; break;
+				case Keyboard::Num3: keysym = XK_3; break;
-			case NzKeyboard::Num4: keysym = XK_4; break;
+				case Keyboard::Num4: keysym = XK_4; break;
-			case NzKeyboard::Num5: keysym = XK_5; break;
+				case Keyboard::Num5: keysym = XK_5; break;
-			case NzKeyboard::Num6: keysym = XK_6; break;
+				case Keyboard::Num6: keysym = XK_6; break;
-			case NzKeyboard::Num7: keysym = XK_7; break;
+				case Keyboard::Num7: keysym = XK_7; break;
-			case NzKeyboard::Num8: keysym = XK_8; break;
+				case Keyboard::Num8: keysym = XK_8; break;
-			case NzKeyboard::Num9: keysym = XK_9; break;
+				case Keyboard::Num9: keysym = XK_9; break;
-			case NzKeyboard::PageDown: keysym = XK_Page_Down; break;
+				case Keyboard::PageDown: keysym = XK_Page_Down; break;
-			case NzKeyboard::PageUp: keysym = XK_Page_Up; break;
+				case Keyboard::PageUp: keysym = XK_Page_Up; break;
-			case NzKeyboard::Pause: keysym = XK_Pause; break;
+				case Keyboard::Pause: keysym = XK_Pause; break;
-			case NzKeyboard::Period: keysym = XK_period; break;
+				case Keyboard::Period: keysym = XK_period; break;
-			case NzKeyboard::Print: keysym = XK_Print; break;
+				case Keyboard::Print: keysym = XK_Print; break;
-			case NzKeyboard::PrintScreen: keysym = XK_Sys_Req; break;
+				case Keyboard::PrintScreen: keysym = XK_Sys_Req; break;
-			case NzKeyboard::Quote: keysym = XK_quotedbl; break;
+				case Keyboard::Quote: keysym = XK_quotedbl; break;
-			case NzKeyboard::RAlt: keysym = XK_Alt_R; break;
+				case Keyboard::RAlt: keysym = XK_Alt_R; break;
-			case NzKeyboard::RBracket: keysym = XK_bracketright; break;
+				case Keyboard::RBracket: keysym = XK_bracketright; break;
-			case NzKeyboard::RControl: keysym = XK_Control_R; break;
+				case Keyboard::RControl: keysym = XK_Control_R; break;
-			case NzKeyboard::Return: keysym = XK_Return; break;
+				case Keyboard::Return: keysym = XK_Return; break;
-			case NzKeyboard::RShift: keysym = XK_Shift_R; break;
+				case Keyboard::RShift: keysym = XK_Shift_R; break;
-			case NzKeyboard::RSystem: keysym = XK_Super_R; break;
+				case Keyboard::RSystem: keysym = XK_Super_R; break;
-			case NzKeyboard::Semicolon: keysym = XK_semicolon; break;
+				case Keyboard::Semicolon: keysym = XK_semicolon; break;
-			case NzKeyboard::Slash: keysym = XK_slash; break;
+				case Keyboard::Slash: keysym = XK_slash; break;
-			case NzKeyboard::Space: keysym = XK_space; break;
+				case Keyboard::Space: keysym = XK_space; break;
-			case NzKeyboard::Tab: keysym = XK_Tab; break;
+				case Keyboard::Tab: keysym = XK_Tab; break;
-			case NzKeyboard::Tilde: keysym = XK_grave; break;
+				case Keyboard::Tilde: keysym = XK_grave; break;
 
 				// Touches navigateur
-			case NzKeyboard::Browser_Back: keysym = XF86XK_Back; break;
+				case Keyboard::Browser_Back: keysym = XF86XK_Back; break;
-			case NzKeyboard::Browser_Favorites: keysym = XF86XK_Favorites; break;
+				case Keyboard::Browser_Favorites: keysym = XF86XK_Favorites; break;
-			case NzKeyboard::Browser_Forward: keysym = XF86XK_Forward; break;
+				case Keyboard::Browser_Forward: keysym = XF86XK_Forward; break;
-			case NzKeyboard::Browser_Home: keysym = XF86XK_HomePage; break;
+				case Keyboard::Browser_Home: keysym = XF86XK_HomePage; break;
-			case NzKeyboard::Browser_Refresh: keysym = XF86XK_Refresh; break;
+				case Keyboard::Browser_Refresh: keysym = XF86XK_Refresh; break;
-			case NzKeyboard::Browser_Search: keysym = XF86XK_Search; break;
+				case Keyboard::Browser_Search: keysym = XF86XK_Search; break;
-			case NzKeyboard::Browser_Stop: keysym = XF86XK_Stop; break;
+				case Keyboard::Browser_Stop: keysym = XF86XK_Stop; break;
 
 				// Touches de contrôle
-			case NzKeyboard::Media_Next: keysym = XF86XK_AudioNext; break;
+				case Keyboard::Media_Next: keysym = XF86XK_AudioNext; break;
-			case NzKeyboard::Media_Play: keysym = XF86XK_AudioPlay; break;
+				case Keyboard::Media_Play: keysym = XF86XK_AudioPlay; break;
-			case NzKeyboard::Media_Previous: keysym = XF86XK_AudioPrev; break;
+				case Keyboard::Media_Previous: keysym = XF86XK_AudioPrev; break;
-			case NzKeyboard::Media_Stop: keysym = XF86XK_AudioStop; break;
+				case Keyboard::Media_Stop: keysym = XF86XK_AudioStop; break;
 
 				// Touches de contrôle du volume
-			case NzKeyboard::Volume_Down: keysym = XF86XK_AudioLowerVolume; break;
+				case Keyboard::Volume_Down: keysym = XF86XK_AudioLowerVolume; break;
-			case NzKeyboard::Volume_Mute: keysym = XF86XK_AudioMute; break;
+				case Keyboard::Volume_Mute: keysym = XF86XK_AudioMute; break;
-			case NzKeyboard::Volume_Up: keysym = XF86XK_AudioRaiseVolume; break;
+				case Keyboard::Volume_Up: keysym = XF86XK_AudioRaiseVolume; break;
 
 				// Touches à verrouillage
-			case NzKeyboard::CapsLock: keysym = XK_Caps_Lock; break;
+				case Keyboard::CapsLock: keysym = XK_Caps_Lock; break;
-			case NzKeyboard::NumLock: keysym = XK_Num_Lock; break;
+				case Keyboard::NumLock: keysym = XK_Num_Lock; break;
-			case NzKeyboard::ScrollLock: keysym = XK_Scroll_Lock; break;
+				case Keyboard::ScrollLock: keysym = XK_Scroll_Lock; break;
 
 				default: break;
 			}
 
 			 // Sanity checks
-		if (key < 0 || key >= NzKeyboard::Count || keysym == 0)
+			if (key < 0 || key >= Keyboard::Count || keysym == 0)
-			NazaraWarning("Key " + NzString::Number(key) + " is not handled in NzKeyboard");
+				NazaraWarning("Key " + String::Number(key) + " is not handled in Keyboard");
 
 			return keysym;
 		}
-}
+	}
 
-NzString NzEventImpl::GetKeyName(NzKeyboard::Key key)
+	String EventImpl::GetKeyName(Keyboard::Key key)
-{
+	{
 		KeySym keySym = GetKeySym(key);
 
 		// XKeysymToString returns a static area.
 		return XKeysymToString(keySym);
-}
+	}
 
-NzVector2i NzEventImpl::GetMousePosition()
+	Vector2i EventImpl::GetMousePosition()
-{
+	{
-	NzScopedXCBConnection connection;
+		ScopedXCBConnection connection;
 
-	NzScopedXCB<xcb_generic_error_t> error(nullptr);
+		ScopedXCB<xcb_generic_error_t> error(nullptr);
 
-	NzScopedXCB<xcb_query_pointer_reply_t> pointer(
+		ScopedXCB<xcb_query_pointer_reply_t> pointer(
 			xcb_query_pointer_reply(
 				connection,
 				xcb_query_pointer(
@@ -199,23 +200,23 @@ NzVector2i NzEventImpl::GetMousePosition()
 		if (error)
 		{
 			NazaraError("Failed to query pointer");
-		return NzVector2i(-1, -1);
+			return Vector2i(-1, -1);
 		}
 
-	return NzVector2i(pointer->root_x, pointer->root_y);
+		return Vector2i(pointer->root_x, pointer->root_y);
-}
+	}
 
-NzVector2i NzEventImpl::GetMousePosition(const NzWindow& relativeTo)
+	Vector2i EventImpl::GetMousePosition(const Window& relativeTo)
-{
+	{
-	NzWindowHandle handle = relativeTo.GetHandle();
+		WindowHandle handle = relativeTo.GetHandle();
 		if (handle)
 		{
 			// Open a connection with the X server
-		NzScopedXCBConnection connection;
+			ScopedXCBConnection connection;
 
-		NzScopedXCB<xcb_generic_error_t> error(nullptr);
+			ScopedXCB<xcb_generic_error_t> error(nullptr);
 
-		NzScopedXCB<xcb_query_pointer_reply_t> pointer(
+			ScopedXCB<xcb_query_pointer_reply_t> pointer(
 				xcb_query_pointer_reply(
 					connection,
 					xcb_query_pointer(
@@ -229,21 +230,21 @@ NzVector2i NzEventImpl::GetMousePosition(const NzWindow& relativeTo)
 			if (error)
 			{
 				NazaraError("Failed to query pointer");
-			return NzVector2i(-1, -1);
+				return Vector2i(-1, -1);
 			}
 
-		return NzVector2i(pointer->win_x, pointer->win_y);
+			return Vector2i(pointer->win_x, pointer->win_y);
 		}
 		else
 		{
 			NazaraError("No window handle");
-		return NzVector2i(-1, -1);
+			return Vector2i(-1, -1);
+		}
 	}
-}
 
-bool NzEventImpl::IsKeyPressed(NzKeyboard::Key key)
+	bool EventImpl::IsKeyPressed(Keyboard::Key key)
-{
+	{
-	NzScopedXCBConnection connection;
+		ScopedXCBConnection connection;
 
 		xcb_keysym_t keySym = GetKeySym(key);
 
@@ -254,7 +255,7 @@ bool NzEventImpl::IsKeyPressed(NzKeyboard::Key key)
 			return false;
 		}
 
-	NzScopedXCB<xcb_keycode_t> keyCode = xcb_key_symbols_get_keycode(keySymbols, keySym);
+		ScopedXCB<xcb_keycode_t> keyCode = xcb_key_symbols_get_keycode(keySymbols, keySym);
 		if (!keyCode)
 		{
 			NazaraError("Failed to get key code");
@@ -262,10 +263,10 @@ bool NzEventImpl::IsKeyPressed(NzKeyboard::Key key)
 		}
 		X11::XCBKeySymbolsFree(keySymbols);
 
-	NzScopedXCB<xcb_generic_error_t> error(nullptr);
+		ScopedXCB<xcb_generic_error_t> error(nullptr);
 
 		// Get the whole keyboard state
-	NzScopedXCB<xcb_query_keymap_reply_t> keymap(
+		ScopedXCB<xcb_query_keymap_reply_t> keymap(
 			xcb_query_keymap_reply(
 				connection,
 				xcb_query_keymap(connection),
@@ -281,16 +282,16 @@ bool NzEventImpl::IsKeyPressed(NzKeyboard::Key key)
 
 		// Check our keycode
 		return (keymap->keys[*keyCode.get() / 8] & (1 << (*keyCode.get() % 8))) != 0;
-}
+	}
 
-bool NzEventImpl::IsMouseButtonPressed(NzMouse::Button button)
+	bool EventImpl::IsMouseButtonPressed(Mouse::Button button)
-{
+	{
-	NzScopedXCBConnection connection;
+		ScopedXCBConnection connection;
 
-	NzScopedXCB<xcb_generic_error_t> error(nullptr);
+		ScopedXCB<xcb_generic_error_t> error(nullptr);
 
 		// Get pointer mask
-	NzScopedXCB<xcb_query_pointer_reply_t> pointer(
+		ScopedXCB<xcb_query_pointer_reply_t> pointer(
 			xcb_query_pointer_reply(
 				connection,
 				xcb_query_pointer(
@@ -311,20 +312,20 @@ bool NzEventImpl::IsMouseButtonPressed(NzMouse::Button button)
 
 		switch (button)
 		{
-		case NzMouse::Left:     return buttons & XCB_BUTTON_MASK_1;
+			case Mouse::Left:     return buttons & XCB_BUTTON_MASK_1;
-		case NzMouse::Right:    return buttons & XCB_BUTTON_MASK_3;
+			case Mouse::Right:    return buttons & XCB_BUTTON_MASK_3;
-		case NzMouse::Middle:   return buttons & XCB_BUTTON_MASK_2;
+			case Mouse::Middle:   return buttons & XCB_BUTTON_MASK_2;
-		case NzMouse::XButton1: return false; // not supported by X
+			case Mouse::XButton1: return false; // not supported by X
-		case NzMouse::XButton2: return false; // not supported by X
+			case Mouse::XButton2: return false; // not supported by X
 		}
 
 		NazaraError("Mouse button not supported.");
 		return false;
-}
+	}
 
-void NzEventImpl::SetMousePosition(int x, int y)
+	void EventImpl::SetMousePosition(int x, int y)
-{
+	{
-	NzScopedXCBConnection connection;
+		ScopedXCBConnection connection;
 
 		xcb_window_t root = X11::XCBDefaultRootWindow(connection);
 
@@ -342,13 +343,13 @@ void NzEventImpl::SetMousePosition(int x, int y)
 			NazaraError("Failed to set mouse position");
 
 		xcb_flush(connection);
-}
+	}
 
-void NzEventImpl::SetMousePosition(int x, int y, const NzWindow& relativeTo)
+	void EventImpl::SetMousePosition(int x, int y, const Window& relativeTo)
-{
+	{
-	NzScopedXCBConnection connection;
+		ScopedXCBConnection connection;
 
-	NzWindowHandle handle = relativeTo.GetHandle();
+		WindowHandle handle = relativeTo.GetHandle();
 		if (handle)
 		{
 			if (!X11::CheckCookie(
@@ -368,4 +369,5 @@ void NzEventImpl::SetMousePosition(int x, int y, const NzWindow& relativeTo)
 		}
 		else
 			NazaraError("No window handle");
+	}
 }

src/Nazara/Utility/X11/InputImpl.hpp

@@ -7,21 +7,25 @@
 #ifndef NAZARA_INPUTIMPL_HPP
 #define NAZARA_INPUTIMPL_HPP
 
+#include <Nazara/Prerequesites.hpp>
 #include <Nazara/Core/String.hpp>
 #include <Nazara/Math/Vector2.hpp>
 #include <Nazara/Utility/Keyboard.hpp>
 #include <Nazara/Utility/Mouse.hpp>
 
-class NzEventImpl
+namespace Nz
 {
+	class EventImpl
+	{
 		public:
-		static NzString GetKeyName(NzKeyboard::Key key);
+			static String GetKeyName(Keyboard::Key key);
-		static NzVector2i GetMousePosition();
+			static Vector2i GetMousePosition();
-		static NzVector2i GetMousePosition(const NzWindow& relativeTo);
+			static Vector2i GetMousePosition(const Window& relativeTo);
-		static bool IsKeyPressed(NzKeyboard::Key key);
+			static bool IsKeyPressed(Keyboard::Key key);
-		static bool IsMouseButtonPressed(NzMouse::Button button);
+			static bool IsMouseButtonPressed(Mouse::Button button);
 			static void SetMousePosition(int x, int y);
-		static void SetMousePosition(int x, int y, const NzWindow& relativeTo);
+			static void SetMousePosition(int x, int y, const Window& relativeTo);
-};
+	};
+}
 
 #endif // NAZARA_INPUTIMPL_HPP

src/Nazara/Utility/X11/ScopedXCB.cpp

@@ -8,69 +8,71 @@
 #include <xcb/xcb_image.h>
 #include <Nazara/Utility/Debug.hpp>
 
-/***********************************************
+namespace Nz
-          NzScopedXCBConnection
-***********************************************/
-
-NzScopedXCBConnection::NzScopedXCBConnection() :
-m_connection(nullptr)
 {
+	/***********************************************
+			  ScopedXCBConnection
+	***********************************************/
+
+	ScopedXCBConnection::ScopedXCBConnection() :
+	m_connection(nullptr)
+	{
 		m_connection = X11::OpenConnection();
-}
+	}
 
-NzScopedXCBConnection::~NzScopedXCBConnection()
+	ScopedXCBConnection::~ScopedXCBConnection()
-{
+	{
 		X11::CloseConnection(m_connection);
-}
+	}
 
-NzScopedXCBConnection::operator xcb_connection_t*() const
+	ScopedXCBConnection::operator xcb_connection_t*() const
-{
+	{
 		return m_connection;
-}
+	}
 
-/***********************************************
+	/***********************************************
-          NzScopedXCBEWMHConnection
+			  ScopedXCBEWMHConnection
-***********************************************/
+	***********************************************/
 
-NzScopedXCBEWMHConnection::NzScopedXCBEWMHConnection(xcb_connection_t* connection) :
+	ScopedXCBEWMHConnection::ScopedXCBEWMHConnection(xcb_connection_t* connection) :
-m_ewmhConnection(nullptr)
+	m_ewmhConnection(nullptr)
-{
+	{
 		m_ewmhConnection = X11::OpenEWMHConnection(connection);
-}
+	}
 
-NzScopedXCBEWMHConnection::~NzScopedXCBEWMHConnection()
+	ScopedXCBEWMHConnection::~ScopedXCBEWMHConnection()
-{
+	{
 		X11::CloseEWMHConnection(m_ewmhConnection);
-}
+	}
 
-xcb_ewmh_connection_t* NzScopedXCBEWMHConnection::operator ->() const
+	xcb_ewmh_connection_t* ScopedXCBEWMHConnection::operator ->() const
-{
+	{
 		return m_ewmhConnection;
-}
+	}
 
-NzScopedXCBEWMHConnection::operator xcb_ewmh_connection_t*() const
+	ScopedXCBEWMHConnection::operator xcb_ewmh_connection_t*() const
-{
+	{
 		return m_ewmhConnection;
-}
+	}
 
-/***********************************************
+	/***********************************************
-               NzXCBGContext
+				   XCBGContext
-***********************************************/
+	***********************************************/
 
-NzXCBGContext::NzXCBGContext(xcb_connection_t* connection) :
+	XCBGContext::XCBGContext(xcb_connection_t* connection) :
-m_connection(connection),
+	m_connection(connection),
-m_gcontext(XCB_NONE)
+	m_gcontext(XCB_NONE)
-{
+	{
 		NazaraAssert(connection, "Connection must have been established");
-}
+	}
 
-NzXCBGContext::~NzXCBGContext()
+	XCBGContext::~XCBGContext()
-{
+	{
 		Destroy();
-}
+	}
 
-bool NzXCBGContext::Create(xcb_drawable_t drawable, uint32_t value_mask, const uint32_t* value_list)
+	bool XCBGContext::Create(xcb_drawable_t drawable, uint32_t value_mask, const uint32_t* value_list)
-{
+	{
 		NazaraAssert(m_gcontext == XCB_NONE, "Context must have been destroyed before or just created");
 
 		m_gcontext = xcb_generate_id(m_connection);
@@ -84,10 +86,10 @@ bool NzXCBGContext::Create(xcb_drawable_t drawable, uint32_t value_mask, const u
 				value_mask,
 				value_list
 			));
-}
+	}
 
-void NzXCBGContext::Destroy()
+	void XCBGContext::Destroy()
-{
+	{
 		if (m_gcontext == XCB_NONE)
 			return;
 
@@ -101,43 +103,43 @@ void NzXCBGContext::Destroy()
 			NazaraError("Failed to free gcontext");
 
 		m_gcontext = XCB_NONE;
-}
+	}
 
-NzXCBGContext::operator xcb_gcontext_t() const
+	XCBGContext::operator xcb_gcontext_t() const
-{
+	{
 		return m_gcontext;
-}
+	}
 
-/***********************************************
+	/***********************************************
-                NzXCBPixmap
+					XCBPixmap
-***********************************************/
+	***********************************************/
 
-NzXCBPixmap::NzXCBPixmap() :
+	XCBPixmap::XCBPixmap() :
-m_connection(nullptr),
+	m_connection(nullptr),
-m_pixmap(XCB_NONE)
+	m_pixmap(XCB_NONE)
-{
+	{
-}
+	}
 
-NzXCBPixmap::NzXCBPixmap(xcb_connection_t* connection) :
+	XCBPixmap::XCBPixmap(xcb_connection_t* connection) :
-m_connection(connection),
+	m_connection(connection),
-m_pixmap(XCB_NONE)
+	m_pixmap(XCB_NONE)
-{
+	{
-}
+	}
 
-NzXCBPixmap::~NzXCBPixmap()
+	XCBPixmap::~XCBPixmap()
-{
+	{
 		Destroy();
-}
+	}
 
-void NzXCBPixmap::Connect(xcb_connection_t* connection)
+	void XCBPixmap::Connect(xcb_connection_t* connection)
-{
+	{
 		NazaraAssert(connection && !m_connection, "Connection must be established");
 
 		m_connection = connection;
-}
+	}
 
-bool NzXCBPixmap::Create(uint8_t depth, xcb_drawable_t drawable, uint16_t width, uint16_t height)
+	bool XCBPixmap::Create(uint8_t depth, xcb_drawable_t drawable, uint16_t width, uint16_t height)
-{
+	{
 		NazaraAssert(m_pixmap == XCB_NONE, "Pixmap must have been destroyed before or just created");
 
 		m_pixmap = xcb_generate_id(m_connection);
@@ -152,10 +154,10 @@ bool NzXCBPixmap::Create(uint8_t depth, xcb_drawable_t drawable, uint16_t width,
 				width,
 				height
 			));
-}
+	}
 
-bool NzXCBPixmap::CreatePixmapFromBitmapData(xcb_drawable_t drawable, uint8_t* data, uint32_t width, uint32_t height, uint32_t depth, uint32_t fg, uint32_t bg, xcb_gcontext_t* gcp)
+	bool XCBPixmap::CreatePixmapFromBitmapData(xcb_drawable_t drawable, uint8_t* data, uint32_t width, uint32_t height, uint32_t depth, uint32_t fg, uint32_t bg, xcb_gcontext_t* gcp)
-{
+	{
 		NazaraAssert(m_pixmap == XCB_NONE, "Pixmap must have been destroyed before or just created");
 
 		m_pixmap = xcb_create_pixmap_from_bitmap_data(
@@ -171,10 +173,10 @@ bool NzXCBPixmap::CreatePixmapFromBitmapData(xcb_drawable_t drawable, uint8_t* d
 		);
 
 		return m_pixmap != XCB_NONE;
-}
+	}
 
-void NzXCBPixmap::Destroy()
+	void XCBPixmap::Destroy()
-{
+	{
 		if (m_pixmap == XCB_NONE)
 			return;
 
@@ -188,9 +190,10 @@ void NzXCBPixmap::Destroy()
 			NazaraError("Failed to free pixmap");
 
 		m_pixmap = XCB_NONE;
-}
+	}
 
-NzXCBPixmap::operator xcb_pixmap_t() const
+	XCBPixmap::operator xcb_pixmap_t() const
-{
+	{
 		return m_pixmap;
+	}
 }

src/Nazara/Utility/X11/ScopedXCB.hpp

@@ -7,25 +7,29 @@
 #ifndef NAZARA_SCOPEDXCB_HPP
 #define NAZARA_SCOPEDXCB_HPP
 
+#include <Nazara/Prerequesites.hpp>
+#include <xcb/xcb.h>
 #include <xcb/xcb_ewmh.h>
 
-class NzScopedXCBConnection
+namespace Nz
 {
+	class ScopedXCBConnection
+	{
 		public:
-		NzScopedXCBConnection();
+			ScopedXCBConnection();
-		~NzScopedXCBConnection();
+			~ScopedXCBConnection();
 
 			operator xcb_connection_t*() const;
 
 		private:
 			xcb_connection_t* m_connection;
-};
+	};
 
-class NzScopedXCBEWMHConnection
+	class ScopedXCBEWMHConnection
-{
+	{
 		public:
-		NzScopedXCBEWMHConnection(xcb_connection_t* connection);
+			ScopedXCBEWMHConnection(xcb_connection_t* connection);
-		~NzScopedXCBEWMHConnection();
+			~ScopedXCBEWMHConnection();
 
 			xcb_ewmh_connection_t* operator ->() const;
 
@@ -33,14 +37,14 @@ class NzScopedXCBEWMHConnection
 
 		private:
 			xcb_ewmh_connection_t* m_ewmhConnection;
-};
+	};
 
-template <typename T>
+	template <typename T>
-class NzScopedXCB
+	class ScopedXCB
-{
+	{
 		public:
-		NzScopedXCB(T* pointer);
+			ScopedXCB(T* pointer);
-		~NzScopedXCB();
+			~ScopedXCB();
 
 			T* operator ->() const;
 			T** operator &();
@@ -51,13 +55,13 @@ class NzScopedXCB
 
 		private:
 			T* m_pointer;
-};
+	};
 
-class NzXCBGContext
+	class XCBGContext
-{
+	{
 		public:
-		NzXCBGContext(xcb_connection_t* connection);
+			XCBGContext(xcb_connection_t* connection);
-		~NzXCBGContext();
+			~XCBGContext();
 
 			bool Create(xcb_drawable_t drawable, uint32_t value_mask, const uint32_t* value_list);
 
@@ -68,14 +72,14 @@ class NzXCBGContext
 		private:
 			xcb_connection_t* m_connection;
 			xcb_gcontext_t m_gcontext;
-};
+	};
 
-class NzXCBPixmap
+	class XCBPixmap
-{
+	{
 		public:
-		NzXCBPixmap();
+			XCBPixmap();
-		NzXCBPixmap(xcb_connection_t* connection);
+			XCBPixmap(xcb_connection_t* connection);
-		~NzXCBPixmap();
+			~XCBPixmap();
 
 			void Connect(xcb_connection_t* connection);
 			bool Create(uint8_t depth, xcb_drawable_t drawable, uint16_t width, uint16_t height);
@@ -88,7 +92,8 @@ class NzXCBPixmap
 		private:
 			xcb_connection_t* m_connection;
 			xcb_pixmap_t m_pixmap;
-};
+	};
+}
 
 #include <Nazara/Utility/X11/ScopedXCB.inl>
 

src/Nazara/Utility/X11/VideoModeImpl.cpp

@@ -10,16 +10,18 @@
 #include <algorithm>
 #include <Nazara/Utility/Debug.hpp>
 
-NzVideoMode NzVideoModeImpl::GetDesktopMode()
+namespace Nz
 {
-	NzVideoMode desktopMode;
+	VideoMode VideoModeImpl::GetDesktopMode()
+	{
+		VideoMode desktopMode;
 
-	NzScopedXCBConnection connection;
+		ScopedXCBConnection connection;
 
 		// Retrieve the default screen
 		xcb_screen_t* screen = X11::XCBDefaultScreen(connection);
 
-	NzScopedXCB<xcb_generic_error_t> error(nullptr);
+		ScopedXCB<xcb_generic_error_t> error(nullptr);
 
 		// Check if the RandR extension is present
 		const xcb_query_extension_reply_t* randrExt = xcb_get_extension_data(connection, &xcb_randr_id);
@@ -32,7 +34,7 @@ NzVideoMode NzVideoModeImpl::GetDesktopMode()
 		}
 
 		// Load RandR and check its version
-	NzScopedXCB<xcb_randr_query_version_reply_t> randrVersion(xcb_randr_query_version_reply(
+		ScopedXCB<xcb_randr_query_version_reply_t> randrVersion(xcb_randr_query_version_reply(
 			connection,
 			xcb_randr_query_version(
 				connection,
@@ -49,7 +51,7 @@ NzVideoMode NzVideoModeImpl::GetDesktopMode()
 		}
 
 		// Get the current configuration
-	NzScopedXCB<xcb_randr_get_screen_info_reply_t> config(xcb_randr_get_screen_info_reply(
+		ScopedXCB<xcb_randr_get_screen_info_reply_t> config(xcb_randr_get_screen_info_reply(
 			connection,
 			xcb_randr_get_screen_info(
 				connection,
@@ -73,7 +75,7 @@ NzVideoMode NzVideoModeImpl::GetDesktopMode()
 		xcb_randr_screen_size_t* sizes = xcb_randr_get_screen_info_sizes(config.get());
 		if (sizes && (nbSizes > 0))
 		{
-		desktopMode = NzVideoMode(sizes[currentMode].width, sizes[currentMode].height, screen->root_depth);
+			desktopMode = VideoMode(sizes[currentMode].width, sizes[currentMode].height, screen->root_depth);
 
 			if (config->rotation == XCB_RANDR_ROTATION_ROTATE_90 ||
 				config->rotation == XCB_RANDR_ROTATION_ROTATE_270)
@@ -85,16 +87,16 @@ NzVideoMode NzVideoModeImpl::GetDesktopMode()
 		}
 
 		return desktopMode;
-}
+	}
 
-void NzVideoModeImpl::GetFullscreenModes(std::vector<NzVideoMode>& modes)
+	void VideoModeImpl::GetFullscreenModes(std::vector<VideoMode>& modes)
-{
+	{
-	NzScopedXCBConnection connection;
+		ScopedXCBConnection connection;
 
 		// Retrieve the default screen
 		xcb_screen_t* screen = X11::XCBDefaultScreen(connection);
 
-	NzScopedXCB<xcb_generic_error_t> error(nullptr);
+		ScopedXCB<xcb_generic_error_t> error(nullptr);
 
 		const xcb_query_extension_reply_t* randrExt = xcb_get_extension_data(connection, &xcb_randr_id);
 
@@ -106,7 +108,7 @@ void NzVideoModeImpl::GetFullscreenModes(std::vector<NzVideoMode>& modes)
 		}
 
 		// Load RandR and check its version
-	NzScopedXCB<xcb_randr_query_version_reply_t> randrVersion(xcb_randr_query_version_reply(
+		ScopedXCB<xcb_randr_query_version_reply_t> randrVersion(xcb_randr_query_version_reply(
 			connection,
 			xcb_randr_query_version(
 				connection,
@@ -123,7 +125,7 @@ void NzVideoModeImpl::GetFullscreenModes(std::vector<NzVideoMode>& modes)
 		}
 
 		// Get the current configuration
-	NzScopedXCB<xcb_randr_get_screen_info_reply_t> config(xcb_randr_get_screen_info_reply(
+		ScopedXCB<xcb_randr_get_screen_info_reply_t> config(xcb_randr_get_screen_info_reply(
 			connection,
 			xcb_randr_get_screen_info(
 				connection,
@@ -151,7 +153,7 @@ void NzVideoModeImpl::GetFullscreenModes(std::vector<NzVideoMode>& modes)
 				for (int j = 0; j < config->nSizes; ++j)
 				{
 					// Convert to VideoMode
-				NzVideoMode mode(sizes[j].width, sizes[j].height, iter.data->depth);
+					VideoMode mode(sizes[j].width, sizes[j].height, iter.data->depth);
 
 					if (config->rotation == XCB_RANDR_ROTATION_ROTATE_90 ||
 						config->rotation == XCB_RANDR_ROTATION_ROTATE_270)
@@ -163,4 +165,5 @@ void NzVideoModeImpl::GetFullscreenModes(std::vector<NzVideoMode>& modes)
 				}
 			}
 		}
+	}
 }

src/Nazara/Utility/X11/VideoModeImpl.hpp

@@ -7,13 +7,17 @@
 #ifndef NAZARA_VIDEOMODEIMPL_HPP
 #define NAZARA_VIDEOMODEIMPL_HPP
 
+#include <Nazara/Prerequesites.hpp>
 #include <Nazara/Utility/VideoMode.hpp>
 
-class NzVideoModeImpl
+namespace Nz
 {
+	class VideoModeImpl
+	{
 		public:
-		static NzVideoMode GetDesktopMode();
+			static VideoMode GetDesktopMode();
-		static void GetFullscreenModes(std::vector<NzVideoMode>& modes);
+			static void GetFullscreenModes(std::vector<VideoMode>& modes);
-};
+	};
+}
 
 #endif // NNAZARA_VIDEOMODEIMPL_HPP

src/Nazara/Utility/X11/WindowImpl.hpp

@@ -9,44 +9,48 @@
 #ifndef NAZARA_WINDOWIMPL_HPP
 #define NAZARA_WINDOWIMPL_HPP
 
-#include <Nazara/Core/NonCopyable.hpp>
+#include <Nazara/Prerequesites.hpp>
 #include <Nazara/Core/Thread.hpp>
 #include <Nazara/Math/Vector2.hpp>
 #include <Nazara/Utility/Enums.hpp>
 #include <Nazara/Utility/Keyboard.hpp>
+#include <Nazara/Utility/X11/Display.hpp>
 #include <xcb/randr.h>
 #include <xcb/xcb_icccm.h>
-#include <Nazara/Utility/X11/Display.hpp>
 
-#if NAZARA_UTILITY_THREADED_WINDOW
+namespace Nz
-class NzConditionVariable;
-class NzMutex;
-#endif
-class NzCursor;
-class NzIcon;
-class NzVideoMode;
-class NzWindow;
-
-class NzWindowImpl : NzNonCopyable
 {
-	public:
+	#if NAZARA_UTILITY_THREADED_WINDOW
-		NzWindowImpl(NzWindow* parent);
+	class ConditionVariable;
-		~NzWindowImpl();
+	class Mutex;
+	#endif
+	class Cursor;
+	class Icon;
+	class VideoMode;
+	class Window;
 
-		bool Create(const NzVideoMode& mode, const NzString& title, nzUInt32 style);
+	class WindowImpl
-		bool Create(NzWindowHandle handle);
+	{
+		public:
+			WindowImpl(Window* parent);
+			WindowImpl(const WindowImpl&) = delete;
+			WindowImpl(WindowImpl&&) = delete; ///TODO?
+			~WindowImpl();
+
+			bool Create(const VideoMode& mode, const String& title, UInt32 style);
+			bool Create(WindowHandle handle);
 
 			void Destroy();
 
 			void EnableKeyRepeat(bool enable);
 			void EnableSmoothScrolling(bool enable);
 
-		NzWindowHandle GetHandle() const;
+			WindowHandle GetHandle() const;
 			unsigned int GetHeight() const;
-		NzVector2i GetPosition() const;
+			Vector2i GetPosition() const;
-		NzVector2ui GetSize() const;
+			Vector2ui GetSize() const;
-		nzUInt32 GetStyle() const;
+			UInt32 GetStyle() const;
-		NzString GetTitle() const;
+			String GetTitle() const;
 			unsigned int GetWidth() const;
 
 			bool HasFocus() const;
@@ -58,19 +62,22 @@ class NzWindowImpl : NzNonCopyable
 
 			void ProcessEvents(bool block);
 
-		void SetCursor(nzWindowCursor cursor);
+			void SetCursor(WindowCursor cursor);
-		void SetCursor(const NzCursor& cursor);
+			void SetCursor(const Cursor& cursor);
 			void SetEventListener(bool listener);
 			void SetFocus();
-		void SetIcon(const NzIcon& icon);
+			void SetIcon(const Icon& icon);
 			void SetMaximumSize(int width, int height);
 			void SetMinimumSize(int width, int height);
 			void SetPosition(int x, int y);
 			void SetSize(unsigned int width, unsigned int height);
 			void SetStayOnTop(bool stayOnTop);
-		void SetTitle(const NzString& title);
+			void SetTitle(const String& title);
 			void SetVisible(bool visible);
 
+			WindowImpl& operator=(const WindowImpl&) = delete;
+			WindowImpl& operator=(WindowImpl&&) = delete; ///TODO?
+
 			static bool Initialize();
 			static void Uninitialize();
 
@@ -78,8 +85,8 @@ class NzWindowImpl : NzNonCopyable
 
 			void CleanUp();
 			xcb_keysym_t ConvertKeyCodeToKeySym(xcb_keycode_t keycode, uint16_t state);
-		NzKeyboard::Key ConvertVirtualKey(xcb_keysym_t symbol);
+			Keyboard::Key ConvertVirtualKey(xcb_keysym_t symbol);
-		const char* ConvertWindowCursorToXName(nzWindowCursor cursor);
+			const char* ConvertWindowCursorToXName(WindowCursor cursor);
 			void CommonInitialize();
 
 			void ProcessEvent(xcb_generic_event_t* windowEvent);
@@ -88,25 +95,25 @@ class NzWindowImpl : NzNonCopyable
 
 			void SetCursor(xcb_cursor_t cursor);
 			void SetMotifHints();
-		void SetVideoMode(const NzVideoMode& mode);
+			void SetVideoMode(const VideoMode& mode);
 			void SwitchToFullscreen();
 
 			bool UpdateNormalHints();
 			void UpdateEventQueue(xcb_generic_event_t* event);
 
 			#if NAZARA_UTILITY_THREADED_WINDOW
-		static void WindowThread(NzWindowImpl* window, NzMutex* mutex, NzConditionVariable* condition);
+			static void WindowThread(WindowImpl* window, Mutex* mutex, ConditionVariable* condition);
 			#endif
 
 			xcb_window_t                      m_window;
 			xcb_screen_t*                     m_screen;
 			xcb_randr_get_screen_info_reply_t m_oldVideoMode;
 			xcb_size_hints_t m_size_hints;
-		nzUInt32 m_style;
+			UInt32 m_style;
 			#if NAZARA_UTILITY_THREADED_WINDOW
-		NzThread m_thread;
+			Thread m_thread;
 			#endif
-		NzWindow* m_parent;
+			Window* m_parent;
 			bool m_eventListener;
 			bool m_ownsWindow;
 			bool m_smoothScrolling;
@@ -114,7 +121,7 @@ class NzWindowImpl : NzNonCopyable
 			bool m_threadActive;
 			#endif
 			short m_scrolling;
-		NzVector2i m_mousePos;
+			Vector2i m_mousePos;
 			bool m_keyRepeat;
 
 			struct
@@ -122,5 +129,7 @@ class NzWindowImpl : NzNonCopyable
 				xcb_generic_event_t* curr = nullptr;
 				xcb_generic_event_t* next = nullptr;
 			} m_eventQueue;
-};
+	};
+}
+
 #endif // NAZARA_WINDOWIMPL_HPP