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

[DEV] step one to build

Browse Source
This commit is contained in:
Edouard DUPIN 2014-05-16 21:52:10 +02:00
parent 8740595b17
commit 227a08be18
67 changed files with 678 additions and 674 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
sources/ewol/context/Context.cpp
View File

@ -20,15 +20,17 @@
#include <ewol/Dimension.h>
#include <ewol/debug.h>
#include <ewol/translate.h>
#include <ewol/openGL/openGL.h>
#include <ewol/object/Object.h>
#include <ewol/object/Manager.h>
#include <ewol/widget/Widget.h>
#include <ewol/widget/Windows.h>
#include <ewol/widget/Manager.h>
#include <ewol/context/Context.h>
#include <ewol/resource/Manager.h>
#include <ewol/openGL/openGL.h>
#include <ewol/widget/Manager.h>
#include <ewol/translate.h>
@ -380,10 +382,10 @@ ewol::Context::~Context() {
lockContext();
// call application to uninit
APP_UnInit(*this);
if (m_windowsCurrent != NULL) {
if (m_windowsCurrent != nullptr) {
EWOL_DEBUG("Main windows has not been auto-removed...");
m_windowsCurrent->removeObject();
m_windowsCurrent = NULL;
m_windowsCurrent.reset();
}
// unset all windows
m_msgSystem.clean();
@ -648,7 +650,7 @@ bool ewol::Context::OS_Draw(bool _displayEveryTime) {
return hasDisplayDone;
}
void ewol::Context::onObjectRemove(ewol::object::Shared<ewol::Object> * _removeObject) {
void ewol::Context::onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject) {
//EWOL_CRITICAL("element removed");
m_input.onObjectRemove(_removeObject);
}
@ -663,7 +665,7 @@ void ewol::Context::OS_OpenGlContextDestroy() {
void ewol::Context::setWindows(ewol::widget::Windows* _windows) {
// remove current focus :
m_widgetManager.focusSetDefault(NULL);
m_widgetManager.focusSetDefault(nullptr);
m_widgetManager.focusRelease();
// set the new pointer as windows system
m_windowsCurrent = _windows;
@ -673,6 +675,10 @@ void ewol::Context::setWindows(ewol::widget::Windows* _windows) {
forceRedrawAll();
}
ewol::object::Shared<ewol::widget::Windows> ewol::Context::getWindows() {
return m_windowsCurrent;
};
void ewol::Context::forceRedrawAll() {
if (m_windowsCurrent == NULL) {
return;

8
sources/ewol/context/Context.h
View File

@ -158,7 +158,7 @@ namespace ewol {
*/
virtual void stop();
private:
ewol::widget::Windows* m_windowsCurrent; //!< curent displayed windows
ewol::object::Shared<ewol::widget::Windows> m_windowsCurrent; //!< curent displayed windows
public:
/**
* @brief set the current windows to display :
@ -169,9 +169,7 @@ namespace ewol {
* @brief get the current windows that is displayed
* @return the current handle on the windows (can be null)
*/
ewol::widget::Windows* getWindows() {
return m_windowsCurrent;
};
ewol::object::Shared<ewol::widget::Windows> getWindows();
private:
vec2 m_windowsSize; //!< current size of the system
public:
@ -229,7 +227,7 @@ namespace ewol {
* @param source the widget where the event came from
* @param destination the widget where the event mitgh be generated now
*/
void inputEventTransfertWidget(ewol::object::Shared<ewol::Widget> _source, ewol::Widget* _destination);
void inputEventTransfertWidget(ewol::object::Shared<ewol::Widget> _source, ewol::object::Shared<ewol::Widget> _destination);
/**
* @brief This fonction lock the pointer properties to move in relative instead of absolute
* @param[in] widget The widget that lock the pointer events

12
sources/ewol/context/InputManager.cpp
View File

@ -93,9 +93,9 @@ void ewol::context::InputManager::cleanElement(InputPoperty *_eventTable,
_eventTable[_idInput].posEvent.setValue(0,0);
}
void ewol::context::InputManager::transfertEvent(ewol::object::Shared<ewol::Widget> _source, ewol::Widget* _destination) {
if( NULL == _source
|| NULL == _destination) {
void ewol::context::InputManager::transfertEvent(ewol::object::Shared<ewol::Widget> _source, ewol::object::Shared<ewol::Widget> _destination) {
if( _source == nullptr
|| _destination == nullptr) {
// prevent errors ...
return;
}
@ -138,7 +138,7 @@ void ewol::context::InputManager::unGrabPointer() {
m_context.grabPointerEvents(false, vec2(0,0));
}
void ewol::context::InputManager::onObjectRemove(ewol::object::Shared<ewol::Object> * removeObject) {
void ewol::context::InputManager::onObjectRemove(ewol::object::Shared<ewol::Object> removeObject) {
for(int32_t iii=0; iii<MAX_MANAGE_INPUT; iii++) {
if (m_eventInputSaved[iii].curentWidgetEvent == removeObject) {
// remove the property of this input ...
@ -221,7 +221,7 @@ void ewol::context::InputManager::motion(enum ewol::key::type _type,
// not manage input
return;
}
ewol::widget::Windows* tmpWindows = m_context.getWindows();
ewol::object::Shared<ewol::widget::Windows> tmpWindows = m_context.getWindows();
// special case for the mouse event 0 that represent the hover event of the system :
if (_type == ewol::key::typeMouse && _pointerID == 0) {
// this event is all time on the good widget ... and manage the enter and leave ...
@ -358,7 +358,7 @@ void ewol::context::InputManager::state(enum ewol::key::type _type,
}
// get the curent time ...
int64_t currentTime = ewol::getTime();
ewol::widget::Windows* tmpWindows = m_context.getWindows();
ewol::object::Shared<ewol::widget::Windows> tmpWindows = m_context.getWindows();
if (true == _isDown) {
EVENT_DEBUG("GUI : Input ID=" << _pointerID

2
sources/ewol/context/InputManager.h
View File

@ -109,7 +109,7 @@ namespace ewol {
* @param _source the widget where the event came from
* @param _destination the widget where the event mitgh be generated now
*/
void transfertEvent(ewol::object::Shared<ewol::Widget> _source, ewol::Widget* _destination);
void transfertEvent(ewol::object::Shared<ewol::Widget> _source, ewol::object::Shared<ewol::Widget> _destination);
/**
* @brief This fonction lock the pointer properties to move in relative instead of absolute
* @param[in] _widget The widget that lock the pointer events

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

@ -21,30 +21,30 @@ size_t ewol::Object::m_valUID = 0;
void ewol::Object::objRefCountIncrement() {
std::scoped_lock lock(m_lockRefCount);
std::unique_lock<std::mutex> lock(m_lockRefCount);
m_objRefCount++;
}
void ewol::Object::objRefCountDecrement() {
std::scoped_lock lock(m_lockRefCount);
std::unique_lock<std::mutex> lock(m_lockRefCount);
m_objRefCount--;
}
bool ewol::Object::setRefOwner(bool _haveOwner) {
std::scoped_lock lock(m_lockRefCount);
std::unique_lock<std::mutex> lock(m_lockRefCount);
if (_haveOwner == true) {
if (m_hasReferenceOwner == true) {
EWOL_CRITICAL("Object have already an owner");
return false;;
}
m_hasReferenceOwner == true;
m_hasReferenceOwner = true;
return true;
}
if (m_hasReferenceOwner == false) {
EWOL_CRITICAL("Object have already NO owner");
return false;
}
m_hasReferenceOwner == false;
m_hasReferenceOwner = false;
return true;
}
@ -54,7 +54,7 @@ void ewol::Object::operator delete(void* _ptr, std::size_t _sz) {
obj->objRefCountDecrement();
if (obj->m_objRefCount <= 0) {
EWOL_DEBUG(" ==> real remove");
if (m_hasReferenceOwner == true) {
if (obj->m_hasReferenceOwner == true) {
EWOL_ERROR(" ==> Remove ofject that have not a reference owner removed");
}
::operator delete(_ptr);
@ -299,7 +299,8 @@ void ewol::Object::unRegisterOnEvent(ewol::object::Shared<ewol::Object> _destina
void ewol::Object::onObjectRemove(ewol::object::Shared<ewol::Object> _object) {
for(int32_t iii=m_externEvent.size()-1; iii >= 0; iii--) {
if (m_externEvent[iii].hasOwner() == false) {
if ( m_externEvent[iii] != nullptr
&& m_externEvent[iii]->destObject.hasOwner() == false) {
m_externEvent.erase(m_externEvent.begin()+iii);
}
}

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

@ -14,6 +14,9 @@
#include <vector>
#include <exml/exml.h>
#include <mutex>
#include <ewol/object/Owner.h>
#include <ewol/object/Shared.h>
namespace ewol {
// some class need to define element befor other ...
class Object;
@ -26,8 +29,6 @@ namespace ewol {
#include <ewol/object/Config.h>
#include <ewol/object/ConfigElement.h>
#include <ewol/object/Owner.h>
#include <ewol/object/Shared.h>
#include <ewol/object/Message.h>
namespace ewol {

4
sources/ewol/object/Owner.h
View File

@ -9,11 +9,11 @@
#ifndef __EWOL_OBJECT_OWNER_H__
#define __EWOL_OBJECT_OWNER_H__
#include <ewol/debug.h>
namespace ewol {
class Object;
namespace object {
template<typename T, typename = typename std::enable_if<std::is_convertible<T*, ewol::Object*>::value>::type>
template<typename T>
class Owner {
private:
T* m_pointer;

37
sources/ewol/object/Shared.h
View File

@ -9,10 +9,11 @@
#ifndef __EWOL_OBJECT_SHARED_H__
#define __EWOL_OBJECT_SHARED_H__
#include <ewol/debug.h>
namespace ewol {
class Object;
namespace object {
template<typename T, typename = typename std::enable_if<std::is_convertible<T*, Object*>::value>::type>
template<typename T>
class Shared {
private:
T* m_pointer;
@ -31,6 +32,15 @@ namespace ewol {
~Shared() {
reset();
}
// shared to private constructor
Shared(const Owner<T>& _obj) :
m_pointer(nullptr) {
m_pointer = _obj.get();
if (m_pointer == nullptr) {
return;
}
m_pointer->objRefCountIncrement();
}
// copy constructor
Shared(const Shared& _obj) :
m_pointer(nullptr) {
@ -80,9 +90,6 @@ namespace ewol {
}
m_pointer = nullptr;
}
T* get() noexcept {
return m_pointer;
}
T* get() const noexcept {
return m_pointer;
}
@ -126,6 +133,16 @@ namespace ewol {
inline bool operator==(const T* _obj, const object::Shared<T2>& _obj2) noexcept {
return _obj == _obj2.get();
}
//! @not in doc
template<typename T, typename T2>
inline bool operator==(const object::Owner<T>& _obj, const object::Shared<T2>& _obj2) noexcept {
return _obj.get() == _obj2.get();
}
//! @not in doc
template<typename T, typename T2>
inline bool operator==(const object::Shared<T>& _obj, const object::Owner<T2>& _obj2) noexcept {
return _obj.get() == _obj2.get();
}
//! @not in doc
template<typename T, typename T2>
@ -154,6 +171,16 @@ namespace ewol {
inline bool operator!=(const T* _obj, const object::Shared<T2>& _obj2) noexcept {
return _obj != _obj2.get();
}
//! @not in doc
template<typename T, typename T2>
inline bool operator!=(const object::Owner<T>& _obj, const object::Shared<T2>& _obj2) noexcept {
return _obj.get() != _obj2.get();
}
//! @not in doc
template<typename T, typename T2>
inline bool operator!=(const object::Shared<T>& _obj, const object::Owner<T2>& _obj2) noexcept {
return _obj.get() != _obj2.get();
}
//! @not in doc
template<typename T>

2
sources/ewol/resource/Manager.cpp
View File

@ -215,7 +215,7 @@ bool ewol::resource::Manager::release(ewol::Resource*& _object) {
}
// in case of error ...
void ewol::resource::Manager::onObjectRemove(ewol::object::Shared<ewol::Object> * _removeObject) {
void ewol::resource::Manager::onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject) {
for (size_t iii=0; iii<m_resourceList.size(); ++iii) {
if (m_resourceList[iii] == _removeObject) {
EWOL_WARNING("Remove Resource that is not removed ... ");

2
sources/ewol/resource/Manager.h
View File

@ -68,7 +68,7 @@ namespace ewol {
*/
bool release(ewol::Resource*& _object);
public: // herited function
virtual void onObjectRemove(ewol::object::Shared<ewol::Object> * _removeObject);
virtual void onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject);
};
};
};

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

@ -14,17 +14,17 @@
#define __class__ "Button"
const char* const ewol::Widget::Button::eventPressed = "pressed";
const char* const ewol::Widget::Button::eventDown = "down";
const char* const ewol::Widget::Button::eventUp = "up";
const char* const ewol::Widget::Button::eventEnter = "enter";
const char* const ewol::Widget::Button::eventLeave = "leave";
const char* const ewol::Widget::Button::eventValue = "value";
const char* const ewol::widget::Button::eventPressed = "pressed";
const char* const ewol::widget::Button::eventDown = "down";
const char* const ewol::widget::Button::eventUp = "up";
const char* const ewol::widget::Button::eventEnter = "enter";
const char* const ewol::widget::Button::eventLeave = "leave";
const char* const ewol::widget::Button::eventValue = "value";
const char* const ewol::Widget::Button::configToggle = "toggle";
const char* const ewol::Widget::Button::configLock = "lock";
const char* const ewol::Widget::Button::configValue = "value";
const char* const ewol::Widget::Button::configShaper = "shaper";
const char* const ewol::widget::Button::configToggle = "toggle";
const char* const ewol::widget::Button::configLock = "lock";
const char* const ewol::widget::Button::configValue = "value";
const char* const ewol::widget::Button::configShaper = "shaper";
// DEFINE for the shader display system :
@ -34,24 +34,24 @@ const char* const ewol::Widget::Button::configShaper = "shaper";
#define STATUS_DOWN (3)
static ewol::object::Shared<ewol::Widget> Create() {
return new ewol::Widget::Button();
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::object::Shared<ewol::widget::Manager> _widgetManager) {
_widgetManager->addWidgetCreator(__class__, &Create);
}
ewol::Widget::Button::Button(const std::string& _shaperName) :
ewol::widget::Button::Button(const std::string& _shaperName) :
m_shaper(_shaperName),
m_value(false),
m_lock(ewol::Widget::Button::lockNone),
m_lock(ewol::widget::Button::lockNone),
m_toggleMode(false),
m_mouseHover(false),
m_buttonPressed(false),
m_selectableAreaPos(0,0),
m_selectableAreaSize(0,0) {
addObjectType("ewol::Widget::Button");
addObjectType("ewol::widget::Button");
// add basic Event generated :
addEventId(eventPressed);
addEventId(eventDown);
@ -74,18 +74,18 @@ ewol::Widget::Button::Button(const std::string& _shaperName) :
}
ewol::Widget::Button::~Button() {
ewol::widget::Button::~Button() {
}
void ewol::Widget::Button::setShaperName(const std::string& _shaperName) {
void ewol::widget::Button::setShaperName(const std::string& _shaperName) {
EWOL_WARNING("set shaper name : '" << _shaperName << "'");
m_shaper.setSource(_shaperName);
markToRedraw();
}
void ewol::Widget::Button::calculateSize(const vec2& _availlable) {
void ewol::widget::Button::calculateSize(const vec2& _availlable) {
ewol::Padding padding = m_shaper.getPadding();
ewol::Padding ret = calculateSizePadded(_availlable, padding);
//EWOL_DEBUG(" configuring : origin=" << origin << " size=" << subElementSize << "");
@ -94,18 +94,18 @@ void ewol::Widget::Button::calculateSize(const vec2& _availlable) {
}
void ewol::Widget::Button::calculateMinMaxSize() {
void ewol::widget::Button::calculateMinMaxSize() {
ewol::Padding padding = m_shaper.getPadding();
calculateMinMaxSizePadded(padding);
}
void ewol::Widget::Button::onDraw() {
void ewol::widget::Button::onDraw() {
// draw the shaaper (if needed indeed)
m_shaper.draw();
}
void ewol::Widget::Button::onRegenerateDisplay() {
ewol::Widget::Container2::onRegenerateDisplay();
void ewol::widget::Button::onRegenerateDisplay() {
ewol::widget::Container2::onRegenerateDisplay();
if (needRedraw() == false) {
return;
}
@ -116,10 +116,10 @@ void ewol::Widget::Button::onRegenerateDisplay() {
vec2ClipInt32(m_selectableAreaSize-vec2(padding.x(),padding.y()) ) );
}
void ewol::Widget::Button::setLock(enum buttonLock _lock) {
void ewol::widget::Button::setLock(enum buttonLock _lock) {
if (m_lock != _lock) {
m_lock = _lock;
if(ewol::Widget::Button::lockAccess == _lock) {
if(ewol::widget::Button::lockAccess == _lock) {
m_buttonPressed = false;
m_mouseHover = false;
}
@ -128,7 +128,7 @@ void ewol::Widget::Button::setLock(enum buttonLock _lock) {
}
}
void ewol::Widget::Button::setValue(bool _val) {
void ewol::widget::Button::setValue(bool _val) {
if (m_value != _val) {
m_value = _val;
if (m_toggleMode == true) {
@ -143,7 +143,7 @@ void ewol::Widget::Button::setValue(bool _val) {
}
}
void ewol::Widget::Button::setToggleMode(bool _togg) {
void ewol::widget::Button::setToggleMode(bool _togg) {
if (m_toggleMode != _togg) {
m_toggleMode = _togg;
if (m_value == true) {
@ -164,10 +164,10 @@ void ewol::Widget::Button::setToggleMode(bool _togg) {
}
}
bool ewol::Widget::Button::onEventInput(const ewol::event::Input& _event) {
bool ewol::widget::Button::onEventInput(const ewol::event::Input& _event) {
EWOL_VERBOSE("Event on BT : " << _event);
// disable event in the lock access mode :
if(ewol::Widget::Button::lockAccess == m_lock) {
if(ewol::widget::Button::lockAccess == m_lock) {
return false;
}
if( ewol::key::statusLeave == _event.getStatus()
@ -204,9 +204,9 @@ bool ewol::Widget::Button::onEventInput(const ewol::event::Input& _event) {
}
if(ewol::key::statusSingle == _event.getStatus()) {
if( ( m_value == true
&& ewol::Widget::Button::lockWhenPressed == m_lock)
&& ewol::widget::Button::lockWhenPressed == m_lock)
|| ( m_value == false
&& ewol::Widget::Button::lockWhenReleased == m_lock) ) {
&& ewol::widget::Button::lockWhenReleased == m_lock) ) {
// nothing to do : Lock mode ...
// user might set himself the new correct value with @ref setValue(xxx)
} else {
@ -219,7 +219,7 @@ bool ewol::Widget::Button::onEventInput(const ewol::event::Input& _event) {
if( false == m_toggleMode
&& true == m_value) {
setValue(false);
EWOL_VERBOSE(getName() << " : Generate event : " << ewol::Widget::Button::eventValue << " val=" << m_value);
EWOL_VERBOSE(getName() << " : Generate event : " << ewol::widget::Button::eventValue << " val=" << m_value);
generateEventId(eventValue, std::to_string(m_value));
}
}
@ -232,7 +232,7 @@ bool ewol::Widget::Button::onEventInput(const ewol::event::Input& _event) {
}
bool ewol::Widget::Button::onEventEntry(const ewol::event::Entry& _event) {
bool ewol::widget::Button::onEventEntry(const ewol::event::Entry& _event) {
//EWOL_DEBUG("BT PRESSED : \"" << UTF8_data << "\" size=" << strlen(UTF8_data));
if( _event.getType() == ewol::key::keyboardChar
&& _event.getStatus() == ewol::key::statusDown
@ -243,13 +243,13 @@ bool ewol::Widget::Button::onEventEntry(const ewol::event::Entry& _event) {
return false;
}
void ewol::Widget::Button::onLostFocus() {
void ewol::widget::Button::onLostFocus() {
m_buttonPressed = false;
EWOL_VERBOSE(getName() << " : Remove Focus ...");
CheckStatus();
}
void ewol::Widget::Button::CheckStatus() {
void ewol::widget::Button::CheckStatus() {
if (true == m_buttonPressed) {
changeStatusIn(STATUS_PRESSED);
} else {
@ -265,7 +265,7 @@ void ewol::Widget::Button::CheckStatus() {
}
}
void ewol::Widget::Button::changeStatusIn(int32_t _newStatusId) {
void ewol::widget::Button::changeStatusIn(int32_t _newStatusId) {
if (true == m_shaper.changeStatusIn(_newStatusId) ) {
periodicCallEnable();
markToRedraw();
@ -273,7 +273,7 @@ void ewol::Widget::Button::changeStatusIn(int32_t _newStatusId) {
}
void ewol::Widget::Button::periodicCall(const ewol::event::Time& _event) {
void ewol::widget::Button::periodicCall(const ewol::event::Time& _event) {
if (false == m_shaper.periodicCall(_event) ) {
periodicCallDisable();
}
@ -281,8 +281,8 @@ void ewol::Widget::Button::periodicCall(const ewol::event::Time& _event) {
}
bool ewol::Widget::Button::onSetConfig(const ewol::object::Config& _conf) {
if (true == ewol::Widget::Container2::onSetConfig(_conf)) {
bool ewol::widget::Button::onSetConfig(const ewol::object::Config& _conf) {
if (true == ewol::widget::Container2::onSetConfig(_conf)) {
return true;
}
if (_conf.getConfig() == configToggle) {
@ -315,8 +315,8 @@ bool ewol::Widget::Button::onSetConfig(const ewol::object::Config& _conf) {
return false;
}
bool ewol::Widget::Button::onGetConfig(const char* _config, std::string& _result) const {
if (true == ewol::Widget::Container2::onGetConfig(_config, _result)) {
bool ewol::widget::Button::onGetConfig(const char* _config, std::string& _result) const {
if (true == ewol::widget::Container2::onGetConfig(_config, _result)) {
return true;
}
if (_config == configToggle) {

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

@ -25,10 +25,10 @@ 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::Container2 {
class Button : public ewol::widget::Container2 {
public:
//! @not-in-doc
static void init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager);
static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager);
// Event list of properties
static const char* const eventPressed;
static const char* const eventDown;

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

@ -15,7 +15,7 @@
#include <ewol/widget/Windows.h>
#include <ewol/ewol.h>
const char * const ewol::Widget::ButtonColor::eventChange = "change";
const char * const ewol::widget::ButtonColor::eventChange = "change";
// DEFINE for the shader display system :
@ -31,18 +31,18 @@ const char * const ewol::Widget::ButtonColor::eventChange = "change";
static const char* const eventColorHasChange = "ewol-widget-ButtonColor-colorChange";
static ewol::Widget* Create() {
return new ewol::Widget::ButtonColor();
return new ewol::widget::ButtonColor();
}
void ewol::Widget::ButtonColor::init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager) {
_widgetManager.addWidgetCreator(__class__,&Create);
void ewol::widget::ButtonColor::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&Create);
}
ewol::Widget::ButtonColor::ButtonColor(etk::Color<> _baseColor, std::string _shaperName) :
ewol::widget::ButtonColor::ButtonColor(etk::Color<> _baseColor, std::string _shaperName) :
m_shaper(_shaperName),
m_textColorFg(_baseColor),
m_widgetContextMenu(NULL) {
addObjectType("ewol::Widget::ButtonColor");
addObjectType("ewol::widget::ButtonColor");
addEventId(eventChange);
changeStatusIn(STATUS_UP);
setCanHaveFocus(true);
@ -51,17 +51,17 @@ ewol::Widget::ButtonColor::ButtonColor(etk::Color<> _baseColor, std::string _sha
}
ewol::Widget::ButtonColor::~ButtonColor() {
ewol::widget::ButtonColor::~ButtonColor() {
}
void ewol::Widget::ButtonColor::setShaperName(std::string _shaperName) {
void ewol::widget::ButtonColor::setShaperName(std::string _shaperName) {
m_shaper.setSource(_shaperName);
}
void ewol::Widget::ButtonColor::calculateMinMaxSize() {
void ewol::widget::ButtonColor::calculateMinMaxSize() {
ewol::Padding padding = m_shaper.getPadding();
std::string label = m_textColorFg.getString();
vec3 minSize = m_text.calculateSize(label);
@ -72,13 +72,13 @@ void ewol::Widget::ButtonColor::calculateMinMaxSize() {
void ewol::Widget::ButtonColor::onDraw() {
void ewol::widget::ButtonColor::onDraw() {
m_shaper.draw();
m_text.draw();
}
void ewol::Widget::ButtonColor::onRegenerateDisplay() {
void ewol::widget::ButtonColor::onRegenerateDisplay() {
if (needRedraw() == false) {
return;
}
@ -142,7 +142,7 @@ void ewol::Widget::ButtonColor::onRegenerateDisplay() {
}
bool ewol::Widget::ButtonColor::onEventInput(const ewol::event::Input& _event) {
bool ewol::widget::ButtonColor::onEventInput(const ewol::event::Input& _event) {
bool previousHoverState = m_mouseHover;
if(ewol::key::statusLeave == _event.getStatus()) {
m_mouseHover = false;
@ -176,27 +176,26 @@ bool ewol::Widget::ButtonColor::onEventInput(const ewol::event::Input& _event) {
m_buttonPressed = false;
m_mouseHover = false;
// create a context menu :
m_widgetContextMenu = new ewol::Widget::ContextMenu();
m_widgetContextMenu = new ewol::widget::ContextMenu();
if (NULL == m_widgetContextMenu) {
EWOL_ERROR("Allocation Error");
return true;
}
vec2 tmpPos = m_origin + m_selectableAreaPos + m_selectableAreaSize;
tmpPos.setX( tmpPos.x() - m_minSize.x()/2.0);
m_widgetContextMenu->setPositionMark(ewol::Widget::ContextMenu::markButtom, tmpPos );
m_widgetContextMenu->setPositionMark(ewol::widget::ContextMenu::markButtom, tmpPos );
ewol::Widget::ColorChooser * myColorChooser = new widget::ColorChooser();
ewol::widget::ColorChooser * myColorChooser = new widget::ColorChooser();
myColorChooser->setColor(m_textColorFg);
// set it in the pop-up-system :
m_widgetContextMenu->setSubWidget(myColorChooser);
myColorChooser->registerOnEvent(this, "change", eventColorHasChange);
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...");
delete(m_widgetContextMenu);
m_widgetContextMenu=NULL;
m_widgetContextMenu.reset();
} else {
currentWindows->popUpWidgetPush(m_widgetContextMenu);
currentWindows->popUpWidgetPush(m_widgetContextMenu.get());
}
markToRedraw();
}
@ -218,17 +217,17 @@ bool ewol::Widget::ButtonColor::onEventInput(const ewol::event::Input& _event) {
}
void ewol::Widget::ButtonColor::setValue(etk::Color<> _color) {
void ewol::widget::ButtonColor::setValue(etk::Color<> _color) {
m_textColorFg = _color;
markToRedraw();
}
etk::Color<> ewol::Widget::ButtonColor::getValue() {
etk::Color<> ewol::widget::ButtonColor::getValue() {
return m_textColorFg;
}
void ewol::Widget::ButtonColor::onReceiveMessage(const ewol::object::Message& _msg) {
void ewol::widget::ButtonColor::onReceiveMessage(const ewol::object::Message& _msg) {
EWOL_INFO("Receive MSG : " << _msg.getData());
if (_msg.getMessage() == eventColorHasChange) {
m_textColorFg = _msg.getData();
@ -238,7 +237,7 @@ void ewol::Widget::ButtonColor::onReceiveMessage(const ewol::object::Message& _m
}
void ewol::Widget::ButtonColor::changeStatusIn(int32_t _newStatusId) {
void ewol::widget::ButtonColor::changeStatusIn(int32_t _newStatusId) {
if (true == m_shaper.changeStatusIn(_newStatusId) ) {
periodicCallEnable();
markToRedraw();
@ -247,7 +246,7 @@ void ewol::Widget::ButtonColor::changeStatusIn(int32_t _newStatusId) {
void ewol::Widget::ButtonColor::periodicCall(const ewol::event::Time& _event) {
void ewol::widget::ButtonColor::periodicCall(const ewol::event::Time& _event) {
if (false == m_shaper.periodicCall(_event) ) {
periodicCallDisable();
}

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

@ -25,12 +25,12 @@ 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::object::Shared<ewol::widget::Manager> _widgetManager);
private:
ewol::compositing::Shaper m_shaper; //!< Compositing theme.
ewol::compositing::Text m_text; //!< Compositing Test display.
etk::Color<> m_textColorFg; //!< Current color.
ewol::object::Shared<ewol::Widget::ContextMenu> m_widgetContextMenu; //!< Specific context menu.
ewol::object::Shared<ewol::widget::ContextMenu> m_widgetContextMenu; //!< Specific context menu.
bool m_mouseHover; //!< Flag to know where the mouse is (inside the displayed widget (if not fill)).
bool m_buttonPressed; //!< Flag to know if the button is curently pressed.
// hover area :

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

@ -9,14 +9,14 @@
#include <ewol/widget/CheckBox.h>
#include <ewol/widget/Manager.h>
const char* const ewol::Widget::CheckBox::eventPressed = "pressed";
const char* const ewol::Widget::CheckBox::eventDown = "down";
const char* const ewol::Widget::CheckBox::eventUp = "up";
const char* const ewol::Widget::CheckBox::eventEnter = "enter";
const char* const ewol::Widget::CheckBox::eventValue = "value";
const char* const ewol::widget::CheckBox::eventPressed = "pressed";
const char* const ewol::widget::CheckBox::eventDown = "down";
const char* const ewol::widget::CheckBox::eventUp = "up";
const char* const ewol::widget::CheckBox::eventEnter = "enter";
const char* const ewol::widget::CheckBox::eventValue = "value";
const char* const ewol::Widget::CheckBox::configValue = "value";
const char* const ewol::Widget::CheckBox::configShaper = "shaper";
const char* const ewol::widget::CheckBox::configValue = "value";
const char* const ewol::widget::CheckBox::configShaper = "shaper";
// DEFINE for the shader display system :
@ -28,14 +28,14 @@ const char* const ewol::Widget::CheckBox::configShaper = "shaper";
#define __class__ "CheckBox"
static ewol::Widget* Create() {
return new ewol::Widget::CheckBox();
return new ewol::widget::CheckBox();
}
void ewol::Widget::CheckBox::init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager) {
_widgetManager.addWidgetCreator(__class__,&Create);
void ewol::widget::CheckBox::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&Create);
}
ewol::Widget::CheckBox::CheckBox(const std::string& _shaperName) :
ewol::widget::CheckBox::CheckBox(const std::string& _shaperName) :
m_shaper(_shaperName),
m_mouseHover(false),
m_buttonPressed(false),
@ -44,7 +44,7 @@ ewol::Widget::CheckBox::CheckBox(const std::string& _shaperName) :
m_shaperIdSize(-1),
m_shaperIdSizeInsize(-1),
m_value(false) {
addObjectType("ewol::Widget::CheckBox");
addObjectType("ewol::widget::CheckBox");
// add basic Event generated :
addEventId(eventPressed);
addEventId(eventDown);
@ -67,17 +67,17 @@ ewol::Widget::CheckBox::CheckBox(const std::string& _shaperName) :
}
ewol::Widget::CheckBox::~CheckBox() {
ewol::widget::CheckBox::~CheckBox() {
}
void ewol::Widget::CheckBox::setShaperName(const std::string& _shaperName) {
void ewol::widget::CheckBox::setShaperName(const std::string& _shaperName) {
EWOL_WARNING("set shaper name : '" << _shaperName << "'");
m_shaper.setSource(_shaperName);
markToRedraw();
}
void ewol::Widget::CheckBox::calculateSize(const vec2& _availlable) {
void ewol::widget::CheckBox::calculateSize(const vec2& _availlable) {
ewol::Padding padding = m_shaper.getPadding();
float boxSize = m_shaper.getConfigNumber(m_shaperIdSize);
padding.setXLeft(padding.xLeft()*2.0f + boxSize);
@ -87,7 +87,7 @@ void ewol::Widget::CheckBox::calculateSize(const vec2& _availlable) {
m_selectableAreaSize = m_size - (m_selectableAreaPos + vec2(ret.xRight(), ret.yTop()));
}
void ewol::Widget::CheckBox::calculateMinMaxSize() {
void ewol::widget::CheckBox::calculateMinMaxSize() {
ewol::Padding padding = m_shaper.getPadding();
float boxSize = m_shaper.getConfigNumber(m_shaperIdSize);
padding.setXLeft(padding.xLeft()*2.0f + boxSize);
@ -97,13 +97,13 @@ void ewol::Widget::CheckBox::calculateMinMaxSize() {
}
}
void ewol::Widget::CheckBox::onDraw() {
void ewol::widget::CheckBox::onDraw() {
// draw the shaaper (if needed indeed)
m_shaper.draw();
}
void ewol::Widget::CheckBox::onRegenerateDisplay() {
ewol::Widget::Container2::onRegenerateDisplay();
void ewol::widget::CheckBox::onRegenerateDisplay() {
ewol::widget::Container2::onRegenerateDisplay();
if (needRedraw() == false) {
return;
}
@ -123,7 +123,7 @@ void ewol::Widget::CheckBox::onRegenerateDisplay() {
vec2ClipInt32(size2-vec2(padding.x(),padding.y()) ));
}
void ewol::Widget::CheckBox::setValue(bool _val) {
void ewol::widget::CheckBox::setValue(bool _val) {
if (m_value != _val) {
m_value = _val;
if (m_value == false) {
@ -137,7 +137,7 @@ void ewol::Widget::CheckBox::setValue(bool _val) {
m_shaper.setActivateState(m_value==true?1:0);
}
bool ewol::Widget::CheckBox::onEventInput(const ewol::event::Input& _event) {
bool ewol::widget::CheckBox::onEventInput(const ewol::event::Input& _event) {
EWOL_VERBOSE("Event on BT : " << _event);
bool previousHoverState = m_mouseHover;
@ -193,7 +193,7 @@ bool ewol::Widget::CheckBox::onEventInput(const ewol::event::Input& _event) {
}
bool ewol::Widget::CheckBox::onEventEntry(const ewol::event::Entry& _event) {
bool ewol::widget::CheckBox::onEventEntry(const ewol::event::Entry& _event) {
//EWOL_DEBUG("BT PRESSED : \"" << UTF8_data << "\" size=" << strlen(UTF8_data));
if( _event.getType() == ewol::key::keyboardChar
&& _event.getStatus() == ewol::key::statusDown
@ -204,7 +204,7 @@ bool ewol::Widget::CheckBox::onEventEntry(const ewol::event::Entry& _event) {
return false;
}
void ewol::Widget::CheckBox::CheckStatus() {
void ewol::widget::CheckBox::CheckStatus() {
if (true == m_buttonPressed) {
changeStatusIn(STATUS_PRESSED);
} else {
@ -216,7 +216,7 @@ void ewol::Widget::CheckBox::CheckStatus() {
}
}
void ewol::Widget::CheckBox::changeStatusIn(int32_t _newStatusId) {
void ewol::widget::CheckBox::changeStatusIn(int32_t _newStatusId) {
if (true == m_shaper.changeStatusIn(_newStatusId) ) {
periodicCallEnable();
markToRedraw();
@ -224,7 +224,7 @@ void ewol::Widget::CheckBox::changeStatusIn(int32_t _newStatusId) {
}
void ewol::Widget::CheckBox::periodicCall(const ewol::event::Time& _event) {
void ewol::widget::CheckBox::periodicCall(const ewol::event::Time& _event) {
if (false == m_shaper.periodicCall(_event) ) {
periodicCallDisable();
}
@ -232,8 +232,8 @@ void ewol::Widget::CheckBox::periodicCall(const ewol::event::Time& _event) {
}
bool ewol::Widget::CheckBox::onSetConfig(const ewol::object::Config& _conf) {
if (true == ewol::Widget::Container2::onSetConfig(_conf)) {
bool ewol::widget::CheckBox::onSetConfig(const ewol::object::Config& _conf) {
if (true == ewol::widget::Container2::onSetConfig(_conf)) {
return true;
}
if (_conf.getConfig() == configValue) {
@ -247,8 +247,8 @@ bool ewol::Widget::CheckBox::onSetConfig(const ewol::object::Config& _conf) {
return false;
}
bool ewol::Widget::CheckBox::onGetConfig(const char* _config, std::string& _result) const {
if (true == ewol::Widget::Container2::onGetConfig(_config, _result)) {
bool ewol::widget::CheckBox::onGetConfig(const char* _config, std::string& _result) const {
if (true == ewol::widget::Container2::onGetConfig(_config, _result)) {
return true;
}
if (_config == configValue) {

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

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

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

@ -13,15 +13,15 @@
#include <etk/Color.h>
const char * const ewol::Widget::ColorBar::eventChange = "change";
const char * const ewol::widget::ColorBar::eventChange = "change";
#undef __class__
#define __class__ "ColorBar"
ewol::Widget::ColorBar::ColorBar() {
addObjectType("ewol::Widget::ColorBar");
ewol::widget::ColorBar::ColorBar() {
addObjectType("ewol::widget::ColorBar");
addEventId(eventChange);
m_currentUserPos.setValue(0,0);
m_currentColor = etk::color::black;
@ -29,12 +29,12 @@ ewol::Widget::ColorBar::ColorBar() {
setMouseLimit(1);
}
ewol::Widget::ColorBar::~ColorBar() {
ewol::widget::ColorBar::~ColorBar() {
}
void ewol::Widget::ColorBar::calculateMinMaxSize() {
void ewol::widget::ColorBar::calculateMinMaxSize() {
m_minSize.setValue(160, 80);
markToRedraw();
}
@ -52,22 +52,22 @@ static etk::Color<> s_listColor[NB_BAND_COLOR+1] = {
0xFF0000FF
};
etk::Color<> ewol::Widget::ColorBar::getCurrentColor() {
etk::Color<> ewol::widget::ColorBar::getCurrentColor() {
return m_currentColor;
}
void ewol::Widget::ColorBar::setCurrentColor(etk::Color<> newOne) {
void ewol::widget::ColorBar::setCurrentColor(etk::Color<> newOne) {
m_currentColor = newOne;
m_currentColor.setA(0xFF);
// estimate the cursor position :
// TODO : Later when really needed ...
}
void ewol::Widget::ColorBar::onDraw() {
void ewol::widget::ColorBar::onDraw() {
m_draw.draw();
}
void ewol::Widget::ColorBar::onRegenerateDisplay() {
void ewol::widget::ColorBar::onRegenerateDisplay() {
if (true == needRedraw()) {
// clean the object list ...
m_draw.clear();
@ -165,7 +165,7 @@ void ewol::Widget::ColorBar::onRegenerateDisplay() {
}
bool ewol::Widget::ColorBar::onEventInput(const ewol::event::Input& _event) {
bool ewol::widget::ColorBar::onEventInput(const ewol::event::Input& _event) {
vec2 relativePos = relativePosition(_event.getPos());
//EWOL_DEBUG("Event on BT ...");
if (1 == _event.getId()) {

28
sources/ewol/widget/Composer.cpp
View File

@ -13,32 +13,32 @@
#include <ewol/widget/Manager.h>
#undef __class__
#define __class__ "ewol::Widget::Composer"
#define __class__ "ewol::widget::Composer"
ewol::Widget::Composer::Composer() {
ewol::widget::Composer::Composer() {
// nothing to do ...
}
ewol::Widget::Composer::Composer(enum composerMode _mode, const std::string& _fileName) {
addObjectType("ewol::Widget::Composer");
ewol::widget::Composer::Composer(enum composerMode _mode, const std::string& _fileName) {
addObjectType("ewol::widget::Composer");
switch(_mode) {
case ewol::Widget::Composer::None:
case ewol::widget::Composer::None:
// nothing to do ...
break;
case ewol::Widget::Composer::String:
case ewol::widget::Composer::String:
loadFromString(_fileName);
break;
case ewol::Widget::Composer::file:
case ewol::widget::Composer::file:
loadFromFile(_fileName);
break;
}
}
ewol::Widget::Composer::~Composer() {
ewol::widget::Composer::~Composer() {
}
bool ewol::Widget::Composer::loadFromFile(const std::string& _fileName) {
bool ewol::widget::Composer::loadFromFile(const std::string& _fileName) {
exml::Document doc;
if (doc.load(_fileName) == false) {
EWOL_ERROR(" can not load file XML : " << _fileName);
@ -58,12 +58,12 @@ bool ewol::Widget::Composer::loadFromFile(const std::string& _fileName) {
}
}
// call upper class to parse his elements ...
ewol::Widget::Container::loadXML(root);
ewol::widget::Container::loadXML(root);
return true;
}
bool ewol::Widget::Composer::loadFromString(const std::string& _composerXmlString) {
bool ewol::widget::Composer::loadFromString(const std::string& _composerXmlString) {
exml::Document doc;
if (doc.parse(_composerXmlString) == false) {
EWOL_ERROR(" can not load file XML string...");
@ -83,20 +83,20 @@ bool ewol::Widget::Composer::loadFromString(const std::string& _composerXmlStrin
}
}
// call upper class to parse his elements ...
ewol::Widget::Container::loadXML(root);
ewol::widget::Container::loadXML(root);
return true;
}
void ewol::Widget::Composer::registerOnEventNameWidget(const std::string& _subWidgetName,
void ewol::widget::Composer::registerOnEventNameWidget(const std::string& _subWidgetName,
const char * _eventId,
const char * _eventIdgenerated,
const std::string& _overloadData) {
registerOnEventNameWidget(this, _subWidgetName, _eventId, _eventIdgenerated, _overloadData);
}
void ewol::Widget::Composer::registerOnEventNameWidget(ewol::object::Shared<ewol::Object> * _destinationObject,
void ewol::widget::Composer::registerOnEventNameWidget(ewol::object::Shared<ewol::Object> _destinationObject,
const std::string& _subWidgetName,
const char * _eventId,
const char * _eventIdgenerated,

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

@ -19,7 +19,7 @@ namespace ewol {
* @ingroup ewolWidgetGroup
* @brief the composer widget is a widget that create a link on a string.file to parse the data and generate some widget tree
*/
class Composer : public ewol::Widget::Container {
class Composer : public ewol::widget::Container {
public:
enum composerMode {
None,

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

@ -16,21 +16,21 @@
#define __class__ "Container"
ewol::Widget::Container::Container(ewol::Widget* _subElement) :
ewol::widget::Container::Container(ewol::Widget* _subElement) :
m_subWidget(_subElement) {
addObjectType("ewol::Widget::Container");
addObjectType("ewol::widget::Container");
// nothing to do ...
}
ewol::Widget::Container::~Container() {
ewol::widget::Container::~Container() {
subWidgetRemove();
}
ewol::object::Shared<ewol::Widget> ewol::Widget::Container::getSubWidget() {
ewol::object::Shared<ewol::Widget> ewol::widget::Container::getSubWidget() {
return m_subWidget;
}
void ewol::Widget::Container::setSubWidget(ewol::Widget* _newWidget) {
void ewol::widget::Container::setSubWidget(ewol::Widget* _newWidget) {
if (NULL == _newWidget) {
return;
}
@ -43,7 +43,7 @@ void ewol::Widget::Container::setSubWidget(ewol::Widget* _newWidget) {
requestUpdateSize();
}
void ewol::Widget::Container::subWidgetRemove() {
void ewol::widget::Container::subWidgetRemove() {
if (NULL != m_subWidget) {
m_subWidget->removeUpperWidget();
m_subWidget->removeObject();
@ -53,14 +53,14 @@ void ewol::Widget::Container::subWidgetRemove() {
}
}
void ewol::Widget::Container::subWidgetUnLink() {
void ewol::widget::Container::subWidgetUnLink() {
if (NULL != m_subWidget) {
m_subWidget->removeUpperWidget();
}
m_subWidget=NULL;
}
ewol::object::Shared<ewol::Widget> ewol::Widget::Container::getWidgetNamed(const std::string& _widgetName) {
ewol::object::Shared<ewol::Widget> ewol::widget::Container::getWidgetNamed(const std::string& _widgetName) {
ewol::object::Shared<ewol::Widget> tmpUpperWidget = ewol::Widget::getWidgetNamed(_widgetName);
if (NULL!=tmpUpperWidget) {
return tmpUpperWidget;
@ -71,7 +71,7 @@ ewol::object::Shared<ewol::Widget> ewol::Widget::Container::getWidgetNamed(const
return NULL;
}
void ewol::Widget::Container::onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject) {
void ewol::widget::Container::onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject) {
if (m_subWidget == _removeObject) {
m_subWidget=NULL;
markToRedraw();
@ -79,7 +79,7 @@ void ewol::Widget::Container::onObjectRemove(ewol::object::Shared<ewol::Object>
}
}
void ewol::Widget::Container::systemDraw(const ewol::DrawProperty& _displayProp) {
void ewol::widget::Container::systemDraw(const ewol::DrawProperty& _displayProp) {
if (true == m_hide){
// widget is hidden ...
return;
@ -92,7 +92,7 @@ void ewol::Widget::Container::systemDraw(const ewol::DrawProperty& _displayProp)
}
}
void ewol::Widget::Container::calculateSize(const vec2& _availlable) {
void ewol::widget::Container::calculateSize(const vec2& _availlable) {
if (NULL!=m_subWidget) {
vec2 origin = m_origin+m_offset;
vec2 minSize = m_subWidget->getCalculateMinSize();
@ -119,7 +119,7 @@ void ewol::Widget::Container::calculateSize(const vec2& _availlable) {
ewol::Widget::calculateSize(_availlable);
}
void ewol::Widget::Container::calculateMinMaxSize() {
void ewol::widget::Container::calculateMinMaxSize() {
// call main class
ewol::Widget::calculateMinMaxSize();
// call sub classes
@ -131,13 +131,13 @@ void ewol::Widget::Container::calculateMinMaxSize() {
//EWOL_ERROR("[" << getId() << "] Result min size : " << m_minSize);
}
void ewol::Widget::Container::onRegenerateDisplay() {
void ewol::widget::Container::onRegenerateDisplay() {
if (NULL!=m_subWidget) {
m_subWidget->onRegenerateDisplay();
}
}
ewol::object::Shared<ewol::Widget> ewol::Widget::Container::getWidgetAtPos(const vec2& _pos) {
ewol::object::Shared<ewol::Widget> ewol::widget::Container::getWidgetAtPos(const vec2& _pos) {
if (false == isHide()) {
if (NULL!=m_subWidget) {
return m_subWidget->getWidgetAtPos(_pos);
@ -147,7 +147,7 @@ ewol::object::Shared<ewol::Widget> ewol::Widget::Container::getWidgetAtPos(const
};
bool ewol::Widget::Container::loadXML(exml::Element* _node) {
bool ewol::widget::Container::loadXML(exml::Element* _node) {
if (NULL == _node) {
return false;
}
@ -173,7 +173,7 @@ bool ewol::Widget::Container::loadXML(exml::Element* _node) {
continue;
}
EWOL_DEBUG("try to create subwidget : '" << widgetName << "'");
ewol::object::Shared<ewol::Widget> tmpWidget = getWidgetManager().create(widgetName);
ewol::Widget* tmpWidget = getWidgetManager().create(widgetName);
if (tmpWidget == NULL) {
EWOL_ERROR ("(l "<<pNode->getPos()<<") Can not create the widget : \"" << widgetName << "\"");
continue;
@ -188,7 +188,7 @@ bool ewol::Widget::Container::loadXML(exml::Element* _node) {
return true;
}
void ewol::Widget::Container::setOffset(const vec2& _newVal) {
void ewol::widget::Container::setOffset(const vec2& _newVal) {
if (m_offset != _newVal) {
ewol::Widget::setOffset(_newVal);
// recalculate the new sise and position of sub widget ...

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

@ -19,7 +19,7 @@ namespace ewol {
* @ingroup ewolWidgetGroup
* @brief the Cotainer widget is a widget that have an only one subWidget
*/
class Container : public ewol::object::Shared<ewol::Widget> {
class Container : public ewol::Widget {
protected:
ewol::object::Owner<ewol::Widget> m_subWidget;
public:

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

@ -16,20 +16,20 @@
#define __class__ "Container2"
ewol::Widget::Container2::Container2(ewol::Widget* _subElement, ewol::Widget* _subElementToggle) :
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");
addObjectType("ewol::widget::Container2");
// nothing to do ...
}
ewol::Widget::Container2::~Container2() {
ewol::widget::Container2::~Container2() {
subWidgetRemove();
subWidgetRemoveToggle();
}
void ewol::Widget::Container2::setSubWidget(ewol::Widget* _newWidget, int32_t _idWidget) {
void ewol::widget::Container2::setSubWidget(ewol::Widget* _newWidget, int32_t _idWidget) {
subWidgetRemove(_idWidget);
m_subWidget[_idWidget] = _newWidget;
if (m_subWidget[_idWidget] != NULL) {
@ -41,7 +41,7 @@ void ewol::Widget::Container2::setSubWidget(ewol::Widget* _newWidget, int32_t _i
}
void ewol::Widget::Container2::subWidgetRemove(int32_t _idWidget) {
void ewol::widget::Container2::subWidgetRemove(int32_t _idWidget) {
if (m_subWidget[_idWidget] != NULL) {
EWOL_VERBOSE("Remove widget : " << _idWidget);
m_subWidget[_idWidget]->removeUpperWidget();
@ -52,7 +52,7 @@ void ewol::Widget::Container2::subWidgetRemove(int32_t _idWidget) {
}
}
void ewol::Widget::Container2::subWidgetUnLink(int32_t _idWidget) {
void ewol::widget::Container2::subWidgetUnLink(int32_t _idWidget) {
if (m_subWidget[_idWidget] != NULL) {
m_subWidget[_idWidget]->removeUpperWidget();
EWOL_VERBOSE("Unlink widget : " << _idWidget);
@ -60,7 +60,7 @@ void ewol::Widget::Container2::subWidgetUnLink(int32_t _idWidget) {
m_subWidget[_idWidget] = NULL;
}
ewol::object::Shared<ewol::Widget> ewol::Widget::Container2::getWidgetNamed(const std::string& _widgetName) {
ewol::object::Shared<ewol::Widget> ewol::widget::Container2::getWidgetNamed(const std::string& _widgetName) {
ewol::object::Shared<ewol::Widget> tmpUpperWidget = ewol::Widget::getWidgetNamed(_widgetName);
if (tmpUpperWidget != NULL) {
return tmpUpperWidget;
@ -74,7 +74,7 @@ ewol::object::Shared<ewol::Widget> ewol::Widget::Container2::getWidgetNamed(cons
return NULL;
}
void ewol::Widget::Container2::onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject) {
void ewol::widget::Container2::onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject) {
if (m_subWidget[0] == _removeObject) {
m_subWidget[0] = NULL;
markToRedraw();
@ -87,7 +87,7 @@ void ewol::Widget::Container2::onObjectRemove(ewol::object::Shared<ewol::Object>
}
}
void ewol::Widget::Container2::systemDraw(const ewol::DrawProperty& _displayProp) {
void ewol::widget::Container2::systemDraw(const ewol::DrawProperty& _displayProp) {
if (true == m_hide){
// widget is hidden ...
return;
@ -98,7 +98,7 @@ void ewol::Widget::Container2::systemDraw(const ewol::DrawProperty& _displayProp
}
}
ewol::Padding ewol::Widget::Container2::calculateSizePadded(const vec2& _availlable, const ewol::Padding& _padding) {
ewol::Padding ewol::widget::Container2::calculateSizePadded(const vec2& _availlable, const ewol::Padding& _padding) {
vec2 localAvaillable = _availlable - vec2(_padding.x(), _padding.y());
ewol::Widget::calculateSize(_availlable);
// set minimal size
@ -149,7 +149,7 @@ ewol::Padding ewol::Widget::Container2::calculateSizePadded(const vec2& _availla
return ewol::Padding(selectableAreaPos.x(), selectableAreaEndPos.y(), selectableAreaEndPos.x(), selectableAreaPos.y());
}
void ewol::Widget::Container2::calculateMinMaxSizePadded(const ewol::Padding& _padding) {
void ewol::widget::Container2::calculateMinMaxSizePadded(const ewol::Padding& _padding) {
// call main class
m_minSize = vec2(0,0);
// call sub classes
@ -167,13 +167,13 @@ void ewol::Widget::Container2::calculateMinMaxSizePadded(const ewol::Padding& _p
markToRedraw();
}
void ewol::Widget::Container2::onRegenerateDisplay() {
void ewol::widget::Container2::onRegenerateDisplay() {
if (m_subWidget[m_idWidgetDisplayed] != NULL) {
m_subWidget[m_idWidgetDisplayed]->onRegenerateDisplay();
}
}
/*
ewol::object::Shared<ewol::Widget> ewol::Widget::Container2::getWidgetAtPos(const vec2& _pos) {
ewol::object::Shared<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);
@ -183,7 +183,7 @@ ewol::object::Shared<ewol::Widget> ewol::Widget::Container2::getWidgetAtPos(cons
}
*/
bool ewol::Widget::Container2::loadXML(exml::Element* _node) {
bool ewol::widget::Container2::loadXML(exml::Element* _node) {
if (NULL == _node) {
return false;
}
@ -213,7 +213,7 @@ bool ewol::Widget::Container2::loadXML(exml::Element* _node) {
}
}
EWOL_DEBUG("try to create subwidget : '" << widgetName << "'");
ewol::object::Shared<ewol::Widget> tmpWidget = getWidgetManager().create(widgetName);
ewol::Widget* tmpWidget = getWidgetManager().create(widgetName);
if (tmpWidget == NULL) {
EWOL_ERROR ("(l "<<pNode->getPos()<<") Can not create the widget : \"" << widgetName << "\"");
continue;
@ -232,7 +232,7 @@ bool ewol::Widget::Container2::loadXML(exml::Element* _node) {
return true;
}
void ewol::Widget::Container2::setOffset(const vec2& _newVal) {
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 ...

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

@ -20,7 +20,7 @@ namespace ewol {
* @ingroup ewolWidgetGroup
* @brief the Cotainer widget is a widget that have an only one subWidget
*/
class Container2 : public ewol::object::Shared<ewol::Widget> {
class Container2 : public ewol::Widget {
protected:
ewol::object::Owner<ewol::Widget> m_subWidget[2]; //!< 2 subwidget possible
int32_t m_idWidgetDisplayed; //!< current widget displayed

44
sources/ewol/widget/ContainerN.cpp
View File

@ -15,19 +15,19 @@
#define __class__ "ContainerN"
ewol::Widget::ContainerN::ContainerN() :
ewol::widget::ContainerN::ContainerN() :
m_lockExpand(false,false),
m_subExpend(false,false) {
addObjectType("ewol::Widget::ContainerN");
addObjectType("ewol::widget::ContainerN");
// nothing to do ...
}
ewol::Widget::ContainerN::~ContainerN() {
ewol::widget::ContainerN::~ContainerN() {
subWidgetRemoveAll();
}
bvec2 ewol::Widget::ContainerN::canExpand() {
bvec2 ewol::widget::ContainerN::canExpand() {
bvec2 res = m_userExpand;
if (false == m_lockExpand.x()) {
if (true == m_subExpend.x()) {
@ -43,7 +43,7 @@ bvec2 ewol::Widget::ContainerN::canExpand() {
return res;
}
void ewol::Widget::ContainerN::lockExpand(const bvec2& _lockExpand) {
void ewol::widget::ContainerN::lockExpand(const bvec2& _lockExpand) {
if (_lockExpand != m_lockExpand) {
m_lockExpand = _lockExpand;
markToRedraw();
@ -52,7 +52,7 @@ void ewol::Widget::ContainerN::lockExpand(const bvec2& _lockExpand) {
}
int32_t ewol::Widget::ContainerN::subWidgetAdd(ewol::Widget* _newWidget) {
int32_t ewol::widget::ContainerN::subWidgetAdd(ewol::Widget* _newWidget) {
if (NULL == _newWidget) {
EWOL_ERROR("[" << getId() << "] {" << getObjectType() << "} Try to add An empty Widget ... ");
return -1;
@ -67,7 +67,7 @@ int32_t ewol::Widget::ContainerN::subWidgetAdd(ewol::Widget* _newWidget) {
return _newWidget->getId();
}
int32_t ewol::Widget::ContainerN::subWidgetAddStart(ewol::Widget* _newWidget) {
int32_t ewol::widget::ContainerN::subWidgetAddStart(ewol::Widget* _newWidget) {
if (NULL == _newWidget) {
EWOL_ERROR("[" << getId() << "] {" << getObjectType() << "} Try to add start An empty Widget ... ");
return -1;
@ -81,7 +81,7 @@ int32_t ewol::Widget::ContainerN::subWidgetAddStart(ewol::Widget* _newWidget) {
return _newWidget->getId();
}
void ewol::Widget::ContainerN::subWidgetRemove(ewol::Widget* _newWidget) {
void ewol::widget::ContainerN::subWidgetRemove(ewol::Widget* _newWidget) {
if (NULL == _newWidget) {
return;
}
@ -103,7 +103,7 @@ void ewol::Widget::ContainerN::subWidgetRemove(ewol::Widget* _newWidget) {
}
}
void ewol::Widget::ContainerN::subWidgetUnLink(ewol::Widget* _newWidget) {
void ewol::widget::ContainerN::subWidgetUnLink(ewol::Widget* _newWidget) {
if (NULL == _newWidget) {
return;
}
@ -119,7 +119,7 @@ void ewol::Widget::ContainerN::subWidgetUnLink(ewol::Widget* _newWidget) {
}
}
void ewol::Widget::ContainerN::subWidgetRemoveAll() {
void ewol::widget::ContainerN::subWidgetRemoveAll() {
size_t errorControl = m_subWidget.size();
// the size automaticly decrement with the auto call of the onObjectRemove function
while (m_subWidget.size() > 0 ) {
@ -140,7 +140,7 @@ void ewol::Widget::ContainerN::subWidgetRemoveAll() {
m_subWidget.clear();
}
void ewol::Widget::ContainerN::subWidgetRemoveAllDelayed() {
void ewol::widget::ContainerN::subWidgetRemoveAllDelayed() {
// the size automaticly decrement with the auto call of the onObjectRemove function
for (size_t iii=0; iii<m_subWidget.size(); iii++) {
if (NULL != m_subWidget[iii]) {
@ -154,7 +154,7 @@ void ewol::Widget::ContainerN::subWidgetRemoveAllDelayed() {
m_subWidget.clear();
}
ewol::object::Shared<ewol::Widget> ewol::Widget::ContainerN::getWidgetNamed(const std::string& _widgetName) {
ewol::object::Shared<ewol::Widget> ewol::widget::ContainerN::getWidgetNamed(const std::string& _widgetName) {
ewol::object::Shared<ewol::Widget> tmpUpperWidget = ewol::Widget::getWidgetNamed(_widgetName);
if (NULL!=tmpUpperWidget) {
return tmpUpperWidget;
@ -170,7 +170,7 @@ ewol::object::Shared<ewol::Widget> ewol::Widget::ContainerN::getWidgetNamed(cons
return NULL;
}
void ewol::Widget::ContainerN::onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject) {
void ewol::widget::ContainerN::onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject) {
// First step call parrent :
ewol::Widget::onObjectRemove(_removeObject);
// second step find if in all the elements ...
@ -183,7 +183,7 @@ void ewol::Widget::ContainerN::onObjectRemove(ewol::object::Shared<ewol::Object>
}
}
void ewol::Widget::ContainerN::systemDraw(const ewol::DrawProperty& _displayProp) {
void ewol::widget::ContainerN::systemDraw(const ewol::DrawProperty& _displayProp) {
if (true == m_hide){
// widget is hidden ...
return;
@ -200,7 +200,7 @@ void ewol::Widget::ContainerN::systemDraw(const ewol::DrawProperty& _displayProp
}
}
void ewol::Widget::ContainerN::calculateSize(const vec2& _availlable) {
void ewol::widget::ContainerN::calculateSize(const vec2& _availlable) {
m_size = _availlable;
for (size_t iii=0; iii<m_subWidget.size(); iii++) {
if (NULL != m_subWidget[iii]) {
@ -211,7 +211,7 @@ void ewol::Widget::ContainerN::calculateSize(const vec2& _availlable) {
markToRedraw();
}
void ewol::Widget::ContainerN::calculateMinMaxSize() {
void ewol::widget::ContainerN::calculateMinMaxSize() {
m_subExpend.setValue(false, false);
m_minSize.setValue(0,0);
m_maxSize.setValue(ULTIMATE_MAX_SIZE,ULTIMATE_MAX_SIZE);
@ -234,7 +234,7 @@ void ewol::Widget::ContainerN::calculateMinMaxSize() {
//EWOL_ERROR("[" << getId() << "] {" << getObjectType() << "} Result min size : " << m_minSize);
}
void ewol::Widget::ContainerN::onRegenerateDisplay() {
void ewol::widget::ContainerN::onRegenerateDisplay() {
for (size_t iii=0; iii<m_subWidget.size(); iii++) {
if (NULL != m_subWidget[iii]) {
m_subWidget[iii]->onRegenerateDisplay();
@ -242,7 +242,7 @@ void ewol::Widget::ContainerN::onRegenerateDisplay() {
}
}
ewol::object::Shared<ewol::Widget> ewol::Widget::ContainerN::getWidgetAtPos(const vec2& _pos) {
ewol::object::Shared<ewol::Widget> ewol::widget::ContainerN::getWidgetAtPos(const vec2& _pos) {
if (true == isHide()) {
return NULL;
}
@ -254,7 +254,7 @@ ewol::object::Shared<ewol::Widget> ewol::Widget::ContainerN::getWidgetAtPos(cons
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[iii]->getWidgetAtPos(_pos);
ewol::object::Shared<ewol::Widget> tmpWidget = m_subWidget[iii]->getWidgetAtPos(_pos);
if (NULL != tmpWidget) {
return tmpWidget;
}
@ -267,7 +267,7 @@ ewol::object::Shared<ewol::Widget> ewol::Widget::ContainerN::getWidgetAtPos(cons
};
bool ewol::Widget::ContainerN::loadXML(exml::Element* _node) {
bool ewol::widget::ContainerN::loadXML(exml::Element* _node) {
if (NULL == _node) {
return false;
}
@ -298,7 +298,7 @@ bool ewol::Widget::ContainerN::loadXML(exml::Element* _node) {
continue;
}
EWOL_DEBUG("[" << getId() << "] {" << getObjectType() << "} load new element : \"" << widgetName << "\"");
ewol::object::Shared<ewol::Widget> *subWidget = getWidgetManager().create(widgetName);
ewol::Widget* subWidget = getWidgetManager().create(widgetName);
if (subWidget == NULL) {
EWOL_ERROR ("[" << getId() << "] {" << getObjectType() << "} (l "<<pNode->getPos()<<") Can not create the widget : \"" << widgetName << "\"");
continue;
@ -318,7 +318,7 @@ bool ewol::Widget::ContainerN::loadXML(exml::Element* _node) {
}
void ewol::Widget::ContainerN::setOffset(const vec2& _newVal) {
void ewol::widget::ContainerN::setOffset(const vec2& _newVal) {
if (m_offset != _newVal) {
ewol::Widget::setOffset(_newVal);
// recalculate the new sise and position of sub widget ...

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

@ -17,23 +17,23 @@
#define __class__ "ContextMenu"
const char* const ewol::Widget::ContextMenu::configArrowPosition = "arrow-position";
const char* const ewol::Widget::ContextMenu::configArrowMode = "arrow-mode";
const char* const ewol::Widget::ContextMenu::configShaper = "shaper";
const char* const ewol::widget::ContextMenu::configArrowPosition = "arrow-position";
const char* const ewol::widget::ContextMenu::configArrowMode = "arrow-mode";
const char* const ewol::widget::ContextMenu::configShaper = "shaper";
static ewol::object::Shared<ewol::Widget> Create() {
return new ewol::Widget::ContextMenu();
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::object::Shared<ewol::widget::Manager> _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&Create);
}
ewol::Widget::ContextMenu::ContextMenu(const std::string& _shaperName) :
ewol::widget::ContextMenu::ContextMenu(const std::string& _shaperName) :
m_shaper(_shaperName) {
addObjectType("ewol::Widget::ContextMenu");
addObjectType("ewol::widget::ContextMenu");
// add basic configurations :
registerConfig(configArrowPosition, "vec2", NULL, "position of the arrow");
registerConfig(configArrowMode, "list", "none;left;buttom;right;top", "Position of the arrow in the pop-up");
@ -53,17 +53,17 @@ ewol::Widget::ContextMenu::ContextMenu(const std::string& _shaperName) :
setMouseLimit(1);
}
ewol::Widget::ContextMenu::~ContextMenu() {
ewol::widget::ContextMenu::~ContextMenu() {
}
void ewol::Widget::ContextMenu::setShaperName(const std::string& _shaperName) {
void ewol::widget::ContextMenu::setShaperName(const std::string& _shaperName) {
m_shaper.setSource(_shaperName);
markToRedraw();
}
void ewol::Widget::ContextMenu::calculateSize(const vec2& _availlable) {
void ewol::widget::ContextMenu::calculateSize(const vec2& _availlable) {
//EWOL_DEBUG("CalculateSize=" << availlable);
// pop-up fill all the display :
m_size = _availlable;
@ -131,9 +131,9 @@ void ewol::Widget::ContextMenu::calculateSize(const vec2& _availlable) {
}
void ewol::Widget::ContextMenu::calculateMinMaxSize() {
void ewol::widget::ContextMenu::calculateMinMaxSize() {
// call main class to calculate the min size...
ewol::Widget::Container::calculateMinMaxSize();
ewol::widget::Container::calculateMinMaxSize();
// add padding of the display
ewol::Padding padding = m_shaper.getPadding();
m_minSize += vec2(padding.x(), padding.y());
@ -142,15 +142,15 @@ void ewol::Widget::ContextMenu::calculateMinMaxSize() {
}
void ewol::Widget::ContextMenu::onDraw() {
void ewol::widget::ContextMenu::onDraw() {
m_compositing.draw();
m_shaper.draw();
}
void ewol::Widget::ContextMenu::onRegenerateDisplay() {
void ewol::widget::ContextMenu::onRegenerateDisplay() {
// call upper class :
ewol::Widget::Container::onRegenerateDisplay();
ewol::widget::Container::onRegenerateDisplay();
if (needRedraw() == false) {
return;
}
@ -214,9 +214,9 @@ void ewol::Widget::ContextMenu::onRegenerateDisplay() {
vec2ClipInt32(shaperSize));
}
bool ewol::Widget::ContextMenu::onEventInput(const ewol::event::Input& _event) {
bool ewol::widget::ContextMenu::onEventInput(const ewol::event::Input& _event) {
if (_event.getId() > 0) {
if (NULL != ewol::Widget::Container::getWidgetAtPos(_event.getPos())) {
if (NULL != ewol::widget::Container::getWidgetAtPos(_event.getPos())) {
return false;
}
if( _event.getStatus() == ewol::key::statusDown
@ -234,15 +234,15 @@ bool ewol::Widget::ContextMenu::onEventInput(const ewol::event::Input& _event) {
}
void ewol::Widget::ContextMenu::setPositionMark(enum markPosition _position, vec2 _arrowPos) {
void ewol::widget::ContextMenu::setPositionMark(enum markPosition _position, vec2 _arrowPos) {
EWOL_DEBUG("set context menu at the position : " << _arrowPos);
m_arrawBorder = _position;
m_arrowPos = _arrowPos;
markToRedraw();
}
ewol::object::Shared<ewol::Widget> ewol::Widget::ContextMenu::getWidgetAtPos(const vec2& _pos) {
ewol::object::Shared<ewol::Widget> val = ewol::Widget::Container::getWidgetAtPos(_pos);
ewol::object::Shared<ewol::Widget> ewol::widget::ContextMenu::getWidgetAtPos(const vec2& _pos) {
ewol::object::Shared<ewol::Widget> val = ewol::widget::Container::getWidgetAtPos(_pos);
if (NULL != val) {
return val;
}
@ -250,8 +250,8 @@ ewol::object::Shared<ewol::Widget> ewol::Widget::ContextMenu::getWidgetAtPos(con
}
bool ewol::Widget::ContextMenu::onSetConfig(const ewol::object::Config& _conf) {
if (true == ewol::Widget::Container::onSetConfig(_conf)) {
bool ewol::widget::ContextMenu::onSetConfig(const ewol::object::Config& _conf) {
if (true == ewol::widget::Container::onSetConfig(_conf)) {
return true;
}
if (_conf.getConfig() == configArrowPosition) {
@ -279,8 +279,8 @@ bool ewol::Widget::ContextMenu::onSetConfig(const ewol::object::Config& _conf) {
return false;
}
bool ewol::Widget::ContextMenu::onGetConfig(const char* _config, std::string& _result) const {
if (true == ewol::Widget::Container::onGetConfig(_config, _result)) {
bool ewol::widget::ContextMenu::onGetConfig(const char* _config, std::string& _result) const {
if (true == ewol::widget::Container::onGetConfig(_config, _result)) {
return true;
}
if (_config == configArrowPosition) {

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

@ -22,7 +22,7 @@ namespace ewol {
/**
* @ingroup ewolWidgetGroup
*/
class ContextMenu : public ewol::Widget::Container {
class ContextMenu : public ewol::widget::Container {
public:
enum markPosition {
markTop,
@ -32,7 +32,7 @@ namespace ewol {
markNone
};
public:
static void init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager);
static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager);
// Config list of properties
static const char* const configArrowPosition;
static const char* const configArrowMode;

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

@ -29,24 +29,24 @@ const char * const ewolEventEntrySelect = "ewol-widget-entry-event-internal-sele
#define STATUS_HOVER (1)
#define STATUS_SELECTED (2)
static ewol::object::Shared<ewol::Widget> create() {
return new ewol::Widget::Entry();
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::object::Shared<ewol::widget::Manager> _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&create);
}
const char * const ewol::Widget::Entry::eventClick = "click";
const char * const ewol::Widget::Entry::eventEnter = "enter";
const char * const ewol::Widget::Entry::eventModify = "modify";
const char * const ewol::widget::Entry::eventClick = "click";
const char * const ewol::widget::Entry::eventEnter = "enter";
const char * const ewol::widget::Entry::eventModify = "modify";
const char* const ewol::Widget::Entry::configMaxChar = "max";
const char* const ewol::Widget::Entry::configRegExp = "regExp";
const char* const ewol::Widget::Entry::configEmptyMessage = "emptytext";
const char* const ewol::Widget::Entry::configValue = "value";
const char* const ewol::widget::Entry::configMaxChar = "max";
const char* const ewol::widget::Entry::configRegExp = "regExp";
const char* const ewol::widget::Entry::configEmptyMessage = "emptytext";
const char* const ewol::widget::Entry::configValue = "value";
ewol::Widget::Entry::Entry(std::string _newData) :
ewol::widget::Entry::Entry(std::string _newData) :
m_shaper("THEME:GUI:Entry.json"),
m_data(""),
m_maxCharacter(0x7FFFFFFF),
@ -57,7 +57,7 @@ ewol::Widget::Entry::Entry(std::string _newData) :
m_displayCursorPos(0),
m_displayCursorPosSelection(0),
m_textWhenNothing("") {
addObjectType("ewol::Widget::Entry");
addObjectType("ewol::widget::Entry");
m_colorIdTextFg = m_shaper.requestColor("text-foreground");
m_colorIdTextBg = m_shaper.requestColor("text-background");
m_colorIdCursor = m_shaper.requestColor("text-cursor");
@ -83,12 +83,12 @@ ewol::Widget::Entry::Entry(std::string _newData) :
}
ewol::Widget::Entry::~Entry() {
ewol::widget::Entry::~Entry() {
}
void ewol::Widget::Entry::setMaxChar(int32_t _nbMax) {
void ewol::widget::Entry::setMaxChar(int32_t _nbMax) {
if (_nbMax <= 0) {
m_maxCharacter = 0x7FFFFFFF;
} else {
@ -97,7 +97,7 @@ void ewol::Widget::Entry::setMaxChar(int32_t _nbMax) {
}
void ewol::Widget::Entry::calculateMinMaxSize() {
void ewol::widget::Entry::calculateMinMaxSize() {
// call main class
ewol::Widget::calculateMinMaxSize();
// get generic padding
@ -112,7 +112,7 @@ void ewol::Widget::Entry::calculateMinMaxSize() {
}
void ewol::Widget::Entry::setValue(const std::string& _newData) {
void ewol::widget::Entry::setValue(const std::string& _newData) {
std::string newData = _newData;
if ((int64_t)newData.size() > m_maxCharacter) {
newData = std::string(_newData, 0, m_maxCharacter);
@ -129,13 +129,13 @@ void ewol::Widget::Entry::setValue(const std::string& _newData) {
}
void ewol::Widget::Entry::onDraw() {
void ewol::widget::Entry::onDraw() {
m_shaper.draw();
m_text.draw();
}
void ewol::Widget::Entry::onRegenerateDisplay() {
void ewol::widget::Entry::onRegenerateDisplay() {
if (true == needRedraw()) {
m_shaper.clear();
m_text.clear();
@ -192,7 +192,7 @@ void ewol::Widget::Entry::onRegenerateDisplay() {
}
void ewol::Widget::Entry::updateCursorPosition(const vec2& _pos, bool _selection) {
void ewol::widget::Entry::updateCursorPosition(const vec2& _pos, bool _selection) {
ewol::Padding padding = m_shaper.getPadding();
vec2 relPos = relativePosition(_pos);
@ -229,7 +229,7 @@ void ewol::Widget::Entry::updateCursorPosition(const vec2& _pos, bool _selection
}
void ewol::Widget::Entry::removeSelected() {
void ewol::widget::Entry::removeSelected() {
if (m_displayCursorPosSelection == m_displayCursorPos) {
// nothing to cut ...
return;
@ -248,7 +248,7 @@ void ewol::Widget::Entry::removeSelected() {
}
void ewol::Widget::Entry::copySelectionToClipBoard(enum ewol::context::clipBoard::clipboardListe _clipboardID) {
void ewol::widget::Entry::copySelectionToClipBoard(enum ewol::context::clipBoard::clipboardListe _clipboardID) {
if (m_displayCursorPosSelection == m_displayCursorPos) {
// nothing to cut ...
return;
@ -265,7 +265,7 @@ void ewol::Widget::Entry::copySelectionToClipBoard(enum ewol::context::clipBoard
}
bool ewol::Widget::Entry::onEventInput(const ewol::event::Input& _event) {
bool ewol::widget::Entry::onEventInput(const ewol::event::Input& _event) {
//EWOL_DEBUG("Event on Entry ... type=" << (int32_t)type << " id=" << IdInput);
if (1 == _event.getId()) {
if (ewol::key::statusSingle == _event.getStatus()) {
@ -358,7 +358,7 @@ bool ewol::Widget::Entry::onEventInput(const ewol::event::Input& _event) {
}
bool ewol::Widget::Entry::onEventEntry(const ewol::event::Entry& _event) {
bool ewol::widget::Entry::onEventEntry(const ewol::event::Entry& _event) {
if (_event.getType() == ewol::key::keyboardChar) {
if(_event.getStatus() == ewol::key::statusDown) {
//EWOL_DEBUG("Entry input data ... : \"" << unicodeData << "\" " );
@ -430,7 +430,7 @@ bool ewol::Widget::Entry::onEventEntry(const ewol::event::Entry& _event) {
return false;
}
void ewol::Widget::Entry::setInternalValue(const std::string& _newData) {
void ewol::widget::Entry::setInternalValue(const std::string& _newData) {
std::string previous = m_data;
// check the RegExp :
if (_newData.size()>0) {
@ -449,7 +449,7 @@ void ewol::Widget::Entry::setInternalValue(const std::string& _newData) {
markToRedraw();
}
void ewol::Widget::Entry::onEventClipboard(enum ewol::context::clipBoard::clipboardListe _clipboardID) {
void ewol::widget::Entry::onEventClipboard(enum ewol::context::clipBoard::clipboardListe _clipboardID) {
// remove curent selected data ...
removeSelected();
// get current selection / Copy :
@ -473,7 +473,7 @@ void ewol::Widget::Entry::onEventClipboard(enum ewol::context::clipBoard::clipbo
}
void ewol::Widget::Entry::onReceiveMessage(const ewol::object::Message& _msg) {
void ewol::widget::Entry::onReceiveMessage(const ewol::object::Message& _msg) {
ewol::Widget::onReceiveMessage(_msg);
if(_msg.getMessage() == ewolEventEntryClean) {
m_data = "";
@ -500,11 +500,11 @@ void ewol::Widget::Entry::onReceiveMessage(const ewol::object::Message& _msg) {
}
}
void ewol::Widget::Entry::markToUpdateTextPosition() {
void ewol::widget::Entry::markToUpdateTextPosition() {
m_needUpdateTextPos=true;
}
void ewol::Widget::Entry::updateTextPosition() {
void ewol::widget::Entry::updateTextPosition() {
if (false == m_needUpdateTextPos) {
return;
}
@ -539,35 +539,35 @@ void ewol::Widget::Entry::updateTextPosition() {
}
}
void ewol::Widget::Entry::onGetFocus() {
void ewol::widget::Entry::onGetFocus() {
m_displayCursor = true;
changeStatusIn(STATUS_SELECTED);
showKeyboard();
markToRedraw();
}
void ewol::Widget::Entry::onLostFocus() {
void ewol::widget::Entry::onLostFocus() {
m_displayCursor = false;
changeStatusIn(STATUS_NORMAL);
hideKeyboard();
markToRedraw();
}
void ewol::Widget::Entry::changeStatusIn(int32_t _newStatusId) {
void ewol::widget::Entry::changeStatusIn(int32_t _newStatusId) {
if (true == m_shaper.changeStatusIn(_newStatusId) ) {
periodicCallEnable();
markToRedraw();
}
}
void ewol::Widget::Entry::periodicCall(const ewol::event::Time& _event) {
void ewol::widget::Entry::periodicCall(const ewol::event::Time& _event) {
if (false == m_shaper.periodicCall(_event) ) {
periodicCallDisable();
}
markToRedraw();
}
void ewol::Widget::Entry::setRegExp(const std::string& _expression) {
void ewol::widget::Entry::setRegExp(const std::string& _expression) {
std::string previousRegExp = m_regExp.getRegExp();
EWOL_DEBUG("change input regExp \"" << previousRegExp << "\" == > \"" << _expression << "\"");
m_regExp.compile(_expression);
@ -577,12 +577,12 @@ void ewol::Widget::Entry::setRegExp(const std::string& _expression) {
}
}
void ewol::Widget::Entry::setEmptyText(const std::string& _text) {
void ewol::widget::Entry::setEmptyText(const std::string& _text) {
m_textWhenNothing = _text;
markToRedraw();
}
bool ewol::Widget::Entry::onSetConfig(const ewol::object::Config& _conf) {
bool ewol::widget::Entry::onSetConfig(const ewol::object::Config& _conf) {
if (true == ewol::Widget::onSetConfig(_conf)) {
return true;
}
@ -605,7 +605,7 @@ bool ewol::Widget::Entry::onSetConfig(const ewol::object::Config& _conf) {
return false;
}
bool ewol::Widget::Entry::onGetConfig(const char* _config, std::string& _result) const {
bool ewol::widget::Entry::onGetConfig(const char* _config, std::string& _result) const {
if (true == ewol::Widget::onGetConfig(_config, _result)) {
return true;
}

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::object::Shared<ewol::widget::Manager> _widgetManager);
private:
ewol::compositing::Shaper m_shaper;
int32_t m_colorIdTextFg; //!< color property of the text foreground

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

@ -15,31 +15,31 @@
#define __class__ "Gird"
static ewol::object::Shared<ewol::Widget> create() {
return new ewol::Widget::Gird();
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::object::Shared<ewol::widget::Manager> _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&create);
}
ewol::Widget::Gird::Gird(int32_t _colNumber) :
ewol::widget::Gird::Gird(int32_t _colNumber) :
m_sizeRow(0),
m_tmpWidget(NULL),
m_gavityButtom(true),
m_borderSize(0,0) {
addObjectType("ewol::Widget::Gird");
addObjectType("ewol::widget::Gird");
setColNumber(_colNumber);
requestUpdateSize();
}
ewol::Widget::Gird::~Gird() {
ewol::widget::Gird::~Gird() {
EWOL_DEBUG("[" << getId() << "]={" << getObjectType() << "} Gird : destroy");
subWidgetRemoveAll();
}
void ewol::Widget::Gird::setBorderSize(const ivec2& _newBorderSize) {
void ewol::widget::Gird::setBorderSize(const ivec2& _newBorderSize) {
m_borderSize = _newBorderSize;
if (m_borderSize.x() < 0) {
EWOL_ERROR("Try to set a border size <0 on x : " << m_borderSize.x() << " == > restore to 0");
@ -53,7 +53,7 @@ void ewol::Widget::Gird::setBorderSize(const ivec2& _newBorderSize) {
requestUpdateSize();
}
void ewol::Widget::Gird::calculateSize(const vec2& _availlable) {
void ewol::widget::Gird::calculateSize(const vec2& _availlable) {
//EWOL_DEBUG("Update size");
m_size = _availlable;
m_size -= m_borderSize*2;
@ -91,7 +91,7 @@ void ewol::Widget::Gird::calculateSize(const vec2& _availlable) {
markToRedraw();
}
void ewol::Widget::Gird::calculateMinMaxSize() {
void ewol::widget::Gird::calculateMinMaxSize() {
for (size_t iii=0; iii<m_sizeCol.size(); iii++ ){
if (m_sizeCol[iii] <= 0) {
m_sizeCol[iii] = 0;
@ -137,7 +137,7 @@ void ewol::Widget::Gird::calculateMinMaxSize() {
//EWOL_DEBUG("Vert Result : expand="<< m_userExpand << " minSize="<< m_minSize);
}
void ewol::Widget::Gird::setColNumber(int32_t _colNumber) {
void ewol::widget::Gird::setColNumber(int32_t _colNumber) {
if ((int64_t)m_sizeCol.size() > _colNumber) {
size_t errorControl = m_subWidget.size();
// remove subWidget :
@ -145,11 +145,10 @@ void ewol::Widget::Gird::setColNumber(int32_t _colNumber) {
if (m_subWidget[iii].col>(_colNumber-1)) {
// out of bounds : must remove it ...
if (m_subWidget[iii].widget != NULL) {
delete (m_subWidget[iii].widget);
m_subWidget[iii].widget.reset();
// no remove, this element is removed with the function onObjectRemove == > it does not exist anymore ...
if (errorControl == m_subWidget.size()) {
EWOL_CRITICAL("[" << getId() << "] The number of element might have been reduced ... == > it is not the case ==> the herited class must call the \"OnObjectRemove\" function...");
m_subWidget[iii].widget = NULL;
}
} else {
EWOL_WARNING("[" << getId() << "] Must not have null pointer on the subWidget list ...");
@ -168,7 +167,7 @@ void ewol::Widget::Gird::setColNumber(int32_t _colNumber) {
}
}
void ewol::Widget::Gird::setColSize(int32_t _colId, int32_t _size) {
void ewol::widget::Gird::setColSize(int32_t _colId, int32_t _size) {
if ((int64_t)m_sizeCol.size() > _colId) {
m_sizeCol[_colId] = _size;
} else {
@ -178,11 +177,11 @@ void ewol::Widget::Gird::setColSize(int32_t _colId, int32_t _size) {
}
}
void ewol::Widget::Gird::setRowSize(int32_t _size) {
void ewol::widget::Gird::setRowSize(int32_t _size) {
m_sizeRow = _size;
}
int32_t ewol::Widget::Gird::getColSize(int32_t _colId) {
int32_t ewol::widget::Gird::getColSize(int32_t _colId) {
if ((int64_t)m_sizeCol.size() > _colId) {
if (m_sizeCol[_colId] <= 0) {
return 0;
@ -193,20 +192,19 @@ int32_t ewol::Widget::Gird::getColSize(int32_t _colId) {
return 0;
}
int32_t ewol::Widget::Gird::getRowSize() {
int32_t ewol::widget::Gird::getRowSize() {
return m_sizeRow;
}
void ewol::Widget::Gird::subWidgetRemoveAll() {
void ewol::widget::Gird::subWidgetRemoveAll() {
size_t errorControl = m_subWidget.size();
// the size automaticly decrement with the auto call of the onObjectRemove function
while (m_subWidget.size() > 0 ) {
if (NULL != m_subWidget[0].widget) {
delete(m_subWidget[0].widget);
m_subWidget[0].widget.reset();
// no remove, this element is removed with the function onObjectRemove == > it does not exist anymore ...
if (errorControl == m_subWidget.size()) {
EWOL_CRITICAL("[" << getId() << "] The number of element might have been reduced ... == > it is not the case ==> the herited class must call the \"OnObjectRemove\" function...");
m_subWidget[0].widget = NULL;
}
} else {
EWOL_WARNING("[" << getId() << "] Must not have null pointer on the subWidget list ...");
@ -218,7 +216,7 @@ void ewol::Widget::Gird::subWidgetRemoveAll() {
}
void ewol::Widget::Gird::subWidgetAdd(int32_t _colId, int32_t _rowId, ewol::Widget* _newWidget) {
void ewol::widget::Gird::subWidgetAdd(int32_t _colId, int32_t _rowId, ewol::Widget* _newWidget) {
if (NULL == _newWidget) {
return;
}
@ -247,7 +245,7 @@ void ewol::Widget::Gird::subWidgetAdd(int32_t _colId, int32_t _rowId, ewol::Widg
m_tmpWidget = m_subWidget[iii].widget;
m_subWidget[iii].widget = _newWidget;
if (NULL != m_tmpWidget) {
delete(m_tmpWidget);
m_tmpWidget.reset();
if (m_tmpWidget != NULL) {
EWOL_CRITICAL("[" << getId() << "] Error while replacing a widget ... == > never call when free");
m_tmpWidget = NULL;
@ -260,28 +258,17 @@ void ewol::Widget::Gird::subWidgetAdd(int32_t _colId, int32_t _rowId, ewol::Widg
m_subWidget.push_back(prop);
}
void ewol::Widget::Gird::subWidgetRemove(ewol::Widget* _newWidget)
{
if (NULL == _newWidget) {
return;
}
size_t errorControl = m_subWidget.size();
void ewol::widget::Gird::subWidgetRemove(ewol::object::Shared<ewol::Widget> _newWidget) {
for (size_t iii=0; iii<m_subWidget.size(); iii++) {
if (_newWidget == m_subWidget[iii].widget) {
delete(m_subWidget[iii].widget);
// no remove, this element is removed with the function onObjectRemove == > it does not exist anymore ...
if (errorControl == m_subWidget.size()) {
EWOL_CRITICAL("[" << getId() << "] The number of element might have been reduced ... == > it is not the case ==> the herited class must call the \"OnObjectRemove\" function...");
m_subWidget[iii].widget = NULL;
m_subWidget.erase(m_subWidget.begin()+iii);
}
return;
}
}
EWOL_WARNING("[" << getId() << "] Can not remove unExistant widget");
}
void ewol::Widget::Gird::subWidgetRemove(int32_t _colId, int32_t _rowId) {
void ewol::widget::Gird::subWidgetRemove(int32_t _colId, int32_t _rowId) {
if (_colId<0 || _rowId<0) {
EWOL_WARNING("[" << getId() << "] try to remove widget with id < 0 col=" << _colId << " row=" << _rowId);
return;
@ -291,40 +278,26 @@ void ewol::Widget::Gird::subWidgetRemove(int32_t _colId, int32_t _rowId) {
for (size_t iii=0; iii<m_subWidget.size(); iii++) {
if( m_subWidget[iii].row == _rowId
&& m_subWidget[iii].col == _colId) {
if (m_subWidget[iii].widget == NULL) {
EWOL_WARNING("[" << getId() << "] remove NULL widget");
m_subWidget.erase(m_subWidget.begin()+iii);
} else {
// The element already exist == > replace it ...
if (m_subWidget[iii].widget != NULL) {
delete(m_subWidget[iii].widget);
if (errorControl == m_subWidget.size()) {
EWOL_CRITICAL("[" << getId() << "] The number of element might have been reduced ... == > it is not the case ==> the herited class must call the \"OnObjectRemove\" function...");
m_subWidget[iii].widget = NULL;
m_subWidget.erase(m_subWidget.begin()+iii);
}
}
}
return;
}
}
EWOL_WARNING("[" << getId() << "] Can not remove unExistant widget");
}
void ewol::Widget::Gird::subWidgetUnLink(ewol::Widget* _newWidget) {
void ewol::widget::Gird::subWidgetUnLink(ewol::object::Shared<ewol::Widget> _newWidget) {
if (NULL == _newWidget) {
return;
}
for (size_t iii=0; iii<m_subWidget.size(); iii++) {
if (_newWidget == m_subWidget[iii].widget) {
m_subWidget[iii].widget = NULL;
m_subWidget.erase(m_subWidget.begin()+iii);
return;
}
}
}
void ewol::Widget::Gird::subWidgetUnLink(int32_t _colId, int32_t _rowId) {
void ewol::widget::Gird::subWidgetUnLink(int32_t _colId, int32_t _rowId) {
if (_colId<0 || _rowId<0) {
EWOL_WARNING("[" << getId() << "] try to Unlink widget with id < 0 col=" << _colId << " row=" << _rowId);
return;
@ -333,7 +306,6 @@ void ewol::Widget::Gird::subWidgetUnLink(int32_t _colId, int32_t _rowId) {
for (size_t iii=0; iii<m_subWidget.size(); iii++) {
if( m_subWidget[iii].row == _rowId
&& m_subWidget[iii].col == _colId) {
m_subWidget[iii].widget = NULL;
m_subWidget.erase(m_subWidget.begin()+iii);
return;
}
@ -341,7 +313,7 @@ void ewol::Widget::Gird::subWidgetUnLink(int32_t _colId, int32_t _rowId) {
EWOL_WARNING("[" << getId() << "] Can not unLink unExistant widget");
}
void ewol::Widget::Gird::systemDraw(const ewol::DrawProperty& _displayProp) {
void ewol::widget::Gird::systemDraw(const ewol::DrawProperty& _displayProp) {
ewol::Widget::systemDraw(_displayProp);
for (size_t iii=0; iii<m_subWidget.size(); iii++) {
if (NULL != m_subWidget[iii].widget) {
@ -350,7 +322,7 @@ void ewol::Widget::Gird::systemDraw(const ewol::DrawProperty& _displayProp) {
}
}
void ewol::Widget::Gird::onRegenerateDisplay() {
void ewol::widget::Gird::onRegenerateDisplay() {
for (size_t iii=0; iii<m_subWidget.size(); iii++) {
if (NULL != m_subWidget[iii].widget) {
m_subWidget[iii].widget->onRegenerateDisplay();
@ -358,7 +330,7 @@ void ewol::Widget::Gird::onRegenerateDisplay() {
}
}
ewol::object::Shared<ewol::Widget> * ewol::Widget::Gird::getWidgetAtPos(const vec2& _pos) {
ewol::object::Shared<ewol::Widget> ewol::widget::Gird::getWidgetAtPos(const vec2& _pos) {
if (true == isHide()) {
return NULL;
}
@ -370,7 +342,7 @@ ewol::object::Shared<ewol::Widget> * ewol::Widget::Gird::getWidgetAtPos(const ve
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[iii].widget->getWidgetAtPos(_pos);
ewol::object::Shared<ewol::Widget> tmpWidget = m_subWidget[iii].widget->getWidgetAtPos(_pos);
if (NULL != tmpWidget) {
return tmpWidget;
}
@ -382,7 +354,7 @@ ewol::object::Shared<ewol::Widget> * ewol::Widget::Gird::getWidgetAtPos(const ve
return NULL;
}
void ewol::Widget::Gird::onObjectRemove(ewol::object::Shared<ewol::Object> * _removeObject) {
void ewol::widget::Gird::onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject) {
// First step call parrent :
ewol::Widget::onObjectRemove(_removeObject);
// second step find if in all the elements ...

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::object::Shared<ewol::widget::Manager> _widgetManager);
private:
class GirdProperties {
public:

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

@ -16,33 +16,33 @@
#undef __class__
#define __class__ "Image"
static ewol::object::Shared<ewol::Widget> create() {
return new ewol::Widget::Image();
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::object::Shared<ewol::widget::Manager> _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&create);
}
const char * const ewol::Widget::Image::eventPressed = "pressed";
const char * const ewol::widget::Image::eventPressed = "pressed";
const char * const ewol::Widget::Image::configRatio = "ratio";
const char * const ewol::Widget::Image::configSize = "size";
const char * const ewol::Widget::Image::configBorder = "border";
const char * const ewol::Widget::Image::configSource = "src";
const char * const ewol::Widget::Image::configDistanceField = "distance-field";
const char * const ewol::Widget::Image::configPartStart = "part-start";
const char * const ewol::Widget::Image::configPartStop = "part-stop";
const char * const ewol::widget::Image::configRatio = "ratio";
const char * const ewol::widget::Image::configSize = "size";
const char * const ewol::widget::Image::configBorder = "border";
const char * const ewol::widget::Image::configSource = "src";
const char * const ewol::widget::Image::configDistanceField = "distance-field";
const char * const ewol::widget::Image::configPartStart = "part-start";
const char * const ewol::widget::Image::configPartStop = "part-stop";
ewol::Widget::Image::Image(const std::string& _file, const ewol::Dimension& _border) :
ewol::widget::Image::Image(const std::string& _file, const ewol::Dimension& _border) :
m_colorProperty(NULL),
m_colorId(-1),
m_imageSize(vec2(0.0f,0.0f)),
m_keepRatio(true),
m_posStart(0.0f,0.0f),
m_posStop(1.0f,1.0f) {
addObjectType("ewol::Widget::Image");
addObjectType("ewol::widget::Image");
addEventId(eventPressed);
registerConfig(configRatio, "bool", NULL, "Keep ratio of the image");
registerConfig(configSize, "Dimension", NULL, "Basic display size of the image");
@ -58,11 +58,11 @@ ewol::Widget::Image::Image(const std::string& _file, const ewol::Dimension& _bor
set(_file, _border);
}
ewol::Widget::Image::~Image() {
ewol::widget::Image::~Image() {
ewol::resource::ColorFile::release(m_colorProperty);
}
void ewol::Widget::Image::setFile(const std::string& _file) {
void ewol::widget::Image::setFile(const std::string& _file) {
EWOL_VERBOSE("Set Image : " << _file);
if (m_fileName != _file) {
// copy data :
@ -74,7 +74,7 @@ void ewol::Widget::Image::setFile(const std::string& _file) {
}
}
void ewol::Widget::Image::setBorder(const ewol::Dimension& _border) {
void ewol::widget::Image::setBorder(const ewol::Dimension& _border) {
EWOL_VERBOSE("Set border=" << _border);
// copy data :
m_border = _border;
@ -84,7 +84,7 @@ void ewol::Widget::Image::setBorder(const ewol::Dimension& _border) {
requestUpdateSize();
}
void ewol::Widget::Image::setKeepRatio(bool _keep) {
void ewol::widget::Image::setKeepRatio(bool _keep) {
if (m_keepRatio == _keep) {
return;
}
@ -95,7 +95,7 @@ void ewol::Widget::Image::setKeepRatio(bool _keep) {
requestUpdateSize();
}
void ewol::Widget::Image::setStartPos(const vec2& _pos) {
void ewol::widget::Image::setStartPos(const vec2& _pos) {
if (m_posStart == _pos) {
return;
}
@ -106,7 +106,7 @@ void ewol::Widget::Image::setStartPos(const vec2& _pos) {
requestUpdateSize();
}
void ewol::Widget::Image::setStopPos(const vec2& _pos) {
void ewol::widget::Image::setStopPos(const vec2& _pos) {
if (m_posStop == _pos) {
return;
}
@ -117,7 +117,7 @@ void ewol::Widget::Image::setStopPos(const vec2& _pos) {
requestUpdateSize();
}
void ewol::Widget::Image::setImageSize(const ewol::Dimension& _size) {
void ewol::widget::Image::setImageSize(const ewol::Dimension& _size) {
EWOL_VERBOSE("Set Image size : " << _size);
if (_size != m_imageSize) {
m_imageSize = _size;
@ -128,7 +128,7 @@ void ewol::Widget::Image::setImageSize(const ewol::Dimension& _size) {
}
}
void ewol::Widget::Image::set(const std::string& _file, const ewol::Dimension& _border) {
void ewol::widget::Image::set(const std::string& _file, const ewol::Dimension& _border) {
EWOL_VERBOSE("Set Image : " << _file << " border=" << _border);
// copy data :
if (m_border != _border) {
@ -139,11 +139,11 @@ void ewol::Widget::Image::set(const std::string& _file, const ewol::Dimension& _
setFile(_file);
}
void ewol::Widget::Image::onDraw() {
void ewol::widget::Image::onDraw() {
m_compositing.draw();
}
void ewol::Widget::Image::onRegenerateDisplay() {
void ewol::widget::Image::onRegenerateDisplay() {
if (true == needRedraw()) {
// remove data of the previous composition :
m_compositing.clear();
@ -197,7 +197,7 @@ void ewol::Widget::Image::onRegenerateDisplay() {
}
}
void ewol::Widget::Image::calculateMinMaxSize() {
void ewol::widget::Image::calculateMinMaxSize() {
vec2 imageBoder = m_border.getPixel()*2.0f;
vec2 imageSize = m_imageSize.getPixel();
if (imageSize!=vec2(0,0)) {
@ -218,7 +218,7 @@ void ewol::Widget::Image::calculateMinMaxSize() {
}
bool ewol::Widget::Image::onEventInput(const ewol::event::Input& _event) {
bool ewol::widget::Image::onEventInput(const ewol::event::Input& _event) {
//EWOL_DEBUG("Event on BT ...");
if (1 == _event.getId()) {
if(ewol::key::statusSingle == _event.getStatus()) {
@ -229,7 +229,7 @@ bool ewol::Widget::Image::onEventInput(const ewol::event::Input& _event) {
return false;
}
bool ewol::Widget::Image::loadXML(exml::Element* _node) {
bool ewol::widget::Image::loadXML(exml::Element* _node) {
if (NULL == _node) {
return false;
}
@ -268,7 +268,7 @@ bool ewol::Widget::Image::loadXML(exml::Element* _node) {
return true;
}
bool ewol::Widget::Image::onSetConfig(const ewol::object::Config& _conf) {
bool ewol::widget::Image::onSetConfig(const ewol::object::Config& _conf) {
if (true == ewol::Widget::onSetConfig(_conf)) {
return true;
}
@ -303,7 +303,7 @@ bool ewol::Widget::Image::onSetConfig(const ewol::object::Config& _conf) {
return false;
}
bool ewol::Widget::Image::onGetConfig(const char* _config, std::string& _result) const {
bool ewol::widget::Image::onGetConfig(const char* _config, std::string& _result) const {
if (true == ewol::Widget::onGetConfig(_config, _result)) {
return true;
}

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::object::Shared<ewol::widget::Manager> _widgetManager);
protected:
ewol::compositing::Image m_compositing; //!< compositing element of the image.
ewol::resource::ColorFile* m_colorProperty; //!< theme color property

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

@ -12,9 +12,9 @@
#include <ewol/compositing/Image.h>
#include <ewol/widget/Manager.h>
const char * const ewol::Widget::Joystick::eventEnable = "enable";
const char * const ewol::Widget::Joystick::eventDisable = "disable";
const char * const ewol::Widget::Joystick::eventMove = "move";
const char * const ewol::widget::Joystick::eventEnable = "enable";
const char * const ewol::widget::Joystick::eventDisable = "disable";
const char * const ewol::widget::Joystick::eventMove = "move";
static bool l_displayBackground(true);
static std::string l_background("");
@ -24,8 +24,8 @@ static float l_ratio(1.0/7.0);
#undef __class__
#define __class__ "Joystick"
ewol::Widget::Joystick::Joystick() {
addObjectType("ewol::Widget::Joystick");
ewol::widget::Joystick::Joystick() {
addObjectType("ewol::widget::Joystick");
addEventId(eventEnable);
addEventId(eventDisable);
addEventId(eventMove);
@ -51,18 +51,18 @@ ewol::Widget::Joystick::Joystick() {
}
ewol::Widget::Joystick::~Joystick() {
ewol::widget::Joystick::~Joystick() {
}
void ewol::Widget::Joystick::calculateSize(const vec2& availlable) {
void ewol::widget::Joystick::calculateSize(const vec2& availlable) {
float minimumSize = etk_min(availlable.x(), availlable.y());
m_size.setValue(minimumSize, minimumSize);
markToRedraw();
}
void ewol::Widget::Joystick::onRegenerateDisplay() {
void ewol::widget::Joystick::onRegenerateDisplay() {
if (true == needRedraw()) {
// clean the object list ...
@ -114,7 +114,7 @@ Sine Function: sin(teta) = Opposite / Hypotenuse
Cosine Function: cos(teta) = Adjacent / Hypotenuse
Tangent Function: tan(teta) = Opposite / Adjacent
*/
bool ewol::Widget::Joystick::onEventInput(const ewol::event::Input& _event) {
bool ewol::widget::Joystick::onEventInput(const ewol::event::Input& _event) {
/*
if (1 == IdInput) {
if( ewol::key::statusDown == typeEvent
@ -173,7 +173,7 @@ bool ewol::Widget::Joystick::onEventInput(const ewol::event::Input& _event) {
}
void ewol::Widget::Joystick::ratio(float newRatio) {
void ewol::widget::Joystick::ratio(float newRatio) {
if (newRatio > 1) {
newRatio = 1;
}
@ -182,7 +182,7 @@ void ewol::Widget::Joystick::ratio(float newRatio) {
}
void ewol::Widget::Joystick::background(std::string imageNameInData, bool display) {
void ewol::widget::Joystick::background(std::string imageNameInData, bool display) {
// TODO : check if it existed
m_background = imageNameInData;
m_displayBackground = display;
@ -190,14 +190,14 @@ void ewol::Widget::Joystick::background(std::string imageNameInData, bool displa
}
void ewol::Widget::Joystick::foreground(std::string imageNameInData) {
void ewol::widget::Joystick::foreground(std::string imageNameInData) {
// TODO : check if it existed
m_foreground = imageNameInData;
EWOL_INFO("Set default Joystick Foreground at " << m_foreground);
}
void ewol::Widget::Joystick::getProperty(float& distance, float& angle) {
void ewol::widget::Joystick::getProperty(float& distance, float& angle) {
distance = m_distance;
angle = m_angle+M_PI/2;
}

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

@ -15,22 +15,22 @@
#undef __class__
#define __class__ "Label"
const char * const ewol::Widget::Label::eventPressed = "pressed";
const char* const ewol::Widget::Label::configValue = "value";
const char * const ewol::widget::Label::eventPressed = "pressed";
const char* const ewol::widget::Label::configValue = "value";
static ewol::Widget* create() {
return new ewol::Widget::Label();
return new ewol::widget::Label();
}
void ewol::Widget::Label::init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager) {
_widgetManager.addWidgetCreator(__class__,&create);
void ewol::widget::Label::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&create);
}
// TODO : Remove the label name in the constructor ...
ewol::Widget::Label::Label(std::string _newLabel) :
ewol::widget::Label::Label(std::string _newLabel) :
m_colorProperty(NULL),
m_colorDefaultFgText(-1),
m_colorDefaultBgText(-1){
addObjectType("ewol::Widget::Label");
addObjectType("ewol::widget::Label");
m_colorProperty = ewol::resource::ColorFile::keep("THEME:COLOR:Label.json");
if (m_colorProperty != NULL) {
m_colorDefaultFgText = m_colorProperty->request("foreground");
@ -43,11 +43,11 @@ ewol::Widget::Label::Label(std::string _newLabel) :
registerConfig(configValue, "string", NULL, "displayed value string"); // TODO : do not store in attibute...
}
ewol::Widget::Label::~Label() {
ewol::widget::Label::~Label() {
ewol::resource::ColorFile::release(m_colorProperty);
}
void ewol::Widget::Label::calculateMinMaxSize() {
void ewol::widget::Label::calculateMinMaxSize() {
vec2 tmpMax = m_userMaxSize.getPixel();
vec2 tmpMin = m_userMinSize.getPixel();
//EWOL_DEBUG("[" << getId() << "] {" << getObjectType() << "} tmpMax : " << tmpMax);
@ -63,21 +63,21 @@ void ewol::Widget::Label::calculateMinMaxSize() {
EWOL_VERBOSE("[" << getId() << "] {" << getObjectType() << "} Result min size : " << tmpMin << " < " << m_minSize << " < " << tmpMax);
}
void ewol::Widget::Label::setLabel(const std::string& _newLabel) {
void ewol::widget::Label::setLabel(const std::string& _newLabel) {
m_label = std::to_u32string(_newLabel);
markToRedraw();
requestUpdateSize();
}
std::string ewol::Widget::Label::getLabel() const {
std::string ewol::widget::Label::getLabel() const {
return std::to_string(m_label);
}
void ewol::Widget::Label::onDraw() {
void ewol::widget::Label::onDraw() {
m_text.draw();
}
void ewol::Widget::Label::onRegenerateDisplay() {
void ewol::widget::Label::onRegenerateDisplay() {
if (needRedraw() == false) {
return;
}
@ -135,7 +135,7 @@ void ewol::Widget::Label::onRegenerateDisplay() {
m_text.printDecorated(m_label);
}
bool ewol::Widget::Label::onEventInput(const ewol::event::Input& _event) {
bool ewol::widget::Label::onEventInput(const ewol::event::Input& _event) {
//EWOL_DEBUG("Event on Label ...");
if (1 == _event.getId()) {
if (ewol::key::statusSingle == _event.getStatus()) {
@ -147,7 +147,7 @@ bool ewol::Widget::Label::onEventInput(const ewol::event::Input& _event) {
return false;
}
bool ewol::Widget::Label::loadXML(exml::Element* _node) {
bool ewol::widget::Label::loadXML(exml::Element* _node) {
if (NULL == _node) {
return false;
}
@ -159,7 +159,7 @@ bool ewol::Widget::Label::loadXML(exml::Element* _node) {
}
bool ewol::Widget::Label::onSetConfig(const ewol::object::Config& _conf) {
bool ewol::widget::Label::onSetConfig(const ewol::object::Config& _conf) {
if (true == ewol::Widget::onSetConfig(_conf)) {
return true;
}
@ -170,7 +170,7 @@ bool ewol::Widget::Label::onSetConfig(const ewol::object::Config& _conf) {
return false;
}
bool ewol::Widget::Label::onGetConfig(const char* _config, std::string& _result) const {
bool ewol::widget::Label::onGetConfig(const char* _config, std::string& _result) const {
if (true == ewol::Widget::onGetConfig(_config, _result)) {
return true;
}

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::object::Shared<ewol::widget::Manager> _widgetManager);
private:
ewol::compositing::Text m_text; //!< Compositing text element.
std::u32string m_label; //!< decorated text to display.

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

@ -14,22 +14,22 @@
#define __class__ "Layer"
static ewol::Widget* create() {
return new ewol::Widget::Layer();
return new ewol::widget::Layer();
}
void ewol::Widget::Layer::init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager) {
_widgetManager.addWidgetCreator(__class__,&create);
void ewol::widget::Layer::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&create);
}
ewol::Widget::Layer::Layer() {
addObjectType("ewol::Widget::Layer");
ewol::widget::Layer::Layer() {
addObjectType("ewol::widget::Layer");
}
ewol::Widget::Layer::~Layer() {
ewol::widget::Layer::~Layer() {
EWOL_DEBUG("[" << getId() << "] Layer : destroy");
}
ewol::object::Shared<ewol::Widget> ewol::Widget::Layer::getWidgetAtPos(const vec2& _pos) {
ewol::object::Shared<ewol::Widget> ewol::widget::Layer::getWidgetAtPos(const vec2& _pos) {
if (true == isHide()) {
return NULL;
}
@ -41,7 +41,7 @@ ewol::object::Shared<ewol::Widget> ewol::Widget::Layer::getWidgetAtPos(const vec
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[iii]->getWidgetAtPos(_pos);
ewol::object::Shared<ewol::Widget> tmpWidget = m_subWidget[iii]->getWidgetAtPos(_pos);
if (NULL != tmpWidget) {
return tmpWidget;
}

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

@ -19,12 +19,12 @@ namespace ewol {
/**
* @ingroup ewolWidgetGroup
*/
class Layer : public ewol::Widget::ContainerN {
class Layer : public ewol::widget::ContainerN {
public:
/**
* @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::object::Shared<ewol::widget::Manager> _widgetManager);
public:
/**
* @brief Constructor

24
sources/ewol/widget/List.cpp
View File

@ -16,8 +16,8 @@
#define __class__ "List"
ewol::Widget::List::List() {
addObjectType("ewol::Widget::List");
ewol::widget::List::List() {
addObjectType("ewol::widget::List");
m_paddingSizeX = 2;
#ifdef __TARGET_OS__Android
m_paddingSizeY = 10;
@ -28,7 +28,7 @@ ewol::Widget::List::List() {
setCanHaveFocus(true);
}
ewol::Widget::List::~List() {
ewol::widget::List::~List() {
//clean all the object
for (size_t iii=0; iii<m_listOObject.size(); iii++) {
delete(m_listOObject[iii]);
@ -37,7 +37,7 @@ ewol::Widget::List::~List() {
m_listOObject.clear();
}
void ewol::Widget::List::setRawVisible(int32_t _id) {
void ewol::widget::List::setRawVisible(int32_t _id) {
EWOL_DEBUG("Set Raw visible : " << _id);
if (_id<0) {
return;
@ -63,7 +63,7 @@ void ewol::Widget::List::setRawVisible(int32_t _id) {
markToRedraw();
}
void ewol::Widget::List::calculateMinMaxSize() {
void ewol::widget::List::calculateMinMaxSize() {
/*int32_t fontId = getDefaultFontId();
int32_t minWidth = ewol::getWidth(fontId, m_label);
int32_t minHeight = ewol::getHeight(fontId);
@ -73,7 +73,7 @@ void ewol::Widget::List::calculateMinMaxSize() {
m_minSize.setValue(200, 150);
}
void ewol::Widget::List::addOObject(ewol::Compositing* _newObject, int32_t _pos) {
void ewol::widget::List::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;
@ -85,7 +85,7 @@ void ewol::Widget::List::addOObject(ewol::Compositing* _newObject, int32_t _pos)
}
}
void ewol::Widget::List::clearOObjectList() {
void ewol::widget::List::clearOObjectList() {
for (size_t iii=0; iii<m_listOObject.size(); iii++) {
delete(m_listOObject[iii]);
m_listOObject[iii] = NULL;
@ -93,7 +93,7 @@ void ewol::Widget::List::clearOObjectList() {
m_listOObject.clear();
}
void ewol::Widget::List::onDraw() {
void ewol::widget::List::onDraw() {
for (size_t iii=0; iii<m_listOObject.size(); iii++) {
if (NULL != m_listOObject[iii]) {
m_listOObject[iii]->draw();
@ -102,7 +102,7 @@ void ewol::Widget::List::onDraw() {
WidgetScrolled::onDraw();
}
void ewol::Widget::List::onRegenerateDisplay() {
void ewol::widget::List::onRegenerateDisplay() {
if (true == needRedraw()) {
// clean the object list ...
@ -212,7 +212,7 @@ void ewol::Widget::List::onRegenerateDisplay() {
}
}
bool ewol::Widget::List::onEventInput(const ewol::event::Input& _event) {
bool ewol::widget::List::onEventInput(const ewol::event::Input& _event) {
vec2 relativePos = relativePosition(_event.getPos());
if (true == WidgetScrolled::onEventInput(_event)) {
@ -240,10 +240,10 @@ bool ewol::Widget::List::onEventInput(const ewol::event::Input& _event) {
return isUsed;
}
void ewol::Widget::List::onGetFocus() {
void ewol::widget::List::onGetFocus() {
EWOL_DEBUG("Ewol::List get focus");
}
void ewol::Widget::List::onLostFocus() {
void ewol::widget::List::onLostFocus() {
EWOL_DEBUG("Ewol::List Lost focus");
}

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

@ -16,33 +16,33 @@
#define __class__ "ListFileSystem"
static ewol::Widget* Create() {
return new ewol::Widget::ListFileSystem();
return new ewol::widget::ListFileSystem();
}
void ewol::Widget::ListFileSystem::init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager) {
_widgetManager.addWidgetCreator(__class__,&Create);
void ewol::widget::ListFileSystem::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&Create);
}
const char * const ewol::Widget::ListFileSystem::eventFileSelect = "file-select";
const char * const ewol::Widget::ListFileSystem::eventFileValidate = "file-validate";
const char * const ewol::Widget::ListFileSystem::eventFolderSelect = "folder-select";
const char * const ewol::Widget::ListFileSystem::eventFolderValidate = "folder-validate";
const char * const ewol::widget::ListFileSystem::eventFileSelect = "file-select";
const char * const ewol::widget::ListFileSystem::eventFileValidate = "file-validate";
const char * const ewol::widget::ListFileSystem::eventFolderSelect = "folder-select";
const char * const ewol::widget::ListFileSystem::eventFolderValidate = "folder-validate";
const char* const ewol::Widget::ListFileSystem::configShowHidden = "show-hidden";
const char* const ewol::Widget::ListFileSystem::configShowFile = "show-file";
const char* const ewol::Widget::ListFileSystem::configShowFolder = "show-folder";
const char* const ewol::Widget::ListFileSystem::configShowTemporary = "show-temporary";
const char* const ewol::Widget::ListFileSystem::configPath = "path";
const char* const ewol::Widget::ListFileSystem::configSelect = "select";
const char* const ewol::widget::ListFileSystem::configShowHidden = "show-hidden";
const char* const ewol::widget::ListFileSystem::configShowFile = "show-file";
const char* const ewol::widget::ListFileSystem::configShowFolder = "show-folder";
const char* const ewol::widget::ListFileSystem::configShowTemporary = "show-temporary";
const char* const ewol::widget::ListFileSystem::configPath = "path";
const char* const ewol::widget::ListFileSystem::configSelect = "select";
ewol::Widget::ListFileSystem::ListFileSystem() :
ewol::widget::ListFileSystem::ListFileSystem() :
m_selectedLine(-1),
m_folder ("/"),
m_showFile(true),
m_showFolder(true),
m_showHidden(true),
m_showTemporaryFile(true) {
addObjectType("ewol::Widget::ListFileSystem");
addObjectType("ewol::widget::ListFileSystem");
#if defined(__TARGET_OS__Windows)
m_folder = "c:/";
#endif
@ -68,12 +68,12 @@ ewol::Widget::ListFileSystem::ListFileSystem() :
setMouseLimit(1);
};
ewol::Widget::ListFileSystem::~ListFileSystem() {
ewol::widget::ListFileSystem::~ListFileSystem() {
clearList();
ewol::resource::ColorFile::release(m_colorProperty);
};
void ewol::Widget::ListFileSystem::clearList() {
void ewol::widget::ListFileSystem::clearList() {
for (size_t iii=0; iii<m_list.size(); iii++) {
if (NULL != m_list[iii]) {
delete(m_list[iii]);
@ -82,12 +82,12 @@ void ewol::Widget::ListFileSystem::clearList() {
}
};
etk::Color<> ewol::Widget::ListFileSystem::getBasicBG() {
etk::Color<> ewol::widget::ListFileSystem::getBasicBG() {
return m_colorProperty->get(m_colorIdBackground1);
}
void ewol::Widget::ListFileSystem::regenerateView() {
void ewol::widget::ListFileSystem::regenerateView() {
clearList();
m_selectedLine = -1;
m_list.clear();
@ -99,7 +99,7 @@ void ewol::Widget::ListFileSystem::regenerateView() {
markToRedraw();
}
std::string ewol::Widget::ListFileSystem::getSelect() const {
std::string ewol::widget::ListFileSystem::getSelect() const {
std::string tmpVal = "";
if (m_selectedLine >= 0) {
if (m_list[m_selectedLine] != NULL) {
@ -110,7 +110,7 @@ std::string ewol::Widget::ListFileSystem::getSelect() const {
}
// select the specific file
void ewol::Widget::ListFileSystem::setSelect(const std::string& _data) {
void ewol::widget::ListFileSystem::setSelect(const std::string& _data) {
// remove selected line
m_selectedLine = -1;
// search the coresponding file :
@ -126,16 +126,16 @@ void ewol::Widget::ListFileSystem::setSelect(const std::string& _data) {
markToRedraw();
}
uint32_t ewol::Widget::ListFileSystem::getNuberOfColomn() {
uint32_t ewol::widget::ListFileSystem::getNuberOfColomn() {
return 1;
}
bool ewol::Widget::ListFileSystem::getTitle(int32_t _colomn, std::string &_myTitle, etk::Color<>& _fg, etk::Color<>& _bg) {
bool ewol::widget::ListFileSystem::getTitle(int32_t _colomn, std::string &_myTitle, etk::Color<>& _fg, etk::Color<>& _bg) {
_myTitle = "title";
return true;
}
uint32_t ewol::Widget::ListFileSystem::getNuberOfRaw() {
uint32_t ewol::widget::ListFileSystem::getNuberOfRaw() {
int32_t offset = 0;
if (m_showFolder == true) {
if (m_folder == "/") {
@ -147,7 +147,7 @@ uint32_t ewol::Widget::ListFileSystem::getNuberOfRaw() {
return m_list.size() + offset;
}
bool ewol::Widget::ListFileSystem::getElement(int32_t _colomn, int32_t _raw, std::string& _myTextToWrite, etk::Color<>& _fg, etk::Color<>& _bg) {
bool ewol::widget::ListFileSystem::getElement(int32_t _colomn, int32_t _raw, std::string& _myTextToWrite, etk::Color<>& _fg, etk::Color<>& _bg) {
int32_t offset = 0;
if (m_showFolder == true) {
if (m_folder == "/") {
@ -181,7 +181,7 @@ bool ewol::Widget::ListFileSystem::getElement(int32_t _colomn, int32_t _raw, std
};
bool ewol::Widget::ListFileSystem::onItemEvent(int32_t _IdInput,
bool ewol::widget::ListFileSystem::onItemEvent(int32_t _IdInput,
enum ewol::key::status _typeEvent,
int32_t _colomn,
int32_t _raw,
@ -264,8 +264,8 @@ bool ewol::Widget::ListFileSystem::onItemEvent(int32_t _IdInput,
}
bool ewol::Widget::ListFileSystem::onSetConfig(const ewol::object::Config& _conf) {
if (true == ewol::Widget::List::onSetConfig(_conf)) {
bool ewol::widget::ListFileSystem::onSetConfig(const ewol::object::Config& _conf) {
if (true == ewol::widget::List::onSetConfig(_conf)) {
return true;
}
if (_conf.getConfig() == configShowHidden) {
@ -295,8 +295,8 @@ bool ewol::Widget::ListFileSystem::onSetConfig(const ewol::object::Config& _conf
return false;
}
bool ewol::Widget::ListFileSystem::onGetConfig(const char* _config, std::string& _result) const {
if (true == ewol::Widget::List::onGetConfig(_config, _result)) {
bool ewol::widget::ListFileSystem::onGetConfig(const char* _config, std::string& _result) const {
if (true == ewol::widget::List::onGetConfig(_config, _result)) {
return true;
}
if (_config == configShowHidden) {

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

@ -18,10 +18,10 @@ namespace ewol {
/**
* @brief Generic display folder class. This widget display the content of a single folder :
*/
class ListFileSystem : public ewol::Widget::List {
class ListFileSystem : public ewol::widget::List {
public:
//! @not-in-doc
static void init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager);
static void init(ewol::object::Shared<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

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

@ -29,9 +29,9 @@
#include <vector>
#undef __class__
#define __class__ "ewol::Widget::Manager"
#define __class__ "ewol::widget::Manager"
ewol::Widget::Manager::Manager() :
ewol::widget::Manager::Manager() :
m_focusWidgetDefault(NULL),
m_focusWidgetCurrent(NULL),
m_havePeriodic(false),
@ -43,26 +43,26 @@ ewol::Widget::Manager::Manager() :
m_applWakeUpTime = ewol::getTime();
m_lastPeriodicCallTime = ewol::getTime();
ewol::Widget::Button::init(*this);
ewol::Widget::ButtonColor::init(*this);
ewol::widget::Button::init(*this);
ewol::widget::ButtonColor::init(*this);
ewol::Widget::Spacer::init(*this);
ewol::Widget::Slider::init(*this);
ewol::Widget::Sizer::init(*this);
ewol::widget::Slider::init(*this);
ewol::widget::Sizer::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::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::ContextMenu::init(*this);
ewol::widget::ContextMenu::init(*this);
ewol::Widget::PopUp::init(*this);
ewol::Widget::WSlider::init(*this);
ewol::Widget::ListFileSystem::init(*this);
ewol::widget::ListFileSystem::init(*this);
}
ewol::Widget::Manager::~Manager() {
ewol::widget::Manager::~Manager() {
EWOL_DEBUG(" == > Un-Init Widget-Manager");
EWOL_INFO("Realease all FOCUS");
focusSetDefault(NULL);
@ -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::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::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::Widget * _newWidget) {
if( NULL != _newWidget
&& false == _newWidget->canHaveFocus() ) {
EWOL_VERBOSE("Widget can not have focus, id=" << _newWidget->getId() );
@ -126,7 +126,7 @@ void ewol::Widget::Manager::focusSetDefault(ewol::Widget * _newWidget) {
m_focusWidgetDefault = _newWidget;
}
void ewol::Widget::Manager::focusRelease() {
void ewol::widget::Manager::focusRelease() {
if (m_focusWidgetDefault == m_focusWidgetCurrent) {
// nothink to do ...
return;
@ -143,11 +143,11 @@ 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;
}
void ewol::Widget::Manager::focusRemoveIfRemove(ewol::object::Shared<ewol::Widget> _newWidget) {
void ewol::widget::Manager::focusRemoveIfRemove(ewol::object::Shared<ewol::Widget> _newWidget) {
if (m_focusWidgetCurrent == _newWidget) {
EWOL_WARNING("Release focus when remove widget");
focusRelease();
@ -158,7 +158,7 @@ void ewol::Widget::Manager::focusRemoveIfRemove(ewol::object::Shared<ewol::Widge
}
}
void ewol::Widget::Manager::periodicCallAdd(ewol::object::Shared<ewol::Widget> _pWidget) {
void ewol::widget::Manager::periodicCallAdd(ewol::object::Shared<ewol::Widget> _pWidget) {
for (size_t iii=0; iii < m_listOfPeriodicWidget.size(); iii++) {
if (m_listOfPeriodicWidget[iii] == _pWidget) {
return;
@ -174,7 +174,7 @@ void ewol::Widget::Manager::periodicCallAdd(ewol::object::Shared<ewol::Widget> _
m_havePeriodic = true;
}
void ewol::Widget::Manager::periodicCallRm(ewol::object::Shared<ewol::Widget> _pWidget) {
void ewol::widget::Manager::periodicCallRm(ewol::object::Shared<ewol::Widget> _pWidget) {
int32_t nbElement = 0;
for (int32_t iii=m_listOfPeriodicWidget.size()-1; iii >= 0 ; iii--) {
if (m_listOfPeriodicWidget[iii] == _pWidget) {
@ -188,11 +188,11 @@ void ewol::Widget::Manager::periodicCallRm(ewol::object::Shared<ewol::Widget> _p
}
}
void ewol::Widget::Manager::periodicCallResume(int64_t _localTime) {
void ewol::widget::Manager::periodicCallResume(int64_t _localTime) {
m_lastPeriodicCallTime = _localTime;
}
void ewol::Widget::Manager::periodicCall(int64_t _localTime) {
void ewol::widget::Manager::periodicCall(int64_t _localTime) {
int64_t previousTime = m_lastPeriodicCallTime;
m_lastPeriodicCallTime = _localTime;
if (m_listOfPeriodicWidget.size() <= 0) {
@ -228,23 +228,23 @@ void ewol::Widget::Manager::periodicCall(int64_t _localTime) {
}
}
bool ewol::Widget::Manager::periodicCallHave() {
bool ewol::widget::Manager::periodicCallHave() {
return m_havePeriodic;
}
void ewol::Widget::Manager::markDrawingIsNeeded() {
void ewol::widget::Manager::markDrawingIsNeeded() {
m_haveRedraw = true;
}
bool ewol::Widget::Manager::isDrawingNeeded() {
bool ewol::widget::Manager::isDrawingNeeded() {
bool tmp = m_haveRedraw;
m_haveRedraw = false;
return tmp;
}
// element that generate the list of elements
void ewol::Widget::Manager::addWidgetCreator(const std::string& _name,
ewol::Widget::Manager::creator_tf _pointer) {
void ewol::widget::Manager::addWidgetCreator(const std::string& _name,
ewol::widget::Manager::creator_tf _pointer) {
if (NULL == _pointer) {
return;
}
@ -259,10 +259,10 @@ void ewol::Widget::Manager::addWidgetCreator(const std::string& _name,
m_creatorList.add(nameLower, _pointer);
}
ewol::Widget* ewol::Widget::Manager::create(const std::string& _name) {
ewol::Widget* ewol::widget::Manager::create(const std::string& _name) {
std::string nameLower = std::tolower(_name);
if (m_creatorList.exist(nameLower) == true) {
ewol::Widget::Manager::creator_tf pointerFunction = m_creatorList[nameLower];
ewol::widget::Manager::creator_tf pointerFunction = m_creatorList[nameLower];
if (pointerFunction != nullptr) {
return pointerFunction();
}
@ -271,12 +271,12 @@ ewol::Widget* ewol::Widget::Manager::create(const std::string& _name) {
return NULL;
}
bool ewol::Widget::Manager::exist(const std::string& _name) {
bool ewol::widget::Manager::exist(const std::string& _name) {
std::string nameLower = std::tolower(_name);
return m_creatorList.exist(nameLower);
}
std::string ewol::Widget::Manager::list() {
std::string ewol::widget::Manager::list() {
std::string tmpVal;
for (int32_t iii=0; iii<m_creatorList.size() ; iii++) {
tmpVal += m_creatorList.getKey(iii);

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

@ -30,7 +30,7 @@ ewol::Widget::Menu::~Menu() {
void ewol::Widget::Menu::subWidgetRemoveAll() {
clear();
ewol::Widget::Sizer::subWidgetRemoveAll();
ewol::widget::Sizer::subWidgetRemoveAll();
}
int32_t ewol::Widget::Menu::subWidgetAdd(ewol::Widget* _newWidget) {
@ -82,8 +82,8 @@ int32_t ewol::Widget::Menu::add(int32_t _parent,
tmpObject->m_message = _message;
m_listElement.push_back(tmpObject);
if (-1 == tmpObject->m_parentId) {
ewol::Widget::Button *myButton = NULL;
myButton = new ewol::Widget::Button();
ewol::widget::Button *myButton = NULL;
myButton = new ewol::widget::Button();
if (NULL == myButton) {
EWOL_ERROR("Allocation button error");
return tmpObject->m_localId;
@ -97,15 +97,15 @@ int32_t ewol::Widget::Menu::add(int32_t _parent,
}
composeString+=" <label>" + tmpObject->m_label + "</label>\n";
composeString+="</sizer>\n";
myButton->setSubWidget(new ewol::Widget::Composer(widget::Composer::String, composeString));
myButton->setSubWidget(new ewol::widget::Composer(widget::Composer::String, composeString));
} else {
myButton->setSubWidget(new ewol::Widget::Label(tmpObject->m_label) );
myButton->setSubWidget(new ewol::widget::Label(tmpObject->m_label) );
}
// add it in the widget list
ewol::Widget::Sizer::subWidgetAdd(myButton);
ewol::widget::Sizer::subWidgetAdd(myButton);
// keep the specific event ...
myButton->registerOnEvent(this, ewol::Widget::Button::eventPressed, widget::Button::eventPressed);
myButton->registerOnEvent(this, ewol::widget::Button::eventPressed, widget::Button::eventPressed);
tmpObject->m_widgetPointer = myButton;
}
return tmpObject->m_localId;
@ -123,7 +123,7 @@ void ewol::Widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
}
*/
EWOL_ERROR(" receive message : " << _msg);
if (_msg.getMessage() == ewol::Widget::Button::eventPressed) {
if (_msg.getMessage() == ewol::widget::Button::eventPressed) {
for (size_t iii=0; iii<m_listElement.size(); iii++) {
if (_msg.getCaller() == m_listElement[iii]->m_widgetPointer) {
// 2 posible case (have a message or have a child ...
@ -151,7 +151,7 @@ void ewol::Widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
return;
}
// create a context menu :
m_widgetContextMenu = new ewol::Widget::ContextMenu();
m_widgetContextMenu = new ewol::widget::ContextMenu();
if (NULL == m_widgetContextMenu) {
EWOL_ERROR("Allocation Error");
return;
@ -167,12 +167,12 @@ void ewol::Widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
tmpOri.y() );
}
m_widgetContextMenu->setPositionMark(ewol::Widget::ContextMenu::markTop, newPosition );
m_widgetContextMenu->setPositionMark(ewol::widget::ContextMenu::markTop, newPosition );
ewol::Widget::Sizer * mySizer = NULL;
ewol::Widget::Button * myButton = NULL;
ewol::widget::Sizer * mySizer = NULL;
ewol::widget::Button * myButton = NULL;
mySizer = new ewol::Widget::Sizer(widget::Sizer::modeVert);
mySizer = new ewol::widget::Sizer(widget::Sizer::modeVert);
if (NULL != mySizer) {
mySizer->lockExpand(vec2(true,true));
// set it in the pop-up-system :
@ -192,7 +192,7 @@ void ewol::Widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
for (int64_t jjj=m_listElement.size()-1; jjj >= 0; jjj--) {
if (m_listElement[iii]!=NULL) {
if (m_listElement[iii]->m_localId == m_listElement[jjj]->m_parentId) {
myButton = new ewol::Widget::Button();
myButton = new ewol::widget::Button();
if (NULL == myButton) {
EWOL_ERROR("Allocation Error");
} else {
@ -208,11 +208,11 @@ void ewol::Widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
composeString+=" <label exand=\"true,true\" fill=\"true,true\">" + m_listElement[jjj]->m_label + "</label>\n";
composeString+=" </sizer>\n";
composeString+="</composer>\n";
myButton->setSubWidget(new ewol::Widget::Composer(widget::Composer::String, composeString));
myButton->setSubWidget(new ewol::widget::Composer(widget::Composer::String, composeString));
} else {
if (true == menuHaveImage) {
myButton->setSubWidget(
new ewol::Widget::Composer(widget::Composer::String,
new ewol::widget::Composer(widget::Composer::String,
std::string("<composer expand=\"true,false\" fill=\"true,true\">\n") +
" <sizer mode=\"hori\" expand=\"true,false\" fill=\"true,true\" lock=\"true\">\n"
" <spacer min-size=\"8,0mm\"/>\n"
@ -220,7 +220,7 @@ void ewol::Widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
" </sizer>\n"
"</composer>\n"));
} else {
ewol::Widget::Label* tmpLabel = new widget::Label(std::string("<left>") + m_listElement[jjj]->m_label + "</left>\n");
ewol::widget::Label* tmpLabel = new widget::Label(std::string("<left>") + m_listElement[jjj]->m_label + "</left>\n");
if (NULL != tmpLabel) {
tmpLabel->setExpand(bvec2(true,false));
tmpLabel->setFill(bvec2(true,true));
@ -229,7 +229,7 @@ void ewol::Widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
}
}
// set the image if one is present ...
myButton->registerOnEvent(this, ewol::Widget::Button::eventPressed, widget::Button::eventPressed);
myButton->registerOnEvent(this, ewol::widget::Button::eventPressed, widget::Button::eventPressed);
myButton->setExpand(bvec2(true,false));
myButton->setFill(bvec2(true,false));
// add it in the widget list
@ -240,7 +240,7 @@ void ewol::Widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
}
}
}
ewol::Widget::Windows* currentWindows = getWindows();
ewol::widget::Windows* currentWindows = getWindows();
if (NULL == currentWindows) {
EWOL_ERROR("Can not get the curent Windows...");
m_widgetContextMenu->removeObject();
@ -257,7 +257,7 @@ void ewol::Widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
void ewol::Widget::Menu::onObjectRemove(ewol::object::Shared<ewol::Object> * _removeObject) {
ewol::Widget::Sizer::onObjectRemove(_removeObject);
ewol::widget::Sizer::onObjectRemove(_removeObject);
if (m_widgetContextMenu == _removeObject) {
m_widgetContextMenu = NULL;
}

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

@ -32,7 +32,7 @@ namespace ewol {
/**
* @ingroup ewolWidgetGroup
*/
class Menu :public ewol::Widget::Sizer {
class Menu :public ewol::widget::Sizer {
public:
Menu();
virtual ~Menu();
@ -44,7 +44,7 @@ namespace ewol {
private:
std::vector<ewol::Widget::MenuElement*> m_listElement;
int32_t m_staticId; // unique ID for every element of the menu ...
ewol::Widget::ContextMenu* m_widgetContextMenu;
ewol::widget::ContextMenu* m_widgetContextMenu;
public:
void clear();
int32_t addTitle(std::string _label, std::string _image="", const char * _generateEvent = NULL, const std::string _message = "");

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

@ -22,12 +22,12 @@ const char* const ewol::Widget::PopUp::configLockExpand="lock";
static const char* annimationIncrease = "increase";
static ewol::object::Shared<ewol::Widget> create() {
static ewol::Widget* create() {
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::object::Shared<ewol::widget::Manager> _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&create);
}
ewol::Widget::PopUp::PopUp(const std::string& _shaperName) :
@ -148,7 +148,7 @@ void ewol::Widget::PopUp::onRegenerateDisplay() {
}
ewol::object::Shared<ewol::Widget> ewol::Widget::PopUp::getWidgetAtPos(const vec2& _pos) {
ewol::object::Shared<ewol::Widget> val = ewol::Widget::Container::getWidgetAtPos(_pos);
ewol::object::Shared<ewol::Widget> val = ewol::widget::Container::getWidgetAtPos(_pos);
if (NULL != val) {
return val;
}
@ -156,7 +156,7 @@ ewol::object::Shared<ewol::Widget> ewol::Widget::PopUp::getWidgetAtPos(const vec
}
bool ewol::Widget::PopUp::onSetConfig(const ewol::object::Config& _conf) {
if (true == ewol::Widget::Container::onSetConfig(_conf)) {
if (true == ewol::widget::Container::onSetConfig(_conf)) {
return true;
}
if (_conf.getConfig() == configShaper) {
@ -175,7 +175,7 @@ bool ewol::Widget::PopUp::onSetConfig(const ewol::object::Config& _conf) {
}
bool ewol::Widget::PopUp::onGetConfig(const char* _config, std::string& _result) const {
if (true == ewol::Widget::Container::onGetConfig(_config, _result)) {
if (true == ewol::widget::Container::onGetConfig(_config, _result)) {
return true;
}
if (_config == configShaper) {

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

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

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

@ -14,12 +14,12 @@
#undef __class__
#define __class__ "ProgressBar"
static ewol::object::Shared<ewol::Widget> create() {
static ewol::Widget* create() {
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::object::Shared<ewol::widget::Manager> _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&create);
}
const char* const ewol::Widget::ProgressBar::configColorBg = "color-bg";

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

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

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

@ -14,12 +14,12 @@
#undef __class__
#define __class__ "Scroll"
static ewol::object::Shared<ewol::Widget> create() {
static ewol::Widget* create() {
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::object::Shared<ewol::widget::Manager> _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&create);
}
const char* const ewol::Widget::Scroll::configLimit = "limit";
@ -76,7 +76,7 @@ void ewol::Widget::Scroll::onDraw() {
void ewol::Widget::Scroll::onRegenerateDisplay() {
// call upper class
ewol::Widget::Container::onRegenerateDisplay();
ewol::widget::Container::onRegenerateDisplay();
if (needRedraw() == false) {
return;
}
@ -350,7 +350,7 @@ bool ewol::Widget::Scroll::onEventInput(const ewol::event::Input& _event) {
}
ewol::object::Shared<ewol::Widget> ewol::Widget::Scroll::getWidgetAtPos(const vec2& _pos) {
ewol::object::Shared<ewol::Widget> tmpWidget = ewol::Widget::Container::getWidgetAtPos(_pos);
ewol::object::Shared<ewol::Widget> tmpWidget = ewol::widget::Container::getWidgetAtPos(_pos);
if (NULL != tmpWidget) {
return tmpWidget;
}
@ -358,7 +358,7 @@ ewol::object::Shared<ewol::Widget> ewol::Widget::Scroll::getWidgetAtPos(const ve
}
bool ewol::Widget::Scroll::onSetConfig(const ewol::object::Config& _conf) {
if (true == ewol::Widget::Container::onSetConfig(_conf)) {
if (true == ewol::widget::Container::onSetConfig(_conf)) {
return true;
}
if (_conf.getConfig() == configLimit) {
@ -369,7 +369,7 @@ bool ewol::Widget::Scroll::onSetConfig(const ewol::object::Config& _conf) {
}
bool ewol::Widget::Scroll::onGetConfig(const char* _config, std::string& _result) const {
if (true == ewol::Widget::Container::onGetConfig(_config, _result)) {
if (true == ewol::widget::Container::onGetConfig(_config, _result)) {
return true;
}
if (_config == configLimit) {

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

@ -21,7 +21,7 @@ namespace ewol {
/**
* @ingroup ewolWidgetGroup
*/
class Scroll : public ewol::Widget::Container {
class Scroll : public ewol::widget::Container {
public:
enum highSpeedMode {
speedModeDisable,
@ -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::object::Shared<ewol::widget::Manager> _widgetManager);
private:
ewol::compositing::Shaper m_shaperH; //!< Compositing theme Horizontal.
ewol::compositing::Shaper m_shaperV; //!< Compositing theme Vertical.

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

@ -10,53 +10,53 @@
#include <ewol/widget/Sizer.h>
#include <ewol/widget/Manager.h>
const char* const ewol::Widget::Sizer::configBorder = "border";
const char* const ewol::Widget::Sizer::configMode = "mode";
const char* const ewol::widget::Sizer::configBorder = "border";
const char* const ewol::widget::Sizer::configMode = "mode";
#undef __class__
#define __class__ "Sizer"
static ewol::object::Shared<ewol::Widget> create() {
return new ewol::Widget::Sizer();
return new ewol::widget::Sizer();
}
void ewol::Widget::Sizer::init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager) {
void ewol::widget::Sizer::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
_widgetManager.addWidgetCreator(__class__,&create);
}
ewol::Widget::Sizer::Sizer(enum displayMode _mode):
ewol::widget::Sizer::Sizer(enum displayMode _mode):
m_mode(_mode),
m_borderSize(),
m_animation(animationNone),
m_animationTime(0) {
addObjectType("ewol::Widget::Sizer");
addObjectType("ewol::widget::Sizer");
registerConfig(configBorder, "dimension", NULL, "The sizer border size");
registerConfig(configMode, "list", "{vert,hori}", "The display mode");
}
ewol::Widget::Sizer::~Sizer() {
ewol::widget::Sizer::~Sizer() {
// disable annimation to remore "remove" error
m_animation = animationNone;
m_animationTime = 0;
//EWOL_DEBUG("[" << getId() << "]={" << getObjectType() << "} sizer : destroy (mode=" << (m_mode == ewol::Widget::Sizer::modeVert?"Vert":"Hori") << ")");
//EWOL_DEBUG("[" << getId() << "]={" << getObjectType() << "} sizer : destroy (mode=" << (m_mode == ewol::widget::Sizer::modeVert?"Vert":"Hori") << ")");
}
void ewol::Widget::Sizer::setBorderSize(const ewol::Dimension& _newBorderSize) {
void ewol::widget::Sizer::setBorderSize(const ewol::Dimension& _newBorderSize) {
m_borderSize = _newBorderSize;
markToRedraw();
requestUpdateSize();
}
void ewol::Widget::Sizer::setMode(enum displayMode _mode) {
void ewol::widget::Sizer::setMode(enum displayMode _mode) {
m_mode = _mode;
markToRedraw();
requestUpdateSize();
}
void ewol::Widget::Sizer::calculateSize(const vec2& _availlable) {
void ewol::widget::Sizer::calculateSize(const vec2& _availlable) {
ewol::Widget::calculateSize(_availlable);
vec2 tmpBorderSize = m_borderSize.getPixel();
EWOL_VERBOSE("[" << getId() << "] update size : " << _availlable << " nbElement : " << m_subWidget.size() << " borderSize=" << tmpBorderSize << " from border=" << m_borderSize);
@ -68,7 +68,7 @@ void ewol::Widget::Sizer::calculateSize(const vec2& _availlable) {
for (size_t iii=0; iii<m_subWidget.size(); iii++) {
if (NULL != m_subWidget[iii]) {
vec2 tmpSize = m_subWidget[iii]->getCalculateMinSize();
if (m_mode == ewol::Widget::Sizer::modeVert) {
if (m_mode == ewol::widget::Sizer::modeVert) {
unexpandableSize += tmpSize.y();
if (false == m_subWidget[iii]->canExpand().y()) {
nbWidgetFixedSize++;
@ -89,7 +89,7 @@ void ewol::Widget::Sizer::calculateSize(const vec2& _availlable) {
float sizeToAddAtEveryOne = 0;
// 2 cases : 1 or more can Expand, or all is done ...
if (0 != nbWidgetNotFixedSize) {
if (m_mode == ewol::Widget::Sizer::modeVert) {
if (m_mode == ewol::widget::Sizer::modeVert) {
sizeToAddAtEveryOne = (m_size.y() - unexpandableSize) / nbWidgetNotFixedSize;
} else {
sizeToAddAtEveryOne = (m_size.x() - unexpandableSize) / nbWidgetNotFixedSize;
@ -106,7 +106,7 @@ void ewol::Widget::Sizer::calculateSize(const vec2& _availlable) {
EWOL_VERBOSE("[" << getId() << "] set iii=" << iii << " ORIGIN : " << tmpOrigin << " & offset=" << m_offset);
m_subWidget[iii]->setOrigin(vec2ClipInt32(tmpOrigin+m_offset));
// Now update his size his size in X and the curent sizer size in Y:
if (m_mode == ewol::Widget::Sizer::modeVert) {
if (m_mode == ewol::widget::Sizer::modeVert) {
if (true == m_subWidget[iii]->canExpand().y()) {
m_subWidget[iii]->calculateSize(vec2ClipInt32(vec2(m_size.x(), tmpSize.y()+sizeToAddAtEveryOne)));
tmpOrigin.setY(tmpOrigin.y() + tmpSize.y()+sizeToAddAtEveryOne);
@ -129,7 +129,7 @@ void ewol::Widget::Sizer::calculateSize(const vec2& _availlable) {
markToRedraw();
}
void ewol::Widget::Sizer::calculateMinMaxSize() {
void ewol::widget::Sizer::calculateMinMaxSize() {
EWOL_VERBOSE("[" << getId() << "] update minimum size");
m_subExpend.setValue(false, false);
m_minSize = m_userMinSize.getPixel();
@ -148,7 +148,7 @@ void ewol::Widget::Sizer::calculateMinMaxSize() {
vec2 tmpSize = m_subWidget[iii]->getCalculateMinSize();
EWOL_VERBOSE("[" << getId() << "] NewMinSize=" << tmpSize);
EWOL_VERBOSE("[" << getId() << "] {" << getObjectType() << "} Get minSize[" << iii << "] "<< tmpSize);
if (m_mode == ewol::Widget::Sizer::modeVert) {
if (m_mode == ewol::widget::Sizer::modeVert) {
m_minSize.setY(m_minSize.y() + tmpSize.y());
if (tmpSize.x()>m_minSize.x()) {
m_minSize.setX(tmpSize.x());
@ -164,42 +164,42 @@ void ewol::Widget::Sizer::calculateMinMaxSize() {
//EWOL_ERROR("[" << getId() << "] {" << getObjectType() << "} Result min size : " << m_minSize);
}
int32_t ewol::Widget::Sizer::subWidgetAdd(ewol::Widget* _newWidget) {
int32_t ewol::widget::Sizer::subWidgetAdd(ewol::Widget* _newWidget) {
if (m_animation == animationNone) {
return ewol::Widget::ContainerN::subWidgetAdd(_newWidget);
return ewol::widget::ContainerN::subWidgetAdd(_newWidget);
}
// TODO : ...
return ewol::Widget::ContainerN::subWidgetAdd(_newWidget);
return ewol::widget::ContainerN::subWidgetAdd(_newWidget);
}
int32_t ewol::Widget::Sizer::subWidgetAddStart(ewol::Widget* _newWidget) {
int32_t ewol::widget::Sizer::subWidgetAddStart(ewol::Widget* _newWidget) {
if (m_animation == animationNone) {
return ewol::Widget::ContainerN::subWidgetAddStart(_newWidget);
return ewol::widget::ContainerN::subWidgetAddStart(_newWidget);
}
// TODO : ...
return ewol::Widget::ContainerN::subWidgetAddStart(_newWidget);
return ewol::widget::ContainerN::subWidgetAddStart(_newWidget);
}
void ewol::Widget::Sizer::subWidgetRemove(ewol::Widget* _newWidget) {
void ewol::widget::Sizer::subWidgetRemove(ewol::Widget* _newWidget) {
if (m_animation == animationNone) {
ewol::Widget::ContainerN::subWidgetRemove(_newWidget);
ewol::widget::ContainerN::subWidgetRemove(_newWidget);
return;
}
// TODO : ...
ewol::Widget::ContainerN::subWidgetRemove(_newWidget);
ewol::widget::ContainerN::subWidgetRemove(_newWidget);
}
void ewol::Widget::Sizer::subWidgetUnLink(ewol::Widget* _newWidget) {
void ewol::widget::Sizer::subWidgetUnLink(ewol::Widget* _newWidget) {
if (m_animation == animationNone) {
ewol::Widget::ContainerN::subWidgetUnLink(_newWidget);
ewol::widget::ContainerN::subWidgetUnLink(_newWidget);
return;
}
// TODO : ...
ewol::Widget::ContainerN::subWidgetUnLink(_newWidget);
ewol::widget::ContainerN::subWidgetUnLink(_newWidget);
}
bool ewol::Widget::Sizer::onSetConfig(const ewol::object::Config& _conf) {
if (true == ewol::Widget::ContainerN::onSetConfig(_conf)) {
bool ewol::widget::Sizer::onSetConfig(const ewol::object::Config& _conf) {
if (true == ewol::widget::ContainerN::onSetConfig(_conf)) {
return true;
}
if (_conf.getConfig() == configBorder) {
@ -217,8 +217,8 @@ bool ewol::Widget::Sizer::onSetConfig(const ewol::object::Config& _conf) {
return false;
}
bool ewol::Widget::Sizer::onGetConfig(const char* _config, std::string& _result) const {
if (true == ewol::Widget::ContainerN::onGetConfig(_config, _result)) {
bool ewol::widget::Sizer::onGetConfig(const char* _config, std::string& _result) const {
if (true == ewol::widget::ContainerN::onGetConfig(_config, _result)) {
return true;
}
if (_config == configBorder) {

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

@ -19,12 +19,12 @@ namespace ewol {
/**
* @ingroup ewolWidgetGroup
*/
class Sizer : public ewol::Widget::ContainerN {
class Sizer : public ewol::widget::ContainerN {
public:
/**
* @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::object::Shared<ewol::widget::Manager> _widgetManager);
// Config list of properties
static const char* const configBorder;
static const char* const configMode;
@ -40,7 +40,7 @@ namespace ewol {
* @brief Constructor
* @param[in] _mode The mode to display the elements
*/
Sizer(enum displayMode _mode=ewol::Widget::Sizer::modeHori);
Sizer(enum displayMode _mode=ewol::widget::Sizer::modeHori);
/**
* @brief Desstructor
*/

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

@ -10,23 +10,23 @@
#include <ewol/widget/Manager.h>
const char * const ewol::Widget::Slider::eventChange = "change";
const char * const ewol::widget::Slider::eventChange = "change";
#undef __class__
#define __class__ "Slider"
static ewol::Widget* create() {
return new ewol::Widget::Slider();
return new ewol::widget::Slider();
}
void ewol::Widget::Slider::init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager) {
_widgetManager.addWidgetCreator(__class__,&create);
void ewol::widget::Slider::init(ewol::object::Shared<ewol::widget::Manager> _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&create);
}
const int32_t dotRadius = 6;
ewol::Widget::Slider::Slider() {
addObjectType("ewol::Widget::Slider");
ewol::widget::Slider::Slider() {
addObjectType("ewol::widget::Slider");
addEventId(eventChange);
m_value = 0;
@ -42,43 +42,43 @@ ewol::Widget::Slider::Slider() {
setMouseLimit(1);
}
ewol::Widget::Slider::~Slider() {
ewol::widget::Slider::~Slider() {
}
void ewol::Widget::Slider::calculateMinMaxSize() {
void ewol::widget::Slider::calculateMinMaxSize() {
vec2 minTmp = m_userMinSize.getPixel();
m_minSize.setValue(etk_max(minTmp.x(), 40),
etk_max(minTmp.y(), dotRadius*2) );
markToRedraw();
}
void ewol::Widget::Slider::setValue(int32_t _val) {
void ewol::widget::Slider::setValue(int32_t _val) {
m_value = etk_max(etk_min(_val, m_max), m_min);
markToRedraw();
}
int32_t ewol::Widget::Slider::getValue() {
int32_t ewol::widget::Slider::getValue() {
return m_value;
}
void ewol::Widget::Slider::setMin(int32_t _val) {
void ewol::widget::Slider::setMin(int32_t _val) {
m_min = _val;
m_value = etk_max(etk_min(m_value, m_max), m_min);
markToRedraw();
}
void ewol::Widget::Slider::setMax(int32_t _val) {
void ewol::widget::Slider::setMax(int32_t _val) {
m_max = _val;
m_value = etk_max(etk_min(m_value, m_max), m_min);
markToRedraw();
}
void ewol::Widget::Slider::onDraw() {
void ewol::widget::Slider::onDraw() {
m_draw.draw();
}
void ewol::Widget::Slider::onRegenerateDisplay() {
void ewol::widget::Slider::onRegenerateDisplay() {
if (needRedraw() == false) {
return;
}
@ -100,7 +100,7 @@ void ewol::Widget::Slider::onRegenerateDisplay() {
m_draw.circle(dotRadius/1.6);
}
bool ewol::Widget::Slider::onEventInput(const ewol::event::Input& _event) {
bool ewol::widget::Slider::onEventInput(const ewol::event::Input& _event) {
vec2 relativePos = relativePosition(_event.getPos());
//EWOL_DEBUG("Event on Slider ...");
if (1 == _event.getId()) {

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::object::Shared<ewol::widget::Manager> _widgetManager);
public:
Slider();
virtual ~Slider();

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

@ -20,8 +20,8 @@ static ewol::Widget* create() {
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::object::Shared<ewol::widget::Manager> _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&create);
}
ewol::Widget::Spacer::Spacer() {

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::object::Shared<ewol::widget::Manager> _widgetManager);
// Config list of properties
static const char* const configColor;
private:

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

@ -34,8 +34,8 @@ static ewol::Widget* create() {
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::object::Shared<ewol::widget::Manager> _widgetManager) {
_widgetManager->addWidgetCreator(__class__,&create);
}
ewol::Widget::WSlider::WSlider() :
@ -60,7 +60,7 @@ ewol::Widget::WSlider::~WSlider() {
void ewol::Widget::WSlider::calculateSize(const vec2& _availlable) {
//EWOL_DEBUG("Update size");
ewol::Widget::ContainerN::calculateSize(_availlable);
ewol::widget::ContainerN::calculateSize(_availlable);
if (m_windowsDestination == m_windowsSources) {
int32_t iii = m_windowsDestination;
@ -272,7 +272,7 @@ void ewol::Widget::WSlider::onRegenerateDisplay() {
}
bool ewol::Widget::WSlider::onSetConfig(const ewol::object::Config& _conf) {
if (true == ewol::Widget::ContainerN::onSetConfig(_conf)) {
if (true == ewol::widget::ContainerN::onSetConfig(_conf)) {
return true;
}
if (_conf.getConfig() == configMode) {
@ -293,7 +293,7 @@ bool ewol::Widget::WSlider::onSetConfig(const ewol::object::Config& _conf) {
}
bool ewol::Widget::WSlider::onGetConfig(const char* _config, std::string& _result) const {
if (true == ewol::Widget::ContainerN::onGetConfig(_config, _result)) {
if (true == ewol::widget::ContainerN::onGetConfig(_config, _result)) {
return true;
}
if (_config == configMode) {

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

@ -19,9 +19,9 @@ namespace ewol {
/**
* @ingroup ewolWidgetGroup
*/
class WSlider :public ewol::Widget::ContainerN {
class WSlider :public ewol::widget::ContainerN {
public:
static void init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager);
static void init(ewol::object::Shared<ewol::widget::Manager> _widgetManager);
// Event list of properties
static const char* const eventStartSlide;
static const char* const eventStopSlide;

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

@ -162,7 +162,7 @@ ewol::Widget::~Widget() {
void ewol::Widget::setUpperWidget(ewol::object::Shared<ewol::Widget> _upper) {
if (_upper == nullptr) {
//just remove father :
m_up = NULL;
m_up.reset();
return;
}
if (m_up != nullptr) {
@ -868,11 +868,11 @@ void ewol::Widget::requestUpdateSize() {
getContext().requestUpdateSize();
}
ewol::object::Shared<ewol::Widget::Manager> ewol::Widget::getWidgetManager() {
ewol::widget::Manager& ewol::Widget::getWidgetManager() {
return getContext().getWidgetManager();
}
ewol::object::Shared<ewol::Widget::Windows> ewol::Widget::getWindows() {
ewol::object::Shared<ewol::widget::Windows> ewol::Widget::getWindows() {
return getContext().getWindows();
}

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

@ -13,6 +13,7 @@
#include <etk/types.h>
#include <etk/math/Vector2D.h>
#include <ewol/debug.h>
#include <ewol/object/Object.h>
#include <ewol/Dimension.h>
@ -23,7 +24,6 @@ namespace ewol {
class Windows;
};
};
#include <ewol/debug.h>
#include <ewol/context/clipBoard.h>
#include <ewol/key/key.h>
#include <ewol/context/cursor.h>
@ -116,7 +116,7 @@ namespace ewol {
* :** Receive Event (keyboard / mouse / ...)
*
*/
class Widget : public ewol::object::Shared<ewol::Object> {
class Widget : public ewol::Object {
public:
// Config list of properties
static const char* const configFill;
@ -712,11 +712,11 @@ namespace ewol {
/**
* @brief get the current Widget Manager
*/
ewol::object::Shared<ewol::Widget::Manager> getWidgetManager();
ewol::widget::Manager& getWidgetManager();
/**
* @brief get the curent Windows
*/
ewol::object::Shared<ewol::Widget::Windows> getWindows();
ewol::object::Shared<ewol::widget::Windows> getWindows();
/*
* Annimation section :
*/

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

@ -23,10 +23,10 @@
extern const char * const ewolEventWindowsHideKeyboard = "ewol Windows hideKeyboard";
ewol::Widget::Windows::Windows() :
ewol::widget::Windows::Windows() :
m_colorProperty(NULL),
m_colorBg(-1) {
addObjectType("ewol::Widget::Windows");
addObjectType("ewol::widget::Windows");
setCanHaveFocus(true);
m_subWidget = NULL;
setDecorationDisable();
@ -37,7 +37,7 @@ ewol::Widget::Windows::Windows() :
//KeyboardShow(KEYBOARD_MODE_CODE);
}
ewol::Widget::Windows::~Windows() {
ewol::widget::Windows::~Windows() {
if (NULL != m_subWidget) {
delete(m_subWidget);
m_subWidget=NULL;
@ -51,7 +51,7 @@ ewol::Widget::Windows::~Windows() {
m_popUpWidgetList.clear();
}
void ewol::Widget::Windows::calculateSize(const vec2& _availlable) {
void ewol::widget::Windows::calculateSize(const vec2& _availlable) {
//EWOL_DEBUG(" _availlable : " << _availlable);
m_size = _availlable;
if (NULL != m_subWidget) {
@ -68,7 +68,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
@ -86,7 +86,7 @@ ewol::object::Shared<ewol::Widget> * ewol::Widget::Windows::getWidgetAtPos(const
return this;
}
void ewol::Widget::Windows::sysDraw() {
void ewol::widget::Windows::sysDraw() {
//EWOL_DEBUG("Drow on (" << m_size.x << "," << m_size.y << ")");
// set the size of the open GL system
glViewport(0,0,m_size.x(),m_size.y());
@ -118,7 +118,7 @@ void ewol::Widget::Windows::sysDraw() {
return;
}
void ewol::Widget::Windows::onRegenerateDisplay() {
void ewol::widget::Windows::onRegenerateDisplay() {
if (NULL != m_subWidget) {
m_subWidget->onRegenerateDisplay();
}
@ -131,7 +131,7 @@ void ewol::Widget::Windows::onRegenerateDisplay() {
//#define TEST_PERFO_WINDOWS
void ewol::Widget::Windows::systemDraw(const ewol::DrawProperty& _displayProp) {
void ewol::widget::Windows::systemDraw(const ewol::DrawProperty& _displayProp) {
ewol::Widget::systemDraw(_displayProp);
#ifdef TEST_PERFO_WINDOWS
int64_t ___startTime0 = ewol::getTime();
@ -175,7 +175,7 @@ void ewol::Widget::Windows::systemDraw(const ewol::DrawProperty& _displayProp) {
#endif
}
void ewol::Widget::Windows::setSubWidget(ewol::Widget* _widget) {
void ewol::widget::Windows::setSubWidget(ewol::Widget* _widget) {
if (m_subWidget != NULL) {
EWOL_INFO("Remove current main windows Widget...");
delete(m_subWidget);
@ -186,7 +186,7 @@ void ewol::Widget::Windows::setSubWidget(ewol::Widget* _widget) {
calculateSize(m_size);
}
void ewol::Widget::Windows::popUpWidgetPush(ewol::Widget* _widget) {
void ewol::widget::Windows::popUpWidgetPush(ewol::Widget* _widget) {
if (_widget == NULL) {
// nothing to do an error appear :
EWOL_ERROR("can not set widget pop-up (null pointer)");
@ -201,7 +201,7 @@ void ewol::Widget::Windows::popUpWidgetPush(ewol::Widget* _widget) {
getContext().resetIOEvent();
}
void ewol::Widget::Windows::popUpWidgetPop() {
void ewol::widget::Windows::popUpWidgetPop() {
if (m_popUpWidgetList.size() == 0) {
return;
}
@ -212,7 +212,7 @@ void ewol::Widget::Windows::popUpWidgetPop() {
widget->removeObject();
}
void ewol::Widget::Windows::onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject) {
void ewol::widget::Windows::onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject) {
// First step call parrent :
ewol::Widget::onObjectRemove(_removeObject);
// second step find if in all the elements ...
@ -230,21 +230,21 @@ void ewol::Widget::Windows::onObjectRemove(ewol::object::Shared<ewol::Object> _r
}
}
void ewol::Widget::Windows::setBackgroundColor(const etk::Color<float>& _color) {
void ewol::widget::Windows::setBackgroundColor(const etk::Color<float>& _color) {
if (m_backgroundColor != _color) {
m_backgroundColor = _color;
markToRedraw();
}
}
void ewol::Widget::Windows::setTitle(const std::string& _title) {
void ewol::widget::Windows::setTitle(const std::string& _title) {
// TODO : remove this ...
std::string title = _title;
getContext().setTitle(title);
}
void ewol::Widget::Windows::createPopUpMessage(enum popUpMessageType _type, const std::string& _message)
void ewol::widget::Windows::createPopUpMessage(enum popUpMessageType _type, const std::string& _message)
{
ewol::Widget::StdPopUp* tmpPopUp = new widget::StdPopUp();
if (tmpPopUp == NULL) {

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

@ -23,16 +23,16 @@ extern "C" {
#define __class__ "ColorChooser"
const char * const ewol::Widget::ColorChooser::eventChange = "change";
const char * const ewol::widget::ColorChooser::eventChange = "change";
static const char * const eventColorBarHasChange = "event-color-bar-has-change";
static const char * const eventColorSpecificHasChange = "event-color-specific-has-change";
ewol::Widget::ColorChooser::ColorChooser() :
ewol::Widget::Sizer(ewol::Widget::Sizer::modeVert) {
addObjectType("ewol::Widget::ColorChooser");
ewol::widget::ColorChooser::ColorChooser() :
ewol::widget::Sizer(ewol::Widget::Sizer::modeVert) {
addObjectType("ewol::widget::ColorChooser");
addEventId(eventChange);
m_widgetColorBar = NULL;
m_widgetRed = NULL;
@ -40,7 +40,7 @@ ewol::Widget::ColorChooser::ColorChooser() :
m_widgetBlue = NULL;
m_widgetAlpha = NULL;
lockExpand(bvec2(true,true));
m_widgetColorBar = new ewol::Widget::ColorBar();
m_widgetColorBar = new ewol::widget::ColorBar();
m_widgetColorBar->registerOnEvent(this, "change", eventColorBarHasChange);
m_widgetColorBar->setFill(bvec2(true,true));
/*
@ -52,7 +52,7 @@ ewol::Widget::ColorChooser::ColorChooser() :
etk::Color<> sliderColor;
sliderColor = etk::color::black;
m_widgetRed = new ewol::Widget::Slider();
m_widgetRed = new ewol::widget::Slider();
m_widgetRed->registerOnEvent(this, "change", eventColorSpecificHasChange);
m_widgetRed->setExpand(bvec2(true,false));
m_widgetRed->setFill(bvec2(true,false));
@ -61,7 +61,7 @@ ewol::Widget::ColorChooser::ColorChooser() :
sliderColor = 0xFF0000FF;
m_widgetRed->setColor(sliderColor);
subWidgetAdd(m_widgetRed.get());
m_widgetGreen = new ewol::Widget::Slider();
m_widgetGreen = new ewol::widget::Slider();
m_widgetGreen->registerOnEvent(this, "change", eventColorSpecificHasChange);
m_widgetGreen->setExpand(bvec2(true,false));
m_widgetGreen->setFill(bvec2(true,false));
@ -70,7 +70,7 @@ ewol::Widget::ColorChooser::ColorChooser() :
m_widgetGreen->setColor(sliderColor);
m_widgetGreen->setMax(255);
subWidgetAdd(m_widgetGreen.get());
m_widgetBlue = new ewol::Widget::Slider();
m_widgetBlue = new ewol::widget::Slider();
m_widgetBlue->registerOnEvent(this, "change", eventColorSpecificHasChange);
m_widgetBlue->setExpand(bvec2(true,false));
m_widgetBlue->setFill(bvec2(true,false));
@ -79,7 +79,7 @@ ewol::Widget::ColorChooser::ColorChooser() :
m_widgetBlue->setColor(sliderColor);
m_widgetBlue->setMax(255);
subWidgetAdd(m_widgetBlue.get());
m_widgetAlpha = new ewol::Widget::Slider();
m_widgetAlpha = new ewol::widget::Slider();
m_widgetAlpha->registerOnEvent(this, "change", eventColorSpecificHasChange);
m_widgetAlpha->setExpand(bvec2(true,false));
m_widgetAlpha->setFill(bvec2(true,false));
@ -91,12 +91,12 @@ ewol::Widget::ColorChooser::ColorChooser() :
}
ewol::Widget::ColorChooser::~ColorChooser() {
ewol::widget::ColorChooser::~ColorChooser() {
}
void ewol::Widget::ColorChooser::setColor(etk::Color<> _newColor) {
void ewol::widget::ColorChooser::setColor(etk::Color<> _newColor) {
m_currentColor = _newColor;
if (NULL != m_widgetRed) {
m_widgetRed->setValue(m_currentColor.r());
@ -116,12 +116,12 @@ void ewol::Widget::ColorChooser::setColor(etk::Color<> _newColor) {
}
etk::Color<> ewol::Widget::ColorChooser::getColor() {
etk::Color<> ewol::widget::ColorChooser::getColor() {
return m_currentColor;
}
void ewol::Widget::ColorChooser::onReceiveMessage(const ewol::object::Message& _msg) {
void ewol::widget::ColorChooser::onReceiveMessage(const ewol::object::Message& _msg) {
if (NULL == _msg.getCaller()) {
return;
}
@ -169,9 +169,9 @@ 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);
ewol::widget::Sizer::onObjectRemove(_removeObject);
// second step find if in all the elements ...
if(_removeObject == m_widgetRed) {
m_widgetRed.reset();

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

@ -24,7 +24,7 @@ namespace ewol {
/**
* @ingroup ewolWidgetGroup
*/
class ColorChooser : public ewol::Widget::Sizer {
class ColorChooser : public ewol::widget::Sizer {
public:
// Event list of properties
static const char * const eventChange;
@ -38,11 +38,11 @@ namespace ewol {
void setColor(etk::Color<> _newColor);
etk::Color<> getColor();
private:
ewol::object::Shared<ewol::Widget::ColorBar> m_widgetColorBar;
ewol::object::Shared<ewol::Widget::Slider> m_widgetRed;
ewol::object::Shared<ewol::Widget::Slider> m_widgetGreen;
ewol::object::Shared<ewol::Widget::Slider> m_widgetBlue;
ewol::object::Shared<ewol::Widget::Slider> m_widgetAlpha;
ewol::object::Shared<ewol::widget::ColorBar> m_widgetColorBar;
ewol::object::Shared<ewol::widget::Slider> m_widgetRed;
ewol::object::Shared<ewol::widget::Slider> m_widgetGreen;
ewol::object::Shared<ewol::widget::Slider> m_widgetBlue;
ewol::object::Shared<ewol::widget::Slider> m_widgetAlpha;
etk::Color<> m_currentColor;
};
};

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

@ -45,7 +45,7 @@ namespace ewol {
* // simply set a folder (by default this is the home folder)
* //tmpWidget->setFolder("/home/me");
* // add the widget as windows pop-up ...
* ewol::Widget::Windows* tmpWindows = getWindows();
* ewol::widget::Windows* tmpWindows = getWindows();
* if (tmpWindows == NULL) {
* APPL_ERROR("Can not get the current windows !!! ");
* return -1;
@ -71,7 +71,7 @@ namespace ewol {
* [/code]
* This is the best example of a Meta-widget.
*/
class FileChooser : public ewol::Widget::Composer {
class FileChooser : public ewol::widget::Composer {
public:
// Event list of properties
static const char* const eventCancel;

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

@ -34,8 +34,8 @@ ewol::Widget::Parameter::Parameter() :
addObjectType("ewol::Widget::Parameter");
addEventId(eventClose);
ewol::Widget::Sizer * mySizerVert = NULL;
ewol::Widget::Sizer * mySizerHori = NULL;
ewol::widget::Sizer * mySizerVert = NULL;
ewol::widget::Sizer * mySizerHori = NULL;
ewol::Widget::Spacer * mySpacer = NULL;
#ifdef __TARGET_OS__Android
setMinSize(ewol::Dimension(vec2(90, 90), ewol::Dimension::Pourcent));
@ -43,7 +43,7 @@ ewol::Widget::Parameter::Parameter() :
setMinSize(ewol::Dimension(vec2(80, 80), ewol::Dimension::Pourcent));
#endif
mySizerVert = new ewol::Widget::Sizer(widget::Sizer::modeVert);
mySizerVert = new ewol::widget::Sizer(widget::Sizer::modeVert);
if (NULL == mySizerVert) {
EWOL_ERROR("Can not allocate widget == > display might be in error");
} else {
@ -53,7 +53,7 @@ ewol::Widget::Parameter::Parameter() :
// set it in the pop-up-system :
setSubWidget(mySizerVert);
mySizerHori = new ewol::Widget::Sizer(widget::Sizer::modeHori);
mySizerHori = new ewol::widget::Sizer(widget::Sizer::modeHori);
if (NULL == mySizerHori) {
EWOL_ERROR("Can not allocate widget == > display might be in error");
} else {
@ -67,12 +67,12 @@ ewol::Widget::Parameter::Parameter() :
mySizerHori->subWidgetAdd(mySpacer);
}
ewol::Widget::Button* tmpButton = new widget::Button();
ewol::widget::Button* tmpButton = new widget::Button();
if (NULL == tmpButton) {
EWOL_ERROR("Can not allocate widget == > display might be in error");
} else {
tmpButton->setSubWidget(
new ewol::Widget::Composer(widget::Composer::String,
new ewol::widget::Composer(widget::Composer::String,
"<composer>\n"
" <sizer mode=\"hori\">\n"
" <image src=\"THEME:GUI:Save.svg\" expand=\"true\" size=\"8,8mm\"/>\n"
@ -92,12 +92,12 @@ ewol::Widget::Parameter::Parameter() :
mySizerHori->subWidgetAdd(mySpacer);
}
tmpButton = new ewol::Widget::Button();
tmpButton = new ewol::widget::Button();
if (NULL == tmpButton) {
EWOL_ERROR("Can not allocate widget == > display might be in error");
} else {
tmpButton->setSubWidget(
new ewol::Widget::Composer(widget::Composer::String,
new ewol::widget::Composer(widget::Composer::String,
"<composer>\n"
" <sizer mode=\"hori\">\n"
" <image src=\"THEME:GUI:Remove.svg\" expand=\"true\" size=\"8,8mm\"/>\n"
@ -109,7 +109,7 @@ ewol::Widget::Parameter::Parameter() :
}
}
mySizerHori = new ewol::Widget::Sizer(widget::Sizer::modeHori);
mySizerHori = new ewol::widget::Sizer(widget::Sizer::modeHori);
if (NULL == mySizerHori) {
EWOL_ERROR("Can not allocate widget == > display might be in error");
} else {
@ -135,7 +135,7 @@ ewol::Widget::Parameter::Parameter() :
mySizerHori->subWidgetAdd(mySpacer);
}
ewol::Widget::Sizer * mySizerVert2 = new widget::Sizer(widget::Sizer::modeVert);
ewol::widget::Sizer * mySizerVert2 = new widget::Sizer(widget::Sizer::modeVert);
if (NULL == mySizerVert2) {
EWOL_ERROR("Can not allocate widget == > display might be in error");
} else {
@ -173,7 +173,7 @@ ewol::Widget::Parameter::Parameter() :
mySizerVert->subWidgetAdd(mySpacer);
}
m_widgetTitle = new ewol::Widget::Label("File chooser ...");
m_widgetTitle = new ewol::widget::Label("File chooser ...");
if (NULL == m_widgetTitle) {
EWOL_ERROR("Can not allocate widget == > display might be in error");
} else {
@ -240,7 +240,7 @@ void ewol::Widget::Parameter::menuAdd(std::string _label, std::string _image, ew
m_wSlider->subWidgetAdd(_associateWidget);
} else {
EWOL_DEBUG("Associate an empty widget on it ...");
ewol::Widget::Label * myLabel = new widget::Label((std::string("No widget for : ") + _label));
ewol::widget::Label * myLabel = new widget::Label((std::string("No widget for : ") + _label));
if (NULL == myLabel) {
EWOL_ERROR("Can not allocate widget == > display might be in error");
} else {

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

@ -44,7 +44,7 @@ namespace ewol {
void menuSeparator();
private:
int32_t m_currentIdList;
ewol::Widget::Label* m_widgetTitle;
ewol::widget::Label* m_widgetTitle;
ewol::Widget::ParameterList* m_paramList;
ewol::Widget::WSlider* m_wSlider;
};

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

@ -25,14 +25,14 @@ ewol::Widget::StdPopUp::StdPopUp() :
addObjectType("ewol::Widget::StdPopUp");
setMinSize(ewol::Dimension(vec2(20,10),ewol::Dimension::Pourcent));
ewol::Widget::Sizer* mySizerVert = NULL;
ewol::widget::Sizer* mySizerVert = NULL;
ewol::Widget::Spacer* mySpacer = NULL;
mySizerVert = new ewol::Widget::Sizer(widget::Sizer::modeVert);
mySizerVert = new ewol::widget::Sizer(widget::Sizer::modeVert);
// set it in the pop-up-system :
setSubWidget(mySizerVert);
m_subBar = new ewol::Widget::Sizer(widget::Sizer::modeHori);
m_subBar = new ewol::widget::Sizer(widget::Sizer::modeHori);
m_subBar->lockExpand(bvec2(true,true));
m_subBar->setExpand(bvec2(true,false));
mySizerVert->subWidgetAdd(m_subBar->get());
@ -51,7 +51,7 @@ ewol::Widget::StdPopUp::StdPopUp() :
mySpacer->setMinSize(ewol::Dimension(vec2(0,5),ewol::Dimension::Pixel));
mySizerVert->subWidgetAdd(mySpacer);
m_comment = new ewol::Widget::Label("No Label");
m_comment = new ewol::widget::Label("No Label");
m_comment->setExpand(bvec2(true,true));
mySizerVert->subWidgetAdd(m_comment->get());
@ -66,7 +66,7 @@ ewol::Widget::StdPopUp::StdPopUp() :
mySpacer->setMinSize(ewol::Dimension(vec2(0,3),ewol::Dimension::Pixel));
mySizerVert->subWidgetAdd(mySpacer);
m_title = new ewol::Widget::Label("<bold>Message</bold>");
m_title = new ewol::widget::Label("<bold>Message</bold>");
m_title->setExpand(bvec2(true,false));
m_title->setFill(bvec2(true,true));
mySizerVert->subWidgetAdd(m_title->get());
@ -92,19 +92,19 @@ 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;
}
ewol::Widget::Button* myButton = new widget::Button();
ewol::widget::Button* myButton = new widget::Button();
if (myButton == NULL) {
EWOL_ERROR("Can not allocate new button ...");
return NULL;
}
myButton->setSubWidget(new ewol::Widget::Label(_text));
myButton->setSubWidget(new ewol::widget::Label(_text));
if(_autoExit == true) {
myButton->registerOnEvent(this, ewol::Widget::Button::eventPressed, eventButtonExit);
myButton->registerOnEvent(this, ewol::widget::Button::eventPressed, eventButtonExit);
}
m_subBar->subWidgetAdd(myButton);
markToRedraw();

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

@ -50,7 +50,7 @@ namespace ewol {
*/
~StdPopUp();
protected:
ewol::object::Shared<ewol::Widget::Label> m_title; //!< Title Label widget
ewol::object::Shared<ewol::widget::Label> m_title; //!< Title Label widget
public:
/**
* @brief Set the title string.
@ -58,7 +58,7 @@ namespace ewol {
*/
void setTitle(const std::string& _text);
protected:
ewol::object::Shared<ewol::Widget::Label> m_comment; //!< Comment label widget
ewol::object::Shared<ewol::widget::Label> m_comment; //!< Comment label widget
public:
/**
* @brief Set the commentary string.
@ -66,13 +66,13 @@ namespace ewol {
*/
void setComment(const std::string& _text);
protected:
ewol::object::Shared<ewol::Widget::Sizer> m_subBar; //!< subwidget bar containing all the button.
ewol::object::Shared<ewol::widget::Sizer> m_subBar; //!< subwidget bar containing all the button.
public:
/**
* @brief Add a buttom button.
* @param[in] _text Decorated text to diplay in button.
*/
ewol::object::Shared<ewol::Widget::Button> addButton(const std::string& _text, bool _autoExit=false);
ewol::object::Shared<ewol::widget::Button> addButton(const std::string& _text, bool _autoExit=false);
public: // Derived function
virtual void onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject);
virtual void onReceiveMessage(const ewol::object::Message& _msg);