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

[DEV] start long rework to have a geneic std::shared_ptr instead of internal ewol::object::Shared ==> need to have only factory

Browse Source
This commit is contained in:
Edouard DUPIN 2014-08-07 22:54:13 +02:00
parent de19f0de61
commit e3305c3757
129 changed files with 1312 additions and 1897 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
build

@ -1 +1 @@
Subproject commit ec60375c9fdf6ae46db9ee5574ec8837e531e5fa
Subproject commit 9d6418eed9d24b85823aca4f3393e15a8edeb0cb

2
external/etk vendored

@ -1 +1 @@
Subproject commit 9c14cc6077de87781f161a6fbb310837c90d91ba
Subproject commit 4c55bca47373281860619295acfdc859ea766bd3

4
sources/ewol/compositing/Area.cpp
View File

@ -22,7 +22,7 @@ ewol::compositing::Area::Area(const ivec2& _size) :
m_GLtexture(-1),
m_GLtexID(-1),
m_resource(nullptr) {
m_resource = ewol::resource::Texture::keep();
m_resource = ewol::resource::Texture::create();
m_resource->setImageSize(_size);
m_resource->flush();
loadProgram();
@ -35,7 +35,7 @@ ewol::compositing::Area::~Area() {
void ewol::compositing::Area::loadProgram() {
// get the shader resource :
m_GLPosition = 0;
m_GLprogram = ewol::resource::Program::keep("DATA:textured3D.prog");
m_GLprogram = ewol::resource::Program::create(std::string("DATA:textured3D.prog"));
if (nullptr != m_GLprogram) {
m_GLPosition = m_GLprogram->getAttribute("EW_coord3d");
m_GLColor = m_GLprogram->getAttribute("EW_color");

4
sources/ewol/compositing/Area.h
View File

@ -22,14 +22,14 @@ namespace ewol {
vec3 m_position; //!< The current position to draw
etk::Color<> m_color; //!< The text foreground color
private:
ewol::object::Shared<ewol::resource::Program> m_GLprogram; //!< pointer on the opengl display program
std::shared_ptr<ewol::resource::Program> m_GLprogram; //!< pointer on the opengl display program
int32_t m_GLPosition; //!< openGL id on the element (vertex buffer)
int32_t m_GLMatrix; //!< openGL id on the element (transformation matrix)
int32_t m_GLColor; //!< openGL id on the element (color buffer)
int32_t m_GLtexture; //!< openGL id on the element (Texture position)
int32_t m_GLtexID; //!< openGL id on the element (texture ID)
private:
ewol::object::Shared<ewol::resource::Texture> m_resource; //!< texture resources
std::shared_ptr<ewol::resource::Texture> m_resource; //!< texture resources
std::vector<vec3 > m_coord; //!< internal coord of the object
std::vector<vec2 > m_coordTex; //!< internal texture coordinate for every point
std::vector<etk::Color<float> > m_coordColor; //!< internal color of the different point

2
sources/ewol/compositing/Drawing.cpp
View File

@ -284,7 +284,7 @@ void ewol::compositing::Drawing::loadProgram() {
// remove previous loading ... in case
unLoadProgram();
// oad the new ...
m_GLprogram = ewol::resource::Program::keep("DATA:color3.prog");
m_GLprogram = ewol::resource::Program::create("DATA:color3.prog");
// get the shader resource :
if (nullptr != m_GLprogram ) {
m_GLPosition = m_GLprogram->getAttribute("EW_coord3d");

2
sources/ewol/compositing/Drawing.h
View File

@ -28,7 +28,7 @@ namespace ewol {
etk::Color<> m_color; //!< The text foreground color
etk::Color<> m_colorBg; //!< The text background color
private:
ewol::object::Shared<ewol::resource::Program> m_GLprogram; //!< pointer on the opengl display program
std::shared_ptr<ewol::resource::Program> m_GLprogram; //!< pointer on the opengl display program
int32_t m_GLPosition; //!< openGL id on the element (vertex buffer)
int32_t m_GLMatrix; //!< openGL id on the element (transformation matrix)
int32_t m_GLColor; //!< openGL id on the element (color buffer)

12
sources/ewol/compositing/Image.cpp
View File

@ -43,9 +43,9 @@ void ewol::compositing::Image::loadProgram() {
m_GLPosition = 0;
m_GLprogram.reset();
if (m_distanceFieldMode == true) {
m_GLprogram = ewol::resource::Program::keep("DATA:texturedDF.prog");
m_GLprogram = ewol::resource::Program::create("DATA:texturedDF.prog");
} else {
m_GLprogram = ewol::resource::Program::keep("DATA:textured3D.prog");
m_GLprogram = ewol::resource::Program::create("DATA:textured3D.prog");
}
if (m_GLprogram != nullptr) {
m_GLPosition = m_GLprogram->getAttribute("EW_coord3d");
@ -247,8 +247,8 @@ void ewol::compositing::Image::printPart(const vec2& _size,
void ewol::compositing::Image::setSource(const std::string& _newFile, const vec2& _size) {
clear();
ewol::object::Shared<ewol::resource::TextureFile> resource(m_resource);
ewol::object::Shared<ewol::resource::ImageDF> resourceDF(m_resourceDF);
std::shared_ptr<ewol::resource::TextureFile> resource(m_resource);
std::shared_ptr<ewol::resource::ImageDF> resourceDF(m_resourceDF);
m_filename = _newFile;
m_requestSize = _size;
m_resource.reset();
@ -258,12 +258,12 @@ void ewol::compositing::Image::setSource(const std::string& _newFile, const vec2
if (_newFile != "") {
// link to new one
if (m_distanceFieldMode == false) {
m_resource = ewol::resource::TextureFile::keep(m_filename, tmpSize);
m_resource = ewol::resource::TextureFile::create(m_filename, tmpSize);
if (m_resource == nullptr) {
EWOL_ERROR("Can not get Image resource");
}
} else {
m_resourceDF = ewol::resource::ImageDF::keep(m_filename, tmpSize);
m_resourceDF = ewol::resource::ImageDF::create(m_filename, tmpSize);
if (m_resourceDF == nullptr) {
EWOL_ERROR("Can not get Image resource DF");
}

6
sources/ewol/compositing/Image.h
View File

@ -29,7 +29,7 @@ namespace ewol {
etk::Color<> m_color; //!< The text foreground color
float m_angle; //!< Angle to set at the axes
private:
ewol::object::Shared<ewol::resource::Program> m_GLprogram; //!< pointer on the opengl display program
std::shared_ptr<ewol::resource::Program> m_GLprogram; //!< pointer on the opengl display program
int32_t m_GLPosition; //!< openGL id on the element (vertex buffer)
int32_t m_GLMatrix; //!< openGL id on the element (transformation matrix)
int32_t m_GLColor; //!< openGL id on the element (color buffer)
@ -37,8 +37,8 @@ namespace ewol {
int32_t m_GLtexID; //!< openGL id on the element (texture ID)
private:
bool m_distanceFieldMode; //!< select distance field mode
ewol::object::Shared<ewol::resource::TextureFile> m_resource; //!< texture resources
ewol::object::Shared<ewol::resource::ImageDF> m_resourceDF; //!< texture resources
std::shared_ptr<ewol::resource::TextureFile> m_resource; //!< texture resources
std::shared_ptr<ewol::resource::ImageDF> m_resourceDF; //!< texture resources
std::vector<vec3 > m_coord; //!< internal coord of the object
std::vector<vec2 > m_coordTex; //!< internal texture coordinate for every point
std::vector<etk::Color<float> > m_coordColor; //!< internal color of the different point

8
sources/ewol/compositing/Shaper.cpp
View File

@ -84,7 +84,7 @@ void ewol::compositing::Shaper::loadProgram() {
EWOL_DEBUG("no Shaper set for loading resources ...");
return;
}
m_config = ewol::resource::ConfigFile::keep(m_name);
m_config = ewol::resource::ConfigFile::create(m_name);
if (nullptr != m_config) {
m_confIdMode = m_config->request("mode");
m_confIdDisplayOutside = m_config->request("display-outside");
@ -118,7 +118,7 @@ void ewol::compositing::Shaper::loadProgram() {
}
// get the shader resource :
m_GLPosition = 0;
m_GLprogram = ewol::resource::Program::keep(tmpFilename);
m_GLprogram = ewol::resource::Program::create(tmpFilename);
if (m_GLprogram != nullptr) {
m_GLPosition = m_GLprogram->getAttribute("EW_coord2d");
m_GLMatrix = m_GLprogram->getUniform("EW_MatrixTransformation");
@ -144,7 +144,7 @@ void ewol::compositing::Shaper::loadProgram() {
EWOL_DEBUG("Shaper try load shaper image : '" << tmpFilename << "'");
}
ivec2 size(64,64);
m_resourceTexture = ewol::resource::TextureFile::keep(tmpFilename, size);
m_resourceTexture = ewol::resource::TextureFile::create(tmpFilename, size);
}
}
std::string basicColorFile = m_config->getString(m_confColorFile);
@ -158,7 +158,7 @@ void ewol::compositing::Shaper::loadProgram() {
} else {
EWOL_DEBUG("Shaper try load colorFile : '" << tmpFilename << "'");
}
m_colorProperty = ewol::resource::ColorFile::keep(tmpFilename);
m_colorProperty = ewol::resource::ColorFile::create(tmpFilename);
if ( m_GLprogram != nullptr
&& m_colorProperty != nullptr) {
std::vector<std::string> listColor = m_colorProperty->getColors();

8
sources/ewol/compositing/Shaper.h
View File

@ -44,7 +44,7 @@ namespace ewol {
private:
std::string m_name; //!< Name of the configuration of the shaper.
// External theme config:
ewol::object::Shared<ewol::resource::ConfigFile> m_config; //!< pointer on the config file resources
std::shared_ptr<ewol::resource::ConfigFile> m_config; //!< pointer on the config file resources
int32_t m_confIdDisplayExternal; //!< Display external border
int32_t m_confIdPaddingOut[shaperPosCount]; //!< Padding out property : X-left X-right Y-top Y-buttom
int32_t m_confIdBorder[shaperPosCount]; //!< border property : X-left X-right Y-top Y-buttom
@ -56,7 +56,7 @@ namespace ewol {
int32_t m_confColorFile; //!< ConfigFile opengGl color file Name
int32_t m_confImageFile; //!< ConfigFile opengGl program Name
// openGL shaders programs:
ewol::object::Shared<ewol::resource::Program> m_GLprogram; //!< pointer on the opengl display program
std::shared_ptr<ewol::resource::Program> m_GLprogram; //!< pointer on the opengl display program
int32_t m_GLPosition; //!< openGL id on the element (vertex buffer)
int32_t m_GLMatrix; //!< openGL id on the element (transformation matrix)
int32_t m_GLPropertyPos; //!< openGL id on the element (simple ratio position in the widget : ____/-----\_____ on vec2(X,Y))
@ -66,7 +66,7 @@ namespace ewol {
int32_t m_GLStateTransition; //!< openGL id on the element (transition ofset [0.0..1.0] )
int32_t m_GLtexID; //!< openGL id on the element (texture image)
// For the Image :
ewol::object::Shared<ewol::resource::TextureFile> m_resourceTexture; //!< texture resources (for the image)
std::shared_ptr<ewol::resource::TextureFile> m_resourceTexture; //!< texture resources (for the image)
// internal needed data :
int32_t m_nextStatusRequested; //!< when status is changing, this represent the next step of it
vec2 m_propertyOrigin; //!< widget origin
@ -81,7 +81,7 @@ namespace ewol {
vec2 m_pos[SHAPER_NB_MAX_VERTEX]; //!< podition to display property
int32_t m_nbVertexToDisplay;
// color management theme:
ewol::object::Shared<ewol::resource::ColorFile> m_colorProperty; //!< input resource for color management
std::shared_ptr<ewol::resource::ColorFile> m_colorProperty; //!< input resource for color management
std::vector<ivec2> m_listAssiciatedId; //!< Corellation ID between ColorProperty (Y) and OpenGL Program (X)
private:
/**

4
sources/ewol/compositing/Text.cpp
View File

@ -152,7 +152,7 @@ void ewol::compositing::Text::setFontName(const std::string& _fontName) {
void ewol::compositing::Text::setFont(std::string _fontName, int32_t _fontSize) {
clear();
// remove old one
ewol::object::Shared<ewol::resource::TexturedFont> previousFont = m_font;
std::shared_ptr<ewol::resource::TexturedFont> previousFont = m_font;
if (_fontSize <= 0) {
_fontSize = ewol::getContext().getFontDefault().getSize();
}
@ -163,7 +163,7 @@ void ewol::compositing::Text::setFont(std::string _fontName, int32_t _fontSize)
_fontName += std::to_string(_fontSize);
EWOL_VERBOSE("plop : " << _fontName << " size=" << _fontSize << " result :" << _fontName);
// link to new one
m_font = ewol::resource::TexturedFont::keep(_fontName);
m_font = ewol::resource::TexturedFont::create(_fontName);
if (m_font == nullptr) {
EWOL_ERROR("Can not get font resource");
m_font = previousFont;

2
sources/ewol/compositing/Text.h
View File

@ -25,7 +25,7 @@ namespace ewol {
namespace compositing {
class Text : public ewol::compositing::TextBase {
protected:
ewol::object::Shared<ewol::resource::TexturedFont> m_font; //!< Font resources
std::shared_ptr<ewol::resource::TexturedFont> m_font; //!< Font resources
public:
/**
* @brief generic constructor

6
sources/ewol/compositing/TextBase.cpp
View File

@ -53,8 +53,8 @@ ewol::compositing::TextBase::~TextBase() {
void ewol::compositing::TextBase::loadProgram(const std::string& _shaderName) {
// get the shader resource :
m_GLPosition = 0;
ewol::object::Shared<ewol::resource::Program> old = m_GLprogram;
m_GLprogram = ewol::resource::Program::keep(_shaderName);
std::shared_ptr<ewol::resource::Program> old = m_GLprogram;
m_GLprogram = ewol::resource::Program::create(_shaderName);
if (m_GLprogram != nullptr) {
m_GLPosition = m_GLprogram->getAttribute("EW_coord3d");
m_GLColor = m_GLprogram->getAttribute("EW_color");
@ -64,7 +64,7 @@ void ewol::compositing::TextBase::loadProgram(const std::string& _shaderName) {
m_GLtextWidth = m_GLprogram->getUniform("EW_texWidth");
m_GLtextHeight = m_GLprogram->getUniform("EW_texHeight");
} else {
EWOL_ERROR("Can not load the program => keep previous one...");
EWOL_ERROR("Can not load the program => create previous one...");
m_GLprogram = old;
old = nullptr;
}

2
sources/ewol/compositing/TextBase.h
View File

@ -77,7 +77,7 @@ namespace ewol {
float m_stopTextPos; //!< end of the alignement (when a string is too hight it cut at the word previously this virtual line and the center is perform with this one)
enum aligneMode m_alignement; //!< Current Alignement mode (justify/left/right ...)
protected:
ewol::object::Shared<ewol::resource::Program> m_GLprogram; //!< pointer on the opengl display program
std::shared_ptr<ewol::resource::Program> m_GLprogram; //!< pointer on the opengl display program
int32_t m_GLPosition; //!< openGL id on the element (vertex buffer)
int32_t m_GLMatrix; //!< openGL id on the element (transformation matrix)
int32_t m_GLColor; //!< openGL id on the element (color buffer)

4
sources/ewol/compositing/TextDF.cpp
View File

@ -155,7 +155,7 @@ void ewol::compositing::TextDF::setFontSize(int32_t _fontSize) {
void ewol::compositing::TextDF::setFontName(const std::string& _fontName) {
clear();
// remove old one
ewol::object::Shared<ewol::resource::DistanceFieldFont> previousFont = m_fontDF;
std::shared_ptr<ewol::resource::DistanceFieldFont> previousFont = m_fontDF;
std::string fontName;
if (_fontName == "") {
fontName = ewol::getContext().getFontDefault().getName();
@ -164,7 +164,7 @@ void ewol::compositing::TextDF::setFontName(const std::string& _fontName) {
}
EWOL_VERBOSE("Set font name: '" << fontName << "'");
// link to new one
m_fontDF = ewol::resource::DistanceFieldFont::keep(fontName);
m_fontDF = ewol::resource::DistanceFieldFont::create(fontName);
if (m_fontDF == nullptr) {
EWOL_ERROR("Can not get find resource");
m_fontDF = previousFont;

2
sources/ewol/compositing/TextDF.h
View File

@ -23,7 +23,7 @@ namespace ewol {
namespace compositing {
class TextDF : public ewol::compositing::TextBase {
protected:
ewol::object::Shared<ewol::resource::DistanceFieldFont> m_fontDF; //!< Font resources
std::shared_ptr<ewol::resource::DistanceFieldFont> m_fontDF; //!< Font resources
std::vector<float> m_glyphLevel; //!< Level of display of the glyph (notmal : 0.50, bold : 0.40, super bold : 0.30 ...)
protected:
int32_t m_GLglyphLevel; //!< openGL Id on the glyph level display

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

@ -135,13 +135,13 @@ namespace ewol {
};
void ewol::Context::inputEventTransfertWidget(ewol::object::Shared<ewol::Widget> _source,
ewol::object::Shared<ewol::Widget> _destination) {
void ewol::Context::inputEventTransfertWidget(std::shared_ptr<ewol::Widget> _source,
std::shared_ptr<ewol::Widget> _destination) {
m_input.transfertEvent(_source, _destination);
}
void ewol::Context::inputEventGrabPointer(ewol::object::Shared<ewol::Widget> _widget) {
void ewol::Context::inputEventGrabPointer(std::shared_ptr<ewol::Widget> _widget) {
m_input.grabPointer(_widget);
}
@ -196,7 +196,7 @@ void ewol::Context::processEvents() {
data->keyboardMove,
data->stateIsDown) ) {
// get the current focused Widget :
ewol::object::Shared<ewol::Widget> tmpWidget = m_widgetManager.focusGet();
std::shared_ptr<ewol::Widget> tmpWidget = m_widgetManager.focusGet();
if (nullptr != tmpWidget) {
// check if the widget allow repeating key events.
//EWOL_DEBUG("repeating test :" << data->repeateKey << " widget=" << tmpWidget->getKeyboardRepeate() << " state=" << data->stateIsDown);
@ -239,7 +239,7 @@ void ewol::Context::processEvents() {
break;
case eSystemMessage::msgClipboardArrive:
{
ewol::object::Shared<ewol::Widget> tmpWidget = m_widgetManager.focusGet();
std::shared_ptr<ewol::Widget> tmpWidget = m_widgetManager.focusGet();
if (tmpWidget != nullptr) {
tmpWidget->onEventClipboard(data->clipboardID);
}
@ -676,7 +676,7 @@ bool ewol::Context::OS_Draw(bool _displayEveryTime) {
return hasDisplayDone;
}
void ewol::Context::onObjectRemove(const ewol::object::Shared<ewol::Object>& _object) {
void ewol::Context::onObjectRemove(const std::shared_ptr<ewol::Object>& _object) {
//EWOL_CRITICAL("element removed");
if (m_windowsCurrent == _object) {
m_windowsCurrent.reset(); // This might never arrived, the owner is the current element (expected when the widget auto remove itself)
@ -695,7 +695,7 @@ void ewol::Context::OS_OpenGlContextDestroy() {
m_resourceManager.contextHasBeenDestroyed();
}
void ewol::Context::setWindows(const ewol::object::Shared<ewol::widget::Windows>& _windows) {
void ewol::Context::setWindows(const std::shared_ptr<ewol::widget::Windows>& _windows) {
// remove current focus :
m_widgetManager.focusSetDefault(nullptr);
m_widgetManager.focusRelease();
@ -707,7 +707,7 @@ void ewol::Context::setWindows(const ewol::object::Shared<ewol::widget::Windows>
forceRedrawAll();
}
ewol::object::Shared<ewol::widget::Windows> ewol::Context::getWindows() {
std::shared_ptr<ewol::widget::Windows> ewol::Context::getWindows() {
return m_windowsCurrent;
};

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

@ -145,7 +145,7 @@ namespace ewol {
// return true if a flush is needed
bool OS_Draw(bool _displayEveryTime);
virtual void onObjectRemove(const ewol::object::Shared<ewol::Object>& _removeObject);
virtual void onObjectRemove(const std::shared_ptr<ewol::Object>& _removeObject);
public:
/**
* @brief reset event management for the IO like Input ou Mouse or keyborad
@ -164,18 +164,18 @@ namespace ewol {
*/
virtual void stop();
private:
ewol::object::Owner<ewol::widget::Windows> m_windowsCurrent; //!< curent displayed windows
std::shared_ptr<ewol::widget::Windows> m_windowsCurrent; //!< curent displayed windows
public:
/**
* @brief set the current windows to display :
* @param _windows Windows that might be displayed
*/
void setWindows(const ewol::object::Shared<ewol::widget::Windows>& _windows);
void setWindows(const std::shared_ptr<ewol::widget::Windows>& _windows);
/**
* @brief get the current windows that is displayed
* @return the current handle on the windows (can be null)
*/
ewol::object::Shared<ewol::widget::Windows> getWindows();
std::shared_ptr<ewol::widget::Windows> getWindows();
private:
vec2 m_windowsSize; //!< current size of the system
public:
@ -233,12 +233,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::object::Shared<ewol::Widget> _source, ewol::object::Shared<ewol::Widget> _destination);
void inputEventTransfertWidget(std::shared_ptr<ewol::Widget> _source, std::shared_ptr<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::object::Shared<ewol::Widget> _widget);
void inputEventGrabPointer(std::shared_ptr<ewol::Widget> _widget);
/**
* @brief This fonction un-lock the pointer properties to move in relative instead of absolute
*/

117
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::object::Shared<ewol::Widget> _destWidget,
std::shared_ptr<ewol::Widget> _destWidget,
int32_t _IdInput,
enum ewol::key::status _status,
vec2 _pos) {
@ -67,7 +67,7 @@ void ewol::context::InputManager::abortElement(InputPoperty *_eventTable,
}
if (_eventTable[_idInput].isUsed == true) {
localEventInput(_type,
_eventTable[_idInput].curentWidgetEvent,
_eventTable[_idInput].curentWidgetEvent.lock(),
_eventTable[_idInput].destinationInputId,
ewol::key::statusAbort,
_eventTable[_idInput].posEvent);
@ -93,38 +93,40 @@ void ewol::context::InputManager::cleanElement(InputPoperty *_eventTable,
_eventTable[_idInput].posEvent.setValue(0,0);
}
void ewol::context::InputManager::transfertEvent(ewol::object::Shared<ewol::Widget> _source, ewol::object::Shared<ewol::Widget> _destination) {
void ewol::context::InputManager::transfertEvent(std::shared_ptr<ewol::Widget> _source, std::shared_ptr<ewol::Widget> _destination) {
if( _source == nullptr
|| _destination == nullptr) {
// prevent errors ...
return;
}
for(int32_t iii=0; iii<MAX_MANAGE_INPUT; iii++) {
if (m_eventInputSaved[iii].curentWidgetEvent == _source) {
std::shared_ptr<ewol::Widget> tmpWidget = m_eventInputSaved[iii].curentWidgetEvent.lock();
if (tmpWidget == _source) {
// inform the widget that it does not receive the event now
EVENT_DEBUG("GUI : Input ID=" << iii << " == >" << m_eventInputSaved[iii].destinationInputId << " [EVENT_INPUT_TYPE_ABORT] " << m_eventInputSaved[iii].posEvent);
localEventInput(ewol::key::typeFinger, m_eventInputSaved[iii].curentWidgetEvent, m_eventInputSaved[iii].destinationInputId, ewol::key::statusAbort, m_eventInputSaved[iii].posEvent);
localEventInput(ewol::key::typeFinger, tmpWidget, m_eventInputSaved[iii].destinationInputId, ewol::key::statusAbort, m_eventInputSaved[iii].posEvent);
// set the new widget ...
m_eventInputSaved[iii].curentWidgetEvent = _destination;
// inform the widget that he receive the event property now...
EVENT_DEBUG("GUI : Input ID=" << iii << " == >" << m_eventInputSaved[iii].destinationInputId << " [EVENT_INPUT_TYPE_TRANSFERT] " << m_eventInputSaved[iii].posEvent);
localEventInput(ewol::key::typeFinger, m_eventInputSaved[iii].curentWidgetEvent, m_eventInputSaved[iii].destinationInputId, ewol::key::statusTransfert, m_eventInputSaved[iii].posEvent);
localEventInput(ewol::key::typeFinger, _destination, m_eventInputSaved[iii].destinationInputId, ewol::key::statusTransfert, m_eventInputSaved[iii].posEvent);
}
if (m_eventMouseSaved[iii].curentWidgetEvent == _source) {
tmpWidget = m_eventMouseSaved[iii].curentWidgetEvent.lock();
if (tmpWidget == _source) {
// inform the widget that it does not receive the event now
EVENT_DEBUG("GUI : Input ID=" << iii << " == >" << m_eventMouseSaved[iii].destinationInputId << " [EVENT_INPUT_TYPE_ABORT] " << m_eventMouseSaved[iii].posEvent);
localEventInput(ewol::key::typeMouse, m_eventMouseSaved[iii].curentWidgetEvent, m_eventMouseSaved[iii].destinationInputId, ewol::key::statusAbort, m_eventMouseSaved[iii].posEvent);
localEventInput(ewol::key::typeMouse, tmpWidget, m_eventMouseSaved[iii].destinationInputId, ewol::key::statusAbort, m_eventMouseSaved[iii].posEvent);
// set the new widget ...
m_eventMouseSaved[iii].curentWidgetEvent = _destination;
// inform the widget that he receive the event property now...
EVENT_DEBUG("GUI : Input ID=" << iii << " == >" << m_eventMouseSaved[iii].destinationInputId << " [EVENT_INPUT_TYPE_TRANSFERT] " << m_eventMouseSaved[iii].posEvent);
localEventInput(ewol::key::typeMouse, m_eventMouseSaved[iii].curentWidgetEvent, m_eventMouseSaved[iii].destinationInputId, ewol::key::statusTransfert, m_eventMouseSaved[iii].posEvent);
localEventInput(ewol::key::typeMouse, _destination, m_eventMouseSaved[iii].destinationInputId, ewol::key::statusTransfert, m_eventMouseSaved[iii].posEvent);
}
}
}
void ewol::context::InputManager::grabPointer(ewol::object::Shared<ewol::Widget> _widget) {
if(nullptr == _widget) {
void ewol::context::InputManager::grabPointer(std::shared_ptr<ewol::Widget> _widget) {
if(_widget == nullptr) {
return;
}
m_grabWidget = _widget;
@ -134,26 +136,29 @@ void ewol::context::InputManager::grabPointer(ewol::object::Shared<ewol::Widget>
}
void ewol::context::InputManager::unGrabPointer() {
m_grabWidget = nullptr;
m_grabWidget.reset();
m_context.grabPointerEvents(false, vec2(0,0));
}
void ewol::context::InputManager::onObjectRemove(const ewol::object::Shared<ewol::Object>& _object) {
void ewol::context::InputManager::onObjectRemove(const std::shared_ptr<ewol::Object>& _object) {
for(int32_t iii=0; iii<MAX_MANAGE_INPUT; iii++) {
if (m_eventInputSaved[iii].curentWidgetEvent == _object) {
std::shared_ptr<ewol::Widget> tmpWidget = m_eventInputSaved[iii].curentWidgetEvent.lock();
if (tmpWidget == _object) {
// remove the property of this input ...
EWOL_VERBOSE("Remove object ==> rm Input Event !!!");
cleanElement(m_eventInputSaved, iii);
}
if (m_eventMouseSaved[iii].curentWidgetEvent == _object) {
tmpWidget = m_eventMouseSaved[iii].curentWidgetEvent.lock();
if (tmpWidget == _object) {
// remove the property of this input ...
EWOL_VERBOSE("Remove object ==> rm Mouse Event !!!");
cleanElement(m_eventMouseSaved, iii);
}
}
if (m_grabWidget == _object) {
std::shared_ptr<ewol::Widget> tmpWidgetGrab = m_grabWidget.lock();
if (tmpWidgetGrab == _object) {
EWOL_VERBOSE("Remove object ==> rm Grab widget !!!");
m_grabWidget.reset();
tmpWidgetGrab.reset();
}
}
@ -168,7 +173,7 @@ void ewol::context::InputManager::newLayerSet() {
}
ewol::context::InputManager::InputManager(ewol::Context& _context) :
m_grabWidget(nullptr),
m_grabWidget(),
m_context(_context) {
setDpi(200);
EWOL_INFO("Init (start)");
@ -186,13 +191,14 @@ ewol::context::InputManager::~InputManager() {
}
int32_t ewol::context::InputManager::localGetDestinationId(enum ewol::key::type _type,
ewol::object::Shared<ewol::Widget> _destWidget,
std::shared_ptr<ewol::Widget> _destWidget,
int32_t _realInputId) {
if (_type == ewol::key::typeFinger) {
int32_t lastMinimum = 0;
for(int32_t iii=0; iii<MAX_MANAGE_INPUT; iii++) {
if (true == m_eventInputSaved[iii].isUsed) {
if (m_eventInputSaved[iii].curentWidgetEvent == _destWidget) {
std::shared_ptr<ewol::Widget> tmpWidget = m_eventInputSaved[iii].curentWidgetEvent.lock();
if (tmpWidget == _destWidget) {
if (iii != _realInputId) {
lastMinimum = std::max(lastMinimum, m_eventInputSaved[iii].destinationInputId);
}
@ -227,21 +233,21 @@ void ewol::context::InputManager::motion(enum ewol::key::type _type,
// not manage input
return;
}
ewol::object::Shared<ewol::widget::Windows> tmpWindows = m_context.getWindows();
std::shared_ptr<ewol::widget::Windows> tmpWindows = m_context.getWindows();
// special case for the mouse event 0 that represent the hover event of the system :
if (_type == ewol::key::typeMouse && _pointerID == 0) {
// this event is all time on the good widget ... and manage the enter and leave ...
// NOTE : the "layer widget" force us to get the widget at the specific position all the time :
ewol::object::Shared<ewol::Widget> tmpWidget = nullptr;
if (m_grabWidget != nullptr) {
std::shared_ptr<ewol::Widget> tmpWidget;
if (m_grabWidget.lock() != nullptr) {
// grab all events ...
tmpWidget = m_grabWidget;
tmpWidget = m_grabWidget.lock();
} else {
if (nullptr != tmpWindows) {
tmpWidget = tmpWindows->getWidgetAtPos(_pos);
}
}
if( tmpWidget != eventTable[_pointerID].curentWidgetEvent
if( tmpWidget != eventTable[_pointerID].curentWidgetEvent.lock()
|| ( true == eventTable[_pointerID].isInside
&& ( eventTable[_pointerID].origin.x() > _pos.x()
|| eventTable[_pointerID].origin.y() > _pos.y()
@ -251,22 +257,21 @@ void ewol::context::InputManager::motion(enum ewol::key::type _type,
EVENT_DEBUG("GUI : Input ID=" << _pointerID << " == >" << eventTable[_pointerID].destinationInputId << " [LEAVE] " << _pos);
eventTable[_pointerID].posEvent = _pos;
localEventInput(_type,
eventTable[_pointerID].curentWidgetEvent,
eventTable[_pointerID].curentWidgetEvent.lock(),
eventTable[_pointerID].destinationInputId,
ewol::key::statusLeave,
_pos);
}
if (false == eventTable[_pointerID].isInside) {
if (eventTable[_pointerID].isInside == false) {
// set the element inside ...
eventTable[_pointerID].isInside = true;
// get destination widget :
eventTable[_pointerID].curentWidgetEvent = tmpWidget;
if (nullptr == eventTable[_pointerID].curentWidgetEvent) {
if (tmpWidget == nullptr) {
eventTable[_pointerID].isInside = false;
}
if (nullptr != eventTable[_pointerID].curentWidgetEvent) {
eventTable[_pointerID].origin = eventTable[_pointerID].curentWidgetEvent->getOrigin();
eventTable[_pointerID].size = eventTable[_pointerID].curentWidgetEvent->getSize();
} else {
eventTable[_pointerID].origin = tmpWidget->getOrigin();
eventTable[_pointerID].size = tmpWidget->getSize();
}
eventTable[_pointerID].destinationInputId = 0;
EVENT_DEBUG("GUI : Input ID=" << _pointerID
@ -274,7 +279,7 @@ void ewol::context::InputManager::motion(enum ewol::key::type _type,
<< " [ENTER] " << _pos);
eventTable[_pointerID].posEvent = _pos;
localEventInput(_type,
eventTable[_pointerID].curentWidgetEvent,
tmpWidget,
eventTable[_pointerID].destinationInputId,
ewol::key::statusEnter,
_pos);
@ -284,7 +289,7 @@ void ewol::context::InputManager::motion(enum ewol::key::type _type,
<< " [MOVE] " << _pos);
eventTable[_pointerID].posEvent = _pos;
localEventInput(_type,
eventTable[_pointerID].curentWidgetEvent,
tmpWidget,
eventTable[_pointerID].destinationInputId,
ewol::key::statusMove,
_pos);
@ -300,7 +305,7 @@ void ewol::context::InputManager::motion(enum ewol::key::type _type,
<< " [LEAVE] " << _pos);
eventTable[_pointerID].posEvent = _pos;
localEventInput(_type,
eventTable[_pointerID].curentWidgetEvent,
eventTable[_pointerID].curentWidgetEvent.lock(),
eventTable[_pointerID].destinationInputId,
ewol::key::statusLeave,
_pos);
@ -316,7 +321,7 @@ void ewol::context::InputManager::motion(enum ewol::key::type _type,
<< " [ENTER] " << _pos);
eventTable[_pointerID].posEvent = _pos;
localEventInput(_type,
eventTable[_pointerID].curentWidgetEvent,
eventTable[_pointerID].curentWidgetEvent.lock(),
eventTable[_pointerID].destinationInputId,
ewol::key::statusEnter,
_pos);
@ -327,7 +332,7 @@ void ewol::context::InputManager::motion(enum ewol::key::type _type,
<< " [MOVE] " << _pos);
eventTable[_pointerID].posEvent = _pos;
localEventInput(_type,
eventTable[_pointerID].curentWidgetEvent,
eventTable[_pointerID].curentWidgetEvent.lock(),
eventTable[_pointerID].destinationInputId,
ewol::key::statusMove,
_pos);
@ -364,7 +369,7 @@ void ewol::context::InputManager::state(enum ewol::key::type _type,
}
// get the curent time ...
int64_t currentTime = ewol::getTime();
ewol::object::Shared<ewol::widget::Windows> tmpWindows = m_context.getWindows();
std::shared_ptr<ewol::widget::Windows> tmpWindows = m_context.getWindows();
if (true == _isDown) {
EVENT_DEBUG("GUI : Input ID=" << _pointerID
@ -388,7 +393,7 @@ void ewol::context::InputManager::state(enum ewol::key::type _type,
<< " [DOWN] " << _pos);
eventTable[_pointerID].posEvent = _pos;
localEventInput(_type,
eventTable[_pointerID].curentWidgetEvent,
eventTable[_pointerID].curentWidgetEvent.lock(),
eventTable[_pointerID].destinationInputId,
ewol::key::statusDown,
_pos);
@ -401,20 +406,23 @@ void ewol::context::InputManager::state(enum ewol::key::type _type,
eventTable[_pointerID].lastTimeEvent = currentTime;
// set the element inside ...
eventTable[_pointerID].isInside = true;
std::shared_ptr<ewol::Widget> tmpWidget = m_grabWidget.lock();
// get destination widget :
if(nullptr != tmpWindows) {
if (m_grabWidget != nullptr && _type == ewol::key::typeMouse) {
eventTable[_pointerID].curentWidgetEvent = m_grabWidget;
if ( tmpWidget != nullptr
&& _type == ewol::key::typeMouse) {
eventTable[_pointerID].curentWidgetEvent = tmpWidget;
} else {
eventTable[_pointerID].curentWidgetEvent = tmpWindows->getWidgetAtPos(_pos);
}
} else {
eventTable[_pointerID].curentWidgetEvent = nullptr;
eventTable[_pointerID].curentWidgetEvent.reset();
}
if (nullptr != eventTable[_pointerID].curentWidgetEvent) {
eventTable[_pointerID].origin = eventTable[_pointerID].curentWidgetEvent->getOrigin();
eventTable[_pointerID].size = eventTable[_pointerID].curentWidgetEvent->getSize();
eventTable[_pointerID].destinationInputId = localGetDestinationId(_type, eventTable[_pointerID].curentWidgetEvent, _pointerID);
tmpWidget = eventTable[_pointerID].curentWidgetEvent.lock();
if (tmpWidget != nullptr) {
eventTable[_pointerID].origin = tmpWidget->getOrigin();
eventTable[_pointerID].size = tmpWidget->getSize();
eventTable[_pointerID].destinationInputId = localGetDestinationId(_type, tmpWidget, _pointerID);
} else {
eventTable[_pointerID].destinationInputId = -1;
}
@ -424,7 +432,7 @@ void ewol::context::InputManager::state(enum ewol::key::type _type,
<< " [DOWN] " << _pos);
eventTable[_pointerID].posEvent = _pos;
localEventInput(_type,
eventTable[_pointerID].curentWidgetEvent,
tmpWidget,
eventTable[_pointerID].destinationInputId,
ewol::key::statusDown,
_pos);
@ -439,8 +447,9 @@ void ewol::context::InputManager::state(enum ewol::key::type _type,
// Mark it un-used :
eventTable[_pointerID].isUsed = false;
// revove the widget ...
eventTable[_pointerID].curentWidgetEvent = nullptr;
eventTable[_pointerID].curentWidgetEvent.reset();
} else {
std::shared_ptr<ewol::Widget> tmpWidget = eventTable[_pointerID].curentWidgetEvent.lock();
// generate UP Event
EVENT_DEBUG("GUI : Input ID=" << _pointerID
<< " == >" << eventTable[_pointerID].destinationInputId
@ -448,7 +457,7 @@ void ewol::context::InputManager::state(enum ewol::key::type _type,
eventTable[_pointerID].posEvent = _pos;
// send up event after the single event to prevent multiple widget getting elements
localEventInput(_type,
eventTable[_pointerID].curentWidgetEvent,
tmpWidget,
_pointerID,
ewol::key::statusUp,
_pos);
@ -460,14 +469,14 @@ void ewol::context::InputManager::state(enum ewol::key::type _type,
// save start time
eventTable[_pointerID].lastTimeEvent = currentTime;
int32_t nbClickMax = 0;
if(eventTable[_pointerID].curentWidgetEvent != nullptr) {
nbClickMax = eventTable[_pointerID].curentWidgetEvent->getMouseLimit();
if(tmpWidget != nullptr) {
nbClickMax = tmpWidget->getMouseLimit();
if (nbClickMax>5) {
nbClickMax = 5;
}
}
// in grab mode the single to quinte event are not generated ....
if( ( m_grabWidget == nullptr
if( ( m_grabWidget.lock() == nullptr
|| _type != ewol::key::typeMouse )
&& eventTable[_pointerID].nbClickEvent < nbClickMax) {
// generate event SINGLE :
@ -477,7 +486,7 @@ void ewol::context::InputManager::state(enum ewol::key::type _type,
<< " [" << eventTable[_pointerID].nbClickEvent << "] " << _pos);
eventTable[_pointerID].posEvent = _pos;
localEventInput(_type,
eventTable[_pointerID].curentWidgetEvent,
tmpWidget,
eventTable[_pointerID].destinationInputId,
(enum ewol::key::status)(ewol::key::statusSingle + eventTable[_pointerID].nbClickEvent-1),
_pos);
@ -490,7 +499,7 @@ void ewol::context::InputManager::state(enum ewol::key::type _type,
}
// send up event after the single event to prevent multiple widget getting elements
localEventInput(_type,
eventTable[_pointerID].curentWidgetEvent,
tmpWidget,
_pointerID,
ewol::key::statusUpAfter,
_pos);

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

@ -22,17 +22,17 @@ namespace ewol {
*/
class InputPoperty {
public:
bool isUsed;
int32_t destinationInputId;
int64_t lastTimeEvent;
ewol::object::Shared<ewol::Widget> curentWidgetEvent;
vec2 origin;
vec2 size;
vec2 downStart;
vec2 posEvent;
bool isDown;
bool isInside;
int32_t nbClickEvent; // 0 .. 1 .. 2 .. 3
bool isUsed;
int32_t destinationInputId;
int64_t lastTimeEvent;
std::weak_ptr<ewol::Widget> curentWidgetEvent;
vec2 origin;
vec2 size;
vec2 downStart;
vec2 posEvent;
bool isDown;
bool isInside;
int32_t nbClickEvent; // 0 .. 1 .. 2 .. 3
};
/**
@ -48,7 +48,7 @@ namespace ewol {
class InputManager{
// special grab pointer mode :
private:
ewol::object::Shared<ewol::Widget> m_grabWidget; //!< widget that grab the curent pointer.
std::weak_ptr<ewol::Widget> m_grabWidget; //!< widget that grab the curent pointer.
private:
int32_t m_dpi;
InputLimit m_eventInputLimit;
@ -68,7 +68,7 @@ namespace ewol {
* @return true if event has been greped
*/
bool localEventInput(enum ewol::key::type _type,
ewol::object::Shared<ewol::Widget> _destWidget,
std::shared_ptr<ewol::Widget> _destWidget,
int32_t _IdInput,
enum ewol::key::status _typeEvent,
vec2 _pos);
@ -82,7 +82,7 @@ namespace ewol {
* @return the ewol input id
*/
int32_t localGetDestinationId(enum ewol::key::type _type,
ewol::object::Shared<ewol::Widget> _destWidget,
std::shared_ptr<ewol::Widget> _destWidget,
int32_t _realInputId);
private:
ewol::Context& m_context;
@ -95,7 +95,7 @@ namespace ewol {
void motion(enum ewol::key::type _type, int _pointerID, vec2 _pos );
void state(enum ewol::key::type _type, int _pointerID, bool _isDown, vec2 _pos);
void onObjectRemove(const ewol::object::Shared<ewol::Object>& _object);
void onObjectRemove(const std::shared_ptr<ewol::Object>& _object);
public:
/**
* @brief a new layer on the windows is set == > might remove all the property of the current element ...
@ -106,12 +106,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::object::Shared<ewol::Widget> _source, ewol::object::Shared<ewol::Widget> _destination);
void transfertEvent(std::shared_ptr<ewol::Widget> _source, std::shared_ptr<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::object::Shared<ewol::Widget> _widget);
void grabPointer(std::shared_ptr<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::object::Shared<ewol::Widget> _dest,
std::shared_ptr<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::object::Shared<ewol::Widget> m_dest;
std::shared_ptr<ewol::Widget> m_dest;
int32_t m_realIdEvent;
public:
void setDestWidget(ewol::object::Shared<ewol::Widget> _dest) {
void setDestWidget(std::shared_ptr<ewol::Widget> _dest) {
m_dest = _dest;
};
inline ewol::object::Shared<ewol::Widget> getDestWidget() const {
inline std::shared_ptr<ewol::Widget> getDestWidget() const {
return m_dest;
};
void setRealId(int32_t _realIdEvent) {

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

@ -22,10 +22,6 @@ ewol::object::Manager::Manager(ewol::Context& _context) :
ewol::object::Manager::~Manager() {
bool hasError = false;
if (m_eObjectListActive.size()!=0) {
EWOL_ERROR("Must not have anymore eObject to auto-remove !!!");
hasError = true;
}
if (m_eObjectList.size()!=0) {
EWOL_ERROR("Must not have anymore eObject !!!");
hasError = true;
@ -39,47 +35,48 @@ ewol::object::Manager::~Manager() {
void ewol::object::Manager::displayListObject() {
EWOL_INFO("List loaded object : ");
for (auto &it : m_eObjectList) {
EWOL_INFO(" Ref=" << it->getRefCount() << " remove=" << it->isDestroyed() << " name='" << it->getName() << "' type=" << it->getObjectType());
std::shared_ptr<ewol::Object> element = it.lock();
if (element != nullptr) {
EWOL_INFO(" name='" << element->getName() << "' type=" << element->getObjectType());
}
}
}
void ewol::object::Manager::unInit() {
EWOL_DEBUG(" == > Un-Init Object-Manager");
for (auto &it : m_eObjectList) {
if (it != nullptr) {
std::shared_ptr<ewol::Object> element = it.lock();
if (element != nullptr) {
//it->removeObject();
}
}
removeAllRemovedObject();
EWOL_INFO(" remove missing user object");
if (m_eObjectListActive.size() != 0) {
EWOL_ERROR("Have " << m_eObjectListActive.size() << " active Object");
if (m_eObjectList.size() != 0) {
EWOL_ERROR("Have " << m_eObjectList.size() << " active Object");
}
m_multiCast.clear();
m_eObjectListActive.clear();
m_eObjectList.clear();
removeAllRemovedObject();
}
void ewol::object::Manager::add(const ewol::object::Shared<ewol::Object>& _object) {
void ewol::object::Manager::add(const std::shared_ptr<ewol::Object>& _object) {
if (_object == nullptr) {
EWOL_ERROR("try to add an inexistant Object in manager");
}
m_eObjectList.push_back(_object);
m_eObjectListActive.push_back(_object);
}
int32_t ewol::object::Manager::getNumberObject() {
return m_eObjectList.size();
}
void ewol::object::Manager::informOneObjectIsRemoved(const ewol::object::Shared<ewol::Object>& _object) {
void ewol::object::Manager::informOneObjectIsRemoved(const std::shared_ptr<ewol::Object>& _object) {
EWOL_TODO("ewol::object::Manager::informOneObjectIsRemoved()");
/*
for (auto &it : m_eObjectList) {
if ( it != nullptr
&& it != _object) {
EWOL_VERBOSE("[" << _object->getId() << "] onObjectRemove() : " << it->getId() << " type=" << it->getObjectType() << " name='" << it->getName() << "'");
it->onObjectRemove(_object);
std::shared_ptr<ewol::Object> element = it.lock();
if ( element != nullptr
&& element != _object) {
EWOL_VERBOSE("[" << _object->getId() << "] onObjectRemove() : " << element->getId() << " type=" << element->getObjectType() << " name='" << element->getName() << "'");
element->onObjectRemove(_object);
}
}
// inform context that n object is removed ...
@ -88,25 +85,17 @@ void ewol::object::Manager::informOneObjectIsRemoved(const ewol::object::Shared<
EWOL_VERBOSE("m_removeEventList.size() = " << m_removeEventList.size());
for (auto &it : m_removeEventList) {
EWOL_VERBOSE("[" << _object->getId() << "] Inform Event Remove Object List : ...");
it->onObjectRemove(_object);
}
}
void ewol::object::Manager::respown(const ewol::object::Shared<ewol::Object>& _object){
if (_object == nullptr) {
EWOL_ERROR("Try to respown nullptr Object");
return;
}
for (auto it : m_eObjectListActive) {
if (it == _object) {
EWOL_ERROR("try to respawn an existing active Object : [" << _object->getId() << "] type='" << _object->getObjectType() << "'");
return;
std::shared_ptr<ewol::Object> element = it.lock();
if (element != nullptr) {
element->onObjectRemove(_object);
}
}
m_eObjectListActive.push_back(_object);
*/
}
void ewol::object::Manager::remove(const ewol::object::Shared<ewol::Object>& _object) {
void ewol::object::Manager::remove(const std::shared_ptr<ewol::Object>& _object) {
EWOL_TODO("ewol::object::Manager::remove()");
/*
if (_object == nullptr) {
EWOL_ERROR("Try to Auto-Remove (nullptr) Object");
return;
@ -133,32 +122,36 @@ void ewol::object::Manager::remove(const ewol::object::Shared<ewol::Object>& _ob
|| count<0) {
EWOL_ERROR("Remove more than one object in the system list ==> this is a real problem ...");
}
*/
}
// clean all Object that request an autoRemove ...
void ewol::object::Manager::removeAllRemovedObject() {
EWOL_VERBOSE("Clean Object List (if needed) : " << m_eObjectListActive.size() << "/" << m_eObjectList.size() << " elemeents");
size_t nbObject = m_eObjectList.size();
EWOL_VERBOSE("Clean Object List (if needed) : " << m_eObjectList.size() << " elements");
auto it(m_eObjectList.begin());
while (it != m_eObjectList.end()) {
if ( *it != nullptr
&& (*it)->getRefCount() <= 1) {
EWOL_DEBUG("remove definitly : [" << (*it)->getId() << "] type='" << (*it)->getObjectType() << "'");
if (it->expired() == true) {
m_eObjectList.erase(it);
it = m_eObjectList.begin();
} else {
++it;
}
}
if (m_eObjectList.size() != nbObject) {
EWOL_VERBOSE(" remove " << nbObject - m_eObjectList.size() << " deprecated objects");
}
}
ewol::object::Shared<ewol::Object> ewol::object::Manager::get(const std::string& _name) {
std::shared_ptr<ewol::Object> ewol::object::Manager::get(const std::string& _name) {
if (_name == "") {
return nullptr;
}
for (auto &it : m_eObjectList) {
if ( it != nullptr
&& it->getName() == _name) {
return it;
std::shared_ptr<ewol::Object> element = it.lock();
if ( element != nullptr
&& element->getName() == _name) {
return element;
}
}
return nullptr;
@ -178,13 +171,7 @@ void ewol::object::Manager::rm(ewol::object::RemoveEvent* _class) {
}
}
ewol::object::Shared<ewol::Object> ewol::object::Manager::getObjectNamed(const std::string& _name) {
for (auto &it : m_eObjectList) {
if ( it != nullptr
&& _name == it->getName()) {
return it;
}
}
return nullptr;
std::shared_ptr<ewol::Object> ewol::object::Manager::getObjectNamed(const std::string& _name) {
return ewol::object::Manager::get(_name);
}

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

@ -20,8 +20,7 @@ namespace ewol {
class Manager {
private:
std::vector<ewol::object::RemoveEvent*> m_removeEventList;
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_eObjectListActive; // all active widget
std::vector<std::weak_ptr<ewol::Object>> m_eObjectList; // all widget allocated == > all time increment ... never removed ...
Context& m_context;
public:
Manager(Context& _context);
@ -43,23 +42,18 @@ namespace ewol {
* @note The manager remove the object when the refecence Low down 1 (last keeper)
* @param[in] _object Reference shared pointer on the object
*/
void add(const ewol::object::Shared<ewol::Object>& _object);
void add(const std::shared_ptr<ewol::Object>& _object);
/**
* @brief Called when an object request to be removed
* @param[in] _object Reference shared pointer on the object
*/
void remove(const ewol::object::Shared<ewol::Object>& _object);
/**
* @brief Called when a user want to reuse an object that have been removed previously
* @param[in] _object Reference shared pointer on the object
*/
void respown(const ewol::object::Shared<ewol::Object>& _object);
void remove(const std::shared_ptr<ewol::Object>& _object);
public:
void removeAllRemovedObject();
ewol::object::Shared<ewol::Object> get(const std::string& _name);
std::shared_ptr<ewol::Object> get(const std::string& _name);
private:
void informOneObjectIsRemoved(const ewol::object::Shared<ewol::Object>& _object);
void informOneObjectIsRemoved(const std::shared_ptr<ewol::Object>& _object);
private:
ewol::object::MultiCast m_multiCast; //!< muticast manager
public:
@ -76,7 +70,7 @@ namespace ewol {
* @param[in] _name Name of the object
* @return the requested object or nullptr
*/
ewol::object::Shared<ewol::Object> getObjectNamed(const std::string& _name);
std::shared_ptr<ewol::Object> getObjectNamed(const std::string& _name);
};
};
};

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

@ -15,11 +15,11 @@ namespace ewol {
namespace object {
class Message {
private:
ewol::object::Shared<ewol::Object> m_callerObject; //!< Caller class.
std::shared_ptr<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(const ewol::object::Shared<ewol::Object>& _caller,
Message(const std::shared_ptr<ewol::Object>& _caller,
const char* _message,
const std::string& _data) :
m_callerObject(_caller),
@ -27,10 +27,10 @@ namespace ewol {
m_data(_data) {
};
void setCaller(const ewol::object::Shared<ewol::Object>& _caller) {
void setCaller(const std::shared_ptr<ewol::Object>& _caller) {
m_callerObject = _caller;
};
inline ewol::object::Shared<ewol::Object> getCaller() const {
inline std::shared_ptr<ewol::Object> getCaller() const {
return m_callerObject;
};
void setMessage(const char* _message) {

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

@ -28,10 +28,11 @@ void ewol::object::MultiCast::clear() {
m_messageList.clear();
}
void ewol::object::MultiCast::onObjectRemove(const ewol::object::Shared<ewol::Object>& _object) {
void ewol::object::MultiCast::onObjectRemove(const std::shared_ptr<ewol::Object>& _object) {
auto it(m_messageList.begin());
while (it != m_messageList.end()) {
if (it->m_object == _object) {
std::shared_ptr<ewol::Object> obj = it->m_object.lock();
if (obj == _object) {
m_messageList.erase(it);
it = m_messageList.begin();
} else {
@ -40,12 +41,12 @@ void ewol::object::MultiCast::onObjectRemove(const ewol::object::Shared<ewol::Ob
}
}
void ewol::object::MultiCast::add(const ewol::object::Shared<ewol::Object>& _object, const char* const _message) {
if (nullptr == _object) {
void ewol::object::MultiCast::add(const std::shared_ptr<ewol::Object>& _object, const char* const _message) {
if (_object == nullptr) {
EWOL_ERROR("Add with nullptr object");
return;
}
if (nullptr == _message) {
if (_message == nullptr) {
EWOL_ERROR("Add with nullptr Message");
return;
}
@ -54,15 +55,16 @@ void ewol::object::MultiCast::add(const ewol::object::Shared<ewol::Object>& _obj
}
void ewol::object::MultiCast::rm(const ewol::object::Shared<ewol::Object>& _object) {
if (nullptr == _object) {
void ewol::object::MultiCast::rm(const std::shared_ptr<ewol::Object>& _object) {
if (_object == nullptr) {
EWOL_ERROR("Rm with nullptr object");
return;
}
// send the message at all registered widget ...
auto it(m_messageList.begin());
while (it != m_messageList.end()) {
if(it->m_object == _object) {
std::shared_ptr<ewol::Object> obj = it->m_object.lock();
if(obj == _object) {
EWOL_DEBUG("SendMulticast RM listener :" << _object->getId());
m_messageList.erase(it);
it = m_messageList.begin();
@ -72,18 +74,19 @@ void ewol::object::MultiCast::rm(const ewol::object::Shared<ewol::Object>& _obje
}
}
void ewol::object::MultiCast::send(const ewol::object::Shared<ewol::Object>& _object, const char* const _message, const std::string& _data) {
void ewol::object::MultiCast::send(const std::shared_ptr<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 ...
for (auto &it : m_messageList) {
std::shared_ptr<ewol::Object> obj = it.m_object.lock();
if( it.m_message == _message
&& it.m_object != _object) {
if (it.m_object != nullptr) {
EWOL_VERBOSE(" id = " << it.m_object->getId() << " type=" << it.m_object->getObjectType());
&& obj != _object) {
if (obj != nullptr) {
EWOL_VERBOSE(" id = " << obj->getId() << " type=" << obj->getObjectType());
// generate event ... (create message before ...
ewol::object::Message tmpMsg(_object, it.m_message, _data);
it.m_object->onReceiveMessage(tmpMsg);
obj->onReceiveMessage(tmpMsg);
}
}
}

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

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

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

@ -19,134 +19,64 @@
const char* const ewol::Object::configName = "name";
size_t ewol::Object::m_valUID = 0;
void ewol::Object::objRefCountIncrement() {
std::unique_lock<std::mutex> lock(m_lockRefCount);
/*
if (std::string("ewol::widget::Windows") == getObjectType()) {
EWOL_ERROR("increment Windows count ++" << m_objRefCount);
//etk::log::displayBacktrace();
}
*/
m_objRefCount++;
}
void ewol::Object::objRefCountDecrement() {
std::unique_lock<std::mutex> lock(m_lockRefCount);
/*
if (std::string("ewol::widget::Windows") == getObjectType()) {
EWOL_ERROR("Decrement Windows count --" << m_objRefCount);
//etk::log::displayBacktrace();
}
*/
m_objRefCount--;
}
void ewol::Object::operator delete(void* _ptr, std::size_t _sz) {
EWOL_VERBOSE("custom delete for size " << _sz);
ewol::Object* obj = (ewol::Object*)_ptr;
obj->objRefCountDecrement();
if (obj->m_objRefCount <= 0) {
EWOL_VERBOSE(" ==> real remove");
::operator delete(_ptr);
} else {
EWOL_ERROR(" ==> Some user is link on it : " << obj->m_objRefCount);
etk::log::displayBacktrace();
}
}
void ewol::Object::operator delete[](void* _ptr, std::size_t _sz) {
EWOL_CRITICAL("custom delete for size ==> not implemented ..." << _sz);
::operator delete(_ptr);
}
#ifdef DEBUG
void ewol::Object::incOwnerCount() {
std::unique_lock<std::mutex> lock(m_lockRefCount);
m_ownerCount++;
if (m_ownerCount>1) {
EWOL_CRITICAL("Multiple Owner on one Object ==> very bad ... " << m_ownerCount);
}
}
void ewol::Object::decOwnerCount() {
std::unique_lock<std::mutex> lock(m_lockRefCount);
m_ownerCount--;
if (m_ownerCount<0) {
EWOL_CRITICAL("Owner remove the owner counter under 1 ==> very bad ... " << m_ownerCount);
}
}
#endif
void ewol::Object::autoDestroy() {
EWOL_VERBOSE("Destroy object : [" << getId() << "] type:" << getObjectType());
bool needRemove = false;
{
std::unique_lock<std::mutex> lock(m_lockRefCount);
if (m_isDestroyed == true) {
EWOL_WARNING("Request remove of a removed object");
return;
} else {
m_isDestroyed = true;
needRemove = true;
}
}
if (needRemove == true) {
getObjectManager().remove(this);
}
}
void ewol::Object::removeObject() {
autoDestroy();
}
void ewol::Object::respownObject() {
std::unique_lock<std::mutex> lock(m_lockRefCount);
if (m_isDestroyed == false) {
EWOL_WARNING("Respawn an alive object");
if (m_objectHasBeenInit == false) {
EWOL_WARNING("try to auto destroy inside a constructor");
return;
}
m_isDestroyed = false;
getObjectManager().respown(this);
EWOL_VERBOSE("Destroy object : [" << getId() << "] type:" << getObjectType());
std::shared_ptr<ewol::Object> parent = m_parent.lock();
// TODO : set a signal to do this ...
if (parent != nullptr) {
parent->requestDestroyFromChild(shared_from_this());
}
//if no parent ==> noting to do ...
}
ewol::Object::Object() :
m_objRefCount(1),
#ifdef DEBUG
m_ownerCount(0),
#endif
m_isDestroyed(false),
m_static(false),
m_isResource(false) {
// note this is nearly atomic ... (but it is enough)
m_uniqueId = m_valUID++;
EWOL_DEBUG("new Object : [" << m_uniqueId << "]");
getObjectManager().add(this);
registerConfig(configName, "string", nullptr, "Object name, might be a unique reference in all the program");
void ewol::Object::requestDestroyFromChild(const std::shared_ptr<ewol::Object>& _child) {
EWOL_WARNING("Call From Child with no effects ==> must implement : requestDestroyFromChild(...)");
}
ewol::Object::Object(const std::string& _name) :
m_objRefCount(1),
#ifdef DEBUG
m_ownerCount(0),
#endif
m_isDestroyed(false),
void ewol::Object::setParent(const std::shared_ptr<ewol::Object>& _newParent) {
// TODO : Implement change of parent ...
m_parent = _newParent;
}
void ewol::Object::removeParent() {
m_parent.reset();
}
ewol::Object::Object() :
m_objectHasBeenInit(false),
m_static(false),
m_name(_name),
m_isResource(false) {
// note this is nearly atomic ... (but it is enough)
m_uniqueId = m_valUID++;
EWOL_DEBUG("new Object : [" << m_uniqueId << "]");
getObjectManager().add(this);
registerConfig(configName, "string", nullptr, "Object name, might be a unique reference in all the program");
}
ewol::Object::~Object() {
EWOL_DEBUG("delete Object : [" << m_uniqueId << "] : " << getTypeDescription() << " refcount=" << m_objRefCount);
getMultiCast().rm(this);
EWOL_DEBUG("delete Object : [" << m_uniqueId << "] : " << getTypeDescription());
//getObjectManager().remove(shared_from_this());
// TODO : getMultiCast().rm();
m_externEvent.clear();
m_availlableEventId.clear();
m_uniqueId = -1;
}
void ewol::Object::init() {
getObjectManager().add(shared_from_this());
m_objectHasBeenInit = true;
}
void ewol::Object::init(const std::string& _name) {
init();
m_name = _name;
}
const char * const ewol::Object::getObjectType() {
if (m_listType.size() == 0) {
return "ewol::Object";
@ -195,6 +125,10 @@ void ewol::Object::addEventId(const char * _generateEventId) {
}
void ewol::Object::generateEventId(const char * _generateEventId, const std::string& _data) {
if (m_objectHasBeenInit == false) {
EWOL_WARNING("try to generate an event inside a constructor");
return;
}
int32_t nbObject = getObjectManager().getNumberObject();
EWOL_VERBOSE("try send message '" << _generateEventId << "'");
// for every element registered ...
@ -204,19 +138,20 @@ void ewol::Object::generateEventId(const char * _generateEventId, const std::str
EWOL_VERBOSE(" wrong event '" << it.localEventId << "' != '" << _generateEventId << "'");
continue;
}
if (it.destObject == nullptr) {
std::shared_ptr<ewol::Object> destObject = it.destObject.lock();
if (destObject == nullptr) {
EWOL_VERBOSE(" nullptr dest");
continue;
}
if (it.overloadData.size() <= 0){
ewol::object::Message tmpMsg(this, it.destEventId, _data);
ewol::object::Message tmpMsg(shared_from_this(), it.destEventId, _data);
EWOL_VERBOSE("send message " << tmpMsg);
it.destObject->onReceiveMessage(tmpMsg);
destObject->onReceiveMessage(tmpMsg);
} else {
// set the user requested data ...
ewol::object::Message tmpMsg(this, it.destEventId, it.overloadData);
ewol::object::Message tmpMsg(shared_from_this(), it.destEventId, it.overloadData);
EWOL_VERBOSE("send message " << tmpMsg);
it.destObject->onReceiveMessage(tmpMsg);
destObject->onReceiveMessage(tmpMsg);
}
}
if (nbObject > getObjectManager().getNumberObject()) {
@ -225,18 +160,26 @@ void ewol::Object::generateEventId(const char * _generateEventId, const std::str
}
void ewol::Object::sendMultiCast(const char* const _messageId, const std::string& _data) {
if (m_objectHasBeenInit == false) {
EWOL_WARNING("try to generate an multicast event inside a constructor");
return;
}
int32_t nbObject = getObjectManager().getNumberObject();
getMultiCast().send(this, _messageId, _data);
getMultiCast().send(shared_from_this(), _messageId, _data);
if (nbObject > getObjectManager().getNumberObject()) {
EWOL_CRITICAL("It if really dangerous ro remove (delete) element inside a callback ... use ->removObject() which is asynchronous");
}
}
void ewol::Object::registerMultiCast(const char* const _messageId) {
getMultiCast().add(this, _messageId);
if (m_objectHasBeenInit == false) {
EWOL_WARNING("try to generate an event inside a constructor");
return;
}
getMultiCast().add(shared_from_this(), _messageId);
}
void ewol::Object::registerOnEvent(const ewol::object::Shared<ewol::Object>& _destinationObject,
void ewol::Object::registerOnEvent(const std::shared_ptr<ewol::Object>& _destinationObject,
const char * _eventId,
const char * _eventIdgenerated,
const std::string& _overloadData) {
@ -300,7 +243,7 @@ void ewol::Object::registerOnEvent(const ewol::object::Shared<ewol::Object>& _de
m_externEvent.push_back(tmpEvent);
}
void ewol::Object::unRegisterOnEvent(const ewol::object::Shared<ewol::Object>& _destinationObject,
void ewol::Object::unRegisterOnEvent(const std::shared_ptr<ewol::Object>& _destinationObject,
const char * _eventId) {
if (_destinationObject == nullptr) {
EWOL_ERROR("Input ERROR nullptr pointer Object ...");
@ -309,10 +252,11 @@ void ewol::Object::unRegisterOnEvent(const ewol::object::Shared<ewol::Object>& _
// check if event existed :
auto it(m_externEvent.begin());
while(it != m_externEvent.end()) {
if (it->destObject == nullptr) {
std::shared_ptr<ewol::Object> obj = it->destObject.lock();
if (obj == nullptr) {
m_externEvent.erase(it);
it = m_externEvent.begin();
} else if ( it->destObject == _destinationObject
} else if ( obj == _destinationObject
&& it->localEventId == _eventId) {
m_externEvent.erase(it);
it = m_externEvent.begin();
@ -323,14 +267,15 @@ void ewol::Object::unRegisterOnEvent(const ewol::object::Shared<ewol::Object>& _
}
}
void ewol::Object::onObjectRemove(const ewol::object::Shared<ewol::Object>& _object) {
void ewol::Object::onObjectRemove(const std::shared_ptr<ewol::Object>& _object) {
EWOL_VERBOSE("[" << getId() << "] onObjectRemove(" << _object->getId() << ")");
auto it(m_externEvent.begin());
while(it != m_externEvent.end()) {
if (it->destObject == nullptr) {
std::shared_ptr<ewol::Object> obj = it->destObject.lock();
if (obj == nullptr) {
m_externEvent.erase(it);
it = m_externEvent.begin();
} else if (it->destObject == _object) {
} else if (obj == _object) {
m_externEvent.erase(it);
it = m_externEvent.begin();
EWOL_INFO("[" << getId() << "] Remove extern event : to object id=" << _object->getId());
@ -457,7 +402,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::Shared<ewol::Object> object = getObjectManager().get(_objectName);
std::shared_ptr<ewol::Object> object = getObjectManager().get(_objectName);
if (object == nullptr) {
return false;
}
@ -465,7 +410,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::Shared<ewol::Object> object = getObjectManager().get(_objectName);
std::shared_ptr<ewol::Object> object = getObjectManager().get(_objectName);
if (object == nullptr) {
return false;
}
@ -473,7 +418,8 @@ bool ewol::Object::setConfigNamed(const std::string& _objectName, const std::str
}
ewol::object::Manager& ewol::Object::getObjectManager() const {
return ewol::getContext().getEObjectManager();
ewol::object::Manager& tmp = ewol::getContext().getEObjectManager();
return tmp;
}
ewol::object::MultiCast& ewol::Object::getMultiCast() const {
@ -484,12 +430,12 @@ ewol::Context& ewol::Object::getContext() const {
return ewol::getContext();
}
void ewol::Object::registerOnObjectEvent(const ewol::object::Shared<ewol::Object>& _destinationObject,
void ewol::Object::registerOnObjectEvent(const std::shared_ptr<ewol::Object>& _destinationObject,
const std::string& _objectName,
const char * _eventId,
const char * _eventIdgenerated,
const std::string& _overloadData) {
ewol::object::Shared<ewol::Object> tmpObject = getObjectManager().getObjectNamed(_objectName);
std::shared_ptr<ewol::Object> tmpObject = getObjectManager().getObjectNamed(_objectName);
if (nullptr != tmpObject) {
EWOL_DEBUG("Find widget named : '" << _objectName << "' register event='" << _eventId << "'");
tmpObject->registerOnEvent(_destinationObject, _eventId, _eventIdgenerated, _overloadData);
@ -498,6 +444,6 @@ void ewol::Object::registerOnObjectEvent(const ewol::object::Shared<ewol::Object
}
}
ewol::object::Shared<ewol::Object> ewol::Object::getObjectNamed(const std::string& _objectName) const {
std::shared_ptr<ewol::Object> ewol::Object::getObjectNamed(const std::string& _objectName) const {
return getObjectManager().getObjectNamed(_objectName);
}

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

@ -14,8 +14,7 @@
#include <vector>
#include <exml/exml.h>
#include <mutex>
#include <ewol/object/Shared.h>
#include <ewol/object/Owner.h>
#include <memory>
namespace ewol {
// some class need to define element befor other ...
@ -31,6 +30,20 @@ namespace ewol {
#include <ewol/object/ConfigElement.h>
#include <ewol/object/Message.h>
#define DECLARE_FACTORY(className) \
template<typename ... T> static std::shared_ptr<className> create( T&& ... all ) { \
std::shared_ptr<className> object(new className()); \
if (object == nullptr) { \
EWOL_ERROR("Factory error"); \
return nullptr; \
} \
object->init(std::forward<T>(all)... ); \
if (object->objectHasBeenCorectlyInit() == false) { \
EWOL_CRITICAL("Object Is not correctly init : " << #className ); \
} \
return object; \
}
namespace ewol {
namespace object {
/**
@ -40,7 +53,7 @@ namespace ewol {
class EventExtGen {
public:
const char* localEventId; //!< local event Id generation
ewol::object::Shared<ewol::Object> destObject; //!< destination widget that might be call
std::weak_ptr<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)
};
@ -49,74 +62,48 @@ namespace ewol {
* @brief Basic message classes for ewol system
* this class mermit at every Object to communicate between them.
*/
class Object {
template<typename T> friend class ewol::object::Shared;
template<typename T> friend class ewol::object::Owner;
private:
//! @not-in-doc
std::mutex m_lockRefCount;
//! @not-in-doc
int32_t m_objRefCount;
public:
//! @not-in-doc
void objRefCountIncrement();
//! @not-in-doc
void objRefCountDecrement();
int32_t getRefCount() {
return m_objRefCount;
}
//! @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);
#ifdef DEBUG
public:
int32_t m_ownerCount;
void incOwnerCount();
void decOwnerCount();
#endif
class Object : public std::enable_shared_from_this<Object> {
private:
static size_t m_valUID; //!< stic used for the unique ID definition
public:
// Config list of properties
static const char* const configName;
public:
private:
bool m_objectHasBeenInit; //!< Know if the init function has bben called
protected:
/**
* @brief Constructor.
*/
Object();
void init();
void init(const std::string& _name);
public:
/**
* @brief Constructor.
* @param[in] _name Name of the Object.
* @brief Factory
*/
Object(const std::string& _name);
DECLARE_FACTORY(Object);
/**
* @brief Destructor
*/
virtual ~Object();
private:
bool m_isDestroyed;
bool objectHasBeenCorectlyInit() {
return m_objectHasBeenInit;
}
protected:
std::weak_ptr<Object> m_parent;
protected:
/**
* @brief Auto-destroy the object
*/
void autoDestroy();
public:
/**
* @brief Asynchronous removing the object
*/
void removeObject();
/**
* @brief Respown a removed object
*/
void respownObject();
/**
* @brief Get if the element is destroyed or not
* @return true The element in destroyed
*/
bool isDestroyed() {
return m_isDestroyed;
void destroy() {
autoDestroy();
}
public:
virtual void requestDestroyFromChild(const std::shared_ptr<Object>& _child);
virtual void setParent(const std::shared_ptr<Object>& _newParent);
virtual void removeParent();
private:
std::vector<const char*> m_listType;
public:
@ -196,7 +183,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(const ewol::object::Shared<ewol::Object>& _destinationObject,
void registerOnEvent(const std::shared_ptr<ewol::Object>& _destinationObject,
const char * _eventId,
const char * _eventIdgenerated = nullptr,
const std::string& _overloadData = "");
@ -205,13 +192,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 (nullptr to remove all event on this object)
*/
void unRegisterOnEvent(const ewol::object::Shared<ewol::Object>& _destinationObject,
void unRegisterOnEvent(const std::shared_ptr<ewol::Object>& _destinationObject,
const char * _eventId = nullptr);
/**
* @brief Inform object that an other object is removed ...
* @note : Sub classes must call this class
*/
virtual void onObjectRemove(const ewol::object::Shared<ewol::Object>& _object);
virtual void onObjectRemove(const std::shared_ptr<ewol::Object>& _object);
/**
* @brief Receive a message from an other Object with a specific eventId and data
* @param[in] _msg Message handle
@ -350,7 +337,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 registerOnObjectEvent(const ewol::object::Shared<ewol::Object>& _destinationObject,
void registerOnObjectEvent(const std::shared_ptr<ewol::Object>& _destinationObject,
const std::string& _objectName,
const char * _eventId,
const char * _eventIdgenerated = nullptr,
@ -360,8 +347,9 @@ namespace ewol {
* @param[in] _name Name of the object
* @return the requested object or nullptr
*/
ewol::object::Shared<ewol::Object> getObjectNamed(const std::string& _objectName) const;
std::shared_ptr<ewol::Object> getObjectNamed(const std::string& _objectName) const;
};
};
#endif

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

@ -1,262 +0,0 @@
/**
* @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__
#include <ewol/debug.h>
namespace ewol {
namespace object {
template<typename T>
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;
}
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;
}
// shared to private constructor
template<typename T2, typename = typename
std::enable_if<std::is_convertible<T*, T2*>::value>::type>
Owner(const Shared<T2>& _obj) :
m_pointer(nullptr) {
m_pointer = _obj.get();
if (m_pointer == nullptr) {
return;
}
m_pointer->objRefCountIncrement();
#ifdef DEBUG
m_pointer->incOwnerCount();
#endif
}
template<typename T2, typename = typename
std::enable_if<std::is_convertible<T*, T2*>::value>::type>
Owner& operator=(const Owner<T2>& _obj) noexcept {
if(this == &_obj) {
return *this;
}
reset();
m_pointer = _obj.get();
if (m_pointer != nullptr) {
m_pointer->objRefCountIncrement();
#ifdef DEBUG
m_pointer->incOwnerCount();
#endif
}
return *this;
}
template<typename T2, typename = typename
std::enable_if<std::is_convertible<T*, T2*>::value>::type>
Owner& operator=(const Shared<T2>& _obj) noexcept {
reset();
m_pointer = _obj.get();
if (m_pointer != nullptr) {
m_pointer->objRefCountIncrement();
#ifdef DEBUG
m_pointer->incOwnerCount();
#endif
}
return *this;
}
void reset() {
if (m_pointer == nullptr) {
return;
}
//etk::log::displayBacktrace();
// To prevent cyclisme
T* tmp = m_pointer;
m_pointer = nullptr;
tmp->removeObject();
if (tmp->m_objRefCount <= 0) {
EWOL_WARNING("Object will be already removed");
} else if (tmp->m_objRefCount == 1) {
EWOL_VERBOSE("Remove object (in Owner)");
delete tmp;
} else {
tmp->objRefCountDecrement();
#ifdef DEBUG
tmp->decOwnerCount();
#endif
}
}
void resetShared() {
if (m_pointer == nullptr) {
return;
}
// To prevent cyclisme
T* tmp = m_pointer;
m_pointer = nullptr;
if (tmp->m_objRefCount <= 0) {
EWOL_WARNING("Object will be already removed");
} else if (tmp->m_objRefCount == 1) {
EWOL_VERBOSE("Remove object (in Owner)");
delete tmp;
} else {
tmp->objRefCountDecrement();
#ifdef DEBUG
tmp->decOwnerCount();
#endif
}
}
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;
}
operator ewol::object::Shared<T>() const noexcept {
return m_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() == nullptr;
}
//! @not in doc
template<typename T2>
inline bool operator==(std::nullptr_t, const object::Owner<T2>& _obj) noexcept {
return _obj.get() == nullptr;
}
//! @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::Shared<T2>& _obj2) noexcept {
return _obj.get() == _obj2.get();
}
//! @not in doc
template<typename T, typename T2>
inline bool operator==(const object::Shared<T>& _obj, const object::Owner<T2>& _obj2) noexcept {
return _obj.get() == _obj2.get();
}
//! @not in doc
template<typename T, typename T2, 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() != nullptr;
}
//! @not in doc
template<typename T>
inline bool operator!=(std::nullptr_t, const object::Owner<T>& _obj) noexcept {
return _obj.get() != nullptr;
}
//! @not in doc
template<typename T, typename T2>
inline bool operator!=(const object::Owner<T>& _obj, const object::Shared<T2>& _obj2) noexcept {
return _obj.get() != _obj2.get();
}
//! @not in doc
template<typename T, typename T2>
inline bool operator!=(const object::Shared<T>& _obj, const object::Owner<T2>& _obj2) noexcept {
return _obj.get() != _obj2.get();
}
/*
template<typename T, typename T2, typename = typename
std::enable_if<std::is_convertible<T*, T2*>::value>::type>
object::Shared<T> operator=(const object::Owner<T2>& _obj) {
return _obj.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

7
sources/ewol/object/RemoveEvent.cpp
View File

@ -10,14 +10,19 @@
#include <ewol/context/Context.h>
ewol::object::RemoveEvent::RemoveEvent() {
EWOL_TODO("ewol::object::RemoveEvent::RemoveEvent()");
/*
Context& tmp = ewol::getContext();
ewol::object::Manager& manager = tmp.getEObjectManager();
manager.add(this);
*/
}
ewol::object::RemoveEvent::~RemoveEvent() {
EWOL_TODO("ewol::object::RemoveEvent::~RemoveEvent()");
/*
Context& tmp = ewol::getContext();
ewol::object::Manager& manager = tmp.getEObjectManager();
manager.rm(this);
*/
}

2
sources/ewol/object/RemoveEvent.h
View File

@ -16,7 +16,7 @@ namespace ewol {
namespace object {
class RemoveEvent {
public:
virtual void onObjectRemove(const ewol::object::Shared<ewol::Object>& _object) = 0;
virtual void onObjectRemove(const std::shared_ptr<ewol::Object>& _object) = 0;
public:
RemoveEvent();
virtual ~RemoveEvent();

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

@ -1,190 +0,0 @@
/**
* @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__
#include <ewol/debug.h>
namespace ewol {
namespace object {
template<typename T>
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;
}
// To prevent cyclisme
T* tmp = m_pointer;
m_pointer = nullptr;
if (tmp->m_objRefCount <= 0) {
EWOL_WARNING("Object is already removed");
} else if (tmp->m_objRefCount == 1) {
EWOL_VERBOSE("Remove object (in shared)");
delete tmp;
} else {
tmp->objRefCountDecrement();
}
}
T* get() const noexcept {
return m_pointer;
}
T& operator*() const noexcept {
return *m_pointer;
}
T* operator->() const noexcept {
return m_pointer;
}
template<typename T2> operator ewol::object::Shared<T2>() const noexcept {
return m_pointer;
}
};
// after calling this function, you might never call a delete on this pointer. (if you want to be able to use a delete, simply Shared<>(pointer)
template<typename T> Shared<T> makeShared(T* _pointer) {
if (_pointer == nullptr) {
return Shared<T>();
}
Shared<T> tmp(_pointer);
// remove one element to permit to remove at the last instance
_pointer->objRefCountDecrement();
return tmp;
}
};
// 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() == nullptr;
}
//! @not in doc
template<typename T2>
inline bool operator==(std::nullptr_t, const object::Shared<T2>& _obj) noexcept {
return _obj.get() == nullptr;
}
//! @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() != nullptr;
}
//! @not in doc
template<typename T>
inline bool operator!=(std::nullptr_t, const object::Shared<T>& _obj) noexcept {
return _obj.get() != nullptr;
}
//! @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 ewol::object::Shared<T2>(obj);
}
return ewol::object::Shared<T2>();
}
};
#endif

36
sources/ewol/resource/ColorFile.cpp
View File

@ -17,21 +17,25 @@
#define __class__ "resource::ColorFile"
ewol::resource::ColorFile::ColorFile(const std::string& _filename) :
ewol::Resource(_filename),
ewol::resource::ColorFile::ColorFile() :
ewol::Resource(),
m_errorColor(etk::color::orange) {
addObjectType("ewol::ColorFile");
}
void ewol::resource::ColorFile::init(const std::string& _filename) {
ewol::Resource::init(_filename);
EWOL_DEBUG("CF : load \"" << _filename << "\"");
reload();
EWOL_DEBUG("List of all color : " << m_list.getKeys());
}
ewol::resource::ColorFile::~ColorFile() {
// remove all element
m_list.clear();
}
void ewol::resource::ColorFile::reload() {
// remove all previous set of value :
for (int32_t iii = 0; iii < m_list.size() ; ++iii) {
@ -73,29 +77,3 @@ int32_t ewol::resource::ColorFile::request(const std::string& _paramName) {
}
return m_list.getId(_paramName);
}
ewol::object::Shared<ewol::resource::ColorFile> ewol::resource::ColorFile::keep(const std::string& _filename) {
EWOL_INFO("KEEP : ColorFile : file : \"" << _filename << "\"");
ewol::object::Shared<ewol::resource::ColorFile> object = nullptr;
ewol::object::Shared<ewol::Resource> object2 = getManager().localKeep(_filename);
if (nullptr != object2) {
object = ewol::dynamic_pointer_cast<ewol::resource::ColorFile>(object2);
if (nullptr == object) {
EWOL_CRITICAL("Request resource file : '" << _filename << "' With the wrong type (dynamic cast error)");
return nullptr;
}
}
if (nullptr != object) {
return object;
}
// this element create a new one every time ....
object = ewol::object::makeShared(new ewol::resource::ColorFile(_filename));
if (nullptr == object) {
EWOL_ERROR("allocation error of a resource : " << _filename);
return nullptr;
}
getManager().localAdd(object);
return object;
}

12
sources/ewol/resource/ColorFile.h
View File

@ -29,8 +29,10 @@ namespace ewol {
* @brief Constructor of the color property file
* @param[in] _filename Name of the file needed
*/
ColorFile(const std::string& _filename);
ColorFile();
void init(const std::string& _filename);
public:
DECLARE_RESOURCE_NAMED_FACTORY(ColorFile);
/**
* @brief Simple Destructor of this class (nothing specific ...)
*/
@ -69,14 +71,6 @@ namespace ewol {
}
public: // herited function:
void reload();
public:
/**
* @brief keep the resource pointer.
* @note Never free this pointer by your own...
* @param[in] _filename Name of the configuration file.
* @return pointer on the resource or nullptr if an error occured.
*/
static ewol::object::Shared<ewol::resource::ColorFile> keep(const std::string& _filename);
};
};
};

14
sources/ewol/resource/Colored3DObject.cpp
View File

@ -19,7 +19,7 @@ ewol::resource::Colored3DObject::Colored3DObject() :
addObjectType("ewol::Colored3DObject");
// get the shader resource :
m_GLPosition = 0;
m_GLprogram = ewol::resource::Program::keep("DATA:simple3D.prog");
m_GLprogram = ewol::resource::Program::create("DATA:simple3D.prog");
if (nullptr != m_GLprogram ) {
m_GLPosition = m_GLprogram->getAttribute("EW_coord3d");
m_GLColor = m_GLprogram->getUniform("EW_color");
@ -154,15 +154,3 @@ void ewol::resource::Colored3DObject::drawLine(std::vector<vec3>& _vertices,
}
}
ewol::object::Shared<ewol::resource::Colored3DObject> ewol::resource::Colored3DObject::keep() {
EWOL_VERBOSE("KEEP : direct Colored3DObject");
// need to crate a new one ...
ewol::object::Shared<ewol::resource::Colored3DObject> object = ewol::object::makeShared(new ewol::resource::Colored3DObject());
if (object == nullptr) {
EWOL_ERROR("allocation error of a resource : ???Colored3DObject??? ");
return nullptr;
}
getManager().localAdd(object);
return object;
}

11
sources/ewol/resource/Colored3DObject.h
View File

@ -19,13 +19,15 @@ namespace ewol {
namespace resource {
class Colored3DObject : public ewol::Resource {
protected:
ewol::object::Shared<ewol::resource::Program> m_GLprogram;
std::shared_ptr<ewol::resource::Program> m_GLprogram;
int32_t m_GLPosition;
int32_t m_GLMatrix;
int32_t m_GLColor;
protected:
Colored3DObject();
void init();
public:
DECLARE_RESOURCE_FACTORY(Colored3DObject);
virtual ~Colored3DObject();
public:
virtual void draw(std::vector<vec3>& _vertices,
@ -42,13 +44,6 @@ namespace ewol {
mat4& _transformationMatrix,
bool _updateDepthBuffer=true,
bool _depthtest=true);
public:
/**
* @brief keep the resource pointer.
* @note Never free this pointer by your own...
* @return pointer on the resource or nullptr if an error occured.
*/
static ewol::object::Shared<ewol::resource::Colored3DObject> keep();
};
};
};

35
sources/ewol/resource/ConfigFile.cpp
View File

@ -19,9 +19,13 @@
#define __class__ "resource::ConfigFile"
ewol::resource::ConfigFile::ConfigFile(const std::string& _filename) :
ewol::Resource(_filename) {
ewol::resource::ConfigFile::ConfigFile() :
ewol::Resource() {
addObjectType("ewol::ConfigFile");
}
void ewol::resource::ConfigFile::init(const std::string& _filename) {
ewol::Resource::init(_filename);
EWOL_DEBUG("SFP : load \"" << _filename << "\"");
reload();
}
@ -103,30 +107,3 @@ bool ewol::resource::ConfigFile::getBoolean(int32_t _id) {
}
return tmp->get();
}
ewol::object::Shared<ewol::resource::ConfigFile> ewol::resource::ConfigFile::keep(const std::string& _filename) {
EWOL_INFO("KEEP : SimpleConfig : file : \"" << _filename << "\"");
ewol::object::Shared<ewol::resource::ConfigFile> object = nullptr;
ewol::object::Shared<ewol::Resource> object2 = getManager().localKeep(_filename);
if (nullptr != object2) {
object = ewol::dynamic_pointer_cast<ewol::resource::ConfigFile>(object2);
if (nullptr == object) {
EWOL_CRITICAL("Request resource file : '" << _filename << "' With the wrong type (dynamic cast error)");
return nullptr;
}
}
if (nullptr != object) {
return object;
}
// this element create a new one every time ....
object = ewol::object::makeShared(new ewol::resource::ConfigFile(_filename));
if (nullptr == object) {
EWOL_ERROR("allocation error of a resource : '" << _filename << "'");
return nullptr;
}
getManager().localAdd(object);
return object;
}

6
sources/ewol/resource/ConfigFile.h
View File

@ -22,9 +22,11 @@ namespace ewol {
ejson::Document m_doc;
etk::Hash<ejson::Value*> m_list;
protected:
ConfigFile(const std::string& _filename);
ConfigFile();
void init(const std::string& _filename);
public:
virtual ~ConfigFile();
DECLARE_RESOURCE_NAMED_FACTORY(ConfigFile);
public:
void reload();
@ -40,7 +42,7 @@ namespace ewol {
* @param[in] _filename Name of the configuration file.
* @return pointer on the resource or nullptr if an error occured.
*/
static ewol::object::Shared<ewol::resource::ConfigFile> keep(const std::string& _filename);
static std::shared_ptr<ewol::resource::ConfigFile> keep(const std::string& _filename);
};
};
};

36
sources/ewol/resource/DistanceFieldFont.cpp
View File

@ -24,8 +24,8 @@
#define __class__ "resource::DistanceFieldFont"
#define SIZE_GENERATION (30)
ewol::resource::DistanceFieldFont::DistanceFieldFont(const std::string& _fontName) :
ewol::resource::Texture(_fontName),
ewol::resource::DistanceFieldFont::DistanceFieldFont() :
ewol::resource::Texture(),
m_borderSize(10),
m_textureBorderSize(0,0) {
addObjectType("ewol::resource::DistanceFieldFont");
@ -33,6 +33,10 @@ ewol::resource::DistanceFieldFont::DistanceFieldFont(const std::string& _fontNam
m_lastGlyphPos.setValue(1,1);
m_lastRawHeigh = 0;
m_sizeRatio = 1.0f;
}
void ewol::resource::DistanceFieldFont::init(const std::string& _fontName) {
ewol::resource::Texture::init(_fontName);
std::string localName = _fontName;
std::vector<std::string> folderList;
if (true == ewol::getContext().getFontDefault().getUseExternal()) {
@ -88,7 +92,7 @@ ewol::resource::DistanceFieldFont::DistanceFieldFont(const std::string& _fontNam
return;
}
EWOL_INFO("Load FONT name : '" << m_fileName << "'");
m_font = ewol::resource::FontFreeType::keep(m_fileName);
m_font = ewol::resource::FontFreeType::create(m_fileName);
if (m_font == nullptr) {
EWOL_ERROR("Pb Loading FONT name : '" << m_fileName << "'" );
}
@ -335,32 +339,6 @@ ewol::GlyphProperty* ewol::resource::DistanceFieldFont::getGlyphPointer(const ch
return &((m_listElement)[index]);
}
ewol::object::Shared<ewol::resource::DistanceFieldFont> ewol::resource::DistanceFieldFont::keep(const std::string& _filename) {
EWOL_VERBOSE("KEEP : DistanceFieldFont : file : '" << _filename << "'");
ewol::object::Shared<ewol::resource::DistanceFieldFont> object = nullptr;
ewol::object::Shared<ewol::Resource> object2 = getManager().localKeep(_filename);
if (nullptr != object2) {
object = ewol::dynamic_pointer_cast<ewol::resource::DistanceFieldFont>(object2);
if (nullptr == object) {
EWOL_CRITICAL("Request resource file : '" << _filename << "' With the wrong type (dynamic cast error)");
return nullptr;
}
}
if (nullptr != object) {
return object;
}
// need to crate a new one ...
EWOL_DEBUG("CREATE: DistanceFieldFont : file : '" << _filename << "'");
object = ewol::object::makeShared(new ewol::resource::DistanceFieldFont(_filename));
if (nullptr == object) {
EWOL_ERROR("allocation error of a resource : " << _filename);
return nullptr;
}
getManager().localAdd(object);
return object;
}
void ewol::resource::DistanceFieldFont::exportOnFile() {
EWOL_DEBUG("EXPORT: DistanceFieldFont : file : '" << m_fileName << ".json'");
ejson::Document doc;

8
sources/ewol/resource/DistanceFieldFont.h
View File

@ -23,7 +23,7 @@ namespace ewol {
// specific element to have the the know if the specify element is known...
// == > otherwise I can just generate italic ...
// == > Bold is a little more complicated (maybe with the bordersize)
ewol::object::Shared<ewol::resource::FontBase> m_font;
std::shared_ptr<ewol::resource::FontBase> m_font;
public:
std::vector<GlyphProperty> m_listElement;
private:
@ -31,8 +31,10 @@ namespace ewol {
ivec2 m_lastGlyphPos;
int32_t m_lastRawHeigh;
protected:
DistanceFieldFont(const std::string& _fontName);
DistanceFieldFont();
void init(const std::string& _fontName);
public:
DECLARE_RESOURCE_NAMED_FACTORY(DistanceFieldFont);
virtual ~DistanceFieldFont();
public:
float getDisplayRatio(float _size);
@ -71,7 +73,7 @@ namespace ewol {
* @param[in] _filename Name of the texture font.
* @return pointer on the resource or nullptr if an error occured.
*/
static ewol::object::Shared<ewol::resource::DistanceFieldFont> keep(const std::string& _filename);
static std::shared_ptr<ewol::resource::DistanceFieldFont> keep(const std::string& _filename);
private:
/**
* @brief add a glyph in a texture font.

32
sources/ewol/resource/FontFreeType.cpp
View File

@ -52,13 +52,15 @@ void ewol::resource::freeTypeUnInit() {
}
}
ewol::resource::FontFreeType::FontFreeType(const std::string& _fontName) :
FontBase(_fontName) {
ewol::resource::FontFreeType::FontFreeType() {
addObjectType("ewol::FontFreeType");
m_init = false;
m_FileBuffer = nullptr;
m_FileSize = 0;
}
void ewol::resource::FontFreeType::init(const std::string& _fontName) {
ewol::resource::FontBase::init(_fontName);
etk::FSNode myfile(_fontName);
if (false == myfile.exist()) {
EWOL_ERROR("File Does not exist : " << myfile);
@ -389,27 +391,3 @@ void ewol::resource::FontFreeType::display() {
//EWOL_INFO(" Current size = " << (int)m_fftFace->size);
}
ewol::object::Shared<ewol::resource::FontBase> ewol::resource::FontFreeType::keep(const std::string& _filename) {
EWOL_VERBOSE("KEEP : Font : file : \"" << _filename << "\"");
ewol::object::Shared<ewol::resource::FontBase> object = nullptr;
ewol::object::Shared<ewol::Resource> object2 = getManager().localKeep(_filename);
if (nullptr != object2) {
object = ewol::dynamic_pointer_cast<ewol::resource::FontBase>(object2);
if (nullptr == object) {
EWOL_CRITICAL("Request resource file : '" << _filename << "' With the wrong type (dynamic cast error)");
return nullptr;
}
}
if (nullptr != object) {
return object;
}
// need to crate a new one ...
object = ewol::object::makeShared(new ewol::resource::FontFreeType(_filename));
if (nullptr == object) {
EWOL_ERROR("allocation error of a resource : " << _filename);
return nullptr;
}
getManager().localAdd(object);
return object;
}

12
sources/ewol/resource/FontFreeType.h
View File

@ -29,8 +29,10 @@ namespace ewol {
bool m_init;
void display();
protected:
FontFreeType(const std::string& _fontName);
FontFreeType();
void init(const std::string& _fontName);
public:
DECLARE_RESOURCE_NAMED_FACTORY(FontFreeType);
virtual ~FontFreeType();
public:
@ -54,14 +56,6 @@ namespace ewol {
float getSizeWithHeight(float _fontHeight);
void generateKerning(int32_t _fontSize, std::vector<ewol::GlyphProperty>& _listGlyph);
public:
/**
* @brief keep the resource pointer.
* @note Never free this pointer by your own...
* @param[in] _filename Name of the base font.
* @return pointer on the resource or nullptr if an error occured.
*/
static ewol::object::Shared<ewol::resource::FontBase> keep(const std::string& _filename);
};
void freeTypeInit();
void freeTypeUnInit();

27
sources/ewol/resource/Image.cpp
View File

@ -17,16 +17,17 @@
#undef __class__
#define __class__ "resource::TextureFile"
ewol::resource::TextureFile::TextureFile(const std::string& _genName) :
Texture(_genName) {
EWOL_DEBUG("create a new resource::Image : _genName=" << _genName << " _tmpfileName=--- size=---");
ewol::resource::TextureFile::TextureFile() {
addObjectType("ewol::resource::Image");
}
void ewol::resource::TextureFile::init() {
ewol::resource::Texture::init();
}
ewol::resource::TextureFile::TextureFile(std::string _genName, const std::string& _tmpfileName, const ivec2& _size) :
ewol::resource::Texture(_genName) {
addObjectType("ewol::resource::Image");
void ewol::resource::TextureFile::init(std::string _genName, const std::string& _tmpfileName, const ivec2& _size) {
ewol::resource::Texture::init(_genName);
EWOL_DEBUG("create a new resource::Image : _genName=" << _genName << " _tmpfileName=" << _tmpfileName << " size=" << _size);
if (false == egami::load(m_data, _tmpfileName, _size)) {
EWOL_ERROR("ERROR when loading the image : " << _tmpfileName);
@ -62,14 +63,15 @@ static int32_t nextP2(int32_t _value) {
ewol::object::Shared<ewol::resource::TextureFile> ewol::resource::TextureFile::keep(const std::string& _filename, ivec2 _size) {
std::shared_ptr<ewol::resource::TextureFile> ewol::resource::TextureFile::create(const std::string& _filename, ivec2 _size) {
EWOL_VERBOSE("KEEP: TextureFile: '" << _filename << "' size=" << _size);
if (_filename == "") {
ewol::object::Shared<ewol::resource::TextureFile> object = ewol::object::makeShared(new ewol::resource::TextureFile(""));
std::shared_ptr<ewol::resource::TextureFile> object(new ewol::resource::TextureFile());
if (nullptr == object) {
EWOL_ERROR("allocation error of a resource : ??TEX??");
return nullptr;
}
object->init();
getManager().localAdd(object);
return object;
}
@ -101,10 +103,10 @@ ewol::object::Shared<ewol::resource::TextureFile> ewol::resource::TextureFile::k
}
EWOL_VERBOSE("KEEP: TextureFile: '" << TmpFilename << "' new size=" << _size);
ewol::object::Shared<ewol::resource::TextureFile> object = nullptr;
ewol::object::Shared<ewol::Resource> object2 = getManager().localKeep(TmpFilename);
std::shared_ptr<ewol::resource::TextureFile> object = nullptr;
std::shared_ptr<ewol::Resource> object2 = getManager().localKeep(TmpFilename);
if (nullptr != object2) {
object = ewol::dynamic_pointer_cast<ewol::resource::TextureFile>(object2);
object = std::dynamic_pointer_cast<ewol::resource::TextureFile>(object2);
if (nullptr == object) {
EWOL_CRITICAL("Request resource file : '" << TmpFilename << "' With the wrong type (dynamic cast error)");
return nullptr;
@ -115,11 +117,12 @@ ewol::object::Shared<ewol::resource::TextureFile> ewol::resource::TextureFile::k
}
EWOL_INFO("CREATE: TextureFile: '" << TmpFilename << "' size=" << _size);
// need to crate a new one ...
object = ewol::object::makeShared(new ewol::resource::TextureFile(TmpFilename, _filename, _size));
object = std::shared_ptr<ewol::resource::TextureFile>(new ewol::resource::TextureFile());
if (nullptr == object) {
EWOL_ERROR("allocation error of a resource : " << _filename);
return nullptr;
}
object->init(TmpFilename, _filename, _size);
getManager().localAdd(object);
return object;
}

9
sources/ewol/resource/Image.h
View File

@ -20,9 +20,10 @@ namespace ewol {
class TextureFile : public ewol::resource::Texture {
private:
vec2 m_realImageSize;
private:
TextureFile(const std::string& _genName);
TextureFile(std::string _genName, const std::string& _fileName, const ivec2& _size);
protected:
TextureFile();
void init();
void init(std::string _genName, const std::string& _fileName, const ivec2& _size);
public:
virtual ~TextureFile() { };
public:
@ -37,7 +38,7 @@ namespace ewol {
* @param[in] _requested size of the image (usefull when loading .svg to automatic rescale)
* @return pointer on the resource or nullptr if an error occured.
*/
static ewol::object::Shared<ewol::resource::TextureFile> keep(const std::string& _filename, ivec2 _size=ivec2(-1,-1));
static std::shared_ptr<ewol::resource::TextureFile> create(const std::string& _filename, ivec2 _size=ivec2(-1,-1));
};
};
};

29
sources/ewol/resource/ImageDF.cpp
View File

@ -18,16 +18,17 @@
#undef __class__
#define __class__ "resource::TextureFile"
ewol::resource::ImageDF::ImageDF(const std::string& _genName) :
Texture(_genName) {
EWOL_DEBUG("create a new resource::ImageDF : _genName=" << _genName << " _tmpfileName=--- size=---");
ewol::resource::ImageDF::ImageDF() {
addObjectType("ewol::resource::ImageDF");
}
ewol::resource::ImageDF::ImageDF(std::string _genName, const std::string& _tmpfileName, const ivec2& _size) :
ewol::resource::Texture(_genName) {
addObjectType("ewol::resource::ImageDF");
void ewol::resource::ImageDF::init() {
ewol::resource::Texture::init();
}
void ewol::resource::ImageDF::init(std::string _genName, const std::string& _tmpfileName, const ivec2& _size) {
ewol::resource::Texture::init(_genName);
EWOL_DEBUG("create a new resource::Image : _genName=" << _genName << " _tmpfileName=" << _tmpfileName << " size=" << _size);
if (false == egami::load(m_data, _tmpfileName, _size)) {
EWOL_ERROR("ERROR when loading the image : " << _tmpfileName);
@ -151,14 +152,15 @@ static int32_t nextP2(int32_t _value) {
ewol::object::Shared<ewol::resource::ImageDF> ewol::resource::ImageDF::keep(const std::string& _filename, ivec2 _size) {
std::shared_ptr<ewol::resource::ImageDF> ewol::resource::ImageDF::create(const std::string& _filename, ivec2 _size) {
EWOL_VERBOSE("KEEP: TextureFile: '" << _filename << "' size=" << _size);
if (_filename == "") {
ewol::object::Shared<ewol::resource::ImageDF> object = ewol::object::makeShared(new ewol::resource::ImageDF(""));
std::shared_ptr<ewol::resource::ImageDF> object(new ewol::resource::ImageDF());
if (nullptr == object) {
EWOL_ERROR("allocation error of a resource : ??TEX??");
return nullptr;
}
object->init();
getManager().localAdd(object);
return object;
}
@ -190,10 +192,10 @@ ewol::object::Shared<ewol::resource::ImageDF> ewol::resource::ImageDF::keep(cons
}
EWOL_VERBOSE("KEEP: TextureFile: '" << TmpFilename << "' new size=" << _size);
ewol::object::Shared<ewol::resource::ImageDF> object = nullptr;
ewol::object::Shared<ewol::Resource> object2 = getManager().localKeep("DF__" + TmpFilename);
std::shared_ptr<ewol::resource::ImageDF> object = nullptr;
std::shared_ptr<ewol::Resource> object2 = getManager().localKeep("DF__" + TmpFilename);
if (nullptr != object2) {
object = ewol::dynamic_pointer_cast<ewol::resource::ImageDF>(object2);
object = std::dynamic_pointer_cast<ewol::resource::ImageDF>(object2);
if (nullptr == object) {
EWOL_CRITICAL("Request resource file : '" << TmpFilename << "' With the wrong type (dynamic cast error)");
return nullptr;
@ -204,11 +206,12 @@ ewol::object::Shared<ewol::resource::ImageDF> ewol::resource::ImageDF::keep(cons
}
EWOL_INFO("CREATE: ImageDF: '" << TmpFilename << "' size=" << _size);
// need to crate a new one ...
object = ewol::object::makeShared(new ewol::resource::ImageDF("DF__" + TmpFilename, _filename, _size));
object = std::shared_ptr<ewol::resource::ImageDF>(new ewol::resource::ImageDF());
if (nullptr == object) {
EWOL_ERROR("allocation error of a resource : " << _filename);
return nullptr;
}
object->init("DF__" + TmpFilename, _filename, _size);
getManager().localAdd(object);
return object;
}

7
sources/ewol/resource/ImageDF.h
View File

@ -22,8 +22,9 @@ namespace ewol {
protected:
vec2 m_realImageSize;
protected:
ImageDF(const std::string& _genName);
ImageDF(std::string _genName, const std::string& _fileName, const ivec2& _size);
ImageDF();
void init();
void init(std::string _genName, const std::string& _fileName, const ivec2& _size);
public:
virtual ~ImageDF() { };
protected:
@ -45,7 +46,7 @@ namespace ewol {
* @param[in] _requested size of the image (usefull when loading .svg to automatic rescale)
* @return pointer on the resource or nullptr if an error occured.
*/
static ewol::object::Shared<ewol::resource::ImageDF> keep(const std::string& _filename, ivec2 _size=ivec2(-1,-1));
static std::shared_ptr<ewol::resource::ImageDF> create(const std::string& _filename, ivec2 _size=ivec2(-1,-1));
};
};
};

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

@ -27,6 +27,7 @@ ewol::resource::Manager::~Manager() {
EWOL_ERROR("Must not have anymore resources to update !!!");
hasError = true;
}
// TODO : Remove unneeded elements
if (m_resourceList.size()!=0) {
EWOL_ERROR("Must not have anymore resources !!!");
hasError = true;
@ -42,10 +43,11 @@ void ewol::resource::Manager::unInit() {
// remove all resources ...
auto it(m_resourceList.begin());
while(it != m_resourceList.end()) {
if ((*it) != nullptr) {
EWOL_WARNING("Find a resource that is not removed : [" << (*it)->getId() << "]"
<< "=\"" << (*it)->getName() << "\" "
<< (*it)->getRefCount() << " elements");
std::shared_ptr<ewol::Resource> tmpRessource = (*it).lock();
if (tmpRessource != nullptr) {
EWOL_WARNING("Find a resource that is not removed : [" << tmpRessource->getId() << "]"
<< "=\"" << tmpRessource->getName() << "\" "
<< tmpRessource.use_count() << " elements");
}
m_resourceList.erase(it);
it = m_resourceList.begin();
@ -57,11 +59,12 @@ void ewol::resource::Manager::display() {
EWOL_INFO("Resources loaded : ");
// remove all resources ...
for (auto &it : m_resourceList) {
if (it != nullptr) {
EWOL_INFO(" [" << it->getId() << "]"
<< it->getObjectType()
<< "=\"" << it->getName() << "\" "
<< it->getRefCount() << " elements");
std::shared_ptr<ewol::Resource> tmpRessource = it.lock();
if (tmpRessource != nullptr) {
EWOL_INFO(" [" << tmpRessource->getId() << "]"
<< tmpRessource->getObjectType()
<< "=\"" << tmpRessource->getName() << "\" "
<< tmpRessource.use_count() << " elements");
}
}
EWOL_INFO("Resources ---");
@ -74,10 +77,11 @@ void ewol::resource::Manager::reLoadResources() {
for (size_t jjj=0; jjj<MAX_RESOURCE_LEVEL; jjj++) {
EWOL_INFO(" Reload level : " << jjj << "/" << (MAX_RESOURCE_LEVEL-1));
for (auto &it : m_resourceList) {
if(it != nullptr) {
if (jjj == it->getResourceLevel()) {
it->reload();
EWOL_INFO(" [" << it->getId() << "]="<< it->getObjectType());
std::shared_ptr<ewol::Resource> tmpRessource = it.lock();
if(tmpRessource != nullptr) {
if (jjj == tmpRessource->getResourceLevel()) {
tmpRessource->reload();
EWOL_INFO(" [" << tmpRessource->getId() << "]="<< tmpRessource->getObjectType());
}
}
}
@ -88,7 +92,7 @@ void ewol::resource::Manager::reLoadResources() {
EWOL_INFO("------------- Resources -------------");
}
void ewol::resource::Manager::update(const ewol::object::Shared<ewol::Resource>& _object) {
void ewol::resource::Manager::update(const std::shared_ptr<ewol::Resource>& _object) {
// chek if not added before
for (auto &it : m_resourceListToUpdate) {
if ( it != nullptr
@ -110,10 +114,11 @@ void ewol::resource::Manager::updateContext() {
for (size_t jjj=0; jjj<MAX_RESOURCE_LEVEL; jjj++) {
EWOL_INFO(" updateContext level (D) : " << jjj << "/" << (MAX_RESOURCE_LEVEL-1));
for (auto &it : m_resourceList) {
if( it != nullptr
&& jjj == it->getResourceLevel()) {
std::shared_ptr<ewol::Resource> tmpRessource = it.lock();
if( tmpRessource != nullptr
&& jjj == tmpRessource->getResourceLevel()) {
//EWOL_DEBUG("Update context named : " << l_resourceList[iii]->getName());
it->updateContext();
tmpRessource->updateContext();
}
}
}
@ -138,8 +143,9 @@ void ewol::resource::Manager::updateContext() {
// in this case, it is really too late ...
void ewol::resource::Manager::contextHasBeenDestroyed() {
for (auto &it : m_resourceList) {
if (it != nullptr) {
it->removeContextToLate();
std::shared_ptr<ewol::Resource> tmpRessource = it.lock();
if (tmpRessource != nullptr) {
tmpRessource->removeContextToLate();
}
}
// no context preent ...
@ -147,12 +153,13 @@ void ewol::resource::Manager::contextHasBeenDestroyed() {
}
// internal generic keeper ...
ewol::object::Shared<ewol::Resource> ewol::resource::Manager::localKeep(const std::string& _filename) {
std::shared_ptr<ewol::Resource> ewol::resource::Manager::localKeep(const std::string& _filename) {
EWOL_VERBOSE("KEEP (DEFAULT) : file : \"" << _filename << "\"");
for (auto &it : m_resourceList) {
if ( it != nullptr
&& it->getName() == _filename) {
return it;
std::shared_ptr<ewol::Resource> tmpRessource = it.lock();
if ( tmpRessource != nullptr
&& tmpRessource->getName() == _filename) {
return tmpRessource;
}
}
// we did not find it ...
@ -160,10 +167,11 @@ ewol::object::Shared<ewol::Resource> ewol::resource::Manager::localKeep(const st
}
// internal generic keeper ...
void ewol::resource::Manager::localAdd(const ewol::object::Shared<ewol::Resource>& _object) {
void ewol::resource::Manager::localAdd(const std::shared_ptr<ewol::Resource>& _object) {
//Add ... find empty slot
for (auto &it : m_resourceList) {
if (it == nullptr) {
std::shared_ptr<ewol::Resource> tmpRessource = it.lock();
if (tmpRessource == nullptr) {
it = _object;
return;
}
@ -177,16 +185,11 @@ bool ewol::resource::Manager::checkResourceToRemove() {
//EWOL_INFO("remove object in Manager");
updateContext();
for (auto it(m_resourceList.begin()); it!=m_resourceList.end(); ++it) {
if ((*it) == nullptr) {
if ((*it).lock() == nullptr) {
m_resourceList.erase(it);
it = m_resourceList.begin();
continue;
}
// 1 in object list, 1 in reference active list, and one here
if ((*it)->getRefCount() > 3) {
continue;
}
EWOL_DEBUG("Request remove of an resource (refcount in Low : " << (*it)->getRefCount() << ")");
m_resourceList.erase(it);
it = m_resourceList.begin();
return true;

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

@ -20,8 +20,8 @@ namespace ewol {
namespace resource {
class Manager{
private:
std::list<ewol::object::Owner<ewol::Resource>> m_resourceList;
std::vector<ewol::object::Shared<ewol::Resource>> m_resourceListToUpdate;
std::list<std::weak_ptr<ewol::Resource>> m_resourceList;
std::vector<std::shared_ptr<ewol::Resource>> m_resourceListToUpdate;
bool m_contextHasBeenRemoved;
public:
/**
@ -50,7 +50,7 @@ namespace ewol {
* @brief Call by the system to send all the needed data on the graphic card chen they change ...
* @param[in] _object The resources that might be updated
*/
void update(const ewol::object::Shared<ewol::Resource>& _object);
void update(const std::shared_ptr<ewol::Resource>& _object);
/**
* @brief Call by the system chen the openGL Context has been unexpectially removed == > This reload all the texture, VBO and other ....
*/
@ -61,8 +61,8 @@ namespace ewol {
void contextHasBeenDestroyed();
public:
// internal API to extent eResources in extern Soft
ewol::object::Shared<ewol::Resource> localKeep(const std::string& _filename);
void localAdd(const ewol::object::Shared<ewol::Resource>& _object);
std::shared_ptr<ewol::Resource> localKeep(const std::string& _filename);
void localAdd(const std::shared_ptr<ewol::Resource>& _object);
virtual bool checkResourceToRemove();
};
};

41
sources/ewol/resource/Program.cpp
View File

@ -19,14 +19,18 @@
#undef __class__
#define __class__ "resource::Program"
ewol::resource::Program::Program(const std::string& _filename) :
ewol::Resource(_filename),
ewol::resource::Program::Program() :
ewol::Resource(),
m_exist(false),
m_program(0),
m_hasTexture(false),
m_hasTexture1(false) {
addObjectType("ewol::resource::Program");
m_resourceLevel = 1;
}
void ewol::resource::Program::init(const std::string& _filename) {
ewol::Resource::init(_filename);
EWOL_DEBUG("OGL : load PROGRAM '" << m_name << "'");
// load data from file "all the time ..."
@ -36,7 +40,7 @@ ewol::resource::Program::Program(const std::string& _filename) :
std::string tmpFilename = m_name;
// remove extention ...
tmpFilename.erase(tmpFilename.size()-4, 4);
ewol::object::Shared<ewol::resource::Shader> tmpShader = ewol::resource::Shader::keep(tmpFilename+"vert");
std::shared_ptr<ewol::resource::Shader> tmpShader = ewol::resource::Shader::create(tmpFilename+"vert");
if (nullptr == tmpShader) {
EWOL_CRITICAL("Error while getting a specific shader filename : " << tmpFilename);
return;
@ -44,7 +48,7 @@ ewol::resource::Program::Program(const std::string& _filename) :
EWOL_DEBUG("Add shader on program : "<< tmpFilename << "vert");
m_shaderList.push_back(tmpShader);
}
tmpShader = ewol::resource::Shader::keep(tmpFilename+"frag");
tmpShader = ewol::resource::Shader::create(tmpFilename+"frag");
if (nullptr == tmpShader) {
EWOL_CRITICAL("Error while getting a specific shader filename : " << tmpFilename);
return;
@ -80,7 +84,7 @@ ewol::resource::Program::Program(const std::string& _filename) :
}
// get it with relative position :
std::string tmpFilename = file.getRelativeFolder() + tmpData;
ewol::object::Shared<ewol::resource::Shader> tmpShader = ewol::resource::Shader::keep(tmpFilename);
std::shared_ptr<ewol::resource::Shader> tmpShader = ewol::resource::Shader::create(tmpFilename);
if (nullptr == tmpShader) {
EWOL_CRITICAL("Error while getting a specific shader filename : " << tmpFilename);
} else {
@ -327,7 +331,7 @@ void ewol::resource::Program::sendAttribute(int32_t _idElem,
void ewol::resource::Program::sendAttributePointer(int32_t _idElem,
int32_t _nbElement,
const ewol::object::Shared<ewol::resource::VirtualBufferObject>& _vbo,
const std::shared_ptr<ewol::resource::VirtualBufferObject>& _vbo,
int32_t _index,
int32_t _jumpBetweenSample,
int32_t _offset) {
@ -769,28 +773,3 @@ void ewol::resource::Program::unUse() {
//checkGlError("glUseProgram", __LINE__);
}
ewol::object::Shared<ewol::resource::Program> ewol::resource::Program::keep(const std::string& _filename) {
EWOL_VERBOSE("KEEP : Program : file : \"" << _filename << "\"");
ewol::object::Shared<ewol::resource::Program> object = nullptr;
ewol::object::Shared<ewol::Resource> object2 = getManager().localKeep(_filename);
if (nullptr != object2) {
object = ewol::dynamic_pointer_cast<ewol::resource::Program>(object2);
if (nullptr == object) {
EWOL_CRITICAL("Request resource file : '" << _filename << "' With the wrong type (dynamic cast error)");
return nullptr;
}
}
if (nullptr != object) {
return object;
}
// need to crate a new one ...
object = ewol::object::makeShared(new ewol::resource::Program(_filename));
if (nullptr == object) {
EWOL_ERROR("allocation error of a resource : " << _filename);
return nullptr;
}
getManager().localAdd(object);
return object;
}

16
sources/ewol/resource/Program.h
View File

@ -50,7 +50,7 @@ namespace ewol {
private :
bool m_exist; //!< the file existed
GLuint m_program; //!< openGL id of the current program
std::vector<ewol::object::Shared<ewol::resource::Shader>> m_shaderList; //!< List of all the shader loaded
std::vector<std::shared_ptr<ewol::resource::Shader>> m_shaderList; //!< List of all the shader loaded
std::vector<ewol::resource::progAttributeElement> m_elementList; //!< List of all the attribute requested by the user
bool m_hasTexture; //!< A texture has been set to the current shader
bool m_hasTexture1; //!< A texture has been set to the current shader
@ -59,8 +59,10 @@ namespace ewol {
* @brief Contructor of an opengl Program.
* @param[in] filename Standard file name format. see @ref etk::FSNode
*/
Program(const std::string& filename);
Program();
void init(const std::string& _filename);
public:
DECLARE_RESOURCE_NAMED_FACTORY(Program);
/**
* @brief Destructor, remove the current Program.
*/
@ -86,7 +88,7 @@ namespace ewol {
int32_t _jumpBetweenSample=0);
void sendAttributePointer(int32_t _idElem,
int32_t _nbElement,
const ewol::object::Shared<ewol::resource::VirtualBufferObject>& _vbo,
const std::shared_ptr<ewol::resource::VirtualBufferObject>& _vbo,
int32_t _index,
int32_t _jumpBetweenSample=0,
int32_t _offset=0);
@ -293,14 +295,6 @@ namespace ewol {
* @note this is really usefull when we tested the new themes or shader developpements.
*/
void reload();
public:
/**
* @brief keep the resource pointer.
* @note Never free this pointer by your own...
* @param[in] _filename Name of the openGL program.
* @return pointer on the resource or nullptr if an error occured.
*/
static ewol::object::Shared<ewol::resource::Program> keep(const std::string& _filename);
};
};
};

15
sources/ewol/resource/Resource.cpp
View File

@ -13,21 +13,28 @@
#include <ewol/ewol.h>
#include <ewol/context/Context.h>
void ewol::Resource::init() {
ewol::Object::init();
}
void ewol::Resource::init(const std::string& _name) {
ewol::Object::init(_name);
}
void ewol::Resource::updateContext() {
EWOL_DEBUG("Not set for : [" << getId() << "]" << getName() << " loaded " << getRefCount() << " time(s)");
EWOL_DEBUG("Not set for : [" << getId() << "]" << getName() << " loaded " << shared_from_this().use_count() << " time(s)");
}
void ewol::Resource::removeContext() {
EWOL_DEBUG("Not set for : [" << getId() << "]" << getName() << " loaded " << getRefCount() << " time(s)");
EWOL_DEBUG("Not set for : [" << getId() << "]" << getName() << " loaded " << shared_from_this().use_count() << " time(s)");
}
void ewol::Resource::removeContextToLate() {
EWOL_DEBUG("Not set for : [" << getId() << "]" << getName() << " loaded " << getRefCount() << " time(s)");
EWOL_DEBUG("Not set for : [" << getId() << "]" << getName() << " loaded " << shared_from_this().use_count() << " time(s)");
}
void ewol::Resource::reload() {
EWOL_DEBUG("Not set for : [" << getId() << "]" << getName() << " loaded " << getRefCount() << " time(s)");
EWOL_DEBUG("Not set for : [" << getId() << "]" << getName() << " loaded " << shared_from_this().use_count() << " time(s)");
}
ewol::resource::Manager& ewol::Resource::getManager() {

83
sources/ewol/resource/Resource.h
View File

@ -17,24 +17,91 @@
#define MAX_RESOURCE_LEVEL (5)
#define DECLARE_RESOURCE_FACTORY(className) \
template<typename ... T> static std::shared_ptr<className> create( T&& ... all ) { \
std::shared_ptr<className> object(new className()); \
if (object == nullptr) { \
EWOL_ERROR("Factory resource error"); \
return nullptr; \
} \
object->init(std::forward<T>(all)... ); \
if (object->objectHasBeenCorectlyInit() == false) { \
EWOL_CRITICAL("Object Is not correctly init : " << #className ); \
} \
getManager().localAdd(object); \
return object; \
}
#define DECLARE_RESOURCE_NAMED_FACTORY(className) \
template<typename ... T> static std::shared_ptr<className> create(const std::string& _name, T&& ... all ) { \
std::shared_ptr<className> object; \
std::shared_ptr<ewol::Resource> object2 = getManager().localKeep(_name); \
if (object2 != nullptr) { \
object = std::dynamic_pointer_cast<className>(object2); \
if (object == nullptr) { \
EWOL_CRITICAL("Request resource file : '" << _name << "' With the wrong type (dynamic cast error)"); \
return nullptr; \
} \
} \
if (object != nullptr) { \
return object; \
} \
object = std::shared_ptr<className>(new className()); \
if (object == nullptr) { \
EWOL_ERROR("allocation error of a resource : " << _name); \
return nullptr; \
} \
object->init(_name, std::forward<T>(all)... ); \
if (object->objectHasBeenCorectlyInit() == false) { \
EWOL_CRITICAL("Object Is not correctly init : " << #className ); \
} \
getManager().localAdd(object); \
return object; \
}
#define DECLARE_RESOURCE_SINGLE_FACTORY(className,uniqueName) \
template<typename ... T> static std::shared_ptr<className> create(T&& ... all ) { \
std::shared_ptr<className> object; \
std::shared_ptr<ewol::Resource> object2 = getManager().localKeep(uniqueName); \
if (object2 != nullptr) { \
object = std::dynamic_pointer_cast<className>(object2); \
if (object == nullptr) { \
EWOL_CRITICAL("Request resource file : '" << uniqueName << "' With the wrong type (dynamic cast error)"); \
return nullptr; \
} \
} \
if (object != nullptr) { \
return object; \
} \
object = std::shared_ptr<className>(new className()); \
if (object == nullptr) { \
EWOL_ERROR("allocation error of a resource : " << uniqueName); \
return nullptr; \
} \
object->init(uniqueName, std::forward<T>(all)... ); \
if (object->objectHasBeenCorectlyInit() == false) { \
EWOL_CRITICAL("Object Is not correctly init : " << #className ); \
} \
getManager().localAdd(object); \
return object; \
}
namespace ewol {
namespace resource {
class Manager;
};
// class resources is pure virtual
class Resource : public ewol::Object {
public:
protected:
Resource() :
m_resourceLevel(MAX_RESOURCE_LEVEL-1) {
addObjectType("ewol::Resource");
setStatusResource(true);
};
Resource(const std::string& _name) :
ewol::Object(_name),
m_resourceLevel(MAX_RESOURCE_LEVEL-1) {
addObjectType("ewol::Resource");
setStatusResource(true);
};
void init();
void init(const std::string& _name);
public:
virtual ~Resource() {
};
@ -52,7 +119,7 @@ namespace ewol {
};
};
#include <ewol/resource/Manager.h>
#endif

31
sources/ewol/resource/Shader.cpp
View File

@ -15,14 +15,18 @@
#undef __class__
#define __class__ "resource::Shader"
ewol::resource::Shader::Shader(const std::string& _filename) :
ewol::Resource(_filename),
ewol::resource::Shader::Shader() :
ewol::Resource(),
m_exist(false),
m_fileData(nullptr),
m_shader(0),
m_type(0) {
addObjectType("ewol::Shader");
m_resourceLevel = 0;
}
void ewol::resource::Shader::init(const std::string& _filename) {
ewol::Resource::init(_filename);
EWOL_DEBUG("OGL : load SHADER \"" << _filename << "\"");
// load data from file "all the time ..."
@ -149,26 +153,3 @@ void ewol::resource::Shader::reload() {
updateContext();
}
ewol::object::Shared<ewol::resource::Shader> ewol::resource::Shader::keep(const std::string& _filename) {
EWOL_VERBOSE("KEEP : Simpleshader : file : \"" << _filename << "\"");
ewol::object::Shared<ewol::resource::Shader> object = nullptr;
ewol::object::Shared<ewol::Resource> object2 = getManager().localKeep(_filename);
if (nullptr != object2) {
object = ewol::dynamic_pointer_cast<ewol::resource::Shader>(object2);
if (nullptr == object) {
EWOL_CRITICAL("Request resource file : '" << _filename << "' With the wrong type (dynamic cast error)");
return nullptr;
}
}
if (nullptr != object) {
return object;
}
// need to crate a new one ...
object = ewol::object::makeShared(new ewol::resource::Shader(_filename));
if (nullptr == object) {
EWOL_ERROR("allocation error of a resource : " << _filename);
return nullptr;
}
getManager().localAdd(object);
return object;
}

12
sources/ewol/resource/Shader.h
View File

@ -30,8 +30,10 @@ namespace ewol {
* @brief Contructor of an opengl Shader
* @param[in] filename Standard file name format. see @ref etk::FSNode
*/
Shader(const std::string& _filename);
Shader();
public:
void init(const std::string& _filename);
DECLARE_RESOURCE_NAMED_FACTORY(Shader);
/**
* @brief Destructor, remove the current Shader
*/
@ -68,14 +70,6 @@ namespace ewol {
* @note this is really usefull when we tested the new themes or shader developpements.
*/
void reload();
public:
/**
* @brief keep the resource pointer.
* @note Never free this pointer by your own...
* @param[in] _filename Name of the openGL Shader.
* @return pointer on the resource or nullptr if an error occured.
*/
static ewol::object::Shared<ewol::resource::Shader> keep(const std::string& _filename);
};
};
};

25
sources/ewol/resource/Texture.cpp
View File

@ -33,12 +33,11 @@ static int32_t nextP2(int32_t _value) {
}
ewol::resource::Texture::Texture(const std::string& _filename) :
ewol::Resource(_filename) {
addObjectType("ewol::resource::Texture");
m_loaded = false;
m_texId = 0;
m_endPointSize.setValue(1.0,1.0);
void ewol::resource::Texture::init(const std::string& _filename) {
ewol::Resource::init(_filename);
}
void ewol::resource::Texture::init() {
ewol::Resource::init();
}
ewol::resource::Texture::Texture() {
@ -99,22 +98,10 @@ void ewol::resource::Texture::removeContextToLate() {
void ewol::resource::Texture::flush() {
// request to the manager to be call at the next update ...
getManager().update(this);
getManager().update(std::dynamic_pointer_cast<ewol::Resource>(shared_from_this()));
}
void ewol::resource::Texture::setImageSize(ivec2 _newSize) {
_newSize.setValue( nextP2(_newSize.x()), nextP2(_newSize.y()) );
m_data.resize(_newSize);
}
ewol::object::Shared<ewol::resource::Texture> ewol::resource::Texture::keep() {
// this element create a new one every time ....
ewol::object::Shared<ewol::resource::Texture> object = ewol::object::makeShared(new ewol::resource::Texture());
if (nullptr == object) {
EWOL_ERROR("allocation error of a resource : ??TEX??");
return nullptr;
}
getManager().localAdd(object);
return object;
}

11
sources/ewol/resource/Texture.h
View File

@ -45,9 +45,11 @@ namespace ewol {
};
// Public API:
protected:
Texture(const std::string& _filename);
void init(const std::string& _filename);
void init();
Texture();
public:
DECLARE_RESOURCE_FACTORY(Texture);
virtual ~Texture();
public:
// you must set the size here, because it will be set in multiple of pow(2)
@ -58,13 +60,6 @@ namespace ewol {
};
// flush the data to send it at the openGl system
void flush();
public:
/**
* @brief keep the resource pointer.
* @note Never free this pointer by your own...
* @return pointer on the resource or nullptr if an error occured.
*/
static ewol::object::Shared<ewol::resource::Texture> keep();
};
};
};

33
sources/ewol/resource/TexturedFont.cpp
View File

@ -42,9 +42,12 @@ std::ostream& ewol::operator <<(std::ostream& _os, enum ewol::font::mode _obj) {
#undef __class__
#define __class__ "resource::TexturedFont"
ewol::resource::TexturedFont::TexturedFont(const std::string& _fontName) :
ewol::resource::Texture(_fontName) {
ewol::resource::TexturedFont::TexturedFont() {
addObjectType("ewol::resource::TexturedFont");
}
void ewol::resource::TexturedFont::init(const std::string& _fontName) {
ewol::resource::Texture::init(_fontName);
EWOL_DEBUG("Load font : '" << _fontName << "'" );
m_font[0] = nullptr;
@ -192,7 +195,7 @@ ewol::resource::TexturedFont::TexturedFont(const std::string& _fontName) :
continue;
}
EWOL_INFO("Load FONT [" << iiiFontId << "] name : \"" << m_fileName[iiiFontId] << "\" == > size=" << m_size);
m_font[iiiFontId] = ewol::resource::FontFreeType::keep(m_fileName[iiiFontId]);
m_font[iiiFontId] = ewol::resource::FontFreeType::create(m_fileName[iiiFontId]);
if (m_font[iiiFontId] == nullptr) {
EWOL_DEBUG("error in loading FONT [" << iiiFontId << "] name : \"" << m_fileName[iiiFontId] << "\" == > size=" << m_size );
}
@ -341,27 +344,3 @@ ewol::GlyphProperty* ewol::resource::TexturedFont::getGlyphPointer(const char32_
return &((m_listElement[_displayMode])[index]);
}
ewol::object::Shared<ewol::resource::TexturedFont> ewol::resource::TexturedFont::keep(const std::string& _filename) {
EWOL_VERBOSE("KEEP : TexturedFont : file : '" << _filename << "'");
ewol::object::Shared<ewol::resource::TexturedFont> object;
ewol::object::Shared<ewol::Resource> object2 = getManager().localKeep(_filename);
if (nullptr != object2) {
object = ewol::dynamic_pointer_cast<ewol::resource::TexturedFont>(object2);
if (nullptr == object) {
EWOL_CRITICAL("Request resource file : '" << _filename << "' With the wrong type (dynamic cast error)");
return nullptr;
}
}
if (nullptr != object) {
return object;
}
// need to crate a new one ...
EWOL_INFO("CREATE: TexturedFont : file : '" << _filename << "'");
object = ewol::object::makeShared(new ewol::resource::TexturedFont(_filename));
if (nullptr == object) {
EWOL_ERROR("allocation error of a resource : " << _filename);
return nullptr;
}
getManager().localAdd(object);
return object;
}

14
sources/ewol/resource/TexturedFont.h
View File

@ -36,7 +36,7 @@ namespace ewol {
// specific element to have the the know if the specify element is known...
// == > otherwise I can just generate italic ...
// == > Bold is a little more complicated (maybe with the bordersize)
ewol::object::Shared<ewol::resource::FontBase> m_font[4];
std::shared_ptr<ewol::resource::FontBase> m_font[4];
enum ewol::font::mode m_modeWraping[4]; //!< This is a wrapping mode to prevent the fact that no font is define for a specific mode
public:
std::vector<GlyphProperty> m_listElement[4];
@ -45,8 +45,10 @@ namespace ewol {
ivec2 m_lastGlyphPos[4];
int32_t m_lastRawHeigh[4];
protected:
TexturedFont(const std::string& _fontName);
TexturedFont();
void init(const std::string& _fontName);
public:
DECLARE_RESOURCE_NAMED_FACTORY(TexturedFont);
virtual ~TexturedFont();
public:
/**
@ -87,14 +89,6 @@ namespace ewol {
enum ewol::font::mode getWrappingMode(const enum ewol::font::mode _source) {
return m_modeWraping[_source];
};
public:
/**
* @brief keep the resource pointer.
* @note Never free this pointer by your own...
* @param[in] _filename Name of the texture font.
* @return pointer on the resource or nullptr if an error occured.
*/
static ewol::object::Shared<ewol::resource::TexturedFont> keep(const std::string& _filename);
private:
/**
* @brief add a glyph in a texture font.

24
sources/ewol/resource/VirtualBufferObject.cpp
View File

@ -14,18 +14,21 @@
#undef __class__
#define __class__ "resource::VirtualBufferObject"
ewol::resource::VirtualBufferObject::VirtualBufferObject(int32_t _number) :
m_exist(false) {
addObjectType("ewol::VirtualBufferObject");
void ewol::resource::VirtualBufferObject::init(int32_t _number) {
ewol::Resource::init();
m_nbVBO = std::avg(1, _number, NB_VBO_MAX);
for (size_t iii=0; iii<NB_VBO_MAX; iii++) {
m_vbo[iii]=0;
m_vboUsed[iii]=false;
}
m_resourceLevel = 3;
EWOL_DEBUG("OGL : load VBO count=\"" << _number << "\"");
}
ewol::resource::VirtualBufferObject::VirtualBufferObject() {
addObjectType("ewol::VirtualBufferObject");
m_resourceLevel = 3;
}
ewol::resource::VirtualBufferObject::~VirtualBufferObject() {
removeContext();
}
@ -82,7 +85,7 @@ void ewol::resource::VirtualBufferObject::reload() {
void ewol::resource::VirtualBufferObject::flush() {
// request to the manager to be call at the next update ...
getManager().update(this);
getManager().update(std::dynamic_pointer_cast<ewol::Resource>(shared_from_this()));
}
void ewol::resource::VirtualBufferObject::pushOnBuffer(int32_t _id, const vec3& _data) {
@ -122,14 +125,3 @@ vec2 ewol::resource::VirtualBufferObject::getOnBufferVec2(int32_t _id, int32_t _
int32_t ewol::resource::VirtualBufferObject::sizeOnBufferVec2(int32_t _id) {
return m_buffer[_id].size()/2;
}
ewol::object::Shared<ewol::resource::VirtualBufferObject> ewol::resource::VirtualBufferObject::keep(int32_t _number) {
// this element create a new one every time ....
ewol::object::Shared<ewol::resource::VirtualBufferObject> object = ewol::object::makeShared(new ewol::resource::VirtualBufferObject(_number));
if (nullptr == object) {
EWOL_ERROR("allocation error of a resource : ??VBO??");
return nullptr;
}
getManager().localAdd(object);
return object;
}

12
sources/ewol/resource/VirtualBufferObject.h
View File

@ -34,8 +34,10 @@ namespace ewol {
* @brief Constructor of this VBO.
* @param[in] accesMode Acces mode : ???
*/
VirtualBufferObject(int32_t _number);
VirtualBufferObject();
void init(int32_t _number);
public:
DECLARE_RESOURCE_FACTORY(VirtualBufferObject);
/**
* @brief Destructor of this VBO.
*/
@ -93,14 +95,6 @@ namespace ewol {
* @note this is really usefull when we tested the new themes or shader developpements.
*/
void reload();
public:
/**
* @brief keep the resource pointer.
* @note Never free this pointer by your own...
* @param[in] _number Number of VBO needed
* @return pointer on the resource or nullptr if an error occured.
*/
static ewol::object::Shared<ewol::resource::VirtualBufferObject> keep(int32_t _number);
};
};
};

7
sources/ewol/resource/font/FontBase.h
View File

@ -22,7 +22,12 @@ namespace ewol {
namespace resource {
class FontBase : public ewol::Resource {
public:
FontBase(const std::string& _fontName) : ewol::Resource(_fontName) {};
FontBase() {
addObjectType("ewol::FontFreeType");
}
void init(const std::string& _fontName) {
ewol::Resource::init(_fontName);
};
virtual ~FontBase() { };

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

@ -34,17 +34,7 @@ const char* const ewol::widget::Button::configShaper = "shaper";
#define STATUS_PRESSED (1)
#define STATUS_DOWN (3)
static ewol::Widget* create() {
return new ewol::widget::Button();
}
void ewol::widget::Button::init(ewol::widget::Manager& _widgetManager) {
_widgetManager.addWidgetCreator(__class__, &create);
}
ewol::widget::Button::Button(const std::string& _shaperName) :
m_shaper(_shaperName),
ewol::widget::Button::Button() :
m_value(false),
m_lock(ewol::widget::Button::lockNone),
m_toggleMode(false),
@ -76,6 +66,11 @@ ewol::widget::Button::Button(const std::string& _shaperName) :
setMouseLimit(1);
}
void ewol::widget::Button::init(const std::string& _shaperName) {
ewol::widget::Container2::init();
m_shaper.setSource(_shaperName);
}
ewol::widget::Button::~Button() {

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

@ -27,8 +27,6 @@ namespace ewol {
*/
class Button : public ewol::widget::Container2 {
public:
//! @not-in-doc
static void init(ewol::widget::Manager& _widgetManager);
// Event list of properties
static const char* const eventPressed;
static const char* const eventDown;
@ -50,12 +48,15 @@ namespace ewol {
};
private:
ewol::compositing::Shaper m_shaper; //!< Compositing theme.
public:
protected:
/**
* @brief Constructor
* @param[in] _shaperName Shaper file properties
*/
Button(const std::string& _shaperName="THEME:GUI:Button.json");
Button();
void init(const std::string& _shaperName="THEME:GUI:Button.json");
public:
DECLARE_WIDGET_FACTORY(Button, "Button");
/**
* @brief Destructor
*/

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

@ -30,17 +30,8 @@ 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();
}
void ewol::widget::ButtonColor::init(ewol::widget::Manager& _widgetManager) {
_widgetManager.addWidgetCreator(__class__, &create);
}
ewol::widget::ButtonColor::ButtonColor(etk::Color<> _baseColor, std::string _shaperName) :
m_shaper(_shaperName),
m_textColorFg(_baseColor),
ewol::widget::ButtonColor::ButtonColor() :
m_textColorFg(etk::color::black),
m_widgetContextMenu(nullptr) {
addObjectType("ewol::widget::ButtonColor");
addEventId(eventChange);
@ -50,6 +41,11 @@ ewol::widget::ButtonColor::ButtonColor(etk::Color<> _baseColor, std::string _sha
setMouseLimit(1);
}
void ewol::widget::ButtonColor::init(etk::Color<> _baseColor, std::string _shaperName) {
ewol::Widget::init();
m_shaper.setSource(_shaperName);
m_textColorFg = _baseColor;
}
ewol::widget::ButtonColor::~ButtonColor() {
@ -176,7 +172,7 @@ 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 = std::make_shared<ewol::widget::ContextMenu>();
if (nullptr == m_widgetContextMenu) {
EWOL_ERROR("Allocation Error");
return true;
@ -185,17 +181,17 @@ bool ewol::widget::ButtonColor::onEventInput(const ewol::event::Input& _event) {
tmpPos.setX( tmpPos.x() - m_minSize.x()/2.0);
m_widgetContextMenu->setPositionMark(ewol::widget::ContextMenu::markButtom, tmpPos );
ewol::widget::ColorChooser * myColorChooser = new widget::ColorChooser();
std::shared_ptr<ewol::widget::ColorChooser> myColorChooser = widget::ColorChooser::create();
myColorChooser->setColor(m_textColorFg);
// set it in the pop-up-system :
m_widgetContextMenu->setSubWidget(myColorChooser);
myColorChooser->registerOnEvent(this, "change", eventColorHasChange);
ewol::object::Shared<ewol::widget::Windows> currentWindows = getWindows();
myColorChooser->registerOnEvent(shared_from_this(), "change", eventColorHasChange);
std::shared_ptr<ewol::widget::Windows> currentWindows = getWindows();
if (currentWindows == nullptr) {
EWOL_ERROR("Can not get the curent Windows...");
m_widgetContextMenu.reset();
} else {
currentWindows->popUpWidgetPush(m_widgetContextMenu.get());
currentWindows->popUpWidgetPush(m_widgetContextMenu);
}
markToRedraw();
}

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

@ -24,25 +24,26 @@ namespace ewol {
public:
// Event list of properties
static const char * const eventChange;
public:
static void init(ewol::widget::Manager& _widgetManager);
private:
ewol::compositing::Shaper m_shaper; //!< Compositing theme.
ewol::compositing::Text m_text; //!< Compositing Test display.
etk::Color<> m_textColorFg; //!< Current color.
ewol::object::Shared<ewol::widget::ContextMenu> m_widgetContextMenu; //!< Specific context menu.
std::shared_ptr<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 :
vec2 m_selectableAreaPos; //!< Start position of the events
vec2 m_selectableAreaSize; //!< size of the event positions
public:
protected:
/**
* @brief Main constructor.
* @param[in] _baseColor basic displayed color.
* @param[in] _shaperName The new shaper filename.
*/
ButtonColor(etk::Color<> _baseColor=etk::color::black, std::string _shaperName="THEME:GUI:widgetButton.json");
ButtonColor();
void init(etk::Color<> _baseColor=etk::color::black, std::string _shaperName="THEME:GUI:widgetButton.json");
public:
DECLARE_WIDGET_FACTORY(ButtonColor, "ButtonColor");
/**
* @brief Main destructor.
*/

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

@ -27,16 +27,8 @@ const char* const ewol::widget::CheckBox::configShaper = "shaper";
#undef __class__
#define __class__ "CheckBox"
static ewol::Widget* create() {
return new ewol::widget::CheckBox();
}
void ewol::widget::CheckBox::init(ewol::widget::Manager& _widgetManager) {
_widgetManager.addWidgetCreator(__class__, &create);
}
ewol::widget::CheckBox::CheckBox(const std::string& _shaperName) :
m_shaper(_shaperName),
ewol::widget::CheckBox::CheckBox() :
m_mouseHover(false),
m_buttonPressed(false),
m_selectableAreaPos(0,0),
@ -67,6 +59,11 @@ ewol::widget::CheckBox::CheckBox(const std::string& _shaperName) :
}
void ewol::widget::CheckBox::init(const std::string& _shaperName) {
ewol::widget::Container2::init();
m_shaper.setSource(_shaperName);
}
ewol::widget::CheckBox::~CheckBox() {
}

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

@ -20,8 +20,6 @@ namespace ewol {
namespace widget {
class CheckBox : public ewol::widget::Container2 {
public:
//! @not-in-doc
static void init(ewol::widget::Manager& _widgetManager);
// Event list of properties
static const char* const eventPressed;
static const char* const eventDown;
@ -41,12 +39,15 @@ namespace ewol {
// shaper ids:
int32_t m_shaperIdSize;
int32_t m_shaperIdSizeInsize;
public:
protected:
/**
* @brief Main checkbox constructor
* @param[in] _shaperName Shaper file properties
*/
CheckBox(const std::string& _shaperName="THEME:GUI:CheckBox.json");
CheckBox();
void init(const std::string& _shaperName="THEME:GUI:CheckBox.json");
public:
DECLARE_WIDGET_FACTORY(CheckBox, "CheckBox");
/**
* @brief main destructor.
*/

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

@ -29,6 +29,10 @@ ewol::widget::ColorBar::ColorBar() {
setMouseLimit(1);
}
void ewol::widget::ColorBar::init() {
ewol::Widget::init();
}
ewol::widget::ColorBar::~ColorBar() {
}

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

@ -22,8 +22,11 @@ namespace ewol {
public:
// Event list of properties
static const char * const eventChange;
public:
protected:
ColorBar();
void init();
public:
DECLARE_WIDGET_FACTORY(ColorBar, "ColorBar");
virtual ~ColorBar();
etk::Color<> getCurrentColor();
void setCurrentColor(etk::Color<> _newOne);

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

@ -15,17 +15,13 @@
#undef __class__
#define __class__ "ewol::widget::Composer"
#include <ewol/widget/Manager.h>
void ewol::widget::Composer::init(ewol::widget::Manager& _widgetManager) {
_widgetManager.addWidgetCreator("Composer",[]() -> ewol::Widget* { return new ewol::widget::Composer(); });
}
ewol::widget::Composer::Composer() {
addObjectType("ewol::widget::Composer");
// nothing to do ...
}
ewol::widget::Composer::Composer(enum composerMode _mode, const std::string& _fileName) {
addObjectType("ewol::widget::Composer");
void ewol::widget::Composer::init(enum composerMode _mode, const std::string& _fileName) {
ewol::widget::Container::init();
switch(_mode) {
case ewol::widget::Composer::None:
// nothing to do ...
@ -98,16 +94,16 @@ void ewol::widget::Composer::registerOnEventNameWidget(const std::string& _subWi
const char * _eventId,
const char * _eventIdgenerated,
const std::string& _overloadData) {
registerOnEventNameWidget(this, _subWidgetName, _eventId, _eventIdgenerated, _overloadData);
registerOnEventNameWidget(shared_from_this(), _subWidgetName, _eventId, _eventIdgenerated, _overloadData);
}
void ewol::widget::Composer::registerOnEventNameWidget(const ewol::object::Shared<ewol::Object>& _destinationObject,
void ewol::widget::Composer::registerOnEventNameWidget(const std::shared_ptr<ewol::Object>& _destinationObject,
const std::string& _subWidgetName,
const char * _eventId,
const char * _eventIdgenerated,
const std::string& _overloadData) {
ewol::object::Shared<ewol::Widget> tmpWidget = getWidgetNamed(_subWidgetName);
if (nullptr != tmpWidget) {
std::shared_ptr<ewol::Widget> tmpWidget = getWidgetNamed(_subWidgetName);
if (tmpWidget != nullptr) {
EWOL_DEBUG("Find widget named : \"" << _subWidgetName << "\" register event=\"" << _eventId << "\"");
tmpWidget->registerOnEvent(_destinationObject, _eventId, _eventIdgenerated, _overloadData);
} else {

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

@ -20,15 +20,13 @@ namespace ewol {
* @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 {
public:
static void init(ewol::widget::Manager& _widgetManager);
public:
enum composerMode {
None,
String,
file
};
public:
protected:
/**
* @brief Constructor
*/
@ -38,7 +36,9 @@ namespace ewol {
* @param[in] _mode mode of parsing the string
* @param[in] _data file/directString data to generate compositing of the widget..
*/
Composer(enum composerMode _mode, const std::string& _data);
void init(enum composerMode _mode = ewol::widget::Composer::None, const std::string& _data = "");
public:
DECLARE_WIDGET_FACTORY(Composer, "Composer");
/**
* @brief Destructor
*/
@ -80,7 +80,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(const ewol::object::Shared<ewol::Object>& _destinationObject,
void registerOnEventNameWidget(const std::shared_ptr<ewol::Object>& _destinationObject,
const std::string& _subWidgetName,
const char * _eventId,
const char * _eventIdgenerated = nullptr,

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

@ -16,37 +16,41 @@
#define __class__ "Container"
ewol::widget::Container::Container(ewol::object::Shared<ewol::Widget> _subElement) :
m_subWidget(_subElement) {
ewol::widget::Container::Container() {
addObjectType("ewol::widget::Container");
// nothing to do ...
}
void ewol::widget::Container::init(std::shared_ptr<ewol::Widget> _subElement) {
ewol::Widget::init();
m_subWidget = _subElement;
}
ewol::widget::Container::~Container() {
subWidgetRemove();
}
ewol::object::Shared<ewol::Widget> ewol::widget::Container::getSubWidget() {
std::shared_ptr<ewol::Widget> ewol::widget::Container::getSubWidget() {
return m_subWidget;
}
void ewol::widget::Container::setSubWidget(ewol::object::Shared<ewol::Widget> _newWidget) {
if (nullptr == _newWidget) {
void ewol::widget::Container::setSubWidget(std::shared_ptr<ewol::Widget> _newWidget) {
if (_newWidget == nullptr) {
return;
}
subWidgetRemove();
m_subWidget = _newWidget;
if (m_subWidget!=nullptr) {
m_subWidget->setUpperWidget(this);
if (m_subWidget != nullptr) {
m_subWidget->setParent(shared_from_this());
}
markToRedraw();
requestUpdateSize();
}
void ewol::widget::Container::subWidgetRemove() {
if (nullptr != m_subWidget) {
m_subWidget->removeUpperWidget();
m_subWidget->removeObject();
if (m_subWidget != nullptr) {
m_subWidget->removeParent();
m_subWidget.reset();
markToRedraw();
requestUpdateSize();
@ -54,14 +58,14 @@ void ewol::widget::Container::subWidgetRemove() {
}
void ewol::widget::Container::subWidgetUnLink() {
if (nullptr != m_subWidget) {
m_subWidget->removeUpperWidget();
if (m_subWidget != nullptr) {
m_subWidget->removeParent();
}
m_subWidget.reset();
}
ewol::object::Shared<ewol::Widget> ewol::widget::Container::getWidgetNamed(const std::string& _widgetName) {
ewol::object::Shared<ewol::Widget> tmpUpperWidget = ewol::Widget::getWidgetNamed(_widgetName);
std::shared_ptr<ewol::Widget> ewol::widget::Container::getWidgetNamed(const std::string& _widgetName) {
std::shared_ptr<ewol::Widget> tmpUpperWidget = ewol::Widget::getWidgetNamed(_widgetName);
if (nullptr!=tmpUpperWidget) {
return tmpUpperWidget;
}
@ -71,7 +75,7 @@ ewol::object::Shared<ewol::Widget> ewol::widget::Container::getWidgetNamed(const
return nullptr;
}
void ewol::widget::Container::onObjectRemove(const ewol::object::Shared<ewol::Object>& _object) {
void ewol::widget::Container::onObjectRemove(const std::shared_ptr<ewol::Object>& _object) {
ewol::Widget::onObjectRemove(_object);
if (m_subWidget == _object) {
m_subWidget.reset();
@ -138,7 +142,7 @@ void ewol::widget::Container::onRegenerateDisplay() {
}
}
ewol::object::Shared<ewol::Widget> ewol::widget::Container::getWidgetAtPos(const vec2& _pos) {
std::shared_ptr<ewol::Widget> ewol::widget::Container::getWidgetAtPos(const vec2& _pos) {
if (false == isHide()) {
if (nullptr!=m_subWidget) {
return m_subWidget->getWidgetAtPos(_pos);
@ -174,7 +178,7 @@ bool ewol::widget::Container::loadXML(exml::Element* _node) {
continue;
}
EWOL_DEBUG("try to create subwidget : '" << widgetName << "'");
ewol::object::Shared<ewol::Widget> tmpWidget = getWidgetManager().create(widgetName);
std::shared_ptr<ewol::Widget> tmpWidget = getWidgetManager().create(widgetName);
if (tmpWidget == nullptr) {
EWOL_ERROR ("(l "<<pNode->getPos()<<") Can not create the widget : \"" << widgetName << "\"");
continue;
@ -197,4 +201,14 @@ void ewol::widget::Container::setOffset(const vec2& _newVal) {
}
}
void ewol::widget::Container::requestDestroyFromChild(const std::shared_ptr<Object>& _child) {
if (m_subWidget != _child) {
return;
}
if (m_subWidget == nullptr) {
return;
}
m_subWidget->removeParent();
m_subWidget.reset();
markToRedraw();
}

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

@ -21,12 +21,14 @@ namespace ewol {
*/
class Container : public ewol::Widget {
protected:
ewol::object::Owner<ewol::Widget> m_subWidget;
public:
std::shared_ptr<ewol::Widget> m_subWidget;
protected:
/**
* @brief Constructor
*/
Container(ewol::object::Shared<ewol::Widget> _subElement=nullptr);
Container();
void init(std::shared_ptr<ewol::Widget> _subElement=nullptr);
public:
/**
* @brief Destructor
*/
@ -36,12 +38,12 @@ namespace ewol {
* @brief get the main node widget
* @return the requested pointer on the node
*/
ewol::object::Shared<ewol::Widget> getSubWidget();
std::shared_ptr<ewol::Widget> getSubWidget();
/**
* @brief set the subWidget node widget.
* @param[in] _newWidget The widget to add.
*/
void setSubWidget(ewol::object::Shared<ewol::Widget> _newWidget);
void setSubWidget(std::shared_ptr<ewol::Widget> _newWidget);
/**
* @brief remove the subWidget node (async).
*/
@ -50,17 +52,17 @@ namespace ewol {
* @brief Unlink the subwidget Node.
*/
void subWidgetUnLink();
public: // Derived function
virtual void systemDraw(const ewol::DrawProperty& _displayProp);
virtual void onRegenerateDisplay();
virtual void onObjectRemove(const ewol::object::Shared<ewol::Object>& _object);
virtual void onObjectRemove(const std::shared_ptr<ewol::Object>& _object);
virtual void calculateSize(const vec2& _availlable);
virtual void calculateMinMaxSize();
virtual ewol::object::Shared<ewol::Widget> getWidgetAtPos(const vec2& _pos);
virtual ewol::object::Shared<ewol::Widget> getWidgetNamed(const std::string& _widgetName);
virtual std::shared_ptr<ewol::Widget> getWidgetAtPos(const vec2& _pos);
virtual std::shared_ptr<ewol::Widget> getWidgetNamed(const std::string& _widgetName);
virtual bool loadXML(exml::Element* _node);
virtual void setOffset(const vec2& _newVal);
virtual void requestDestroyFromChild(const std::shared_ptr<Object>& _child);
};
};
};

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

@ -16,25 +16,29 @@
#define __class__ "Container2"
ewol::widget::Container2::Container2(ewol::object::Shared<ewol::Widget> _subElement, ewol::object::Shared<ewol::Widget> _subElementToggle) :
ewol::widget::Container2::Container2() :
m_idWidgetDisplayed(0) {
m_subWidget[0] = _subElement;
m_subWidget[1] = _subElementToggle;
addObjectType("ewol::widget::Container2");
// nothing to do ...
}
void ewol::widget::Container2::init(std::shared_ptr<ewol::Widget> _subElement, std::shared_ptr<ewol::Widget> _subElementToggle) {
ewol::Widget::init();
m_subWidget[0] = _subElement;
m_subWidget[1] = _subElementToggle;
}
ewol::widget::Container2::~Container2() {
subWidgetRemove();
subWidgetRemoveToggle();
}
void ewol::widget::Container2::setSubWidget(ewol::object::Shared<ewol::Widget> _newWidget, int32_t _idWidget) {
void ewol::widget::Container2::setSubWidget(std::shared_ptr<ewol::Widget> _newWidget, int32_t _idWidget) {
subWidgetRemove(_idWidget);
m_subWidget[_idWidget] = _newWidget;
if (m_subWidget[_idWidget] != nullptr) {
EWOL_VERBOSE("Add widget : " << _idWidget);
m_subWidget[_idWidget]->setUpperWidget(this);
m_subWidget[_idWidget]->setParent(shared_from_this());
}
markToRedraw();
requestUpdateSize();
@ -44,7 +48,7 @@ void ewol::widget::Container2::setSubWidget(ewol::object::Shared<ewol::Widget> _
void ewol::widget::Container2::subWidgetRemove(int32_t _idWidget) {
if (m_subWidget[_idWidget] != nullptr) {
EWOL_VERBOSE("Remove widget : " << _idWidget);
m_subWidget[_idWidget]->removeUpperWidget();
m_subWidget[_idWidget]->removeParent();
m_subWidget[_idWidget].reset();
markToRedraw();
requestUpdateSize();
@ -53,14 +57,14 @@ void ewol::widget::Container2::subWidgetRemove(int32_t _idWidget) {
void ewol::widget::Container2::subWidgetUnLink(int32_t _idWidget) {
if (m_subWidget[_idWidget] != nullptr) {
m_subWidget[_idWidget]->removeUpperWidget();
m_subWidget[_idWidget]->removeParent();
EWOL_VERBOSE("Unlink widget : " << _idWidget);
}
m_subWidget[_idWidget].resetShared();
m_subWidget[_idWidget].reset();
}
ewol::object::Shared<ewol::Widget> ewol::widget::Container2::getWidgetNamed(const std::string& _widgetName) {
ewol::object::Shared<ewol::Widget> tmpUpperWidget = ewol::Widget::getWidgetNamed(_widgetName);
std::shared_ptr<ewol::Widget> ewol::widget::Container2::getWidgetNamed(const std::string& _widgetName) {
std::shared_ptr<ewol::Widget> tmpUpperWidget = ewol::Widget::getWidgetNamed(_widgetName);
if (tmpUpperWidget != nullptr) {
return tmpUpperWidget;
}
@ -73,7 +77,7 @@ ewol::object::Shared<ewol::Widget> ewol::widget::Container2::getWidgetNamed(cons
return nullptr;
}
void ewol::widget::Container2::onObjectRemove(const ewol::object::Shared<ewol::Object>& _object) {
void ewol::widget::Container2::onObjectRemove(const std::shared_ptr<ewol::Object>& _object) {
ewol::Widget::onObjectRemove(_object);
if (m_subWidget[0] == _object) {
m_subWidget[0].reset();
@ -173,7 +177,7 @@ void ewol::widget::Container2::onRegenerateDisplay() {
}
}
/*
ewol::object::Shared<ewol::Widget> ewol::widget::Container2::getWidgetAtPos(const vec2& _pos) {
std::shared_ptr<ewol::Widget> ewol::widget::Container2::getWidgetAtPos(const vec2& _pos) {
if (isHide() == false) {
if (m_subWidget[m_idWidgetDisplayed] != nullptr) {
return m_subWidget[m_idWidgetDisplayed]->getWidgetAtPos(_pos);
@ -213,7 +217,7 @@ bool ewol::widget::Container2::loadXML(exml::Element* _node) {
}
}
EWOL_DEBUG("try to create subwidget : '" << widgetName << "'");
ewol::object::Shared<ewol::Widget> tmpWidget = getWidgetManager().create(widgetName);
std::shared_ptr<ewol::Widget> tmpWidget = getWidgetManager().create(widgetName);
if (tmpWidget == nullptr) {
EWOL_ERROR ("(l "<<pNode->getPos()<<") Can not create the widget : \"" << widgetName << "\"");
continue;
@ -240,4 +244,23 @@ void ewol::widget::Container2::setOffset(const vec2& _newVal) {
}
}
void ewol::widget::Container2::requestDestroyFromChild(const std::shared_ptr<Object>& _child) {
if (m_subWidget[0] == _child) {
if (m_subWidget[0] == nullptr) {
return;
}
m_subWidget[0]->removeParent();
m_subWidget[0].reset();
markToRedraw();
}
if (m_subWidget[1] == _child) {
if (m_subWidget[1] == nullptr) {
return;
}
m_subWidget[1]->removeParent();
m_subWidget[1].reset();
markToRedraw();
}
}

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

@ -22,15 +22,17 @@ namespace ewol {
*/
class Container2 : public ewol::Widget {
protected:
ewol::object::Owner<ewol::Widget> m_subWidget[2]; //!< 2 subwidget possible
std::shared_ptr<ewol::Widget> m_subWidget[2]; //!< 2 subwidget possible
int32_t m_idWidgetDisplayed; //!< current widget displayed
public:
protected:
/**
* @brief Constructor
* @param[in] _subElement Widget to set on the normal position
* @param[in] _subElementToggle Widget to set on the toggle position
*/
Container2(ewol::object::Shared<ewol::Widget> _subElement = nullptr, ewol::object::Shared<ewol::Widget> _subElementToggle = nullptr);
Container2();
void init(std::shared_ptr<ewol::Widget> _subElement = nullptr, std::shared_ptr<ewol::Widget> _subElementToggle = nullptr);
public:
/**
* @brief Destructor
*/
@ -41,20 +43,20 @@ namespace ewol {
* @param[in] _subWidget Widget to add normal
* @param[in] _idWidget Id of the widget to set
*/
void setSubWidget(ewol::object::Shared<ewol::Widget> _subWidget, int32_t _idWidget);
void setSubWidget(std::shared_ptr<ewol::Widget> _subWidget, int32_t _idWidget);
public:
/**
* @brief Specify the current widget
* @param[in] _subWidget Widget to add normal
*/
void setSubWidget(ewol::object::Shared<ewol::Widget> _subWidget) {
void setSubWidget(std::shared_ptr<ewol::Widget> _subWidget) {
setSubWidget(_subWidget, 0);
}
/**
* @brief Specify the current toggle widget
* @param[in] _subWidget Widget to add Toggle
*/
void setSubWidgetToggle(ewol::object::Shared<ewol::Widget> _subWidget) {
void setSubWidgetToggle(std::shared_ptr<ewol::Widget> _subWidget) {
setSubWidget(_subWidget, 1);
}
private:
@ -63,7 +65,7 @@ namespace ewol {
* @param[in] _idWidget Id of the widget to set
* @return The base widget
*/
ewol::object::Shared<ewol::Widget> getSubWidget(int32_t _idWidget) const {
std::shared_ptr<ewol::Widget> getSubWidget(int32_t _idWidget) const {
return m_subWidget[_idWidget];
};
public:
@ -71,14 +73,14 @@ namespace ewol {
* @brief get the current displayed composition
* @return The base widget
*/
ewol::object::Shared<ewol::Widget> getSubWidget() const {
std::shared_ptr<ewol::Widget> getSubWidget() const {
return getSubWidget(0);
};
/**
* @brief get the current displayed composition
* @return The toggle widget
*/
ewol::object::Shared<ewol::Widget> getSubWidgetToggle() const {
std::shared_ptr<ewol::Widget> getSubWidgetToggle() const {
return getSubWidget(1);
};
private:
@ -152,17 +154,18 @@ namespace ewol {
public: // Derived function
virtual void systemDraw(const ewol::DrawProperty& _displayProp);
virtual void onRegenerateDisplay();
virtual void onObjectRemove(const ewol::object::Shared<ewol::Object>& _object);
virtual void onObjectRemove(const std::shared_ptr<ewol::Object>& _object);
virtual void calculateSize(const vec2& _availlable) {
calculateSizePadded(_availlable);
}
virtual void calculateMinMaxSize() {
calculateMinMaxSizePadded();
}
//virtual ewol::object::Shared<ewol::Widget> getWidgetAtPos(const vec2& _pos);
virtual ewol::object::Shared<ewol::Widget> getWidgetNamed(const std::string& _widgetName);
//virtual std::shared_ptr<ewol::Widget> getWidgetAtPos(const vec2& _pos);
virtual std::shared_ptr<ewol::Widget> getWidgetNamed(const std::string& _widgetName);
virtual bool loadXML(exml::Element* _node);
virtual void setOffset(const vec2& _newVal);
virtual void requestDestroyFromChild(const std::shared_ptr<Object>& _child);
};
};
};

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

@ -22,6 +22,10 @@ ewol::widget::ContainerN::ContainerN() :
// nothing to do ...
}
void ewol::widget::ContainerN::init() {
ewol::Widget::init();
}
ewol::widget::ContainerN::~ContainerN() {
subWidgetRemoveAll();
}
@ -52,13 +56,13 @@ void ewol::widget::ContainerN::lockExpand(const bvec2& _lockExpand) {
}
int32_t ewol::widget::ContainerN::subWidgetAdd(ewol::object::Shared<ewol::Widget> _newWidget) {
int32_t ewol::widget::ContainerN::subWidgetAdd(std::shared_ptr<ewol::Widget> _newWidget) {
if (nullptr == _newWidget) {
EWOL_ERROR("[" << getId() << "] {" << getObjectType() << "} Try to add An empty Widget ... ");
return -1;
}
if (_newWidget!=nullptr) {
_newWidget->setUpperWidget(this);
if (_newWidget != nullptr) {
_newWidget->setParent(shared_from_this());
}
m_subWidget.push_back(_newWidget);
markToRedraw();
@ -67,13 +71,13 @@ int32_t ewol::widget::ContainerN::subWidgetAdd(ewol::object::Shared<ewol::Widget
return _newWidget->getId();
}
int32_t ewol::widget::ContainerN::subWidgetAddStart(ewol::object::Shared<ewol::Widget> _newWidget) {
int32_t ewol::widget::ContainerN::subWidgetAddStart(std::shared_ptr<ewol::Widget> _newWidget) {
if (nullptr == _newWidget) {
EWOL_ERROR("[" << getId() << "] {" << getObjectType() << "} Try to add start An empty Widget ... ");
return -1;
}
if (_newWidget!=nullptr) {
_newWidget->setUpperWidget(this);
if (_newWidget != nullptr) {
_newWidget->setParent(shared_from_this());
}
m_subWidget.insert(m_subWidget.begin(), _newWidget);
markToRedraw();
@ -81,7 +85,7 @@ int32_t ewol::widget::ContainerN::subWidgetAddStart(ewol::object::Shared<ewol::W
return _newWidget->getId();
}
void ewol::widget::ContainerN::subWidgetRemove(ewol::object::Shared<ewol::Widget> _newWidget) {
void ewol::widget::ContainerN::subWidgetRemove(std::shared_ptr<ewol::Widget> _newWidget) {
if (nullptr == _newWidget) {
return;
}
@ -90,7 +94,7 @@ void ewol::widget::ContainerN::subWidgetRemove(ewol::object::Shared<ewol::Widget
auto it(m_subWidget.begin());
while (it != m_subWidget.end()) {
if (_newWidget == *it) {
(*it)->removeUpperWidget();
(*it)->removeParent();
m_subWidget.erase(it);
it = m_subWidget.begin();
markToRedraw();
@ -101,15 +105,15 @@ void ewol::widget::ContainerN::subWidgetRemove(ewol::object::Shared<ewol::Widget
}
}
void ewol::widget::ContainerN::subWidgetUnLink(ewol::object::Shared<ewol::Widget> _newWidget) {
void ewol::widget::ContainerN::subWidgetUnLink(std::shared_ptr<ewol::Widget> _newWidget) {
if (nullptr == _newWidget) {
return;
}
auto it(m_subWidget.begin());
while (it != m_subWidget.end()) {
if (_newWidget == *it) {
(*it)->removeUpperWidget();
(*it).resetShared();
(*it)->removeParent();
(*it).reset();
m_subWidget.erase(it);
it = m_subWidget.begin();
markToRedraw();
@ -123,7 +127,7 @@ void ewol::widget::ContainerN::subWidgetUnLink(ewol::object::Shared<ewol::Widget
void ewol::widget::ContainerN::subWidgetRemoveAll() {
for(auto &it : m_subWidget) {
if (it != nullptr) {
it->removeUpperWidget();
it->removeParent();
}
it.reset();
}
@ -134,14 +138,14 @@ void ewol::widget::ContainerN::subWidgetRemoveAllDelayed() {
subWidgetRemoveAll();
}
ewol::object::Shared<ewol::Widget> ewol::widget::ContainerN::getWidgetNamed(const std::string& _widgetName) {
ewol::object::Shared<ewol::Widget> tmpUpperWidget = ewol::Widget::getWidgetNamed(_widgetName);
std::shared_ptr<ewol::Widget> ewol::widget::ContainerN::getWidgetNamed(const std::string& _widgetName) {
std::shared_ptr<ewol::Widget> tmpUpperWidget = ewol::Widget::getWidgetNamed(_widgetName);
if (tmpUpperWidget != nullptr) {
return tmpUpperWidget;
}
for (auto &it : m_subWidget) {
if (it != nullptr) {
ewol::object::Shared<ewol::Widget> tmpWidget = it->getWidgetNamed(_widgetName);
std::shared_ptr<ewol::Widget> tmpWidget = it->getWidgetNamed(_widgetName);
if (tmpWidget != nullptr) {
return tmpWidget;
}
@ -150,7 +154,7 @@ ewol::object::Shared<ewol::Widget> ewol::widget::ContainerN::getWidgetNamed(cons
return nullptr;
}
void ewol::widget::ContainerN::onObjectRemove(const ewol::object::Shared<ewol::Object>& _object) {
void ewol::widget::ContainerN::onObjectRemove(const std::shared_ptr<ewol::Object>& _object) {
// First step call parrent :
ewol::Widget::onObjectRemove(_object);
// second step find if in all the elements ...
@ -224,7 +228,7 @@ void ewol::widget::ContainerN::onRegenerateDisplay() {
}
}
ewol::object::Shared<ewol::Widget> ewol::widget::ContainerN::getWidgetAtPos(const vec2& _pos) {
std::shared_ptr<ewol::Widget> ewol::widget::ContainerN::getWidgetAtPos(const vec2& _pos) {
if (true == isHide()) {
return nullptr;
}
@ -236,7 +240,7 @@ ewol::object::Shared<ewol::Widget> ewol::widget::ContainerN::getWidgetAtPos(cons
if( (tmpOrigin.x() <= _pos.x() && tmpOrigin.x() + tmpSize.x() >= _pos.x())
&& (tmpOrigin.y() <= _pos.y() && tmpOrigin.y() + tmpSize.y() >= _pos.y()) )
{
ewol::object::Shared<ewol::Widget> tmpWidget = it->getWidgetAtPos(_pos);
std::shared_ptr<ewol::Widget> tmpWidget = it->getWidgetAtPos(_pos);
if (nullptr != tmpWidget) {
return tmpWidget;
}
@ -280,7 +284,7 @@ bool ewol::widget::ContainerN::loadXML(exml::Element* _node) {
continue;
}
EWOL_DEBUG("[" << getId() << "] {" << getObjectType() << "} load new element : \"" << widgetName << "\"");
ewol::object::Shared<ewol::Widget> subWidget = getWidgetManager().create(widgetName);
std::shared_ptr<ewol::Widget> subWidget = getWidgetManager().create(widgetName);
if (subWidget == nullptr) {
EWOL_ERROR ("[" << getId() << "] {" << getObjectType() << "} (l "<<pNode->getPos()<<") Can not create the widget : \"" << widgetName << "\"");
continue;
@ -308,3 +312,23 @@ void ewol::widget::ContainerN::setOffset(const vec2& _newVal) {
}
}
void ewol::widget::ContainerN::requestDestroyFromChild(const std::shared_ptr<Object>& _child) {
auto it = m_subWidget.begin();
while (it != m_subWidget.end()) {
if (*it == _child) {
if (*it == nullptr) {
m_subWidget.erase(it);
it = m_subWidget.begin();
continue;
}
(*it)->removeParent();
(*it).reset();
m_subWidget.erase(it);
it = m_subWidget.begin();
markToRedraw();
continue;
}
++it;
}
}

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

@ -22,12 +22,14 @@ namespace ewol {
*/
class ContainerN : public ewol::Widget {
protected:
std::list<ewol::object::Owner<ewol::Widget>> m_subWidget;
public:
std::list<std::shared_ptr<ewol::Widget>> m_subWidget;
protected:
/**
* @brief Constructor
*/
ContainerN();
void init();
public:
/**
* @brief Destructor
*/
@ -57,13 +59,13 @@ namespace ewol {
* @param[in] _newWidget the element pointer
* @return the ID of the set element
*/
virtual int32_t subWidgetAdd(ewol::object::Shared<ewol::Widget> _newWidget);
virtual int32_t subWidgetAdd(std::shared_ptr<ewol::Widget> _newWidget);
//! @previous
inline int32_t subWidgetAddBack(ewol::object::Shared<ewol::Widget> _newWidget) {
inline int32_t subWidgetAddBack(std::shared_ptr<ewol::Widget> _newWidget) {
return subWidgetAdd(_newWidget);
};
//! @previous
inline int32_t subWidgetAddEnd(ewol::object::Shared<ewol::Widget> _newWidget) {
inline int32_t subWidgetAddEnd(std::shared_ptr<ewol::Widget> _newWidget) {
return subWidgetAdd(_newWidget);
};
/**
@ -71,31 +73,32 @@ namespace ewol {
* @param[in] _newWidget the element pointer
* @return the ID of the set element
*/
virtual int32_t subWidgetAddStart(ewol::object::Shared<ewol::Widget> _newWidget);
virtual int32_t subWidgetAddStart(std::shared_ptr<ewol::Widget> _newWidget);
//! @previous
inline int32_t subWidgetAddFront(ewol::object::Shared<ewol::Widget> _newWidget) {
inline int32_t subWidgetAddFront(std::shared_ptr<ewol::Widget> _newWidget) {
return subWidgetAddStart(_newWidget);
};
/**
* @brief remove definitly a widget from the system and this layer.
* @param[in] _newWidget the element pointer.
*/
virtual void subWidgetRemove(ewol::object::Shared<ewol::Widget> _newWidget);
virtual void subWidgetRemove(std::shared_ptr<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] _newWidget the element pointer.
*/
virtual void subWidgetUnLink(ewol::object::Shared<ewol::Widget> _newWidget);
virtual void subWidgetUnLink(std::shared_ptr<ewol::Widget> _newWidget);
public:// Derived function
virtual void systemDraw(const ewol::DrawProperty& _displayProp);
virtual void onRegenerateDisplay();
virtual void onObjectRemove(const ewol::object::Shared<ewol::Object>& _object);
virtual void onObjectRemove(const std::shared_ptr<ewol::Object>& _object);
virtual void calculateSize(const vec2& _availlable);
virtual void calculateMinMaxSize();
virtual ewol::object::Shared<ewol::Widget> getWidgetAtPos(const vec2& _pos);
virtual ewol::object::Shared<ewol::Widget> getWidgetNamed(const std::string& _widgetName);
virtual std::shared_ptr<ewol::Widget> getWidgetAtPos(const vec2& _pos);
virtual std::shared_ptr<ewol::Widget> getWidgetNamed(const std::string& _widgetName);
virtual bool loadXML(exml::Element* _node);
virtual void setOffset(const vec2& _newVal);
virtual void requestDestroyFromChild(const std::shared_ptr<Object>& _child);
};
};
};

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

@ -21,18 +21,7 @@ const char* const ewol::widget::ContextMenu::configArrowPosition = "arrow-positi
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();
}
void ewol::widget::ContextMenu::init(ewol::widget::Manager& _widgetManager) {
_widgetManager.addWidgetCreator(__class__, &create);
}
ewol::widget::ContextMenu::ContextMenu(const std::string& _shaperName) :
m_shaper(_shaperName) {
ewol::widget::ContextMenu::ContextMenu() {
addObjectType("ewol::widget::ContextMenu");
// add basic configurations :
registerConfig(configArrowPosition, "vec2", nullptr, "position of the arrow");
@ -53,6 +42,11 @@ ewol::widget::ContextMenu::ContextMenu(const std::string& _shaperName) :
setMouseLimit(1);
}
void ewol::widget::ContextMenu::init(const std::string& _shaperName) {
ewol::widget::Container::init();
m_shaper.setSource(_shaperName);
}
ewol::widget::ContextMenu::~ContextMenu() {
}
@ -241,12 +235,12 @@ void ewol::widget::ContextMenu::setPositionMark(enum markPosition _position, vec
markToRedraw();
}
ewol::object::Shared<ewol::Widget> ewol::widget::ContextMenu::getWidgetAtPos(const vec2& _pos) {
ewol::object::Shared<ewol::Widget> val = ewol::widget::Container::getWidgetAtPos(_pos);
std::shared_ptr<ewol::Widget> ewol::widget::ContextMenu::getWidgetAtPos(const vec2& _pos) {
std::shared_ptr<ewol::Widget> val = ewol::widget::Container::getWidgetAtPos(_pos);
if (nullptr != val) {
return val;
}
return this;
return std::dynamic_pointer_cast<ewol::Widget>(shared_from_this());
}

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

@ -32,13 +32,15 @@ namespace ewol {
markNone
};
public:
static void init(ewol::widget::Manager& _widgetManager);
// Config list of properties
static const char* const configArrowPosition;
static const char* const configArrowMode;
static const char* const configShaper;
public:
ContextMenu(const std::string& _shaperName="THEME:GUI:ContextMenu.json");
ContextMenu();
void init(const std::string& _shaperName="THEME:GUI:ContextMenu.json");
public:
DECLARE_WIDGET_FACTORY(ContextMenu, "ContextMenu");
virtual ~ContextMenu();
private:
ewol::compositing::Shaper m_shaper; //!< Compositing theme.
@ -69,7 +71,7 @@ namespace ewol {
virtual bool onEventInput(const ewol::event::Input& _event);
virtual void calculateSize(const vec2& _availlable);
virtual void calculateMinMaxSize();
virtual ewol::object::Shared<ewol::Widget> getWidgetAtPos(const vec2& _pos);
virtual std::shared_ptr<ewol::Widget> getWidgetAtPos(const vec2& _pos);
};
};
};

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

@ -29,14 +29,6 @@ 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();
}
void ewol::widget::Entry::init(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";
@ -46,7 +38,7 @@ 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() :
m_shaper("THEME:GUI:Entry.json"),
m_data(""),
m_maxCharacter(0x7FFFFFFF),
@ -78,11 +70,16 @@ ewol::widget::Entry::Entry(std::string _newData) :
registerConfig(configEmptyMessage, "string", nullptr, "Text that is displayed when the Entry is empty (decorated text)");
registerConfig(configValue, "string", nullptr, "Value display in the entry (decorated text)");
setValue(_newData);
markToRedraw();
}
void ewol::widget::Entry::init(const std::string& _newData) {
ewol::Widget::init();
setValue(_newData);
}
ewol::widget::Entry::~Entry() {
}

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

@ -42,8 +42,6 @@ namespace ewol {
static const char* const configRegExp;
static const char* const configEmptyMessage;
static const char* const configValue;
public:
static void init(ewol::widget::Manager& _widgetManager);
private:
ewol::compositing::Shaper m_shaper;
int32_t m_colorIdTextFg; //!< color property of the text foreground
@ -56,7 +54,10 @@ namespace ewol {
* @brief Contuctor
* @param[in] _newData The USting that might be set in the Entry box (no event generation!!)
*/
Entry(std::string _newData = "");
Entry();
void init(const std::string& _newData = "");
public:
DECLARE_WIDGET_FACTORY(Entry, "Entry");
/**
* @brief Destuctor
*/

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

@ -14,25 +14,19 @@
#undef __class__
#define __class__ "Gird"
static ewol::Widget* create() {
return new ewol::widget::Gird();
}
void ewol::widget::Gird::init(ewol::widget::Manager& _widgetManager) {
_widgetManager.addWidgetCreator(__class__,&create);
}
ewol::widget::Gird::Gird(int32_t _colNumber) :
ewol::widget::Gird::Gird() :
m_sizeRow(0),
m_tmpWidget(nullptr),
m_gavityButtom(true),
m_borderSize(0,0) {
addObjectType("ewol::widget::Gird");
setColNumber(_colNumber);
requestUpdateSize();
}
void ewol::widget::Gird::init(int32_t _colNumber) {
ewol::Widget::init();
setColNumber(_colNumber);
}
ewol::widget::Gird::~Gird() {
EWOL_DEBUG("[" << getId() << "]={" << getObjectType() << "} Gird : destroy");
@ -216,7 +210,7 @@ void ewol::widget::Gird::subWidgetRemoveAll() {
}
void ewol::widget::Gird::subWidgetAdd(int32_t _colId, int32_t _rowId, ewol::object::Shared<ewol::Widget> _newWidget) {
void ewol::widget::Gird::subWidgetAdd(int32_t _colId, int32_t _rowId, std::shared_ptr<ewol::Widget> _newWidget) {
if (nullptr == _newWidget) {
return;
}
@ -258,7 +252,7 @@ void ewol::widget::Gird::subWidgetAdd(int32_t _colId, int32_t _rowId, ewol::obje
m_subWidget.push_back(prop);
}
void ewol::widget::Gird::subWidgetRemove(ewol::object::Shared<ewol::Widget> _newWidget) {
void ewol::widget::Gird::subWidgetRemove(std::shared_ptr<ewol::Widget> _newWidget) {
for (size_t iii=0; iii<m_subWidget.size(); iii++) {
if (_newWidget == m_subWidget[iii].widget) {
m_subWidget.erase(m_subWidget.begin()+iii);
@ -285,7 +279,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::object::Shared<ewol::Widget> _newWidget) {
void ewol::widget::Gird::subWidgetUnLink(std::shared_ptr<ewol::Widget> _newWidget) {
if (nullptr == _newWidget) {
return;
}
@ -330,7 +324,7 @@ void ewol::widget::Gird::onRegenerateDisplay() {
}
}
ewol::object::Shared<ewol::Widget> ewol::widget::Gird::getWidgetAtPos(const vec2& _pos) {
std::shared_ptr<ewol::Widget> ewol::widget::Gird::getWidgetAtPos(const vec2& _pos) {
if (true == isHide()) {
return nullptr;
}
@ -342,7 +336,7 @@ ewol::object::Shared<ewol::Widget> ewol::widget::Gird::getWidgetAtPos(const vec2
if( (tmpOrigin.x() <= _pos.x() && tmpOrigin.x() + tmpSize.x() >= _pos.x())
&& (tmpOrigin.y() <= _pos.y() && tmpOrigin.y() + tmpSize.y() >= _pos.y()) )
{
ewol::object::Shared<ewol::Widget> tmpWidget = m_subWidget[iii].widget->getWidgetAtPos(_pos);
std::shared_ptr<ewol::Widget> tmpWidget = m_subWidget[iii].widget->getWidgetAtPos(_pos);
if (nullptr != tmpWidget) {
return tmpWidget;
}
@ -354,7 +348,7 @@ ewol::object::Shared<ewol::Widget> ewol::widget::Gird::getWidgetAtPos(const vec2
return nullptr;
}
void ewol::widget::Gird::onObjectRemove(const ewol::object::Shared<ewol::Object>& _removeObject) {
void ewol::widget::Gird::onObjectRemove(const std::shared_ptr<ewol::Object>& _removeObject) {
// First step call parrent :
ewol::Widget::onObjectRemove(_removeObject);
// second step find if in all the elements ...

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

@ -21,12 +21,10 @@ namespace ewol {
* @ingroup ewolWidgetGroup
*/
class Gird :public ewol::Widget {
public:
static void init(ewol::widget::Manager& _widgetManager);
private:
class GirdProperties {
public:
ewol::object::Shared<ewol::Widget> widget;
std::shared_ptr<ewol::Widget> widget;
int32_t row;
int32_t col;
};
@ -34,13 +32,16 @@ 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::object::Shared<ewol::Widget> m_tmpWidget; //!< use when replace a widget ...
std::shared_ptr<ewol::Widget> m_tmpWidget; //!< use when replace a widget ...
bool m_gavityButtom;
public:
protected:
/**
* @brief Constructor
*/
Gird(int32_t _colNumber=1);
Gird();
void init(int32_t _colNumber=1);
public:
DECLARE_WIDGET_FACTORY(Gird, "Gird");
/**
* @brief Desstructor
*/
@ -97,12 +98,12 @@ namespace ewol {
* @param[in] _rowId Id of the row [0..y].
* @param[in] _newWidget the element pointer
*/
virtual void subWidgetAdd(int32_t _colId, int32_t _rowId, ewol::object::Shared<ewol::Widget> _newWidget);
virtual void subWidgetAdd(int32_t _colId, int32_t _rowId, std::shared_ptr<ewol::Widget> _newWidget);
/**
* @brief remove definitly a widget from the system and this Gird.
* @param[in] _newWidget the element pointer.
*/
virtual void subWidgetRemove(ewol::object::Shared<ewol::Widget> _newWidget);
virtual void subWidgetRemove(std::shared_ptr<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 +114,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::object::Shared<ewol::Widget> _newWidget);
virtual void subWidgetUnLink(std::shared_ptr<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].
@ -138,8 +139,8 @@ namespace ewol {
public: // Derived function
virtual void systemDraw(const ewol::DrawProperty& _displayProp);
virtual void onRegenerateDisplay();
virtual ewol::object::Shared<ewol::Widget> getWidgetAtPos(const vec2& pos);
virtual void onObjectRemove(const ewol::object::Shared<ewol::Object>& _removeObject);
virtual std::shared_ptr<ewol::Widget> getWidgetAtPos(const vec2& pos);
virtual void onObjectRemove(const std::shared_ptr<ewol::Object>& _removeObject);
virtual void calculateSize(const vec2& _availlable);
virtual void calculateMinMaxSize();
};

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

@ -16,15 +16,6 @@
#undef __class__
#define __class__ "Image"
static ewol::Widget* create() {
return new ewol::widget::Image();
}
void ewol::widget::Image::init(ewol::widget::Manager& _widgetManager) {
_widgetManager.addWidgetCreator(__class__,&create);
}
const char * const ewol::widget::Image::eventPressed = "pressed";
const char * const ewol::widget::Image::configRatio = "ratio";
@ -35,7 +26,7 @@ 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() :
m_colorProperty(nullptr),
m_colorId(-1),
m_imageSize(vec2(0.0f,0.0f)),
@ -51,13 +42,18 @@ ewol::widget::Image::Image(const std::string& _file, const ewol::Dimension& _bor
registerConfig(configDistanceField, "bool", "Distance field mode");
registerConfig(configPartStart, "vec2", nullptr, "Start display position in the image [0.0 .. 1.0]");
registerConfig(configPartStop, "vec2", nullptr, "Stop display position in the image [0.0 .. 1.0]");
m_colorProperty = ewol::resource::ColorFile::keep("THEME:COLOR:Image.json");
m_colorProperty = ewol::resource::ColorFile::create("THEME:COLOR:Image.json");
if (m_colorProperty != nullptr) {
m_colorId = m_colorProperty->request("foreground");
}
}
void ewol::widget::Image::init(const std::string& _file, const ewol::Dimension& _border) {
ewol::Widget::init();
set(_file, _border);
}
ewol::widget::Image::~Image() {
}

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

@ -34,21 +34,19 @@ namespace ewol {
static const char * const configDistanceField;
static const char * const configPartStart;
static const char * const configPartStop;
public:
/**
* @brief Main call of recording the widget on the List of "widget named creator"
*/
static void init(ewol::widget::Manager& _widgetManager);
protected:
ewol::compositing::Image m_compositing; //!< compositing element of the image.
ewol::object::Shared<ewol::resource::ColorFile> m_colorProperty; //!< theme color property
std::shared_ptr<ewol::resource::ColorFile> m_colorProperty; //!< theme color property
int32_t m_colorId; //!< Color of the image.
public:
/**
* @brief
*/
Image(const std::string& _file="",
const ewol::Dimension& _border=ewol::Dimension(vec2(0,0),ewol::Dimension::Millimeter));
Image();
void init(const std::string& _file="",
const ewol::Dimension& _border=ewol::Dimension(vec2(0,0),ewol::Dimension::Millimeter));
public:
DECLARE_WIDGET_FACTORY(Image, "Image");
/**
* @brief
*/

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

@ -50,6 +50,10 @@ ewol::widget::Joystick::Joystick() {
setCanHaveFocus(true);
}
void ewol::widget::Joystick::init() {
ewol::Widget::init();
}
ewol::widget::Joystick::~Joystick() {

5
sources/ewol/widget/Joystick.h
View File

@ -45,8 +45,11 @@ namespace ewol {
std::string m_background;
std::string m_foreground;
float m_ratio;
public:
protected:
Joystick();
void init();
public:
DECLARE_WIDGET_FACTORY(Joystick, "Joystick");
virtual ~Joystick();
public:
void setLockMode(bool _lockWhenOut) {

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

@ -18,31 +18,28 @@
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();
}
void ewol::widget::Label::init(ewol::widget::Manager& _widgetManager) {
_widgetManager.addWidgetCreator(__class__,&create);
}
// TODO : Remove the label name in the constructor ...
ewol::widget::Label::Label(std::string _newLabel) :
ewol::widget::Label::Label() :
m_colorProperty(nullptr),
m_colorDefaultFgText(-1),
m_colorDefaultBgText(-1){
addObjectType("ewol::widget::Label");
m_colorProperty = ewol::resource::ColorFile::keep("THEME:COLOR:Label.json");
m_colorProperty = ewol::resource::ColorFile::create("THEME:COLOR:Label.json");
if (m_colorProperty != nullptr) {
m_colorDefaultFgText = m_colorProperty->request("foreground");
m_colorDefaultBgText = m_colorProperty->request("background");
}
m_label = std::to_u32string(_newLabel);
addEventId(eventPressed);
setCanHaveFocus(false);
setMouseLimit(1);
registerConfig(configValue, "string", nullptr, "displayed value string"); // TODO : do not store in attibute...
}
void ewol::widget::Label::init(std::string _newLabel) {
ewol::Widget::init();
m_label = std::to_u32string(_newLabel);
}
ewol::widget::Label::~Label() {
}

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

@ -27,22 +27,21 @@ namespace ewol {
static const char * const eventPressed;
// Config list of properties
static const char* const configValue;
/**
* @brief Main call of recording the widget on the List of "widget named creator"
*/
static void init(ewol::widget::Manager& _widgetManager);
private:
ewol::compositing::Text m_text; //!< Compositing text element.
std::u32string m_label; //!< decorated text to display.
ewol::object::Shared<ewol::resource::ColorFile> m_colorProperty; //!< theme color property
std::shared_ptr<ewol::resource::ColorFile> m_colorProperty; //!< theme color property
int32_t m_colorDefaultFgText; //!< Default color of the text
int32_t m_colorDefaultBgText; //!< Default Background color of the text
public:
protected:
/**
* @brief Constructor
* @param[in] _newLabel The displayed decorated text.
*/
Label(std::string _newLabel="---");
Label();
void init(std::string _newLabel="---");
public:
DECLARE_WIDGET_FACTORY(Label, "Label");
/**
* @brief destructor
*/

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

@ -13,23 +13,19 @@
#undef __class__
#define __class__ "Layer"
static ewol::Widget* create() {
return new ewol::widget::Layer();
}
void ewol::widget::Layer::init(ewol::widget::Manager& _widgetManager) {
_widgetManager.addWidgetCreator(__class__,&create);
}
ewol::widget::Layer::Layer() {
addObjectType("ewol::widget::Layer");
}
void ewol::widget::Layer::init() {
ewol::widget::ContainerN::init();
}
ewol::widget::Layer::~Layer() {
EWOL_DEBUG("[" << getId() << "] Layer : destroy");
}
ewol::object::Shared<ewol::Widget> ewol::widget::Layer::getWidgetAtPos(const vec2& _pos) {
std::shared_ptr<ewol::Widget> ewol::widget::Layer::getWidgetAtPos(const vec2& _pos) {
if (true == isHide()) {
return nullptr;
}
@ -43,7 +39,7 @@ ewol::object::Shared<ewol::Widget> ewol::widget::Layer::getWidgetAtPos(const vec
if( (tmpOrigin.x() <= _pos.x() && tmpOrigin.x() + tmpSize.x() >= _pos.x())
&& (tmpOrigin.y() <= _pos.y() && tmpOrigin.y() + tmpSize.y() >= _pos.y()) )
{
ewol::object::Shared<ewol::Widget> tmpWidget = it->getWidgetAtPos(_pos);
std::shared_ptr<ewol::Widget> tmpWidget = it->getWidgetAtPos(_pos);
if (nullptr != tmpWidget) {
return tmpWidget;
}

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

@ -20,22 +20,20 @@ namespace ewol {
* @ingroup ewolWidgetGroup
*/
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);
public:
protected:
/**
* @brief Constructor
*/
Layer();
void init();
public:
DECLARE_WIDGET_FACTORY(Layer, "Layer");
/**
* @brief Desstructor
*/
virtual ~Layer();
public: // Derived function
virtual ewol::object::Shared<ewol::Widget> getWidgetAtPos(const vec2& _pos);
virtual std::shared_ptr<ewol::Widget> getWidgetAtPos(const vec2& _pos);
};
};
};

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

@ -28,6 +28,10 @@ ewol::widget::List::List() {
setCanHaveFocus(true);
}
void ewol::widget::List::init() {
ewol::widget::WidgetScrolled::init();
}
ewol::widget::List::~List() {
//clean all the object
for (size_t iii=0; iii<m_listOObject.size(); iii++) {
@ -235,7 +239,7 @@ 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::object::Shared<ewol::Widget>Manager::focusKeep(this);
//std::shared_ptr<ewol::Widget>Manager::focusKeep(this);
}
return isUsed;
}

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

@ -21,8 +21,10 @@ namespace ewol {
* @ingroup ewolWidgetGroup
*/
class List : public ewol::widget::WidgetScrolled {
public:
protected:
List();
void init();
public:
virtual ~List();
virtual void calculateMinMaxSize();
void setLabel(std::string _newLabel);

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

@ -15,14 +15,6 @@
#undef __class__
#define __class__ "ListFileSystem"
static ewol::Widget* create() {
return new ewol::widget::ListFileSystem();
}
void ewol::widget::ListFileSystem::init(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";
@ -46,7 +38,7 @@ ewol::widget::ListFileSystem::ListFileSystem() :
#if defined(__TARGET_OS__Windows)
m_folder = "c:/";
#endif
m_colorProperty = ewol::resource::ColorFile::keep("THEME:COLOR:ListFileSystem.json");
m_colorProperty = ewol::resource::ColorFile::create("THEME:COLOR:ListFileSystem.json");
if (m_colorProperty != nullptr) {
m_colorIdText = m_colorProperty->request("text");
m_colorIdBackground1 = m_colorProperty->request("background1");
@ -68,6 +60,11 @@ ewol::widget::ListFileSystem::ListFileSystem() :
setMouseLimit(1);
};
void ewol::widget::ListFileSystem::init() {
ewol::widget::List::init();
};
ewol::widget::ListFileSystem::~ListFileSystem() {
clearList();
};

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

@ -20,8 +20,6 @@ namespace ewol {
*/
class ListFileSystem : public ewol::widget::List {
public:
//! @not-in-doc
static void init(ewol::widget::Manager& _widgetManager);
// Event list of properties
static const char * const eventFileSelect; //!< @event "file-select" Generated when a file is selected.
static const char * const eventFileValidate; //!< @event "file-validate" Generate when the user validate (return) or double click on the element
@ -35,11 +33,14 @@ namespace ewol {
static const char* const configPath;
static const char* const configSelect;
// TODO : Add a standalone configuration ..
public:
protected:
ListFileSystem();
void init();
public:
DECLARE_WIDGET_FACTORY(ListFileSystem, "ListFileSystem");
virtual ~ListFileSystem();
protected:
ewol::object::Shared<ewol::resource::ColorFile> m_colorProperty; //!< theme color property.
std::shared_ptr<ewol::resource::ColorFile> m_colorProperty; //!< theme color property.
int32_t m_colorIdText; //!< Color of the text.
int32_t m_colorIdBackground1; //!< Color of the Background.
int32_t m_colorIdBackground2; //!< Color of the Background 2.

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

@ -44,24 +44,24 @@ 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::Composer::init(*this);
ewol::widget::Button::createManagerWidget(*this);
ewol::widget::ButtonColor::createManagerWidget(*this);
ewol::widget::Spacer::createManagerWidget(*this);
ewol::widget::Slider::createManagerWidget(*this);
ewol::widget::Sizer::createManagerWidget(*this);
ewol::widget::ProgressBar::createManagerWidget(*this);
ewol::widget::Layer::createManagerWidget(*this);
ewol::widget::Label::createManagerWidget(*this);
ewol::widget::Image::createManagerWidget(*this);
ewol::widget::Gird::createManagerWidget(*this);
ewol::widget::Entry::createManagerWidget(*this);
ewol::widget::CheckBox::createManagerWidget(*this);
ewol::widget::Scroll::createManagerWidget(*this);
ewol::widget::ContextMenu::createManagerWidget(*this);
ewol::widget::PopUp::createManagerWidget(*this);
ewol::widget::WSlider::createManagerWidget(*this);
ewol::widget::ListFileSystem::createManagerWidget(*this);
ewol::widget::Composer::createManagerWidget(*this);
}
ewol::widget::Manager::~Manager() {
@ -78,7 +78,7 @@ ewol::widget::Manager::~Manager() {
* focus Area :
* *************************************************************************/
void ewol::widget::Manager::focusKeep(const ewol::object::Shared<ewol::Widget>& _newWidget) {
void ewol::widget::Manager::focusKeep(const std::shared_ptr<ewol::Widget>& _newWidget) {
if (_newWidget == nullptr) {
// nothing to do ...
return;
@ -105,7 +105,7 @@ void ewol::widget::Manager::focusKeep(const ewol::object::Shared<ewol::Widget>&
}
}
void ewol::widget::Manager::focusSetDefault(const ewol::object::Shared<ewol::Widget>& _newWidget) {
void ewol::widget::Manager::focusSetDefault(const std::shared_ptr<ewol::Widget>& _newWidget) {
if( _newWidget != nullptr
&& _newWidget->canHaveFocus() == false) {
EWOL_VERBOSE("Widget can not have focus, id=" << _newWidget->getId() );
@ -142,11 +142,11 @@ void ewol::widget::Manager::focusRelease() {
}
const ewol::object::Shared<ewol::Widget>& ewol::widget::Manager::focusGet() {
const std::shared_ptr<ewol::Widget>& ewol::widget::Manager::focusGet() {
return m_focusWidgetCurrent;
}
void ewol::widget::Manager::focusRemoveIfRemove(const ewol::object::Shared<ewol::Widget>& _newWidget) {
void ewol::widget::Manager::focusRemoveIfRemove(const std::shared_ptr<ewol::Widget>& _newWidget) {
if (m_focusWidgetCurrent == _newWidget) {
EWOL_WARNING("Release focus when remove widget");
focusRelease();
@ -157,7 +157,7 @@ void ewol::widget::Manager::focusRemoveIfRemove(const ewol::object::Shared<ewol:
}
}
void ewol::widget::Manager::periodicCallAdd(const ewol::object::Shared<ewol::Widget>& _pWidget) {
void ewol::widget::Manager::periodicCallAdd(const std::shared_ptr<ewol::Widget>& _pWidget) {
if (_pWidget == nullptr) {
return;
}
@ -177,7 +177,7 @@ void ewol::widget::Manager::periodicCallAdd(const ewol::object::Shared<ewol::Wid
m_listOfPeriodicWidget.push_back(_pWidget);
}
void ewol::widget::Manager::periodicCallRm(const ewol::object::Shared<ewol::Widget>& _pWidget) {
void ewol::widget::Manager::periodicCallRm(const std::shared_ptr<ewol::Widget>& _pWidget) {
for (auto &it : m_listOfPeriodicWidget) {
if (it == _pWidget) {
it.reset();
@ -271,12 +271,12 @@ void ewol::widget::Manager::addWidgetCreator(const std::string& _name,
m_creatorList.add(nameLower, _pointer);
}
ewol::object::Shared<ewol::Widget> ewol::widget::Manager::create(const std::string& _name) {
std::shared_ptr<ewol::Widget> ewol::widget::Manager::create(const std::string& _name) {
std::string nameLower = std::tolower(_name);
if (m_creatorList.exist(nameLower) == true) {
ewol::widget::Manager::creator_tf pointerFunction = m_creatorList[nameLower];
if (pointerFunction != nullptr) {
return ewol::object::makeShared<ewol::Widget>(pointerFunction());
return pointerFunction();
}
}
EWOL_WARNING("try to create an UnExistant widget : " << nameLower);
@ -297,7 +297,7 @@ std::string ewol::widget::Manager::list() {
return tmpVal;
}
void ewol::widget::Manager::onObjectRemove(const ewol::object::Shared<ewol::Object>& _object) {
void ewol::widget::Manager::onObjectRemove(const std::shared_ptr<ewol::Object>& _object) {
if (m_focusWidgetDefault == _object) {
EWOL_VERBOSE("Remove object ==> rm default focus !!!");
m_focusWidgetDefault.reset();

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

@ -20,12 +20,12 @@ namespace ewol {
namespace widget {
class Manager {
public:
typedef ewol::Widget* (*creator_tf)();
typedef std::shared_ptr<ewol::Widget> (*creator_tf)();
private:
// For the focus Management
ewol::object::Shared<ewol::Widget> m_focusWidgetDefault;
ewol::object::Shared<ewol::Widget> m_focusWidgetCurrent;
std::vector<ewol::object::Shared<ewol::Widget>> m_listOfPeriodicWidget;
std::shared_ptr<ewol::Widget> m_focusWidgetDefault;
std::shared_ptr<ewol::Widget> m_focusWidgetCurrent;
std::vector<std::shared_ptr<ewol::Widget>> m_listOfPeriodicWidget;
bool m_havePeriodic;
bool m_haveRedraw;
etk::Hash<creator_tf> m_creatorList;
@ -35,14 +35,14 @@ namespace ewol {
Manager();
virtual ~Manager();
void focusKeep(const ewol::object::Shared<ewol::Widget>& _newWidget); // set the focus at the specific widget
void focusSetDefault(const ewol::object::Shared<ewol::Widget>& _newWidget); // select the default focus getter
void focusKeep(const std::shared_ptr<ewol::Widget>& _newWidget); // set the focus at the specific widget
void focusSetDefault(const std::shared_ptr<ewol::Widget>& _newWidget); // select the default focus getter
void focusRelease(); // release focus from the current widget to the default
const ewol::object::Shared<ewol::Widget>& focusGet();
void focusRemoveIfRemove(const ewol::object::Shared<ewol::Widget>& _newWidget);
const std::shared_ptr<ewol::Widget>& focusGet();
void focusRemoveIfRemove(const std::shared_ptr<ewol::Widget>& _newWidget);
void periodicCallAdd(const ewol::object::Shared<ewol::Widget>& _pWidget);
void periodicCallRm(const ewol::object::Shared<ewol::Widget>& _pWidget);
void periodicCallAdd(const std::shared_ptr<ewol::Widget>& _pWidget);
void periodicCallRm(const std::shared_ptr<ewol::Widget>& _pWidget);
void periodicCall(int64_t _localTime);
void periodicCallResume(int64_t _localTime);
bool periodicCallHave();
@ -52,10 +52,10 @@ namespace ewol {
// element that generate the list of elements
void addWidgetCreator(const std::string& _name, creator_tf _pointer);
ewol::object::Shared<ewol::Widget> create(const std::string& _name);
std::shared_ptr<ewol::Widget> create(const std::string& _name);
bool exist(const std::string& _name);
std::string list();
virtual void onObjectRemove(const ewol::object::Shared<ewol::Object>& _object);
virtual void onObjectRemove(const std::shared_ptr<ewol::Object>& _object);
private:
void periodicCallUpdateCount();
};

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

@ -23,6 +23,10 @@ ewol::widget::Menu::Menu() {
m_staticId = 0;
}
void ewol::widget::Menu::init() {
ewol::widget::Sizer::init();
}
ewol::widget::Menu::~Menu() {
clear();
}
@ -32,16 +36,16 @@ void ewol::widget::Menu::subWidgetRemoveAll() {
ewol::widget::Sizer::subWidgetRemoveAll();
}
int32_t ewol::widget::Menu::subWidgetAdd(ewol::object::Shared<ewol::Widget> _newWidget) {
int32_t ewol::widget::Menu::subWidgetAdd(std::shared_ptr<ewol::Widget> _newWidget) {
EWOL_ERROR("Not availlable");
return -1;
}
void ewol::widget::Menu::subWidgetRemove(ewol::object::Shared<ewol::Widget> _newWidget) {
void ewol::widget::Menu::subWidgetRemove(std::shared_ptr<ewol::Widget> _newWidget) {
EWOL_ERROR("Not availlable");
}
void ewol::widget::Menu::subWidgetUnLink(ewol::object::Shared<ewol::Widget> _newWidget) {
void ewol::widget::Menu::subWidgetUnLink(std::shared_ptr<ewol::Widget> _newWidget) {
EWOL_ERROR("Not availlable");
}
@ -81,7 +85,7 @@ int32_t ewol::widget::Menu::add(int32_t _parent,
tmpObject->m_message = _message;
m_listElement.push_back(tmpObject);
if (-1 == tmpObject->m_parentId) {
ewol::object::Shared<ewol::widget::Button> myButton = ewol::object::makeShared(new ewol::widget::Button());
std::shared_ptr<ewol::widget::Button> myButton = ewol::widget::Button::create();
if (myButton == nullptr) {
EWOL_ERROR("Allocation button error");
return tmpObject->m_localId;
@ -95,15 +99,15 @@ int32_t ewol::widget::Menu::add(int32_t _parent,
}
composeString+=" <label>" + tmpObject->m_label + "</label>\n";
composeString+="</sizer>\n";
myButton->setSubWidget(ewol::object::makeShared(new ewol::widget::Composer(widget::Composer::String, composeString)));
myButton->setSubWidget(ewol::widget::Composer::create(widget::Composer::String, composeString));
} else {
myButton->setSubWidget(ewol::object::makeShared(new ewol::widget::Label(tmpObject->m_label)) );
myButton->setSubWidget(ewol::widget::Label::create(tmpObject->m_label) );
}
// add it in the widget list
ewol::widget::Sizer::subWidgetAdd(myButton);
// keep the specific event ...
myButton->registerOnEvent(this, ewol::widget::Button::eventPressed, widget::Button::eventPressed);
myButton->registerOnEvent(shared_from_this(), ewol::widget::Button::eventPressed, widget::Button::eventPressed);
tmpObject->m_widgetPointer = myButton;
}
return tmpObject->m_localId;
@ -131,8 +135,7 @@ void ewol::widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
sendMultiCast(m_listElement[iii]->m_generateEvent, m_listElement[iii]->m_message);
if (nullptr != m_widgetContextMenu) {
EWOL_DEBUG("Mark the menu to remove ...");
m_widgetContextMenu->removeObject();
m_widgetContextMenu = nullptr;
m_widgetContextMenu.reset();
}
return;
} else{
@ -149,14 +152,14 @@ void ewol::widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
return;
}
// create a context menu :
m_widgetContextMenu = ewol::object::makeShared(new ewol::widget::ContextMenu());
m_widgetContextMenu = ewol::widget::ContextMenu::create();
if (nullptr == m_widgetContextMenu) {
EWOL_ERROR("Allocation Error");
return;
}
// get the button widget :
vec2 newPosition;
ewol::object::Shared<ewol::Widget> eventFromWidget = dynamic_pointer_cast<ewol::Widget>(_msg.getCaller());
std::shared_ptr<ewol::Widget> eventFromWidget = std::dynamic_pointer_cast<ewol::Widget>(_msg.getCaller());
if (eventFromWidget != nullptr) {
vec2 tmpOri = eventFromWidget->getOrigin();
vec2 tmpSize = eventFromWidget->getSize();
@ -166,10 +169,10 @@ void ewol::widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
}
m_widgetContextMenu->setPositionMark(ewol::widget::ContextMenu::markTop, newPosition );
ewol::object::Shared<ewol::widget::Sizer> mySizer;
ewol::object::Shared<ewol::widget::Button> myButton;
std::shared_ptr<ewol::widget::Sizer> mySizer;
std::shared_ptr<ewol::widget::Button> myButton;
mySizer = ewol::object::makeShared(new ewol::widget::Sizer(widget::Sizer::modeVert));
mySizer = ewol::widget::Sizer::create(widget::Sizer::modeVert);
if (nullptr != mySizer) {
mySizer->lockExpand(vec2(true,true));
// set it in the pop-up-system :
@ -189,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]!=nullptr) {
if (m_listElement[iii]->m_localId == m_listElement[jjj]->m_parentId) {
myButton = ewol::object::makeShared(new ewol::widget::Button());
myButton = ewol::widget::Button::create();
if (nullptr == myButton) {
EWOL_ERROR("Allocation Error");
} else {
@ -205,19 +208,18 @@ 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(ewol::object::makeShared(new ewol::widget::Composer(widget::Composer::String, composeString)));
myButton->setSubWidget(ewol::widget::Composer::create(widget::Composer::String, composeString));
} else {
if (true == menuHaveImage) {
myButton->setSubWidget(ewol::object::makeShared(
new ewol::widget::Composer(widget::Composer::String,
myButton->setSubWidget(ewol::widget::Composer::create(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"
" <label exand=\"true,true\" fill=\"true,true\"><![CDATA[" + m_listElement[jjj]->m_label + "]]></label>\n"
" </sizer>\n"
"</composer>\n")));
"</composer>\n"));
} else {
ewol::object::Shared<ewol::widget::Label> tmpLabel = ewol::object::makeShared(new widget::Label(std::string("<left>") + m_listElement[jjj]->m_label + "</left>\n"));
std::shared_ptr<ewol::widget::Label> tmpLabel = widget::Label::create(std::string("<left>") + m_listElement[jjj]->m_label + "</left>\n");
if (tmpLabel != nullptr) {
tmpLabel->setExpand(bvec2(true,false));
tmpLabel->setFill(bvec2(true,true));
@ -226,7 +228,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(shared_from_this(), ewol::widget::Button::eventPressed, widget::Button::eventPressed);
myButton->setExpand(bvec2(true,false));
myButton->setFill(bvec2(true,false));
// add it in the widget list
@ -237,11 +239,10 @@ void ewol::widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
}
}
}
ewol::object::Shared<ewol::widget::Windows> currentWindows = getWindows();
std::shared_ptr<ewol::widget::Windows> currentWindows = getWindows();
if (currentWindows == nullptr) {
EWOL_ERROR("Can not get the curent Windows...");
m_widgetContextMenu->removeObject();
m_widgetContextMenu = nullptr;
m_widgetContextMenu.reset();
} else {
currentWindows->popUpWidgetPush(m_widgetContextMenu);
}
@ -253,7 +254,7 @@ void ewol::widget::Menu::onReceiveMessage(const ewol::object::Message& _msg) {
}
void ewol::widget::Menu::onObjectRemove(const ewol::object::Shared<ewol::Object>& _removeObject) {
void ewol::widget::Menu::onObjectRemove(const std::shared_ptr<ewol::Object>& _removeObject) {
ewol::widget::Sizer::onObjectRemove(_removeObject);
if (m_widgetContextMenu == _removeObject) {
m_widgetContextMenu.reset();

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

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

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

@ -22,16 +22,7 @@ const char* const ewol::widget::PopUp::configLockExpand="lock";
static const char* annimationIncrease = "increase";
static ewol::Widget* create() {
return new ewol::widget::PopUp();
}
void ewol::widget::PopUp::init(ewol::widget::Manager& _widgetManager) {
_widgetManager.addWidgetCreator(__class__,&create);
}
ewol::widget::PopUp::PopUp(const std::string& _shaperName) :
m_shaper(_shaperName),
ewol::widget::PopUp::PopUp() :
m_lockExpand(true,true),
m_closeOutEvent(false) {
addObjectType("ewol::widget::PopUp");
@ -46,6 +37,10 @@ ewol::widget::PopUp::PopUp(const std::string& _shaperName) :
addAnnimationType(ewol::Widget::annimationModeEnableAdd, annimationIncrease);
}
void ewol::widget::PopUp::init(const std::string& _shaperName) {
ewol::widget::Container::init();
m_shaper.setSource(_shaperName);
}
ewol::widget::PopUp::~PopUp() {
}
@ -147,12 +142,12 @@ void ewol::widget::PopUp::onRegenerateDisplay() {
}
}
ewol::object::Shared<ewol::Widget> ewol::widget::PopUp::getWidgetAtPos(const vec2& _pos) {
ewol::object::Shared<ewol::Widget> val = ewol::widget::Container::getWidgetAtPos(_pos);
std::shared_ptr<ewol::Widget> ewol::widget::PopUp::getWidgetAtPos(const vec2& _pos) {
std::shared_ptr<ewol::Widget> val = ewol::widget::Container::getWidgetAtPos(_pos);
if (nullptr != val) {
return val;
}
return this;
return std::dynamic_pointer_cast<ewol::Widget>(shared_from_this());
}
bool ewol::widget::PopUp::onSetConfig(const ewol::object::Config& _conf) {

Some files were not shown because too many files have changed in this diff Show More