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);
}
/*
void ewol::Object::registerOnEvent(const std::shared_ptr<ewol::Object>& _destinationObject,
const char * _eventId,
const char * _eventIdgenerated,
const std::string& _overloadData) {
if (nullptr == _destinationObject) {
EWOL_ERROR("Input ERROR nullptr pointer Object ...");
return;
}
if (nullptr == _eventId) {
EWOL_ERROR("Input ERROR nullptr pointer Event Id...");
return;
}
if ( _eventId[0] == '*'
&& _eventId[1] == '\0') {
EWOL_VERBOSE("Register on all event ...");
for(auto &it : m_availlableEventId) {
ewol::object::EventExtGen tmpEvent;
tmpEvent.localEventId = it;
tmpEvent.destObject = _destinationObject;
tmpEvent.overloadData = _overloadData;
if (nullptr != _eventIdgenerated) {
tmpEvent.destEventId = _eventIdgenerated;
} else {
tmpEvent.destEventId = it;
}
m_externEvent.push_back(tmpEvent);
}
return;
}
// check if event existed :
bool findIt = false;
for(auto &it : m_availlableEventId) {
if (it == _eventId) {
findIt = true;
break;
}
}
if (false == findIt) {
EWOL_VERBOSE("Try to register with a NON direct string name");
for(auto &it : m_availlableEventId) {
if (0 == strncmp(it, _eventId, 1024)) {
findIt = true;
_eventId = it;
EWOL_VERBOSE("find event ID : '" << _eventId << "' ==> '" << _eventIdgenerated << "'");
break;
}
}
}
if (false == findIt) {
EWOL_ERROR("Can not register event on this Type=" << getObjectType() << " event=\"" << _eventId << "\" == > unknow event");
return;
}
ewol::object::EventExtGen tmpEvent;
tmpEvent.localEventId = _eventId;
tmpEvent.destObject = _destinationObject;
tmpEvent.overloadData = _overloadData;
if (nullptr != _eventIdgenerated) {
tmpEvent.destEventId = _eventIdgenerated;
} else {
tmpEvent.destEventId = _eventId;
}
m_externEvent.push_back(tmpEvent);
}
void ewol::Object::unRegisterOnEvent(const std::shared_ptr<ewol::Object>& _destinationObject,
const char * _eventId) {
if (_destinationObject == nullptr) {
EWOL_ERROR("Input ERROR nullptr pointer Object ...");
return;
}
// check if event existed :
auto it(m_externEvent.begin());
while(it != m_externEvent.end()) {
std::shared_ptr<ewol::Object> obj = it->destObject.lock();
if (obj == nullptr) {
m_externEvent.erase(it);
it = m_externEvent.begin();
} else if ( obj == _destinationObject
&& it->localEventId == _eventId) {
m_externEvent.erase(it);
it = m_externEvent.begin();
EWOL_INFO("[" << getId() << "] Remove extern event : to object id=" << _destinationObject->getId() << " event=" << _eventId);
} else {
++it;
}
}
}
*/
bool ewol::Object::loadXML(exml::Element* _node) {
if (nullptr == _node) {
@ -315,21 +226,6 @@ ewol::object::MultiCast& ewol::Object::getMultiCast() const {
ewol::Context& ewol::Object::getContext() const {
return ewol::getContext();
}
/*
void ewol::Object::registerOnObjectEvent(const std::shared_ptr<ewol::Object>& _destinationObject,
const std::string& _objectName,
const char * _eventId,
const char * _eventIdgenerated,
const std::string& _overloadData) {
std::shared_ptr<ewol::Object> tmpObject = getObjectManager().getObjectNamed(_objectName);
if (nullptr != tmpObject) {
EWOL_DEBUG("Find widget named : '" << _objectName << "' register event='" << _eventId << "'");
tmpObject->registerOnEvent(_destinationObject, _eventId, _eventIdgenerated, _overloadData);
} else {
EWOL_WARNING("[" << getId() << "] {" << getObjectType() << "} Can not register event : \"" << _eventId << "\" the object named=\"" << _objectName << "\" does not exist");
}
}
*/
std::shared_ptr<ewol::Object> ewol::Object::getObjectNamed(const std::string& _objectName) const {
return getObjectManager().getObjectNamed(_objectName);
}

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

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

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 ...
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() { };
const std::string& getName() {
const std::string& getName() const {
return m_name;
}
const std::string& getDescription() {
const std::string& getDescription() const {
return m_description;
}
virtual void connect(std::shared_ptr<ewol::Object> _obj, const char* _destId=nullptr, const std::string& _data="" ) = 0;
virtual void release(std::shared_ptr<ewol::Object> _obj) = 0;
};
std::ostream& operator <<(std::ostream& _os, const SignalBase& _obj);
};
};
#endif

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

@ -11,6 +11,7 @@
#include <ewol/object/Object.h>
#include <ewol/object/SignalList.h>
#include <ewol/object/SignalBase.h>
#include <ewol/context/Context.h>
ewol::object::SignalList::SignalList() {
@ -29,60 +30,85 @@ void ewol::object::SignalList::signalAdd(SignalBase* _pointerOnSignal) {
m_list.push_back(_pointerOnSignal);
}
#if 0
// Note no lock is needed at this level, because the lock is done is the upper elements ...
// the parameter set might be done with a pool of parameter, allone, the overhed is bigger ...
bool ewol::object::SignalList::parameterSet(const std::string& _parameter, const std::string& _value) {
for (auto &it : m_list) {
if( it != nullptr
&& it->getName() == _parameter) {
it->setString(_value);
return true;
}
}
// can not find the parameters :
return false;
}
std::string ewol::object::SignalList::parameterGet(const std::string& _parameter) const {
for (auto &it : m_list) {
if( it != nullptr
&& it->getName() == _parameter) {
return it->getString();
}
}
return "???";
}
void ewol::object::SignalList::parameterDisplay(bool _changeOnly) const {
EWOL_INFO(" Object parameters:");
std::vector<std::string> ewol::object::SignalList::signalGetAll() const {
std::vector<std::string> out;
for (auto &it : m_list) {
if(it != nullptr) {
std::string paramName = it->getName();
std::string paramVal = it->getString();
std::string paramInfo = it->getInfo();
if ( _changeOnly == false
|| it->isDefault() == false) {
EWOL_INFO(" | param='" << paramName << "' value=" << paramVal << " (" << paramInfo << ")");
}
} else {
EWOL_INFO(" | param=nullptr");
}
}
}
std::map<std::string, std::string> ewol::object::SignalList::parameterGetAll(bool _notIfDefault) const {
std::map<std::string, std::string> out;
for (auto &it : m_list) {
if(it != nullptr) {
std::string paramName = it->getName();
std::string paramVal = it->getString();
if ( _notIfDefault == false
|| it->isDefault() == false) {
out.insert(std::make_pair(paramName, paramVal));
}
out.push_back(it->getName());
}
}
return out;
}
#endif
void ewol::object::SignalList::registerOnObjectEvent(const std::shared_ptr<ewol::Object>& _destinationObject,
const std::string& _objectName,
const char * _eventId,
const char * _eventIdgenerated,
const std::string& _overloadData) {
ewol::object::Manager& tmp = ewol::getContext().getEObjectManager();
std::shared_ptr<ewol::Object> tmpObject = tmp.getObjectNamed(_objectName);
if (nullptr != tmpObject) {
EWOL_DEBUG("Find widget named : '" << _objectName << "' register event='" << _eventId << "'");
tmpObject->registerOnEvent(_destinationObject, _eventId, _eventIdgenerated, _overloadData);
} else {
EWOL_WARNING(" Can not register event : '" << _eventId << "' the object named='" << _objectName << "' does not exist");
}
}
void ewol::object::SignalList::registerOnEvent(const std::shared_ptr<ewol::Object>& _destinationObject,
const char * _eventId,
const char * _eventIdgenerated,
const std::string& _overloadData) {
if (_destinationObject == nullptr) {
EWOL_ERROR("Input ERROR nullptr pointer Object ...");
return;
}
if (_eventId == nullptr) {
EWOL_ERROR("Input ERROR nullptr pointer Event Id...");
return;
}
if ( _eventId[0] == '*'
&& _eventId[1] == '\0') {
EWOL_VERBOSE("Register on all event ...");
for(auto &it : m_list) {
if (it == nullptr) {
continue;
}
it->connect(_destinationObject, _eventIdgenerated, _overloadData);
}
return;
}
// check if event existed :
bool findIt = false;
for(auto &it : m_list) {
if (it == nullptr) {
continue;
}
if (it->getName() == _eventId) {
findIt = true;
it->connect(_destinationObject, _eventIdgenerated, _overloadData);
}
}
if (false == findIt) {
EWOL_ERROR("Can not register event on this event=\"" << _eventId << "\" == > unknow event");
return;
}
}
void ewol::object::SignalList::unRegisterOnEvent(const std::shared_ptr<ewol::Object>& _destinationObject,
const char * _eventId) {
if (_destinationObject == nullptr) {
EWOL_ERROR("Input ERROR nullptr pointer Object ...");
return;
}
for(auto &it : m_list) {
if (it == nullptr) {
continue;
}
if ( it->getName() == _eventId
|| ( _eventId[0] == '*'
&& _eventId[1] == '\0') ) {
it->release(_destinationObject);
}
}
}

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.
*/
void signalAdd(SignalBase* _pointerOnParameter);
#if 0
/**
* @brief Set a specific value to the parameter reference name.
* @param[in] parameter The parameter string name.
* @param[in] value The new value of the parameter (string).
* @return true Parameter update.
* @return false Parameter not update.
* @brief Get All the signal list:
* @return vector on all the signals names
*/
bool parameterSet(const std::string& _parameter, const std::string& _value);
/**
* @brief Get a specific value of the parameter reference name.
* @param[in] parameter The parameter string name.
* @return The value of the parameter (string).
*/
std::string parameterGet(const std::string& _parameter) const;
/**
* @brief Display all the parameter value with there name.
* @param[in] changeOnly check at true if the user want to display only parameter that are not at default value.
*/
void parameterDisplay(bool _changeOnly = false) const;
/**
* @brief Called when a parameter change value.
* @param[in] _paramPointer Pointer on the parameter (to know which parameter have change);
*/
virtual void onParameterChangeValue(const ewol::object::ParameterRef& _paramPointer) { };
/**
* @brief Get All the parameter configuration:
* @return map on the parameters
*/
std::map<std::string, std::string> parameterGetAll(bool _notIfDefault=true) const;
#endif
std::vector<std::string> signalGetAll() const;
/**
* @brief Register an Event an named widget. @see registerOnEvent
* @param[in] _destinationObject pointer on the object that might be call when an event is generated

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

@ -14,14 +14,6 @@
#define __class__ "Button"
const char* const ewol::widget::Button::eventPressed = "pressed";
const char* const ewol::widget::Button::eventDown = "down";
const char* const ewol::widget::Button::eventUp = "up";
const char* const ewol::widget::Button::eventEnter = "enter";
const char* const ewol::widget::Button::eventLeave = "leave";
const char* const ewol::widget::Button::eventValue = "value";
// DEFINE for the shader display system :
#define STATUS_UP (0)
#define STATUS_HOVER (2)
@ -30,6 +22,11 @@ const char* const ewol::widget::Button::eventValue = "value";
ewol::widget::Button::Button() :
signalPressed(*this, "pressed", "Button is pressed"),
signalDown(*this, "down", "Button is DOWN"),
signalUp(*this, "up", "Button is UP"),
signalEnter(*this, "enter", "The cursor enter inside the button"),
signalLeave(*this, "leave", "the cursor leave the button"),
signalValue(*this, "value", "button value change"),
m_shaper(*this, "shaper", "The display name for config file"),
m_value(*this, "value", false, "Value of the Button"),
m_lock(*this, "lock", lockNone, "Lock the button in a special state to permit changing state only by the coder"),
@ -40,13 +37,6 @@ ewol::widget::Button::Button() :
m_selectableAreaPos(0,0),
m_selectableAreaSize(0,0) {
addObjectType("ewol::widget::Button");
// add basic Event generated :
addEventId(eventPressed);
addEventId(eventDown);
addEventId(eventUp);
addEventId(eventEnter);
addEventId(eventLeave);
addEventId(eventValue);
// set property list:
m_lock.add(lockNone, "none");
@ -131,14 +121,14 @@ bool ewol::widget::Button::onEventInput(const ewol::event::Input& _event) {
if (true == m_mouseHover) {
if (1 == _event.getId()) {
if(ewol::key::statusDown == _event.getStatus()) {
EWOL_VERBOSE(getName() << " : Generate event : " << eventDown);
generateEventId(eventDown);
EWOL_VERBOSE(getName() << " : Generate event : " << signalDown);
signalDown.emit(shared_from_this());
m_buttonPressed = true;
markToRedraw();
}
if(ewol::key::statusUp == _event.getStatus()) {
EWOL_VERBOSE(getName() << " : Generate event : " << eventUp);
generateEventId(eventUp);
EWOL_VERBOSE(getName() << " : Generate event : " << signalUp);
signalUp.emit(shared_from_this());
m_buttonPressed = false;
markToRedraw();
}
@ -152,15 +142,15 @@ bool ewol::widget::Button::onEventInput(const ewol::event::Input& _event) {
} else {
// inverse value :
setValue((m_value)?false:true);
EWOL_VERBOSE(getName() << " : Generate event : " << eventPressed);
generateEventId(eventPressed);
EWOL_VERBOSE(getName() << " : Generate event : " << eventValue << " val=" << m_value );
generateEventId(eventValue, etk::to_string(m_value.get()));
EWOL_VERBOSE(getName() << " : Generate event : " << signalPressed);
signalPressed.emit(shared_from_this());
EWOL_VERBOSE(getName() << " : Generate event : " << signalValue << " val=" << m_value );
signalValue.emit(shared_from_this(), m_value.get());
if( false == m_toggleMode
&& true == m_value) {
setValue(false);
EWOL_VERBOSE(getName() << " : Generate event : " << ewol::widget::Button::eventValue << " val=" << m_value);
generateEventId(eventValue, etk::to_string(m_value.get()));
EWOL_VERBOSE(getName() << " : Generate event : " << signalValue << " val=" << m_value);
signalValue.emit(shared_from_this(), m_value.get());
}
}
markToRedraw();
@ -177,7 +167,7 @@ bool ewol::widget::Button::onEventEntry(const ewol::event::Entry& _event) {
if( _event.getType() == ewol::key::keyboardChar
&& _event.getStatus() == ewol::key::statusDown
&& _event.getChar() == '\r') {
generateEventId(eventEnter);
signalEnter.emit(shared_from_this());
return true;
}
return false;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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_SELECTED (2)
const char * const ewol::widget::Entry::eventClick = "click";
const char * const ewol::widget::Entry::eventEnter = "enter";
const char * const ewol::widget::Entry::eventModify = "modify";
ewol::widget::Entry::Entry() :
signalClick(*this, "click", "the user Click on the Entry box"),
signalEnter(*this, "enter", "The cursor enter inside the button"),
signalModify(*this, "modify", "Entry box value change"),
m_shaper(*this, "shaper", "Shaper to display the background"),
m_data(*this, "value", "", "Value display in the entry (decorated text)"),
m_maxCharacter(*this, "max", 0x7FFFFFFF, 0, 0x7FFFFFFF, "Maximum cgar that can be set on the Entry"),
@ -46,9 +45,6 @@ ewol::widget::Entry::Entry() :
m_textWhenNothing(*this, "emptytext", "", "Text that is displayed when the Entry is empty (decorated text)") {
addObjectType("ewol::widget::Entry");
setCanHaveFocus(true);
addEventId(eventClick);
addEventId(eventEnter);
addEventId(eventModify);
shortCutAdd("ctrl+w", ewolEventEntryClean);
shortCutAdd("ctrl+x", ewolEventEntryCut);
shortCutAdd("ctrl+c", ewolEventEntryCopy);
@ -244,7 +240,7 @@ bool ewol::widget::Entry::onEventInput(const ewol::event::Input& _event) {
if (1 == _event.getId()) {
if (ewol::key::statusSingle == _event.getStatus()) {
keepFocus();
generateEventId(eventClick);
signalClick.emit(shared_from_this());
//nothing to do ...
return true;
} else if (ewol::key::statusDouble == _event.getStatus()) {
@ -335,13 +331,11 @@ bool ewol::widget::Entry::onEventInput(const ewol::event::Input& _event) {
bool ewol::widget::Entry::onEventEntry(const ewol::event::Entry& _event) {
if (_event.getType() == ewol::key::keyboardChar) {
if(_event.getStatus() == ewol::key::statusDown) {
//EWOL_DEBUG("Entry input data ... : \"" << unicodeData << "\" " );
//return GenEventInputExternal(eventEnter, -1, -1);
// remove curent selected data ...
removeSelected();
if( _event.getChar() == '\n'
|| _event.getChar() == '\r') {
generateEventId(eventEnter, m_data);
signalEnter.emit(shared_from_this(), m_data);
return true;
} else if (_event.getChar() == 0x7F) {
// SUPPR :
@ -371,7 +365,7 @@ bool ewol::widget::Entry::onEventEntry(const ewol::event::Entry& _event) {
}
}
}
generateEventId(eventModify, m_data);
signalModify.emit(shared_from_this(), m_data);
markToRedraw();
return true;
}
@ -443,7 +437,7 @@ void ewol::widget::Entry::onEventClipboard(enum ewol::context::clipBoard::clipbo
markToRedraw();
}
}
generateEventId(eventModify, m_data);
signalModify.emit(shared_from_this(), m_data);
}
@ -458,7 +452,7 @@ void ewol::widget::Entry::onReceiveMessage(const ewol::object::Message& _msg) {
} else if(_msg.getMessage() == ewolEventEntryCut) {
copySelectionToClipBoard(ewol::context::clipBoard::clipboardStd);
removeSelected();
generateEventId(eventModify, m_data);
signalModify.emit(shared_from_this(), m_data);
} else if(_msg.getMessage() == ewolEventEntryCopy) {
copySelectionToClipBoard(ewol::context::clipBoard::clipboardStd);
} else if(_msg.getMessage() == ewolEventEntryPaste) {

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

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

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

@ -16,9 +16,8 @@
#undef __class__
#define __class__ "Image"
const char * const ewol::widget::Image::eventPressed = "pressed";
ewol::widget::Image::Image() :
signalPressed(*this, "pressed", "Image is pressed"),
m_colorProperty(nullptr),
m_colorId(-1),
m_fileName(*this, "src", "", "Image source path"),
@ -29,7 +28,6 @@ ewol::widget::Image::Image() :
m_posStop(*this, "part-stop", vec2(1.0f, 1.0f), vec2(0.0f, 0.0f), vec2(1.0f, 1.0f), "Start display position in the image"),
m_distanceFieldMode(*this, "distance-field", false, "Distance field mode") {
addObjectType("ewol::widget::Image");
addEventId(eventPressed);
m_colorProperty = ewol::resource::ColorFile::create("THEME:COLOR:Image.json");
if (m_colorProperty != nullptr) {
m_colorId = m_colorProperty->request("foreground");
@ -135,7 +133,7 @@ bool ewol::widget::Image::onEventInput(const ewol::event::Input& _event) {
//EWOL_DEBUG("Event on BT ...");
if (1 == _event.getId()) {
if(ewol::key::statusSingle == _event.getStatus()) {
generateEventId(eventPressed);
signalPressed.emit(shared_from_this());
return true;
}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -10,16 +10,14 @@
#include <ewol/widget/Manager.h>
const char * const ewol::widget::Slider::eventChange = "change";
#undef __class__
#define __class__ "Slider"
const int32_t dotRadius = 6;
ewol::widget::Slider::Slider() {
ewol::widget::Slider::Slider() :
signalChange(*this, "change") {
addObjectType("ewol::widget::Slider");
addEventId(eventChange);
m_value = 0;
m_min = 0;
@ -109,7 +107,7 @@ bool ewol::widget::Slider::onEventInput(const ewol::event::Input& _event) {
m_value = std::max(std::min(m_value, m_max), m_min);
if (oldValue != m_value) {
EWOL_DEBUG(" new value : " << m_value << " in [" << m_min << ".." << m_max << "]");
generateEventId(eventChange, etk::to_string(m_value));
signalChange.emit(shared_from_this(), m_value);
markToRedraw();
}
return true;

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

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

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__
#define __class__ "WSlider"
// Event list of properties
const char* const ewol::widget::WSlider::eventStartSlide = "ewol-widget-wslider-event-start-slide";
const char* const ewol::widget::WSlider::eventStopSlide = "ewol-widget-wslider-event-stop-slide";
ewol::widget::WSlider::WSlider() :
signalStartSlide(*this, "start"),
signalStopSlide(*this, "stop"),
m_windowsSources(0),
m_windowsDestination(0),
m_windowsRequested(-1),
@ -36,8 +34,6 @@ ewol::widget::WSlider::WSlider() :
m_transitionSpeed(*this, "speed", 1.0f, 0.0f, 200.0f, "Transition speed of the slider"),
m_transitionSlide(*this, "mode", sladingTransitionHori, "Transition mode of the slider") {
addObjectType("ewol::widget::WSlider");
addEventId(eventStartSlide);
addEventId(eventStopSlide);
m_transitionSlide.add(sladingTransitionVert, "vert");
m_transitionSlide.add(sladingTransitionHori, "hori");
}
@ -105,7 +101,7 @@ void ewol::widget::WSlider::subWidgetSelectSetVectorId(int32_t _id) {
}
if (_id != m_windowsDestination) {
m_windowsRequested = _id;
generateEventId(eventStartSlide);
signalStartSlide.emit(shared_from_this());
periodicCallEnable();
markToRedraw();
}
@ -189,7 +185,7 @@ void ewol::widget::WSlider::periodicCall(const ewol::event::Time& _event) {
} else {
// end of periodic :
periodicCallDisable();
generateEventId(eventStopSlide);
signalStopSlide.emit(shared_from_this());
}
m_windowsRequested = -1;
}

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

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

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__
#define __class__ "Widget"
// event generated :
const char* const ewol::Widget::eventAnnimationStart = "annimation-start";
const char* const ewol::Widget::eventAnnimationRatio = "annimation-ratio";
const char* const ewol::Widget::eventAnnimationStop = "annimation-stop";
ewol::Widget::Widget() :
m_size(10,10),
m_minSize(0,0),
@ -113,6 +108,9 @@ ewol::Widget::Widget() :
m_needRegenerateDisplay(true),
m_grabCursor(false),
m_cursorDisplay(ewol::context::cursorArrow),
signalAnnimationStart(*this, "annimation-start"),
signalAnnimationRatio(*this, "annimation-ratio"),
signalAnnimationStop(*this, "annimation-stop"),
m_annimationMode(annimationModeDisable),
m_annimationratio(0.0f),
m_annimationTypeStart(*this, "annimation-start-type", 0, "Annimation type, when adding/show a widget"),
@ -133,10 +131,6 @@ ewol::Widget::Widget() :
m_gravity.add(ewol::gravityLeft, "left");
m_annimationTypeStart.add(0, "none");
m_annimationTypeStop.add(0, "none");
addEventId(eventAnnimationStart);
addEventId(eventAnnimationRatio);
addEventId(eventAnnimationStop);
}
void ewol::Widget::init() {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -15,15 +15,13 @@
#include <ewol/compositing/Text.h>
#include <ewol/widget/Manager.h>
const char * const ewol::widget::ParameterList::eventSelect = "select";
#undef __class__
#define __class__ "List"
ewol::widget::ParameterList::ParameterList() {
ewol::widget::ParameterList::ParameterList() :
signalSelect(*this, "select") {
addObjectType("ewol::widget::ParameterList");
addEventId(eventSelect);
m_idSelected = -1;
m_paddingSizeX = 2;
@ -192,7 +190,7 @@ bool ewol::widget::ParameterList::onEventInput(const ewol::event::Input& _event)
if (rawID >= 0 && (size_t)rawID < m_list.size()) {
if (m_list[rawID]!=nullptr) {
if (m_list[rawID]->m_refId >= 0) {
generateEventId(eventSelect, etk::to_string(m_list[rawID]->m_refId));
signalSelect.emit(shared_from_this(), m_list[rawID]->m_refId);
m_idSelected = rawID;
markToRedraw();
return true;

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

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

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));
if(_autoExit == true) {
myButton->registerOnEvent(shared_from_this(), ewol::widget::Button::eventPressed, eventButtonExit);
myButton->registerOnEvent(shared_from_this(), "pressed", eventButtonExit);
}
m_subBar->subWidgetAdd(myButton);
markToRedraw();