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();
}
void ewol::widget::Button::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
_widgetManager->addWidgetCreator(__class__, &Create);
void ewol::widget::Button::init(ewol::widget::Manager& _widgetManager) {
_widgetManager.addWidgetCreator(__class__, &Create);
}
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 {
public:
//! @not-in-doc
static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager);
static void init(ewol::widget::Manager& _widgetManager);
// Event list of properties
static const char* const eventPressed;
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();
}
void ewol::widget::ButtonColor::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&Create);
void ewol::widget::ButtonColor::init(ewol::widget::Manager& _widgetManager) {
_widgetManager.addWidgetCreator(__class__,&Create);
}
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
static const char * const eventChange;
public:
static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager);
static void init(ewol::widget::Manager& _widgetManager);
private:
ewol::compositing::Shaper m_shaper; //!< Compositing theme.
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();
}
void ewol::widget::CheckBox::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&Create);
void ewol::widget::CheckBox::init(ewol::widget::Manager& _widgetManager) {
_widgetManager.addWidgetCreator(__class__,&Create);
}
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 {
public:
//! @not-in-doc
static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager);
static void init(ewol::widget::Manager& _widgetManager);
// Event list of properties
static const char* const eventPressed;
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();
}
void ewol::widget::ContextMenu::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&Create);
void ewol::widget::ContextMenu::init(ewol::widget::Manager& _widgetManager) {
_widgetManager.addWidgetCreator(__class__,&Create);
}

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

@ -32,7 +32,7 @@ namespace ewol {
markNone
};
public:
static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager);
static void init(ewol::widget::Manager& _widgetManager);
// Config list of properties
static const char* const configArrowPosition;
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();
}
void ewol::widget::Entry::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&create);
void ewol::widget::Entry::init(ewol::widget::Manager& _widgetManager) {
_widgetManager.addWidgetCreator(__class__,&create);
}
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 configValue;
public:
static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager);
static void init(ewol::widget::Manager& _widgetManager);
private:
ewol::compositing::Shaper m_shaper;
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();
}
void ewol::widget::Gird::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&create);
void ewol::widget::Gird::init(ewol::widget::Manager& _widgetManager) {
_widgetManager.addWidgetCreator(__class__,&create);
}

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

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

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

@ -20,8 +20,8 @@ static ewol::Widget* create() {
return new ewol::widget::Image();
}
void ewol::widget::Image::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&create);
void ewol::widget::Image::init(ewol::widget::Manager& _widgetManager) {
_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"
*/
static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager);
static void init(ewol::widget::Manager& _widgetManager);
protected:
ewol::compositing::Image m_compositing; //!< compositing element of the image.
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();
}
void ewol::widget::Label::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&create);
void ewol::widget::Label::init(ewol::widget::Manager& _widgetManager) {
_widgetManager.addWidgetCreator(__class__,&create);
}
// TODO : Remove the label name in the constructor ...
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"
*/
static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager);
static void init(ewol::widget::Manager& _widgetManager);
private:
ewol::compositing::Text m_text; //!< Compositing text element.
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();
}
void ewol::widget::Layer::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&create);
void ewol::widget::Layer::init(ewol::widget::Manager& _widgetManager) {
_widgetManager.addWidgetCreator(__class__,&create);
}
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"
*/
static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager);
static void init(ewol::widget::Manager& _widgetManager);
public:
/**
* @brief Constructor

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

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

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

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

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

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

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

@ -18,35 +18,35 @@
#undef __class__
#define __class__ "Menu"
ewol::Widget::Menu::Menu() {
addObjectType("ewol::Widget::Menu");
ewol::widget::Menu::Menu() {
addObjectType("ewol::widget::Menu");
m_staticId = 0;
m_widgetContextMenu = NULL;
}
ewol::Widget::Menu::~Menu() {
ewol::widget::Menu::~Menu() {
clear();
}
void ewol::Widget::Menu::subWidgetRemoveAll() {
void ewol::widget::Menu::subWidgetRemoveAll() {
clear();
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");
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");
}
void ewol::Widget::Menu::subWidgetUnLink(ewol::Widget* _newWidget) {
void ewol::widget::Menu::subWidgetUnLink(ewol::object::Shared<ewol::Widget> _newWidget) {
EWOL_ERROR("Not availlable");
}
void ewol::Widget::Menu::clear() {
void ewol::widget::Menu::clear() {
for (size_t iii=0; iii < m_listElement.size(); iii++) {
if (m_listElement[iii] != NULL) {
delete(m_listElement[iii]);
@ -56,19 +56,19 @@ void ewol::Widget::Menu::clear() {
m_listElement.clear();
}
int32_t ewol::Widget::Menu::addTitle(std::string _label,
std::string _image,
const char * _generateEvent,
const std::string _message) {
int32_t ewol::widget::Menu::addTitle(std::string _label,
std::string _image,
const char * _generateEvent,
const std::string _message) {
return add(-1, _label, _image, _generateEvent, _message);
}
int32_t ewol::Widget::Menu::add(int32_t _parent,
std::string _label,
std::string _image,
const char *_generateEvent,
const std::string _message) {
ewol::Widget::MenuElement *tmpObject = new ewol::Widget::MenuElement();
int32_t ewol::widget::Menu::add(int32_t _parent,
std::string _label,
std::string _image,
const char *_generateEvent,
const std::string _message) {
ewol::widget::MenuElement *tmpObject = new ewol::widget::MenuElement();
if (NULL == tmpObject) {
EWOL_ERROR("Allocation problem");
return -1;
@ -111,12 +111,12 @@ int32_t ewol::Widget::Menu::add(int32_t _parent,
return tmpObject->m_localId;
}
void ewol::Widget::Menu::addSpacer() {
void ewol::widget::Menu::addSpacer() {
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) {
return true;
@ -158,7 +158,9 @@ void ewol::Widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
}
// get the button widget :
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) {
vec2 tmpOri = eventFromWidget->getOrigin();
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,
tmpOri.y() );
}
*/
m_widgetContextMenu->setPositionMark(ewol::widget::ContextMenu::markTop, newPosition );
ewol::widget::Sizer * mySizer = NULL;
@ -240,11 +242,11 @@ void ewol::Widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
}
}
}
ewol::widget::Windows* currentWindows = getWindows();
if (NULL == currentWindows) {
ewol::object::Shared<ewol::widget::Windows> currentWindows = getWindows();
if (currentWindows == nullptr) {
EWOL_ERROR("Can not get the curent Windows...");
m_widgetContextMenu->removeObject();
m_widgetContextMenu=NULL;
m_widgetContextMenu = NULL;
} else {
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);
if (m_widgetContextMenu == _removeObject) {
delete(m_widgetContextMenu);
m_widgetContextMenu = NULL;
}
for (size_t jjj=0; jjj<m_listElement.size(); jjj++) {
if (NULL != m_listElement[jjj]) {
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 subWidgetUnLink(ewol::object::Shared<ewol::Widget> _newWidget);
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 ...
ewol::widget::ContextMenu* m_widgetContextMenu;
public:
@ -52,7 +52,7 @@ namespace ewol {
void addSpacer();
// Derived function
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__
#define __class__ "PopUp"
const char* const ewol::Widget::PopUp::configShaper="shaper";
const char* const ewol::Widget::PopUp::configRemoveOnExternClick="out-click-remove";
const char* const ewol::Widget::PopUp::configAnimation="animation";
const char* const ewol::Widget::PopUp::configLockExpand="lock";
const char* const ewol::widget::PopUp::configShaper="shaper";
const char* const ewol::widget::PopUp::configRemoveOnExternClick="out-click-remove";
const char* const ewol::widget::PopUp::configAnimation="animation";
const char* const ewol::widget::PopUp::configLockExpand="lock";
static const char* annimationIncrease = "increase";
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) {
_widgetManager->addWidgetCreator(__class__,&create);
void ewol::widget::PopUp::init(ewol::widget::Manager& _widgetManager) {
_widgetManager.addWidgetCreator(__class__,&create);
}
ewol::Widget::PopUp::PopUp(const std::string& _shaperName) :
ewol::widget::PopUp::PopUp(const std::string& _shaperName) :
m_shaper(_shaperName),
m_lockExpand(true,true),
m_closeOutEvent(false) {
addObjectType("ewol::Widget::PopUp");
addObjectType("ewol::widget::PopUp");
m_userExpand.setValue(false, false);
setMinSize(ewol::Dimension(vec2(80,80),ewol::Dimension::Pourcent));
registerConfig(configShaper, "string", NULL, "The shaper properties");
@ -46,11 +46,11 @@ ewol::Widget::PopUp::PopUp(const std::string& _shaperName) :
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) {
m_lockExpand = _lockExpand;
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);
markToRedraw();
}
void ewol::Widget::PopUp::calculateSize(const vec2& _available) {
void ewol::widget::PopUp::calculateSize(const vec2& _available) {
ewol::Widget::calculateSize(_available);
if (NULL != m_subWidget) {
ewol::Padding padding = m_shaper.getPadding();
@ -97,7 +97,7 @@ void ewol::Widget::PopUp::calculateSize(const vec2& _available) {
markToRedraw();
}
void ewol::Widget::PopUp::systemDraw(const ewol::DrawProperty& _displayProp) {
void ewol::widget::PopUp::systemDraw(const ewol::DrawProperty& _displayProp) {
if (true == m_hide){
// widget is hidden ...
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();
}
void ewol::Widget::PopUp::onRegenerateDisplay() {
void ewol::widget::PopUp::onRegenerateDisplay() {
if (true == needRedraw()) {
m_shaper.clear();
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);
if (NULL != val) {
return val;
@ -155,7 +155,7 @@ ewol::object::Shared<ewol::Widget> ewol::Widget::PopUp::getWidgetAtPos(const vec
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)) {
return true;
}
@ -174,7 +174,7 @@ bool ewol::Widget::PopUp::onSetConfig(const ewol::object::Config& _conf) {
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)) {
return true;
}
@ -193,7 +193,7 @@ bool ewol::Widget::PopUp::onGetConfig(const char* _config, std::string& _result)
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 (true == m_closeOutEvent) {
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) {
return false;
}
@ -231,11 +231,11 @@ bool ewol::Widget::PopUp::onStartAnnimation(enum ewol::Widget::annimationMode _m
return false;
}
void ewol::Widget::PopUp::onStopAnnimation() {
void ewol::widget::PopUp::onStopAnnimation() {
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) ) {
stopAnnimation();
}

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

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

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

@ -15,22 +15,22 @@
#define __class__ "ProgressBar"
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) {
_widgetManager->addWidgetCreator(__class__,&create);
void ewol::widget::ProgressBar::init(ewol::widget::Manager& _widgetManager) {
_widgetManager.addWidgetCreator(__class__,&create);
}
const char* const ewol::Widget::ProgressBar::configColorBg = "color-bg";
const char* const ewol::Widget::ProgressBar::configColorFgOn = "color-on";
const char* const ewol::Widget::ProgressBar::configColorFgOff = "color-off";
const char* const ewol::Widget::ProgressBar::configValue = "value";
const char* const ewol::widget::ProgressBar::configColorBg = "color-bg";
const char* const ewol::widget::ProgressBar::configColorFgOn = "color-on";
const char* const ewol::widget::ProgressBar::configColorFgOff = "color-off";
const char* const ewol::widget::ProgressBar::configValue = "value";
const int32_t dotRadius = 6;
ewol::Widget::ProgressBar::ProgressBar() {
addObjectType("ewol::Widget::ProgressBar");
ewol::widget::ProgressBar::ProgressBar() {
addObjectType("ewol::widget::ProgressBar");
m_value = 0.0;
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();
m_minSize.setValue( etk_max(tmpMin.x(), 40),
etk_max(tmpMin.y(), dotRadius*2) );
markToRedraw();
}
void ewol::Widget::ProgressBar::setValue(float _val) {
void ewol::widget::ProgressBar::setValue(float _val) {
m_value = etk_avg(0, _val, 1);
markToRedraw();
}
void ewol::Widget::ProgressBar::onDraw() {
void ewol::widget::ProgressBar::onDraw() {
m_draw.draw();
}
void ewol::Widget::ProgressBar::onRegenerateDisplay() {
void ewol::widget::ProgressBar::onRegenerateDisplay() {
if (true == needRedraw()) {
// clean the object list ...
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)) {
return true;
}
@ -120,7 +120,7 @@ bool ewol::Widget::ProgressBar::onSetConfig(const ewol::object::Config& _conf) {
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)) {
return true;
}

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

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

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

@ -15,16 +15,16 @@
#define __class__ "Scroll"
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) {
_widgetManager->addWidgetCreator(__class__,&create);
void ewol::widget::Scroll::init(ewol::widget::Manager& _widgetManager) {
_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_shaperV(_shaperName),
m_limit(0.15,0.5),
@ -33,22 +33,22 @@ ewol::Widget::Scroll::Scroll(const std::string& _shaperName) :
m_highSpeedMode(speedModeDisable),
m_highSpeedButton(-1),
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");
}
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;
markToRedraw();
}
#define SCROLL_BAR_SPACE (15)
void ewol::Widget::Scroll::calculateMinMaxSize() {
void ewol::widget::Scroll::calculateMinMaxSize() {
// call main class !! and not containter class ...
ewol::Widget::calculateMinMaxSize();
// 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) {
return;
}
@ -69,12 +69,12 @@ void ewol::Widget::Scroll::systemDraw(const ewol::DrawProperty& _displayProp) {
ewol::Widget::systemDraw(_displayProp);
}
void ewol::Widget::Scroll::onDraw() {
void ewol::widget::Scroll::onDraw() {
m_shaperH.draw();
m_shaperV.draw();
}
void ewol::Widget::Scroll::onRegenerateDisplay() {
void ewol::widget::Scroll::onRegenerateDisplay() {
// call upper class
ewol::widget::Container::onRegenerateDisplay();
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;
//_event.setType(ewol::key::typeFinger);
vec2 relativePos = relativePosition(_event.getPos());
@ -349,7 +349,7 @@ bool ewol::Widget::Scroll::onEventInput(const ewol::event::Input& _event) {
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);
if (NULL != tmpWidget) {
return tmpWidget;
@ -357,7 +357,7 @@ ewol::object::Shared<ewol::Widget> ewol::Widget::Scroll::getWidgetAtPos(const ve
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)) {
return true;
}
@ -368,7 +368,7 @@ bool ewol::Widget::Scroll::onSetConfig(const ewol::object::Config& _conf) {
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)) {
return true;
}

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

@ -35,7 +35,7 @@ namespace ewol {
// Cinfig parameter list:
static const char* const configLimit;
public:
static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager);
static void init(ewol::widget::Manager& _widgetManager);
private:
ewol::compositing::Shaper m_shaperH; //!< Compositing theme Horizontal.
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__
#define __class__ "Sizer"
static ewol::object::Shared<ewol::Widget> create() {
static ewol::Widget* create() {
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);
}

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"
*/
static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager);
static void init(ewol::widget::Manager& _widgetManager);
// Config list of properties
static const char* const configBorder;
static const char* const configMode;
@ -119,10 +119,10 @@ namespace ewol {
virtual void calculateSize(const vec2& _availlable);
virtual void calculateMinMaxSize();
// overwrite the set fuction to start annimations ...
virtual int32_t subWidgetAdd(ewol::object::Shared<ewol::Widget> _newWidget);
virtual int32_t subWidgetAddStart(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 int32_t subWidgetAdd(ewol::Widget* _newWidget);
virtual int32_t subWidgetAddStart(ewol::Widget* _newWidget);
virtual void subWidgetRemove(ewol::Widget* _newWidget);
virtual void subWidgetUnLink(ewol::Widget* _newWidget);
virtual bool onSetConfig(const ewol::object::Config& _conf);
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();
}
void ewol::widget::Slider::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&create);
void ewol::widget::Slider::init(ewol::widget::Manager& _widgetManager) {
_widgetManager.addWidgetCreator(__class__,&create);
}
const int32_t dotRadius = 6;

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

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

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

@ -14,18 +14,18 @@
#undef __class__
#define __class__ "Spacer"
const char* const ewol::Widget::Spacer::configColor = "color";
const char* const ewol::widget::Spacer::configColor = "color";
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) {
_widgetManager->addWidgetCreator(__class__,&create);
void ewol::widget::Spacer::init(ewol::widget::Manager& _widgetManager) {
_widgetManager.addWidgetCreator(__class__,&create);
}
ewol::Widget::Spacer::Spacer() {
addObjectType("ewol::Widget::Spacer");
ewol::widget::Spacer::Spacer() {
addObjectType("ewol::widget::Spacer");
m_userMinSize = ewol::Dimension(vec2(10,10));
setCanHaveFocus(false);
m_color = etk::color::black;
@ -33,16 +33,16 @@ ewol::Widget::Spacer::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();
}
#define BORDER_SIZE_TMP (4)
void ewol::Widget::Spacer::onRegenerateDisplay() {
void ewol::widget::Spacer::onRegenerateDisplay() {
if (false == needRedraw()) {
return;
}
@ -56,7 +56,7 @@ void ewol::Widget::Spacer::onRegenerateDisplay() {
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)) {
return true;
}
@ -68,7 +68,7 @@ bool ewol::Widget::Spacer::onSetConfig(const ewol::object::Config& _conf) {
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)) {
return true;
}

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

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

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

@ -10,12 +10,12 @@
#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 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];
return _os;
}
@ -24,28 +24,28 @@ std::ostream& operator <<(std::ostream& _os, const enum ewol::Widget::WSlider::s
#define __class__ "WSlider"
// Event list of properties
const char* const ewol::Widget::WSlider::eventStartSlide = "ewol-widget-wslider-event-start-slide";
const char* const ewol::Widget::WSlider::eventStopSlide = "ewol-widget-wslider-event-stop-slide";
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";
// Config list of properties
const char* const ewol::Widget::WSlider::configMode = "mode";
const char* const ewol::Widget::WSlider::configSpeed = "speed";
const char* const ewol::widget::WSlider::configMode = "mode";
const char* const ewol::widget::WSlider::configSpeed = "speed";
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) {
_widgetManager->addWidgetCreator(__class__,&create);
void ewol::widget::WSlider::init(ewol::widget::Manager& _widgetManager) {
_widgetManager.addWidgetCreator(__class__,&create);
}
ewol::Widget::WSlider::WSlider() :
ewol::widget::WSlider::WSlider() :
m_windowsSources(0),
m_windowsDestination(0),
m_windowsRequested(-1),
m_slidingProgress(1.0f),
m_transitionSpeed(1.0f),
m_transitionSlide(sladingTransitionHori) {
addObjectType("ewol::Widget::WSlider");
addObjectType("ewol::widget::WSlider");
addEventId(eventStartSlide);
addEventId(eventStopSlide);
// add configuration
@ -53,12 +53,12 @@ ewol::Widget::WSlider::WSlider() :
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::widget::ContainerN::calculateSize(_availlable);
@ -109,7 +109,7 @@ void ewol::Widget::WSlider::calculateSize(const vec2& _availlable) {
markToRedraw();
}
void ewol::Widget::WSlider::subWidgetSelectSetVectorId(int32_t _id) {
void ewol::widget::WSlider::subWidgetSelectSetVectorId(int32_t _id) {
if (_id<0) {
EWOL_ERROR("Can not change to a widget not present : vectID=" << _id);
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;
// search element in the list :
for (size_t iii=0 ; iii<m_subWidget.size() ; iii++) {
@ -136,7 +136,7 @@ void ewol::Widget::WSlider::subWidgetSelectSet(int32_t _id) {
subWidgetSelectSetVectorId(elementID);
}
void ewol::Widget::WSlider::subWidgetSelectSet(ewol::Widget* _widgetPointer) {
void ewol::widget::WSlider::subWidgetSelectSet(ewol::object::Shared<ewol::Widget> _widgetPointer) {
if (_widgetPointer == NULL) {
EWOL_ERROR("Can not change to a widget NULL");
return;
@ -152,7 +152,7 @@ void ewol::Widget::WSlider::subWidgetSelectSet(ewol::Widget* _widgetPointer) {
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 == "") {
EWOL_ERROR("Can not change to a widget with no name (input)");
return;
@ -168,14 +168,14 @@ void ewol::Widget::WSlider::subWidgetSelectSet(const std::string& _widgetName) {
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) {
m_transitionSlide = _mode;
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) {
m_windowsSources = m_windowsDestination;
if( m_windowsRequested != -1
@ -208,7 +208,7 @@ void ewol::Widget::WSlider::periodicCall(const ewol::event::Time& _event) {
markToRedraw();
}
void ewol::Widget::WSlider::systemDraw(const ewol::DrawProperty& _displayProp) {
void ewol::widget::WSlider::systemDraw(const ewol::DrawProperty& _displayProp) {
if (true == m_hide){
// widget is hidden ...
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) {
int32_t iii = m_windowsDestination;
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)) {
return true;
}
@ -292,7 +292,7 @@ bool ewol::Widget::WSlider::onSetConfig(const ewol::object::Config& _conf) {
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)) {
return true;
}
@ -315,7 +315,7 @@ bool ewol::Widget::WSlider::onGetConfig(const char* _config, std::string& _resul
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()) {
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())
&& (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) {
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())
&& (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) {
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())
&& (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) {
return tmpWidget;
}

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

@ -21,7 +21,7 @@ namespace ewol {
*/
class WSlider :public ewol::widget::ContainerN {
public:
static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager);
static void init(ewol::widget::Manager& _widgetManager);
// Event list of properties
static const char* const eventStartSlide;
static const char* const eventStopSlide;
@ -106,7 +106,7 @@ namespace ewol {
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

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_shaperV(_shaperName),
m_singleFingerMode(true) {
addObjectType("ewol::Widget::WidgetScrolled");
addObjectType("ewol::widget::WidgetScrolled");
m_originScrooled.setValue(0,0);
m_pixelScrolling = 20;
m_highSpeedMode = ewol::Widget::Scroll::speedModeDisable;
m_highSpeedMode = ewol::widget::Scroll::speedModeDisable;
m_scroollingMode = scroolModeNormal;
m_highSpeedType = ewol::key::typeUnknow;
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_shaperV.clear();
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);
vec2 relativePos = relativePosition(_event.getPos());
// 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( m_size.y() < m_maxSize.y()
|| m_originScrooled.y() != 0) {
m_highSpeedMode = ewol::Widget::Scroll::speedModeEnableVertical;
m_highSpeedMode = ewol::widget::Scroll::speedModeEnableVertical;
m_highSpeedType = ewol::key::typeMouse;
m_highSpeedStartPos.setX(relativePos.x());
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())) {
if( m_size.x() < m_maxSize.x()
|| m_originScrooled.x()!=0) {
m_highSpeedMode = ewol::Widget::Scroll::speedModeEnableHorizontal;
m_highSpeedMode = ewol::widget::Scroll::speedModeEnableHorizontal;
m_highSpeedType = ewol::key::typeMouse;
m_highSpeedStartPos.setX(m_originScrooled.x() / m_maxSize.x() * (m_size.x()-paddingH.xLeft()*2));
m_highSpeedStartPos.setY(relativePos.y());
@ -186,29 +186,29 @@ bool ewol::Widget::WidgetScrolled::onEventInput(const ewol::event::Input& _event
}
} else */{
if (_event.getStatus() == ewol::key::statusDown) {
m_highSpeedMode = ewol::Widget::Scroll::speedModeInit;
m_highSpeedMode = ewol::widget::Scroll::speedModeInit;
m_highSpeedType = ewol::key::typeMouse;
m_highSpeedStartPos.setValue(relativePos.x(), relativePos.y());
m_highSpeedButton = 2;
return true;
}
}
} else if ( m_highSpeedMode != ewol::Widget::Scroll::speedModeDisable
} else if ( m_highSpeedMode != ewol::widget::Scroll::speedModeDisable
&& _event.getStatus() == ewol::key::statusLeave) {
m_highSpeedMode = ewol::Widget::Scroll::speedModeDisable;
m_highSpeedMode = ewol::widget::Scroll::speedModeDisable;
m_highSpeedType = ewol::key::typeUnknow;
markToRedraw();
return true;
}
if ( _event.getId() == m_highSpeedButton
&& m_highSpeedMode != ewol::Widget::Scroll::speedModeDisable) {
&& m_highSpeedMode != ewol::widget::Scroll::speedModeDisable) {
if (_event.getStatus() == ewol::key::statusUpAfter) {
m_highSpeedMode = ewol::Widget::Scroll::speedModeDisable;
m_highSpeedMode = ewol::widget::Scroll::speedModeDisable;
m_highSpeedType = ewol::key::typeUnknow;
return false;
} else if (m_highSpeedMode == ewol::Widget::Scroll::speedModeGrepEndEvent) {
} else if (m_highSpeedMode == ewol::widget::Scroll::speedModeGrepEndEvent) {
if (_event.getStatus() == ewol::key::statusSingle) {
m_highSpeedMode = ewol::Widget::Scroll::speedModeDisable;
m_highSpeedMode = ewol::widget::Scroll::speedModeDisable;
m_highSpeedType = ewol::key::typeUnknow;
m_highSpeedButton = -1;
markToRedraw();
@ -216,7 +216,7 @@ bool ewol::Widget::WidgetScrolled::onEventInput(const ewol::event::Input& _event
return true;
} else if (_event.getStatus() == ewol::key::statusUp) {
return true;
} else if ( m_highSpeedMode == ewol::Widget::Scroll::speedModeInit
} else if ( m_highSpeedMode == ewol::widget::Scroll::speedModeInit
&& _event.getStatus() == ewol::key::statusMove) {
// wait that the cursor move more than 10 px to enable it :
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 :
// select the direction :
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()) {
m_highSpeedMode = ewol::Widget::Scroll::speedModeEnableHorizontal;
m_highSpeedMode = ewol::widget::Scroll::speedModeEnableHorizontal;
} else {
float coef = (relativePos.y() - m_highSpeedStartPos.y()) / (relativePos.x() - m_highSpeedStartPos.x());
if (abs(coef) <= 1 ) {
m_highSpeedMode = ewol::Widget::Scroll::speedModeEnableHorizontal;
m_highSpeedMode = ewol::widget::Scroll::speedModeEnableHorizontal;
} 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()));
} else {
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)));
return true;
}
if ( m_highSpeedMode == ewol::Widget::Scroll::speedModeEnableHorizontal
if ( m_highSpeedMode == ewol::widget::Scroll::speedModeEnableHorizontal
&& _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(etk_avg(0, m_originScrooled.x(), (m_maxSize.x() - m_size.x()*m_limitScrolling)));
markToRedraw();
return true;
}
if ( m_highSpeedMode == ewol::Widget::Scroll::speedModeEnableVertical
if ( m_highSpeedMode == ewol::widget::Scroll::speedModeEnableVertical
&& _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(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) {
EWOL_VERBOSE("event 1 " << _event);
if (_event.getStatus() == ewol::key::statusDown) {
m_highSpeedMode = ewol::Widget::Scroll::speedModeInit;
m_highSpeedMode = ewol::widget::Scroll::speedModeInit;
m_highSpeedType = ewol::key::typeFinger;
m_highSpeedStartPos.setValue(relativePos.x(), relativePos.y());
EWOL_VERBOSE("SCROOL == > INIT");
return true;
} else if (_event.getStatus() == ewol::key::statusUpAfter) {
m_highSpeedMode = ewol::Widget::Scroll::speedModeDisable;
m_highSpeedMode = ewol::widget::Scroll::speedModeDisable;
m_highSpeedType = ewol::key::typeUnknow;
EWOL_VERBOSE("SCROOL == > DISABLE");
markToRedraw();
return true;
} else if ( m_highSpeedMode == ewol::Widget::Scroll::speedModeInit
} else if ( m_highSpeedMode == ewol::widget::Scroll::speedModeInit
&& _event.getStatus() == ewol::key::statusMove) {
// wait that the cursor move more than 10 px to enable it :
if( abs(relativePos.x() - m_highSpeedStartPos.x()) > 10
|| abs(relativePos.y() - m_highSpeedStartPos.y()) > 10 ) {
// the scrooling can start :
// select the direction :
m_highSpeedMode = ewol::Widget::Scroll::speedModeEnableFinger;
m_highSpeedMode = ewol::widget::Scroll::speedModeEnableFinger;
EWOL_DEBUG("SCROOL == > ENABLE");
markToRedraw();
}
return true;
} if ( m_highSpeedMode == ewol::Widget::Scroll::speedModeEnableFinger
} if ( m_highSpeedMode == ewol::widget::Scroll::speedModeEnableFinger
&& _event.getStatus() == ewol::key::statusMove) {
//m_originScrooled.x = (int32_t)(m_maxSize.x * x / m_size.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();
return true;
}
} else if ( m_highSpeedMode == ewol::Widget::Scroll::speedModeDisable
} else if ( m_highSpeedMode == ewol::widget::Scroll::speedModeDisable
&& _event.getStatus() == ewol::key::statusLeave) {
m_highSpeedMode = ewol::Widget::Scroll::speedModeDisable;
m_highSpeedMode = ewol::widget::Scroll::speedModeDisable;
m_highSpeedType = ewol::key::typeUnknow;
EWOL_VERBOSE("SCROOL == > DISABLE");
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_shaperV.draw();
}
void ewol::Widget::WidgetScrolled::systemDraw(const ewol::DrawProperty& _displayProp) {
void ewol::widget::WidgetScrolled::systemDraw(const ewol::DrawProperty& _displayProp) {
ewol::openGL::push();
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
@ -437,7 +437,7 @@ void ewol::Widget::WidgetScrolled::systemDraw(const ewol::DrawProperty& _display
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) {
_borderWidth.setValue(m_size.x() / 2 - _borderWidth.x(),
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;
if (m_scroollingMode == scroolModeGame) {
// 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) {
return;
}

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

@ -38,16 +38,7 @@ ewol::widget::Windows::Windows() :
}
ewol::widget::Windows::~Windows() {
if (NULL != m_subWidget) {
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_subWidget.reset();
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
vec2 relativePos = relativePosition(_pos);
// 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) {
if (m_subWidget != NULL) {
EWOL_INFO("Remove current main windows Widget...");
delete(m_subWidget);
m_subWidget = NULL;
m_subWidget.reset();
}
m_subWidget = _widget;
// 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)
{
ewol::Widget::StdPopUp* tmpPopUp = new widget::StdPopUp();
ewol::widget::StdPopUp* tmpPopUp = new widget::StdPopUp();
if (tmpPopUp == NULL) {
EWOL_ERROR("Can not create a simple pop-up");
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::Sizer(ewol::Widget::Sizer::modeVert) {
ewol::widget::Sizer(ewol::widget::Sizer::modeVert) {
addObjectType("ewol::widget::ColorChooser");
addEventId(eventChange);
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 :
ewol::widget::Sizer::onObjectRemove(_removeObject);
// 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"
const char * const ewol::Widget::FileChooser::eventCancel = "cancel";
const char * const ewol::Widget::FileChooser::eventValidate = "validate";
const char * const ewol::widget::FileChooser::eventCancel = "cancel";
const char * const ewol::widget::FileChooser::eventValidate = "validate";
static const char * const ewolEventFileChooserHidenFileChange = "ewol-event-file-chooser-Show/Hide-hiden-Files";
static const char * const ewolEventFileChooserEntryFolder = "ewol-event-file-chooser-modify-entry-folder";
@ -44,8 +44,8 @@ static const char * const ewolEventFileChooserListFileValidate = "ewol-event-fil
static const char * const ewolEventFileChooserHome = "ewol-event-file-chooser-home";
ewol::Widget::FileChooser::FileChooser() {
addObjectType("ewol::Widget::FileChooser");
ewol::widget::FileChooser::FileChooser() {
addObjectType("ewol::widget::FileChooser");
addEventId(eventCancel);
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);
}
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);
}
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);
}
void ewol::Widget::FileChooser::setFolder(const std::string& _folder) {
void ewol::widget::FileChooser::setFolder(const std::string& _folder) {
m_folder = _folder + "/";
updateCurrentFolder();
}
void ewol::Widget::FileChooser::setFileName(const std::string& _filename) {
void ewol::widget::FileChooser::setFileName(const std::string& _filename) {
m_file = _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);
if (_msg.getMessage() == ewolEventFileChooserEntryFolder) {
// == > change the folder name
@ -202,7 +202,7 @@ void ewol::Widget::FileChooser::onReceiveMessage(const ewol::object::Message& _m
return;
};
void ewol::Widget::FileChooser::updateCurrentFolder() {
void ewol::widget::FileChooser::updateCurrentFolder() {
if (m_folder != "" ) {
if (m_folder[m_folder.size()-1] != '/') {
m_folder += "/";
@ -214,7 +214,7 @@ void ewol::Widget::FileChooser::updateCurrentFolder() {
markToRedraw();
}
std::string ewol::Widget::FileChooser::getCompleateFileName() {
std::string ewol::widget::FileChooser::getCompleateFileName() {
std::string tmpString = m_folder;
tmpString += "/";
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 :
* [code style=c++]
* ewol::Widget::FileChooser* tmpWidget = new ewol::Widget::FileChooser();
* ewol::widget::FileChooser* tmpWidget = new ewol::Widget::FileChooser();
* if (tmpWidget == NULL) {
* APPL_ERROR("Can not open File chooser !!! ");
* return -1;

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

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

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

@ -26,7 +26,7 @@ namespace ewol {
/**
* @ingroup ewolWidgetGroup
*/
class Parameter : public ewol::Widget::PopUp {
class Parameter : public ewol::widget::PopUp {
public:
// Event list of properties
static const char * const eventClose;
@ -38,15 +38,15 @@ namespace ewol {
virtual void onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject);
public:
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 menuClear();
void menuSeparator();
private:
int32_t m_currentIdList;
ewol::widget::Label* m_widgetTitle;
ewol::Widget::ParameterList* m_paramList;
ewol::Widget::WSlider* m_wSlider;
int32_t m_currentIdList;
ewol::object::Shared<ewol::widget::Label> m_widgetTitle;
ewol::object::Shared<ewol::widget::ParameterList> m_paramList;
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/widget/Manager.h>
const char * const ewol::Widget::ParameterList::eventSelect = "select";
const char * const ewol::widget::ParameterList::eventSelect = "select";
#undef __class__
#define __class__ "List"
ewol::Widget::ParameterList::ParameterList() {
addObjectType("ewol::Widget::ParameterList");
ewol::widget::ParameterList::ParameterList() {
addObjectType("ewol::widget::ParameterList");
addEventId(eventSelect);
m_idSelected = -1;
@ -35,7 +35,7 @@ ewol::Widget::ParameterList::ParameterList() {
setCanHaveFocus(true);
}
ewol::Widget::ParameterList::~ParameterList() {
ewol::widget::ParameterList::~ParameterList() {
//clean all the object
for (size_t iii=0; iii<m_listOObject.size(); iii++) {
delete(m_listOObject[iii]);
@ -45,7 +45,7 @@ ewol::Widget::ParameterList::~ParameterList() {
menuClear();
}
void ewol::Widget::ParameterList::calculateMinMaxSize() {
void ewol::widget::ParameterList::calculateMinMaxSize() {
/*int32_t fontId = getDefaultFontId();
int32_t minWidth = ewol::getWidth(fontId, m_label);
int32_t minHeight = ewol::getHeight(fontId);
@ -55,7 +55,7 @@ void ewol::Widget::ParameterList::calculateMinMaxSize() {
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) {
EWOL_ERROR("Try to add an empty object in the Widget generic display system");
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++) {
delete(m_listOObject[iii]);
m_listOObject[iii] = NULL;
@ -75,7 +75,7 @@ void ewol::Widget::ParameterList::clearOObjectList() {
m_listOObject.clear();
}
void ewol::Widget::ParameterList::onDraw() {
void ewol::widget::ParameterList::onDraw() {
for (size_t iii=0; iii<m_listOObject.size(); iii++) {
if (NULL != m_listOObject[iii]) {
m_listOObject[iii]->draw();
@ -84,7 +84,7 @@ void ewol::Widget::ParameterList::onDraw() {
WidgetScrolled::onDraw();
}
void ewol::Widget::ParameterList::onRegenerateDisplay() {
void ewol::widget::ParameterList::onRegenerateDisplay() {
if (true == needRedraw()) {
// clean the object list ...
clearOObjectList();
@ -162,12 +162,12 @@ void ewol::Widget::ParameterList::onRegenerateDisplay() {
addOObject(tmpDraw, 0);
// 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)) {
keepFocus();
// nothing to do ... done on upper widet ...
@ -200,16 +200,16 @@ bool ewol::Widget::ParameterList::onEventInput(const ewol::event::Input& _event)
return false;
}
void ewol::Widget::ParameterList::onGetFocus() {
void ewol::widget::ParameterList::onGetFocus() {
EWOL_DEBUG("Ewol::List get focus");
}
void ewol::Widget::ParameterList::onLostFocus() {
void ewol::widget::ParameterList::onLostFocus() {
EWOL_DEBUG("Ewol::List Lost focus");
}
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);
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);
if (NULL != tmpEmement) {
m_list.push_back(tmpEmement);
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 = "";
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) {
m_list.push_back(tmpEmement);
markToRedraw();
}
}
void ewol::Widget::ParameterList::menuClear() {
void ewol::widget::ParameterList::menuClear() {
m_idSelected = -1;
for (size_t iii=0; iii<m_list.size(); iii++) {
if (NULL != m_list[iii]) {
@ -239,7 +239,7 @@ void ewol::Widget::ParameterList::menuClear() {
m_list.clear();
}
void ewol::Widget::ParameterList::menuSeparator() {
void ewol::widget::ParameterList::menuSeparator() {
if (m_list.size()>0) {
std::string label = "";
std::string image = "";

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

@ -36,13 +36,13 @@ namespace ewol {
/**
* @ingroup ewolWidgetGroup
*/
class ParameterList :public ewol::Widget::WidgetScrolled {
class ParameterList :public ewol::widget::WidgetScrolled {
public:
// Event list of properties
static const char * const eventSelect;
private:
int32_t m_idSelected;
std::vector<ewol::Widget::elementPL *> m_list;
std::vector<ewol::widget::elementPL *> m_list;
public:
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";
ewol::Widget::StdPopUp::StdPopUp() :
ewol::widget::StdPopUp::StdPopUp() :
m_title(NULL),
m_comment(NULL),
m_subBar(NULL) {
addObjectType("ewol::Widget::StdPopUp");
addObjectType("ewol::widget::StdPopUp");
setMinSize(ewol::Dimension(vec2(20,10),ewol::Dimension::Pourcent));
ewol::widget::Sizer* mySizerVert = NULL;
ewol::Widget::Spacer* mySpacer = NULL;
ewol::widget::Spacer* mySpacer = NULL;
mySizerVert = new ewol::widget::Sizer(widget::Sizer::modeVert);
// 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->lockExpand(bvec2(true,true));
m_subBar->setExpand(bvec2(true,false));
mySizerVert->subWidgetAdd(m_subBar->get());
mySpacer = new ewol::Widget::Spacer();
mySizerVert->subWidgetAdd(m_subBar.get());
mySpacer = new ewol::widget::Spacer();
mySpacer->setExpand(bvec2(true,false));
m_subBar->subWidgetAdd(mySpacer);
mySpacer = new ewol::Widget::Spacer();
mySpacer = new ewol::widget::Spacer();
mySpacer->setExpand(bvec2(true,false));
mySpacer->setColor(etk::Color<>(0x888888FF));
mySpacer->setMinSize(ewol::Dimension(vec2(0,3),ewol::Dimension::Pixel));
mySizerVert->subWidgetAdd(mySpacer);
mySpacer = new ewol::Widget::Spacer();
mySpacer = new ewol::widget::Spacer();
mySpacer->setExpand(bvec2(true,false));
mySpacer->setMinSize(ewol::Dimension(vec2(0,5),ewol::Dimension::Pixel));
mySizerVert->subWidgetAdd(mySpacer);
m_comment = new ewol::widget::Label("No Label");
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->setMinSize(ewol::Dimension(vec2(0,5),ewol::Dimension::Pixel));
mySizerVert->subWidgetAdd(mySpacer);
mySpacer = new ewol::Widget::Spacer();
mySpacer = new ewol::widget::Spacer();
mySpacer->setExpand(bvec2(true,false));
mySpacer->setColor(etk::Color<>(0x888888FF));
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->setExpand(bvec2(true,false));
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) {
return;
}
@ -84,7 +84,7 @@ void ewol::Widget::StdPopUp::setTitle(const std::string& _text) {
markToRedraw();
}
void ewol::Widget::StdPopUp::setComment(const std::string& _text) {
void ewol::widget::StdPopUp::setComment(const std::string& _text) {
if (m_comment == NULL) {
return;
}
@ -92,7 +92,7 @@ void ewol::Widget::StdPopUp::setComment(const std::string& _text) {
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) {
EWOL_ERROR("button-bar does not existed ...");
return NULL;
@ -111,9 +111,9 @@ ewol::object::Shared<ewol::widget::Button> ewol::Widget::StdPopUp::addButton(con
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:
ewol::Widget::PopUp::onObjectRemove(_removeObject);
ewol::widget::PopUp::onObjectRemove(_removeObject);
if (_removeObject == m_subBar) {
m_subBar = NULL;
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:
ewol::Widget::PopUp::onReceiveMessage(_msg);
ewol::widget::PopUp::onReceiveMessage(_msg);
if (_msg.getMessage() == eventButtonExit) {
autoDestroy();
}

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

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