/**
 * @author Edouard DUPIN
 * 
 * @copyright 2011, Edouard DUPIN, all right reserved
 * 
 * @license BSD v3 (see license file)
 */

#include <ewol/widget/Widget.h>
#include <ewol/eObject/EObjectManager.h>
#include <ewol/widget/WidgetManager.h>
#include <ewol/ewol.h>
#include <ewol/renderer/openGL.h>
#include <ewol/renderer/os/eSystem.h>
#include <ewol/renderer/os/gui.h>


#undef __class__
#define __class__	"Widget"

ewol::Widget::Widget(void) :
	m_up(NULL),
	m_size(10,10),
	m_minSize(0,0),
	m_maxSize(vec2(ULTIMATE_MAX_SIZE,ULTIMATE_MAX_SIZE)),
	m_zoom(1.0f),
	m_origin(0,0),
	m_userMinSize(vec2(0,0),ewol::Dimension::Pixel),
	m_userMaxSize(vec2(ULTIMATE_MAX_SIZE,ULTIMATE_MAX_SIZE),ewol::Dimension::Pixel),
	m_userExpand(false,false),
	m_userFill(false,false),
	m_hide(false),
	m_hasFocus(false),
	m_canFocus(false),
	m_limitMouseEvent(3),
	m_allowRepeateKeyboardEvent(true),
	m_needRegenerateDisplay(true),
	m_grabCursor(false),
	m_cursorDisplay(ewol::cursorArrow)
{
	
}


ewol::Widget::~Widget(void)
{
	// Remove his own focus...
	ewol::widgetManager::Rm(this);
	// clean all the short-cut ...
	ShortCutClean();
}

void ewol::Widget::SetUpperWidget(ewol::Widget* _upper)
{
	if (NULL == _upper) {
		//just remove father :
		m_up = NULL;
		return;
	}
	if (NULL != m_up) {
		EWOL_WARNING("[" << GetId() << "] Replace upper widget of this one ...");
	}
	m_up = _upper;
}

void ewol::Widget::OnObjectRemove(ewol::EObject* _removeObject)
{
	if (_removeObject == m_up) {
		EWOL_WARNING("[" << GetId() << "] Remove upper widget befor removing this widget ...");
		m_up = NULL;
	}
}

void ewol::Widget::Hide(void)
{
	m_hide = true;
	MarkToRedraw();
	ewol::RequestUpdateSize();
}


void ewol::Widget::Show(void)
{
	m_hide = false;
	MarkToRedraw();
	ewol::RequestUpdateSize();
}


void ewol::Widget::CalculateSize(const vec2& _availlable)
{
	m_size = _availlable;
	MarkToRedraw();
}


bool ewol::Widget::SetFocus(void)
{
	if (true == m_canFocus) {
		m_hasFocus = true;
		OnGetFocus();
		return true;
	}
	return false;
}


bool ewol::Widget::RmFocus(void)
{
	if (true == m_canFocus) {
		m_hasFocus = false;
		OnLostFocus();
		return true;
	}
	return false;
}


void ewol::Widget::SetCanHaveFocus(bool _canFocusState)
{
	m_canFocus = _canFocusState;
	if (true == m_hasFocus) {
		(void)RmFocus();
	}
}


void ewol::Widget::KeepFocus(void)
{
	ewol::widgetManager::FocusKeep(this);
}


void ewol::Widget::GenDraw(DrawProperty _displayProp)
{
	if (true==m_hide){
		// widget is hidden ...
		return;
	}
	// check if the element is displayable in the windows : 
	if(    _displayProp.m_windowsSize.x() < m_origin.x()
	    || _displayProp.m_windowsSize.y() < m_origin.y() ) {
		// out of the windows ==> nothing to display ...
		return;
	}
	ewol::openGL::Push();
	if(    (_displayProp.m_origin.x() > m_origin.x())
	    || (_displayProp.m_origin.x() + _displayProp.m_size.x() < m_size.x() + m_origin.x()) ) {
		// here we invert the reference of the standard OpenGl view because the reference in the common display is Top left and not buttom left
		int32_t tmpOriginX = etk_max(_displayProp.m_origin.x(), m_origin.x());
		int32_t tmppp1 = _displayProp.m_origin.x() + _displayProp.m_size.x();
		int32_t tmppp2 = m_origin.x() + m_size.x();
		int32_t tmpclipX = etk_min(tmppp1, tmppp2) - tmpOriginX;
		
		int32_t tmpOriginY = etk_max(_displayProp.m_origin.y(), m_origin.y());
		tmppp1 = _displayProp.m_origin.y() + _displayProp.m_size.y();
		tmppp2 = m_origin.y() + m_size.y();
		//int32_t tmpclipY = etk_min(tmppp1, tmppp2) - tmpOriginX;
		
		glViewport( tmpOriginX,
		            tmpOriginY,
		            tmpclipX,
		            m_size.y());
		mat4 tmpTranslate = etk::matTranslate(vec3((float)(-tmpclipX/2 - (tmpOriginX-m_origin.x())), (float)(-m_size.y()/2.0), -1.0f));
		mat4 tmpScale = etk::matScale(vec3(m_zoom, m_zoom, 1));
		mat4 tmpProjection = etk::matOrtho(-tmpclipX/2, tmpclipX/2, -m_size.y()/2, m_size.y()/2, -1, 1);
		mat4 tmpMat = tmpProjection * tmpScale * tmpTranslate;
		// set internal matrix system :
		ewol::openGL::SetMatrix(tmpMat);
		// Call the widget drawing methode
		_displayProp.m_origin.setValue(tmpOriginX, tmpOriginY);
		_displayProp.m_size.setValue(tmpclipX, m_size.y());
		//int64_t ___startTime = ewol::GetTime();
		OnDraw(_displayProp);
		//float ___localTime = (float)(ewol::GetTime() - ___startTime) / 1000.0f;
		//EWOL_DEBUG("      Widget1  : " << ___localTime << "ms ");
	} else {
		glViewport( m_origin.x(),
		            m_origin.y(),
		            m_size.x(),
		            m_size.y());
		mat4 tmpTranslate = etk::matTranslate(vec3(-m_size.x()/2, -m_size.y()/2, -1.0f));
		mat4 tmpScale = etk::matScale(vec3(m_zoom, m_zoom, 1.0f));
		mat4 tmpProjection = etk::matOrtho(-m_size.x()/2, m_size.x()/2, -m_size.y()/2, m_size.y()/2, -1, 1);
		mat4 tmpMat = tmpProjection * tmpScale * tmpTranslate;
		// set internal matrix system :
		ewol::openGL::SetMatrix(tmpMat);
		// Call the widget drawing methode
		_displayProp.m_origin = m_origin;
		_displayProp.m_size = m_size;
		//int64_t ___startTime = ewol::GetTime();
		OnDraw(_displayProp);
		//float ___localTime = (float)(ewol::GetTime() - ___startTime) / 1000.0f;
		//EWOL_DEBUG("      Widget2  : " << ___localTime << "ms ");
	}
	ewol::openGL::Pop();
	return;
}


void ewol::Widget::PeriodicCallSet(bool _statusToSet)
{
	if (true == _statusToSet) {
		ewol::widgetManager::PeriodicCallAdd(this);
	} else {
		ewol::widgetManager::PeriodicCallRm(this);
	}
}


void ewol::Widget::MarkToRedraw(void)
{
	m_needRegenerateDisplay = true;
	ewol::widgetManager::MarkDrawingIsNeeded();
}


void ewol::Widget::SetZoom(float _newVal)
{
	m_zoom = etk_avg(0.0000001,_newVal,1000000.0);
	MarkToRedraw();
}

float ewol::Widget::GetZoom(void)
{
	return m_zoom;
}

void ewol::Widget::SetOrigin(const vec2& _pos)
{
	m_origin = _pos;
}

vec2 ewol::Widget::GetOrigin(void)
{
	return m_origin;
}

vec2 ewol::Widget::RelativePosition(const vec2& _pos)
{
	return _pos - m_origin;
}

void ewol::Widget::CalculateMinMaxSize(void)
{
	m_minSize = m_userMinSize.GetPixel();
	m_maxSize = m_userMaxSize.GetPixel();
	MarkToRedraw();
}

vec2 ewol::Widget::GetCalculateMinSize(void)
{
	if (false==IsHide()) {
		return m_minSize;
	}
	return vec2(0,0);
}

vec2 ewol::Widget::GetCalculateMaxSize(void)
{
	if (false==IsHide()) {
		return m_maxSize;
	}
	return vec2(ULTIMATE_MAX_SIZE,ULTIMATE_MAX_SIZE);
}

void ewol::Widget::SetMinSize(const ewol::Dimension& _size)
{
	vec2 pixelMin = _size.GetPixel();
	vec2 pixelMax = m_userMaxSize.GetPixel();
	// check minimum & maximum compatibility :
	bool error=false;
	if (pixelMin.x()>pixelMax.x()) {
		error=true;
	}
	if (pixelMin.y()>pixelMax.y()) {
		error=true;
	}
	if (error==true) {
		EWOL_ERROR("Can not set a 'min Size' > 'max size' set nothing ...");
		return;
	}
	m_userMinSize = _size;
	ewol::RequestUpdateSize();
}

void ewol::Widget::SetNoMinSize(void)
{
	m_userMinSize.Set(vec2(0,0),ewol::Dimension::Pixel);
}

void ewol::Widget::CheckMinSize(void)
{
	vec2 pixelSize = m_userMinSize.GetPixel();
	m_minSize.setX(etk_max(m_minSize.x(), pixelSize.x()));
	m_minSize.setY(etk_max(m_minSize.y(), pixelSize.y()));
}

void ewol::Widget::SetMaxSize(const ewol::Dimension& _size)
{
	vec2 pixelMin = m_userMinSize.GetPixel();
	vec2 pixelMax = _size.GetPixel();
	// check minimum & maximum compatibility :
	bool error=false;
	if (pixelMin.x()>pixelMax.x()) {
		error=true;
	}
	if (pixelMin.y()>pixelMax.y()) {
		error=true;
	}
	if (error==true) {
		EWOL_ERROR("Can not set a 'min Size' > 'max size' set nothing ...");
		return;
	}
	m_userMaxSize = _size;
	ewol::RequestUpdateSize();
}

void ewol::Widget::SetNoMaxSize(void)
{
	m_userMaxSize.Set(vec2(ULTIMATE_MAX_SIZE,ULTIMATE_MAX_SIZE),ewol::Dimension::Pixel);
}

void ewol::Widget::CheckMaxSize(void)
{
	vec2 pixelSize = m_userMaxSize.GetPixel();
	m_maxSize.setX(etk_min(m_maxSize.x(), pixelSize.x()));
	m_maxSize.setY(etk_min(m_maxSize.y(), pixelSize.y()));
}

vec2 ewol::Widget::GetSize(void)
{
	if (false==IsHide()) {
		return m_size;
	}
	return vec2(0,0);
}

void ewol::Widget::SetExpand(const bvec2& _newExpand)
{
	if(    m_userExpand.x() != _newExpand.x()
	    || m_userExpand.y() != _newExpand.y()) {
		m_userExpand = _newExpand;
		ewol::RequestUpdateSize();
		MarkToRedraw();
	}
}

bvec2 ewol::Widget::CanExpand(void)
{
	if (false==IsHide()) {
		return m_userExpand;
	}
	return bvec2(false,false);
}


void ewol::Widget::SetFill(const bvec2& _newFill)
{
	if(    m_userFill.x() != _newFill.x()
	    || m_userFill.y() != _newFill.y()) {
		m_userFill = _newFill;
		ewol::RequestUpdateSize();
		MarkToRedraw();
	}
}

const bvec2& ewol::Widget::CanFill(void)
{
	return m_userFill;
}

// ----------------------------------------------------------------------------------------------------------------
// -- Shortcut : management of the shortcut
// ----------------------------------------------------------------------------------------------------------------

void ewol::Widget::ShortCutAdd(const char * _descriptiveString, const char * _generateEventId, etk::UString _data, bool _broadcast)
{
	if(		NULL==_descriptiveString
		||	0==strlen(_descriptiveString))
	{
		EWOL_ERROR("try to add shortcut with no descriptive string ...");
		return;
	}
	
	EventShortCut* tmpElement = new EventShortCut();
	if (NULL == tmpElement) {
		EWOL_ERROR("allocation error ... Memory error ...");
		return;
	}
	tmpElement->broadcastEvent = _broadcast;
	tmpElement->generateEventId = _generateEventId;
	tmpElement->eventData = _data;
	// parsing of the string :
	//"ctrl+shift+alt+meta+s"
	const char * tmp = strstr(_descriptiveString, "ctrl");
	if(NULL != tmp) {
		tmpElement->specialKey.ctrl = true;
	}
	tmp = strstr(_descriptiveString, "shift");
	if(NULL != tmp) {
		tmpElement->specialKey.shift = true;
	}
	tmp = strstr(_descriptiveString, "alt");
	if(NULL != tmp) {
		tmpElement->specialKey.alt = true;
	}
	tmp = strstr(_descriptiveString, "meta");
	if(NULL != tmp) {
		tmpElement->specialKey.meta = true;
	}
	if(NULL != strstr(_descriptiveString, "F12") ) {
		tmpElement->keyboardMoveValue = ewol::keyEvent::keyboardF12;
	} else if(NULL != strstr(_descriptiveString, "F11") ) {
		tmpElement->keyboardMoveValue = ewol::keyEvent::keyboardF11;
	} else if(NULL != strstr(_descriptiveString, "F10") ) {
		tmpElement->keyboardMoveValue = ewol::keyEvent::keyboardF10;
	} else if(NULL != strstr(_descriptiveString, "F9") ) {
		tmpElement->keyboardMoveValue = ewol::keyEvent::keyboardF9;
	} else if(NULL != strstr(_descriptiveString, "F8") ) {
		tmpElement->keyboardMoveValue = ewol::keyEvent::keyboardF8;
	} else if(NULL != strstr(_descriptiveString, "F7") ) {
		tmpElement->keyboardMoveValue = ewol::keyEvent::keyboardF7;
	} else if(NULL != strstr(_descriptiveString, "F6") ) {
		tmpElement->keyboardMoveValue = ewol::keyEvent::keyboardF6;
	} else if(NULL != strstr(_descriptiveString, "F5") ) {
		tmpElement->keyboardMoveValue = ewol::keyEvent::keyboardF5;
	} else if(NULL != strstr(_descriptiveString, "F4") ) {
		tmpElement->keyboardMoveValue = ewol::keyEvent::keyboardF4;
	} else if(NULL != strstr(_descriptiveString, "F3") ) {
		tmpElement->keyboardMoveValue = ewol::keyEvent::keyboardF3;
	} else if(NULL != strstr(_descriptiveString, "F2") ) {
		tmpElement->keyboardMoveValue = ewol::keyEvent::keyboardF2;
	} else if(NULL != strstr(_descriptiveString, "F1") ) {
		tmpElement->keyboardMoveValue = ewol::keyEvent::keyboardF1;
	} else if(NULL != strstr(_descriptiveString, "LEFT") ) {
		tmpElement->keyboardMoveValue = ewol::keyEvent::keyboardLeft;
	} else if(NULL != strstr(_descriptiveString, "RIGHT") ) {
		tmpElement->keyboardMoveValue = ewol::keyEvent::keyboardRight;
	} else if(NULL != strstr(_descriptiveString, "UP") ) {
		tmpElement->keyboardMoveValue = ewol::keyEvent::keyboardUp;
	} else if(NULL != strstr(_descriptiveString, "DOWN") ) {
		tmpElement->keyboardMoveValue = ewol::keyEvent::keyboardDown;
	} else if(NULL != strstr(_descriptiveString, "PAGE_UP") ) {
		tmpElement->keyboardMoveValue = ewol::keyEvent::keyboardPageUp;
	} else if(NULL != strstr(_descriptiveString, "PAGE_DOWN") ) {
		tmpElement->keyboardMoveValue = ewol::keyEvent::keyboardPageDown;
	} else if(NULL != strstr(_descriptiveString, "START") ) {
		tmpElement->keyboardMoveValue = ewol::keyEvent::keyboardStart;
	} else if(NULL != strstr(_descriptiveString, "END") ) {
		tmpElement->keyboardMoveValue = ewol::keyEvent::keyboardEnd;
	} else if(NULL != strstr(_descriptiveString, "PRINT") ) {
		tmpElement->keyboardMoveValue = ewol::keyEvent::keyboardPrint;
	} else if(NULL != strstr(_descriptiveString, "ARRET_DEFIL") ) {
		tmpElement->keyboardMoveValue = ewol::keyEvent::keyboardStopDefil;
	} else if(NULL != strstr(_descriptiveString, "WAIT") ) {
		tmpElement->keyboardMoveValue = ewol::keyEvent::keyboardWait;
	} else if(NULL != strstr(_descriptiveString, "INSERT") ) {
		tmpElement->keyboardMoveValue = ewol::keyEvent::keyboardInsert;
	} else if(NULL != strstr(_descriptiveString, "CAPLOCK") ) {
		tmpElement->keyboardMoveValue = ewol::keyEvent::keyboardCapLock;
	} else if(NULL != strstr(_descriptiveString, "CONTEXT_MENU") ) {
		tmpElement->keyboardMoveValue = ewol::keyEvent::keyboardContextMenu;
	} else if(NULL != strstr(_descriptiveString, "NUM_LOCK") ) {
		tmpElement->keyboardMoveValue = ewol::keyEvent::keyboardNumLock;
	} else {
		tmpElement->unicodeValue = _descriptiveString[strlen(_descriptiveString) -1];
	}
	// add it on the List ...
	m_localShortcut.PushBack(tmpElement);
}


void ewol::Widget::ShortCutClean(void)
{
	for (int32_t iii=0; iii<m_localShortcut.Size(); iii++) {
		if (NULL != m_localShortcut[iii]) {
			delete(m_localShortcut[iii]);
			m_localShortcut[iii]=NULL;
		}
	}
	m_localShortcut.Clear();
}


bool ewol::Widget::OnEventShortCut(ewol::SpecialKey& _special, uniChar_t _unicodeValue, ewol::keyEvent::keyboard_te _kbMove, bool _isDown)
{
	if (_unicodeValue >= 'A' && _unicodeValue <='Z') {
		_unicodeValue += 'a' - 'A';
	}
	//EWOL_INFO("Try to find generic shortcut ...");
	for(int32_t iii=m_localShortcut.Size()-1; iii>=0; iii--) {
		if(NULL != m_localShortcut[iii]) {
			if(    m_localShortcut[iii]->specialKey.shift == _special.shift
			    && m_localShortcut[iii]->specialKey.ctrl  == _special.ctrl
			    && m_localShortcut[iii]->specialKey.alt   == _special.alt
			    && m_localShortcut[iii]->specialKey.meta  == _special.meta
			    && (    (    m_localShortcut[iii]->keyboardMoveValue == ewol::keyEvent::keyboardUnknow
			              && m_localShortcut[iii]->unicodeValue == _unicodeValue)
			         || (    m_localShortcut[iii]->keyboardMoveValue == _kbMove
			              && m_localShortcut[iii]->unicodeValue == 0)
			       ) )
			{
				if (_isDown) {
					if (true == m_localShortcut[iii]->broadcastEvent) {
						// send message at all the widget (exepted this one)
						SendMultiCast(m_localShortcut[iii]->generateEventId, m_localShortcut[iii]->eventData);
					}
					// send message direct to the current widget (in every case, really useful for some generic windows shortcut)
					OnReceiveMessage(this, m_localShortcut[iii]->generateEventId, m_localShortcut[iii]->eventData);
				} // no else
				return true;
			}
		}
	}
	return false;
}


void ewol::Widget::GrabCursor(void)
{
	if (false == m_grabCursor) {
		eSystem::InputEventGrabPointer(this);
		m_grabCursor = true;
	}
}

void ewol::Widget::UnGrabCursor(void)
{
	if (true==m_grabCursor) {
		eSystem::InputEventUnGrabPointer();
		m_grabCursor = false;
	}
}


bool ewol::Widget::GetGrabStatus(void)
{
	return m_grabCursor;
}



void ewol::Widget::SetCursor(ewol::cursorDisplay_te _newCursor)
{
	EWOL_DEBUG("Change Cursor in " << _newCursor);
	m_cursorDisplay = _newCursor;
	guiInterface::SetCursor(m_cursorDisplay);
}

ewol::cursorDisplay_te ewol::Widget::GetCursor(void)
{
	return m_cursorDisplay;
}

bool ewol::Widget::LoadXML(TiXmlNode* _node)
{
	if (NULL==_node) {
		return false;
	}
	bool ret = true;
	const char *tmpAttributeValue = _node->ToElement()->Attribute("name");
	if (NULL != tmpAttributeValue) {
		SetName(tmpAttributeValue);
	}
	tmpAttributeValue = _node->ToElement()->Attribute("fill");
	if (NULL != tmpAttributeValue) {
		if (strcmp("false,false", tmpAttributeValue)==0) {
			SetFill(bvec2(false,false));
		} else if (strcmp("false,true", tmpAttributeValue)==0) {
			SetFill(bvec2(false,true));
		} else if (strcmp("true,false", tmpAttributeValue)==0) {
			SetFill(bvec2(true,false));
		} else if (strcmp("false", tmpAttributeValue)==0) {
			SetFill(bvec2(false,false));
		} else {
			SetFill(bvec2(true,true));
		}
	}
	tmpAttributeValue = _node->ToElement()->Attribute("expand");
	if (NULL != tmpAttributeValue) {
		if (strcmp("false,false", tmpAttributeValue)==0) {
			SetExpand(bvec2(false,false));
		} else if (strcmp("false,true", tmpAttributeValue)==0) {
			SetExpand(bvec2(false,true));
		} else if (strcmp("true,false", tmpAttributeValue)==0) {
			SetExpand(bvec2(true,false));
		} else if (strcmp("false", tmpAttributeValue)==0) {
			SetExpand(bvec2(false,false));
		} else {
			SetExpand(bvec2(true,true));
		}
	}
	tmpAttributeValue = _node->ToElement()->Attribute("hide");
	if (NULL != tmpAttributeValue) {
		if (strcmp("true", tmpAttributeValue)==0) {
			Hide();
		} else {
			Show();
		}
	}
	tmpAttributeValue = _node->ToElement()->Attribute("focus");
	if (NULL != tmpAttributeValue) {
		if (strcmp("true", tmpAttributeValue)==0) {
			KeepFocus();
		}
	}
	tmpAttributeValue = _node->ToElement()->Attribute("min-size");
	if (NULL != tmpAttributeValue) {
		m_userMinSize.SetString(tmpAttributeValue);
	}
	tmpAttributeValue = _node->ToElement()->Attribute("max-size");
	if (NULL != tmpAttributeValue) {
		m_userMaxSize.SetString(tmpAttributeValue);
	}
	EWOL_DEBUG("Widget parse: m_hide=" << m_hide << "  m_userMinSize=" << m_userMinSize << "  m_userMaxSize=" << m_userMaxSize << "  m_userFill=" << m_userFill << "  m_userExpand=" << m_userExpand);
	MarkToRedraw();
	return ret;
}

bool ewol::Widget::StoreXML(TiXmlNode* _node)
{
	if (NULL==_node) {
		return false;
	}
	/*
	TiXmlElement * element = new TiXmlElement(__class__);
	if (NULL == element) {
		EWOL_ERROR("TinyXML node allocation error");
		return false;
	}
	_node->LinkEndChild(element);
	*/
	if (GetName().Size()!=0) {
		_node->ToElement()->SetAttribute("name", GetName().c_str() );
	}
	
	if (m_userMinSize.GetPixel() != vec2(0,0)) {
		_node->ToElement()->SetAttribute("min-size", m_userMinSize.GetString().c_str() );
	}
	if (m_userMaxSize.GetPixel() != vec2(ULTIMATE_MAX_SIZE,ULTIMATE_MAX_SIZE)) {
		_node->ToElement()->SetAttribute("max-size", m_userMaxSize.GetString().c_str() );
	}
	if (m_userExpand != bvec2(false,false)) {
		etk::UString tmpVal = etk::UString(m_userExpand.x()) + "," + etk::UString(m_userExpand.y());
		_node->ToElement()->SetAttribute("expand", tmpVal.c_str() );
	}
	if (m_userFill != bvec2(false,false)) {
		etk::UString tmpVal = etk::UString(m_userFill.x()) + "," + etk::UString(m_userFill.y());
		_node->ToElement()->SetAttribute("fill", tmpVal.c_str() );
	}
	if (IsHide() != false) {
		_node->ToElement()->SetAttribute("hide", "true" );
	}
	return true;
}


ewol::Widget* ewol::Widget::GetWidgetNamed(const etk::UString& _widgetName)
{
	if (GetName()==_widgetName) {
		return this;
	}
	return NULL;
}


bool ewol::Widget::SystemEventEntry(ewol::EventEntrySystem& _event)
{
	if (NULL != m_up) {
		if (true==m_up->SystemEventEntry(_event)) {
			return true;
		}
	}
	return OnEventEntry(_event.m_event);
}

bool ewol::Widget::SystemEventInput(ewol::EventInputSystem& _event)
{
	if (NULL != m_up) {
		if (true==m_up->SystemEventInput(_event)) {
			return true;
		}
	}
	return OnEventInput(_event.m_event);
}