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

[DEV] start big rework of the shared pointer on objects

Browse Source
This commit is contained in:
Edouard DUPIN 2014-05-15 23:43:03 +02:00
parent cfbdc0e84e
commit 8740595b17
82 changed files with 1392 additions and 1142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -133,13 +133,13 @@ namespace ewol {
};
void ewol::Context::inputEventTransfertWidget(ewol::Widget* _source,
ewol::Widget* _destination) {
void ewol::Context::inputEventTransfertWidget(ewol::object::Shared<ewol::Widget> _source,
ewol::object::Shared<ewol::Widget> _destination) {
m_input.transfertEvent(_source, _destination);
}
void ewol::Context::inputEventGrabPointer(ewol::Widget* _widget) {
void ewol::Context::inputEventGrabPointer(ewol::object::Shared<ewol::Widget> _widget) {
m_input.grabPointer(_widget);
}
@ -194,7 +194,7 @@ void ewol::Context::processEvents() {
data->keyboardMove,
data->stateIsDown) ) {
// get the current focused Widget :
ewol::Widget * tmpWidget = m_widgetManager.focusGet();
ewol::object::Shared<ewol::Widget> tmpWidget = m_widgetManager.focusGet();
if (NULL != tmpWidget) {
// check if the widget allow repeating key events.
//EWOL_DEBUG("repeating test :" << data->repeateKey << " widget=" << tmpWidget->getKeyboardRepeate() << " state=" << data->stateIsDown);
@ -237,7 +237,7 @@ void ewol::Context::processEvents() {
break;
case eSystemMessage::msgClipboardArrive:
{
ewol::Widget * tmpWidget = m_widgetManager.focusGet();
ewol::object::Shared<ewol::Widget> tmpWidget = m_widgetManager.focusGet();
if (tmpWidget != NULL) {
tmpWidget->onEventClipboard(data->clipboardID);
}
@ -581,7 +581,7 @@ bool ewol::Context::OS_Draw(bool _displayEveryTime) {
//! ewol::widgetManager::periodicCall(currentTime);
m_widgetManager.periodicCall(currentTime);
// remove all widget that they are no more usefull (these who decided to destroy themself)
//! ewol::ObjectManager::removeAllAutoRemove();
//! ewol::object::Shared<ewol::Object>Manager::removeAllAutoRemove();
m_objectManager.removeAllAutoRemove();
// check if the user selected a windows
if (NULL != m_windowsCurrent) {
@ -648,7 +648,7 @@ bool ewol::Context::OS_Draw(bool _displayEveryTime) {
return hasDisplayDone;
}
void ewol::Context::onObjectRemove(ewol::Object * _removeObject) {
void ewol::Context::onObjectRemove(ewol::object::Shared<ewol::Object> * _removeObject) {
//EWOL_CRITICAL("element removed");
m_input.onObjectRemove(_removeObject);
}

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

@ -140,7 +140,7 @@ namespace ewol {
* @param[in] removeObject Pointer on the EObject removed == > the user must remove all reference on this EObject
* @note : Sub classes must call this class
*/
void onObjectRemove(ewol::Object* _removeObject);
void onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject);
/**
* @brief reset event management for the IO like Input ou Mouse or keyborad
*/
@ -229,12 +229,12 @@ 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::Widget* _source, ewol::Widget* _destination);
void inputEventTransfertWidget(ewol::object::Shared<ewol::Widget> _source, 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
*/
void inputEventGrabPointer(ewol::Widget* _widget);
void inputEventGrabPointer(ewol::object::Shared<ewol::Widget> _widget);
/**
* @brief This fonction un-lock the pointer properties to move in relative instead of absolute
*/

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

@ -42,7 +42,7 @@ void ewol::context::InputManager::setDpi(int32_t newDPI) {
}
bool ewol::context::InputManager::localEventInput(enum ewol::key::type _type,
ewol::Widget* _destWidget,
ewol::object::Shared<ewol::Widget> _destWidget,
int32_t _IdInput,
enum ewol::key::status _status,
vec2 _pos) {
@ -93,7 +93,7 @@ void ewol::context::InputManager::cleanElement(InputPoperty *_eventTable,
_eventTable[_idInput].posEvent.setValue(0,0);
}
void ewol::context::InputManager::transfertEvent(ewol::Widget* _source, ewol::Widget* _destination) {
void ewol::context::InputManager::transfertEvent(ewol::object::Shared<ewol::Widget> _source, ewol::Widget* _destination) {
if( NULL == _source
|| NULL == _destination) {
// prevent errors ...
@ -123,7 +123,7 @@ void ewol::context::InputManager::transfertEvent(ewol::Widget* _source, ewol::Wi
}
}
void ewol::context::InputManager::grabPointer(ewol::Widget* _widget) {
void ewol::context::InputManager::grabPointer(ewol::object::Shared<ewol::Widget> _widget) {
if(NULL == _widget) {
return;
}
@ -138,7 +138,7 @@ void ewol::context::InputManager::unGrabPointer() {
m_context.grabPointerEvents(false, vec2(0,0));
}
void ewol::context::InputManager::onObjectRemove(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 ...
@ -180,7 +180,7 @@ ewol::context::InputManager::~InputManager() {
}
int32_t ewol::context::InputManager::localGetDestinationId(enum ewol::key::type _type,
ewol::Widget* _destWidget,
ewol::object::Shared<ewol::Widget> _destWidget,
int32_t _realInputId) {
if (_type == ewol::key::typeFinger) {
int32_t lastMinimum = 0;
@ -226,7 +226,7 @@ void ewol::context::InputManager::motion(enum ewol::key::type _type,
if (_type == ewol::key::typeMouse && _pointerID == 0) {
// this event is all time on the good widget ... and manage the enter and leave ...
// NOTE : the "layer widget" force us to get the widget at the specific position all the time :
ewol::Widget* tmpWidget = NULL;
ewol::object::Shared<ewol::Widget> tmpWidget = NULL;
if (m_grabWidget != NULL) {
// grab all events ...
tmpWidget = m_grabWidget;

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

@ -24,7 +24,7 @@ namespace ewol {
bool isUsed;
int32_t destinationInputId;
int64_t lastTimeEvent;
ewol::Widget* curentWidgetEvent;
ewol::object::Shared<ewol::Widget> curentWidgetEvent;
vec2 origin;
vec2 size;
vec2 downStart;
@ -47,7 +47,7 @@ namespace ewol {
class InputManager {
// special grab pointer mode :
private:
ewol::Widget* m_grabWidget; //!< widget that grab the curent pointer.
ewol::object::Shared<ewol::Widget> m_grabWidget; //!< widget that grab the curent pointer.
private:
int32_t m_dpi;
InputLimit m_eventInputLimit;
@ -67,7 +67,7 @@ namespace ewol {
* @return true if event has been greped
*/
bool localEventInput(enum ewol::key::type _type,
ewol::Widget* _destWidget,
ewol::object::Shared<ewol::Widget> _destWidget,
int32_t _IdInput,
enum ewol::key::status _typeEvent,
vec2 _pos);
@ -81,7 +81,7 @@ namespace ewol {
* @return the ewol input id
*/
int32_t localGetDestinationId(enum ewol::key::type _type,
ewol::Widget* _destWidget,
ewol::object::Shared<ewol::Widget> _destWidget,
int32_t _realInputId);
private:
ewol::Context& m_context;
@ -99,7 +99,7 @@ namespace ewol {
* @param[in] removeObject Pointer on the Object remeved == > the user must remove all reference on this Object
* @note : Sub classes must call this class
*/
void onObjectRemove(ewol::Object* _removeObject);
void onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject);
/**
* @brief a new layer on the windows is set == > might remove all the property of the current element ...
*/
@ -109,12 +109,12 @@ 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::Widget* _source, ewol::Widget* _destination);
void transfertEvent(ewol::object::Shared<ewol::Widget> _source, 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
*/
void grabPointer(ewol::Widget* _widget);
void grabPointer(ewol::object::Shared<ewol::Widget> _widget);
/**
* @brief This fonction un-lock the pointer properties to move in relative instead of absolute
*/

8
sources/ewol/event/Input.h
View File

@ -78,7 +78,7 @@ namespace ewol {
enum ewol::key::status _status,
uint8_t _id,
const vec2& _pos,
ewol::Widget* _dest,
ewol::object::Shared<ewol::Widget> _dest,
int32_t _realIdEvent,
ewol::key::Special _specialKey) :
m_event(_type, _status, _id, _pos, _specialKey),
@ -86,13 +86,13 @@ namespace ewol {
m_realIdEvent(_realIdEvent) { };
ewol::event::Input m_event;
private:
ewol::Widget* m_dest;
ewol::object::Shared<ewol::Widget> m_dest;
int32_t m_realIdEvent;
public:
void setDestWidget(ewol::Widget* _dest) {
void setDestWidget(ewol::object::Shared<ewol::Widget> _dest) {
m_dest = _dest;
};
inline ewol::Widget* getDestWidget() const {
inline ewol::object::Shared<ewol::Widget> getDestWidget() const {
return m_dest;
};
void setRealId(int32_t _realIdEvent) {

12
sources/ewol/object/Manager.cpp
View File

@ -81,7 +81,7 @@ void ewol::object::Manager::unInit() {
}
}
void ewol::object::Manager::add(ewol::Object* _object) {
void ewol::object::Manager::add(ewol::object::Shared<ewol::Object> _object) {
if (_object == NULL) {
EWOL_ERROR("try to add an inexistant Object in manager");
}
@ -93,7 +93,7 @@ int32_t ewol::object::Manager::getNumberObject() {
return m_eObjectList.size() + m_eObjectAutoRemoveList.size();
}
void ewol::object::Manager::informOneObjectIsRemoved(ewol::Object* _object) {
void ewol::object::Manager::informOneObjectIsRemoved(ewol::object::Shared<ewol::Object> _object) {
size_t mbElement = m_eObjectList.size();
for (int64_t iii=0; iii<(int64_t)m_eObjectList.size(); ++iii) {
if ( m_eObjectList[iii] != NULL
@ -125,8 +125,8 @@ void ewol::object::Manager::informOneObjectIsRemoved(ewol::Object* _object) {
ewol::getContext().onObjectRemove(_object);
}
void ewol::object::Manager::rm(ewol::Object* _object) {
if (NULL == _object) {
void ewol::object::Manager::rm(ewol::object::Shared<ewol::Object> _object) {
if (_object == NULL) {
EWOL_ERROR("Try to remove (NULL) Object");
return;
}
@ -150,7 +150,7 @@ void ewol::object::Manager::rm(ewol::Object* _object) {
EWOL_ERROR("Try to remove Object that is not referenced ...");
}
void ewol::object::Manager::autoRemove(ewol::Object* _object) {
void ewol::object::Manager::autoRemove(ewol::object::Shared<ewol::Object> _object) {
if (NULL == _object) {
EWOL_ERROR("Try to Auto-Remove (NULL) Object");
return;
@ -185,7 +185,7 @@ void ewol::object::Manager::removeAllAutoRemove() {
m_eObjectAutoRemoveList.clear();
}
ewol::Object* ewol::object::Manager::get(const std::string& _name) {
ewol::object::Shared<ewol::Object> ewol::object::Manager::get(const std::string& _name) {
if (_name == "") {
return NULL;
}

14
sources/ewol/object/Manager.h
View File

@ -17,8 +17,8 @@ namespace ewol {
namespace object {
class Manager {
private:
std::vector<ewol::Object::Shared<ewol::Object>> m_eObjectList; // all widget allocated == > all time increment ... never removed ...
std::vector<ewol::Object::Shared<ewol::Object>> m_eObjectAutoRemoveList; // all widget allocated
std::vector<ewol::object::Shared<ewol::Object>> m_eObjectList; // all widget allocated == > all time increment ... never removed ...
std::vector<ewol::object::Shared<ewol::Object>> m_eObjectAutoRemoveList; // all widget allocated
public:
Manager();
~Manager();
@ -27,16 +27,16 @@ namespace ewol {
*/
void unInit();
void add(ewol::Object* _object);
void rm(ewol::Object* _object);
void add(ewol::object::Shared<ewol::Object> _object);
void rm(ewol::object::Shared<ewol::Object> _object);
int32_t getNumberObject();
void autoRemove(ewol::Object* _object);
void autoRemove(ewol::object::Shared<ewol::Object> _object);
void removeAllAutoRemove();
ewol::Object* get(const std::string& _name);
ewol::object::Shared<ewol::Object> get(const std::string& _name);
private:
void informOneObjectIsRemoved(ewol::Object* _object);
void informOneObjectIsRemoved(ewol::object::Shared<ewol::Object> _object);
private:
ewol::object::MultiCast m_multiCast; //!< muticast manager
public:

8
sources/ewol/object/Message.h
View File

@ -15,11 +15,11 @@ namespace ewol {
namespace object {
class Message {
private:
ewol::Object* m_callerObject; //!< Caller class.
ewol::object::Shared<ewol::Object> m_callerObject; //!< Caller class.
const char* m_event; //!< Event pointer == > unique Id define by the system ...
std::string m_data; //!< compositing additionnal message Value.
public:
Message(ewol::Object* _caller,
Message(ewol::object::Shared<ewol::Object> _caller,
const char* _message,
const std::string& _data) :
m_callerObject(_caller),
@ -27,10 +27,10 @@ namespace ewol {
m_data(_data) {
};
void setCaller(ewol::Object* _caller) {
void setCaller(ewol::object::Shared<ewol::Object> _caller) {
m_callerObject = _caller;
};
inline ewol::Object* getCaller() const {
inline ewol::object::Shared<ewol::Object> getCaller() const {
return m_callerObject;
};
void setMessage(const char* _message) {

6
sources/ewol/object/MultiCast.cpp
View File

@ -24,7 +24,7 @@ ewol::object::MultiCast::~MultiCast() {
}
void ewol::object::MultiCast::add(ewol::Object* _object, const char* const _message) {
void ewol::object::MultiCast::add(ewol::object::Shared<ewol::Object> _object, const char* const _message) {
if (NULL == _object) {
EWOL_ERROR("Add with NULL object");
return;
@ -38,7 +38,7 @@ void ewol::object::MultiCast::add(ewol::Object* _object, const char* const _mess
}
void ewol::object::MultiCast::rm(ewol::Object* _object) {
void ewol::object::MultiCast::rm(ewol::object::Shared<ewol::Object> _object) {
if (NULL == _object) {
EWOL_ERROR("Rm with NULL object");
return;
@ -54,7 +54,7 @@ void ewol::object::MultiCast::rm(ewol::Object* _object) {
}
}
void ewol::object::MultiCast::send(ewol::Object* _object, const char* const _message, const std::string& _data) {
void ewol::object::MultiCast::send(ewol::object::Shared<ewol::Object> _object, const char* const _message, const std::string& _data) {
EWOL_VERBOSE("SendMulticast message \"" << _message << "\" data=\"" << _data << "\" to :");
// send the message at all registered widget ...

10
sources/ewol/object/MultiCast.h
View File

@ -22,12 +22,12 @@ namespace ewol {
private:
class MessageList {
public:
MessageList(const char* _message=NULL, ewol::Object* _object=NULL) :
MessageList(const char* _message=NULL, ewol::object::Shared<ewol::Object> _object=NULL) :
m_message(_message), m_object(_object) {
}
const char* m_message;
ewol::Object* m_object;
ewol::object::Shared<ewol::Object> m_object;
};
std::vector<MessageList> m_messageList; //!< List of all message ...
public:
@ -36,9 +36,9 @@ namespace ewol {
void anonymousSend(const char* const _messageId, const std::string& _data) {
send(NULL, _messageId, _data);
};
void send(ewol::Object* _object, const char* const _message, const std::string& _data);
void rm(ewol::Object* _object);
void add(ewol::Object* _object, const char* const _message);
void send(ewol::object::Shared<ewol::Object> _object, const char* const _message, const std::string& _data);
void rm(ewol::object::Shared<ewol::Object> _object);
void add(ewol::object::Shared<ewol::Object> _object, const char* const _message);
};
};
};

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

@ -13,7 +13,7 @@
#include <ewol/object/MultiCast.h>
#undef __class__
#define __class__ "ewol::Object"
#define __class__ "ewol::object::Shared<ewol::Object>"
const char* const ewol::Object::configName = "name";
@ -21,19 +21,42 @@ size_t ewol::Object::m_valUID = 0;
void ewol::Object::objRefCountIncrement() {
std::scoped_lock lock(m_lockRefCount);
m_objRefCount++;
}
void ewol::Object::objRefCountDecrement() {
std::scoped_lock lock(m_lockRefCount);
m_objRefCount--;
}
bool ewol::Object::setRefOwner(bool _haveOwner) {
std::scoped_lock lock(m_lockRefCount);
if (_haveOwner == true) {
if (m_hasReferenceOwner == true) {
EWOL_CRITICAL("Object have already an owner");
return false;;
}
m_hasReferenceOwner == true;
return true;
}
if (m_hasReferenceOwner == false) {
EWOL_CRITICAL("Object have already NO owner");
return false;
}
m_hasReferenceOwner == false;
return true;
}
void ewol::Object::operator delete(void* _ptr, std::size_t _sz) {
EWOL_DEBUG("custom delete for size " << _sz);
ewol::Object* obj = (ewol::Object*)_ptr;
ewol::object::Shared<ewol::Object> obj = (ewol::Object*)_ptr;
obj->objRefCountDecrement();
if (obj->m_objRefCount <= 0) {
EWOL_DEBUG(" ==> real remove");
if (m_hasReferenceOwner == true) {
EWOL_ERROR(" ==> Remove ofject that have not a reference owner removed");
}
::operator delete(_ptr);
} else {
EWOL_DEBUG(" ==> Some user is link on it ...");
@ -49,6 +72,7 @@ void ewol::Object::operator delete[](void* _ptr, std::size_t _sz) {
ewol::Object::Object() :
m_objRefCount(1),
m_hasReferenceOwner(false),
m_static(false),
m_isResource(false) {
// note this is nearly atomic ... (but it is enough)
@ -86,7 +110,7 @@ ewol::Object::~Object() {
const char * const ewol::Object::getObjectType() {
if (m_listType.size() == 0) {
return "ewol::Object";
return "ewol::object::Shared<ewol::Object>";
}
return m_listType.back();
}
@ -99,7 +123,7 @@ void ewol::Object::addObjectType(const char* _type) {
m_listType.push_back(_type);
}
std::string ewol::Object::getTypeDescription() {
std::string ret("ewol::Object");
std::string ret("ewol::object::Shared<ewol::Object>");
for(auto element : m_listType) {
ret += "|";
ret += element;
@ -108,7 +132,7 @@ std::string ewol::Object::getTypeDescription() {
}
bool ewol::Object::isTypeCompatible(const std::string& _type) {
if (_type == "ewol::Object") {
if (_type == "ewol::object::Shared<ewol::Object>") {
return true;
}
for(auto element : m_listType) {
@ -179,7 +203,7 @@ void ewol::Object::registerMultiCast(const char* const _messageId) {
getMultiCast().add(this, _messageId);
}
void ewol::Object::registerOnEvent(ewol::Object * _destinationObject,
void ewol::Object::registerOnEvent(ewol::object::Shared<ewol::Object> _destinationObject,
const char * _eventId,
const char * _eventIdgenerated,
const std::string& _overloadData) {
@ -251,7 +275,7 @@ void ewol::Object::registerOnEvent(ewol::Object * _destinationObject,
m_externEvent.push_back(tmpEvent);
}
void ewol::Object::unRegisterOnEvent(ewol::Object * _destinationObject,
void ewol::Object::unRegisterOnEvent(ewol::object::Shared<ewol::Object> _destinationObject,
const char * _eventId) {
if (NULL == _destinationObject) {
EWOL_ERROR("Input ERROR NULL pointer Object ...");
@ -273,11 +297,9 @@ void ewol::Object::unRegisterOnEvent(ewol::Object * _destinationObject,
}
}
void ewol::Object::onObjectRemove(ewol::Object * _removObject) {
void ewol::Object::onObjectRemove(ewol::object::Shared<ewol::Object> _object) {
for(int32_t iii=m_externEvent.size()-1; iii >= 0; iii--) {
if (NULL == m_externEvent[iii]) {
m_externEvent.erase(m_externEvent.begin()+iii);
} else if (m_externEvent[iii]->destObject == _removObject) {
if (m_externEvent[iii].hasOwner() == false) {
m_externEvent.erase(m_externEvent.begin()+iii);
}
}
@ -285,10 +307,10 @@ void ewol::Object::onObjectRemove(ewol::Object * _removObject) {
void ewol::Object::registerConfig(const char* _config,
const char* _type,
const char* _control,
const char* _description,
const char* _default) {
const char* _type,
const char* _control,
const char* _description,
const char* _default) {
if (NULL == _config) {
EWOL_ERROR("Try to add NULL config");
return;
@ -400,7 +422,7 @@ std::string ewol::Object::getConfig(const std::string& _config) const {
}
bool ewol::Object::setConfigNamed(const std::string& _objectName, const ewol::object::Config& _conf) {
ewol::Object* object = getObjectManager().get(_objectName);
ewol::object::Shared<ewol::Object> object = getObjectManager().get(_objectName);
if (object == NULL) {
return false;
}
@ -408,7 +430,7 @@ bool ewol::Object::setConfigNamed(const std::string& _objectName, const ewol::ob
}
bool ewol::Object::setConfigNamed(const std::string& _objectName, const std::string& _config, const std::string& _value) {
ewol::Object* object = getObjectManager().get(_objectName);
ewol::object::Shared<ewol::Object> object = getObjectManager().get(_objectName);
if (object == NULL) {
return false;
}

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

@ -13,7 +13,7 @@
#include <etk/types.h>
#include <vector>
#include <exml/exml.h>
#include <vector>
#include <mutex>
namespace ewol {
// some class need to define element befor other ...
class Object;
@ -26,6 +26,8 @@ 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 {
@ -37,7 +39,7 @@ namespace ewol {
class EventExtGen {
public:
const char* localEventId; //!< local event Id generation
ewol::Object* destObject; //!< destination widget that might be call
ewol::object::Shared<ewol::Object> destObject; //!< destination widget that might be call
const char* destEventId; //!< generated event ID on the distant widget
std::string overloadData; //!< sometimes the user prefer to receive some specific data on an event (instead of the one sed by the widget)
};
@ -47,91 +49,29 @@ namespace ewol {
* this class mermit at every Object to communicate between them.
*/
class Object {
public:
template<typename T, typename = typename std::enable_if<std::is_convertible<T*, Object*>::value>::type>
class Shared {
private:
T* m_pointer;
public:
Shared() :
m_pointer(nullptr) {
// nothing to do ...
}
Shared(T* _pointer) :
m_pointer(_pointer) {
if (m_pointer == nullptr) {
return;
}
m_pointer->objRefCountIncrement();
}
~Shared() {
reset();
}
// copy constructor
Shared(const Shared& _obj) :
m_pointer(nullptr) {
m_pointer = _obj.get();
if (m_pointer == nullptr) {
return;
}
m_pointer->objRefCountIncrement();
}
// Move Constructor
Shared(Shared&& _obj) :
m_pointer(nullptr) {
// transfert pointer
m_pointer = _obj.m_pointer;
_obj.m_pointer = nullptr;
}
Shared& operator=(const Shared<T>& _obj) noexcept {
if(this == &_obj) {
return *this;
}
reset();
m_pointer = _obj.get();
if (m_pointer != nullptr) {
m_pointer->objRefCountIncrement();
}
return *this;
}
void reset() {
if (m_pointer == nullptr) {
return;
}
if (m_pointer->m_objRefCount <= 0) {
TK_ERROR("Object is already removed");
} else if (m_pointer->m_objRefCount == 1) {
TK_ERROR("Remove object (in shared)");
delete m_pointer;
} else {
m_pointer->objRefCountDecrement();
}
m_pointer = nullptr;
}
T* get() noexcept {
return m_pointer;
}
T* get() const noexcept {
return m_pointer;
}
T& operator*() const noexcept {
return *m_pointer;
}
T* operator->() const noexcept {
return m_pointer;
}
};
template<typename T> Shared<T> makeShared(T* _pointer) {
return Shared<T>(_pointer);
}
template<typename T> friend class ewol::object::Shared;
template<typename T> friend class ewol::object::Owner;
private:
// TODO : Lock Refcounting ...
//! @not-in-doc
std::mutex m_lockRefCount;
//! @not-in-doc
int32_t m_objRefCount;
//! @not-in-doc
bool m_hasReferenceOwner;
public:
//! @not-in-doc
void objRefCountIncrement();
//! @not-in-doc
void objRefCountDecrement();
//! @not-in-doc
bool setRefOwner(bool haveOwner);
//! @not-in-doc
bool getRefOwner() {
return m_hasReferenceOwner;
}
//! @not-in-doc
static void operator delete(void* _ptr, std::size_t _sz);
//! @not-in-doc
static void operator delete[](void* _ptr, std::size_t _sz);
private:
static size_t m_valUID; //!< stic used for the unique ID definition
@ -241,7 +181,7 @@ namespace ewol {
* @param[in] _eventIdgenerated event generated when call the distant Object.onReceiveMessage(...)
* @param[in] _overloadData When the user prever to receive a data specificly for this event ...
*/
void registerOnEvent(ewol::Object * _destinationObject,
void registerOnEvent(ewol::object::Shared<ewol::Object> _destinationObject,
const char * _eventId,
const char * _eventIdgenerated = NULL,
const std::string& _overloadData = "");
@ -250,14 +190,13 @@ namespace ewol {
* @param[in] _destinationObject pointer on the object that might be call when an event is generated
* @param[in] _eventId Event generate inside the object (NULL to remove all event on this object)
*/
void unRegisterOnEvent(ewol::Object * _destinationObject,
void unRegisterOnEvent(ewol::object::Shared<ewol::Object> _destinationObject,
const char * _eventId = NULL);
/**
* @brief Inform object that an other object is removed ...
* @param[in] _removObject Pointer on the Object remeved == > the user must remove all reference on this Object
* @note : Sub classes must call this class
*/
virtual void onObjectRemove(ewol::Object * _removeObject);
virtual void onObjectRemove(ewol::object::Shared<ewol::Object> _object);
/**
* @brief Receive a message from an other Object with a specific eventId and data
* @param[in] _msg Message handle
@ -388,91 +327,6 @@ namespace ewol {
return m_isResource;
}
};
// section to compare shared pointer of an object with an other
//! @not in doc
template<typename T, typename T2>
inline bool operator==(const Object::Shared<T>& _obj, const Object::Shared<T2>& _obj2) noexcept {
return _obj.get() == _obj2.get();
}
//! @not in doc
template<typename T2>
inline bool operator==(const Object::Shared<T2>& _obj, std::nullptr_t) noexcept {
return _obj.get() == NULL;
}
//! @not in doc
template<typename T2>
inline bool operator==(std::nullptr_t, const Object::Shared<T2>& _obj) noexcept {
return _obj.get() == NULL;
}
//! @not in doc
template<typename T, typename T2, typename = typename
std::enable_if<std::is_convertible<T*, T2*>::value>::type>
inline bool operator==(const Object::Shared<T>& _obj, const T2* _obj2) noexcept {
return _obj.get() == _obj2;
}
//! @not in doc
template<typename T, typename T2, typename = typename
std::enable_if<std::is_convertible<T*, T2*>::value>::type>
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::Shared<T>& _obj, const Object::Shared<T2>& _obj2) noexcept {
return _obj.get() != _obj2.get();
}
//! @not in doc
template<typename T>
inline bool operator!=(const Object::Shared<T>& _obj, std::nullptr_t) noexcept {
return _obj.get() != NULL;
}
//! @not in doc
template<typename T>
inline bool operator!=(std::nullptr_t, const Object::Shared<T>& _obj) noexcept {
return _obj.get() != NULL;
}
//! @not in doc
template<typename T, typename T2, typename = typename
std::enable_if<std::is_convertible<T*, T2*>::value>::type>
inline bool operator!=(const Object::Shared<T>& _obj, const T2* _obj2) noexcept {
return _obj.get() != _obj2;
}
//! @not in doc
template<typename T, typename T2, typename = typename
std::enable_if<std::is_convertible<T*, T2*>::value>::type>
inline bool operator!=(const T* _obj, const Object::Shared<T2>& _obj2) noexcept {
return _obj != _obj2.get();
}
//! @not in doc
template<typename T>
inline void swap(Object::Shared<T>& _obj, Object::Shared<T>& _obj2) noexcept {
_obj2.swap(_obj);
}
//! @not in doc
template<typename T2, typename T>
inline Object::Shared<T2> static_pointer_cast(const Object::Shared<T>& _obj) noexcept {
return Object::Shared<T2>(_obj, static_cast<T2*>(_obj.get()));
}
//! @not in doc
template<typename T2, typename T>
inline Object::Shared<T2> const_pointer_cast(const Object::Shared<T>& _obj) noexcept {
return Object::Shared<T2>(_obj, const_cast<T2*>(_obj.get()));
}
//! @not in doc
template<typename T2, typename T>
inline Object::Shared<T2> dynamic_pointer_cast(const Object::Shared<T>& _obj) noexcept {
if (T2* obj = dynamic_cast<T2*>(_obj.get())) {
return Object::Shared<T2>(_obj, obj);
}
return Object::Shared<T2>();
}
};
#endif

185
sources/ewol/object/Owner.h Normal file
View File

@ -0,0 +1,185 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license BSD 3 clauses (see license file)
*/
#ifndef __EWOL_OBJECT_OWNER_H__
#define __EWOL_OBJECT_OWNER_H__
namespace ewol {
class Object;
namespace object {
template<typename T, typename = typename std::enable_if<std::is_convertible<T*, ewol::Object*>::value>::type>
class Owner {
private:
T* m_pointer;
public:
Owner() :
m_pointer(nullptr) {
// nothing to do ...
}
Owner(T* _pointer) :
m_pointer(_pointer) {
if (m_pointer == nullptr) {
return;
}
if (m_pointer->setRefOwner(true) == false) {
m_pointer = nullptr;
return;
}
m_pointer->objRefCountIncrement();
}
~Owner() {
reset();
}
// copy constructor
Owner(const Owner& _obj) :
m_pointer(nullptr) {
EWOL_CRITICAL("You can not user copy operator for Owner reference...");
}
// Move Constructor
Owner(Owner&& _obj) :
m_pointer(nullptr) {
// transfert pointer
m_pointer = _obj.m_pointer;
_obj.m_pointer = nullptr;
}
Owner& operator=(const Owner<T>& _obj) noexcept {
if(this == &_obj) {
return *this;
}
reset();
m_pointer = _obj.get();
if (m_pointer != nullptr) {
if (m_pointer->setRefOwner(true) == false) {
m_pointer = nullptr;
return *this;
}
m_pointer->objRefCountIncrement();
}
return *this;
}
void reset() {
if (m_pointer == nullptr) {
return;
}
m_pointer->setRefOwner(false);
if (m_pointer->m_objRefCount <= 0) {
EWOL_ERROR("Object is already removed");
} else if (m_pointer->m_objRefCount == 1) {
EWOL_ERROR("Remove object (in Owner)");
delete m_pointer;
} else {
m_pointer->objRefCountDecrement();
}
m_pointer = nullptr;
}
T* get() noexcept {
return m_pointer;
}
T* get() const noexcept {
return m_pointer;
}
T& operator*() const noexcept {
return *m_pointer;
}
T* operator->() const noexcept {
return m_pointer;
}
};
template<typename T> Owner<T> makeOwner(T* _pointer) {
return Owner<T>(_pointer);
}
};
// section to compare Owner pointer of an object with an other
//! @not in doc
template<typename T, typename T2>
inline bool operator==(const object::Owner<T>& _obj, const object::Owner<T2>& _obj2) noexcept {
return _obj.get() == _obj2.get();
}
//! @not in doc
template<typename T2>
inline bool operator==(const object::Owner<T2>& _obj, std::nullptr_t) noexcept {
return _obj.get() == NULL;
}
//! @not in doc
template<typename T2>
inline bool operator==(std::nullptr_t, const object::Owner<T2>& _obj) noexcept {
return _obj.get() == NULL;
}
//! @not in doc
template<typename T, typename T2, typename = typename
std::enable_if<std::is_convertible<T*, T2*>::value>::type>
inline bool operator==(const object::Owner<T>& _obj, const T2* _obj2) noexcept {
return _obj.get() == _obj2;
}
//! @not in doc
template<typename T, typename T2, typename = typename
std::enable_if<std::is_convertible<T*, T2*>::value>::type>
inline bool operator==(const T* _obj, const object::Owner<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::Owner<T2>& _obj2) noexcept {
return _obj.get() != _obj2.get();
}
//! @not in doc
template<typename T>
inline bool operator!=(const object::Owner<T>& _obj, std::nullptr_t) noexcept {
return _obj.get() != NULL;
}
//! @not in doc
template<typename T>
inline bool operator!=(std::nullptr_t, const object::Owner<T>& _obj) noexcept {
return _obj.get() != NULL;
}
//! @not in doc
template<typename T, typename T2, typename = typename
std::enable_if<std::is_convertible<T*, T2*>::value>::type>
inline bool operator!=(const object::Owner<T>& _obj, const T2* _obj2) noexcept {
return _obj.get() != _obj2;
}
//! @not in doc
template<typename T, typename T2, typename = typename
std::enable_if<std::is_convertible<T*, T2*>::value>::type>
inline bool operator!=(const T* _obj, const object::Owner<T2>& _obj2) noexcept {
return _obj != _obj2.get();
}
//! @not in doc
template<typename T>
inline void swap(object::Owner<T>& _obj, object::Owner<T>& _obj2) noexcept {
_obj2.swap(_obj);
}
//! @not in doc
template<typename T2, typename T>
inline object::Owner<T2> static_pointer_cast(const object::Owner<T>& _obj) noexcept {
return object::Owner<T2>(_obj, static_cast<T2*>(_obj.get()));
}
//! @not in doc
template<typename T2, typename T>
inline object::Owner<T2> const_pointer_cast(const object::Owner<T>& _obj) noexcept {
return object::Owner<T2>(_obj, const_cast<T2*>(_obj.get()));
}
//! @not in doc
template<typename T2, typename T>
inline object::Owner<T2> dynamic_pointer_cast(const object::Owner<T>& _obj) noexcept {
if (T2* obj = dynamic_cast<T2*>(_obj.get())) {
return object::Owner<T2>(_obj, obj);
}
return object::Owner<T2>();
}
};
#endif

186
sources/ewol/object/Shared.h Normal file
View File

@ -0,0 +1,186 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license BSD 3 clauses (see license file)
*/
#ifndef __EWOL_OBJECT_SHARED_H__
#define __EWOL_OBJECT_SHARED_H__
namespace ewol {
class Object;
namespace object {
template<typename T, typename = typename std::enable_if<std::is_convertible<T*, Object*>::value>::type>
class Shared {
private:
T* m_pointer;
public:
Shared() :
m_pointer(nullptr) {
// nothing to do ...
}
Shared(T* _pointer) :
m_pointer(_pointer) {
if (m_pointer == nullptr) {
return;
}
m_pointer->objRefCountIncrement();
}
~Shared() {
reset();
}
// copy constructor
Shared(const Shared& _obj) :
m_pointer(nullptr) {
m_pointer = _obj.get();
if (m_pointer == nullptr) {
return;
}
m_pointer->objRefCountIncrement();
}
// Move Constructor
Shared(Shared&& _obj) :
m_pointer(nullptr) {
// transfert pointer
m_pointer = _obj.m_pointer;
_obj.m_pointer = nullptr;
}
bool hasOwner() {
if (m_pointer == nullptr) {
return false;
}
return m_pointer->getRefOwner();
}
Shared& operator=(const Shared<T>& _obj) noexcept {
if(this == &_obj) {
return *this;
}
reset();
m_pointer = _obj.get();
if (m_pointer != nullptr) {
m_pointer->objRefCountIncrement();
}
return *this;
}
void reset() {
if (m_pointer == nullptr) {
return;
}
if (m_pointer->m_objRefCount <= 0) {
EWOL_ERROR("Object is already removed");
} else if (m_pointer->m_objRefCount == 1) {
EWOL_ERROR("Remove object (in shared)");
delete m_pointer;
} else {
m_pointer->objRefCountDecrement();
}
m_pointer = nullptr;
}
T* get() noexcept {
return m_pointer;
}
T* get() const noexcept {
return m_pointer;
}
T& operator*() const noexcept {
return *m_pointer;
}
T* operator->() const noexcept {
return m_pointer;
}
};
template<typename T> Shared<T> makeShared(T* _pointer) {
return Shared<T>(_pointer);
}
};
// section to compare shared pointer of an object with an other
//! @not in doc
template<typename T, typename T2>
inline bool operator==(const object::Shared<T>& _obj, const object::Shared<T2>& _obj2) noexcept {
return _obj.get() == _obj2.get();
}
//! @not in doc
template<typename T2>
inline bool operator==(const object::Shared<T2>& _obj, std::nullptr_t) noexcept {
return _obj.get() == NULL;
}
//! @not in doc
template<typename T2>
inline bool operator==(std::nullptr_t, const object::Shared<T2>& _obj) noexcept {
return _obj.get() == NULL;
}
//! @not in doc
template<typename T, typename T2, typename = typename
std::enable_if<std::is_convertible<T*, T2*>::value>::type>
inline bool operator==(const object::Shared<T>& _obj, const T2* _obj2) noexcept {
return _obj.get() == _obj2;
}
//! @not in doc
template<typename T, typename T2, typename = typename
std::enable_if<std::is_convertible<T*, T2*>::value>::type>
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::Shared<T>& _obj, const object::Shared<T2>& _obj2) noexcept {
return _obj.get() != _obj2.get();
}
//! @not in doc
template<typename T>
inline bool operator!=(const object::Shared<T>& _obj, std::nullptr_t) noexcept {
return _obj.get() != NULL;
}
//! @not in doc
template<typename T>
inline bool operator!=(std::nullptr_t, const object::Shared<T>& _obj) noexcept {
return _obj.get() != NULL;
}
//! @not in doc
template<typename T, typename T2, typename = typename
std::enable_if<std::is_convertible<T*, T2*>::value>::type>
inline bool operator!=(const object::Shared<T>& _obj, const T2* _obj2) noexcept {
return _obj.get() != _obj2;
}
//! @not in doc
template<typename T, typename T2, typename = typename
std::enable_if<std::is_convertible<T*, T2*>::value>::type>
inline bool operator!=(const T* _obj, const object::Shared<T2>& _obj2) noexcept {
return _obj != _obj2.get();
}
//! @not in doc
template<typename T>
inline void swap(object::Shared<T>& _obj, object::Shared<T>& _obj2) noexcept {
_obj2.swap(_obj);
}
//! @not in doc
template<typename T2, typename T>
inline object::Shared<T2> static_pointer_cast(const object::Shared<T>& _obj) noexcept {
return object::Shared<T2>(_obj, static_cast<T2*>(_obj.get()));
}
//! @not in doc
template<typename T2, typename T>
inline object::Shared<T2> const_pointer_cast(const object::Shared<T>& _obj) noexcept {
return object::Shared<T2>(_obj, const_cast<T2*>(_obj.get()));
}
//! @not in doc
template<typename T2, typename T>
inline object::Shared<T2> dynamic_pointer_cast(const object::Shared<T>& _obj) noexcept {
if (T2* obj = dynamic_cast<T2*>(_obj.get())) {
return object::Shared<T2>(_obj, obj);
}
return object::Shared<T2>();
}
};
#endif

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 * _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 * _removeObject);
virtual void onObjectRemove(ewol::object::Shared<ewol::Object> * _removeObject);
};
};
};

82
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::Widget* Create() {
return new ewol::widget::Button();
static ewol::object::Shared<ewol::Widget> Create() {
return new ewol::Widget::Button();
}
void ewol::widget::Button::init(ewol::widget::Manager& _widgetManager) {
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::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;

40
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::widget::Manager& _widgetManager) {
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,21 +176,21 @@ 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();
ewol::Widget::Windows* currentWindows = getWindows();
if (NULL == currentWindows) {
EWOL_ERROR("Can not get the curent Windows...");
delete(m_widgetContextMenu);
@ -218,17 +218,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 +238,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 +247,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::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::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 :

56
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::widget::Manager& _widgetManager) {
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::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()) {

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

@ -18,7 +18,7 @@
namespace ewol {
namespace widget {
class ColorBar :public ewol::Widget {
class ColorBar : public ewol::Widget {
public:
// Event list of properties
static const char * const eventChange;

30
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,25 +83,25 @@ 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 * _destinationObject,
void ewol::Widget::Composer::registerOnEventNameWidget(ewol::object::Shared<ewol::Object> * _destinationObject,
const std::string& _subWidgetName,
const char * _eventId,
const char * _eventIdgenerated,
const std::string& _overloadData) {
ewol::Widget* tmpWidget = getWidgetNamed(_subWidgetName);
ewol::object::Shared<ewol::Widget> tmpWidget = getWidgetNamed(_subWidgetName);
if (NULL != tmpWidget) {
EWOL_DEBUG("Find widget named : \"" << _subWidgetName << "\" register event=\"" << _eventId << "\"");
tmpWidget->registerOnEvent(_destinationObject, _eventId, _eventIdgenerated, _overloadData);

4
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,
@ -78,7 +78,7 @@ namespace ewol {
* @param[in] _overloadData When the user prever to receive a data specificly for this event ...
* @note : To used when NOT herited from this object.
*/
void registerOnEventNameWidget(ewol::Object * _destinationObject,
void registerOnEventNameWidget(ewol::object::Shared<ewol::Object> _destinationObject,
const std::string& _subWidgetName,
const char * _eventId,
const char * _eventIdgenerated = NULL,

36
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::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,15 +53,15 @@ 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::Widget* ewol::widget::Container::getWidgetNamed(const std::string& _widgetName) {
ewol::Widget* tmpUpperWidget = ewol::Widget::getWidgetNamed(_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::Widget* ewol::widget::Container::getWidgetNamed(const std::string& _widget
return NULL;
}
void ewol::widget::Container::onObjectRemove(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* _removeObject) {
}
}
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::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::Widget* ewol::widget::Container::getWidgetAtPos(const vec2& _pos) {
};
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::Widget* tmpWidget = getWidgetManager().create(widgetName);
ewol::object::Shared<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 ...

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

@ -19,9 +19,9 @@ namespace ewol {
* @ingroup ewolWidgetGroup
* @brief the Cotainer widget is a widget that have an only one subWidget
*/
class Container : public ewol::Widget {
class Container : public ewol::object::Shared<ewol::Widget> {
protected:
ewol::Widget* m_subWidget;
ewol::object::Owner<ewol::Widget> m_subWidget;
public:
/**
* @brief Constructor
@ -36,7 +36,7 @@ namespace ewol {
* @brief get the main node widget
* @return the requested pointer on the node
*/
ewol::Widget* getSubWidget();
ewol::object::Shared<ewol::Widget> getSubWidget();
/**
* @brief set the subWidget node widget.
* @param[in] _newWidget The widget to add.
@ -54,11 +54,11 @@ namespace ewol {
public: // Derived function
virtual void systemDraw(const ewol::DrawProperty& _displayProp);
virtual void onRegenerateDisplay();
virtual void onObjectRemove(ewol::Object* _removeObject);
virtual void onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject);
virtual void calculateSize(const vec2& _availlable);
virtual void calculateMinMaxSize();
virtual ewol::Widget* getWidgetAtPos(const vec2& _pos);
virtual ewol::Widget* getWidgetNamed(const std::string& _widgetName);
virtual ewol::object::Shared<ewol::Widget> getWidgetAtPos(const vec2& _pos);
virtual ewol::object::Shared<ewol::Widget> getWidgetNamed(const std::string& _widgetName);
virtual bool loadXML(exml::Element* _node);
virtual void setOffset(const vec2& _newVal);
};

34
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,8 +60,8 @@ void ewol::widget::Container2::subWidgetUnLink(int32_t _idWidget) {
m_subWidget[_idWidget] = NULL;
}
ewol::Widget* ewol::widget::Container2::getWidgetNamed(const std::string& _widgetName) {
ewol::Widget* tmpUpperWidget = ewol::Widget::getWidgetNamed(_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::Widget* ewol::widget::Container2::getWidgetNamed(const std::string& _widge
return NULL;
}
void ewol::widget::Container2::onObjectRemove(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* _removeObject) {
}
}
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::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::Widget* ewol::widget::Container2::getWidgetAtPos(const vec2& _pos) {
}
*/
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::Widget* tmpWidget = getWidgetManager().create(widgetName);
ewol::object::Shared<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 ...

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

@ -20,9 +20,9 @@ namespace ewol {
* @ingroup ewolWidgetGroup
* @brief the Cotainer widget is a widget that have an only one subWidget
*/
class Container2 : public ewol::Widget {
class Container2 : public ewol::object::Shared<ewol::Widget> {
protected:
ewol::Widget* m_subWidget[2]; //!< 2 subwidget possible
ewol::object::Owner<ewol::Widget> m_subWidget[2]; //!< 2 subwidget possible
int32_t m_idWidgetDisplayed; //!< current widget displayed
public:
/**
@ -30,7 +30,7 @@ namespace ewol {
* @param[in] _subElement Widget to set on the normal position
* @param[in] _subElementToggle Widget to set on the toggle position
*/
Container2(ewol::Widget* _subElement = NULL, ewol::Widget* _subElementToggle = NULL);
Container2(ewol::Widget* _subElement = nullptr, ewol::Widget* _subElementToggle = nullptr);
/**
* @brief Destructor
*/
@ -63,7 +63,7 @@ namespace ewol {
* @param[in] _idWidget Id of the widget to set
* @return The base widget
*/
ewol::Widget* getSubWidget(int32_t _idWidget) const {
ewol::object::Shared<ewol::Widget> getSubWidget(int32_t _idWidget) const {
return m_subWidget[_idWidget];
};
public:
@ -71,14 +71,14 @@ namespace ewol {
* @brief get the current displayed composition
* @return The base widget
*/
ewol::Widget* getSubWidget() const {
ewol::object::Shared<ewol::Widget> getSubWidget() const {
return getSubWidget(0);
};
/**
* @brief get the current displayed composition
* @return The toggle widget
*/
ewol::Widget* getSubWidgetToggle() const {
ewol::object::Shared<ewol::Widget> getSubWidgetToggle() const {
return getSubWidget(1);
};
private:
@ -152,15 +152,15 @@ namespace ewol {
public: // Derived function
virtual void systemDraw(const ewol::DrawProperty& _displayProp);
virtual void onRegenerateDisplay();
virtual void onObjectRemove(ewol::Object* _removeObject);
virtual void onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject);
virtual void calculateSize(const vec2& _availlable) {
calculateSizePadded(_availlable);
}
virtual void calculateMinMaxSize() {
calculateMinMaxSizePadded();
}
//virtual ewol::Widget* getWidgetAtPos(const vec2& _pos);
virtual ewol::Widget* getWidgetNamed(const std::string& _widgetName);
//virtual ewol::object::Shared<ewol::Widget> getWidgetAtPos(const vec2& _pos);
virtual ewol::object::Shared<ewol::Widget> getWidgetNamed(const std::string& _widgetName);
virtual bool loadXML(exml::Element* _node);
virtual void setOffset(const vec2& _newVal);
};

48
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,14 +154,14 @@ void ewol::widget::ContainerN::subWidgetRemoveAllDelayed() {
m_subWidget.clear();
}
ewol::Widget* ewol::widget::ContainerN::getWidgetNamed(const std::string& _widgetName) {
ewol::Widget* tmpUpperWidget = ewol::Widget::getWidgetNamed(_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;
}
for (size_t iii=0; iii<m_subWidget.size(); iii++) {
if (NULL != m_subWidget[iii]) {
ewol::Widget* tmpWidget = m_subWidget[iii]->getWidgetNamed(_widgetName);
ewol::object::Shared<ewol::Widget> tmpWidget = m_subWidget[iii]->getWidgetNamed(_widgetName);
if (NULL != tmpWidget) {
return tmpWidget;
}
@ -170,7 +170,7 @@ ewol::Widget* ewol::widget::ContainerN::getWidgetNamed(const std::string& _widge
return NULL;
}
void ewol::widget::ContainerN::onObjectRemove(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* _removeObject) {
}
}
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::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::Widget* ewol::widget::ContainerN::getWidgetAtPos(const vec2& _pos) {
if( (tmpOrigin.x() <= _pos.x() && tmpOrigin.x() + tmpSize.x() >= _pos.x())
&& (tmpOrigin.y() <= _pos.y() && tmpOrigin.y() + tmpSize.y() >= _pos.y()) )
{
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::Widget* ewol::widget::ContainerN::getWidgetAtPos(const vec2& _pos) {
};
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::Widget *subWidget = getWidgetManager().create(widgetName);
ewol::object::Shared<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 ...

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

@ -21,7 +21,7 @@ namespace ewol {
*/
class ContainerN : public ewol::Widget {
protected:
std::vector<ewol::Widget*> m_subWidget;
std::vector<ewol::object::Owner<ewol::Widget>> m_subWidget;
public:
/**
* @brief Constructor
@ -88,11 +88,11 @@ namespace ewol {
public:// Derived function
virtual void systemDraw(const ewol::DrawProperty& _displayProp);
virtual void onRegenerateDisplay();
virtual void onObjectRemove(ewol::Object* _removeObject);
virtual void onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject);
virtual void calculateSize(const vec2& _availlable);
virtual void calculateMinMaxSize();
virtual ewol::Widget* getWidgetAtPos(const vec2& _pos);
virtual ewol::Widget* getWidgetNamed(const std::string& _widgetName);
virtual ewol::object::Shared<ewol::Widget> getWidgetAtPos(const vec2& _pos);
virtual ewol::object::Shared<ewol::Widget> getWidgetNamed(const std::string& _widgetName);
virtual bool loadXML(exml::Element* _node);
virtual void setOffset(const vec2& _newVal);
};

50
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::Widget* Create() {
return new ewol::widget::ContextMenu();
static ewol::object::Shared<ewol::Widget> Create() {
return new ewol::Widget::ContextMenu();
}
void ewol::widget::ContextMenu::init(ewol::widget::Manager& _widgetManager) {
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::Widget* ewol::widget::ContextMenu::getWidgetAtPos(const vec2& _pos) {
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::Widget* ewol::widget::ContextMenu::getWidgetAtPos(const vec2& _pos) {
}
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) {

8
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::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;
@ -67,9 +67,9 @@ namespace ewol {
public: // Derived function
virtual void onRegenerateDisplay();
virtual bool onEventInput(const ewol::event::Input& _event);
virtual void calculateSize(const vec2& availlable);
virtual void calculateSize(const vec2& _availlable);
virtual void calculateMinMaxSize();
virtual ewol::Widget* getWidgetAtPos(const vec2& pos);
virtual ewol::object::Shared<ewol::Widget> getWidgetAtPos(const vec2& _pos);
};
};
};

72
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::Widget* create() {
return new ewol::widget::Entry();
static ewol::object::Shared<ewol::Widget> create() {
return new ewol::Widget::Entry();
}
void ewol::widget::Entry::init(ewol::widget::Manager& _widgetManager) {
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::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

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

@ -15,31 +15,31 @@
#define __class__ "Gird"
static ewol::Widget* create() {
return new ewol::widget::Gird();
static ewol::object::Shared<ewol::Widget> create() {
return new ewol::Widget::Gird();
}
void ewol::widget::Gird::init(ewol::widget::Manager& _widgetManager) {
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 :
@ -168,7 +168,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 +178,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,11 +193,11 @@ 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 ) {
@ -218,7 +218,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;
}
@ -260,7 +260,7 @@ 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)
void ewol::Widget::Gird::subWidgetRemove(ewol::Widget* _newWidget)
{
if (NULL == _newWidget) {
return;
@ -281,7 +281,7 @@ void ewol::widget::Gird::subWidgetRemove(ewol::Widget* _newWidget)
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;
@ -311,7 +311,7 @@ void ewol::widget::Gird::subWidgetRemove(int32_t _colId, int32_t _rowId) {
EWOL_WARNING("[" << getId() << "] Can not remove unExistant widget");
}
void ewol::widget::Gird::subWidgetUnLink(ewol::Widget* _newWidget) {
void ewol::Widget::Gird::subWidgetUnLink(ewol::Widget* _newWidget) {
if (NULL == _newWidget) {
return;
}
@ -324,7 +324,7 @@ void ewol::widget::Gird::subWidgetUnLink(ewol::Widget* _newWidget) {
}
}
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;
@ -341,7 +341,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 +350,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 +358,7 @@ void ewol::widget::Gird::onRegenerateDisplay() {
}
}
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 +370,7 @@ ewol::Widget * ewol::widget::Gird::getWidgetAtPos(const vec2& _pos) {
if( (tmpOrigin.x() <= _pos.x() && tmpOrigin.x() + tmpSize.x() >= _pos.x())
&& (tmpOrigin.y() <= _pos.y() && tmpOrigin.y() + tmpSize.y() >= _pos.y()) )
{
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 +382,7 @@ ewol::Widget * ewol::widget::Gird::getWidgetAtPos(const vec2& _pos) {
return NULL;
}
void ewol::widget::Gird::onObjectRemove(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 ...

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

@ -22,11 +22,11 @@ namespace ewol {
*/
class Gird :public ewol::Widget {
public:
static void init(ewol::widget::Manager& _widgetManager);
static void init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager);
private:
class GirdProperties {
public:
ewol::Widget* widget;
ewol::object::Owner<ewol::Widget> widget;
int32_t row;
int32_t col;
};
@ -34,7 +34,7 @@ namespace ewol {
int32_t m_uniformSizeRow;
std::vector<int32_t> m_sizeCol; //!< size of all colomn (if set (otherwise 0))
std::vector<GirdProperties> m_subWidget; //!< all sub widget are contained in this element
ewol::Widget* m_tmpWidget; //!< use when replace a widget ...
ewol::object::Shared<ewol::Widget> m_tmpWidget; //!< use when replace a widget ...
bool m_gavityButtom;
public:
/**
@ -102,7 +102,7 @@ namespace ewol {
* @brief remove definitly a widget from the system and this Gird.
* @param[in] _newWidget the element pointer.
*/
virtual void subWidgetRemove(ewol::Widget* _newWidget);
virtual void subWidgetRemove(ewol::object::Shared<ewol::Widget> _newWidget);
/**
* @brief remove definitly a widget from the system and this Gird.
* @param[in] _colId Id of the colomn [0..x].
@ -113,7 +113,7 @@ namespace ewol {
* @brief Just unlick the specify widget, this function does not remove it from the system (if you can, do nt use it ...).
* @param[in] _newWidget the element pointer.
*/
virtual void subWidgetUnLink(ewol::Widget* _newWidget);
virtual void subWidgetUnLink(ewol::object::Shared<ewol::Widget> _newWidget);
/**
* @brief Just unlick the specify widget, this function does not remove it from the system (if you can, do nt use it ...).
* @param[in] _colId Id of the colomn [0..x].
@ -132,12 +132,14 @@ namespace ewol {
* @brief get the current border size of the current element:
* @return the border size (0 if not used)
*/
const ivec2& getBorderSize() { return m_borderSize; };
const ivec2& getBorderSize() {
return m_borderSize;
};
public: // Derived function
virtual void systemDraw(const ewol::DrawProperty& _displayProp);
virtual void onRegenerateDisplay();
virtual ewol::Widget* getWidgetAtPos(const vec2& pos);
virtual void onObjectRemove(ewol::Object* _removeObject);
virtual ewol::object::Shared<ewol::Widget> getWidgetAtPos(const vec2& pos);
virtual void onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject);
virtual void calculateSize(const vec2& _availlable);
virtual void calculateMinMaxSize();
};

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

@ -16,33 +16,33 @@
#undef __class__
#define __class__ "Image"
static ewol::Widget* create() {
return new ewol::widget::Image();
static ewol::object::Shared<ewol::Widget> create() {
return new ewol::Widget::Image();
}
void ewol::widget::Image::init(ewol::widget::Manager& _widgetManager) {
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::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;
}

32
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::widget::Manager& _widgetManager) {
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::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.

14
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::widget::Manager& _widgetManager) {
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::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::Widget* ewol::widget::Layer::getWidgetAtPos(const vec2& _pos) {
if( (tmpOrigin.x() <= _pos.x() && tmpOrigin.x() + tmpSize.x() >= _pos.x())
&& (tmpOrigin.y() <= _pos.y() && tmpOrigin.y() + tmpSize.y() >= _pos.y()) )
{
ewol::Widget * tmpWidget = m_subWidget[iii]->getWidgetAtPos(_pos);
ewol::object::Shared<ewol::Widget> * tmpWidget = m_subWidget[iii]->getWidgetAtPos(_pos);
if (NULL != tmpWidget) {
return tmpWidget;
}

6
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::widget::Manager& _widgetManager);
static void init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager);
public:
/**
* @brief Constructor
@ -35,7 +35,7 @@ namespace ewol {
*/
virtual ~Layer();
public: // Derived function
virtual ewol::Widget* getWidgetAtPos(const vec2& _pos);
virtual ewol::object::Shared<ewol::Widget> getWidgetAtPos(const vec2& _pos);
};
};
};

26
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)) {
@ -235,15 +235,15 @@ bool ewol::widget::List::onEventInput(const ewol::event::Input& _event) {
bool isUsed = onItemEvent(_event.getId(), _event.getStatus(), 0, rawID, _event.getPos().x(), _event.getPos().y());
if (true == isUsed) {
// TODO : this generate bugs ... I did not understand why ..
//ewol::widgetManager::focusKeep(this);
//ewol::object::Shared<ewol::Widget>Manager::focusKeep(this);
}
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");
}

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

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

58
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::widget::Manager& _widgetManager) {
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::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

82
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::Spacer::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::Scroll::init(*this);
ewol::widget::ContextMenu::init(*this);
ewol::widget::PopUp::init(*this);
ewol::widget::WSlider::init(*this);
ewol::widget::ListFileSystem::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::ProgressBar::init(*this);
ewol::Widget::Layer::init(*this);
ewol::Widget::Label::init(*this);
ewol::Widget::Image::init(*this);
ewol::Widget::Gird::init(*this);
ewol::Widget::Entry::init(*this);
ewol::Widget::CheckBox::init(*this);
ewol::Widget::Scroll::init(*this);
ewol::Widget::ContextMenu::init(*this);
ewol::Widget::PopUp::init(*this);
ewol::Widget::WSlider::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::Widget * ewol::widget::Manager::focusGet() {
ewol::object::Shared<ewol::Widget> * ewol::Widget::Manager::focusGet() {
return m_focusWidgetCurrent;
}
void ewol::widget::Manager::focusRemoveIfRemove(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::Widget* _newWidget) {
}
}
void ewol::widget::Manager::periodicCallAdd(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::Widget* _pWidget) {
m_havePeriodic = true;
}
void ewol::widget::Manager::periodicCallRm(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::Widget * _pWidget) {
}
}
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,11 +259,11 @@ 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 (true == m_creatorList.exist(nameLower)) {
ewol::widget::Manager::creator_tf pointerFunction = m_creatorList[nameLower];
if (NULL != pointerFunction) {
if (m_creatorList.exist(nameLower) == true) {
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);

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

@ -22,9 +22,9 @@ namespace ewol {
typedef ewol::Widget* (*creator_tf)();
private:
// For the focus Management
ewol::Widget* m_focusWidgetDefault;
ewol::Widget* m_focusWidgetCurrent;
std::vector<ewol::Widget*> m_listOfPeriodicWidget;
ewol::object::Shared<ewol::Widget> m_focusWidgetDefault;
ewol::object::Shared<ewol::Widget> m_focusWidgetCurrent;
std::vector<ewol::object::Shared<ewol::Widget>> m_listOfPeriodicWidget;
bool m_havePeriodic;
bool m_haveRedraw;
etk::Hash<creator_tf> m_creatorList;
@ -34,16 +34,16 @@ namespace ewol {
Manager();
~Manager();
// need to call when remove a widget to clear all dependency of the focus system
void rm(ewol::Widget* _newWidget);
void rm(ewol::object::Shared<ewol::Widget> _newWidget);
void focusKeep(ewol::Widget* _newWidget); // set the focus at the specific widget
void focusSetDefault(ewol::Widget* _newWidget); // select the default focus getter
void focusKeep(ewol::object::Shared<ewol::Widget> _newWidget); // set the focus at the specific widget
void focusSetDefault(ewol::object::Shared<ewol::Widget> _newWidget); // select the default focus getter
void focusRelease(); // release focus from the current widget to the default
ewol::Widget* focusGet();
void focusRemoveIfRemove(ewol::Widget* _newWidget);
ewol::object::Shared<ewol::Widget> focusGet();
void focusRemoveIfRemove(ewol::object::Shared<ewol::Widget> _newWidget);
void periodicCallAdd(ewol::Widget* _pWidget);
void periodicCallRm(ewol::Widget* _pWidget);
void periodicCallAdd(ewol::object::Shared<ewol::Widget> _pWidget);
void periodicCallRm(ewol::object::Shared<ewol::Widget> _pWidget);
void periodicCall(int64_t _localTime);
void periodicCallResume(int64_t _localTime);
bool periodicCallHave();

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

@ -18,35 +18,35 @@
#undef __class__
#define __class__ "Menu"
ewol::widget::Menu::Menu() {
addObjectType("ewol::widget::Menu");
ewol::Widget::Menu::Menu() {
addObjectType("ewol::Widget::Menu");
m_staticId = 0;
m_widgetContextMenu = NULL;
}
ewol::widget::Menu::~Menu() {
ewol::Widget::Menu::~Menu() {
clear();
}
void ewol::widget::Menu::subWidgetRemoveAll() {
void ewol::Widget::Menu::subWidgetRemoveAll() {
clear();
ewol::widget::Sizer::subWidgetRemoveAll();
ewol::Widget::Sizer::subWidgetRemoveAll();
}
int32_t ewol::widget::Menu::subWidgetAdd(ewol::Widget* _newWidget) {
int32_t ewol::Widget::Menu::subWidgetAdd(ewol::Widget* _newWidget) {
EWOL_ERROR("Not availlable");
return -1;
}
void ewol::widget::Menu::subWidgetRemove(ewol::Widget* _newWidget) {
void ewol::Widget::Menu::subWidgetRemove(ewol::Widget* _newWidget) {
EWOL_ERROR("Not availlable");
}
void ewol::widget::Menu::subWidgetUnLink(ewol::Widget* _newWidget) {
void ewol::Widget::Menu::subWidgetUnLink(ewol::Widget* _newWidget) {
EWOL_ERROR("Not availlable");
}
void ewol::widget::Menu::clear() {
void ewol::Widget::Menu::clear() {
for (size_t iii=0; iii < m_listElement.size(); iii++) {
if (m_listElement[iii] != NULL) {
delete(m_listElement[iii]);
@ -56,19 +56,19 @@ void ewol::widget::Menu::clear() {
m_listElement.clear();
}
int32_t ewol::widget::Menu::addTitle(std::string _label,
int32_t ewol::Widget::Menu::addTitle(std::string _label,
std::string _image,
const char * _generateEvent,
const std::string _message) {
return add(-1, _label, _image, _generateEvent, _message);
}
int32_t ewol::widget::Menu::add(int32_t _parent,
int32_t ewol::Widget::Menu::add(int32_t _parent,
std::string _label,
std::string _image,
const char *_generateEvent,
const std::string _message) {
ewol::widget::MenuElement *tmpObject = new ewol::widget::MenuElement();
ewol::Widget::MenuElement *tmpObject = new ewol::Widget::MenuElement();
if (NULL == tmpObject) {
EWOL_ERROR("Allocation problem");
return -1;
@ -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,33 +97,33 @@ 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;
}
void ewol::widget::Menu::addSpacer() {
void ewol::Widget::Menu::addSpacer() {
EWOL_TODO("NOT now...");
}
void ewol::widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
void ewol::Widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
/*
if (true == ewol::sizer::onReceiveMessage(_msg) {
return true;
}
*/
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,14 +151,14 @@ 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;
}
// get the button widget :
vec2 newPosition;
ewol::Widget * eventFromWidget = static_cast<ewol::Widget*>(_msg.getCaller());
ewol::object::Shared<ewol::Widget> * eventFromWidget = static_cast<ewol::Widget*>(_msg.getCaller());
if (NULL != eventFromWidget) {
vec2 tmpOri = eventFromWidget->getOrigin();
vec2 tmpSize = eventFromWidget->getSize();
@ -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();
@ -256,8 +256,8 @@ void ewol::widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
}
void ewol::widget::Menu::onObjectRemove(ewol::Object * _removeObject) {
ewol::widget::Sizer::onObjectRemove(_removeObject);
void ewol::Widget::Menu::onObjectRemove(ewol::object::Shared<ewol::Object> * _removeObject) {
ewol::Widget::Sizer::onObjectRemove(_removeObject);
if (m_widgetContextMenu == _removeObject) {
m_widgetContextMenu = NULL;
}

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

@ -23,7 +23,7 @@ namespace ewol {
MenuElement() : m_widgetPointer(NULL) { };
int32_t m_localId;
int32_t m_parentId;
ewol::Object* m_widgetPointer;
ewol::object::Shared<ewol::Object> m_widgetPointer;
std::string m_label;
std::string m_image;
const char *m_generateEvent;
@ -32,19 +32,19 @@ namespace ewol {
/**
* @ingroup ewolWidgetGroup
*/
class Menu :public ewol::widget::Sizer {
class Menu :public ewol::Widget::Sizer {
public:
Menu();
virtual ~Menu();
private:
virtual void subWidgetRemoveAll();
virtual int32_t subWidgetAdd(ewol::Widget* _newWidget);
virtual void subWidgetRemove(ewol::Widget* _newWidget);
virtual void subWidgetUnLink(ewol::Widget* _newWidget);
virtual int32_t subWidgetAdd(ewol::object::Shared<ewol::Widget> _newWidget);
virtual void subWidgetRemove(ewol::object::Shared<ewol::Widget> _newWidget);
virtual void subWidgetUnLink(ewol::object::Shared<ewol::Widget> _newWidget);
private:
std::vector<ewol::widget::MenuElement*> m_listElement;
std::vector<ewol::Widget::MenuElement*> m_listElement;
int32_t m_staticId; // unique ID for every element of the menu ...
ewol::widget::ContextMenu* m_widgetContextMenu;
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 = "");
@ -52,7 +52,7 @@ namespace ewol {
void addSpacer();
// Derived function
virtual void onReceiveMessage(const ewol::object::Message& _msg);
virtual void onObjectRemove(ewol::Object * _removeObject);
virtual void onObjectRemove(ewol::object::Shared<ewol::Object> * _removeObject);
};
};
};

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

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

6
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::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;
@ -82,7 +82,7 @@ namespace ewol {
virtual void onRegenerateDisplay();
virtual void calculateSize(const vec2& _available);
virtual bool onEventInput(const ewol::event::Input& _event);
virtual ewol::Widget* getWidgetAtPos(const vec2& pos);
virtual ewol::object::Shared<ewol::Widget> getWidgetAtPos(const vec2& _pos);
protected:
virtual bool onStartAnnimation(enum ewol::Widget::annimationMode _mode);
virtual void onStopAnnimation();

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

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

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

@ -21,9 +21,9 @@ namespace ewol {
/**
* @ingroup ewolWidgetGroup
*/
class ProgressBar : public ewol::Widget {
class ProgressBar : public ewol::object::Shared<ewol::Widget> {
public:
static void init(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;

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

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

6
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::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.
@ -67,7 +67,7 @@ namespace ewol {
virtual void onRegenerateDisplay();
virtual bool onEventInput(const ewol::event::Input& _event);
virtual void systemDraw(const ewol::DrawProperty& _displayProp);
virtual ewol::Widget* getWidgetAtPos(const vec2& _pos);
virtual ewol::object::Shared<ewol::Widget> getWidgetAtPos(const vec2& _pos);
protected: // Derived function
virtual void onDraw();
virtual bool onSetConfig(const ewol::object::Config& _conf);

66
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::Widget* create() {
return new ewol::widget::Sizer();
static ewol::object::Shared<ewol::Widget> create() {
return new ewol::Widget::Sizer();
}
void ewol::widget::Sizer::init(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) {

14
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::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
*/
@ -119,10 +119,10 @@ namespace ewol {
virtual void calculateSize(const vec2& _availlable);
virtual void calculateMinMaxSize();
// overwrite the set fuction to start annimations ...
virtual int32_t subWidgetAdd(ewol::Widget* _newWidget);
virtual int32_t subWidgetAddStart(ewol::Widget* _newWidget);
virtual void subWidgetRemove(ewol::Widget* _newWidget);
virtual void subWidgetUnLink(ewol::Widget* _newWidget);
virtual int32_t subWidgetAdd(ewol::object::Shared<ewol::Widget> _newWidget);
virtual int32_t subWidgetAddStart(ewol::object::Shared<ewol::Widget> _newWidget);
virtual void subWidgetRemove(ewol::object::Shared<ewol::Widget> _newWidget);
virtual void subWidgetUnLink(ewol::object::Shared<ewol::Widget> _newWidget);
virtual bool onSetConfig(const ewol::object::Config& _conf);
virtual bool onGetConfig(const char* _config, std::string& _result) const;
};

28
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::widget::Manager& _widgetManager) {
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()) {

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

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

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

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

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

@ -21,9 +21,9 @@ namespace ewol {
/**
* @ingroup ewolWidgetGroup
*/
class Spacer :public ewol::Widget {
class Spacer : public ewol::Widget {
public:
static void init(ewol::widget::Manager& _widgetManager);
static void init(ewol::object::Shared<ewol::Widget::Manager> _widgetManager);
// Config list of properties
static const char* const configColor;
private:
@ -46,7 +46,7 @@ namespace ewol {
*/
void setColor(etk::Color<> _newColor) { m_color = _newColor; markToRedraw(); };
public: // Derived function
virtual ewol::Widget * getWidgetAtPos(const vec2& _pos) { return NULL; };
virtual ewol::object::Shared<ewol::Widget> getWidgetAtPos(const vec2& _pos) { return NULL; };
virtual void onRegenerateDisplay();
virtual void onDraw();
virtual bool onSetConfig(const ewol::object::Config& _conf);

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

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

10
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::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;
@ -58,7 +58,7 @@ namespace ewol {
* @brief Select a new subwidget to display
* @param[in] _widgetPointer Pointer on the widget selected (must be added before)
*/
void subWidgetSelectSet(ewol::Widget* _widgetPointer);
void subWidgetSelectSet(ewol::object::Shared<ewol::Widget> _widgetPointer);
/**
* @brief Select a new subwidget to display
* @param[in] _widgetName Name of the subwidget name
@ -100,13 +100,13 @@ namespace ewol {
virtual void calculateSize(const vec2& _availlable);
virtual void systemDraw(const ewol::DrawProperty& _displayProp);
virtual void onRegenerateDisplay();
virtual ewol::Widget* getWidgetAtPos(const vec2& _pos);
virtual ewol::object::Shared<ewol::Widget> getWidgetAtPos(const vec2& _pos);
virtual void periodicCall(const ewol::event::Time& _event);
virtual bool onSetConfig(const ewol::object::Config& _conf);
virtual bool onGetConfig(const char* _config, std::string& _result) const;
};
};
std::ostream& operator <<(std::ostream& _os, const enum ewol::widget::WSlider::sladingMode _obj);
std::ostream& operator <<(std::ostream& _os, const enum ewol::Widget::WSlider::sladingMode _obj);
};
#endif

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

@ -133,7 +133,7 @@ ewol::Widget::Widget() :
m_annimationType[1] = NULL;
m_annimationTime[0] = 0.1f; // annimation will be 100ms at the first state
m_annimationTime[1] = 0.1f; // annimation will be 100ms at the first state
addObjectType("ewol::Widget");
addObjectType("ewol::object::Shared<ewol::Widget>");
// set all the config in the list :
registerConfig(ewol::Widget::configFill, "bvec2", NULL, "Fill the widget available size");
registerConfig(ewol::Widget::configExpand, "bvec2", NULL, "Request the widget Expand size wile space is available");
@ -159,22 +159,22 @@ ewol::Widget::~Widget() {
shortCutClean();
}
void ewol::Widget::setUpperWidget(ewol::Widget* _upper) {
if (NULL == _upper) {
void ewol::Widget::setUpperWidget(ewol::object::Shared<ewol::Widget> _upper) {
if (_upper == nullptr) {
//just remove father :
m_up = NULL;
return;
}
if (NULL != m_up) {
if (m_up != nullptr) {
EWOL_WARNING("[" << getId() << "] Replace upper widget of this one ...");
}
m_up = _upper;
}
void ewol::Widget::onObjectRemove(ewol::Object* _removeObject) {
void ewol::Widget::onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject) {
if (_removeObject == m_up) {
EWOL_WARNING("[" << getId() << "] remove upper widget befor removing this widget ...");
m_up = NULL;
EWOL_WARNING("[" << getId() << "] remove upper widget before removing this widget ...");
m_up = nullptr;
}
}
@ -717,7 +717,7 @@ bool ewol::Widget::loadXML(exml::Element* _node) {
return true;
}
ewol::Widget* ewol::Widget::getWidgetNamed(const std::string& _widgetName) {
ewol::object::Shared<ewol::Widget> ewol::Widget::getWidgetNamed(const std::string& _widgetName) {
EWOL_VERBOSE("[" << getId() << "] {" << getObjectType() << "} compare : " << getName() << " == " << _widgetName );
if (getName() == _widgetName) {
return this;
@ -868,11 +868,11 @@ void ewol::Widget::requestUpdateSize() {
getContext().requestUpdateSize();
}
ewol::widget::Manager& ewol::Widget::getWidgetManager() {
ewol::object::Shared<ewol::Widget::Manager> ewol::Widget::getWidgetManager() {
return getContext().getWidgetManager();
}
ewol::widget::Windows* ewol::Widget::getWindows() {
ewol::object::Shared<ewol::Widget::Windows> ewol::Widget::getWindows() {
return getContext().getWindows();
}

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

@ -9,6 +9,10 @@
#ifndef __EWOL_WIDGET_H__
#define __EWOL_WIDGET_H__
#include <vector>
#include <etk/types.h>
#include <etk/math/Vector2D.h>
#include <ewol/object/Object.h>
#include <ewol/Dimension.h>
@ -19,9 +23,6 @@ namespace ewol {
class Windows;
};
};
#include <etk/types.h>
#include <vector>
#include <etk/math/Vector2D.h>
#include <ewol/debug.h>
#include <ewol/context/clipBoard.h>
#include <ewol/key/key.h>
@ -115,7 +116,7 @@ namespace ewol {
* :** Receive Event (keyboard / mouse / ...)
*
*/
class Widget : public ewol::Object {
class Widget : public ewol::object::Shared<ewol::Object> {
public:
// Config list of properties
static const char* const configFill;
@ -139,13 +140,13 @@ namespace ewol {
// -- Hierarchy management:
// ----------------------------------------------------------------------------------------------------------------
protected:
ewol::Widget* m_up; //!< uppper widget in the tree of widget
ewol::object::Shared<ewol::Widget> m_up; //!< uppper widget in the tree of widget
public:
/**
* @brief set the upper widget of this widget.
* @param[in] _upper Father widget (only keep the last and write error if a previous was set) == > disable with NULL.
*/
void setUpperWidget(ewol::Widget* _upper);
void setUpperWidget(ewol::object::Shared<ewol::Widget> _upper);
/**
* @brief remove the upper widget of this widget.
*/
@ -156,7 +157,7 @@ namespace ewol {
* @brief get the upper widget (father).
* @ return the requested widget (if NULL , 2 case : root widget or error implementation).
*/
ewol::Widget* getUpperWidget() {
ewol::object::Shared<ewol::Widget> getUpperWidget() {
return m_up;
};
// ----------------------------------------------------------------------------------------------------------------
@ -531,7 +532,7 @@ namespace ewol {
* @return pointer on the widget found
* @note : INTERNAL EWOL SYSTEM
*/
virtual ewol::Widget* getWidgetAtPos(const vec2& _pos) {
virtual ewol::object::Shared<ewol::Widget> getWidgetAtPos(const vec2& _pos) {
if (false == isHide()) {
return this;
}
@ -542,7 +543,7 @@ namespace ewol {
* @param[in] _widgetName name of the widget
* @return the requested pointer on the node (or NULL pointer)
*/
virtual ewol::Widget* getWidgetNamed(const std::string& _widgetName);
virtual ewol::object::Shared<ewol::Widget> getWidgetNamed(const std::string& _widgetName);
// event section:
public:
@ -698,7 +699,7 @@ namespace ewol {
*/
virtual enum ewol::context::cursorDisplay getCursor();
public: // Derived function
virtual void onObjectRemove(ewol::Object* _removeObject);
virtual void onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject);
virtual bool loadXML(exml::Element* _node);
protected: // Derived function
virtual bool onSetConfig(const ewol::object::Config& _conf);
@ -711,11 +712,11 @@ namespace ewol {
/**
* @brief get the current Widget Manager
*/
ewol::widget::Manager& getWidgetManager();
ewol::object::Shared<ewol::Widget::Manager> getWidgetManager();
/**
* @brief get the curent Windows
*/
ewol::widget::Windows* getWindows();
ewol::object::Shared<ewol::Widget::Windows> getWindows();
/*
* Annimation section :
*/

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

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

34
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::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::Widget * ewol::widget::Windows::getWidgetAtPos(const vec2& _pos) {
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,18 +201,18 @@ 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;
}
ewol::Widget* widget = m_popUpWidgetList[m_popUpWidgetList.size()-1];
ewol::object::Shared<ewol::Widget> widget = m_popUpWidgetList[m_popUpWidgetList.size()-1];
if (widget == NULL) {
return;
}
widget->removeObject();
}
void ewol::widget::Windows::onObjectRemove(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,23 +230,23 @@ void ewol::widget::Windows::onObjectRemove(ewol::Object* _removeObject) {
}
}
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();
ewol::Widget::StdPopUp* tmpPopUp = new widget::StdPopUp();
if (tmpPopUp == NULL) {
EWOL_ERROR("Can not create a simple pop-up");
return;

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

@ -56,8 +56,8 @@ namespace ewol {
m_hasDecoration = true;
}
private:
ewol::Widget* m_subWidget;
std::vector<ewol::Widget*> m_popUpWidgetList;
ewol::object::Owner<ewol::Widget> m_subWidget;
std::vector<ewol::object::Owner<ewol::Widget>> m_popUpWidgetList;
public:
void setSubWidget(ewol::Widget* _widget);
void popUpWidgetPush(ewol::Widget* _widget);
@ -84,9 +84,9 @@ namespace ewol {
virtual void systemDraw(const ewol::DrawProperty& _displayProp);
public: // Derived function
virtual void onRegenerateDisplay();
virtual void onObjectRemove(ewol::Object * _removeObject);
virtual void onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject);
virtual void calculateSize(const vec2& _availlable);
virtual ewol::Widget * getWidgetAtPos(const vec2& _pos);
virtual ewol::object::Shared<ewol::Widget> getWidgetAtPos(const vec2& _pos);
void setTitle(const std::string& _title);
public:
enum popUpMessageType {

50
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,19 +40,19 @@ 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));
/*
m_widgetColorBar->setWidth(200);
m_widgetColorBar->setHeigh(200);
*/
subWidgetAdd(m_widgetColorBar);
subWidgetAdd(m_widgetColorBar.get());
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));
@ -60,8 +60,8 @@ ewol::widget::ColorChooser::ColorChooser() :
m_widgetRed->setMax(255);
sliderColor = 0xFF0000FF;
m_widgetRed->setColor(sliderColor);
subWidgetAdd(m_widgetRed);
m_widgetGreen = new ewol::widget::Slider();
subWidgetAdd(m_widgetRed.get());
m_widgetGreen = new ewol::Widget::Slider();
m_widgetGreen->registerOnEvent(this, "change", eventColorSpecificHasChange);
m_widgetGreen->setExpand(bvec2(true,false));
m_widgetGreen->setFill(bvec2(true,false));
@ -69,8 +69,8 @@ ewol::widget::ColorChooser::ColorChooser() :
sliderColor = 0x00FF00FF;
m_widgetGreen->setColor(sliderColor);
m_widgetGreen->setMax(255);
subWidgetAdd(m_widgetGreen);
m_widgetBlue = new ewol::widget::Slider();
subWidgetAdd(m_widgetGreen.get());
m_widgetBlue = new ewol::Widget::Slider();
m_widgetBlue->registerOnEvent(this, "change", eventColorSpecificHasChange);
m_widgetBlue->setExpand(bvec2(true,false));
m_widgetBlue->setFill(bvec2(true,false));
@ -78,25 +78,25 @@ ewol::widget::ColorChooser::ColorChooser() :
sliderColor = 0x0000FFFF;
m_widgetBlue->setColor(sliderColor);
m_widgetBlue->setMax(255);
subWidgetAdd(m_widgetBlue);
m_widgetAlpha = new ewol::widget::Slider();
subWidgetAdd(m_widgetBlue.get());
m_widgetAlpha = new ewol::Widget::Slider();
m_widgetAlpha->registerOnEvent(this, "change", eventColorSpecificHasChange);
m_widgetAlpha->setExpand(bvec2(true,false));
m_widgetAlpha->setFill(bvec2(true,false));
m_widgetAlpha->setMin(0);
m_widgetAlpha->setMax(255);
subWidgetAdd(m_widgetAlpha);
subWidgetAdd(m_widgetAlpha.get());
m_currentColor = etk::color::white;
}
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,24 +169,24 @@ void ewol::widget::ColorChooser::onReceiveMessage(const ewol::object::Message& _
};
void ewol::widget::ColorChooser::onObjectRemove(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 = NULL;
m_widgetRed.reset();
}
if(_removeObject == m_widgetGreen) {
m_widgetGreen = NULL;
m_widgetGreen.reset();
}
if(_removeObject == m_widgetBlue) {
m_widgetBlue = NULL;
m_widgetBlue.reset();
}
if(_removeObject == m_widgetAlpha) {
m_widgetAlpha = NULL;
m_widgetAlpha.reset();
}
if(_removeObject == m_widgetColorBar) {
m_widgetColorBar = NULL;
m_widgetColorBar.reset();
}
}

14
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;
@ -33,16 +33,16 @@ namespace ewol {
~ColorChooser();
public: // Derived function
virtual void onReceiveMessage(const ewol::object::Message& _msg);
virtual void onObjectRemove(ewol::Object* _removeObject);
virtual void onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject);
public:
void setColor(etk::Color<> _newColor);
etk::Color<> getColor();
private:
ewol::widget::ColorBar* m_widgetColorBar;
ewol::widget::Slider* m_widgetRed;
ewol::widget::Slider* m_widgetGreen;
ewol::widget::Slider* m_widgetBlue;
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;
};
};

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

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

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

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

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

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

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

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

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

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

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

@ -36,13 +36,13 @@ namespace ewol {
/**
* @ingroup ewolWidgetGroup
*/
class ParameterList :public ewol::widget::WidgetScrolled {
class ParameterList :public ewol::Widget::WidgetScrolled {
public:
// Event list of properties
static const char * const eventSelect;
private:
int32_t m_idSelected;
std::vector<ewol::widget::elementPL *> m_list;
std::vector<ewol::Widget::elementPL *> m_list;
public:
ParameterList();
virtual ~ParameterList();

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

@ -18,65 +18,65 @@
static const char * const eventButtonExit = "ewol-event-pop-up-exit-button";
ewol::widget::StdPopUp::StdPopUp() :
ewol::Widget::StdPopUp::StdPopUp() :
m_title(NULL),
m_comment(NULL),
m_subBar(NULL) {
addObjectType("ewol::widget::StdPopUp");
addObjectType("ewol::Widget::StdPopUp");
setMinSize(ewol::Dimension(vec2(20,10),ewol::Dimension::Pourcent));
ewol::widget::Sizer* mySizerVert = NULL;
ewol::widget::Spacer* mySpacer = NULL;
ewol::Widget::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);
mySpacer = new ewol::widget::Spacer();
mySizerVert->subWidgetAdd(m_subBar->get());
mySpacer = new ewol::Widget::Spacer();
mySpacer->setExpand(bvec2(true,false));
m_subBar->subWidgetAdd(mySpacer);
mySpacer = new ewol::widget::Spacer();
mySpacer = new ewol::Widget::Spacer();
mySpacer->setExpand(bvec2(true,false));
mySpacer->setColor(etk::Color<>(0x888888FF));
mySpacer->setMinSize(ewol::Dimension(vec2(0,3),ewol::Dimension::Pixel));
mySizerVert->subWidgetAdd(mySpacer);
mySpacer = new ewol::widget::Spacer();
mySpacer = new ewol::Widget::Spacer();
mySpacer->setExpand(bvec2(true,false));
mySpacer->setMinSize(ewol::Dimension(vec2(0,5),ewol::Dimension::Pixel));
mySizerVert->subWidgetAdd(mySpacer);
m_comment = new ewol::widget::Label("No Label");
m_comment = new ewol::Widget::Label("No Label");
m_comment->setExpand(bvec2(true,true));
mySizerVert->subWidgetAdd(m_comment);
mySizerVert->subWidgetAdd(m_comment->get());
mySpacer = new ewol::widget::Spacer();
mySpacer = new ewol::Widget::Spacer();
mySpacer->setExpand(bvec2(true,false));
mySpacer->setMinSize(ewol::Dimension(vec2(0,5),ewol::Dimension::Pixel));
mySizerVert->subWidgetAdd(mySpacer);
mySpacer = new ewol::widget::Spacer();
mySpacer = new ewol::Widget::Spacer();
mySpacer->setExpand(bvec2(true,false));
mySpacer->setColor(etk::Color<>(0x888888FF));
mySpacer->setMinSize(ewol::Dimension(vec2(0,3),ewol::Dimension::Pixel));
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);
mySizerVert->subWidgetAdd(m_title->get());
}
ewol::widget::StdPopUp::~StdPopUp() {
ewol::Widget::StdPopUp::~StdPopUp() {
}
void ewol::widget::StdPopUp::setTitle(const std::string& _text) {
void ewol::Widget::StdPopUp::setTitle(const std::string& _text) {
if (m_title == NULL) {
return;
}
@ -84,7 +84,7 @@ void ewol::widget::StdPopUp::setTitle(const std::string& _text) {
markToRedraw();
}
void ewol::widget::StdPopUp::setComment(const std::string& _text) {
void ewol::Widget::StdPopUp::setComment(const std::string& _text) {
if (m_comment == NULL) {
return;
}
@ -92,28 +92,28 @@ void ewol::widget::StdPopUp::setComment(const std::string& _text) {
markToRedraw();
}
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();
return myButton;
}
void ewol::widget::StdPopUp::onObjectRemove(ewol::Object* _removeObject) {
void ewol::Widget::StdPopUp::onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject) {
// call parent:
ewol::widget::PopUp::onObjectRemove(_removeObject);
ewol::Widget::PopUp::onObjectRemove(_removeObject);
if (_removeObject == m_subBar) {
m_subBar = NULL;
markToRedraw();
@ -131,9 +131,9 @@ void ewol::widget::StdPopUp::onObjectRemove(ewol::Object* _removeObject) {
}
}
void ewol::widget::StdPopUp::onReceiveMessage(const ewol::object::Message& _msg) {
void ewol::Widget::StdPopUp::onReceiveMessage(const ewol::object::Message& _msg) {
// call parent:
ewol::widget::PopUp::onReceiveMessage(_msg);
ewol::Widget::PopUp::onReceiveMessage(_msg);
if (_msg.getMessage() == eventButtonExit) {
autoDestroy();
}

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

@ -39,7 +39,7 @@ namespace ewol {
* +---------------------------------------------+
* [/pre]
*/
class StdPopUp : public ewol::widget::PopUp {
class StdPopUp : public ewol::Widget::PopUp {
public:
/**
* @brief std-pop-up constructor.
@ -50,7 +50,7 @@ namespace ewol {
*/
~StdPopUp();
protected:
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::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,15 +66,15 @@ namespace ewol {
*/
void setComment(const std::string& _text);
protected:
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::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* _removeObject);
virtual void onObjectRemove(ewol::object::Shared<ewol::Object> _removeObject);
virtual void onReceiveMessage(const ewol::object::Message& _msg);
};
};