diff --git a/external/ege b/external/ege
index d22d7ade..87b68c40 160000
--- a/external/ege
+++ b/external/ege
@@ -1 +1 @@
-Subproject commit d22d7ade7310428a294cc8b057d9ab2563afc9b6
+Subproject commit 87b68c408e3bceff1923e84d2e08fcee9d868561
diff --git a/sources/ewol/object/Object.cpp b/sources/ewol/object/Object.cpp
index 60c77947..3c3033f9 100644
--- a/sources/ewol/object/Object.cpp
+++ b/sources/ewol/object/Object.cpp
@@ -176,95 +176,6 @@ void ewol::Object::registerMultiCast(const char* const _messageId) {
 	}
 	getMultiCast().add(shared_from_this(), _messageId);
 }
-/*
-void ewol::Object::registerOnEvent(const std::shared_ptr<ewol::Object>& _destinationObject,
-                                    const char * _eventId,
-                                    const char * _eventIdgenerated,
-                                    const std::string& _overloadData) {
-	if (nullptr == _destinationObject) {
-		EWOL_ERROR("Input ERROR nullptr pointer Object ...");
-		return;
-	}
-	if (nullptr == _eventId) {
-		EWOL_ERROR("Input ERROR nullptr pointer Event Id...");
-		return;
-	}
-	if (    _eventId[0] == '*'
-	     && _eventId[1] == '\0') {
-		EWOL_VERBOSE("Register on all event ...");
-		for(auto &it : m_availlableEventId) {
-			ewol::object::EventExtGen tmpEvent;
-			tmpEvent.localEventId = it;
-			tmpEvent.destObject = _destinationObject;
-			tmpEvent.overloadData = _overloadData;
-			if (nullptr != _eventIdgenerated) {
-				tmpEvent.destEventId = _eventIdgenerated;
-			} else {
-				tmpEvent.destEventId = it;
-			}
-			m_externEvent.push_back(tmpEvent);
-		}
-		return;
-	}
-	// check if event existed :
-	bool findIt = false;
-	for(auto &it : m_availlableEventId) {
-		if (it == _eventId) {
-			findIt = true;
-			break;
-		}
-	}
-	if (false == findIt) {
-		EWOL_VERBOSE("Try to register with a NON direct string name");
-		for(auto &it : m_availlableEventId) {
-			if (0 == strncmp(it, _eventId, 1024)) {
-				findIt = true;
-				_eventId = it;
-				EWOL_VERBOSE("find event ID : '" << _eventId << "' ==> '" << _eventIdgenerated << "'");
-				break;
-			}
-		}
-	}
-	if (false == findIt) {
-		EWOL_ERROR("Can not register event on this Type=" << getObjectType() << " event=\"" << _eventId << "\"  == > unknow event");
-		return;
-	}
-	ewol::object::EventExtGen tmpEvent;
-	tmpEvent.localEventId = _eventId;
-	tmpEvent.destObject = _destinationObject;
-	tmpEvent.overloadData = _overloadData;
-	if (nullptr != _eventIdgenerated) {
-		tmpEvent.destEventId = _eventIdgenerated;
-	} else {
-		tmpEvent.destEventId = _eventId;
-	}
-	m_externEvent.push_back(tmpEvent);
-}
-
-void ewol::Object::unRegisterOnEvent(const std::shared_ptr<ewol::Object>& _destinationObject,
-                                     const char * _eventId) {
-	if (_destinationObject == nullptr) {
-		EWOL_ERROR("Input ERROR nullptr pointer Object ...");
-		return;
-	}
-	// check if event existed :
-	auto it(m_externEvent.begin());
-	while(it != m_externEvent.end()) {
-		std::shared_ptr<ewol::Object> obj = it->destObject.lock();
-		if (obj == nullptr) {
-			m_externEvent.erase(it);
-			it = m_externEvent.begin();
-		} else if (    obj == _destinationObject
-		            && it->localEventId == _eventId) {
-			m_externEvent.erase(it);
-			it = m_externEvent.begin();
-			EWOL_INFO("[" << getId() << "] Remove extern event : to object id=" << _destinationObject->getId() << " event=" << _eventId);
-		} else {
-			++it;
-		}
-	}
-}
-*/
 
 bool ewol::Object::loadXML(exml::Element* _node) {
 	if (nullptr == _node) {
@@ -315,21 +226,6 @@ ewol::object::MultiCast& ewol::Object::getMultiCast() const {
 ewol::Context& ewol::Object::getContext() const {
 	return ewol::getContext();
 }
-/*
-void ewol::Object::registerOnObjectEvent(const std::shared_ptr<ewol::Object>& _destinationObject,
-                                         const std::string& _objectName,
-                                         const char * _eventId,
-                                         const char * _eventIdgenerated,
-                                         const std::string& _overloadData) {
-	std::shared_ptr<ewol::Object> tmpObject = getObjectManager().getObjectNamed(_objectName);
-	if (nullptr != tmpObject) {
-		EWOL_DEBUG("Find widget named : '" << _objectName << "' register event='" << _eventId << "'");
-		tmpObject->registerOnEvent(_destinationObject, _eventId, _eventIdgenerated, _overloadData);
-	} else {
-		EWOL_WARNING("[" << getId() << "] {" << getObjectType() << "} Can not register event : \"" << _eventId << "\" the object named=\"" << _objectName << "\" does not exist");
-	}
-}
-*/
 std::shared_ptr<ewol::Object> ewol::Object::getObjectNamed(const std::string& _objectName) const {
 	return getObjectManager().getObjectNamed(_objectName);
 }
diff --git a/sources/ewol/object/Signal.h b/sources/ewol/object/Signal.h
index 61553b18..fc6b517c 100644
--- a/sources/ewol/object/Signal.h
+++ b/sources/ewol/object/Signal.h
@@ -18,10 +18,22 @@
 
 namespace ewol {
 	namespace object {
+		class SignalCallerIdentifier {
+			public:
+				std::weak_ptr<ewol::Object> m_object;
+				const char* m_enevntId;
+				std::string m_data;
+				SignalCallerIdentifier(std::shared_ptr<ewol::Object> _object, const char* _enevntId, const std::string& _data) :
+				  m_object(_object),
+				  m_enevntId(_enevntId),
+				  m_data(_data) {
+					// nothing to do ...
+				}
+		};
 		template<typename T> class Signal : public SignalBase {
 			private:
 				//std::vector<std::funtion<void(const T&)>> m_callerList;
-				std::vector<std::tuple<std::weak_ptr<ewol::Object>, const char*, std::string>> m_serializedCallerList;
+				std::vector<SignalCallerIdentifier> m_serializedCallerList;
 			public:
 				/**
 				 * @brief Create a parameter with a specific type.
@@ -42,21 +54,12 @@ namespace ewol {
 				 * @brief Destructor.
 				 */
 				virtual ~Signal() { };
-				
-				const std::string& getName() {
-					return m_name;
+				void connect(std::shared_ptr<ewol::Object> _obj, const char* _destId=nullptr, const std::string& _data="" ) {
+					m_serializedCallerList.push_back(SignalCallerIdentifier(_obj, _destId, _data));
 				}
-				const std::string& getDescription() {
-					return m_description;
-				}
-				
-				bool connect(std::shared_ptr<ewol::Object> _obj, const char* _destId=nullptr, const std::string& _data="" ) {
-					m_serializedCallerList.push_back(std::make_tuple(_obj, _destId, _data));
-					return true;
-				}
-				bool release(std::shared_ptr<ewol::Object> _obj) {
+				void release(std::shared_ptr<ewol::Object> _obj) {
 					for (auto it(m_serializedCallerList.begin()) ; it != m_serializedCallerList.end(); ++it) {
-						if (std::get<0>(it) == _obj) {
+						if (it->m_object.lock() == _obj) {
 							m_serializedCallerList.erase(it);
 							it = m_serializedCallerList.begin();
 						}
@@ -89,30 +92,30 @@ namespace ewol {
 					}
 				}
 				*/
-				bool emit(const std::shared_ptr<ewol::Object>& _source, const T& _data) {
+				void emit(const std::shared_ptr<ewol::Object>& _source, const T& _data) {
 					// note : this can not emit on function ....
 					std::string stringData;
 					if (m_serializedCallerList.size()>0 ) {
 						stringData = etk::to_string(_data);
 					}
 					for (auto &it : m_serializedCallerList) {
-						std::shared_ptr<ewol::Object> destObject = std::get<0>(it).lock();
+						std::shared_ptr<ewol::Object> destObject = it.m_object.lock();
 						if (destObject == nullptr) {
 							// TODO : Remove instance ...
 							EWOL_VERBOSE("    nullptr dest");
 							continue;
 						}
 						const char* eventId = m_name.c_str();
-						if (std::get<1>(it) != nullptr) {
-							eventId = std::get<1>(it);
+						if (it.m_enevntId != nullptr) {
+							eventId = it.m_enevntId;
 						}
-						if (std::get<2>(it).size() <= 0){
+						if (it.m_data.size() <= 0){
 							ewol::object::Message tmpMsg(_source, eventId, stringData);
 							EWOL_VERBOSE("send message " << tmpMsg);
 							destObject->onReceiveMessage(tmpMsg);
 						} else {
 							// set the user requested data ...
-							ewol::object::Message tmpMsg(_source, eventId, std::get<2>(it));
+							ewol::object::Message tmpMsg(_source, eventId, it.m_data);
 							EWOL_VERBOSE("send message " << tmpMsg);
 							destObject->onReceiveMessage(tmpMsg);
 						}
@@ -123,7 +126,7 @@ namespace ewol {
 		template<> class Signal<void> : public SignalBase {
 			private:
 				//std::vector<std::funtion<void(const T&)>> m_callerList;
-				std::vector<std::tuple<std::weak_ptr<ewol::Object>, const char*, std::string>> m_serializedCallerList;
+				std::vector<SignalCallerIdentifier> m_serializedCallerList;
 			public:
 				/**
 				 * @brief Create a parameter with a specific type.
@@ -145,46 +148,38 @@ namespace ewol {
 				 */
 				virtual ~Signal() { };
 				
-				const std::string& getName() {
-					return m_name;
+				void connect(std::shared_ptr<ewol::Object> _obj, const char* _destId=nullptr, const std::string& _data="" ) {
+					m_serializedCallerList.push_back(SignalCallerIdentifier(_obj, _destId, _data));
 				}
-				const std::string& getDescription() {
-					return m_description;
-				}
-				
-				bool connect(std::shared_ptr<ewol::Object> _obj, const char* _destId=nullptr, const std::string& _data="" ) {
-					m_serializedCallerList.push_back(std::make_tuple(_obj, _destId, _data));
-					return true;
-				}
-				bool release(std::shared_ptr<ewol::Object> _obj) {
+				void release(std::shared_ptr<ewol::Object> _obj) {
 					for (auto it(m_serializedCallerList.begin()) ; it != m_serializedCallerList.end(); ++it) {
-						if (std::get<0>(it) == _obj) {
+						if (it->m_object.lock() == _obj) {
 							m_serializedCallerList.erase(it);
 							it = m_serializedCallerList.begin();
 						}
 					}
 				}
-				bool emit(const std::shared_ptr<ewol::Object>& _source) {
+				void emit(const std::shared_ptr<ewol::Object>& _source) {
 					// note : this can not emit on function ....
 					std::string stringData;
 					for (auto &it : m_serializedCallerList) {
-						std::shared_ptr<ewol::Object> destObject = std::get<0>(it).lock();
+						std::shared_ptr<ewol::Object> destObject = it.m_object.lock();
 						if (destObject == nullptr) {
 							// TODO : Remove instance ...
 							EWOL_VERBOSE("    nullptr dest");
 							continue;
 						}
 						const char* eventId = m_name.c_str();
-						if (std::get<1>(it) != nullptr) {
-							eventId = std::get<1>(it);
+						if (it.m_enevntId != nullptr) {
+							eventId = it.m_enevntId;
 						}
-						if (std::get<2>(it).size() <= 0){
+						if (it.m_data.size() <= 0){
 							ewol::object::Message tmpMsg(_source, eventId, stringData);
 							EWOL_VERBOSE("send message " << tmpMsg);
 							destObject->onReceiveMessage(tmpMsg);
 						} else {
 							// set the user requested data ...
-							ewol::object::Message tmpMsg(_source, eventId, std::get<2>(it));
+							ewol::object::Message tmpMsg(_source, eventId, it.m_data);
 							EWOL_VERBOSE("send message " << tmpMsg);
 							destObject->onReceiveMessage(tmpMsg);
 						}
diff --git a/sources/ewol/object/SignalBase.cpp b/sources/ewol/object/SignalBase.cpp
index 66cd59a9..11d2aac6 100644
--- a/sources/ewol/object/SignalBase.cpp
+++ b/sources/ewol/object/SignalBase.cpp
@@ -21,3 +21,9 @@ ewol::object::SignalBase::SignalBase(ewol::object::SignalList& _objectLink,
 	// add a reference on the current signal ...
 	m_objectLink.signalAdd(this);
 }
+
+std::ostream& ewol::object::operator <<(std::ostream& _os, const ewol::object::SignalBase& _obj) {
+	_os << _obj.getName();
+	return _os;
+}
+
diff --git a/sources/ewol/object/SignalBase.h b/sources/ewol/object/SignalBase.h
index 535ed751..f6951795 100644
--- a/sources/ewol/object/SignalBase.h
+++ b/sources/ewol/object/SignalBase.h
@@ -36,13 +36,16 @@ namespace ewol {
 				 */
 				virtual ~SignalBase() { };
 				
-				const std::string& getName() {
+				const std::string& getName() const {
 					return m_name;
 				}
-				const std::string& getDescription() {
+				const std::string& getDescription() const {
 					return m_description;
 				}
+				virtual void connect(std::shared_ptr<ewol::Object> _obj, const char* _destId=nullptr, const std::string& _data="" ) = 0;
+				virtual void release(std::shared_ptr<ewol::Object> _obj) = 0;
 		};
+		std::ostream& operator <<(std::ostream& _os, const SignalBase& _obj);
 	};
 };
 #endif
diff --git a/sources/ewol/object/SignalList.cpp b/sources/ewol/object/SignalList.cpp
index ce1c8498..92e9b5a3 100644
--- a/sources/ewol/object/SignalList.cpp
+++ b/sources/ewol/object/SignalList.cpp
@@ -11,6 +11,7 @@
 #include <ewol/object/Object.h>
 #include <ewol/object/SignalList.h>
 #include <ewol/object/SignalBase.h>
+#include <ewol/context/Context.h>
 
 ewol::object::SignalList::SignalList() {
 	
@@ -29,60 +30,85 @@ void ewol::object::SignalList::signalAdd(SignalBase* _pointerOnSignal) {
 	m_list.push_back(_pointerOnSignal);
 }
 
-#if 0
-// Note no lock is needed at this level, because the lock is done is the upper elements ...
-// the parameter set might be done with a pool of parameter, allone, the overhed is bigger ...
-bool ewol::object::SignalList::parameterSet(const std::string& _parameter, const std::string& _value) {
-	for (auto &it : m_list) {
-		if(    it != nullptr
-		    && it->getName() == _parameter) {
-			it->setString(_value);
-			return true;
-		}
-	}
-	// can not find the parameters :
-	return false;
-}
-
-std::string ewol::object::SignalList::parameterGet(const std::string& _parameter) const {
-	for (auto &it : m_list) {
-		if(    it != nullptr
-		    && it->getName() == _parameter) {
-			return it->getString();
-		}
-	}
-	return "???";
-}
-
-void ewol::object::SignalList::parameterDisplay(bool _changeOnly) const {
-	EWOL_INFO("    Object parameters:");
+std::vector<std::string> ewol::object::SignalList::signalGetAll() const {
+	std::vector<std::string> out;
 	for (auto &it : m_list) {
 		if(it != nullptr) {
-			std::string paramName = it->getName();
-			std::string paramVal = it->getString();
-			std::string paramInfo = it->getInfo();
-			if (    _changeOnly == false
-			     || it->isDefault() == false) {
-				EWOL_INFO("    |       param='" << paramName << "' value=" << paramVal << "     (" << paramInfo << ")");
-			}
-		} else {
-			EWOL_INFO("    |       param=nullptr");
-		}
-	}
-}
-
-std::map<std::string, std::string> ewol::object::SignalList::parameterGetAll(bool _notIfDefault) const {
-	std::map<std::string, std::string> out;
-	for (auto &it : m_list) {
-		if(it != nullptr) {
-			std::string paramName = it->getName();
-			std::string paramVal = it->getString();
-			if (    _notIfDefault == false
-			     || it->isDefault() == false) {
-				out.insert(std::make_pair(paramName, paramVal));
-			}
+			out.push_back(it->getName());
 		}
 	}
 	return out;
 }
-#endif
+
+void ewol::object::SignalList::registerOnObjectEvent(const std::shared_ptr<ewol::Object>& _destinationObject,
+                                                     const std::string& _objectName,
+                                                     const char * _eventId,
+                                                     const char * _eventIdgenerated,
+                                                     const std::string& _overloadData) {
+	ewol::object::Manager& tmp = ewol::getContext().getEObjectManager();
+	std::shared_ptr<ewol::Object> tmpObject = tmp.getObjectNamed(_objectName);
+	if (nullptr != tmpObject) {
+		EWOL_DEBUG("Find widget named : '" << _objectName << "' register event='" << _eventId << "'");
+		tmpObject->registerOnEvent(_destinationObject, _eventId, _eventIdgenerated, _overloadData);
+	} else {
+		EWOL_WARNING(" Can not register event : '" << _eventId << "' the object named='" << _objectName << "' does not exist");
+	}
+}
+
+void ewol::object::SignalList::registerOnEvent(const std::shared_ptr<ewol::Object>& _destinationObject,
+                                               const char * _eventId,
+                                               const char * _eventIdgenerated,
+                                               const std::string& _overloadData) {
+	if (_destinationObject == nullptr) {
+		EWOL_ERROR("Input ERROR nullptr pointer Object ...");
+		return;
+	}
+	if (_eventId == nullptr) {
+		EWOL_ERROR("Input ERROR nullptr pointer Event Id...");
+		return;
+	}
+	if (    _eventId[0] == '*'
+	     && _eventId[1] == '\0') {
+		EWOL_VERBOSE("Register on all event ...");
+		for(auto &it : m_list) {
+			if (it == nullptr) {
+				continue;
+			}
+			it->connect(_destinationObject, _eventIdgenerated, _overloadData);
+		}
+		return;
+	}
+	// check if event existed :
+	bool findIt = false;
+	for(auto &it : m_list) {
+		if (it == nullptr) {
+			continue;
+		}
+		if (it->getName() == _eventId) {
+			findIt = true;
+			it->connect(_destinationObject, _eventIdgenerated, _overloadData);
+		}
+	}
+	if (false == findIt) {
+		EWOL_ERROR("Can not register event on this event=\"" << _eventId << "\"  == > unknow event");
+		return;
+	}
+}
+
+void ewol::object::SignalList::unRegisterOnEvent(const std::shared_ptr<ewol::Object>& _destinationObject,
+                                                 const char * _eventId) {
+	if (_destinationObject == nullptr) {
+		EWOL_ERROR("Input ERROR nullptr pointer Object ...");
+		return;
+	}
+	for(auto &it : m_list) {
+		if (it == nullptr) {
+			continue;
+		}
+		if (    it->getName() == _eventId
+		     || (    _eventId[0] == '*'
+		          && _eventId[1] == '\0') ) {
+			it->release(_destinationObject);
+		}
+	}
+}
diff --git a/sources/ewol/object/SignalList.h b/sources/ewol/object/SignalList.h
index 38924010..dde06808 100644
--- a/sources/ewol/object/SignalList.h
+++ b/sources/ewol/object/SignalList.h
@@ -35,37 +35,11 @@ namespace ewol {
 				 * @param[in] pointerOnParameter Pointer on the parameter that might be added.
 				 */
 				void signalAdd(SignalBase* _pointerOnParameter);
-				#if 0
 				/**
-				 * @brief Set a specific value to the parameter reference name.
-				 * @param[in] parameter The parameter string name.
-				 * @param[in] value The new value of the parameter (string).
-				 * @return true Parameter update.
-				 * @return false Parameter not update.
+				 * @brief Get All the signal list:
+				 * @return vector on all the signals names
 				 */
-				bool parameterSet(const std::string& _parameter, const std::string& _value);
-				/**
-				 * @brief Get a specific value of the parameter reference name.
-				 * @param[in] parameter The parameter string name.
-				 * @return The value of the parameter (string).
-				 */
-				std::string parameterGet(const std::string& _parameter) const;
-				/**
-				 * @brief Display all the parameter value with there name.
-				 * @param[in] changeOnly check at true if the user want to display only parameter that are not at default value.
-				 */
-				void parameterDisplay(bool _changeOnly = false) const;
-				/**
-				 * @brief Called when a parameter change value.
-				 * @param[in] _paramPointer Pointer on the parameter (to know which parameter have change);
-				 */
-				virtual void onParameterChangeValue(const ewol::object::ParameterRef& _paramPointer) { };
-				/**
-				 * @brief Get All the parameter configuration:
-				 * @return map on the parameters
-				 */
-				std::map<std::string, std::string> parameterGetAll(bool _notIfDefault=true) const;
-				#endif
+				std::vector<std::string> signalGetAll() const;
 				/**
 				 * @brief Register an Event an named widget. @see registerOnEvent
 				 * @param[in] _destinationObject pointer on the object that might be call when an event is generated
diff --git a/sources/ewol/widget/Button.cpp b/sources/ewol/widget/Button.cpp
index 86197e9e..e6d80c9f 100644
--- a/sources/ewol/widget/Button.cpp
+++ b/sources/ewol/widget/Button.cpp
@@ -14,14 +14,6 @@
 #define __class__ "Button"
 
 
-const char* const ewol::widget::Button::eventPressed    = "pressed";
-const char* const ewol::widget::Button::eventDown       = "down";
-const char* const ewol::widget::Button::eventUp         = "up";
-const char* const ewol::widget::Button::eventEnter      = "enter";
-const char* const ewol::widget::Button::eventLeave      = "leave";
-const char* const ewol::widget::Button::eventValue      = "value";
-
-
 // DEFINE for the shader display system :
 #define STATUS_UP        (0)
 #define STATUS_HOVER     (2)
@@ -30,6 +22,11 @@ const char* const ewol::widget::Button::eventValue      = "value";
 
 ewol::widget::Button::Button() :
   signalPressed(*this, "pressed", "Button is pressed"),
+  signalDown(*this, "down", "Button is DOWN"),
+  signalUp(*this, "up", "Button is UP"),
+  signalEnter(*this, "enter", "The cursor enter inside the button"),
+  signalLeave(*this, "leave", "the cursor leave the button"),
+  signalValue(*this, "value", "button value change"),
   m_shaper(*this, "shaper", "The display name for config file"),
   m_value(*this, "value", false, "Value of the Button"),
   m_lock(*this, "lock", lockNone, "Lock the button in a special state to permit changing state only by the coder"),
@@ -40,13 +37,6 @@ ewol::widget::Button::Button() :
   m_selectableAreaPos(0,0),
   m_selectableAreaSize(0,0) {
 	addObjectType("ewol::widget::Button");
-	// add basic Event generated :
-	addEventId(eventPressed);
-	addEventId(eventDown);
-	addEventId(eventUp);
-	addEventId(eventEnter);
-	addEventId(eventLeave);
-	addEventId(eventValue);
 	
 	// set property list:
 	m_lock.add(lockNone, "none");
@@ -131,14 +121,14 @@ bool ewol::widget::Button::onEventInput(const ewol::event::Input& _event) {
 	if (true == m_mouseHover) {
 		if (1 == _event.getId()) {
 			if(ewol::key::statusDown == _event.getStatus()) {
-				EWOL_VERBOSE(getName() << " : Generate event : " << eventDown);
-				generateEventId(eventDown);
+				EWOL_VERBOSE(getName() << " : Generate event : " << signalDown);
+				signalDown.emit(shared_from_this());
 				m_buttonPressed = true;
 				markToRedraw();
 			}
 			if(ewol::key::statusUp == _event.getStatus()) {
-				EWOL_VERBOSE(getName() << " : Generate event : " << eventUp);
-				generateEventId(eventUp);
+				EWOL_VERBOSE(getName() << " : Generate event : " << signalUp);
+				signalUp.emit(shared_from_this());
 				m_buttonPressed = false;
 				markToRedraw();
 			}
@@ -152,15 +142,15 @@ bool ewol::widget::Button::onEventInput(const ewol::event::Input& _event) {
 				} else {
 					// inverse value :
 					setValue((m_value)?false:true);
-					EWOL_VERBOSE(getName() << " : Generate event : " << eventPressed);
-					generateEventId(eventPressed);
-					EWOL_VERBOSE(getName() << " : Generate event : " << eventValue << " val=" << m_value );
-					generateEventId(eventValue, etk::to_string(m_value.get()));
+					EWOL_VERBOSE(getName() << " : Generate event : " << signalPressed);
+					signalPressed.emit(shared_from_this());
+					EWOL_VERBOSE(getName() << " : Generate event : " << signalValue << " val=" << m_value );
+					signalValue.emit(shared_from_this(), m_value.get());
 					if(    false == m_toggleMode
 					    && true == m_value) {
 						setValue(false);
-						EWOL_VERBOSE(getName() << " : Generate event : " << ewol::widget::Button::eventValue << " val=" << m_value);
-						generateEventId(eventValue, etk::to_string(m_value.get()));
+						EWOL_VERBOSE(getName() << " : Generate event : " << signalValue << " val=" << m_value);
+						signalValue.emit(shared_from_this(), m_value.get());
 					}
 				}
 				markToRedraw();
@@ -177,7 +167,7 @@ bool ewol::widget::Button::onEventEntry(const ewol::event::Entry& _event) {
 	if(    _event.getType() == ewol::key::keyboardChar
 	    && _event.getStatus() == ewol::key::statusDown
 	    && _event.getChar() == '\r') {
-		generateEventId(eventEnter);
+		signalEnter.emit(shared_from_this());
 		return true;
 	}
 	return false;
diff --git a/sources/ewol/widget/Button.h b/sources/ewol/widget/Button.h
index 6f5c60db..8a06404b 100644
--- a/sources/ewol/widget/Button.h
+++ b/sources/ewol/widget/Button.h
@@ -30,12 +30,12 @@ namespace ewol {
 		class Button : public ewol::widget::Container2 {
 			public:
 				// Event list of properties
-				ewol::object::Signal<int> signalPressed;
+				ewol::object::Signal<void> signalPressed;
 				ewol::object::Signal<void> signalDown;
 				ewol::object::Signal<void> signalUp;
 				ewol::object::Signal<void> signalEnter;
 				ewol::object::Signal<void> signalLeave;
-				ewol::object::Signal<void> signalValue;
+				ewol::object::Signal<bool> signalValue;
 				enum buttonLock{
 					lockNone, //!< normal status of the button
 					lockWhenPressed, //!< When the state is set in pressed, the status stay in this one
diff --git a/sources/ewol/widget/ButtonColor.cpp b/sources/ewol/widget/ButtonColor.cpp
index 088c155b..29b79622 100644
--- a/sources/ewol/widget/ButtonColor.cpp
+++ b/sources/ewol/widget/ButtonColor.cpp
@@ -15,9 +15,6 @@
 #include <ewol/widget/Windows.h>
 #include <ewol/ewol.h>
 
-const char * const ewol::widget::ButtonColor::eventChange = "change";
-
-
 // DEFINE for the shader display system :
 #define STATUS_UP        (0)
 #define STATUS_HOVER     (2)
@@ -31,10 +28,10 @@ const char * const ewol::widget::ButtonColor::eventChange = "change";
 static const char* const eventColorHasChange = "ewol-widget-ButtonColor-colorChange";
 
 ewol::widget::ButtonColor::ButtonColor() :
+  signalChange(*this, "change", "Button color change value"),
   m_textColorFg(etk::color::black),
   m_widgetContextMenu(nullptr) {
 	addObjectType("ewol::widget::ButtonColor");
-	addEventId(eventChange);
 	changeStatusIn(STATUS_UP);
 	setCanHaveFocus(true);
 	// Limit event at 1:
@@ -227,7 +224,9 @@ void ewol::widget::ButtonColor::onReceiveMessage(const ewol::object::Message& _m
 	EWOL_INFO("Receive MSG : " <<  _msg.getData());
 	if (_msg.getMessage() == eventColorHasChange) {
 		m_textColorFg = _msg.getData();
-		generateEventId(eventChange, _msg.getData());
+		// TODO : set a proper call
+		//signalChange.emit(shared_from_this(), _msg.getData());
+		EWOL_TODO("generate signal of change color : " << _msg.getData());
 		markToRedraw();
 	}
 }
diff --git a/sources/ewol/widget/ButtonColor.h b/sources/ewol/widget/ButtonColor.h
index 53bd0bb7..590bf70b 100644
--- a/sources/ewol/widget/ButtonColor.h
+++ b/sources/ewol/widget/ButtonColor.h
@@ -17,13 +17,14 @@
 #include <ewol/compositing/Shaper.h>
 #include <ewol/widget/Widget.h>
 #include <ewol/widget/Manager.h>
+#include <ewol/object/Signal.h>
 
 namespace ewol {
 	namespace widget {
 		class ButtonColor : public ewol::Widget {
 			public:
 				// Event list of properties
-				static const char * const eventChange;
+				ewol::object::Signal<etk::Color<>> signalChange;
 			private:
 				ewol::compositing::Shaper m_shaper; //!< Compositing theme.
 				ewol::compositing::Text m_text; //!< Compositing Test display.
diff --git a/sources/ewol/widget/CheckBox.cpp b/sources/ewol/widget/CheckBox.cpp
index 99fbabed..45c9ada0 100644
--- a/sources/ewol/widget/CheckBox.cpp
+++ b/sources/ewol/widget/CheckBox.cpp
@@ -9,13 +9,6 @@
 #include <ewol/widget/CheckBox.h>
 #include <ewol/widget/Manager.h>
 
-const char* const ewol::widget::CheckBox::eventPressed    = "pressed";
-const char* const ewol::widget::CheckBox::eventDown       = "down";
-const char* const ewol::widget::CheckBox::eventUp         = "up";
-const char* const ewol::widget::CheckBox::eventEnter      = "enter";
-const char* const ewol::widget::CheckBox::eventValue      = "value";
-
-
 // DEFINE for the shader display system :
 #define STATUS_UP        (0)
 #define STATUS_HOVER     (2)
@@ -26,6 +19,11 @@ const char* const ewol::widget::CheckBox::eventValue      = "value";
 
 
 ewol::widget::CheckBox::CheckBox() :
+  signalPressed(*this, "pressed", "CheckBox is pressed"),
+  signalDown(*this, "down", "CheckBox is DOWN"),
+  signalUp(*this, "up", "CheckBox is UP"),
+  signalEnter(*this, "enter", "The cursor enter inside the CheckBox"),
+  signalValue(*this, "value", "CheckBox value change"),
   m_shaper(*this, "shaper", "The display name for config file"),
   m_mouseHover(false),
   m_buttonPressed(false),
@@ -35,12 +33,6 @@ ewol::widget::CheckBox::CheckBox() :
   m_shaperIdSizeInsize(-1),
   m_value(*this, "value", false, "Basic value of the widget") {
 	addObjectType("ewol::widget::CheckBox");
-	// add basic Event generated :
-	addEventId(eventPressed);
-	addEventId(eventDown);
-	addEventId(eventUp);
-	addEventId(eventEnter);
-	addEventId(eventValue);
 	
 	m_shaperIdSize = m_shaper->requestConfig("box-size");
 	m_shaperIdSizeInsize = m_shaper->requestConfig("box-inside");
@@ -135,24 +127,24 @@ bool ewol::widget::CheckBox::onEventInput(const ewol::event::Input& _event) {
 	if (true == m_mouseHover) {
 		if (1 == _event.getId()) {
 			if(ewol::key::statusDown == _event.getStatus()) {
-				EWOL_VERBOSE(getName() << " : Generate event : " << eventDown);
-				generateEventId(eventDown);
+				EWOL_VERBOSE(getName() << " : Generate event : " << signalDown);
+				signalDown.emit(shared_from_this());
 				m_buttonPressed = true;
 				markToRedraw();
 			}
 			if(ewol::key::statusUp == _event.getStatus()) {
-				EWOL_VERBOSE(getName() << " : Generate event : " << eventUp);
-				generateEventId(eventUp);
+				EWOL_VERBOSE(getName() << " : Generate event : " << signalUp);
+				signalUp.emit(shared_from_this());
 				m_buttonPressed = false;
 				markToRedraw();
 			}
 			if(ewol::key::statusSingle == _event.getStatus()) {
 				// inverse value :
 				setValue((m_value)?false:true);
-				EWOL_VERBOSE(getName() << " : Generate event : " << eventPressed);
-				generateEventId(eventPressed);
-				EWOL_VERBOSE(getName() << " : Generate event : " << eventValue << " val=" << m_value );
-				generateEventId(eventValue, etk::to_string(m_value.get()));
+				EWOL_VERBOSE(getName() << " : Generate event : " << signalPressed);
+				signalPressed.emit(shared_from_this());
+				EWOL_VERBOSE(getName() << " : Generate event : " << signalValue << " val=" << m_value );
+				signalValue.emit(shared_from_this(), m_value.get());
 				markToRedraw();
 			}
 		}
@@ -170,7 +162,7 @@ bool ewol::widget::CheckBox::onEventEntry(const ewol::event::Entry& _event) {
 	if(    _event.getType() == ewol::key::keyboardChar
 	    && _event.getStatus() == ewol::key::statusDown
 	    && _event.getChar() == '\r') {
-		generateEventId(eventEnter);
+		signalEnter.emit(shared_from_this());
 		return true;
 	}
 	return false;
diff --git a/sources/ewol/widget/CheckBox.h b/sources/ewol/widget/CheckBox.h
index 741ef2df..20cbfeee 100644
--- a/sources/ewol/widget/CheckBox.h
+++ b/sources/ewol/widget/CheckBox.h
@@ -14,6 +14,7 @@
 #include <ewol/compositing/Shaper.h>
 #include <ewol/widget/Container2.h>
 #include <ewol/widget/Manager.h>
+#include <ewol/object/Signal.h>
 
 
 namespace ewol {
@@ -21,11 +22,11 @@ namespace ewol {
 		class CheckBox : public ewol::widget::Container2 {
 			public:
 				// Event list of properties
-				static const char* const eventPressed;
-				static const char* const eventDown;
-				static const char* const eventUp;
-				static const char* const eventEnter;
-				static const char* const eventValue;
+				ewol::object::Signal<void> signalPressed;
+				ewol::object::Signal<void> signalDown;
+				ewol::object::Signal<void> signalUp;
+				ewol::object::Signal<void> signalEnter;
+				ewol::object::Signal<bool> signalValue;
 			private:
 				ewol::object::Param<ewol::compositing::Shaper> m_shaper; //!< Compositing theme.
 				bool m_mouseHover; //!< Flag to know where the mouse is (inside the displayed widget (if not fill)).
diff --git a/sources/ewol/widget/ColorBar.cpp b/sources/ewol/widget/ColorBar.cpp
index b4e28ae1..b5958014 100644
--- a/sources/ewol/widget/ColorBar.cpp
+++ b/sources/ewol/widget/ColorBar.cpp
@@ -13,16 +13,12 @@
 
 #include <etk/Color.h>
 
-const char * const ewol::widget::ColorBar::eventChange    = "change";
-
-
-
 #undef __class__
 #define __class__ "ColorBar"
 
-ewol::widget::ColorBar::ColorBar() {
+ewol::widget::ColorBar::ColorBar() :
+  signalChange(*this, "change", "Color value change") {
 	addObjectType("ewol::widget::ColorBar");
-	addEventId(eventChange);
 	m_currentUserPos.setValue(0,0);
 	m_currentColor = etk::color::black;
 	setCanHaveFocus(true);
@@ -224,7 +220,7 @@ bool ewol::widget::ColorBar::onEventInput(const ewol::event::Input& _event) {
 			}
 			if(m_currentColor != estimateColor) {
 				m_currentColor = estimateColor;
-				generateEventId(eventChange);
+				signalChange.emit(shared_from_this(), m_currentColor);
 			}
 			return true;
 		}
diff --git a/sources/ewol/widget/ColorBar.h b/sources/ewol/widget/ColorBar.h
index 5597771a..98a1f7ab 100644
--- a/sources/ewol/widget/ColorBar.h
+++ b/sources/ewol/widget/ColorBar.h
@@ -14,6 +14,7 @@
 #include <etk/Color.h>
 #include <ewol/widget/Widget.h>
 #include <ewol/compositing/Drawing.h>
+#include <ewol/object/Signal.h>
 
 
 namespace ewol {
@@ -21,7 +22,7 @@ namespace ewol {
 		class ColorBar : public ewol::Widget {
 			public:
 				// Event list of properties
-				static const char * const eventChange;
+				ewol::object::Signal<etk::Color<>> signalChange;
 			protected:
 				ColorBar();
 				void init();
diff --git a/sources/ewol/widget/Entry.cpp b/sources/ewol/widget/Entry.cpp
index 4e9bb379..d0c723da 100644
--- a/sources/ewol/widget/Entry.cpp
+++ b/sources/ewol/widget/Entry.cpp
@@ -29,11 +29,10 @@ const char * const ewolEventEntrySelect = "ewol-widget-entry-event-internal-sele
 #define STATUS_HOVER     (1)
 #define STATUS_SELECTED  (2)
 
-const char * const ewol::widget::Entry::eventClick  = "click";
-const char * const ewol::widget::Entry::eventEnter  = "enter";
-const char * const ewol::widget::Entry::eventModify = "modify";
-
 ewol::widget::Entry::Entry() :
+  signalClick(*this, "click", "the user Click on the Entry box"),
+  signalEnter(*this, "enter", "The cursor enter inside the button"),
+  signalModify(*this, "modify", "Entry box value change"),
   m_shaper(*this, "shaper", "Shaper to display the background"),
   m_data(*this, "value", "", "Value display in the entry (decorated text)"),
   m_maxCharacter(*this, "max", 0x7FFFFFFF, 0, 0x7FFFFFFF, "Maximum cgar that can be set on the Entry"),
@@ -46,9 +45,6 @@ ewol::widget::Entry::Entry() :
   m_textWhenNothing(*this, "emptytext", "", "Text that is displayed when the Entry is empty (decorated text)") {
 	addObjectType("ewol::widget::Entry");
 	setCanHaveFocus(true);
-	addEventId(eventClick);
-	addEventId(eventEnter);
-	addEventId(eventModify);
 	shortCutAdd("ctrl+w", ewolEventEntryClean);
 	shortCutAdd("ctrl+x", ewolEventEntryCut);
 	shortCutAdd("ctrl+c", ewolEventEntryCopy);
@@ -244,7 +240,7 @@ bool ewol::widget::Entry::onEventInput(const ewol::event::Input& _event) {
 	if (1 == _event.getId()) {
 		if (ewol::key::statusSingle == _event.getStatus()) {
 			keepFocus();
-			generateEventId(eventClick);
+			signalClick.emit(shared_from_this());
 			//nothing to do ...
 			return true;
 		} else if (ewol::key::statusDouble == _event.getStatus()) {
@@ -335,13 +331,11 @@ bool ewol::widget::Entry::onEventInput(const ewol::event::Input& _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 << "\" " );
-			//return GenEventInputExternal(eventEnter, -1, -1);
 			// remove curent selected data ...
 			removeSelected();
 			if(    _event.getChar() == '\n'
 			    || _event.getChar() == '\r') {
-				generateEventId(eventEnter, m_data);
+				signalEnter.emit(shared_from_this(), m_data);
 				return true;
 			} else if (_event.getChar() == 0x7F) {
 				// SUPPR :
@@ -371,7 +365,7 @@ bool ewol::widget::Entry::onEventEntry(const ewol::event::Entry& _event) {
 					}
 				}
 			}
-			generateEventId(eventModify, m_data);
+			signalModify.emit(shared_from_this(), m_data);
 			markToRedraw();
 			return true;
 		}
@@ -443,7 +437,7 @@ void ewol::widget::Entry::onEventClipboard(enum ewol::context::clipBoard::clipbo
 			markToRedraw();
 		}
 	}
-	generateEventId(eventModify, m_data);
+	signalModify.emit(shared_from_this(), m_data);
 }
 
 
@@ -458,7 +452,7 @@ void ewol::widget::Entry::onReceiveMessage(const ewol::object::Message& _msg) {
 	} else if(_msg.getMessage() == ewolEventEntryCut) {
 		copySelectionToClipBoard(ewol::context::clipBoard::clipboardStd);
 		removeSelected();
-		generateEventId(eventModify, m_data);
+		signalModify.emit(shared_from_this(), m_data);
 	} else if(_msg.getMessage() == ewolEventEntryCopy) {
 		copySelectionToClipBoard(ewol::context::clipBoard::clipboardStd);
 	} else if(_msg.getMessage() == ewolEventEntryPaste) {
diff --git a/sources/ewol/widget/Entry.h b/sources/ewol/widget/Entry.h
index 93024b50..52e58a89 100644
--- a/sources/ewol/widget/Entry.h
+++ b/sources/ewol/widget/Entry.h
@@ -18,6 +18,7 @@
 #include <ewol/widget/Widget.h>
 #include <etk/Color.h>
 #include <ewol/widget/Manager.h>
+#include <ewol/object/Signal.h>
 
 namespace ewol {
 	namespace widget {
@@ -33,10 +34,9 @@ namespace ewol {
 		 */
 		class Entry : public ewol::Widget {
 			public:
-				// Event list of properties
-				static const char * const eventClick;
-				static const char * const eventEnter;
-				static const char * const eventModify; // return in the data the new string inside it ...
+				ewol::object::Signal<void> signalClick; //!< bang on click the entry box
+				ewol::object::Signal<std::string> signalEnter; //!< Enter key is pressed
+				ewol::object::Signal<std::string> signalModify; //!< data change
 			private:
 				ewol::object::Param<ewol::compositing::Shaper> m_shaper;
 				int32_t m_colorIdTextFg; //!< color property of the text foreground
diff --git a/sources/ewol/widget/Image.cpp b/sources/ewol/widget/Image.cpp
index 45b70b42..b44a775a 100644
--- a/sources/ewol/widget/Image.cpp
+++ b/sources/ewol/widget/Image.cpp
@@ -16,9 +16,8 @@
 #undef __class__
 #define __class__ "Image"
 
-const char * const ewol::widget::Image::eventPressed = "pressed";
-
 ewol::widget::Image::Image() :
+  signalPressed(*this, "pressed", "Image is pressed"),
   m_colorProperty(nullptr),
   m_colorId(-1),
   m_fileName(*this, "src", "", "Image source path"),
@@ -29,7 +28,6 @@ ewol::widget::Image::Image() :
   m_posStop(*this, "part-stop", vec2(1.0f, 1.0f), vec2(0.0f, 0.0f), vec2(1.0f, 1.0f), "Start display position in the image"),
   m_distanceFieldMode(*this, "distance-field", false, "Distance field mode") {
 	addObjectType("ewol::widget::Image");
-	addEventId(eventPressed);
 	m_colorProperty = ewol::resource::ColorFile::create("THEME:COLOR:Image.json");
 	if (m_colorProperty != nullptr) {
 		m_colorId = m_colorProperty->request("foreground");
@@ -135,7 +133,7 @@ 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()) {
-			generateEventId(eventPressed);
+			signalPressed.emit(shared_from_this());
 			return true;
 		}
 	}
diff --git a/sources/ewol/widget/Image.h b/sources/ewol/widget/Image.h
index df2a07d7..0954722e 100644
--- a/sources/ewol/widget/Image.h
+++ b/sources/ewol/widget/Image.h
@@ -16,6 +16,7 @@
 #include <ewol/compositing/Image.h>
 #include <ewol/resource/ColorFile.h>
 #include <ewol/widget/Manager.h>
+#include <ewol/object/Signal.h>
 
 namespace ewol {
 	namespace widget {
@@ -25,7 +26,7 @@ namespace ewol {
 		class Image :public ewol::Widget {
 			public:
 				// Event list of properties
-				static const char * const eventPressed;
+				ewol::object::Signal<void> signalPressed;
 			protected:
 				ewol::compositing::Image m_compositing; //!< compositing element of the image.
 				std::shared_ptr<ewol::resource::ColorFile> m_colorProperty; //!< theme color property
diff --git a/sources/ewol/widget/Joystick.cpp b/sources/ewol/widget/Joystick.cpp
index 73fd63a6..d3e5b46a 100644
--- a/sources/ewol/widget/Joystick.cpp
+++ b/sources/ewol/widget/Joystick.cpp
@@ -12,10 +12,6 @@
 #include <ewol/compositing/Image.h>
 #include <ewol/widget/Manager.h>
 
-const char * const ewol::widget::Joystick::eventEnable   = "enable";
-const char * const ewol::widget::Joystick::eventDisable  = "disable";
-const char * const ewol::widget::Joystick::eventMove     = "move";
-
 static bool l_displayBackground(true);
 static std::string l_background("");
 static std::string l_foreground("");
@@ -24,11 +20,11 @@ static float l_ratio(1.0/7.0);
 #undef __class__
 #define __class__ "Joystick"
 
-ewol::widget::Joystick::Joystick() {
+ewol::widget::Joystick::Joystick() :
+  signalEnable(*this, "enable"),
+  signalDisable(*this, "disable"),
+  signalMove(*this, "move") {
 	addObjectType("ewol::widget::Joystick");
-	addEventId(eventEnable);
-	addEventId(eventDisable);
-	addEventId(eventMove);
 	// by default the joy does not lock when free out
 	m_lock = false;
 	m_displayMode = modeNormal;
@@ -148,10 +144,10 @@ bool ewol::widget::Joystick::onEventInput(const ewol::event::Input& _event) {
 			}
 			markToRedraw();
 			if(ewol::key::statusDown == typeEvent) {
-				generateEventId(eventEnable);
+				signalEnable.emit(shared_from_this());
 			} else {
 				std::string tmp = std::string("distance=") + std::string(m_distance) + std::string("angle=") + std::string(m_angle+M_PI/2);
-				generateEventId(eventMove, tmp);
+				signalMove.emit(shared_from_this(), m_angle+M_PI/2);
 			}
 			//teta += M_PI/2;
 			//EWOL_DEBUG("TETA = " << (m_angle*180/M_PI) << " deg distance = " << m_distance);
@@ -167,7 +163,7 @@ bool ewol::widget::Joystick::onEventInput(const ewol::event::Input& _event) {
 				m_distance = 0;
 			}
 			markToRedraw();
-			generateEventId(eventDisable);
+			signalDisable.emit(shared_from_this());
 			return true;
 		}
 		return false;
diff --git a/sources/ewol/widget/Joystick.h b/sources/ewol/widget/Joystick.h
index 5ead150b..a5cbff2d 100644
--- a/sources/ewol/widget/Joystick.h
+++ b/sources/ewol/widget/Joystick.h
@@ -13,6 +13,7 @@
 #include <ewol/debug.h>
 #include <ewol/widget/Widget.h>
 #include <draw/Color.h>
+#include <ewol/object/Signal.h>
 
 
 namespace ewol {
@@ -23,9 +24,9 @@ namespace ewol {
 		class Joystick :public ewol::Widget {
 			public:
 				// Event list of properties
-				static const char * const eventEnable;
-				static const char * const eventDisable;
-				static const char * const eventMove;
+				ewol::object::Signal<void> signalEnable;
+				ewol::object::Signal<void> signalDisable;
+				ewol::object::Signal<vec2> signalMove;
 			public:
 				enum joystickMode {
 					modeNormal,
@@ -34,7 +35,7 @@ namespace ewol {
 			private:
 				draw::Color m_colorFg; //!< Forground  color
 				draw::Color m_colorBg; //!< Background color
-				vec2  m_displayPos; //!< direction of the cursor ...
+				vec2 m_displayPos; //!< direction of the cursor ...
 				float m_distance; //!< dintance from the center
 				float m_angle; //!< angle of the arraw (if < 0 : No arraw...) 0 is the TOP ...
 				bool m_lock; //!< flag to mark the lock when the cursor is free when we are outside the circle
diff --git a/sources/ewol/widget/Label.cpp b/sources/ewol/widget/Label.cpp
index 46424a74..d6ec3794 100644
--- a/sources/ewol/widget/Label.cpp
+++ b/sources/ewol/widget/Label.cpp
@@ -15,10 +15,9 @@
 #undef __class__
 #define __class__ "Label"
 
-const char * const ewol::widget::Label::eventPressed = "pressed";
-
 // TODO : Remove the label name in the constructor ...
 ewol::widget::Label::Label() :
+  signalPressed(*this, "pressed"),
   m_label(*this, "value", U"", "displayed value string"),
   m_colorProperty(nullptr),
   m_colorDefaultFgText(-1),
@@ -29,7 +28,6 @@ ewol::widget::Label::Label() :
 		m_colorDefaultFgText = m_colorProperty->request("foreground");
 		m_colorDefaultBgText = m_colorProperty->request("background");
 	}
-	addEventId(eventPressed);
 	setCanHaveFocus(false);
 	setMouseLimit(1);
 }
@@ -126,7 +124,7 @@ bool ewol::widget::Label::onEventInput(const ewol::event::Input& _event) {
 	if (1 == _event.getId()) {
 		if (ewol::key::statusSingle == _event.getStatus()) {
 			// nothing to do ...
-			generateEventId(eventPressed);
+			signalPressed.emit(shared_from_this());
 			return true;
 		}
 	}
diff --git a/sources/ewol/widget/Label.h b/sources/ewol/widget/Label.h
index f1d9f887..3ee63a80 100644
--- a/sources/ewol/widget/Label.h
+++ b/sources/ewol/widget/Label.h
@@ -15,6 +15,7 @@
 #include <ewol/widget/Widget.h>
 #include <ewol/widget/Manager.h>
 #include <ewol/resource/ColorFile.h>
+#include <ewol/object/Signal.h>
 
 namespace ewol {
 	namespace widget {
@@ -24,7 +25,7 @@ namespace ewol {
 		class Label : public ewol::Widget {
 			public:
 				// Event list of properties
-				static const char * const eventPressed;
+				ewol::object::Signal<void> signalPressed;
 			private:
 				ewol::compositing::Text m_text; //!< Compositing text element.
 				ewol::object::Param<std::u32string> m_label; //!< decorated text to display.
diff --git a/sources/ewol/widget/ListFileSystem.cpp b/sources/ewol/widget/ListFileSystem.cpp
index 31b35f09..271954ea 100644
--- a/sources/ewol/widget/ListFileSystem.cpp
+++ b/sources/ewol/widget/ListFileSystem.cpp
@@ -15,13 +15,11 @@
 #undef __class__
 #define __class__ "ListFileSystem"
 
-const char * const ewol::widget::ListFileSystem::eventFileSelect     = "file-select";
-const char * const ewol::widget::ListFileSystem::eventFileValidate   = "file-validate";
-const char * const ewol::widget::ListFileSystem::eventFolderSelect   = "folder-select";
-const char * const ewol::widget::ListFileSystem::eventFolderValidate = "folder-validate";
-
-
 ewol::widget::ListFileSystem::ListFileSystem() :
+  signalFileSelect(*this, "file-select"),
+  signalFileValidate(*this, "file-validate"),
+  signalFolderSelect(*this, "folder-select"),
+  signalFolderValidate(*this, "folder-validate"),
   m_selectedLine(-1),
   m_folder(*this, "path", "/", "Path to display"),
   m_selectFile(*this, "select", "", "selection af a specific file"),
@@ -40,11 +38,6 @@ ewol::widget::ListFileSystem::ListFileSystem() :
 		m_colorIdBackground2 = m_colorProperty->request("background2");
 		m_colorIdBackgroundSelected = m_colorProperty->request("selected");
 	}
-	addEventId(eventFileSelect);
-	addEventId(eventFileValidate);
-	addEventId(eventFolderSelect);
-	addEventId(eventFolderValidate);
-	
 	setMouseLimit(1);
 };
 
@@ -192,21 +185,21 @@ bool ewol::widget::ListFileSystem::onItemEvent(int32_t _IdInput,
 				if(    m_showFolder == true
 				    && m_selectedLine == 0) {
 					// "." folder
-					generateEventId(eventFolderSelect, ".");
+					signalFolderSelect.emit(shared_from_this(), ".");
 				} else if (    m_showFolder == true
 				            && m_selectedLine == 1) {
 					// ".." folder
-					generateEventId(eventFolderSelect, "..");
+					signalFolderSelect.emit(shared_from_this(), "..");
 				} else if(    m_selectedLine-offset  >= 0
 				           && m_selectedLine-offset < (int32_t)m_list.size()
 				           && nullptr != m_list[m_selectedLine-offset] ) {
 					// generate event extern : 
 					switch(m_list[m_selectedLine-offset]->getNodeType()) {
 						case etk::FSN_FILE :
-							generateEventId(eventFileSelect, m_list[m_selectedLine-offset]->getNameFile());
+							signalFileSelect.emit(shared_from_this(), m_list[m_selectedLine-offset]->getNameFile());
 							break;
 						case etk::FSN_FOLDER :
-							generateEventId(eventFolderSelect, m_list[m_selectedLine-offset]->getNameFile());
+							signalFolderSelect.emit(shared_from_this(), m_list[m_selectedLine-offset]->getNameFile());
 							break;
 						default:
 							EWOL_ERROR("Can not generate event on an unknow type");
@@ -217,21 +210,20 @@ bool ewol::widget::ListFileSystem::onItemEvent(int32_t _IdInput,
 				if(    m_showFolder == true
 				    && m_selectedLine == 0) {
 					// "." folder
-					generateEventId(eventFolderValidate, ".");
+					signalFolderValidate.emit(shared_from_this(), ".");
 				} else if (    m_showFolder == true
 				            && m_selectedLine == 1) {
 					// ".." folder
-					generateEventId(eventFolderValidate, "..");
+					signalFolderValidate.emit(shared_from_this(), "..");
 				} else if(    m_selectedLine-offset >= 0
 				           && m_selectedLine-offset < (int32_t)m_list.size()
 				           && nullptr != m_list[m_selectedLine-offset] ) {
-					switch(m_list[m_selectedLine-offset]->getNodeType())
-					{
+					switch(m_list[m_selectedLine-offset]->getNodeType()) {
 						case etk::FSN_FILE :
-							generateEventId(eventFileValidate, m_list[m_selectedLine-offset]->getNameFile());
+							signalFileValidate.emit(shared_from_this(), m_list[m_selectedLine-offset]->getNameFile());
 							break;
 						case etk::FSN_FOLDER :
-							generateEventId(eventFolderValidate, m_list[m_selectedLine-offset]->getNameFile());
+							signalFolderValidate.emit(shared_from_this(), m_list[m_selectedLine-offset]->getNameFile());
 							break;
 						default:
 							EWOL_ERROR("Can not generate event on an unknow type");
diff --git a/sources/ewol/widget/ListFileSystem.h b/sources/ewol/widget/ListFileSystem.h
index 3de039bf..49ce10f5 100644
--- a/sources/ewol/widget/ListFileSystem.h
+++ b/sources/ewol/widget/ListFileSystem.h
@@ -12,6 +12,7 @@
 #include <ewol/widget/List.h>
 #include <etk/os/FSNode.h>
 #include <ewol/resource/ColorFile.h>
+#include <ewol/object/Signal.h>
 
 namespace ewol {
 	namespace widget {
@@ -21,10 +22,10 @@ namespace ewol {
 		class ListFileSystem : public ewol::widget::List {
 			public:
 				// 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
-				static const char * const eventFolderSelect;
-				static const char * const eventFolderValidate;
+				ewol::object::Signal<std::string> signalFileSelect; //!< @event "file-select" Generated when a file is selected.
+				ewol::object::Signal<std::string> signalFileValidate; //!< @event "file-validate" Generate when the user validate (return) or double click on the element
+				ewol::object::Signal<std::string> signalFolderSelect;
+				ewol::object::Signal<std::string> signalFolderValidate;
 			protected:
 				ListFileSystem();
 				void init();
diff --git a/sources/ewol/widget/Menu.cpp b/sources/ewol/widget/Menu.cpp
index 94d310c5..b6cbb78d 100644
--- a/sources/ewol/widget/Menu.cpp
+++ b/sources/ewol/widget/Menu.cpp
@@ -60,6 +60,8 @@ int32_t ewol::widget::Menu::addTitle(std::string _label,
 	return add(-1, _label, _image, _generateEvent, _message);
 }
 
+static const char* eventButtonPressed = "menu-local-pressed";
+
 int32_t ewol::widget::Menu::add(int32_t _parent,
                                 std::string _label,
                                 std::string _image,
@@ -95,7 +97,7 @@ int32_t ewol::widget::Menu::add(int32_t _parent,
 		// add it in the widget list
 		ewol::widget::Sizer::subWidgetAdd(myButton);
 		// keep the specific event ...
-		myButton->registerOnEvent(shared_from_this(), ewol::widget::Button::eventPressed, widget::Button::eventPressed);
+		myButton->registerOnEvent(shared_from_this(), "pressed", eventButtonPressed);
 		tmpObject.m_widgetPointer = myButton;
 	}
 	m_listElement.push_back(tmpObject);
@@ -114,7 +116,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() == eventButtonPressed) {
 		for (auto &it : m_listElement) {
 			if (_msg.getCaller() == it.m_widgetPointer.lock()) {
 				// 2 posible case (have a message or have a child ...
@@ -215,7 +217,7 @@ void ewol::widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
 										}
 									}
 									// set the image if one is present ...
-									myButton->registerOnEvent(shared_from_this(), ewol::widget::Button::eventPressed, widget::Button::eventPressed);
+									myButton->registerOnEvent(shared_from_this(), "pressed", eventButtonPressed);
 									myButton->setExpand(bvec2(true,false));
 									myButton->setFill(bvec2(true,false));
 									// add it in the widget list
diff --git a/sources/ewol/widget/Slider.cpp b/sources/ewol/widget/Slider.cpp
index 0395da27..8dd4bf30 100644
--- a/sources/ewol/widget/Slider.cpp
+++ b/sources/ewol/widget/Slider.cpp
@@ -10,16 +10,14 @@
 
 #include <ewol/widget/Manager.h>
 
-const char * const ewol::widget::Slider::eventChange = "change";
-
 #undef __class__
 #define __class__ "Slider"
 
 const int32_t dotRadius = 6;
 
-ewol::widget::Slider::Slider() {
+ewol::widget::Slider::Slider() :
+  signalChange(*this, "change") {
 	addObjectType("ewol::widget::Slider");
-	addEventId(eventChange);
 	
 	m_value = 0;
 	m_min = 0;
@@ -109,7 +107,7 @@ bool ewol::widget::Slider::onEventInput(const ewol::event::Input& _event) {
 			m_value = std::max(std::min(m_value, m_max), m_min);
 			if (oldValue != m_value) {
 				EWOL_DEBUG(" new value : " << m_value << " in [" << m_min << ".." << m_max << "]");
-				generateEventId(eventChange, etk::to_string(m_value));
+				signalChange.emit(shared_from_this(), m_value);
 				markToRedraw();
 			}
 			return true;
diff --git a/sources/ewol/widget/Slider.h b/sources/ewol/widget/Slider.h
index 4d3dd1ee..d6f02210 100644
--- a/sources/ewol/widget/Slider.h
+++ b/sources/ewol/widget/Slider.h
@@ -14,6 +14,7 @@
 #include <ewol/debug.h>
 #include <ewol/widget/Widget.h>
 #include <ewol/compositing/Drawing.h>
+#include <ewol/object/Signal.h>
 
 namespace ewol {
 	namespace widget {
@@ -23,7 +24,7 @@ namespace ewol {
 		class Slider : public ewol::Widget {
 			public:
 				// Event list of properties
-				static const char * const eventChange;
+				ewol::object::Signal<int32_t> signalChange;
 			protected:
 				Slider();
 				void init();
diff --git a/sources/ewol/widget/WSlider.cpp b/sources/ewol/widget/WSlider.cpp
index 3b3159d6..0a9d7671 100644
--- a/sources/ewol/widget/WSlider.cpp
+++ b/sources/ewol/widget/WSlider.cpp
@@ -23,11 +23,9 @@ std::ostream& operator <<(std::ostream& _os, const enum ewol::widget::WSlider::s
 #undef __class__
 #define __class__ "WSlider"
 
-// Event list of properties
-const char* const ewol::widget::WSlider::eventStartSlide = "ewol-widget-wslider-event-start-slide";
-const char* const ewol::widget::WSlider::eventStopSlide = "ewol-widget-wslider-event-stop-slide";
-
 ewol::widget::WSlider::WSlider() :
+  signalStartSlide(*this, "start"),
+  signalStopSlide(*this, "stop"),
   m_windowsSources(0),
   m_windowsDestination(0),
   m_windowsRequested(-1),
@@ -36,8 +34,6 @@ ewol::widget::WSlider::WSlider() :
   m_transitionSpeed(*this, "speed", 1.0f, 0.0f, 200.0f, "Transition speed of the slider"),
   m_transitionSlide(*this, "mode", sladingTransitionHori, "Transition mode of the slider") {
 	addObjectType("ewol::widget::WSlider");
-	addEventId(eventStartSlide);
-	addEventId(eventStopSlide);
 	m_transitionSlide.add(sladingTransitionVert, "vert");
 	m_transitionSlide.add(sladingTransitionHori, "hori");
 }
@@ -105,7 +101,7 @@ void ewol::widget::WSlider::subWidgetSelectSetVectorId(int32_t _id) {
 	}
 	if (_id != m_windowsDestination) {
 		m_windowsRequested = _id;
-		generateEventId(eventStartSlide);
+		signalStartSlide.emit(shared_from_this());
 		periodicCallEnable();
 		markToRedraw();
 	}
@@ -189,7 +185,7 @@ void ewol::widget::WSlider::periodicCall(const ewol::event::Time& _event) {
 		} else {
 			// end of periodic :
 			periodicCallDisable();
-			generateEventId(eventStopSlide);
+			signalStopSlide.emit(shared_from_this());
 		}
 		m_windowsRequested = -1;
 	}
diff --git a/sources/ewol/widget/WSlider.h b/sources/ewol/widget/WSlider.h
index 5e56de7c..1deec94d 100644
--- a/sources/ewol/widget/WSlider.h
+++ b/sources/ewol/widget/WSlider.h
@@ -13,6 +13,7 @@
 #include <ewol/debug.h>
 #include <ewol/widget/ContainerN.h>
 #include <ewol/widget/Manager.h>
+#include <ewol/object/Signal.h>
 
 namespace ewol {
 	namespace widget {
@@ -22,8 +23,8 @@ namespace ewol {
 		class WSlider :public ewol::widget::ContainerN {
 			public:
 				// Event list of properties
-				static const char* const eventStartSlide;
-				static const char* const eventStopSlide;
+				ewol::object::Signal<void> signalStartSlide;
+				ewol::object::Signal<void> signalStopSlide;
 				enum sladingMode {
 					sladingTransitionVert,
 					sladingTransitionHori,
diff --git a/sources/ewol/widget/Widget.cpp b/sources/ewol/widget/Widget.cpp
index ef20011c..b59c72d6 100644
--- a/sources/ewol/widget/Widget.cpp
+++ b/sources/ewol/widget/Widget.cpp
@@ -86,11 +86,6 @@ std::ostream& ewol::operator <<(std::ostream& _os, const enum ewol::gravity _obj
 #undef __class__
 #define __class__ "Widget"
 
-// event generated :
-const char* const ewol::Widget::eventAnnimationStart = "annimation-start";
-const char* const ewol::Widget::eventAnnimationRatio = "annimation-ratio";
-const char* const ewol::Widget::eventAnnimationStop = "annimation-stop";
-
 ewol::Widget::Widget() :
   m_size(10,10),
   m_minSize(0,0),
@@ -113,6 +108,9 @@ ewol::Widget::Widget() :
   m_needRegenerateDisplay(true),
   m_grabCursor(false),
   m_cursorDisplay(ewol::context::cursorArrow),
+  signalAnnimationStart(*this, "annimation-start"),
+  signalAnnimationRatio(*this, "annimation-ratio"),
+  signalAnnimationStop(*this, "annimation-stop"),
   m_annimationMode(annimationModeDisable),
   m_annimationratio(0.0f),
   m_annimationTypeStart(*this, "annimation-start-type", 0, "Annimation type, when adding/show a widget"),
@@ -133,10 +131,6 @@ ewol::Widget::Widget() :
 	m_gravity.add(ewol::gravityLeft, "left");
 	m_annimationTypeStart.add(0, "none");
 	m_annimationTypeStop.add(0, "none");
-	
-	addEventId(eventAnnimationStart);
-	addEventId(eventAnnimationRatio);
-	addEventId(eventAnnimationStop);
 }
 
 void ewol::Widget::init() {
diff --git a/sources/ewol/widget/Widget.h b/sources/ewol/widget/Widget.h
index 2ec51867..032135c5 100644
--- a/sources/ewol/widget/Widget.h
+++ b/sources/ewol/widget/Widget.h
@@ -31,6 +31,7 @@ namespace ewol {
 #include <ewol/event/Entry.h>
 #include <ewol/event/Time.h>
 #include <ewol/translate.h>
+#include <ewol/object/Signal.h>
 
 #define ULTIMATE_MAX_SIZE  (99999999)
 
@@ -713,9 +714,9 @@ namespace ewol {
 		 */
 		public:
 			// event generated :
-			static const char* const eventAnnimationStart; //!< event when start annimation
-			static const char* const eventAnnimationRatio; //!< event when % of annimation change (integer)
-			static const char* const eventAnnimationStop;  //!< event when stop annimation
+			ewol::object::Signal<void> signalAnnimationStart; //!< event when start annimation
+			ewol::object::Signal<float> signalAnnimationRatio; //!< event when % of annimation change (integer)
+			ewol::object::Signal<void> signalAnnimationStop;  //!< event when stop annimation
 		protected:
 			enum annimationMode {
 				annimationModeEnableAdd,
diff --git a/sources/ewol/widget/meta/ColorChooser.cpp b/sources/ewol/widget/meta/ColorChooser.cpp
index ffd47df2..3972dfe1 100644
--- a/sources/ewol/widget/meta/ColorChooser.cpp
+++ b/sources/ewol/widget/meta/ColorChooser.cpp
@@ -22,17 +22,13 @@ extern "C" {
 #undef __class__
 #define __class__	"ColorChooser"
 
-
-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() :
+  signalChange(*this, "change") {
 	addObjectType("ewol::widget::ColorChooser");
-	addEventId(eventChange);
 }
 
 void ewol::widget::ColorChooser::init() {
@@ -140,7 +136,7 @@ void ewol::widget::ColorChooser::onReceiveMessage(const ewol::object::Message& _
 		if (nullptr != m_widgetAlpha) {
 			m_widgetAlpha->setValue(m_currentColor.a());
 		}
-		generateEventId(eventChange, m_currentColor.getString());
+		signalChange.emit(shared_from_this(), m_currentColor);
 	} else if (eventColorSpecificHasChange == _msg.getMessage()) {
 		// Slider has changes his color  == > get the one change ...
 		if (_msg.getCaller() == m_widgetRed) {
@@ -158,7 +154,7 @@ void ewol::widget::ColorChooser::onReceiveMessage(const ewol::object::Message& _
 		if (nullptr != m_widgetColorBar) {
 			m_widgetColorBar->setCurrentColor(m_currentColor);
 		}
-		generateEventId(eventChange, m_currentColor.getString());
+		signalChange.emit(shared_from_this(), m_currentColor);
 	}
 };
 
diff --git a/sources/ewol/widget/meta/ColorChooser.h b/sources/ewol/widget/meta/ColorChooser.h
index 187f5731..445b081b 100644
--- a/sources/ewol/widget/meta/ColorChooser.h
+++ b/sources/ewol/widget/meta/ColorChooser.h
@@ -18,6 +18,7 @@
 #include <ewol/widget/Sizer.h>
 #include <ewol/widget/ColorBar.h>
 #include <ewol/widget/Slider.h>
+#include <ewol/object/Signal.h>
 
 namespace ewol {
 	namespace widget {
@@ -27,7 +28,7 @@ namespace ewol {
 		class ColorChooser : public ewol::widget::Sizer {
 			public:
 				// Event list of properties
-				static const char * const eventChange;
+				ewol::object::Signal<etk::Color<>> signalChange;
 			protected:
 				ColorChooser();
 				void init();
diff --git a/sources/ewol/widget/meta/FileChooser.cpp b/sources/ewol/widget/meta/FileChooser.cpp
index d716c73b..16c3d5c7 100644
--- a/sources/ewol/widget/meta/FileChooser.cpp
+++ b/sources/ewol/widget/meta/FileChooser.cpp
@@ -30,9 +30,8 @@ extern "C" {
 #define __class__ "FileChooser"
 
 
-const char * const ewol::widget::FileChooser::eventCancel     = "cancel";
-const char * const ewol::widget::FileChooser::eventValidate   = "validate";
-
+static const char * const ewolEventFileChooserCancel           = "ewol-event-file-chooser-cancel";
+static const char * const ewolEventFileChooserValidate         = "ewol-event-file-chooser-validate";
 static const char * const ewolEventFileChooserHidenFileChange  = "ewol-event-file-chooser-Show/Hide-hiden-Files";
 static const char * const ewolEventFileChooserEntryFolder      = "ewol-event-file-chooser-modify-entry-folder";
 static const char * const ewolEventFileChooserEntryFolderEnter = "ewol-event-file-chooser-modify-entry-folder-enter";
@@ -44,10 +43,10 @@ static const char * const ewolEventFileChooserListFileValidate = "ewol-event-fil
 static const char * const ewolEventFileChooserHome             = "ewol-event-file-chooser-home";
 
 
-ewol::widget::FileChooser::FileChooser() {
+ewol::widget::FileChooser::FileChooser() :
+  signalCancel(*this, "cancel"),
+  signalValidate(*this, "validate") {
 	addObjectType("ewol::widget::FileChooser");
-	addEventId(eventCancel);
-	addEventId(eventValidate);
 }
 
 void ewol::widget::FileChooser::init() {
@@ -107,8 +106,8 @@ void ewol::widget::FileChooser::init() {
 	      + "</popup>";
 	loadFromString(myDescription);
 	registerOnEventNameWidget("[" + etk::to_string(getId()) + "]file-shooser:show-hiden-file", "value", ewolEventFileChooserHidenFileChange);
-	registerOnEventNameWidget("[" + etk::to_string(getId()) + "]file-shooser:button-validate", "pressed", eventValidate);
-	registerOnEventNameWidget("[" + etk::to_string(getId()) + "]file-shooser:button-cancel", "pressed", eventCancel);
+	registerOnEventNameWidget("[" + etk::to_string(getId()) + "]file-shooser:button-validate", "pressed", ewolEventFileChooserValidate);
+	registerOnEventNameWidget("[" + etk::to_string(getId()) + "]file-shooser:button-cancel", "pressed", ewolEventFileChooserCancel);
 	registerOnEventNameWidget("[" + etk::to_string(getId()) + "]file-shooser:list-folder", "folder-validate", ewolEventFileChooserListFolder);
 	registerOnEventNameWidget("[" + etk::to_string(getId()) + "]file-shooser:list-files", "file-select", ewolEventFileChooserListFile);
 	registerOnEventNameWidget("[" + etk::to_string(getId()) + "]file-shooser:list-files", "file-validate", ewolEventFileChooserListFileValidate);
@@ -163,9 +162,9 @@ void ewol::widget::FileChooser::onReceiveMessage(const ewol::object::Message& _m
 		m_file = _msg.getData();
 		// update the selected file in the list :
 		parameterSetOnWidgetNamed("[" + etk::to_string(getId()) + "]file-shooser:list-files", "select", m_file);
-	} else if (eventCancel == _msg.getMessage()) {
+	} else if (ewolEventFileChooserCancel == _msg.getMessage()) {
 		// == > Auto remove ...
-		generateEventId(_msg.getMessage());
+		signalCancel.emit(shared_from_this());
 		autoDestroy();
 	} else if (_msg.getMessage() == ewolEventFileChooserHidenFileChange) {
 		if (_msg.getData() == "true") {
@@ -187,16 +186,16 @@ void ewol::widget::FileChooser::onReceiveMessage(const ewol::object::Message& _m
 		setFileName(_msg.getData());
 		std::string tmpFileCompleatName = m_folder;
 		tmpFileCompleatName += m_file;
-		generateEventId(_msg.getMessage(), tmpFileCompleatName);
+		// TODO : generateEventId(_msg.getMessage(), tmpFileCompleatName);
 	} else if(     _msg.getMessage() == ewolEventFileChooserListFileValidate 
-	           || (_msg.getMessage() == eventValidate && m_file != "" )
+	           || (_msg.getMessage() == ewolEventFileChooserValidate && m_file != "" )
 	           || (_msg.getMessage() == ewolEventFileChooserEntryFileEnter && m_file != "" ) ) {
 		// select the file  == > generate a validate
 		if (_msg.getData() != "") {
 			setFileName(_msg.getData());
 		}
 		EWOL_VERBOSE(" generate a fiel opening : \"" << m_folder << "\" / \"" << m_file << "\"");
-		generateEventId(eventValidate, getCompleateFileName());
+		signalValidate.emit(shared_from_this(), getCompleateFileName());
 		autoDestroy();
 	} else if(_msg.getMessage() == ewolEventFileChooserHome) {
 		std::string tmpUserFolder = etk::getUserHomeFolder();
diff --git a/sources/ewol/widget/meta/FileChooser.h b/sources/ewol/widget/meta/FileChooser.h
index aab643b2..eaa9b806 100644
--- a/sources/ewol/widget/meta/FileChooser.h
+++ b/sources/ewol/widget/meta/FileChooser.h
@@ -12,6 +12,7 @@
 #include <etk/types.h>
 #include <ewol/debug.h>
 #include <ewol/widget/Composer.h>
+#include <ewol/object/Signal.h>
 
 namespace ewol {
 	namespace widget {
@@ -74,8 +75,8 @@ namespace ewol {
 		class FileChooser : public ewol::widget::Composer {
 			public:
 				// Event list of properties
-				static const char* const eventCancel;
-				static const char* const eventValidate;
+				ewol::object::Signal<void> signalCancel;
+				ewol::object::Signal<std::string> signalValidate;
 			protected:
 				FileChooser();
 				void init();
diff --git a/sources/ewol/widget/meta/Parameter.cpp b/sources/ewol/widget/meta/Parameter.cpp
index 7d84aae0..9825fc25 100644
--- a/sources/ewol/widget/meta/Parameter.cpp
+++ b/sources/ewol/widget/meta/Parameter.cpp
@@ -20,19 +20,17 @@
 
 #undef __class__
 #define __class__ "Parameter"
-
-const char * const ewol::widget::Parameter::eventClose = "close";
-
 static const char * const ewolEventParameterValidate = "ewol-event-parameter-validate";
 static const char * const ewolEventParameterSave     = "ewol-event-parameter-save";
 static const char * const l_eventMenuSelected = "local-event-menu-selected";
+static const char * const ewolEventMenuclosed = "local-event-menu-closed";
 
 ewol::widget::Parameter::Parameter() :
+  signalClose(*this, "close"),
   m_currentIdList(0),
   m_widgetTitle(),
   m_paramList() {
 	addObjectType("ewol::widget::Parameter");
-	addEventId(eventClose);
 }
 
 void ewol::widget::Parameter::init() {
@@ -106,7 +104,7 @@ void ewol::widget::Parameter::init() {
 				        "		<label>Close</label>\n"
 				        "	</sizer>\n"
 				        "</composer>\n"));
-				tmpButton->registerOnEvent(shared_from_this(), "pressed", eventClose);
+				tmpButton->registerOnEvent(shared_from_this(), "pressed", ewolEventMenuclosed);
 				mySizerHori->subWidgetAdd(tmpButton);
 			}
 		}
@@ -200,9 +198,9 @@ void ewol::widget::Parameter::setTitle(std::string _label) {
 void ewol::widget::Parameter::onReceiveMessage(const ewol::object::Message& _msg) {
 	ewol::widget::PopUp::onReceiveMessage(_msg);
 	EWOL_DEBUG("event on the parameter : " << _msg);
-	if (_msg.getMessage() == eventClose) {
+	if (_msg.getMessage() == ewolEventMenuclosed) {
 		// inform that the parameter windows is closed
-		generateEventId(eventClose);
+		signalClose.emit(shared_from_this());
 		// close this widget ...
 		autoDestroy();
 	} else if (_msg.getMessage() == ewolEventParameterSave) {
diff --git a/sources/ewol/widget/meta/Parameter.h b/sources/ewol/widget/meta/Parameter.h
index 1adc531a..a8ad5d6b 100644
--- a/sources/ewol/widget/meta/Parameter.h
+++ b/sources/ewol/widget/meta/Parameter.h
@@ -29,7 +29,7 @@ namespace ewol {
 		class Parameter : public ewol::widget::PopUp {
 			public:
 				// Event list of properties
-				static const char * const eventClose;
+				ewol::object::Signal<void> signalClose;
 			protected:
 				Parameter();
 				void init();
diff --git a/sources/ewol/widget/meta/ParameterList.cpp b/sources/ewol/widget/meta/ParameterList.cpp
index b32286ec..29ef9695 100644
--- a/sources/ewol/widget/meta/ParameterList.cpp
+++ b/sources/ewol/widget/meta/ParameterList.cpp
@@ -15,15 +15,13 @@
 #include <ewol/compositing/Text.h>
 #include <ewol/widget/Manager.h>
 
-const char * const ewol::widget::ParameterList::eventSelect = "select";
-
 #undef __class__
 #define __class__ "List"
 
 
-ewol::widget::ParameterList::ParameterList() {
+ewol::widget::ParameterList::ParameterList() :
+  signalSelect(*this, "select") {
 	addObjectType("ewol::widget::ParameterList");
-	addEventId(eventSelect);
 	
 	m_idSelected = -1;
 	m_paddingSizeX = 2;
@@ -192,7 +190,7 @@ bool ewol::widget::ParameterList::onEventInput(const ewol::event::Input& _event)
 		if (rawID >= 0 && (size_t)rawID < m_list.size()) {
 			if (m_list[rawID]!=nullptr) {
 				if (m_list[rawID]->m_refId >= 0) {
-					generateEventId(eventSelect, etk::to_string(m_list[rawID]->m_refId));
+					signalSelect.emit(shared_from_this(), m_list[rawID]->m_refId);
 					m_idSelected = rawID;
 					markToRedraw();
 					return true;
diff --git a/sources/ewol/widget/meta/ParameterList.h b/sources/ewol/widget/meta/ParameterList.h
index 4def9ec2..df6d026b 100644
--- a/sources/ewol/widget/meta/ParameterList.h
+++ b/sources/ewol/widget/meta/ParameterList.h
@@ -39,7 +39,7 @@ namespace ewol {
 		class ParameterList :public ewol::widget::WidgetScrolled {
 			public:
 				// Event list of properties
-				static const char * const eventSelect;
+				ewol::object::Signal<int32_t> signalSelect;
 			private:
 				int32_t m_idSelected;
 				std::vector<ewol::widget::elementPL *> m_list;
diff --git a/sources/ewol/widget/meta/StdPopUp.cpp b/sources/ewol/widget/meta/StdPopUp.cpp
index 53b37a46..7a10b83a 100644
--- a/sources/ewol/widget/meta/StdPopUp.cpp
+++ b/sources/ewol/widget/meta/StdPopUp.cpp
@@ -107,7 +107,7 @@ std::shared_ptr<ewol::widget::Button> ewol::widget::StdPopUp::addButton(const st
 	}
 	myButton->setSubWidget(ewol::widget::Label::create(_text));
 	if(_autoExit == true) {
-		myButton->registerOnEvent(shared_from_this(), ewol::widget::Button::eventPressed, eventButtonExit);
+		myButton->registerOnEvent(shared_from_this(), "pressed", eventButtonExit);
 	}
 	m_subBar->subWidgetAdd(myButton);
 	markToRedraw();