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

[DEV] normalize event in the access methosde

Browse Source
This commit is contained in:
Edouard DUPIN 2013-12-28 15:14:36 +01:00
parent bcfd9a54c3
commit 278ecbd12d
25 changed files with 147 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -161,6 +161,27 @@ void ewol::Object::registerOnEvent(ewol::Object * _destinationObject,
EWOL_ERROR("Input ERROR NULL pointer Event Id..."); EWOL_ERROR("Input ERROR NULL pointer Event Id...");
return; return;
} }
if ( _eventId[0] == '*'
&& _eventId[1] == '\0') {
EWOL_VERBOSE("Register on all event ...");
for(size_t iii=0; iii<m_availlableEventId.size(); iii++) {
ewol::object::EventExtGen * tmpEvent = new ewol::object::EventExtGen();
if (NULL == tmpEvent) {
EWOL_ERROR("Allocation error in Register Event...");
continue;
}
tmpEvent->localEventId = m_availlableEventId[iii];
tmpEvent->destObject = _destinationObject;
tmpEvent->overloadData = _overloadData;
if (NULL != _eventIdgenerated) {
tmpEvent->destEventId = _eventIdgenerated;
} else {
tmpEvent->destEventId = m_availlableEventId[iii];
}
m_externEvent.push_back(tmpEvent);
}
return;
}
// check if event existed : // check if event existed :
bool findIt = false; bool findIt = false;
for(size_t iii=0; iii<m_availlableEventId.size(); iii++) { for(size_t iii=0; iii<m_availlableEventId.size(); iii++) {

2
sources/ewol/object/Object.h
View File

@ -151,7 +151,7 @@ namespace ewol {
/** /**
* @brief Register an Object over an other to get event on the second... * @brief Register an Object over an other to get event on the second...
* @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
* @param[in] _eventId Event generate inside the object * @param[in] _eventId Event generate inside the object (note : "*" event register on all event generated )
* @param[in] _eventIdgenerated event generated when call the distant Object.onReceiveMessage(...) * @param[in] _eventIdgenerated event generated when call the distant Object.onReceiveMessage(...)
* @param[in] _overloadData When the user prever to receive a data specificly for this event ... * @param[in] _overloadData When the user prever to receive a data specificly for this event ...
*/ */

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

@ -22,8 +22,8 @@
namespace ewol { namespace ewol {
namespace widget { namespace widget {
/** /**
* @ingroup ewolWidgetGroup * @brief a composed button is a button with an inside composed with the specify XML element
* @brief a composed button is a button with an inside composed with the specify XML element == > this permit to generate standard element simple * ==> this permit to generate standard element simple
*/ */
class Button : public ewol::Widget { class Button : public ewol::Widget {
public: public:

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

@ -15,7 +15,7 @@
#include <ewol/widget/Windows.h> #include <ewol/widget/Windows.h>
#include <ewol/ewol.h> #include <ewol/ewol.h>
extern const char * const ewolEventButtonColorChange = "ewol-Button-Color-Change"; const char * const ewol::widget::ButtonColor::eventChange = "change";
// DEFINE for the shader display system : // DEFINE for the shader display system :
@ -28,7 +28,7 @@ extern const char * const ewolEventButtonColorChange = "ewol-Button-Color-Cha
#undef __class__ #undef __class__
#define __class__ "ButtonColor" #define __class__ "ButtonColor"
static const char* const eventColorHasChange = "ewol-widget-ButtonColor-colorChange";
static ewol::Widget* Create(void) { static ewol::Widget* Create(void) {
return new ewol::widget::ButtonColor(); return new ewol::widget::ButtonColor();
@ -43,7 +43,7 @@ ewol::widget::ButtonColor::ButtonColor(etk::Color<> _baseColor, std::string _sha
m_textColorFg(_baseColor), m_textColorFg(_baseColor),
m_widgetContextMenu(NULL) { m_widgetContextMenu(NULL) {
addObjectType("ewol::widget::ButtonColor"); addObjectType("ewol::widget::ButtonColor");
addEventId(ewolEventButtonColorChange); addEventId(eventChange);
changeStatusIn(STATUS_UP); changeStatusIn(STATUS_UP);
setCanHaveFocus(true); setCanHaveFocus(true);
// Limit event at 1: // Limit event at 1:
@ -190,7 +190,7 @@ bool ewol::widget::ButtonColor::onEventInput(const ewol::event::Input& _event) {
myColorChooser->setColor(m_textColorFg); myColorChooser->setColor(m_textColorFg);
// set it in the pop-up-system : // set it in the pop-up-system :
m_widgetContextMenu->setSubWidget(myColorChooser); m_widgetContextMenu->setSubWidget(myColorChooser);
myColorChooser->registerOnEvent(this, ewolEventColorChooserChange, ewolEventColorChooserChange); myColorChooser->registerOnEvent(this, "change", eventColorHasChange);
ewol::widget::Windows* currentWindows = getWindows(); ewol::widget::Windows* currentWindows = getWindows();
if (NULL == currentWindows) { if (NULL == currentWindows) {
EWOL_ERROR("Can not get the curent Windows..."); EWOL_ERROR("Can not get the curent Windows...");
@ -231,9 +231,9 @@ etk::Color<> ewol::widget::ButtonColor::getValue(void) {
void ewol::widget::ButtonColor::onReceiveMessage(const ewol::object::Message& _msg) { void ewol::widget::ButtonColor::onReceiveMessage(const ewol::object::Message& _msg) {
EWOL_INFO("Receive MSG : " << _msg.getData()); EWOL_INFO("Receive MSG : " << _msg.getData());
if (_msg.getMessage() == ewolEventColorChooserChange) { if (_msg.getMessage() == eventColorHasChange) {
m_textColorFg = _msg.getData(); m_textColorFg = _msg.getData();
generateEventId(ewolEventButtonColorChange, _msg.getData()); generateEventId(eventChange, _msg.getData());
markToRedraw(); markToRedraw();
} }
} }

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

@ -18,14 +18,12 @@
#include <ewol/widget/Widget.h> #include <ewol/widget/Widget.h>
#include <ewol/widget/Manager.h> #include <ewol/widget/Manager.h>
extern const char * const ewolEventButtonColorChange;
namespace ewol { namespace ewol {
namespace widget { namespace widget {
/**
* @ingroup ewolWidgetGroup
*/
class ButtonColor : public ewol::Widget { class ButtonColor : public ewol::Widget {
public:
// Event list of properties
static const char * const eventChange;
public: public:
static void init(ewol::widget::Manager& _widgetManager); static void init(ewol::widget::Manager& _widgetManager);
private: private:

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

@ -10,7 +10,7 @@
#include <ewol/widget/Manager.h> #include <ewol/widget/Manager.h>
extern const char * const ewolEventCheckBoxClicked = "ewol CheckBox Clicked"; const char * const ewol::widget::CheckBox::eventClicked = "clicked";
#undef __class__ #undef __class__
#define __class__ "CheckBox" #define __class__ "CheckBox"
@ -26,7 +26,7 @@ void ewol::widget::CheckBox::init(ewol::widget::Manager& _widgetManager) {
ewol::widget::CheckBox::CheckBox(const std::string& _newLabel) { ewol::widget::CheckBox::CheckBox(const std::string& _newLabel) {
addObjectType("ewol::widget::CheckBox"); addObjectType("ewol::widget::CheckBox");
m_label = _newLabel; m_label = _newLabel;
addEventId(ewolEventCheckBoxClicked); addEventId(eventClicked);
m_textColorFg = etk::color::black; m_textColorFg = etk::color::black;
m_textColorBg = etk::color::white; m_textColorBg = etk::color::white;
m_value = false; m_value = false;
@ -105,10 +105,10 @@ bool ewol::widget::CheckBox::onEventInput(const ewol::event::Input& _event) {
if (ewol::key::statusSingle == _event.getStatus()) { if (ewol::key::statusSingle == _event.getStatus()) {
if(true == m_value) { if(true == m_value) {
m_value = false; m_value = false;
generateEventId(ewolEventCheckBoxClicked, "false"); generateEventId(eventClicked, "false");
} else { } else {
m_value = true; m_value = true;
generateEventId(ewolEventCheckBoxClicked, "true"); generateEventId(eventClicked, "true");
} }
keepFocus(); keepFocus();
markToRedraw(); markToRedraw();
@ -127,10 +127,10 @@ bool ewol::widget::CheckBox::onEventEntry(const ewol::event::Entry& _event) {
) { ) {
if(true == m_value) { if(true == m_value) {
m_value = false; m_value = false;
generateEventId(ewolEventCheckBoxClicked, "false"); generateEventId(eventClicked, "false");
} else { } else {
m_value = true; m_value = true;
generateEventId(ewolEventCheckBoxClicked, "true"); generateEventId(eventClicked, "true");
} }
markToRedraw(); markToRedraw();
return true; return true;

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

@ -16,14 +16,13 @@
#include <ewol/widget/Widget.h> #include <ewol/widget/Widget.h>
#include <ewol/widget/Manager.h> #include <ewol/widget/Manager.h>
extern const char* const ewolEventCheckBoxClicked;
namespace ewol { namespace ewol {
namespace widget { namespace widget {
/**
* @ingroup ewolWidgetGroup
*/
class CheckBox : public ewol::Widget { class CheckBox : public ewol::Widget {
public:
// Event list of properties
static const char* const eventClicked;
public: public:
static void init(ewol::widget::Manager& _widgetManager); static void init(ewol::widget::Manager& _widgetManager);
public: public:

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

@ -13,7 +13,7 @@
#include <etk/Color.h> #include <etk/Color.h>
extern const char * const ewolEventColorBarChange = "ewol-color-bar-change"; const char * const ewol::widget::ColorBar::eventChange = "change";
@ -22,7 +22,7 @@ extern const char * const ewolEventColorBarChange = "ewol-color-bar-change";
ewol::widget::ColorBar::ColorBar(void) { ewol::widget::ColorBar::ColorBar(void) {
addObjectType("ewol::widget::ColorBar"); addObjectType("ewol::widget::ColorBar");
addEventId(ewolEventColorBarChange); 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);
@ -221,7 +221,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(ewolEventColorBarChange); generateEventId(eventChange);
} }
return true; return true;
} }

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

@ -15,14 +15,13 @@
#include <ewol/widget/Widget.h> #include <ewol/widget/Widget.h>
#include <ewol/compositing/Drawing.h> #include <ewol/compositing/Drawing.h>
extern const char * const ewolEventColorBarChange;
namespace ewol { namespace ewol {
namespace widget { namespace widget {
/**
* @ingroup ewolWidgetGroup
*/
class ColorBar :public ewol::Widget { class ColorBar :public ewol::Widget {
public:
// Event list of properties
static const char * const eventChange;
public: public:
ColorBar(void); ColorBar(void);
virtual ~ColorBar(void); virtual ~ColorBar(void);

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

@ -25,7 +25,7 @@ void ewol::widget::Image::init(ewol::widget::Manager& _widgetManager) {
} }
const char * const ewol::widget::Image::eventPressed = "ewol-widget-image-event-pressed"; const char * const ewol::widget::Image::eventPressed = "pressed";
const char * const ewol::widget::Image::configRatio = "ratio"; const char * const ewol::widget::Image::configRatio = "ratio";
const char * const ewol::widget::Image::configSize = "size"; const char * const ewol::widget::Image::configSize = "size";

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

@ -16,8 +16,6 @@
#include <ewol/compositing/Image.h> #include <ewol/compositing/Image.h>
#include <ewol/widget/Manager.h> #include <ewol/widget/Manager.h>
extern const char * const ewolEventImagePressed;
namespace ewol { namespace ewol {
namespace widget { namespace widget {
/** /**

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

@ -12,9 +12,9 @@
#include <ewol/compositing/Image.h> #include <ewol/compositing/Image.h>
#include <ewol/widget/Manager.h> #include <ewol/widget/Manager.h>
extern const char * const ewolEventJoystickEnable = "ewol-joystick-enable"; const char * const ewol::widget::Joystick::eventEnable = "enable";
extern const char * const ewolEventJoystickDisable = "ewol-joystick-disable"; const char * const ewol::widget::Joystick::eventDisable = "disable";
extern const char * const ewolEventJoystickMove = "ewol-joystick-move"; 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("");
@ -26,9 +26,9 @@ static float l_ratio(1.0/7.0);
ewol::widget::Joystick::Joystick(void) { ewol::widget::Joystick::Joystick(void) {
addObjectType("ewol::widget::Joystick"); addObjectType("ewol::widget::Joystick");
addEventId(ewolEventJoystickEnable); addEventId(eventEnable);
addEventId(ewolEventJoystickDisable); addEventId(eventDisable);
addEventId(ewolEventJoystickMove); 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;
@ -144,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(ewolEventJoystickEnable); generateEventId(eventEnable);
} 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(ewolEventJoystickMove, tmp); generateEventId(eventMove, tmp);
} }
//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);
@ -163,7 +163,7 @@ bool ewol::widget::Joystick::onEventInput(const ewol::event::Input& _event) {
m_distance = 0; m_distance = 0;
} }
markToRedraw(); markToRedraw();
generateEventId(ewolEventJoystickDisable); generateEventId(eventDisable);
return true; return true;
} }
return false; return false;

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

@ -14,9 +14,6 @@
#include <ewol/widget/Widget.h> #include <ewol/widget/Widget.h>
#include <draw/Color.h> #include <draw/Color.h>
extern const char * const ewolEventJoystickEnable;
extern const char * const ewolEventJoystickDisable;
extern const char * const ewolEventJoystickMove;
namespace ewol { namespace ewol {
namespace widget { namespace widget {
@ -24,6 +21,11 @@ namespace ewol {
* @ingroup ewolWidgetGroup * @ingroup ewolWidgetGroup
*/ */
class Joystick :public ewol::Widget { 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;
public: public:
enum joystickMode { enum joystickMode {
modeNormal, modeNormal,

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

@ -15,7 +15,7 @@
#undef __class__ #undef __class__
#define __class__ "Label" #define __class__ "Label"
const char * const ewol::widget::Label::eventPressed = "ewol-widget-label-event-pressed"; const char * const ewol::widget::Label::eventPressed = "pressed";
static ewol::Widget* create(void) { static ewol::Widget* create(void) {
return new ewol::widget::Label(); return new ewol::widget::Label();

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

@ -15,10 +15,10 @@
#undef __class__ #undef __class__
#define __class__ "ListFileSystem" #define __class__ "ListFileSystem"
extern const char * const ewolEventFSFileSelect = "ewol-event-file-system-file-select"; const char * const ewol::widget::ListFileSystem::eventFileSelect = "file-select";
extern const char * const ewolEventFSFileValidate = "ewol-event-file-system-file-validate"; const char * const ewol::widget::ListFileSystem::eventFileValidate = "file-validate";
extern const char * const ewolEventFSFolderSelect = "ewol-event-file-system-folder-select"; const char * const ewol::widget::ListFileSystem::eventFolderSelect = "folder-select";
extern const char * const ewolEventFSFolderValidate = "ewol-event-file-system-folder-validate"; const char * const ewol::widget::ListFileSystem::eventFolderValidate = "folder-validate";
ewol::widget::ListFileSystem::ListFileSystem(void) { ewol::widget::ListFileSystem::ListFileSystem(void) {
@ -33,10 +33,10 @@ ewol::widget::ListFileSystem::ListFileSystem(void) {
#else #else
m_folder = "/"; m_folder = "/";
#endif #endif
addEventId(ewolEventFSFileSelect); addEventId(eventFileSelect);
addEventId(ewolEventFSFileValidate); addEventId(eventFileValidate);
addEventId(ewolEventFSFolderSelect); addEventId(eventFolderSelect);
addEventId(ewolEventFSFolderValidate); addEventId(eventFolderValidate);
setMouseLimit(1); setMouseLimit(1);
}; };
@ -203,21 +203,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(ewolEventFSFolderSelect, "."); generateEventId(eventFolderSelect, ".");
} else if ( m_showFolder == true } else if ( m_showFolder == true
&& m_selectedLine == 1) { && m_selectedLine == 1) {
// ".." folder // ".." folder
generateEventId(ewolEventFSFolderSelect, ".."); generateEventId(eventFolderSelect, "..");
} 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()
&& NULL != m_list[m_selectedLine-offset] ) { && NULL != 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(ewolEventFSFileSelect, m_list[m_selectedLine-offset]->getNameFile()); generateEventId(eventFileSelect, m_list[m_selectedLine-offset]->getNameFile());
break; break;
case etk::FSN_FOLDER : case etk::FSN_FOLDER :
generateEventId(ewolEventFSFolderSelect, m_list[m_selectedLine-offset]->getNameFile()); generateEventId(eventFolderSelect, 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");
@ -228,21 +228,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(ewolEventFSFolderValidate, "."); generateEventId(eventFolderValidate, ".");
} else if ( m_showFolder == true } else if ( m_showFolder == true
&& m_selectedLine == 1) { && m_selectedLine == 1) {
// ".." folder // ".." folder
generateEventId(ewolEventFSFolderValidate, ".."); generateEventId(eventFolderValidate, "..");
} 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()
&& NULL != m_list[m_selectedLine-offset] ) { && NULL != 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(ewolEventFSFileValidate, m_list[m_selectedLine-offset]->getNameFile()); generateEventId(eventFileValidate, m_list[m_selectedLine-offset]->getNameFile());
break; break;
case etk::FSN_FOLDER : case etk::FSN_FOLDER :
generateEventId(ewolEventFSFolderValidate, m_list[m_selectedLine-offset]->getNameFile()); generateEventId(eventFolderValidate, 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");

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

@ -12,10 +12,6 @@
#include <ewol/widget/List.h> #include <ewol/widget/List.h>
#include <etk/os/FSNode.h> #include <etk/os/FSNode.h>
extern const char * const ewolEventFSFileSelect;
extern const char * const ewolEventFSFileValidate;
extern const char * const ewolEventFSFolderSelect;
extern const char * const ewolEventFSFolderValidate;
namespace ewol { namespace ewol {
namespace widget { namespace widget {
@ -23,6 +19,12 @@ namespace ewol {
* @ingroup ewolWidgetGroup * @ingroup ewolWidgetGroup
*/ */
class ListFileSystem : public ewol::widget::List { class ListFileSystem : public ewol::widget::List {
public:
// Event list of properties
static const char * const eventFileSelect;
static const char * const eventFileValidate;
static const char * const eventFolderSelect;
static const char * const eventFolderValidate;
private: private:
std::vector<etk::FSNode *> m_list; std::vector<etk::FSNode *> m_list;
std::string m_folder; std::string m_folder;

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

@ -10,7 +10,7 @@
#include <ewol/widget/Manager.h> #include <ewol/widget/Manager.h>
extern const char * const ewolEventSliderChange = "ewol-event-slider-change"; const char * const ewol::widget::Slider::eventChange = "change";
#undef __class__ #undef __class__
#define __class__ "Slider" #define __class__ "Slider"
@ -27,7 +27,7 @@ const int32_t dotRadius = 6;
ewol::widget::Slider::Slider(void) { ewol::widget::Slider::Slider(void) {
addObjectType("ewol::widget::Slider"); addObjectType("ewol::widget::Slider");
addEventId(ewolEventSliderChange); addEventId(eventChange);
m_value = 0; m_value = 0;
m_min = 0; m_min = 0;
@ -113,7 +113,7 @@ bool ewol::widget::Slider::onEventInput(const ewol::event::Input& _event) {
m_value = etk_max(etk_min(m_value, m_max), m_min); m_value = etk_max(etk_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(ewolEventSliderChange, std::to_string(m_value)); generateEventId(eventChange, std::to_string(m_value));
markToRedraw(); markToRedraw();
} }
return true; return true;

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

@ -15,14 +15,15 @@
#include <ewol/widget/Widget.h> #include <ewol/widget/Widget.h>
#include <ewol/compositing/Drawing.h> #include <ewol/compositing/Drawing.h>
extern const char * const ewolEventSliderChange;
namespace ewol { namespace ewol {
namespace widget { namespace widget {
/** /**
* @ingroup ewolWidgetGroup * @ingroup ewolWidgetGroup
*/ */
class Slider :public ewol::Widget { class Slider :public ewol::Widget {
public:
// Event list of properties
static const char * const eventChange;
public: public:
static void init(ewol::widget::Manager& _widgetManager); static void init(ewol::widget::Manager& _widgetManager);
public: public:

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

@ -23,19 +23,17 @@ extern "C" {
#define __class__ "ColorChooser" #define __class__ "ColorChooser"
const char * const ewol::widget::ColorChooser::eventChange = "change";
extern const char * const ewolEventColorChooserChange = "ewol-event-color-chooser-change"; static const char * const eventColorBarHasChange = "event-color-bar-has-change";
static const char * const eventColorSpecificHasChange = "event-color-specific-has-change";
const char * const eventColorBarHasChange = "event-color-bar-has-change";
const char * const eventColorSpecificHasChange = "event-color-specific-has-change";
ewol::widget::ColorChooser::ColorChooser(void) : ewol::widget::ColorChooser::ColorChooser(void) :
ewol::widget::Sizer(ewol::widget::Sizer::modeVert) { ewol::widget::Sizer(ewol::widget::Sizer::modeVert) {
addObjectType("ewol::widget::ColorChooser"); addObjectType("ewol::widget::ColorChooser");
addEventId(ewolEventColorChooserChange); addEventId(eventChange);
m_widgetColorBar = NULL; m_widgetColorBar = NULL;
m_widgetRed = NULL; m_widgetRed = NULL;
m_widgetGreen = NULL; m_widgetGreen = NULL;
@ -43,7 +41,7 @@ ewol::widget::ColorChooser::ColorChooser(void) :
m_widgetAlpha = NULL; m_widgetAlpha = NULL;
lockExpand(bvec2(true,true)); lockExpand(bvec2(true,true));
m_widgetColorBar = new ewol::widget::ColorBar(); m_widgetColorBar = new ewol::widget::ColorBar();
m_widgetColorBar->registerOnEvent(this, ewolEventColorBarChange, eventColorBarHasChange); m_widgetColorBar->registerOnEvent(this, "change", eventColorBarHasChange);
m_widgetColorBar->setFill(bvec2(true,true)); m_widgetColorBar->setFill(bvec2(true,true));
/* /*
m_widgetColorBar->setWidth(200); m_widgetColorBar->setWidth(200);
@ -55,7 +53,7 @@ ewol::widget::ColorChooser::ColorChooser(void) :
sliderColor = etk::color::black; sliderColor = etk::color::black;
m_widgetRed = new ewol::widget::Slider(); m_widgetRed = new ewol::widget::Slider();
m_widgetRed->registerOnEvent(this, ewolEventSliderChange, eventColorSpecificHasChange); m_widgetRed->registerOnEvent(this, "change", eventColorSpecificHasChange);
m_widgetRed->setExpand(bvec2(true,false)); m_widgetRed->setExpand(bvec2(true,false));
m_widgetRed->setFill(bvec2(true,false)); m_widgetRed->setFill(bvec2(true,false));
m_widgetRed->setMin(0); m_widgetRed->setMin(0);
@ -64,7 +62,7 @@ ewol::widget::ColorChooser::ColorChooser(void) :
m_widgetRed->setColor(sliderColor); m_widgetRed->setColor(sliderColor);
subWidgetAdd(m_widgetRed); subWidgetAdd(m_widgetRed);
m_widgetGreen = new ewol::widget::Slider(); m_widgetGreen = new ewol::widget::Slider();
m_widgetGreen->registerOnEvent(this, ewolEventSliderChange, eventColorSpecificHasChange); m_widgetGreen->registerOnEvent(this, "change", eventColorSpecificHasChange);
m_widgetGreen->setExpand(bvec2(true,false)); m_widgetGreen->setExpand(bvec2(true,false));
m_widgetGreen->setFill(bvec2(true,false)); m_widgetGreen->setFill(bvec2(true,false));
m_widgetGreen->setMin(0); m_widgetGreen->setMin(0);
@ -73,7 +71,7 @@ ewol::widget::ColorChooser::ColorChooser(void) :
m_widgetGreen->setMax(255); m_widgetGreen->setMax(255);
subWidgetAdd(m_widgetGreen); subWidgetAdd(m_widgetGreen);
m_widgetBlue = new ewol::widget::Slider(); m_widgetBlue = new ewol::widget::Slider();
m_widgetBlue->registerOnEvent(this, ewolEventSliderChange, eventColorSpecificHasChange); m_widgetBlue->registerOnEvent(this, "change", eventColorSpecificHasChange);
m_widgetBlue->setExpand(bvec2(true,false)); m_widgetBlue->setExpand(bvec2(true,false));
m_widgetBlue->setFill(bvec2(true,false)); m_widgetBlue->setFill(bvec2(true,false));
m_widgetBlue->setMin(0); m_widgetBlue->setMin(0);
@ -82,7 +80,7 @@ ewol::widget::ColorChooser::ColorChooser(void) :
m_widgetBlue->setMax(255); m_widgetBlue->setMax(255);
subWidgetAdd(m_widgetBlue); subWidgetAdd(m_widgetBlue);
m_widgetAlpha = new ewol::widget::Slider(); m_widgetAlpha = new ewol::widget::Slider();
m_widgetAlpha->registerOnEvent(this, ewolEventSliderChange, eventColorSpecificHasChange); m_widgetAlpha->registerOnEvent(this, "change", eventColorSpecificHasChange);
m_widgetAlpha->setExpand(bvec2(true,false)); m_widgetAlpha->setExpand(bvec2(true,false));
m_widgetAlpha->setFill(bvec2(true,false)); m_widgetAlpha->setFill(bvec2(true,false));
m_widgetAlpha->setMin(0); m_widgetAlpha->setMin(0);
@ -148,7 +146,7 @@ void ewol::widget::ColorChooser::onReceiveMessage(const ewol::object::Message& _
if (NULL != m_widgetAlpha) { if (NULL != m_widgetAlpha) {
m_widgetAlpha->setValue(m_currentColor.a()); m_widgetAlpha->setValue(m_currentColor.a());
} }
generateEventId(ewolEventColorChooserChange, m_currentColor.getString()); generateEventId(eventChange, m_currentColor.getString());
} 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) {
@ -166,7 +164,7 @@ void ewol::widget::ColorChooser::onReceiveMessage(const ewol::object::Message& _
if (NULL != m_widgetColorBar) { if (NULL != m_widgetColorBar) {
m_widgetColorBar->setCurrentColor(m_currentColor); m_widgetColorBar->setCurrentColor(m_currentColor);
} }
generateEventId(ewolEventColorChooserChange, m_currentColor.getString()); generateEventId(eventChange, m_currentColor.getString());
} }
}; };

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

@ -19,14 +19,15 @@
#include <ewol/widget/ColorBar.h> #include <ewol/widget/ColorBar.h>
#include <ewol/widget/Slider.h> #include <ewol/widget/Slider.h>
extern const char * const ewolEventColorChooserChange;
namespace ewol { namespace ewol {
namespace widget { namespace widget {
/** /**
* @ingroup ewolWidgetGroup * @ingroup ewolWidgetGroup
*/ */
class ColorChooser : public ewol::widget::Sizer { class ColorChooser : public ewol::widget::Sizer {
public:
// Event list of properties
static const char * const eventChange;
public: public:
ColorChooser(void); ColorChooser(void);
~ColorChooser(void); ~ColorChooser(void);

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

@ -30,17 +30,18 @@ extern "C" {
#define __class__ "FileChooser" #define __class__ "FileChooser"
extern const char * const ewol::widget::FileChooser::eventCancel = "ewol-event-file-chooser-cancel"; const char * const ewol::widget::FileChooser::eventCancel = "cancel";
extern const char * const ewol::widget::FileChooser::eventValidate = "ewol-event-file-chooser-validate"; const char * const ewol::widget::FileChooser::eventValidate = "validate";
extern const char * const ewolEventFileChooserHidenFileChange = "ewol-event-file-chooser-Show/Hide-hiden-Files";
extern const char * const ewolEventFileChooserEntryFolder = "ewol-event-file-chooser-modify-entry-folder"; static const char * const ewolEventFileChooserHidenFileChange = "ewol-event-file-chooser-Show/Hide-hiden-Files";
extern const char * const ewolEventFileChooserEntryFolderEnter = "ewol-event-file-chooser-modify-entry-folder-enter"; static const char * const ewolEventFileChooserEntryFolder = "ewol-event-file-chooser-modify-entry-folder";
extern const char * const ewolEventFileChooserEntryFile = "ewol-event-file-chooser-modify-entry-file"; static const char * const ewolEventFileChooserEntryFolderEnter = "ewol-event-file-chooser-modify-entry-folder-enter";
extern const char * const ewolEventFileChooserEntryFileEnter = "ewol-event-file-chooser-modify-entry-file-enter"; static const char * const ewolEventFileChooserEntryFile = "ewol-event-file-chooser-modify-entry-file";
extern const char * const ewolEventFileChooserListFolder = "ewol-event-file-chooser-modify-list-folder"; static const char * const ewolEventFileChooserEntryFileEnter = "ewol-event-file-chooser-modify-entry-file-enter";
extern const char * const ewolEventFileChooserListFile = "ewol-event-file-chooser-modify-list-file"; static const char * const ewolEventFileChooserListFolder = "ewol-event-file-chooser-modify-list-folder";
extern const char * const ewolEventFileChooserListFileValidate = "ewol-event-file-chooser-modify-list-file-validate"; static const char * const ewolEventFileChooserListFile = "ewol-event-file-chooser-modify-list-file";
extern const char * const ewolEventFileChooserHome = "ewol-event-file-chooser-home"; static const char * const ewolEventFileChooserListFileValidate = "ewol-event-file-chooser-modify-list-file-validate";
static const char * const ewolEventFileChooserHome = "ewol-event-file-chooser-home";
ewol::widget::FileChooser::FileChooser(void) { ewol::widget::FileChooser::FileChooser(void) {
@ -124,7 +125,7 @@ ewol::widget::FileChooser::FileChooser(void) {
if (NULL == m_widgetCheckBox) { if (NULL == m_widgetCheckBox) {
EWOL_ERROR("Can not allocate widget == > display might be in error"); EWOL_ERROR("Can not allocate widget == > display might be in error");
} else { } else {
m_widgetCheckBox->registerOnEvent(this, ewolEventCheckBoxClicked, ewolEventFileChooserHidenFileChange); m_widgetCheckBox->registerOnEvent(this, "clicked", ewolEventFileChooserHidenFileChange);
m_widgetCheckBox->setValue(false); m_widgetCheckBox->setValue(false);
mySizerHori->subWidgetAdd(m_widgetCheckBox); mySizerHori->subWidgetAdd(m_widgetCheckBox);
} }
@ -147,7 +148,7 @@ ewol::widget::FileChooser::FileChooser(void) {
" <label>Validate</label>\n" " <label>Validate</label>\n"
" </sizer>\n" " </sizer>\n"
"</composer>\n")); "</composer>\n"));
m_widgetValidate->registerOnEvent(this, ewol::widget::Button::eventPressed, eventValidate); m_widgetValidate->registerOnEvent(this, "pressed", eventValidate);
mySizerHori->subWidgetAdd(m_widgetValidate); mySizerHori->subWidgetAdd(m_widgetValidate);
} }
m_widgetCancel = new ewol::widget::Button(); m_widgetCancel = new ewol::widget::Button();
@ -162,7 +163,7 @@ ewol::widget::FileChooser::FileChooser(void) {
" <label>Cancel</label>\n" " <label>Cancel</label>\n"
" </sizer>\n" " </sizer>\n"
"</composer>\n")); "</composer>\n"));
m_widgetCancel->registerOnEvent(this, ewol::widget::Button::eventPressed, eventCancel); m_widgetCancel->registerOnEvent(this, "pressed", eventCancel);
mySizerHori->subWidgetAdd(m_widgetCancel); mySizerHori->subWidgetAdd(m_widgetCancel);
} }
} }
@ -185,7 +186,7 @@ ewol::widget::FileChooser::FileChooser(void) {
m_widgetListFolder->setShowFolder(true); m_widgetListFolder->setShowFolder(true);
m_widgetListFolder->setShowFiles(false); m_widgetListFolder->setShowFiles(false);
m_widgetListFolder->setShowHiddenFiles(false); m_widgetListFolder->setShowHiddenFiles(false);
m_widgetListFolder->registerOnEvent(this, ewolEventFSFolderValidate, ewolEventFileChooserListFolder); m_widgetListFolder->registerOnEvent(this, "folder-validate", ewolEventFileChooserListFolder);
m_widgetListFolder->setExpand(bvec2(false,true)); m_widgetListFolder->setExpand(bvec2(false,true));
m_widgetListFolder->setFill(bvec2(false,true)); m_widgetListFolder->setFill(bvec2(false,true));
mySizerHori->subWidgetAdd(m_widgetListFolder); mySizerHori->subWidgetAdd(m_widgetListFolder);
@ -204,8 +205,8 @@ ewol::widget::FileChooser::FileChooser(void) {
m_widgetListFile->setShowFolder(false); m_widgetListFile->setShowFolder(false);
m_widgetListFile->setShowFiles(true); m_widgetListFile->setShowFiles(true);
m_widgetListFile->setShowHiddenFiles(false); m_widgetListFile->setShowHiddenFiles(false);
m_widgetListFile->registerOnEvent(this, ewolEventFSFileSelect, ewolEventFileChooserListFile); m_widgetListFile->registerOnEvent(this, "file-select", ewolEventFileChooserListFile);
m_widgetListFile->registerOnEvent(this, ewolEventFSFileValidate, ewolEventFileChooserListFileValidate); m_widgetListFile->registerOnEvent(this, "file-validate", ewolEventFileChooserListFileValidate);
m_widgetListFile->setExpand(bvec2(true,true)); m_widgetListFile->setExpand(bvec2(true,true));
m_widgetListFile->setFill(bvec2(true,true)); m_widgetListFile->setFill(bvec2(true,true));
mySizerHori->subWidgetAdd(m_widgetListFile); mySizerHori->subWidgetAdd(m_widgetListFile);
@ -235,8 +236,8 @@ ewol::widget::FileChooser::FileChooser(void) {
if (NULL == m_widgetCurrentFileName) { if (NULL == m_widgetCurrentFileName) {
EWOL_ERROR("Can not allocate widget == > display might be in error"); EWOL_ERROR("Can not allocate widget == > display might be in error");
} else { } else {
m_widgetCurrentFileName->registerOnEvent(this, ewol::widget::Entry::eventModify, ewolEventFileChooserEntryFile); m_widgetCurrentFileName->registerOnEvent(this, "modify", ewolEventFileChooserEntryFile);
m_widgetCurrentFileName->registerOnEvent(this, ewol::widget::Entry::eventEnter, ewolEventFileChooserEntryFileEnter); m_widgetCurrentFileName->registerOnEvent(this, "enter", ewolEventFileChooserEntryFileEnter);
m_widgetCurrentFileName->setExpand(bvec2(true,false)); m_widgetCurrentFileName->setExpand(bvec2(true,false));
m_widgetCurrentFileName->setFill(bvec2(true,false)); m_widgetCurrentFileName->setFill(bvec2(true,false));
//m_widgetCurrentFileName->setWidth(200); //m_widgetCurrentFileName->setWidth(200);
@ -261,8 +262,8 @@ ewol::widget::FileChooser::FileChooser(void) {
if (NULL == m_widgetCurrentFolder) { if (NULL == m_widgetCurrentFolder) {
EWOL_ERROR("Can not allocate widget == > display might be in error"); EWOL_ERROR("Can not allocate widget == > display might be in error");
} else { } else {
m_widgetCurrentFolder->registerOnEvent(this, ewol::widget::Entry::eventModify, ewolEventFileChooserEntryFolder); m_widgetCurrentFolder->registerOnEvent(this, "modify", ewolEventFileChooserEntryFolder);
m_widgetCurrentFolder->registerOnEvent(this, ewol::widget::Entry::eventEnter, ewolEventFileChooserEntryFolderEnter); m_widgetCurrentFolder->registerOnEvent(this, "enter", ewolEventFileChooserEntryFolderEnter);
m_widgetCurrentFolder->setExpand(bvec2(true,false)); m_widgetCurrentFolder->setExpand(bvec2(true,false));
m_widgetCurrentFolder->setFill(bvec2(true,false)); m_widgetCurrentFolder->setFill(bvec2(true,false));
//m_widgetCurrentFolder->setWidth(200); //m_widgetCurrentFolder->setWidth(200);
@ -273,7 +274,7 @@ ewol::widget::FileChooser::FileChooser(void) {
EWOL_ERROR("Can not allocate widget == > display might be in error"); EWOL_ERROR("Can not allocate widget == > display might be in error");
} else { } else {
//myImage->setImageSize(ewol::Dimension(vec2(8,8),ewol::Dimension::Millimeter)); //myImage->setImageSize(ewol::Dimension(vec2(8,8),ewol::Dimension::Millimeter));
myImage->registerOnEvent(this, ewol::widget::Image::eventPressed, ewolEventFileChooserHome); myImage->registerOnEvent(this, "pressed", ewolEventFileChooserHome);
myImage->setExpand(bvec2(false,false)); myImage->setExpand(bvec2(false,false));
mySizerHori->subWidgetAdd(myImage); mySizerHori->subWidgetAdd(myImage);
} }

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

@ -21,11 +21,10 @@
#undef __class__ #undef __class__
#define __class__ "Parameter" #define __class__ "Parameter"
const char * const ewol::widget::Parameter::eventClose = "close";
extern const char * const ewolEventParameterValidate = "ewol-event-parameter-validate"; static const char * const ewolEventParameterValidate = "ewol-event-parameter-validate";
extern const char * const ewolEventParameterClose = "ewol-event-parameter-close"; static const char * const ewolEventParameterSave = "ewol-event-parameter-save";
extern 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";
ewol::widget::Parameter::Parameter(void) : ewol::widget::Parameter::Parameter(void) :
@ -33,7 +32,7 @@ ewol::widget::Parameter::Parameter(void) :
m_widgetTitle(NULL), m_widgetTitle(NULL),
m_paramList(NULL) { m_paramList(NULL) {
addObjectType("ewol::widget::Parameter"); addObjectType("ewol::widget::Parameter");
addEventId(ewolEventParameterClose); addEventId(eventClose);
ewol::widget::Sizer * mySizerVert = NULL; ewol::widget::Sizer * mySizerVert = NULL;
ewol::widget::Sizer * mySizerHori = NULL; ewol::widget::Sizer * mySizerHori = NULL;
@ -80,7 +79,7 @@ ewol::widget::Parameter::Parameter(void) :
" <label>Save</label>\n" " <label>Save</label>\n"
" </sizer>\n" " </sizer>\n"
"</composer>\n")); "</composer>\n"));
tmpButton->registerOnEvent(this, ewol::widget::Button::eventPressed, ewolEventParameterSave); tmpButton->registerOnEvent(this, "pressed", ewolEventParameterSave);
mySizerHori->subWidgetAdd(tmpButton); mySizerHori->subWidgetAdd(tmpButton);
} }
@ -105,7 +104,7 @@ ewol::widget::Parameter::Parameter(void) :
" <label>Close</label>\n" " <label>Close</label>\n"
" </sizer>\n" " </sizer>\n"
"</composer>\n")); "</composer>\n"));
tmpButton->registerOnEvent(this, ewol::widget::Button::eventPressed, ewolEventParameterClose); tmpButton->registerOnEvent(this, "pressed", eventClose);
mySizerHori->subWidgetAdd(tmpButton); mySizerHori->subWidgetAdd(tmpButton);
} }
} }
@ -121,7 +120,7 @@ ewol::widget::Parameter::Parameter(void) :
EWOL_ERROR("Can not allocate widget == > display might be in error"); EWOL_ERROR("Can not allocate widget == > display might be in error");
} else { } else {
m_paramList->registerOnEvent(this, ewolEventParameterListSelect, l_eventMenuSelected); m_paramList->registerOnEvent(this, "select", l_eventMenuSelected);
m_paramList->setFill(bvec2(false,true)); m_paramList->setFill(bvec2(false,true));
m_paramList->setExpand(bvec2(false,true)); m_paramList->setExpand(bvec2(false,true));
mySizerHori->subWidgetAdd(m_paramList); mySizerHori->subWidgetAdd(m_paramList);
@ -199,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() == ewolEventParameterClose) { if (_msg.getMessage() == eventClose) {
// inform that the parameter windows is closed // inform that the parameter windows is closed
generateEventId(ewolEventParameterClose); generateEventId(eventClose);
// close this widget ... // close this widget ...
autoDestroy(); autoDestroy();
} else if (_msg.getMessage() == ewolEventParameterSave) { } else if (_msg.getMessage() == ewolEventParameterSave) {

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

@ -20,7 +20,6 @@
#include <ewol/widget/WSlider.h> #include <ewol/widget/WSlider.h>
#include <ewol/widget/meta/ParameterList.h> #include <ewol/widget/meta/ParameterList.h>
extern const char * const ewolEventParameterClose;
namespace ewol { namespace ewol {
namespace widget { namespace widget {
@ -28,6 +27,9 @@ namespace ewol {
* @ingroup ewolWidgetGroup * @ingroup ewolWidgetGroup
*/ */
class Parameter : public ewol::widget::PopUp { class Parameter : public ewol::widget::PopUp {
public:
// Event list of properties
static const char * const eventClose;
public: public:
Parameter(void); Parameter(void);
~Parameter(void); ~Parameter(void);

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

@ -15,7 +15,7 @@
#include <ewol/compositing/Text.h> #include <ewol/compositing/Text.h>
#include <ewol/widget/Manager.h> #include <ewol/widget/Manager.h>
extern const char * const ewolEventParameterListSelect = "ewol-event-parameter-list-select"; const char * const ewol::widget::ParameterList::eventSelect = "select";
#undef __class__ #undef __class__
#define __class__ "List" #define __class__ "List"
@ -23,7 +23,7 @@ extern const char * const ewolEventParameterListSelect = "ewol-event-paramet
ewol::widget::ParameterList::ParameterList(void) { ewol::widget::ParameterList::ParameterList(void) {
addObjectType("ewol::widget::ParameterList"); addObjectType("ewol::widget::ParameterList");
addEventId(ewolEventParameterListSelect); addEventId(eventSelect);
m_idSelected = -1; m_idSelected = -1;
m_paddingSizeX = 2; m_paddingSizeX = 2;
@ -189,7 +189,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]!=NULL) { if (m_list[rawID]!=NULL) {
if (m_list[rawID]->m_refId >= 0) { if (m_list[rawID]->m_refId >= 0) {
generateEventId(ewolEventParameterListSelect, std::to_string(m_list[rawID]->m_refId)); generateEventId(eventSelect, std::to_string(m_list[rawID]->m_refId));
m_idSelected = rawID; m_idSelected = rawID;
markToRedraw(); markToRedraw();
return true; return true;

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

@ -13,7 +13,6 @@
#include <ewol/debug.h> #include <ewol/debug.h>
#include <ewol/widget/WidgetScrolled.h> #include <ewol/widget/WidgetScrolled.h>
extern const char * const ewolEventParameterListSelect;
namespace ewol { namespace ewol {
@ -38,6 +37,9 @@ namespace ewol {
* @ingroup ewolWidgetGroup * @ingroup ewolWidgetGroup
*/ */
class ParameterList :public ewol::widget::WidgetScrooled { class ParameterList :public ewol::widget::WidgetScrooled {
public:
// Event list of properties
static const char * const eventSelect;
private: private:
int32_t m_idSelected; int32_t m_idSelected;
std::vector<ewol::widget::elementPL *> m_list; std::vector<ewol::widget::elementPL *> m_list;