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

[DEV] integarate std x11

Browse Source
This commit is contained in:
Edouard DUPIN 2013-11-11 20:20:05 +01:00
parent ff1f2692de
commit 410db2d5e0
74 changed files with 320 additions and 320 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
build

@ -1 +1 @@
Subproject commit 1a424abd21d9262b1cfc911fcc830d003bf6078b Subproject commit 47c1762724759b107ea98eb6cf86c10c65d7ae79

2
external/agg vendored

@ -1 +1 @@
Subproject commit ee8d48447080a6594f490f77390fae9ece5c606c Subproject commit 5f26683625412f2ec0aad32adf6a85abb8312684

2
external/egami vendored

@ -1 +1 @@
Subproject commit 59738fd521534c9f71146513905b42ad56407fed Subproject commit 1ab4e02e492599ec77c3452cfe6a2e97188a40c8

2
external/ege vendored

@ -1 +1 @@
Subproject commit a52c92e96fec84f7b2681e59ba13676c331ad7b1 Subproject commit 1d10f953326d14ff134be6c37a447d0f8a2e0c83

2
external/ejson vendored

@ -1 +1 @@
Subproject commit a94a1c6e600fcbbfe706cda6cc7e4e2c939c8f09 Subproject commit 43ddd2549c0638d3463be37d8f0c651437de7d7b

2
external/esvg vendored

@ -1 +1 @@
Subproject commit 7e28d6b250292b3773d2aff2ce066ee6298bf19d Subproject commit 32b1966f8d42e374eaa8f2d5d9cae5d4f5d1db8b

2
external/etk vendored

@ -1 +1 @@
Subproject commit 51606313ab962db03eb0642be06e52ef70e6e6d8 Subproject commit b83c99e37152351adfd259d54281391256b6baf9

2
external/exml vendored

@ -1 +1 @@
Subproject commit c9f7abcd96f2decebe4968fe10071c6e861a4d85 Subproject commit 23258089971f05411b725a24a8806dcd51e86754

2
sources/ewol/Material.h
View File

@ -36,7 +36,7 @@ namespace ewol {
float m_shininess; float m_shininess;
ewol::TextureFile* m_texture0; ewol::TextureFile* m_texture0;
public: public:
etk::Vector<uint32_t> m_listIndexFaces; std::vector<uint32_t> m_listIndexFaces;
public: public:
Material(void); Material(void);
~Material(void); ~Material(void);

6
sources/ewol/commandLine.cpp
View File

@ -8,12 +8,12 @@
#include <ewol/debug.h> #include <ewol/debug.h>
#include <ewol/commandLine.h> #include <ewol/commandLine.h>
#include <etk/Vector.h> #include <vector>
void ewol::CommandLine::parse(int32_t _argc, const char* _argv[]) { void ewol::CommandLine::parse(int32_t _argc, const char* _argv[]) {
for( int32_t i=1 ; i<_argc; i++) { for( int32_t i=1 ; i<_argc; i++) {
EWOL_INFO("commandLine : \"" << _argv[i] << "\"" ); EWOL_INFO("commandLine : \"" << _argv[i] << "\"" );
m_listArgs.pushBack(_argv[i]); m_listArgs.push_back(_argv[i]);
} }
} }
@ -32,7 +32,7 @@ const etk::UString& ewol::CommandLine::get(int32_t _id) {
} }
void ewol::CommandLine::add(const etk::UString& _newElement) { void ewol::CommandLine::add(const etk::UString& _newElement) {
m_listArgs.pushBack(_newElement); m_listArgs.push_back(_newElement);
} }
void ewol::CommandLine::remove(esize_t _id) { void ewol::CommandLine::remove(esize_t _id) {

2
sources/ewol/commandLine.h
View File

@ -15,7 +15,7 @@
namespace ewol { namespace ewol {
class CommandLine { class CommandLine {
private: private:
etk::Vector<etk::UString> m_listArgs; //!< list of all argument parsed std::vector<etk::UString> m_listArgs; //!< list of all argument parsed
public: public:
/** /**
* @brief Parse the command line parameters * @brief Parse the command line parameters

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

@ -92,41 +92,41 @@ void ewol::Area::print(const ivec2& _size) {
vec2 tex(0,1); vec2 tex(0,1);
point.setX(m_position.x()); point.setX(m_position.x());
point.setY(m_position.y()); point.setY(m_position.y());
m_coord.pushBack(point); m_coord.push_back(point);
m_coordTex.pushBack(tex); m_coordTex.push_back(tex);
m_coordColor.pushBack(m_color); m_coordColor.push_back(m_color);
tex.setValue(1,1); tex.setValue(1,1);
point.setX(m_position.x() + _size.x()); point.setX(m_position.x() + _size.x());
point.setY(m_position.y()); point.setY(m_position.y());
m_coord.pushBack(point); m_coord.push_back(point);
m_coordTex.pushBack(tex); m_coordTex.push_back(tex);
m_coordColor.pushBack(m_color); m_coordColor.push_back(m_color);
tex.setValue(1,0); tex.setValue(1,0);
point.setX(m_position.x() + _size.x()); point.setX(m_position.x() + _size.x());
point.setY(m_position.y() + _size.y()); point.setY(m_position.y() + _size.y());
m_coord.pushBack(point); m_coord.push_back(point);
m_coordTex.pushBack(tex); m_coordTex.push_back(tex);
m_coordColor.pushBack(m_color); m_coordColor.push_back(m_color);
m_coord.pushBack(point); m_coord.push_back(point);
m_coordTex.pushBack(tex); m_coordTex.push_back(tex);
m_coordColor.pushBack(m_color); m_coordColor.push_back(m_color);
tex.setValue(0,0); tex.setValue(0,0);
point.setX(m_position.x()); point.setX(m_position.x());
point.setY(m_position.y() + _size.y()); point.setY(m_position.y() + _size.y());
m_coord.pushBack(point); m_coord.push_back(point);
m_coordTex.pushBack(tex); m_coordTex.push_back(tex);
m_coordColor.pushBack(m_color); m_coordColor.push_back(m_color);
tex.setValue(0,1); tex.setValue(0,1);
point.setX(m_position.x()); point.setX(m_position.x());
point.setY(m_position.y()); point.setY(m_position.y());
m_coord.pushBack(point); m_coord.push_back(point);
m_coordTex.pushBack(tex); m_coordTex.push_back(tex);
m_coordColor.pushBack(m_color); m_coordColor.push_back(m_color);
} }

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

@ -29,9 +29,9 @@ 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:
ewol::Texture* m_resource; //!< texture resources ewol::Texture* m_resource; //!< texture resources
etk::Vector<vec3 > m_coord; //!< internal coord of the object std::vector<vec3 > m_coord; //!< internal coord of the object
etk::Vector<vec2 > m_coordTex; //!< internal texture coordinate for every point std::vector<vec2 > m_coordTex; //!< internal texture coordinate for every point
etk::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
private: private:
/** /**
* @brief load the openGL program and get all the ID needed * @brief load the openGL program and get all the ID needed

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

@ -12,21 +12,21 @@
#if 0 #if 0
static void generatePolyGone(etk::Vector<vec2 > & input, etk::Vector<vec2 > & output ) static void generatePolyGone(std::vector<vec2 > & input, std::vector<vec2 > & output )
{ {
if (input.size()<3) { if (input.size()<3) {
return; return;
} }
// TODO : Regenerate a linear poligone generation // TODO : Regenerate a linear poligone generation
for (int32_t iii=1; iii<input.size()-1; iii++) { for (int32_t iii=1; iii<input.size()-1; iii++) {
output.pushBack(input[0]); output.push_back(input[0]);
output.pushBack(input[iii]); output.push_back(input[iii]);
output.pushBack(input[iii+1]); output.push_back(input[iii+1]);
} }
//EWOL_DEBUG("generate Plygone : " << input.size() << " == > " << output.size() ); //EWOL_DEBUG("generate Plygone : " << input.size() << " == > " << output.size() );
} }
static void SutherlandHodgman(etk::Vector<vec2 > & input, etk::Vector<vec2 > & output, float sx, float sy, float ex, float ey) static void SutherlandHodgman(std::vector<vec2 > & input, std::vector<vec2 > & output, float sx, float sy, float ex, float ey)
{ {
// with Sutherland-Hodgman-Algorithm // with Sutherland-Hodgman-Algorithm
if (input.size() <0) { if (input.size() <0) {
@ -51,7 +51,7 @@ static void SutherlandHodgman(etk::Vector<vec2 > & input, etk::Vector<vec2 > & o
float bbb = lastElement.y - (aaa*lastElement.x); float bbb = lastElement.y - (aaa*lastElement.x);
destPoint.y = aaa*sx + bbb; destPoint.y = aaa*sx + bbb;
destPoint.x = sx; destPoint.x = sx;
output.pushBack(destPoint); output.push_back(destPoint);
} else { } else {
//EWOL_DEBUG("element OUT == > OUT "); //EWOL_DEBUG("element OUT == > OUT ");
} }
@ -59,7 +59,7 @@ static void SutherlandHodgman(etk::Vector<vec2 > & input, etk::Vector<vec2 > & o
} else { } else {
if(true == inside) { if(true == inside) {
//EWOL_DEBUG("element IN == > IN "); //EWOL_DEBUG("element IN == > IN ");
output.pushBack(input[iii]); output.push_back(input[iii]);
} else { } else {
//EWOL_DEBUG("element OUT == > IN "); //EWOL_DEBUG("element OUT == > IN ");
//new point intersection ... //new point intersection ...
@ -68,8 +68,8 @@ static void SutherlandHodgman(etk::Vector<vec2 > & input, etk::Vector<vec2 > & o
float bbb = lastElement.y - (aaa*lastElement.x); float bbb = lastElement.y - (aaa*lastElement.x);
destPoint.y = aaa*sx + bbb; destPoint.y = aaa*sx + bbb;
destPoint.x = sx; destPoint.x = sx;
output.pushBack(destPoint); output.push_back(destPoint);
output.pushBack(input[iii]); output.push_back(input[iii]);
} }
inside = true; inside = true;
} }
@ -96,7 +96,7 @@ static void SutherlandHodgman(etk::Vector<vec2 > & input, etk::Vector<vec2 > & o
float bbb = lastElement.x - (aaa*lastElement.y); float bbb = lastElement.x - (aaa*lastElement.y);
destPoint.y = sy; destPoint.y = sy;
destPoint.x = sy*aaa + bbb; destPoint.x = sy*aaa + bbb;
output.pushBack(destPoint); output.push_back(destPoint);
} else { } else {
//EWOL_DEBUG("element OUT == > OUT "); //EWOL_DEBUG("element OUT == > OUT ");
} }
@ -104,7 +104,7 @@ static void SutherlandHodgman(etk::Vector<vec2 > & input, etk::Vector<vec2 > & o
} else { } else {
if(true == inside) { if(true == inside) {
//EWOL_DEBUG("element IN == > IN "); //EWOL_DEBUG("element IN == > IN ");
output.pushBack(input[iii]); output.push_back(input[iii]);
} else { } else {
//EWOL_DEBUG("element OUT == > IN "); //EWOL_DEBUG("element OUT == > IN ");
//new point intersection ... //new point intersection ...
@ -113,8 +113,8 @@ static void SutherlandHodgman(etk::Vector<vec2 > & input, etk::Vector<vec2 > & o
float bbb = lastElement.x - (aaa*lastElement.y); float bbb = lastElement.x - (aaa*lastElement.y);
destPoint.y = sy; destPoint.y = sy;
destPoint.x = sy*aaa + bbb; destPoint.x = sy*aaa + bbb;
output.pushBack(destPoint); output.push_back(destPoint);
output.pushBack(input[iii]); output.push_back(input[iii]);
} }
inside = true; inside = true;
} }
@ -141,7 +141,7 @@ static void SutherlandHodgman(etk::Vector<vec2 > & input, etk::Vector<vec2 > & o
float bbb = lastElement.y - (aaa*lastElement.x); float bbb = lastElement.y - (aaa*lastElement.x);
destPoint.y = aaa*ex + bbb; destPoint.y = aaa*ex + bbb;
destPoint.x = ex; destPoint.x = ex;
output.pushBack(destPoint); output.push_back(destPoint);
} else { } else {
//EWOL_DEBUG("element OUT == > OUT "); //EWOL_DEBUG("element OUT == > OUT ");
} }
@ -149,7 +149,7 @@ static void SutherlandHodgman(etk::Vector<vec2 > & input, etk::Vector<vec2 > & o
} else { } else {
if(true == inside) { if(true == inside) {
//EWOL_DEBUG("element IN == > IN "); //EWOL_DEBUG("element IN == > IN ");
output.pushBack(input[iii]); output.push_back(input[iii]);
} else { } else {
//EWOL_DEBUG("element OUT == > IN "); //EWOL_DEBUG("element OUT == > IN ");
//new point intersection ... //new point intersection ...
@ -158,8 +158,8 @@ static void SutherlandHodgman(etk::Vector<vec2 > & input, etk::Vector<vec2 > & o
float bbb = lastElement.y - (aaa*lastElement.x); float bbb = lastElement.y - (aaa*lastElement.x);
destPoint.y = aaa*ex + bbb; destPoint.y = aaa*ex + bbb;
destPoint.x = ex; destPoint.x = ex;
output.pushBack(destPoint); output.push_back(destPoint);
output.pushBack(input[iii]); output.push_back(input[iii]);
} }
inside = true; inside = true;
} }
@ -185,7 +185,7 @@ static void SutherlandHodgman(etk::Vector<vec2 > & input, etk::Vector<vec2 > & o
float bbb = lastElement.x - (aaa*lastElement.y); float bbb = lastElement.x - (aaa*lastElement.y);
destPoint.y = ey; destPoint.y = ey;
destPoint.x = ey*aaa + bbb; destPoint.x = ey*aaa + bbb;
output.pushBack(destPoint); output.push_back(destPoint);
} else { } else {
//EWOL_DEBUG("element OUT == > OUT "); //EWOL_DEBUG("element OUT == > OUT ");
} }
@ -193,7 +193,7 @@ static void SutherlandHodgman(etk::Vector<vec2 > & input, etk::Vector<vec2 > & o
} else { } else {
if(true == inside) { if(true == inside) {
//EWOL_DEBUG("element IN == > IN "); //EWOL_DEBUG("element IN == > IN ");
output.pushBack(input[iii]); output.push_back(input[iii]);
} else { } else {
//EWOL_DEBUG("element OUT == > IN "); //EWOL_DEBUG("element OUT == > IN ");
//new point intersection ... //new point intersection ...
@ -202,8 +202,8 @@ static void SutherlandHodgman(etk::Vector<vec2 > & input, etk::Vector<vec2 > & o
float bbb = lastElement.x - (aaa*lastElement.y); float bbb = lastElement.x - (aaa*lastElement.y);
destPoint.y = ey; destPoint.y = ey;
destPoint.x = ey*aaa + bbb; destPoint.x = ey*aaa + bbb;
output.pushBack(destPoint); output.push_back(destPoint);
output.pushBack(input[iii]); output.push_back(input[iii]);
} }
inside = true; inside = true;
} }
@ -244,12 +244,12 @@ ewol::Drawing::~Drawing(void) {
void ewol::Drawing::generateTriangle(void) { void ewol::Drawing::generateTriangle(void) {
m_triElement = 0; m_triElement = 0;
m_coord.pushBack(m_triangle[0]); m_coord.push_back(m_triangle[0]);
m_coordColor.pushBack(m_tricolor[0]); m_coordColor.push_back(m_tricolor[0]);
m_coord.pushBack(m_triangle[1]); m_coord.push_back(m_triangle[1]);
m_coordColor.pushBack(m_tricolor[1]); m_coordColor.push_back(m_tricolor[1]);
m_coord.pushBack(m_triangle[2]); m_coord.push_back(m_triangle[2]);
m_coordColor.pushBack(m_tricolor[2]); m_coordColor.push_back(m_tricolor[2]);
} }
void ewol::Drawing::internalSetColor(const etk::Color<>& _color) { void ewol::Drawing::internalSetColor(const etk::Color<>& _color) {

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

@ -32,8 +32,8 @@ namespace ewol {
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)
private: // Background Color (display only when needed) private: // Background Color (display only when needed)
etk::Vector<vec3 > m_coord; //!< internal position for the text display std::vector<vec3 > m_coord; //!< internal position for the text display
etk::Vector<etk::Color<float> > m_coordColor; //!< internal color of the background std::vector<etk::Color<float> > m_coordColor; //!< internal color of the background
public: public:
/** /**
* @brief Basic constructor * @brief Basic constructor

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

@ -140,43 +140,43 @@ void ewol::Image::printPart(const vec2& _size,
vec3 point = m_position; vec3 point = m_position;
vec2 tex(_sourcePosStart.x(),_sourcePosStop.y()); vec2 tex(_sourcePosStart.x(),_sourcePosStop.y());
m_coord.pushBack(point); m_coord.push_back(point);
m_coordTex.pushBack(tex); m_coordTex.push_back(tex);
m_coordColor.pushBack(m_color); m_coordColor.push_back(m_color);
tex.setValue(_sourcePosStop.x(),_sourcePosStop.y()); tex.setValue(_sourcePosStop.x(),_sourcePosStop.y());
point.setX(m_position.x() + _size.x()); point.setX(m_position.x() + _size.x());
point.setY(m_position.y()); point.setY(m_position.y());
m_coord.pushBack(point); m_coord.push_back(point);
m_coordTex.pushBack(tex); m_coordTex.push_back(tex);
m_coordColor.pushBack(m_color); m_coordColor.push_back(m_color);
tex.setValue(_sourcePosStop.x(),_sourcePosStart.y()); tex.setValue(_sourcePosStop.x(),_sourcePosStart.y());
point.setX(m_position.x() + _size.x()); point.setX(m_position.x() + _size.x());
point.setY(m_position.y() + _size.y()); point.setY(m_position.y() + _size.y());
m_coord.pushBack(point); m_coord.push_back(point);
m_coordTex.pushBack(tex); m_coordTex.push_back(tex);
m_coordColor.pushBack(m_color); m_coordColor.push_back(m_color);
m_coord.pushBack(point); m_coord.push_back(point);
m_coordTex.pushBack(tex); m_coordTex.push_back(tex);
m_coordColor.pushBack(m_color); m_coordColor.push_back(m_color);
tex.setValue(_sourcePosStart.x(),_sourcePosStart.y()); tex.setValue(_sourcePosStart.x(),_sourcePosStart.y());
point.setX(m_position.x()); point.setX(m_position.x());
point.setY(m_position.y() + _size.y()); point.setY(m_position.y() + _size.y());
m_coord.pushBack(point); m_coord.push_back(point);
m_coordTex.pushBack(tex); m_coordTex.push_back(tex);
m_coordColor.pushBack(m_color); m_coordColor.push_back(m_color);
tex.setValue(_sourcePosStart.x(),_sourcePosStop.y()); tex.setValue(_sourcePosStart.x(),_sourcePosStop.y());
point.setX(m_position.x()); point.setX(m_position.x());
point.setY(m_position.y()); point.setY(m_position.y());
m_coord.pushBack(point); m_coord.push_back(point);
m_coordTex.pushBack(tex); m_coordTex.push_back(tex);
m_coordColor.pushBack(m_color); m_coordColor.push_back(m_color);
return; return;
} }
vec3 center = m_position + vec3(_size.x(),_size.y(),0)/2.0f; vec3 center = m_position + vec3(_size.x(),_size.y(),0)/2.0f;
@ -187,43 +187,43 @@ void ewol::Image::printPart(const vec2& _size,
point.setValue(-limitedSize.x(), -limitedSize.y(), 0); point.setValue(-limitedSize.x(), -limitedSize.y(), 0);
point = point.rotate(vec3(0,0,1), m_angle) + center; point = point.rotate(vec3(0,0,1), m_angle) + center;
m_coord.pushBack(point); m_coord.push_back(point);
m_coordTex.pushBack(tex); m_coordTex.push_back(tex);
m_coordColor.pushBack(m_color); m_coordColor.push_back(m_color);
tex.setValue(_sourcePosStop.x(),_sourcePosStop.y()); tex.setValue(_sourcePosStop.x(),_sourcePosStop.y());
point.setValue(limitedSize.x(), -limitedSize.y(), 0); point.setValue(limitedSize.x(), -limitedSize.y(), 0);
point = point.rotate(vec3(0,0,1), m_angle) + center; point = point.rotate(vec3(0,0,1), m_angle) + center;
m_coord.pushBack(point); m_coord.push_back(point);
m_coordTex.pushBack(tex); m_coordTex.push_back(tex);
m_coordColor.pushBack(m_color); m_coordColor.push_back(m_color);
tex.setValue(_sourcePosStop.x(),_sourcePosStart.y()); tex.setValue(_sourcePosStop.x(),_sourcePosStart.y());
point.setValue(limitedSize.x(), limitedSize.y(), 0); point.setValue(limitedSize.x(), limitedSize.y(), 0);
point = point.rotate(vec3(0,0,1), m_angle) + center; point = point.rotate(vec3(0,0,1), m_angle) + center;
m_coord.pushBack(point); m_coord.push_back(point);
m_coordTex.pushBack(tex); m_coordTex.push_back(tex);
m_coordColor.pushBack(m_color); m_coordColor.push_back(m_color);
m_coord.pushBack(point); m_coord.push_back(point);
m_coordTex.pushBack(tex); m_coordTex.push_back(tex);
m_coordColor.pushBack(m_color); m_coordColor.push_back(m_color);
tex.setValue(_sourcePosStart.x(),_sourcePosStart.y()); tex.setValue(_sourcePosStart.x(),_sourcePosStart.y());
point.setValue(-limitedSize.x(), limitedSize.y(), 0); point.setValue(-limitedSize.x(), limitedSize.y(), 0);
point = point.rotate(vec3(0,0,1), m_angle) + center; point = point.rotate(vec3(0,0,1), m_angle) + center;
m_coord.pushBack(point); m_coord.push_back(point);
m_coordTex.pushBack(tex); m_coordTex.push_back(tex);
m_coordColor.pushBack(m_color); m_coordColor.push_back(m_color);
tex.setValue(_sourcePosStart.x(),_sourcePosStop.y()); tex.setValue(_sourcePosStart.x(),_sourcePosStop.y());
point.setValue(-limitedSize.x(), -limitedSize.y(), 0); point.setValue(-limitedSize.x(), -limitedSize.y(), 0);
point = point.rotate(vec3(0,0,1), m_angle) + center; point = point.rotate(vec3(0,0,1), m_angle) + center;
m_coord.pushBack(point); m_coord.push_back(point);
m_coordTex.pushBack(tex); m_coordTex.push_back(tex);
m_coordColor.pushBack(m_color); m_coordColor.push_back(m_color);
} }
void ewol::Image::setSource(const etk::UString& _newFile, const vec2& _size) { void ewol::Image::setSource(const etk::UString& _newFile, const vec2& _size) {

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

@ -32,9 +32,9 @@ 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:
ewol::TextureFile* m_resource; //!< texture resources ewol::TextureFile* m_resource; //!< texture resources
etk::Vector<vec3 > m_coord; //!< internal coord of the object std::vector<vec3 > m_coord; //!< internal coord of the object
etk::Vector<vec2 > m_coordTex; //!< internal texture coordinate for every point std::vector<vec2 > m_coordTex; //!< internal texture coordinate for every point
etk::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
private: private:
/** /**
* @brief load the openGL program and get all the ID needed * @brief load the openGL program and get all the ID needed

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

@ -363,7 +363,7 @@ void ewol::Text::setDistanceFieldMode(bool _newMode) {
} }
void ewol::Text::print(const etk::UString& _text) { void ewol::Text::print(const etk::UString& _text) {
etk::Vector<TextDecoration> decorationEmpty; std::vector<TextDecoration> decorationEmpty;
print(_text, decorationEmpty); print(_text, decorationEmpty);
} }
@ -498,7 +498,7 @@ void ewol::Text::printHTML(const etk::UString& _text) {
htmlFlush(); htmlFlush();
} }
void ewol::Text::print(const etk::UString& _text, const etk::Vector<TextDecoration>& _decoration) { void ewol::Text::print(const etk::UString& _text, const std::vector<TextDecoration>& _decoration) {
if (m_font == NULL) { if (m_font == NULL) {
EWOL_ERROR("Font Id is not corectly defined"); EWOL_ERROR("Font Id is not corectly defined");
return; return;
@ -816,17 +816,17 @@ void ewol::Text::print(const etk::UChar& _charcode) {
* *
*/ */
// set texture coordonates : // set texture coordonates :
m_coordTex.pushBack(texturePos[0]); m_coordTex.push_back(texturePos[0]);
m_coordTex.pushBack(texturePos[1]); m_coordTex.push_back(texturePos[1]);
m_coordTex.pushBack(texturePos[2]); m_coordTex.push_back(texturePos[2]);
// set display positions : // set display positions :
m_coord.pushBack(bitmapDrawPos[0]); m_coord.push_back(bitmapDrawPos[0]);
m_coord.pushBack(bitmapDrawPos[1]); m_coord.push_back(bitmapDrawPos[1]);
m_coord.pushBack(bitmapDrawPos[2]); m_coord.push_back(bitmapDrawPos[2]);
// set the color // set the color
m_coordColor.pushBack(m_color); m_coordColor.push_back(m_color);
m_coordColor.pushBack(m_color); m_coordColor.push_back(m_color);
m_coordColor.pushBack(m_color); m_coordColor.push_back(m_color);
/* Step 2 : /* Step 2 :
* *
* ** * **
@ -835,17 +835,17 @@ void ewol::Text::print(const etk::UChar& _charcode) {
* ******** * ********
*/ */
// set texture coordonates : // set texture coordonates :
m_coordTex.pushBack(texturePos[0]); m_coordTex.push_back(texturePos[0]);
m_coordTex.pushBack(texturePos[2]); m_coordTex.push_back(texturePos[2]);
m_coordTex.pushBack(texturePos[3]); m_coordTex.push_back(texturePos[3]);
// set display positions : // set display positions :
m_coord.pushBack(bitmapDrawPos[0]); m_coord.push_back(bitmapDrawPos[0]);
m_coord.pushBack(bitmapDrawPos[2]); m_coord.push_back(bitmapDrawPos[2]);
m_coord.pushBack(bitmapDrawPos[3]); m_coord.push_back(bitmapDrawPos[3]);
// set the color // set the color
m_coordColor.pushBack(m_color); m_coordColor.push_back(m_color);
m_coordColor.pushBack(m_color); m_coordColor.push_back(m_color);
m_coordColor.pushBack(m_color); m_coordColor.push_back(m_color);
} }
} }
} }
@ -1044,14 +1044,14 @@ void ewol::Text::htmlAddData(const etk::UString& _data) {
m_htmlCurrrentLine+=" "; m_htmlCurrrentLine+=" ";
if(m_htmlDecoration.size()>0) { if(m_htmlDecoration.size()>0) {
TextDecoration tmp = m_htmlDecoration[m_htmlDecoration.size()-1]; TextDecoration tmp = m_htmlDecoration[m_htmlDecoration.size()-1];
m_htmlDecoration.pushBack(tmp); m_htmlDecoration.push_back(tmp);
} else { } else {
m_htmlDecoration.pushBack(m_htmlDecoTmp); m_htmlDecoration.push_back(m_htmlDecoTmp);
} }
} }
m_htmlCurrrentLine += _data; m_htmlCurrrentLine += _data;
for(int32_t iii=0; iii<_data.size() ; iii++) { for(int32_t iii=0; iii<_data.size() ; iii++) {
m_htmlDecoration.pushBack(m_htmlDecoTmp); m_htmlDecoration.push_back(m_htmlDecoTmp);
} }
} }

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

@ -85,9 +85,9 @@ namespace ewol {
private: private:
ewol::TexturedFont* m_font; //!< Font resources ewol::TexturedFont* m_font; //!< Font resources
private: // Text private: // Text
etk::Vector<vec2 > m_coord; //!< internal coord of the object std::vector<vec2 > m_coord; //!< internal coord of the object
etk::Vector<vec2 > m_coordTex; //!< internal texture coordinate for every point std::vector<vec2 > m_coordTex; //!< internal texture coordinate for every point
etk::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
private: private:
/** /**
* @brief load the openGL program and get all the ID needed * @brief load the openGL program and get all the ID needed
@ -301,7 +301,7 @@ namespace ewol {
* @param[in] _text The string to display. * @param[in] _text The string to display.
* @param[in] _decoration The text decoration for the text that might be display (if the vector is smaller, the last parameter is get) * @param[in] _decoration The text decoration for the text that might be display (if the vector is smaller, the last parameter is get)
*/ */
void print(const etk::UString& _text, const etk::Vector<TextDecoration>& _decoration); void print(const etk::UString& _text, const std::vector<TextDecoration>& _decoration);
/** /**
* @brief display the current char in the current element (note that the kerning is availlable if the position is not changed) * @brief display the current char in the current element (note that the kerning is availlable if the position is not changed)
* @param[in] _charcode Char that might be dispalyed * @param[in] _charcode Char that might be dispalyed
@ -379,7 +379,7 @@ namespace ewol {
private: private:
// this section is reserved for HTML parsing and display: // this section is reserved for HTML parsing and display:
etk::UString m_htmlCurrrentLine; //!< current line for HTML display etk::UString m_htmlCurrrentLine; //!< current line for HTML display
etk::Vector<TextDecoration> m_htmlDecoration; //!< current decoration for the HTML display std::vector<TextDecoration> m_htmlDecoration; //!< current decoration for the HTML display
TextDecoration m_htmlDecoTmp; //!< current decoration TextDecoration m_htmlDecoTmp; //!< current decoration
/** /**
* @brief add a line with the current m_htmlDecoTmp decoration * @brief add a line with the current m_htmlDecoTmp decoration

4
sources/ewol/physicsShape/PhysicsConvexHull.cpp
View File

@ -22,12 +22,12 @@ bool ewol::PhysicsConvexHull::parse(const char* _line) {
while (tmp != NULL) { while (tmp != NULL) {
*tmp = '\0'; *tmp = '\0';
sscanf(base, "%f %f %f", &pos.m_floats[0], &pos.m_floats[1], &pos.m_floats[2] ); sscanf(base, "%f %f %f", &pos.m_floats[0], &pos.m_floats[1], &pos.m_floats[2] );
m_points.pushBack(pos); m_points.push_back(pos);
base = tmp+1; base = tmp+1;
tmp= strchr(base, '|'); tmp= strchr(base, '|');
} }
sscanf(base, "%f %f %f", &pos.m_floats[0], &pos.m_floats[1], &pos.m_floats[2] ); sscanf(base, "%f %f %f", &pos.m_floats[0], &pos.m_floats[1], &pos.m_floats[2] );
m_points.pushBack(pos); m_points.push_back(pos);
/* /*
for (int32_t iii=0; iii<m_points.size(); iii++) { for (int32_t iii=0; iii<m_points.size(); iii++) {
EWOL_VERBOSE(" parsed " << m_points[iii]); EWOL_VERBOSE(" parsed " << m_points[iii]);

4
sources/ewol/physicsShape/PhysicsConvexHull.h
View File

@ -33,9 +33,9 @@ namespace ewol {
return m_scale; return m_scale;
}; };
private: private:
etk::Vector<vec3> m_points; std::vector<vec3> m_points;
public: public:
const etk::Vector<vec3>& getPointList(void) const { const std::vector<vec3>& getPointList(void) const {
return m_points; return m_points;
}; };
public: public:

4
sources/ewol/renderer/Android/Context.cpp
View File

@ -395,7 +395,7 @@ class AndroidContext : public ewol::eContext {
} }
}; };
static etk::Vector<AndroidContext*> s_listInstance; static std::vector<AndroidContext*> s_listInstance;
extern "C" extern "C"
{ {
@ -458,7 +458,7 @@ extern "C"
return -1; return -1;
} }
// for future case : all time this ... // for future case : all time this ...
s_listInstance.pushBack(tmpContext); s_listInstance.push_back(tmpContext);
int32_t newID = s_listInstance.size()-1; int32_t newID = s_listInstance.size()-1;
return newID; return newID;
} }

2
sources/ewol/renderer/EMultiCast.cpp
View File

@ -33,7 +33,7 @@ void ewol::EMultiCast::add(ewol::EObject* _object, const char* const _message) {
EWOL_ERROR("Add with NULL Message"); EWOL_ERROR("Add with NULL Message");
return; return;
} }
m_messageList.pushBack(MessageList(_message, _object)); m_messageList.push_back(MessageList(_message, _object));
EWOL_DEBUG("SendMulticast ADD listener :" << _object->getId() << " on \"" << _message << "\"" ); EWOL_DEBUG("SendMulticast ADD listener :" << _object->getId() << " on \"" << _message << "\"" );
} }

4
sources/ewol/renderer/EMultiCast.h
View File

@ -11,7 +11,7 @@
#include <etk/types.h> #include <etk/types.h>
#include <etk/UString.h> #include <etk/UString.h>
#include <etk/Vector.h> #include <vector>
#include <exml/exml.h> #include <exml/exml.h>
#include <ewol/renderer/EObject.h> #include <ewol/renderer/EObject.h>
@ -28,7 +28,7 @@ namespace ewol {
const char* m_message; const char* m_message;
ewol::EObject* m_object; ewol::EObject* m_object;
}; };
etk::Vector<MessageList> m_messageList; //!< List of all message ... std::vector<MessageList> m_messageList; //!< List of all message ...
public: public:
EMultiCast(); EMultiCast();
~EMultiCast(void); ~EMultiCast(void);

6
sources/ewol/renderer/EObject.cpp
View File

@ -53,7 +53,7 @@ void ewol::EObject::removeObject(void) {
void ewol::EObject::addEventId(const char * _generateEventId) { void ewol::EObject::addEventId(const char * _generateEventId) {
if (NULL != _generateEventId) { if (NULL != _generateEventId) {
m_availlableEventId.pushBack(_generateEventId); m_availlableEventId.push_back(_generateEventId);
} }
} }
@ -141,7 +141,7 @@ void ewol::EObject::registerOnEvent(ewol::EObject * _destinationObject,
} else { } else {
tmpEvent->destEventId = _eventId; tmpEvent->destEventId = _eventId;
} }
m_externEvent.pushBack(tmpEvent); m_externEvent.push_back(tmpEvent);
} }
void ewol::EObject::unRegisterOnEvent(ewol::EObject * _destinationObject, void ewol::EObject::unRegisterOnEvent(ewol::EObject * _destinationObject,
@ -193,7 +193,7 @@ void ewol::EObject::registerConfig(const char* _config,
} }
} }
} }
m_listConfig.pushBack(ewol::EConfigElement(_config, _type, _control, _description, _default)); m_listConfig.push_back(ewol::EConfigElement(_config, _type, _control, _description, _default));
} }

10
sources/ewol/renderer/EObject.h
View File

@ -11,7 +11,7 @@
#include <etk/types.h> #include <etk/types.h>
#include <etk/UString.h> #include <etk/UString.h>
#include <etk/Vector.h> #include <vector>
#include <exml/exml.h> #include <exml/exml.h>
namespace ewol { namespace ewol {
// some class need to define element befor other ... // some class need to define element befor other ...
@ -47,8 +47,8 @@ namespace ewol {
bool m_static; //!< set this variable at true if this element must not be auto destroy (exemple : use static object) bool m_static; //!< set this variable at true if this element must not be auto destroy (exemple : use static object)
private: private:
int32_t m_uniqueId; //!< Object UniqueID == > TODO : Check if it use is needed int32_t m_uniqueId; //!< Object UniqueID == > TODO : Check if it use is needed
etk::Vector<EventExtGen*> m_externEvent; //!< Generic list of event generation for output link std::vector<EventExtGen*> m_externEvent; //!< Generic list of event generation for output link
etk::Vector<const char*> m_availlableEventId; //!< List of all event availlable for this widget std::vector<const char*> m_availlableEventId; //!< List of all event availlable for this widget
public: public:
/** /**
* @brief Constructor * @brief Constructor
@ -137,7 +137,7 @@ namespace ewol {
*/ */
virtual void onReceiveMessage(const ewol::EMessage& _msg) { }; virtual void onReceiveMessage(const ewol::EMessage& _msg) { };
private: private:
etk::Vector<ewol::EConfigElement> m_listConfig; std::vector<ewol::EConfigElement> m_listConfig;
protected: protected:
/** /**
* @brief the EObject add a configuration capabilities * @brief the EObject add a configuration capabilities
@ -166,7 +166,7 @@ namespace ewol {
* @brief get all the configuration list * @brief get all the configuration list
* @return The list of all parameter availlable in the widget * @return The list of all parameter availlable in the widget
*/ */
virtual const etk::Vector<ewol::EConfigElement>& getConfigList(void) { return m_listConfig; }; virtual const std::vector<ewol::EConfigElement>& getConfigList(void) { return m_listConfig; };
/** /**
* @brief Configuration requested to the curent EObject (systrem mode) * @brief Configuration requested to the curent EObject (systrem mode)
* @param[in] _conf Configuration handle. * @param[in] _conf Configuration handle.

4
sources/ewol/renderer/EObjectManager.cpp
View File

@ -57,7 +57,7 @@ void ewol::EObjectManager::unInit(void) {
void ewol::EObjectManager::add(ewol::EObject* _object) { void ewol::EObjectManager::add(ewol::EObject* _object) {
if (NULL != _object) { if (NULL != _object) {
m_eObjectList.pushBack(_object); m_eObjectList.push_back(_object);
} else { } else {
EWOL_ERROR("try to add an inexistant EObject in manager"); EWOL_ERROR("try to add an inexistant EObject in manager");
} }
@ -120,7 +120,7 @@ void ewol::EObjectManager::autoRemove(ewol::EObject* _object) {
m_eObjectList.erase(iii); m_eObjectList.erase(iii);
EWOL_DEBUG("Auto-Remove EObject : [" << _object->getId() << "] type=\"" << _object->getObjectType() << "\""); EWOL_DEBUG("Auto-Remove EObject : [" << _object->getId() << "] type=\"" << _object->getObjectType() << "\"");
informOneObjectIsRemoved(_object); informOneObjectIsRemoved(_object);
m_eObjectAutoRemoveList.pushBack(_object); m_eObjectAutoRemoveList.push_back(_object);
ewol::getContext().forceRedrawAll(); ewol::getContext().forceRedrawAll();
return; return;
} }

4
sources/ewol/renderer/EObjectManager.h
View File

@ -16,8 +16,8 @@
namespace ewol { namespace ewol {
class EObjectManager { class EObjectManager {
private: private:
etk::Vector<ewol::EObject*> m_eObjectList; // all widget allocated == > all time increment ... never removed ... std::vector<ewol::EObject*> m_eObjectList; // all widget allocated == > all time increment ... never removed ...
etk::Vector<ewol::EObject*> m_eObjectAutoRemoveList; // all widget allocated std::vector<ewol::EObject*> m_eObjectAutoRemoveList; // all widget allocated
public: public:
EObjectManager(void); EObjectManager(void);
~EObjectManager(void); ~EObjectManager(void);

10
sources/ewol/renderer/audio/audio.cpp
View File

@ -274,9 +274,9 @@ class RequestPlay {
} }
}; };
#include <etk/Vector.h> #include <vector>
etk::Vector<EffectsLoaded*> ListEffects; std::vector<EffectsLoaded*> ListEffects;
etk::Vector<RequestPlay*> ListEffectsPlaying; std::vector<RequestPlay*> ListEffectsPlaying;
int32_t ewol::audio::effects::add(etk::UString _file) { int32_t ewol::audio::effects::add(etk::UString _file) {
@ -294,7 +294,7 @@ int32_t ewol::audio::effects::add(etk::UString _file) {
EWOL_ERROR("Error to load the effects : \"" << _file << "\""); EWOL_ERROR("Error to load the effects : \"" << _file << "\"");
return -1; return -1;
} }
ListEffects.pushBack(tmpEffect); ListEffects.push_back(tmpEffect);
return ListEffects.size()-1; return ListEffects.size()-1;
} }
@ -342,7 +342,7 @@ void ewol::audio::effects::play(int32_t _effectId, float _xxx, float _yyy) {
EWOL_CRITICAL("Allocation error of a playing element : " << _effectId); EWOL_CRITICAL("Allocation error of a playing element : " << _effectId);
return; return;
} }
ListEffectsPlaying.pushBack(newPlay); ListEffectsPlaying.push_back(newPlay);
} }

24
sources/ewol/renderer/openGL.cpp
View File

@ -6,7 +6,7 @@
* @license BSD v3 (see license file) * @license BSD v3 (see license file)
*/ */
#include <etk/Vector.h> #include <vector>
#include <ewol/debug.h> #include <ewol/debug.h>
#include <ewol/renderer/openGL.h> #include <ewol/renderer/openGL.h>
@ -20,7 +20,7 @@ static etk::Mutex& mutexOpenGl(void) {
return s_drawMutex; return s_drawMutex;
} }
etk::Vector<mat4> l_matrixList; std::vector<mat4> l_matrixList;
mat4 l_matrixCamera; mat4 l_matrixCamera;
static uint32_t l_flagsCurrent = 0; static uint32_t l_flagsCurrent = 0;
static uint32_t l_flagsMustBeSet = 0; static uint32_t l_flagsMustBeSet = 0;
@ -32,7 +32,7 @@ void ewol::openGL::lock(void) {
mutexOpenGl().lock(); mutexOpenGl().lock();
l_matrixList.clear(); l_matrixList.clear();
mat4 tmpMat; mat4 tmpMat;
l_matrixList.pushBack(tmpMat); l_matrixList.push_back(tmpMat);
l_matrixCamera.identity(); l_matrixCamera.identity();
l_flagsCurrent = 0; l_flagsCurrent = 0;
l_flagsMustBeSet = 0; l_flagsMustBeSet = 0;
@ -49,13 +49,13 @@ void ewol::openGL::setBasicMatrix(const mat4& _newOne) {
EWOL_ERROR("matrix is not corect size in the stack : " << l_matrixList.size()); EWOL_ERROR("matrix is not corect size in the stack : " << l_matrixList.size());
} }
l_matrixList.clear(); l_matrixList.clear();
l_matrixList.pushBack(_newOne); l_matrixList.push_back(_newOne);
} }
void ewol::openGL::setMatrix(const mat4& _newOne) { void ewol::openGL::setMatrix(const mat4& _newOne) {
if (l_matrixList.size() == 0) { if (l_matrixList.size() == 0) {
EWOL_ERROR("set matrix list is not corect size in the stack : " << l_matrixList.size()); EWOL_ERROR("set matrix list is not corect size in the stack : " << l_matrixList.size());
l_matrixList.pushBack(_newOne); l_matrixList.push_back(_newOne);
return; return;
} }
l_matrixList[l_matrixList.size()-1] = _newOne; l_matrixList[l_matrixList.size()-1] = _newOne;
@ -65,11 +65,11 @@ void ewol::openGL::push(void) {
if (l_matrixList.size() == 0) { if (l_matrixList.size() == 0) {
EWOL_ERROR("set matrix list is not corect size in the stack : " << l_matrixList.size()); EWOL_ERROR("set matrix list is not corect size in the stack : " << l_matrixList.size());
mat4 tmp; mat4 tmp;
l_matrixList.pushBack(tmp); l_matrixList.push_back(tmp);
return; return;
} }
mat4 tmp = l_matrixList[l_matrixList.size()-1]; mat4 tmp = l_matrixList[l_matrixList.size()-1];
l_matrixList.pushBack(tmp); l_matrixList.push_back(tmp);
} }
void ewol::openGL::pop(void) { void ewol::openGL::pop(void) {
@ -77,7 +77,7 @@ void ewol::openGL::pop(void) {
EWOL_ERROR("set matrix list is not corect size in the stack : " << l_matrixList.size()); EWOL_ERROR("set matrix list is not corect size in the stack : " << l_matrixList.size());
l_matrixList.clear(); l_matrixList.clear();
mat4 tmp; mat4 tmp;
l_matrixList.pushBack(tmp); l_matrixList.push_back(tmp);
l_matrixCamera.identity(); l_matrixCamera.identity();
return; return;
} }
@ -89,7 +89,7 @@ const mat4& ewol::openGL::getMatrix(void) {
if (l_matrixList.size() == 0) { if (l_matrixList.size() == 0) {
EWOL_ERROR("set matrix list is not corect size in the stack : " << l_matrixList.size()); EWOL_ERROR("set matrix list is not corect size in the stack : " << l_matrixList.size());
mat4 tmp; mat4 tmp;
l_matrixList.pushBack(tmp); l_matrixList.push_back(tmp);
} }
return l_matrixList[l_matrixList.size()-1]; return l_matrixList[l_matrixList.size()-1];
} }
@ -252,7 +252,7 @@ void ewol::openGL::drawArrays(uint32_t _mode, int32_t _first, int32_t _count) {
} }
} }
void ewol::openGL::drawElements(uint32_t _mode, const etk::Vector<uint32_t>& _indices) { void ewol::openGL::drawElements(uint32_t _mode, const std::vector<uint32_t>& _indices) {
if (l_programId >= 0) { if (l_programId >= 0) {
updateAllFlags(); updateAllFlags();
//EWOL_DEBUG("Request draw of " << indices.size() << "elements"); //EWOL_DEBUG("Request draw of " << indices.size() << "elements");
@ -260,14 +260,14 @@ void ewol::openGL::drawElements(uint32_t _mode, const etk::Vector<uint32_t>& _in
} }
} }
void ewol::openGL::drawElements16(uint32_t _mode, const etk::Vector<uint16_t>& _indices) { void ewol::openGL::drawElements16(uint32_t _mode, const std::vector<uint16_t>& _indices) {
if (l_programId >= 0) { if (l_programId >= 0) {
updateAllFlags(); updateAllFlags();
glDrawElements(_mode, _indices.size(), GL_UNSIGNED_SHORT, &_indices[0]); glDrawElements(_mode, _indices.size(), GL_UNSIGNED_SHORT, &_indices[0]);
} }
} }
void ewol::openGL::drawElements8(uint32_t _mode, const etk::Vector<uint8_t>& _indices) { void ewol::openGL::drawElements8(uint32_t _mode, const std::vector<uint8_t>& _indices) {
if (l_programId >= 0) { if (l_programId >= 0) {
updateAllFlags(); updateAllFlags();
glDrawElements(_mode, _indices.size(), GL_UNSIGNED_BYTE, &_indices[0]); glDrawElements(_mode, _indices.size(), GL_UNSIGNED_BYTE, &_indices[0]);

8
sources/ewol/renderer/openGL.h
View File

@ -10,7 +10,7 @@
#define __OPEN_GL_H__ #define __OPEN_GL_H__
#include <etk/types.h> #include <etk/types.h>
#include <etk/Vector.h> #include <vector>
#include <etk/math/Matrix4.h> #include <etk/math/Matrix4.h>
#ifdef __cplusplus #ifdef __cplusplus
@ -170,9 +170,9 @@ namespace ewol {
* @brief draw a specific array == > this enable mode difference ... * @brief draw a specific array == > this enable mode difference ...
*/ */
void drawArrays(uint32_t _mode, int32_t _first, int32_t _count); void drawArrays(uint32_t _mode, int32_t _first, int32_t _count);
void drawElements (uint32_t _mode, const etk::Vector<uint32_t>& _indices); void drawElements (uint32_t _mode, const std::vector<uint32_t>& _indices);
void drawElements16(uint32_t _mode, const etk::Vector<uint16_t>& _indices); void drawElements16(uint32_t _mode, const std::vector<uint16_t>& _indices);
void drawElements8 (uint32_t _mode, const etk::Vector<uint8_t>& _indices); void drawElements8 (uint32_t _mode, const std::vector<uint8_t>& _indices);
/** /**
* @brief Use openGL program * @brief Use openGL program
* @param[in] id Id of the program that might be used * @param[in] id Id of the program that might be used

6
sources/ewol/resources/Colored3DObject.cpp
View File

@ -32,7 +32,7 @@ ewol::Colored3DObject::~Colored3DObject(void) {
} }
void ewol::Colored3DObject::draw(etk::Vector<vec3>& _vertices, void ewol::Colored3DObject::draw(std::vector<vec3>& _vertices,
const etk::Color<float>& _color, const etk::Color<float>& _color,
bool _updateDepthBuffer, bool _updateDepthBuffer,
bool _depthtest) { bool _depthtest) {
@ -74,7 +74,7 @@ void ewol::Colored3DObject::draw(etk::Vector<vec3>& _vertices,
} }
} }
void ewol::Colored3DObject::draw(etk::Vector<vec3>& _vertices, void ewol::Colored3DObject::draw(std::vector<vec3>& _vertices,
const etk::Color<float>& _color, const etk::Color<float>& _color,
mat4& _transformationMatrix, mat4& _transformationMatrix,
bool _updateDepthBuffer, bool _updateDepthBuffer,
@ -114,7 +114,7 @@ void ewol::Colored3DObject::draw(etk::Vector<vec3>& _vertices,
} }
} }
void ewol::Colored3DObject::drawLine(etk::Vector<vec3>& _vertices, void ewol::Colored3DObject::drawLine(std::vector<vec3>& _vertices,
const etk::Color<float>& _color, const etk::Color<float>& _color,
mat4& _transformationMatrix, mat4& _transformationMatrix,
bool _updateDepthBuffer, bool _updateDepthBuffer,

6
sources/ewol/resources/Colored3DObject.h
View File

@ -27,16 +27,16 @@ namespace ewol {
virtual ~Colored3DObject(void); virtual ~Colored3DObject(void);
public: public:
virtual const char* getType(void) { return "ewol::Colored3DObject"; }; virtual const char* getType(void) { return "ewol::Colored3DObject"; };
virtual void draw(etk::Vector<vec3>& _vertices, virtual void draw(std::vector<vec3>& _vertices,
const etk::Color<float>& _color, const etk::Color<float>& _color,
bool _updateDepthBuffer=true, bool _updateDepthBuffer=true,
bool _depthtest=true); bool _depthtest=true);
virtual void draw(etk::Vector<vec3>& _vertices, virtual void draw(std::vector<vec3>& _vertices,
const etk::Color<float>& _color, const etk::Color<float>& _color,
mat4& _transformationMatrix, mat4& _transformationMatrix,
bool _updateDepthBuffer=true, bool _updateDepthBuffer=true,
bool _depthtest=true); bool _depthtest=true);
virtual void drawLine(etk::Vector<vec3>& _vertices, virtual void drawLine(std::vector<vec3>& _vertices,
const etk::Color<float>& _color, const etk::Color<float>& _color,
mat4& _transformationMatrix, mat4& _transformationMatrix,
bool _updateDepthBuffer=true, bool _updateDepthBuffer=true,

4
sources/ewol/resources/ConfigFile.cpp
View File

@ -118,7 +118,7 @@ void ewol::ConfigFile::reload(void) {
EWOL_DEBUG("error while allocation"); EWOL_DEBUG("error while allocation");
} else { } else {
tmpElement->parse(paramValue); tmpElement->parse(paramValue);
m_list.pushBack(tmpElement); m_list.push_back(tmpElement);
} }
} }
} }
@ -140,7 +140,7 @@ int32_t ewol::ConfigFile::request(const etk::UString& _paramName) {
if (NULL == tmpElement) { if (NULL == tmpElement) {
EWOL_DEBUG("error while allocation"); EWOL_DEBUG("error while allocation");
} else { } else {
m_list.pushBack(tmpElement); m_list.push_back(tmpElement);
} }
return m_list.size()-1; return m_list.size()-1;
} }

2
sources/ewol/resources/ConfigFile.h
View File

@ -36,7 +36,7 @@ namespace ewol {
class ConfigFile : public ewol::Resource { class ConfigFile : public ewol::Resource {
private: private:
etk::Vector<ewol::SimpleConfigElement*> m_list; std::vector<ewol::SimpleConfigElement*> m_list;
etk::UString m_errorString; etk::UString m_errorString;
protected: protected:
ConfigFile(const etk::UString& _filename); ConfigFile(const etk::UString& _filename);

4
sources/ewol/resources/FontFreeType.cpp
View File

@ -7,7 +7,7 @@
*/ */
#include <etk/unicode.h> #include <etk/unicode.h>
#include <etk/Vector.h> #include <vector>
#include <etk/os/FSNode.h> #include <etk/os/FSNode.h>
@ -223,7 +223,7 @@ bool ewol::FontFreeType::drawGlyph(egami::Image& _imageOut,
} }
void ewol::FontFreeType::generateKerning(int32_t fontSize, etk::Vector<ewol::GlyphProperty>& listGlyph) { void ewol::FontFreeType::generateKerning(int32_t fontSize, std::vector<ewol::GlyphProperty>& listGlyph) {
if(false == m_init) { if(false == m_init) {
return; return;
} }

2
sources/ewol/resources/FontFreeType.h
View File

@ -44,7 +44,7 @@ namespace ewol {
int32_t getHeight(int32_t _fontSize); int32_t getHeight(int32_t _fontSize);
void generateKerning(int32_t _fontSize, etk::Vector<ewol::GlyphProperty>& _listGlyph); void generateKerning(int32_t _fontSize, std::vector<ewol::GlyphProperty>& _listGlyph);
public: public:
/** /**
* @brief keep the resource pointer. * @brief keep the resource pointer.

114
sources/ewol/resources/Mesh.cpp
View File

@ -133,15 +133,15 @@ void ewol::Mesh::draw(mat4& _positionMatrix,
vec3 cameraNormal = vec3(0,0,-1); vec3 cameraNormal = vec3(0,0,-1);
cameraNormal.normalized(); cameraNormal.normalized();
// remove face that is notin the view ... // remove face that is notin the view ...
etk::Vector<uint32_t> tmpIndexResult; std::vector<uint32_t> tmpIndexResult;
etk::Vector<ewol::Face>& tmppFaces = m_listFaces.getValue(kkk).m_faces; std::vector<ewol::Face>& tmppFaces = m_listFaces.getValue(kkk).m_faces;
//etk::Vector<uint32_t>& tmppIndex = m_listFaces.getValue(kkk).m_index; //std::vector<uint32_t>& tmppIndex = m_listFaces.getValue(kkk).m_index;
if (normalModeFace == m_normalMode) { if (normalModeFace == m_normalMode) {
for(int32_t iii=0; iii<tmppFaces.size() ; ++iii) { for(int32_t iii=0; iii<tmppFaces.size() ; ++iii) {
if(btDot(mattttt * m_listFacesNormal[tmppFaces[iii].m_normal[0]], cameraNormal) >= 0.0f) { if(btDot(mattttt * m_listFacesNormal[tmppFaces[iii].m_normal[0]], cameraNormal) >= 0.0f) {
tmpIndexResult.pushBack(iii*3); tmpIndexResult.push_back(iii*3);
tmpIndexResult.pushBack(iii*3+1); tmpIndexResult.push_back(iii*3+1);
tmpIndexResult.pushBack(iii*3+2); tmpIndexResult.push_back(iii*3+2);
} }
} }
} else { } else {
@ -149,9 +149,9 @@ void ewol::Mesh::draw(mat4& _positionMatrix,
if( (btDot(mattttt * m_listVertexNormal[tmppFaces[iii].m_normal[0]], cameraNormal) >= -0.2f) if( (btDot(mattttt * m_listVertexNormal[tmppFaces[iii].m_normal[0]], cameraNormal) >= -0.2f)
|| (btDot(mattttt * m_listVertexNormal[tmppFaces[iii].m_normal[1]], cameraNormal) >= -0.2f) || (btDot(mattttt * m_listVertexNormal[tmppFaces[iii].m_normal[1]], cameraNormal) >= -0.2f)
|| (btDot(mattttt * m_listVertexNormal[tmppFaces[iii].m_normal[2]], cameraNormal) >= -0.2f) ) { || (btDot(mattttt * m_listVertexNormal[tmppFaces[iii].m_normal[2]], cameraNormal) >= -0.2f) ) {
tmpIndexResult.pushBack(iii*3); tmpIndexResult.push_back(iii*3);
tmpIndexResult.pushBack(iii*3+1); tmpIndexResult.push_back(iii*3+1);
tmpIndexResult.pushBack(iii*3+2); tmpIndexResult.push_back(iii*3+2);
} }
} }
} }
@ -180,12 +180,12 @@ void ewol::Mesh::draw(mat4& _positionMatrix,
void ewol::Mesh::calculateNormaleFace(void) { void ewol::Mesh::calculateNormaleFace(void) {
m_listFacesNormal.clear(); m_listFacesNormal.clear();
if (m_normalMode != ewol::Mesh::normalModeFace) { if (m_normalMode != ewol::Mesh::normalModeFace) {
etk::Vector<Face>& tmpFaceList = m_listFaces.getValue(0).m_faces; std::vector<Face>& tmpFaceList = m_listFaces.getValue(0).m_faces;
for(int32_t iii=0 ; iii<tmpFaceList.size() ; iii++) { for(int32_t iii=0 ; iii<tmpFaceList.size() ; iii++) {
// for all case, We use only the 3 vertex for quad element, in theory 3D modeler export element in triangle if it is not a real plane. // for all case, We use only the 3 vertex for quad element, in theory 3D modeler export element in triangle if it is not a real plane.
vec3 normal = btCross(m_listVertex[tmpFaceList[iii].m_vertex[0]]-m_listVertex[tmpFaceList[iii].m_vertex[1]], vec3 normal = btCross(m_listVertex[tmpFaceList[iii].m_vertex[0]]-m_listVertex[tmpFaceList[iii].m_vertex[1]],
m_listVertex[tmpFaceList[iii].m_vertex[1]]-m_listVertex[tmpFaceList[iii].m_vertex[2]]); m_listVertex[tmpFaceList[iii].m_vertex[1]]-m_listVertex[tmpFaceList[iii].m_vertex[2]]);
m_listFacesNormal.pushBack(normal.normalized()); m_listFacesNormal.push_back(normal.normalized());
} }
m_normalMode = ewol::Mesh::normalModeFace; m_normalMode = ewol::Mesh::normalModeFace;
} }
@ -195,7 +195,7 @@ void ewol::Mesh::calculateNormaleEdge(void) {
m_listVertexNormal.clear(); m_listVertexNormal.clear();
if (m_normalMode != ewol::Mesh::normalModeVertex) { if (m_normalMode != ewol::Mesh::normalModeVertex) {
for(int32_t iii=0 ; iii<m_listVertex.size() ; iii++) { for(int32_t iii=0 ; iii<m_listVertex.size() ; iii++) {
etk::Vector<Face>& tmpFaceList = m_listFaces.getValue(0).m_faces; std::vector<Face>& tmpFaceList = m_listFaces.getValue(0).m_faces;
vec3 normal(0,0,0); vec3 normal(0,0,0);
// add the vertex from all the element in the list for face when the element in the face ... // add the vertex from all the element in the list for face when the element in the face ...
for(int32_t jjj=0 ; jjj<tmpFaceList.size() ; jjj++) { for(int32_t jjj=0 ; jjj<tmpFaceList.size() ; jjj++) {
@ -207,9 +207,9 @@ void ewol::Mesh::calculateNormaleEdge(void) {
} }
} }
if (normal == vec3(0,0,0)) { if (normal == vec3(0,0,0)) {
m_listVertexNormal.pushBack(vec3(1,1,1)); m_listVertexNormal.push_back(vec3(1,1,1));
} else { } else {
m_listVertexNormal.pushBack(normal.normalized()); m_listVertexNormal.push_back(normal.normalized());
} }
} }
m_normalMode = ewol::Mesh::normalModeVertex; m_normalMode = ewol::Mesh::normalModeVertex;
@ -271,7 +271,7 @@ void ewol::Mesh::generateVBO(void) {
} }
} }
for(int32_t indice=0 ; indice<3; indice++) { for(int32_t indice=0 ; indice<3; indice++) {
tmpFaceList.m_index.pushBack(vertexVBOId[indice]); tmpFaceList.m_index.push_back(vertexVBOId[indice]);
} }
} }
#ifdef TRY_MINIMAL_VBO #ifdef TRY_MINIMAL_VBO
@ -310,14 +310,14 @@ void ewol::Mesh::createViewBox(const etk::UString& _materialName,float _size) {
o---------------------o o---------------------o
0 3 0 3
*/ */
m_listVertex.pushBack(vec3( _size, -_size, -_size)); // 0 m_listVertex.push_back(vec3( _size, -_size, -_size)); // 0
m_listVertex.pushBack(vec3( _size, -_size, _size)); // 1 m_listVertex.push_back(vec3( _size, -_size, _size)); // 1
m_listVertex.pushBack(vec3(-_size, -_size, _size)); // 2 m_listVertex.push_back(vec3(-_size, -_size, _size)); // 2
m_listVertex.pushBack(vec3(-_size, -_size, -_size)); // 3 m_listVertex.push_back(vec3(-_size, -_size, -_size)); // 3
m_listVertex.pushBack(vec3( _size, _size, -_size)); // 4 m_listVertex.push_back(vec3( _size, _size, -_size)); // 4
m_listVertex.pushBack(vec3( _size, _size, _size)); // 5 m_listVertex.push_back(vec3( _size, _size, _size)); // 5
m_listVertex.pushBack(vec3(-_size, _size, _size)); // 6 m_listVertex.push_back(vec3(-_size, _size, _size)); // 6
m_listVertex.pushBack(vec3(-_size, _size, -_size)); // 7 m_listVertex.push_back(vec3(-_size, _size, -_size)); // 7
/* /*
o----------o----------o----------o o----------o----------o----------o
|8 |9 |10 |11 |8 |9 |10 |11
@ -340,18 +340,18 @@ void ewol::Mesh::createViewBox(const etk::UString& _materialName,float _size) {
o----------o----------o----------o o----------o----------o----------o
0 1 2 3 0 1 2 3
*/ */
m_listUV.pushBack(vec2(0.0 , 0.0 )); // 0 m_listUV.push_back(vec2(0.0 , 0.0 )); // 0
m_listUV.pushBack(vec2(1.0/3.0, 0.0 )); // 1 m_listUV.push_back(vec2(1.0/3.0, 0.0 )); // 1
m_listUV.pushBack(vec2(2.0/3.0, 0.0 )); // 2 m_listUV.push_back(vec2(2.0/3.0, 0.0 )); // 2
m_listUV.pushBack(vec2(1.0 , 0.0 )); // 3 m_listUV.push_back(vec2(1.0 , 0.0 )); // 3
m_listUV.pushBack(vec2(0.0 , 0.5 )); // 4 m_listUV.push_back(vec2(0.0 , 0.5 )); // 4
m_listUV.pushBack(vec2(1.0/3.0, 0.5 )); // 5 m_listUV.push_back(vec2(1.0/3.0, 0.5 )); // 5
m_listUV.pushBack(vec2(2.0/3.0, 0.5 )); // 6 m_listUV.push_back(vec2(2.0/3.0, 0.5 )); // 6
m_listUV.pushBack(vec2(1.0 , 0.5 )); // 7 m_listUV.push_back(vec2(1.0 , 0.5 )); // 7
m_listUV.pushBack(vec2(0.0 , 1.0 )); // 8 m_listUV.push_back(vec2(0.0 , 1.0 )); // 8
m_listUV.pushBack(vec2(1.0/3.0, 1.0 )); // 9 m_listUV.push_back(vec2(1.0/3.0, 1.0 )); // 9
m_listUV.pushBack(vec2(2.0/3.0, 1.0 )); // 10 m_listUV.push_back(vec2(2.0/3.0, 1.0 )); // 10
m_listUV.pushBack(vec2(1.0 , 1.0 )); // 11 m_listUV.push_back(vec2(1.0 , 1.0 )); // 11
if (m_listFaces.exist(_materialName) == false) { if (m_listFaces.exist(_materialName) == false) {
FaceIndexing empty; FaceIndexing empty;
@ -359,18 +359,18 @@ void ewol::Mesh::createViewBox(const etk::UString& _materialName,float _size) {
} }
{ {
FaceIndexing& tmpElement = m_listFaces[_materialName]; FaceIndexing& tmpElement = m_listFaces[_materialName];
tmpElement.m_faces.pushBack(Face(0,1, 1,5, 2,6)); // 4 tmpElement.m_faces.push_back(Face(0,1, 1,5, 2,6)); // 4
tmpElement.m_faces.pushBack(Face(0,1, 2,6, 3,2)); // 4 tmpElement.m_faces.push_back(Face(0,1, 2,6, 3,2)); // 4
tmpElement.m_faces.pushBack(Face(4,4, 0,0, 3,1)); // 3 tmpElement.m_faces.push_back(Face(4,4, 0,0, 3,1)); // 3
tmpElement.m_faces.pushBack(Face(4,4, 3,1, 7,5)); // 3 tmpElement.m_faces.push_back(Face(4,4, 3,1, 7,5)); // 3
tmpElement.m_faces.pushBack(Face(2,6, 6,10, 7,11)); // 2 tmpElement.m_faces.push_back(Face(2,6, 6,10, 7,11)); // 2
tmpElement.m_faces.pushBack(Face(2,6, 7,11, 3,7)); // 2 tmpElement.m_faces.push_back(Face(2,6, 7,11, 3,7)); // 2
tmpElement.m_faces.pushBack(Face(4,2, 7,3, 6,7)); // 5 tmpElement.m_faces.push_back(Face(4,2, 7,3, 6,7)); // 5
tmpElement.m_faces.pushBack(Face(4,2, 6,7, 5,6)); // 5 tmpElement.m_faces.push_back(Face(4,2, 6,7, 5,6)); // 5
tmpElement.m_faces.pushBack(Face(1,5, 5,9, 6,10)); // 1 tmpElement.m_faces.push_back(Face(1,5, 5,9, 6,10)); // 1
tmpElement.m_faces.pushBack(Face(1,5, 6,10, 2,6)); // 1 tmpElement.m_faces.push_back(Face(1,5, 6,10, 2,6)); // 1
tmpElement.m_faces.pushBack(Face(0,4, 4,8, 5,9)); // 0 tmpElement.m_faces.push_back(Face(0,4, 4,8, 5,9)); // 0
tmpElement.m_faces.pushBack(Face(0,4, 5,9, 1,5)); // 0 tmpElement.m_faces.push_back(Face(0,4, 5,9, 1,5)); // 0
} }
calculateNormaleFace(); calculateNormaleFace();
} }
@ -405,12 +405,12 @@ bool ewol::Mesh::loadOBJ(const etk::UString& _fileName) {
// Texture position : vt 0.748573 0.750412 // Texture position : vt 0.748573 0.750412
vec2 vertex(0,0); vec2 vertex(0,0);
sscanf(&inputDataLine[3], "%f %f", &vertex.m_floats[0], &vertex.m_floats[1]); sscanf(&inputDataLine[3], "%f %f", &vertex.m_floats[0], &vertex.m_floats[1]);
m_listUV.pushBack(vertex); m_listUV.push_back(vertex);
} else { } else {
// Vertice position : v 1.000000 -1.000000 -1.000000 // Vertice position : v 1.000000 -1.000000 -1.000000
vec3 vertex(0,0,0); vec3 vertex(0,0,0);
sscanf(&inputDataLine[2], "%f %f %f", &vertex.m_floats[0], &vertex.m_floats[1], &vertex.m_floats[2] ); sscanf(&inputDataLine[2], "%f %f %f", &vertex.m_floats[0], &vertex.m_floats[1], &vertex.m_floats[2] );
m_listVertex.pushBack(vertex); m_listVertex.push_back(vertex);
} }
} else if (inputDataLine[0] == 'f') { } else if (inputDataLine[0] == 'f') {
// face : f 5/1/1 1/2/1 4/3/1* // face : f 5/1/1 1/2/1 4/3/1*
@ -448,12 +448,12 @@ bool ewol::Mesh::loadOBJ(const etk::UString& _fileName) {
} }
} }
if (true == quadMode) { if (true == quadMode) {
m_listFaces.pushBack(Face(vertexIndex[0]-1, uvIndex[0]-1, m_listFaces.push_back(Face(vertexIndex[0]-1, uvIndex[0]-1,
vertexIndex[1]-1, uvIndex[1]-1, vertexIndex[1]-1, uvIndex[1]-1,
vertexIndex[2]-1, uvIndex[2]-1, vertexIndex[2]-1, uvIndex[2]-1,
vertexIndex[3]-1, uvIndex[3]-1)); vertexIndex[3]-1, uvIndex[3]-1));
} else { } else {
m_listFaces.pushBack(Face(vertexIndex[0]-1, uvIndex[0]-1, m_listFaces.push_back(Face(vertexIndex[0]-1, uvIndex[0]-1,
vertexIndex[1]-1, uvIndex[1]-1, vertexIndex[1]-1, uvIndex[1]-1,
vertexIndex[2]-1, uvIndex[2]-1)); vertexIndex[2]-1, uvIndex[2]-1));
} }
@ -736,7 +736,7 @@ bool ewol::Mesh::loadEMF(const etk::UString& _fileName) {
break; break;
} }
sscanf(inputDataLine, "%f %f %f", &vertex.m_floats[0], &vertex.m_floats[1], &vertex.m_floats[2] ); sscanf(inputDataLine, "%f %f %f", &vertex.m_floats[0], &vertex.m_floats[1], &vertex.m_floats[2] );
m_listVertex.pushBack(vertex); m_listVertex.push_back(vertex);
int32_t len = strlen(inputDataLine)-1; int32_t len = strlen(inputDataLine)-1;
if( inputDataLine[len] == '\n' if( inputDataLine[len] == '\n'
|| inputDataLine[len] == '\r') { || inputDataLine[len] == '\r') {
@ -753,7 +753,7 @@ bool ewol::Mesh::loadEMF(const etk::UString& _fileName) {
break; break;
} }
sscanf(inputDataLine, "%f %f", &uvMap.m_floats[0], &uvMap.m_floats[1]); sscanf(inputDataLine, "%f %f", &uvMap.m_floats[0], &uvMap.m_floats[1]);
m_listUV.pushBack(uvMap); m_listUV.push_back(uvMap);
int32_t len = strlen(inputDataLine)-1; int32_t len = strlen(inputDataLine)-1;
if( inputDataLine[len] == '\n' if( inputDataLine[len] == '\n'
|| inputDataLine[len] == '\r') { || inputDataLine[len] == '\r') {
@ -772,7 +772,7 @@ bool ewol::Mesh::loadEMF(const etk::UString& _fileName) {
break; break;
} }
sscanf(inputDataLine, "%f %f %f", &normal.m_floats[0], &normal.m_floats[1], &normal.m_floats[2] ); sscanf(inputDataLine, "%f %f %f", &normal.m_floats[0], &normal.m_floats[1], &normal.m_floats[2] );
m_listVertexNormal.pushBack(normal); m_listVertexNormal.push_back(normal);
int32_t len = strlen(inputDataLine)-1; int32_t len = strlen(inputDataLine)-1;
if( inputDataLine[len] == '\n' if( inputDataLine[len] == '\n'
|| inputDataLine[len] == '\r') { || inputDataLine[len] == '\r') {
@ -791,7 +791,7 @@ bool ewol::Mesh::loadEMF(const etk::UString& _fileName) {
break; break;
} }
sscanf(inputDataLine, "%f %f %f", &normal.m_floats[0], &normal.m_floats[1], &normal.m_floats[2] ); sscanf(inputDataLine, "%f %f %f", &normal.m_floats[0], &normal.m_floats[1], &normal.m_floats[2] );
m_listFacesNormal.pushBack(normal); m_listFacesNormal.push_back(normal);
int32_t len = strlen(inputDataLine)-1; int32_t len = strlen(inputDataLine)-1;
if( inputDataLine[len] == '\n' if( inputDataLine[len] == '\n'
|| inputDataLine[len] == '\r') { || inputDataLine[len] == '\r') {
@ -840,7 +840,7 @@ bool ewol::Mesh::loadEMF(const etk::UString& _fileName) {
&vertexIndex[0], &uvIndex[0], &normalIndex[0], &vertexIndex[0], &uvIndex[0], &normalIndex[0],
&vertexIndex[1], &uvIndex[1], &normalIndex[1], &vertexIndex[1], &uvIndex[1], &normalIndex[1],
&vertexIndex[2], &uvIndex[2], &normalIndex[2] ); &vertexIndex[2], &uvIndex[2], &normalIndex[2] );
m_listFaces.getValue(meshFaceMaterialID).m_faces.pushBack(Face(vertexIndex[0], uvIndex[0], normalIndex[0], m_listFaces.getValue(meshFaceMaterialID).m_faces.push_back(Face(vertexIndex[0], uvIndex[0], normalIndex[0],
vertexIndex[1], uvIndex[1], normalIndex[1], vertexIndex[1], uvIndex[1], normalIndex[1],
vertexIndex[2], uvIndex[2], normalIndex[2])); vertexIndex[2], uvIndex[2], normalIndex[2]));
/* /*
@ -874,7 +874,7 @@ bool ewol::Mesh::loadEMF(const etk::UString& _fileName) {
EWOL_ERROR("Allocation error when creating physical shape ..."); EWOL_ERROR("Allocation error when creating physical shape ...");
continue; continue;
} }
m_physics.pushBack(physics); m_physics.push_back(physics);
EWOL_VERBOSE(" " << m_physics.size() << " " << inputDataLine); EWOL_VERBOSE(" " << m_physics.size() << " " << inputDataLine);
currentMode = EMFModuleMeshPhysicsNamed; currentMode = EMFModuleMeshPhysicsNamed;
} else if (currentMode == EMFModuleMeshPhysicsNamed) { } else if (currentMode == EMFModuleMeshPhysicsNamed) {

16
sources/ewol/resources/Mesh.h
View File

@ -67,8 +67,8 @@ namespace ewol {
}; };
class FaceIndexing { class FaceIndexing {
public: public:
etk::Vector<Face> m_faces; std::vector<Face> m_faces;
etk::Vector<uint32_t> m_index; std::vector<uint32_t> m_index;
}; };
class Mesh : public ewol::Resource { class Mesh : public ewol::Resource {
public: public:
@ -92,13 +92,13 @@ namespace ewol {
MaterialGlId m_GLMaterial; MaterialGlId m_GLMaterial;
ewol::Light m_light; ewol::Light m_light;
protected: protected:
etk::Vector<vec3> m_listVertex; //!< List of all vertex in the element std::vector<vec3> m_listVertex; //!< List of all vertex in the element
etk::Vector<vec2> m_listUV; //!< List of all UV point in the mesh (for the specify texture) std::vector<vec2> m_listUV; //!< List of all UV point in the mesh (for the specify texture)
etk::Vector<vec3> m_listFacesNormal; //!< List of all Face normal, when calculated std::vector<vec3> m_listFacesNormal; //!< List of all Face normal, when calculated
etk::Vector<vec3> m_listVertexNormal; //!< List of all Face normal, when calculated std::vector<vec3> m_listVertexNormal; //!< List of all Face normal, when calculated
etk::Hash<FaceIndexing> m_listFaces; //!< List of all Face for the mesh etk::Hash<FaceIndexing> m_listFaces; //!< List of all Face for the mesh
etk::Hash<ewol::Material*> m_materials; etk::Hash<ewol::Material*> m_materials;
etk::Vector<ewol::PhysicsShape*> m_physics; //!< collision shape module ... (independent of bullet lib) std::vector<ewol::PhysicsShape*> m_physics; //!< collision shape module ... (independent of bullet lib)
protected: protected:
ewol::VirtualBufferObject* m_verticesVBO; ewol::VirtualBufferObject* m_verticesVBO;
protected: protected:
@ -129,7 +129,7 @@ namespace ewol {
* @return get the chcking stus of normal or not * @return get the chcking stus of normal or not
*/ */
bool getCheckNormal(void) { return m_checkNormal; }; bool getCheckNormal(void) { return m_checkNormal; };
const etk::Vector<ewol::PhysicsShape*>& getPhysicalProperties(void) const { return m_physics; }; const std::vector<ewol::PhysicsShape*>& getPhysicalProperties(void) const { return m_physics; };
private: private:
void* m_pointerShape; //!< all mesh have a basic shape (bullet or other) the void pointer mermit to not depent on the bullet lib void* m_pointerShape; //!< all mesh have a basic shape (bullet or other) the void pointer mermit to not depent on the bullet lib
public: public:

10
sources/ewol/resources/Program.cpp
View File

@ -41,7 +41,7 @@ ewol::Program::Program(const etk::UString& _filename) :
return; return;
} else { } else {
EWOL_DEBUG("Add shader on program : "<< tmpFilename << "vert"); EWOL_DEBUG("Add shader on program : "<< tmpFilename << "vert");
m_shaderList.pushBack(tmpShader); m_shaderList.push_back(tmpShader);
} }
tmpShader = ewol::Shader::keep(tmpFilename+"frag"); tmpShader = ewol::Shader::keep(tmpFilename+"frag");
if (NULL == tmpShader) { if (NULL == tmpShader) {
@ -49,7 +49,7 @@ ewol::Program::Program(const etk::UString& _filename) :
return; return;
} else { } else {
EWOL_DEBUG("Add shader on program : "<< tmpFilename << "frag"); EWOL_DEBUG("Add shader on program : "<< tmpFilename << "frag");
m_shaderList.pushBack(tmpShader); m_shaderList.push_back(tmpShader);
} }
} else { } else {
etk::UString fileExtention = file.fileGetExtention(); etk::UString fileExtention = file.fileGetExtention();
@ -84,7 +84,7 @@ ewol::Program::Program(const etk::UString& _filename) :
EWOL_CRITICAL("Error while getting a specific shader filename : " << tmpFilename); EWOL_CRITICAL("Error while getting a specific shader filename : " << tmpFilename);
} else { } else {
EWOL_DEBUG("Add shader on program : "<< tmpFilename); EWOL_DEBUG("Add shader on program : "<< tmpFilename);
m_shaderList.pushBack(tmpShader); m_shaderList.push_back(tmpShader);
} }
} }
@ -132,7 +132,7 @@ int32_t ewol::Program::getAttribute(etk::UString _elementName) {
EWOL_WARNING("glGetAttribLocation(\"" << tmp.m_name << "\") = " << tmp.m_elementId); EWOL_WARNING("glGetAttribLocation(\"" << tmp.m_name << "\") = " << tmp.m_elementId);
tmp.m_isLinked = false; tmp.m_isLinked = false;
} }
m_elementList.pushBack(tmp); m_elementList.push_back(tmp);
return m_elementList.size()-1; return m_elementList.size()-1;
} }
@ -153,7 +153,7 @@ int32_t ewol::Program::getUniform(etk::UString _elementName) {
EWOL_WARNING("glGetUniformLocation(\"" << tmp.m_name << "\") = " << tmp.m_elementId); EWOL_WARNING("glGetUniformLocation(\"" << tmp.m_name << "\") = " << tmp.m_elementId);
tmp.m_isLinked = false; tmp.m_isLinked = false;
} }
m_elementList.pushBack(tmp); m_elementList.push_back(tmp);
return m_elementList.size()-1; return m_elementList.size()-1;
} }

4
sources/ewol/resources/Program.h
View File

@ -47,8 +47,8 @@ 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
etk::Vector<ewol::Shader*> m_shaderList; //!< List of all the shader loaded std::vector<ewol::Shader*> m_shaderList; //!< List of all the shader loaded
etk::Vector<ewol::progAttributeElement> m_elementList; //!< List of all the attribute requested by the user std::vector<ewol::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
protected: protected:

4
sources/ewol/resources/ResourceManager.cpp
View File

@ -98,7 +98,7 @@ void ewol::ResourceManager::update(ewol::Resource* _object) {
} }
} }
// add it ... // add it ...
m_resourceListToUpdate.pushBack(_object); m_resourceListToUpdate.push_back(_object);
} }
// Specific to load or update the data in the openGl context == > system use only // Specific to load or update the data in the openGl context == > system use only
@ -173,7 +173,7 @@ void ewol::ResourceManager::localAdd(ewol::Resource* _object) {
} }
} }
// add at the end if no slot is free // add at the end if no slot is free
m_resourceList.pushBack(_object); m_resourceList.push_back(_object);
} }
bool ewol::ResourceManager::release(ewol::Resource*& _object) { bool ewol::ResourceManager::release(ewol::Resource*& _object) {

4
sources/ewol/resources/ResourceManager.h
View File

@ -25,8 +25,8 @@
namespace ewol { namespace ewol {
class ResourceManager { class ResourceManager {
private: private:
etk::Vector<ewol::Resource*> m_resourceList; std::vector<ewol::Resource*> m_resourceList;
etk::Vector<ewol::Resource*> m_resourceListToUpdate; std::vector<ewol::Resource*> m_resourceListToUpdate;
bool m_contextHasBeenRemoved; bool m_contextHasBeenRemoved;
public: public:
/** /**

2
sources/ewol/resources/Shader.cpp
View File

@ -86,7 +86,7 @@ void ewol::Shader::updateContext(void) {
} }
EWOL_ERROR("Could not compile \"" << tmpShaderType << "\" name='" << m_name << "'"); EWOL_ERROR("Could not compile \"" << tmpShaderType << "\" name='" << m_name << "'");
EWOL_ERROR("Error " << l_bufferDisplayError); EWOL_ERROR("Error " << l_bufferDisplayError);
etk::Vector<etk::UString> lines = etk::UString(m_fileData).split('\n'); std::vector<etk::UString> lines = etk::UString(m_fileData).split('\n');
for (esize_t iii=0 ; iii<lines.size() ; iii++) { for (esize_t iii=0 ; iii<lines.size() ; iii++) {
EWOL_ERROR("file " << (iii+1) << "|" << lines[iii]); EWOL_ERROR("file " << (iii+1) << "|" << lines[iii]);
} }

14
sources/ewol/resources/TexturedFont.cpp
View File

@ -84,21 +84,21 @@ ewol::TexturedFont::TexturedFont(const etk::UString& _fontName) :
etk::UString localName = _fontName.extract(0, (tmpPos - tmpData)); etk::UString localName = _fontName.extract(0, (tmpPos - tmpData));
m_size = tmpSize; m_size = tmpSize;
etk::Vector<etk::UString> folderList; std::vector<etk::UString> folderList;
if (true == ewol::getContext().getFontDefault().getUseExternal()) { if (true == ewol::getContext().getFontDefault().getUseExternal()) {
#if defined(__TARGET_OS__Android) #if defined(__TARGET_OS__Android)
folderList.pushBack("/system/fonts"); folderList.push_back("/system/fonts");
#elif defined(__TARGET_OS__Linux) #elif defined(__TARGET_OS__Linux)
folderList.pushBack("/usr/share/fonts/truetype"); folderList.push_back("/usr/share/fonts/truetype");
#endif #endif
} }
folderList.pushBack(ewol::getContext().getFontDefault().getFolder()); folderList.push_back(ewol::getContext().getFontDefault().getFolder());
for (int32_t folderID=0; folderID<folderList.size() ; folderID++) { for (int32_t folderID=0; folderID<folderList.size() ; folderID++) {
etk::FSNode myFolder(folderList[folderID]); etk::FSNode myFolder(folderList[folderID]);
// find the real Font name : // find the real Font name :
etk::Vector<etk::UString> output; std::vector<etk::UString> output;
myFolder.folderGetRecursiveFiles(output); myFolder.folderGetRecursiveFiles(output);
etk::Vector<etk::UString> split = localName.split(';'); std::vector<etk::UString> split = localName.split(';');
EWOL_INFO("try to find font named : " << split << " in: " << myFolder); EWOL_INFO("try to find font named : " << split << " in: " << myFolder);
//EWOL_CRITICAL("parse string : " << split); //EWOL_CRITICAL("parse string : " << split);
bool hasFindAFont = false; bool hasFindAFont = false;
@ -282,7 +282,7 @@ bool ewol::TexturedFont::addGlyph(const etk::UChar& _val) {
EWOL_WARNING("Did not find char : '" << _val << "'=" << _val.get()); EWOL_WARNING("Did not find char : '" << _val << "'=" << _val.get());
tmpchar.setNotExist(); tmpchar.setNotExist();
} }
m_listElement[iii].pushBack(tmpchar); m_listElement[iii].push_back(tmpchar);
//m_font[iii]->display(); //m_font[iii]->display();
// generate the kerning for all the characters : // generate the kerning for all the characters :
if (tmpchar.exist() == true) { if (tmpchar.exist() == true) {

2
sources/ewol/resources/TexturedFont.h
View File

@ -35,7 +35,7 @@ namespace ewol {
ewol::FontBase* m_font[4]; ewol::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:
etk::Vector<GlyphProperty> m_listElement[4]; std::vector<GlyphProperty> m_listElement[4];
private: private:
// for the texture generation : // for the texture generation :
ivec2 m_lastGlyphPos[4]; ivec2 m_lastGlyphPos[4];

10
sources/ewol/resources/VirtualBufferObject.cpp
View File

@ -87,9 +87,9 @@ void ewol::VirtualBufferObject::flush(void) {
void ewol::VirtualBufferObject::pushOnBuffer(int32_t _id, const vec3& _data) { void ewol::VirtualBufferObject::pushOnBuffer(int32_t _id, const vec3& _data) {
m_vboUsed[_id] = true; m_vboUsed[_id] = true;
m_buffer[_id].pushBack(_data.x()); m_buffer[_id].push_back(_data.x());
m_buffer[_id].pushBack(_data.y()); m_buffer[_id].push_back(_data.y());
m_buffer[_id].pushBack(_data.z()); m_buffer[_id].push_back(_data.z());
} }
vec3 ewol::VirtualBufferObject::getOnBufferVec3(int32_t _id, int32_t _elementID) { vec3 ewol::VirtualBufferObject::getOnBufferVec3(int32_t _id, int32_t _elementID) {
@ -107,8 +107,8 @@ int32_t ewol::VirtualBufferObject::sizeOnBufferVec3(int32_t _id) {
void ewol::VirtualBufferObject::pushOnBuffer(int32_t _id, const vec2& _data) { void ewol::VirtualBufferObject::pushOnBuffer(int32_t _id, const vec2& _data) {
m_vboUsed[_id] = true; m_vboUsed[_id] = true;
m_buffer[_id].pushBack(_data.x()); m_buffer[_id].push_back(_data.x());
m_buffer[_id].pushBack(_data.y()); m_buffer[_id].push_back(_data.y());
} }
vec2 ewol::VirtualBufferObject::getOnBufferVec2(int32_t _id, int32_t _elementID) { vec2 ewol::VirtualBufferObject::getOnBufferVec2(int32_t _id, int32_t _elementID) {

4
sources/ewol/resources/VirtualBufferObject.h
View File

@ -27,7 +27,7 @@ namespace ewol {
bool m_exist; //!< This data is availlable in the Graphic card bool m_exist; //!< This data is availlable in the Graphic card
GLuint m_vbo[NB_VBO_MAX]; //!< openGl ID of this VBO GLuint m_vbo[NB_VBO_MAX]; //!< openGl ID of this VBO
bool m_vboUsed[NB_VBO_MAX]; //!< true if the VBO is allocated or used ... bool m_vboUsed[NB_VBO_MAX]; //!< true if the VBO is allocated or used ...
etk::Vector<float> m_buffer[NB_VBO_MAX]; //!< data that is availlable in the VBO system ... std::vector<float> m_buffer[NB_VBO_MAX]; //!< data that is availlable in the VBO system ...
protected: protected:
/** /**
* @brief Constructor of this VBO. * @brief Constructor of this VBO.
@ -54,7 +54,7 @@ namespace ewol {
* @param[in] id Id of the buffer requested * @param[in] id Id of the buffer requested
* @return A reference on the data. * @return A reference on the data.
*/ */
etk::Vector<float>& getRefBuffer(int32_t id) { m_vboUsed[id] = true; return m_buffer[id]; }; std::vector<float>& getRefBuffer(int32_t id) { m_vboUsed[id] = true; return m_buffer[id]; };
/** /**
* @brief push data on a buffer with a custum type : * @brief push data on a buffer with a custum type :
* @param[in] id Id of the buffer requested. * @param[in] id Id of the buffer requested.

2
sources/ewol/resources/font/FontBase.h
View File

@ -39,7 +39,7 @@ namespace ewol {
virtual int32_t getHeight(int32_t _fontSize) = 0; virtual int32_t getHeight(int32_t _fontSize) = 0;
virtual void generateKerning(int32_t _fontSize, etk::Vector<ewol::GlyphProperty>& _listGlyph) { }; virtual void generateKerning(int32_t _fontSize, std::vector<ewol::GlyphProperty>& _listGlyph) { };
virtual void display(void) {}; virtual void display(void) {};
}; };

4
sources/ewol/resources/font/GlyphProperty.h
View File

@ -61,7 +61,7 @@ namespace ewol {
vec2 m_texturePosStart; //!< Texture normalised position (START) vec2 m_texturePosStart; //!< Texture normalised position (START)
vec2 m_texturePosSize; //!< Texture normalised position (SIZE) vec2 m_texturePosSize; //!< Texture normalised position (SIZE)
private: private:
etk::Vector<ewol::Kerning> m_kerning; //!< kerning values of link of all elements std::vector<ewol::Kerning> m_kerning; //!< kerning values of link of all elements
public: public:
GlyphProperty(void) : GlyphProperty(void) :
m_UVal(0), m_UVal(0),
@ -84,7 +84,7 @@ namespace ewol {
}; };
void kerningAdd(const etk::UChar _charcode, float _value) void kerningAdd(const etk::UChar _charcode, float _value)
{ {
m_kerning.pushBack(ewol::Kerning(_charcode, _value)); m_kerning.push_back(ewol::Kerning(_charcode, _value));
}; };
void kerningClear(void) void kerningClear(void)
{ {

2
sources/ewol/resources/font/Kerning.h
View File

@ -42,7 +42,7 @@ namespace ewol {
float m_value; //!< kerning real offset float m_value; //!< kerning real offset
public: public:
/** /**
* @brief Simple constructor that allow to allocate the etk::Vector element * @brief Simple constructor that allow to allocate the std::vector element
*/ */
Kerning(void) : Kerning(void) :
m_UVal(0), m_UVal(0),

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

@ -59,7 +59,7 @@ int32_t widget::ContainerN::subWidgetAdd(ewol::Widget* _newWidget) {
if (_newWidget!=NULL) { if (_newWidget!=NULL) {
_newWidget->setUpperWidget(this); _newWidget->setUpperWidget(this);
} }
m_subWidget.pushBack(_newWidget); m_subWidget.push_back(_newWidget);
markToRedraw(); markToRedraw();
requestUpdateSize(); requestUpdateSize();
// added at the last eelement : // added at the last eelement :

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

@ -20,7 +20,7 @@ namespace widget {
*/ */
class ContainerN : public ewol::Widget { class ContainerN : public ewol::Widget {
protected: protected:
etk::Vector<ewol::Widget*> m_subWidget; std::vector<ewol::Widget*> m_subWidget;
public: public:
/** /**
* @brief Constructor * @brief Constructor

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

@ -162,7 +162,7 @@ void widget::Gird::setColNumber(int32_t _colNumber) {
} else { } else {
// just add the col size: // just add the col size:
for (int32_t iii=m_sizeCol.size()-1; iii<_colNumber-1 ; iii++) { for (int32_t iii=m_sizeCol.size()-1; iii<_colNumber-1 ; iii++) {
m_sizeCol.pushBack(0); m_sizeCol.push_back(0);
} }
} }
} }
@ -256,7 +256,7 @@ void widget::Gird::subWidgetAdd(int32_t _colId, int32_t _rowId, ewol::Widget* _n
} }
} }
// not find == > just adding it ... // not find == > just adding it ...
m_subWidget.pushBack(prop); m_subWidget.push_back(prop);
} }
void widget::Gird::subWidgetRemove(ewol::Widget* _newWidget) void widget::Gird::subWidgetRemove(ewol::Widget* _newWidget)

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

@ -10,7 +10,7 @@
#define __EWOL_WIDGET_GIRD_H__ #define __EWOL_WIDGET_GIRD_H__
#include <etk/types.h> #include <etk/types.h>
#include <etk/Vector.h> #include <vector>
#include <ewol/debug.h> #include <ewol/debug.h>
#include <ewol/widget/Widget.h> #include <ewol/widget/Widget.h>
#include <ewol/widget/WidgetManager.h> #include <ewol/widget/WidgetManager.h>
@ -31,8 +31,8 @@ namespace widget {
}; };
int32_t m_sizeRow; //!< size of all lines (row) (if set (otherwise 0)) == > we have a only one size ==> multiple size will have no use ... int32_t m_sizeRow; //!< size of all lines (row) (if set (otherwise 0)) == > we have a only one size ==> multiple size will have no use ...
int32_t m_uniformSizeRow; int32_t m_uniformSizeRow;
etk::Vector<int32_t> m_sizeCol; //!< size of all colomn (if set (otherwise 0)) std::vector<int32_t> m_sizeCol; //!< size of all colomn (if set (otherwise 0))
etk::Vector<GirdProperties> m_subWidget; //!< all sub widget are contained in this element std::vector<GirdProperties> m_subWidget; //!< all sub widget are contained in this element
ewol::Widget* m_tmpWidget; //!< use when replace a widget ... ewol::Widget* m_tmpWidget; //!< use when replace a widget ...
bool m_gavityButtom; bool m_gavityButtom;
public: public:

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

@ -78,7 +78,7 @@ void widget::List::addOObject(ewol::Compositing* _newObject, int32_t _pos) {
return; return;
} }
if (_pos < 0 || _pos >= m_listOObject.size() ) { if (_pos < 0 || _pos >= m_listOObject.size() ) {
m_listOObject.pushBack(_newObject); m_listOObject.push_back(_newObject);
} else { } else {
m_listOObject.insert(_pos, _newObject); m_listOObject.insert(_pos, _newObject);
} }
@ -128,7 +128,7 @@ void widget::List::onRegenerateDisplay(void) {
(minHeight + 2*m_paddingSizeY) * nbRaw ); (minHeight + 2*m_paddingSizeY) * nbRaw );
etk::Vector<int32_t> listSizeColomn; std::vector<int32_t> listSizeColomn;
ewol::Drawing * BGOObjects = new ewol::Drawing(); ewol::Drawing * BGOObjects = new ewol::Drawing();
etk::Color<> basicBG = getBasicBG(); etk::Color<> basicBG = getBasicBG();
@ -159,7 +159,7 @@ void widget::List::onRegenerateDisplay(void) {
int32_t displayPositionX = 0; int32_t displayPositionX = 0;
ivec2 tmpRegister(startRaw, displayPositionY); ivec2 tmpRegister(startRaw, displayPositionY);
// add the default position raw : // add the default position raw :
m_lineSize.pushBack(tmpRegister); m_lineSize.push_back(tmpRegister);
for(int32_t jjj=0; jjj<nbColomn && displayPositionX < m_size.x() ; jjj++) { for(int32_t jjj=0; jjj<nbColomn && displayPositionX < m_size.x() ; jjj++) {
int32_t sizeColom = 0; int32_t sizeColom = 0;
@ -196,14 +196,14 @@ void widget::List::onRegenerateDisplay(void) {
// add the raw position to remember it ... // add the raw position to remember it ...
tmpRegister.setX(tmpRegister.x()+1); tmpRegister.setX(tmpRegister.x()+1);
tmpRegister.setY(displayPositionY); tmpRegister.setY(displayPositionY);
m_lineSize.pushBack(tmpRegister); m_lineSize.push_back(tmpRegister);
//EWOL_DEBUG("List indexation:" << tmpRegister); //EWOL_DEBUG("List indexation:" << tmpRegister);
} }
} }
displayPositionX += sizeColom; displayPositionX += sizeColom;
tmpOriginX += m_paddingSizeX*2*2; tmpOriginX += m_paddingSizeX*2*2;
} }
//m_lineSize.pushBack(tmpOriginY); //m_lineSize.push_back(tmpOriginY);
addOObject(BGOObjects, 0); addOObject(BGOObjects, 0);
// call the herited class... // call the herited class...

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

@ -31,8 +31,8 @@ namespace widget {
void setLabel(etk::UString _newLabel); void setLabel(etk::UString _newLabel);
// drawing capabilities .... // drawing capabilities ....
private: private:
etk::Vector<ewol::Compositing*> m_listOObject; //!< generic element to display... std::vector<ewol::Compositing*> m_listOObject; //!< generic element to display...
etk::Vector<ivec2 > m_lineSize; std::vector<ivec2 > m_lineSize;
public: public:
void addOObject(ewol::Compositing* _newObject, int32_t _pos=-1); void addOObject(ewol::Compositing* _newObject, int32_t _pos=-1);
void clearOObjectList(void); void clearOObjectList(void);

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

@ -23,7 +23,7 @@ namespace widget {
*/ */
class ListFileSystem : public widget::List { class ListFileSystem : public widget::List {
private: private:
etk::Vector<etk::FSNode *> m_list; std::vector<etk::FSNode *> m_list;
etk::UString m_folder; etk::UString m_folder;
int32_t m_selectedLine; int32_t m_selectedLine;
bool m_showFile; bool m_showFile;

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

@ -79,7 +79,7 @@ int32_t widget::Menu::add(int32_t _parent,
tmpObject->m_image = _image; tmpObject->m_image = _image;
tmpObject->m_generateEvent = _generateEvent; tmpObject->m_generateEvent = _generateEvent;
tmpObject->m_message = _message; tmpObject->m_message = _message;
m_listElement.pushBack(tmpObject); m_listElement.push_back(tmpObject);
if (-1 == tmpObject->m_parentId) { if (-1 == tmpObject->m_parentId) {
widget::Button *myButton = NULL; widget::Button *myButton = NULL;
myButton = new widget::Button(); myButton = new widget::Button();

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

@ -45,7 +45,7 @@ namespace widget {
virtual void subWidgetRemove(ewol::Widget* _newWidget); virtual void subWidgetRemove(ewol::Widget* _newWidget);
virtual void subWidgetUnLink(ewol::Widget* _newWidget); virtual void subWidgetUnLink(ewol::Widget* _newWidget);
private: private:
etk::Vector<widget::MenuElement*> m_listElement; std::vector<widget::MenuElement*> m_listElement;
int32_t m_staticId; // unique ID for every element of the menu ... int32_t m_staticId; // unique ID for every element of the menu ...
widget::ContextMenu* m_widgetContextMenu; widget::ContextMenu* m_widgetContextMenu;
public: public:

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

@ -591,7 +591,7 @@ void ewol::Widget::shortCutAdd(const char * _descriptiveString,
tmpElement->unicodeValue = _descriptiveString[strlen(_descriptiveString) -1]; tmpElement->unicodeValue = _descriptiveString[strlen(_descriptiveString) -1];
} }
// add it on the List ... // add it on the List ...
m_localShortcut.pushBack(tmpElement); m_localShortcut.push_back(tmpElement);
} }
void ewol::Widget::shortCutClean(void) { void ewol::Widget::shortCutClean(void) {

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

@ -18,7 +18,7 @@ namespace ewol {
class Windows; class Windows;
}; };
#include <etk/types.h> #include <etk/types.h>
#include <etk/Vector.h> #include <vector>
#include <etk/math/Vector2D.h> #include <etk/math/Vector2D.h>
#include <ewol/debug.h> #include <ewol/debug.h>
#include <ewol/clipBoard.h> #include <ewol/clipBoard.h>
@ -585,7 +585,7 @@ namespace ewol {
// -- Shortcut : management of the shortcut // -- Shortcut : management of the shortcut
// ---------------------------------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------------------------------
private: private:
etk::Vector<EventShortCut*> m_localShortcut; //!< list of all shortcut in the widget std::vector<EventShortCut*> m_localShortcut; //!< list of all shortcut in the widget
protected: protected:
/** /**
* @brief add a specific shortcut with his description * @brief add a specific shortcut with his description

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

@ -24,7 +24,7 @@
#include <ewol/widget/CheckBox.h> #include <ewol/widget/CheckBox.h>
#include <ewol/widget/Scroll.h> #include <ewol/widget/Scroll.h>
#include <ewol/widget/PopUp.h> #include <ewol/widget/PopUp.h>
#include <etk/Vector.h> #include <vector>
#undef __class__ #undef __class__
#define __class__ "WidgetManager" #define __class__ "WidgetManager"
@ -165,7 +165,7 @@ void ewol::WidgetManager::periodicCallAdd(ewol::Widget* _pWidget) {
return; return;
} }
} }
m_listOfPeriodicWidget.pushBack(_pWidget); m_listOfPeriodicWidget.push_back(_pWidget);
m_havePeriodic = true; m_havePeriodic = true;
} }

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

@ -11,7 +11,7 @@
#include <etk/types.h> #include <etk/types.h>
#include <ewol/debug.h> #include <ewol/debug.h>
#include <etk/Vector.h> #include <vector>
#include <etk/Hash.h> #include <etk/Hash.h>
#include <ewol/widget/Widget.h> #include <ewol/widget/Widget.h>
@ -23,7 +23,7 @@ namespace ewol {
// For the focus Management // For the focus Management
ewol::Widget* m_focusWidgetDefault; ewol::Widget* m_focusWidgetDefault;
ewol::Widget* m_focusWidgetCurrent; ewol::Widget* m_focusWidgetCurrent;
etk::Vector<ewol::Widget*> m_listOfPeriodicWidget; std::vector<ewol::Widget*> m_listOfPeriodicWidget;
bool m_havePeriodic; bool m_havePeriodic;
bool m_haveRedraw; bool m_haveRedraw;
etk::Hash<creator_tf> m_creatorList; etk::Hash<creator_tf> m_creatorList;

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

@ -326,7 +326,7 @@ void widget::WidgetScrooled::addOObject(ewol::Compositing* _newObject, int32_t _
return; return;
} }
if (_pos < 0 || _pos >= m_listOObject.size() ) { if (_pos < 0 || _pos >= m_listOObject.size() ) {
m_listOObject.pushBack(_newObject); m_listOObject.push_back(_newObject);
} else { } else {
m_listOObject.insert(_pos, _newObject); m_listOObject.insert(_pos, _newObject);
} }

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

@ -27,7 +27,7 @@ namespace widget {
scroolModeGame, //!< Zoom enable, no move left and right scroolModeGame, //!< Zoom enable, no move left and right
}; };
private: private:
etk::Vector<ewol::Compositing*> m_listOObject; //!< generic element to display... std::vector<ewol::Compositing*> m_listOObject; //!< generic element to display...
void addOObject(ewol::Compositing* _newObject, int32_t _pos=-1); void addOObject(ewol::Compositing* _newObject, int32_t _pos=-1);
void clearOObjectList(void); void clearOObjectList(void);
protected: protected:

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

@ -180,7 +180,7 @@ void ewol::Windows::setSubWidget(ewol::Widget* _widget) {
} }
void ewol::Windows::popUpWidgetPush(ewol::Widget* _widget) { void ewol::Windows::popUpWidgetPush(ewol::Widget* _widget) {
m_popUpWidgetList.pushBack(_widget); m_popUpWidgetList.push_back(_widget);
// Regenerate the size calculation : // Regenerate the size calculation :
calculateSize(m_size); calculateSize(m_size);
// TODO : it is dansgerous to access directly to the system ... // TODO : it is dansgerous to access directly to the system ...

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

@ -48,7 +48,7 @@ namespace ewol {
} }
private: private:
ewol::Widget* m_subWidget; ewol::Widget* m_subWidget;
etk::Vector<ewol::Widget*> m_popUpWidgetList; std::vector<ewol::Widget*> m_popUpWidgetList;
public: public:
void setSubWidget(ewol::Widget* _widget); void setSubWidget(ewol::Widget* _widget);
void popUpWidgetPush(ewol::Widget* _widget); void popUpWidgetPush(ewol::Widget* _widget);

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

@ -11,8 +11,8 @@
#include <ewol/widget/List.h> #include <ewol/widget/List.h>
#include <ewol/widget/Spacer.h> #include <ewol/widget/Spacer.h>
#include <ewol/widget/WidgetManager.h> #include <ewol/widget/WidgetManager.h>
//#include <etk/Vector.h> //#include <vector>
#include <etk/Vector.h> #include <vector>
extern "C" { extern "C" {
// file browsing ... // file browsing ...

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

@ -14,8 +14,8 @@
#include <ewol/widget/Image.h> #include <ewol/widget/Image.h>
#include <ewol/widget/Composer.h> #include <ewol/widget/Composer.h>
#include <ewol/widget/WidgetManager.h> #include <ewol/widget/WidgetManager.h>
//#include <etk/Vector.h> //#include <vector>
#include <etk/Vector.h> #include <vector>
#include <etk/tool.h> #include <etk/tool.h>
#include <etk/os/FSNode.h> #include <etk/os/FSNode.h>

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

@ -13,7 +13,7 @@
#include <ewol/widget/Image.h> #include <ewol/widget/Image.h>
#include <ewol/widget/WidgetManager.h> #include <ewol/widget/WidgetManager.h>
#include <ewol/widget/Composer.h> #include <ewol/widget/Composer.h>
#include <etk/Vector.h> #include <vector>
#include <ewol/ewol.h> #include <ewol/ewol.h>

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

@ -60,7 +60,7 @@ void widget::ParameterList::addOObject(ewol::Compositing* _newObject, int32_t _p
return; return;
} }
if (_pos < 0 || _pos >= m_listOObject.size() ) { if (_pos < 0 || _pos >= m_listOObject.size() ) {
m_listOObject.pushBack(_newObject); m_listOObject.push_back(_newObject);
} else { } else {
m_listOObject.insert(_pos, _newObject); m_listOObject.insert(_pos, _newObject);
} }
@ -116,7 +116,7 @@ void widget::ParameterList::onRegenerateDisplay(void) {
(minHeight + 2*m_paddingSizeY) * nbRaw ); (minHeight + 2*m_paddingSizeY) * nbRaw );
etk::Vector<int32_t> listSizeColomn; std::vector<int32_t> listSizeColomn;
// set background color : // set background color :
ewol::Drawing * tmpDraw = new ewol::Drawing(); ewol::Drawing * tmpDraw = new ewol::Drawing();
@ -210,7 +210,7 @@ void widget::ParameterList::onLostFocus(void) {
void widget::ParameterList::menuAdd(etk::UString& _label, int32_t _refId, etk::UString& _image) { void widget::ParameterList::menuAdd(etk::UString& _label, int32_t _refId, etk::UString& _image) {
widget::elementPL* tmpEmement = new widget::elementPL(_label, _refId, _image, false); widget::elementPL* tmpEmement = new widget::elementPL(_label, _refId, _image, false);
if (NULL != tmpEmement) { if (NULL != tmpEmement) {
m_list.pushBack(tmpEmement); m_list.push_back(tmpEmement);
if (m_idSelected == -1 && _label != "---" && _refId>0) { if (m_idSelected == -1 && _label != "---" && _refId>0) {
m_idSelected = m_list.size()-1; m_idSelected = m_list.size()-1;
} }
@ -222,7 +222,7 @@ void widget::ParameterList::menuAddGroup(etk::UString& _label) {
etk::UString image = ""; etk::UString image = "";
widget::elementPL* tmpEmement = new widget::elementPL(_label, -1, image, true); widget::elementPL* tmpEmement = new widget::elementPL(_label, -1, image, true);
if (NULL != tmpEmement) { if (NULL != tmpEmement) {
m_list.pushBack(tmpEmement); m_list.push_back(tmpEmement);
markToRedraw(); markToRedraw();
} }
} }

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

@ -39,14 +39,14 @@ namespace widget {
class ParameterList :public widget::WidgetScrooled { class ParameterList :public widget::WidgetScrooled {
private: private:
int32_t m_idSelected; int32_t m_idSelected;
etk::Vector<widget::elementPL *> m_list; std::vector<widget::elementPL *> m_list;
public: public:
ParameterList(void); ParameterList(void);
virtual ~ParameterList(void); virtual ~ParameterList(void);
void setLabel(etk::UString _newLabel); void setLabel(etk::UString _newLabel);
// drawing capabilities .... // drawing capabilities ....
private: private:
etk::Vector<ewol::Compositing*> m_listOObject; //!< generic element to display... std::vector<ewol::Compositing*> m_listOObject; //!< generic element to display...
public: public:
void addOObject(ewol::Compositing* _newObject, int32_t _pos=-1); void addOObject(ewol::Compositing* _newObject, int32_t _pos=-1);
void clearOObjectList(void); void clearOObjectList(void);

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

@ -11,7 +11,7 @@
#include <ewol/widget/Spacer.h> #include <ewol/widget/Spacer.h>
#include <ewol/widget/Label.h> #include <ewol/widget/Label.h>
#include <ewol/widget/WidgetManager.h> #include <ewol/widget/WidgetManager.h>
#include <etk/Vector.h> #include <vector>
#undef __class__ #undef __class__
#define __class__ "ewol::StdPopUp" #define __class__ "ewol::StdPopUp"