diff --git a/gale/context/wayland/Context.cpp b/gale/context/wayland/Context.cpp
new file mode 100644
index 0000000..41b0c66
--- /dev/null
+++ b/gale/context/wayland/Context.cpp
@@ -0,0 +1,1415 @@
+/** @file
+ * @author Edouard DUPIN
+ * @copyright 2011, Edouard DUPIN, all right reserved
+ * @license MPL v2.0 (see license file)
+ */
+
+
+#include <cstdlib>
+#include <cstdio>
+#include <cstring>
+
+#include <etk/types.hpp>
+#include <etk/os/FSNode.hpp>
+#include <etk/tool.hpp>
+
+#include <gale/debug.hpp>
+#include <gale/gale.hpp>
+#include <gale/key/key.hpp>
+#include <gale/context/commandLine.hpp>
+#include <gale/resource/Manager.hpp>
+#include <gale/context/Context.hpp>
+#include <gale/Dimension.hpp>
+#include <etk/etk.hpp>
+
+extern "C" {
+	#include <wayland-client.h>
+	#include <wayland-client.h>
+	#include <wayland-server.h>
+	#include <wayland-client-protocol.h>
+	#include <wayland-egl.h>
+	#include <EGL/egl.h>
+	#include <GLES2/gl2.h>
+}
+
+#include <gale/renderer/openGL/openGL-include.hpp>
+
+bool hasDisplay = false;
+#define DEBUG_WAYLAND_EVENT
+#ifdef DEBUG_WAYLAND_EVENT
+	#define WAYLAND_DEBUG      GALE_DEBUG
+	#define WAYLAND_VERBOSE    GALE_VERBOSE
+	#define WAYLAND_INFO       GALE_INFO
+	#define WAYLAND_CRITICAL   GALE_CRITICAL
+#else
+	#define WAYLAND_DEBUG      GALE_VERBOSE
+	#define WAYLAND_VERBOSE    GALE_VERBOSE
+	#define WAYLAND_INFO       GALE_VERBOSE
+	#define WAYLAND_CRITICAL   GALE_VERBOSE
+#endif
+
+// see this ... https://jan.newmarch.name/Wayland/Input/
+
+static void global_registry_handler(void* _data, struct wl_registry* _registry, uint32_t _id, const char* _interface, uint32_t _version);
+static void global_registry_remover(void* _data, struct wl_registry* _registry, uint32_t _id);
+
+static const struct wl_registry_listener registry_listener = {
+    global_registry_handler,
+    global_registry_remover
+};
+
+
+class WAYLANDInterface : public gale::Context {
+	private:
+		gale::key::Special m_guiKeyBoardMode;
+		bool m_inputIsPressed[MAX_MANAGE_INPUT];
+		struct wl_display* m_display;
+		std::string m_uniqueWindowsName;
+		bool m_run;
+		
+		
+		struct wl_compositor* m_compositor;
+		struct wl_surface* m_surface;
+		struct wl_egl_window* m_egl_window;
+		struct wl_region* m_region;
+		struct wl_shell* m_shell;
+		struct wl_shell_surface* m_shell_surface;
+		
+		EGLDisplay m_egl_display;
+		EGLConfig m_egl_conf;
+		EGLSurface m_egl_surface;
+		EGLContext m_egl_context;
+		
+	public:
+		WAYLANDInterface(gale::Application* _application, int32_t _argc, const char* _argv[]) :
+		  gale::Context(_application, _argc, _argv),
+		  m_display(nullptr),
+		  m_run(false),
+		  m_compositor(nullptr),
+		  m_surface(nullptr),
+		  m_egl_window(nullptr),
+		  m_region(nullptr),
+		  m_shell(nullptr),
+		  m_shell_surface(nullptr) {
+			WAYLAND_INFO("WAYLAND:INIT");
+			for (int32_t iii=0; iii<MAX_MANAGE_INPUT; iii++) {
+				m_inputIsPressed[iii] = false;
+			}
+			getServerReferences();
+			m_surface = wl_compositor_create_surface(m_compositor);
+			if (m_surface == NULL) {
+				GALE_CRITICAL("Can't create surface");
+			} else {
+				WAYLAND_INFO("Created surface");
+			}
+			m_shell_surface = wl_shell_get_shell_surface(m_shell, m_surface);
+			wl_shell_surface_set_toplevel(m_shell_surface);
+			createOpaqueRegion();
+			initEgl();
+			createWindow();
+			m_uniqueWindowsName   = "GALE_" + etk::to_string(etk::tool::irand(0, 1999999999));
+			m_run = true;
+		}
+		
+		~WAYLANDInterface() {
+			if (m_display != nullptr) {
+				wl_display_disconnect(m_display);
+				WAYLAND_INFO("disconnected from display");
+			}
+			// TODO : ...
+		}
+		
+		
+		void registryHandler(struct wl_registry* _registry, uint32_t _id, const char* _interface, uint32_t _version) {
+			GALE_WARNING("Got a registry event for '" << _interface  << "' id=" << _id);
+			if (strcmp(_interface, "wl_compositor") == 0) {
+				m_compositor = (struct wl_compositor*)wl_registry_bind(_registry, _id, &wl_compositor_interface, 1);
+			} else if (strcmp(_interface, "wl_shell") == 0) {
+				m_shell = (struct wl_shell*)wl_registry_bind(_registry, _id, &wl_shell_interface, 1);
+			}
+		}
+		
+		void registryRemover(struct wl_registry* _registry, uint32_t _id) {
+			GALE_WARNING("Got a registry losing event for " << _id);
+		}
+		
+		/****************************************************************************************/
+		bool getServerReferences() {
+			WAYLAND_INFO("WAYLAND: CreateWAYLANDContext");
+			
+			m_display = wl_display_connect(NULL);
+			if (m_display == nullptr) {
+				GALE_CRITICAL("Can't connect to wayland display");
+				return false;
+			}
+			WAYLAND_INFO("connected to display");
+			
+			struct wl_registry* registry = wl_display_get_registry(m_display);
+			wl_registry_add_listener(registry, &registry_listener, this);
+			
+			wl_display_dispatch(m_display);
+			wl_display_roundtrip(m_display);
+			
+			if (    m_compositor == NULL
+			     || m_shell == NULL) {
+				GALE_CRITICAL("Can't find compositor or shell");
+				return false;
+			} else {
+				GALE_INFO("Found compositor and shell");
+			}
+			
+			// basic title of the windows ...
+			static char *title = (char*)"Gale";
+			/*
+			// set the DPI for the current screen :
+			gale::Dimension::setPixelRatio(vec2((float)DisplayWidth(m_display, Xscreen)/(float)DisplayWidthMM(m_display, Xscreen),
+			                                    (float)DisplayHeight(m_display, Xscreen)/(float)DisplayHeightMM(m_display, Xscreen)),
+			                               gale::distance::millimeter);
+				m_doubleBuffered = false;
+				GALE_INFO("GL-X singlebuffered rendering will be used, no doublebuffering available");
+			*/
+			
+			return true;
+		}
+		
+		void createOpaqueRegion() {
+			m_region = wl_compositor_create_region(m_compositor);
+			wl_region_add(m_region, 0, 0, 480, 360);
+			wl_surface_set_opaque_region(m_surface, m_region);
+		}
+		
+		void initEgl() {
+			EGLint configAttribs[] = {
+				EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
+				EGL_RED_SIZE, 8,
+				EGL_GREEN_SIZE, 8,
+				EGL_BLUE_SIZE, 8,
+				EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+				EGL_NONE
+			};
+			static const EGLint contextAttribs[] = {
+				EGL_CONTEXT_CLIENT_VERSION, 2,
+				EGL_NONE
+			};
+			m_egl_display = eglGetDisplay((EGLNativeDisplayType)m_display);
+			if (m_egl_display == EGL_NO_DISPLAY) {
+				GALE_CRITICAL("Can't create egl display");
+				return;
+			} else {
+				GALE_INFO("Created egl display");
+			}
+			EGLint major = 0;
+			EGLint minor = 0;
+			if (eglInitialize(m_egl_display, &major, &minor) != EGL_TRUE) {
+				GALE_CRITICAL("Can't initialise egl display");
+				return;
+			}
+			GALE_INFO("EGL major=" << major << " minor=" << minor);
+			EGLint count = 0;
+			eglGetConfigs(m_egl_display, nullptr, 0, &count);
+			GALE_INFO("EGL has " << count << " configs");
+			EGLConfig* configs = (EGLConfig*)calloc(count, sizeof *configs);
+			EGLint nnn = 0;
+			eglChooseConfig(m_egl_display, configAttribs, configs, count, &nnn);
+			GALE_INFO("Display all configs:");
+			for (size_t iii=0; iii<nnn; ++iii) {
+				EGLint size = 0;
+				EGLint sizeRed = 0;
+				eglGetConfigAttrib(m_egl_display, configs[iii], EGL_BUFFER_SIZE, &size);
+				eglGetConfigAttrib(m_egl_display, configs[iii], EGL_RED_SIZE, &sizeRed);
+				GALE_INFO("    " << iii << "     BufferSize=" << size << "     red size=" << sizeRed);
+				// just choose the first one
+				m_egl_conf = configs[0];
+			}
+			m_egl_context = eglCreateContext(m_egl_display, m_egl_conf, EGL_NO_CONTEXT, contextAttribs);
+		}
+		
+		void createWindow() {
+			m_egl_window = wl_egl_window_create(m_surface, 480, 360);
+			if (m_egl_window == EGL_NO_SURFACE) {
+				GALE_CRITICAL("Can't create egl window");
+			} else {
+				GALE_INFO("Created egl window");
+			}
+			m_egl_surface = eglCreateWindowSurface(m_egl_display, m_egl_conf, m_egl_window, nullptr);
+			if (eglMakeCurrent(m_egl_display, m_egl_surface, m_egl_surface, m_egl_context)) {
+				GALE_INFO("Made current\n");
+			} else {
+				GALE_ERROR("Made current failed");
+			}
+			
+			glClearColor(1.0, 0.0, 0.0, 1.0);
+			glClear(GL_COLOR_BUFFER_BIT);
+			glFlush();
+			
+			if (eglSwapBuffers(m_egl_display, m_egl_surface)) {
+				GALE_INFO("Swap buffers done");
+			} else {
+				GALE_ERROR("Swapped buffers failed");
+			}
+		}
+		
+		
+		/****************************************************************************************/
+		int32_t run() {
+			while (m_run == true) {
+				auto retDispatch = wl_display_dispatch(m_display);
+				if (retDispatch < 0) {
+					GALE_INFO("Main loop error");
+					m_run = false;
+				} else {
+					GALE_INFO("loop dispatch event " << retDispatch);
+				}
+			}
+			/*
+			bool specialEventThatNeedARedraw = false;
+			// main cycle
+			while(m_run == true) {
+				//GALE_ERROR("plop1");
+				XEvent event;
+				XEvent respond;
+				// main X boucle :
+				while (XPending(m_display)) {
+					XNextEvent(m_display, &event);
+					switch (event.type) {
+						case ClientMessage: {
+							WAYLAND_INFO("Receive : ClientMessage");
+							if(XAtomDeleteWindows == (uint64_t)event.xclient.data.l[0]) {
+								GALE_INFO("     == > Kill Requested ...");
+								OS_Stop();
+								// We do not close here but in the application only:
+								//m_run = false;
+							}
+							break;
+						}
+						///////////////////////////////////////////////////////////////////////////////////////////////////////////////
+						//                               Selection AREA                                                              //
+						///////////////////////////////////////////////////////////////////////////////////////////////////////////////
+						case SelectionClear: {
+							// Selection has been done on an other program  == > clear ours ...
+							WAYLAND_INFO("WAYLAND event SelectionClear");
+							#ifdef DEBUG_WAYLAND_EVENT
+							{
+								XSelectionRequestEvent *req=&(event.xselectionrequest);
+								if (req->property == 0) {
+									GALE_ERROR("Get nullptr ATOM ... property");
+									break;
+								}
+								if (req->target == 0) {
+									GALE_ERROR("Get nullptr ATOM ... target");
+									break;
+								}
+								char * atomNameProperty = XGetAtomName(m_display, req->property);
+								char * atomNameTarget = XGetAtomName(m_display, req->target);
+								GALE_INFO("WAYLAND    property: \"" << atomNameProperty << "\"");
+								GALE_INFO("WAYLAND    target:   \"" << atomNameTarget << "\"");
+								if (atomNameProperty != nullptr) {
+									XFree(atomNameProperty);
+								}
+								if (atomNameTarget != nullptr) {
+									XFree(atomNameTarget);
+								}
+							}
+							#endif
+							if (m_clipBoardOwnerPrimary == true) {
+								m_clipBoardOwnerPrimary = false;
+							} else if (m_clipBoardOwnerStd == true) {
+								m_clipBoardOwnerStd = false;
+							} else {
+								GALE_ERROR("WAYLAND event SelectionClear  == > but no selection requested anymore ...");
+							}
+							break;
+						}
+						case SelectionNotify:
+							WAYLAND_INFO("WAYLAND event SelectionNotify");
+							if (event.xselection.property == None) {
+								GALE_VERBOSE("     == > no data ...");
+							} else {
+								unsigned char *buf = 0;
+								Atom type;
+								int format;
+								unsigned long nitems, bytes;
+								XGetWindowProperty(m_display,
+								                   m_WindowHandle,
+								                   event.xselection.property,
+								                   0, // offset
+								                   (~0L), // length
+								                   False, // delete
+								                   AnyPropertyType, // reg_type
+								                   &type,// *actual_type::return,
+								                   &format,// *actual_format_return
+								                   &nitems,// *nitems_return
+								                   &bytes, // *bytes_after_return
+								                   &buf// **prop_return);
+								                   );
+								if (m_clipBoardRequestPrimary == true) {
+									std::string tmpppp((char*)buf);
+									gale::context::clipBoard::setSystem(gale::context::clipBoard::clipboardSelection, tmpppp);
+									// just transmit an event , we have the data in the system
+									OS_ClipBoardArrive(gale::context::clipBoard::clipboardSelection);
+								} else {
+									std::string tmpppp((char*)buf);
+									gale::context::clipBoard::setSystem(gale::context::clipBoard::clipboardStd, tmpppp);
+									// just transmit an event , we have the data in the system
+									OS_ClipBoardArrive(gale::context::clipBoard::clipboardStd);
+								}
+							}
+							break;
+						case SelectionRequest: {
+							WAYLAND_INFO("WAYLAND event SelectionRequest");
+							XSelectionRequestEvent *req=&(event.xselectionrequest);
+							#ifdef DEBUG_WAYLAND_EVENT
+							{
+								if (req->property == 0) {
+									GALE_ERROR("Get nullptr ATOM ... property");
+									break;
+								}
+								if (req->selection == 0) {
+									GALE_ERROR("Get nullptr ATOM ... selection");
+									break;
+								}
+								if (req->target == 0) {
+									GALE_ERROR("Get nullptr ATOM ... target");
+									break;
+								}
+								char * atomNameProperty = XGetAtomName(m_display, req->property);
+								char * atomNameSelection = XGetAtomName(m_display, req->selection);
+								char * atomNameTarget = XGetAtomName(m_display, req->target);
+								GALE_INFO("    from: " << atomNameProperty << "  request=" << atomNameSelection << " in " << atomNameTarget);
+								if (nullptr != atomNameProperty) { XFree(atomNameProperty); }
+								if (nullptr != atomNameSelection) { XFree(atomNameSelection); }
+								if (nullptr != atomNameTarget) { XFree(atomNameTarget); }
+							}
+							#endif
+							
+							std::string tmpData = "";
+							if (req->selection == XAtomSelection) {
+								tmpData = gale::context::clipBoard::get(gale::context::clipBoard::clipboardSelection);
+							} else if (req->selection == XAtomClipBoard) {
+								tmpData = gale::context::clipBoard::get(gale::context::clipBoard::clipboardStd);
+							}
+							const char * magatTextToSend = tmpData.c_str();
+							Atom listOfAtom[4];
+							if(strlen(magatTextToSend) == 0 ) {
+								respond.xselection.property= None;
+							} else if(XAtomTargetTarget == req->target) {
+								// We need to generate the list of the possibles target element of atom
+								int32_t nbAtomSupported = 0;
+								listOfAtom[nbAtomSupported++] = XAtomTargetTarget;
+								listOfAtom[nbAtomSupported++] = XAtomTargetString;
+								listOfAtom[nbAtomSupported++] = XAtomTargetStringUTF8;
+								listOfAtom[nbAtomSupported++] = None;
+								XChangeProperty( m_display,
+								                 req->requestor,
+								                 req->property,
+								                 XA_ATOM,
+								                 32,
+								                 PropModeReplace,
+								                 (unsigned char*)listOfAtom,
+								                 nbAtomSupported );
+								respond.xselection.property=req->property;
+								GALE_INFO("             == > Respond ... (test)");
+							} else if(XAtomTargetString == req->target) {
+								XChangeProperty( m_display,
+								                 req->requestor,
+								                 req->property,
+								                 req->target,
+								                 8,
+								                 PropModeReplace,
+								                 (unsigned char*)magatTextToSend,
+								                 strlen(magatTextToSend));
+								respond.xselection.property=req->property;
+								GALE_INFO("             == > Respond ...");
+							} else if (XAtomTargetStringUTF8 == req->target) {
+								XChangeProperty( m_display,
+								                 req->requestor,
+								                 req->property,
+								                 req->target,
+								                 8,
+								                 PropModeReplace,
+								                 (unsigned char*)magatTextToSend,
+								                 strlen(magatTextToSend));
+								respond.xselection.property=req->property;
+								GALE_INFO("             == > Respond ...");
+							} else {
+								respond.xselection.property= None;
+							}
+							respond.xselection.type= SelectionNotify;
+							respond.xselection.display= req->display;
+							respond.xselection.requestor= req->requestor;
+							respond.xselection.selection=req->selection;
+							respond.xselection.target= req->target;
+							respond.xselection.time = req->time;
+							XSendEvent (m_display, req->requestor,0,0,&respond);
+							// flush the message on the pipe ...
+							XFlush (m_display);
+							break;
+						}
+						///////////////////////////////////////////////////////////////////////////////////////////////////////////////
+						case Expose:
+							WAYLAND_INFO("WAYLAND event Expose");
+							specialEventThatNeedARedraw = true;
+							break;
+						case GraphicsExpose:
+							WAYLAND_INFO("WAYLAND event GraphicsExpose");
+							specialEventThatNeedARedraw = true;
+							break;
+						case NoExpose:
+							WAYLAND_INFO("WAYLAND event NoExpose");
+							break;
+						case CreateNotify:
+							WAYLAND_INFO("WAYLAND event CreateNotify");
+							break;
+						case DestroyNotify:
+							WAYLAND_INFO("WAYLAND event DestroyNotify");
+							break;
+						case GravityNotify:
+							WAYLAND_INFO("WAYLAND event GravityNotify");
+							break;
+						case VisibilityNotify:
+							WAYLAND_INFO("WAYLAND event VisibilityNotify");
+							break;
+						case CirculateNotify:
+							WAYLAND_INFO("WAYLAND event CirculateNotify");
+							break;
+						case ReparentNotify:
+							WAYLAND_INFO("WAYLAND event ReparentNotify");
+							break;
+						case PropertyNotify:
+							specialEventThatNeedARedraw=true;
+							WAYLAND_INFO("WAYLAND event PropertyNotify");
+							break;
+						case ConfigureNotify:
+							specialEventThatNeedARedraw=true;
+							WAYLAND_INFO("WAYLAND event ConfigureNotify");
+							if (m_display == event.xconfigure.display) {
+								//GALE_INFO("WAYLAND event ConfigureNotify event=" << (int32_t)event.xconfigure.event << "  Window=" << (int32_t)event.xconfigure.window << "  above=" << (int32_t)event.xconfigure.above << "  border_width=" << (int32_t)event.xconfigure.border_width );
+								m_originX = event.xconfigure.x;
+								m_originY = event.xconfigure.y;
+								OS_Move(vec2(event.xconfigure.x,event.xconfigure.y));
+								WAYLAND_INFO("WAYLAND configure windows position : (" << m_originX << "," << m_originY << ")");
+								m_currentHeight = event.xconfigure.height;
+								m_currentWidth = event.xconfigure.width;
+								WAYLAND_INFO("WAYLAND configure windows size : (" << m_currentHeight << "," << m_currentWidth << ")");
+								OS_Resize(vec2(event.xconfigure.width, event.xconfigure.height));
+							}
+							break;
+						case ButtonPress:
+							WAYLAND_INFO("WAYLAND event ButtonPress");
+							m_cursorEventX = event.xbutton.x;
+							m_cursorEventY = (m_currentHeight-event.xbutton.y);
+							if (event.xbutton.button < MAX_MANAGE_INPUT) {
+								m_inputIsPressed[event.xbutton.button] = true;
+							}
+							OS_SetInput(gale::key::type::mouse,
+							            gale::key::status::down,
+							            event.xbutton.button,
+							            vec2(event.xbutton.x, m_cursorEventY));
+							break;
+						case ButtonRelease:
+							WAYLAND_INFO("WAYLAND event ButtonRelease");
+							m_cursorEventX = event.xbutton.x;
+							m_cursorEventY = (m_currentHeight-event.xbutton.y);
+							if (event.xbutton.button < MAX_MANAGE_INPUT) {
+								m_inputIsPressed[event.xbutton.button] = false;
+							}
+							OS_SetInput(gale::key::type::mouse,
+							            gale::key::status::up,
+							            event.xbutton.button,
+							            vec2(event.xbutton.x, m_cursorEventY));
+							break;
+						case EnterNotify:
+							WAYLAND_INFO("WAYLAND event EnterNotify");
+							m_cursorEventX = event.xcrossing.x;
+							m_cursorEventY = (m_currentHeight-event.xcrossing.y);
+							//GALE_DEBUG("WAYLAND event : " << event.type << " = \"EnterNotify\" (" << (float)event.xcrossing.x << "," << (float)event.xcrossing.y << ")");
+							//gui_uniqueWindows->GenEventInput(0, gale::EVENT_INPUT_TYPE_ENTER, (float)event.xcrossing.x, (float)event.xcrossing.y);
+							m_curentGrabDelta -= vec2(m_originX, -m_originY);
+							GALE_VERBOSE("change grab delta of : " << vec2(m_originX, m_originY) );
+							break;
+						case LeaveNotify:
+							WAYLAND_INFO("WAYLAND event LeaveNotify");
+							m_cursorEventX = event.xcrossing.x;
+							m_cursorEventY = (m_currentHeight-event.xcrossing.y);
+							//GALE_DEBUG("WAYLAND event : " << event.type << " = \"LeaveNotify\" (" << (float)event.xcrossing.x << "," << (float)event.xcrossing.y << ")");
+							m_curentGrabDelta += vec2(m_originX, -m_originY);
+							GALE_VERBOSE("change grab delta of : " << vec2(m_originX, m_originY) );
+							break;
+						case MotionNotify:
+							WAYLAND_INFO("WAYLAND event MotionNotify");
+							if(    m_grabAllEvent == true
+							    && event.xmotion.x == int32_t(m_forcePos.x())
+							    && event.xmotion.y == int32_t(m_forcePos.y()) ) {
+								WAYLAND_VERBOSE("WAYLAND reject mouse move (grab mode)");
+								// we get our requested position...
+								m_positionChangeRequested = false;
+								m_curentGrabDelta = vec2(0,0);
+							} else {
+								m_cursorEventX = event.xmotion.x;
+								m_cursorEventY = (m_currentHeight-event.xmotion.y);
+								if(m_grabAllEvent == true) {
+									m_cursorEventX -= m_forcePos.x();
+									m_cursorEventY -= (m_currentHeight-m_forcePos.y());
+								}
+								vec2 newDelta = vec2(m_cursorEventX, m_cursorEventY);
+								if(m_grabAllEvent == true) {
+									m_cursorEventX -= m_curentGrabDelta.x();
+									m_cursorEventY -= m_curentGrabDelta.y();
+								}
+								m_curentGrabDelta = newDelta;
+								// For compatibility of the Android system : 
+								bool findOne = false;
+								for (int32_t iii=0; iii<MAX_MANAGE_INPUT ; iii++) {
+									if (m_inputIsPressed[iii] == true) {
+										WAYLAND_DEBUG("WAYLAND event: bt=" << iii << " " << event.type << " = \"MotionNotify\" (" << m_cursorEventX << "," << m_cursorEventY << ")");
+										OS_SetInput(gale::key::type::mouse,
+										            gale::key::status::move,
+										            iii,
+										            vec2(m_cursorEventX, m_cursorEventY));
+										findOne = true;
+									}
+								}
+								if (findOne == false) {
+									WAYLAND_DEBUG("WAYLAND event: bt=" << 0 << " " << event.type << " = \"MotionNotify\" (" << m_cursorEventX << "," << m_cursorEventY << ")");
+										OS_SetInput(gale::key::type::mouse,
+										            gale::key::status::move,
+										            0,
+										            vec2(m_cursorEventX, m_cursorEventY));
+								}
+								if (m_grabAllEvent == true) {
+									if (m_positionChangeRequested == false) {
+										WAYLAND_DEBUG("WAYLAND set pointer position : " << m_forcePos);
+										XWarpPointer(m_display, None, m_WindowHandle, 0,0, 0, 0, m_forcePos.x(), m_forcePos.y());
+										XFlush(m_display);
+										m_positionChangeRequested = true;
+									}
+								}
+							}
+							break;
+						case FocusIn:
+							WAYLAND_INFO("WAYLAND event focusIn");
+							specialEventThatNeedARedraw=true;
+							break;
+						case FocusOut:
+							WAYLAND_INFO("WAYLAND event : focusOut");
+							specialEventThatNeedARedraw=true;
+							break;
+						case KeyPress:
+						case KeyRelease: {
+							bool thisIsAReapeateKey = false;
+							// filter repeate key : 
+							if(    event.type == KeyRelease
+							    && XEventsQueued(m_display, QueuedAfterReading)) {
+								XEvent nev;
+								XPeekEvent(m_display, &nev);
+								if(    nev.type == KeyPress
+								    && nev.xkey.time == event.xkey.time
+								    && nev.xkey.keycode == event.xkey.keycode) {
+									// Key was not actually released
+									// remove next event too ...
+									
+									//This remove repeate key
+									XNextEvent(m_display, &nev);
+									//break;
+									
+									thisIsAReapeateKey = true;
+								}
+							}
+							WAYLAND_INFO("WAYLAND event : " << event.type << " = 'KeyPress/KeyRelease' ");
+							{
+								WAYLAND_DEBUG("eventKey : " << event.xkey.keycode << " state : " << event.xkey.state);
+								if (event.xkey.state & (1<<0) ) {
+									//GALE_DEBUG("    Special Key : SHIFT");
+									m_guiKeyBoardMode.setShift(true);
+								} else {
+									m_guiKeyBoardMode.setShift(false);
+								}
+								if (event.xkey.state & (1<<1) ) {
+									//GALE_DEBUG("    Special Key : CAPS_LOCK");
+									m_guiKeyBoardMode.setCapsLock(true);
+								} else {
+									m_guiKeyBoardMode.setCapsLock(false);
+								}
+								if (event.xkey.state & (1<<2) ) {
+									//GALE_DEBUG("    Special Key : Ctrl");
+									m_guiKeyBoardMode.setCtrl(true);
+								} else {
+									m_guiKeyBoardMode.setCtrl(false);
+								}
+								if (event.xkey.state & (1<<3) ) {
+									//GALE_DEBUG("    Special Key : Alt");
+									m_guiKeyBoardMode.setAlt(true);
+								} else {
+									m_guiKeyBoardMode.setAlt(false);
+								}
+								if (event.xkey.state & (1<<4) ) {
+									//GALE_DEBUG("    Special Key : VER_num");
+									m_guiKeyBoardMode.setNumLock(true);
+								} else {
+									m_guiKeyBoardMode.setNumLock(false);
+								}
+								if (event.xkey.state & (1<<5) ) {
+									GALE_DEBUG("    Special Key : MOD");
+								}
+								if (event.xkey.state & (1<<6) ) {
+									//GALE_DEBUG("    Special Key : META");
+									m_guiKeyBoardMode.setMeta(true);
+								} else {
+									m_guiKeyBoardMode.setMeta(false);
+								}
+								if (event.xkey.state & (1<<7) ) {
+									//GALE_DEBUG("    Special Key : ALT_GR");
+									m_guiKeyBoardMode.setAltGr(true);
+								} else {
+									m_guiKeyBoardMode.setAltGr(false);
+								}
+								bool find = true;
+								enum gale::key::keyboard keyInput;
+								switch (event.xkey.keycode) {
+									//case 80: // keypad
+									case 111:	keyInput = gale::key::keyboard::up;            break;
+									//case 83: // keypad
+									case 113:	keyInput = gale::key::keyboard::left;          break;
+									//case 85: // keypad
+									case 114:	keyInput = gale::key::keyboard::right;         break;
+									//case 88: // keypad
+									case 116:	keyInput = gale::key::keyboard::down;          break;
+									//case 81: // keypad
+									case 112:	keyInput = gale::key::keyboard::pageUp;        break;
+									//case 89: // keypad
+									case 117:	keyInput = gale::key::keyboard::pageDown;      break;
+									//case 79: // keypad
+									case 110:	keyInput = gale::key::keyboard::start;         break;
+									//case 87: // keypad
+									case 115:	keyInput = gale::key::keyboard::end;           break;
+									case 78:	keyInput = gale::key::keyboard::stopDefil;     break;
+									case 127:	keyInput = gale::key::keyboard::wait;          break;
+									//case 90: // keypad
+									case 118:
+										keyInput = gale::key::keyboard::insert;
+										if(event.type == KeyRelease) {
+											if (m_guiKeyBoardMode.getInsert() == true) {
+												m_guiKeyBoardMode.setInsert(false);
+											} else {
+												m_guiKeyBoardMode.setInsert(true);
+											}
+										}
+										break;
+									//case 84:  keyInput = gale::key::keyboardCenter; break; // Keypad
+									case 67:    keyInput = gale::key::keyboard::f1; break;
+									case 68:    keyInput = gale::key::keyboard::f2; break;
+									case 69:    keyInput = gale::key::keyboard::f3; break;
+									case 70:    keyInput = gale::key::keyboard::f4; break;
+									case 71:    keyInput = gale::key::keyboard::f5; break;
+									case 72:    keyInput = gale::key::keyboard::f6; break;
+									case 73:    keyInput = gale::key::keyboard::f7; break;
+									case 74:    keyInput = gale::key::keyboard::f8; break;
+									case 75:    keyInput = gale::key::keyboard::f9; break;
+									case 76:    keyInput = gale::key::keyboard::f10; break;
+									case 95:    keyInput = gale::key::keyboard::f11; break;
+									case 96:    keyInput = gale::key::keyboard::f12; break;
+									case 66:    keyInput = gale::key::keyboard::capLock;     m_guiKeyBoardMode.setCapsLock( (event.type == KeyPress) ? true : false); break;
+									case 50:    keyInput = gale::key::keyboard::shiftLeft;   m_guiKeyBoardMode.setShift   ( (event.type == KeyPress) ? true : false); break;
+									case 62:    keyInput = gale::key::keyboard::shiftRight;  m_guiKeyBoardMode.setShift   ( (event.type == KeyPress) ? true : false); break;
+									case 37:    keyInput = gale::key::keyboard::ctrlLeft;    m_guiKeyBoardMode.setCtrl    ( (event.type == KeyPress) ? true : false); break;
+									case 105:   keyInput = gale::key::keyboard::ctrlRight;   m_guiKeyBoardMode.setCtrl    ( (event.type == KeyPress) ? true : false); break;
+									case 133:   keyInput = gale::key::keyboard::metaLeft;    m_guiKeyBoardMode.setMeta    ( (event.type == KeyPress) ? true : false); break;
+									case 134:   keyInput = gale::key::keyboard::metaRight;   m_guiKeyBoardMode.setMeta    ( (event.type == KeyPress) ? true : false); break;
+									case 64:    keyInput = gale::key::keyboard::alt;         m_guiKeyBoardMode.setAlt     ( (event.type == KeyPress) ? true : false); break;
+									case 108:   keyInput = gale::key::keyboard::altGr;       m_guiKeyBoardMode.setAltGr   ( (event.type == KeyPress) ? true : false); break;
+									case 135:   keyInput = gale::key::keyboard::contextMenu; break;
+									case 77:    keyInput = gale::key::keyboard::numLock;     m_guiKeyBoardMode.setNumLock ( (event.type == KeyPress) ? true : false); break;
+									case 91: // Suppr on keypad
+										find = false;
+										if(m_guiKeyBoardMode.getNumLock() == true){
+											OS_setKeyboard(m_guiKeyBoardMode,
+											               gale::key::keyboard::character,
+											               (event.type==KeyPress?gale::key::status::down:gale::key::status::up),
+											               thisIsAReapeateKey,
+											               '.');
+											if (thisIsAReapeateKey == true) {
+												OS_setKeyboard(m_guiKeyBoardMode,
+												               gale::key::keyboard::character,
+												               (event.type!=KeyPress?gale::key::status::down:gale::key::status::up),
+												               thisIsAReapeateKey,
+												               '.');
+											}
+										} else {
+											OS_setKeyboard(m_guiKeyBoardMode,
+											               gale::key::keyboard::character,
+											               (event.type==KeyPress?gale::key::status::down:gale::key::status::up),
+											               thisIsAReapeateKey,
+											               0x7F);
+											if (thisIsAReapeateKey == true) {
+												OS_setKeyboard(m_guiKeyBoardMode,
+												               gale::key::keyboard::character,
+												               (event.type!=KeyPress?gale::key::status::down:gale::key::status::up),
+												               thisIsAReapeateKey,
+												               0x7F);
+											}
+										}
+										break;
+									case 23: // special case for TAB
+										find = false;
+										OS_setKeyboard(m_guiKeyBoardMode,
+										               gale::key::keyboard::character,
+										               (event.type==KeyPress?gale::key::status::down:gale::key::status::up),
+										               thisIsAReapeateKey,
+										               0x09);
+										if (thisIsAReapeateKey == true) {
+											OS_setKeyboard(m_guiKeyBoardMode,
+											               gale::key::keyboard::character,
+											               (event.type!=KeyPress?gale::key::status::down:gale::key::status::up),
+											               thisIsAReapeateKey,
+											               0x09);
+										}
+										break;
+									default:
+										find = false;
+										{
+											char buf[11];
+											//GALE_DEBUG("Keycode: " << event.xkey.keycode);
+											// change keystate for simple reson of the ctrl error...
+											int32_t keyStateSave = event.xkey.state;
+											if (event.xkey.state & (1<<2) ) {
+												event.xkey.state = event.xkey.state & 0xFFFFFFFB;
+											}
+											KeySym keysym;
+											Status status = 0;
+											//int count = Xutf8LookupString(m_xic, (XKeyPressedEvent*)&event, buf, 10, &keysym, &status);
+											int count = Xutf8LookupString(m_xic, &event.xkey, buf, 10, &keysym, &status);
+											// retreave real keystate
+											event.xkey.state = keyStateSave;
+											buf[count] = '\0';
+											// Replace \r error ...
+											if (buf[0] == '\r') {
+												buf[0] = '\n';
+												buf[1] = '\0';
+											}
+											if (count >= 0) {
+												// repeated kay from previous element :
+												if (count > 0) {
+													// transform it in unicode
+													m_lastKeyPressed = utf8::convertChar32(buf);
+												}
+												WAYLAND_INFO("event Key : " << event.xkey.keycode << " char=\"" << buf << "\"'len=" << strlen(buf) << " unicode=" << m_lastKeyPressed);
+												OS_setKeyboard(m_guiKeyBoardMode,
+												               gale::key::keyboard::character,
+												               (event.type==KeyPress?gale::key::status::down:gale::key::status::up),
+												               thisIsAReapeateKey,
+												               m_lastKeyPressed);
+												if (thisIsAReapeateKey == true) {
+													OS_setKeyboard(m_guiKeyBoardMode,
+													               gale::key::keyboard::character,
+													               (event.type!=KeyPress?gale::key::status::down:gale::key::status::up),
+													               thisIsAReapeateKey,
+													               m_lastKeyPressed);
+												}
+											} else {
+												GALE_WARNING("Unknow event Key : " << event.xkey.keycode << " res='" << buf << "' repeate=" << thisIsAReapeateKey);
+											}
+										}
+										break;
+								}
+								if (find == true) {
+									//GALE_DEBUG("eventKey Move type : " << getCharTypeMoveEvent(keyInput) );
+									OS_setKeyboard(m_guiKeyBoardMode,
+									               keyInput,
+									               (event.type==KeyPress?gale::key::status::down:gale::key::status::up),
+									               thisIsAReapeateKey);
+									if (thisIsAReapeateKey == true) {
+										OS_setKeyboard(m_guiKeyBoardMode,
+										               keyInput,
+										               (event.type!=KeyPress?gale::key::status::down:gale::key::status::up),
+										               thisIsAReapeateKey);
+									}
+								}
+							}
+							break;
+						}
+						//case DestroyNotify:
+						//	break;
+						case MapNotify:
+							WAYLAND_INFO("WAYLAND event : MapNotify");
+							specialEventThatNeedARedraw=true;
+							OS_Show();
+							break;
+						case UnmapNotify:
+							WAYLAND_INFO("WAYLAND event : UnmapNotify");
+							specialEventThatNeedARedraw=true;
+							OS_Hide();
+							break;
+						default:
+							WAYLAND_INFO("WAYLAND event : " << event.type << " = \"???\"");
+							break;
+					}
+				}
+				if(m_run == true) {
+					if (m_doubleBuffered && hasDisplay) {
+						#if defined(__TARGET_OS__Web)
+							glfwSwapBuffers();
+						#else
+							glXSwapBuffers(m_display, m_WindowHandle);
+						#endif
+						XSync(m_display,0);
+					}
+					// draw after switch the previous windows ...
+					//GALE_DEBUG("specialEventThatNeedARedraw"<<specialEventThatNeedARedraw);
+					hasDisplay = OS_Draw(specialEventThatNeedARedraw);
+					specialEventThatNeedARedraw = false;
+				}
+			}
+			*/
+			return 0;
+		}
+		/****************************************************************************************/
+		virtual void stop() {
+			WAYLAND_INFO("WAYLAND-API: Stop");
+			m_run = false;
+		}
+		/****************************************************************************************/
+		virtual void setSize(const vec2& _size) {
+			WAYLAND_INFO("WAYLAND-API: changeSize=" << _size);
+			/*
+			m_currentHeight = _size.y();
+			m_currentWidth = _size.x();
+			XResizeWindow(m_display, m_WindowHandle, _size.x(), _size.y());
+			*/
+		}
+		/****************************************************************************************/
+		void setFullScreen(bool _status) {
+			WAYLAND_INFO("WAYLAND-API: changeFullscreen=" << _status);
+			/*
+			XEvent event;
+			event.xclient.type = ClientMessage;
+			event.xclient.serial = 0;
+			event.xclient.send_event = True;
+			event.xclient.display = m_display;
+			event.xclient.window = m_WindowHandle;
+			event.xclient.message_type = XInternAtom(m_display, "_NET_WM_STATE", False);
+			event.xclient.format = 32;
+			if (_status == true) {
+				event.xclient.data.l[0] = 1;//XInternAtom(m_display, "_NET_WM_STATE_REMOVE", False);
+			} else {
+				event.xclient.data.l[0] = 0;//XInternAtom(m_display, "_NET_WM_STATE_ADD", False);
+			}
+			event.xclient.data.l[1] = XInternAtom(m_display, "_NET_WM_STATE_FULLSCREEN", False);
+			event.xclient.data.l[2] = 0;
+			event.xclient.data.l[3] = 0;
+			event.xclient.data.l[4] = 0;
+			
+			//long mask = SubstructureNotifyMask;
+			//long mask = StructureNotifyMask | ResizeRedirectMask;
+			//long mask = SubstructureRedirectMask;
+			long mask = PropertyChangeMask;
+			
+			XSendEvent(m_display,
+			           RootWindow(m_display, DefaultScreen(m_display)),
+			           False,
+			           mask,
+			           &event);
+			// associate the keyboard grabing (99% associated case)
+			grabKeyboardEvents(_status);
+			*/
+		}
+		/****************************************************************************************/
+		virtual void grabKeyboardEvents(bool _status) {
+			/*
+			if (_status == true) {
+				WAYLAND_INFO("WAYLAND-API: Grab Keyboard Events");
+				XGrabKeyboard(m_display, m_WindowHandle,
+				              False,
+				              GrabModeAsync,
+				              GrabModeAsync,
+				              CurrentTime);
+			} else {
+				WAYLAND_INFO("WAYLAND-API: Un-Grab Keyboard Events");
+				XUngrabKeyboard(m_display, CurrentTime);
+			}
+			*/
+		}
+		/****************************************************************************************/
+		virtual void setWindowsDecoration(bool _status) {
+			WAYLAND_INFO("WAYLAND-API: setWindows Decoration :" << _status);
+			/*
+			// Remove/set decoration
+			Hints hints;
+			hints.flags = 2;
+			if (_status == true) {
+				hints.decorations = 1;
+			} else {
+				hints.decorations = 0;
+			}
+			XChangeProperty(m_display, m_WindowHandle,
+			                XInternAtom(m_display, "_MOTIF_WM_HINTS", False),
+			                XInternAtom(m_display, "_MOTIF_WM_HINTS", False),
+			                32, PropModeReplace,
+			                (unsigned char *)&hints,5);
+			*/
+		};
+		/****************************************************************************************/
+		virtual void setPos(const vec2& _pos) {
+			WAYLAND_INFO("WAYLAND-API: changePos=" << _pos);
+			/*
+			m_windowsPos = _pos;
+			XMoveWindow(m_display, m_WindowHandle, _pos.x(), _pos.y());
+			m_originX = _pos.x();
+			m_originY = _pos.y();
+			*/
+		}
+		/****************************************************************************************/
+		/*
+		virtual void getAbsPos(ivec2& pos) {
+			WAYLAND_INFO("WAYLAND-API: getAbsPos");
+			int tmp;
+			unsigned int tmp2;
+			Window fromroot, tmpwin;
+			XQueryPointer(m_display, m_WindowHandle, &fromroot, &tmpwin, &pos.m_floats[0], &pos.m_floats[1], &tmp, &tmp, &tmp2);
+		}
+		*/
+		/****************************************************************************************/
+		virtual void setCursor(enum gale::context::cursor _newCursor) {
+			/*
+			if (_newCursor != m_currentCursor) {
+				WAYLAND_DEBUG("WAYLAND-API: set New Cursor : " << _newCursor);
+				// undefine previous cursors ...
+				XUndefineCursor(m_display, m_WindowHandle);
+				// set the new one :
+				m_currentCursor = _newCursor;
+				Cursor myCursor = None;
+				switch (m_currentCursor) {
+					case gale::context::cursor::none:
+						{
+							Pixmap bitmapNoData;
+							XColor black;
+							static char noData[] = { 0,0,0,0,0,0,0,0 };
+							black.red = 0;
+							black.green = 0;
+							black.blue = 0;
+							bitmapNoData = XCreateBitmapFromData(m_display, m_WindowHandle, noData, 8, 8);
+							myCursor = XCreatePixmapCursor(m_display, bitmapNoData, bitmapNoData, 
+							                               &black, &black, 0, 0);
+						}
+						break;
+					case gale::context::cursor::leftArrow:
+						myCursor = XCreateFontCursor(m_display, XC_top_left_arrow);
+						break;
+					case gale::context::cursor::info:
+						myCursor = XCreateFontCursor(m_display, XC_hand1);
+						break;
+					case gale::context::cursor::destroy:
+						myCursor = XCreateFontCursor(m_display, XC_pirate);
+						break;
+					case gale::context::cursor::help:
+						myCursor = XCreateFontCursor(m_display, XC_question_arrow);
+						break;
+					case gale::context::cursor::cycle:
+						myCursor = XCreateFontCursor(m_display, XC_exchange);
+						break;
+					case gale::context::cursor::spray:
+						myCursor = XCreateFontCursor(m_display, XC_spraycan);
+						break;
+					case gale::context::cursor::wait:
+						myCursor = XCreateFontCursor(m_display, XC_watch);
+						break;
+					case gale::context::cursor::text:
+						myCursor = XCreateFontCursor(m_display, XC_xterm);
+						break;
+					case gale::context::cursor::crossHair:
+						myCursor = XCreateFontCursor(m_display, XC_crosshair);
+						break;
+					case gale::context::cursor::slideUpDown:
+						myCursor = XCreateFontCursor(m_display, XC_sb_v_double_arrow);
+						break;
+					case gale::context::cursor::slideLeftRight:
+						myCursor = XCreateFontCursor(m_display, XC_sb_h_double_arrow);
+						break;
+					case gale::context::cursor::resizeUp:
+						myCursor = XCreateFontCursor(m_display, XC_top_side);
+						break;
+					case gale::context::cursor::resizeDown:
+						myCursor = XCreateFontCursor(m_display, XC_bottom_side);
+						break;
+					case gale::context::cursor::resizeLeft:
+						myCursor = XCreateFontCursor(m_display, XC_left_side);
+						break;
+					case gale::context::cursor::resizeRight:
+						myCursor = XCreateFontCursor(m_display, XC_right_side);
+						break;
+					case gale::context::cursor::cornerTopLeft:
+						myCursor = XCreateFontCursor(m_display, XC_top_left_corner);
+						break;
+					case gale::context::cursor::cornerTopRight:
+						myCursor = XCreateFontCursor(m_display, XC_top_right_corner);
+						break;
+					case gale::context::cursor::cornerButtomLeft:
+						myCursor = XCreateFontCursor(m_display, XC_bottom_right_corner);
+						break;
+					case gale::context::cursor::cornerButtomRight:
+						myCursor = XCreateFontCursor(m_display, XC_bottom_left_corner);
+						break;
+					default :
+						// nothing to do ... basic pointer ...
+						break;
+				}
+				if (myCursor != None) {
+					XDefineCursor(m_display, m_WindowHandle, myCursor);
+					XFreeCursor(m_display, myCursor);
+				}
+			}
+			*/
+		}
+		/****************************************************************************************/
+		void grabPointerEvents(bool _status, const vec2& _forcedPosition) {
+			/*
+			if (_status == true) {
+				WAYLAND_DEBUG("WAYLAND-API: Grab Events");
+				int32_t test = XGrabPointer(m_display,RootWindow(m_display, DefaultScreen(m_display)), True,
+				                            ButtonPressMask |
+				                            ButtonReleaseMask |
+				                            PointerMotionMask |
+				                            FocusChangeMask |
+				                            EnterWindowMask |
+				                            LeaveWindowMask,
+				                            GrabModeAsync,
+				                            GrabModeAsync,
+				                            RootWindow(m_display, DefaultScreen(m_display)),
+				                            None,
+				                            CurrentTime);
+				if (GrabSuccess != test) {
+					GALE_CRITICAL("Display error " << test);
+					switch (test) {
+						case BadCursor:
+							GALE_CRITICAL(" BadCursor");
+							break;
+						case BadValue:
+							GALE_CRITICAL(" BadValue");
+							break;
+						case BadWindow:
+							GALE_CRITICAL(" BadWindow");
+							break;
+					}
+				}
+				m_forcePos = _forcedPosition;
+				m_forcePos.setY(m_currentHeight - m_forcePos.y());
+				m_grabAllEvent = true;
+				// change the pointer position to generate a good mouving at the start ...
+				WAYLAND_DEBUG("WAYLAND-API: set pointer position : " << m_forcePos);
+				XWarpPointer(m_display, None, m_WindowHandle, 0,0, 0, 0, m_forcePos.x(), m_forcePos.y());
+				XFlush(m_display);
+				m_positionChangeRequested = true;
+				m_curentGrabDelta = vec2(0,0);
+			} else {
+				WAYLAND_DEBUG("WAYLAND-API: Un-Grab Events");
+				XUngrabPointer(m_display, CurrentTime);
+				m_grabAllEvent = false;
+				m_forcePos = vec2(0,0);
+				m_curentGrabDelta = vec2(0,0);
+			}
+			*/
+		}
+		/****************************************************************************************/
+		void setIcon(const std::string& _inputFile) {
+			/*
+			#if    defined(GALE_BUILD_EGAMI) \
+			    && !defined(__TARGET_OS__Web)
+				egami::Image dataImage = egami::load(_inputFile);
+				// load data
+				if (dataImage.exist() == false) {
+					GALE_ERROR("Error when loading Icon");
+					return;
+				}
+				int32_t depth = DefaultDepth(m_display, DefaultScreen(m_display) );
+				GALE_DEBUG("WAYLAND Create icon size=(" << dataImage.getWidth() << "," << dataImage.getHeight() << ") depth=" << depth);
+				switch(depth) {
+					case 8:
+						GALE_CRITICAL("Not manage pixmap in 8 bit...  == > no icon ...");
+						return;
+					case 16:
+						break;
+					case 24:
+						break;
+					case 32:
+						break;
+					default:
+						GALE_CRITICAL("Unknow thys type of bitDepth : " << depth);
+						return;
+				}
+				char* tmpVal = new char[4*dataImage.getWidth()*dataImage.getHeight()];
+				if (nullptr == tmpVal) {
+					GALE_CRITICAL("Allocation error ...");
+					return;
+				}
+				char* tmpPointer = tmpVal;
+				switch(depth) {
+					case 16:
+						for(ivec2 pos(0,0); pos.y()<dataImage.getHeight(); pos.setY(pos.y()+1)) {
+							for(pos.setX(0); pos.x()<dataImage.getHeight();  pos.setX(pos.x()+1)) {
+								etk::Color<> tmpColor = dataImage.get(pos);
+								int16_t tmpVal =   (((uint16_t)((uint16_t)tmpColor.r()>>3))<<11)
+								                 + (((uint16_t)((uint16_t)tmpColor.g()>>2))<<5)
+								                 +  ((uint16_t)((uint16_t)tmpColor.b()>>3));
+								*tmpPointer++ = (uint8_t)(tmpVal>>8);
+								*tmpPointer++ = (uint8_t)(tmpVal&0x00FF);
+							}
+						}
+						break;
+					case 24:
+						for(ivec2 pos(0,0); pos.y()<dataImage.getHeight(); pos.setY(pos.y()+1)) {
+							for(pos.setX(0); pos.x()<dataImage.getHeight();  pos.setX(pos.x()+1)) {
+								etk::Color<> tmpColor = dataImage.get(pos);
+								*tmpPointer++ = tmpColor.b();
+								*tmpPointer++ = tmpColor.g();
+								*tmpPointer++ = tmpColor.r();
+								tmpPointer++;
+							}
+						}
+						break;
+					case 32:
+						for(ivec2 pos(0,0); pos.y()<dataImage.getHeight(); pos.setY(pos.y()+1)) {
+							for(pos.setX(0); pos.x()<dataImage.getHeight();  pos.setX(pos.x()+1)) {
+								etk::Color<> tmpColor = dataImage.get(pos);
+								*tmpPointer++ = tmpColor.a();
+								*tmpPointer++ = tmpColor.b();
+								*tmpPointer++ = tmpColor.g();
+								*tmpPointer++ = tmpColor.r();
+							}
+						}
+						break;
+					default:
+						return;
+				}
+				
+				XImage* myImage = XCreateImage(m_display,
+				                               m_visual->visual,
+				                               depth,
+				                               ZPixmap,
+				                               0,
+				                               (char*)tmpVal,
+				                               dataImage.getWidth(),
+				                               dataImage.getHeight(),
+				                               32,
+				                               0);
+				
+				Pixmap tmpPixmap = XCreatePixmap(m_display,
+				                                 m_WindowHandle,
+				                                 dataImage.getWidth(),
+				                                 dataImage.getHeight(),
+				                                 depth);
+				switch(tmpPixmap) {
+					case BadAlloc:
+						GALE_ERROR("WAYLAND: BadAlloc");
+						break;
+					case BadDrawable:
+						GALE_ERROR("WAYLAND: BadDrawable");
+						break;
+					case BadValue:
+						GALE_ERROR("WAYLAND: BadValue");
+						break;
+					default:
+						GALE_DEBUG("Create Pixmap OK");
+						break;
+				}
+				GC tmpGC = DefaultGC(m_display, DefaultScreen(m_display) );
+				int error = XPutImage(m_display,
+				                      tmpPixmap,
+				                      tmpGC,
+				                      myImage,
+				                      0, 0, 0, 0,
+				                      dataImage.getWidth(),
+				                      dataImage.getHeight());
+				switch(error) {
+					case BadDrawable:
+						GALE_ERROR("WAYLAND: BadDrawable");
+						break;
+					case BadGC:
+						GALE_ERROR("WAYLAND: BadGC");
+						break;
+					case BadMatch:
+						GALE_ERROR("WAYLAND: BadMatch");
+						break;
+					case BadValue:
+						GALE_ERROR("WAYLAND: BadValue");
+						break;
+					default:
+						GALE_DEBUG("insert image OK");
+						break;
+				}
+				// allocate a WM hints structure.
+				XWMHints* win_hints = XAllocWMHints();
+				if (win_hints == nullptr) {
+					GALE_ERROR("XAllocWMHints - out of memory");
+					return;
+				}
+				// initialize the structure appropriately. first, specify which size hints we want to fill in. in our case - setting the icon's pixmap.
+				win_hints->flags = IconPixmapHint;
+				// next, specify the desired hints data. in our case - supply the icon's desired pixmap.
+				win_hints->icon_pixmap = tmpPixmap;
+				// pass the hints to the window manager.
+				XSetWMHints(m_display, m_WindowHandle, win_hints);
+				GALE_INFO("     == > might be done ");
+				// finally, we can free the WM hints structure.
+				XFree(win_hints);
+				
+				// Note when we free the pixmap ... the icon is removed ...  == > this is a real memory leek ...
+				//XFreePixmap(m_display, tmpPixmap);
+				
+				myImage->data = nullptr;
+				XDestroyImage(myImage);
+				delete[] tmpVal;
+			#endif
+			*/
+		}
+		/****************************************************************************************/
+		bool createOGlContext() {
+			#if 0
+			WAYLAND_INFO("WAYLAND:CreateOGlContext");
+			#if defined(__TARGET_OS__Web)
+				/* create a GLX context */
+				GContext RenderContext = wglCreateContext(m_display, 0, GL_TRUE);
+				/* connect the glx-context to the window */
+				wglMakeCurrent(m_display, m_WindowHandle, RenderContext);
+				if (glwIsDirect(m_display, RenderContext)) {
+					GALE_INFO("XF86 DRI enabled\n");
+				} else {
+					GALE_INFO("XF86 DRI NOT available\n");
+				}
+			#else
+				/* create a GLX context */
+				GLXContext RenderContext = glXCreateContext(m_display, m_visual, 0, GL_TRUE);
+				/* connect the glx-context to the window */
+				glXMakeCurrent(m_display, m_WindowHandle, RenderContext);
+				if (glXIsDirect(m_display, RenderContext)) {
+					GALE_INFO("XF86 DRI enabled\n");
+				} else {
+					GALE_INFO("XF86 DRI NOT available\n");
+				}
+			#endif
+			// enable vertical synchronisation : (some computer has synchronisation disable)
+			setVSync(true);
+			#endif
+			return true;
+		}
+		/****************************************************************************************/
+		void setTitle(const std::string& _title) {
+			WAYLAND_INFO("WAYLAND: set Title (START)");
+			/*
+			XTextProperty tp;
+			tp.value = (unsigned char *)_title.c_str();
+			tp.encoding = XA_WM_NAME;
+			tp.format = 8;
+			tp.nitems = strlen((const char*)tp.value);
+			XSetWMName(m_display, m_WindowHandle, &tp);
+			XStoreName(m_display, m_WindowHandle, (const char*)tp.value);
+			XSetIconName(m_display, m_WindowHandle, (const char*)tp.value);
+			XSetWMIconName(m_display, m_WindowHandle, &tp);
+			*/
+			WAYLAND_INFO("WAYLAND: set Title (END)");
+		}
+		void openURL(const std::string& _url) {
+			std::string req = "xdg-open ";
+			req += _url;
+			system(req.c_str());
+			return;
+		}
+		/****************************************************************************************/
+		void clipBoardGet(enum gale::context::clipBoard::clipboardListe _clipboardID) {
+			/*
+			switch (_clipboardID) {
+				case gale::context::clipBoard::clipboardSelection:
+					if (m_clipBoardOwnerPrimary == false) {
+						m_clipBoardRequestPrimary = true;
+						// generate a request on WAYLAND
+						XConvertSelection(m_display,
+						                  XAtomSelection,
+						                  XAtomTargetStringUTF8,
+						                  XAtomGALE,
+						                  m_WindowHandle,
+						                  CurrentTime);
+					} else {
+						// just transmit an event , we have the data in the system
+						OS_ClipBoardArrive(_clipboardID);
+					}
+					break;
+				case gale::context::clipBoard::clipboardStd:
+					if (m_clipBoardOwnerStd == false) {
+						m_clipBoardRequestPrimary = false;
+						// generate a request on WAYLAND
+						XConvertSelection(m_display,
+						                  XAtomClipBoard,
+						                  XAtomTargetStringUTF8,
+						                  XAtomGALE,
+						                  m_WindowHandle,
+						                  CurrentTime);
+					} else {
+						// just transmit an event , we have the data in the system
+						OS_ClipBoardArrive(_clipboardID);
+					}
+					break;
+				default:
+					GALE_ERROR("Request an unknow ClipBoard ...");
+					break;
+			}
+			*/
+		}
+		/****************************************************************************************/
+		void clipBoardSet(enum gale::context::clipBoard::clipboardListe _clipboardID) {
+			/*
+			switch (_clipboardID) {
+				case gale::context::clipBoard::clipboardSelection:
+					// Request the selection :
+					if (m_clipBoardOwnerPrimary == false) {
+						XSetSelectionOwner(m_display, XAtomSelection, m_WindowHandle, CurrentTime);
+						m_clipBoardOwnerPrimary = true;
+					}
+					break;
+				case gale::context::clipBoard::clipboardStd:
+					// Request the clipBoard :
+					if (m_clipBoardOwnerStd == false) {
+						XSetSelectionOwner(m_display, XAtomClipBoard, m_WindowHandle, CurrentTime);
+						m_clipBoardOwnerStd = true;
+					}
+					break;
+				default:
+					GALE_ERROR("Request an unknow ClipBoard ...");
+					break;
+			}
+			*/
+		}
+};
+
+
+static void global_registry_handler(void* _data, struct wl_registry* _registry, uint32_t _id, const char* _interface, uint32_t _version) {
+	WAYLANDInterface* interface = (WAYLANDInterface*)_data;
+	if (interface == nullptr) {
+		return;
+	}
+	interface->registryHandler(_registry, _id, _interface, _version);
+}
+
+static void global_registry_remover(void* _data, struct wl_registry* _registry, uint32_t _id) {
+	WAYLANDInterface* interface = (WAYLANDInterface*)_data;
+	if (interface == nullptr) {
+		return;
+	}
+	interface->registryRemover(_registry, _id);
+}
+
+
+/**
+ * @brief Main of the program
+ * @param std IO
+ * @return std IO
+ */
+int gale::run(gale::Application* _application, int _argc, const char *_argv[]) {
+	etk::init(_argc, _argv);
+	WAYLANDInterface* interface = new WAYLANDInterface(_application, _argc, _argv);
+	if (interface == nullptr) {
+		GALE_CRITICAL("Can not create the WAYLAND interface ... MEMORY allocation error");
+		return -2;
+	}
+	int32_t retValue = interface->run();
+	delete(interface);
+	interface = nullptr;
+	return retValue;
+}
diff --git a/lutin_gale.py b/lutin_gale.py
index 1135caa..5e65a5f 100644
--- a/lutin_gale.py
+++ b/lutin_gale.py
@@ -64,7 +64,11 @@ def configure(target, my_module):
 	if "Web" in target.get_type():
 		my_module.add_src_file('gale/context/SDL/Context.cpp')
 	elif "Linux" in target.get_type():
-		my_module.add_src_file('gale/context/X11/Context.cpp')
+		# TODO : Do it better ...
+		if False:
+			my_module.add_src_file('gale/context/X11/Context.cpp')
+		else:
+			my_module.add_src_file('gale/context/wayland/Context.cpp')
 		# check if egami is present in the worktree: this is for the icon parsing ...
 		my_module.add_optionnal_depend('egami', ["c++", "-DGALE_BUILD_EGAMI"])
 	elif "Windows" in target.get_type():
@@ -157,7 +161,14 @@ def configure(target, my_module):
 		    "SDL"
 		    ])
 	elif "Linux" in target.get_type():
-		pass
+		if False:
+			my_module.add_depend("X11")
+		else:
+			my_module.add_depend([
+			    'wayland',
+			    'egl',
+			    'gles2'
+			    ])
 	elif "Android" in target.get_type():
 		my_module.add_depend(["SDK", "jvm-basics"])
 		# add tre creator of the basic java class ...
diff --git a/sample/basic.cpp b/sample/basic.cpp
index 8969dd8..39e9364 100644
--- a/sample/basic.cpp
+++ b/sample/basic.cpp
@@ -98,7 +98,7 @@ class MainApplication : public gale::Application {
 			mat4 tmpMatrix = projMatrix * camMatrix;
 			
 			m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix);
-			#if 0
+			#if 1
 				// position:
 				m_GLprogram->sendAttributePointer(m_GLPosition, m_verticesVBO, GALE_SAMPLE_VBO_VERTICES);
 				// color: