atria-soft/ewol
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[DEV] rework signal interface (step 1 normalisation)

Browse Source
This commit is contained in:
Edouard DUPIN 2014-08-20 22:34:31 +02:00
parent 006ed42f38
commit 3175657fed
41 changed files with 281 additions and 433 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
external/ege vendored

@ -1 +1 @@
Subproject commit d22d7ade7310428a294cc8b057d9ab2563afc9b6 Subproject commit 87b68c408e3bceff1923e84d2e08fcee9d868561

104
sources/ewol/object/Object.cpp
View File

@ -176,95 +176,6 @@ void ewol::Object::registerMultiCast(const char* const _messageId) {
} }
getMultiCast().add(shared_from_this(), _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) { bool ewol::Object::loadXML(exml::Element* _node) {
if (nullptr == _node) { if (nullptr == _node) {
@ -315,21 +226,6 @@ ewol::object::MultiCast& ewol::Object::getMultiCast() const {
ewol::Context& ewol::Object::getContext() const { ewol::Context& ewol::Object::getContext() const {
return ewol::getContext(); 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 { std::shared_ptr<ewol::Object> ewol::Object::getObjectNamed(const std::string& _objectName) const {
return getObjectManager().getObjectNamed(_objectName); return getObjectManager().getObjectNamed(_objectName);
} }

73
sources/ewol/object/Signal.h
View File

@ -18,10 +18,22 @@
namespace ewol { namespace ewol {
namespace object { 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 { template<typename T> class Signal : public SignalBase {
private: private:
//std::vector<std::funtion<void(const T&)>> m_callerList; //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: public:
/** /**
* @brief Create a parameter with a specific type. * @brief Create a parameter with a specific type.
@ -42,21 +54,12 @@ namespace ewol {
* @brief Destructor. * @brief Destructor.
*/ */
virtual ~Signal() { }; virtual ~Signal() { };
void connect(std::shared_ptr<ewol::Object> _obj, const char* _destId=nullptr, const std::string& _data="" ) {
const std::string& getName() { m_serializedCallerList.push_back(SignalCallerIdentifier(_obj, _destId, _data));
return m_name;
} }
const std::string& getDescription() { void release(std::shared_ptr<ewol::Object> _obj) {
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) {
for (auto it(m_serializedCallerList.begin()) ; it != m_serializedCallerList.end(); ++it) { 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); m_serializedCallerList.erase(it);
it = m_serializedCallerList.begin(); 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 .... // note : this can not emit on function ....
std::string stringData; std::string stringData;
if (m_serializedCallerList.size()>0 ) { if (m_serializedCallerList.size()>0 ) {
stringData = etk::to_string(_data); stringData = etk::to_string(_data);
} }
for (auto &it : m_serializedCallerList) { 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) { if (destObject == nullptr) {
// TODO : Remove instance ... // TODO : Remove instance ...
EWOL_VERBOSE(" nullptr dest"); EWOL_VERBOSE(" nullptr dest");
continue; continue;
} }
const char* eventId = m_name.c_str(); const char* eventId = m_name.c_str();
if (std::get<1>(it) != nullptr) { if (it.m_enevntId != nullptr) {
eventId = std::get<1>(it); 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::object::Message tmpMsg(_source, eventId, stringData);
EWOL_VERBOSE("send message " << tmpMsg); EWOL_VERBOSE("send message " << tmpMsg);
destObject->onReceiveMessage(tmpMsg); destObject->onReceiveMessage(tmpMsg);
} else { } else {
// set the user requested data ... // 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); EWOL_VERBOSE("send message " << tmpMsg);
destObject->onReceiveMessage(tmpMsg); destObject->onReceiveMessage(tmpMsg);
} }
@ -123,7 +126,7 @@ namespace ewol {
template<> class Signal<void> : public SignalBase { template<> class Signal<void> : public SignalBase {
private: private:
//std::vector<std::funtion<void(const T&)>> m_callerList; //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: public:
/** /**
* @brief Create a parameter with a specific type. * @brief Create a parameter with a specific type.
@ -145,46 +148,38 @@ namespace ewol {
*/ */
virtual ~Signal() { }; virtual ~Signal() { };
const std::string& getName() { void connect(std::shared_ptr<ewol::Object> _obj, const char* _destId=nullptr, const std::string& _data="" ) {
return m_name; m_serializedCallerList.push_back(SignalCallerIdentifier(_obj, _destId, _data));
} }
const std::string& getDescription() { void release(std::shared_ptr<ewol::Object> _obj) {
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) {
for (auto it(m_serializedCallerList.begin()) ; it != m_serializedCallerList.end(); ++it) { 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); m_serializedCallerList.erase(it);
it = m_serializedCallerList.begin(); 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 .... // note : this can not emit on function ....
std::string stringData; std::string stringData;
for (auto &it : m_serializedCallerList) { 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) { if (destObject == nullptr) {
// TODO : Remove instance ... // TODO : Remove instance ...
EWOL_VERBOSE(" nullptr dest"); EWOL_VERBOSE(" nullptr dest");
continue; continue;
} }
const char* eventId = m_name.c_str(); const char* eventId = m_name.c_str();
if (std::get<1>(it) != nullptr) { if (it.m_enevntId != nullptr) {
eventId = std::get<1>(it); 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::object::Message tmpMsg(_source, eventId, stringData);
EWOL_VERBOSE("send message " << tmpMsg); EWOL_VERBOSE("send message " << tmpMsg);
destObject->onReceiveMessage(tmpMsg); destObject->onReceiveMessage(tmpMsg);
} else { } else {
// set the user requested data ... // 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); EWOL_VERBOSE("send message " << tmpMsg);
destObject->onReceiveMessage(tmpMsg); destObject->onReceiveMessage(tmpMsg);
} }

6
sources/ewol/object/SignalBase.cpp
View File

@ -21,3 +21,9 @@ ewol::object::SignalBase::SignalBase(ewol::object::SignalList& _objectLink,
// add a reference on the current signal ... // add a reference on the current signal ...
m_objectLink.signalAdd(this); m_objectLink.signalAdd(this);
} }
std::ostream& ewol::object::operator <<(std::ostream& _os, const ewol::object::SignalBase& _obj) {
_os << _obj.getName();
return _os;
}

7
sources/ewol/object/SignalBase.h
View File

@ -36,13 +36,16 @@ namespace ewol {
*/ */
virtual ~SignalBase() { }; virtual ~SignalBase() { };
const std::string& getName() { const std::string& getName() const {
return m_name; return m_name;
} }
const std::string& getDescription() { const std::string& getDescription() const {
return m_description; 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 #endif

128
sources/ewol/object/SignalList.cpp
View File

@ -11,6 +11,7 @@
#include <ewol/object/Object.h> #include <ewol/object/Object.h>
#include <ewol/object/SignalList.h> #include <ewol/object/SignalList.h>
#include <ewol/object/SignalBase.h> #include <ewol/object/SignalBase.h>
#include <ewol/context/Context.h>
ewol::object::SignalList::SignalList() { ewol::object::SignalList::SignalList() {
@ -29,60 +30,85 @@ void ewol::object::SignalList::signalAdd(SignalBase* _pointerOnSignal) {
m_list.push_back(_pointerOnSignal); m_list.push_back(_pointerOnSignal);
} }
#if 0 std::vector<std::string> ewol::object::SignalList::signalGetAll() const {
// Note no lock is needed at this level, because the lock is done is the upper elements ... std::vector<std::string> out;
// 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:");
for (auto &it : m_list) { for (auto &it : m_list) {
if(it != nullptr) { if(it != nullptr) {
std::string paramName = it->getName(); out.push_back(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));
}
} }
} }
return out; 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);
}
}
}

32
sources/ewol/object/SignalList.h
View File

@ -35,37 +35,11 @@ namespace ewol {
* @param[in] pointerOnParameter Pointer on the parameter that might be added. * @param[in] pointerOnParameter Pointer on the parameter that might be added.
*/ */
void signalAdd(SignalBase* _pointerOnParameter); void signalAdd(SignalBase* _pointerOnParameter);
#if 0
/** /**
* @brief Set a specific value to the parameter reference name. * @brief Get All the signal list:
* @param[in] parameter The parameter string name. * @return vector on all the signals names
* @param[in] value The new value of the parameter (string).
* @return true Parameter update.
* @return false Parameter not update.
*/ */
bool parameterSet(const std::string& _parameter, const std::string& _value); std::vector<std::string> signalGetAll() const;
/**
* @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
/** /**
* @brief Register an Event an named widget. @see registerOnEvent * @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 * @param[in] _destinationObject pointer on the object that might be call when an event is generated

42
sources/ewol/widget/Button.cpp
View File

@ -14,14 +14,6 @@
#define __class__ "Button" #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 for the shader display system :
#define STATUS_UP (0) #define STATUS_UP (0)
#define STATUS_HOVER (2) #define STATUS_HOVER (2)
@ -30,6 +22,11 @@ const char* const ewol::widget::Button::eventValue = "value";
ewol::widget::Button::Button() : ewol::widget::Button::Button() :
signalPressed(*this, "pressed", "Button is pressed"), 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_shaper(*this, "shaper", "The display name for config file"),
m_value(*this, "value", false, "Value of the Button"), 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"), 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_selectableAreaPos(0,0),
m_selectableAreaSize(0,0) { m_selectableAreaSize(0,0) {
addObjectType("ewol::widget::Button"); addObjectType("ewol::widget::Button");
// add basic Event generated :
addEventId(eventPressed);
addEventId(eventDown);
addEventId(eventUp);
addEventId(eventEnter);
addEventId(eventLeave);
addEventId(eventValue);
// set property list: // set property list:
m_lock.add(lockNone, "none"); m_lock.add(lockNone, "none");
@ -131,14 +121,14 @@ bool ewol::widget::Button::onEventInput(const ewol::event::Input& _event) {
if (true == m_mouseHover) { if (true == m_mouseHover) {
if (1 == _event.getId()) { if (1 == _event.getId()) {
if(ewol::key::statusDown == _event.getStatus()) { if(ewol::key::statusDown == _event.getStatus()) {
EWOL_VERBOSE(getName() << " : Generate event : " << eventDown); EWOL_VERBOSE(getName() << " : Generate event : " << signalDown);
generateEventId(eventDown); signalDown.emit(shared_from_this());
m_buttonPressed = true; m_buttonPressed = true;
markToRedraw(); markToRedraw();
} }
if(ewol::key::statusUp == _event.getStatus()) { if(ewol::key::statusUp == _event.getStatus()) {
EWOL_VERBOSE(getName() << " : Generate event : " << eventUp); EWOL_VERBOSE(getName() << " : Generate event : " << signalUp);
generateEventId(eventUp); signalUp.emit(shared_from_this());
m_buttonPressed = false; m_buttonPressed = false;
markToRedraw(); markToRedraw();
} }
@ -152,15 +142,15 @@ bool ewol::widget::Button::onEventInput(const ewol::event::Input& _event) {
} else { } else {
// inverse value : // inverse value :
setValue((m_value)?false:true); setValue((m_value)?false:true);
EWOL_VERBOSE(getName() << " : Generate event : " << eventPressed); EWOL_VERBOSE(getName() << " : Generate event : " << signalPressed);
generateEventId(eventPressed); signalPressed.emit(shared_from_this());
EWOL_VERBOSE(getName() << " : Generate event : " << eventValue << " val=" << m_value ); EWOL_VERBOSE(getName() << " : Generate event : " << signalValue << " val=" << m_value );
generateEventId(eventValue, etk::to_string(m_value.get())); signalValue.emit(shared_from_this(), m_value.get());
if( false == m_toggleMode if( false == m_toggleMode
&& true == m_value) { && true == m_value) {
setValue(false); setValue(false);
EWOL_VERBOSE(getName() << " : Generate event : " << ewol::widget::Button::eventValue << " val=" << m_value); EWOL_VERBOSE(getName() << " : Generate event : " << signalValue << " val=" << m_value);
generateEventId(eventValue, etk::to_string(m_value.get())); signalValue.emit(shared_from_this(), m_value.get());
} }
} }
markToRedraw(); markToRedraw();
@ -177,7 +167,7 @@ bool ewol::widget::Button::onEventEntry(const ewol::event::Entry& _event) {
if( _event.getType() == ewol::key::keyboardChar if( _event.getType() == ewol::key::keyboardChar
&& _event.getStatus() == ewol::key::statusDown && _event.getStatus() == ewol::key::statusDown
&& _event.getChar() == '\r') { && _event.getChar() == '\r') {
generateEventId(eventEnter); signalEnter.emit(shared_from_this());
return true; return true;
} }
return false; return false;

4
sources/ewol/widget/Button.h
View File

@ -30,12 +30,12 @@ namespace ewol {
class Button : public ewol::widget::Container2 { class Button : public ewol::widget::Container2 {
public: public:
// Event list of properties // Event list of properties
ewol::object::Signal<int> signalPressed; ewol::object::Signal<void> signalPressed;
ewol::object::Signal<void> signalDown; ewol::object::Signal<void> signalDown;
ewol::object::Signal<void> signalUp; ewol::object::Signal<void> signalUp;
ewol::object::Signal<void> signalEnter; ewol::object::Signal<void> signalEnter;
ewol::object::Signal<void> signalLeave; ewol::object::Signal<void> signalLeave;
ewol::object::Signal<void> signalValue; ewol::object::Signal<bool> signalValue;
enum buttonLock{ enum buttonLock{
lockNone, //!< normal status of the button lockNone, //!< normal status of the button
lockWhenPressed, //!< When the state is set in pressed, the status stay in this one lockWhenPressed, //!< When the state is set in pressed, the status stay in this one

9
sources/ewol/widget/ButtonColor.cpp
View File

@ -15,9 +15,6 @@
#include <ewol/widget/Windows.h> #include <ewol/widget/Windows.h>
#include <ewol/ewol.h> #include <ewol/ewol.h>
const char * const ewol::widget::ButtonColor::eventChange = "change";
// DEFINE for the shader display system : // DEFINE for the shader display system :
#define STATUS_UP (0) #define STATUS_UP (0)
#define STATUS_HOVER (2) #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"; static const char* const eventColorHasChange = "ewol-widget-ButtonColor-colorChange";
ewol::widget::ButtonColor::ButtonColor() : ewol::widget::ButtonColor::ButtonColor() :
signalChange(*this, "change", "Button color change value"),
m_textColorFg(etk::color::black), m_textColorFg(etk::color::black),
m_widgetContextMenu(nullptr) { m_widgetContextMenu(nullptr) {
addObjectType("ewol::widget::ButtonColor"); addObjectType("ewol::widget::ButtonColor");
addEventId(eventChange);
changeStatusIn(STATUS_UP); changeStatusIn(STATUS_UP);
setCanHaveFocus(true); setCanHaveFocus(true);
// Limit event at 1: // Limit event at 1:
@ -227,7 +224,9 @@ void ewol::widget::ButtonColor::onReceiveMessage(const ewol::object::Message& _m
EWOL_INFO("Receive MSG : " << _msg.getData()); EWOL_INFO("Receive MSG : " << _msg.getData());
if (_msg.getMessage() == eventColorHasChange) { if (_msg.getMessage() == eventColorHasChange) {
m_textColorFg = _msg.getData(); 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(); markToRedraw();
} }
} }

3
sources/ewol/widget/ButtonColor.h
View File

@ -17,13 +17,14 @@
#include <ewol/compositing/Shaper.h> #include <ewol/compositing/Shaper.h>
#include <ewol/widget/Widget.h> #include <ewol/widget/Widget.h>
#include <ewol/widget/Manager.h> #include <ewol/widget/Manager.h>
#include <ewol/object/Signal.h>
namespace ewol { namespace ewol {
namespace widget { namespace widget {
class ButtonColor : public ewol::Widget { class ButtonColor : public ewol::Widget {
public: public:
// Event list of properties // Event list of properties
static const char * const eventChange; ewol::object::Signal<etk::Color<>> signalChange;
private: private:
ewol::compositing::Shaper m_shaper; //!< Compositing theme. ewol::compositing::Shaper m_shaper; //!< Compositing theme.
ewol::compositing::Text m_text; //!< Compositing Test display. ewol::compositing::Text m_text; //!< Compositing Test display.

36
sources/ewol/widget/CheckBox.cpp
View File

@ -9,13 +9,6 @@
#include <ewol/widget/CheckBox.h> #include <ewol/widget/CheckBox.h>
#include <ewol/widget/Manager.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 for the shader display system :
#define STATUS_UP (0) #define STATUS_UP (0)
#define STATUS_HOVER (2) #define STATUS_HOVER (2)
@ -26,6 +19,11 @@ const char* const ewol::widget::CheckBox::eventValue = "value";
ewol::widget::CheckBox::CheckBox() : 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_shaper(*this, "shaper", "The display name for config file"),
m_mouseHover(false), m_mouseHover(false),
m_buttonPressed(false), m_buttonPressed(false),
@ -35,12 +33,6 @@ ewol::widget::CheckBox::CheckBox() :
m_shaperIdSizeInsize(-1), m_shaperIdSizeInsize(-1),
m_value(*this, "value", false, "Basic value of the widget") { m_value(*this, "value", false, "Basic value of the widget") {
addObjectType("ewol::widget::CheckBox"); 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_shaperIdSize = m_shaper->requestConfig("box-size");
m_shaperIdSizeInsize = m_shaper->requestConfig("box-inside"); 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 (true == m_mouseHover) {
if (1 == _event.getId()) { if (1 == _event.getId()) {
if(ewol::key::statusDown == _event.getStatus()) { if(ewol::key::statusDown == _event.getStatus()) {
EWOL_VERBOSE(getName() << " : Generate event : " << eventDown); EWOL_VERBOSE(getName() << " : Generate event : " << signalDown);
generateEventId(eventDown); signalDown.emit(shared_from_this());
m_buttonPressed = true; m_buttonPressed = true;
markToRedraw(); markToRedraw();
} }
if(ewol::key::statusUp == _event.getStatus()) { if(ewol::key::statusUp == _event.getStatus()) {
EWOL_VERBOSE(getName() << " : Generate event : " << eventUp); EWOL_VERBOSE(getName() << " : Generate event : " << signalUp);
generateEventId(eventUp); signalUp.emit(shared_from_this());
m_buttonPressed = false; m_buttonPressed = false;
markToRedraw(); markToRedraw();
} }
if(ewol::key::statusSingle == _event.getStatus()) { if(ewol::key::statusSingle == _event.getStatus()) {
// inverse value : // inverse value :
setValue((m_value)?false:true); setValue((m_value)?false:true);
EWOL_VERBOSE(getName() << " : Generate event : " << eventPressed); EWOL_VERBOSE(getName() << " : Generate event : " << signalPressed);
generateEventId(eventPressed); signalPressed.emit(shared_from_this());
EWOL_VERBOSE(getName() << " : Generate event : " << eventValue << " val=" << m_value ); EWOL_VERBOSE(getName() << " : Generate event : " << signalValue << " val=" << m_value );
generateEventId(eventValue, etk::to_string(m_value.get())); signalValue.emit(shared_from_this(), m_value.get());
markToRedraw(); markToRedraw();
} }
} }
@ -170,7 +162,7 @@ bool ewol::widget::CheckBox::onEventEntry(const ewol::event::Entry& _event) {
if( _event.getType() == ewol::key::keyboardChar if( _event.getType() == ewol::key::keyboardChar
&& _event.getStatus() == ewol::key::statusDown && _event.getStatus() == ewol::key::statusDown
&& _event.getChar() == '\r') { && _event.getChar() == '\r') {
generateEventId(eventEnter); signalEnter.emit(shared_from_this());
return true; return true;
} }
return false; return false;

11
sources/ewol/widget/CheckBox.h
View File

@ -14,6 +14,7 @@
#include <ewol/compositing/Shaper.h> #include <ewol/compositing/Shaper.h>
#include <ewol/widget/Container2.h> #include <ewol/widget/Container2.h>
#include <ewol/widget/Manager.h> #include <ewol/widget/Manager.h>
#include <ewol/object/Signal.h>
namespace ewol { namespace ewol {
@ -21,11 +22,11 @@ namespace ewol {
class CheckBox : public ewol::widget::Container2 { class CheckBox : public ewol::widget::Container2 {
public: public:
// Event list of properties // Event list of properties
static const char* const eventPressed; ewol::object::Signal<void> signalPressed;
static const char* const eventDown; ewol::object::Signal<void> signalDown;
static const char* const eventUp; ewol::object::Signal<void> signalUp;
static const char* const eventEnter; ewol::object::Signal<void> signalEnter;
static const char* const eventValue; ewol::object::Signal<bool> signalValue;
private: private:
ewol::object::Param<ewol::compositing::Shaper> m_shaper; //!< Compositing theme. 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)). bool m_mouseHover; //!< Flag to know where the mouse is (inside the displayed widget (if not fill)).

10
sources/ewol/widget/ColorBar.cpp
View File

@ -13,16 +13,12 @@
#include <etk/Color.h> #include <etk/Color.h>
const char * const ewol::widget::ColorBar::eventChange = "change";
#undef __class__ #undef __class__
#define __class__ "ColorBar" #define __class__ "ColorBar"
ewol::widget::ColorBar::ColorBar() { ewol::widget::ColorBar::ColorBar() :
signalChange(*this, "change", "Color value change") {
addObjectType("ewol::widget::ColorBar"); addObjectType("ewol::widget::ColorBar");
addEventId(eventChange);
m_currentUserPos.setValue(0,0); m_currentUserPos.setValue(0,0);
m_currentColor = etk::color::black; m_currentColor = etk::color::black;
setCanHaveFocus(true); setCanHaveFocus(true);
@ -224,7 +220,7 @@ bool ewol::widget::ColorBar::onEventInput(const ewol::event::Input& _event) {
} }
if(m_currentColor != estimateColor) { if(m_currentColor != estimateColor) {
m_currentColor = estimateColor; m_currentColor = estimateColor;
generateEventId(eventChange); signalChange.emit(shared_from_this(), m_currentColor);
} }
return true; return true;
} }

3
sources/ewol/widget/ColorBar.h
View File

@ -14,6 +14,7 @@
#include <etk/Color.h> #include <etk/Color.h>
#include <ewol/widget/Widget.h> #include <ewol/widget/Widget.h>
#include <ewol/compositing/Drawing.h> #include <ewol/compositing/Drawing.h>
#include <ewol/object/Signal.h>
namespace ewol { namespace ewol {
@ -21,7 +22,7 @@ namespace ewol {
class ColorBar : public ewol::Widget { class ColorBar : public ewol::Widget {
public: public:
// Event list of properties // Event list of properties
static const char * const eventChange; ewol::object::Signal<etk::Color<>> signalChange;
protected: protected:
ColorBar(); ColorBar();
void init(); void init();

22
sources/ewol/widget/Entry.cpp
View File

@ -29,11 +29,10 @@ const char * const ewolEventEntrySelect = "ewol-widget-entry-event-internal-sele
#define STATUS_HOVER (1) #define STATUS_HOVER (1)
#define STATUS_SELECTED (2) #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() : 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_shaper(*this, "shaper", "Shaper to display the background"),
m_data(*this, "value", "", "Value display in the entry (decorated text)"), 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"), 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)") { m_textWhenNothing(*this, "emptytext", "", "Text that is displayed when the Entry is empty (decorated text)") {
addObjectType("ewol::widget::Entry"); addObjectType("ewol::widget::Entry");
setCanHaveFocus(true); setCanHaveFocus(true);
addEventId(eventClick);
addEventId(eventEnter);
addEventId(eventModify);
shortCutAdd("ctrl+w", ewolEventEntryClean); shortCutAdd("ctrl+w", ewolEventEntryClean);
shortCutAdd("ctrl+x", ewolEventEntryCut); shortCutAdd("ctrl+x", ewolEventEntryCut);
shortCutAdd("ctrl+c", ewolEventEntryCopy); shortCutAdd("ctrl+c", ewolEventEntryCopy);
@ -244,7 +240,7 @@ bool ewol::widget::Entry::onEventInput(const ewol::event::Input& _event) {
if (1 == _event.getId()) { if (1 == _event.getId()) {
if (ewol::key::statusSingle == _event.getStatus()) { if (ewol::key::statusSingle == _event.getStatus()) {
keepFocus(); keepFocus();
generateEventId(eventClick); signalClick.emit(shared_from_this());
//nothing to do ... //nothing to do ...
return true; return true;
} else if (ewol::key::statusDouble == _event.getStatus()) { } 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) { bool ewol::widget::Entry::onEventEntry(const ewol::event::Entry& _event) {
if (_event.getType() == ewol::key::keyboardChar) { if (_event.getType() == ewol::key::keyboardChar) {
if(_event.getStatus() == ewol::key::statusDown) { if(_event.getStatus() == ewol::key::statusDown) {
//EWOL_DEBUG("Entry input data ... : \"" << unicodeData << "\" " );
//return GenEventInputExternal(eventEnter, -1, -1);
// remove curent selected data ... // remove curent selected data ...
removeSelected(); removeSelected();
if( _event.getChar() == '\n' if( _event.getChar() == '\n'
|| _event.getChar() == '\r') { || _event.getChar() == '\r') {
generateEventId(eventEnter, m_data); signalEnter.emit(shared_from_this(), m_data);
return true; return true;
} else if (_event.getChar() == 0x7F) { } else if (_event.getChar() == 0x7F) {
// SUPPR : // 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(); markToRedraw();
return true; return true;
} }
@ -443,7 +437,7 @@ void ewol::widget::Entry::onEventClipboard(enum ewol::context::clipBoard::clipbo
markToRedraw(); 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) { } else if(_msg.getMessage() == ewolEventEntryCut) {
copySelectionToClipBoard(ewol::context::clipBoard::clipboardStd); copySelectionToClipBoard(ewol::context::clipBoard::clipboardStd);
removeSelected(); removeSelected();
generateEventId(eventModify, m_data); signalModify.emit(shared_from_this(), m_data);
} else if(_msg.getMessage() == ewolEventEntryCopy) { } else if(_msg.getMessage() == ewolEventEntryCopy) {
copySelectionToClipBoard(ewol::context::clipBoard::clipboardStd); copySelectionToClipBoard(ewol::context::clipBoard::clipboardStd);
} else if(_msg.getMessage() == ewolEventEntryPaste) { } else if(_msg.getMessage() == ewolEventEntryPaste) {

8
sources/ewol/widget/Entry.h
View File

@ -18,6 +18,7 @@
#include <ewol/widget/Widget.h> #include <ewol/widget/Widget.h>
#include <etk/Color.h> #include <etk/Color.h>
#include <ewol/widget/Manager.h> #include <ewol/widget/Manager.h>
#include <ewol/object/Signal.h>
namespace ewol { namespace ewol {
namespace widget { namespace widget {
@ -33,10 +34,9 @@ namespace ewol {
*/ */
class Entry : public ewol::Widget { class Entry : public ewol::Widget {
public: public:
// Event list of properties ewol::object::Signal<void> signalClick; //!< bang on click the entry box
static const char * const eventClick; ewol::object::Signal<std::string> signalEnter; //!< Enter key is pressed
static const char * const eventEnter; ewol::object::Signal<std::string> signalModify; //!< data change
static const char * const eventModify; // return in the data the new string inside it ...
private: private:
ewol::object::Param<ewol::compositing::Shaper> m_shaper; ewol::object::Param<ewol::compositing::Shaper> m_shaper;
int32_t m_colorIdTextFg; //!< color property of the text foreground int32_t m_colorIdTextFg; //!< color property of the text foreground

6
sources/ewol/widget/Image.cpp
View File

@ -16,9 +16,8 @@
#undef __class__ #undef __class__
#define __class__ "Image" #define __class__ "Image"
const char * const ewol::widget::Image::eventPressed = "pressed";
ewol::widget::Image::Image() : ewol::widget::Image::Image() :
signalPressed(*this, "pressed", "Image is pressed"),
m_colorProperty(nullptr), m_colorProperty(nullptr),
m_colorId(-1), m_colorId(-1),
m_fileName(*this, "src", "", "Image source path"), 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_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") { m_distanceFieldMode(*this, "distance-field", false, "Distance field mode") {
addObjectType("ewol::widget::Image"); addObjectType("ewol::widget::Image");
addEventId(eventPressed);
m_colorProperty = ewol::resource::ColorFile::create("THEME:COLOR:Image.json"); m_colorProperty = ewol::resource::ColorFile::create("THEME:COLOR:Image.json");
if (m_colorProperty != nullptr) { if (m_colorProperty != nullptr) {
m_colorId = m_colorProperty->request("foreground"); 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 ..."); //EWOL_DEBUG("Event on BT ...");
if (1 == _event.getId()) { if (1 == _event.getId()) {
if(ewol::key::statusSingle == _event.getStatus()) { if(ewol::key::statusSingle == _event.getStatus()) {
generateEventId(eventPressed); signalPressed.emit(shared_from_this());
return true; return true;
} }
} }

3
sources/ewol/widget/Image.h
View File

@ -16,6 +16,7 @@
#include <ewol/compositing/Image.h> #include <ewol/compositing/Image.h>
#include <ewol/resource/ColorFile.h> #include <ewol/resource/ColorFile.h>
#include <ewol/widget/Manager.h> #include <ewol/widget/Manager.h>
#include <ewol/object/Signal.h>
namespace ewol { namespace ewol {
namespace widget { namespace widget {
@ -25,7 +26,7 @@ namespace ewol {
class Image :public ewol::Widget { class Image :public ewol::Widget {
public: public:
// Event list of properties // Event list of properties
static const char * const eventPressed; ewol::object::Signal<void> signalPressed;
protected: protected:
ewol::compositing::Image m_compositing; //!< compositing element of the image. ewol::compositing::Image m_compositing; //!< compositing element of the image.
std::shared_ptr<ewol::resource::ColorFile> m_colorProperty; //!< theme color property std::shared_ptr<ewol::resource::ColorFile> m_colorProperty; //!< theme color property

18
sources/ewol/widget/Joystick.cpp
View File

@ -12,10 +12,6 @@
#include <ewol/compositing/Image.h> #include <ewol/compositing/Image.h>
#include <ewol/widget/Manager.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 bool l_displayBackground(true);
static std::string l_background(""); static std::string l_background("");
static std::string l_foreground(""); static std::string l_foreground("");
@ -24,11 +20,11 @@ static float l_ratio(1.0/7.0);
#undef __class__ #undef __class__
#define __class__ "Joystick" #define __class__ "Joystick"
ewol::widget::Joystick::Joystick() { ewol::widget::Joystick::Joystick() :
signalEnable(*this, "enable"),
signalDisable(*this, "disable"),
signalMove(*this, "move") {
addObjectType("ewol::widget::Joystick"); addObjectType("ewol::widget::Joystick");
addEventId(eventEnable);
addEventId(eventDisable);
addEventId(eventMove);
// by default the joy does not lock when free out // by default the joy does not lock when free out
m_lock = false; m_lock = false;
m_displayMode = modeNormal; m_displayMode = modeNormal;
@ -148,10 +144,10 @@ bool ewol::widget::Joystick::onEventInput(const ewol::event::Input& _event) {
} }
markToRedraw(); markToRedraw();
if(ewol::key::statusDown == typeEvent) { if(ewol::key::statusDown == typeEvent) {
generateEventId(eventEnable); signalEnable.emit(shared_from_this());
} else { } else {
std::string tmp = std::string("distance=") + std::string(m_distance) + std::string("angle=") + std::string(m_angle+M_PI/2); 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; //teta += M_PI/2;
//EWOL_DEBUG("TETA = " << (m_angle*180/M_PI) << " deg distance = " << m_distance); //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; m_distance = 0;
} }
markToRedraw(); markToRedraw();
generateEventId(eventDisable); signalDisable.emit(shared_from_this());
return true; return true;
} }
return false; return false;

9
sources/ewol/widget/Joystick.h
View File

@ -13,6 +13,7 @@
#include <ewol/debug.h> #include <ewol/debug.h>
#include <ewol/widget/Widget.h> #include <ewol/widget/Widget.h>
#include <draw/Color.h> #include <draw/Color.h>
#include <ewol/object/Signal.h>
namespace ewol { namespace ewol {
@ -23,9 +24,9 @@ namespace ewol {
class Joystick :public ewol::Widget { class Joystick :public ewol::Widget {
public: public:
// Event list of properties // Event list of properties
static const char * const eventEnable; ewol::object::Signal<void> signalEnable;
static const char * const eventDisable; ewol::object::Signal<void> signalDisable;
static const char * const eventMove; ewol::object::Signal<vec2> signalMove;
public: public:
enum joystickMode { enum joystickMode {
modeNormal, modeNormal,
@ -34,7 +35,7 @@ namespace ewol {
private: private:
draw::Color m_colorFg; //!< Forground color draw::Color m_colorFg; //!< Forground color
draw::Color m_colorBg; //!< Background 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_distance; //!< dintance from the center
float m_angle; //!< angle of the arraw (if < 0 : No arraw...) 0 is the TOP ... 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 bool m_lock; //!< flag to mark the lock when the cursor is free when we are outside the circle

6
sources/ewol/widget/Label.cpp
View File

@ -15,10 +15,9 @@
#undef __class__ #undef __class__
#define __class__ "Label" #define __class__ "Label"
const char * const ewol::widget::Label::eventPressed = "pressed";
// TODO : Remove the label name in the constructor ... // TODO : Remove the label name in the constructor ...
ewol::widget::Label::Label() : ewol::widget::Label::Label() :
signalPressed(*this, "pressed"),
m_label(*this, "value", U"", "displayed value string"), m_label(*this, "value", U"", "displayed value string"),
m_colorProperty(nullptr), m_colorProperty(nullptr),
m_colorDefaultFgText(-1), m_colorDefaultFgText(-1),
@ -29,7 +28,6 @@ ewol::widget::Label::Label() :
m_colorDefaultFgText = m_colorProperty->request("foreground"); m_colorDefaultFgText = m_colorProperty->request("foreground");
m_colorDefaultBgText = m_colorProperty->request("background"); m_colorDefaultBgText = m_colorProperty->request("background");
} }
addEventId(eventPressed);
setCanHaveFocus(false); setCanHaveFocus(false);
setMouseLimit(1); setMouseLimit(1);
} }
@ -126,7 +124,7 @@ bool ewol::widget::Label::onEventInput(const ewol::event::Input& _event) {
if (1 == _event.getId()) { if (1 == _event.getId()) {
if (ewol::key::statusSingle == _event.getStatus()) { if (ewol::key::statusSingle == _event.getStatus()) {
// nothing to do ... // nothing to do ...
generateEventId(eventPressed); signalPressed.emit(shared_from_this());
return true; return true;
} }
} }

3
sources/ewol/widget/Label.h
View File

@ -15,6 +15,7 @@
#include <ewol/widget/Widget.h> #include <ewol/widget/Widget.h>
#include <ewol/widget/Manager.h> #include <ewol/widget/Manager.h>
#include <ewol/resource/ColorFile.h> #include <ewol/resource/ColorFile.h>
#include <ewol/object/Signal.h>
namespace ewol { namespace ewol {
namespace widget { namespace widget {
@ -24,7 +25,7 @@ namespace ewol {
class Label : public ewol::Widget { class Label : public ewol::Widget {
public: public:
// Event list of properties // Event list of properties
static const char * const eventPressed; ewol::object::Signal<void> signalPressed;
private: private:
ewol::compositing::Text m_text; //!< Compositing text element. ewol::compositing::Text m_text; //!< Compositing text element.
ewol::object::Param<std::u32string> m_label; //!< decorated text to display. ewol::object::Param<std::u32string> m_label; //!< decorated text to display.

34
sources/ewol/widget/ListFileSystem.cpp
View File

@ -15,13 +15,11 @@
#undef __class__ #undef __class__
#define __class__ "ListFileSystem" #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() : ewol::widget::ListFileSystem::ListFileSystem() :
signalFileSelect(*this, "file-select"),
signalFileValidate(*this, "file-validate"),
signalFolderSelect(*this, "folder-select"),
signalFolderValidate(*this, "folder-validate"),
m_selectedLine(-1), m_selectedLine(-1),
m_folder(*this, "path", "/", "Path to display"), m_folder(*this, "path", "/", "Path to display"),
m_selectFile(*this, "select", "", "selection af a specific file"), m_selectFile(*this, "select", "", "selection af a specific file"),
@ -40,11 +38,6 @@ ewol::widget::ListFileSystem::ListFileSystem() :
m_colorIdBackground2 = m_colorProperty->request("background2"); m_colorIdBackground2 = m_colorProperty->request("background2");
m_colorIdBackgroundSelected = m_colorProperty->request("selected"); m_colorIdBackgroundSelected = m_colorProperty->request("selected");
} }
addEventId(eventFileSelect);
addEventId(eventFileValidate);
addEventId(eventFolderSelect);
addEventId(eventFolderValidate);
setMouseLimit(1); setMouseLimit(1);
}; };
@ -192,21 +185,21 @@ bool ewol::widget::ListFileSystem::onItemEvent(int32_t _IdInput,
if( m_showFolder == true if( m_showFolder == true
&& m_selectedLine == 0) { && m_selectedLine == 0) {
// "." folder // "." folder
generateEventId(eventFolderSelect, "."); signalFolderSelect.emit(shared_from_this(), ".");
} else if ( m_showFolder == true } else if ( m_showFolder == true
&& m_selectedLine == 1) { && m_selectedLine == 1) {
// ".." folder // ".." folder
generateEventId(eventFolderSelect, ".."); signalFolderSelect.emit(shared_from_this(), "..");
} else if( m_selectedLine-offset >= 0 } else if( m_selectedLine-offset >= 0
&& m_selectedLine-offset < (int32_t)m_list.size() && m_selectedLine-offset < (int32_t)m_list.size()
&& nullptr != m_list[m_selectedLine-offset] ) { && nullptr != m_list[m_selectedLine-offset] ) {
// generate event extern : // generate event extern :
switch(m_list[m_selectedLine-offset]->getNodeType()) { switch(m_list[m_selectedLine-offset]->getNodeType()) {
case etk::FSN_FILE : case etk::FSN_FILE :
generateEventId(eventFileSelect, m_list[m_selectedLine-offset]->getNameFile()); signalFileSelect.emit(shared_from_this(), m_list[m_selectedLine-offset]->getNameFile());
break; break;
case etk::FSN_FOLDER : case etk::FSN_FOLDER :
generateEventId(eventFolderSelect, m_list[m_selectedLine-offset]->getNameFile()); signalFolderSelect.emit(shared_from_this(), m_list[m_selectedLine-offset]->getNameFile());
break; break;
default: default:
EWOL_ERROR("Can not generate event on an unknow type"); 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 if( m_showFolder == true
&& m_selectedLine == 0) { && m_selectedLine == 0) {
// "." folder // "." folder
generateEventId(eventFolderValidate, "."); signalFolderValidate.emit(shared_from_this(), ".");
} else if ( m_showFolder == true } else if ( m_showFolder == true
&& m_selectedLine == 1) { && m_selectedLine == 1) {
// ".." folder // ".." folder
generateEventId(eventFolderValidate, ".."); signalFolderValidate.emit(shared_from_this(), "..");
} else if( m_selectedLine-offset >= 0 } else if( m_selectedLine-offset >= 0
&& m_selectedLine-offset < (int32_t)m_list.size() && m_selectedLine-offset < (int32_t)m_list.size()
&& nullptr != m_list[m_selectedLine-offset] ) { && nullptr != m_list[m_selectedLine-offset] ) {
switch(m_list[m_selectedLine-offset]->getNodeType()) switch(m_list[m_selectedLine-offset]->getNodeType()) {
{
case etk::FSN_FILE : case etk::FSN_FILE :
generateEventId(eventFileValidate, m_list[m_selectedLine-offset]->getNameFile()); signalFileValidate.emit(shared_from_this(), m_list[m_selectedLine-offset]->getNameFile());
break; break;
case etk::FSN_FOLDER : case etk::FSN_FOLDER :
generateEventId(eventFolderValidate, m_list[m_selectedLine-offset]->getNameFile()); signalFolderValidate.emit(shared_from_this(), m_list[m_selectedLine-offset]->getNameFile());
break; break;
default: default:
EWOL_ERROR("Can not generate event on an unknow type"); EWOL_ERROR("Can not generate event on an unknow type");

9
sources/ewol/widget/ListFileSystem.h
View File

@ -12,6 +12,7 @@
#include <ewol/widget/List.h> #include <ewol/widget/List.h>
#include <etk/os/FSNode.h> #include <etk/os/FSNode.h>
#include <ewol/resource/ColorFile.h> #include <ewol/resource/ColorFile.h>
#include <ewol/object/Signal.h>
namespace ewol { namespace ewol {
namespace widget { namespace widget {
@ -21,10 +22,10 @@ namespace ewol {
class ListFileSystem : public ewol::widget::List { class ListFileSystem : public ewol::widget::List {
public: public:
// Event list of properties // Event list of properties
static const char * const eventFileSelect; //!< @event "file-select" Generated when a file is selected. ewol::object::Signal<std::string> signalFileSelect; //!< @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 ewol::object::Signal<std::string> signalFileValidate; //!< @event "file-validate" Generate when the user validate (return) or double click on the element
static const char * const eventFolderSelect; ewol::object::Signal<std::string> signalFolderSelect;
static const char * const eventFolderValidate; ewol::object::Signal<std::string> signalFolderValidate;
protected: protected:
ListFileSystem(); ListFileSystem();
void init(); void init();

8
sources/ewol/widget/Menu.cpp
View File

@ -60,6 +60,8 @@ int32_t ewol::widget::Menu::addTitle(std::string _label,
return add(-1, _label, _image, _generateEvent, _message); return add(-1, _label, _image, _generateEvent, _message);
} }
static const char* eventButtonPressed = "menu-local-pressed";
int32_t ewol::widget::Menu::add(int32_t _parent, int32_t ewol::widget::Menu::add(int32_t _parent,
std::string _label, std::string _label,
std::string _image, std::string _image,
@ -95,7 +97,7 @@ int32_t ewol::widget::Menu::add(int32_t _parent,
// add it in the widget list // add it in the widget list
ewol::widget::Sizer::subWidgetAdd(myButton); ewol::widget::Sizer::subWidgetAdd(myButton);
// keep the specific event ... // 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; tmpObject.m_widgetPointer = myButton;
} }
m_listElement.push_back(tmpObject); m_listElement.push_back(tmpObject);
@ -114,7 +116,7 @@ void ewol::widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
} }
*/ */
EWOL_ERROR(" receive message : " << _msg); EWOL_ERROR(" receive message : " << _msg);
if (_msg.getMessage() == ewol::widget::Button::eventPressed) { if (_msg.getMessage() == eventButtonPressed) {
for (auto &it : m_listElement) { for (auto &it : m_listElement) {
if (_msg.getCaller() == it.m_widgetPointer.lock()) { if (_msg.getCaller() == it.m_widgetPointer.lock()) {
// 2 posible case (have a message or have a child ... // 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 ... // 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->setExpand(bvec2(true,false));
myButton->setFill(bvec2(true,false)); myButton->setFill(bvec2(true,false));
// add it in the widget list // add it in the widget list

8
sources/ewol/widget/Slider.cpp
View File

@ -10,16 +10,14 @@
#include <ewol/widget/Manager.h> #include <ewol/widget/Manager.h>
const char * const ewol::widget::Slider::eventChange = "change";
#undef __class__ #undef __class__
#define __class__ "Slider" #define __class__ "Slider"
const int32_t dotRadius = 6; const int32_t dotRadius = 6;
ewol::widget::Slider::Slider() { ewol::widget::Slider::Slider() :
signalChange(*this, "change") {
addObjectType("ewol::widget::Slider"); addObjectType("ewol::widget::Slider");
addEventId(eventChange);
m_value = 0; m_value = 0;
m_min = 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); m_value = std::max(std::min(m_value, m_max), m_min);
if (oldValue != m_value) { if (oldValue != m_value) {
EWOL_DEBUG(" new value : " << m_value << " in [" << m_min << ".." << m_max << "]"); 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(); markToRedraw();
} }
return true; return true;

3
sources/ewol/widget/Slider.h
View File

@ -14,6 +14,7 @@
#include <ewol/debug.h> #include <ewol/debug.h>
#include <ewol/widget/Widget.h> #include <ewol/widget/Widget.h>
#include <ewol/compositing/Drawing.h> #include <ewol/compositing/Drawing.h>
#include <ewol/object/Signal.h>
namespace ewol { namespace ewol {
namespace widget { namespace widget {
@ -23,7 +24,7 @@ namespace ewol {
class Slider : public ewol::Widget { class Slider : public ewol::Widget {
public: public:
// Event list of properties // Event list of properties
static const char * const eventChange; ewol::object::Signal<int32_t> signalChange;
protected: protected:
Slider(); Slider();
void init(); void init();

12
sources/ewol/widget/WSlider.cpp
View File

@ -23,11 +23,9 @@ std::ostream& operator <<(std::ostream& _os, const enum ewol::widget::WSlider::s
#undef __class__ #undef __class__
#define __class__ "WSlider" #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() : ewol::widget::WSlider::WSlider() :
signalStartSlide(*this, "start"),
signalStopSlide(*this, "stop"),
m_windowsSources(0), m_windowsSources(0),
m_windowsDestination(0), m_windowsDestination(0),
m_windowsRequested(-1), 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_transitionSpeed(*this, "speed", 1.0f, 0.0f, 200.0f, "Transition speed of the slider"),
m_transitionSlide(*this, "mode", sladingTransitionHori, "Transition mode of the slider") { m_transitionSlide(*this, "mode", sladingTransitionHori, "Transition mode of the slider") {
addObjectType("ewol::widget::WSlider"); addObjectType("ewol::widget::WSlider");
addEventId(eventStartSlide);
addEventId(eventStopSlide);
m_transitionSlide.add(sladingTransitionVert, "vert"); m_transitionSlide.add(sladingTransitionVert, "vert");
m_transitionSlide.add(sladingTransitionHori, "hori"); m_transitionSlide.add(sladingTransitionHori, "hori");
} }
@ -105,7 +101,7 @@ void ewol::widget::WSlider::subWidgetSelectSetVectorId(int32_t _id) {
} }
if (_id != m_windowsDestination) { if (_id != m_windowsDestination) {
m_windowsRequested = _id; m_windowsRequested = _id;
generateEventId(eventStartSlide); signalStartSlide.emit(shared_from_this());
periodicCallEnable(); periodicCallEnable();
markToRedraw(); markToRedraw();
} }
@ -189,7 +185,7 @@ void ewol::widget::WSlider::periodicCall(const ewol::event::Time& _event) {
} else { } else {
// end of periodic : // end of periodic :
periodicCallDisable(); periodicCallDisable();
generateEventId(eventStopSlide); signalStopSlide.emit(shared_from_this());
} }
m_windowsRequested = -1; m_windowsRequested = -1;
} }

5
sources/ewol/widget/WSlider.h
View File

@ -13,6 +13,7 @@
#include <ewol/debug.h> #include <ewol/debug.h>
#include <ewol/widget/ContainerN.h> #include <ewol/widget/ContainerN.h>
#include <ewol/widget/Manager.h> #include <ewol/widget/Manager.h>
#include <ewol/object/Signal.h>
namespace ewol { namespace ewol {
namespace widget { namespace widget {
@ -22,8 +23,8 @@ namespace ewol {
class WSlider :public ewol::widget::ContainerN { class WSlider :public ewol::widget::ContainerN {
public: public:
// Event list of properties // Event list of properties
static const char* const eventStartSlide; ewol::object::Signal<void> signalStartSlide;
static const char* const eventStopSlide; ewol::object::Signal<void> signalStopSlide;
enum sladingMode { enum sladingMode {
sladingTransitionVert, sladingTransitionVert,
sladingTransitionHori, sladingTransitionHori,

12
sources/ewol/widget/Widget.cpp
View File

@ -86,11 +86,6 @@ std::ostream& ewol::operator <<(std::ostream& _os, const enum ewol::gravity _obj
#undef __class__ #undef __class__
#define __class__ "Widget" #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() : ewol::Widget::Widget() :
m_size(10,10), m_size(10,10),
m_minSize(0,0), m_minSize(0,0),
@ -113,6 +108,9 @@ ewol::Widget::Widget() :
m_needRegenerateDisplay(true), m_needRegenerateDisplay(true),
m_grabCursor(false), m_grabCursor(false),
m_cursorDisplay(ewol::context::cursorArrow), m_cursorDisplay(ewol::context::cursorArrow),
signalAnnimationStart(*this, "annimation-start"),
signalAnnimationRatio(*this, "annimation-ratio"),
signalAnnimationStop(*this, "annimation-stop"),
m_annimationMode(annimationModeDisable), m_annimationMode(annimationModeDisable),
m_annimationratio(0.0f), m_annimationratio(0.0f),
m_annimationTypeStart(*this, "annimation-start-type", 0, "Annimation type, when adding/show a widget"), 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_gravity.add(ewol::gravityLeft, "left");
m_annimationTypeStart.add(0, "none"); m_annimationTypeStart.add(0, "none");
m_annimationTypeStop.add(0, "none"); m_annimationTypeStop.add(0, "none");
addEventId(eventAnnimationStart);
addEventId(eventAnnimationRatio);
addEventId(eventAnnimationStop);
} }
void ewol::Widget::init() { void ewol::Widget::init() {

7
sources/ewol/widget/Widget.h
View File

@ -31,6 +31,7 @@ namespace ewol {
#include <ewol/event/Entry.h> #include <ewol/event/Entry.h>
#include <ewol/event/Time.h> #include <ewol/event/Time.h>
#include <ewol/translate.h> #include <ewol/translate.h>
#include <ewol/object/Signal.h>
#define ULTIMATE_MAX_SIZE (99999999) #define ULTIMATE_MAX_SIZE (99999999)
@ -713,9 +714,9 @@ namespace ewol {
*/ */
public: public:
// event generated : // event generated :
static const char* const eventAnnimationStart; //!< event when start annimation ewol::object::Signal<void> signalAnnimationStart; //!< event when start annimation
static const char* const eventAnnimationRatio; //!< event when % of annimation change (integer) ewol::object::Signal<float> signalAnnimationRatio; //!< event when % of annimation change (integer)
static const char* const eventAnnimationStop; //!< event when stop annimation ewol::object::Signal<void> signalAnnimationStop; //!< event when stop annimation
protected: protected:
enum annimationMode { enum annimationMode {
annimationModeEnableAdd, annimationModeEnableAdd,

12
sources/ewol/widget/meta/ColorChooser.cpp
View File

@ -22,17 +22,13 @@ extern "C" {
#undef __class__ #undef __class__
#define __class__ "ColorChooser" #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 eventColorBarHasChange = "event-color-bar-has-change";
static const char * const eventColorSpecificHasChange = "event-color-specific-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"); addObjectType("ewol::widget::ColorChooser");
addEventId(eventChange);
} }
void ewol::widget::ColorChooser::init() { void ewol::widget::ColorChooser::init() {
@ -140,7 +136,7 @@ void ewol::widget::ColorChooser::onReceiveMessage(const ewol::object::Message& _
if (nullptr != m_widgetAlpha) { if (nullptr != m_widgetAlpha) {
m_widgetAlpha->setValue(m_currentColor.a()); m_widgetAlpha->setValue(m_currentColor.a());
} }
generateEventId(eventChange, m_currentColor.getString()); signalChange.emit(shared_from_this(), m_currentColor);
} else if (eventColorSpecificHasChange == _msg.getMessage()) { } else if (eventColorSpecificHasChange == _msg.getMessage()) {
// Slider has changes his color == > get the one change ... // Slider has changes his color == > get the one change ...
if (_msg.getCaller() == m_widgetRed) { if (_msg.getCaller() == m_widgetRed) {
@ -158,7 +154,7 @@ void ewol::widget::ColorChooser::onReceiveMessage(const ewol::object::Message& _
if (nullptr != m_widgetColorBar) { if (nullptr != m_widgetColorBar) {
m_widgetColorBar->setCurrentColor(m_currentColor); m_widgetColorBar->setCurrentColor(m_currentColor);
} }
generateEventId(eventChange, m_currentColor.getString()); signalChange.emit(shared_from_this(), m_currentColor);
} }
}; };

3
sources/ewol/widget/meta/ColorChooser.h
View File

@ -18,6 +18,7 @@
#include <ewol/widget/Sizer.h> #include <ewol/widget/Sizer.h>
#include <ewol/widget/ColorBar.h> #include <ewol/widget/ColorBar.h>
#include <ewol/widget/Slider.h> #include <ewol/widget/Slider.h>
#include <ewol/object/Signal.h>
namespace ewol { namespace ewol {
namespace widget { namespace widget {
@ -27,7 +28,7 @@ namespace ewol {
class ColorChooser : public ewol::widget::Sizer { class ColorChooser : public ewol::widget::Sizer {
public: public:
// Event list of properties // Event list of properties
static const char * const eventChange; ewol::object::Signal<etk::Color<>> signalChange;
protected: protected:
ColorChooser(); ColorChooser();
void init(); void init();

25
sources/ewol/widget/meta/FileChooser.cpp
View File

@ -30,9 +30,8 @@ extern "C" {
#define __class__ "FileChooser" #define __class__ "FileChooser"
const char * const ewol::widget::FileChooser::eventCancel = "cancel"; static const char * const ewolEventFileChooserCancel = "ewol-event-file-chooser-cancel";
const char * const ewol::widget::FileChooser::eventValidate = "validate"; 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 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 ewolEventFileChooserEntryFolder = "ewol-event-file-chooser-modify-entry-folder";
static const char * const ewolEventFileChooserEntryFolderEnter = "ewol-event-file-chooser-modify-entry-folder-enter"; 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"; 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"); addObjectType("ewol::widget::FileChooser");
addEventId(eventCancel);
addEventId(eventValidate);
} }
void ewol::widget::FileChooser::init() { void ewol::widget::FileChooser::init() {
@ -107,8 +106,8 @@ void ewol::widget::FileChooser::init() {
+ "</popup>"; + "</popup>";
loadFromString(myDescription); loadFromString(myDescription);
registerOnEventNameWidget("[" + etk::to_string(getId()) + "]file-shooser:show-hiden-file", "value", ewolEventFileChooserHidenFileChange); 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-validate", "pressed", ewolEventFileChooserValidate);
registerOnEventNameWidget("[" + etk::to_string(getId()) + "]file-shooser:button-cancel", "pressed", eventCancel); 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-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-select", ewolEventFileChooserListFile);
registerOnEventNameWidget("[" + etk::to_string(getId()) + "]file-shooser:list-files", "file-validate", ewolEventFileChooserListFileValidate); 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(); m_file = _msg.getData();
// update the selected file in the list : // update the selected file in the list :
parameterSetOnWidgetNamed("[" + etk::to_string(getId()) + "]file-shooser:list-files", "select", m_file); parameterSetOnWidgetNamed("[" + etk::to_string(getId()) + "]file-shooser:list-files", "select", m_file);
} else if (eventCancel == _msg.getMessage()) { } else if (ewolEventFileChooserCancel == _msg.getMessage()) {
// == > Auto remove ... // == > Auto remove ...
generateEventId(_msg.getMessage()); signalCancel.emit(shared_from_this());
autoDestroy(); autoDestroy();
} else if (_msg.getMessage() == ewolEventFileChooserHidenFileChange) { } else if (_msg.getMessage() == ewolEventFileChooserHidenFileChange) {
if (_msg.getData() == "true") { if (_msg.getData() == "true") {
@ -187,16 +186,16 @@ void ewol::widget::FileChooser::onReceiveMessage(const ewol::object::Message& _m
setFileName(_msg.getData()); setFileName(_msg.getData());
std::string tmpFileCompleatName = m_folder; std::string tmpFileCompleatName = m_folder;
tmpFileCompleatName += m_file; tmpFileCompleatName += m_file;
generateEventId(_msg.getMessage(), tmpFileCompleatName); // TODO : generateEventId(_msg.getMessage(), tmpFileCompleatName);
} else if( _msg.getMessage() == ewolEventFileChooserListFileValidate } else if( _msg.getMessage() == ewolEventFileChooserListFileValidate
|| (_msg.getMessage() == eventValidate && m_file != "" ) || (_msg.getMessage() == ewolEventFileChooserValidate && m_file != "" )
|| (_msg.getMessage() == ewolEventFileChooserEntryFileEnter && m_file != "" ) ) { || (_msg.getMessage() == ewolEventFileChooserEntryFileEnter && m_file != "" ) ) {
// select the file == > generate a validate // select the file == > generate a validate
if (_msg.getData() != "") { if (_msg.getData() != "") {
setFileName(_msg.getData()); setFileName(_msg.getData());
} }
EWOL_VERBOSE(" generate a fiel opening : \"" << m_folder << "\" / \"" << m_file << "\""); EWOL_VERBOSE(" generate a fiel opening : \"" << m_folder << "\" / \"" << m_file << "\"");
generateEventId(eventValidate, getCompleateFileName()); signalValidate.emit(shared_from_this(), getCompleateFileName());
autoDestroy(); autoDestroy();
} else if(_msg.getMessage() == ewolEventFileChooserHome) { } else if(_msg.getMessage() == ewolEventFileChooserHome) {
std::string tmpUserFolder = etk::getUserHomeFolder(); std::string tmpUserFolder = etk::getUserHomeFolder();

5
sources/ewol/widget/meta/FileChooser.h
View File

@ -12,6 +12,7 @@
#include <etk/types.h> #include <etk/types.h>
#include <ewol/debug.h> #include <ewol/debug.h>
#include <ewol/widget/Composer.h> #include <ewol/widget/Composer.h>
#include <ewol/object/Signal.h>
namespace ewol { namespace ewol {
namespace widget { namespace widget {
@ -74,8 +75,8 @@ namespace ewol {
class FileChooser : public ewol::widget::Composer { class FileChooser : public ewol::widget::Composer {
public: public:
// Event list of properties // Event list of properties
static const char* const eventCancel; ewol::object::Signal<void> signalCancel;
static const char* const eventValidate; ewol::object::Signal<std::string> signalValidate;
protected: protected:
FileChooser(); FileChooser();
void init(); void init();

12
sources/ewol/widget/meta/Parameter.cpp
View File

@ -20,19 +20,17 @@
#undef __class__ #undef __class__
#define __class__ "Parameter" #define __class__ "Parameter"
const char * const ewol::widget::Parameter::eventClose = "close";
static const char * const ewolEventParameterValidate = "ewol-event-parameter-validate"; static const char * const ewolEventParameterValidate = "ewol-event-parameter-validate";
static const char * const ewolEventParameterSave = "ewol-event-parameter-save"; static const char * const ewolEventParameterSave = "ewol-event-parameter-save";
static const char * const l_eventMenuSelected = "local-event-menu-selected"; static const char * const l_eventMenuSelected = "local-event-menu-selected";
static const char * const ewolEventMenuclosed = "local-event-menu-closed";
ewol::widget::Parameter::Parameter() : ewol::widget::Parameter::Parameter() :
signalClose(*this, "close"),
m_currentIdList(0), m_currentIdList(0),
m_widgetTitle(), m_widgetTitle(),
m_paramList() { m_paramList() {
addObjectType("ewol::widget::Parameter"); addObjectType("ewol::widget::Parameter");
addEventId(eventClose);
} }
void ewol::widget::Parameter::init() { void ewol::widget::Parameter::init() {
@ -106,7 +104,7 @@ void ewol::widget::Parameter::init() {
" <label>Close</label>\n" " <label>Close</label>\n"
" </sizer>\n" " </sizer>\n"
"</composer>\n")); "</composer>\n"));
tmpButton->registerOnEvent(shared_from_this(), "pressed", eventClose); tmpButton->registerOnEvent(shared_from_this(), "pressed", ewolEventMenuclosed);
mySizerHori->subWidgetAdd(tmpButton); 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) { void ewol::widget::Parameter::onReceiveMessage(const ewol::object::Message& _msg) {
ewol::widget::PopUp::onReceiveMessage(_msg); ewol::widget::PopUp::onReceiveMessage(_msg);
EWOL_DEBUG("event on the parameter : " << _msg); EWOL_DEBUG("event on the parameter : " << _msg);
if (_msg.getMessage() == eventClose) { if (_msg.getMessage() == ewolEventMenuclosed) {
// inform that the parameter windows is closed // inform that the parameter windows is closed
generateEventId(eventClose); signalClose.emit(shared_from_this());
// close this widget ... // close this widget ...
autoDestroy(); autoDestroy();
} else if (_msg.getMessage() == ewolEventParameterSave) { } else if (_msg.getMessage() == ewolEventParameterSave) {

2
sources/ewol/widget/meta/Parameter.h
View File

@ -29,7 +29,7 @@ namespace ewol {
class Parameter : public ewol::widget::PopUp { class Parameter : public ewol::widget::PopUp {
public: public:
// Event list of properties // Event list of properties
static const char * const eventClose; ewol::object::Signal<void> signalClose;
protected: protected:
Parameter(); Parameter();
void init(); void init();

8
sources/ewol/widget/meta/ParameterList.cpp
View File

@ -15,15 +15,13 @@
#include <ewol/compositing/Text.h> #include <ewol/compositing/Text.h>
#include <ewol/widget/Manager.h> #include <ewol/widget/Manager.h>
const char * const ewol::widget::ParameterList::eventSelect = "select";
#undef __class__ #undef __class__
#define __class__ "List" #define __class__ "List"
ewol::widget::ParameterList::ParameterList() { ewol::widget::ParameterList::ParameterList() :
signalSelect(*this, "select") {
addObjectType("ewol::widget::ParameterList"); addObjectType("ewol::widget::ParameterList");
addEventId(eventSelect);
m_idSelected = -1; m_idSelected = -1;
m_paddingSizeX = 2; 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 (rawID >= 0 && (size_t)rawID < m_list.size()) {
if (m_list[rawID]!=nullptr) { if (m_list[rawID]!=nullptr) {
if (m_list[rawID]->m_refId >= 0) { 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; m_idSelected = rawID;
markToRedraw(); markToRedraw();
return true; return true;

2
sources/ewol/widget/meta/ParameterList.h
View File

@ -39,7 +39,7 @@ namespace ewol {
class ParameterList :public ewol::widget::WidgetScrolled { class ParameterList :public ewol::widget::WidgetScrolled {
public: public:
// Event list of properties // Event list of properties
static const char * const eventSelect; ewol::object::Signal<int32_t> signalSelect;
private: private:
int32_t m_idSelected; int32_t m_idSelected;
std::vector<ewol::widget::elementPL *> m_list; std::vector<ewol::widget::elementPL *> m_list;

2
sources/ewol/widget/meta/StdPopUp.cpp
View File

@ -107,7 +107,7 @@ std::shared_ptr<ewol::widget::Button> ewol::widget::StdPopUp::addButton(const st
} }
myButton->setSubWidget(ewol::widget::Label::create(_text)); myButton->setSubWidget(ewol::widget::Label::create(_text));
if(_autoExit == true) { if(_autoExit == true) {
myButton->registerOnEvent(shared_from_this(), ewol::widget::Button::eventPressed, eventButtonExit); myButton->registerOnEvent(shared_from_this(), "pressed", eventButtonExit);
} }
m_subBar->subWidgetAdd(myButton); m_subBar->subWidgetAdd(myButton);
markToRedraw(); markToRedraw();