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...");
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 :
bool findIt = false;
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...
* @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] _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 widget {
/**
* @ingroup ewolWidgetGroup
* @brief a composed button is a button with an inside composed with the specify XML element == > this permit to generate standard element simple
* @brief a composed button is a button with an inside composed with the specify XML element
* ==> this permit to generate standard element simple
*/
class Button : public ewol::Widget {
public:

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

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

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

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

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

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

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

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

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

@ -13,7 +13,7 @@
#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) {
addObjectType("ewol::widget::ColorBar");
addEventId(ewolEventColorBarChange);
addEventId(eventChange);
m_currentUserPos.setValue(0,0);
m_currentColor = etk::color::black;
setCanHaveFocus(true);
@ -221,7 +221,7 @@ bool ewol::widget::ColorBar::onEventInput(const ewol::event::Input& _event) {
}
if(m_currentColor != estimateColor) {
m_currentColor = estimateColor;
generateEventId(ewolEventColorBarChange);
generateEventId(eventChange);
}
return true;
}

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

@ -15,14 +15,13 @@
#include <ewol/widget/Widget.h>
#include <ewol/compositing/Drawing.h>
extern const char * const ewolEventColorBarChange;
namespace ewol {
namespace widget {
/**
* @ingroup ewolWidgetGroup
*/
class ColorBar :public ewol::Widget {
public:
// Event list of properties
static const char * const eventChange;
public:
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::configSize = "size";

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

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

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

@ -12,9 +12,9 @@
#include <ewol/compositing/Image.h>
#include <ewol/widget/Manager.h>
extern const char * const ewolEventJoystickEnable = "ewol-joystick-enable";
extern const char * const ewolEventJoystickDisable = "ewol-joystick-disable";
extern const char * const ewolEventJoystickMove = "ewol-joystick-move";
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("");
@ -26,9 +26,9 @@ static float l_ratio(1.0/7.0);
ewol::widget::Joystick::Joystick(void) {
addObjectType("ewol::widget::Joystick");
addEventId(ewolEventJoystickEnable);
addEventId(ewolEventJoystickDisable);
addEventId(ewolEventJoystickMove);
addEventId(eventEnable);
addEventId(eventDisable);
addEventId(eventMove);
// by default the joy does not lock when free out
m_lock = false;
m_displayMode = modeNormal;
@ -144,10 +144,10 @@ bool ewol::widget::Joystick::onEventInput(const ewol::event::Input& _event) {
}
markToRedraw();
if(ewol::key::statusDown == typeEvent) {
generateEventId(ewolEventJoystickEnable);
generateEventId(eventEnable);
} else {
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;
//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;
}
markToRedraw();
generateEventId(ewolEventJoystickDisable);
generateEventId(eventDisable);
return true;
}
return false;

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

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

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

@ -15,7 +15,7 @@
#undef __class__
#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) {
return new ewol::widget::Label();

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

@ -15,10 +15,10 @@
#undef __class__
#define __class__ "ListFileSystem"
extern const char * const ewolEventFSFileSelect = "ewol-event-file-system-file-select";
extern const char * const ewolEventFSFileValidate = "ewol-event-file-system-file-validate";
extern const char * const ewolEventFSFolderSelect = "ewol-event-file-system-folder-select";
extern const char * const ewolEventFSFolderValidate = "ewol-event-file-system-folder-validate";
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(void) {
@ -33,10 +33,10 @@ ewol::widget::ListFileSystem::ListFileSystem(void) {
#else
m_folder = "/";
#endif
addEventId(ewolEventFSFileSelect);
addEventId(ewolEventFSFileValidate);
addEventId(ewolEventFSFolderSelect);
addEventId(ewolEventFSFolderValidate);
addEventId(eventFileSelect);
addEventId(eventFileValidate);
addEventId(eventFolderSelect);
addEventId(eventFolderValidate);
setMouseLimit(1);
};
@ -203,21 +203,21 @@ bool ewol::widget::ListFileSystem::onItemEvent(int32_t _IdInput,
if( m_showFolder == true
&& m_selectedLine == 0) {
// "." folder
generateEventId(ewolEventFSFolderSelect, ".");
generateEventId(eventFolderSelect, ".");
} else if ( m_showFolder == true
&& m_selectedLine == 1) {
// ".." folder
generateEventId(ewolEventFSFolderSelect, "..");
generateEventId(eventFolderSelect, "..");
} else if( m_selectedLine-offset >= 0
&& m_selectedLine-offset < (int32_t)m_list.size()
&& NULL != m_list[m_selectedLine-offset] ) {
// generate event extern :
switch(m_list[m_selectedLine-offset]->getNodeType()) {
case etk::FSN_FILE :
generateEventId(ewolEventFSFileSelect, m_list[m_selectedLine-offset]->getNameFile());
generateEventId(eventFileSelect, m_list[m_selectedLine-offset]->getNameFile());
break;
case etk::FSN_FOLDER :
generateEventId(ewolEventFSFolderSelect, m_list[m_selectedLine-offset]->getNameFile());
generateEventId(eventFolderSelect, m_list[m_selectedLine-offset]->getNameFile());
break;
default:
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
&& m_selectedLine == 0) {
// "." folder
generateEventId(ewolEventFSFolderValidate, ".");
generateEventId(eventFolderValidate, ".");
} else if ( m_showFolder == true
&& m_selectedLine == 1) {
// ".." folder
generateEventId(ewolEventFSFolderValidate, "..");
generateEventId(eventFolderValidate, "..");
} else if( m_selectedLine-offset >= 0
&& m_selectedLine-offset < (int32_t)m_list.size()
&& NULL != m_list[m_selectedLine-offset] ) {
switch(m_list[m_selectedLine-offset]->getNodeType())
{
case etk::FSN_FILE :
generateEventId(ewolEventFSFileValidate, m_list[m_selectedLine-offset]->getNameFile());
generateEventId(eventFileValidate, m_list[m_selectedLine-offset]->getNameFile());
break;
case etk::FSN_FOLDER :
generateEventId(ewolEventFSFolderValidate, m_list[m_selectedLine-offset]->getNameFile());
generateEventId(eventFolderValidate, m_list[m_selectedLine-offset]->getNameFile());
break;
default:
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 <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 widget {
@ -23,6 +19,12 @@ namespace ewol {
* @ingroup ewolWidgetGroup
*/
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:
std::vector<etk::FSNode *> m_list;
std::string m_folder;

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

@ -10,7 +10,7 @@
#include <ewol/widget/Manager.h>
extern const char * const ewolEventSliderChange = "ewol-event-slider-change";
const char * const ewol::widget::Slider::eventChange = "change";
#undef __class__
#define __class__ "Slider"
@ -27,7 +27,7 @@ const int32_t dotRadius = 6;
ewol::widget::Slider::Slider(void) {
addObjectType("ewol::widget::Slider");
addEventId(ewolEventSliderChange);
addEventId(eventChange);
m_value = 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);
if (oldValue != m_value) {
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();
}
return true;

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

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

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

@ -23,19 +23,17 @@ extern "C" {
#define __class__ "ColorChooser"
const char * const ewol::widget::ColorChooser::eventChange = "change";
extern const char * const ewolEventColorChooserChange = "ewol-event-color-chooser-change";
const char * const eventColorBarHasChange = "event-color-bar-has-change";
const char * const eventColorSpecificHasChange = "event-color-specific-has-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(void) :
ewol::widget::Sizer(ewol::widget::Sizer::modeVert) {
addObjectType("ewol::widget::ColorChooser");
addEventId(ewolEventColorChooserChange);
addEventId(eventChange);
m_widgetColorBar = NULL;
m_widgetRed = NULL;
m_widgetGreen = NULL;
@ -43,7 +41,7 @@ ewol::widget::ColorChooser::ColorChooser(void) :
m_widgetAlpha = NULL;
lockExpand(bvec2(true,true));
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->setWidth(200);
@ -55,7 +53,7 @@ ewol::widget::ColorChooser::ColorChooser(void) :
sliderColor = etk::color::black;
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->setFill(bvec2(true,false));
m_widgetRed->setMin(0);
@ -64,7 +62,7 @@ ewol::widget::ColorChooser::ColorChooser(void) :
m_widgetRed->setColor(sliderColor);
subWidgetAdd(m_widgetRed);
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->setFill(bvec2(true,false));
m_widgetGreen->setMin(0);
@ -73,7 +71,7 @@ ewol::widget::ColorChooser::ColorChooser(void) :
m_widgetGreen->setMax(255);
subWidgetAdd(m_widgetGreen);
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->setFill(bvec2(true,false));
m_widgetBlue->setMin(0);
@ -82,7 +80,7 @@ ewol::widget::ColorChooser::ColorChooser(void) :
m_widgetBlue->setMax(255);
subWidgetAdd(m_widgetBlue);
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->setFill(bvec2(true,false));
m_widgetAlpha->setMin(0);
@ -148,7 +146,7 @@ void ewol::widget::ColorChooser::onReceiveMessage(const ewol::object::Message& _
if (NULL != m_widgetAlpha) {
m_widgetAlpha->setValue(m_currentColor.a());
}
generateEventId(ewolEventColorChooserChange, m_currentColor.getString());
generateEventId(eventChange, m_currentColor.getString());
} else if (eventColorSpecificHasChange == _msg.getMessage()) {
// Slider has changes his color == > get the one change ...
if (_msg.getCaller() == m_widgetRed) {
@ -166,7 +164,7 @@ void ewol::widget::ColorChooser::onReceiveMessage(const ewol::object::Message& _
if (NULL != m_widgetColorBar) {
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/Slider.h>
extern const char * const ewolEventColorChooserChange;
namespace ewol {
namespace widget {
/**
* @ingroup ewolWidgetGroup
*/
class ColorChooser : public ewol::widget::Sizer {
public:
// Event list of properties
static const char * const eventChange;
public:
ColorChooser(void);
~ColorChooser(void);

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

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

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

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

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

@ -15,7 +15,7 @@
#include <ewol/compositing/Text.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__
#define __class__ "List"
@ -23,7 +23,7 @@ extern const char * const ewolEventParameterListSelect = "ewol-event-paramet
ewol::widget::ParameterList::ParameterList(void) {
addObjectType("ewol::widget::ParameterList");
addEventId(ewolEventParameterListSelect);
addEventId(eventSelect);
m_idSelected = -1;
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 (m_list[rawID]!=NULL) {
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;
markToRedraw();
return true;

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

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