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

[DEV] it compile but it can not work now ...

Browse Source
This commit is contained in:
Edouard DUPIN 2014-05-17 20:24:11 +02:00
parent 227a08be18
commit 7aa87e0fcc
49 changed files with 310 additions and 317 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -38,8 +38,8 @@ static ewol::Widget* Create() {
return new ewol::widget::Button(); return new ewol::widget::Button();
} }
void ewol::widget::Button::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) { void ewol::widget::Button::init(ewol::widget::Manager& _widgetManager) {
_widgetManager->addWidgetCreator(__class__, &Create); _widgetManager.addWidgetCreator(__class__, &Create);
} }
ewol::widget::Button::Button(const std::string& _shaperName) : ewol::widget::Button::Button(const std::string& _shaperName) :

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

@ -28,7 +28,7 @@ namespace ewol {
class Button : public ewol::widget::Container2 { class Button : public ewol::widget::Container2 {
public: public:
//! @not-in-doc //! @not-in-doc
static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager); static void init(ewol::widget::Manager& _widgetManager);
// Event list of properties // Event list of properties
static const char* const eventPressed; static const char* const eventPressed;
static const char* const eventDown; static const char* const eventDown;

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

@ -34,8 +34,8 @@ static ewol::Widget* Create() {
return new ewol::widget::ButtonColor(); return new ewol::widget::ButtonColor();
} }
void ewol::widget::ButtonColor::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) { void ewol::widget::ButtonColor::init(ewol::widget::Manager& _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&Create); _widgetManager.addWidgetCreator(__class__,&Create);
} }
ewol::widget::ButtonColor::ButtonColor(etk::Color<> _baseColor, std::string _shaperName) : ewol::widget::ButtonColor::ButtonColor(etk::Color<> _baseColor, std::string _shaperName) :

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

@ -25,7 +25,7 @@ namespace ewol {
// Event list of properties // Event list of properties
static const char * const eventChange; static const char * const eventChange;
public: public:
static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager); static void init(ewol::widget::Manager& _widgetManager);
private: private:
ewol::compositing::Shaper m_shaper; //!< Compositing theme. ewol::compositing::Shaper m_shaper; //!< Compositing theme.
ewol::compositing::Text m_text; //!< Compositing Test display. ewol::compositing::Text m_text; //!< Compositing Test display.

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

@ -31,8 +31,8 @@ static ewol::Widget* Create() {
return new ewol::widget::CheckBox(); return new ewol::widget::CheckBox();
} }
void ewol::widget::CheckBox::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) { void ewol::widget::CheckBox::init(ewol::widget::Manager& _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&Create); _widgetManager.addWidgetCreator(__class__,&Create);
} }
ewol::widget::CheckBox::CheckBox(const std::string& _shaperName) : ewol::widget::CheckBox::CheckBox(const std::string& _shaperName) :

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

@ -21,7 +21,7 @@ namespace ewol {
class CheckBox : public ewol::widget::Container2 { class CheckBox : public ewol::widget::Container2 {
public: public:
//! @not-in-doc //! @not-in-doc
static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager); static void init(ewol::widget::Manager& _widgetManager);
// Event list of properties // Event list of properties
static const char* const eventPressed; static const char* const eventPressed;
static const char* const eventDown; static const char* const eventDown;

4
sources/ewol/widget/ContextMenu.cpp
View File

@ -25,8 +25,8 @@ static ewol::Widget* Create() {
return new ewol::widget::ContextMenu(); return new ewol::widget::ContextMenu();
} }
void ewol::widget::ContextMenu::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) { void ewol::widget::ContextMenu::init(ewol::widget::Manager& _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&Create); _widgetManager.addWidgetCreator(__class__,&Create);
} }

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

@ -32,7 +32,7 @@ namespace ewol {
markNone markNone
}; };
public: public:
static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager); static void init(ewol::widget::Manager& _widgetManager);
// Config list of properties // Config list of properties
static const char* const configArrowPosition; static const char* const configArrowPosition;
static const char* const configArrowMode; static const char* const configArrowMode;

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

@ -33,8 +33,8 @@ static ewol::Widget* create() {
return new ewol::widget::Entry(); return new ewol::widget::Entry();
} }
void ewol::widget::Entry::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) { void ewol::widget::Entry::init(ewol::widget::Manager& _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&create); _widgetManager.addWidgetCreator(__class__,&create);
} }
const char * const ewol::widget::Entry::eventClick = "click"; const char * const ewol::widget::Entry::eventClick = "click";

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

@ -43,7 +43,7 @@ namespace ewol {
static const char* const configEmptyMessage; static const char* const configEmptyMessage;
static const char* const configValue; static const char* const configValue;
public: public:
static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager); static void init(ewol::widget::Manager& _widgetManager);
private: private:
ewol::compositing::Shaper m_shaper; ewol::compositing::Shaper m_shaper;
int32_t m_colorIdTextFg; //!< color property of the text foreground int32_t m_colorIdTextFg; //!< color property of the text foreground

4
sources/ewol/widget/Gird.cpp
View File

@ -19,8 +19,8 @@ static ewol::Widget* create() {
return new ewol::widget::Gird(); return new ewol::widget::Gird();
} }
void ewol::widget::Gird::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) { void ewol::widget::Gird::init(ewol::widget::Manager& _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&create); _widgetManager.addWidgetCreator(__class__,&create);
} }

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

@ -22,7 +22,7 @@ namespace ewol {
*/ */
class Gird :public ewol::Widget { class Gird :public ewol::Widget {
public: public:
static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager); static void init(ewol::widget::Manager& _widgetManager);
private: private:
class GirdProperties { class GirdProperties {
public: public:

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

@ -20,8 +20,8 @@ static ewol::Widget* create() {
return new ewol::widget::Image(); return new ewol::widget::Image();
} }
void ewol::widget::Image::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) { void ewol::widget::Image::init(ewol::widget::Manager& _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&create); _widgetManager.addWidgetCreator(__class__,&create);
} }

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

@ -38,7 +38,7 @@ namespace ewol {
/** /**
* @brief Main call of recording the widget on the List of "widget named creator" * @brief Main call of recording the widget on the List of "widget named creator"
*/ */
static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager); static void init(ewol::widget::Manager& _widgetManager);
protected: protected:
ewol::compositing::Image m_compositing; //!< compositing element of the image. ewol::compositing::Image m_compositing; //!< compositing element of the image.
ewol::resource::ColorFile* m_colorProperty; //!< theme color property ewol::resource::ColorFile* m_colorProperty; //!< theme color property

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

@ -22,8 +22,8 @@ static ewol::Widget* create() {
return new ewol::widget::Label(); return new ewol::widget::Label();
} }
void ewol::widget::Label::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) { void ewol::widget::Label::init(ewol::widget::Manager& _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&create); _widgetManager.addWidgetCreator(__class__,&create);
} }
// TODO : Remove the label name in the constructor ... // TODO : Remove the label name in the constructor ...
ewol::widget::Label::Label(std::string _newLabel) : ewol::widget::Label::Label(std::string _newLabel) :

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

@ -30,7 +30,7 @@ namespace ewol {
/** /**
* @brief Main call of recording the widget on the List of "widget named creator" * @brief Main call of recording the widget on the List of "widget named creator"
*/ */
static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager); static void init(ewol::widget::Manager& _widgetManager);
private: private:
ewol::compositing::Text m_text; //!< Compositing text element. ewol::compositing::Text m_text; //!< Compositing text element.
std::u32string m_label; //!< decorated text to display. std::u32string m_label; //!< decorated text to display.

4
sources/ewol/widget/Layer.cpp
View File

@ -17,8 +17,8 @@ static ewol::Widget* create() {
return new ewol::widget::Layer(); return new ewol::widget::Layer();
} }
void ewol::widget::Layer::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) { void ewol::widget::Layer::init(ewol::widget::Manager& _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&create); _widgetManager.addWidgetCreator(__class__,&create);
} }
ewol::widget::Layer::Layer() { ewol::widget::Layer::Layer() {

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

@ -24,7 +24,7 @@ namespace ewol {
/** /**
* @brief Main call of recording the widget on the List of "widget named creator" * @brief Main call of recording the widget on the List of "widget named creator"
*/ */
static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager); static void init(ewol::widget::Manager& _widgetManager);
public: public:
/** /**
* @brief Constructor * @brief Constructor

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

@ -20,7 +20,7 @@ namespace ewol {
/** /**
* @ingroup ewolWidgetGroup * @ingroup ewolWidgetGroup
*/ */
class List : public ewol::Widget::WidgetScrolled { class List : public ewol::widget::WidgetScrolled {
public: public:
List(); List();
virtual ~List(); virtual ~List();

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

@ -19,8 +19,8 @@ static ewol::Widget* Create() {
return new ewol::widget::ListFileSystem(); return new ewol::widget::ListFileSystem();
} }
void ewol::widget::ListFileSystem::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) { void ewol::widget::ListFileSystem::init(ewol::widget::Manager& _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&Create); _widgetManager.addWidgetCreator(__class__,&Create);
} }
const char * const ewol::widget::ListFileSystem::eventFileSelect = "file-select"; const char * const ewol::widget::ListFileSystem::eventFileSelect = "file-select";

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

@ -21,7 +21,7 @@ namespace ewol {
class ListFileSystem : public ewol::widget::List { class ListFileSystem : public ewol::widget::List {
public: public:
//! @not-in-doc //! @not-in-doc
static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager); static void init(ewol::widget::Manager& _widgetManager);
// Event list of properties // Event list of properties
static const char * const eventFileSelect; //!< @event "file-select" Generated when a file is selected. 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 eventFileValidate; //!< @event "file-validate" Generate when the user validate (return) or double click on the element

20
sources/ewol/widget/Manager.cpp
View File

@ -45,20 +45,20 @@ ewol::widget::Manager::Manager() :
ewol::widget::Button::init(*this); ewol::widget::Button::init(*this);
ewol::widget::ButtonColor::init(*this); ewol::widget::ButtonColor::init(*this);
ewol::Widget::Spacer::init(*this); ewol::widget::Spacer::init(*this);
ewol::widget::Slider::init(*this); ewol::widget::Slider::init(*this);
ewol::widget::Sizer::init(*this); ewol::widget::Sizer::init(*this);
ewol::Widget::ProgressBar::init(*this); ewol::widget::ProgressBar::init(*this);
ewol::widget::Layer::init(*this); ewol::widget::Layer::init(*this);
ewol::widget::Label::init(*this); ewol::widget::Label::init(*this);
ewol::widget::Image::init(*this); ewol::widget::Image::init(*this);
ewol::widget::Gird::init(*this); ewol::widget::Gird::init(*this);
ewol::widget::Entry::init(*this); ewol::widget::Entry::init(*this);
ewol::widget::CheckBox::init(*this); ewol::widget::CheckBox::init(*this);
ewol::Widget::Scroll::init(*this); ewol::widget::Scroll::init(*this);
ewol::widget::ContextMenu::init(*this); ewol::widget::ContextMenu::init(*this);
ewol::Widget::PopUp::init(*this); ewol::widget::PopUp::init(*this);
ewol::Widget::WSlider::init(*this); ewol::widget::WSlider::init(*this);
ewol::widget::ListFileSystem::init(*this); ewol::widget::ListFileSystem::init(*this);
} }
@ -72,7 +72,7 @@ ewol::widget::Manager::~Manager() {
m_creatorList.clear(); m_creatorList.clear();
} }
void ewol::widget::Manager::rm(ewol::Widget* _newWidget) { void ewol::widget::Manager::rm(ewol::object::Shared<ewol::Widget> _newWidget) {
periodicCallRm(_newWidget); periodicCallRm(_newWidget);
focusRemoveIfRemove(_newWidget); focusRemoveIfRemove(_newWidget);
} }
@ -81,7 +81,7 @@ void ewol::widget::Manager::rm(ewol::Widget* _newWidget) {
* focus Area : * focus Area :
* *************************************************************************/ * *************************************************************************/
void ewol::widget::Manager::focusKeep(ewol::Widget* _newWidget) { void ewol::widget::Manager::focusKeep(ewol::object::Shared<ewol::Widget> _newWidget) {
if (NULL == _newWidget) { if (NULL == _newWidget) {
// nothing to do ... // nothing to do ...
return; return;
@ -106,7 +106,7 @@ void ewol::widget::Manager::focusKeep(ewol::Widget* _newWidget) {
} }
} }
void ewol::widget::Manager::focusSetDefault(ewol::Widget * _newWidget) { void ewol::widget::Manager::focusSetDefault(ewol::object::Shared<ewol::Widget> _newWidget) {
if( NULL != _newWidget if( NULL != _newWidget
&& false == _newWidget->canHaveFocus() ) { && false == _newWidget->canHaveFocus() ) {
EWOL_VERBOSE("Widget can not have focus, id=" << _newWidget->getId() ); EWOL_VERBOSE("Widget can not have focus, id=" << _newWidget->getId() );
@ -143,7 +143,7 @@ void ewol::widget::Manager::focusRelease() {
} }
ewol::object::Shared<ewol::Widget> * ewol::widget::Manager::focusGet() { ewol::object::Shared<ewol::Widget> ewol::widget::Manager::focusGet() {
return m_focusWidgetCurrent; return m_focusWidgetCurrent;
} }
@ -244,7 +244,7 @@ bool ewol::widget::Manager::isDrawingNeeded() {
// element that generate the list of elements // element that generate the list of elements
void ewol::widget::Manager::addWidgetCreator(const std::string& _name, void ewol::widget::Manager::addWidgetCreator(const std::string& _name,
ewol::widget::Manager::creator_tf _pointer) { ewol::widget::Manager::creator_tf _pointer) {
if (NULL == _pointer) { if (NULL == _pointer) {
return; return;
} }

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

@ -18,35 +18,35 @@
#undef __class__ #undef __class__
#define __class__ "Menu" #define __class__ "Menu"
ewol::Widget::Menu::Menu() { ewol::widget::Menu::Menu() {
addObjectType("ewol::Widget::Menu"); addObjectType("ewol::widget::Menu");
m_staticId = 0; m_staticId = 0;
m_widgetContextMenu = NULL; m_widgetContextMenu = NULL;
} }
ewol::Widget::Menu::~Menu() { ewol::widget::Menu::~Menu() {
clear(); clear();
} }
void ewol::Widget::Menu::subWidgetRemoveAll() { void ewol::widget::Menu::subWidgetRemoveAll() {
clear(); clear();
ewol::widget::Sizer::subWidgetRemoveAll(); ewol::widget::Sizer::subWidgetRemoveAll();
} }
int32_t ewol::Widget::Menu::subWidgetAdd(ewol::Widget* _newWidget) { int32_t ewol::widget::Menu::subWidgetAdd(ewol::object::Shared<ewol::Widget> _newWidget) {
EWOL_ERROR("Not availlable"); EWOL_ERROR("Not availlable");
return -1; return -1;
} }
void ewol::Widget::Menu::subWidgetRemove(ewol::Widget* _newWidget) { void ewol::widget::Menu::subWidgetRemove(ewol::object::Shared<ewol::Widget> _newWidget) {
EWOL_ERROR("Not availlable"); EWOL_ERROR("Not availlable");
} }
void ewol::Widget::Menu::subWidgetUnLink(ewol::Widget* _newWidget) { void ewol::widget::Menu::subWidgetUnLink(ewol::object::Shared<ewol::Widget> _newWidget) {
EWOL_ERROR("Not availlable"); EWOL_ERROR("Not availlable");
} }
void ewol::Widget::Menu::clear() { void ewol::widget::Menu::clear() {
for (size_t iii=0; iii < m_listElement.size(); iii++) { for (size_t iii=0; iii < m_listElement.size(); iii++) {
if (m_listElement[iii] != NULL) { if (m_listElement[iii] != NULL) {
delete(m_listElement[iii]); delete(m_listElement[iii]);
@ -56,19 +56,19 @@ void ewol::Widget::Menu::clear() {
m_listElement.clear(); m_listElement.clear();
} }
int32_t ewol::Widget::Menu::addTitle(std::string _label, int32_t ewol::widget::Menu::addTitle(std::string _label,
std::string _image, std::string _image,
const char * _generateEvent, const char * _generateEvent,
const std::string _message) { const std::string _message) {
return add(-1, _label, _image, _generateEvent, _message); return add(-1, _label, _image, _generateEvent, _message);
} }
int32_t ewol::Widget::Menu::add(int32_t _parent, int32_t ewol::widget::Menu::add(int32_t _parent,
std::string _label, std::string _label,
std::string _image, std::string _image,
const char *_generateEvent, const char *_generateEvent,
const std::string _message) { const std::string _message) {
ewol::Widget::MenuElement *tmpObject = new ewol::Widget::MenuElement(); ewol::widget::MenuElement *tmpObject = new ewol::widget::MenuElement();
if (NULL == tmpObject) { if (NULL == tmpObject) {
EWOL_ERROR("Allocation problem"); EWOL_ERROR("Allocation problem");
return -1; return -1;
@ -111,12 +111,12 @@ int32_t ewol::Widget::Menu::add(int32_t _parent,
return tmpObject->m_localId; return tmpObject->m_localId;
} }
void ewol::Widget::Menu::addSpacer() { void ewol::widget::Menu::addSpacer() {
EWOL_TODO("NOT now..."); EWOL_TODO("NOT now...");
} }
void ewol::Widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) { void ewol::widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
/* /*
if (true == ewol::sizer::onReceiveMessage(_msg) { if (true == ewol::sizer::onReceiveMessage(_msg) {
return true; return true;
@ -158,7 +158,9 @@ void ewol::Widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
} }
// get the button widget : // get the button widget :
vec2 newPosition; vec2 newPosition;
ewol::object::Shared<ewol::Widget> * eventFromWidget = static_cast<ewol::Widget*>(_msg.getCaller()); // TODO : Set it back :
/*
ewol::object::Shared<ewol::Widget> eventFromWidget = static_cast<ewol::object::Shared<ewol::Widget>>(_msg.getCaller());
if (NULL != eventFromWidget) { if (NULL != eventFromWidget) {
vec2 tmpOri = eventFromWidget->getOrigin(); vec2 tmpOri = eventFromWidget->getOrigin();
vec2 tmpSize = eventFromWidget->getSize(); vec2 tmpSize = eventFromWidget->getSize();
@ -166,7 +168,7 @@ void ewol::Widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
newPosition.setValue(tmpOri.x() + tmpSize.x()/2, newPosition.setValue(tmpOri.x() + tmpSize.x()/2,
tmpOri.y() ); tmpOri.y() );
} }
*/
m_widgetContextMenu->setPositionMark(ewol::widget::ContextMenu::markTop, newPosition ); m_widgetContextMenu->setPositionMark(ewol::widget::ContextMenu::markTop, newPosition );
ewol::widget::Sizer * mySizer = NULL; ewol::widget::Sizer * mySizer = NULL;
@ -240,11 +242,11 @@ void ewol::Widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
} }
} }
} }
ewol::widget::Windows* currentWindows = getWindows(); ewol::object::Shared<ewol::widget::Windows> currentWindows = getWindows();
if (NULL == currentWindows) { if (currentWindows == nullptr) {
EWOL_ERROR("Can not get the curent Windows..."); EWOL_ERROR("Can not get the curent Windows...");
m_widgetContextMenu->removeObject(); m_widgetContextMenu->removeObject();
m_widgetContextMenu=NULL; m_widgetContextMenu = NULL;
} else { } else {
currentWindows->popUpWidgetPush(m_widgetContextMenu); currentWindows->popUpWidgetPush(m_widgetContextMenu);
} }
@ -256,15 +258,16 @@ void ewol::Widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
} }
void ewol::Widget::Menu::onObjectRemove(ewol::object::Shared<ewol::Object> * _removeObject) { void ewol::widget::Menu::onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject) {
ewol::widget::Sizer::onObjectRemove(_removeObject); ewol::widget::Sizer::onObjectRemove(_removeObject);
if (m_widgetContextMenu == _removeObject) { if (m_widgetContextMenu == _removeObject) {
delete(m_widgetContextMenu);
m_widgetContextMenu = NULL; m_widgetContextMenu = NULL;
} }
for (size_t jjj=0; jjj<m_listElement.size(); jjj++) { for (size_t jjj=0; jjj<m_listElement.size(); jjj++) {
if (NULL != m_listElement[jjj]) { if (NULL != m_listElement[jjj]) {
if (m_listElement[jjj]->m_widgetPointer == _removeObject) { if (m_listElement[jjj]->m_widgetPointer == _removeObject) {
m_listElement[jjj]->m_widgetPointer = NULL; m_listElement[jjj]->m_widgetPointer.reset();
} }
} }
} }

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

@ -42,7 +42,7 @@ namespace ewol {
virtual void subWidgetRemove(ewol::object::Shared<ewol::Widget> _newWidget); virtual void subWidgetRemove(ewol::object::Shared<ewol::Widget> _newWidget);
virtual void subWidgetUnLink(ewol::object::Shared<ewol::Widget> _newWidget); virtual void subWidgetUnLink(ewol::object::Shared<ewol::Widget> _newWidget);
private: private:
std::vector<ewol::Widget::MenuElement*> m_listElement; std::vector<ewol::widget::MenuElement*> m_listElement;
int32_t m_staticId; // unique ID for every element of the menu ... int32_t m_staticId; // unique ID for every element of the menu ...
ewol::widget::ContextMenu* m_widgetContextMenu; ewol::widget::ContextMenu* m_widgetContextMenu;
public: public:
@ -52,7 +52,7 @@ namespace ewol {
void addSpacer(); void addSpacer();
// Derived function // Derived function
virtual void onReceiveMessage(const ewol::object::Message& _msg); virtual void onReceiveMessage(const ewol::object::Message& _msg);
virtual void onObjectRemove(ewol::object::Shared<ewol::Object> * _removeObject); virtual void onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject);
}; };
}; };
}; };

46
sources/ewol/widget/PopUp.cpp
View File

@ -15,26 +15,26 @@
#undef __class__ #undef __class__
#define __class__ "PopUp" #define __class__ "PopUp"
const char* const ewol::Widget::PopUp::configShaper="shaper"; const char* const ewol::widget::PopUp::configShaper="shaper";
const char* const ewol::Widget::PopUp::configRemoveOnExternClick="out-click-remove"; const char* const ewol::widget::PopUp::configRemoveOnExternClick="out-click-remove";
const char* const ewol::Widget::PopUp::configAnimation="animation"; const char* const ewol::widget::PopUp::configAnimation="animation";
const char* const ewol::Widget::PopUp::configLockExpand="lock"; const char* const ewol::widget::PopUp::configLockExpand="lock";
static const char* annimationIncrease = "increase"; static const char* annimationIncrease = "increase";
static ewol::Widget* create() { static ewol::Widget* create() {
return new ewol::Widget::PopUp(); return new ewol::widget::PopUp();
} }
void ewol::Widget::PopUp::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) { void ewol::widget::PopUp::init(ewol::widget::Manager& _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&create); _widgetManager.addWidgetCreator(__class__,&create);
} }
ewol::Widget::PopUp::PopUp(const std::string& _shaperName) : ewol::widget::PopUp::PopUp(const std::string& _shaperName) :
m_shaper(_shaperName), m_shaper(_shaperName),
m_lockExpand(true,true), m_lockExpand(true,true),
m_closeOutEvent(false) { m_closeOutEvent(false) {
addObjectType("ewol::Widget::PopUp"); addObjectType("ewol::widget::PopUp");
m_userExpand.setValue(false, false); m_userExpand.setValue(false, false);
setMinSize(ewol::Dimension(vec2(80,80),ewol::Dimension::Pourcent)); setMinSize(ewol::Dimension(vec2(80,80),ewol::Dimension::Pourcent));
registerConfig(configShaper, "string", NULL, "The shaper properties"); registerConfig(configShaper, "string", NULL, "The shaper properties");
@ -46,11 +46,11 @@ ewol::Widget::PopUp::PopUp(const std::string& _shaperName) :
addAnnimationType(ewol::Widget::annimationModeEnableAdd, annimationIncrease); addAnnimationType(ewol::Widget::annimationModeEnableAdd, annimationIncrease);
} }
ewol::Widget::PopUp::~PopUp() { ewol::widget::PopUp::~PopUp() {
} }
void ewol::Widget::PopUp::lockExpand(const bvec2& _lockExpand) { void ewol::widget::PopUp::lockExpand(const bvec2& _lockExpand) {
if (_lockExpand != m_lockExpand) { if (_lockExpand != m_lockExpand) {
m_lockExpand = _lockExpand; m_lockExpand = _lockExpand;
markToRedraw(); markToRedraw();
@ -58,12 +58,12 @@ void ewol::Widget::PopUp::lockExpand(const bvec2& _lockExpand) {
} }
} }
void ewol::Widget::PopUp::setShaperName(const std::string& _shaperName) { void ewol::widget::PopUp::setShaperName(const std::string& _shaperName) {
m_shaper.setSource(_shaperName); m_shaper.setSource(_shaperName);
markToRedraw(); markToRedraw();
} }
void ewol::Widget::PopUp::calculateSize(const vec2& _available) { void ewol::widget::PopUp::calculateSize(const vec2& _available) {
ewol::Widget::calculateSize(_available); ewol::Widget::calculateSize(_available);
if (NULL != m_subWidget) { if (NULL != m_subWidget) {
ewol::Padding padding = m_shaper.getPadding(); ewol::Padding padding = m_shaper.getPadding();
@ -97,7 +97,7 @@ void ewol::Widget::PopUp::calculateSize(const vec2& _available) {
markToRedraw(); markToRedraw();
} }
void ewol::Widget::PopUp::systemDraw(const ewol::DrawProperty& _displayProp) { void ewol::widget::PopUp::systemDraw(const ewol::DrawProperty& _displayProp) {
if (true == m_hide){ if (true == m_hide){
// widget is hidden ... // widget is hidden ...
return; return;
@ -113,11 +113,11 @@ void ewol::Widget::PopUp::systemDraw(const ewol::DrawProperty& _displayProp) {
} }
} }
void ewol::Widget::PopUp::onDraw() { void ewol::widget::PopUp::onDraw() {
m_shaper.draw(); m_shaper.draw();
} }
void ewol::Widget::PopUp::onRegenerateDisplay() { void ewol::widget::PopUp::onRegenerateDisplay() {
if (true == needRedraw()) { if (true == needRedraw()) {
m_shaper.clear(); m_shaper.clear();
ewol::Padding padding = m_shaper.getPadding(); ewol::Padding padding = m_shaper.getPadding();
@ -147,7 +147,7 @@ void ewol::Widget::PopUp::onRegenerateDisplay() {
} }
} }
ewol::object::Shared<ewol::Widget> ewol::Widget::PopUp::getWidgetAtPos(const vec2& _pos) { ewol::object::Shared<ewol::Widget> ewol::widget::PopUp::getWidgetAtPos(const vec2& _pos) {
ewol::object::Shared<ewol::Widget> val = ewol::widget::Container::getWidgetAtPos(_pos); ewol::object::Shared<ewol::Widget> val = ewol::widget::Container::getWidgetAtPos(_pos);
if (NULL != val) { if (NULL != val) {
return val; return val;
@ -155,7 +155,7 @@ ewol::object::Shared<ewol::Widget> ewol::Widget::PopUp::getWidgetAtPos(const vec
return this; return this;
} }
bool ewol::Widget::PopUp::onSetConfig(const ewol::object::Config& _conf) { bool ewol::widget::PopUp::onSetConfig(const ewol::object::Config& _conf) {
if (true == ewol::widget::Container::onSetConfig(_conf)) { if (true == ewol::widget::Container::onSetConfig(_conf)) {
return true; return true;
} }
@ -174,7 +174,7 @@ bool ewol::Widget::PopUp::onSetConfig(const ewol::object::Config& _conf) {
return false; return false;
} }
bool ewol::Widget::PopUp::onGetConfig(const char* _config, std::string& _result) const { bool ewol::widget::PopUp::onGetConfig(const char* _config, std::string& _result) const {
if (true == ewol::widget::Container::onGetConfig(_config, _result)) { if (true == ewol::widget::Container::onGetConfig(_config, _result)) {
return true; return true;
} }
@ -193,7 +193,7 @@ bool ewol::Widget::PopUp::onGetConfig(const char* _config, std::string& _result)
return false; return false;
} }
bool ewol::Widget::PopUp::onEventInput(const ewol::event::Input& _event) { bool ewol::widget::PopUp::onEventInput(const ewol::event::Input& _event) {
if (0 != _event.getId()) { if (0 != _event.getId()) {
if (true == m_closeOutEvent) { if (true == m_closeOutEvent) {
ewol::Padding padding = m_shaper.getPadding(); ewol::Padding padding = m_shaper.getPadding();
@ -220,7 +220,7 @@ bool ewol::Widget::PopUp::onEventInput(const ewol::event::Input& _event) {
} }
bool ewol::Widget::PopUp::onStartAnnimation(enum ewol::Widget::annimationMode _mode) { bool ewol::widget::PopUp::onStartAnnimation(enum ewol::Widget::annimationMode _mode) {
if (m_annimationType[_mode] != annimationIncrease) { if (m_annimationType[_mode] != annimationIncrease) {
return false; return false;
} }
@ -231,11 +231,11 @@ bool ewol::Widget::PopUp::onStartAnnimation(enum ewol::Widget::annimationMode _m
return false; return false;
} }
void ewol::Widget::PopUp::onStopAnnimation() { void ewol::widget::PopUp::onStopAnnimation() {
periodicCallDisable(); periodicCallDisable();
} }
void ewol::Widget::PopUp::periodicCall(const ewol::event::Time& _event) { void ewol::widget::PopUp::periodicCall(const ewol::event::Time& _event) {
if (false == m_shaper.periodicCall(_event) ) { if (false == m_shaper.periodicCall(_event) ) {
stopAnnimation(); stopAnnimation();
} }

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

@ -24,7 +24,7 @@ namespace ewol {
*/ */
class PopUp : public ewol::widget::Container { class PopUp : public ewol::widget::Container {
public: public:
static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager); static void init(ewol::widget::Manager& _widgetManager);
// Config list of properties // Config list of properties
static const char* const configShaper; static const char* const configShaper;
static const char* const configRemoveOnExternClick; static const char* const configRemoveOnExternClick;

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

@ -15,22 +15,22 @@
#define __class__ "ProgressBar" #define __class__ "ProgressBar"
static ewol::Widget* create() { static ewol::Widget* create() {
return new ewol::Widget::ProgressBar(); return new ewol::widget::ProgressBar();
} }
void ewol::Widget::ProgressBar::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) { void ewol::widget::ProgressBar::init(ewol::widget::Manager& _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&create); _widgetManager.addWidgetCreator(__class__,&create);
} }
const char* const ewol::Widget::ProgressBar::configColorBg = "color-bg"; const char* const ewol::widget::ProgressBar::configColorBg = "color-bg";
const char* const ewol::Widget::ProgressBar::configColorFgOn = "color-on"; const char* const ewol::widget::ProgressBar::configColorFgOn = "color-on";
const char* const ewol::Widget::ProgressBar::configColorFgOff = "color-off"; const char* const ewol::widget::ProgressBar::configColorFgOff = "color-off";
const char* const ewol::Widget::ProgressBar::configValue = "value"; const char* const ewol::widget::ProgressBar::configValue = "value";
const int32_t dotRadius = 6; const int32_t dotRadius = 6;
ewol::Widget::ProgressBar::ProgressBar() { ewol::widget::ProgressBar::ProgressBar() {
addObjectType("ewol::Widget::ProgressBar"); addObjectType("ewol::widget::ProgressBar");
m_value = 0.0; m_value = 0.0;
m_textColorFg = etk::color::black; m_textColorFg = etk::color::black;
@ -47,27 +47,27 @@ ewol::Widget::ProgressBar::ProgressBar() {
} }
ewol::Widget::ProgressBar::~ProgressBar() { ewol::widget::ProgressBar::~ProgressBar() {
} }
void ewol::Widget::ProgressBar::calculateMinMaxSize() { void ewol::widget::ProgressBar::calculateMinMaxSize() {
vec2 tmpMin = m_userMinSize.getPixel(); vec2 tmpMin = m_userMinSize.getPixel();
m_minSize.setValue( etk_max(tmpMin.x(), 40), m_minSize.setValue( etk_max(tmpMin.x(), 40),
etk_max(tmpMin.y(), dotRadius*2) ); etk_max(tmpMin.y(), dotRadius*2) );
markToRedraw(); markToRedraw();
} }
void ewol::Widget::ProgressBar::setValue(float _val) { void ewol::widget::ProgressBar::setValue(float _val) {
m_value = etk_avg(0, _val, 1); m_value = etk_avg(0, _val, 1);
markToRedraw(); markToRedraw();
} }
void ewol::Widget::ProgressBar::onDraw() { void ewol::widget::ProgressBar::onDraw() {
m_draw.draw(); m_draw.draw();
} }
void ewol::Widget::ProgressBar::onRegenerateDisplay() { void ewol::widget::ProgressBar::onRegenerateDisplay() {
if (true == needRedraw()) { if (true == needRedraw()) {
// clean the object list ... // clean the object list ...
m_draw.clear(); m_draw.clear();
@ -93,7 +93,7 @@ void ewol::Widget::ProgressBar::onRegenerateDisplay() {
bool ewol::Widget::ProgressBar::onSetConfig(const ewol::object::Config& _conf) { bool ewol::widget::ProgressBar::onSetConfig(const ewol::object::Config& _conf) {
if (true == ewol::Widget::onSetConfig(_conf)) { if (true == ewol::Widget::onSetConfig(_conf)) {
return true; return true;
} }
@ -120,7 +120,7 @@ bool ewol::Widget::ProgressBar::onSetConfig(const ewol::object::Config& _conf) {
return false; return false;
} }
bool ewol::Widget::ProgressBar::onGetConfig(const char* _config, std::string& _result) const { bool ewol::widget::ProgressBar::onGetConfig(const char* _config, std::string& _result) const {
if (true == ewol::Widget::onGetConfig(_config, _result)) { if (true == ewol::Widget::onGetConfig(_config, _result)) {
return true; return true;
} }

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

@ -21,9 +21,9 @@ namespace ewol {
/** /**
* @ingroup ewolWidgetGroup * @ingroup ewolWidgetGroup
*/ */
class ProgressBar : public ewol::object::Shared<ewol::Widget> { class ProgressBar : public ewol::Widget {
public: public:
static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager); static void init(ewol::widget::Manager& _widgetManager);
// Config list of properties // Config list of properties
static const char* const configColorBg; static const char* const configColorBg;
static const char* const configColorFgOn; static const char* const configColorFgOn;

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

@ -15,16 +15,16 @@
#define __class__ "Scroll" #define __class__ "Scroll"
static ewol::Widget* create() { static ewol::Widget* create() {
return new ewol::Widget::Scroll(); return new ewol::widget::Scroll();
} }
void ewol::Widget::Scroll::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) { void ewol::widget::Scroll::init(ewol::widget::Manager& _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&create); _widgetManager.addWidgetCreator(__class__,&create);
} }
const char* const ewol::Widget::Scroll::configLimit = "limit"; const char* const ewol::widget::Scroll::configLimit = "limit";
ewol::Widget::Scroll::Scroll(const std::string& _shaperName) : ewol::widget::Scroll::Scroll(const std::string& _shaperName) :
m_shaperH(_shaperName), m_shaperH(_shaperName),
m_shaperV(_shaperName), m_shaperV(_shaperName),
m_limit(0.15,0.5), m_limit(0.15,0.5),
@ -33,22 +33,22 @@ ewol::Widget::Scroll::Scroll(const std::string& _shaperName) :
m_highSpeedMode(speedModeDisable), m_highSpeedMode(speedModeDisable),
m_highSpeedButton(-1), m_highSpeedButton(-1),
m_highSpeedType(ewol::key::typeUnknow) { m_highSpeedType(ewol::key::typeUnknow) {
addObjectType("ewol::Widget::Scroll"); addObjectType("ewol::widget::Scroll");
registerConfig(configLimit, "vec2", NULL, "Limit the scroll maximum position [0..1]% represent the free space in the scoll when arrive at the end"); registerConfig(configLimit, "vec2", NULL, "Limit the scroll maximum position [0..1]% represent the free space in the scoll when arrive at the end");
} }
ewol::Widget::Scroll::~Scroll() { ewol::widget::Scroll::~Scroll() {
} }
void ewol::Widget::Scroll::setLimit(const vec2& _limit) { void ewol::widget::Scroll::setLimit(const vec2& _limit) {
m_limit = _limit; m_limit = _limit;
markToRedraw(); markToRedraw();
} }
#define SCROLL_BAR_SPACE (15) #define SCROLL_BAR_SPACE (15)
void ewol::Widget::Scroll::calculateMinMaxSize() { void ewol::widget::Scroll::calculateMinMaxSize() {
// call main class !! and not containter class ... // call main class !! and not containter class ...
ewol::Widget::calculateMinMaxSize(); ewol::Widget::calculateMinMaxSize();
// call sub classes // call sub classes
@ -57,7 +57,7 @@ void ewol::Widget::Scroll::calculateMinMaxSize() {
} }
} }
void ewol::Widget::Scroll::systemDraw(const ewol::DrawProperty& _displayProp) { void ewol::widget::Scroll::systemDraw(const ewol::DrawProperty& _displayProp) {
if (m_hide == true) { if (m_hide == true) {
return; return;
} }
@ -69,12 +69,12 @@ void ewol::Widget::Scroll::systemDraw(const ewol::DrawProperty& _displayProp) {
ewol::Widget::systemDraw(_displayProp); ewol::Widget::systemDraw(_displayProp);
} }
void ewol::Widget::Scroll::onDraw() { void ewol::widget::Scroll::onDraw() {
m_shaperH.draw(); m_shaperH.draw();
m_shaperV.draw(); m_shaperV.draw();
} }
void ewol::Widget::Scroll::onRegenerateDisplay() { void ewol::widget::Scroll::onRegenerateDisplay() {
// call upper class // call upper class
ewol::widget::Container::onRegenerateDisplay(); ewol::widget::Container::onRegenerateDisplay();
if (needRedraw() == false) { if (needRedraw() == false) {
@ -117,7 +117,7 @@ void ewol::Widget::Scroll::onRegenerateDisplay() {
} }
} }
bool ewol::Widget::Scroll::onEventInput(const ewol::event::Input& _event) { bool ewol::widget::Scroll::onEventInput(const ewol::event::Input& _event) {
//ewol::event::Input _event = event; //ewol::event::Input _event = event;
//_event.setType(ewol::key::typeFinger); //_event.setType(ewol::key::typeFinger);
vec2 relativePos = relativePosition(_event.getPos()); vec2 relativePos = relativePosition(_event.getPos());
@ -349,7 +349,7 @@ bool ewol::Widget::Scroll::onEventInput(const ewol::event::Input& _event) {
return false; return false;
} }
ewol::object::Shared<ewol::Widget> ewol::Widget::Scroll::getWidgetAtPos(const vec2& _pos) { ewol::object::Shared<ewol::Widget> ewol::widget::Scroll::getWidgetAtPos(const vec2& _pos) {
ewol::object::Shared<ewol::Widget> tmpWidget = ewol::widget::Container::getWidgetAtPos(_pos); ewol::object::Shared<ewol::Widget> tmpWidget = ewol::widget::Container::getWidgetAtPos(_pos);
if (NULL != tmpWidget) { if (NULL != tmpWidget) {
return tmpWidget; return tmpWidget;
@ -357,7 +357,7 @@ ewol::object::Shared<ewol::Widget> ewol::Widget::Scroll::getWidgetAtPos(const ve
return this; return this;
} }
bool ewol::Widget::Scroll::onSetConfig(const ewol::object::Config& _conf) { bool ewol::widget::Scroll::onSetConfig(const ewol::object::Config& _conf) {
if (true == ewol::widget::Container::onSetConfig(_conf)) { if (true == ewol::widget::Container::onSetConfig(_conf)) {
return true; return true;
} }
@ -368,7 +368,7 @@ bool ewol::Widget::Scroll::onSetConfig(const ewol::object::Config& _conf) {
return false; return false;
} }
bool ewol::Widget::Scroll::onGetConfig(const char* _config, std::string& _result) const { bool ewol::widget::Scroll::onGetConfig(const char* _config, std::string& _result) const {
if (true == ewol::widget::Container::onGetConfig(_config, _result)) { if (true == ewol::widget::Container::onGetConfig(_config, _result)) {
return true; return true;
} }

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

@ -35,7 +35,7 @@ namespace ewol {
// Cinfig parameter list: // Cinfig parameter list:
static const char* const configLimit; static const char* const configLimit;
public: public:
static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager); static void init(ewol::widget::Manager& _widgetManager);
private: private:
ewol::compositing::Shaper m_shaperH; //!< Compositing theme Horizontal. ewol::compositing::Shaper m_shaperH; //!< Compositing theme Horizontal.
ewol::compositing::Shaper m_shaperV; //!< Compositing theme Vertical. ewol::compositing::Shaper m_shaperV; //!< Compositing theme Vertical.

4
sources/ewol/widget/Sizer.cpp
View File

@ -16,11 +16,11 @@ const char* const ewol::widget::Sizer::configMode = "mode";
#undef __class__ #undef __class__
#define __class__ "Sizer" #define __class__ "Sizer"
static ewol::object::Shared<ewol::Widget> create() { static ewol::Widget* create() {
return new ewol::widget::Sizer(); return new ewol::widget::Sizer();
} }
void ewol::widget::Sizer::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) { void ewol::widget::Sizer::init(ewol::widget::Manager& _widgetManager) {
_widgetManager.addWidgetCreator(__class__,&create); _widgetManager.addWidgetCreator(__class__,&create);
} }

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

@ -24,7 +24,7 @@ namespace ewol {
/** /**
* @brief Main call of recording the widget on the List of "widget named creator" * @brief Main call of recording the widget on the List of "widget named creator"
*/ */
static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager); static void init(ewol::widget::Manager& _widgetManager);
// Config list of properties // Config list of properties
static const char* const configBorder; static const char* const configBorder;
static const char* const configMode; static const char* const configMode;
@ -119,10 +119,10 @@ namespace ewol {
virtual void calculateSize(const vec2& _availlable); virtual void calculateSize(const vec2& _availlable);
virtual void calculateMinMaxSize(); virtual void calculateMinMaxSize();
// overwrite the set fuction to start annimations ... // overwrite the set fuction to start annimations ...
virtual int32_t subWidgetAdd(ewol::object::Shared<ewol::Widget> _newWidget); virtual int32_t subWidgetAdd(ewol::Widget* _newWidget);
virtual int32_t subWidgetAddStart(ewol::object::Shared<ewol::Widget> _newWidget); virtual int32_t subWidgetAddStart(ewol::Widget* _newWidget);
virtual void subWidgetRemove(ewol::object::Shared<ewol::Widget> _newWidget); virtual void subWidgetRemove(ewol::Widget* _newWidget);
virtual void subWidgetUnLink(ewol::object::Shared<ewol::Widget> _newWidget); virtual void subWidgetUnLink(ewol::Widget* _newWidget);
virtual bool onSetConfig(const ewol::object::Config& _conf); virtual bool onSetConfig(const ewol::object::Config& _conf);
virtual bool onGetConfig(const char* _config, std::string& _result) const; virtual bool onGetConfig(const char* _config, std::string& _result) const;
}; };

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

@ -19,8 +19,8 @@ static ewol::Widget* create() {
return new ewol::widget::Slider(); return new ewol::widget::Slider();
} }
void ewol::widget::Slider::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) { void ewol::widget::Slider::init(ewol::widget::Manager& _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&create); _widgetManager.addWidgetCreator(__class__,&create);
} }
const int32_t dotRadius = 6; const int32_t dotRadius = 6;

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

@ -25,7 +25,7 @@ namespace ewol {
// Event list of properties // Event list of properties
static const char * const eventChange; static const char * const eventChange;
public: public:
static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager); static void init(ewol::widget::Manager& _widgetManager);
public: public:
Slider(); Slider();
virtual ~Slider(); virtual ~Slider();

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

@ -14,18 +14,18 @@
#undef __class__ #undef __class__
#define __class__ "Spacer" #define __class__ "Spacer"
const char* const ewol::Widget::Spacer::configColor = "color"; const char* const ewol::widget::Spacer::configColor = "color";
static ewol::Widget* create() { static ewol::Widget* create() {
return new ewol::Widget::Spacer(); return new ewol::widget::Spacer();
} }
void ewol::Widget::Spacer::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) { void ewol::widget::Spacer::init(ewol::widget::Manager& _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&create); _widgetManager.addWidgetCreator(__class__,&create);
} }
ewol::Widget::Spacer::Spacer() { ewol::widget::Spacer::Spacer() {
addObjectType("ewol::Widget::Spacer"); addObjectType("ewol::widget::Spacer");
m_userMinSize = ewol::Dimension(vec2(10,10)); m_userMinSize = ewol::Dimension(vec2(10,10));
setCanHaveFocus(false); setCanHaveFocus(false);
m_color = etk::color::black; m_color = etk::color::black;
@ -33,16 +33,16 @@ ewol::Widget::Spacer::Spacer() {
registerConfig(configColor, "color", NULL, "background of the spacer"); registerConfig(configColor, "color", NULL, "background of the spacer");
} }
ewol::Widget::Spacer::~Spacer() { ewol::widget::Spacer::~Spacer() {
} }
void ewol::Widget::Spacer::onDraw() { void ewol::widget::Spacer::onDraw() {
m_draw.draw(); m_draw.draw();
} }
#define BORDER_SIZE_TMP (4) #define BORDER_SIZE_TMP (4)
void ewol::Widget::Spacer::onRegenerateDisplay() { void ewol::widget::Spacer::onRegenerateDisplay() {
if (false == needRedraw()) { if (false == needRedraw()) {
return; return;
} }
@ -56,7 +56,7 @@ void ewol::Widget::Spacer::onRegenerateDisplay() {
m_draw.rectangleWidth(vec3(m_size.x(), m_size.y(),0) ); m_draw.rectangleWidth(vec3(m_size.x(), m_size.y(),0) );
} }
bool ewol::Widget::Spacer::onSetConfig(const ewol::object::Config& _conf) { bool ewol::widget::Spacer::onSetConfig(const ewol::object::Config& _conf) {
if (true == ewol::Widget::onSetConfig(_conf)) { if (true == ewol::Widget::onSetConfig(_conf)) {
return true; return true;
} }
@ -68,7 +68,7 @@ bool ewol::Widget::Spacer::onSetConfig(const ewol::object::Config& _conf) {
return false; return false;
} }
bool ewol::Widget::Spacer::onGetConfig(const char* _config, std::string& _result) const { bool ewol::widget::Spacer::onGetConfig(const char* _config, std::string& _result) const {
if (true == ewol::Widget::onGetConfig(_config, _result)) { if (true == ewol::Widget::onGetConfig(_config, _result)) {
return true; return true;
} }

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

@ -23,7 +23,7 @@ namespace ewol {
*/ */
class Spacer : public ewol::Widget { class Spacer : public ewol::Widget {
public: public:
static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager); static void init(ewol::widget::Manager& _widgetManager);
// Config list of properties // Config list of properties
static const char* const configColor; static const char* const configColor;
private: private:

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

@ -10,12 +10,12 @@
#include <ewol/ewol.h> #include <ewol/ewol.h>
static const char* l_listsladingMode[ewol::Widget::WSlider::sladingTransition_count] = { static const char* l_listsladingMode[ewol::widget::WSlider::sladingTransition_count] = {
"transition vertical", "transition vertical",
"transition horisantal" "transition horisantal"
}; };
std::ostream& operator <<(std::ostream& _os, const enum ewol::Widget::WSlider::sladingMode _obj) { std::ostream& operator <<(std::ostream& _os, const enum ewol::widget::WSlider::sladingMode _obj) {
_os << l_listsladingMode[_obj]; _os << l_listsladingMode[_obj];
return _os; return _os;
} }
@ -24,28 +24,28 @@ std::ostream& operator <<(std::ostream& _os, const enum ewol::Widget::WSlider::s
#define __class__ "WSlider" #define __class__ "WSlider"
// Event list of properties // Event list of properties
const char* const ewol::Widget::WSlider::eventStartSlide = "ewol-widget-wslider-event-start-slide"; 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"; const char* const ewol::widget::WSlider::eventStopSlide = "ewol-widget-wslider-event-stop-slide";
// Config list of properties // Config list of properties
const char* const ewol::Widget::WSlider::configMode = "mode"; const char* const ewol::widget::WSlider::configMode = "mode";
const char* const ewol::Widget::WSlider::configSpeed = "speed"; const char* const ewol::widget::WSlider::configSpeed = "speed";
static ewol::Widget* create() { static ewol::Widget* create() {
return new ewol::Widget::WSlider(); return new ewol::widget::WSlider();
} }
void ewol::Widget::WSlider::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) { void ewol::widget::WSlider::init(ewol::widget::Manager& _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&create); _widgetManager.addWidgetCreator(__class__,&create);
} }
ewol::Widget::WSlider::WSlider() : ewol::widget::WSlider::WSlider() :
m_windowsSources(0), m_windowsSources(0),
m_windowsDestination(0), m_windowsDestination(0),
m_windowsRequested(-1), m_windowsRequested(-1),
m_slidingProgress(1.0f), m_slidingProgress(1.0f),
m_transitionSpeed(1.0f), m_transitionSpeed(1.0f),
m_transitionSlide(sladingTransitionHori) { m_transitionSlide(sladingTransitionHori) {
addObjectType("ewol::Widget::WSlider"); addObjectType("ewol::widget::WSlider");
addEventId(eventStartSlide); addEventId(eventStartSlide);
addEventId(eventStopSlide); addEventId(eventStopSlide);
// add configuration // add configuration
@ -53,12 +53,12 @@ ewol::Widget::WSlider::WSlider() :
registerConfig(configSpeed, "float", NULL, "Transition speed of the slider"); registerConfig(configSpeed, "float", NULL, "Transition speed of the slider");
} }
ewol::Widget::WSlider::~WSlider() { ewol::widget::WSlider::~WSlider() {
} }
void ewol::Widget::WSlider::calculateSize(const vec2& _availlable) { void ewol::widget::WSlider::calculateSize(const vec2& _availlable) {
//EWOL_DEBUG("Update size"); //EWOL_DEBUG("Update size");
ewol::widget::ContainerN::calculateSize(_availlable); ewol::widget::ContainerN::calculateSize(_availlable);
@ -109,7 +109,7 @@ void ewol::Widget::WSlider::calculateSize(const vec2& _availlable) {
markToRedraw(); markToRedraw();
} }
void ewol::Widget::WSlider::subWidgetSelectSetVectorId(int32_t _id) { void ewol::widget::WSlider::subWidgetSelectSetVectorId(int32_t _id) {
if (_id<0) { if (_id<0) {
EWOL_ERROR("Can not change to a widget not present : vectID=" << _id); EWOL_ERROR("Can not change to a widget not present : vectID=" << _id);
return; return;
@ -122,7 +122,7 @@ void ewol::Widget::WSlider::subWidgetSelectSetVectorId(int32_t _id) {
} }
} }
void ewol::Widget::WSlider::subWidgetSelectSet(int32_t _id) { void ewol::widget::WSlider::subWidgetSelectSet(int32_t _id) {
int32_t elementID = -1; int32_t elementID = -1;
// search element in the list : // search element in the list :
for (size_t iii=0 ; iii<m_subWidget.size() ; iii++) { for (size_t iii=0 ; iii<m_subWidget.size() ; iii++) {
@ -136,7 +136,7 @@ void ewol::Widget::WSlider::subWidgetSelectSet(int32_t _id) {
subWidgetSelectSetVectorId(elementID); subWidgetSelectSetVectorId(elementID);
} }
void ewol::Widget::WSlider::subWidgetSelectSet(ewol::Widget* _widgetPointer) { void ewol::widget::WSlider::subWidgetSelectSet(ewol::object::Shared<ewol::Widget> _widgetPointer) {
if (_widgetPointer == NULL) { if (_widgetPointer == NULL) {
EWOL_ERROR("Can not change to a widget NULL"); EWOL_ERROR("Can not change to a widget NULL");
return; return;
@ -152,7 +152,7 @@ void ewol::Widget::WSlider::subWidgetSelectSet(ewol::Widget* _widgetPointer) {
EWOL_ERROR("Can not change to a widget not present"); EWOL_ERROR("Can not change to a widget not present");
} }
void ewol::Widget::WSlider::subWidgetSelectSet(const std::string& _widgetName) { void ewol::widget::WSlider::subWidgetSelectSet(const std::string& _widgetName) {
if (_widgetName == "") { if (_widgetName == "") {
EWOL_ERROR("Can not change to a widget with no name (input)"); EWOL_ERROR("Can not change to a widget with no name (input)");
return; return;
@ -168,14 +168,14 @@ void ewol::Widget::WSlider::subWidgetSelectSet(const std::string& _widgetName) {
EWOL_ERROR("Can not change to a widget not present"); EWOL_ERROR("Can not change to a widget not present");
} }
void ewol::Widget::WSlider::setTransitionMode(enum sladingMode _mode) { void ewol::widget::WSlider::setTransitionMode(enum sladingMode _mode) {
if (m_transitionSlide != _mode) { if (m_transitionSlide != _mode) {
m_transitionSlide = _mode; m_transitionSlide = _mode;
markToRedraw(); markToRedraw();
} }
} }
void ewol::Widget::WSlider::periodicCall(const ewol::event::Time& _event) { void ewol::widget::WSlider::periodicCall(const ewol::event::Time& _event) {
if (m_slidingProgress >= 1.0) { if (m_slidingProgress >= 1.0) {
m_windowsSources = m_windowsDestination; m_windowsSources = m_windowsDestination;
if( m_windowsRequested != -1 if( m_windowsRequested != -1
@ -208,7 +208,7 @@ void ewol::Widget::WSlider::periodicCall(const ewol::event::Time& _event) {
markToRedraw(); markToRedraw();
} }
void ewol::Widget::WSlider::systemDraw(const ewol::DrawProperty& _displayProp) { void ewol::widget::WSlider::systemDraw(const ewol::DrawProperty& _displayProp) {
if (true == m_hide){ if (true == m_hide){
// widget is hidden ... // widget is hidden ...
return; return;
@ -247,7 +247,7 @@ void ewol::Widget::WSlider::systemDraw(const ewol::DrawProperty& _displayProp) {
} }
} }
void ewol::Widget::WSlider::onRegenerateDisplay() { void ewol::widget::WSlider::onRegenerateDisplay() {
if (m_windowsDestination == m_windowsSources) { if (m_windowsDestination == m_windowsSources) {
int32_t iii = m_windowsDestination; int32_t iii = m_windowsDestination;
if (iii >= 0 || (size_t)iii < m_subWidget.size()) { if (iii >= 0 || (size_t)iii < m_subWidget.size()) {
@ -271,7 +271,7 @@ void ewol::Widget::WSlider::onRegenerateDisplay() {
} }
} }
bool ewol::Widget::WSlider::onSetConfig(const ewol::object::Config& _conf) { bool ewol::widget::WSlider::onSetConfig(const ewol::object::Config& _conf) {
if (true == ewol::widget::ContainerN::onSetConfig(_conf)) { if (true == ewol::widget::ContainerN::onSetConfig(_conf)) {
return true; return true;
} }
@ -292,7 +292,7 @@ bool ewol::Widget::WSlider::onSetConfig(const ewol::object::Config& _conf) {
return false; return false;
} }
bool ewol::Widget::WSlider::onGetConfig(const char* _config, std::string& _result) const { bool ewol::widget::WSlider::onGetConfig(const char* _config, std::string& _result) const {
if (true == ewol::widget::ContainerN::onGetConfig(_config, _result)) { if (true == ewol::widget::ContainerN::onGetConfig(_config, _result)) {
return true; return true;
} }
@ -315,7 +315,7 @@ bool ewol::Widget::WSlider::onGetConfig(const char* _config, std::string& _resul
return false; return false;
} }
ewol::object::Shared<ewol::Widget> ewol::Widget::WSlider::getWidgetAtPos(const vec2& _pos) { ewol::object::Shared<ewol::Widget> ewol::widget::WSlider::getWidgetAtPos(const vec2& _pos) {
if (true == isHide()) { if (true == isHide()) {
return NULL; return NULL;
} }
@ -326,7 +326,7 @@ ewol::object::Shared<ewol::Widget> ewol::Widget::WSlider::getWidgetAtPos(const v
if( (tmpOrigin.x() <= _pos.x() && tmpOrigin.x() + tmpSize.x() >= _pos.x()) if( (tmpOrigin.x() <= _pos.x() && tmpOrigin.x() + tmpSize.x() >= _pos.x())
&& (tmpOrigin.y() <= _pos.y() && tmpOrigin.y() + tmpSize.y() >= _pos.y()) ) && (tmpOrigin.y() <= _pos.y() && tmpOrigin.y() + tmpSize.y() >= _pos.y()) )
{ {
ewol::object::Shared<ewol::Widget> * tmpWidget = m_subWidget[m_windowsDestination]->getWidgetAtPos(_pos); ewol::object::Shared<ewol::Widget> tmpWidget = m_subWidget[m_windowsDestination]->getWidgetAtPos(_pos);
if (NULL != tmpWidget) { if (NULL != tmpWidget) {
return tmpWidget; return tmpWidget;
} }
@ -340,7 +340,7 @@ ewol::object::Shared<ewol::Widget> ewol::Widget::WSlider::getWidgetAtPos(const v
if( (tmpOrigin.x() <= _pos.x() && tmpOrigin.x() + tmpSize.x() >= _pos.x()) if( (tmpOrigin.x() <= _pos.x() && tmpOrigin.x() + tmpSize.x() >= _pos.x())
&& (tmpOrigin.y() <= _pos.y() && tmpOrigin.y() + tmpSize.y() >= _pos.y()) ) && (tmpOrigin.y() <= _pos.y() && tmpOrigin.y() + tmpSize.y() >= _pos.y()) )
{ {
ewol::object::Shared<ewol::Widget> * tmpWidget = m_subWidget[m_windowsDestination]->getWidgetAtPos(_pos); ewol::object::Shared<ewol::Widget> tmpWidget = m_subWidget[m_windowsDestination]->getWidgetAtPos(_pos);
if (NULL != tmpWidget) { if (NULL != tmpWidget) {
return tmpWidget; return tmpWidget;
} }
@ -353,7 +353,7 @@ ewol::object::Shared<ewol::Widget> ewol::Widget::WSlider::getWidgetAtPos(const v
if( (tmpOrigin.x() <= _pos.x() && tmpOrigin.x() + tmpSize.x() >= _pos.x()) if( (tmpOrigin.x() <= _pos.x() && tmpOrigin.x() + tmpSize.x() >= _pos.x())
&& (tmpOrigin.y() <= _pos.y() && tmpOrigin.y() + tmpSize.y() >= _pos.y()) ) && (tmpOrigin.y() <= _pos.y() && tmpOrigin.y() + tmpSize.y() >= _pos.y()) )
{ {
ewol::object::Shared<ewol::Widget> * tmpWidget = m_subWidget[m_windowsSources]->getWidgetAtPos(_pos); ewol::object::Shared<ewol::Widget> tmpWidget = m_subWidget[m_windowsSources]->getWidgetAtPos(_pos);
if (NULL != tmpWidget) { if (NULL != tmpWidget) {
return tmpWidget; return tmpWidget;
} }

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

@ -21,7 +21,7 @@ namespace ewol {
*/ */
class WSlider :public ewol::widget::ContainerN { class WSlider :public ewol::widget::ContainerN {
public: public:
static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager); static void init(ewol::widget::Manager& _widgetManager);
// Event list of properties // Event list of properties
static const char* const eventStartSlide; static const char* const eventStartSlide;
static const char* const eventStopSlide; static const char* const eventStopSlide;
@ -106,7 +106,7 @@ namespace ewol {
virtual bool onGetConfig(const char* _config, std::string& _result) const; virtual bool onGetConfig(const char* _config, std::string& _result) const;
}; };
}; };
std::ostream& operator <<(std::ostream& _os, const enum ewol::Widget::WSlider::sladingMode _obj); std::ostream& operator <<(std::ostream& _os, const enum ewol::widget::WSlider::sladingMode _obj);
}; };
#endif #endif

70
sources/ewol/widget/WidgetScrolled.cpp
View File

@ -15,14 +15,14 @@
ewol::Widget::WidgetScrolled::WidgetScrolled(const std::string& _shaperName) : ewol::widget::WidgetScrolled::WidgetScrolled(const std::string& _shaperName) :
m_shaperH(_shaperName), m_shaperH(_shaperName),
m_shaperV(_shaperName), m_shaperV(_shaperName),
m_singleFingerMode(true) { m_singleFingerMode(true) {
addObjectType("ewol::Widget::WidgetScrolled"); addObjectType("ewol::widget::WidgetScrolled");
m_originScrooled.setValue(0,0); m_originScrooled.setValue(0,0);
m_pixelScrolling = 20; m_pixelScrolling = 20;
m_highSpeedMode = ewol::Widget::Scroll::speedModeDisable; m_highSpeedMode = ewol::widget::Scroll::speedModeDisable;
m_scroollingMode = scroolModeNormal; m_scroollingMode = scroolModeNormal;
m_highSpeedType = ewol::key::typeUnknow; m_highSpeedType = ewol::key::typeUnknow;
m_highSpeedButton = -1; m_highSpeedButton = -1;
@ -34,11 +34,11 @@ ewol::Widget::WidgetScrolled::WidgetScrolled(const std::string& _shaperName) :
} }
} }
ewol::Widget::WidgetScrolled::~WidgetScrolled() { ewol::widget::WidgetScrolled::~WidgetScrolled() {
} }
void ewol::Widget::WidgetScrolled::onRegenerateDisplay() { void ewol::widget::WidgetScrolled::onRegenerateDisplay() {
m_shaperH.clear(); m_shaperH.clear();
m_shaperV.clear(); m_shaperV.clear();
if (m_scroollingMode == scroolModeGame) { if (m_scroollingMode == scroolModeGame) {
@ -73,7 +73,7 @@ void ewol::Widget::WidgetScrolled::onRegenerateDisplay() {
} }
} }
bool ewol::Widget::WidgetScrolled::onEventInput(const ewol::event::Input& _event) { bool ewol::widget::WidgetScrolled::onEventInput(const ewol::event::Input& _event) {
EWOL_VERBOSE("event XXX " << _event); EWOL_VERBOSE("event XXX " << _event);
vec2 relativePos = relativePosition(_event.getPos()); vec2 relativePos = relativePosition(_event.getPos());
// corection due to the open Gl invertion ... // corection due to the open Gl invertion ...
@ -90,7 +90,7 @@ bool ewol::Widget::WidgetScrolled::onEventInput(const ewol::event::Input& _event
if (relativePos.x() >= (m_size.x()-paddingV.x())) { if (relativePos.x() >= (m_size.x()-paddingV.x())) {
if( m_size.y() < m_maxSize.y() if( m_size.y() < m_maxSize.y()
|| m_originScrooled.y() != 0) { || m_originScrooled.y() != 0) {
m_highSpeedMode = ewol::Widget::Scroll::speedModeEnableVertical; m_highSpeedMode = ewol::widget::Scroll::speedModeEnableVertical;
m_highSpeedType = ewol::key::typeMouse; m_highSpeedType = ewol::key::typeMouse;
m_highSpeedStartPos.setX(relativePos.x()); m_highSpeedStartPos.setX(relativePos.x());
m_highSpeedStartPos.setY(m_originScrooled.y() / m_maxSize.y() * (m_size.y()-paddingV.yButtom()*2)); m_highSpeedStartPos.setY(m_originScrooled.y() / m_maxSize.y() * (m_size.y()-paddingV.yButtom()*2));
@ -104,7 +104,7 @@ bool ewol::Widget::WidgetScrolled::onEventInput(const ewol::event::Input& _event
} else if (relativePos.y() >= (m_size.y()-paddingH.y())) { } else if (relativePos.y() >= (m_size.y()-paddingH.y())) {
if( m_size.x() < m_maxSize.x() if( m_size.x() < m_maxSize.x()
|| m_originScrooled.x()!=0) { || m_originScrooled.x()!=0) {
m_highSpeedMode = ewol::Widget::Scroll::speedModeEnableHorizontal; m_highSpeedMode = ewol::widget::Scroll::speedModeEnableHorizontal;
m_highSpeedType = ewol::key::typeMouse; m_highSpeedType = ewol::key::typeMouse;
m_highSpeedStartPos.setX(m_originScrooled.x() / m_maxSize.x() * (m_size.x()-paddingH.xLeft()*2)); m_highSpeedStartPos.setX(m_originScrooled.x() / m_maxSize.x() * (m_size.x()-paddingH.xLeft()*2));
m_highSpeedStartPos.setY(relativePos.y()); m_highSpeedStartPos.setY(relativePos.y());
@ -186,29 +186,29 @@ bool ewol::Widget::WidgetScrolled::onEventInput(const ewol::event::Input& _event
} }
} else */{ } else */{
if (_event.getStatus() == ewol::key::statusDown) { if (_event.getStatus() == ewol::key::statusDown) {
m_highSpeedMode = ewol::Widget::Scroll::speedModeInit; m_highSpeedMode = ewol::widget::Scroll::speedModeInit;
m_highSpeedType = ewol::key::typeMouse; m_highSpeedType = ewol::key::typeMouse;
m_highSpeedStartPos.setValue(relativePos.x(), relativePos.y()); m_highSpeedStartPos.setValue(relativePos.x(), relativePos.y());
m_highSpeedButton = 2; m_highSpeedButton = 2;
return true; return true;
} }
} }
} else if ( m_highSpeedMode != ewol::Widget::Scroll::speedModeDisable } else if ( m_highSpeedMode != ewol::widget::Scroll::speedModeDisable
&& _event.getStatus() == ewol::key::statusLeave) { && _event.getStatus() == ewol::key::statusLeave) {
m_highSpeedMode = ewol::Widget::Scroll::speedModeDisable; m_highSpeedMode = ewol::widget::Scroll::speedModeDisable;
m_highSpeedType = ewol::key::typeUnknow; m_highSpeedType = ewol::key::typeUnknow;
markToRedraw(); markToRedraw();
return true; return true;
} }
if ( _event.getId() == m_highSpeedButton if ( _event.getId() == m_highSpeedButton
&& m_highSpeedMode != ewol::Widget::Scroll::speedModeDisable) { && m_highSpeedMode != ewol::widget::Scroll::speedModeDisable) {
if (_event.getStatus() == ewol::key::statusUpAfter) { if (_event.getStatus() == ewol::key::statusUpAfter) {
m_highSpeedMode = ewol::Widget::Scroll::speedModeDisable; m_highSpeedMode = ewol::widget::Scroll::speedModeDisable;
m_highSpeedType = ewol::key::typeUnknow; m_highSpeedType = ewol::key::typeUnknow;
return false; return false;
} else if (m_highSpeedMode == ewol::Widget::Scroll::speedModeGrepEndEvent) { } else if (m_highSpeedMode == ewol::widget::Scroll::speedModeGrepEndEvent) {
if (_event.getStatus() == ewol::key::statusSingle) { if (_event.getStatus() == ewol::key::statusSingle) {
m_highSpeedMode = ewol::Widget::Scroll::speedModeDisable; m_highSpeedMode = ewol::widget::Scroll::speedModeDisable;
m_highSpeedType = ewol::key::typeUnknow; m_highSpeedType = ewol::key::typeUnknow;
m_highSpeedButton = -1; m_highSpeedButton = -1;
markToRedraw(); markToRedraw();
@ -216,7 +216,7 @@ bool ewol::Widget::WidgetScrolled::onEventInput(const ewol::event::Input& _event
return true; return true;
} else if (_event.getStatus() == ewol::key::statusUp) { } else if (_event.getStatus() == ewol::key::statusUp) {
return true; return true;
} else if ( m_highSpeedMode == ewol::Widget::Scroll::speedModeInit } else if ( m_highSpeedMode == ewol::widget::Scroll::speedModeInit
&& _event.getStatus() == ewol::key::statusMove) { && _event.getStatus() == ewol::key::statusMove) {
// wait that the cursor move more than 10 px to enable it : // wait that the cursor move more than 10 px to enable it :
if( abs(relativePos.x() - m_highSpeedStartPos.x()) > 10 if( abs(relativePos.x() - m_highSpeedStartPos.x()) > 10
@ -224,18 +224,18 @@ bool ewol::Widget::WidgetScrolled::onEventInput(const ewol::event::Input& _event
// the scrooling can start : // the scrooling can start :
// select the direction : // select the direction :
if (relativePos.x() == m_highSpeedStartPos.x()) { if (relativePos.x() == m_highSpeedStartPos.x()) {
m_highSpeedMode = ewol::Widget::Scroll::speedModeEnableVertical; m_highSpeedMode = ewol::widget::Scroll::speedModeEnableVertical;
} else if (relativePos.y() == m_highSpeedStartPos.y()) { } else if (relativePos.y() == m_highSpeedStartPos.y()) {
m_highSpeedMode = ewol::Widget::Scroll::speedModeEnableHorizontal; m_highSpeedMode = ewol::widget::Scroll::speedModeEnableHorizontal;
} else { } else {
float coef = (relativePos.y() - m_highSpeedStartPos.y()) / (relativePos.x() - m_highSpeedStartPos.x()); float coef = (relativePos.y() - m_highSpeedStartPos.y()) / (relativePos.x() - m_highSpeedStartPos.x());
if (abs(coef) <= 1 ) { if (abs(coef) <= 1 ) {
m_highSpeedMode = ewol::Widget::Scroll::speedModeEnableHorizontal; m_highSpeedMode = ewol::widget::Scroll::speedModeEnableHorizontal;
} else { } else {
m_highSpeedMode = ewol::Widget::Scroll::speedModeEnableVertical; m_highSpeedMode = ewol::widget::Scroll::speedModeEnableVertical;
} }
} }
if (m_highSpeedMode == ewol::Widget::Scroll::speedModeEnableHorizontal) { if (m_highSpeedMode == ewol::widget::Scroll::speedModeEnableHorizontal) {
m_highSpeedStartPos.setX(m_originScrooled.x() / m_maxSize.x() * (m_size.x()-paddingV.x())); m_highSpeedStartPos.setX(m_originScrooled.x() / m_maxSize.x() * (m_size.x()-paddingV.x()));
} else { } else {
m_highSpeedStartPos.setY(m_originScrooled.y() / m_maxSize.y() * (m_size.y()-paddingV.y())); m_highSpeedStartPos.setY(m_originScrooled.y() / m_maxSize.y() * (m_size.y()-paddingV.y()));
@ -245,14 +245,14 @@ bool ewol::Widget::WidgetScrolled::onEventInput(const ewol::event::Input& _event
m_originScrooled.setY(etk_avg(0, m_originScrooled.y(), (m_maxSize.y() - m_size.y()*m_limitScrolling))); m_originScrooled.setY(etk_avg(0, m_originScrooled.y(), (m_maxSize.y() - m_size.y()*m_limitScrolling)));
return true; return true;
} }
if ( m_highSpeedMode == ewol::Widget::Scroll::speedModeEnableHorizontal if ( m_highSpeedMode == ewol::widget::Scroll::speedModeEnableHorizontal
&& _event.getStatus() == ewol::key::statusMove) { && _event.getStatus() == ewol::key::statusMove) {
m_originScrooled.setX((int32_t)(m_maxSize.x() * (relativePos.x()-paddingH.xLeft()) / (m_size.x()-paddingH.x()))); m_originScrooled.setX((int32_t)(m_maxSize.x() * (relativePos.x()-paddingH.xLeft()) / (m_size.x()-paddingH.x())));
m_originScrooled.setX(etk_avg(0, m_originScrooled.x(), (m_maxSize.x() - m_size.x()*m_limitScrolling))); m_originScrooled.setX(etk_avg(0, m_originScrooled.x(), (m_maxSize.x() - m_size.x()*m_limitScrolling)));
markToRedraw(); markToRedraw();
return true; return true;
} }
if ( m_highSpeedMode == ewol::Widget::Scroll::speedModeEnableVertical if ( m_highSpeedMode == ewol::widget::Scroll::speedModeEnableVertical
&& _event.getStatus() == ewol::key::statusMove) { && _event.getStatus() == ewol::key::statusMove) {
m_originScrooled.setY((int32_t)(m_maxSize.y() * (relativePos.y()-paddingV.yButtom()) / (m_size.y()-paddingV.y()))); m_originScrooled.setY((int32_t)(m_maxSize.y() * (relativePos.y()-paddingV.yButtom()) / (m_size.y()-paddingV.y())));
m_originScrooled.setY(etk_avg(0, m_originScrooled.y(), (m_maxSize.y() - m_size.y()*m_limitScrolling))); m_originScrooled.setY(etk_avg(0, m_originScrooled.y(), (m_maxSize.y() - m_size.y()*m_limitScrolling)));
@ -314,30 +314,30 @@ bool ewol::Widget::WidgetScrolled::onEventInput(const ewol::event::Input& _event
if (_event.getId() == 1) { if (_event.getId() == 1) {
EWOL_VERBOSE("event 1 " << _event); EWOL_VERBOSE("event 1 " << _event);
if (_event.getStatus() == ewol::key::statusDown) { if (_event.getStatus() == ewol::key::statusDown) {
m_highSpeedMode = ewol::Widget::Scroll::speedModeInit; m_highSpeedMode = ewol::widget::Scroll::speedModeInit;
m_highSpeedType = ewol::key::typeFinger; m_highSpeedType = ewol::key::typeFinger;
m_highSpeedStartPos.setValue(relativePos.x(), relativePos.y()); m_highSpeedStartPos.setValue(relativePos.x(), relativePos.y());
EWOL_VERBOSE("SCROOL == > INIT"); EWOL_VERBOSE("SCROOL == > INIT");
return true; return true;
} else if (_event.getStatus() == ewol::key::statusUpAfter) { } else if (_event.getStatus() == ewol::key::statusUpAfter) {
m_highSpeedMode = ewol::Widget::Scroll::speedModeDisable; m_highSpeedMode = ewol::widget::Scroll::speedModeDisable;
m_highSpeedType = ewol::key::typeUnknow; m_highSpeedType = ewol::key::typeUnknow;
EWOL_VERBOSE("SCROOL == > DISABLE"); EWOL_VERBOSE("SCROOL == > DISABLE");
markToRedraw(); markToRedraw();
return true; return true;
} else if ( m_highSpeedMode == ewol::Widget::Scroll::speedModeInit } else if ( m_highSpeedMode == ewol::widget::Scroll::speedModeInit
&& _event.getStatus() == ewol::key::statusMove) { && _event.getStatus() == ewol::key::statusMove) {
// wait that the cursor move more than 10 px to enable it : // wait that the cursor move more than 10 px to enable it :
if( abs(relativePos.x() - m_highSpeedStartPos.x()) > 10 if( abs(relativePos.x() - m_highSpeedStartPos.x()) > 10
|| abs(relativePos.y() - m_highSpeedStartPos.y()) > 10 ) { || abs(relativePos.y() - m_highSpeedStartPos.y()) > 10 ) {
// the scrooling can start : // the scrooling can start :
// select the direction : // select the direction :
m_highSpeedMode = ewol::Widget::Scroll::speedModeEnableFinger; m_highSpeedMode = ewol::widget::Scroll::speedModeEnableFinger;
EWOL_DEBUG("SCROOL == > ENABLE"); EWOL_DEBUG("SCROOL == > ENABLE");
markToRedraw(); markToRedraw();
} }
return true; return true;
} if ( m_highSpeedMode == ewol::Widget::Scroll::speedModeEnableFinger } if ( m_highSpeedMode == ewol::widget::Scroll::speedModeEnableFinger
&& _event.getStatus() == ewol::key::statusMove) { && _event.getStatus() == ewol::key::statusMove) {
//m_originScrooled.x = (int32_t)(m_maxSize.x * x / m_size.x); //m_originScrooled.x = (int32_t)(m_maxSize.x * x / m_size.x);
m_originScrooled.setX(m_originScrooled.x() - (relativePos.x() - m_highSpeedStartPos.x())); m_originScrooled.setX(m_originScrooled.x() - (relativePos.x() - m_highSpeedStartPos.x()));
@ -349,9 +349,9 @@ bool ewol::Widget::WidgetScrolled::onEventInput(const ewol::event::Input& _event
markToRedraw(); markToRedraw();
return true; return true;
} }
} else if ( m_highSpeedMode == ewol::Widget::Scroll::speedModeDisable } else if ( m_highSpeedMode == ewol::widget::Scroll::speedModeDisable
&& _event.getStatus() == ewol::key::statusLeave) { && _event.getStatus() == ewol::key::statusLeave) {
m_highSpeedMode = ewol::Widget::Scroll::speedModeDisable; m_highSpeedMode = ewol::widget::Scroll::speedModeDisable;
m_highSpeedType = ewol::key::typeUnknow; m_highSpeedType = ewol::key::typeUnknow;
EWOL_VERBOSE("SCROOL == > DISABLE"); EWOL_VERBOSE("SCROOL == > DISABLE");
markToRedraw(); markToRedraw();
@ -396,12 +396,12 @@ bool ewol::Widget::WidgetScrolled::onEventInput(const ewol::event::Input& _event
} }
void ewol::Widget::WidgetScrolled::onDraw() { void ewol::widget::WidgetScrolled::onDraw() {
m_shaperH.draw(); m_shaperH.draw();
m_shaperV.draw(); m_shaperV.draw();
} }
void ewol::Widget::WidgetScrolled::systemDraw(const ewol::DrawProperty& _displayProp) { void ewol::widget::WidgetScrolled::systemDraw(const ewol::DrawProperty& _displayProp) {
ewol::openGL::push(); ewol::openGL::push();
if (m_scroollingMode == scroolModeCenter) { if (m_scroollingMode == scroolModeCenter) {
// here we invert the reference of the standard openGl view because the reference in the common display is Top left and not buttom left // here we invert the reference of the standard openGl view because the reference in the common display is Top left and not buttom left
@ -437,7 +437,7 @@ void ewol::Widget::WidgetScrolled::systemDraw(const ewol::DrawProperty& _display
ewol::openGL::pop(); ewol::openGL::pop();
} }
void ewol::Widget::WidgetScrolled::setScrollingPositionDynamic(vec2 _borderWidth, const vec2& _currentPosition, bool _center) { void ewol::widget::WidgetScrolled::setScrollingPositionDynamic(vec2 _borderWidth, const vec2& _currentPosition, bool _center) {
if (true == _center) { if (true == _center) {
_borderWidth.setValue(m_size.x() / 2 - _borderWidth.x(), _borderWidth.setValue(m_size.x() / 2 - _borderWidth.x(),
m_size.y() / 2 - _borderWidth.y() ); m_size.y() / 2 - _borderWidth.y() );
@ -460,7 +460,7 @@ void ewol::Widget::WidgetScrolled::setScrollingPositionDynamic(vec2 _borderWidth
} }
} }
void ewol::Widget::WidgetScrolled::scroolingMode(enum scrollingMode _newMode) { void ewol::widget::WidgetScrolled::scroolingMode(enum scrollingMode _newMode) {
m_scroollingMode = _newMode; m_scroollingMode = _newMode;
if (m_scroollingMode == scroolModeGame) { if (m_scroollingMode == scroolModeGame) {
// set the scene maximum size : // set the scene maximum size :
@ -470,7 +470,7 @@ void ewol::Widget::WidgetScrolled::scroolingMode(enum scrollingMode _newMode) {
} }
} }
void ewol::Widget::WidgetScrolled::setSingleFinger(bool _status) { void ewol::widget::WidgetScrolled::setSingleFinger(bool _status) {
if (m_singleFingerMode == _status) { if (m_singleFingerMode == _status) {
return; return;
} }

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

@ -38,16 +38,7 @@ ewol::widget::Windows::Windows() :
} }
ewol::widget::Windows::~Windows() { ewol::widget::Windows::~Windows() {
if (NULL != m_subWidget) { m_subWidget.reset();
delete(m_subWidget);
m_subWidget=NULL;
}
for (size_t iii=0; iii<m_popUpWidgetList.size(); iii++) {
if (NULL != m_popUpWidgetList[iii]) {
delete(m_popUpWidgetList[iii]);
m_popUpWidgetList[iii]=NULL;
}
}
m_popUpWidgetList.clear(); m_popUpWidgetList.clear();
} }
@ -68,7 +59,7 @@ void ewol::widget::Windows::calculateSize(const vec2& _availlable) {
} }
} }
ewol::object::Shared<ewol::Widget> * ewol::widget::Windows::getWidgetAtPos(const vec2& _pos) { ewol::object::Shared<ewol::Widget> ewol::widget::Windows::getWidgetAtPos(const vec2& _pos) {
// calculate relative position // calculate relative position
vec2 relativePos = relativePosition(_pos); vec2 relativePos = relativePosition(_pos);
// event go directly on the pop-up // event go directly on the pop-up
@ -178,8 +169,7 @@ void ewol::widget::Windows::systemDraw(const ewol::DrawProperty& _displayProp) {
void ewol::widget::Windows::setSubWidget(ewol::Widget* _widget) { void ewol::widget::Windows::setSubWidget(ewol::Widget* _widget) {
if (m_subWidget != NULL) { if (m_subWidget != NULL) {
EWOL_INFO("Remove current main windows Widget..."); EWOL_INFO("Remove current main windows Widget...");
delete(m_subWidget); m_subWidget.reset();
m_subWidget = NULL;
} }
m_subWidget = _widget; m_subWidget = _widget;
// Regenerate the size calculation : // Regenerate the size calculation :
@ -246,7 +236,7 @@ void ewol::widget::Windows::setTitle(const std::string& _title) {
void ewol::widget::Windows::createPopUpMessage(enum popUpMessageType _type, const std::string& _message) void ewol::widget::Windows::createPopUpMessage(enum popUpMessageType _type, const std::string& _message)
{ {
ewol::Widget::StdPopUp* tmpPopUp = new widget::StdPopUp(); ewol::widget::StdPopUp* tmpPopUp = new widget::StdPopUp();
if (tmpPopUp == NULL) { if (tmpPopUp == NULL) {
EWOL_ERROR("Can not create a simple pop-up"); EWOL_ERROR("Can not create a simple pop-up");
return; return;

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

@ -31,7 +31,7 @@ static const char * const eventColorSpecificHasChange = "event-color-specifi
ewol::widget::ColorChooser::ColorChooser() : ewol::widget::ColorChooser::ColorChooser() :
ewol::widget::Sizer(ewol::Widget::Sizer::modeVert) { ewol::widget::Sizer(ewol::widget::Sizer::modeVert) {
addObjectType("ewol::widget::ColorChooser"); addObjectType("ewol::widget::ColorChooser");
addEventId(eventChange); addEventId(eventChange);
m_widgetColorBar = NULL; m_widgetColorBar = NULL;
@ -169,7 +169,7 @@ void ewol::widget::ColorChooser::onReceiveMessage(const ewol::object::Message& _
}; };
void ewol::widget::ColorChooser::onObjectRemove(ewol::object::Shared<ewol::Object> * _removeObject) { void ewol::widget::ColorChooser::onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject) {
// First step call parrent : // First step call parrent :
ewol::widget::Sizer::onObjectRemove(_removeObject); ewol::widget::Sizer::onObjectRemove(_removeObject);
// second step find if in all the elements ... // second step find if in all the elements ...

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

@ -30,8 +30,8 @@ extern "C" {
#define __class__ "FileChooser" #define __class__ "FileChooser"
const char * const ewol::Widget::FileChooser::eventCancel = "cancel"; const char * const ewol::widget::FileChooser::eventCancel = "cancel";
const char * const ewol::Widget::FileChooser::eventValidate = "validate"; 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 ewolEventFileChooserHidenFileChange = "ewol-event-file-chooser-Show/Hide-hiden-Files";
static const char * const ewolEventFileChooserEntryFolder = "ewol-event-file-chooser-modify-entry-folder"; static const char * const ewolEventFileChooserEntryFolder = "ewol-event-file-chooser-modify-entry-folder";
@ -44,8 +44,8 @@ static const char * const ewolEventFileChooserListFileValidate = "ewol-event-fil
static const char * const ewolEventFileChooserHome = "ewol-event-file-chooser-home"; static const char * const ewolEventFileChooserHome = "ewol-event-file-chooser-home";
ewol::Widget::FileChooser::FileChooser() { ewol::widget::FileChooser::FileChooser() {
addObjectType("ewol::Widget::FileChooser"); addObjectType("ewol::widget::FileChooser");
addEventId(eventCancel); addEventId(eventCancel);
addEventId(eventValidate); addEventId(eventValidate);
@ -119,33 +119,33 @@ ewol::Widget::FileChooser::FileChooser() {
} }
ewol::Widget::FileChooser::~FileChooser() { ewol::widget::FileChooser::~FileChooser() {
} }
void ewol::Widget::FileChooser::setTitle(const std::string& _label) { void ewol::widget::FileChooser::setTitle(const std::string& _label) {
setConfigNamed("[" + std::to_string(getId()) + "]file-shooser:title-label", "value", _label); setConfigNamed("[" + std::to_string(getId()) + "]file-shooser:title-label", "value", _label);
} }
void ewol::Widget::FileChooser::setValidateLabel(const std::string& _label) { void ewol::widget::FileChooser::setValidateLabel(const std::string& _label) {
setConfigNamed("[" + std::to_string(getId()) + "]file-shooser:validate-label", "value", _label); setConfigNamed("[" + std::to_string(getId()) + "]file-shooser:validate-label", "value", _label);
} }
void ewol::Widget::FileChooser::setCancelLabel(const std::string& _label) { void ewol::widget::FileChooser::setCancelLabel(const std::string& _label) {
setConfigNamed("[" + std::to_string(getId()) + "]file-shooser:cancel-label", "value", _label); setConfigNamed("[" + std::to_string(getId()) + "]file-shooser:cancel-label", "value", _label);
} }
void ewol::Widget::FileChooser::setFolder(const std::string& _folder) { void ewol::widget::FileChooser::setFolder(const std::string& _folder) {
m_folder = _folder + "/"; m_folder = _folder + "/";
updateCurrentFolder(); updateCurrentFolder();
} }
void ewol::Widget::FileChooser::setFileName(const std::string& _filename) { void ewol::widget::FileChooser::setFileName(const std::string& _filename) {
m_file = _filename; m_file = _filename;
setConfigNamed("[" + std::to_string(getId()) + "]file-shooser:entry-file", "value", _filename); setConfigNamed("[" + std::to_string(getId()) + "]file-shooser:entry-file", "value", _filename);
} }
void ewol::Widget::FileChooser::onReceiveMessage(const ewol::object::Message& _msg) { void ewol::widget::FileChooser::onReceiveMessage(const ewol::object::Message& _msg) {
EWOL_INFO("Receive Event from the LIST ... : " << _msg); EWOL_INFO("Receive Event from the LIST ... : " << _msg);
if (_msg.getMessage() == ewolEventFileChooserEntryFolder) { if (_msg.getMessage() == ewolEventFileChooserEntryFolder) {
// == > change the folder name // == > change the folder name
@ -202,7 +202,7 @@ void ewol::Widget::FileChooser::onReceiveMessage(const ewol::object::Message& _m
return; return;
}; };
void ewol::Widget::FileChooser::updateCurrentFolder() { void ewol::widget::FileChooser::updateCurrentFolder() {
if (m_folder != "" ) { if (m_folder != "" ) {
if (m_folder[m_folder.size()-1] != '/') { if (m_folder[m_folder.size()-1] != '/') {
m_folder += "/"; m_folder += "/";
@ -214,7 +214,7 @@ void ewol::Widget::FileChooser::updateCurrentFolder() {
markToRedraw(); markToRedraw();
} }
std::string ewol::Widget::FileChooser::getCompleateFileName() { std::string ewol::widget::FileChooser::getCompleateFileName() {
std::string tmpString = m_folder; std::string tmpString = m_folder;
tmpString += "/"; tmpString += "/";
tmpString += m_file; tmpString += m_file;

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

@ -29,7 +29,7 @@ namespace ewol {
* *
* The first step is to create the file chooser pop-up : * The first step is to create the file chooser pop-up :
* [code style=c++] * [code style=c++]
* ewol::Widget::FileChooser* tmpWidget = new ewol::Widget::FileChooser(); * ewol::widget::FileChooser* tmpWidget = new ewol::Widget::FileChooser();
* if (tmpWidget == NULL) { * if (tmpWidget == NULL) {
* APPL_ERROR("Can not open File chooser !!! "); * APPL_ERROR("Can not open File chooser !!! ");
* return -1; * return -1;

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

@ -21,22 +21,22 @@
#undef __class__ #undef __class__
#define __class__ "Parameter" #define __class__ "Parameter"
const char * const ewol::Widget::Parameter::eventClose = "close"; const char * const ewol::widget::Parameter::eventClose = "close";
static const char * const ewolEventParameterValidate = "ewol-event-parameter-validate"; static const char * const ewolEventParameterValidate = "ewol-event-parameter-validate";
static const char * const ewolEventParameterSave = "ewol-event-parameter-save"; static const char * const ewolEventParameterSave = "ewol-event-parameter-save";
static const char * const l_eventMenuSelected = "local-event-menu-selected"; static const char * const l_eventMenuSelected = "local-event-menu-selected";
ewol::Widget::Parameter::Parameter() : ewol::widget::Parameter::Parameter() :
m_currentIdList(0), m_currentIdList(0),
m_widgetTitle(NULL), m_widgetTitle(NULL),
m_paramList(NULL) { m_paramList(NULL) {
addObjectType("ewol::Widget::Parameter"); addObjectType("ewol::widget::Parameter");
addEventId(eventClose); addEventId(eventClose);
ewol::widget::Sizer * mySizerVert = NULL; ewol::widget::Sizer * mySizerVert = NULL;
ewol::widget::Sizer * mySizerHori = NULL; ewol::widget::Sizer * mySizerHori = NULL;
ewol::Widget::Spacer * mySpacer = NULL; ewol::widget::Spacer * mySpacer = NULL;
#ifdef __TARGET_OS__Android #ifdef __TARGET_OS__Android
setMinSize(ewol::Dimension(vec2(90, 90), ewol::Dimension::Pourcent)); setMinSize(ewol::Dimension(vec2(90, 90), ewol::Dimension::Pourcent));
#else #else
@ -59,7 +59,7 @@ ewol::Widget::Parameter::Parameter() :
} else { } else {
mySizerVert->subWidgetAdd(mySizerHori); mySizerVert->subWidgetAdd(mySizerHori);
mySpacer = new ewol::Widget::Spacer(); mySpacer = new ewol::widget::Spacer();
if (NULL == mySpacer) { if (NULL == mySpacer) {
EWOL_ERROR("Can not allocate widget == > display might be in error"); EWOL_ERROR("Can not allocate widget == > display might be in error");
} else { } else {
@ -83,7 +83,7 @@ ewol::Widget::Parameter::Parameter() :
mySizerHori->subWidgetAdd(tmpButton); mySizerHori->subWidgetAdd(tmpButton);
} }
mySpacer = new ewol::Widget::Spacer(); mySpacer = new ewol::widget::Spacer();
if (NULL == mySpacer) { if (NULL == mySpacer) {
EWOL_ERROR("Can not allocate widget == > display might be in error"); EWOL_ERROR("Can not allocate widget == > display might be in error");
} else { } else {
@ -115,7 +115,7 @@ ewol::Widget::Parameter::Parameter() :
} else { } else {
mySizerVert->subWidgetAdd(mySizerHori); mySizerVert->subWidgetAdd(mySizerHori);
m_paramList = new ewol::Widget::ParameterList(); m_paramList = new ewol::widget::ParameterList();
if (NULL == m_paramList) { if (NULL == m_paramList) {
EWOL_ERROR("Can not allocate widget == > display might be in error"); EWOL_ERROR("Can not allocate widget == > display might be in error");
} else { } else {
@ -123,9 +123,9 @@ ewol::Widget::Parameter::Parameter() :
m_paramList->registerOnEvent(this, "select", 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.get());
} }
mySpacer = new ewol::Widget::Spacer(); mySpacer = new ewol::widget::Spacer();
if (NULL == mySpacer) { if (NULL == mySpacer) {
EWOL_ERROR("Can not allocate widget == > display might be in error"); EWOL_ERROR("Can not allocate widget == > display might be in error");
} else { } else {
@ -141,7 +141,7 @@ ewol::Widget::Parameter::Parameter() :
} else { } else {
mySizerHori->subWidgetAdd(mySizerVert2); mySizerHori->subWidgetAdd(mySizerVert2);
mySpacer = new ewol::Widget::Spacer(); mySpacer = new ewol::widget::Spacer();
if (NULL == mySpacer) { if (NULL == mySpacer) {
EWOL_ERROR("Can not allocate widget == > display might be in error"); EWOL_ERROR("Can not allocate widget == > display might be in error");
} else { } else {
@ -151,19 +151,19 @@ ewol::Widget::Parameter::Parameter() :
mySizerVert2->subWidgetAdd(mySpacer); mySizerVert2->subWidgetAdd(mySpacer);
} }
m_wSlider = new ewol::Widget::WSlider(); m_wSlider = new ewol::widget::WSlider();
if (NULL == m_wSlider) { if (NULL == m_wSlider) {
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_wSlider->setTransitionSpeed(0.5); m_wSlider->setTransitionSpeed(0.5);
m_wSlider->setTransitionMode(ewol::Widget::WSlider::sladingTransitionVert); m_wSlider->setTransitionMode(ewol::widget::WSlider::sladingTransitionVert);
m_wSlider->setExpand(bvec2(true,true)); m_wSlider->setExpand(bvec2(true,true));
mySizerVert2->subWidgetAdd(m_wSlider); mySizerVert2->subWidgetAdd(m_wSlider.get());
} }
} }
} }
mySpacer = new ewol::Widget::Spacer(); mySpacer = new ewol::widget::Spacer();
if (NULL == mySpacer) { if (NULL == mySpacer) {
EWOL_ERROR("Can not allocate widget == > display might be in error"); EWOL_ERROR("Can not allocate widget == > display might be in error");
} else { } else {
@ -178,25 +178,25 @@ ewol::Widget::Parameter::Parameter() :
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_widgetTitle->setExpand(bvec2(true,false)); m_widgetTitle->setExpand(bvec2(true,false));
mySizerVert->subWidgetAdd(m_widgetTitle); mySizerVert->subWidgetAdd(m_widgetTitle.get());
} }
} }
markToRedraw(); markToRedraw();
} }
ewol::Widget::Parameter::~Parameter() { ewol::widget::Parameter::~Parameter() {
} }
void ewol::Widget::Parameter::setTitle(std::string _label) { void ewol::widget::Parameter::setTitle(std::string _label) {
if (NULL == m_widgetTitle) { if (NULL == m_widgetTitle) {
return; return;
} }
m_widgetTitle->setLabel(_label); m_widgetTitle->setLabel(_label);
} }
void ewol::Widget::Parameter::onReceiveMessage(const ewol::object::Message& _msg) { void ewol::widget::Parameter::onReceiveMessage(const ewol::object::Message& _msg) {
ewol::Widget::PopUp::onReceiveMessage(_msg); ewol::widget::PopUp::onReceiveMessage(_msg);
EWOL_DEBUG("event on the parameter : " << _msg); EWOL_DEBUG("event on the parameter : " << _msg);
if (_msg.getMessage() == eventClose) { if (_msg.getMessage() == eventClose) {
// inform that the parameter windows is closed // inform that the parameter windows is closed
@ -217,9 +217,9 @@ void ewol::Widget::Parameter::onReceiveMessage(const ewol::object::Message& _msg
return; return;
} }
void ewol::Widget::Parameter::onObjectRemove(ewol::object::Shared<ewol::Object> * _removeObject) { void ewol::widget::Parameter::onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject) {
// First step call parrent : // First step call parrent :
ewol::Widget::PopUp::onObjectRemove(_removeObject); ewol::widget::PopUp::onObjectRemove(_removeObject);
// second step find if in all the elements ... // second step find if in all the elements ...
if(_removeObject == m_widgetTitle) { if(_removeObject == m_widgetTitle) {
m_widgetTitle = NULL; m_widgetTitle = NULL;
@ -232,7 +232,7 @@ void ewol::Widget::Parameter::onObjectRemove(ewol::object::Shared<ewol::Object>
} }
} }
void ewol::Widget::Parameter::menuAdd(std::string _label, std::string _image, ewol::Widget* _associateWidget) { void ewol::widget::Parameter::menuAdd(std::string _label, std::string _image, ewol::Widget* _associateWidget) {
if (NULL != m_paramList) { if (NULL != m_paramList) {
m_paramList->menuAdd(_label, m_currentIdList, _image); m_paramList->menuAdd(_label, m_currentIdList, _image);
if (NULL != m_wSlider) { if (NULL != m_wSlider) {
@ -255,21 +255,21 @@ void ewol::Widget::Parameter::menuAdd(std::string _label, std::string _image, ew
m_currentIdList++; m_currentIdList++;
} }
} }
void ewol::Widget::Parameter::menuAddGroup(std::string _label) { void ewol::widget::Parameter::menuAddGroup(std::string _label) {
if (NULL != m_paramList) { if (NULL != m_paramList) {
m_paramList->menuSeparator(); m_paramList->menuSeparator();
m_paramList->menuAddGroup(_label); m_paramList->menuAddGroup(_label);
} }
} }
void ewol::Widget::Parameter::menuClear() { void ewol::widget::Parameter::menuClear() {
if (NULL != m_paramList) { if (NULL != m_paramList) {
m_paramList->menuClear(); m_paramList->menuClear();
m_currentIdList = 0; m_currentIdList = 0;
} }
} }
void ewol::Widget::Parameter::menuSeparator() { void ewol::widget::Parameter::menuSeparator() {
if (NULL != m_paramList) { if (NULL != m_paramList) {
m_paramList->menuSeparator(); m_paramList->menuSeparator();
} }

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

@ -26,7 +26,7 @@ namespace ewol {
/** /**
* @ingroup ewolWidgetGroup * @ingroup ewolWidgetGroup
*/ */
class Parameter : public ewol::Widget::PopUp { class Parameter : public ewol::widget::PopUp {
public: public:
// Event list of properties // Event list of properties
static const char * const eventClose; static const char * const eventClose;
@ -38,15 +38,15 @@ namespace ewol {
virtual void onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject); virtual void onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject);
public: public:
void setTitle(std::string _label); void setTitle(std::string _label);
void menuAdd(std::string _label, std::string _image, ewol::object::Shared<ewol::Widget> _associateWidget); void menuAdd(std::string _label, std::string _image, ewol::Widget* _associateWidget);
void menuAddGroup(std::string _label); void menuAddGroup(std::string _label);
void menuClear(); void menuClear();
void menuSeparator(); void menuSeparator();
private: private:
int32_t m_currentIdList; int32_t m_currentIdList;
ewol::widget::Label* m_widgetTitle; ewol::object::Shared<ewol::widget::Label> m_widgetTitle;
ewol::Widget::ParameterList* m_paramList; ewol::object::Shared<ewol::widget::ParameterList> m_paramList;
ewol::Widget::WSlider* m_wSlider; ewol::object::Shared<ewol::widget::WSlider> m_wSlider;
}; };
}; };
}; };

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

@ -15,14 +15,14 @@
#include <ewol/compositing/Text.h> #include <ewol/compositing/Text.h>
#include <ewol/widget/Manager.h> #include <ewol/widget/Manager.h>
const char * const ewol::Widget::ParameterList::eventSelect = "select"; const char * const ewol::widget::ParameterList::eventSelect = "select";
#undef __class__ #undef __class__
#define __class__ "List" #define __class__ "List"
ewol::Widget::ParameterList::ParameterList() { ewol::widget::ParameterList::ParameterList() {
addObjectType("ewol::Widget::ParameterList"); addObjectType("ewol::widget::ParameterList");
addEventId(eventSelect); addEventId(eventSelect);
m_idSelected = -1; m_idSelected = -1;
@ -35,7 +35,7 @@ ewol::Widget::ParameterList::ParameterList() {
setCanHaveFocus(true); setCanHaveFocus(true);
} }
ewol::Widget::ParameterList::~ParameterList() { ewol::widget::ParameterList::~ParameterList() {
//clean all the object //clean all the object
for (size_t iii=0; iii<m_listOObject.size(); iii++) { for (size_t iii=0; iii<m_listOObject.size(); iii++) {
delete(m_listOObject[iii]); delete(m_listOObject[iii]);
@ -45,7 +45,7 @@ ewol::Widget::ParameterList::~ParameterList() {
menuClear(); menuClear();
} }
void ewol::Widget::ParameterList::calculateMinMaxSize() { void ewol::widget::ParameterList::calculateMinMaxSize() {
/*int32_t fontId = getDefaultFontId(); /*int32_t fontId = getDefaultFontId();
int32_t minWidth = ewol::getWidth(fontId, m_label); int32_t minWidth = ewol::getWidth(fontId, m_label);
int32_t minHeight = ewol::getHeight(fontId); int32_t minHeight = ewol::getHeight(fontId);
@ -55,7 +55,7 @@ void ewol::Widget::ParameterList::calculateMinMaxSize() {
m_minSize.setValue(150, 150); m_minSize.setValue(150, 150);
} }
void ewol::Widget::ParameterList::addOObject(ewol::Compositing* _newObject, int32_t _pos) { void ewol::widget::ParameterList::addOObject(ewol::Compositing* _newObject, int32_t _pos) {
if (NULL == _newObject) { if (NULL == _newObject) {
EWOL_ERROR("Try to add an empty object in the Widget generic display system"); EWOL_ERROR("Try to add an empty object in the Widget generic display system");
return; return;
@ -67,7 +67,7 @@ void ewol::Widget::ParameterList::addOObject(ewol::Compositing* _newObject, int3
} }
} }
void ewol::Widget::ParameterList::clearOObjectList() { void ewol::widget::ParameterList::clearOObjectList() {
for (size_t iii=0; iii<m_listOObject.size(); iii++) { for (size_t iii=0; iii<m_listOObject.size(); iii++) {
delete(m_listOObject[iii]); delete(m_listOObject[iii]);
m_listOObject[iii] = NULL; m_listOObject[iii] = NULL;
@ -75,7 +75,7 @@ void ewol::Widget::ParameterList::clearOObjectList() {
m_listOObject.clear(); m_listOObject.clear();
} }
void ewol::Widget::ParameterList::onDraw() { void ewol::widget::ParameterList::onDraw() {
for (size_t iii=0; iii<m_listOObject.size(); iii++) { for (size_t iii=0; iii<m_listOObject.size(); iii++) {
if (NULL != m_listOObject[iii]) { if (NULL != m_listOObject[iii]) {
m_listOObject[iii]->draw(); m_listOObject[iii]->draw();
@ -84,7 +84,7 @@ void ewol::Widget::ParameterList::onDraw() {
WidgetScrolled::onDraw(); WidgetScrolled::onDraw();
} }
void ewol::Widget::ParameterList::onRegenerateDisplay() { void ewol::widget::ParameterList::onRegenerateDisplay() {
if (true == needRedraw()) { if (true == needRedraw()) {
// clean the object list ... // clean the object list ...
clearOObjectList(); clearOObjectList();
@ -162,12 +162,12 @@ void ewol::Widget::ParameterList::onRegenerateDisplay() {
addOObject(tmpDraw, 0); addOObject(tmpDraw, 0);
// call the herited class... // call the herited class...
ewol::Widget::WidgetScrolled::onRegenerateDisplay(); ewol::widget::WidgetScrolled::onRegenerateDisplay();
} }
} }
bool ewol::Widget::ParameterList::onEventInput(const ewol::event::Input& _event) { bool ewol::widget::ParameterList::onEventInput(const ewol::event::Input& _event) {
if (true == WidgetScrolled::onEventInput(_event)) { if (true == WidgetScrolled::onEventInput(_event)) {
keepFocus(); keepFocus();
// nothing to do ... done on upper widet ... // nothing to do ... done on upper widet ...
@ -200,16 +200,16 @@ bool ewol::Widget::ParameterList::onEventInput(const ewol::event::Input& _event)
return false; return false;
} }
void ewol::Widget::ParameterList::onGetFocus() { void ewol::widget::ParameterList::onGetFocus() {
EWOL_DEBUG("Ewol::List get focus"); EWOL_DEBUG("Ewol::List get focus");
} }
void ewol::Widget::ParameterList::onLostFocus() { void ewol::widget::ParameterList::onLostFocus() {
EWOL_DEBUG("Ewol::List Lost focus"); EWOL_DEBUG("Ewol::List Lost focus");
} }
void ewol::Widget::ParameterList::menuAdd(std::string& _label, int32_t _refId, std::string& _image) { void ewol::widget::ParameterList::menuAdd(std::string& _label, int32_t _refId, std::string& _image) {
ewol::Widget::elementPL* tmpEmement = new widget::elementPL(_label, _refId, _image, false); ewol::widget::elementPL* tmpEmement = new widget::elementPL(_label, _refId, _image, false);
if (NULL != tmpEmement) { if (NULL != tmpEmement) {
m_list.push_back(tmpEmement); m_list.push_back(tmpEmement);
if (m_idSelected == -1 && _label != "---" && _refId>0) { if (m_idSelected == -1 && _label != "---" && _refId>0) {
@ -219,16 +219,16 @@ void ewol::Widget::ParameterList::menuAdd(std::string& _label, int32_t _refId, s
} }
} }
void ewol::Widget::ParameterList::menuAddGroup(std::string& _label) { void ewol::widget::ParameterList::menuAddGroup(std::string& _label) {
std::string image = ""; std::string image = "";
ewol::Widget::elementPL* tmpEmement = new widget::elementPL(_label, -1, image, true); ewol::widget::elementPL* tmpEmement = new widget::elementPL(_label, -1, image, true);
if (NULL != tmpEmement) { if (NULL != tmpEmement) {
m_list.push_back(tmpEmement); m_list.push_back(tmpEmement);
markToRedraw(); markToRedraw();
} }
} }
void ewol::Widget::ParameterList::menuClear() { void ewol::widget::ParameterList::menuClear() {
m_idSelected = -1; m_idSelected = -1;
for (size_t iii=0; iii<m_list.size(); iii++) { for (size_t iii=0; iii<m_list.size(); iii++) {
if (NULL != m_list[iii]) { if (NULL != m_list[iii]) {
@ -239,7 +239,7 @@ void ewol::Widget::ParameterList::menuClear() {
m_list.clear(); m_list.clear();
} }
void ewol::Widget::ParameterList::menuSeparator() { void ewol::widget::ParameterList::menuSeparator() {
if (m_list.size()>0) { if (m_list.size()>0) {
std::string label = ""; std::string label = "";
std::string image = ""; std::string image = "";

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

@ -36,13 +36,13 @@ namespace ewol {
/** /**
* @ingroup ewolWidgetGroup * @ingroup ewolWidgetGroup
*/ */
class ParameterList :public ewol::Widget::WidgetScrolled { class ParameterList :public ewol::widget::WidgetScrolled {
public: public:
// Event list of properties // Event list of properties
static const char * const eventSelect; 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;
public: public:
ParameterList(); ParameterList();
virtual ~ParameterList(); virtual ~ParameterList();

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

@ -18,15 +18,15 @@
static const char * const eventButtonExit = "ewol-event-pop-up-exit-button"; static const char * const eventButtonExit = "ewol-event-pop-up-exit-button";
ewol::Widget::StdPopUp::StdPopUp() : ewol::widget::StdPopUp::StdPopUp() :
m_title(NULL), m_title(NULL),
m_comment(NULL), m_comment(NULL),
m_subBar(NULL) { m_subBar(NULL) {
addObjectType("ewol::Widget::StdPopUp"); addObjectType("ewol::widget::StdPopUp");
setMinSize(ewol::Dimension(vec2(20,10),ewol::Dimension::Pourcent)); setMinSize(ewol::Dimension(vec2(20,10),ewol::Dimension::Pourcent));
ewol::widget::Sizer* mySizerVert = NULL; ewol::widget::Sizer* mySizerVert = NULL;
ewol::Widget::Spacer* mySpacer = NULL; ewol::widget::Spacer* mySpacer = NULL;
mySizerVert = new ewol::widget::Sizer(widget::Sizer::modeVert); mySizerVert = new ewol::widget::Sizer(widget::Sizer::modeVert);
// set it in the pop-up-system : // set it in the pop-up-system :
@ -35,32 +35,32 @@ ewol::Widget::StdPopUp::StdPopUp() :
m_subBar = new ewol::widget::Sizer(widget::Sizer::modeHori); m_subBar = new ewol::widget::Sizer(widget::Sizer::modeHori);
m_subBar->lockExpand(bvec2(true,true)); m_subBar->lockExpand(bvec2(true,true));
m_subBar->setExpand(bvec2(true,false)); m_subBar->setExpand(bvec2(true,false));
mySizerVert->subWidgetAdd(m_subBar->get()); mySizerVert->subWidgetAdd(m_subBar.get());
mySpacer = new ewol::Widget::Spacer(); mySpacer = new ewol::widget::Spacer();
mySpacer->setExpand(bvec2(true,false)); mySpacer->setExpand(bvec2(true,false));
m_subBar->subWidgetAdd(mySpacer); m_subBar->subWidgetAdd(mySpacer);
mySpacer = new ewol::Widget::Spacer(); mySpacer = new ewol::widget::Spacer();
mySpacer->setExpand(bvec2(true,false)); mySpacer->setExpand(bvec2(true,false));
mySpacer->setColor(etk::Color<>(0x888888FF)); mySpacer->setColor(etk::Color<>(0x888888FF));
mySpacer->setMinSize(ewol::Dimension(vec2(0,3),ewol::Dimension::Pixel)); mySpacer->setMinSize(ewol::Dimension(vec2(0,3),ewol::Dimension::Pixel));
mySizerVert->subWidgetAdd(mySpacer); mySizerVert->subWidgetAdd(mySpacer);
mySpacer = new ewol::Widget::Spacer(); mySpacer = new ewol::widget::Spacer();
mySpacer->setExpand(bvec2(true,false)); mySpacer->setExpand(bvec2(true,false));
mySpacer->setMinSize(ewol::Dimension(vec2(0,5),ewol::Dimension::Pixel)); mySpacer->setMinSize(ewol::Dimension(vec2(0,5),ewol::Dimension::Pixel));
mySizerVert->subWidgetAdd(mySpacer); mySizerVert->subWidgetAdd(mySpacer);
m_comment = new ewol::widget::Label("No Label"); m_comment = new ewol::widget::Label("No Label");
m_comment->setExpand(bvec2(true,true)); m_comment->setExpand(bvec2(true,true));
mySizerVert->subWidgetAdd(m_comment->get()); mySizerVert->subWidgetAdd(m_comment.get());
mySpacer = new ewol::Widget::Spacer(); mySpacer = new ewol::widget::Spacer();
mySpacer->setExpand(bvec2(true,false)); mySpacer->setExpand(bvec2(true,false));
mySpacer->setMinSize(ewol::Dimension(vec2(0,5),ewol::Dimension::Pixel)); mySpacer->setMinSize(ewol::Dimension(vec2(0,5),ewol::Dimension::Pixel));
mySizerVert->subWidgetAdd(mySpacer); mySizerVert->subWidgetAdd(mySpacer);
mySpacer = new ewol::Widget::Spacer(); mySpacer = new ewol::widget::Spacer();
mySpacer->setExpand(bvec2(true,false)); mySpacer->setExpand(bvec2(true,false));
mySpacer->setColor(etk::Color<>(0x888888FF)); mySpacer->setColor(etk::Color<>(0x888888FF));
mySpacer->setMinSize(ewol::Dimension(vec2(0,3),ewol::Dimension::Pixel)); mySpacer->setMinSize(ewol::Dimension(vec2(0,3),ewol::Dimension::Pixel));
@ -69,14 +69,14 @@ ewol::Widget::StdPopUp::StdPopUp() :
m_title = new ewol::widget::Label("<bold>Message</bold>"); m_title = new ewol::widget::Label("<bold>Message</bold>");
m_title->setExpand(bvec2(true,false)); m_title->setExpand(bvec2(true,false));
m_title->setFill(bvec2(true,true)); m_title->setFill(bvec2(true,true));
mySizerVert->subWidgetAdd(m_title->get()); mySizerVert->subWidgetAdd(m_title.get());
} }
ewol::Widget::StdPopUp::~StdPopUp() { ewol::widget::StdPopUp::~StdPopUp() {
} }
void ewol::Widget::StdPopUp::setTitle(const std::string& _text) { void ewol::widget::StdPopUp::setTitle(const std::string& _text) {
if (m_title == NULL) { if (m_title == NULL) {
return; return;
} }
@ -84,7 +84,7 @@ void ewol::Widget::StdPopUp::setTitle(const std::string& _text) {
markToRedraw(); markToRedraw();
} }
void ewol::Widget::StdPopUp::setComment(const std::string& _text) { void ewol::widget::StdPopUp::setComment(const std::string& _text) {
if (m_comment == NULL) { if (m_comment == NULL) {
return; return;
} }
@ -92,7 +92,7 @@ void ewol::Widget::StdPopUp::setComment(const std::string& _text) {
markToRedraw(); markToRedraw();
} }
ewol::object::Shared<ewol::widget::Button> ewol::Widget::StdPopUp::addButton(const std::string& _text, bool _autoExit) { ewol::object::Shared<ewol::widget::Button> ewol::widget::StdPopUp::addButton(const std::string& _text, bool _autoExit) {
if (m_subBar == NULL) { if (m_subBar == NULL) {
EWOL_ERROR("button-bar does not existed ..."); EWOL_ERROR("button-bar does not existed ...");
return NULL; return NULL;
@ -111,9 +111,9 @@ ewol::object::Shared<ewol::widget::Button> ewol::Widget::StdPopUp::addButton(con
return myButton; return myButton;
} }
void ewol::Widget::StdPopUp::onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject) { void ewol::widget::StdPopUp::onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject) {
// call parent: // call parent:
ewol::Widget::PopUp::onObjectRemove(_removeObject); ewol::widget::PopUp::onObjectRemove(_removeObject);
if (_removeObject == m_subBar) { if (_removeObject == m_subBar) {
m_subBar = NULL; m_subBar = NULL;
markToRedraw(); markToRedraw();
@ -131,9 +131,9 @@ void ewol::Widget::StdPopUp::onObjectRemove(ewol::object::Shared<ewol::Object> _
} }
} }
void ewol::Widget::StdPopUp::onReceiveMessage(const ewol::object::Message& _msg) { void ewol::widget::StdPopUp::onReceiveMessage(const ewol::object::Message& _msg) {
// call parent: // call parent:
ewol::Widget::PopUp::onReceiveMessage(_msg); ewol::widget::PopUp::onReceiveMessage(_msg);
if (_msg.getMessage() == eventButtonExit) { if (_msg.getMessage() == eventButtonExit) {
autoDestroy(); autoDestroy();
} }

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

@ -39,7 +39,7 @@ namespace ewol {
* +---------------------------------------------+ * +---------------------------------------------+
* [/pre] * [/pre]
*/ */
class StdPopUp : public ewol::Widget::PopUp { class StdPopUp : public ewol::widget::PopUp {
public: public:
/** /**
* @brief std-pop-up constructor. * @brief std-pop-up constructor.