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

[DEV] try factorise Button code

Browse Source
This commit is contained in:
Edouard DUPIN 2014-01-23 21:12:54 +01:00
parent dbd7e1a401
commit 726135ff8c
10 changed files with 523 additions and 253 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
data/fontDistanceField/font1.frag
View File

@ -1,6 +1,7 @@
#ifdef GL_ES
precision mediump float;
precision mediump int;
#extension GL_OES_standard_derivatives : enable
#endif
// Input :
@ -24,11 +25,7 @@ vec3 glow_color = vec3(0.0,0.0,0.0);
void main(void) {
vec4 color = texture2D(EW_texID, f_texcoord );
float dist = color.r;
#ifndef GL_ES
float width = fwidth(dist);
#else
float width = dist;
#endif
float alpha = smoothstep(f_glyphLevel-width, f_glyphLevel+width, dist);
// Smooth

7
data/texturedDF.frag
View File

@ -1,6 +1,7 @@
#ifdef GL_ES
precision mediump float;
precision mediump int;
#extension GL_OES_standard_derivatives : enable
#endif
// Input :
@ -16,15 +17,9 @@ varying vec4 f_color;
void main(void) {
vec4 color = texture2D(EW_texID, f_texcoord );
float dist = color.r;
#ifndef GL_ES
float width = fwidth(dist);
#else
// float width = abs(dFdx(dist)) + abs(dFdy(dist))
float width = dist;
#endif
float alpha = smoothstep(0.5-width, 0.5+width, dist);
// Smooth
gl_FragColor = vec4(f_color[0], f_color[1], f_color[2], f_color[3]*alpha);
}

48
sources/ewol/Padding.h Normal file
View File

@ -0,0 +1,48 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license BSD v3 (see license file)
*/
#ifndef __EWOL_PADDING_H__
#define __EWOL_PADDING_H__
#include <ewol/debug.h>
namespace ewol {
class Padding {
private:
float value[4];
public:
Padding(void) { }
Padding(float _xl, float _yt=0, float _xr=0, float _yb=0) {
value[0] = _xl;
value[1] = _yt;
value[2] = _xr;
value[3] = _yb;
}
float x(void) const {
return value[0] + value[2];
}
float y(void) const {
return value[1] + value[3];
}
float xLeft(void) const {
return value[0];
}
float xRight(void) const {
return value[2];
}
float yTop(void) const {
return value[1];
}
float yButtom(void) const {
return value[3];
}
};
};
#endif

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

@ -52,9 +52,6 @@ ewol::widget::Button::Button(const std::string& _shaperName) :
m_selectableAreaPos(0,0),
m_selectableAreaSize(0,0) {
addObjectType("ewol::widget::Button");
// by default set no widget :
m_subWidget[0] = NULL;
m_subWidget[1] = NULL;
// add basic Event generated :
addEventId(eventPressed);
addEventId(eventDown);
@ -88,126 +85,31 @@ void ewol::widget::Button::setShaperName(const std::string& _shaperName) {
markToRedraw();
}
void ewol::widget::Button::setSubWidget(ewol::Widget* _subWidget) {
int32_t idWidget=0;
if (NULL!=m_subWidget[idWidget]) {
m_subWidget[idWidget]->removeObject();
m_subWidget[idWidget]=NULL;
}
EWOL_VERBOSE("Add button : " << idWidget << " element : " << (int64_t)_subWidget);
m_subWidget[idWidget] = _subWidget;
// element change ... We need to recalculate all the subElments :
requestUpdateSize();
markToRedraw();
}
void ewol::widget::Button::setSubWidgetToggle(ewol::Widget* _subWidget) {
int32_t idWidget=1;
if (NULL!=m_subWidget[idWidget]) {
m_subWidget[idWidget]->removeObject();
m_subWidget[idWidget]=NULL;
}
EWOL_VERBOSE("Add button : " << idWidget << " element : " << (int64_t)_subWidget);
m_subWidget[idWidget] = _subWidget;
// element change ... We need to recalculate all the subElments :
requestUpdateSize();
}
void ewol::widget::Button::calculateSize(const vec2& _availlable) {
vec2 padding = m_shaper.getPadding();
// set minimal size
m_size = m_minSize;
/*
if (m_origin.x()<0) {
EWOL_ERROR("[" << getId() << "] position error ori=" << m_origin << " size=" << m_size);
etk::displayBacktrace();
}
*/
vec2 minimumSizeBase(0,0);
vec2 minimumSizeToggle(0,0);
// Checking the expand properties :
if (m_userExpand.x() == true) {
m_size.setX(_availlable.x());
}
if (m_userExpand.y() == true) {
m_size.setY(_availlable.y());
}
// Checkin the filling properties == > for the subElements:
vec2 subElementSize = m_minSize;
if (m_userFill.x() == true) {
subElementSize.setX(m_size.x());
}
if (m_userFill.y() == true) {
subElementSize.setY(m_size.y());
}
vec2 origin = (m_size - subElementSize)/2.0f + padding;
subElementSize -= padding*2.0f;
if (NULL!=m_subWidget[0]) {
m_subWidget[0]->setOrigin(m_origin+origin);
m_subWidget[0]->calculateSize(subElementSize);
}
if (NULL!=m_subWidget[1]) {
m_subWidget[1]->setOrigin(m_origin+origin);
m_subWidget[1]->calculateSize(subElementSize);
}
ewol::Padding ret = calculateSizePadded(_availlable, ewol::Padding(padding.x(), padding.y(), padding.x(), padding.y()));
//EWOL_DEBUG(" configuring : origin=" << origin << " size=" << subElementSize << "");
m_selectableAreaSize = subElementSize + (padding*2.0f);
m_selectableAreaPos = origin-padding;
markToRedraw();
/*
m_selectableAreaSize = m_size;// - (padding*2.0f);
m_selectableAreaPos = vec2(0,0);//vec2(ret.xLeft(), ret.yButtom())-padding;
*/
m_selectableAreaSize = vec2(ret.xRight(), ret.yButtom());
m_selectableAreaPos = vec2(ret.xLeft(), ret.yTop());
}
void ewol::widget::Button::calculateMinMaxSize(void) {
vec2 padding = m_shaper.getPadding();
vec2 minimumSizeBase(0,0);
vec2 minimumSizeToggle(0,0);
if (NULL!=m_subWidget[0]) {
m_subWidget[0]->calculateMinMaxSize();
minimumSizeBase = m_subWidget[0]->getCalculateMinSize();
}
if (NULL!=m_subWidget[1]) {
m_subWidget[1]->calculateMinMaxSize();
minimumSizeToggle = m_subWidget[1]->getCalculateMinSize();
}
// get the maxixmum min size of the 2 sub-widget (if they are present indeed):
m_minSize.setX(etk_max(minimumSizeBase.x(), minimumSizeToggle.x()) );
m_minSize.setY(etk_max(minimumSizeBase.y(), minimumSizeToggle.y()) );
// add padding :
m_minSize += padding*2.0f;
// verify the min max of the min size ...
checkMinSize();
//EWOL_ERROR("[" << getId() << "] {" << getObjectType() << "} Result min size : " << m_minSize);
markToRedraw();
calculateMinMaxSizePadded(ewol::Padding(padding.x(), padding.y(), padding.x(), padding.y()));
}
void ewol::widget::Button::systemDraw(const ewol::DrawProperty& _displayProp) {
if (true == m_hide){
// widget is hidden ...
return;
}
ewol::Widget::systemDraw(_displayProp);
// draw the widget that need something ...
if( m_toggleMode == false
|| m_value == false
|| m_subWidget[1] == NULL) {
if (m_subWidget[0] != NULL) {
m_subWidget[0]->systemDraw(_displayProp);
}
} else {
if (m_subWidget[1] != NULL) {
m_subWidget[1]->systemDraw(_displayProp);
}
}
}
void ewol::widget::Button::onDraw(void) {
// draw the shaaper (if needed indeed)
m_shaper.draw();
}
void ewol::widget::Button::onRegenerateDisplay(void) {
ewol::widget::Container2::onRegenerateDisplay();
if (true == needRedraw()) {
vec2 padding = m_shaper.getPadding();
m_shaper.clear();
@ -216,17 +118,6 @@ void ewol::widget::Button::onRegenerateDisplay(void) {
m_shaper.setInsidePos(vec2ClipInt32(m_selectableAreaPos+padding));
m_shaper.setInsideSize(vec2ClipInt32(m_selectableAreaSize-padding*2.0f));
}
if( false == m_toggleMode
|| false == m_value
|| NULL == m_subWidget[1]) {
if (NULL!=m_subWidget[0]) {
m_subWidget[0]->onRegenerateDisplay();
}
} else {
if (NULL!=m_subWidget[1]) {
m_subWidget[1]->onRegenerateDisplay();
}
}
}
void ewol::widget::Button::setLock(enum buttonLock _lock) {
@ -244,6 +135,13 @@ void ewol::widget::Button::setLock(enum buttonLock _lock) {
void ewol::widget::Button::setValue(bool _val) {
if (m_value != _val) {
m_value = _val;
if (m_toggleMode == true) {
if (m_value == false) {
m_idWidgetDisplayed = 0;
} else {
m_idWidgetDisplayed = 1;
}
}
CheckStatus();
markToRedraw();
}
@ -256,6 +154,15 @@ void ewol::widget::Button::setToggleMode(bool _togg) {
m_value = false;
// TODO : change display and send event ...
}
if (m_toggleMode == false) {
m_idWidgetDisplayed = 0;
} else {
if (m_value == false) {
m_idWidgetDisplayed = 0;
} else {
m_idWidgetDisplayed = 1;
}
}
CheckStatus();
markToRedraw();
}
@ -310,14 +217,14 @@ bool ewol::widget::Button::onEventInput(const ewol::event::Input& _event) {
// user might set himself the new correct value with @ref setValue(xxx)
} else {
// inverse value :
m_value = (m_value)?false:true;
setValue((m_value)?false:true);
EWOL_VERBOSE(getName() << " : Generate event : " << eventPressed);
generateEventId(eventPressed);
EWOL_VERBOSE(getName() << " : Generate event : " << eventValue << " val=" << m_value );
generateEventId(eventValue, std::to_string(m_value));
if( false == m_toggleMode
&& true == m_value) {
m_value = false;
setValue(false);
EWOL_VERBOSE(getName() << " : Generate event : " << ewol::widget::Button::eventValue << " val=" << m_value);
generateEventId(eventValue, std::to_string(m_value));
}
@ -377,80 +284,8 @@ void ewol::widget::Button::periodicCall(const ewol::event::Time& _event) {
}
ewol::Widget* ewol::widget::Button::getWidgetNamed(const std::string& _widgetName) {
ewol::Widget* tmpUpperWidget = ewol::Widget::getWidgetNamed(_widgetName);
if (NULL!=tmpUpperWidget) {
return tmpUpperWidget;
}
if (m_subWidget[0]!= NULL) {
ewol::Widget* tmpWidget = m_subWidget[0]->getWidgetNamed(_widgetName);
if (NULL != tmpWidget) {
return tmpWidget;
}
}
if (m_subWidget[1]!= NULL) {
ewol::Widget* tmpWidget = m_subWidget[1]->getWidgetNamed(_widgetName);
if (NULL != tmpWidget) {
return tmpWidget;
}
}
return NULL;
}
bool ewol::widget::Button::loadXML(exml::Element* _element) {
if (NULL == _element) {
return false;
}
// parse generic properties :
ewol::Widget::loadXML(_element);
// remove previous element :
setSubWidget(NULL);
setSubWidgetToggle(NULL);
// parse all the elements :
for(size_t iii=0; iii< _element->size(); iii++) {
exml::Element* pNode = _element->getElement(iii);
if (pNode == NULL) {
// trash here all that is not element
continue;
}
std::string widgetName = pNode->getValue();
if (getWidgetManager().exist(widgetName) == false) {
EWOL_ERROR("(l "<<pNode->getPos()<<") Unknown basic node=\"" << widgetName << "\" not in : [" << getWidgetManager().list() << "]" );
continue;
}
bool toogleMode=false;
if (NULL != getSubWidget()) {
toogleMode=true;
if (NULL != getSubWidgetToggle()) {
EWOL_ERROR("(l "<<pNode->getPos()<<") " << __class__ << " Can only have one subWidget ??? node=\"" << widgetName << "\"" );
continue;
}
}
EWOL_DEBUG("try to create subwidget : '" << widgetName << "'");
ewol::Widget* tmpWidget = getWidgetManager().create(widgetName);
if (tmpWidget == NULL) {
EWOL_ERROR ("(l "<<pNode->getPos()<<") Can not create the widget : \"" << widgetName << "\"");
continue;
}
// add widget :
if (toogleMode == false) {
setSubWidget(tmpWidget);
} else {
setToggleMode(true);
setSubWidgetToggle(tmpWidget);
}
if (false == tmpWidget->loadXML(pNode)) {
EWOL_ERROR ("(l "<<pNode->getPos()<<") can not load widget properties : \"" << widgetName << "\"");
return false;
}
}
return true;
}
bool ewol::widget::Button::onSetConfig(const ewol::object::Config& _conf) {
if (true == ewol::Widget::onSetConfig(_conf)) {
if (true == ewol::widget::Container2::onSetConfig(_conf)) {
return true;
}
if (_conf.getConfig() == configToggle) {
@ -484,7 +319,7 @@ bool ewol::widget::Button::onSetConfig(const ewol::object::Config& _conf) {
}
bool ewol::widget::Button::onGetConfig(const char* _config, std::string& _result) const {
if (true == ewol::Widget::onGetConfig(_config, _result)) {
if (true == ewol::widget::Container2::onGetConfig(_config, _result)) {
return true;
}
if (_config == configToggle) {

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

@ -12,7 +12,7 @@
#include <etk/types.h>
#include <ewol/debug.h>
#include <ewol/widget/Widget.h>
#include <ewol/widget/Container2.h>
#include <ewol/compositing/Text.h>
#include <ewol/compositing/Image.h>
#include <ewol/compositing/Shaper.h>
@ -25,7 +25,7 @@ namespace ewol {
* @brief a composed button is a button with an inside composed with the specify XML element
* ==> this permit to generate standard element simple
*/
class Button : public ewol::Widget {
class Button : public ewol::widget::Container2 {
public:
//! @not-in-doc
static void init(ewol::widget::Manager& _widgetManager);
@ -64,33 +64,6 @@ namespace ewol {
* @param[in] _shaperName The new shaper filename
*/
void setShaperName(const std::string& _shaperName);
protected:
ewol::Widget* m_subWidget[2]; //!< subwidget of the button
public:
/**
* @brief Specify the current widget
* @param[in] _subWidget Widget to add normal
*/
void setSubWidget(ewol::Widget* _subWidget);
/**
* @brief Specify the current widget
* @param[in] _subWidget Widget to add Toggle
*/
void setSubWidgetToggle(ewol::Widget* _subWidget);
/**
* @brief get the current displayed composition
* @return The base widget
*/
ewol::Widget* getSubWidget(void) const {
return m_subWidget[0];
};
/**
* @brief get the current displayed composition
* @return The toggle widget
*/
ewol::Widget* getSubWidgetToggle(void) const {
return m_subWidget[1];
};
protected:
bool m_value; //!< Current state of the button.
public:
@ -162,11 +135,11 @@ namespace ewol {
virtual void calculateMinMaxSize(void);
virtual void calculateSize(const vec2& _availlable);
virtual void onRegenerateDisplay(void);
virtual void systemDraw(const ewol::DrawProperty& _displayProp);
virtual bool onEventInput(const ewol::event::Input& _event);
virtual bool onEventEntry(const ewol::event::Entry& _event);
virtual bool loadXML(exml::Element* _node);
virtual ewol::Widget* getWidgetNamed(const std::string& _widgetName);
virtual void onDetectPresenceToggleWidget(void) {
setToggleMode(true);
}
private: // derived function
virtual void periodicCall(const ewol::event::Time& _event);
};

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

@ -44,19 +44,6 @@ void ewol::widget::Container::setSubWidget(ewol::Widget* _newWidget) {
}
void ewol::widget::Container::subWidgetRemove(void) {
if (NULL != m_subWidget) {
m_subWidget->removeUpperWidget();
delete(m_subWidget);
// might have been destroy first here :
if (m_subWidget!=NULL) {
EWOL_ERROR("Composer : An error Occured when removing main node");
}
markToRedraw();
requestUpdateSize();
}
}
void ewol::widget::Container::subWidgetRemoveDelayed(void) {
if (NULL != m_subWidget) {
m_subWidget->removeUpperWidget();
m_subWidget->removeObject();
@ -66,6 +53,13 @@ void ewol::widget::Container::subWidgetRemoveDelayed(void) {
}
}
void ewol::widget::Container::subWidgetUnLink(void) {
if (NULL != m_subWidget) {
m_subWidget->removeUpperWidget();
}
m_subWidget=NULL;
}
ewol::Widget* ewol::widget::Container::getWidgetNamed(const std::string& _widgetName) {
ewol::Widget* tmpUpperWidget = ewol::Widget::getWidgetNamed(_widgetName);
if (NULL!=tmpUpperWidget) {
@ -160,7 +154,7 @@ bool ewol::widget::Container::loadXML(exml::Element* _node) {
// parse generic properties :
ewol::Widget::loadXML(_node);
// remove previous element :
subWidgetRemoveDelayed();
subWidgetRemove();
// parse all the elements :
for(size_t iii=0; iii< _node->size(); iii++) {

6
sources/ewol/widget/Container.h
View File

@ -43,13 +43,13 @@ namespace ewol {
*/
void setSubWidget(ewol::Widget* _newWidget);
/**
* @brief remove the subWidget node.
* @brief remove the subWidget node (async).
*/
void subWidgetRemove(void);
/**
* @brief remove the subWidget node (delayed to prevent remove in the callbback).
* @brief Unlink the subwidget Node.
*/
virtual void subWidgetRemoveDelayed(void);
void subWidgetUnLink(void);
public: // Derived function
virtual void systemDraw(const ewol::DrawProperty& _displayProp);

268
sources/ewol/widget/Container2.cpp Normal file
View File

@ -0,0 +1,268 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license BSD v3 (see license file)
*/
#include <ewol/ewol.h>
#include <ewol/widget/Container2.h>
#include <ewol/widget/Manager.h>
#undef __class__
#define __class__ "Container2"
ewol::widget::Container2::Container2(ewol::Widget* _subElement, ewol::Widget* _subElementToggle) :
m_idWidgetDisplayed(0) {
m_subWidget[0] = _subElement;
m_subWidget[1] = _subElementToggle;
addObjectType("ewol::widget::Container2");
// nothing to do ...
}
ewol::widget::Container2::~Container2(void) {
subWidgetRemove();
subWidgetRemoveToggle();
}
void ewol::widget::Container2::setSubWidget(ewol::Widget* _newWidget, int32_t _idWidget) {
subWidgetRemove(_idWidget);
m_subWidget[_idWidget] = _newWidget;
if (m_subWidget[_idWidget] != NULL) {
EWOL_VERBOSE("Add widget : " << _idWidget);
m_subWidget[_idWidget]->setUpperWidget(this);
}
markToRedraw();
requestUpdateSize();
}
void ewol::widget::Container2::subWidgetRemove(int32_t _idWidget) {
if (m_subWidget[_idWidget] != NULL) {
EWOL_VERBOSE("Remove widget : " << _idWidget);
m_subWidget[_idWidget]->removeUpperWidget();
m_subWidget[_idWidget]->removeObject();
m_subWidget[_idWidget] = NULL;
markToRedraw();
requestUpdateSize();
}
}
void ewol::widget::Container2::subWidgetUnLink(int32_t _idWidget) {
if (m_subWidget[_idWidget] != NULL) {
m_subWidget[_idWidget]->removeUpperWidget();
EWOL_VERBOSE("Unlink widget : " << _idWidget);
}
m_subWidget[_idWidget] = NULL;
}
ewol::Widget* ewol::widget::Container2::getWidgetNamed(const std::string& _widgetName) {
ewol::Widget* tmpUpperWidget = ewol::Widget::getWidgetNamed(_widgetName);
if (tmpUpperWidget != NULL) {
return tmpUpperWidget;
}
if (m_subWidget[0] != NULL) {
return m_subWidget[0]->getWidgetNamed(_widgetName);
}
if (m_subWidget[1] != NULL) {
return m_subWidget[1]->getWidgetNamed(_widgetName);
}
return NULL;
}
void ewol::widget::Container2::onObjectRemove(ewol::Object* _removeObject) {
if (m_subWidget[0] == _removeObject) {
m_subWidget[0] = NULL;
markToRedraw();
requestUpdateSize();
}
if (m_subWidget[1] == _removeObject) {
m_subWidget[1] = NULL;
markToRedraw();
requestUpdateSize();
}
}
void ewol::widget::Container2::systemDraw(const ewol::DrawProperty& _displayProp) {
if (true == m_hide){
// widget is hidden ...
return;
}
ewol::Widget::systemDraw(_displayProp);
if (m_subWidget[m_idWidgetDisplayed] != NULL) {
m_subWidget[m_idWidgetDisplayed]->systemDraw(_displayProp);
}
}
ewol::Padding ewol::widget::Container2::calculateSizePadded(const vec2& _availlable, const ewol::Padding& _padding) {
#if 1
vec2 localAvaillable = _availlable - vec2(_padding.x(), _padding.y());
//ewol::Widget::calculateSize(_availlable);
// set minimal size
m_size = m_minSize;
if (m_userExpand.x() == true) {
m_size.setX(_availlable.x());
}
if (m_userExpand.y() == true) {
m_size.setY(_availlable.y());
}
for (size_t iii = 0; iii < 2; ++iii) {
if (m_subWidget[iii] != NULL) {
vec2 origin = m_origin+m_offset;
vec2 minSize = m_subWidget[iii]->getCalculateMinSize();
bvec2 expand = m_subWidget[iii]->getExpand();
if ( expand.x() == false
|| minSize.x()>localAvaillable.x()) {
if (m_gravity == ewol::gravityCenter) {
origin -= vec2((minSize.x() - localAvaillable.x())/2.0f, 0);
} else if (((int32_t)m_gravity & (int32_t)ewol::gravityRight) != 0) {
origin -= vec2((minSize.x() - localAvaillable.x()), 0);
}
}
if( expand.y() == false
|| minSize.y()>localAvaillable.y()) {
if (m_gravity == ewol::gravityCenter) {
origin -= vec2(0, (minSize.y() - localAvaillable.y())/2.0f);
} else if (((int32_t)m_gravity & (int32_t)ewol::gravityTop) != 0) {
origin -= vec2(0, (minSize.y() - localAvaillable.y()));
}
}
m_subWidget[iii]->setOrigin(origin + vec2(_padding.xLeft(), _padding.yButtom()));
m_subWidget[iii]->calculateSize(localAvaillable);
}
}
return ewol::Padding(m_origin.x(), 0, 0, m_origin.y());
#else
// set minimal size
m_size = m_minSize;
vec2 minimumSizeBase(0,0);
vec2 minimumSizeToggle(0,0);
// Checking the expand properties :
if (m_userExpand.x() == true) {
m_size.setX(_availlable.x());
}
if (m_userExpand.y() == true) {
m_size.setY(_availlable.y());
}
// Checkin the filling properties == > for the subElements:
vec2 subElementSize = m_minSize;
if (m_userFill.x() == true) {
subElementSize.setX(m_size.x());
}
if (m_userFill.y() == true) {
subElementSize.setY(m_size.y());
}
vec2 origin = (m_size - subElementSize)*0.5f + vec2(_padding.xLeft(), _padding.yButtom());
subElementSize -= vec2(_padding.x(), _padding.y());
if (NULL!=m_subWidget[0]) {
m_subWidget[0]->setOrigin(m_origin+origin);
m_subWidget[0]->calculateSize(subElementSize);
}
if (NULL!=m_subWidget[1]) {
m_subWidget[1]->setOrigin(m_origin+origin);
m_subWidget[1]->calculateSize(subElementSize);
}
//EWOL_DEBUG(" configuring : origin=" << origin << " size=" << subElementSize << "");
vec2 selectableAreaSize = subElementSize + vec2(_padding.x(), _padding.y());
vec2 selectableAreaPos = origin-vec2(_padding.xLeft(), _padding.yButtom());
markToRedraw();
return ewol::Padding(selectableAreaPos.x(), selectableAreaPos.y(), selectableAreaSize.x(), selectableAreaSize.y());
#endif
}
void ewol::widget::Container2::calculateMinMaxSizePadded(const ewol::Padding& _padding) {
// call main class
m_minSize = vec2(0,0);
// call sub classes
for (size_t iii = 0; iii < 2; ++iii) {
if (m_subWidget[iii] != NULL) {
m_subWidget[iii]->calculateMinMaxSize();
vec2 min = m_subWidget[iii]->getCalculateMinSize();
m_minSize.setMax(min);
}
}
// add padding :
m_minSize += vec2(_padding.x(), _padding.y());
// verify the min max of the min size ...
checkMinSize();
markToRedraw();
}
void ewol::widget::Container2::onRegenerateDisplay(void) {
if (m_subWidget[m_idWidgetDisplayed] != NULL) {
m_subWidget[m_idWidgetDisplayed]->onRegenerateDisplay();
}
}
ewol::Widget* ewol::widget::Container2::getWidgetAtPos(const vec2& _pos) {
if (isHide() == false) {
if (m_subWidget[m_idWidgetDisplayed] != NULL) {
return m_subWidget[m_idWidgetDisplayed]->getWidgetAtPos(_pos);
}
}
return NULL;
}
bool ewol::widget::Container2::loadXML(exml::Element* _node) {
if (NULL == _node) {
return false;
}
// parse generic properties :
ewol::Widget::loadXML(_node);
// remove previous element :
subWidgetRemove();
// parse all the elements :
for(size_t iii=0; iii< _node->size(); iii++) {
exml::Element* pNode = _node->getElement(iii);
if (pNode == NULL) {
// trash here all that is not element
continue;
}
std::string widgetName = pNode->getValue();
if (getWidgetManager().exist(widgetName) == false) {
EWOL_ERROR("(l "<<pNode->getPos()<<") Unknown basic node=\"" << widgetName << "\" not in : [" << getWidgetManager().list() << "]" );
continue;
}
bool toogleMode=false;
if (NULL != getSubWidget()) {
toogleMode=true;
if (NULL != getSubWidgetToggle()) {
EWOL_ERROR("(l "<<pNode->getPos()<<") " << __class__ << " Can only have one subWidget ??? node=\"" << widgetName << "\"" );
continue;
}
}
EWOL_DEBUG("try to create subwidget : '" << widgetName << "'");
ewol::Widget* tmpWidget = getWidgetManager().create(widgetName);
if (tmpWidget == NULL) {
EWOL_ERROR ("(l "<<pNode->getPos()<<") Can not create the widget : \"" << widgetName << "\"");
continue;
}
// add widget :
if (toogleMode == false) {
setSubWidget(tmpWidget);
} else {
setSubWidgetToggle(tmpWidget);
}
if (false == tmpWidget->loadXML(pNode)) {
EWOL_ERROR ("(l "<<pNode->getPos()<<") can not load widget properties : \"" << widgetName << "\"");
return false;
}
}
return true;
}
void ewol::widget::Container2::setOffset(const vec2& _newVal) {
if (m_offset != _newVal) {
ewol::Widget::setOffset(_newVal);
// recalculate the new sise and position of sub widget ...
calculateSize(m_size);
}
}

159
sources/ewol/widget/Container2.h Normal file
View File

@ -0,0 +1,159 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license BSD v3 (see license file)
*/
#ifndef __EWOL_WIDGET_CONTAINER_2_H__
#define __EWOL_WIDGET_CONTAINER_2_H__
#include <etk/types.h>
#include <ewol/debug.h>
#include <ewol/widget/Widget.h>
#include <ewol/Padding.h>
namespace ewol {
namespace widget {
/**
* @ingroup ewolWidgetGroup
* @brief the Cotainer widget is a widget that have an only one subWidget
*/
class Container2 : public ewol::Widget {
protected:
ewol::Widget* m_subWidget[2]; //!< 2 subwidget possible
int32_t m_idWidgetDisplayed; //!< current widget displayed
public:
/**
* @brief Constructor
* @param[in] _subElement Widget to set on the normal position
* @param[in] _subElementToggle Widget to set on the toggle position
*/
Container2(ewol::Widget* _subElement = NULL, ewol::Widget* _subElementToggle = NULL);
/**
* @brief Destructor
*/
~Container2(void);
private:
/**
* @brief Specify the current widget
* @param[in] _subWidget Widget to add normal
* @param[in] _idWidget Id of the widget to set
*/
void setSubWidget(ewol::Widget* _subWidget, int32_t _idWidget);
public:
/**
* @brief Specify the current widget
* @param[in] _subWidget Widget to add normal
*/
void setSubWidget(ewol::Widget* _subWidget) {
setSubWidget(_subWidget, 0);
}
/**
* @brief Specify the current toggle widget
* @param[in] _subWidget Widget to add Toggle
*/
void setSubWidgetToggle(ewol::Widget* _subWidget) {
setSubWidget(_subWidget, 1);
}
private:
/**
* @brief get the current displayed composition
* @param[in] _idWidget Id of the widget to set
* @return The base widget
*/
ewol::Widget* getSubWidget(int32_t _idWidget) const {
return m_subWidget[_idWidget];
};
public:
/**
* @brief get the current displayed composition
* @return The base widget
*/
ewol::Widget* getSubWidget(void) const {
return getSubWidget(0);
};
/**
* @brief get the current displayed composition
* @return The toggle widget
*/
ewol::Widget* getSubWidgetToggle(void) const {
return getSubWidget(1);
};
private:
/**
* @brief remove the subWidget node (async).
* @param[in] _idWidget Id of the widget to set
*/
void subWidgetRemove(int32_t _idWidget);
public:
/**
* @brief remove the subWidget node (async).
*/
void subWidgetRemove(void) {
subWidgetRemove(0);
}
/**
* @brief remove the subWidget Toggle node (async).
*/
void subWidgetRemoveToggle(void) {
subWidgetRemove(1);
}
private:
/**
* @brief Unlink the subwidget Node.
* @param[in] _idWidget Id of the widget to set
*/
void subWidgetUnLink(int32_t _idWidget);
public:
/**
* @brief Unlink the subwidget Node.
*/
void subWidgetUnLink(void) {
subWidgetUnLink(0);
}
/**
* @brief Unlink the subwidget Toggle Node.
*/
void subWidgetUnLinkToggle(void) {
subWidgetUnLink(1);
}
protected:
/**
* @brief Parent set the possible diplay size of the current widget whith his own possibilities
* By default this save the widget available size in the widget size
* @param[in] _available Available x&y pixel size
* @param[in] _padding Padding of the widget.
* @note : INTERNAL EWOL SYSTEM
*/
virtual ewol::Padding calculateSizePadded(const vec2& _availlable, const ewol::Padding& _padding = ewol::Padding(0,0,0,0));
/**
* @brief calculate the minimum and maximum size (need to estimate expend properties of the widget)
* @param[in] _padding Padding of the widget.
* @note : INTERNAL EWOL SYSTEM
*/
virtual void calculateMinMaxSizePadded(const ewol::Padding& _padding = ewol::Padding(0,0,0,0));
/**
* @brief Called when parsing a XML and detect the presence of a second Widget
*/
virtual void onDetectPresenceToggleWidget(void) {}
public: // Derived function
virtual void systemDraw(const ewol::DrawProperty& _displayProp);
virtual void onRegenerateDisplay(void);
virtual void onObjectRemove(ewol::Object* _removeObject);
virtual void calculateSize(const vec2& _availlable) {
calculateSizePadded(_availlable);
}
virtual void calculateMinMaxSize(void) {
calculateMinMaxSizePadded();
}
virtual ewol::Widget* getWidgetAtPos(const vec2& _pos);
virtual ewol::Widget* getWidgetNamed(const std::string& _widgetName);
virtual bool loadXML(exml::Element* _node);
virtual void setOffset(const vec2& _newVal);
};
};
};
#endif

1
sources/lutin_ewol.py
View File

@ -126,6 +126,7 @@ def create(target):
'ewol/widget/ColorBar.cpp',
'ewol/widget/Composer.cpp',
'ewol/widget/Container.cpp',
'ewol/widget/Container2.cpp',
'ewol/widget/ContainerN.cpp',
'ewol/widget/ContextMenu.cpp',
'ewol/widget/Entry.cpp',