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

[DEV] change resource in shgared pointer

Browse Source
This commit is contained in:
Edouard DUPIN 2014-05-20 21:33:04 +02:00
parent 63f50b54d4
commit f72b15664d
48 changed files with 134 additions and 337 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -29,8 +29,7 @@ ewol::compositing::Area::Area(const ivec2& _size) :
} }
ewol::compositing::Area::~Area() { ewol::compositing::Area::~Area() {
ewol::resource::Texture::release(m_resource);
ewol::resource::Program::release(m_GLprogram);
} }
void ewol::compositing::Area::loadProgram() { void ewol::compositing::Area::loadProgram() {

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

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

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

@ -277,7 +277,7 @@ void ewol::compositing::Drawing::resetCount() {
} }
void ewol::compositing::Drawing::unLoadProgram() { void ewol::compositing::Drawing::unLoadProgram() {
ewol::resource::Program::release(m_GLprogram); m_GLprogram.reset();
} }
void ewol::compositing::Drawing::loadProgram() { void ewol::compositing::Drawing::loadProgram() {

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_color; //!< The text foreground color
etk::Color<> m_colorBg; //!< The text background color etk::Color<> m_colorBg; //!< The text background color
private: private:
ewol::resource::Program* m_GLprogram; //!< pointer on the opengl display program ewol::object::Shared<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_GLPosition; //!< openGL id on the element (vertex buffer)
int32_t m_GLMatrix; //!< openGL id on the element (transformation matrix) 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_GLColor; //!< openGL id on the element (color buffer)

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

@ -35,15 +35,12 @@ ewol::compositing::Image::Image(const std::string& _imageName, bool _df) :
} }
ewol::compositing::Image::~Image() { ewol::compositing::Image::~Image() {
ewol::resource::TextureFile::release(m_resource);
ewol::resource::ImageDF::release(m_resourceDF);
ewol::resource::Program::release(m_GLprogram);
} }
void ewol::compositing::Image::loadProgram() { void ewol::compositing::Image::loadProgram() {
// get the shader resource : // get the shader resource :
m_GLPosition = 0; m_GLPosition = 0;
ewol::resource::Program::release(m_GLprogram);
if (m_distanceFieldMode == true) { if (m_distanceFieldMode == true) {
m_GLprogram = ewol::resource::Program::keep("DATA:texturedDF.prog"); m_GLprogram = ewol::resource::Program::keep("DATA:texturedDF.prog");
} else { } else {
@ -249,8 +246,8 @@ void ewol::compositing::Image::printPart(const vec2& _size,
void ewol::compositing::Image::setSource(const std::string& _newFile, const vec2& _size) { void ewol::compositing::Image::setSource(const std::string& _newFile, const vec2& _size) {
clear(); clear();
ewol::resource::TextureFile* resource = m_resource; ewol::object::Shared<ewol::resource::TextureFile> resource = m_resource;
ewol::resource::ImageDF* resourceDF = m_resourceDF; ewol::object::Shared<ewol::resource::ImageDF> resourceDF = m_resourceDF;
m_filename = _newFile; m_filename = _newFile;
m_requestSize = _size; m_requestSize = _size;
m_resource = nullptr; m_resource = nullptr;
@ -281,9 +278,6 @@ void ewol::compositing::Image::setSource(const std::string& _newFile, const vec2
EWOL_WARNING("Retrive previous resource (DF)"); EWOL_WARNING("Retrive previous resource (DF)");
m_resourceDF = resourceDF; m_resourceDF = resourceDF;
} }
} else {
ewol::resource::TextureFile::release(resource);
ewol::resource::ImageDF::release(resourceDF);
} }
} }

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

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

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

@ -57,10 +57,6 @@ ewol::compositing::Shaper::~Shaper() {
} }
void ewol::compositing::Shaper::unLoadProgram() { void ewol::compositing::Shaper::unLoadProgram() {
ewol::resource::Program::release(m_GLprogram);
ewol::resource::TextureFile::release(m_resourceTexture);
ewol::resource::ConfigFile::release(m_config);
ewol::resource::ColorFile::release(m_colorProperty);
for (size_t iii=0; iii<shaperPosCount; ++iii) { for (size_t iii=0; iii<shaperPosCount; ++iii) {
m_confIdPaddingOut[iii] = -1; m_confIdPaddingOut[iii] = -1;
m_confIdBorder[iii] = -1; m_confIdBorder[iii] = -1;

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

@ -44,7 +44,7 @@ namespace ewol {
private: private:
std::string m_name; //!< Name of the configuration of the shaper. std::string m_name; //!< Name of the configuration of the shaper.
// External theme config: // External theme config:
ewol::resource::ConfigFile* m_config; //!< pointer on the config file resources ewol::object::Shared<ewol::resource::ConfigFile> m_config; //!< pointer on the config file resources
int32_t m_confIdDisplayExternal; //!< Display external border 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_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 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_confColorFile; //!< ConfigFile opengGl color file Name
int32_t m_confImageFile; //!< ConfigFile opengGl program Name int32_t m_confImageFile; //!< ConfigFile opengGl program Name
// openGL shaders programs: // openGL shaders programs:
ewol::resource::Program* m_GLprogram; //!< pointer on the opengl display program ewol::object::Shared<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_GLPosition; //!< openGL id on the element (vertex buffer)
int32_t m_GLMatrix; //!< openGL id on the element (transformation matrix) 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)) 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_GLStateTransition; //!< openGL id on the element (transition ofset [0.0..1.0] )
int32_t m_GLtexID; //!< openGL id on the element (texture image) int32_t m_GLtexID; //!< openGL id on the element (texture image)
// For the Image : // For the Image :
ewol::resource::TextureFile* m_resourceTexture; //!< texture resources (for the image) ewol::object::Shared<ewol::resource::TextureFile> m_resourceTexture; //!< texture resources (for the image)
// internal needed data : // internal needed data :
int32_t m_nextStatusRequested; //!< when status is changing, this represent the next step of it int32_t m_nextStatusRequested; //!< when status is changing, this represent the next step of it
vec2 m_propertyOrigin; //!< widget origin vec2 m_propertyOrigin; //!< widget origin
@ -81,7 +81,7 @@ namespace ewol {
vec2 m_pos[SHAPER_NB_MAX_VERTEX]; //!< podition to display property vec2 m_pos[SHAPER_NB_MAX_VERTEX]; //!< podition to display property
int32_t m_nbVertexToDisplay; int32_t m_nbVertexToDisplay;
// color management theme: // color management theme:
ewol::resource::ColorFile* m_colorProperty; //!< input resource for color management ewol::object::Shared<ewol::resource::ColorFile> m_colorProperty; //!< input resource for color management
std::vector<ivec2> m_listAssiciatedId; //!< Corellation ID between ColorProperty (Y) and OpenGL Program (X) std::vector<ivec2> m_listAssiciatedId; //!< Corellation ID between ColorProperty (Y) and OpenGL Program (X)
private: private:
/** /**

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

@ -22,7 +22,7 @@ ewol::compositing::Text::Text(const std::string& _fontName, int32_t _fontSize) :
ewol::compositing::Text::~Text() { ewol::compositing::Text::~Text() {
ewol::resource::TexturedFont::release(m_font);
} }
void ewol::compositing::Text::drawMT(const mat4& _transformationMatrix, bool _enableDepthTest) { void ewol::compositing::Text::drawMT(const mat4& _transformationMatrix, bool _enableDepthTest) {
@ -152,7 +152,7 @@ void ewol::compositing::Text::setFontName(const std::string& _fontName) {
void ewol::compositing::Text::setFont(std::string _fontName, int32_t _fontSize) { void ewol::compositing::Text::setFont(std::string _fontName, int32_t _fontSize) {
clear(); clear();
// remove old one // remove old one
ewol::resource::TexturedFont * previousFont = m_font; ewol::object::Shared<ewol::resource::TexturedFont> previousFont = m_font;
if (_fontSize <= 0) { if (_fontSize <= 0) {
_fontSize = ewol::getContext().getFontDefault().getSize(); _fontSize = ewol::getContext().getFontDefault().getSize();
} }
@ -167,8 +167,6 @@ void ewol::compositing::Text::setFont(std::string _fontName, int32_t _fontSize)
if (m_font == nullptr) { if (m_font == nullptr) {
EWOL_ERROR("Can not get font resource"); EWOL_ERROR("Can not get font resource");
m_font = previousFont; m_font = previousFont;
} else {
ewol::resource::TexturedFont::release(previousFont);
} }
} }

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

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

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

@ -47,13 +47,13 @@ ewol::compositing::TextBase::TextBase(const std::string& _shaderName, bool _load
ewol::compositing::TextBase::~TextBase() { ewol::compositing::TextBase::~TextBase() {
ewol::resource::Program::release(m_GLprogram);
} }
void ewol::compositing::TextBase::loadProgram(const std::string& _shaderName) { void ewol::compositing::TextBase::loadProgram(const std::string& _shaderName) {
// get the shader resource : // get the shader resource :
m_GLPosition = 0; m_GLPosition = 0;
ewol::resource::Program* old = m_GLprogram; ewol::object::Shared<ewol::resource::Program> old = m_GLprogram;
m_GLprogram = ewol::resource::Program::keep(_shaderName); m_GLprogram = ewol::resource::Program::keep(_shaderName);
if (m_GLprogram != nullptr) { if (m_GLprogram != nullptr) {
m_GLPosition = m_GLprogram->getAttribute("EW_coord3d"); m_GLPosition = m_GLprogram->getAttribute("EW_coord3d");
@ -68,8 +68,6 @@ void ewol::compositing::TextBase::loadProgram(const std::string& _shaderName) {
m_GLprogram = old; m_GLprogram = old;
old = nullptr; old = nullptr;
} }
// Release old program if needed ...
ewol::resource::Program::release(old);
} }
void ewol::compositing::TextBase::translate(const vec3& _vect) { void ewol::compositing::TextBase::translate(const vec3& _vect) {

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) 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 ...) enum aligneMode m_alignement; //!< Current Alignement mode (justify/left/right ...)
protected: protected:
ewol::resource::Program* m_GLprogram; //!< pointer on the opengl display program ewol::object::Shared<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_GLPosition; //!< openGL id on the element (vertex buffer)
int32_t m_GLMatrix; //!< openGL id on the element (transformation matrix) 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_GLColor; //!< openGL id on the element (color buffer)

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

@ -26,7 +26,7 @@ ewol::compositing::TextDF::TextDF(const std::string& _fontName, int32_t _fontSiz
ewol::compositing::TextDF::~TextDF() { ewol::compositing::TextDF::~TextDF() {
ewol::resource::DistanceFieldFont::release(m_fontDF);
} }
void ewol::compositing::TextDF::updateSizeToRender(const vec2& _size) { void ewol::compositing::TextDF::updateSizeToRender(const vec2& _size) {
@ -155,7 +155,7 @@ void ewol::compositing::TextDF::setFontSize(int32_t _fontSize) {
void ewol::compositing::TextDF::setFontName(const std::string& _fontName) { void ewol::compositing::TextDF::setFontName(const std::string& _fontName) {
clear(); clear();
// remove old one // remove old one
ewol::resource::DistanceFieldFont* previousFont = m_fontDF; ewol::object::Shared<ewol::resource::DistanceFieldFont> previousFont = m_fontDF;
std::string fontName; std::string fontName;
if (_fontName == "") { if (_fontName == "") {
fontName = ewol::getContext().getFontDefault().getName(); fontName = ewol::getContext().getFontDefault().getName();
@ -168,8 +168,6 @@ void ewol::compositing::TextDF::setFontName(const std::string& _fontName) {
if (m_fontDF == nullptr) { if (m_fontDF == nullptr) {
EWOL_ERROR("Can not get find resource"); EWOL_ERROR("Can not get find resource");
m_fontDF = previousFont; m_fontDF = previousFont;
} else {
ewol::resource::DistanceFieldFont::release(previousFont);
} }
} }

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

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

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

@ -217,9 +217,9 @@ namespace ewol {
template<typename T2, typename T> template<typename T2, typename T>
inline object::Shared<T2> dynamic_pointer_cast(const object::Shared<T>& _obj) noexcept { inline object::Shared<T2> dynamic_pointer_cast(const object::Shared<T>& _obj) noexcept {
if (T2* obj = dynamic_cast<T2*>(_obj.get())) { if (T2* obj = dynamic_cast<T2*>(_obj.get())) {
return object::Shared<T2>(_obj, obj); return ewol::object::Shared<T2>(obj);
} }
return object::Shared<T2>(); return ewol::object::Shared<T2>();
} }
}; };

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

@ -75,12 +75,12 @@ int32_t ewol::resource::ColorFile::request(const std::string& _paramName) {
} }
ewol::resource::ColorFile* ewol::resource::ColorFile::keep(const std::string& _filename) { ewol::object::Shared<ewol::resource::ColorFile> ewol::resource::ColorFile::keep(const std::string& _filename) {
EWOL_INFO("KEEP : ColorFile : file : \"" << _filename << "\""); EWOL_INFO("KEEP : ColorFile : file : \"" << _filename << "\"");
ewol::resource::ColorFile* object = nullptr; ewol::object::Shared<ewol::resource::ColorFile> object = nullptr;
ewol::Resource* object2 = getManager().localKeep(_filename); ewol::object::Shared<ewol::Resource> object2 = getManager().localKeep(_filename);
if (nullptr != object2) { if (nullptr != object2) {
object = dynamic_cast<ewol::resource::ColorFile*>(object2); object = ewol::dynamic_pointer_cast<ewol::resource::ColorFile>(object2);
if (nullptr == object) { if (nullptr == object) {
EWOL_CRITICAL("Request resource file : '" << _filename << "' With the wrong type (dynamic cast error)"); EWOL_CRITICAL("Request resource file : '" << _filename << "' With the wrong type (dynamic cast error)");
return nullptr; return nullptr;
@ -90,7 +90,7 @@ ewol::resource::ColorFile* ewol::resource::ColorFile::keep(const std::string& _f
return object; return object;
} }
// this element create a new one every time .... // this element create a new one every time ....
object = new ewol::resource::ColorFile(_filename); object = ewol::object::makeShared(new ewol::resource::ColorFile(_filename));
if (nullptr == object) { if (nullptr == object) {
EWOL_ERROR("allocation error of a resource : " << _filename); EWOL_ERROR("allocation error of a resource : " << _filename);
return nullptr; return nullptr;
@ -99,14 +99,3 @@ ewol::resource::ColorFile* ewol::resource::ColorFile::keep(const std::string& _f
return object; return object;
} }
void ewol::resource::ColorFile::release(ewol::resource::ColorFile*& _object) {
if (nullptr == _object) {
return;
}
ewol::Resource* object2 = static_cast<ewol::Resource*>(_object);
getManager().release(object2);
_object = nullptr;
}

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

@ -30,6 +30,7 @@ namespace ewol {
* @param[in] _filename Name of the file needed * @param[in] _filename Name of the file needed
*/ */
ColorFile(const std::string& _filename); ColorFile(const std::string& _filename);
public:
/** /**
* @brief Simple Destructor of this class (nothing specific ...) * @brief Simple Destructor of this class (nothing specific ...)
*/ */
@ -75,12 +76,7 @@ namespace ewol {
* @param[in] _filename Name of the configuration file. * @param[in] _filename Name of the configuration file.
* @return pointer on the resource or nullptr if an error occured. * @return pointer on the resource or nullptr if an error occured.
*/ */
static ewol::resource::ColorFile* keep(const std::string& _filename); static ewol::object::Shared<ewol::resource::ColorFile> keep(const std::string& _filename);
/**
* @brief release the keeped resources
* @param[in,out] reference on the object pointer
*/
static void release(ewol::resource::ColorFile*& _object);
}; };
}; };
}; };

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

@ -28,8 +28,7 @@ ewol::resource::Colored3DObject::Colored3DObject() :
} }
ewol::resource::Colored3DObject::~Colored3DObject() { ewol::resource::Colored3DObject::~Colored3DObject() {
// remove dynamics dependencies :
ewol::resource::Program::release(m_GLprogram);
} }
@ -155,11 +154,11 @@ void ewol::resource::Colored3DObject::drawLine(std::vector<vec3>& _vertices,
} }
} }
ewol::resource::Colored3DObject* ewol::resource::Colored3DObject::keep() { ewol::object::Shared<ewol::resource::Colored3DObject> ewol::resource::Colored3DObject::keep() {
EWOL_VERBOSE("KEEP : direct Colored3DObject"); EWOL_VERBOSE("KEEP : direct Colored3DObject");
// need to crate a new one ... // need to crate a new one ...
ewol::resource::Colored3DObject* object = new ewol::resource::Colored3DObject(); ewol::object::Shared<ewol::resource::Colored3DObject> object = ewol::object::makeShared(new ewol::resource::Colored3DObject());
if (nullptr == object) { if (object == nullptr) {
EWOL_ERROR("allocation error of a resource : ???Colored3DObject??? "); EWOL_ERROR("allocation error of a resource : ???Colored3DObject??? ");
return nullptr; return nullptr;
} }
@ -167,11 +166,3 @@ ewol::resource::Colored3DObject* ewol::resource::Colored3DObject::keep() {
return object; return object;
} }
void ewol::resource::Colored3DObject::release(ewol::resource::Colored3DObject*& _object) {
if (nullptr == _object) {
return;
}
ewol::Resource* object2 = static_cast<ewol::Resource*>(_object);
getManager().release(object2);
_object = nullptr;
}

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

@ -19,12 +19,13 @@ namespace ewol {
namespace resource { namespace resource {
class Colored3DObject : public ewol::Resource { class Colored3DObject : public ewol::Resource {
protected: protected:
ewol::resource::Program* m_GLprogram; ewol::object::Shared<ewol::resource::Program> m_GLprogram;
int32_t m_GLPosition; int32_t m_GLPosition;
int32_t m_GLMatrix; int32_t m_GLMatrix;
int32_t m_GLColor; int32_t m_GLColor;
protected: protected:
Colored3DObject(); Colored3DObject();
public:
virtual ~Colored3DObject(); virtual ~Colored3DObject();
public: public:
virtual void draw(std::vector<vec3>& _vertices, virtual void draw(std::vector<vec3>& _vertices,
@ -47,12 +48,7 @@ namespace ewol {
* @note Never free this pointer by your own... * @note Never free this pointer by your own...
* @return pointer on the resource or nullptr if an error occured. * @return pointer on the resource or nullptr if an error occured.
*/ */
static ewol::resource::Colored3DObject* keep(); static ewol::object::Shared<ewol::resource::Colored3DObject> keep();
/**
* @brief release the keeped resources
* @param[in,out] reference on the object pointer
*/
static void release(ewol::resource::Colored3DObject*& _object);
}; };
}; };
}; };

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

@ -104,12 +104,12 @@ bool ewol::resource::ConfigFile::getBoolean(int32_t _id) {
return tmp->get(); return tmp->get();
} }
ewol::resource::ConfigFile* ewol::resource::ConfigFile::keep(const std::string& _filename) { ewol::object::Shared<ewol::resource::ConfigFile> ewol::resource::ConfigFile::keep(const std::string& _filename) {
EWOL_INFO("KEEP : SimpleConfig : file : \"" << _filename << "\""); EWOL_INFO("KEEP : SimpleConfig : file : \"" << _filename << "\"");
ewol::resource::ConfigFile* object = nullptr; ewol::object::Shared<ewol::resource::ConfigFile> object = nullptr;
ewol::Resource* object2 = getManager().localKeep(_filename); ewol::object::Shared<ewol::Resource> object2 = getManager().localKeep(_filename);
if (nullptr != object2) { if (nullptr != object2) {
object = dynamic_cast<ewol::resource::ConfigFile*>(object2); object = ewol::dynamic_pointer_cast<ewol::resource::ConfigFile>(object2);
if (nullptr == object) { if (nullptr == object) {
EWOL_CRITICAL("Request resource file : '" << _filename << "' With the wrong type (dynamic cast error)"); EWOL_CRITICAL("Request resource file : '" << _filename << "' With the wrong type (dynamic cast error)");
return nullptr; return nullptr;
@ -119,7 +119,7 @@ ewol::resource::ConfigFile* ewol::resource::ConfigFile::keep(const std::string&
return object; return object;
} }
// this element create a new one every time .... // this element create a new one every time ....
object = new ewol::resource::ConfigFile(_filename); object = ewol::object::makeShared(new ewol::resource::ConfigFile(_filename));
if (nullptr == object) { if (nullptr == object) {
EWOL_ERROR("allocation error of a resource : '" << _filename << "'"); EWOL_ERROR("allocation error of a resource : '" << _filename << "'");
return nullptr; return nullptr;
@ -128,14 +128,5 @@ ewol::resource::ConfigFile* ewol::resource::ConfigFile::keep(const std::string&
return object; return object;
} }
void ewol::resource::ConfigFile::release(ewol::resource::ConfigFile*& _object) {
if (nullptr == _object) {
return;
}
ewol::Resource* object2 = static_cast<ewol::Resource*>(_object);
getManager().release(object2);
_object = nullptr;
}

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

@ -23,6 +23,7 @@ namespace ewol {
etk::Hash<ejson::Value*> m_list; etk::Hash<ejson::Value*> m_list;
protected: protected:
ConfigFile(const std::string& _filename); ConfigFile(const std::string& _filename);
public:
virtual ~ConfigFile(); virtual ~ConfigFile();
public: public:
void reload(); void reload();
@ -39,12 +40,7 @@ namespace ewol {
* @param[in] _filename Name of the configuration file. * @param[in] _filename Name of the configuration file.
* @return pointer on the resource or nullptr if an error occured. * @return pointer on the resource or nullptr if an error occured.
*/ */
static ewol::resource::ConfigFile* keep(const std::string& _filename); static ewol::object::Shared<ewol::resource::ConfigFile> keep(const std::string& _filename);
/**
* @brief release the keeped resources
* @param[in,out] reference on the object pointer
*/
static void release(ewol::resource::ConfigFile*& _object);
}; };
}; };
}; };

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

@ -121,7 +121,7 @@ ewol::resource::DistanceFieldFont::DistanceFieldFont(const std::string& _fontNam
} }
ewol::resource::DistanceFieldFont::~DistanceFieldFont() { ewol::resource::DistanceFieldFont::~DistanceFieldFont() {
ewol::resource::FontFreeType::release(m_font);
} }
@ -335,12 +335,12 @@ ewol::GlyphProperty* ewol::resource::DistanceFieldFont::getGlyphPointer(const ch
return &((m_listElement)[index]); return &((m_listElement)[index]);
} }
ewol::resource::DistanceFieldFont* ewol::resource::DistanceFieldFont::keep(const std::string& _filename) { ewol::object::Shared<ewol::resource::DistanceFieldFont> ewol::resource::DistanceFieldFont::keep(const std::string& _filename) {
EWOL_VERBOSE("KEEP : DistanceFieldFont : file : '" << _filename << "'"); EWOL_VERBOSE("KEEP : DistanceFieldFont : file : '" << _filename << "'");
ewol::resource::DistanceFieldFont* object = nullptr; ewol::object::Shared<ewol::resource::DistanceFieldFont> object = nullptr;
ewol::Resource* object2 = getManager().localKeep(_filename); ewol::object::Shared<ewol::Resource> object2 = getManager().localKeep(_filename);
if (nullptr != object2) { if (nullptr != object2) {
object = dynamic_cast<ewol::resource::DistanceFieldFont*>(object2); object = ewol::dynamic_pointer_cast<ewol::resource::DistanceFieldFont>(object2);
if (nullptr == object) { if (nullptr == object) {
EWOL_CRITICAL("Request resource file : '" << _filename << "' With the wrong type (dynamic cast error)"); EWOL_CRITICAL("Request resource file : '" << _filename << "' With the wrong type (dynamic cast error)");
return nullptr; return nullptr;
@ -351,7 +351,7 @@ ewol::resource::DistanceFieldFont* ewol::resource::DistanceFieldFont::keep(const
} }
// need to crate a new one ... // need to crate a new one ...
EWOL_DEBUG("CREATE: DistanceFieldFont : file : '" << _filename << "'"); EWOL_DEBUG("CREATE: DistanceFieldFont : file : '" << _filename << "'");
object = new ewol::resource::DistanceFieldFont(_filename); object = ewol::object::makeShared(new ewol::resource::DistanceFieldFont(_filename));
if (nullptr == object) { if (nullptr == object) {
EWOL_ERROR("allocation error of a resource : " << _filename); EWOL_ERROR("allocation error of a resource : " << _filename);
return nullptr; return nullptr;
@ -360,19 +360,6 @@ ewol::resource::DistanceFieldFont* ewol::resource::DistanceFieldFont::keep(const
return object; return object;
} }
void ewol::resource::DistanceFieldFont::release(ewol::resource::DistanceFieldFont*& _object) {
if (nullptr == _object) {
return;
}
std::string name = _object->getName();
int32_t count = _object->getCounter() - 1;
ewol::Resource* object2 = static_cast<ewol::Resource*>(_object);
if (getManager().release(object2) == true) {
EWOL_DEBUG("REMOVE: DistanceFieldFont : file : '" << name << "' count=" << count);
//etk::displayBacktrace(false);
}
_object = nullptr;
}
void ewol::resource::DistanceFieldFont::exportOnFile() { void ewol::resource::DistanceFieldFont::exportOnFile() {
EWOL_DEBUG("EXPORT: DistanceFieldFont : file : '" << m_fileName << ".json'"); EWOL_DEBUG("EXPORT: DistanceFieldFont : file : '" << m_fileName << ".json'");

10
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... // specific element to have the the know if the specify element is known...
// == > otherwise I can just generate italic ... // == > otherwise I can just generate italic ...
// == > Bold is a little more complicated (maybe with the bordersize) // == > Bold is a little more complicated (maybe with the bordersize)
ewol::resource::FontBase* m_font; ewol::object::Shared<ewol::resource::FontBase> m_font;
public: public:
std::vector<GlyphProperty> m_listElement; std::vector<GlyphProperty> m_listElement;
private: private:
@ -32,6 +32,7 @@ namespace ewol {
int32_t m_lastRawHeigh; int32_t m_lastRawHeigh;
protected: protected:
DistanceFieldFont(const std::string& _fontName); DistanceFieldFont(const std::string& _fontName);
public:
~DistanceFieldFont(); ~DistanceFieldFont();
public: public:
float getDisplayRatio(float _size); float getDisplayRatio(float _size);
@ -70,12 +71,7 @@ namespace ewol {
* @param[in] _filename Name of the texture font. * @param[in] _filename Name of the texture font.
* @return pointer on the resource or nullptr if an error occured. * @return pointer on the resource or nullptr if an error occured.
*/ */
static ewol::resource::DistanceFieldFont* keep(const std::string& _filename); static ewol::object::Shared<ewol::resource::DistanceFieldFont> keep(const std::string& _filename);
/**
* @brief release the keeped resources
* @param[in,out] reference on the object pointer
*/
static void release(ewol::resource::DistanceFieldFont*& _object);
private: private:
/** /**
* @brief add a glyph in a texture font. * @brief add a glyph in a texture font.

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

@ -390,12 +390,12 @@ void ewol::resource::FontFreeType::display() {
//EWOL_INFO(" Current size = " << (int)m_fftFace->size); //EWOL_INFO(" Current size = " << (int)m_fftFace->size);
} }
ewol::resource::FontBase* ewol::resource::FontFreeType::keep(const std::string& _filename) { ewol::object::Shared<ewol::resource::FontBase> ewol::resource::FontFreeType::keep(const std::string& _filename) {
EWOL_VERBOSE("KEEP : Font : file : \"" << _filename << "\""); EWOL_VERBOSE("KEEP : Font : file : \"" << _filename << "\"");
ewol::resource::FontBase* object = nullptr; ewol::object::Shared<ewol::resource::FontBase> object = nullptr;
ewol::Resource* object2 = getManager().localKeep(_filename); ewol::object::Shared<ewol::Resource> object2 = getManager().localKeep(_filename);
if (nullptr != object2) { if (nullptr != object2) {
object = dynamic_cast<ewol::resource::FontBase*>(object2); object = ewol::dynamic_pointer_cast<ewol::resource::FontBase>(object2);
if (nullptr == object) { if (nullptr == object) {
EWOL_CRITICAL("Request resource file : '" << _filename << "' With the wrong type (dynamic cast error)"); EWOL_CRITICAL("Request resource file : '" << _filename << "' With the wrong type (dynamic cast error)");
return nullptr; return nullptr;
@ -405,7 +405,7 @@ ewol::resource::FontBase* ewol::resource::FontFreeType::keep(const std::string&
return object; return object;
} }
// need to crate a new one ... // need to crate a new one ...
object = new ewol::resource::FontFreeType(_filename); object = ewol::object::makeShared(new ewol::resource::FontFreeType(_filename));
if (nullptr == object) { if (nullptr == object) {
EWOL_ERROR("allocation error of a resource : " << _filename); EWOL_ERROR("allocation error of a resource : " << _filename);
return nullptr; return nullptr;
@ -413,13 +413,3 @@ ewol::resource::FontBase* ewol::resource::FontFreeType::keep(const std::string&
getManager().localAdd(object); getManager().localAdd(object);
return object; return object;
} }
void ewol::resource::FontFreeType::release(ewol::resource::FontBase*& _object) {
if (nullptr == _object) {
return;
}
ewol::Resource* object2 = static_cast<ewol::Resource*>(_object);
getManager().release(object2);
_object = nullptr;
}

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

@ -30,6 +30,7 @@ namespace ewol {
void display(); void display();
protected: protected:
FontFreeType(const std::string& _fontName); FontFreeType(const std::string& _fontName);
public:
~FontFreeType(); ~FontFreeType();
public: public:
@ -60,12 +61,7 @@ namespace ewol {
* @param[in] _filename Name of the base font. * @param[in] _filename Name of the base font.
* @return pointer on the resource or nullptr if an error occured. * @return pointer on the resource or nullptr if an error occured.
*/ */
static ewol::resource::FontBase* keep(const std::string& _filename); static ewol::object::Shared<ewol::resource::FontBase> keep(const std::string& _filename);
/**
* @brief release the keeped resources
* @param[in,out] reference on the object pointer
*/
static void release(ewol::resource::FontBase*& _object);
}; };
void freeTypeInit(); void freeTypeInit();
void freeTypeUnInit(); void freeTypeUnInit();

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

@ -62,10 +62,10 @@ static int32_t nextP2(int32_t _value) {
ewol::resource::TextureFile* ewol::resource::TextureFile::keep(const std::string& _filename, ivec2 _size) { ewol::object::Shared<ewol::resource::TextureFile> ewol::resource::TextureFile::keep(const std::string& _filename, ivec2 _size) {
EWOL_VERBOSE("KEEP: TextureFile: '" << _filename << "' size=" << _size); EWOL_VERBOSE("KEEP: TextureFile: '" << _filename << "' size=" << _size);
if (_filename == "") { if (_filename == "") {
ewol::resource::TextureFile* object = new ewol::resource::TextureFile(""); ewol::object::Shared<ewol::resource::TextureFile> object = ewol::object::makeShared(new ewol::resource::TextureFile(""));
if (nullptr == object) { if (nullptr == object) {
EWOL_ERROR("allocation error of a resource : ??TEX??"); EWOL_ERROR("allocation error of a resource : ??TEX??");
return nullptr; return nullptr;
@ -101,10 +101,10 @@ ewol::resource::TextureFile* ewol::resource::TextureFile::keep(const std::string
} }
EWOL_VERBOSE("KEEP: TextureFile: '" << TmpFilename << "' new size=" << _size); EWOL_VERBOSE("KEEP: TextureFile: '" << TmpFilename << "' new size=" << _size);
ewol::resource::TextureFile* object = nullptr; ewol::object::Shared<ewol::resource::TextureFile> object = nullptr;
ewol::Resource* object2 = getManager().localKeep(TmpFilename); ewol::object::Shared<ewol::Resource> object2 = getManager().localKeep(TmpFilename);
if (nullptr != object2) { if (nullptr != object2) {
object = dynamic_cast<ewol::resource::TextureFile*>(object2); object = ewol::dynamic_pointer_cast<ewol::resource::TextureFile>(object2);
if (nullptr == object) { if (nullptr == object) {
EWOL_CRITICAL("Request resource file : '" << TmpFilename << "' With the wrong type (dynamic cast error)"); EWOL_CRITICAL("Request resource file : '" << TmpFilename << "' With the wrong type (dynamic cast error)");
return nullptr; return nullptr;
@ -115,7 +115,7 @@ ewol::resource::TextureFile* ewol::resource::TextureFile::keep(const std::string
} }
EWOL_INFO("CREATE: TextureFile: '" << TmpFilename << "' size=" << _size); EWOL_INFO("CREATE: TextureFile: '" << TmpFilename << "' size=" << _size);
// need to crate a new one ... // need to crate a new one ...
object = new ewol::resource::TextureFile(TmpFilename, _filename, _size); object = ewol::object::makeShared(new ewol::resource::TextureFile(TmpFilename, _filename, _size));
if (nullptr == object) { if (nullptr == object) {
EWOL_ERROR("allocation error of a resource : " << _filename); EWOL_ERROR("allocation error of a resource : " << _filename);
return nullptr; return nullptr;
@ -123,14 +123,3 @@ ewol::resource::TextureFile* ewol::resource::TextureFile::keep(const std::string
getManager().localAdd(object); getManager().localAdd(object);
return object; return object;
} }
void ewol::resource::TextureFile::release(ewol::resource::TextureFile*& _object) {
if (nullptr == _object) {
return;
}
ewol::Resource* object2 = static_cast<ewol::Resource*>(_object);
getManager().release(object2);
_object = nullptr;
}

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

@ -23,6 +23,7 @@ namespace ewol {
private: private:
TextureFile(const std::string& _genName); TextureFile(const std::string& _genName);
TextureFile(std::string _genName, const std::string& _fileName, const ivec2& _size); TextureFile(std::string _genName, const std::string& _fileName, const ivec2& _size);
public:
virtual ~TextureFile() { }; virtual ~TextureFile() { };
public: public:
const vec2& getRealSize() { const vec2& getRealSize() {
@ -36,12 +37,7 @@ namespace ewol {
* @param[in] _requested size of the image (usefull when loading .svg to automatic rescale) * @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. * @return pointer on the resource or nullptr if an error occured.
*/ */
static ewol::resource::TextureFile* keep(const std::string& _filename, ivec2 _size=ivec2(-1,-1)); static ewol::object::Shared<ewol::resource::TextureFile> keep(const std::string& _filename, ivec2 _size=ivec2(-1,-1));
/**
* @brief release the keeped resources
* @param[in,out] reference on the object pointer
*/
static void release(ewol::resource::TextureFile*& _object);
}; };
}; };
}; };

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

@ -151,10 +151,10 @@ static int32_t nextP2(int32_t _value) {
ewol::resource::ImageDF* ewol::resource::ImageDF::keep(const std::string& _filename, ivec2 _size) { ewol::object::Shared<ewol::resource::ImageDF> ewol::resource::ImageDF::keep(const std::string& _filename, ivec2 _size) {
EWOL_VERBOSE("KEEP: TextureFile: '" << _filename << "' size=" << _size); EWOL_VERBOSE("KEEP: TextureFile: '" << _filename << "' size=" << _size);
if (_filename == "") { if (_filename == "") {
ewol::resource::ImageDF* object = new ewol::resource::ImageDF(""); ewol::object::Shared<ewol::resource::ImageDF> object = ewol::object::makeShared(new ewol::resource::ImageDF(""));
if (nullptr == object) { if (nullptr == object) {
EWOL_ERROR("allocation error of a resource : ??TEX??"); EWOL_ERROR("allocation error of a resource : ??TEX??");
return nullptr; return nullptr;
@ -190,10 +190,10 @@ ewol::resource::ImageDF* ewol::resource::ImageDF::keep(const std::string& _filen
} }
EWOL_VERBOSE("KEEP: TextureFile: '" << TmpFilename << "' new size=" << _size); EWOL_VERBOSE("KEEP: TextureFile: '" << TmpFilename << "' new size=" << _size);
ewol::resource::ImageDF* object = nullptr; ewol::object::Shared<ewol::resource::ImageDF> object = nullptr;
ewol::Resource* object2 = getManager().localKeep("DF__" + TmpFilename); ewol::object::Shared<ewol::Resource> object2 = getManager().localKeep("DF__" + TmpFilename);
if (nullptr != object2) { if (nullptr != object2) {
object = dynamic_cast<ewol::resource::ImageDF*>(object2); object = ewol::dynamic_pointer_cast<ewol::resource::ImageDF>(object2);
if (nullptr == object) { if (nullptr == object) {
EWOL_CRITICAL("Request resource file : '" << TmpFilename << "' With the wrong type (dynamic cast error)"); EWOL_CRITICAL("Request resource file : '" << TmpFilename << "' With the wrong type (dynamic cast error)");
return nullptr; return nullptr;
@ -204,7 +204,7 @@ ewol::resource::ImageDF* ewol::resource::ImageDF::keep(const std::string& _filen
} }
EWOL_INFO("CREATE: ImageDF: '" << TmpFilename << "' size=" << _size); EWOL_INFO("CREATE: ImageDF: '" << TmpFilename << "' size=" << _size);
// need to crate a new one ... // need to crate a new one ...
object = new ewol::resource::ImageDF("DF__" + TmpFilename, _filename, _size); object = ewol::object::makeShared(new ewol::resource::ImageDF("DF__" + TmpFilename, _filename, _size));
if (nullptr == object) { if (nullptr == object) {
EWOL_ERROR("allocation error of a resource : " << _filename); EWOL_ERROR("allocation error of a resource : " << _filename);
return nullptr; return nullptr;
@ -213,13 +213,3 @@ ewol::resource::ImageDF* ewol::resource::ImageDF::keep(const std::string& _filen
return object; return object;
} }
void ewol::resource::ImageDF::release(ewol::resource::ImageDF*& _object) {
if (nullptr == _object) {
return;
}
ewol::Resource* object2 = static_cast<ewol::Resource*>(_object);
getManager().release(object2);
_object = nullptr;
}

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

@ -24,7 +24,9 @@ namespace ewol {
protected: protected:
ImageDF(const std::string& _genName); ImageDF(const std::string& _genName);
ImageDF(std::string _genName, const std::string& _fileName, const ivec2& _size); ImageDF(std::string _genName, const std::string& _fileName, const ivec2& _size);
public:
virtual ~ImageDF() { }; virtual ~ImageDF() { };
protected:
/** /**
* @brief Generate distance field of this Image input. * @brief Generate distance field of this Image input.
* @param[in] _input Input image to change in distance field mode. * @param[in] _input Input image to change in distance field mode.
@ -43,12 +45,7 @@ namespace ewol {
* @param[in] _requested size of the image (usefull when loading .svg to automatic rescale) * @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. * @return pointer on the resource or nullptr if an error occured.
*/ */
static ewol::resource::ImageDF* keep(const std::string& _filename, ivec2 _size=ivec2(-1,-1)); static ewol::object::Shared<ewol::resource::ImageDF> keep(const std::string& _filename, ivec2 _size=ivec2(-1,-1));
/**
* @brief release the keeped resources
* @param[in,out] reference on the object pointer
*/
static void release(ewol::resource::ImageDF*& _object);
}; };
}; };
}; };

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

@ -45,8 +45,7 @@ void ewol::resource::Manager::unInit() {
EWOL_WARNING("Find a resource that is not removed : [" << m_resourceList[iii]->getId() << "]" EWOL_WARNING("Find a resource that is not removed : [" << m_resourceList[iii]->getId() << "]"
<< "=\"" << m_resourceList[iii]->getName() << "\" " << "=\"" << m_resourceList[iii]->getName() << "\" "
<< m_resourceList[iii]->getCounter() << " elements"); << m_resourceList[iii]->getCounter() << " elements");
delete(m_resourceList[iii]); m_resourceList[iii].reset();
m_resourceList[iii] = nullptr;
} }
} }
m_resourceList.clear(); m_resourceList.clear();
@ -87,7 +86,7 @@ void ewol::resource::Manager::reLoadResources() {
EWOL_INFO("------------- Resources -------------"); EWOL_INFO("------------- Resources -------------");
} }
void ewol::resource::Manager::update(ewol::Resource* _object) { void ewol::resource::Manager::update(const ewol::object::Shared<ewol::Resource>& _object) {
// chek if not added before // chek if not added before
for (size_t iii=0; iii<m_resourceListToUpdate.size(); iii++) { for (size_t iii=0; iii<m_resourceListToUpdate.size(); iii++) {
if (m_resourceListToUpdate[iii] != nullptr) { if (m_resourceListToUpdate[iii] != nullptr) {
@ -149,7 +148,7 @@ void ewol::resource::Manager::contextHasBeenDestroyed() {
} }
// internal generic keeper ... // internal generic keeper ...
ewol::Resource* ewol::resource::Manager::localKeep(const std::string& _filename) { ewol::object::Shared<ewol::Resource> ewol::resource::Manager::localKeep(const std::string& _filename) {
EWOL_VERBOSE("KEEP (DEFAULT) : file : \"" << _filename << "\""); EWOL_VERBOSE("KEEP (DEFAULT) : file : \"" << _filename << "\"");
for (size_t iii=0; iii<m_resourceList.size(); iii++) { for (size_t iii=0; iii<m_resourceList.size(); iii++) {
if (m_resourceList[iii] != nullptr) { if (m_resourceList[iii] != nullptr) {
@ -164,7 +163,7 @@ ewol::Resource* ewol::resource::Manager::localKeep(const std::string& _filename)
} }
// internal generic keeper ... // internal generic keeper ...
void ewol::resource::Manager::localAdd(ewol::Resource* _object) { void ewol::resource::Manager::localAdd(const ewol::object::Shared<ewol::Resource>& _object) {
//Add ... find empty slot //Add ... find empty slot
for (size_t iii=0; iii<m_resourceList.size(); iii++) { for (size_t iii=0; iii<m_resourceList.size(); iii++) {
if (m_resourceList[iii] == nullptr) { if (m_resourceList[iii] == nullptr) {
@ -175,8 +174,8 @@ void ewol::resource::Manager::localAdd(ewol::Resource* _object) {
// add at the end if no slot is free // add at the end if no slot is free
m_resourceList.push_back(_object); m_resourceList.push_back(_object);
} }
/*
bool ewol::resource::Manager::release(ewol::Resource*& _object) { bool ewol::resource::Manager::release(ewol::object::Shared<ewol::Resource> _object) {
if (nullptr == _object) { if (nullptr == _object) {
EWOL_ERROR("Try to remove a resource that have null pointer ..."); EWOL_ERROR("Try to remove a resource that have null pointer ...");
return false; return false;
@ -213,19 +212,19 @@ bool ewol::resource::Manager::release(ewol::Resource*& _object) {
_object = nullptr; _object = nullptr;
return false; return false;
} }
*/
// in case of error ... // in case of error ...
void ewol::resource::Manager::onObjectRemove(const ewol::object::Shared<ewol::Object>& _removeObject) { void ewol::resource::Manager::onObjectRemove(const ewol::object::Shared<ewol::Object>& _removeObject) {
for (size_t iii=0; iii<m_resourceList.size(); ++iii) { for (size_t iii=0; iii<m_resourceList.size(); ++iii) {
if (m_resourceList[iii] == _removeObject) { if (m_resourceList[iii] == _removeObject) {
EWOL_WARNING("Remove Resource that is not removed ... "); EWOL_WARNING("Remove Resource that is not removed ... ");
m_resourceList[iii] = nullptr; m_resourceList[iii].reset();
} }
} }
for (size_t iii=0; iii<m_resourceListToUpdate.size(); ++iii) { for (size_t iii=0; iii<m_resourceListToUpdate.size(); ++iii) {
if (m_resourceListToUpdate[iii] == _removeObject) { if (m_resourceListToUpdate[iii] == _removeObject) {
EWOL_WARNING("Remove Resource that is not removed .2. "); EWOL_WARNING("Remove Resource that is not removed .2. ");
m_resourceListToUpdate[iii] = nullptr; m_resourceListToUpdate[iii].reset();
} }
} }
} }

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

@ -17,8 +17,8 @@ namespace ewol {
namespace resource { namespace resource {
class Manager { class Manager {
private: private:
std::vector<ewol::Resource*> m_resourceList; std::vector<ewol::object::Owner<ewol::Resource>> m_resourceList;
std::vector<ewol::Resource*> m_resourceListToUpdate; std::vector<ewol::object::Shared<ewol::Resource>> m_resourceListToUpdate;
bool m_contextHasBeenRemoved; bool m_contextHasBeenRemoved;
public: public:
/** /**
@ -47,7 +47,7 @@ namespace ewol {
* @brief Call by the system to send all the needed data on the graphic card chen they change ... * @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 * @param[in] _object The resources that might be updated
*/ */
void update(ewol::Resource* _object); void update(const ewol::object::Shared<ewol::Resource>& _object);
/** /**
* @brief Call by the system chen the openGL Context has been unexpectially removed == > This reload all the texture, VBO and other .... * @brief Call by the system chen the openGL Context has been unexpectially removed == > This reload all the texture, VBO and other ....
*/ */
@ -58,15 +58,8 @@ namespace ewol {
void contextHasBeenDestroyed(); void contextHasBeenDestroyed();
public: public:
// internal API to extent eResources in extern Soft // internal API to extent eResources in extern Soft
ewol::Resource* localKeep(const std::string& _filename); ewol::object::Shared<ewol::Resource> localKeep(const std::string& _filename);
void localAdd(ewol::Resource* _object); void localAdd(const ewol::object::Shared<ewol::Resource>& _object);
public:
/**
* @brief release a resources and free it if the Last release is call.
* @param[in,out] _object element to realease == > is return at nullptr value.
* @return true, if element is removed, and false for just decreasing counter
*/
bool release(ewol::Resource*& _object);
public: // herited function public: // herited function
virtual void onObjectRemove(const ewol::object::Shared<ewol::Object>& _removeObject); virtual void onObjectRemove(const ewol::object::Shared<ewol::Object>& _removeObject);
}; };

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

@ -36,7 +36,7 @@ ewol::resource::Program::Program(const std::string& _filename) :
std::string tmpFilename = m_name; std::string tmpFilename = m_name;
// remove extention ... // remove extention ...
tmpFilename.erase(tmpFilename.size()-4, 4); tmpFilename.erase(tmpFilename.size()-4, 4);
ewol::resource::Shader* tmpShader = ewol::resource::Shader::keep(tmpFilename+"vert"); ewol::object::Shared<ewol::resource::Shader> tmpShader = ewol::resource::Shader::keep(tmpFilename+"vert");
if (nullptr == tmpShader) { if (nullptr == tmpShader) {
EWOL_CRITICAL("Error while getting a specific shader filename : " << tmpFilename); EWOL_CRITICAL("Error while getting a specific shader filename : " << tmpFilename);
return; return;
@ -80,7 +80,7 @@ ewol::resource::Program::Program(const std::string& _filename) :
} }
// get it with relative position : // get it with relative position :
std::string tmpFilename = file.getRelativeFolder() + tmpData; std::string tmpFilename = file.getRelativeFolder() + tmpData;
ewol::resource::Shader* tmpShader = ewol::resource::Shader::keep(tmpFilename); ewol::object::Shared<ewol::resource::Shader> tmpShader = ewol::resource::Shader::keep(tmpFilename);
if (nullptr == tmpShader) { if (nullptr == tmpShader) {
EWOL_CRITICAL("Error while getting a specific shader filename : " << tmpFilename); EWOL_CRITICAL("Error while getting a specific shader filename : " << tmpFilename);
} else { } else {
@ -96,10 +96,6 @@ ewol::resource::Program::Program(const std::string& _filename) :
} }
ewol::resource::Program::~Program() { ewol::resource::Program::~Program() {
for (size_t iii=0; iii<m_shaderList.size(); iii++) {
ewol::resource::Shader::release(m_shaderList[iii]);
m_shaderList[iii] = 0;
}
m_shaderList.clear(); m_shaderList.clear();
removeContext(); removeContext();
m_elementList.clear(); m_elementList.clear();
@ -775,12 +771,12 @@ void ewol::resource::Program::unUse() {
ewol::resource::Program* ewol::resource::Program::keep(const std::string& _filename) { ewol::object::Shared<ewol::resource::Program> ewol::resource::Program::keep(const std::string& _filename) {
EWOL_VERBOSE("KEEP : Program : file : \"" << _filename << "\""); EWOL_VERBOSE("KEEP : Program : file : \"" << _filename << "\"");
ewol::resource::Program* object = nullptr; ewol::object::Shared<ewol::resource::Program> object = nullptr;
ewol::Resource* object2 = getManager().localKeep(_filename); ewol::object::Shared<ewol::Resource> object2 = getManager().localKeep(_filename);
if (nullptr != object2) { if (nullptr != object2) {
object = dynamic_cast<ewol::resource::Program*>(object2); object = ewol::dynamic_pointer_cast<ewol::resource::Program>(object2);
if (nullptr == object) { if (nullptr == object) {
EWOL_CRITICAL("Request resource file : '" << _filename << "' With the wrong type (dynamic cast error)"); EWOL_CRITICAL("Request resource file : '" << _filename << "' With the wrong type (dynamic cast error)");
return nullptr; return nullptr;
@ -790,7 +786,7 @@ ewol::resource::Program* ewol::resource::Program::keep(const std::string& _filen
return object; return object;
} }
// need to crate a new one ... // need to crate a new one ...
object = new ewol::resource::Program(_filename); object = ewol::object::makeShared(new ewol::resource::Program(_filename));
if (nullptr == object) { if (nullptr == object) {
EWOL_ERROR("allocation error of a resource : " << _filename); EWOL_ERROR("allocation error of a resource : " << _filename);
return nullptr; return nullptr;
@ -798,13 +794,3 @@ ewol::resource::Program* ewol::resource::Program::keep(const std::string& _filen
getManager().localAdd(object); getManager().localAdd(object);
return object; return object;
} }
void ewol::resource::Program::release(ewol::resource::Program*& _object) {
if (nullptr == _object) {
return;
}
ewol::Resource* object2 = static_cast<ewol::Resource*>(_object);
getManager().release(object2);
_object = nullptr;
}

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

@ -50,7 +50,7 @@ namespace ewol {
private : private :
bool m_exist; //!< the file existed bool m_exist; //!< the file existed
GLuint m_program; //!< openGL id of the current program GLuint m_program; //!< openGL id of the current program
std::vector<ewol::resource::Shader*> m_shaderList; //!< List of all the shader loaded std::vector<ewol::object::Shared<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 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_hasTexture; //!< A texture has been set to the current shader
bool m_hasTexture1; //!< A texture has been set to the current shader bool m_hasTexture1; //!< A texture has been set to the current shader
@ -60,6 +60,7 @@ namespace ewol {
* @param[in] filename Standard file name format. see @ref etk::FSNode * @param[in] filename Standard file name format. see @ref etk::FSNode
*/ */
Program(const std::string& filename); Program(const std::string& filename);
public:
/** /**
* @brief Destructor, remove the current Program. * @brief Destructor, remove the current Program.
*/ */
@ -299,12 +300,7 @@ namespace ewol {
* @param[in] _filename Name of the openGL program. * @param[in] _filename Name of the openGL program.
* @return pointer on the resource or nullptr if an error occured. * @return pointer on the resource or nullptr if an error occured.
*/ */
static ewol::resource::Program* keep(const std::string& _filename); static ewol::object::Shared<ewol::resource::Program> keep(const std::string& _filename);
/**
* @brief release the keeped resources
* @param[in,out] reference on the object pointer
*/
static void release(ewol::resource::Program*& _object);
}; };
}; };
}; };

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

@ -149,12 +149,12 @@ void ewol::resource::Shader::reload() {
updateContext(); updateContext();
} }
ewol::resource::Shader* ewol::resource::Shader::keep(const std::string& _filename) { ewol::object::Shared<ewol::resource::Shader> ewol::resource::Shader::keep(const std::string& _filename) {
EWOL_VERBOSE("KEEP : Simpleshader : file : \"" << _filename << "\""); EWOL_VERBOSE("KEEP : Simpleshader : file : \"" << _filename << "\"");
ewol::resource::Shader* object = nullptr; ewol::object::Shared<ewol::resource::Shader> object = nullptr;
ewol::Resource* object2 = getManager().localKeep(_filename); ewol::object::Shared<ewol::Resource> object2 = getManager().localKeep(_filename);
if (nullptr != object2) { if (nullptr != object2) {
object = dynamic_cast<ewol::resource::Shader*>(object2); object = ewol::dynamic_pointer_cast<ewol::resource::Shader>(object2);
if (nullptr == object) { if (nullptr == object) {
EWOL_CRITICAL("Request resource file : '" << _filename << "' With the wrong type (dynamic cast error)"); EWOL_CRITICAL("Request resource file : '" << _filename << "' With the wrong type (dynamic cast error)");
return nullptr; return nullptr;
@ -164,7 +164,7 @@ ewol::resource::Shader* ewol::resource::Shader::keep(const std::string& _filenam
return object; return object;
} }
// need to crate a new one ... // need to crate a new one ...
object = new ewol::resource::Shader(_filename); object = ewol::object::makeShared(new ewol::resource::Shader(_filename));
if (nullptr == object) { if (nullptr == object) {
EWOL_ERROR("allocation error of a resource : " << _filename); EWOL_ERROR("allocation error of a resource : " << _filename);
return nullptr; return nullptr;
@ -172,12 +172,3 @@ ewol::resource::Shader* ewol::resource::Shader::keep(const std::string& _filenam
getManager().localAdd(object); getManager().localAdd(object);
return object; return object;
} }
void ewol::resource::Shader::release(ewol::resource::Shader*& _object) {
if (nullptr == _object) {
return;
}
ewol::Resource* object2 = static_cast<ewol::Resource*>(_object);
getManager().release(object2);
_object = nullptr;
}

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

@ -31,6 +31,7 @@ namespace ewol {
* @param[in] filename Standard file name format. see @ref etk::FSNode * @param[in] filename Standard file name format. see @ref etk::FSNode
*/ */
Shader(const std::string& _filename); Shader(const std::string& _filename);
public:
/** /**
* @brief Destructor, remove the current Shader * @brief Destructor, remove the current Shader
*/ */
@ -74,12 +75,7 @@ namespace ewol {
* @param[in] _filename Name of the openGL Shader. * @param[in] _filename Name of the openGL Shader.
* @return pointer on the resource or nullptr if an error occured. * @return pointer on the resource or nullptr if an error occured.
*/ */
static ewol::resource::Shader* keep(const std::string& _filename); static ewol::object::Shared<ewol::resource::Shader> keep(const std::string& _filename);
/**
* @brief release the keeped resources
* @param[in,out] reference on the object pointer
*/
static void release(ewol::resource::Shader*& _object);
}; };
}; };
}; };

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

@ -107,9 +107,9 @@ void ewol::resource::Texture::setImageSize(ivec2 _newSize) {
m_data.resize(_newSize); m_data.resize(_newSize);
} }
ewol::resource::Texture* ewol::resource::Texture::keep() { ewol::object::Shared<ewol::resource::Texture> ewol::resource::Texture::keep() {
// this element create a new one every time .... // this element create a new one every time ....
ewol::resource::Texture* object = new ewol::resource::Texture(); ewol::object::Shared<ewol::resource::Texture> object = ewol::object::makeShared(new ewol::resource::Texture());
if (nullptr == object) { if (nullptr == object) {
EWOL_ERROR("allocation error of a resource : ??TEX??"); EWOL_ERROR("allocation error of a resource : ??TEX??");
return nullptr; return nullptr;
@ -118,11 +118,3 @@ ewol::resource::Texture* ewol::resource::Texture::keep() {
return object; return object;
} }
void ewol::resource::Texture::release(ewol::resource::Texture*& _object) {
if (nullptr == _object) {
return;
}
ewol::Resource* object2 = static_cast<ewol::Resource*>(_object);
getManager().release(object2);
_object = nullptr;
}

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

@ -47,6 +47,7 @@ namespace ewol {
protected: protected:
Texture(const std::string& _filename); Texture(const std::string& _filename);
Texture(); Texture();
public:
~Texture(); ~Texture();
public: public:
// you must set the size here, because it will be set in multiple of pow(2) // you must set the size here, because it will be set in multiple of pow(2)
@ -63,12 +64,7 @@ namespace ewol {
* @note Never free this pointer by your own... * @note Never free this pointer by your own...
* @return pointer on the resource or nullptr if an error occured. * @return pointer on the resource or nullptr if an error occured.
*/ */
static ewol::resource::Texture* keep(); static ewol::object::Shared<ewol::resource::Texture> keep();
/**
* @brief release the keeped resources
* @param[in,out] reference on the object pointer
*/
static void release(ewol::resource::Texture*& _object);
}; };
}; };
}; };

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

@ -225,9 +225,7 @@ ewol::resource::TexturedFont::TexturedFont(const std::string& _fontName) :
} }
ewol::resource::TexturedFont::~TexturedFont() { ewol::resource::TexturedFont::~TexturedFont() {
for (int32_t iiiFontId=0; iiiFontId<4 ; iiiFontId++) {
ewol::resource::FontFreeType::release(m_font[iiiFontId]);
}
} }
bool ewol::resource::TexturedFont::addGlyph(const char32_t& _val) { bool ewol::resource::TexturedFont::addGlyph(const char32_t& _val) {
@ -343,12 +341,12 @@ ewol::GlyphProperty* ewol::resource::TexturedFont::getGlyphPointer(const char32_
return &((m_listElement[_displayMode])[index]); return &((m_listElement[_displayMode])[index]);
} }
ewol::resource::TexturedFont* ewol::resource::TexturedFont::keep(const std::string& _filename) { ewol::object::Shared<ewol::resource::TexturedFont> ewol::resource::TexturedFont::keep(const std::string& _filename) {
EWOL_VERBOSE("KEEP : TexturedFont : file : '" << _filename << "'"); EWOL_VERBOSE("KEEP : TexturedFont : file : '" << _filename << "'");
ewol::resource::TexturedFont* object = nullptr; ewol::object::Shared<ewol::resource::TexturedFont> object;
ewol::Resource* object2 = getManager().localKeep(_filename); ewol::object::Shared<ewol::Resource> object2 = getManager().localKeep(_filename);
if (nullptr != object2) { if (nullptr != object2) {
object = dynamic_cast<ewol::resource::TexturedFont*>(object2); object = ewol::dynamic_pointer_cast<ewol::resource::TexturedFont>(object2);
if (nullptr == object) { if (nullptr == object) {
EWOL_CRITICAL("Request resource file : '" << _filename << "' With the wrong type (dynamic cast error)"); EWOL_CRITICAL("Request resource file : '" << _filename << "' With the wrong type (dynamic cast error)");
return nullptr; return nullptr;
@ -359,7 +357,7 @@ ewol::resource::TexturedFont* ewol::resource::TexturedFont::keep(const std::stri
} }
// need to crate a new one ... // need to crate a new one ...
EWOL_INFO("CREATE: TexturedFont : file : '" << _filename << "'"); EWOL_INFO("CREATE: TexturedFont : file : '" << _filename << "'");
object = new ewol::resource::TexturedFont(_filename); object = ewol::object::makeShared(new ewol::resource::TexturedFont(_filename));
if (nullptr == object) { if (nullptr == object) {
EWOL_ERROR("allocation error of a resource : " << _filename); EWOL_ERROR("allocation error of a resource : " << _filename);
return nullptr; return nullptr;
@ -367,18 +365,3 @@ ewol::resource::TexturedFont* ewol::resource::TexturedFont::keep(const std::stri
getManager().localAdd(object); getManager().localAdd(object);
return object; return object;
} }
void ewol::resource::TexturedFont::release(ewol::resource::TexturedFont*& _object) {
if (nullptr == _object) {
return;
}
EWOL_VERBOSE("RELEASE: TexturedFont : file : '" << _object->getName() << "' count=" << _object->getCounter());
std::string name = _object->getName();
int32_t count = _object->getCounter() - 1;
ewol::Resource* object2 = static_cast<ewol::Resource*>(_object);
if (getManager().release(object2) == true) {
EWOL_ERROR("REMOVE: TexturedFont : file : '" << name << "' count=" << count);
//etk::displayBacktrace(false);
}
_object = nullptr;
}

10
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... // specific element to have the the know if the specify element is known...
// == > otherwise I can just generate italic ... // == > otherwise I can just generate italic ...
// == > Bold is a little more complicated (maybe with the bordersize) // == > Bold is a little more complicated (maybe with the bordersize)
ewol::resource::FontBase* m_font[4]; ewol::object::Shared<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 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: public:
std::vector<GlyphProperty> m_listElement[4]; std::vector<GlyphProperty> m_listElement[4];
@ -46,6 +46,7 @@ namespace ewol {
int32_t m_lastRawHeigh[4]; int32_t m_lastRawHeigh[4];
protected: protected:
TexturedFont(const std::string& _fontName); TexturedFont(const std::string& _fontName);
public:
~TexturedFont(); ~TexturedFont();
public: public:
/** /**
@ -93,12 +94,7 @@ namespace ewol {
* @param[in] _filename Name of the texture font. * @param[in] _filename Name of the texture font.
* @return pointer on the resource or nullptr if an error occured. * @return pointer on the resource or nullptr if an error occured.
*/ */
static ewol::resource::TexturedFont* keep(const std::string& _filename); static ewol::object::Shared<ewol::resource::TexturedFont> keep(const std::string& _filename);
/**
* @brief release the keeped resources
* @param[in,out] reference on the object pointer
*/
static void release(ewol::resource::TexturedFont*& _object);
private: private:
/** /**
* @brief add a glyph in a texture font. * @brief add a glyph in a texture font.

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

@ -123,9 +123,9 @@ int32_t ewol::resource::VirtualBufferObject::sizeOnBufferVec2(int32_t _id) {
return m_buffer[_id].size()/2; return m_buffer[_id].size()/2;
} }
ewol::resource::VirtualBufferObject* ewol::resource::VirtualBufferObject::keep(int32_t _number) { ewol::object::Shared<ewol::resource::VirtualBufferObject> ewol::resource::VirtualBufferObject::keep(int32_t _number) {
// this element create a new one every time .... // this element create a new one every time ....
ewol::resource::VirtualBufferObject* object = new ewol::resource::VirtualBufferObject(_number); ewol::object::Shared<ewol::resource::VirtualBufferObject> object = ewol::object::makeShared(new ewol::resource::VirtualBufferObject(_number));
if (nullptr == object) { if (nullptr == object) {
EWOL_ERROR("allocation error of a resource : ??VBO??"); EWOL_ERROR("allocation error of a resource : ??VBO??");
return nullptr; return nullptr;
@ -133,12 +133,3 @@ ewol::resource::VirtualBufferObject* ewol::resource::VirtualBufferObject::keep(i
getManager().localAdd(object); getManager().localAdd(object);
return object; return object;
} }
void ewol::resource::VirtualBufferObject::release(ewol::resource::VirtualBufferObject*& _object) {
if (nullptr == _object) {
return;
}
ewol::Resource* object2 = static_cast<ewol::Resource*>(_object);
getManager().release(object2);
_object = nullptr;
}

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

@ -35,6 +35,7 @@ namespace ewol {
* @param[in] accesMode Acces mode : ??? * @param[in] accesMode Acces mode : ???
*/ */
VirtualBufferObject(int32_t _number); VirtualBufferObject(int32_t _number);
public:
/** /**
* @brief Destructor of this VBO. * @brief Destructor of this VBO.
*/ */
@ -99,12 +100,7 @@ namespace ewol {
* @param[in] _number Number of VBO needed * @param[in] _number Number of VBO needed
* @return pointer on the resource or nullptr if an error occured. * @return pointer on the resource or nullptr if an error occured.
*/ */
static ewol::resource::VirtualBufferObject* keep(int32_t _number); static ewol::object::Shared<ewol::resource::VirtualBufferObject> keep(int32_t _number);
/**
* @brief release the keeped resources
* @param[in,out] reference on the object pointer
*/
static void release(ewol::resource::VirtualBufferObject*& _object);
}; };
}; };
}; };

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

@ -59,7 +59,7 @@ ewol::widget::Image::Image(const std::string& _file, const ewol::Dimension& _bor
} }
ewol::widget::Image::~Image() { ewol::widget::Image::~Image() {
ewol::resource::ColorFile::release(m_colorProperty);
} }
void ewol::widget::Image::setFile(const std::string& _file) { void ewol::widget::Image::setFile(const std::string& _file) {

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

@ -41,7 +41,7 @@ namespace ewol {
static void init(ewol::widget::Manager& _widgetManager); static void init(ewol::widget::Manager& _widgetManager);
protected: protected:
ewol::compositing::Image m_compositing; //!< compositing element of the image. ewol::compositing::Image m_compositing; //!< compositing element of the image.
ewol::resource::ColorFile* m_colorProperty; //!< theme color property ewol::object::Shared<ewol::resource::ColorFile> m_colorProperty; //!< theme color property
int32_t m_colorId; //!< Color of the image. int32_t m_colorId; //!< Color of the image.
public: public:
/** /**

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

@ -44,7 +44,7 @@ ewol::widget::Label::Label(std::string _newLabel) :
} }
ewol::widget::Label::~Label() { ewol::widget::Label::~Label() {
ewol::resource::ColorFile::release(m_colorProperty);
} }
void ewol::widget::Label::calculateMinMaxSize() { void ewol::widget::Label::calculateMinMaxSize() {

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

@ -34,7 +34,7 @@ namespace ewol {
private: private:
ewol::compositing::Text m_text; //!< Compositing text element. ewol::compositing::Text m_text; //!< Compositing text element.
std::u32string m_label; //!< decorated text to display. std::u32string m_label; //!< decorated text to display.
ewol::resource::ColorFile* m_colorProperty; //!< theme color property ewol::object::Shared<ewol::resource::ColorFile> m_colorProperty; //!< theme color property
int32_t m_colorDefaultFgText; //!< Default color of the text int32_t m_colorDefaultFgText; //!< Default color of the text
int32_t m_colorDefaultBgText; //!< Default Background color of the text int32_t m_colorDefaultBgText; //!< Default Background color of the text
public: public:

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

@ -70,7 +70,6 @@ ewol::widget::ListFileSystem::ListFileSystem() :
ewol::widget::ListFileSystem::~ListFileSystem() { ewol::widget::ListFileSystem::~ListFileSystem() {
clearList(); clearList();
ewol::resource::ColorFile::release(m_colorProperty);
}; };
void ewol::widget::ListFileSystem::clearList() { void ewol::widget::ListFileSystem::clearList() {

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

@ -39,7 +39,7 @@ namespace ewol {
ListFileSystem(); ListFileSystem();
~ListFileSystem(); ~ListFileSystem();
protected: protected:
ewol::resource::ColorFile* m_colorProperty; //!< theme color property. ewol::object::Shared<ewol::resource::ColorFile> m_colorProperty; //!< theme color property.
int32_t m_colorIdText; //!< Color of the text. int32_t m_colorIdText; //!< Color of the text.
int32_t m_colorIdBackground1; //!< Color of the Background. int32_t m_colorIdBackground1; //!< Color of the Background.
int32_t m_colorIdBackground2; //!< Color of the Background 2. int32_t m_colorIdBackground2; //!< Color of the Background 2.

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

@ -22,7 +22,7 @@ namespace ewol {
*/ */
class Windows : public ewol::Widget { class Windows : public ewol::Widget {
protected: protected:
ewol::resource::ColorFile* m_colorProperty; //!< theme color property ewol::object::Shared<ewol::resource::ColorFile> m_colorProperty; //!< theme color property
int32_t m_colorBg; //!< Default background color of the windows int32_t m_colorBg; //!< Default background color of the windows
public: public:
Windows(); Windows();