[DEV] add capabilities at the WSlider widget'

sources/ewol/widget/ContainerN.cpp

@@ -55,11 +55,11 @@ void widget::ContainerN::LockExpand(const bvec2& _lockExpand)
 }
 
 
-void widget::ContainerN::SubWidgetAdd(ewol::Widget* _newWidget)
+int32_t widget::ContainerN::SubWidgetAdd(ewol::Widget* _newWidget)
 {
 	if (NULL == _newWidget) {
 		EWOL_ERROR("[" << GetId() << "] {" << GetObjectType() << "} Try to add An empty Widget ... ");
-		return;
+		return -1;
 	}
 	if (_newWidget!=NULL) {
 		_newWidget->SetUpperWidget(this);
@@ -67,6 +67,8 @@ void widget::ContainerN::SubWidgetAdd(ewol::Widget* _newWidget)
 	m_subWidget.PushBack(_newWidget);
 	MarkToRedraw();
 	ewol::RequestUpdateSize();
+	// added at the last eelement :
+	return m_subWidget.Size()-1;
 }
 
 void widget::ContainerN::SubWidgetAddStart(ewol::Widget* _newWidget)

sources/ewol/widget/ContainerN.h

@@ -55,9 +55,9 @@ namespace widget
 			 * @brief Add at end position a Widget (note : This system use an inverted phylisophie (button to top, and left to right)
 			 * @param[in] _newWidget the element pointer
 			 */
-			virtual void SubWidgetAdd(ewol::Widget* _newWidget);
+			virtual int32_t SubWidgetAdd(ewol::Widget* _newWidget);
-			inline  void SubWidgetAddBack(ewol::Widget* _newWidget) { SubWidgetAdd(_newWidget); };
+			inline  int32_t SubWidgetAddBack(ewol::Widget* _newWidget) { return SubWidgetAdd(_newWidget); };
-			inline  void SubWidgetAddEnd(ewol::Widget* _newWidget)  { SubWidgetAdd(_newWidget); };
+			inline  int32_t SubWidgetAddEnd(ewol::Widget* _newWidget)  { return SubWidgetAdd(_newWidget); };
 			/**
 			 * @brief Add at start position a Widget (note : This system use an inverted phylisophie (button to top, and left to right)
 			 * @param[in] _newWidget the element pointer

sources/ewol/widget/Menu.cpp

@@ -36,17 +36,18 @@ void widget::Menu::SubWidgetRemoveAll(void)
 	widget::Sizer::SubWidgetRemoveAll();
 }
 
-void widget::Menu::SubWidgetAdd(ewol::Widget* newWidget)
+int32_t widget::Menu::SubWidgetAdd(ewol::Widget* _newWidget)
+{
+	EWOL_ERROR("Not availlable");
+	return -1;
+}
+
+void widget::Menu::SubWidgetRemove(ewol::Widget* _newWidget)
 {
 	EWOL_ERROR("Not availlable");
 }
 
-void widget::Menu::SubWidgetRemove(ewol::Widget* newWidget)
+void widget::Menu::SubWidgetUnLink(ewol::Widget* _newWidget)
-{
-	EWOL_ERROR("Not availlable");
-}
-
-void widget::Menu::SubWidgetUnLink(ewol::Widget* newWidget)
 {
 	EWOL_ERROR("Not availlable");
 }

sources/ewol/widget/Menu.h

@@ -38,9 +38,9 @@ namespace widget {
 			virtual const char * const GetObjectType(void) { return "EwolMenu"; };
 		private:
 			virtual void SubWidgetRemoveAll(void);
-			virtual void SubWidgetAdd(ewol::Widget* newWidget);
+			virtual int32_t SubWidgetAdd(ewol::Widget* _newWidget);
-			virtual void SubWidgetRemove(ewol::Widget* newWidget);
+			virtual void SubWidgetRemove(ewol::Widget* _newWidget);
-			virtual void SubWidgetUnLink(ewol::Widget* newWidget);
+			virtual void SubWidgetUnLink(ewol::Widget* _newWidget);
 		private:
 			etk::Vector<widget::MenuElement*> m_listElement;
 			int32_t m_staticId; // unique ID for every element of the menu ...

sources/ewol/widget/WSlider.cpp

@@ -11,51 +11,108 @@
 #include <ewol/ewol.h>
 
 
+static const char* l_listsladingMode[widget::WSlider::sladingTransition_count] = {
+	"transition vertical",
+	"transition horisantal"
+};
+
+etk::CCout& operator <<(etk::CCout& _os, const widget::WSlider::sladingMode_te _obj)
+{
+	_os << l_listsladingMode[_obj];
+	return _os;
+}
+
 #undef __class__
 #define __class__	"WSlider"
 
 
-widget::WSlider::WSlider(void)
+
+// Event list of properties
+const char* const widget::WSlider::eventStartSlide = "ewol-widget-wslider-event-start-slide";
+const char* const widget::WSlider::eventStopSlide = "ewol-widget-wslider-event-stop-slide";
+// Config list of properties
+const char* const widget::WSlider::configMode = "mode";
+
+
+static ewol::Widget* Create(void)
 {
-	// set contamination enable
+	return new widget::WSlider();
-	LockExpandContamination(bvec2(false,false));
+}
-	m_windowsDestination = 0;
+
-	m_slidingProgress = 0;
+void widget::WSlider::Init(void)
-	m_windowsSources = 0;
+{
-	m_underExpand.setValue(false,false);
+	ewol::widgetManager::AddWidgetCreator(__class__,&Create);
+}
+
+void widget::WSlider::UnInit(void)
+{
+	ewol::widgetManager::AddWidgetCreator(__class__,NULL);
+}
+
+widget::WSlider::WSlider(void) : 
+	m_windowsSources(0),
+	m_windowsDestination(0),
+	m_slidingProgress(0.0f),
+	m_transitionSpeed(1.0f),
+	m_transitionSlide(sladingTransitionHori)
+{
+	AddEventId(eventStartSlide);
+	AddEventId(eventStopSlide);
+	// Add configuration
+	RegisterConfig(configMode, "list", "vert;hori", "Transition mode of the slider");
 }
 
 widget::WSlider::~WSlider(void)
 {
-	SubWidgetRemoveAll();
+	
 }
 
 
-void widget::WSlider::CalculateSize(const vec2& availlable)
+void widget::WSlider::CalculateSize(const vec2& _availlable)
 {
 	//EWOL_DEBUG("Update Size");
-	m_size = availlable;
+	widget::ContainerN::CalculateSize(_availlable);
 	
 	if (m_windowsDestination == m_windowsSources) {
 		int32_t iii = m_windowsDestination;
 		if (iii < m_subWidget.Size()) {
 			if (NULL != m_subWidget[iii]) {
-				m_subWidget[iii]->SetOrigin(m_origin);
+				m_subWidget[iii]->SetOrigin(m_origin+m_offset);
 				m_subWidget[iii]->CalculateSize(m_size);
 			}
 		}
 	} else {
+		float factor = -1.0f;
+		if (m_windowsSources < m_windowsDestination) {
+			factor = 1.0f;
+		}
 		int32_t iii = m_windowsSources;
 		if (iii < m_subWidget.Size()) {
 			if (NULL != m_subWidget[iii]) {
-				m_subWidget[iii]->SetOrigin(vec2(m_origin.x() - (m_size.x()*(float)m_slidingProgress/1000.0),  m_origin.y()));
+				if (m_transitionSlide == sladingTransitionHori) {
+					m_subWidget[iii]->SetOrigin(   vec2(m_origin.x() + factor*(m_size.x()*m_slidingProgress),
+					                                    m_origin.y())
+					                             + m_offset);
+				} else {
+					m_subWidget[iii]->SetOrigin(   vec2(m_origin.x(),
+					                                    m_origin.y() + factor*(m_size.y()*m_slidingProgress))
+					                             + m_offset);
+				}
 				m_subWidget[iii]->CalculateSize(m_size);
 			}
 		}
 		iii = m_windowsDestination;
 		if (iii < m_subWidget.Size()) {
 			if (NULL != m_subWidget[iii]) {
-				m_subWidget[iii]->SetOrigin(vec2(m_origin.x() - (m_size.x()*((float)m_slidingProgress/1000.0) - m_size.x()),  m_origin.y()));
+				if (m_transitionSlide == sladingTransitionHori) {
+					m_subWidget[iii]->SetOrigin(   vec2(m_origin.x() + factor*(m_size.x()*m_slidingProgress - m_size.x()),
+					                                    m_origin.y())
+					                             + m_offset);
+				} else {
+					m_subWidget[iii]->SetOrigin(   vec2(m_origin.x(),
+					                                    m_origin.y() + factor*(m_size.y()*m_slidingProgress - m_size.y()))
+					                             + m_offset);
+				}
 				m_subWidget[iii]->CalculateSize(m_size);
 			}
 		}
@@ -63,134 +120,79 @@ void widget::WSlider::CalculateSize(const vec2& availlable)
 	MarkToRedraw();
 }
 
-
+void widget::WSlider::SubWidgetSelectSet(int32_t _id)
-void widget::WSlider::CalculateMinMaxSize(void)
 {
-	EWOL_DEBUG("Calculate MinSize");
+	if (_id<0 || _id >= m_subWidget.Size()) {
-	m_underExpand.setValue(false,false);
-	m_minSize.setValue(0,0);
-	for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
-		if (NULL != m_subWidget[iii]) {
-			m_subWidget[iii]->CalculateMinMaxSize();
-			if (true == m_subWidget[iii]->CanExpand().x()) {
-				m_underExpand.setX(true);
-			}
-			if (true == m_subWidget[iii]->CanExpand().y()) {
-				m_underExpand.setY(true);
-			}
-			vec2 tmpSize = m_subWidget[iii]->GetCalculateMinSize();
-			m_minSize.setValue(etk_max(tmpSize.x(), m_minSize.x()),
-			                   etk_max(tmpSize.y(), m_minSize.y()));
-		}
-	}
-}
-
-void widget::WSlider::SetMinSize(const vec2& size)
-{
-	EWOL_ERROR("Layer can not have a user Minimum size (herited from under elements)");
-}
-
-bvec2 widget::WSlider::CanExpand(void)
-{
-	bvec2 res = m_userExpand;
-	if (true == m_underExpand.x()) {
-		res.setX(true);
-	}
-	if (true == m_underExpand.y()) {
-		res.setY(true);
-	}
-	if (true == m_lockExpandContamination.x()) {
-		res.setX(false);
-	}
-	if (true == m_lockExpandContamination.y()) {
-		res.setY(false);
-	}
-	return res;
-}
-
-void widget::WSlider::LockExpandContamination(const bvec2& lockExpand)
-{
-	m_lockExpandContamination = lockExpand;
-}
-
-//etk::Vector<ewol::Widget*> m_SubWidget;
-
-void widget::WSlider::SubWidgetRemoveAll(void)
-{
-	for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
-		delete(m_subWidget[iii]);
-		m_subWidget[iii] = NULL;
-	}
-	m_subWidget.Clear();
-}
-
-
-int32_t widget::WSlider::SubWidgetAdd(ewol::Widget* newWidget)
-{
-	if (NULL == newWidget) {
-		return -1;
-	}
-	m_subWidget.PushBack(newWidget);
-	MarkToRedraw();
-	ewol::RequestUpdateSize();
-	return m_subWidget.Size()-1;
-}
-
-
-void widget::WSlider::SubWidgetRemove(ewol::Widget* newWidget)
-{
-	if (NULL == newWidget) {
-		return;
-	}
-	for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
-		if (newWidget == m_subWidget[iii]) {
-			delete(m_subWidget[iii]);
-			m_subWidget[iii] = NULL;
-			m_subWidget.Erase(iii);
-			MarkToRedraw();
-			ewol::RequestUpdateSize();
-			return;
-		}
-	}
-}
-
-void widget::WSlider::SubWidgetUnLink(ewol::Widget* newWidget)
-{
-	if (NULL == newWidget) {
-		return;
-	}
-	for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
-		if (newWidget == m_subWidget[iii]) {
-			m_subWidget[iii] = NULL;
-			m_subWidget.Erase(iii);
-			ewol::RequestUpdateSize();
-			MarkToRedraw();
-			return;
-		}
-	}
-}
-
-void widget::WSlider::SubWidgetSelectSet(int32_t id)
-{
-	if (id<0 || id > m_subWidget.Size()) {
 		EWOL_ERROR("Can not change to a widget not present");
 	}
-	m_windowsDestination = id;
+	m_windowsDestination = _id;
 	m_slidingProgress = 0;
+	GenerateEventId(eventStartSlide);
 	PeriodicCallSet(true);
 	MarkToRedraw();
 }
 
-
+void widget::WSlider::SubWidgetSelectSet(ewol::Widget* _widgetPointer)
-void widget::WSlider::PeriodicCall(int64_t localTime)
 {
-	if (m_slidingProgress >= 1000) {
+	if (_widgetPointer == NULL) {
+		EWOL_ERROR("Can not change to a widget NULL");
+		return;
+	}
+	for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
+		if (m_subWidget[iii] != NULL) {
+			if (m_subWidget[iii] == _widgetPointer) {
+				SubWidgetSelectSet(iii);
+				return;
+			}
+		}
+	}
+	EWOL_ERROR("Can not change to a widget not present");
+}
+
+void widget::WSlider::SubWidgetSelectSet(const etk::UString& _widgetName)
+{
+	if (_widgetName == "") {
+		EWOL_ERROR("Can not change to a widget with no name (input)");
+		return;
+	}
+	for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
+		if (m_subWidget[iii] != NULL) {
+			if (m_subWidget[iii]->GetName() == _widgetName) {
+				SubWidgetSelectSet(iii);
+				return;
+			}
+		}
+	}
+	EWOL_ERROR("Can not change to a widget not present");
+}
+
+
+
+void widget::WSlider::SetTransitionMode(widget::WSlider::sladingMode_te _mode)
+{
+	if (m_transitionSlide != _mode) {
+		m_transitionSlide = _mode;
+		MarkToRedraw();
+	}
+}
+
+
+
+void widget::WSlider::PeriodicCall(int64_t _localTime)
+{
+	if (m_slidingProgress >= 1.0) {
 		// end of periodic :
 		PeriodicCallSet(false);
 		m_windowsSources = m_windowsDestination;
+		m_lastPeriodicCall = -1;
+		GenerateEventId(eventStopSlide);
 	} else {
-		m_slidingProgress += 30;
+		if (m_lastPeriodicCall != -1) {
-		m_slidingProgress = etk_avg(0, m_slidingProgress, 1000);
+			float delta = (double)(_localTime - m_lastPeriodicCall)/1000000.0;
+			m_slidingProgress += m_transitionSpeed*delta;
+			m_slidingProgress = etk_avg(0.0f, m_slidingProgress, 1.0f);
+		}
+		m_lastPeriodicCall = _localTime;
 	}
 	CalculateSize(m_size);
 	MarkToRedraw();
@@ -199,105 +201,106 @@ void widget::WSlider::PeriodicCall(int64_t localTime)
 
 void widget::WSlider::SystemDraw(const ewol::DrawProperty& _displayProp)
 {
+	if (true==m_hide){
+		// widget is hidden ...
+		return;
+	}
+	// note : do not call the widget container ==> overload this one ...
 	ewol::Widget::SystemDraw(_displayProp);
+	
+	// subwidget draw
+	ewol::DrawProperty prop = _displayProp;
+	prop.Limit(m_origin, m_size);
+	
 	if (m_windowsDestination == m_windowsSources) {
 		//EWOL_DEBUG("Draw : " << m_windowsDestination);
 		int32_t iii = m_windowsDestination;
-		if (iii<0 || iii > m_subWidget.Size()) {
+		if (iii>=0 || iii < m_subWidget.Size()) {
-			return;
+			if (NULL != m_subWidget[iii]) {
-		}
+				m_subWidget[iii]->SystemDraw(prop);
-		if (NULL != m_subWidget[iii]) {
+			}
-			m_subWidget[iii]->SystemDraw(_displayProp);
 		}
 	} else {
 		//EWOL_DEBUG("Draw : " << m_windowsSources << "=>" << m_windowsDestination << "progress=" << ((float)m_slidingProgress/1000.) );
 		// draw Sources :
 		int32_t iii = m_windowsSources;
-		if (iii<0 || iii > m_subWidget.Size()) {
+		if (iii>=0 || iii < m_subWidget.Size()) {
-			return;
+			if (NULL != m_subWidget[iii]) {
-		}
+				m_subWidget[iii]->SystemDraw(prop);
-		if (NULL != m_subWidget[iii]) {
+			}
-			m_subWidget[iii]->SystemDraw(_displayProp);
 		}
 		// Draw Destination : 
 		iii = m_windowsDestination;
-		if (iii<0 || iii > m_subWidget.Size()) {
+		if (iii>=0 || iii < m_subWidget.Size()) {
-			return;
+			if (NULL != m_subWidget[iii]) {
-		}
+				m_subWidget[iii]->SystemDraw(prop);
-		if (NULL != m_subWidget[iii]) {
+			}
-			m_subWidget[iii]->SystemDraw(_displayProp);
 		}
 	}
 }
 
-
 void widget::WSlider::OnRegenerateDisplay(void)
 {
 	if (m_windowsDestination == m_windowsSources) {
 		int32_t iii = m_windowsDestination;
-		if (iii<0 || iii > m_subWidget.Size()) {
+		if (iii>=0 || iii < m_subWidget.Size()) {
-			return;
+			if (NULL != m_subWidget[iii]) {
-		}
+				m_subWidget[iii]->OnRegenerateDisplay();
-		if (NULL != m_subWidget[iii]) {
+			}
-			m_subWidget[iii]->OnRegenerateDisplay();
 		}
 	} else {
 		int32_t iii = m_windowsSources;
-		if (iii<0 || iii > m_subWidget.Size()) {
+		if (iii>=0 || iii < m_subWidget.Size()) {
-			return;
+			if (NULL != m_subWidget[iii]) {
-		}
+				m_subWidget[iii]->OnRegenerateDisplay();
-		if (NULL != m_subWidget[iii]) {
+			}
-			m_subWidget[iii]->OnRegenerateDisplay();
 		}
 		iii = m_windowsDestination;
-		if (iii<0 || iii > m_subWidget.Size()) {
+		if (iii>=0 || iii < m_subWidget.Size()) {
-			return;
+			if (NULL != m_subWidget[iii]) {
-		}
+				m_subWidget[iii]->OnRegenerateDisplay();
-		if (NULL != m_subWidget[iii]) {
-			m_subWidget[iii]->OnRegenerateDisplay();
-		}
-	}
-}
-
-
-ewol::Widget * widget::WSlider::GetWidgetAtPos(const vec2& pos)
-{
-	// TODO : Review this ...
-	if (m_windowsDestination<0 || m_windowsDestination > m_subWidget.Size()) {
-		// error ...
-		return NULL;
-	}
-	int32_t iii = m_windowsDestination;
-	
-	if (NULL != m_subWidget[iii]) {
-		vec2 tmpSize = m_subWidget[iii]->GetSize();
-		vec2 tmpOrigin = m_subWidget[iii]->GetOrigin();
-		if(    (tmpOrigin.x() <= pos.x() && tmpOrigin.x() + tmpSize.x() >= pos.x())
-		    && (tmpOrigin.y() <= pos.y() && tmpOrigin.y() + tmpSize.y() >= pos.y()) )
-		{
-			ewol::Widget * tmpWidget = m_subWidget[iii]->GetWidgetAtPos(pos);
-			if (NULL != tmpWidget) {
-				return tmpWidget;
 			}
 		}
 	}
-	// otherwise the event go to this widget ...
-	return this;
 }
 
 
-void widget::WSlider::OnObjectRemove(ewol::EObject * removeObject)
+bool widget::WSlider::OnSetConfig(const ewol::EConfig& _conf)
 {
-	// First step call parrent : 
+	if (true == widget::ContainerN::OnSetConfig(_conf)) {
-	ewol::Widget::OnObjectRemove(removeObject);
+		return true;
-	// second step find if in all the elements ...
-	for(int32_t iii=m_subWidget.Size()-1; iii>=0; iii--) {
-		if(m_subWidget[iii] == removeObject) {
-			EWOL_DEBUG("Remove sizer sub Element [" << iii << "] ==> destroyed object");
-			m_subWidget[iii] = NULL;
-			m_subWidget.Erase(iii);
-		}
 	}
+	if (_conf.GetConfig() == configMode) {
+		sladingMode_te tmpTransition = sladingTransitionHori;
+		if(true == _conf.GetData().CompareNoCase("vert")) {
+			tmpTransition = sladingTransitionVert;
+		} else if(true == _conf.GetData().CompareNoCase("hori")) {
+			tmpTransition = sladingTransitionHori;
+		}
+		SetTransitionMode(tmpTransition);
+		return true;
+	}
+	return false;
+}
+
+bool widget::WSlider::OnGetConfig(const char* _config, etk::UString& _result) const
+{
+	if (true == widget::ContainerN::OnGetConfig(_config, _result)) {
+		return true;
+	}
+	if (_config == configMode) {
+		switch(m_transitionSlide){
+			default:
+			case sladingTransitionHori:
+				_result = "hori";
+				break;
+			case sladingTransitionVert:
+				_result = "vert";
+				break;
+		}
+		return true;
+	}
+	return false;
 }
 
 

sources/ewol/widget/WSlider.h

@@ -11,47 +11,73 @@
 
 #include <etk/types.h>
 #include <ewol/debug.h>
-#include <ewol/widget/Widget.h>
+#include <ewol/widget/ContainerN.h>
+
 
 namespace widget {
-	class WSlider :public ewol::Widget
+	class WSlider :public widget::ContainerN
 	{
+		public:
+			static void Init(void);
+			static void UnInit(void);
+			// Event list of properties
+			static const char* const eventStartSlide;
+			static const char* const eventStopSlide;
+			// Config list of properties
+			static const char* const configMode;
+			typedef enum {
+				sladingTransitionVert,
+				sladingTransitionHori,
+				sladingTransition_count,
+			} sladingMode_te;
 		public:
 			WSlider(void);
 			virtual ~WSlider(void);
-			// Derived function
-			virtual const char * const GetObjectType(void) { return "EwolWSlider"; };
 		private:
-			bvec2 m_underExpand; // expand of the uner elements ...
+			int32_t m_windowsSources; //!< widget source viewed
+			int32_t m_windowsDestination; //!< widget destinated viewed
+			float m_slidingProgress; //!< ratio progression of a sliding
+			int64_t m_lastPeriodicCall;
+			float m_transitionSpeed; //!< speed of the transition (default 1 ==> 1s)
+			sladingMode_te m_transitionSlide; //!< mode to slide the widgets
 		public:
-			// Derived function
+			/** 
-			virtual void CalculateSize(const vec2& availlable);
+			 * @brief Select a new subwidget to display
-			virtual void CalculateMinMaxSize(void);
+			 * @param[in] _id Id of the subwidget requested
-			virtual void SetMinSize(const vec2& size);
+			 */
-			virtual bvec2 CanExpand(void);
+			void SubWidgetSelectSet(int32_t _id);
-			void LockExpandContamination(const bvec2& lockExpand);
+			/** 
-		private:
+			 * @brief Select a new subwidget to display
-			bvec2 m_lockExpandContamination;
+			 * @param[in] _widgetPointer Pointer on the widget selected (must be added before)
-			etk::Vector<ewol::Widget*> m_subWidget;
+			 */
-			int32_t m_windowsSources; // widget source viewed
+			void SubWidgetSelectSet(ewol::Widget* _widgetPointer);
-			int32_t m_windowsDestination; // widget destinated viewed
+			/** 
-			int32_t m_slidingProgress; // ratio progression of a sliding
+			 * @brief Select a new subwidget to display
-		public:
+			 * @param[in] _widgetName Name of the subwidget name
-			virtual void SubWidgetRemoveAll(void);
+			 */
-			virtual int32_t SubWidgetAdd(ewol::Widget* newWidget);
+			void SubWidgetSelectSet(const etk::UString& _widgetName);
-			virtual void SubWidgetRemove(ewol::Widget* newWidget);
+			/** 
-			virtual void SubWidgetUnLink(ewol::Widget* newWidget);
+			 * @brief Set a new mode of sliding element
-			void SubWidgetSelectSet(int32_t id);
+			 * @param[in] _mode new display mode
-			int32_t SubWidgetSelectGet(void) { return (int32_t)m_slidingProgress; };
+			 */
-			int32_t SubWidgetNumber(void) { return m_subWidget.Size(); };
+			void SetTransitionMode(sladingMode_te _mode);
+			/** 
+			 * @brief Get a new mode of sliding element
+			 * @return The current sliding mode
+			 */
+			sladingMode_te GetTransitionMode(void) { return m_transitionSlide; };
+			
 		public: // Derived function
-			virtual void SystemDraw(const ewol::DrawProperty& displayProp);
+			virtual const char * const GetObjectType(void) { return "Ewol::WSlider"; };
-			virtual void   OnRegenerateDisplay(void);
+			virtual void CalculateSize(const vec2& _availlable);
-			virtual ewol::Widget * GetWidgetAtPos(const vec2& pos);
+			virtual void SystemDraw(const ewol::DrawProperty& _displayProp);
-			virtual void OnObjectRemove(ewol::EObject * removeObject);
+			virtual void OnRegenerateDisplay(void);
-			virtual void PeriodicCall(int64_t localTime);
+			virtual void PeriodicCall(int64_t _localTime);
+			virtual bool OnSetConfig(const ewol::EConfig& _conf);
+			virtual bool OnGetConfig(const char* _config, etk::UString& _result) const;
 	};
 	
+	etk::CCout& operator <<(etk::CCout& _os, const widget::WSlider::sladingMode_te _obj);
 };
 
 #endif