[DEV] step one to build

sources/ewol/context/Context.cpp

@@ -20,15 +20,17 @@
 #include <ewol/Dimension.h>
 #include <ewol/debug.h>
 
+#include <ewol/translate.h>
+#include <ewol/openGL/openGL.h>
 #include <ewol/object/Object.h>
 #include <ewol/object/Manager.h>
+#include <ewol/widget/Widget.h>
+#include <ewol/widget/Windows.h>
+#include <ewol/widget/Manager.h>
 
 #include <ewol/context/Context.h>
 #include <ewol/resource/Manager.h>
-#include <ewol/openGL/openGL.h>
 
-#include <ewol/widget/Manager.h>
-#include <ewol/translate.h>
 
 
 
@@ -134,7 +136,7 @@ namespace ewol {
 
 
 void ewol::Context::inputEventTransfertWidget(ewol::object::Shared<ewol::Widget> _source,
-                                               ewol::object::Shared<ewol::Widget> _destination) {
+                                              ewol::object::Shared<ewol::Widget> _destination) {
 	m_input.transfertEvent(_source, _destination);
 }
 
@@ -380,10 +382,10 @@ ewol::Context::~Context() {
 	lockContext();
 	// call application to uninit
 	APP_UnInit(*this);
-	if (m_windowsCurrent != NULL) {
+	if (m_windowsCurrent != nullptr) {
 		EWOL_DEBUG("Main windows has not been auto-removed...");
 		m_windowsCurrent->removeObject();
-		m_windowsCurrent = NULL;
+		m_windowsCurrent.reset();
 	}
 	// unset all windows
 	m_msgSystem.clean();
@@ -648,7 +650,7 @@ bool ewol::Context::OS_Draw(bool _displayEveryTime) {
 	return hasDisplayDone;
 }
 
-void ewol::Context::onObjectRemove(ewol::object::Shared<ewol::Object> * _removeObject) {
+void ewol::Context::onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject) {
 	//EWOL_CRITICAL("element removed");
 	m_input.onObjectRemove(_removeObject);
 }
@@ -663,7 +665,7 @@ void ewol::Context::OS_OpenGlContextDestroy() {
 
 void ewol::Context::setWindows(ewol::widget::Windows* _windows) {
 	// remove current focus :
-	m_widgetManager.focusSetDefault(NULL);
+	m_widgetManager.focusSetDefault(nullptr);
 	m_widgetManager.focusRelease();
 	// set the new pointer as windows system
 	m_windowsCurrent = _windows;
@@ -673,6 +675,10 @@ void ewol::Context::setWindows(ewol::widget::Windows* _windows) {
 	forceRedrawAll();
 }
 
+ewol::object::Shared<ewol::widget::Windows> ewol::Context::getWindows() {
+	return m_windowsCurrent;
+};
+
 void ewol::Context::forceRedrawAll() {
 	if (m_windowsCurrent == NULL) {
 		return;

sources/ewol/context/Context.h

@@ -158,7 +158,7 @@ namespace ewol {
 			 */
 			virtual void stop();
 		private:
-			ewol::widget::Windows* m_windowsCurrent; //!< curent displayed windows
+			ewol::object::Shared<ewol::widget::Windows> m_windowsCurrent; //!< curent displayed windows
 		public:
 			/**
 			 * @brief set the current windows to display :
@@ -169,9 +169,7 @@ namespace ewol {
 			 * @brief get the current windows that is displayed
 			 * @return the current handle on the windows (can be null)
 			 */
-			ewol::widget::Windows* getWindows() {
+			ewol::object::Shared<ewol::widget::Windows> getWindows();
-				return m_windowsCurrent;
-			};
 		private:
 			vec2 m_windowsSize; //!< current size of the system
 		public:
@@ -229,7 +227,7 @@ namespace ewol {
 			 * @param source the widget where the event came from
 			 * @param destination the widget where the event mitgh be generated now
 			 */
-			void inputEventTransfertWidget(ewol::object::Shared<ewol::Widget> _source, ewol::Widget* _destination);
+			void inputEventTransfertWidget(ewol::object::Shared<ewol::Widget> _source, ewol::object::Shared<ewol::Widget> _destination);
 			/**
 			 * @brief This fonction lock the pointer properties to move in relative instead of absolute
 			 * @param[in] widget The widget that lock the pointer events

sources/ewol/context/InputManager.cpp

@@ -93,9 +93,9 @@ void ewol::context::InputManager::cleanElement(InputPoperty *_eventTable,
 	_eventTable[_idInput].posEvent.setValue(0,0);
 }
 
-void ewol::context::InputManager::transfertEvent(ewol::object::Shared<ewol::Widget> _source, ewol::Widget* _destination) {
+void ewol::context::InputManager::transfertEvent(ewol::object::Shared<ewol::Widget> _source, ewol::object::Shared<ewol::Widget> _destination) {
-	if(    NULL == _source
+	if(    _source == nullptr
-	    || NULL == _destination) {
+	    || _destination == nullptr) {
 		// prevent errors ...
 		return;
 	}
@@ -138,7 +138,7 @@ void ewol::context::InputManager::unGrabPointer() {
 	m_context.grabPointerEvents(false, vec2(0,0));
 }
 
-void ewol::context::InputManager::onObjectRemove(ewol::object::Shared<ewol::Object> * removeObject) {
+void ewol::context::InputManager::onObjectRemove(ewol::object::Shared<ewol::Object> removeObject) {
 	for(int32_t iii=0; iii<MAX_MANAGE_INPUT; iii++) {
 		if (m_eventInputSaved[iii].curentWidgetEvent == removeObject) {
 			// remove the property of this input ...
@@ -221,7 +221,7 @@ void ewol::context::InputManager::motion(enum ewol::key::type _type,
 		// not manage input
 		return;
 	}
-	ewol::widget::Windows* tmpWindows = m_context.getWindows();
+	ewol::object::Shared<ewol::widget::Windows> tmpWindows = m_context.getWindows();
 	// special case for the mouse event 0 that represent the hover event of the system :
 	if (_type == ewol::key::typeMouse && _pointerID == 0) {
 		// this event is all time on the good widget ... and manage the enter and leave ...
@@ -358,7 +358,7 @@ void ewol::context::InputManager::state(enum ewol::key::type _type,
 	}
 	// get the curent time ...
 	int64_t currentTime = ewol::getTime();
-	ewol::widget::Windows* tmpWindows = m_context.getWindows();
+	ewol::object::Shared<ewol::widget::Windows> tmpWindows = m_context.getWindows();
 	
 	if (true == _isDown) {
 		EVENT_DEBUG("GUI : Input ID=" << _pointerID

sources/ewol/context/InputManager.h

@@ -109,7 +109,7 @@ namespace ewol {
 				 * @param _source the widget where the event came from
 				 * @param _destination the widget where the event mitgh be generated now
 				 */
-				void transfertEvent(ewol::object::Shared<ewol::Widget> _source, ewol::Widget* _destination);
+				void transfertEvent(ewol::object::Shared<ewol::Widget> _source, ewol::object::Shared<ewol::Widget> _destination);
 				/**
 				 * @brief This fonction lock the pointer properties to move in relative instead of absolute
 				 * @param[in] _widget The widget that lock the pointer events

sources/ewol/object/Object.cpp

@@ -21,30 +21,30 @@ size_t ewol::Object::m_valUID = 0;
 
 
 void ewol::Object::objRefCountIncrement() {
-	std::scoped_lock lock(m_lockRefCount);
+	std::unique_lock<std::mutex> lock(m_lockRefCount);
 	m_objRefCount++;
 }
 
 void ewol::Object::objRefCountDecrement() {
-	std::scoped_lock lock(m_lockRefCount);
+	std::unique_lock<std::mutex> lock(m_lockRefCount);
 	m_objRefCount--;
 }
 
 bool ewol::Object::setRefOwner(bool _haveOwner) {
-	std::scoped_lock lock(m_lockRefCount);
+	std::unique_lock<std::mutex> lock(m_lockRefCount);
 	if (_haveOwner == true) {
 		if (m_hasReferenceOwner == true) {
 			EWOL_CRITICAL("Object have already an owner");
 			return false;;
 		}
-		m_hasReferenceOwner == true;
+		m_hasReferenceOwner = true;
 		return true;
 	}
 	if (m_hasReferenceOwner == false) {
 		EWOL_CRITICAL("Object have already NO owner");
 		return false;
 	}
-	m_hasReferenceOwner == false;
+	m_hasReferenceOwner = false;
 	return true;
 }
 
@@ -54,7 +54,7 @@ void ewol::Object::operator delete(void* _ptr, std::size_t _sz) {
 	obj->objRefCountDecrement();
 	if (obj->m_objRefCount <= 0) {
 		EWOL_DEBUG("    ==> real remove");
-		if (m_hasReferenceOwner == true) {
+		if (obj->m_hasReferenceOwner == true) {
 			EWOL_ERROR("    ==> Remove ofject that have not a reference owner removed");
 		}
 		::operator delete(_ptr);
@@ -299,7 +299,8 @@ void ewol::Object::unRegisterOnEvent(ewol::object::Shared<ewol::Object> _destina
 
 void ewol::Object::onObjectRemove(ewol::object::Shared<ewol::Object> _object) {
 	for(int32_t iii=m_externEvent.size()-1; iii >= 0; iii--) {
-		if (m_externEvent[iii].hasOwner() == false) {
+		if (    m_externEvent[iii] != nullptr
+		     && m_externEvent[iii]->destObject.hasOwner() == false) {
 			m_externEvent.erase(m_externEvent.begin()+iii);
 		}
 	}

sources/ewol/object/Object.h

@@ -14,6 +14,9 @@
 #include <vector>
 #include <exml/exml.h>
 #include <mutex>
+#include <ewol/object/Owner.h>
+#include <ewol/object/Shared.h>
+
 namespace ewol {
 	// some class need to define element befor other ...
 	class Object;
@@ -26,8 +29,6 @@ namespace ewol {
 
 #include <ewol/object/Config.h>
 #include <ewol/object/ConfigElement.h>
-#include <ewol/object/Owner.h>
-#include <ewol/object/Shared.h>
 #include <ewol/object/Message.h>
 
 namespace ewol {

sources/ewol/object/Owner.h

@@ -9,11 +9,11 @@
 #ifndef __EWOL_OBJECT_OWNER_H__
 #define __EWOL_OBJECT_OWNER_H__
 
+#include <ewol/debug.h>
 
 namespace ewol {
-	class Object;
 	namespace object {
-		template<typename T, typename = typename std::enable_if<std::is_convertible<T*, ewol::Object*>::value>::type>
+		template<typename T>
 			class Owner {
 				private:
 					T* m_pointer;

sources/ewol/object/Shared.h

@@ -9,10 +9,11 @@
 #ifndef __EWOL_OBJECT_SHARED_H__
 #define __EWOL_OBJECT_SHARED_H__
 
+#include <ewol/debug.h>
+
 namespace ewol {
-	class Object;
 	namespace object {
-		template<typename T, typename = typename std::enable_if<std::is_convertible<T*, Object*>::value>::type>
+		template<typename T>
 			class Shared {
 				private:
 					T* m_pointer;
@@ -31,6 +32,15 @@ namespace ewol {
 					~Shared() {
 						reset();
 					}
+					// shared to private constructor
+					Shared(const Owner<T>& _obj) :
+					  m_pointer(nullptr) {
+						m_pointer = _obj.get();
+						if (m_pointer == nullptr) {
+							return;
+						}
+						m_pointer->objRefCountIncrement();
+					}
 					// copy constructor
 					Shared(const Shared& _obj) :
 					  m_pointer(nullptr) {
@@ -80,9 +90,6 @@ namespace ewol {
 						}
 						m_pointer = nullptr;
 					}
-					T* get() noexcept {
-						return m_pointer;
-					}
 					T* get() const noexcept {
 						return m_pointer;
 					}
@@ -126,6 +133,16 @@ namespace ewol {
 	inline bool operator==(const T* _obj, const object::Shared<T2>& _obj2) noexcept {
 		return _obj == _obj2.get();
 	}
+	//! @not in doc
+	template<typename T, typename T2>
+	inline bool operator==(const object::Owner<T>& _obj, const object::Shared<T2>& _obj2) noexcept {
+		return _obj.get() == _obj2.get();
+	}
+	//! @not in doc
+	template<typename T, typename T2>
+	inline bool operator==(const object::Shared<T>& _obj, const object::Owner<T2>& _obj2) noexcept {
+		return _obj.get() == _obj2.get();
+	}
 	
 	//! @not in doc
 	template<typename T, typename T2>
@@ -154,6 +171,16 @@ namespace ewol {
 	inline bool operator!=(const T* _obj, const object::Shared<T2>& _obj2) noexcept {
 		return _obj != _obj2.get();
 	}
+	//! @not in doc
+	template<typename T, typename T2>
+	inline bool operator!=(const object::Owner<T>& _obj, const object::Shared<T2>& _obj2) noexcept {
+		return _obj.get() != _obj2.get();
+	}
+	//! @not in doc
+	template<typename T, typename T2>
+	inline bool operator!=(const object::Shared<T>& _obj, const object::Owner<T2>& _obj2) noexcept {
+		return _obj.get() != _obj2.get();
+	}
 	
 	//! @not in doc
 	template<typename T>

sources/ewol/resource/Manager.cpp

@@ -215,7 +215,7 @@ bool ewol::resource::Manager::release(ewol::Resource*& _object) {
 }
 
 // in case of error ...
-void ewol::resource::Manager::onObjectRemove(ewol::object::Shared<ewol::Object> * _removeObject) {
+void ewol::resource::Manager::onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject) {
 	for (size_t iii=0; iii<m_resourceList.size(); ++iii) {
 		if (m_resourceList[iii] == _removeObject) {
 			EWOL_WARNING("Remove Resource that is not removed ... ");

sources/ewol/resource/Manager.h

@@ -68,7 +68,7 @@ namespace ewol {
 				 */
 				bool release(ewol::Resource*& _object);
 			public: // herited function
-				virtual void onObjectRemove(ewol::object::Shared<ewol::Object> * _removeObject);
+				virtual void onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject);
 		};
 	};
 };

sources/ewol/widget/Button.cpp

@@ -14,17 +14,17 @@
 #define __class__ "Button"
 
 
-const char* const ewol::Widget::Button::eventPressed    = "pressed";
+const char* const ewol::widget::Button::eventPressed    = "pressed";
-const char* const ewol::Widget::Button::eventDown       = "down";
+const char* const ewol::widget::Button::eventDown       = "down";
-const char* const ewol::Widget::Button::eventUp         = "up";
+const char* const ewol::widget::Button::eventUp         = "up";
-const char* const ewol::Widget::Button::eventEnter      = "enter";
+const char* const ewol::widget::Button::eventEnter      = "enter";
-const char* const ewol::Widget::Button::eventLeave      = "leave";
+const char* const ewol::widget::Button::eventLeave      = "leave";
-const char* const ewol::Widget::Button::eventValue      = "value";
+const char* const ewol::widget::Button::eventValue      = "value";
 
-const char* const ewol::Widget::Button::configToggle = "toggle";
+const char* const ewol::widget::Button::configToggle = "toggle";
-const char* const ewol::Widget::Button::configLock   = "lock";
+const char* const ewol::widget::Button::configLock   = "lock";
-const char* const ewol::Widget::Button::configValue  = "value";
+const char* const ewol::widget::Button::configValue  = "value";
-const char* const ewol::Widget::Button::configShaper = "shaper";
+const char* const ewol::widget::Button::configShaper = "shaper";
 
 
 // DEFINE for the shader display system :
@@ -34,24 +34,24 @@ const char* const ewol::Widget::Button::configShaper = "shaper";
 #define STATUS_DOWN      (3)
 
 
-static ewol::object::Shared<ewol::Widget> Create() {
+static ewol::Widget* Create() {
-	return new ewol::Widget::Button();
+	return new ewol::widget::Button();
 }
 
-void ewol::Widget::Button::init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager) {
+void ewol::widget::Button::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
-	_widgetManager.addWidgetCreator(__class__, &Create);
+	_widgetManager->addWidgetCreator(__class__, &Create);
 }
 
-ewol::Widget::Button::Button(const std::string& _shaperName) :
+ewol::widget::Button::Button(const std::string& _shaperName) :
   m_shaper(_shaperName),
   m_value(false),
-  m_lock(ewol::Widget::Button::lockNone),
+  m_lock(ewol::widget::Button::lockNone),
   m_toggleMode(false),
   m_mouseHover(false),
   m_buttonPressed(false),
   m_selectableAreaPos(0,0),
   m_selectableAreaSize(0,0) {
-	addObjectType("ewol::Widget::Button");
+	addObjectType("ewol::widget::Button");
 	// add basic Event generated :
 	addEventId(eventPressed);
 	addEventId(eventDown);
@@ -74,18 +74,18 @@ ewol::Widget::Button::Button(const std::string& _shaperName) :
 }
 
 
-ewol::Widget::Button::~Button() {
+ewol::widget::Button::~Button() {
 	
 }
 
 
-void ewol::Widget::Button::setShaperName(const std::string& _shaperName) {
+void ewol::widget::Button::setShaperName(const std::string& _shaperName) {
 	EWOL_WARNING("set shaper name : '" << _shaperName << "'");
 	m_shaper.setSource(_shaperName);
 	markToRedraw();
 }
 
-void ewol::Widget::Button::calculateSize(const vec2& _availlable) {
+void ewol::widget::Button::calculateSize(const vec2& _availlable) {
 	ewol::Padding padding = m_shaper.getPadding();
 	ewol::Padding ret = calculateSizePadded(_availlable, padding);
 	//EWOL_DEBUG(" configuring : origin=" << origin << " size=" << subElementSize << "");
@@ -94,18 +94,18 @@ void ewol::Widget::Button::calculateSize(const vec2& _availlable) {
 }
 
 
-void ewol::Widget::Button::calculateMinMaxSize() {
+void ewol::widget::Button::calculateMinMaxSize() {
 	ewol::Padding padding = m_shaper.getPadding();
 	calculateMinMaxSizePadded(padding);
 }
 
-void ewol::Widget::Button::onDraw() {
+void ewol::widget::Button::onDraw() {
 	// draw the shaaper (if needed indeed)
 	m_shaper.draw();
 }
 
-void ewol::Widget::Button::onRegenerateDisplay() {
+void ewol::widget::Button::onRegenerateDisplay() {
-	ewol::Widget::Container2::onRegenerateDisplay();
+	ewol::widget::Container2::onRegenerateDisplay();
 	if (needRedraw() == false) {
 		return;
 	}
@@ -116,10 +116,10 @@ void ewol::Widget::Button::onRegenerateDisplay() {
 	                  vec2ClipInt32(m_selectableAreaSize-vec2(padding.x(),padding.y()) ) );
 }
 
-void ewol::Widget::Button::setLock(enum buttonLock _lock) {
+void ewol::widget::Button::setLock(enum buttonLock _lock) {
 	if (m_lock != _lock) {
 		m_lock = _lock;
-		if(ewol::Widget::Button::lockAccess == _lock) {
+		if(ewol::widget::Button::lockAccess == _lock) {
 			m_buttonPressed = false;
 			m_mouseHover = false;
 		}
@@ -128,7 +128,7 @@ void ewol::Widget::Button::setLock(enum buttonLock _lock) {
 	}
 }
 
-void ewol::Widget::Button::setValue(bool _val) {
+void ewol::widget::Button::setValue(bool _val) {
 	if (m_value != _val) {
 		m_value = _val;
 		if (m_toggleMode == true) {
@@ -143,7 +143,7 @@ void ewol::Widget::Button::setValue(bool _val) {
 	}
 }
 
-void ewol::Widget::Button::setToggleMode(bool _togg) {
+void ewol::widget::Button::setToggleMode(bool _togg) {
 	if (m_toggleMode != _togg) {
 		m_toggleMode = _togg;
 		if (m_value == true) {
@@ -164,10 +164,10 @@ void ewol::Widget::Button::setToggleMode(bool _togg) {
 	}
 }
 
-bool ewol::Widget::Button::onEventInput(const ewol::event::Input& _event) {
+bool ewol::widget::Button::onEventInput(const ewol::event::Input& _event) {
 	EWOL_VERBOSE("Event on BT : " << _event);
 	// disable event in the lock access mode :
-	if(ewol::Widget::Button::lockAccess == m_lock) {
+	if(ewol::widget::Button::lockAccess == m_lock) {
 		return false;
 	}
 	if(    ewol::key::statusLeave == _event.getStatus()
@@ -204,9 +204,9 @@ bool ewol::Widget::Button::onEventInput(const ewol::event::Input& _event) {
 			}
 			if(ewol::key::statusSingle == _event.getStatus()) {
 				if(    (    m_value == true
-				         && ewol::Widget::Button::lockWhenPressed == m_lock)
+				         && ewol::widget::Button::lockWhenPressed == m_lock)
 				    || (    m_value == false
-				         && ewol::Widget::Button::lockWhenReleased == m_lock) ) {
+				         && ewol::widget::Button::lockWhenReleased == m_lock) ) {
 					// nothing to do : Lock mode ...
 					// user might set himself the new correct value with @ref setValue(xxx)
 				} else {
@@ -219,7 +219,7 @@ bool ewol::Widget::Button::onEventInput(const ewol::event::Input& _event) {
 					if(    false == m_toggleMode
 					    && true == m_value) {
 						setValue(false);
-						EWOL_VERBOSE(getName() << " : Generate event : " << ewol::Widget::Button::eventValue << " val=" << m_value);
+						EWOL_VERBOSE(getName() << " : Generate event : " << ewol::widget::Button::eventValue << " val=" << m_value);
 						generateEventId(eventValue, std::to_string(m_value));
 					}
 				}
@@ -232,7 +232,7 @@ bool ewol::Widget::Button::onEventInput(const ewol::event::Input& _event) {
 }
 
 
-bool ewol::Widget::Button::onEventEntry(const ewol::event::Entry& _event) {
+bool ewol::widget::Button::onEventEntry(const ewol::event::Entry& _event) {
 	//EWOL_DEBUG("BT PRESSED : \"" << UTF8_data << "\" size=" << strlen(UTF8_data));
 	if(    _event.getType() == ewol::key::keyboardChar
 	    && _event.getStatus() == ewol::key::statusDown
@@ -243,13 +243,13 @@ bool ewol::Widget::Button::onEventEntry(const ewol::event::Entry& _event) {
 	return false;
 }
 
-void ewol::Widget::Button::onLostFocus() {
+void ewol::widget::Button::onLostFocus() {
 	m_buttonPressed = false;
 	EWOL_VERBOSE(getName() << " : Remove Focus ...");
 	CheckStatus();
 }
 
-void ewol::Widget::Button::CheckStatus() {
+void ewol::widget::Button::CheckStatus() {
 	if (true == m_buttonPressed) {
 		changeStatusIn(STATUS_PRESSED);
 	} else {
@@ -265,7 +265,7 @@ void ewol::Widget::Button::CheckStatus() {
 	}
 }
 
-void ewol::Widget::Button::changeStatusIn(int32_t _newStatusId) {
+void ewol::widget::Button::changeStatusIn(int32_t _newStatusId) {
 	if (true == m_shaper.changeStatusIn(_newStatusId) ) {
 		periodicCallEnable();
 		markToRedraw();
@@ -273,7 +273,7 @@ void ewol::Widget::Button::changeStatusIn(int32_t _newStatusId) {
 }
 
 
-void ewol::Widget::Button::periodicCall(const ewol::event::Time& _event) {
+void ewol::widget::Button::periodicCall(const ewol::event::Time& _event) {
 	if (false == m_shaper.periodicCall(_event) ) {
 		periodicCallDisable();
 	}
@@ -281,8 +281,8 @@ void ewol::Widget::Button::periodicCall(const ewol::event::Time& _event) {
 }
 
 
-bool ewol::Widget::Button::onSetConfig(const ewol::object::Config& _conf) {
+bool ewol::widget::Button::onSetConfig(const ewol::object::Config& _conf) {
-	if (true == ewol::Widget::Container2::onSetConfig(_conf)) {
+	if (true == ewol::widget::Container2::onSetConfig(_conf)) {
 		return true;
 	}
 	if (_conf.getConfig() == configToggle) {
@@ -315,8 +315,8 @@ bool ewol::Widget::Button::onSetConfig(const ewol::object::Config& _conf) {
 	return false;
 }
 
-bool ewol::Widget::Button::onGetConfig(const char* _config, std::string& _result) const {
+bool ewol::widget::Button::onGetConfig(const char* _config, std::string& _result) const {
-	if (true == ewol::Widget::Container2::onGetConfig(_config, _result)) {
+	if (true == ewol::widget::Container2::onGetConfig(_config, _result)) {
 		return true;
 	}
 	if (_config == configToggle) {

sources/ewol/widget/Button.h

@@ -25,10 +25,10 @@ namespace ewol {
 		 * @brief a composed button is a button with an inside composed with the specify XML element 
 		 * ==> this permit to generate standard element simple
 		 */
-		class Button : public ewol::Widget::Container2 {
+		class Button : public ewol::widget::Container2 {
 			public:
 				//! @not-in-doc
-				static void init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager);
+				static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager);
 				// Event list of properties
 				static const char* const eventPressed;
 				static const char* const eventDown;

sources/ewol/widget/ButtonColor.cpp

@@ -15,7 +15,7 @@
 #include <ewol/widget/Windows.h>
 #include <ewol/ewol.h>
 
-const char * const ewol::Widget::ButtonColor::eventChange = "change";
+const char * const ewol::widget::ButtonColor::eventChange = "change";
 
 
 // DEFINE for the shader display system :
@@ -31,18 +31,18 @@ const char * const ewol::Widget::ButtonColor::eventChange = "change";
 static const char* const eventColorHasChange = "ewol-widget-ButtonColor-colorChange";
 
 static ewol::Widget* Create() {
-	return new ewol::Widget::ButtonColor();
+	return new ewol::widget::ButtonColor();
 }
 
-void ewol::Widget::ButtonColor::init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager) {
+void ewol::widget::ButtonColor::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
-	_widgetManager.addWidgetCreator(__class__,&Create);
+	_widgetManager->addWidgetCreator(__class__,&Create);
 }
 
-ewol::Widget::ButtonColor::ButtonColor(etk::Color<> _baseColor, std::string _shaperName) :
+ewol::widget::ButtonColor::ButtonColor(etk::Color<> _baseColor, std::string _shaperName) :
   m_shaper(_shaperName),
   m_textColorFg(_baseColor),
   m_widgetContextMenu(NULL) {
-	addObjectType("ewol::Widget::ButtonColor");
+	addObjectType("ewol::widget::ButtonColor");
 	addEventId(eventChange);
 	changeStatusIn(STATUS_UP);
 	setCanHaveFocus(true);
@@ -51,17 +51,17 @@ ewol::Widget::ButtonColor::ButtonColor(etk::Color<> _baseColor, std::string _sha
 }
 
 
-ewol::Widget::ButtonColor::~ButtonColor() {
+ewol::widget::ButtonColor::~ButtonColor() {
 	
 }
 
 
-void ewol::Widget::ButtonColor::setShaperName(std::string _shaperName) {
+void ewol::widget::ButtonColor::setShaperName(std::string _shaperName) {
 	m_shaper.setSource(_shaperName);
 }
 
 
-void ewol::Widget::ButtonColor::calculateMinMaxSize() {
+void ewol::widget::ButtonColor::calculateMinMaxSize() {
 	ewol::Padding padding = m_shaper.getPadding();
 	std::string label = m_textColorFg.getString();
 	vec3 minSize = m_text.calculateSize(label);
@@ -72,13 +72,13 @@ void ewol::Widget::ButtonColor::calculateMinMaxSize() {
 
 
 
-void ewol::Widget::ButtonColor::onDraw() {
+void ewol::widget::ButtonColor::onDraw() {
 	m_shaper.draw();
 	m_text.draw();
 }
 
 
-void ewol::Widget::ButtonColor::onRegenerateDisplay() {
+void ewol::widget::ButtonColor::onRegenerateDisplay() {
 	if (needRedraw() == false) {
 		return;
 	}
@@ -142,7 +142,7 @@ void ewol::Widget::ButtonColor::onRegenerateDisplay() {
 }
 
 
-bool ewol::Widget::ButtonColor::onEventInput(const ewol::event::Input& _event) {
+bool ewol::widget::ButtonColor::onEventInput(const ewol::event::Input& _event) {
 	bool previousHoverState = m_mouseHover;
 	if(ewol::key::statusLeave == _event.getStatus()) {
 		m_mouseHover = false;
@@ -176,27 +176,26 @@ bool ewol::Widget::ButtonColor::onEventInput(const ewol::event::Input& _event) {
 				m_buttonPressed = false;
 				m_mouseHover = false;
 				// create a context menu : 
-				m_widgetContextMenu = new ewol::Widget::ContextMenu();
+				m_widgetContextMenu = new ewol::widget::ContextMenu();
 				if (NULL == m_widgetContextMenu) {
 					EWOL_ERROR("Allocation Error");
 					return true;
 				}
 				vec2 tmpPos = m_origin + m_selectableAreaPos + m_selectableAreaSize;
 				tmpPos.setX( tmpPos.x() - m_minSize.x()/2.0);
-				m_widgetContextMenu->setPositionMark(ewol::Widget::ContextMenu::markButtom, tmpPos );
+				m_widgetContextMenu->setPositionMark(ewol::widget::ContextMenu::markButtom, tmpPos );
 				
-				ewol::Widget::ColorChooser * myColorChooser = new widget::ColorChooser();
+				ewol::widget::ColorChooser * myColorChooser = new widget::ColorChooser();
 				myColorChooser->setColor(m_textColorFg);
 				// set it in the pop-up-system : 
 				m_widgetContextMenu->setSubWidget(myColorChooser);
 				myColorChooser->registerOnEvent(this, "change", eventColorHasChange);
-				ewol::Widget::Windows* currentWindows = getWindows();
+				ewol::object::Shared<ewol::widget::Windows> currentWindows = getWindows();
-				if (NULL == currentWindows) {
+				if (currentWindows == nullptr) {
 					EWOL_ERROR("Can not get the curent Windows...");
-					delete(m_widgetContextMenu);
+					m_widgetContextMenu.reset();
-					m_widgetContextMenu=NULL;
 				} else {
-					currentWindows->popUpWidgetPush(m_widgetContextMenu);
+					currentWindows->popUpWidgetPush(m_widgetContextMenu.get());
 				}
 				markToRedraw();
 			}
@@ -218,17 +217,17 @@ bool ewol::Widget::ButtonColor::onEventInput(const ewol::event::Input& _event) {
 }
 
 
-void ewol::Widget::ButtonColor::setValue(etk::Color<> _color) {
+void ewol::widget::ButtonColor::setValue(etk::Color<> _color) {
 	m_textColorFg = _color;
 	markToRedraw();
 }
 
-etk::Color<> ewol::Widget::ButtonColor::getValue() {
+etk::Color<> ewol::widget::ButtonColor::getValue() {
 	return m_textColorFg;
 }
 
 
-void ewol::Widget::ButtonColor::onReceiveMessage(const ewol::object::Message& _msg) {
+void ewol::widget::ButtonColor::onReceiveMessage(const ewol::object::Message& _msg) {
 	EWOL_INFO("Receive MSG : " <<  _msg.getData());
 	if (_msg.getMessage() == eventColorHasChange) {
 		m_textColorFg = _msg.getData();
@@ -238,7 +237,7 @@ void ewol::Widget::ButtonColor::onReceiveMessage(const ewol::object::Message& _m
 }
 
 
-void ewol::Widget::ButtonColor::changeStatusIn(int32_t _newStatusId) {
+void ewol::widget::ButtonColor::changeStatusIn(int32_t _newStatusId) {
 	if (true == m_shaper.changeStatusIn(_newStatusId) ) {
 		periodicCallEnable();
 		markToRedraw();
@@ -247,7 +246,7 @@ void ewol::Widget::ButtonColor::changeStatusIn(int32_t _newStatusId) {
 
 
 
-void ewol::Widget::ButtonColor::periodicCall(const ewol::event::Time& _event) {
+void ewol::widget::ButtonColor::periodicCall(const ewol::event::Time& _event) {
 	if (false == m_shaper.periodicCall(_event) ) {
 		periodicCallDisable();
 	}

sources/ewol/widget/ButtonColor.h

@@ -25,12 +25,12 @@ namespace ewol {
 				// Event list of properties
 				static const char * const eventChange;
 			public:
-				static void init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager);
+				static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager);
 			private:
 				ewol::compositing::Shaper m_shaper; //!< Compositing theme.
 				ewol::compositing::Text m_text; //!< Compositing Test display.
 				etk::Color<> m_textColorFg; //!< Current color.
-				ewol::object::Shared<ewol::Widget::ContextMenu> m_widgetContextMenu; //!< Specific context menu.
+				ewol::object::Shared<ewol::widget::ContextMenu> m_widgetContextMenu; //!< Specific context menu.
 				bool m_mouseHover; //!< Flag to know where the mouse is (inside the displayed widget (if not fill)).
 				bool m_buttonPressed; //!< Flag to know if the button is curently pressed.
 				// hover area :

sources/ewol/widget/CheckBox.cpp

@@ -9,14 +9,14 @@
 #include <ewol/widget/CheckBox.h>
 #include <ewol/widget/Manager.h>
 
-const char* const ewol::Widget::CheckBox::eventPressed    = "pressed";
+const char* const ewol::widget::CheckBox::eventPressed    = "pressed";
-const char* const ewol::Widget::CheckBox::eventDown       = "down";
+const char* const ewol::widget::CheckBox::eventDown       = "down";
-const char* const ewol::Widget::CheckBox::eventUp         = "up";
+const char* const ewol::widget::CheckBox::eventUp         = "up";
-const char* const ewol::Widget::CheckBox::eventEnter      = "enter";
+const char* const ewol::widget::CheckBox::eventEnter      = "enter";
-const char* const ewol::Widget::CheckBox::eventValue      = "value";
+const char* const ewol::widget::CheckBox::eventValue      = "value";
 
-const char* const ewol::Widget::CheckBox::configValue  = "value";
+const char* const ewol::widget::CheckBox::configValue  = "value";
-const char* const ewol::Widget::CheckBox::configShaper = "shaper";
+const char* const ewol::widget::CheckBox::configShaper = "shaper";
 
 
 // DEFINE for the shader display system :
@@ -28,14 +28,14 @@ const char* const ewol::Widget::CheckBox::configShaper = "shaper";
 #define __class__	"CheckBox"
 
 static ewol::Widget* Create() {
-	return new ewol::Widget::CheckBox();
+	return new ewol::widget::CheckBox();
 }
 
-void ewol::Widget::CheckBox::init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager) {
+void ewol::widget::CheckBox::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
-	_widgetManager.addWidgetCreator(__class__,&Create);
+	_widgetManager->addWidgetCreator(__class__,&Create);
 }
 
-ewol::Widget::CheckBox::CheckBox(const std::string& _shaperName) :
+ewol::widget::CheckBox::CheckBox(const std::string& _shaperName) :
   m_shaper(_shaperName),
   m_mouseHover(false),
   m_buttonPressed(false),
@@ -44,7 +44,7 @@ ewol::Widget::CheckBox::CheckBox(const std::string& _shaperName) :
   m_shaperIdSize(-1),
   m_shaperIdSizeInsize(-1),
   m_value(false) {
-	addObjectType("ewol::Widget::CheckBox");
+	addObjectType("ewol::widget::CheckBox");
 	// add basic Event generated :
 	addEventId(eventPressed);
 	addEventId(eventDown);
@@ -67,17 +67,17 @@ ewol::Widget::CheckBox::CheckBox(const std::string& _shaperName) :
 }
 
 
-ewol::Widget::CheckBox::~CheckBox() {
+ewol::widget::CheckBox::~CheckBox() {
 	
 }
 
-void ewol::Widget::CheckBox::setShaperName(const std::string& _shaperName) {
+void ewol::widget::CheckBox::setShaperName(const std::string& _shaperName) {
 	EWOL_WARNING("set shaper name : '" << _shaperName << "'");
 	m_shaper.setSource(_shaperName);
 	markToRedraw();
 }
 
-void ewol::Widget::CheckBox::calculateSize(const vec2& _availlable) {
+void ewol::widget::CheckBox::calculateSize(const vec2& _availlable) {
 	ewol::Padding padding = m_shaper.getPadding();
 	float boxSize = m_shaper.getConfigNumber(m_shaperIdSize);
 	padding.setXLeft(padding.xLeft()*2.0f + boxSize);
@@ -87,7 +87,7 @@ void ewol::Widget::CheckBox::calculateSize(const vec2& _availlable) {
 	m_selectableAreaSize = m_size - (m_selectableAreaPos + vec2(ret.xRight(), ret.yTop()));
 }
 
-void ewol::Widget::CheckBox::calculateMinMaxSize() {
+void ewol::widget::CheckBox::calculateMinMaxSize() {
 	ewol::Padding padding = m_shaper.getPadding();
 	float boxSize = m_shaper.getConfigNumber(m_shaperIdSize);
 	padding.setXLeft(padding.xLeft()*2.0f + boxSize);
@@ -97,13 +97,13 @@ void ewol::Widget::CheckBox::calculateMinMaxSize() {
 	}
 }
 
-void ewol::Widget::CheckBox::onDraw() {
+void ewol::widget::CheckBox::onDraw() {
 	// draw the shaaper (if needed indeed)
 	m_shaper.draw();
 }
 
-void ewol::Widget::CheckBox::onRegenerateDisplay() {
+void ewol::widget::CheckBox::onRegenerateDisplay() {
-	ewol::Widget::Container2::onRegenerateDisplay();
+	ewol::widget::Container2::onRegenerateDisplay();
 	if (needRedraw() == false) {
 		return;
 	}
@@ -123,7 +123,7 @@ void ewol::Widget::CheckBox::onRegenerateDisplay() {
 	                  vec2ClipInt32(size2-vec2(padding.x(),padding.y()) ));
 }
 
-void ewol::Widget::CheckBox::setValue(bool _val) {
+void ewol::widget::CheckBox::setValue(bool _val) {
 	if (m_value != _val) {
 		m_value = _val;
 		if (m_value == false) {
@@ -137,7 +137,7 @@ void ewol::Widget::CheckBox::setValue(bool _val) {
 	m_shaper.setActivateState(m_value==true?1:0);
 }
 
-bool ewol::Widget::CheckBox::onEventInput(const ewol::event::Input& _event) {
+bool ewol::widget::CheckBox::onEventInput(const ewol::event::Input& _event) {
 	EWOL_VERBOSE("Event on BT : " << _event);
 	
 	bool previousHoverState = m_mouseHover;
@@ -193,7 +193,7 @@ bool ewol::Widget::CheckBox::onEventInput(const ewol::event::Input& _event) {
 }
 
 
-bool ewol::Widget::CheckBox::onEventEntry(const ewol::event::Entry& _event) {
+bool ewol::widget::CheckBox::onEventEntry(const ewol::event::Entry& _event) {
 	//EWOL_DEBUG("BT PRESSED : \"" << UTF8_data << "\" size=" << strlen(UTF8_data));
 	if(    _event.getType() == ewol::key::keyboardChar
 	    && _event.getStatus() == ewol::key::statusDown
@@ -204,7 +204,7 @@ bool ewol::Widget::CheckBox::onEventEntry(const ewol::event::Entry& _event) {
 	return false;
 }
 
-void ewol::Widget::CheckBox::CheckStatus() {
+void ewol::widget::CheckBox::CheckStatus() {
 	if (true == m_buttonPressed) {
 		changeStatusIn(STATUS_PRESSED);
 	} else {
@@ -216,7 +216,7 @@ void ewol::Widget::CheckBox::CheckStatus() {
 	}
 }
 
-void ewol::Widget::CheckBox::changeStatusIn(int32_t _newStatusId) {
+void ewol::widget::CheckBox::changeStatusIn(int32_t _newStatusId) {
 	if (true == m_shaper.changeStatusIn(_newStatusId) ) {
 		periodicCallEnable();
 		markToRedraw();
@@ -224,7 +224,7 @@ void ewol::Widget::CheckBox::changeStatusIn(int32_t _newStatusId) {
 }
 
 
-void ewol::Widget::CheckBox::periodicCall(const ewol::event::Time& _event) {
+void ewol::widget::CheckBox::periodicCall(const ewol::event::Time& _event) {
 	if (false == m_shaper.periodicCall(_event) ) {
 		periodicCallDisable();
 	}
@@ -232,8 +232,8 @@ void ewol::Widget::CheckBox::periodicCall(const ewol::event::Time& _event) {
 }
 
 
-bool ewol::Widget::CheckBox::onSetConfig(const ewol::object::Config& _conf) {
+bool ewol::widget::CheckBox::onSetConfig(const ewol::object::Config& _conf) {
-	if (true == ewol::Widget::Container2::onSetConfig(_conf)) {
+	if (true == ewol::widget::Container2::onSetConfig(_conf)) {
 		return true;
 	}
 	if (_conf.getConfig() == configValue) {
@@ -247,8 +247,8 @@ bool ewol::Widget::CheckBox::onSetConfig(const ewol::object::Config& _conf) {
 	return false;
 }
 
-bool ewol::Widget::CheckBox::onGetConfig(const char* _config, std::string& _result) const {
+bool ewol::widget::CheckBox::onGetConfig(const char* _config, std::string& _result) const {
-	if (true == ewol::Widget::Container2::onGetConfig(_config, _result)) {
+	if (true == ewol::widget::Container2::onGetConfig(_config, _result)) {
 		return true;
 	}
 	if (_config == configValue) {

sources/ewol/widget/CheckBox.h

@@ -18,10 +18,10 @@
 
 namespace ewol {
 	namespace widget {
-		class CheckBox : public ewol::Widget::Container2 {
+		class CheckBox : public ewol::widget::Container2 {
 			public:
 				//! @not-in-doc
-				static void init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager);
+				static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager);
 				// Event list of properties
 				static const char* const eventPressed;
 				static const char* const eventDown;

sources/ewol/widget/ColorBar.cpp

@@ -13,15 +13,15 @@
 
 #include <etk/Color.h>
 
-const char * const ewol::Widget::ColorBar::eventChange    = "change";
+const char * const ewol::widget::ColorBar::eventChange    = "change";
 
 
 
 #undef __class__
 #define __class__ "ColorBar"
 
-ewol::Widget::ColorBar::ColorBar() {
+ewol::widget::ColorBar::ColorBar() {
-	addObjectType("ewol::Widget::ColorBar");
+	addObjectType("ewol::widget::ColorBar");
 	addEventId(eventChange);
 	m_currentUserPos.setValue(0,0);
 	m_currentColor = etk::color::black;
@@ -29,12 +29,12 @@ ewol::Widget::ColorBar::ColorBar() {
 	setMouseLimit(1);
 }
 
-ewol::Widget::ColorBar::~ColorBar() {
+ewol::widget::ColorBar::~ColorBar() {
 	
 }
 
 
-void ewol::Widget::ColorBar::calculateMinMaxSize() {
+void ewol::widget::ColorBar::calculateMinMaxSize() {
 	m_minSize.setValue(160, 80);
 	markToRedraw();
 }
@@ -52,22 +52,22 @@ static etk::Color<> s_listColor[NB_BAND_COLOR+1] = {
 	0xFF0000FF
 };
 
-etk::Color<> ewol::Widget::ColorBar::getCurrentColor() {
+etk::Color<> ewol::widget::ColorBar::getCurrentColor() {
 	return m_currentColor;
 }
-void ewol::Widget::ColorBar::setCurrentColor(etk::Color<> newOne) {
+void ewol::widget::ColorBar::setCurrentColor(etk::Color<> newOne) {
 	m_currentColor = newOne;
 	m_currentColor.setA(0xFF);
 	// estimate the cursor position :
 	// TODO : Later when really needed ...
 }
 
-void ewol::Widget::ColorBar::onDraw() {
+void ewol::widget::ColorBar::onDraw() {
 	m_draw.draw();
 }
 
 
-void ewol::Widget::ColorBar::onRegenerateDisplay() {
+void ewol::widget::ColorBar::onRegenerateDisplay() {
 	if (true == needRedraw()) {
 		// clean the object list ...
 		m_draw.clear();
@@ -165,7 +165,7 @@ void ewol::Widget::ColorBar::onRegenerateDisplay() {
 }
 
 
-bool ewol::Widget::ColorBar::onEventInput(const ewol::event::Input& _event) {
+bool ewol::widget::ColorBar::onEventInput(const ewol::event::Input& _event) {
 	vec2 relativePos = relativePosition(_event.getPos());
 	//EWOL_DEBUG("Event on BT ...");
 	if (1 == _event.getId()) {

sources/ewol/widget/Composer.cpp

@@ -13,32 +13,32 @@
 #include <ewol/widget/Manager.h>
 
 #undef __class__
-#define __class__	"ewol::Widget::Composer"
+#define __class__	"ewol::widget::Composer"
 
-ewol::Widget::Composer::Composer() {
+ewol::widget::Composer::Composer() {
 	// nothing to do ...
 }
 
-ewol::Widget::Composer::Composer(enum composerMode _mode, const std::string& _fileName) {
+ewol::widget::Composer::Composer(enum composerMode _mode, const std::string& _fileName) {
-	addObjectType("ewol::Widget::Composer");
+	addObjectType("ewol::widget::Composer");
 	switch(_mode) {
-		case ewol::Widget::Composer::None:
+		case ewol::widget::Composer::None:
 			// nothing to do ...
 			break;
-		case ewol::Widget::Composer::String:
+		case ewol::widget::Composer::String:
 			loadFromString(_fileName);
 			break;
-		case ewol::Widget::Composer::file:
+		case ewol::widget::Composer::file:
 			loadFromFile(_fileName);
 			break;
 	}
 }
 
-ewol::Widget::Composer::~Composer() {
+ewol::widget::Composer::~Composer() {
 	
 }
 
-bool ewol::Widget::Composer::loadFromFile(const std::string& _fileName) {
+bool ewol::widget::Composer::loadFromFile(const std::string& _fileName) {
 	exml::Document doc;
 	if (doc.load(_fileName) == false) {
 		EWOL_ERROR(" can not load file XML : " << _fileName);
@@ -58,12 +58,12 @@ bool ewol::Widget::Composer::loadFromFile(const std::string& _fileName) {
 		}
 	}
 	// call upper class to parse his elements ...
-	ewol::Widget::Container::loadXML(root);
+	ewol::widget::Container::loadXML(root);
 	
 	return true;
 }
 
-bool ewol::Widget::Composer::loadFromString(const std::string& _composerXmlString) {
+bool ewol::widget::Composer::loadFromString(const std::string& _composerXmlString) {
 	exml::Document doc;
 	if (doc.parse(_composerXmlString) == false) {
 		EWOL_ERROR(" can not load file XML string...");
@@ -83,20 +83,20 @@ bool ewol::Widget::Composer::loadFromString(const std::string& _composerXmlStrin
 		}
 	}
 	// call upper class to parse his elements ...
-	ewol::Widget::Container::loadXML(root);
+	ewol::widget::Container::loadXML(root);
 	
 	return true;
 }
 
 
-void ewol::Widget::Composer::registerOnEventNameWidget(const std::string& _subWidgetName,
+void ewol::widget::Composer::registerOnEventNameWidget(const std::string& _subWidgetName,
                                                        const char * _eventId,
                                                        const char * _eventIdgenerated,
                                                        const std::string& _overloadData) {
 	registerOnEventNameWidget(this, _subWidgetName, _eventId, _eventIdgenerated, _overloadData);
 }
 
-void ewol::Widget::Composer::registerOnEventNameWidget(ewol::object::Shared<ewol::Object> * _destinationObject,
+void ewol::widget::Composer::registerOnEventNameWidget(ewol::object::Shared<ewol::Object> _destinationObject,
                                                        const std::string& _subWidgetName,
                                                        const char * _eventId,
                                                        const char * _eventIdgenerated,

sources/ewol/widget/Composer.h

@@ -19,7 +19,7 @@ namespace ewol {
 		 * @ingroup ewolWidgetGroup
 		 * @brief the composer widget is a widget that create a link on a string.file to parse the data and generate some widget tree
 		 */
-		class Composer : public ewol::Widget::Container {
+		class Composer : public ewol::widget::Container {
 			public:
 				enum composerMode {
 					None,

sources/ewol/widget/Container.cpp

@@ -16,21 +16,21 @@
 #define __class__	"Container"
 
 
-ewol::Widget::Container::Container(ewol::Widget* _subElement) :
+ewol::widget::Container::Container(ewol::Widget* _subElement) :
   m_subWidget(_subElement) {
-	addObjectType("ewol::Widget::Container");
+	addObjectType("ewol::widget::Container");
 	// nothing to do ...
 }
 
-ewol::Widget::Container::~Container() {
+ewol::widget::Container::~Container() {
 	subWidgetRemove();
 }
 
-ewol::object::Shared<ewol::Widget> ewol::Widget::Container::getSubWidget() {
+ewol::object::Shared<ewol::Widget> ewol::widget::Container::getSubWidget() {
 	return m_subWidget;
 }
 
-void ewol::Widget::Container::setSubWidget(ewol::Widget* _newWidget) {
+void ewol::widget::Container::setSubWidget(ewol::Widget* _newWidget) {
 	if (NULL == _newWidget) {
 		return;
 	}
@@ -43,7 +43,7 @@ void ewol::Widget::Container::setSubWidget(ewol::Widget* _newWidget) {
 	requestUpdateSize();
 }
 
-void ewol::Widget::Container::subWidgetRemove() {
+void ewol::widget::Container::subWidgetRemove() {
 	if (NULL != m_subWidget) {
 		m_subWidget->removeUpperWidget();
 		m_subWidget->removeObject();
@@ -53,14 +53,14 @@ void ewol::Widget::Container::subWidgetRemove() {
 	}
 }
 
-void ewol::Widget::Container::subWidgetUnLink() {
+void ewol::widget::Container::subWidgetUnLink() {
 	if (NULL != m_subWidget) {
 		m_subWidget->removeUpperWidget();
 	}
 	m_subWidget=NULL;
 }
 
-ewol::object::Shared<ewol::Widget> ewol::Widget::Container::getWidgetNamed(const std::string& _widgetName) {
+ewol::object::Shared<ewol::Widget> ewol::widget::Container::getWidgetNamed(const std::string& _widgetName) {
 	ewol::object::Shared<ewol::Widget> tmpUpperWidget = ewol::Widget::getWidgetNamed(_widgetName);
 	if (NULL!=tmpUpperWidget) {
 		return tmpUpperWidget;
@@ -71,7 +71,7 @@ ewol::object::Shared<ewol::Widget> ewol::Widget::Container::getWidgetNamed(const
 	return NULL;
 }
 
-void ewol::Widget::Container::onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject) {
+void ewol::widget::Container::onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject) {
 	if (m_subWidget == _removeObject) {
 		m_subWidget=NULL;
 		markToRedraw();
@@ -79,7 +79,7 @@ void ewol::Widget::Container::onObjectRemove(ewol::object::Shared<ewol::Object>
 	}
 }
 
-void ewol::Widget::Container::systemDraw(const ewol::DrawProperty& _displayProp) {
+void ewol::widget::Container::systemDraw(const ewol::DrawProperty& _displayProp) {
 	if (true == m_hide){
 		// widget is hidden ...
 		return;
@@ -92,7 +92,7 @@ void ewol::Widget::Container::systemDraw(const ewol::DrawProperty& _displayProp)
 	}
 }
 
-void ewol::Widget::Container::calculateSize(const vec2& _availlable) {
+void ewol::widget::Container::calculateSize(const vec2& _availlable) {
 	if (NULL!=m_subWidget) {
 		vec2 origin = m_origin+m_offset;
 		vec2 minSize = m_subWidget->getCalculateMinSize();
@@ -119,7 +119,7 @@ void ewol::Widget::Container::calculateSize(const vec2& _availlable) {
 	ewol::Widget::calculateSize(_availlable);
 }
 
-void ewol::Widget::Container::calculateMinMaxSize() {
+void ewol::widget::Container::calculateMinMaxSize() {
 	// call main class
 	ewol::Widget::calculateMinMaxSize();
 	// call sub classes
@@ -131,13 +131,13 @@ void ewol::Widget::Container::calculateMinMaxSize() {
 	//EWOL_ERROR("[" << getId() << "] Result min size : " <<  m_minSize);
 }
 
-void ewol::Widget::Container::onRegenerateDisplay() {
+void ewol::widget::Container::onRegenerateDisplay() {
 	if (NULL!=m_subWidget) {
 		m_subWidget->onRegenerateDisplay();
 	}
 }
 
-ewol::object::Shared<ewol::Widget> ewol::Widget::Container::getWidgetAtPos(const vec2& _pos) {
+ewol::object::Shared<ewol::Widget> ewol::widget::Container::getWidgetAtPos(const vec2& _pos) {
 	if (false == isHide()) {
 		if (NULL!=m_subWidget) {
 			return m_subWidget->getWidgetAtPos(_pos);
@@ -147,7 +147,7 @@ ewol::object::Shared<ewol::Widget> ewol::Widget::Container::getWidgetAtPos(const
 };
 
 
-bool ewol::Widget::Container::loadXML(exml::Element* _node) {
+bool ewol::widget::Container::loadXML(exml::Element* _node) {
 	if (NULL == _node) {
 		return false;
 	}
@@ -173,7 +173,7 @@ bool ewol::Widget::Container::loadXML(exml::Element* _node) {
 			continue;
 		}
 		EWOL_DEBUG("try to create subwidget : '" << widgetName << "'");
-		ewol::object::Shared<ewol::Widget> tmpWidget = getWidgetManager().create(widgetName);
+		ewol::Widget* tmpWidget = getWidgetManager().create(widgetName);
 		if (tmpWidget == NULL) {
 			EWOL_ERROR ("(l "<<pNode->getPos()<<") Can not create the widget : \"" << widgetName << "\"");
 			continue;
@@ -188,7 +188,7 @@ bool ewol::Widget::Container::loadXML(exml::Element* _node) {
 	return true;
 }
 
-void ewol::Widget::Container::setOffset(const vec2& _newVal) {
+void ewol::widget::Container::setOffset(const vec2& _newVal) {
 	if (m_offset != _newVal) {
 		ewol::Widget::setOffset(_newVal);
 		// recalculate the new sise and position of sub widget ...

sources/ewol/widget/Container.h

@@ -19,7 +19,7 @@ namespace ewol {
 		 * @ingroup ewolWidgetGroup
 		 * @brief the Cotainer widget is a widget that have an only one subWidget
 		 */
-		class Container : public ewol::object::Shared<ewol::Widget> {
+		class Container : public ewol::Widget {
 			protected:
 				ewol::object::Owner<ewol::Widget> m_subWidget;
 			public:

sources/ewol/widget/Container2.cpp

@@ -16,20 +16,20 @@
 #define __class__	"Container2"
 
 
-ewol::Widget::Container2::Container2(ewol::Widget* _subElement, ewol::Widget* _subElementToggle) :
+ewol::widget::Container2::Container2(ewol::Widget* _subElement, ewol::Widget* _subElementToggle) :
   m_idWidgetDisplayed(0) {
 	m_subWidget[0] = _subElement;
 	m_subWidget[1] = _subElementToggle;
-	addObjectType("ewol::Widget::Container2");
+	addObjectType("ewol::widget::Container2");
 	// nothing to do ...
 }
 
-ewol::Widget::Container2::~Container2() {
+ewol::widget::Container2::~Container2() {
 	subWidgetRemove();
 	subWidgetRemoveToggle();
 }
 
-void ewol::Widget::Container2::setSubWidget(ewol::Widget* _newWidget, int32_t _idWidget) {
+void ewol::widget::Container2::setSubWidget(ewol::Widget* _newWidget, int32_t _idWidget) {
 	subWidgetRemove(_idWidget);
 	m_subWidget[_idWidget] = _newWidget;
 	if (m_subWidget[_idWidget] != NULL) {
@@ -41,7 +41,7 @@ void ewol::Widget::Container2::setSubWidget(ewol::Widget* _newWidget, int32_t _i
 }
 
 
-void ewol::Widget::Container2::subWidgetRemove(int32_t _idWidget) {
+void ewol::widget::Container2::subWidgetRemove(int32_t _idWidget) {
 	if (m_subWidget[_idWidget] != NULL) {
 		EWOL_VERBOSE("Remove widget : " << _idWidget);
 		m_subWidget[_idWidget]->removeUpperWidget();
@@ -52,7 +52,7 @@ void ewol::Widget::Container2::subWidgetRemove(int32_t _idWidget) {
 	}
 }
 
-void ewol::Widget::Container2::subWidgetUnLink(int32_t _idWidget) {
+void ewol::widget::Container2::subWidgetUnLink(int32_t _idWidget) {
 	if (m_subWidget[_idWidget] != NULL) {
 		m_subWidget[_idWidget]->removeUpperWidget();
 		EWOL_VERBOSE("Unlink widget : " << _idWidget);
@@ -60,7 +60,7 @@ void ewol::Widget::Container2::subWidgetUnLink(int32_t _idWidget) {
 	m_subWidget[_idWidget] = NULL;
 }
 
-ewol::object::Shared<ewol::Widget> ewol::Widget::Container2::getWidgetNamed(const std::string& _widgetName) {
+ewol::object::Shared<ewol::Widget> ewol::widget::Container2::getWidgetNamed(const std::string& _widgetName) {
 	ewol::object::Shared<ewol::Widget> tmpUpperWidget = ewol::Widget::getWidgetNamed(_widgetName);
 	if (tmpUpperWidget != NULL) {
 		return tmpUpperWidget;
@@ -74,7 +74,7 @@ ewol::object::Shared<ewol::Widget> ewol::Widget::Container2::getWidgetNamed(cons
 	return NULL;
 }
 
-void ewol::Widget::Container2::onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject) {
+void ewol::widget::Container2::onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject) {
 	if (m_subWidget[0] == _removeObject) {
 		m_subWidget[0] = NULL;
 		markToRedraw();
@@ -87,7 +87,7 @@ void ewol::Widget::Container2::onObjectRemove(ewol::object::Shared<ewol::Object>
 	}
 }
 
-void ewol::Widget::Container2::systemDraw(const ewol::DrawProperty& _displayProp) {
+void ewol::widget::Container2::systemDraw(const ewol::DrawProperty& _displayProp) {
 	if (true == m_hide){
 		// widget is hidden ...
 		return;
@@ -98,7 +98,7 @@ void ewol::Widget::Container2::systemDraw(const ewol::DrawProperty& _displayProp
 	}
 }
 
-ewol::Padding ewol::Widget::Container2::calculateSizePadded(const vec2& _availlable, const ewol::Padding& _padding) {
+ewol::Padding ewol::widget::Container2::calculateSizePadded(const vec2& _availlable, const ewol::Padding& _padding) {
 	vec2 localAvaillable = _availlable - vec2(_padding.x(), _padding.y());
 	ewol::Widget::calculateSize(_availlable);
 	// set minimal size
@@ -149,7 +149,7 @@ ewol::Padding ewol::Widget::Container2::calculateSizePadded(const vec2& _availla
 	return ewol::Padding(selectableAreaPos.x(), selectableAreaEndPos.y(), selectableAreaEndPos.x(), selectableAreaPos.y());
 }
 
-void ewol::Widget::Container2::calculateMinMaxSizePadded(const ewol::Padding& _padding) {
+void ewol::widget::Container2::calculateMinMaxSizePadded(const ewol::Padding& _padding) {
 	// call main class
 	m_minSize = vec2(0,0);
 	// call sub classes
@@ -167,13 +167,13 @@ void ewol::Widget::Container2::calculateMinMaxSizePadded(const ewol::Padding& _p
 	markToRedraw();
 }
 
-void ewol::Widget::Container2::onRegenerateDisplay() {
+void ewol::widget::Container2::onRegenerateDisplay() {
 	if (m_subWidget[m_idWidgetDisplayed] != NULL) {
 		m_subWidget[m_idWidgetDisplayed]->onRegenerateDisplay();
 	}
 }
 /*
-ewol::object::Shared<ewol::Widget> ewol::Widget::Container2::getWidgetAtPos(const vec2& _pos) {
+ewol::object::Shared<ewol::Widget> ewol::widget::Container2::getWidgetAtPos(const vec2& _pos) {
 	if (isHide() == false) {
 		if (m_subWidget[m_idWidgetDisplayed] != NULL) {
 			return m_subWidget[m_idWidgetDisplayed]->getWidgetAtPos(_pos);
@@ -183,7 +183,7 @@ ewol::object::Shared<ewol::Widget> ewol::Widget::Container2::getWidgetAtPos(cons
 }
 */
 
-bool ewol::Widget::Container2::loadXML(exml::Element* _node) {
+bool ewol::widget::Container2::loadXML(exml::Element* _node) {
 	if (NULL == _node) {
 		return false;
 	}
@@ -213,7 +213,7 @@ bool ewol::Widget::Container2::loadXML(exml::Element* _node) {
 			}
 		}
 		EWOL_DEBUG("try to create subwidget : '" << widgetName << "'");
-		ewol::object::Shared<ewol::Widget> tmpWidget = getWidgetManager().create(widgetName);
+		ewol::Widget* tmpWidget = getWidgetManager().create(widgetName);
 		if (tmpWidget == NULL) {
 			EWOL_ERROR ("(l "<<pNode->getPos()<<") Can not create the widget : \"" << widgetName << "\"");
 			continue;
@@ -232,7 +232,7 @@ bool ewol::Widget::Container2::loadXML(exml::Element* _node) {
 	return true;
 }
 
-void ewol::Widget::Container2::setOffset(const vec2& _newVal) {
+void ewol::widget::Container2::setOffset(const vec2& _newVal) {
 	if (m_offset != _newVal) {
 		ewol::Widget::setOffset(_newVal);
 		// recalculate the new sise and position of sub widget ...

sources/ewol/widget/Container2.h

@@ -20,7 +20,7 @@ namespace ewol {
 		 * @ingroup ewolWidgetGroup
 		 * @brief the Cotainer widget is a widget that have an only one subWidget
 		 */
-		class Container2 : public ewol::object::Shared<ewol::Widget> {
+		class Container2 : public ewol::Widget {
 			protected:
 				ewol::object::Owner<ewol::Widget> m_subWidget[2]; //!< 2 subwidget possible
 				int32_t m_idWidgetDisplayed; //!< current widget displayed

sources/ewol/widget/ContainerN.cpp

@@ -15,19 +15,19 @@
 #define __class__	"ContainerN"
 
 
-ewol::Widget::ContainerN::ContainerN() :
+ewol::widget::ContainerN::ContainerN() :
   m_lockExpand(false,false),
   m_subExpend(false,false) {
-	addObjectType("ewol::Widget::ContainerN");
+	addObjectType("ewol::widget::ContainerN");
 	// nothing to do ...
 }
 
-ewol::Widget::ContainerN::~ContainerN() {
+ewol::widget::ContainerN::~ContainerN() {
 	subWidgetRemoveAll();
 }
 
 
-bvec2 ewol::Widget::ContainerN::canExpand() {
+bvec2 ewol::widget::ContainerN::canExpand() {
 	bvec2 res = m_userExpand;
 	if (false == m_lockExpand.x()) {
 		if (true == m_subExpend.x()) {
@@ -43,7 +43,7 @@ bvec2 ewol::Widget::ContainerN::canExpand() {
 	return res;
 }
 
-void ewol::Widget::ContainerN::lockExpand(const bvec2& _lockExpand) {
+void ewol::widget::ContainerN::lockExpand(const bvec2& _lockExpand) {
 	if (_lockExpand != m_lockExpand) {
 		m_lockExpand = _lockExpand;
 		markToRedraw();
@@ -52,7 +52,7 @@ void ewol::Widget::ContainerN::lockExpand(const bvec2& _lockExpand) {
 }
 
 
-int32_t ewol::Widget::ContainerN::subWidgetAdd(ewol::Widget* _newWidget) {
+int32_t ewol::widget::ContainerN::subWidgetAdd(ewol::Widget* _newWidget) {
 	if (NULL == _newWidget) {
 		EWOL_ERROR("[" << getId() << "] {" << getObjectType() << "} Try to add An empty Widget ... ");
 		return -1;
@@ -67,7 +67,7 @@ int32_t ewol::Widget::ContainerN::subWidgetAdd(ewol::Widget* _newWidget) {
 	return _newWidget->getId();
 }
 
-int32_t ewol::Widget::ContainerN::subWidgetAddStart(ewol::Widget* _newWidget) {
+int32_t ewol::widget::ContainerN::subWidgetAddStart(ewol::Widget* _newWidget) {
 	if (NULL == _newWidget) {
 		EWOL_ERROR("[" << getId() << "] {" << getObjectType() << "} Try to add start An empty Widget ... ");
 		return -1;
@@ -81,7 +81,7 @@ int32_t ewol::Widget::ContainerN::subWidgetAddStart(ewol::Widget* _newWidget) {
 	return _newWidget->getId();
 }
 
-void ewol::Widget::ContainerN::subWidgetRemove(ewol::Widget* _newWidget) {
+void ewol::widget::ContainerN::subWidgetRemove(ewol::Widget* _newWidget) {
 	if (NULL == _newWidget) {
 		return;
 	}
@@ -103,7 +103,7 @@ void ewol::Widget::ContainerN::subWidgetRemove(ewol::Widget* _newWidget) {
 	}
 }
 
-void ewol::Widget::ContainerN::subWidgetUnLink(ewol::Widget* _newWidget) {
+void ewol::widget::ContainerN::subWidgetUnLink(ewol::Widget* _newWidget) {
 	if (NULL == _newWidget) {
 		return;
 	}
@@ -119,7 +119,7 @@ void ewol::Widget::ContainerN::subWidgetUnLink(ewol::Widget* _newWidget) {
 	}
 }
 
-void ewol::Widget::ContainerN::subWidgetRemoveAll() {
+void ewol::widget::ContainerN::subWidgetRemoveAll() {
 	size_t errorControl = m_subWidget.size();
 	// the size automaticly decrement with the auto call of the onObjectRemove function
 	while (m_subWidget.size() > 0 ) {
@@ -140,7 +140,7 @@ void ewol::Widget::ContainerN::subWidgetRemoveAll() {
 	m_subWidget.clear();
 }
 
-void ewol::Widget::ContainerN::subWidgetRemoveAllDelayed() {
+void ewol::widget::ContainerN::subWidgetRemoveAllDelayed() {
 	// the size automaticly decrement with the auto call of the onObjectRemove function
 	for (size_t iii=0; iii<m_subWidget.size(); iii++) {
 		if (NULL != m_subWidget[iii]) {
@@ -154,7 +154,7 @@ void ewol::Widget::ContainerN::subWidgetRemoveAllDelayed() {
 	m_subWidget.clear();
 }
 
-ewol::object::Shared<ewol::Widget> ewol::Widget::ContainerN::getWidgetNamed(const std::string& _widgetName) {
+ewol::object::Shared<ewol::Widget> ewol::widget::ContainerN::getWidgetNamed(const std::string& _widgetName) {
 	ewol::object::Shared<ewol::Widget> tmpUpperWidget = ewol::Widget::getWidgetNamed(_widgetName);
 	if (NULL!=tmpUpperWidget) {
 		return tmpUpperWidget;
@@ -170,7 +170,7 @@ ewol::object::Shared<ewol::Widget> ewol::Widget::ContainerN::getWidgetNamed(cons
 	return NULL;
 }
 
-void ewol::Widget::ContainerN::onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject) {
+void ewol::widget::ContainerN::onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject) {
 	// First step call parrent :
 	ewol::Widget::onObjectRemove(_removeObject);
 	// second step find if in all the elements ...
@@ -183,7 +183,7 @@ void ewol::Widget::ContainerN::onObjectRemove(ewol::object::Shared<ewol::Object>
 	}
 }
 
-void ewol::Widget::ContainerN::systemDraw(const ewol::DrawProperty& _displayProp) {
+void ewol::widget::ContainerN::systemDraw(const ewol::DrawProperty& _displayProp) {
 	if (true == m_hide){
 		// widget is hidden ...
 		return;
@@ -200,7 +200,7 @@ void ewol::Widget::ContainerN::systemDraw(const ewol::DrawProperty& _displayProp
 	}
 }
 
-void ewol::Widget::ContainerN::calculateSize(const vec2& _availlable) {
+void ewol::widget::ContainerN::calculateSize(const vec2& _availlable) {
 	m_size = _availlable;
 	for (size_t iii=0; iii<m_subWidget.size(); iii++) {
 		if (NULL != m_subWidget[iii]) {
@@ -211,7 +211,7 @@ void ewol::Widget::ContainerN::calculateSize(const vec2& _availlable) {
 	markToRedraw();
 }
 
-void ewol::Widget::ContainerN::calculateMinMaxSize() {
+void ewol::widget::ContainerN::calculateMinMaxSize() {
 	m_subExpend.setValue(false, false);
 	m_minSize.setValue(0,0);
 	m_maxSize.setValue(ULTIMATE_MAX_SIZE,ULTIMATE_MAX_SIZE);
@@ -234,7 +234,7 @@ void ewol::Widget::ContainerN::calculateMinMaxSize() {
 	//EWOL_ERROR("[" << getId() << "] {" << getObjectType() << "} Result min size : " <<  m_minSize);
 }
 
-void ewol::Widget::ContainerN::onRegenerateDisplay() {
+void ewol::widget::ContainerN::onRegenerateDisplay() {
 	for (size_t iii=0; iii<m_subWidget.size(); iii++) {
 		if (NULL != m_subWidget[iii]) {
 			m_subWidget[iii]->onRegenerateDisplay();
@@ -242,7 +242,7 @@ void ewol::Widget::ContainerN::onRegenerateDisplay() {
 	}
 }
 
-ewol::object::Shared<ewol::Widget> ewol::Widget::ContainerN::getWidgetAtPos(const vec2& _pos) {
+ewol::object::Shared<ewol::Widget> ewol::widget::ContainerN::getWidgetAtPos(const vec2& _pos) {
 	if (true == isHide()) {
 		return NULL;
 	}
@@ -254,7 +254,7 @@ ewol::object::Shared<ewol::Widget> ewol::Widget::ContainerN::getWidgetAtPos(cons
 			if(    (tmpOrigin.x() <= _pos.x() && tmpOrigin.x() + tmpSize.x() >= _pos.x())
 			    && (tmpOrigin.y() <= _pos.y() && tmpOrigin.y() + tmpSize.y() >= _pos.y()) )
 			{
-				ewol::object::Shared<ewol::Widget> * tmpWidget = m_subWidget[iii]->getWidgetAtPos(_pos);
+				ewol::object::Shared<ewol::Widget> tmpWidget = m_subWidget[iii]->getWidgetAtPos(_pos);
 				if (NULL != tmpWidget) {
 					return tmpWidget;
 				}
@@ -267,7 +267,7 @@ ewol::object::Shared<ewol::Widget> ewol::Widget::ContainerN::getWidgetAtPos(cons
 };
 
 
-bool ewol::Widget::ContainerN::loadXML(exml::Element* _node) {
+bool ewol::widget::ContainerN::loadXML(exml::Element* _node) {
 	if (NULL == _node) {
 		return false;
 	}
@@ -298,7 +298,7 @@ bool ewol::Widget::ContainerN::loadXML(exml::Element* _node) {
 			continue;
 		}
 		EWOL_DEBUG("[" << getId() << "] {" << getObjectType() << "} load new element : \"" << widgetName << "\"");
-		ewol::object::Shared<ewol::Widget> *subWidget = getWidgetManager().create(widgetName);
+		ewol::Widget* subWidget = getWidgetManager().create(widgetName);
 		if (subWidget == NULL) {
 			EWOL_ERROR ("[" << getId() << "] {" << getObjectType() << "} (l "<<pNode->getPos()<<") Can not create the widget : \"" << widgetName << "\"");
 			continue;
@@ -318,7 +318,7 @@ bool ewol::Widget::ContainerN::loadXML(exml::Element* _node) {
 }
 
 
-void ewol::Widget::ContainerN::setOffset(const vec2& _newVal) {
+void ewol::widget::ContainerN::setOffset(const vec2& _newVal) {
 	if (m_offset != _newVal) {
 		ewol::Widget::setOffset(_newVal);
 		// recalculate the new sise and position of sub widget ...

sources/ewol/widget/ContextMenu.cpp

@@ -17,23 +17,23 @@
 #define __class__	"ContextMenu"
 
 
-const char* const ewol::Widget::ContextMenu::configArrowPosition = "arrow-position";
+const char* const ewol::widget::ContextMenu::configArrowPosition = "arrow-position";
-const char* const ewol::Widget::ContextMenu::configArrowMode     = "arrow-mode";
+const char* const ewol::widget::ContextMenu::configArrowMode     = "arrow-mode";
-const char* const ewol::Widget::ContextMenu::configShaper        = "shaper";
+const char* const ewol::widget::ContextMenu::configShaper        = "shaper";
 
-static ewol::object::Shared<ewol::Widget> Create() {
+static ewol::Widget* Create() {
-	return new ewol::Widget::ContextMenu();
+	return new ewol::widget::ContextMenu();
 }
 
-void ewol::Widget::ContextMenu::init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager) {
+void ewol::widget::ContextMenu::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
-	_widgetManager.addWidgetCreator(__class__,&Create);
+	_widgetManager->addWidgetCreator(__class__,&Create);
 }
 
 
 
-ewol::Widget::ContextMenu::ContextMenu(const std::string& _shaperName) :
+ewol::widget::ContextMenu::ContextMenu(const std::string& _shaperName) :
   m_shaper(_shaperName) {
-	addObjectType("ewol::Widget::ContextMenu");
+	addObjectType("ewol::widget::ContextMenu");
 	// add basic configurations :
 	registerConfig(configArrowPosition, "vec2", NULL, "position of the arrow");
 	registerConfig(configArrowMode, "list", "none;left;buttom;right;top", "Position of the arrow in the pop-up");
@@ -53,17 +53,17 @@ ewol::Widget::ContextMenu::ContextMenu(const std::string& _shaperName) :
 	setMouseLimit(1);
 }
 
-ewol::Widget::ContextMenu::~ContextMenu() {
+ewol::widget::ContextMenu::~ContextMenu() {
 	
 }
 
-void ewol::Widget::ContextMenu::setShaperName(const std::string& _shaperName) {
+void ewol::widget::ContextMenu::setShaperName(const std::string& _shaperName) {
 	m_shaper.setSource(_shaperName);
 	markToRedraw();
 }
 
 
-void ewol::Widget::ContextMenu::calculateSize(const vec2& _availlable) {
+void ewol::widget::ContextMenu::calculateSize(const vec2& _availlable) {
 	//EWOL_DEBUG("CalculateSize=" << availlable);
 	// pop-up fill all the display :
 	m_size = _availlable;
@@ -131,9 +131,9 @@ void ewol::Widget::ContextMenu::calculateSize(const vec2& _availlable) {
 }
 
 
-void ewol::Widget::ContextMenu::calculateMinMaxSize() {
+void ewol::widget::ContextMenu::calculateMinMaxSize() {
 	// call main class to calculate the min size...
-	ewol::Widget::Container::calculateMinMaxSize();
+	ewol::widget::Container::calculateMinMaxSize();
 	// add padding of the display
 	ewol::Padding padding = m_shaper.getPadding();
 	m_minSize += vec2(padding.x(), padding.y());
@@ -142,15 +142,15 @@ void ewol::Widget::ContextMenu::calculateMinMaxSize() {
 }
 
 
-void ewol::Widget::ContextMenu::onDraw() {
+void ewol::widget::ContextMenu::onDraw() {
 	m_compositing.draw();
 	m_shaper.draw();
 }
 
 
-void ewol::Widget::ContextMenu::onRegenerateDisplay() {
+void ewol::widget::ContextMenu::onRegenerateDisplay() {
 	// call upper class :
-	ewol::Widget::Container::onRegenerateDisplay();
+	ewol::widget::Container::onRegenerateDisplay();
 	if (needRedraw() == false) {
 		return;
 	}
@@ -214,9 +214,9 @@ void ewol::Widget::ContextMenu::onRegenerateDisplay() {
 	                  vec2ClipInt32(shaperSize));
 }
 
-bool ewol::Widget::ContextMenu::onEventInput(const ewol::event::Input& _event) {
+bool ewol::widget::ContextMenu::onEventInput(const ewol::event::Input& _event) {
 	if (_event.getId() > 0) {
-		if (NULL != ewol::Widget::Container::getWidgetAtPos(_event.getPos())) {
+		if (NULL != ewol::widget::Container::getWidgetAtPos(_event.getPos())) {
 			return false;
 		}
 		if(    _event.getStatus() == ewol::key::statusDown
@@ -234,15 +234,15 @@ bool ewol::Widget::ContextMenu::onEventInput(const ewol::event::Input& _event) {
 }
 
 
-void ewol::Widget::ContextMenu::setPositionMark(enum markPosition _position, vec2 _arrowPos) {
+void ewol::widget::ContextMenu::setPositionMark(enum markPosition _position, vec2 _arrowPos) {
 	EWOL_DEBUG("set context menu at the position : " << _arrowPos);
 	m_arrawBorder = _position;
 	m_arrowPos = _arrowPos;
 	markToRedraw();
 }
 
-ewol::object::Shared<ewol::Widget> ewol::Widget::ContextMenu::getWidgetAtPos(const vec2& _pos) {
+ewol::object::Shared<ewol::Widget> ewol::widget::ContextMenu::getWidgetAtPos(const vec2& _pos) {
-	ewol::object::Shared<ewol::Widget> val = ewol::Widget::Container::getWidgetAtPos(_pos);
+	ewol::object::Shared<ewol::Widget> val = ewol::widget::Container::getWidgetAtPos(_pos);
 	if (NULL != val) {
 		return val;
 	}
@@ -250,8 +250,8 @@ ewol::object::Shared<ewol::Widget> ewol::Widget::ContextMenu::getWidgetAtPos(con
 }
 
 
-bool ewol::Widget::ContextMenu::onSetConfig(const ewol::object::Config& _conf) {
+bool ewol::widget::ContextMenu::onSetConfig(const ewol::object::Config& _conf) {
-	if (true == ewol::Widget::Container::onSetConfig(_conf)) {
+	if (true == ewol::widget::Container::onSetConfig(_conf)) {
 		return true;
 	}
 	if (_conf.getConfig() == configArrowPosition) {
@@ -279,8 +279,8 @@ bool ewol::Widget::ContextMenu::onSetConfig(const ewol::object::Config& _conf) {
 	return false;
 }
 
-bool ewol::Widget::ContextMenu::onGetConfig(const char* _config, std::string& _result) const {
+bool ewol::widget::ContextMenu::onGetConfig(const char* _config, std::string& _result) const {
-	if (true == ewol::Widget::Container::onGetConfig(_config, _result)) {
+	if (true == ewol::widget::Container::onGetConfig(_config, _result)) {
 		return true;
 	}
 	if (_config == configArrowPosition) {

sources/ewol/widget/ContextMenu.h

@@ -22,7 +22,7 @@ namespace ewol {
 		/**
 		 * @ingroup ewolWidgetGroup
 		 */
-		class ContextMenu : public ewol::Widget::Container {
+		class ContextMenu : public ewol::widget::Container {
 			public:
 				enum markPosition {
 					markTop,
@@ -32,7 +32,7 @@ namespace ewol {
 					markNone
 				};
 			public:
-				static void init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager);
+				static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager);
 				// Config list of properties
 				static const char* const configArrowPosition;
 				static const char* const configArrowMode;

sources/ewol/widget/Entry.cpp

@@ -29,24 +29,24 @@ const char * const ewolEventEntrySelect = "ewol-widget-entry-event-internal-sele
 #define STATUS_HOVER     (1)
 #define STATUS_SELECTED  (2)
 
-static ewol::object::Shared<ewol::Widget> create() {
+static ewol::Widget* create() {
-	return new ewol::Widget::Entry();
+	return new ewol::widget::Entry();
 }
 
-void ewol::Widget::Entry::init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager) {
+void ewol::widget::Entry::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
-	_widgetManager.addWidgetCreator(__class__,&create);
+	_widgetManager->addWidgetCreator(__class__,&create);
 }
 
-const char * const ewol::Widget::Entry::eventClick  = "click";
+const char * const ewol::widget::Entry::eventClick  = "click";
-const char * const ewol::Widget::Entry::eventEnter  = "enter";
+const char * const ewol::widget::Entry::eventEnter  = "enter";
-const char * const ewol::Widget::Entry::eventModify = "modify";
+const char * const ewol::widget::Entry::eventModify = "modify";
 
-const char* const ewol::Widget::Entry::configMaxChar = "max";
+const char* const ewol::widget::Entry::configMaxChar = "max";
-const char* const ewol::Widget::Entry::configRegExp  = "regExp";
+const char* const ewol::widget::Entry::configRegExp  = "regExp";
-const char* const ewol::Widget::Entry::configEmptyMessage = "emptytext";
+const char* const ewol::widget::Entry::configEmptyMessage = "emptytext";
-const char* const ewol::Widget::Entry::configValue = "value";
+const char* const ewol::widget::Entry::configValue = "value";
 
-ewol::Widget::Entry::Entry(std::string _newData) :
+ewol::widget::Entry::Entry(std::string _newData) :
   m_shaper("THEME:GUI:Entry.json"),
   m_data(""),
   m_maxCharacter(0x7FFFFFFF),
@@ -57,7 +57,7 @@ ewol::Widget::Entry::Entry(std::string _newData) :
   m_displayCursorPos(0),
   m_displayCursorPosSelection(0),
   m_textWhenNothing("") {
-	addObjectType("ewol::Widget::Entry");
+	addObjectType("ewol::widget::Entry");
 	m_colorIdTextFg = m_shaper.requestColor("text-foreground");
 	m_colorIdTextBg = m_shaper.requestColor("text-background");
 	m_colorIdCursor = m_shaper.requestColor("text-cursor");
@@ -83,12 +83,12 @@ ewol::Widget::Entry::Entry(std::string _newData) :
 }
 
 
-ewol::Widget::Entry::~Entry() {
+ewol::widget::Entry::~Entry() {
 	
 }
 
 
-void ewol::Widget::Entry::setMaxChar(int32_t _nbMax) {
+void ewol::widget::Entry::setMaxChar(int32_t _nbMax) {
 	if (_nbMax <= 0) {
 		m_maxCharacter = 0x7FFFFFFF;
 	} else {
@@ -97,7 +97,7 @@ void ewol::Widget::Entry::setMaxChar(int32_t _nbMax) {
 }
 
 
-void ewol::Widget::Entry::calculateMinMaxSize() {
+void ewol::widget::Entry::calculateMinMaxSize() {
 	// call main class
 	ewol::Widget::calculateMinMaxSize();
 	// get generic padding
@@ -112,7 +112,7 @@ void ewol::Widget::Entry::calculateMinMaxSize() {
 }
 
 
-void ewol::Widget::Entry::setValue(const std::string& _newData) {
+void ewol::widget::Entry::setValue(const std::string& _newData) {
 	std::string newData = _newData;
 	if ((int64_t)newData.size() > m_maxCharacter) {
 		newData = std::string(_newData, 0, m_maxCharacter);
@@ -129,13 +129,13 @@ void ewol::Widget::Entry::setValue(const std::string& _newData) {
 }
 
 
-void ewol::Widget::Entry::onDraw() {
+void ewol::widget::Entry::onDraw() {
 	m_shaper.draw();
 	m_text.draw();
 }
 
 
-void ewol::Widget::Entry::onRegenerateDisplay() {
+void ewol::widget::Entry::onRegenerateDisplay() {
 	if (true == needRedraw()) {
 		m_shaper.clear();
 		m_text.clear();
@@ -192,7 +192,7 @@ void ewol::Widget::Entry::onRegenerateDisplay() {
 }
 
 
-void ewol::Widget::Entry::updateCursorPosition(const vec2& _pos, bool _selection) {
+void ewol::widget::Entry::updateCursorPosition(const vec2& _pos, bool _selection) {
 	ewol::Padding padding = m_shaper.getPadding();
 	
 	vec2 relPos = relativePosition(_pos);
@@ -229,7 +229,7 @@ void ewol::Widget::Entry::updateCursorPosition(const vec2& _pos, bool _selection
 }
 
 
-void ewol::Widget::Entry::removeSelected() {
+void ewol::widget::Entry::removeSelected() {
 	if (m_displayCursorPosSelection == m_displayCursorPos) {
 		// nothing to cut ...
 		return;
@@ -248,7 +248,7 @@ void ewol::Widget::Entry::removeSelected() {
 }
 
 
-void ewol::Widget::Entry::copySelectionToClipBoard(enum ewol::context::clipBoard::clipboardListe _clipboardID) {
+void ewol::widget::Entry::copySelectionToClipBoard(enum ewol::context::clipBoard::clipboardListe _clipboardID) {
 	if (m_displayCursorPosSelection == m_displayCursorPos) {
 		// nothing to cut ...
 		return;
@@ -265,7 +265,7 @@ void ewol::Widget::Entry::copySelectionToClipBoard(enum ewol::context::clipBoard
 }
 
 
-bool ewol::Widget::Entry::onEventInput(const ewol::event::Input& _event) {
+bool ewol::widget::Entry::onEventInput(const ewol::event::Input& _event) {
 	//EWOL_DEBUG("Event on Entry ... type=" << (int32_t)type << " id=" << IdInput);
 	if (1 == _event.getId()) {
 		if (ewol::key::statusSingle == _event.getStatus()) {
@@ -358,7 +358,7 @@ bool ewol::Widget::Entry::onEventInput(const ewol::event::Input& _event) {
 }
 
 
-bool ewol::Widget::Entry::onEventEntry(const ewol::event::Entry& _event) {
+bool ewol::widget::Entry::onEventEntry(const ewol::event::Entry& _event) {
 	if (_event.getType() == ewol::key::keyboardChar) {
 		if(_event.getStatus() == ewol::key::statusDown) {
 			//EWOL_DEBUG("Entry input data ... : \"" << unicodeData << "\" " );
@@ -430,7 +430,7 @@ bool ewol::Widget::Entry::onEventEntry(const ewol::event::Entry& _event) {
 	return false;
 }
 
-void ewol::Widget::Entry::setInternalValue(const std::string& _newData) {
+void ewol::widget::Entry::setInternalValue(const std::string& _newData) {
 	std::string previous = m_data;
 	// check the RegExp :
 	if (_newData.size()>0) {
@@ -449,7 +449,7 @@ void ewol::Widget::Entry::setInternalValue(const std::string& _newData) {
 	markToRedraw();
 }
 
-void ewol::Widget::Entry::onEventClipboard(enum ewol::context::clipBoard::clipboardListe _clipboardID) {
+void ewol::widget::Entry::onEventClipboard(enum ewol::context::clipBoard::clipboardListe _clipboardID) {
 	// remove curent selected data ...
 	removeSelected();
 	// get current selection / Copy :
@@ -473,7 +473,7 @@ void ewol::Widget::Entry::onEventClipboard(enum ewol::context::clipBoard::clipbo
 }
 
 
-void ewol::Widget::Entry::onReceiveMessage(const ewol::object::Message& _msg) {
+void ewol::widget::Entry::onReceiveMessage(const ewol::object::Message& _msg) {
 	ewol::Widget::onReceiveMessage(_msg);
 	if(_msg.getMessage() == ewolEventEntryClean) {
 		m_data = "";
@@ -500,11 +500,11 @@ void ewol::Widget::Entry::onReceiveMessage(const ewol::object::Message& _msg) {
 	}
 }
 
-void ewol::Widget::Entry::markToUpdateTextPosition() {
+void ewol::widget::Entry::markToUpdateTextPosition() {
 	m_needUpdateTextPos=true;
 }
 
-void ewol::Widget::Entry::updateTextPosition() {
+void ewol::widget::Entry::updateTextPosition() {
 	if (false == m_needUpdateTextPos) {
 		return;
 	}
@@ -539,35 +539,35 @@ void ewol::Widget::Entry::updateTextPosition() {
 	}
 }
 
-void ewol::Widget::Entry::onGetFocus() {
+void ewol::widget::Entry::onGetFocus() {
 	m_displayCursor = true;
 	changeStatusIn(STATUS_SELECTED);
 	showKeyboard();
 	markToRedraw();
 }
 
-void ewol::Widget::Entry::onLostFocus() {
+void ewol::widget::Entry::onLostFocus() {
 	m_displayCursor = false;
 	changeStatusIn(STATUS_NORMAL);
 	hideKeyboard();
 	markToRedraw();
 }
 
-void ewol::Widget::Entry::changeStatusIn(int32_t _newStatusId) {
+void ewol::widget::Entry::changeStatusIn(int32_t _newStatusId) {
 	if (true == m_shaper.changeStatusIn(_newStatusId) ) {
 		periodicCallEnable();
 		markToRedraw();
 	}
 }
 
-void ewol::Widget::Entry::periodicCall(const ewol::event::Time& _event) {
+void ewol::widget::Entry::periodicCall(const ewol::event::Time& _event) {
 	if (false == m_shaper.periodicCall(_event) ) {
 		periodicCallDisable();
 	}
 	markToRedraw();
 }
 
-void ewol::Widget::Entry::setRegExp(const std::string& _expression) {
+void ewol::widget::Entry::setRegExp(const std::string& _expression) {
 	std::string previousRegExp = m_regExp.getRegExp();
 	EWOL_DEBUG("change input regExp \"" << previousRegExp << "\"  == > \"" << _expression << "\"");
 	m_regExp.compile(_expression);
@@ -577,12 +577,12 @@ void ewol::Widget::Entry::setRegExp(const std::string& _expression) {
 	}
 }
 
-void ewol::Widget::Entry::setEmptyText(const std::string& _text) {
+void ewol::widget::Entry::setEmptyText(const std::string& _text) {
 	m_textWhenNothing = _text;
 	markToRedraw();
 }
 
-bool ewol::Widget::Entry::onSetConfig(const ewol::object::Config& _conf) {
+bool ewol::widget::Entry::onSetConfig(const ewol::object::Config& _conf) {
 	if (true == ewol::Widget::onSetConfig(_conf)) {
 		return true;
 	}
@@ -605,7 +605,7 @@ bool ewol::Widget::Entry::onSetConfig(const ewol::object::Config& _conf) {
 	return false;
 }
 
-bool ewol::Widget::Entry::onGetConfig(const char* _config, std::string& _result) const {
+bool ewol::widget::Entry::onGetConfig(const char* _config, std::string& _result) const {
 	if (true == ewol::Widget::onGetConfig(_config, _result)) {
 		return true;
 	}

sources/ewol/widget/Entry.h

@@ -43,7 +43,7 @@ namespace ewol {
 				static const char* const configEmptyMessage;
 				static const char* const configValue;
 			public:
-				static void init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager);
+				static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager);
 			private:
 				ewol::compositing::Shaper m_shaper;
 				int32_t m_colorIdTextFg; //!< color property of the text foreground

sources/ewol/widget/Gird.cpp

@@ -15,31 +15,31 @@
 #define __class__ "Gird"
 
 
-static ewol::object::Shared<ewol::Widget> create() {
+static ewol::Widget* create() {
-	return new ewol::Widget::Gird();
+	return new ewol::widget::Gird();
 }
 
-void ewol::Widget::Gird::init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager) {
+void ewol::widget::Gird::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
-	_widgetManager.addWidgetCreator(__class__,&create);
+	_widgetManager->addWidgetCreator(__class__,&create);
 }
 
 
-ewol::Widget::Gird::Gird(int32_t _colNumber) :
+ewol::widget::Gird::Gird(int32_t _colNumber) :
   m_sizeRow(0),
   m_tmpWidget(NULL),
   m_gavityButtom(true),
   m_borderSize(0,0) {
-	addObjectType("ewol::Widget::Gird");
+	addObjectType("ewol::widget::Gird");
 	setColNumber(_colNumber);
 	requestUpdateSize();
 }
 
-ewol::Widget::Gird::~Gird() {
+ewol::widget::Gird::~Gird() {
 	EWOL_DEBUG("[" << getId() << "]={" << getObjectType() << "} Gird : destroy");
 	subWidgetRemoveAll();
 }
 
-void ewol::Widget::Gird::setBorderSize(const ivec2& _newBorderSize) {
+void ewol::widget::Gird::setBorderSize(const ivec2& _newBorderSize) {
 	m_borderSize = _newBorderSize;
 	if (m_borderSize.x() < 0) {
 		EWOL_ERROR("Try to set a border size <0 on x : " << m_borderSize.x() << "  == > restore to 0");
@@ -53,7 +53,7 @@ void ewol::Widget::Gird::setBorderSize(const ivec2& _newBorderSize) {
 	requestUpdateSize();
 }
 
-void ewol::Widget::Gird::calculateSize(const vec2& _availlable) {
+void ewol::widget::Gird::calculateSize(const vec2& _availlable) {
 	//EWOL_DEBUG("Update size");
 	m_size = _availlable;
 	m_size -= m_borderSize*2;
@@ -91,7 +91,7 @@ void ewol::Widget::Gird::calculateSize(const vec2& _availlable) {
 	markToRedraw();
 }
 
-void ewol::Widget::Gird::calculateMinMaxSize() {
+void ewol::widget::Gird::calculateMinMaxSize() {
 	for (size_t iii=0; iii<m_sizeCol.size(); iii++ ){
 		if (m_sizeCol[iii] <= 0) {
 			m_sizeCol[iii] = 0;
@@ -137,7 +137,7 @@ void ewol::Widget::Gird::calculateMinMaxSize() {
 	//EWOL_DEBUG("Vert Result : expand="<< m_userExpand << "  minSize="<< m_minSize);
 }
 
-void ewol::Widget::Gird::setColNumber(int32_t _colNumber) {
+void ewol::widget::Gird::setColNumber(int32_t _colNumber) {
 	if ((int64_t)m_sizeCol.size() > _colNumber) {
 		size_t errorControl = m_subWidget.size();
 		// remove subWidget :
@@ -145,11 +145,10 @@ void ewol::Widget::Gird::setColNumber(int32_t _colNumber) {
 			if (m_subWidget[iii].col>(_colNumber-1)) {
 				// out of bounds : must remove it ...
 				if (m_subWidget[iii].widget != NULL) {
-					delete (m_subWidget[iii].widget);
+					m_subWidget[iii].widget.reset();
 					// no remove, this element is removed with the function onObjectRemove  == > it does not exist anymore ...
 					if (errorControl == m_subWidget.size()) {
 						EWOL_CRITICAL("[" << getId() << "] The number of element might have been reduced ...  == > it is not the case ==> the herited class must call the \"OnObjectRemove\" function...");
-						m_subWidget[iii].widget = NULL;
 					}
 				} else {
 					EWOL_WARNING("[" << getId() << "] Must not have null pointer on the subWidget list ...");
@@ -168,7 +167,7 @@ void ewol::Widget::Gird::setColNumber(int32_t _colNumber) {
 	}
 }
 
-void ewol::Widget::Gird::setColSize(int32_t _colId, int32_t _size) {
+void ewol::widget::Gird::setColSize(int32_t _colId, int32_t _size) {
 	if ((int64_t)m_sizeCol.size() > _colId) {
 		m_sizeCol[_colId] = _size;
 	} else {
@@ -178,11 +177,11 @@ void ewol::Widget::Gird::setColSize(int32_t _colId, int32_t _size) {
 	}
 }
 
-void ewol::Widget::Gird::setRowSize(int32_t _size) {
+void ewol::widget::Gird::setRowSize(int32_t _size) {
 	m_sizeRow = _size;
 }
 
-int32_t ewol::Widget::Gird::getColSize(int32_t _colId) {
+int32_t ewol::widget::Gird::getColSize(int32_t _colId) {
 	if ((int64_t)m_sizeCol.size() > _colId) {
 		if (m_sizeCol[_colId] <= 0) {
 			return 0;
@@ -193,20 +192,19 @@ int32_t ewol::Widget::Gird::getColSize(int32_t _colId) {
 	return 0;
 }
 
-int32_t ewol::Widget::Gird::getRowSize() {
+int32_t ewol::widget::Gird::getRowSize() {
 	return m_sizeRow;
 }
 
-void ewol::Widget::Gird::subWidgetRemoveAll() {
+void ewol::widget::Gird::subWidgetRemoveAll() {
 	size_t errorControl = m_subWidget.size();
 	// the size automaticly decrement with the auto call of the onObjectRemove function
 	while (m_subWidget.size() > 0 ) {
 		if (NULL != m_subWidget[0].widget) {
-			delete(m_subWidget[0].widget);
+			m_subWidget[0].widget.reset();
 			// no remove, this element is removed with the function onObjectRemove  == > it does not exist anymore ...
 			if (errorControl == m_subWidget.size()) {
 				EWOL_CRITICAL("[" << getId() << "] The number of element might have been reduced ...  == > it is not the case ==> the herited class must call the \"OnObjectRemove\" function...");
-				m_subWidget[0].widget = NULL;
 			}
 		} else {
 			EWOL_WARNING("[" << getId() << "] Must not have null pointer on the subWidget list ...");
@@ -218,7 +216,7 @@ void ewol::Widget::Gird::subWidgetRemoveAll() {
 }
 
 
-void ewol::Widget::Gird::subWidgetAdd(int32_t _colId, int32_t _rowId, ewol::Widget* _newWidget) {
+void ewol::widget::Gird::subWidgetAdd(int32_t _colId, int32_t _rowId, ewol::Widget* _newWidget) {
 	if (NULL == _newWidget) {
 		return;
 	}
@@ -247,7 +245,7 @@ void ewol::Widget::Gird::subWidgetAdd(int32_t _colId, int32_t _rowId, ewol::Widg
 				m_tmpWidget = m_subWidget[iii].widget;
 				m_subWidget[iii].widget = _newWidget;
 				if (NULL != m_tmpWidget) {
-					delete(m_tmpWidget);
+					m_tmpWidget.reset();
 					if (m_tmpWidget != NULL) {
 						EWOL_CRITICAL("[" << getId() << "] Error while replacing a widget ...  == > never call when free");
 						m_tmpWidget = NULL;
@@ -260,28 +258,17 @@ void ewol::Widget::Gird::subWidgetAdd(int32_t _colId, int32_t _rowId, ewol::Widg
 	m_subWidget.push_back(prop);
 }
 
-void ewol::Widget::Gird::subWidgetRemove(ewol::Widget* _newWidget)
+void ewol::widget::Gird::subWidgetRemove(ewol::object::Shared<ewol::Widget> _newWidget) {
-{
-	if (NULL == _newWidget) {
-		return;
-	}
-	size_t errorControl = m_subWidget.size();
 	for (size_t iii=0; iii<m_subWidget.size(); iii++) {
 		if (_newWidget == m_subWidget[iii].widget) {
-			delete(m_subWidget[iii].widget);
+			m_subWidget.erase(m_subWidget.begin()+iii);
-			// no remove, this element is removed with the function onObjectRemove  == > it does not exist anymore ...
-			if (errorControl == m_subWidget.size()) {
-				EWOL_CRITICAL("[" << getId() << "] The number of element might have been reduced ...  == > it is not the case ==> the herited class must call the \"OnObjectRemove\" function...");
-				m_subWidget[iii].widget = NULL;
-				m_subWidget.erase(m_subWidget.begin()+iii);
-			}
 			return;
 		}
 	}
 	EWOL_WARNING("[" << getId() << "] Can not remove unExistant widget");
 }
 
-void ewol::Widget::Gird::subWidgetRemove(int32_t _colId, int32_t _rowId) {
+void ewol::widget::Gird::subWidgetRemove(int32_t _colId, int32_t _rowId) {
 	if (_colId<0 || _rowId<0) {
 		EWOL_WARNING("[" << getId() << "] try to remove widget with id < 0 col=" << _colId << " row=" << _rowId);
 		return;
@@ -291,40 +278,26 @@ void ewol::Widget::Gird::subWidgetRemove(int32_t _colId, int32_t _rowId) {
 	for (size_t iii=0; iii<m_subWidget.size(); iii++) {
 		if(    m_subWidget[iii].row == _rowId
 		    && m_subWidget[iii].col == _colId) {
-			if (m_subWidget[iii].widget == NULL) {
+			m_subWidget.erase(m_subWidget.begin()+iii);
-				EWOL_WARNING("[" << getId() << "] remove NULL widget");
-				m_subWidget.erase(m_subWidget.begin()+iii);
-			} else {
-				// The element already exist  == > replace it ...
-				if (m_subWidget[iii].widget != NULL) {
-					delete(m_subWidget[iii].widget);
-					if (errorControl == m_subWidget.size()) {
-						EWOL_CRITICAL("[" << getId() << "] The number of element might have been reduced ...  == > it is not the case ==> the herited class must call the \"OnObjectRemove\" function...");
-						m_subWidget[iii].widget = NULL;
-						m_subWidget.erase(m_subWidget.begin()+iii);
-					}
-				}
-			}
 			return;
 		}
 	}
 	EWOL_WARNING("[" << getId() << "] Can not remove unExistant widget");
 }
 
-void ewol::Widget::Gird::subWidgetUnLink(ewol::Widget* _newWidget) {
+void ewol::widget::Gird::subWidgetUnLink(ewol::object::Shared<ewol::Widget> _newWidget) {
 	if (NULL == _newWidget) {
 		return;
 	}
 	for (size_t iii=0; iii<m_subWidget.size(); iii++) {
 		if (_newWidget == m_subWidget[iii].widget) {
-			m_subWidget[iii].widget = NULL;
 			m_subWidget.erase(m_subWidget.begin()+iii);
 			return;
 		}
 	}
 }
 
-void ewol::Widget::Gird::subWidgetUnLink(int32_t _colId, int32_t _rowId) {
+void ewol::widget::Gird::subWidgetUnLink(int32_t _colId, int32_t _rowId) {
 	if (_colId<0 || _rowId<0) {
 		EWOL_WARNING("[" << getId() << "] try to Unlink widget with id < 0 col=" << _colId << " row=" << _rowId);
 		return;
@@ -333,7 +306,6 @@ void ewol::Widget::Gird::subWidgetUnLink(int32_t _colId, int32_t _rowId) {
 	for (size_t iii=0; iii<m_subWidget.size(); iii++) {
 		if(    m_subWidget[iii].row == _rowId
 		    && m_subWidget[iii].col == _colId) {
-			m_subWidget[iii].widget = NULL;
 			m_subWidget.erase(m_subWidget.begin()+iii);
 			return;
 		}
@@ -341,7 +313,7 @@ void ewol::Widget::Gird::subWidgetUnLink(int32_t _colId, int32_t _rowId) {
 	EWOL_WARNING("[" << getId() << "] Can not unLink unExistant widget");
 }
 
-void ewol::Widget::Gird::systemDraw(const ewol::DrawProperty& _displayProp) {
+void ewol::widget::Gird::systemDraw(const ewol::DrawProperty& _displayProp) {
 	ewol::Widget::systemDraw(_displayProp);
 	for (size_t iii=0; iii<m_subWidget.size(); iii++) {
 		if (NULL != m_subWidget[iii].widget) {
@@ -350,7 +322,7 @@ void ewol::Widget::Gird::systemDraw(const ewol::DrawProperty& _displayProp) {
 	}
 }
 
-void ewol::Widget::Gird::onRegenerateDisplay() {
+void ewol::widget::Gird::onRegenerateDisplay() {
 	for (size_t iii=0; iii<m_subWidget.size(); iii++) {
 		if (NULL != m_subWidget[iii].widget) {
 			m_subWidget[iii].widget->onRegenerateDisplay();
@@ -358,7 +330,7 @@ void ewol::Widget::Gird::onRegenerateDisplay() {
 	}
 }
 
-ewol::object::Shared<ewol::Widget> * ewol::Widget::Gird::getWidgetAtPos(const vec2& _pos) {
+ewol::object::Shared<ewol::Widget> ewol::widget::Gird::getWidgetAtPos(const vec2& _pos) {
 	if (true == isHide()) {
 		return NULL;
 	}
@@ -370,7 +342,7 @@ ewol::object::Shared<ewol::Widget> * ewol::Widget::Gird::getWidgetAtPos(const ve
 			if(    (tmpOrigin.x() <= _pos.x() && tmpOrigin.x() + tmpSize.x() >= _pos.x())
 			    && (tmpOrigin.y() <= _pos.y() && tmpOrigin.y() + tmpSize.y() >= _pos.y()) )
 			{
-				ewol::object::Shared<ewol::Widget> * tmpWidget = m_subWidget[iii].widget->getWidgetAtPos(_pos);
+				ewol::object::Shared<ewol::Widget> tmpWidget = m_subWidget[iii].widget->getWidgetAtPos(_pos);
 				if (NULL != tmpWidget) {
 					return tmpWidget;
 				}
@@ -382,7 +354,7 @@ ewol::object::Shared<ewol::Widget> * ewol::Widget::Gird::getWidgetAtPos(const ve
 	return NULL;
 }
 
-void ewol::Widget::Gird::onObjectRemove(ewol::object::Shared<ewol::Object> * _removeObject) {
+void ewol::widget::Gird::onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject) {
 	// First step call parrent : 
 	ewol::Widget::onObjectRemove(_removeObject);
 	// second step find if in all the elements ...

sources/ewol/widget/Gird.h

@@ -22,7 +22,7 @@ namespace ewol {
 		 */
 		class Gird :public ewol::Widget {
 			public:
-				static void init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager);
+				static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager);
 			private:
 				class GirdProperties {
 					public:

sources/ewol/widget/Image.cpp

@@ -16,33 +16,33 @@
 #undef __class__
 #define __class__ "Image"
 
-static ewol::object::Shared<ewol::Widget> create() {
+static ewol::Widget* create() {
-	return new ewol::Widget::Image();
+	return new ewol::widget::Image();
 }
 
-void ewol::Widget::Image::init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager) {
+void ewol::widget::Image::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
-	_widgetManager.addWidgetCreator(__class__,&create);
+	_widgetManager->addWidgetCreator(__class__,&create);
 }
 
 
-const char * const ewol::Widget::Image::eventPressed = "pressed";
+const char * const ewol::widget::Image::eventPressed = "pressed";
 
-const char * const ewol::Widget::Image::configRatio = "ratio";
+const char * const ewol::widget::Image::configRatio = "ratio";
-const char * const ewol::Widget::Image::configSize = "size";
+const char * const ewol::widget::Image::configSize = "size";
-const char * const ewol::Widget::Image::configBorder = "border";
+const char * const ewol::widget::Image::configBorder = "border";
-const char * const ewol::Widget::Image::configSource = "src";
+const char * const ewol::widget::Image::configSource = "src";
-const char * const ewol::Widget::Image::configDistanceField = "distance-field";
+const char * const ewol::widget::Image::configDistanceField = "distance-field";
-const char * const ewol::Widget::Image::configPartStart = "part-start";
+const char * const ewol::widget::Image::configPartStart = "part-start";
-const char * const ewol::Widget::Image::configPartStop = "part-stop";
+const char * const ewol::widget::Image::configPartStop = "part-stop";
 
-ewol::Widget::Image::Image(const std::string& _file, const ewol::Dimension& _border) :
+ewol::widget::Image::Image(const std::string& _file, const ewol::Dimension& _border) :
   m_colorProperty(NULL),
   m_colorId(-1),
   m_imageSize(vec2(0.0f,0.0f)),
   m_keepRatio(true),
   m_posStart(0.0f,0.0f),
   m_posStop(1.0f,1.0f) {
-	addObjectType("ewol::Widget::Image");
+	addObjectType("ewol::widget::Image");
 	addEventId(eventPressed);
 	registerConfig(configRatio, "bool", NULL, "Keep ratio of the image");
 	registerConfig(configSize, "Dimension", NULL, "Basic display size of the image");
@@ -58,11 +58,11 @@ ewol::Widget::Image::Image(const std::string& _file, const ewol::Dimension& _bor
 	set(_file, _border);
 }
 
-ewol::Widget::Image::~Image() {
+ewol::widget::Image::~Image() {
 	ewol::resource::ColorFile::release(m_colorProperty);
 }
 
-void ewol::Widget::Image::setFile(const std::string& _file) {
+void ewol::widget::Image::setFile(const std::string& _file) {
 	EWOL_VERBOSE("Set Image : " << _file);
 	if (m_fileName != _file) {
 		// copy data :
@@ -74,7 +74,7 @@ void ewol::Widget::Image::setFile(const std::string& _file) {
 	}
 }
 
-void ewol::Widget::Image::setBorder(const ewol::Dimension& _border) {
+void ewol::widget::Image::setBorder(const ewol::Dimension& _border) {
 	EWOL_VERBOSE("Set border=" << _border);
 	// copy data :
 	m_border = _border;
@@ -84,7 +84,7 @@ void ewol::Widget::Image::setBorder(const ewol::Dimension& _border) {
 	requestUpdateSize();
 }
 
-void ewol::Widget::Image::setKeepRatio(bool _keep) {
+void ewol::widget::Image::setKeepRatio(bool _keep) {
 	if (m_keepRatio == _keep) {
 		return;
 	}
@@ -95,7 +95,7 @@ void ewol::Widget::Image::setKeepRatio(bool _keep) {
 	requestUpdateSize();
 }
 
-void ewol::Widget::Image::setStartPos(const vec2& _pos) {
+void ewol::widget::Image::setStartPos(const vec2& _pos) {
 	if (m_posStart == _pos) {
 		return;
 	}
@@ -106,7 +106,7 @@ void ewol::Widget::Image::setStartPos(const vec2& _pos) {
 	requestUpdateSize();
 }
 
-void ewol::Widget::Image::setStopPos(const vec2& _pos) {
+void ewol::widget::Image::setStopPos(const vec2& _pos) {
 	if (m_posStop == _pos) {
 		return;
 	}
@@ -117,7 +117,7 @@ void ewol::Widget::Image::setStopPos(const vec2& _pos) {
 	requestUpdateSize();
 }
 
-void ewol::Widget::Image::setImageSize(const ewol::Dimension& _size) {
+void ewol::widget::Image::setImageSize(const ewol::Dimension& _size) {
 	EWOL_VERBOSE("Set Image size : " << _size);
 	if (_size != m_imageSize) {
 		m_imageSize = _size;
@@ -128,7 +128,7 @@ void ewol::Widget::Image::setImageSize(const ewol::Dimension& _size) {
 	}
 }
 
-void ewol::Widget::Image::set(const std::string& _file, const ewol::Dimension& _border) {
+void ewol::widget::Image::set(const std::string& _file, const ewol::Dimension& _border) {
 	EWOL_VERBOSE("Set Image : " << _file << " border=" << _border);
 	// copy data :
 	if (m_border != _border) {
@@ -139,11 +139,11 @@ void ewol::Widget::Image::set(const std::string& _file, const ewol::Dimension& _
 	setFile(_file);
 }
 
-void ewol::Widget::Image::onDraw() {
+void ewol::widget::Image::onDraw() {
 	m_compositing.draw();
 }
 
-void ewol::Widget::Image::onRegenerateDisplay() {
+void ewol::widget::Image::onRegenerateDisplay() {
 	if (true == needRedraw()) {
 		// remove data of the previous composition :
 		m_compositing.clear();
@@ -197,7 +197,7 @@ void ewol::Widget::Image::onRegenerateDisplay() {
 	}
 }
 
-void ewol::Widget::Image::calculateMinMaxSize() {
+void ewol::widget::Image::calculateMinMaxSize() {
 	vec2 imageBoder = m_border.getPixel()*2.0f;
 	vec2 imageSize = m_imageSize.getPixel();
 	if (imageSize!=vec2(0,0)) {
@@ -218,7 +218,7 @@ void ewol::Widget::Image::calculateMinMaxSize() {
 }
 
 
-bool ewol::Widget::Image::onEventInput(const ewol::event::Input& _event) {
+bool ewol::widget::Image::onEventInput(const ewol::event::Input& _event) {
 	//EWOL_DEBUG("Event on BT ...");
 	if (1 == _event.getId()) {
 		if(ewol::key::statusSingle == _event.getStatus()) {
@@ -229,7 +229,7 @@ bool ewol::Widget::Image::onEventInput(const ewol::event::Input& _event) {
 	return false;
 }
 
-bool ewol::Widget::Image::loadXML(exml::Element* _node) {
+bool ewol::widget::Image::loadXML(exml::Element* _node) {
 	if (NULL == _node) {
 		return false;
 	}
@@ -268,7 +268,7 @@ bool ewol::Widget::Image::loadXML(exml::Element* _node) {
 	return true;
 }
 
-bool ewol::Widget::Image::onSetConfig(const ewol::object::Config& _conf) {
+bool ewol::widget::Image::onSetConfig(const ewol::object::Config& _conf) {
 	if (true == ewol::Widget::onSetConfig(_conf)) {
 		return true;
 	}
@@ -303,7 +303,7 @@ bool ewol::Widget::Image::onSetConfig(const ewol::object::Config& _conf) {
 	return false;
 }
 
-bool ewol::Widget::Image::onGetConfig(const char* _config, std::string& _result) const {
+bool ewol::widget::Image::onGetConfig(const char* _config, std::string& _result) const {
 	if (true == ewol::Widget::onGetConfig(_config, _result)) {
 		return true;
 	}

sources/ewol/widget/Image.h

@@ -38,7 +38,7 @@ namespace ewol {
 				/**
 				 * @brief Main call of recording the widget on the List of "widget named creator"
 				 */
-				static void init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager);
+				static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager);
 			protected:
 				ewol::compositing::Image m_compositing; //!< compositing element of the image.
 				ewol::resource::ColorFile* m_colorProperty; //!< theme color property

sources/ewol/widget/Joystick.cpp

@@ -12,20 +12,20 @@
 #include <ewol/compositing/Image.h>
 #include <ewol/widget/Manager.h>
 
-const char * const ewol::Widget::Joystick::eventEnable   = "enable";
+const char * const ewol::widget::Joystick::eventEnable   = "enable";
-const char * const ewol::Widget::Joystick::eventDisable  = "disable";
+const char * const ewol::widget::Joystick::eventDisable  = "disable";
-const char * const ewol::Widget::Joystick::eventMove     = "move";
+const char * const ewol::widget::Joystick::eventMove     = "move";
 
-static bool         l_displayBackground(true);
+static bool l_displayBackground(true);
 static std::string l_background("");
 static std::string l_foreground("");
-static float   l_ratio(1.0/7.0);
+static float l_ratio(1.0/7.0);
 
 #undef __class__
 #define __class__ "Joystick"
 
-ewol::Widget::Joystick::Joystick() {
+ewol::widget::Joystick::Joystick() {
-	addObjectType("ewol::Widget::Joystick");
+	addObjectType("ewol::widget::Joystick");
 	addEventId(eventEnable);
 	addEventId(eventDisable);
 	addEventId(eventMove);
@@ -51,18 +51,18 @@ ewol::Widget::Joystick::Joystick() {
 }
 
 
-ewol::Widget::Joystick::~Joystick() {
+ewol::widget::Joystick::~Joystick() {
 	
 }
 
 
-void ewol::Widget::Joystick::calculateSize(const vec2& availlable) {
+void ewol::widget::Joystick::calculateSize(const vec2& availlable) {
 	float minimumSize = etk_min(availlable.x(), availlable.y());
 	m_size.setValue(minimumSize, minimumSize);
 	markToRedraw();
 }
 
-void ewol::Widget::Joystick::onRegenerateDisplay() {
+void ewol::widget::Joystick::onRegenerateDisplay() {
 	if (true == needRedraw()) {
 		// clean the object list ...
 		
@@ -114,7 +114,7 @@ Sine Function:    sin(teta) = Opposite / Hypotenuse
 Cosine Function:  cos(teta) = Adjacent / Hypotenuse
 Tangent Function: tan(teta) = Opposite / Adjacent
 */
-bool ewol::Widget::Joystick::onEventInput(const ewol::event::Input& _event) {
+bool ewol::widget::Joystick::onEventInput(const ewol::event::Input& _event) {
 /*
 	if (1 == IdInput) {
 		if(    ewol::key::statusDown == typeEvent
@@ -173,7 +173,7 @@ bool ewol::Widget::Joystick::onEventInput(const ewol::event::Input& _event) {
 }
 
 
-void ewol::Widget::Joystick::ratio(float newRatio) {
+void ewol::widget::Joystick::ratio(float newRatio) {
 	if (newRatio > 1) {
 		newRatio = 1;
 	}
@@ -182,7 +182,7 @@ void ewol::Widget::Joystick::ratio(float newRatio) {
 }
 
 
-void ewol::Widget::Joystick::background(std::string imageNameInData, bool display) {
+void ewol::widget::Joystick::background(std::string imageNameInData, bool display) {
 	// TODO : check if it existed
 	m_background = imageNameInData;
 	m_displayBackground = display;
@@ -190,14 +190,14 @@ void ewol::Widget::Joystick::background(std::string imageNameInData, bool displa
 }
 
 
-void ewol::Widget::Joystick::foreground(std::string imageNameInData) {
+void ewol::widget::Joystick::foreground(std::string imageNameInData) {
 	// TODO : check if it existed
 	m_foreground = imageNameInData;
 	EWOL_INFO("Set default Joystick Foreground at " << m_foreground);
 }
 
 
-void ewol::Widget::Joystick::getProperty(float& distance, float& angle) {
+void ewol::widget::Joystick::getProperty(float& distance, float& angle) {
 	distance = m_distance;
 	angle = m_angle+M_PI/2;
 }

sources/ewol/widget/Label.cpp

@@ -15,22 +15,22 @@
 #undef __class__
 #define __class__ "Label"
 
-const char * const ewol::Widget::Label::eventPressed = "pressed";
+const char * const ewol::widget::Label::eventPressed = "pressed";
-const char* const ewol::Widget::Label::configValue  = "value";
+const char* const ewol::widget::Label::configValue  = "value";
 
 static ewol::Widget* create() {
-	return new ewol::Widget::Label();
+	return new ewol::widget::Label();
 }
 
-void ewol::Widget::Label::init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager) {
+void ewol::widget::Label::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
-	_widgetManager.addWidgetCreator(__class__,&create);
+	_widgetManager->addWidgetCreator(__class__,&create);
 }
 // TODO : Remove the label name in the constructor ...
-ewol::Widget::Label::Label(std::string _newLabel) :
+ewol::widget::Label::Label(std::string _newLabel) :
   m_colorProperty(NULL),
   m_colorDefaultFgText(-1),
   m_colorDefaultBgText(-1){
-	addObjectType("ewol::Widget::Label");
+	addObjectType("ewol::widget::Label");
 	m_colorProperty = ewol::resource::ColorFile::keep("THEME:COLOR:Label.json");
 	if (m_colorProperty != NULL) {
 		m_colorDefaultFgText = m_colorProperty->request("foreground");
@@ -43,11 +43,11 @@ ewol::Widget::Label::Label(std::string _newLabel) :
 	registerConfig(configValue, "string", NULL, "displayed value string"); // TODO : do not store in attibute...
 }
 
-ewol::Widget::Label::~Label() {
+ewol::widget::Label::~Label() {
 	ewol::resource::ColorFile::release(m_colorProperty);
 }
 
-void ewol::Widget::Label::calculateMinMaxSize() {
+void ewol::widget::Label::calculateMinMaxSize() {
 	vec2 tmpMax = m_userMaxSize.getPixel();
 	vec2 tmpMin = m_userMinSize.getPixel();
 	//EWOL_DEBUG("[" << getId() << "] {" << getObjectType() << "} tmpMax : " << tmpMax);
@@ -63,21 +63,21 @@ void ewol::Widget::Label::calculateMinMaxSize() {
 	EWOL_VERBOSE("[" << getId() << "] {" << getObjectType() << "} Result min size : " << tmpMin << " < " << m_minSize << " < " << tmpMax);
 }
 
-void ewol::Widget::Label::setLabel(const std::string& _newLabel) {
+void ewol::widget::Label::setLabel(const std::string& _newLabel) {
 	m_label = std::to_u32string(_newLabel);
 	markToRedraw();
 	requestUpdateSize();
 }
 
-std::string ewol::Widget::Label::getLabel() const {
+std::string ewol::widget::Label::getLabel() const {
 	return std::to_string(m_label);
 }
 
-void ewol::Widget::Label::onDraw() {
+void ewol::widget::Label::onDraw() {
 	m_text.draw();
 }
 
-void ewol::Widget::Label::onRegenerateDisplay() {
+void ewol::widget::Label::onRegenerateDisplay() {
 	if (needRedraw() == false) {
 		return;
 	}
@@ -135,7 +135,7 @@ void ewol::Widget::Label::onRegenerateDisplay() {
 	m_text.printDecorated(m_label);
 }
 
-bool ewol::Widget::Label::onEventInput(const ewol::event::Input& _event) {
+bool ewol::widget::Label::onEventInput(const ewol::event::Input& _event) {
 	//EWOL_DEBUG("Event on Label ...");
 	if (1 == _event.getId()) {
 		if (ewol::key::statusSingle == _event.getStatus()) {
@@ -147,7 +147,7 @@ bool ewol::Widget::Label::onEventInput(const ewol::event::Input& _event) {
 	return false;
 }
 
-bool ewol::Widget::Label::loadXML(exml::Element* _node) {
+bool ewol::widget::Label::loadXML(exml::Element* _node) {
 	if (NULL == _node) {
 		return false;
 	}
@@ -159,7 +159,7 @@ bool ewol::Widget::Label::loadXML(exml::Element* _node) {
 }
 
 
-bool ewol::Widget::Label::onSetConfig(const ewol::object::Config& _conf) {
+bool ewol::widget::Label::onSetConfig(const ewol::object::Config& _conf) {
 	if (true == ewol::Widget::onSetConfig(_conf)) {
 		return true;
 	}
@@ -170,7 +170,7 @@ bool ewol::Widget::Label::onSetConfig(const ewol::object::Config& _conf) {
 	return false;
 }
 
-bool ewol::Widget::Label::onGetConfig(const char* _config, std::string& _result) const {
+bool ewol::widget::Label::onGetConfig(const char* _config, std::string& _result) const {
 	if (true == ewol::Widget::onGetConfig(_config, _result)) {
 		return true;
 	}

sources/ewol/widget/Label.h

@@ -30,7 +30,7 @@ namespace ewol {
 				/**
 				 * @brief Main call of recording the widget on the List of "widget named creator"
 				 */
-				static void init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager);
+				static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager);
 			private:
 				ewol::compositing::Text m_text; //!< Compositing text element.
 				std::u32string m_label; //!< decorated text to display.

sources/ewol/widget/Layer.cpp

@@ -14,22 +14,22 @@
 #define __class__ "Layer"
 
 static ewol::Widget* create() {
-	return new ewol::Widget::Layer();
+	return new ewol::widget::Layer();
 }
 
-void ewol::Widget::Layer::init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager) {
+void ewol::widget::Layer::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
-	_widgetManager.addWidgetCreator(__class__,&create);
+	_widgetManager->addWidgetCreator(__class__,&create);
 }
 
-ewol::Widget::Layer::Layer() {
+ewol::widget::Layer::Layer() {
-	addObjectType("ewol::Widget::Layer");
+	addObjectType("ewol::widget::Layer");
 }
 
-ewol::Widget::Layer::~Layer() {
+ewol::widget::Layer::~Layer() {
 	EWOL_DEBUG("[" << getId() << "] Layer : destroy");
 }
 
-ewol::object::Shared<ewol::Widget> ewol::Widget::Layer::getWidgetAtPos(const vec2& _pos) {
+ewol::object::Shared<ewol::Widget> ewol::widget::Layer::getWidgetAtPos(const vec2& _pos) {
 	if (true == isHide()) {
 		return NULL;
 	}
@@ -41,7 +41,7 @@ ewol::object::Shared<ewol::Widget> ewol::Widget::Layer::getWidgetAtPos(const vec
 			if(    (tmpOrigin.x() <= _pos.x() && tmpOrigin.x() + tmpSize.x() >= _pos.x())
 			    && (tmpOrigin.y() <= _pos.y() && tmpOrigin.y() + tmpSize.y() >= _pos.y()) )
 			{
-				ewol::object::Shared<ewol::Widget> * tmpWidget = m_subWidget[iii]->getWidgetAtPos(_pos);
+				ewol::object::Shared<ewol::Widget> tmpWidget = m_subWidget[iii]->getWidgetAtPos(_pos);
 				if (NULL != tmpWidget) {
 					return tmpWidget;
 				}

sources/ewol/widget/Layer.h

@@ -19,12 +19,12 @@ namespace ewol {
 		/**
 		 * @ingroup ewolWidgetGroup
 		 */
-		class Layer : public ewol::Widget::ContainerN {
+		class Layer : public ewol::widget::ContainerN {
 			public:
 				/**
 				 * @brief Main call of recording the widget on the List of "widget named creator"
 				 */
-				static void init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager);
+				static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager);
 			public:
 				/**
 				 * @brief Constructor

sources/ewol/widget/List.cpp

@@ -16,8 +16,8 @@
 #define __class__ "List"
 
 
-ewol::Widget::List::List() {
+ewol::widget::List::List() {
-	addObjectType("ewol::Widget::List");
+	addObjectType("ewol::widget::List");
 	m_paddingSizeX = 2;
 	#ifdef __TARGET_OS__Android
 		m_paddingSizeY = 10;
@@ -28,7 +28,7 @@ ewol::Widget::List::List() {
 	setCanHaveFocus(true);
 }
 
-ewol::Widget::List::~List() {
+ewol::widget::List::~List() {
 	//clean all the object
 	for (size_t iii=0; iii<m_listOObject.size(); iii++) {
 		delete(m_listOObject[iii]);
@@ -37,7 +37,7 @@ ewol::Widget::List::~List() {
 	m_listOObject.clear();
 }
 
-void ewol::Widget::List::setRawVisible(int32_t _id) {
+void ewol::widget::List::setRawVisible(int32_t _id) {
 	EWOL_DEBUG("Set Raw visible : " << _id);
 	if (_id<0) {
 		return;
@@ -63,7 +63,7 @@ void ewol::Widget::List::setRawVisible(int32_t _id) {
 	markToRedraw();
 }
 
-void ewol::Widget::List::calculateMinMaxSize() {
+void ewol::widget::List::calculateMinMaxSize() {
 	/*int32_t fontId = getDefaultFontId();
 	int32_t minWidth = ewol::getWidth(fontId, m_label);
 	int32_t minHeight = ewol::getHeight(fontId);
@@ -73,7 +73,7 @@ void ewol::Widget::List::calculateMinMaxSize() {
 	m_minSize.setValue(200, 150);
 }
 
-void ewol::Widget::List::addOObject(ewol::Compositing* _newObject, int32_t _pos) {
+void ewol::widget::List::addOObject(ewol::Compositing* _newObject, int32_t _pos) {
 	if (NULL == _newObject) {
 		EWOL_ERROR("Try to add an empty object in the Widget generic display system");
 		return;
@@ -85,7 +85,7 @@ void ewol::Widget::List::addOObject(ewol::Compositing* _newObject, int32_t _pos)
 	}
 }
 
-void ewol::Widget::List::clearOObjectList() {
+void ewol::widget::List::clearOObjectList() {
 	for (size_t iii=0; iii<m_listOObject.size(); iii++) {
 		delete(m_listOObject[iii]);
 		m_listOObject[iii] = NULL;
@@ -93,7 +93,7 @@ void ewol::Widget::List::clearOObjectList() {
 	m_listOObject.clear();
 }
 
-void ewol::Widget::List::onDraw() {
+void ewol::widget::List::onDraw() {
 	for (size_t iii=0; iii<m_listOObject.size(); iii++) {
 		if (NULL != m_listOObject[iii]) {
 			m_listOObject[iii]->draw();
@@ -102,7 +102,7 @@ void ewol::Widget::List::onDraw() {
 	WidgetScrolled::onDraw();
 }
 
-void ewol::Widget::List::onRegenerateDisplay() {
+void ewol::widget::List::onRegenerateDisplay() {
 	if (true == needRedraw()) {
 		
 		// clean the object list ...
@@ -212,7 +212,7 @@ void ewol::Widget::List::onRegenerateDisplay() {
 	}
 }
 
-bool ewol::Widget::List::onEventInput(const ewol::event::Input& _event) {
+bool ewol::widget::List::onEventInput(const ewol::event::Input& _event) {
 	vec2 relativePos = relativePosition(_event.getPos());
 	
 	if (true == WidgetScrolled::onEventInput(_event)) {
@@ -240,10 +240,10 @@ bool ewol::Widget::List::onEventInput(const ewol::event::Input& _event) {
 	return isUsed;
 }
 
-void ewol::Widget::List::onGetFocus() {
+void ewol::widget::List::onGetFocus() {
 	EWOL_DEBUG("Ewol::List get focus");
 }
 
-void ewol::Widget::List::onLostFocus() {
+void ewol::widget::List::onLostFocus() {
 	EWOL_DEBUG("Ewol::List Lost focus");
 }

sources/ewol/widget/ListFileSystem.cpp

@@ -16,33 +16,33 @@
 #define __class__ "ListFileSystem"
 
 static ewol::Widget* Create() {
-	return new ewol::Widget::ListFileSystem();
+	return new ewol::widget::ListFileSystem();
 }
 
-void ewol::Widget::ListFileSystem::init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager) {
+void ewol::widget::ListFileSystem::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
-	_widgetManager.addWidgetCreator(__class__,&Create);
+	_widgetManager->addWidgetCreator(__class__,&Create);
 }
 
-const char * const ewol::Widget::ListFileSystem::eventFileSelect     = "file-select";
+const char * const ewol::widget::ListFileSystem::eventFileSelect     = "file-select";
-const char * const ewol::Widget::ListFileSystem::eventFileValidate   = "file-validate";
+const char * const ewol::widget::ListFileSystem::eventFileValidate   = "file-validate";
-const char * const ewol::Widget::ListFileSystem::eventFolderSelect   = "folder-select";
+const char * const ewol::widget::ListFileSystem::eventFolderSelect   = "folder-select";
-const char * const ewol::Widget::ListFileSystem::eventFolderValidate = "folder-validate";
+const char * const ewol::widget::ListFileSystem::eventFolderValidate = "folder-validate";
 
-const char* const ewol::Widget::ListFileSystem::configShowHidden = "show-hidden";
+const char* const ewol::widget::ListFileSystem::configShowHidden = "show-hidden";
-const char* const ewol::Widget::ListFileSystem::configShowFile = "show-file";
+const char* const ewol::widget::ListFileSystem::configShowFile = "show-file";
-const char* const ewol::Widget::ListFileSystem::configShowFolder = "show-folder";
+const char* const ewol::widget::ListFileSystem::configShowFolder = "show-folder";
-const char* const ewol::Widget::ListFileSystem::configShowTemporary = "show-temporary";
+const char* const ewol::widget::ListFileSystem::configShowTemporary = "show-temporary";
-const char* const ewol::Widget::ListFileSystem::configPath = "path";
+const char* const ewol::widget::ListFileSystem::configPath = "path";
-const char* const ewol::Widget::ListFileSystem::configSelect = "select";
+const char* const ewol::widget::ListFileSystem::configSelect = "select";
 
-ewol::Widget::ListFileSystem::ListFileSystem() :
+ewol::widget::ListFileSystem::ListFileSystem() :
   m_selectedLine(-1),
   m_folder ("/"),
   m_showFile(true),
   m_showFolder(true),
   m_showHidden(true),
   m_showTemporaryFile(true) {
-	addObjectType("ewol::Widget::ListFileSystem");
+	addObjectType("ewol::widget::ListFileSystem");
 	#if defined(__TARGET_OS__Windows)
 		m_folder = "c:/";
 	#endif
@@ -68,12 +68,12 @@ ewol::Widget::ListFileSystem::ListFileSystem() :
 	setMouseLimit(1);
 };
 
-ewol::Widget::ListFileSystem::~ListFileSystem() {
+ewol::widget::ListFileSystem::~ListFileSystem() {
 	clearList();
 	ewol::resource::ColorFile::release(m_colorProperty);
 };
 
-void ewol::Widget::ListFileSystem::clearList() {
+void ewol::widget::ListFileSystem::clearList() {
 	for (size_t iii=0; iii<m_list.size(); iii++) {
 		if (NULL != m_list[iii]) {
 			delete(m_list[iii]);
@@ -82,12 +82,12 @@ void ewol::Widget::ListFileSystem::clearList() {
 	}
 };
 
-etk::Color<> ewol::Widget::ListFileSystem::getBasicBG() {
+etk::Color<> ewol::widget::ListFileSystem::getBasicBG() {
 	return m_colorProperty->get(m_colorIdBackground1);
 }
 
 
-void ewol::Widget::ListFileSystem::regenerateView() {
+void ewol::widget::ListFileSystem::regenerateView() {
 	clearList();
 	m_selectedLine = -1;
 	m_list.clear();
@@ -99,7 +99,7 @@ void ewol::Widget::ListFileSystem::regenerateView() {
 	markToRedraw();
 }
 
-std::string ewol::Widget::ListFileSystem::getSelect() const {
+std::string ewol::widget::ListFileSystem::getSelect() const {
 	std::string tmpVal = "";
 	if (m_selectedLine >= 0) {
 		if (m_list[m_selectedLine] != NULL) {
@@ -110,7 +110,7 @@ std::string ewol::Widget::ListFileSystem::getSelect() const {
 }
 
 // select the specific file
-void ewol::Widget::ListFileSystem::setSelect(const std::string& _data) {
+void ewol::widget::ListFileSystem::setSelect(const std::string& _data) {
 	// remove selected line
 	m_selectedLine = -1;
 	// search the coresponding file :
@@ -126,16 +126,16 @@ void ewol::Widget::ListFileSystem::setSelect(const std::string& _data) {
 	markToRedraw();
 }
 
-uint32_t ewol::Widget::ListFileSystem::getNuberOfColomn() {
+uint32_t ewol::widget::ListFileSystem::getNuberOfColomn() {
 	return 1;
 }
 
-bool ewol::Widget::ListFileSystem::getTitle(int32_t _colomn, std::string &_myTitle, etk::Color<>& _fg, etk::Color<>& _bg) {
+bool ewol::widget::ListFileSystem::getTitle(int32_t _colomn, std::string &_myTitle, etk::Color<>& _fg, etk::Color<>& _bg) {
 	_myTitle = "title";
 	return true;
 }
 
-uint32_t ewol::Widget::ListFileSystem::getNuberOfRaw() {
+uint32_t ewol::widget::ListFileSystem::getNuberOfRaw() {
 	int32_t offset = 0;
 	if (m_showFolder == true) {
 		if (m_folder == "/") {
@@ -147,7 +147,7 @@ uint32_t ewol::Widget::ListFileSystem::getNuberOfRaw() {
 	return m_list.size() + offset;
 }
 
-bool ewol::Widget::ListFileSystem::getElement(int32_t _colomn, int32_t _raw, std::string& _myTextToWrite, etk::Color<>& _fg, etk::Color<>& _bg) {
+bool ewol::widget::ListFileSystem::getElement(int32_t _colomn, int32_t _raw, std::string& _myTextToWrite, etk::Color<>& _fg, etk::Color<>& _bg) {
 	int32_t offset = 0;
 	if (m_showFolder == true) {
 		if (m_folder == "/") {
@@ -181,7 +181,7 @@ bool ewol::Widget::ListFileSystem::getElement(int32_t _colomn, int32_t _raw, std
 };
 
 
-bool ewol::Widget::ListFileSystem::onItemEvent(int32_t _IdInput,
+bool ewol::widget::ListFileSystem::onItemEvent(int32_t _IdInput,
                                                enum ewol::key::status _typeEvent,
                                                int32_t _colomn,
                                                int32_t _raw,
@@ -264,8 +264,8 @@ bool ewol::Widget::ListFileSystem::onItemEvent(int32_t _IdInput,
 }
 
 
-bool ewol::Widget::ListFileSystem::onSetConfig(const ewol::object::Config& _conf) {
+bool ewol::widget::ListFileSystem::onSetConfig(const ewol::object::Config& _conf) {
-	if (true == ewol::Widget::List::onSetConfig(_conf)) {
+	if (true == ewol::widget::List::onSetConfig(_conf)) {
 		return true;
 	}
 	if (_conf.getConfig() == configShowHidden) {
@@ -295,8 +295,8 @@ bool ewol::Widget::ListFileSystem::onSetConfig(const ewol::object::Config& _conf
 	return false;
 }
 
-bool ewol::Widget::ListFileSystem::onGetConfig(const char* _config, std::string& _result) const {
+bool ewol::widget::ListFileSystem::onGetConfig(const char* _config, std::string& _result) const {
-	if (true == ewol::Widget::List::onGetConfig(_config, _result)) {
+	if (true == ewol::widget::List::onGetConfig(_config, _result)) {
 		return true;
 	}
 	if (_config == configShowHidden) {

sources/ewol/widget/ListFileSystem.h

@@ -18,10 +18,10 @@ namespace ewol {
 		/**
 		 * @brief Generic display folder class. This widget display the content of a single folder :
 		 */
-		class ListFileSystem : public ewol::Widget::List {
+		class ListFileSystem : public ewol::widget::List {
 			public:
 				//! @not-in-doc
-				static void init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager);
+				static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager);
 				// Event list of properties
 				static const char * const eventFileSelect; //!< @event "file-select" Generated when a file is selected.
 				static const char * const eventFileValidate; //!< @event "file-validate" Generate when the user validate (return) or double click on the element

sources/ewol/widget/Manager.cpp

@@ -29,9 +29,9 @@
 #include <vector>
 
 #undef __class__
-#define __class__ "ewol::Widget::Manager"
+#define __class__ "ewol::widget::Manager"
 
-ewol::Widget::Manager::Manager() :
+ewol::widget::Manager::Manager() :
   m_focusWidgetDefault(NULL),
   m_focusWidgetCurrent(NULL),
   m_havePeriodic(false),
@@ -43,26 +43,26 @@ ewol::Widget::Manager::Manager() :
 	m_applWakeUpTime = ewol::getTime();
 	m_lastPeriodicCallTime = ewol::getTime();
 	
-	ewol::Widget::Button::init(*this);
+	ewol::widget::Button::init(*this);
-	ewol::Widget::ButtonColor::init(*this);
+	ewol::widget::ButtonColor::init(*this);
 	ewol::Widget::Spacer::init(*this);
-	ewol::Widget::Slider::init(*this);
+	ewol::widget::Slider::init(*this);
-	ewol::Widget::Sizer::init(*this);
+	ewol::widget::Sizer::init(*this);
 	ewol::Widget::ProgressBar::init(*this);
-	ewol::Widget::Layer::init(*this);
+	ewol::widget::Layer::init(*this);
-	ewol::Widget::Label::init(*this);
+	ewol::widget::Label::init(*this);
-	ewol::Widget::Image::init(*this);
+	ewol::widget::Image::init(*this);
-	ewol::Widget::Gird::init(*this);
+	ewol::widget::Gird::init(*this);
-	ewol::Widget::Entry::init(*this);
+	ewol::widget::Entry::init(*this);
-	ewol::Widget::CheckBox::init(*this);
+	ewol::widget::CheckBox::init(*this);
 	ewol::Widget::Scroll::init(*this);
-	ewol::Widget::ContextMenu::init(*this);
+	ewol::widget::ContextMenu::init(*this);
 	ewol::Widget::PopUp::init(*this);
 	ewol::Widget::WSlider::init(*this);
-	ewol::Widget::ListFileSystem::init(*this);
+	ewol::widget::ListFileSystem::init(*this);
 }
 
-ewol::Widget::Manager::~Manager() {
+ewol::widget::Manager::~Manager() {
 	EWOL_DEBUG(" == > Un-Init Widget-Manager");
 	EWOL_INFO("Realease all FOCUS");
 	focusSetDefault(NULL);
@@ -72,7 +72,7 @@ ewol::Widget::Manager::~Manager() {
 	m_creatorList.clear();
 }
 
-void ewol::Widget::Manager::rm(ewol::Widget* _newWidget) {
+void ewol::widget::Manager::rm(ewol::Widget* _newWidget) {
 	periodicCallRm(_newWidget);
 	focusRemoveIfRemove(_newWidget);
 }
@@ -81,7 +81,7 @@ void ewol::Widget::Manager::rm(ewol::Widget* _newWidget) {
  * focus Area : 
  * *************************************************************************/
 
-void ewol::Widget::Manager::focusKeep(ewol::Widget* _newWidget) {
+void ewol::widget::Manager::focusKeep(ewol::Widget* _newWidget) {
 	if (NULL == _newWidget) {
 		// nothing to do ...
 		return;
@@ -106,7 +106,7 @@ void ewol::Widget::Manager::focusKeep(ewol::Widget* _newWidget) {
 	}
 }
 
-void ewol::Widget::Manager::focusSetDefault(ewol::Widget * _newWidget) {
+void ewol::widget::Manager::focusSetDefault(ewol::Widget * _newWidget) {
 	if(    NULL != _newWidget
 	    && false == _newWidget->canHaveFocus() ) {
 		EWOL_VERBOSE("Widget can not have focus, id=" << _newWidget->getId() );
@@ -126,7 +126,7 @@ void ewol::Widget::Manager::focusSetDefault(ewol::Widget * _newWidget) {
 	m_focusWidgetDefault = _newWidget;
 }
 
-void ewol::Widget::Manager::focusRelease() {
+void ewol::widget::Manager::focusRelease() {
 	if (m_focusWidgetDefault == m_focusWidgetCurrent) {
 		// nothink to do ...
 		return;
@@ -143,11 +143,11 @@ void ewol::Widget::Manager::focusRelease() {
 }
 
 
-ewol::object::Shared<ewol::Widget> * ewol::Widget::Manager::focusGet() {
+ewol::object::Shared<ewol::Widget> * ewol::widget::Manager::focusGet() {
 	return m_focusWidgetCurrent;
 }
 
-void ewol::Widget::Manager::focusRemoveIfRemove(ewol::object::Shared<ewol::Widget> _newWidget) {
+void ewol::widget::Manager::focusRemoveIfRemove(ewol::object::Shared<ewol::Widget> _newWidget) {
 	if (m_focusWidgetCurrent == _newWidget) {
 		EWOL_WARNING("Release focus when remove widget");
 		focusRelease();
@@ -158,7 +158,7 @@ void ewol::Widget::Manager::focusRemoveIfRemove(ewol::object::Shared<ewol::Widge
 	}
 }
 
-void ewol::Widget::Manager::periodicCallAdd(ewol::object::Shared<ewol::Widget> _pWidget) {
+void ewol::widget::Manager::periodicCallAdd(ewol::object::Shared<ewol::Widget> _pWidget) {
 	for (size_t iii=0; iii < m_listOfPeriodicWidget.size(); iii++) {
 		if (m_listOfPeriodicWidget[iii] == _pWidget) {
 			return;
@@ -174,7 +174,7 @@ void ewol::Widget::Manager::periodicCallAdd(ewol::object::Shared<ewol::Widget> _
 	m_havePeriodic = true;
 }
 
-void ewol::Widget::Manager::periodicCallRm(ewol::object::Shared<ewol::Widget> _pWidget) {
+void ewol::widget::Manager::periodicCallRm(ewol::object::Shared<ewol::Widget> _pWidget) {
 	int32_t nbElement = 0;
 	for (int32_t iii=m_listOfPeriodicWidget.size()-1; iii >= 0 ; iii--) {
 		if (m_listOfPeriodicWidget[iii] == _pWidget) {
@@ -188,11 +188,11 @@ void ewol::Widget::Manager::periodicCallRm(ewol::object::Shared<ewol::Widget> _p
 	}
 }
 
-void ewol::Widget::Manager::periodicCallResume(int64_t _localTime) {
+void ewol::widget::Manager::periodicCallResume(int64_t _localTime) {
 	m_lastPeriodicCallTime = _localTime;
 }
 
-void ewol::Widget::Manager::periodicCall(int64_t _localTime) {
+void ewol::widget::Manager::periodicCall(int64_t _localTime) {
 	int64_t previousTime = m_lastPeriodicCallTime;
 	m_lastPeriodicCallTime = _localTime;
 	if (m_listOfPeriodicWidget.size() <= 0) {
@@ -228,23 +228,23 @@ void ewol::Widget::Manager::periodicCall(int64_t _localTime) {
 	}
 }
 
-bool ewol::Widget::Manager::periodicCallHave() {
+bool ewol::widget::Manager::periodicCallHave() {
 	return m_havePeriodic;
 }
 
-void ewol::Widget::Manager::markDrawingIsNeeded() {
+void ewol::widget::Manager::markDrawingIsNeeded() {
 	m_haveRedraw = true;
 }
 
-bool ewol::Widget::Manager::isDrawingNeeded() {
+bool ewol::widget::Manager::isDrawingNeeded() {
 	bool tmp = m_haveRedraw;
 	m_haveRedraw = false;
 	return tmp;
 }
 
 // element that generate the list of elements
-void ewol::Widget::Manager::addWidgetCreator(const std::string& _name,
+void ewol::widget::Manager::addWidgetCreator(const std::string& _name,
-                                           ewol::Widget::Manager::creator_tf _pointer) {
+                                           ewol::widget::Manager::creator_tf _pointer) {
 	if (NULL == _pointer) {
 		return;
 	}
@@ -259,10 +259,10 @@ void ewol::Widget::Manager::addWidgetCreator(const std::string& _name,
 	m_creatorList.add(nameLower, _pointer);
 }
 
-ewol::Widget* ewol::Widget::Manager::create(const std::string& _name) {
+ewol::Widget* ewol::widget::Manager::create(const std::string& _name) {
 	std::string nameLower = std::tolower(_name);
 	if (m_creatorList.exist(nameLower) == true) {
-		ewol::Widget::Manager::creator_tf pointerFunction = m_creatorList[nameLower];
+		ewol::widget::Manager::creator_tf pointerFunction = m_creatorList[nameLower];
 		if (pointerFunction != nullptr) {
 			return pointerFunction();
 		}
@@ -271,12 +271,12 @@ ewol::Widget* ewol::Widget::Manager::create(const std::string& _name) {
 	return NULL;
 }
 
-bool ewol::Widget::Manager::exist(const std::string& _name) {
+bool ewol::widget::Manager::exist(const std::string& _name) {
 	std::string nameLower = std::tolower(_name);
 	return m_creatorList.exist(nameLower);
 }
 
-std::string ewol::Widget::Manager::list() {
+std::string ewol::widget::Manager::list() {
 	std::string tmpVal;
 	for (int32_t iii=0; iii<m_creatorList.size() ; iii++) {
 		tmpVal += m_creatorList.getKey(iii);

sources/ewol/widget/Menu.cpp

@@ -30,7 +30,7 @@ ewol::Widget::Menu::~Menu() {
 
 void ewol::Widget::Menu::subWidgetRemoveAll() {
 	clear();
-	ewol::Widget::Sizer::subWidgetRemoveAll();
+	ewol::widget::Sizer::subWidgetRemoveAll();
 }
 
 int32_t ewol::Widget::Menu::subWidgetAdd(ewol::Widget* _newWidget) {
@@ -82,8 +82,8 @@ int32_t ewol::Widget::Menu::add(int32_t _parent,
 	tmpObject->m_message = _message;
 	m_listElement.push_back(tmpObject);
 	if (-1 == tmpObject->m_parentId) {
-		ewol::Widget::Button *myButton = NULL;
+		ewol::widget::Button *myButton = NULL;
-		myButton = new ewol::Widget::Button();
+		myButton = new ewol::widget::Button();
 		if (NULL == myButton) {
 			EWOL_ERROR("Allocation button error");
 			return tmpObject->m_localId;
@@ -97,15 +97,15 @@ int32_t ewol::Widget::Menu::add(int32_t _parent,
 			}
 			composeString+="    <label>" + tmpObject->m_label + "</label>\n";
 			composeString+="</sizer>\n";
-			myButton->setSubWidget(new ewol::Widget::Composer(widget::Composer::String, composeString));
+			myButton->setSubWidget(new ewol::widget::Composer(widget::Composer::String, composeString));
 		} else {
-			myButton->setSubWidget(new ewol::Widget::Label(tmpObject->m_label) );
+			myButton->setSubWidget(new ewol::widget::Label(tmpObject->m_label) );
 		}
 		
 		// add it in the widget list
-		ewol::Widget::Sizer::subWidgetAdd(myButton);
+		ewol::widget::Sizer::subWidgetAdd(myButton);
 		// keep the specific event ...
-		myButton->registerOnEvent(this, ewol::Widget::Button::eventPressed, widget::Button::eventPressed);
+		myButton->registerOnEvent(this, ewol::widget::Button::eventPressed, widget::Button::eventPressed);
 		tmpObject->m_widgetPointer = myButton;
 	}
 	return tmpObject->m_localId;
@@ -123,7 +123,7 @@ void ewol::Widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
 	}
 	*/
 	EWOL_ERROR(" receive message : " << _msg);
-	if (_msg.getMessage() == ewol::Widget::Button::eventPressed) {
+	if (_msg.getMessage() == ewol::widget::Button::eventPressed) {
 		for (size_t iii=0; iii<m_listElement.size(); iii++) {
 			if (_msg.getCaller() == m_listElement[iii]->m_widgetPointer) {
 				// 2 posible case (have a message or have a child ...
@@ -151,7 +151,7 @@ void ewol::Widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
 						return;
 					}
 					// create a context menu : 
-					m_widgetContextMenu = new ewol::Widget::ContextMenu();
+					m_widgetContextMenu = new ewol::widget::ContextMenu();
 					if (NULL == m_widgetContextMenu) {
 						EWOL_ERROR("Allocation Error");
 						return;
@@ -167,12 +167,12 @@ void ewol::Widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
 						                     tmpOri.y() );
 					}
 					
-					m_widgetContextMenu->setPositionMark(ewol::Widget::ContextMenu::markTop, newPosition );
+					m_widgetContextMenu->setPositionMark(ewol::widget::ContextMenu::markTop, newPosition );
 					
-					ewol::Widget::Sizer * mySizer = NULL;
+					ewol::widget::Sizer * mySizer = NULL;
-					ewol::Widget::Button * myButton = NULL;
+					ewol::widget::Button * myButton = NULL;
 					
-					mySizer = new ewol::Widget::Sizer(widget::Sizer::modeVert);
+					mySizer = new ewol::widget::Sizer(widget::Sizer::modeVert);
 					if (NULL != mySizer) {
 						mySizer->lockExpand(vec2(true,true));
 						// set it in the pop-up-system : 
@@ -192,7 +192,7 @@ void ewol::Widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
 						for (int64_t jjj=m_listElement.size()-1; jjj >= 0; jjj--) {
 							if (m_listElement[iii]!=NULL) {
 								if (m_listElement[iii]->m_localId == m_listElement[jjj]->m_parentId) {
-									myButton = new ewol::Widget::Button();
+									myButton = new ewol::widget::Button();
 									if (NULL == myButton) {
 										EWOL_ERROR("Allocation Error");
 									} else {
@@ -208,11 +208,11 @@ void ewol::Widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
 											composeString+="        <label exand=\"true,true\" fill=\"true,true\">" + m_listElement[jjj]->m_label + "</label>\n";
 											composeString+="    </sizer>\n";
 											composeString+="</composer>\n";
-											myButton->setSubWidget(new ewol::Widget::Composer(widget::Composer::String, composeString));
+											myButton->setSubWidget(new ewol::widget::Composer(widget::Composer::String, composeString));
 										} else {
 											if (true == menuHaveImage) {
 												myButton->setSubWidget(
-												    new ewol::Widget::Composer(widget::Composer::String,
+												    new ewol::widget::Composer(widget::Composer::String,
 												        std::string("<composer expand=\"true,false\" fill=\"true,true\">\n") + 
 												        "	<sizer mode=\"hori\" expand=\"true,false\" fill=\"true,true\" lock=\"true\">\n"
 												        "		<spacer min-size=\"8,0mm\"/>\n"
@@ -220,7 +220,7 @@ void ewol::Widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
 												        "	</sizer>\n"
 												        "</composer>\n"));
 											} else {
-												ewol::Widget::Label* tmpLabel = new widget::Label(std::string("<left>") + m_listElement[jjj]->m_label + "</left>\n");
+												ewol::widget::Label* tmpLabel = new widget::Label(std::string("<left>") + m_listElement[jjj]->m_label + "</left>\n");
 												if (NULL != tmpLabel) {
 													tmpLabel->setExpand(bvec2(true,false));
 													tmpLabel->setFill(bvec2(true,true));
@@ -229,7 +229,7 @@ void ewol::Widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
 											}
 										}
 										// set the image if one is present ...
-										myButton->registerOnEvent(this, ewol::Widget::Button::eventPressed, widget::Button::eventPressed);
+										myButton->registerOnEvent(this, ewol::widget::Button::eventPressed, widget::Button::eventPressed);
 										myButton->setExpand(bvec2(true,false));
 										myButton->setFill(bvec2(true,false));
 										// add it in the widget list
@@ -240,7 +240,7 @@ void ewol::Widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
 							}
 						}
 					}
-					ewol::Widget::Windows* currentWindows = getWindows();
+					ewol::widget::Windows* currentWindows = getWindows();
 					if (NULL == currentWindows) {
 						EWOL_ERROR("Can not get the curent Windows...");
 						m_widgetContextMenu->removeObject();
@@ -257,7 +257,7 @@ void ewol::Widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
 
 
 void ewol::Widget::Menu::onObjectRemove(ewol::object::Shared<ewol::Object> * _removeObject) {
-	ewol::Widget::Sizer::onObjectRemove(_removeObject);
+	ewol::widget::Sizer::onObjectRemove(_removeObject);
 	if (m_widgetContextMenu == _removeObject) {
 		m_widgetContextMenu = NULL;
 	}

sources/ewol/widget/Menu.h

@@ -32,7 +32,7 @@ namespace ewol {
 		/**
 		 * @ingroup ewolWidgetGroup
 		 */
-		class Menu :public ewol::Widget::Sizer {
+		class Menu :public ewol::widget::Sizer {
 			public:
 				Menu();
 				virtual ~Menu();
@@ -44,7 +44,7 @@ namespace ewol {
 			private:
 				std::vector<ewol::Widget::MenuElement*> m_listElement;
 				int32_t m_staticId; // unique ID for every element of the menu ...
-				ewol::Widget::ContextMenu* m_widgetContextMenu;
+				ewol::widget::ContextMenu* m_widgetContextMenu;
 			public:
 				void clear();
 				int32_t addTitle(std::string _label, std::string _image="", const char * _generateEvent = NULL, const std::string _message = "");

sources/ewol/widget/PopUp.cpp

@@ -22,12 +22,12 @@ const char* const ewol::Widget::PopUp::configLockExpand="lock";
 
 static const char* annimationIncrease = "increase";
 
-static ewol::object::Shared<ewol::Widget> create() {
+static ewol::Widget* create() {
 	return new ewol::Widget::PopUp();
 }
 
-void ewol::Widget::PopUp::init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager) {
+void ewol::Widget::PopUp::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
-	_widgetManager.addWidgetCreator(__class__,&create);
+	_widgetManager->addWidgetCreator(__class__,&create);
 }
 
 ewol::Widget::PopUp::PopUp(const std::string& _shaperName) :
@@ -148,7 +148,7 @@ void ewol::Widget::PopUp::onRegenerateDisplay() {
 }
 
 ewol::object::Shared<ewol::Widget> ewol::Widget::PopUp::getWidgetAtPos(const vec2& _pos) {
-	ewol::object::Shared<ewol::Widget> val = ewol::Widget::Container::getWidgetAtPos(_pos);
+	ewol::object::Shared<ewol::Widget> val = ewol::widget::Container::getWidgetAtPos(_pos);
 	if (NULL != val) {
 		return val;
 	}
@@ -156,7 +156,7 @@ ewol::object::Shared<ewol::Widget> ewol::Widget::PopUp::getWidgetAtPos(const vec
 }
 
 bool ewol::Widget::PopUp::onSetConfig(const ewol::object::Config& _conf) {
-	if (true == ewol::Widget::Container::onSetConfig(_conf)) {
+	if (true == ewol::widget::Container::onSetConfig(_conf)) {
 		return true;
 	}
 	if (_conf.getConfig() == configShaper) {
@@ -175,7 +175,7 @@ bool ewol::Widget::PopUp::onSetConfig(const ewol::object::Config& _conf) {
 }
 
 bool ewol::Widget::PopUp::onGetConfig(const char* _config, std::string& _result) const {
-	if (true == ewol::Widget::Container::onGetConfig(_config, _result)) {
+	if (true == ewol::widget::Container::onGetConfig(_config, _result)) {
 		return true;
 	}
 	if (_config == configShaper) {

sources/ewol/widget/PopUp.h

@@ -22,9 +22,9 @@ namespace ewol {
 		/**
 		 * @ingroup ewolWidgetGroup
 		 */
-		class PopUp : public ewol::Widget::Container {
+		class PopUp : public ewol::widget::Container {
 			public:
-				static void init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager);
+				static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager);
 				// Config list of properties
 				static const char* const configShaper;
 				static const char* const configRemoveOnExternClick;

sources/ewol/widget/ProgressBar.cpp

@@ -14,12 +14,12 @@
 #undef __class__
 #define __class__	"ProgressBar"
 
-static ewol::object::Shared<ewol::Widget> create() {
+static ewol::Widget* create() {
 	return new ewol::Widget::ProgressBar();
 }
 
-void ewol::Widget::ProgressBar::init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager) {
+void ewol::Widget::ProgressBar::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
-	_widgetManager.addWidgetCreator(__class__,&create);
+	_widgetManager->addWidgetCreator(__class__,&create);
 }
 
 const char* const ewol::Widget::ProgressBar::configColorBg = "color-bg";

sources/ewol/widget/ProgressBar.h

@@ -23,7 +23,7 @@ namespace ewol {
 		 */
 		class ProgressBar : public ewol::object::Shared<ewol::Widget> {
 			public:
-				static void init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager);
+				static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager);
 				// Config list of properties
 				static const char* const configColorBg;
 				static const char* const configColorFgOn;

sources/ewol/widget/Scroll.cpp

@@ -14,12 +14,12 @@
 #undef __class__
 #define __class__ "Scroll"
 
-static ewol::object::Shared<ewol::Widget> create() {
+static ewol::Widget* create() {
 	return new ewol::Widget::Scroll();
 }
 
-void ewol::Widget::Scroll::init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager) {
+void ewol::Widget::Scroll::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
-	_widgetManager.addWidgetCreator(__class__,&create);
+	_widgetManager->addWidgetCreator(__class__,&create);
 }
 
 const char* const ewol::Widget::Scroll::configLimit = "limit";
@@ -76,7 +76,7 @@ void ewol::Widget::Scroll::onDraw() {
 
 void ewol::Widget::Scroll::onRegenerateDisplay() {
 	// call upper class
-	ewol::Widget::Container::onRegenerateDisplay();
+	ewol::widget::Container::onRegenerateDisplay();
 	if (needRedraw() == false) {
 		return;
 	}
@@ -350,7 +350,7 @@ bool ewol::Widget::Scroll::onEventInput(const ewol::event::Input& _event) {
 }
 
 ewol::object::Shared<ewol::Widget> ewol::Widget::Scroll::getWidgetAtPos(const vec2& _pos) {
-	ewol::object::Shared<ewol::Widget> tmpWidget = ewol::Widget::Container::getWidgetAtPos(_pos);
+	ewol::object::Shared<ewol::Widget> tmpWidget = ewol::widget::Container::getWidgetAtPos(_pos);
 	if (NULL != tmpWidget) {
 		return tmpWidget;
 	}
@@ -358,7 +358,7 @@ ewol::object::Shared<ewol::Widget> ewol::Widget::Scroll::getWidgetAtPos(const ve
 }
 
 bool ewol::Widget::Scroll::onSetConfig(const ewol::object::Config& _conf) {
-	if (true == ewol::Widget::Container::onSetConfig(_conf)) {
+	if (true == ewol::widget::Container::onSetConfig(_conf)) {
 		return true;
 	}
 	if (_conf.getConfig() == configLimit) {
@@ -369,7 +369,7 @@ bool ewol::Widget::Scroll::onSetConfig(const ewol::object::Config& _conf) {
 }
 
 bool ewol::Widget::Scroll::onGetConfig(const char* _config, std::string& _result) const {
-	if (true == ewol::Widget::Container::onGetConfig(_config, _result)) {
+	if (true == ewol::widget::Container::onGetConfig(_config, _result)) {
 		return true;
 	}
 	if (_config == configLimit) {

sources/ewol/widget/Scroll.h

@@ -21,7 +21,7 @@ namespace ewol {
 		/**
 		 * @ingroup ewolWidgetGroup
 		 */
-		class Scroll : public ewol::Widget::Container {
+		class Scroll : public ewol::widget::Container {
 			public:
 				enum highSpeedMode {
 					speedModeDisable,
@@ -35,7 +35,7 @@ namespace ewol {
 				// Cinfig parameter list:
 				static const char* const configLimit;
 			public:
-				static void init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager);
+				static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager);
 			private:
 				ewol::compositing::Shaper m_shaperH; //!< Compositing theme Horizontal.
 				ewol::compositing::Shaper m_shaperV; //!< Compositing theme Vertical.

sources/ewol/widget/Sizer.cpp

@@ -10,53 +10,53 @@
 #include <ewol/widget/Sizer.h>
 #include <ewol/widget/Manager.h>
 
-const char* const ewol::Widget::Sizer::configBorder = "border";
+const char* const ewol::widget::Sizer::configBorder = "border";
-const char* const ewol::Widget::Sizer::configMode = "mode";
+const char* const ewol::widget::Sizer::configMode = "mode";
 
 #undef __class__
 #define __class__ "Sizer"
 
 static ewol::object::Shared<ewol::Widget> create() {
-	return new ewol::Widget::Sizer();
+	return new ewol::widget::Sizer();
 }
 
-void ewol::Widget::Sizer::init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager) {
+void ewol::widget::Sizer::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
 	_widgetManager.addWidgetCreator(__class__,&create);
 }
 
 
-ewol::Widget::Sizer::Sizer(enum displayMode _mode):
+ewol::widget::Sizer::Sizer(enum displayMode _mode):
   m_mode(_mode),
   m_borderSize(),
   m_animation(animationNone),
   m_animationTime(0) {
-	addObjectType("ewol::Widget::Sizer");
+	addObjectType("ewol::widget::Sizer");
 	registerConfig(configBorder, "dimension", NULL, "The sizer border size");
 	registerConfig(configMode, "list", "{vert,hori}", "The display mode");
 	
 }
 
-ewol::Widget::Sizer::~Sizer() {
+ewol::widget::Sizer::~Sizer() {
 	// disable annimation to remore "remove" error
 	m_animation = animationNone;
 	m_animationTime = 0;
-	//EWOL_DEBUG("[" << getId() << "]={" << getObjectType() << "}  sizer : destroy (mode=" << (m_mode == ewol::Widget::Sizer::modeVert?"Vert":"Hori") << ")");
+	//EWOL_DEBUG("[" << getId() << "]={" << getObjectType() << "}  sizer : destroy (mode=" << (m_mode == ewol::widget::Sizer::modeVert?"Vert":"Hori") << ")");
 }
 
 
-void ewol::Widget::Sizer::setBorderSize(const ewol::Dimension& _newBorderSize) {
+void ewol::widget::Sizer::setBorderSize(const ewol::Dimension& _newBorderSize) {
 	m_borderSize = _newBorderSize;
 	markToRedraw();
 	requestUpdateSize();
 }
 
-void ewol::Widget::Sizer::setMode(enum displayMode _mode) {
+void ewol::widget::Sizer::setMode(enum displayMode _mode) {
 	m_mode = _mode;
 	markToRedraw();
 	requestUpdateSize();
 }
 
-void ewol::Widget::Sizer::calculateSize(const vec2& _availlable) {
+void ewol::widget::Sizer::calculateSize(const vec2& _availlable) {
 	ewol::Widget::calculateSize(_availlable);
 	vec2 tmpBorderSize = m_borderSize.getPixel();
 	EWOL_VERBOSE("[" << getId() << "] update size : " << _availlable << " nbElement : " << m_subWidget.size() << " borderSize=" << tmpBorderSize << " from border=" << m_borderSize);
@@ -68,7 +68,7 @@ void ewol::Widget::Sizer::calculateSize(const vec2& _availlable) {
 	for (size_t iii=0; iii<m_subWidget.size(); iii++) {
 		if (NULL != m_subWidget[iii]) {
 			vec2 tmpSize = m_subWidget[iii]->getCalculateMinSize();
-			if (m_mode == ewol::Widget::Sizer::modeVert) {
+			if (m_mode == ewol::widget::Sizer::modeVert) {
 				unexpandableSize += tmpSize.y();
 				if (false == m_subWidget[iii]->canExpand().y()) {
 					nbWidgetFixedSize++;
@@ -89,7 +89,7 @@ void ewol::Widget::Sizer::calculateSize(const vec2& _availlable) {
 	float sizeToAddAtEveryOne = 0;
 	// 2 cases : 1 or more can Expand, or all is done ...
 	if (0 != nbWidgetNotFixedSize) {
-		if (m_mode == ewol::Widget::Sizer::modeVert) {
+		if (m_mode == ewol::widget::Sizer::modeVert) {
 			sizeToAddAtEveryOne = (m_size.y() - unexpandableSize) / nbWidgetNotFixedSize;
 		} else {
 			sizeToAddAtEveryOne = (m_size.x() - unexpandableSize) / nbWidgetNotFixedSize;
@@ -106,7 +106,7 @@ void ewol::Widget::Sizer::calculateSize(const vec2& _availlable) {
 			EWOL_VERBOSE("[" << getId() << "] set iii=" << iii << " ORIGIN : " << tmpOrigin << " & offset=" << m_offset);
 			m_subWidget[iii]->setOrigin(vec2ClipInt32(tmpOrigin+m_offset));
 			// Now update his size  his size in X and the curent sizer size in Y:
-			if (m_mode == ewol::Widget::Sizer::modeVert) {
+			if (m_mode == ewol::widget::Sizer::modeVert) {
 				if (true == m_subWidget[iii]->canExpand().y()) {
 					m_subWidget[iii]->calculateSize(vec2ClipInt32(vec2(m_size.x(), tmpSize.y()+sizeToAddAtEveryOne)));
 					tmpOrigin.setY(tmpOrigin.y() + tmpSize.y()+sizeToAddAtEveryOne);
@@ -129,7 +129,7 @@ void ewol::Widget::Sizer::calculateSize(const vec2& _availlable) {
 	markToRedraw();
 }
 
-void ewol::Widget::Sizer::calculateMinMaxSize() {
+void ewol::widget::Sizer::calculateMinMaxSize() {
 	EWOL_VERBOSE("[" << getId() << "] update minimum size");
 	m_subExpend.setValue(false, false);
 	m_minSize = m_userMinSize.getPixel();
@@ -148,7 +148,7 @@ void ewol::Widget::Sizer::calculateMinMaxSize() {
 			vec2 tmpSize = m_subWidget[iii]->getCalculateMinSize();
 			EWOL_VERBOSE("[" << getId() << "] NewMinSize=" << tmpSize);
 			EWOL_VERBOSE("[" << getId() << "] {" << getObjectType() << "}     Get minSize[" << iii << "] "<< tmpSize);
-			if (m_mode == ewol::Widget::Sizer::modeVert) {
+			if (m_mode == ewol::widget::Sizer::modeVert) {
 				m_minSize.setY(m_minSize.y() + tmpSize.y());
 				if (tmpSize.x()>m_minSize.x()) {
 					m_minSize.setX(tmpSize.x());
@@ -164,42 +164,42 @@ void ewol::Widget::Sizer::calculateMinMaxSize() {
 	//EWOL_ERROR("[" << getId() << "] {" << getObjectType() << "} Result min size : " <<  m_minSize);
 }
 
-int32_t ewol::Widget::Sizer::subWidgetAdd(ewol::Widget* _newWidget) {
+int32_t ewol::widget::Sizer::subWidgetAdd(ewol::Widget* _newWidget) {
 	if (m_animation == animationNone) {
-		return ewol::Widget::ContainerN::subWidgetAdd(_newWidget);
+		return ewol::widget::ContainerN::subWidgetAdd(_newWidget);
 	}
 	// TODO : ...
-	return ewol::Widget::ContainerN::subWidgetAdd(_newWidget);
+	return ewol::widget::ContainerN::subWidgetAdd(_newWidget);
 }
 
-int32_t ewol::Widget::Sizer::subWidgetAddStart(ewol::Widget* _newWidget) {
+int32_t ewol::widget::Sizer::subWidgetAddStart(ewol::Widget* _newWidget) {
 	if (m_animation == animationNone) {
-		return ewol::Widget::ContainerN::subWidgetAddStart(_newWidget);
+		return ewol::widget::ContainerN::subWidgetAddStart(_newWidget);
 	}
 	// TODO : ...
-	return ewol::Widget::ContainerN::subWidgetAddStart(_newWidget);
+	return ewol::widget::ContainerN::subWidgetAddStart(_newWidget);
 }
 
-void ewol::Widget::Sizer::subWidgetRemove(ewol::Widget* _newWidget) {
+void ewol::widget::Sizer::subWidgetRemove(ewol::Widget* _newWidget) {
 	if (m_animation == animationNone) {
-		ewol::Widget::ContainerN::subWidgetRemove(_newWidget);
+		ewol::widget::ContainerN::subWidgetRemove(_newWidget);
 		return;
 	}
 	// TODO : ...
-	ewol::Widget::ContainerN::subWidgetRemove(_newWidget);
+	ewol::widget::ContainerN::subWidgetRemove(_newWidget);
 }
 
-void ewol::Widget::Sizer::subWidgetUnLink(ewol::Widget* _newWidget) {
+void ewol::widget::Sizer::subWidgetUnLink(ewol::Widget* _newWidget) {
 	if (m_animation == animationNone) {
-		ewol::Widget::ContainerN::subWidgetUnLink(_newWidget);
+		ewol::widget::ContainerN::subWidgetUnLink(_newWidget);
 		return;
 	}
 	// TODO : ...
-	ewol::Widget::ContainerN::subWidgetUnLink(_newWidget);
+	ewol::widget::ContainerN::subWidgetUnLink(_newWidget);
 }
 
-bool ewol::Widget::Sizer::onSetConfig(const ewol::object::Config& _conf) {
+bool ewol::widget::Sizer::onSetConfig(const ewol::object::Config& _conf) {
-	if (true == ewol::Widget::ContainerN::onSetConfig(_conf)) {
+	if (true == ewol::widget::ContainerN::onSetConfig(_conf)) {
 		return true;
 	}
 	if (_conf.getConfig() == configBorder) {
@@ -217,8 +217,8 @@ bool ewol::Widget::Sizer::onSetConfig(const ewol::object::Config& _conf) {
 	return false;
 }
 
-bool ewol::Widget::Sizer::onGetConfig(const char* _config, std::string& _result) const {
+bool ewol::widget::Sizer::onGetConfig(const char* _config, std::string& _result) const {
-	if (true == ewol::Widget::ContainerN::onGetConfig(_config, _result)) {
+	if (true == ewol::widget::ContainerN::onGetConfig(_config, _result)) {
 		return true;
 	}
 	if (_config == configBorder) {

sources/ewol/widget/Sizer.h

@@ -19,12 +19,12 @@ namespace ewol {
 		/**
 		 * @ingroup ewolWidgetGroup
 		 */
-		class Sizer : public ewol::Widget::ContainerN {
+		class Sizer : public ewol::widget::ContainerN {
 			public:
 				/**
 				 * @brief Main call of recording the widget on the List of "widget named creator"
 				 */
-				static void init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager);
+				static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager);
 				// Config list of properties
 				static const char* const configBorder;
 				static const char* const configMode;
@@ -40,7 +40,7 @@ namespace ewol {
 				 * @brief Constructor
 				 * @param[in] _mode The mode to display the elements
 				 */
-				Sizer(enum displayMode _mode=ewol::Widget::Sizer::modeHori);
+				Sizer(enum displayMode _mode=ewol::widget::Sizer::modeHori);
 				/**
 				 * @brief Desstructor
 				 */

sources/ewol/widget/Slider.cpp

@@ -10,23 +10,23 @@
 
 #include <ewol/widget/Manager.h>
 
-const char * const ewol::Widget::Slider::eventChange = "change";
+const char * const ewol::widget::Slider::eventChange = "change";
 
 #undef __class__
 #define __class__ "Slider"
 
 static ewol::Widget* create() {
-	return new ewol::Widget::Slider();
+	return new ewol::widget::Slider();
 }
 
-void ewol::Widget::Slider::init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager) {
+void ewol::widget::Slider::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
-	_widgetManager.addWidgetCreator(__class__,&create);
+	_widgetManager->addWidgetCreator(__class__,&create);
 }
 
 const int32_t dotRadius = 6;
 
-ewol::Widget::Slider::Slider() {
+ewol::widget::Slider::Slider() {
-	addObjectType("ewol::Widget::Slider");
+	addObjectType("ewol::widget::Slider");
 	addEventId(eventChange);
 	
 	m_value = 0;
@@ -42,43 +42,43 @@ ewol::Widget::Slider::Slider() {
 	setMouseLimit(1);
 }
 
-ewol::Widget::Slider::~Slider() {
+ewol::widget::Slider::~Slider() {
 	
 }
 
-void ewol::Widget::Slider::calculateMinMaxSize() {
+void ewol::widget::Slider::calculateMinMaxSize() {
 	vec2 minTmp = m_userMinSize.getPixel();
 	m_minSize.setValue(etk_max(minTmp.x(), 40),
 	                   etk_max(minTmp.y(), dotRadius*2) );
 	markToRedraw();
 }
 
-void ewol::Widget::Slider::setValue(int32_t _val) {
+void ewol::widget::Slider::setValue(int32_t _val) {
 	m_value = etk_max(etk_min(_val, m_max), m_min);
 	markToRedraw();
 }
 
-int32_t ewol::Widget::Slider::getValue() {
+int32_t ewol::widget::Slider::getValue() {
 	return m_value;
 }
 
-void ewol::Widget::Slider::setMin(int32_t _val) {
+void ewol::widget::Slider::setMin(int32_t _val) {
 	m_min = _val;
 	m_value = etk_max(etk_min(m_value, m_max), m_min);
 	markToRedraw();
 }
 
-void ewol::Widget::Slider::setMax(int32_t _val) {
+void ewol::widget::Slider::setMax(int32_t _val) {
 	m_max = _val;
 	m_value = etk_max(etk_min(m_value, m_max), m_min);
 	markToRedraw();
 }
 
-void ewol::Widget::Slider::onDraw() {
+void ewol::widget::Slider::onDraw() {
 	m_draw.draw();
 }
 
-void ewol::Widget::Slider::onRegenerateDisplay() {
+void ewol::widget::Slider::onRegenerateDisplay() {
 	if (needRedraw() == false) {
 		return;
 	}
@@ -100,7 +100,7 @@ void ewol::Widget::Slider::onRegenerateDisplay() {
 	m_draw.circle(dotRadius/1.6);
 }
 
-bool ewol::Widget::Slider::onEventInput(const ewol::event::Input& _event) {
+bool ewol::widget::Slider::onEventInput(const ewol::event::Input& _event) {
 	vec2 relativePos = relativePosition(_event.getPos());
 	//EWOL_DEBUG("Event on Slider ...");
 	if (1 == _event.getId()) {

sources/ewol/widget/Slider.h

@@ -25,7 +25,7 @@ namespace ewol {
 				// Event list of properties
 				static const char * const eventChange;
 			public:
-				static void init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager);
+				static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager);
 			public:
 				Slider();
 				virtual ~Slider();

sources/ewol/widget/Spacer.cpp

@@ -20,8 +20,8 @@ static ewol::Widget* create() {
 	return new ewol::Widget::Spacer();
 }
 
-void ewol::Widget::Spacer::init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager) {
+void ewol::Widget::Spacer::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
-	_widgetManager.addWidgetCreator(__class__,&create);
+	_widgetManager->addWidgetCreator(__class__,&create);
 }
 
 ewol::Widget::Spacer::Spacer() {

sources/ewol/widget/Spacer.h

@@ -23,7 +23,7 @@ namespace ewol {
 		 */
 		class Spacer : public ewol::Widget {
 			public:
-				static void init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager);
+				static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager);
 				// Config list of properties
 				static const char* const configColor;
 			private:

sources/ewol/widget/WSlider.cpp

@@ -34,8 +34,8 @@ static ewol::Widget* create() {
 	return new ewol::Widget::WSlider();
 }
 
-void ewol::Widget::WSlider::init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager) {
+void ewol::Widget::WSlider::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
-	_widgetManager.addWidgetCreator(__class__,&create);
+	_widgetManager->addWidgetCreator(__class__,&create);
 }
 
 ewol::Widget::WSlider::WSlider() :
@@ -60,7 +60,7 @@ ewol::Widget::WSlider::~WSlider() {
 
 void ewol::Widget::WSlider::calculateSize(const vec2& _availlable) {
 	//EWOL_DEBUG("Update size");
-	ewol::Widget::ContainerN::calculateSize(_availlable);
+	ewol::widget::ContainerN::calculateSize(_availlable);
 	
 	if (m_windowsDestination == m_windowsSources) {
 		int32_t iii = m_windowsDestination;
@@ -272,7 +272,7 @@ void ewol::Widget::WSlider::onRegenerateDisplay() {
 }
 
 bool ewol::Widget::WSlider::onSetConfig(const ewol::object::Config& _conf) {
-	if (true == ewol::Widget::ContainerN::onSetConfig(_conf)) {
+	if (true == ewol::widget::ContainerN::onSetConfig(_conf)) {
 		return true;
 	}
 	if (_conf.getConfig() == configMode) {
@@ -293,7 +293,7 @@ bool ewol::Widget::WSlider::onSetConfig(const ewol::object::Config& _conf) {
 }
 
 bool ewol::Widget::WSlider::onGetConfig(const char* _config, std::string& _result) const {
-	if (true == ewol::Widget::ContainerN::onGetConfig(_config, _result)) {
+	if (true == ewol::widget::ContainerN::onGetConfig(_config, _result)) {
 		return true;
 	}
 	if (_config == configMode) {

sources/ewol/widget/WSlider.h

@@ -19,9 +19,9 @@ namespace ewol {
 		/**
 		 * @ingroup ewolWidgetGroup
 		 */
-		class WSlider :public ewol::Widget::ContainerN {
+		class WSlider :public ewol::widget::ContainerN {
 			public:
-				static void init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager);
+				static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager);
 				// Event list of properties
 				static const char* const eventStartSlide;
 				static const char* const eventStopSlide;

sources/ewol/widget/Widget.cpp

@@ -162,7 +162,7 @@ ewol::Widget::~Widget() {
 void ewol::Widget::setUpperWidget(ewol::object::Shared<ewol::Widget> _upper) {
 	if (_upper == nullptr) {
 		//just remove father :
-		m_up = NULL;
+		m_up.reset();
 		return;
 	}
 	if (m_up != nullptr) {
@@ -868,11 +868,11 @@ void ewol::Widget::requestUpdateSize() {
 	getContext().requestUpdateSize();
 }
 
-ewol::object::Shared<ewol::Widget::Manager> ewol::Widget::getWidgetManager() {
+ewol::widget::Manager& ewol::Widget::getWidgetManager() {
 	return getContext().getWidgetManager();
 }
 
-ewol::object::Shared<ewol::Widget::Windows> ewol::Widget::getWindows() {
+ewol::object::Shared<ewol::widget::Windows> ewol::Widget::getWindows() {
 	return getContext().getWindows();
 }
 

sources/ewol/widget/Widget.h

@@ -13,6 +13,7 @@
 #include <etk/types.h>
 #include <etk/math/Vector2D.h>
 
+#include <ewol/debug.h>
 #include <ewol/object/Object.h>
 #include <ewol/Dimension.h>
 
@@ -23,7 +24,6 @@ namespace ewol {
 		class Windows;
 	};
 };
-#include <ewol/debug.h>
 #include <ewol/context/clipBoard.h>
 #include <ewol/key/key.h>
 #include <ewol/context/cursor.h>
@@ -116,7 +116,7 @@ namespace ewol {
 	 * :** Receive Event (keyboard / mouse / ...)
 	 * 
 	 */
-	class Widget : public ewol::object::Shared<ewol::Object> {
+	class Widget : public ewol::Object {
 		public:
 			// Config list of properties
 			static const char* const configFill;
@@ -712,11 +712,11 @@ namespace ewol {
 			/**
 			 * @brief get the current Widget Manager
 			 */
-			ewol::object::Shared<ewol::Widget::Manager> getWidgetManager();
+			ewol::widget::Manager& getWidgetManager();
 			/**
 			 * @brief get the curent Windows
 			 */
-			ewol::object::Shared<ewol::Widget::Windows> getWindows();
+			ewol::object::Shared<ewol::widget::Windows> getWindows();
 		/*
 		 * Annimation section :
 		 */

sources/ewol/widget/Windows.cpp

@@ -23,10 +23,10 @@
 extern const char * const ewolEventWindowsHideKeyboard   = "ewol Windows hideKeyboard";
 
 
-ewol::Widget::Windows::Windows() :
+ewol::widget::Windows::Windows() :
   m_colorProperty(NULL),
   m_colorBg(-1) {
-	addObjectType("ewol::Widget::Windows");
+	addObjectType("ewol::widget::Windows");
 	setCanHaveFocus(true);
 	m_subWidget = NULL;
 	setDecorationDisable();
@@ -37,7 +37,7 @@ ewol::Widget::Windows::Windows() :
 	//KeyboardShow(KEYBOARD_MODE_CODE);
 }
 
-ewol::Widget::Windows::~Windows() {
+ewol::widget::Windows::~Windows() {
 	if (NULL != m_subWidget) {
 		delete(m_subWidget);
 		m_subWidget=NULL;
@@ -51,7 +51,7 @@ ewol::Widget::Windows::~Windows() {
 	m_popUpWidgetList.clear();
 }
 
-void ewol::Widget::Windows::calculateSize(const vec2& _availlable) {
+void ewol::widget::Windows::calculateSize(const vec2& _availlable) {
 	//EWOL_DEBUG(" _availlable : " << _availlable);
 	m_size = _availlable;
 	if (NULL != m_subWidget) {
@@ -68,7 +68,7 @@ void ewol::Widget::Windows::calculateSize(const vec2& _availlable) {
 	}
 }
 
-ewol::object::Shared<ewol::Widget> * ewol::Widget::Windows::getWidgetAtPos(const vec2& _pos) {
+ewol::object::Shared<ewol::Widget> * ewol::widget::Windows::getWidgetAtPos(const vec2& _pos) {
 	// calculate relative position
 	vec2 relativePos = relativePosition(_pos);
 	// event go directly on the pop-up
@@ -86,7 +86,7 @@ ewol::object::Shared<ewol::Widget> * ewol::Widget::Windows::getWidgetAtPos(const
 	return this;
 }
 
-void ewol::Widget::Windows::sysDraw() {
+void ewol::widget::Windows::sysDraw() {
 	//EWOL_DEBUG("Drow on (" << m_size.x << "," << m_size.y << ")");
 	// set the size of the open GL system
 	glViewport(0,0,m_size.x(),m_size.y());
@@ -118,7 +118,7 @@ void ewol::Widget::Windows::sysDraw() {
 	return;
 }
 
-void ewol::Widget::Windows::onRegenerateDisplay() {
+void ewol::widget::Windows::onRegenerateDisplay() {
 	if (NULL != m_subWidget) {
 		m_subWidget->onRegenerateDisplay();
 	}
@@ -131,7 +131,7 @@ void ewol::Widget::Windows::onRegenerateDisplay() {
 
 //#define TEST_PERFO_WINDOWS
 
-void ewol::Widget::Windows::systemDraw(const ewol::DrawProperty& _displayProp) {
+void ewol::widget::Windows::systemDraw(const ewol::DrawProperty& _displayProp) {
 	ewol::Widget::systemDraw(_displayProp);
 	#ifdef TEST_PERFO_WINDOWS
 	int64_t ___startTime0 = ewol::getTime();
@@ -175,7 +175,7 @@ void ewol::Widget::Windows::systemDraw(const ewol::DrawProperty& _displayProp) {
 	#endif
 }
 
-void ewol::Widget::Windows::setSubWidget(ewol::Widget* _widget) {
+void ewol::widget::Windows::setSubWidget(ewol::Widget* _widget) {
 	if (m_subWidget != NULL) {
 		EWOL_INFO("Remove current main windows Widget...");
 		delete(m_subWidget);
@@ -186,7 +186,7 @@ void ewol::Widget::Windows::setSubWidget(ewol::Widget* _widget) {
 	calculateSize(m_size);
 }
 
-void ewol::Widget::Windows::popUpWidgetPush(ewol::Widget* _widget) {
+void ewol::widget::Windows::popUpWidgetPush(ewol::Widget* _widget) {
 	if (_widget == NULL) {
 		// nothing to do an error appear :
 		EWOL_ERROR("can not set widget pop-up (null pointer)");
@@ -201,7 +201,7 @@ void ewol::Widget::Windows::popUpWidgetPush(ewol::Widget* _widget) {
 	getContext().resetIOEvent();
 }
 
-void ewol::Widget::Windows::popUpWidgetPop() {
+void ewol::widget::Windows::popUpWidgetPop() {
 	if (m_popUpWidgetList.size() == 0) {
 		return;
 	}
@@ -212,7 +212,7 @@ void ewol::Widget::Windows::popUpWidgetPop() {
 	widget->removeObject();
 }
 
-void ewol::Widget::Windows::onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject) {
+void ewol::widget::Windows::onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject) {
 	// First step call parrent : 
 	ewol::Widget::onObjectRemove(_removeObject);
 	// second step find if in all the elements ...
@@ -230,21 +230,21 @@ void ewol::Widget::Windows::onObjectRemove(ewol::object::Shared<ewol::Object> _r
 	}
 }
 
-void ewol::Widget::Windows::setBackgroundColor(const etk::Color<float>& _color) {
+void ewol::widget::Windows::setBackgroundColor(const etk::Color<float>& _color) {
 	if (m_backgroundColor != _color) {
 		m_backgroundColor = _color;
 		markToRedraw();
 	}
 }
 
-void ewol::Widget::Windows::setTitle(const std::string& _title) {
+void ewol::widget::Windows::setTitle(const std::string& _title) {
 	// TODO : remove this ...
 	std::string title = _title;
 	getContext().setTitle(title);
 }
 
 
-void ewol::Widget::Windows::createPopUpMessage(enum popUpMessageType _type, const std::string& _message)
+void ewol::widget::Windows::createPopUpMessage(enum popUpMessageType _type, const std::string& _message)
 {
 	ewol::Widget::StdPopUp* tmpPopUp = new widget::StdPopUp();
 	if (tmpPopUp == NULL) {

sources/ewol/widget/meta/ColorChooser.cpp

@@ -23,16 +23,16 @@ extern "C" {
 #define __class__	"ColorChooser"
 
 
-const char * const ewol::Widget::ColorChooser::eventChange = "change";
+const char * const ewol::widget::ColorChooser::eventChange = "change";
 
 
 static const char * const eventColorBarHasChange          = "event-color-bar-has-change";
 static const char * const eventColorSpecificHasChange     = "event-color-specific-has-change";
 
 
-ewol::Widget::ColorChooser::ColorChooser() :
+ewol::widget::ColorChooser::ColorChooser() :
-  ewol::Widget::Sizer(ewol::Widget::Sizer::modeVert) {
+  ewol::widget::Sizer(ewol::Widget::Sizer::modeVert) {
-	addObjectType("ewol::Widget::ColorChooser");
+	addObjectType("ewol::widget::ColorChooser");
 	addEventId(eventChange);
 	m_widgetColorBar = NULL;
 	m_widgetRed = NULL;
@@ -40,7 +40,7 @@ ewol::Widget::ColorChooser::ColorChooser() :
 	m_widgetBlue = NULL;
 	m_widgetAlpha = NULL;
 	lockExpand(bvec2(true,true));
-		m_widgetColorBar = new ewol::Widget::ColorBar();
+		m_widgetColorBar = new ewol::widget::ColorBar();
 			m_widgetColorBar->registerOnEvent(this, "change", eventColorBarHasChange);
 			m_widgetColorBar->setFill(bvec2(true,true));
 			/*
@@ -52,7 +52,7 @@ ewol::Widget::ColorChooser::ColorChooser() :
 		etk::Color<> sliderColor;
 		sliderColor = etk::color::black;
 		
-		m_widgetRed = new ewol::Widget::Slider();
+		m_widgetRed = new ewol::widget::Slider();
 			m_widgetRed->registerOnEvent(this, "change", eventColorSpecificHasChange);
 			m_widgetRed->setExpand(bvec2(true,false));
 			m_widgetRed->setFill(bvec2(true,false));
@@ -61,7 +61,7 @@ ewol::Widget::ColorChooser::ColorChooser() :
 			sliderColor = 0xFF0000FF;
 			m_widgetRed->setColor(sliderColor);
 			subWidgetAdd(m_widgetRed.get());
-		m_widgetGreen = new ewol::Widget::Slider();
+		m_widgetGreen = new ewol::widget::Slider();
 			m_widgetGreen->registerOnEvent(this, "change", eventColorSpecificHasChange);
 			m_widgetGreen->setExpand(bvec2(true,false));
 			m_widgetGreen->setFill(bvec2(true,false));
@@ -70,7 +70,7 @@ ewol::Widget::ColorChooser::ColorChooser() :
 			m_widgetGreen->setColor(sliderColor);
 			m_widgetGreen->setMax(255);
 			subWidgetAdd(m_widgetGreen.get());
-		m_widgetBlue = new ewol::Widget::Slider();
+		m_widgetBlue = new ewol::widget::Slider();
 			m_widgetBlue->registerOnEvent(this, "change", eventColorSpecificHasChange);
 			m_widgetBlue->setExpand(bvec2(true,false));
 			m_widgetBlue->setFill(bvec2(true,false));
@@ -79,7 +79,7 @@ ewol::Widget::ColorChooser::ColorChooser() :
 			m_widgetBlue->setColor(sliderColor);
 			m_widgetBlue->setMax(255);
 			subWidgetAdd(m_widgetBlue.get());
-		m_widgetAlpha = new ewol::Widget::Slider();
+		m_widgetAlpha = new ewol::widget::Slider();
 			m_widgetAlpha->registerOnEvent(this, "change", eventColorSpecificHasChange);
 			m_widgetAlpha->setExpand(bvec2(true,false));
 			m_widgetAlpha->setFill(bvec2(true,false));
@@ -91,12 +91,12 @@ ewol::Widget::ColorChooser::ColorChooser() :
 }
 
 
-ewol::Widget::ColorChooser::~ColorChooser() {
+ewol::widget::ColorChooser::~ColorChooser() {
 	
 }
 
 
-void ewol::Widget::ColorChooser::setColor(etk::Color<> _newColor) {
+void ewol::widget::ColorChooser::setColor(etk::Color<> _newColor) {
 	m_currentColor = _newColor;
 	if (NULL != m_widgetRed) {
 		m_widgetRed->setValue(m_currentColor.r());
@@ -116,12 +116,12 @@ void ewol::Widget::ColorChooser::setColor(etk::Color<> _newColor) {
 }
 
 
-etk::Color<> ewol::Widget::ColorChooser::getColor() {
+etk::Color<> ewol::widget::ColorChooser::getColor() {
 	return m_currentColor;
 }
 
 
-void ewol::Widget::ColorChooser::onReceiveMessage(const ewol::object::Message& _msg) {
+void ewol::widget::ColorChooser::onReceiveMessage(const ewol::object::Message& _msg) {
 	if (NULL == _msg.getCaller()) {
 		return;
 	}
@@ -169,9 +169,9 @@ void ewol::Widget::ColorChooser::onReceiveMessage(const ewol::object::Message& _
 };
 
 
-void ewol::Widget::ColorChooser::onObjectRemove(ewol::object::Shared<ewol::Object> * _removeObject) {
+void ewol::widget::ColorChooser::onObjectRemove(ewol::object::Shared<ewol::Object> * _removeObject) {
 	// First step call parrent : 
-	ewol::Widget::Sizer::onObjectRemove(_removeObject);
+	ewol::widget::Sizer::onObjectRemove(_removeObject);
 	// second step find if in all the elements ...
 	if(_removeObject == m_widgetRed) {
 		m_widgetRed.reset();

sources/ewol/widget/meta/ColorChooser.h

@@ -24,7 +24,7 @@ namespace ewol {
 		/**
 		 * @ingroup ewolWidgetGroup
 		 */
-		class ColorChooser : public ewol::Widget::Sizer {
+		class ColorChooser : public ewol::widget::Sizer {
 			public:
 				// Event list of properties
 				static const char * const eventChange;
@@ -38,11 +38,11 @@ namespace ewol {
 				void setColor(etk::Color<> _newColor);
 				etk::Color<> getColor();
 			private:
-				ewol::object::Shared<ewol::Widget::ColorBar> m_widgetColorBar;
+				ewol::object::Shared<ewol::widget::ColorBar> m_widgetColorBar;
-				ewol::object::Shared<ewol::Widget::Slider> m_widgetRed;
+				ewol::object::Shared<ewol::widget::Slider> m_widgetRed;
-				ewol::object::Shared<ewol::Widget::Slider> m_widgetGreen;
+				ewol::object::Shared<ewol::widget::Slider> m_widgetGreen;
-				ewol::object::Shared<ewol::Widget::Slider> m_widgetBlue;
+				ewol::object::Shared<ewol::widget::Slider> m_widgetBlue;
-				ewol::object::Shared<ewol::Widget::Slider> m_widgetAlpha;
+				ewol::object::Shared<ewol::widget::Slider> m_widgetAlpha;
 				etk::Color<> m_currentColor;
 		};
 	};

sources/ewol/widget/meta/FileChooser.h

@@ -45,7 +45,7 @@ namespace ewol {
 		 *  // simply set a folder (by default this is the home folder)
 		 *  //tmpWidget->setFolder("/home/me");
 		 *  // add the widget as windows pop-up ...
-		 *  ewol::Widget::Windows* tmpWindows = getWindows();
+		 *  ewol::widget::Windows* tmpWindows = getWindows();
 		 *  if (tmpWindows == NULL) {
 		 *  	APPL_ERROR("Can not get the current windows !!! ");
 		 *  	return -1;
@@ -71,7 +71,7 @@ namespace ewol {
 		 *  [/code]
 		 *  This is the best example of a Meta-widget.
 		 */
-		class FileChooser : public ewol::Widget::Composer {
+		class FileChooser : public ewol::widget::Composer {
 			public:
 				// Event list of properties
 				static const char* const eventCancel;

sources/ewol/widget/meta/Parameter.cpp

@@ -34,8 +34,8 @@ ewol::Widget::Parameter::Parameter() :
 	addObjectType("ewol::Widget::Parameter");
 	addEventId(eventClose);
 	
-	ewol::Widget::Sizer * mySizerVert = NULL;
+	ewol::widget::Sizer * mySizerVert = NULL;
-	ewol::Widget::Sizer * mySizerHori = NULL;
+	ewol::widget::Sizer * mySizerHori = NULL;
 	ewol::Widget::Spacer * mySpacer = NULL;
 	#ifdef __TARGET_OS__Android
 		setMinSize(ewol::Dimension(vec2(90, 90), ewol::Dimension::Pourcent));
@@ -43,7 +43,7 @@ ewol::Widget::Parameter::Parameter() :
 		setMinSize(ewol::Dimension(vec2(80, 80), ewol::Dimension::Pourcent));
 	#endif
 	
-	mySizerVert = new ewol::Widget::Sizer(widget::Sizer::modeVert);
+	mySizerVert = new ewol::widget::Sizer(widget::Sizer::modeVert);
 	if (NULL == mySizerVert) {
 		EWOL_ERROR("Can not allocate widget  == > display might be in error");
 	} else {
@@ -53,7 +53,7 @@ ewol::Widget::Parameter::Parameter() :
 		// set it in the pop-up-system :
 		setSubWidget(mySizerVert);
 		
-		mySizerHori = new ewol::Widget::Sizer(widget::Sizer::modeHori);
+		mySizerHori = new ewol::widget::Sizer(widget::Sizer::modeHori);
 		if (NULL == mySizerHori) {
 			EWOL_ERROR("Can not allocate widget  == > display might be in error");
 		} else {
@@ -67,12 +67,12 @@ ewol::Widget::Parameter::Parameter() :
 				mySizerHori->subWidgetAdd(mySpacer);
 			}
 			
-			ewol::Widget::Button* tmpButton = new widget::Button();
+			ewol::widget::Button* tmpButton = new widget::Button();
 			if (NULL == tmpButton) {
 				EWOL_ERROR("Can not allocate widget  == > display might be in error");
 			} else {
 				tmpButton->setSubWidget(
-				    new ewol::Widget::Composer(widget::Composer::String,
+				    new ewol::widget::Composer(widget::Composer::String,
 				        "<composer>\n"
 				        "	<sizer mode=\"hori\">\n"
 				        "		<image src=\"THEME:GUI:Save.svg\" expand=\"true\" size=\"8,8mm\"/>\n"
@@ -92,12 +92,12 @@ ewol::Widget::Parameter::Parameter() :
 				mySizerHori->subWidgetAdd(mySpacer);
 			}
 			
-			tmpButton = new ewol::Widget::Button();
+			tmpButton = new ewol::widget::Button();
 			if (NULL == tmpButton) {
 				EWOL_ERROR("Can not allocate widget  == > display might be in error");
 			} else {
 				tmpButton->setSubWidget(
-				    new ewol::Widget::Composer(widget::Composer::String,
+				    new ewol::widget::Composer(widget::Composer::String,
 				        "<composer>\n"
 				        "	<sizer mode=\"hori\">\n"
 				        "		<image src=\"THEME:GUI:Remove.svg\" expand=\"true\" size=\"8,8mm\"/>\n"
@@ -109,7 +109,7 @@ ewol::Widget::Parameter::Parameter() :
 			}
 		}
 		
-		mySizerHori = new ewol::Widget::Sizer(widget::Sizer::modeHori);
+		mySizerHori = new ewol::widget::Sizer(widget::Sizer::modeHori);
 		if (NULL == mySizerHori) {
 			EWOL_ERROR("Can not allocate widget  == > display might be in error");
 		} else {
@@ -135,7 +135,7 @@ ewol::Widget::Parameter::Parameter() :
 				mySizerHori->subWidgetAdd(mySpacer);
 			}
 			
-			ewol::Widget::Sizer * mySizerVert2 = new widget::Sizer(widget::Sizer::modeVert);
+			ewol::widget::Sizer * mySizerVert2 = new widget::Sizer(widget::Sizer::modeVert);
 			if (NULL == mySizerVert2) {
 				EWOL_ERROR("Can not allocate widget  == > display might be in error");
 			} else {
@@ -173,7 +173,7 @@ ewol::Widget::Parameter::Parameter() :
 			mySizerVert->subWidgetAdd(mySpacer);
 		}
 		
-		m_widgetTitle = new ewol::Widget::Label("File chooser ...");
+		m_widgetTitle = new ewol::widget::Label("File chooser ...");
 		if (NULL == m_widgetTitle) {
 			EWOL_ERROR("Can not allocate widget  == > display might be in error");
 		} else {
@@ -240,7 +240,7 @@ void ewol::Widget::Parameter::menuAdd(std::string _label, std::string _image, ew
 				m_wSlider->subWidgetAdd(_associateWidget);
 			} else { 
 				EWOL_DEBUG("Associate an empty widget on it ...");
-				ewol::Widget::Label * myLabel = new widget::Label((std::string("No widget for : ") + _label));
+				ewol::widget::Label * myLabel = new widget::Label((std::string("No widget for : ") + _label));
 				if (NULL == myLabel) {
 					EWOL_ERROR("Can not allocate widget  == > display might be in error");
 				} else {

sources/ewol/widget/meta/Parameter.h

@@ -44,7 +44,7 @@ namespace ewol {
 				void menuSeparator();
 			private:
 				int32_t                 m_currentIdList;
-				ewol::Widget::Label*          m_widgetTitle;
+				ewol::widget::Label*          m_widgetTitle;
 				ewol::Widget::ParameterList*  m_paramList;
 				ewol::Widget::WSlider*        m_wSlider;
 		};

sources/ewol/widget/meta/StdPopUp.cpp

@@ -25,14 +25,14 @@ ewol::Widget::StdPopUp::StdPopUp() :
 	addObjectType("ewol::Widget::StdPopUp");
 	setMinSize(ewol::Dimension(vec2(20,10),ewol::Dimension::Pourcent));
 	
-	ewol::Widget::Sizer* mySizerVert = NULL;
+	ewol::widget::Sizer* mySizerVert = NULL;
 	ewol::Widget::Spacer* mySpacer = NULL;
 	
-	mySizerVert = new ewol::Widget::Sizer(widget::Sizer::modeVert);
+	mySizerVert = new ewol::widget::Sizer(widget::Sizer::modeVert);
 		// set it in the pop-up-system : 
 		setSubWidget(mySizerVert);
 		
-		m_subBar = new ewol::Widget::Sizer(widget::Sizer::modeHori);
+		m_subBar = new ewol::widget::Sizer(widget::Sizer::modeHori);
 			m_subBar->lockExpand(bvec2(true,true));
 			m_subBar->setExpand(bvec2(true,false));
 			mySizerVert->subWidgetAdd(m_subBar->get());
@@ -51,7 +51,7 @@ ewol::Widget::StdPopUp::StdPopUp() :
 			mySpacer->setMinSize(ewol::Dimension(vec2(0,5),ewol::Dimension::Pixel));
 			mySizerVert->subWidgetAdd(mySpacer);
 		
-		m_comment = new ewol::Widget::Label("No Label");
+		m_comment = new ewol::widget::Label("No Label");
 			m_comment->setExpand(bvec2(true,true));
 			mySizerVert->subWidgetAdd(m_comment->get());
 		
@@ -66,7 +66,7 @@ ewol::Widget::StdPopUp::StdPopUp() :
 			mySpacer->setMinSize(ewol::Dimension(vec2(0,3),ewol::Dimension::Pixel));
 			mySizerVert->subWidgetAdd(mySpacer);
 		
-		m_title = new ewol::Widget::Label("<bold>Message</bold>");
+		m_title = new ewol::widget::Label("<bold>Message</bold>");
 			m_title->setExpand(bvec2(true,false));
 			m_title->setFill(bvec2(true,true));
 			mySizerVert->subWidgetAdd(m_title->get());
@@ -92,19 +92,19 @@ void ewol::Widget::StdPopUp::setComment(const std::string& _text) {
 	markToRedraw();
 }
 
-ewol::object::Shared<ewol::Widget::Button> ewol::Widget::StdPopUp::addButton(const std::string& _text, bool _autoExit) {
+ewol::object::Shared<ewol::widget::Button> ewol::Widget::StdPopUp::addButton(const std::string& _text, bool _autoExit) {
 	if (m_subBar == NULL) {
 		EWOL_ERROR("button-bar does not existed ...");
 		return NULL;
 	}
-	ewol::Widget::Button* myButton = new widget::Button();
+	ewol::widget::Button* myButton = new widget::Button();
 	if (myButton == NULL) {
 		EWOL_ERROR("Can not allocate new button ...");
 		return NULL;
 	}
-	myButton->setSubWidget(new ewol::Widget::Label(_text));
+	myButton->setSubWidget(new ewol::widget::Label(_text));
 	if(_autoExit == true) {
-		myButton->registerOnEvent(this, ewol::Widget::Button::eventPressed, eventButtonExit);
+		myButton->registerOnEvent(this, ewol::widget::Button::eventPressed, eventButtonExit);
 	}
 	m_subBar->subWidgetAdd(myButton);
 	markToRedraw();

sources/ewol/widget/meta/StdPopUp.h

@@ -50,7 +50,7 @@ namespace ewol {
 				 */
 				~StdPopUp();
 			protected:
-				ewol::object::Shared<ewol::Widget::Label> m_title; //!< Title Label widget
+				ewol::object::Shared<ewol::widget::Label> m_title; //!< Title Label widget
 			public:
 				/**
 				 * @brief Set the title string.
@@ -58,7 +58,7 @@ namespace ewol {
 				 */
 				void setTitle(const std::string& _text);
 			protected:
-				ewol::object::Shared<ewol::Widget::Label> m_comment; //!< Comment label widget
+				ewol::object::Shared<ewol::widget::Label> m_comment; //!< Comment label widget
 			public:
 				/**
 				 * @brief Set the commentary string.
@@ -66,13 +66,13 @@ namespace ewol {
 				 */
 				void setComment(const std::string& _text);
 			protected:
-				ewol::object::Shared<ewol::Widget::Sizer> m_subBar; //!< subwidget bar containing all the button.
+				ewol::object::Shared<ewol::widget::Sizer> m_subBar; //!< subwidget bar containing all the button.
 			public:
 				/**
 				 * @brief Add a buttom button.
 				 * @param[in] _text Decorated text to diplay in button.
 				 */
-				ewol::object::Shared<ewol::Widget::Button> addButton(const std::string& _text, bool _autoExit=false);
+				ewol::object::Shared<ewol::widget::Button> addButton(const std::string& _text, bool _autoExit=false);
 			public: // Derived function
 				virtual void onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject);
 				virtual void onReceiveMessage(const ewol::object::Message& _msg);