diff --git a/build b/build
index d207607b..a4e1c141 160000
--- a/build
+++ b/build
@@ -1 +1 @@
-Subproject commit d207607bac4827ecc6dd02ccb08059ec9d191e4f
+Subproject commit a4e1c141f04e96da02edfa64644a85ab332eadad
diff --git a/sources/Android.mk b/sources/Android.mk
index 3ba6ba26..522c9b78 100644
--- a/sources/Android.mk
+++ b/sources/Android.mk
@@ -27,8 +27,8 @@ LOCAL_EXPORT_LDLIBS := -lGLESv2
 LOCAL_EXPORT_LDLIBS += -ldl -llog
 
 
-FILE_ABSTRACTION:=$(LOCAL_PATH)/ewol/os/gui.Android.base.cpp
-FILE_ABSTRACTION_DEST:=ewol/os/gui.Android.tmp.cpp
+FILE_ABSTRACTION:=$(LOCAL_PATH)/ewol/renderer/os/gui.Android.base.cpp
+FILE_ABSTRACTION_DEST:=ewol/renderer/os/gui.Android.tmp.cpp
 
 EWOL_TMP_PATH:=$(LOCAL_PATH)
 
@@ -51,7 +51,7 @@ LOCAL_PREREQUISITES := $(FILE_ABSTRACTION_DEST)
 # load the common sources file of the platform
 include $(LOCAL_PATH)/file.mk
 
-LOCAL_SRC_FILES := ewol/os/gui.Android.cpp $(FILE_LIST)
+LOCAL_SRC_FILES := ewol/renderer/os/gui.Android.cpp $(FILE_LIST)
 
 include $(BUILD_STATIC_LIBRARY)
 
diff --git a/sources/Windows.mk b/sources/Windows.mk
index b53b2f00..dbf1884a 100644
--- a/sources/Windows.mk
+++ b/sources/Windows.mk
@@ -26,7 +26,7 @@ LOCAL_CFLAGS := -Wno-write-strings \
 # load the common sources file of the platform
 include $(LOCAL_PATH)/file.mk
 
-LOCAL_SRC_FILES := $(FILE_LIST) ewol/os/gui.Windows.cpp
+LOCAL_SRC_FILES := $(FILE_LIST) ewol/renderer/os/gui.Windows.cpp
 
 
 
diff --git a/sources/ewol/commandLine.cpp b/sources/ewol/commandLine.cpp
index 264f0cbc..6e21f572 100644
--- a/sources/ewol/commandLine.cpp
+++ b/sources/ewol/commandLine.cpp
@@ -6,6 +6,7 @@
  * @license BSD v3 (see license file)
  */
 
+#include <ewol/debug.h>
 #include <ewol/commandLine.h>
 #include <etk/Vector.h>
 
@@ -18,7 +19,9 @@ static etk::Vector<etk::UString> listArgs;
 
 void ewol::commandLine::Clean(void)
 {
+	EWOL_DEBUG("Clean commandLine (START)");
 	listArgs.Clear();
+	EWOL_DEBUG("Clean commandLine (END)");
 }
 
 int32_t ewol::commandLine::Size(void)
diff --git a/sources/ewol/ewol.cpp b/sources/ewol/ewol.cpp
index 7c1e2730..a5b03512 100644
--- a/sources/ewol/ewol.cpp
+++ b/sources/ewol/ewol.cpp
@@ -11,6 +11,7 @@
 #include <ewol/renderer/os/eSystem.h>
 
 #include <ewol/renderer/os/gui.h>
+#include <ewol/commandLine.h>
 
 #undef __class__
 #define __class__	"ewol"
@@ -18,8 +19,38 @@
 
 int32_t ewol::Run(int32_t argc, const char* argv[])
 {
+	EWOL_DEBUG("Store commangLine in the specific system");
+	ewol::commandLine::Clean();
+	for( int32_t i=1 ; i<argc; i++) {
+		EWOL_INFO("commandLine : \"" << argv[i] << "\"" );
+		if (0==strncmp("-l0", argv[i], 256)) {
+			GeneralDebugSetLevel(etk::LOG_LEVEL_NONE);
+		} else if (0==strncmp("-l1", argv[i], 256)) {
+			GeneralDebugSetLevel(etk::LOG_LEVEL_CRITICAL);
+		} else if (0==strncmp("-l2", argv[i], 256)) {
+			GeneralDebugSetLevel(etk::LOG_LEVEL_ERROR);
+		} else if (0==strncmp("-l3", argv[i], 256)) {
+			GeneralDebugSetLevel(etk::LOG_LEVEL_WARNING);
+		} else if (0==strncmp("-l4", argv[i], 256)) {
+			GeneralDebugSetLevel(etk::LOG_LEVEL_INFO);
+		} else if (0==strncmp("-l5", argv[i], 256)) {
+			GeneralDebugSetLevel(etk::LOG_LEVEL_DEBUG);
+		} else if(    0==strncmp("-l6", argv[i], 256)
+		           || 0==strncmp("-l7", argv[i], 256)
+		           || 0==strncmp("-l8", argv[i], 256)
+		           || 0==strncmp("-l9", argv[i], 256)) {
+			GeneralDebugSetLevel(etk::LOG_LEVEL_VERBOSE);
+		} else {
+			etk::UString tmpString(argv[i]);
+			ewol::commandLine::Add(tmpString);
+		}
+	}
 	// call standard RUN ...
-	return guiInterface::main(argc, argv);
+	int32_t error = guiInterface::main(argc, argv);
+	
+	ewol::commandLine::Clean();
+	
+	return error;
 }
 
 
diff --git a/sources/ewol/key.h b/sources/ewol/key.h
index e9534442..4cc89474 100644
--- a/sources/ewol/key.h
+++ b/sources/ewol/key.h
@@ -104,27 +104,26 @@ namespace ewol
 	
 	class SpecialKey {
 		public:
-			unsigned capLock   : 1;
-			unsigned shift     : 1;
-			unsigned ctrl      : 1;
-			unsigned meta      : 1;
-			unsigned alt       : 1;
-			unsigned altGr     : 1;
-			unsigned verNum    : 1;
-			unsigned insert    : 1;
+			union {
+				uint32_t value;
+				struct {
+					unsigned capLock   : 1;
+					unsigned shift     : 1;
+					unsigned ctrl      : 1;
+					unsigned meta      : 1;
+					unsigned alt       : 1;
+					unsigned altGr     : 1;
+					unsigned verNum    : 1;
+					unsigned insert    : 1;
+				};
+			};
+		SpecialKey(void) :
+			value(0)
+		{
+			
+		}
 	};
 	/*
-		SpecialKey(void)
-		{
-			capLock = false;
-			shift = false;
-			ctrl = false;
-			meta = false;
-			alt = false;
-			altGr = false;
-			verNum = false;
-			insert = false;
-		}
 		bool IsSetCapsLock(void)
 		{
 			return capLock;
diff --git a/sources/ewol/renderer/os/eSystem.cpp b/sources/ewol/renderer/os/eSystem.cpp
index 6732305a..8d325549 100644
--- a/sources/ewol/renderer/os/eSystem.cpp
+++ b/sources/ewol/renderer/os/eSystem.cpp
@@ -40,7 +40,8 @@ void eSystem::InputEventTransfertWidget(ewol::Widget* source, ewol::Widget* dest
 }
 
 
-enum {
+typedef enum {
+	THREAD_NONE,
 	THREAD_INIT,
 	THREAD_RECALCULATE_SIZE,
 	THREAD_RESIZE,
@@ -54,37 +55,44 @@ enum {
 	THREAD_KEYBORAD_MOVE,
 	
 	THREAD_CLIPBOARD_ARRIVE,
-};
+} theadMessage_te;
 
 
 #include <unistd.h>
 
-typedef struct {
-	int w;
-	int h;
-} eventResize_ts;
-
-typedef struct {
-	ewol::keyEvent::type_te type;
-	int pointerID;
-	bool state;
-	float x;
-	float y;
-} eventInput_ts;
-
-typedef struct {
-	int32_t TypeMessage;
-	union {
+class eSystemMessage {
+	public :
+		// specify the message type
+		theadMessage_te TypeMessage;
+		// can not set a union ...
 		ewol::clipBoard::clipboardListe_te clipboardID;
-		eventResize_ts resize;
-		eventInput_ts input;
-		eSystem::keyboardMove_ts keyboardMove;
-		eSystem::keyboardKey_ts  keyboardKey;
-	};
-} eSystemMessage_ts;
+		// InputId
+		ewol::keyEvent::type_te inputType;
+		int32_t                 inputId;
+		// generic dimentions
+		etk::Vector2D<float> dimention;
+		// keyboard events :
+		bool                        stateIsDown;
+		uniChar_t                   keyboardChar;
+		ewol::keyEvent::keyboard_te keyboardMove;
+		ewol::SpecialKey            keyboardSpecial;
+		
+		eSystemMessage(void) :
+			TypeMessage(THREAD_NONE),
+			clipboardID(ewol::clipBoard::clipboardStd),
+			inputType(ewol::keyEvent::typeUnknow),
+			inputId(-1),
+			dimention(0,0),
+			stateIsDown(false),
+			keyboardChar(0),
+			keyboardMove(ewol::keyEvent::keyboardUnknow)
+		{
+			
+		}
+};
 
 // deblare the message system
-static etk::MessageFifo<eSystemMessage_ts> l_msgSystem;
+static etk::MessageFifo<eSystemMessage> l_msgSystem;
 
 static bool requestEndProcessing = false;
 
@@ -92,7 +100,7 @@ void ewolProcessEvents(void)
 {
 	int32_t nbEvent = 0;
 	//EWOL_DEBUG(" ********  Event");
-	eSystemMessage_ts data;
+	eSystemMessage data;
 	while (l_msgSystem.Count()>0) 
 	{
 		nbEvent++;
@@ -108,83 +116,52 @@ void ewolProcessEvents(void)
 				break;
 			case THREAD_RESIZE:
 				//EWOL_DEBUG("Receive MSG : THREAD_RESIZE");
-				windowsSize.x = data.resize.w;
-				windowsSize.y = data.resize.h;
+				windowsSize.x = data.dimention.x;
+				windowsSize.y = data.dimention.y;
 				eSystem::ForceRedrawAll();
 				break;
 			case THREAD_INPUT_MOTION:
 				//EWOL_DEBUG("Receive MSG : THREAD_INPUT_MOTION");
-				{
-					etk::Vector2D<float> pos;
-					pos.x = data.input.x;
-					pos.y = data.input.y;
-					l_managementInput.Motion(data.input.type, data.input.pointerID, pos);
-				}
+				l_managementInput.Motion(data.inputType, data.inputId, data.dimention);
 				break;
 			case THREAD_INPUT_STATE:
 				//EWOL_DEBUG("Receive MSG : THREAD_INPUT_STATE");
-				{
-					etk::Vector2D<float> pos;
-					pos.x = data.input.x;
-					pos.y = data.input.y;
-					l_managementInput.State(data.input.type, data.input.pointerID, data.input.state, pos);
-				}
+				l_managementInput.State(data.inputType, data.inputId, data.stateIsDown, data.dimention);
 				break;
 			case THREAD_KEYBORAD_KEY:
 				//EWOL_DEBUG("Receive MSG : THREAD_KEYBORAD_KEY");
 				{
 					ewol::SpecialKey& specialCurrentKey = ewol::GetCurrentSpecialKeyStatus();
-					specialCurrentKey = data.keyboardKey.special;
-					if (NULL != windowsCurrent) {
-						if (false==windowsCurrent->OnEventShortCut(data.keyboardKey.special,
-						                                           data.keyboardKey.myChar,
-						                                           ewol::keyEvent::keyboardUnknow,
-						                                           data.keyboardKey.isDown)) {
-							// Get the current Focused Widget :
-							ewol::Widget * tmpWidget = ewol::widgetManager::FocusGet();
-							if (NULL != tmpWidget) {
-								// check Widget shortcut
-								if (false==tmpWidget->OnEventShortCut(data.keyboardKey.special,
-								                                      data.keyboardKey.myChar,
-								                                      ewol::keyEvent::keyboardUnknow,
-								                                      data.keyboardKey.isDown)) {
-									// generate the direct event ...
-									if(true == data.keyboardKey.isDown) {
-										EWOL_VERBOSE("GUI PRESSED : \"" << data.keyboardKey.myChar << "\"");
-										tmpWidget->OnEventKb(ewol::keyEvent::statusDown, data.keyboardKey.myChar);
-									} else {
-										EWOL_VERBOSE("GUI Release : \"" << data.keyboardKey.myChar << "\"");
-										tmpWidget->OnEventKb(ewol::keyEvent::statusUp, data.keyboardKey.myChar);
-									}
-								}
-							}
-						}
-					}
+					specialCurrentKey = data.keyboardSpecial;
 				}
-				break;
+				// no break ... (normal case ...)
 			case THREAD_KEYBORAD_MOVE:
-				//EWOL_DEBUG("Receive MSG : THREAD_KEYBORAD_MOVE");
-				// check main shortcut
 				if (NULL != windowsCurrent) {
-					if (false==windowsCurrent->OnEventShortCut(data.keyboardKey.special,
-					                                           data.keyboardKey.myChar,
-					                                           ewol::keyEvent::keyboardUnknow,
-					                                           data.keyboardKey.isDown)) {
-						ewol::SpecialKey& specialCurrentKey = ewol::GetCurrentSpecialKeyStatus();
-						specialCurrentKey = data.keyboardMove.special;
+					if (false==windowsCurrent->OnEventShortCut(data.keyboardSpecial,
+					                                           data.keyboardChar,
+					                                           data.keyboardMove,
+					                                           data.stateIsDown) ) {
 						// Get the current Focused Widget :
 						ewol::Widget * tmpWidget = ewol::widgetManager::FocusGet();
 						if (NULL != tmpWidget) {
 							// check Widget shortcut
-							if (false==tmpWidget->OnEventShortCut(data.keyboardKey.special,
-							                                      data.keyboardKey.myChar,
-							                                      ewol::keyEvent::keyboardUnknow,
-							                                      data.keyboardKey.isDown)) {
+							if (false==tmpWidget->OnEventShortCut(data.keyboardSpecial,
+							                                      data.keyboardChar,
+							                                      data.keyboardMove,
+							                                      data.stateIsDown) ) {
 								// generate the direct event ...
-								if(true == data.keyboardMove.isDown) {
-									tmpWidget->OnEventKbMove(ewol::keyEvent::statusDown, data.keyboardMove.move);
-								} else {
-									tmpWidget->OnEventKbMove(ewol::keyEvent::statusUp, data.keyboardMove.move);
+								if (data.TypeMessage == THREAD_KEYBORAD_KEY) {
+									if(true == data.stateIsDown) {
+										tmpWidget->OnEventKb(ewol::keyEvent::statusDown, data.keyboardChar);
+									} else {
+										tmpWidget->OnEventKb(ewol::keyEvent::statusUp, data.keyboardChar);
+									}
+								} else { // THREAD_KEYBORAD_MOVE
+									if(true == data.stateIsDown) {
+										tmpWidget->OnEventKbMove(ewol::keyEvent::statusDown, data.keyboardMove);
+									} else {
+										tmpWidget->OnEventKbMove(ewol::keyEvent::statusUp, data.keyboardMove);
+									}
 								}
 							}
 						}
@@ -252,7 +229,7 @@ bool isGlobalSystemInit = false;
 void RequestInit(void)
 {
 	if (true == isGlobalSystemInit) {
-		eSystemMessage_ts data;
+		eSystemMessage data;
 		data.TypeMessage = THREAD_INIT;
 		l_msgSystem.Post(data);
 	}
@@ -317,7 +294,7 @@ void eSystem::UnInit(void)
 void eSystem::RequestUpdateSize(void)
 {
 	if (true == isGlobalSystemInit) {
-		eSystemMessage_ts data;
+		eSystemMessage data;
 		data.TypeMessage = THREAD_RECALCULATE_SIZE;
 		l_msgSystem.Post(data);
 	}
@@ -326,10 +303,10 @@ void eSystem::RequestUpdateSize(void)
 void eSystem::Resize(int w, int h )
 {
 	if (true == isGlobalSystemInit) {
-		eSystemMessage_ts data;
+		eSystemMessage data;
 		data.TypeMessage = THREAD_RESIZE;
-		data.resize.w = w;
-		data.resize.h = h;
+		data.dimention.x = w;
+		data.dimention.y = h;
 		l_msgSystem.Post(data);
 	}
 }
@@ -337,7 +314,7 @@ void eSystem::Move(int w, int h )
 {
 	if (true == isGlobalSystemInit) {
 		/*
-		eSystemMessage_ts data;
+		eSystemMessage data;
 		data.TypeMessage = THREAD_RESIZE;
 		data.resize.w = w;
 		data.resize.h = h;
@@ -349,27 +326,27 @@ void eSystem::Move(int w, int h )
 void eSystem::SetInputMotion(int pointerID, float x, float y )
 {
 	if (true == isGlobalSystemInit) {
-		eSystemMessage_ts data;
+		eSystemMessage data;
 		data.TypeMessage = THREAD_INPUT_MOTION;
-		data.input.type = ewol::keyEvent::typeFinger;
-		data.input.pointerID = pointerID;
-		data.input.x = x;
-		data.input.y = y;
+		data.inputType = ewol::keyEvent::typeFinger;
+		data.inputId = pointerID;
+		data.dimention.x = x;
+		data.dimention.y = y;
 		l_msgSystem.Post(data);
 	}
 }
 
 
-void eSystem::SetInputState(int pointerID, bool isUp, float x, float y )
+void eSystem::SetInputState(int pointerID, bool isDown, float x, float y )
 {
 	if (true == isGlobalSystemInit) {
-		eSystemMessage_ts data;
+		eSystemMessage data;
 		data.TypeMessage = THREAD_INPUT_STATE;
-		data.input.type = ewol::keyEvent::typeFinger;
-		data.input.pointerID = pointerID;
-		data.input.state = isUp;
-		data.input.x = x;
-		data.input.y = y;
+		data.inputType = ewol::keyEvent::typeFinger;
+		data.inputId = pointerID;
+		data.stateIsDown = isDown;
+		data.dimention.x = x;
+		data.dimention.y = y;
 		l_msgSystem.Post(data);
 	}
 }
@@ -378,47 +355,56 @@ void eSystem::SetInputState(int pointerID, bool isUp, float x, float y )
 void eSystem::SetMouseMotion(int pointerID, float x, float y )
 {
 	if (true == isGlobalSystemInit) {
-		eSystemMessage_ts data;
+		eSystemMessage data;
 		data.TypeMessage = THREAD_INPUT_MOTION;
-		data.input.type = ewol::keyEvent::typeMouse;
-		data.input.pointerID = pointerID;
-		data.input.x = x;
-		data.input.y = y;
+		data.inputType = ewol::keyEvent::typeMouse;
+		data.inputId = pointerID;
+		data.dimention.x = x;
+		data.dimention.y = y;
 		l_msgSystem.Post(data);
 	}
 }
 
 
-void eSystem::SetMouseState(int pointerID, bool isUp, float x, float y )
+void eSystem::SetMouseState(int pointerID, bool isDown, float x, float y )
 {
 	if (true == isGlobalSystemInit) {
-		eSystemMessage_ts data;
+		eSystemMessage data;
 		data.TypeMessage = THREAD_INPUT_STATE;
-		data.input.type = ewol::keyEvent::typeMouse;
-		data.input.pointerID = pointerID;
-		data.input.state = isUp;
-		data.input.x = x;
-		data.input.y = y;
+		data.inputType = ewol::keyEvent::typeMouse;
+		data.inputId = pointerID;
+		data.stateIsDown = isDown;
+		data.dimention.x = x;
+		data.dimention.y = y;
 		l_msgSystem.Post(data);
 	}
 }
 
-void eSystem::SetKeyboard(eSystem::keyboardKey_ts& keyInput)
+
+void eSystem::SetKeyboard(ewol::SpecialKey& special,
+                          uniChar_t myChar,
+                          bool isDown)
 {
 	if (true == isGlobalSystemInit) {
-		eSystemMessage_ts data;
+		eSystemMessage data;
 		data.TypeMessage = THREAD_KEYBORAD_KEY;
-		data.keyboardKey = keyInput;
+		data.stateIsDown = isDown;
+		data.keyboardChar = myChar;
+		data.keyboardSpecial = special;
 		l_msgSystem.Post(data);
 	}
 }
 
-void eSystem::SetKeyboardMove(eSystem::keyboardMove_ts& keyInput)
+void eSystem::SetKeyboardMove(ewol::SpecialKey& special,
+                              ewol::keyEvent::keyboard_te move,
+                              bool isDown)
 {
 	if (true == isGlobalSystemInit) {
-		eSystemMessage_ts data;
+		eSystemMessage data;
 		data.TypeMessage = THREAD_KEYBORAD_MOVE;
-		data.keyboardMove = keyInput;
+		data.stateIsDown = isDown;
+		data.keyboardMove = move;
+		data.keyboardSpecial = special;
 		l_msgSystem.Post(data);
 	}
 }
@@ -427,7 +413,7 @@ void eSystem::SetKeyboardMove(eSystem::keyboardMove_ts& keyInput)
 void eSystem::Hide(void)
 {
 	if (true == isGlobalSystemInit) {
-		eSystemMessage_ts data;
+		eSystemMessage data;
 		data.TypeMessage = THREAD_HIDE;
 		l_msgSystem.Post(data);
 	}
@@ -436,7 +422,7 @@ void eSystem::Hide(void)
 void eSystem::Show(void)
 {
 	if (true == isGlobalSystemInit) {
-		eSystemMessage_ts data;
+		eSystemMessage data;
 		data.TypeMessage = THREAD_SHOW;
 		l_msgSystem.Post(data);
 	}
@@ -446,7 +432,7 @@ void eSystem::Show(void)
 void eSystem::ClipBoardArrive(ewol::clipBoard::clipboardListe_te clipboardID)
 {
 	if (true == isGlobalSystemInit) {
-		eSystemMessage_ts data;
+		eSystemMessage data;
 		data.TypeMessage = THREAD_CLIPBOARD_ARRIVE;
 		data.clipboardID = clipboardID;
 		l_msgSystem.Post(data);
diff --git a/sources/ewol/renderer/os/eSystem.h b/sources/ewol/renderer/os/eSystem.h
index b61facf9..2567f7e7 100644
--- a/sources/ewol/renderer/os/eSystem.h
+++ b/sources/ewol/renderer/os/eSystem.h
@@ -27,25 +27,17 @@ namespace eSystem
 	void Show(void);
 	
 	void SetInputMotion(int pointerID, float x, float y);
-	void SetInputState(int pointerID, bool isUp, float x, float y);
+	void SetInputState(int pointerID, bool isDown, float x, float y);
 	
 	void SetMouseMotion(int pointerID, float x, float y);
-	void SetMouseState(int pointerID, bool isUp, float x, float y);
+	void SetMouseState(int pointerID, bool isDown, float x, float y);
 	
-	typedef struct {
-		bool                isDown;
-		uniChar_t           myChar;
-		ewol::SpecialKey    special;
-	} keyboardKey_ts;
-	
-	typedef struct {
-		bool                        isDown;
-		ewol::keyEvent::keyboard_te move;
-		ewol::SpecialKey            special;
-	} keyboardMove_ts;
-	
-	void SetKeyboard(eSystem::keyboardKey_ts& keyInput);
-	void SetKeyboardMove(eSystem::keyboardMove_ts& keyInput);
+	void SetKeyboard(ewol::SpecialKey& special,
+	                 uniChar_t myChar,
+	                 bool isDown);
+	void SetKeyboardMove(ewol::SpecialKey& special,
+	                     ewol::keyEvent::keyboard_te move,
+	                     bool isDown);
 	
 	void ClipBoardArrive(ewol::clipBoard::clipboardListe_te clipboardID);
 	
diff --git a/sources/ewol/renderer/os/gui.Android.base.cpp b/sources/ewol/renderer/os/gui.Android.base.cpp
index 2fe9fb34..5eb819d7 100644
--- a/sources/ewol/renderer/os/gui.Android.base.cpp
+++ b/sources/ewol/renderer/os/gui.Android.base.cpp
@@ -11,10 +11,10 @@
 #include <time.h>
 #include <stdint.h>
 #include <pthread.h>
-#include <ewol/Debug.h>
-#include <ewol/os/eSystem.h>
-#include <ewol/audio/audio.h>
-#include <ewol/os/gui.h>
+#include <ewol/debug.h>
+#include <ewol/renderer/os/eSystem.h>
+#include <ewol/renderer/audio/audio.h>
+#include <ewol/renderer/os/gui.h>
 
 // get a resources from the java environement : 
 static JNIEnv*   JavaVirtualMachinePointer = NULL; // the JVM
@@ -31,6 +31,10 @@ static int32_t m_currentHeight = 0;
 
 static JavaVM* g_JavaVM = NULL;
 
+// special key of the android system :
+static ewol::SpecialKey guiKeyBoardSpecialKeyMode;
+
+
 // jni doc : /usr/lib/jvm/java-1.6.0-openjdk/include
 
 
@@ -401,10 +405,7 @@ extern "C"
 	void Java_org_ewol_interfaceJNI_IOKeyboardEventKey( JNIEnv* env, jobject  thiz, jint uniChar, jboolean isdown)
 	{
 		EWOL_DEBUG("IO keyboard Key event : \"" << uniChar << "\" is down=" << isdown);
-		eSystem::keyboardKey_ts keyInput;
-		keyInput.myChar = uniChar;
-		keyInput.isDown = isdown;
-		eSystem::SetKeyboard(keyInput);
+		eSystem::SetKeyboard(guiKeyBoardSpecialKeyMode, uniChar, isdown);
 	}
 	
 	enum {
@@ -488,6 +489,10 @@ extern "C"
 #define __class__ "guiInterface"
 
 
+int guiInterface::main(int argc, const char *argv[])
+{
+	// unneeded fuction, all is controlled by android java ...
+}
 
 int64_t guiInterface::GetTime(void)
 {
@@ -516,12 +521,12 @@ void guiInterface::ClipBoardGet(ewol::clipBoard::clipboardListe_te clipboardID)
 	l_clipBoardOwnerStd = true;
 	switch (clipboardID)
 	{
-		case ewol::clipBoard::CLIPBOARD_SELECTION:
+		case ewol::clipBoard::clipboardSelection:
 			// NOTE : Windows does not support the middle button the we do it internaly
 			// just transmit an event , we have the data in the system
 			eSystem::ClipBoardArrive(clipboardID);
 			break;
-		case ewol::clipBoard::CLIPBOARD_STD:
+		case ewol::clipBoard::clipboardStd:
 			if (false == l_clipBoardOwnerStd) {
 				// Generate a request TO the OS
 				// TODO : Send the message to the OS "We disire to receive the copy buffer ...
@@ -540,10 +545,10 @@ void guiInterface::ClipBoardSet(ewol::clipBoard::clipboardListe_te clipboardID)
 {
 	switch (clipboardID)
 	{
-		case ewol::clipBoard::CLIPBOARD_SELECTION:
+		case ewol::clipBoard::clipboardSelection:
 			// NOTE : nothing to do : Windows deas ot supported Middle button
 			break;
-		case ewol::clipBoard::CLIPBOARD_STD:
+		case ewol::clipBoard::clipboardStd:
 			// Request the clipBoard :
 			if (false == l_clipBoardOwnerStd) {
 				// TODO : Inform the OS that we have the current buffer of copy ...
diff --git a/sources/ewol/renderer/os/gui.Android.cpp b/sources/ewol/renderer/os/gui.Android.cpp
index 97d6d6ec..d8270181 100644
--- a/sources/ewol/renderer/os/gui.Android.cpp
+++ b/sources/ewol/renderer/os/gui.Android.cpp
@@ -7,4 +7,4 @@
  */
 
 // this include a dynamic generating file ==> this is really stupid, but it is needed for the dependency coherency
-#include <ewol/os/gui.Android.tmp.cpp>
+#include <ewol/renderer/os/gui.Android.tmp.cpp>
diff --git a/sources/ewol/renderer/os/gui.Windows.cpp b/sources/ewol/renderer/os/gui.Windows.cpp
index a5b00e86..920b6507 100644
--- a/sources/ewol/renderer/os/gui.Windows.cpp
+++ b/sources/ewol/renderer/os/gui.Windows.cpp
@@ -7,19 +7,20 @@
  */
 
 
-#include <ewol/Debug.h>
+#include <ewol/debug.h>
 #include <ewol/ewol.h>
 
-#include <etk/math/math.h>
+#include <etk/math/Vector2D.h>
+#include <etk/math/Vector3D.h>
 #include <etk/UString.h>
 #include <etk/unicode.h>
 #include <ewol/widget/WidgetManager.h>
-#include <ewol/os/gui.h>
+#include <ewol/renderer/os/gui.h>
 
-#include <ewol/texture/Texture.h>
-#include <ewol/texture/TextureBMP.h>
-#include <ewol/os/eSystem.h>
-#include <ewol/openGL/openGL.h>
+#include <ewol/renderer/resources/Texture.h>
+#include <ewol/renderer/resources/Image.h>
+#include <ewol/renderer/os/eSystem.h>
+#include <ewol/renderer/openGL.h>
 
 #include <sys/time.h>
 
@@ -106,12 +107,12 @@ void guiInterface::ClipBoardGet(ewol::clipBoard::clipboardListe_te clipboardID)
 	l_clipBoardOwnerStd = true;
 	switch (clipboardID)
 	{
-		case ewol::clipBoard::CLIPBOARD_SELECTION:
+		case ewol::clipBoard::clipboardSelection:
 			// NOTE : Windows does not support the middle button the we do it internaly
 			// just transmit an event , we have the data in the system
 			eSystem::ClipBoardArrive(clipboardID);
 			break;
-		case ewol::clipBoard::CLIPBOARD_STD:
+		case ewol::clipBoard::clipboardStd:
 			if (false == l_clipBoardOwnerStd) {
 				// Generate a request TO the OS
 				// TODO : Send the message to the OS "We disire to receive the copy buffer ...
@@ -131,10 +132,10 @@ void guiInterface::ClipBoardSet(ewol::clipBoard::clipboardListe_te clipboardID)
 {
 	switch (clipboardID)
 	{
-		case ewol::clipBoard::CLIPBOARD_SELECTION:
+		case ewol::clipBoard::clipboardSelection:
 			// NOTE : nothing to do : Windows deas ot supported Middle button
 			break;
-		case ewol::clipBoard::CLIPBOARD_STD:
+		case ewol::clipBoard::clipboardStd:
 			// Request the clipBoard :
 			if (false == l_clipBoardOwnerStd) {
 				// TODO : Inform the OS that we have the current buffer of copy ...
@@ -159,7 +160,13 @@ void EnableOpenGL(HWND hWnd, HDC * hDC, HGLRC * hRC);
 void DisableOpenGL(HWND hWnd, HDC hDC, HGLRC hRC);
 int Windows_Run(void);
 
-int main(int argc, char *argv[])
+
+/**
+ * @brief Main of the program
+ * @param std IO
+ * @return std IO
+ */
+int guiInterface::main(int argc, const char *argv[])
 {
 	glewInit();
 	if (!glewIsSupported("GL_VERSION_2_0")) {
@@ -167,29 +174,6 @@ int main(int argc, char *argv[])
 		return 1;
 	}
 	
-	ewol::CmdLine::Clean();
-	for( int32_t i=1 ; i<argc; i++) {
-		EWOL_INFO("CmdLine : \"" << argv[i] << "\"" );
-		if (0==strncmp("-l0", argv[i], 256)) {
-			GeneralDebugSetLevel(etk::LOG_LEVEL_NONE);
-		} else if (0==strncmp("-l1", argv[i], 256)) {
-			GeneralDebugSetLevel(etk::LOG_LEVEL_CRITICAL);
-		} else if (0==strncmp("-l2", argv[i], 256)) {
-			GeneralDebugSetLevel(etk::LOG_LEVEL_ERROR);
-		} else if (0==strncmp("-l3", argv[i], 256)) {
-			GeneralDebugSetLevel(etk::LOG_LEVEL_WARNING);
-		} else if (0==strncmp("-l4", argv[i], 256)) {
-			GeneralDebugSetLevel(etk::LOG_LEVEL_INFO);
-		} else if (0==strncmp("-l5", argv[i], 256)) {
-			GeneralDebugSetLevel(etk::LOG_LEVEL_DEBUG);
-		} else if (0==strncmp("-l6", argv[i], 256)) {
-			GeneralDebugSetLevel(etk::LOG_LEVEL_VERBOSE);
-		} else {
-			etk::UString tmpString(argv[i]);
-			ewol::CmdLine::Add(tmpString);
-		}
-	}
-	
 	for (int32_t iii=0; iii<NB_MAX_INPUT; iii++) {
 		inputIsPressed[iii] = false;
 	}
@@ -214,7 +198,6 @@ int main(int argc, char *argv[])
 	guiInterface::Stop();
 	// uninit ALL :
 	eSystem::UnInit();
-	ewol::CmdLine::Clean();
 	return 0;
 }
 
@@ -351,42 +334,42 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 		case WM_KEYDOWN:
 			{
 				uniChar_t tmpChar = 0;
-				ewol::eventKbMoveType_te keyInput;
+				ewol::keyEvent::keyboard_te keyInput;
 				switch (wParam) {
 					//case 80: // keypad
-					case VK_UP:     keyInput = ewol::EVENT_KB_MOVE_TYPE_UP; break;
+					case VK_UP:     keyInput = ewol::keyEvent::keyboardUp; break;
 					//case 83: // keypad
-					case VK_LEFT:   keyInput = ewol::EVENT_KB_MOVE_TYPE_LEFT; break;
+					case VK_LEFT:   keyInput = ewol::keyEvent::keyboardLeft; break;
 					//case 85: // keypad
-					case VK_RIGHT:  keyInput = ewol::EVENT_KB_MOVE_TYPE_RIGHT; break;
+					case VK_RIGHT:  keyInput = ewol::keyEvent::keyboardRight; break;
 					//case 88: // keypad
-					case VK_DOWN:   keyInput = ewol::EVENT_KB_MOVE_TYPE_DOWN; break;
+					case VK_DOWN:   keyInput = ewol::keyEvent::keyboardDown; break;
 					//case 81: // keypad
-					case VK_PRIOR:  keyInput = ewol::EVENT_KB_MOVE_TYPE_PAGE_UP; break;
+					case VK_PRIOR:  keyInput = ewol::keyEvent::keyboardPageUp; break;
 					//case 89: // keypad
-					case VK_NEXT:   keyInput = ewol::EVENT_KB_MOVE_TYPE_PAGE_DOWN; break;
+					case VK_NEXT:   keyInput = ewol::keyEvent::keyboardPageDown; break;
 					//case 79: // keypad
-					case VK_HOME:   keyInput = ewol::EVENT_KB_MOVE_TYPE_START; break;
+					case VK_HOME:   keyInput = ewol::keyEvent::keyboardStart; break;
 					//case 87: // keypad
-					case VK_END:    keyInput = ewol::EVENT_KB_MOVE_TYPE_END; break;
-					//case VK_:     keyInput = ewol::EVENT_KB_MOVE_TYPE_ARRET_DEFIL; break;
-					case VK_PAUSE:  keyInput = ewol::EVENT_KB_MOVE_TYPE_WAIT; break;
+					case VK_END:    keyInput = ewol::keyEvent::keyboardEnd; break;
+					//case VK_:     keyInput = ewol::keyEvent::keyboardStopDefil; break;
+					case VK_PAUSE:  keyInput = ewol::keyEvent::keyboardWait; break;
 					//case 90: // keypad
 					case VK_INSERT:
-						keyInput = ewol::EVENT_KB_MOVE_TYPE_INSERT;
+						keyInput = ewol::keyEvent::keyboardInsert;
 						guiKeyBoardMode.insert = buttonIsDown;
 						break;
-					case VK_F1: keyInput = ewol::EVENT_KB_MOVE_TYPE_F1; break;
-					case VK_F2: keyInput = ewol::EVENT_KB_MOVE_TYPE_F2; break;
-					case VK_F3: keyInput = ewol::EVENT_KB_MOVE_TYPE_F3; break;
-					case VK_F4: keyInput = ewol::EVENT_KB_MOVE_TYPE_F4; break;
-					case VK_F5: keyInput = ewol::EVENT_KB_MOVE_TYPE_F5; break;
-					case VK_F6: keyInput = ewol::EVENT_KB_MOVE_TYPE_F6; break;
-					case VK_F7: keyInput = ewol::EVENT_KB_MOVE_TYPE_F7; break;
-					case VK_F8: keyInput = ewol::EVENT_KB_MOVE_TYPE_F8; break;
-					case VK_F9: keyInput = ewol::EVENT_KB_MOVE_TYPE_F9; break;
-					case VK_F10: keyInput = ewol::EVENT_KB_MOVE_TYPE_F10; break;
-					case VK_F11: keyInput = ewol::EVENT_KB_MOVE_TYPE_F11; break;
+					case VK_F1: keyInput = ewol::keyEvent::keyboardF1; break;
+					case VK_F2: keyInput = ewol::keyEvent::keyboardF2; break;
+					case VK_F3: keyInput = ewol::keyEvent::keyboardF3; break;
+					case VK_F4: keyInput = ewol::keyEvent::keyboardF4; break;
+					case VK_F5: keyInput = ewol::keyEvent::keyboardF5; break;
+					case VK_F6: keyInput = ewol::keyEvent::keyboardF6; break;
+					case VK_F7: keyInput = ewol::keyEvent::keyboardF7; break;
+					case VK_F8: keyInput = ewol::keyEvent::keyboardF8; break;
+					case VK_F9: keyInput = ewol::keyEvent::keyboardF9; break;
+					case VK_F10: keyInput = ewol::keyEvent::keyboardF10; break;
+					case VK_F11: keyInput = ewol::keyEvent::keyboardF11; break;
 					case VK_F12:
 					case VK_F13:
 					case VK_F14:
@@ -399,25 +382,25 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 					case VK_F21:
 					case VK_F22:
 					case VK_F23:
-					case VK_F24: keyInput = ewol::EVENT_KB_MOVE_TYPE_F12; break;
-					case VK_CAPITAL:   keyInput = ewol::EVENT_KB_MOVE_TYPE_CAPLOCK;     guiKeyBoardMode.capLock = buttonIsDown; break;
+					case VK_F24: keyInput = ewol::keyEvent::keyboardF12; break;
+					case VK_CAPITAL:   keyInput = ewol::keyEvent::keyboardCapLock;    guiKeyBoardMode.capLock = buttonIsDown; break;
 					
 					case VK_SHIFT:
-					case VK_LSHIFT:    keyInput = ewol::EVENT_KB_MOVE_TYPE_SHIFT_LEFT;  guiKeyBoardMode.shift   = buttonIsDown; break;
-					case VK_RSHIFT:    keyInput = ewol::EVENT_KB_MOVE_TYPE_SHIFT_RIGHT; guiKeyBoardMode.shift   = buttonIsDown; break;
+					case VK_LSHIFT:    keyInput = ewol::keyEvent::keyboardShiftLeft;  guiKeyBoardMode.shift   = buttonIsDown; break;
+					case VK_RSHIFT:    keyInput = ewol::keyEvent::keyboardShiftRight; guiKeyBoardMode.shift   = buttonIsDown; break;
 					
 					case VK_CONTROL:
-					case VK_LCONTROL:  keyInput = ewol::EVENT_KB_MOVE_TYPE_CTRL_LEFT;   guiKeyBoardMode.ctrl    = buttonIsDown; break;
-					case VK_RCONTROL:  keyInput = ewol::EVENT_KB_MOVE_TYPE_CTRL_RIGHT;  guiKeyBoardMode.ctrl    = buttonIsDown; break;
+					case VK_LCONTROL:  keyInput = ewol::keyEvent::keyboardCtrlLeft;   guiKeyBoardMode.ctrl    = buttonIsDown; break;
+					case VK_RCONTROL:  keyInput = ewol::keyEvent::keyboardCtrlRight;  guiKeyBoardMode.ctrl    = buttonIsDown; break;
 					
-					case VK_LWIN:      keyInput = ewol::EVENT_KB_MOVE_TYPE_META_LEFT;   guiKeyBoardMode.meta    = buttonIsDown; break;
-					case VK_RWIN:      keyInput = ewol::EVENT_KB_MOVE_TYPE_META_RIGHT;  guiKeyBoardMode.meta    = buttonIsDown; break;
+					case VK_LWIN:      keyInput = ewol::keyEvent::keyboardMetaLeft;   guiKeyBoardMode.meta    = buttonIsDown; break;
+					case VK_RWIN:      keyInput = ewol::keyEvent::keyboardMetaRight;  guiKeyBoardMode.meta    = buttonIsDown; break;
 					
 					case VK_MENU:
-					case VK_LMENU:     keyInput = ewol::EVENT_KB_MOVE_TYPE_ALT;         guiKeyBoardMode.alt     = buttonIsDown; break;
-					case VK_RMENU:     keyInput = ewol::EVENT_KB_MOVE_TYPE_ALT_GR;      guiKeyBoardMode.altGr   = buttonIsDown; break;
-					//case :   keyInput = ewol::EVENT_KB_MOVE_TYPE_CONTEXT_MENU; break;
-					case VK_NUMLOCK:   keyInput = ewol::EVENT_KB_MOVE_TYPE_VER_NUM;     guiKeyBoardMode.verNum  = buttonIsDown; break;
+					case VK_LMENU:     keyInput = ewol::keyEvent::keyboardAlt;        guiKeyBoardMode.alt     = buttonIsDown; break;
+					case VK_RMENU:     keyInput = ewol::keyEvent::keyboardAltGr;      guiKeyBoardMode.altGr   = buttonIsDown; break;
+					//case :   keyInput = ewol::keyEvent::keyboardContextMenu; break;
+					case VK_NUMLOCK:   keyInput = ewol::keyEvent::keyboardVerNum;     guiKeyBoardMode.verNum  = buttonIsDown; break;
 					case VK_BACK: // DEL
 						tmpChar = 0x00000008;
 						break;
@@ -446,17 +429,9 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 				EWOL_DEBUG("kjhkjhkjhkjhkj = " << wParam);
 				if (tmpChar == 0) {
 					//EWOL_DEBUG("eventKey Move type : " << GetCharTypeMoveEvent(keyInput) );
-					eSystem::keyboardMove_ts specialEvent;
-					specialEvent.special = guiKeyBoardMode;
-					specialEvent.move = keyInput;
-					specialEvent.isDown = buttonIsDown;
-					eSystem::SetKeyboardMove(specialEvent);
+					eSystem::SetKeyboardMove(guiKeyBoardMode, keyInput, buttonIsDown);
 				} else {
-					eSystem::keyboardKey_ts specialEvent;
-					specialEvent.special = guiKeyBoardMode;
-					specialEvent.myChar = tmpChar;
-					specialEvent.isDown = buttonIsDown;
-					eSystem::SetKeyboard(specialEvent);
+					eSystem::SetKeyboard(guiKeyBoardMode, tmpChar, buttonIsDown);
 				}
 			}
 			return 0;
diff --git a/sources/ewol/renderer/os/gui.X11.cpp b/sources/ewol/renderer/os/gui.X11.cpp
index 5095c32a..58e426e2 100644
--- a/sources/ewol/renderer/os/gui.X11.cpp
+++ b/sources/ewol/renderer/os/gui.X11.cpp
@@ -867,31 +867,11 @@ void X11_Run(void)
 							case 77:    keyInput = ewol::keyEvent::keyboardVerNum;      guiKeyBoardMode.verNum  = (event.type == KeyPress) ? true : false; break;
 							case 91: // Suppr on keypad
 								find = false;
-								{
-									eSystem::keyboardKey_ts specialEvent;
-									specialEvent.special = guiKeyBoardMode;
-									specialEvent.myChar = 0x0000007F;
-									if(event.type == KeyPress) {
-										specialEvent.isDown = true;
-									} else {
-										specialEvent.isDown = false;
-									}
-									eSystem::SetKeyboard(specialEvent);
-								}
+								eSystem::SetKeyboard(guiKeyBoardMode, 0x7F, (event.type==KeyPress));
 								break;
 							case 23: // special case for TAB
 								find = false;
-								{
-									eSystem::keyboardKey_ts specialEvent;
-									specialEvent.special = guiKeyBoardMode;
-									specialEvent.myChar = 0x00000009;
-									if(event.type == KeyPress) {
-										specialEvent.isDown = true;
-									} else {
-										specialEvent.isDown = false;
-									}
-									eSystem::SetKeyboard(specialEvent);
-								}
+								eSystem::SetKeyboard(guiKeyBoardMode, 0x09, (event.type==KeyPress));
 								break;
 							default:
 								find = false;
@@ -915,17 +895,11 @@ void X11_Run(void)
 										buf[1] = '\0';
 									}
 									if (count>0) {
-										// transform iun unicode
-										eSystem::keyboardKey_ts specialEvent;
-										specialEvent.special = guiKeyBoardMode;
-										unicode::convertIsoToUnicode(unicode::EDN_CHARSET_ISO_8859_15, buf[0], specialEvent.myChar);
+										// transform it in unicode
+										uniChar_t tmpChar = 0;
+										unicode::convertIsoToUnicode(unicode::EDN_CHARSET_ISO_8859_15, buf[0], tmpChar);
 										//EWOL_INFO("event Key : " << event.xkey.keycode << " char=\"" << buf << "\"'len=" << strlen(buf) << " unicode=" << unicodeValue);
-										if(event.type == KeyPress) {
-											specialEvent.isDown = true;
-										} else {
-											specialEvent.isDown = false;
-										}
-										eSystem::SetKeyboard(specialEvent);
+										eSystem::SetKeyboard(guiKeyBoardMode, tmpChar, (event.type==KeyPress));
 									} else {
 										EWOL_WARNING("Unknow event Key : " << event.xkey.keycode);
 									}
@@ -934,15 +908,7 @@ void X11_Run(void)
 						}
 						if (true == find) {
 							//EWOL_DEBUG("eventKey Move type : " << GetCharTypeMoveEvent(keyInput) );
-							eSystem::keyboardMove_ts specialEvent;
-							specialEvent.special = guiKeyBoardMode;
-							if(event.type == KeyPress) {
-								specialEvent.isDown = true;
-							} else {
-								specialEvent.isDown = false;
-							}
-							specialEvent.move = keyInput;
-							eSystem::SetKeyboardMove(specialEvent);
+							eSystem::SetKeyboardMove(guiKeyBoardMode, keyInput, (event.type==KeyPress));
 						}
 					}
 					break;
@@ -1114,28 +1080,6 @@ void guiInterface::GetAbsPos(etk::Vector2D<int32_t>& pos)
  */
 int guiInterface::main(int argc, const char *argv[])
 {
-	ewol::commandLine::Clean();
-	for( int32_t i=1 ; i<argc; i++) {
-		EWOL_INFO("commandLine : \"" << argv[i] << "\"" );
-		if (0==strncmp("-l0", argv[i], 256)) {
-			GeneralDebugSetLevel(etk::LOG_LEVEL_NONE);
-		} else if (0==strncmp("-l1", argv[i], 256)) {
-			GeneralDebugSetLevel(etk::LOG_LEVEL_CRITICAL);
-		} else if (0==strncmp("-l2", argv[i], 256)) {
-			GeneralDebugSetLevel(etk::LOG_LEVEL_ERROR);
-		} else if (0==strncmp("-l3", argv[i], 256)) {
-			GeneralDebugSetLevel(etk::LOG_LEVEL_WARNING);
-		} else if (0==strncmp("-l4", argv[i], 256)) {
-			GeneralDebugSetLevel(etk::LOG_LEVEL_INFO);
-		} else if (0==strncmp("-l5", argv[i], 256)) {
-			GeneralDebugSetLevel(etk::LOG_LEVEL_DEBUG);
-		} else if (0==strncmp("-l6", argv[i], 256)) {
-			GeneralDebugSetLevel(etk::LOG_LEVEL_VERBOSE);
-		} else {
-			etk::UString tmpString(argv[i]);
-			ewol::commandLine::Add(tmpString);
-		}
-	}
 	
 	for (int32_t iii=0; iii<NB_MAX_INPUT; iii++) {
 		inputIsPressed[iii] = false;
@@ -1163,7 +1107,6 @@ int guiInterface::main(int argc, const char *argv[])
 	guiInterface::Stop();
 	// uninit ALL :
 	eSystem::UnInit();
-	ewol::commandLine::Clean();
 	return 0;
 }
 
diff --git a/sources/ewol/renderer/resources/FontFreeType.cpp b/sources/ewol/renderer/resources/FontFreeType.cpp
index 599883aa..f1d503a4 100644
--- a/sources/ewol/renderer/resources/FontFreeType.cpp
+++ b/sources/ewol/renderer/resources/FontFreeType.cpp
@@ -37,12 +37,11 @@ void ewol::FreeTypeInit(void)
 void ewol::FreeTypeUnInit(void)
 {
 	EWOL_DEBUG("==> Un-Init Font-Manager");
-	/*int32_t error = FT_Done_FreeType( library );
+	int32_t error = FT_Done_FreeType( library );
 	library = NULL;
 	if(0 != error) {
 		EWOL_CRITICAL(" when Un-loading FreeType Librairy ...");
 	}
-	*/
 }
 
 
@@ -100,6 +99,7 @@ ewol::FontFreeType::~FontFreeType(void)
 		m_FileBuffer = NULL;
 	}
 	// must be deleted fftFace
+	FT_Done_Face( m_fftFace );
 }
 
 
diff --git a/sources/ewol/widget/PopUp.cpp b/sources/ewol/widget/PopUp.cpp
index 1c509edb..a8addc71 100644
--- a/sources/ewol/widget/PopUp.cpp
+++ b/sources/ewol/widget/PopUp.cpp
@@ -157,7 +157,7 @@ void widget::PopUp::OnRegenerateDisplay(void)
 		etk::Vector2D<float> tmpOrigin = m_subWidget->GetOrigin();
 		BGOObjects->SetColor(m_colorBorder);
 		BGOObjects->SetPos(etk::Vector3D<float>(tmpOrigin.x-BORDER_SIZE_TMP, tmpOrigin.y-BORDER_SIZE_TMP,0) );
-		BGOObjects->Rectangle(etk::Vector3D<float>(tmpSize.x+2*BORDER_SIZE_TMP, tmpSize.y+2*BORDER_SIZE_TMP, 0) );
+		BGOObjects->RectangleWidth(etk::Vector3D<float>(tmpSize.x+2*BORDER_SIZE_TMP, tmpSize.y+2*BORDER_SIZE_TMP, 0) );
 		BGOObjects->SetColor(m_colorBackGroung);
 		BGOObjects->SetPos(etk::Vector3D<float>(tmpOrigin.x, tmpOrigin.y,0) );
 		BGOObjects->RectangleWidth(etk::Vector3D<float>(tmpSize.x, tmpSize.y, 0) );