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;
ewol::TextureFile* m_texture0;
public:
etk::Vector<uint32_t> m_listIndexFaces;
std::vector<uint32_t> m_listIndexFaces;
public:
Material(void);
~Material(void);

6
sources/ewol/commandLine.cpp
View File

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

2
sources/ewol/commandLine.h
View File

@ -15,7 +15,7 @@
namespace ewol {
class CommandLine {
private:
etk::Vector<etk::UString> m_listArgs; //!< list of all argument parsed
std::vector<etk::UString> m_listArgs; //!< list of all argument parsed
public:
/**
* @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);
point.setX(m_position.x());
point.setY(m_position.y());
m_coord.pushBack(point);
m_coordTex.pushBack(tex);
m_coordColor.pushBack(m_color);
m_coord.push_back(point);
m_coordTex.push_back(tex);
m_coordColor.push_back(m_color);
tex.setValue(1,1);
point.setX(m_position.x() + _size.x());
point.setY(m_position.y());
m_coord.pushBack(point);
m_coordTex.pushBack(tex);
m_coordColor.pushBack(m_color);
m_coord.push_back(point);
m_coordTex.push_back(tex);
m_coordColor.push_back(m_color);
tex.setValue(1,0);
point.setX(m_position.x() + _size.x());
point.setY(m_position.y() + _size.y());
m_coord.pushBack(point);
m_coordTex.pushBack(tex);
m_coordColor.pushBack(m_color);
m_coord.push_back(point);
m_coordTex.push_back(tex);
m_coordColor.push_back(m_color);
m_coord.pushBack(point);
m_coordTex.pushBack(tex);
m_coordColor.pushBack(m_color);
m_coord.push_back(point);
m_coordTex.push_back(tex);
m_coordColor.push_back(m_color);
tex.setValue(0,0);
point.setX(m_position.x());
point.setY(m_position.y() + _size.y());
m_coord.pushBack(point);
m_coordTex.pushBack(tex);
m_coordColor.pushBack(m_color);
m_coord.push_back(point);
m_coordTex.push_back(tex);
m_coordColor.push_back(m_color);
tex.setValue(0,1);
point.setX(m_position.x());
point.setY(m_position.y());
m_coord.pushBack(point);
m_coordTex.pushBack(tex);
m_coordColor.pushBack(m_color);
m_coord.push_back(point);
m_coordTex.push_back(tex);
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)
private:
ewol::Texture* m_resource; //!< texture resources
etk::Vector<vec3 > m_coord; //!< internal coord of the object
etk::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<vec3 > m_coord; //!< internal coord of the object
std::vector<vec2 > m_coordTex; //!< internal texture coordinate for every point
std::vector<etk::Color<float> > m_coordColor; //!< internal color of the different point
private:
/**
* @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
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) {
return;
}
// TODO : Regenerate a linear poligone generation
for (int32_t iii=1; iii<input.size()-1; iii++) {
output.pushBack(input[0]);
output.pushBack(input[iii]);
output.pushBack(input[iii+1]);
output.push_back(input[0]);
output.push_back(input[iii]);
output.push_back(input[iii+1]);
}
//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
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);
destPoint.y = aaa*sx + bbb;
destPoint.x = sx;
output.pushBack(destPoint);
output.push_back(destPoint);
} else {
//EWOL_DEBUG("element OUT == > OUT ");
}
@ -59,7 +59,7 @@ static void SutherlandHodgman(etk::Vector<vec2 > & input, etk::Vector<vec2 > & o
} else {
if(true == inside) {
//EWOL_DEBUG("element IN == > IN ");
output.pushBack(input[iii]);
output.push_back(input[iii]);
} else {
//EWOL_DEBUG("element OUT == > IN ");
//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);
destPoint.y = aaa*sx + bbb;
destPoint.x = sx;
output.pushBack(destPoint);
output.pushBack(input[iii]);
output.push_back(destPoint);
output.push_back(input[iii]);
}
inside = true;
}
@ -96,7 +96,7 @@ static void SutherlandHodgman(etk::Vector<vec2 > & input, etk::Vector<vec2 > & o
float bbb = lastElement.x - (aaa*lastElement.y);
destPoint.y = sy;
destPoint.x = sy*aaa + bbb;
output.pushBack(destPoint);
output.push_back(destPoint);
} else {
//EWOL_DEBUG("element OUT == > OUT ");
}
@ -104,7 +104,7 @@ static void SutherlandHodgman(etk::Vector<vec2 > & input, etk::Vector<vec2 > & o
} else {
if(true == inside) {
//EWOL_DEBUG("element IN == > IN ");
output.pushBack(input[iii]);
output.push_back(input[iii]);
} else {
//EWOL_DEBUG("element OUT == > IN ");
//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);
destPoint.y = sy;
destPoint.x = sy*aaa + bbb;
output.pushBack(destPoint);
output.pushBack(input[iii]);
output.push_back(destPoint);
output.push_back(input[iii]);
}
inside = true;
}
@ -141,7 +141,7 @@ static void SutherlandHodgman(etk::Vector<vec2 > & input, etk::Vector<vec2 > & o
float bbb = lastElement.y - (aaa*lastElement.x);
destPoint.y = aaa*ex + bbb;
destPoint.x = ex;
output.pushBack(destPoint);
output.push_back(destPoint);
} else {
//EWOL_DEBUG("element OUT == > OUT ");
}
@ -149,7 +149,7 @@ static void SutherlandHodgman(etk::Vector<vec2 > & input, etk::Vector<vec2 > & o
} else {
if(true == inside) {
//EWOL_DEBUG("element IN == > IN ");
output.pushBack(input[iii]);
output.push_back(input[iii]);
} else {
//EWOL_DEBUG("element OUT == > IN ");
//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);
destPoint.y = aaa*ex + bbb;
destPoint.x = ex;
output.pushBack(destPoint);
output.pushBack(input[iii]);
output.push_back(destPoint);
output.push_back(input[iii]);
}
inside = true;
}
@ -185,7 +185,7 @@ static void SutherlandHodgman(etk::Vector<vec2 > & input, etk::Vector<vec2 > & o
float bbb = lastElement.x - (aaa*lastElement.y);
destPoint.y = ey;
destPoint.x = ey*aaa + bbb;
output.pushBack(destPoint);
output.push_back(destPoint);
} else {
//EWOL_DEBUG("element OUT == > OUT ");
}
@ -193,7 +193,7 @@ static void SutherlandHodgman(etk::Vector<vec2 > & input, etk::Vector<vec2 > & o
} else {
if(true == inside) {
//EWOL_DEBUG("element IN == > IN ");
output.pushBack(input[iii]);
output.push_back(input[iii]);
} else {
//EWOL_DEBUG("element OUT == > IN ");
//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);
destPoint.y = ey;
destPoint.x = ey*aaa + bbb;
output.pushBack(destPoint);
output.pushBack(input[iii]);
output.push_back(destPoint);
output.push_back(input[iii]);
}
inside = true;
}
@ -244,12 +244,12 @@ ewol::Drawing::~Drawing(void) {
void ewol::Drawing::generateTriangle(void) {
m_triElement = 0;
m_coord.pushBack(m_triangle[0]);
m_coordColor.pushBack(m_tricolor[0]);
m_coord.pushBack(m_triangle[1]);
m_coordColor.pushBack(m_tricolor[1]);
m_coord.pushBack(m_triangle[2]);
m_coordColor.pushBack(m_tricolor[2]);
m_coord.push_back(m_triangle[0]);
m_coordColor.push_back(m_tricolor[0]);
m_coord.push_back(m_triangle[1]);
m_coordColor.push_back(m_tricolor[1]);
m_coord.push_back(m_triangle[2]);
m_coordColor.push_back(m_tricolor[2]);
}
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_GLColor; //!< openGL id on the element (color buffer)
private: // Background Color (display only when needed)
etk::Vector<vec3 > m_coord; //!< internal position for the text display
etk::Vector<etk::Color<float> > m_coordColor; //!< internal color of the background
std::vector<vec3 > m_coord; //!< internal position for the text display
std::vector<etk::Color<float> > m_coordColor; //!< internal color of the background
public:
/**
* @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;
vec2 tex(_sourcePosStart.x(),_sourcePosStop.y());
m_coord.pushBack(point);
m_coordTex.pushBack(tex);
m_coordColor.pushBack(m_color);
m_coord.push_back(point);
m_coordTex.push_back(tex);
m_coordColor.push_back(m_color);
tex.setValue(_sourcePosStop.x(),_sourcePosStop.y());
point.setX(m_position.x() + _size.x());
point.setY(m_position.y());
m_coord.pushBack(point);
m_coordTex.pushBack(tex);
m_coordColor.pushBack(m_color);
m_coord.push_back(point);
m_coordTex.push_back(tex);
m_coordColor.push_back(m_color);
tex.setValue(_sourcePosStop.x(),_sourcePosStart.y());
point.setX(m_position.x() + _size.x());
point.setY(m_position.y() + _size.y());
m_coord.pushBack(point);
m_coordTex.pushBack(tex);
m_coordColor.pushBack(m_color);
m_coord.push_back(point);
m_coordTex.push_back(tex);
m_coordColor.push_back(m_color);
m_coord.pushBack(point);
m_coordTex.pushBack(tex);
m_coordColor.pushBack(m_color);
m_coord.push_back(point);
m_coordTex.push_back(tex);
m_coordColor.push_back(m_color);
tex.setValue(_sourcePosStart.x(),_sourcePosStart.y());
point.setX(m_position.x());
point.setY(m_position.y() + _size.y());
m_coord.pushBack(point);
m_coordTex.pushBack(tex);
m_coordColor.pushBack(m_color);
m_coord.push_back(point);
m_coordTex.push_back(tex);
m_coordColor.push_back(m_color);
tex.setValue(_sourcePosStart.x(),_sourcePosStop.y());
point.setX(m_position.x());
point.setY(m_position.y());
m_coord.pushBack(point);
m_coordTex.pushBack(tex);
m_coordColor.pushBack(m_color);
m_coord.push_back(point);
m_coordTex.push_back(tex);
m_coordColor.push_back(m_color);
return;
}
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 = point.rotate(vec3(0,0,1), m_angle) + center;
m_coord.pushBack(point);
m_coordTex.pushBack(tex);
m_coordColor.pushBack(m_color);
m_coord.push_back(point);
m_coordTex.push_back(tex);
m_coordColor.push_back(m_color);
tex.setValue(_sourcePosStop.x(),_sourcePosStop.y());
point.setValue(limitedSize.x(), -limitedSize.y(), 0);
point = point.rotate(vec3(0,0,1), m_angle) + center;
m_coord.pushBack(point);
m_coordTex.pushBack(tex);
m_coordColor.pushBack(m_color);
m_coord.push_back(point);
m_coordTex.push_back(tex);
m_coordColor.push_back(m_color);
tex.setValue(_sourcePosStop.x(),_sourcePosStart.y());
point.setValue(limitedSize.x(), limitedSize.y(), 0);
point = point.rotate(vec3(0,0,1), m_angle) + center;
m_coord.pushBack(point);
m_coordTex.pushBack(tex);
m_coordColor.pushBack(m_color);
m_coord.push_back(point);
m_coordTex.push_back(tex);
m_coordColor.push_back(m_color);
m_coord.pushBack(point);
m_coordTex.pushBack(tex);
m_coordColor.pushBack(m_color);
m_coord.push_back(point);
m_coordTex.push_back(tex);
m_coordColor.push_back(m_color);
tex.setValue(_sourcePosStart.x(),_sourcePosStart.y());
point.setValue(-limitedSize.x(), limitedSize.y(), 0);
point = point.rotate(vec3(0,0,1), m_angle) + center;
m_coord.pushBack(point);
m_coordTex.pushBack(tex);
m_coordColor.pushBack(m_color);
m_coord.push_back(point);
m_coordTex.push_back(tex);
m_coordColor.push_back(m_color);
tex.setValue(_sourcePosStart.x(),_sourcePosStop.y());
point.setValue(-limitedSize.x(), -limitedSize.y(), 0);
point = point.rotate(vec3(0,0,1), m_angle) + center;
m_coord.pushBack(point);
m_coordTex.pushBack(tex);
m_coordColor.pushBack(m_color);
m_coord.push_back(point);
m_coordTex.push_back(tex);
m_coordColor.push_back(m_color);
}
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)
private:
ewol::TextureFile* m_resource; //!< texture resources
etk::Vector<vec3 > m_coord; //!< internal coord of the object
etk::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<vec3 > m_coord; //!< internal coord of the object
std::vector<vec2 > m_coordTex; //!< internal texture coordinate for every point
std::vector<etk::Color<float> > m_coordColor; //!< internal color of the different point
private:
/**
* @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) {
etk::Vector<TextDecoration> decorationEmpty;
std::vector<TextDecoration> decorationEmpty;
print(_text, decorationEmpty);
}
@ -498,7 +498,7 @@ void ewol::Text::printHTML(const etk::UString& _text) {
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) {
EWOL_ERROR("Font Id is not corectly defined");
return;
@ -816,17 +816,17 @@ void ewol::Text::print(const etk::UChar& _charcode) {
*
*/
// set texture coordonates :
m_coordTex.pushBack(texturePos[0]);
m_coordTex.pushBack(texturePos[1]);
m_coordTex.pushBack(texturePos[2]);
m_coordTex.push_back(texturePos[0]);
m_coordTex.push_back(texturePos[1]);
m_coordTex.push_back(texturePos[2]);
// set display positions :
m_coord.pushBack(bitmapDrawPos[0]);
m_coord.pushBack(bitmapDrawPos[1]);
m_coord.pushBack(bitmapDrawPos[2]);
m_coord.push_back(bitmapDrawPos[0]);
m_coord.push_back(bitmapDrawPos[1]);
m_coord.push_back(bitmapDrawPos[2]);
// set the color
m_coordColor.pushBack(m_color);
m_coordColor.pushBack(m_color);
m_coordColor.pushBack(m_color);
m_coordColor.push_back(m_color);
m_coordColor.push_back(m_color);
m_coordColor.push_back(m_color);
/* Step 2 :
*
* **
@ -835,17 +835,17 @@ void ewol::Text::print(const etk::UChar& _charcode) {
* ********
*/
// set texture coordonates :
m_coordTex.pushBack(texturePos[0]);
m_coordTex.pushBack(texturePos[2]);
m_coordTex.pushBack(texturePos[3]);
m_coordTex.push_back(texturePos[0]);
m_coordTex.push_back(texturePos[2]);
m_coordTex.push_back(texturePos[3]);
// set display positions :
m_coord.pushBack(bitmapDrawPos[0]);
m_coord.pushBack(bitmapDrawPos[2]);
m_coord.pushBack(bitmapDrawPos[3]);
m_coord.push_back(bitmapDrawPos[0]);
m_coord.push_back(bitmapDrawPos[2]);
m_coord.push_back(bitmapDrawPos[3]);
// set the color
m_coordColor.pushBack(m_color);
m_coordColor.pushBack(m_color);
m_coordColor.pushBack(m_color);
m_coordColor.push_back(m_color);
m_coordColor.push_back(m_color);
m_coordColor.push_back(m_color);
}
}
}
@ -1044,14 +1044,14 @@ void ewol::Text::htmlAddData(const etk::UString& _data) {
m_htmlCurrrentLine+=" ";
if(m_htmlDecoration.size()>0) {
TextDecoration tmp = m_htmlDecoration[m_htmlDecoration.size()-1];
m_htmlDecoration.pushBack(tmp);
m_htmlDecoration.push_back(tmp);
} else {
m_htmlDecoration.pushBack(m_htmlDecoTmp);
m_htmlDecoration.push_back(m_htmlDecoTmp);
}
}
m_htmlCurrrentLine += _data;
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:
ewol::TexturedFont* m_font; //!< Font resources
private: // Text
etk::Vector<vec2 > m_coord; //!< internal coord of the object
etk::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<vec2 > m_coord; //!< internal coord of the object
std::vector<vec2 > m_coordTex; //!< internal texture coordinate for every point
std::vector<etk::Color<float> > m_coordColor; //!< internal color of the different point
private:
/**
* @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] _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)
* @param[in] _charcode Char that might be dispalyed
@ -379,7 +379,7 @@ namespace ewol {
private:
// this section is reserved for HTML parsing and 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
/**
* @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) {
*tmp = '\0';
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;
tmp= strchr(base, '|');
}
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++) {
EWOL_VERBOSE(" parsed " << m_points[iii]);

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

@ -33,9 +33,9 @@ namespace ewol {
return m_scale;
};
private:
etk::Vector<vec3> m_points;
std::vector<vec3> m_points;
public:
const etk::Vector<vec3>& getPointList(void) const {
const std::vector<vec3>& getPointList(void) const {
return m_points;
};
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"
{
@ -458,7 +458,7 @@ extern "C"
return -1;
}
// for future case : all time this ...
s_listInstance.pushBack(tmpContext);
s_listInstance.push_back(tmpContext);
int32_t newID = s_listInstance.size()-1;
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");
return;
}
m_messageList.pushBack(MessageList(_message, _object));
m_messageList.push_back(MessageList(_message, _object));
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/UString.h>
#include <etk/Vector.h>
#include <vector>
#include <exml/exml.h>
#include <ewol/renderer/EObject.h>
@ -28,7 +28,7 @@ namespace ewol {
const char* m_message;
ewol::EObject* m_object;
};
etk::Vector<MessageList> m_messageList; //!< List of all message ...
std::vector<MessageList> m_messageList; //!< List of all message ...
public:
EMultiCast();
~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) {
if (NULL != _generateEventId) {
m_availlableEventId.pushBack(_generateEventId);
m_availlableEventId.push_back(_generateEventId);
}
}
@ -141,7 +141,7 @@ void ewol::EObject::registerOnEvent(ewol::EObject * _destinationObject,
} else {
tmpEvent->destEventId = _eventId;
}
m_externEvent.pushBack(tmpEvent);
m_externEvent.push_back(tmpEvent);
}
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/UString.h>
#include <etk/Vector.h>
#include <vector>
#include <exml/exml.h>
namespace ewol {
// 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)
private:
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
etk::Vector<const char*> m_availlableEventId; //!< List of all event availlable for this widget
std::vector<EventExtGen*> m_externEvent; //!< Generic list of event generation for output link
std::vector<const char*> m_availlableEventId; //!< List of all event availlable for this widget
public:
/**
* @brief Constructor
@ -137,7 +137,7 @@ namespace ewol {
*/
virtual void onReceiveMessage(const ewol::EMessage& _msg) { };
private:
etk::Vector<ewol::EConfigElement> m_listConfig;
std::vector<ewol::EConfigElement> m_listConfig;
protected:
/**
* @brief the EObject add a configuration capabilities
@ -166,7 +166,7 @@ namespace ewol {
* @brief get all the configuration list
* @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)
* @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) {
if (NULL != _object) {
m_eObjectList.pushBack(_object);
m_eObjectList.push_back(_object);
} else {
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);
EWOL_DEBUG("Auto-Remove EObject : [" << _object->getId() << "] type=\"" << _object->getObjectType() << "\"");
informOneObjectIsRemoved(_object);
m_eObjectAutoRemoveList.pushBack(_object);
m_eObjectAutoRemoveList.push_back(_object);
ewol::getContext().forceRedrawAll();
return;
}

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

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

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

@ -274,9 +274,9 @@ class RequestPlay {
}
};
#include <etk/Vector.h>
etk::Vector<EffectsLoaded*> ListEffects;
etk::Vector<RequestPlay*> ListEffectsPlaying;
#include <vector>
std::vector<EffectsLoaded*> ListEffects;
std::vector<RequestPlay*> ListEffectsPlaying;
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 << "\"");
return -1;
}
ListEffects.pushBack(tmpEffect);
ListEffects.push_back(tmpEffect);
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);
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)
*/
#include <etk/Vector.h>
#include <vector>
#include <ewol/debug.h>
#include <ewol/renderer/openGL.h>
@ -20,7 +20,7 @@ static etk::Mutex& mutexOpenGl(void) {
return s_drawMutex;
}
etk::Vector<mat4> l_matrixList;
std::vector<mat4> l_matrixList;
mat4 l_matrixCamera;
static uint32_t l_flagsCurrent = 0;
static uint32_t l_flagsMustBeSet = 0;
@ -32,7 +32,7 @@ void ewol::openGL::lock(void) {
mutexOpenGl().lock();
l_matrixList.clear();
mat4 tmpMat;
l_matrixList.pushBack(tmpMat);
l_matrixList.push_back(tmpMat);
l_matrixCamera.identity();
l_flagsCurrent = 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());
}
l_matrixList.clear();
l_matrixList.pushBack(_newOne);
l_matrixList.push_back(_newOne);
}
void ewol::openGL::setMatrix(const mat4& _newOne) {
if (l_matrixList.size() == 0) {
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;
}
l_matrixList[l_matrixList.size()-1] = _newOne;
@ -65,11 +65,11 @@ void ewol::openGL::push(void) {
if (l_matrixList.size() == 0) {
EWOL_ERROR("set matrix list is not corect size in the stack : " << l_matrixList.size());
mat4 tmp;
l_matrixList.pushBack(tmp);
l_matrixList.push_back(tmp);
return;
}
mat4 tmp = l_matrixList[l_matrixList.size()-1];
l_matrixList.pushBack(tmp);
l_matrixList.push_back(tmp);
}
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());
l_matrixList.clear();
mat4 tmp;
l_matrixList.pushBack(tmp);
l_matrixList.push_back(tmp);
l_matrixCamera.identity();
return;
}
@ -89,7 +89,7 @@ const mat4& ewol::openGL::getMatrix(void) {
if (l_matrixList.size() == 0) {
EWOL_ERROR("set matrix list is not corect size in the stack : " << l_matrixList.size());
mat4 tmp;
l_matrixList.pushBack(tmp);
l_matrixList.push_back(tmp);
}
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) {
updateAllFlags();
//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) {
updateAllFlags();
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) {
updateAllFlags();
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__
#include <etk/types.h>
#include <etk/Vector.h>
#include <vector>
#include <etk/math/Matrix4.h>
#ifdef __cplusplus
@ -170,9 +170,9 @@ namespace ewol {
* @brief draw a specific array == > this enable mode difference ...
*/
void drawArrays(uint32_t _mode, int32_t _first, int32_t _count);
void drawElements (uint32_t _mode, const etk::Vector<uint32_t>& _indices);
void drawElements16(uint32_t _mode, const etk::Vector<uint16_t>& _indices);
void drawElements8 (uint32_t _mode, const etk::Vector<uint8_t>& _indices);
void drawElements (uint32_t _mode, const std::vector<uint32_t>& _indices);
void drawElements16(uint32_t _mode, const std::vector<uint16_t>& _indices);
void drawElements8 (uint32_t _mode, const std::vector<uint8_t>& _indices);
/**
* @brief Use openGL program
* @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,
bool _updateDepthBuffer,
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,
mat4& _transformationMatrix,
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,
mat4& _transformationMatrix,
bool _updateDepthBuffer,

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

@ -27,16 +27,16 @@ namespace ewol {
virtual ~Colored3DObject(void);
public:
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,
bool _updateDepthBuffer=true,
bool _depthtest=true);
virtual void draw(etk::Vector<vec3>& _vertices,
virtual void draw(std::vector<vec3>& _vertices,
const etk::Color<float>& _color,
mat4& _transformationMatrix,
bool _updateDepthBuffer=true,
bool _depthtest=true);
virtual void drawLine(etk::Vector<vec3>& _vertices,
virtual void drawLine(std::vector<vec3>& _vertices,
const etk::Color<float>& _color,
mat4& _transformationMatrix,
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");
} else {
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) {
EWOL_DEBUG("error while allocation");
} else {
m_list.pushBack(tmpElement);
m_list.push_back(tmpElement);
}
return m_list.size()-1;
}

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

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

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

@ -7,7 +7,7 @@
*/
#include <etk/unicode.h>
#include <etk/Vector.h>
#include <vector>
#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) {
return;
}

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

@ -44,7 +44,7 @@ namespace ewol {
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:
/**
* @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);
cameraNormal.normalized();
// remove face that is notin the view ...
etk::Vector<uint32_t> tmpIndexResult;
etk::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> tmpIndexResult;
std::vector<ewol::Face>& tmppFaces = m_listFaces.getValue(kkk).m_faces;
//std::vector<uint32_t>& tmppIndex = m_listFaces.getValue(kkk).m_index;
if (normalModeFace == m_normalMode) {
for(int32_t iii=0; iii<tmppFaces.size() ; ++iii) {
if(btDot(mattttt * m_listFacesNormal[tmppFaces[iii].m_normal[0]], cameraNormal) >= 0.0f) {
tmpIndexResult.pushBack(iii*3);
tmpIndexResult.pushBack(iii*3+1);
tmpIndexResult.pushBack(iii*3+2);
tmpIndexResult.push_back(iii*3);
tmpIndexResult.push_back(iii*3+1);
tmpIndexResult.push_back(iii*3+2);
}
}
} else {
@ -149,9 +149,9 @@ void ewol::Mesh::draw(mat4& _positionMatrix,
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[2]], cameraNormal) >= -0.2f) ) {
tmpIndexResult.pushBack(iii*3);
tmpIndexResult.pushBack(iii*3+1);
tmpIndexResult.pushBack(iii*3+2);
tmpIndexResult.push_back(iii*3);
tmpIndexResult.push_back(iii*3+1);
tmpIndexResult.push_back(iii*3+2);
}
}
}
@ -180,12 +180,12 @@ void ewol::Mesh::draw(mat4& _positionMatrix,
void ewol::Mesh::calculateNormaleFace(void) {
m_listFacesNormal.clear();
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 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]],
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;
}
@ -195,7 +195,7 @@ void ewol::Mesh::calculateNormaleEdge(void) {
m_listVertexNormal.clear();
if (m_normalMode != ewol::Mesh::normalModeVertex) {
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);
// 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++) {
@ -207,9 +207,9 @@ void ewol::Mesh::calculateNormaleEdge(void) {
}
}
if (normal == vec3(0,0,0)) {
m_listVertexNormal.pushBack(vec3(1,1,1));
m_listVertexNormal.push_back(vec3(1,1,1));
} else {
m_listVertexNormal.pushBack(normal.normalized());
m_listVertexNormal.push_back(normal.normalized());
}
}
m_normalMode = ewol::Mesh::normalModeVertex;
@ -271,7 +271,7 @@ void ewol::Mesh::generateVBO(void) {
}
}
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
@ -310,14 +310,14 @@ void ewol::Mesh::createViewBox(const etk::UString& _materialName,float _size) {
o---------------------o
0 3
*/
m_listVertex.pushBack(vec3( _size, -_size, -_size)); // 0
m_listVertex.pushBack(vec3( _size, -_size, _size)); // 1
m_listVertex.pushBack(vec3(-_size, -_size, _size)); // 2
m_listVertex.pushBack(vec3(-_size, -_size, -_size)); // 3
m_listVertex.pushBack(vec3( _size, _size, -_size)); // 4
m_listVertex.pushBack(vec3( _size, _size, _size)); // 5
m_listVertex.pushBack(vec3(-_size, _size, _size)); // 6
m_listVertex.pushBack(vec3(-_size, _size, -_size)); // 7
m_listVertex.push_back(vec3( _size, -_size, -_size)); // 0
m_listVertex.push_back(vec3( _size, -_size, _size)); // 1
m_listVertex.push_back(vec3(-_size, -_size, _size)); // 2
m_listVertex.push_back(vec3(-_size, -_size, -_size)); // 3
m_listVertex.push_back(vec3( _size, _size, -_size)); // 4
m_listVertex.push_back(vec3( _size, _size, _size)); // 5
m_listVertex.push_back(vec3(-_size, _size, _size)); // 6
m_listVertex.push_back(vec3(-_size, _size, -_size)); // 7
/*
o----------o----------o----------o
|8 |9 |10 |11
@ -340,18 +340,18 @@ void ewol::Mesh::createViewBox(const etk::UString& _materialName,float _size) {
o----------o----------o----------o
0 1 2 3
*/
m_listUV.pushBack(vec2(0.0 , 0.0 )); // 0
m_listUV.pushBack(vec2(1.0/3.0, 0.0 )); // 1
m_listUV.pushBack(vec2(2.0/3.0, 0.0 )); // 2
m_listUV.pushBack(vec2(1.0 , 0.0 )); // 3
m_listUV.pushBack(vec2(0.0 , 0.5 )); // 4
m_listUV.pushBack(vec2(1.0/3.0, 0.5 )); // 5
m_listUV.pushBack(vec2(2.0/3.0, 0.5 )); // 6
m_listUV.pushBack(vec2(1.0 , 0.5 )); // 7
m_listUV.pushBack(vec2(0.0 , 1.0 )); // 8
m_listUV.pushBack(vec2(1.0/3.0, 1.0 )); // 9
m_listUV.pushBack(vec2(2.0/3.0, 1.0 )); // 10
m_listUV.pushBack(vec2(1.0 , 1.0 )); // 11
m_listUV.push_back(vec2(0.0 , 0.0 )); // 0
m_listUV.push_back(vec2(1.0/3.0, 0.0 )); // 1
m_listUV.push_back(vec2(2.0/3.0, 0.0 )); // 2
m_listUV.push_back(vec2(1.0 , 0.0 )); // 3
m_listUV.push_back(vec2(0.0 , 0.5 )); // 4
m_listUV.push_back(vec2(1.0/3.0, 0.5 )); // 5
m_listUV.push_back(vec2(2.0/3.0, 0.5 )); // 6
m_listUV.push_back(vec2(1.0 , 0.5 )); // 7
m_listUV.push_back(vec2(0.0 , 1.0 )); // 8
m_listUV.push_back(vec2(1.0/3.0, 1.0 )); // 9
m_listUV.push_back(vec2(2.0/3.0, 1.0 )); // 10
m_listUV.push_back(vec2(1.0 , 1.0 )); // 11
if (m_listFaces.exist(_materialName) == false) {
FaceIndexing empty;
@ -359,18 +359,18 @@ void ewol::Mesh::createViewBox(const etk::UString& _materialName,float _size) {
}
{
FaceIndexing& tmpElement = m_listFaces[_materialName];
tmpElement.m_faces.pushBack(Face(0,1, 1,5, 2,6)); // 4
tmpElement.m_faces.pushBack(Face(0,1, 2,6, 3,2)); // 4
tmpElement.m_faces.pushBack(Face(4,4, 0,0, 3,1)); // 3
tmpElement.m_faces.pushBack(Face(4,4, 3,1, 7,5)); // 3
tmpElement.m_faces.pushBack(Face(2,6, 6,10, 7,11)); // 2
tmpElement.m_faces.pushBack(Face(2,6, 7,11, 3,7)); // 2
tmpElement.m_faces.pushBack(Face(4,2, 7,3, 6,7)); // 5
tmpElement.m_faces.pushBack(Face(4,2, 6,7, 5,6)); // 5
tmpElement.m_faces.pushBack(Face(1,5, 5,9, 6,10)); // 1
tmpElement.m_faces.pushBack(Face(1,5, 6,10, 2,6)); // 1
tmpElement.m_faces.pushBack(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,1, 1,5, 2,6)); // 4
tmpElement.m_faces.push_back(Face(0,1, 2,6, 3,2)); // 4
tmpElement.m_faces.push_back(Face(4,4, 0,0, 3,1)); // 3
tmpElement.m_faces.push_back(Face(4,4, 3,1, 7,5)); // 3
tmpElement.m_faces.push_back(Face(2,6, 6,10, 7,11)); // 2
tmpElement.m_faces.push_back(Face(2,6, 7,11, 3,7)); // 2
tmpElement.m_faces.push_back(Face(4,2, 7,3, 6,7)); // 5
tmpElement.m_faces.push_back(Face(4,2, 6,7, 5,6)); // 5
tmpElement.m_faces.push_back(Face(1,5, 5,9, 6,10)); // 1
tmpElement.m_faces.push_back(Face(1,5, 6,10, 2,6)); // 1
tmpElement.m_faces.push_back(Face(0,4, 4,8, 5,9)); // 0
tmpElement.m_faces.push_back(Face(0,4, 5,9, 1,5)); // 0
}
calculateNormaleFace();
}
@ -405,12 +405,12 @@ bool ewol::Mesh::loadOBJ(const etk::UString& _fileName) {
// Texture position : vt 0.748573 0.750412
vec2 vertex(0,0);
sscanf(&inputDataLine[3], "%f %f", &vertex.m_floats[0], &vertex.m_floats[1]);
m_listUV.pushBack(vertex);
m_listUV.push_back(vertex);
} else {
// Vertice position : v 1.000000 -1.000000 -1.000000
vec3 vertex(0,0,0);
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') {
// 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) {
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[2]-1, uvIndex[2]-1,
vertexIndex[3]-1, uvIndex[3]-1));
} 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[2]-1, uvIndex[2]-1));
}
@ -736,7 +736,7 @@ bool ewol::Mesh::loadEMF(const etk::UString& _fileName) {
break;
}
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;
if( inputDataLine[len] == '\n'
|| inputDataLine[len] == '\r') {
@ -753,7 +753,7 @@ bool ewol::Mesh::loadEMF(const etk::UString& _fileName) {
break;
}
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;
if( inputDataLine[len] == '\n'
|| inputDataLine[len] == '\r') {
@ -772,7 +772,7 @@ bool ewol::Mesh::loadEMF(const etk::UString& _fileName) {
break;
}
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;
if( inputDataLine[len] == '\n'
|| inputDataLine[len] == '\r') {
@ -791,7 +791,7 @@ bool ewol::Mesh::loadEMF(const etk::UString& _fileName) {
break;
}
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;
if( inputDataLine[len] == '\n'
|| inputDataLine[len] == '\r') {
@ -840,7 +840,7 @@ bool ewol::Mesh::loadEMF(const etk::UString& _fileName) {
&vertexIndex[0], &uvIndex[0], &normalIndex[0],
&vertexIndex[1], &uvIndex[1], &normalIndex[1],
&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[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 ...");
continue;
}
m_physics.pushBack(physics);
m_physics.push_back(physics);
EWOL_VERBOSE(" " << m_physics.size() << " " << inputDataLine);
currentMode = EMFModuleMeshPhysicsNamed;
} else if (currentMode == EMFModuleMeshPhysicsNamed) {

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

@ -67,8 +67,8 @@ namespace ewol {
};
class FaceIndexing {
public:
etk::Vector<Face> m_faces;
etk::Vector<uint32_t> m_index;
std::vector<Face> m_faces;
std::vector<uint32_t> m_index;
};
class Mesh : public ewol::Resource {
public:
@ -92,13 +92,13 @@ namespace ewol {
MaterialGlId m_GLMaterial;
ewol::Light m_light;
protected:
etk::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)
etk::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_listVertex; //!< List of all vertex in the element
std::vector<vec2> m_listUV; //!< List of all UV point in the mesh (for the specify texture)
std::vector<vec3> m_listFacesNormal; //!< 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<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:
ewol::VirtualBufferObject* m_verticesVBO;
protected:
@ -129,7 +129,7 @@ namespace ewol {
* @return get the chcking stus of normal or not
*/
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:
void* m_pointerShape; //!< all mesh have a basic shape (bullet or other) the void pointer mermit to not depent on the bullet lib
public:

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

@ -41,7 +41,7 @@ ewol::Program::Program(const etk::UString& _filename) :
return;
} else {
EWOL_DEBUG("Add shader on program : "<< tmpFilename << "vert");
m_shaderList.pushBack(tmpShader);
m_shaderList.push_back(tmpShader);
}
tmpShader = ewol::Shader::keep(tmpFilename+"frag");
if (NULL == tmpShader) {
@ -49,7 +49,7 @@ ewol::Program::Program(const etk::UString& _filename) :
return;
} else {
EWOL_DEBUG("Add shader on program : "<< tmpFilename << "frag");
m_shaderList.pushBack(tmpShader);
m_shaderList.push_back(tmpShader);
}
} else {
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);
} else {
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);
tmp.m_isLinked = false;
}
m_elementList.pushBack(tmp);
m_elementList.push_back(tmp);
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);
tmp.m_isLinked = false;
}
m_elementList.pushBack(tmp);
m_elementList.push_back(tmp);
return m_elementList.size()-1;
}

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

@ -47,8 +47,8 @@ namespace ewol {
private :
bool m_exist; //!< the file existed
GLuint m_program; //!< openGL id of the current program
etk::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::Shader*> m_shaderList; //!< List of all the shader loaded
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_hasTexture1; //!< A texture has been set to the current shader
protected:

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

@ -98,7 +98,7 @@ void ewol::ResourceManager::update(ewol::Resource* _object) {
}
}
// 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
@ -173,7 +173,7 @@ void ewol::ResourceManager::localAdd(ewol::Resource* _object) {
}
}
// 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) {

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

@ -25,8 +25,8 @@
namespace ewol {
class ResourceManager {
private:
etk::Vector<ewol::Resource*> m_resourceList;
etk::Vector<ewol::Resource*> m_resourceListToUpdate;
std::vector<ewol::Resource*> m_resourceList;
std::vector<ewol::Resource*> m_resourceListToUpdate;
bool m_contextHasBeenRemoved;
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("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++) {
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));
m_size = tmpSize;
etk::Vector<etk::UString> folderList;
std::vector<etk::UString> folderList;
if (true == ewol::getContext().getFontDefault().getUseExternal()) {
#if defined(__TARGET_OS__Android)
folderList.pushBack("/system/fonts");
folderList.push_back("/system/fonts");
#elif defined(__TARGET_OS__Linux)
folderList.pushBack("/usr/share/fonts/truetype");
folderList.push_back("/usr/share/fonts/truetype");
#endif
}
folderList.pushBack(ewol::getContext().getFontDefault().getFolder());
folderList.push_back(ewol::getContext().getFontDefault().getFolder());
for (int32_t folderID=0; folderID<folderList.size() ; folderID++) {
etk::FSNode myFolder(folderList[folderID]);
// find the real Font name :
etk::Vector<etk::UString> output;
std::vector<etk::UString> 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_CRITICAL("parse string : " << split);
bool hasFindAFont = false;
@ -282,7 +282,7 @@ bool ewol::TexturedFont::addGlyph(const etk::UChar& _val) {
EWOL_WARNING("Did not find char : '" << _val << "'=" << _val.get());
tmpchar.setNotExist();
}
m_listElement[iii].pushBack(tmpchar);
m_listElement[iii].push_back(tmpchar);
//m_font[iii]->display();
// generate the kerning for all the characters :
if (tmpchar.exist() == true) {

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

@ -35,7 +35,7 @@ namespace ewol {
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
public:
etk::Vector<GlyphProperty> m_listElement[4];
std::vector<GlyphProperty> m_listElement[4];
private:
// for the texture generation :
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) {
m_vboUsed[_id] = true;
m_buffer[_id].pushBack(_data.x());
m_buffer[_id].pushBack(_data.y());
m_buffer[_id].pushBack(_data.z());
m_buffer[_id].push_back(_data.x());
m_buffer[_id].push_back(_data.y());
m_buffer[_id].push_back(_data.z());
}
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) {
m_vboUsed[_id] = true;
m_buffer[_id].pushBack(_data.x());
m_buffer[_id].pushBack(_data.y());
m_buffer[_id].push_back(_data.x());
m_buffer[_id].push_back(_data.y());
}
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
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 ...
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:
/**
* @brief Constructor of this VBO.
@ -54,7 +54,7 @@ namespace ewol {
* @param[in] id Id of the buffer requested
* @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 :
* @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 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) {};
};

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

@ -61,7 +61,7 @@ namespace ewol {
vec2 m_texturePosStart; //!< Texture normalised position (START)
vec2 m_texturePosSize; //!< Texture normalised position (SIZE)
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:
GlyphProperty(void) :
m_UVal(0),
@ -84,7 +84,7 @@ namespace ewol {
};
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)
{

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

@ -42,7 +42,7 @@ namespace ewol {
float m_value; //!< kerning real offset
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) :
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) {
_newWidget->setUpperWidget(this);
}
m_subWidget.pushBack(_newWidget);
m_subWidget.push_back(_newWidget);
markToRedraw();
requestUpdateSize();
// added at the last eelement :

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

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

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

@ -162,7 +162,7 @@ void widget::Gird::setColNumber(int32_t _colNumber) {
} else {
// just add the col size:
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 ...
m_subWidget.pushBack(prop);
m_subWidget.push_back(prop);
}
void widget::Gird::subWidgetRemove(ewol::Widget* _newWidget)

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

@ -10,7 +10,7 @@
#define __EWOL_WIDGET_GIRD_H__
#include <etk/types.h>
#include <etk/Vector.h>
#include <vector>
#include <ewol/debug.h>
#include <ewol/widget/Widget.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_uniformSizeRow;
etk::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<int32_t> m_sizeCol; //!< size of all colomn (if set (otherwise 0))
std::vector<GirdProperties> m_subWidget; //!< all sub widget are contained in this element
ewol::Widget* m_tmpWidget; //!< use when replace a widget ...
bool m_gavityButtom;
public:

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

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

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

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

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

@ -23,7 +23,7 @@ namespace widget {
*/
class ListFileSystem : public widget::List {
private:
etk::Vector<etk::FSNode *> m_list;
std::vector<etk::FSNode *> m_list;
etk::UString m_folder;
int32_t m_selectedLine;
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_generateEvent = _generateEvent;
tmpObject->m_message = _message;
m_listElement.pushBack(tmpObject);
m_listElement.push_back(tmpObject);
if (-1 == tmpObject->m_parentId) {
widget::Button *myButton = NULL;
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 subWidgetUnLink(ewol::Widget* _newWidget);
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 ...
widget::ContextMenu* m_widgetContextMenu;
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];
}
// add it on the List ...
m_localShortcut.pushBack(tmpElement);
m_localShortcut.push_back(tmpElement);
}
void ewol::Widget::shortCutClean(void) {

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

@ -18,7 +18,7 @@ namespace ewol {
class Windows;
};
#include <etk/types.h>
#include <etk/Vector.h>
#include <vector>
#include <etk/math/Vector2D.h>
#include <ewol/debug.h>
#include <ewol/clipBoard.h>
@ -585,7 +585,7 @@ namespace ewol {
// -- Shortcut : management of the shortcut
// ----------------------------------------------------------------------------------------------------------------
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:
/**
* @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/Scroll.h>
#include <ewol/widget/PopUp.h>
#include <etk/Vector.h>
#include <vector>
#undef __class__
#define __class__ "WidgetManager"
@ -165,7 +165,7 @@ void ewol::WidgetManager::periodicCallAdd(ewol::Widget* _pWidget) {
return;
}
}
m_listOfPeriodicWidget.pushBack(_pWidget);
m_listOfPeriodicWidget.push_back(_pWidget);
m_havePeriodic = true;
}

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

@ -11,7 +11,7 @@
#include <etk/types.h>
#include <ewol/debug.h>
#include <etk/Vector.h>
#include <vector>
#include <etk/Hash.h>
#include <ewol/widget/Widget.h>
@ -23,7 +23,7 @@ namespace ewol {
// For the focus Management
ewol::Widget* m_focusWidgetDefault;
ewol::Widget* m_focusWidgetCurrent;
etk::Vector<ewol::Widget*> m_listOfPeriodicWidget;
std::vector<ewol::Widget*> m_listOfPeriodicWidget;
bool m_havePeriodic;
bool m_haveRedraw;
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;
}
if (_pos < 0 || _pos >= m_listOObject.size() ) {
m_listOObject.pushBack(_newObject);
m_listOObject.push_back(_newObject);
} else {
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
};
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 clearOObjectList(void);
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) {
m_popUpWidgetList.pushBack(_widget);
m_popUpWidgetList.push_back(_widget);
// Regenerate the size calculation :
calculateSize(m_size);
// 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:
ewol::Widget* m_subWidget;
etk::Vector<ewol::Widget*> m_popUpWidgetList;
std::vector<ewol::Widget*> m_popUpWidgetList;
public:
void setSubWidget(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/Spacer.h>
#include <ewol/widget/WidgetManager.h>
//#include <etk/Vector.h>
#include <etk/Vector.h>
//#include <vector>
#include <vector>
extern "C" {
// file browsing ...

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

@ -14,8 +14,8 @@
#include <ewol/widget/Image.h>
#include <ewol/widget/Composer.h>
#include <ewol/widget/WidgetManager.h>
//#include <etk/Vector.h>
#include <etk/Vector.h>
//#include <vector>
#include <vector>
#include <etk/tool.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/WidgetManager.h>
#include <ewol/widget/Composer.h>
#include <etk/Vector.h>
#include <vector>
#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;
}
if (_pos < 0 || _pos >= m_listOObject.size() ) {
m_listOObject.pushBack(_newObject);
m_listOObject.push_back(_newObject);
} else {
m_listOObject.insert(_pos, _newObject);
}
@ -116,7 +116,7 @@ void widget::ParameterList::onRegenerateDisplay(void) {
(minHeight + 2*m_paddingSizeY) * nbRaw );
etk::Vector<int32_t> listSizeColomn;
std::vector<int32_t> listSizeColomn;
// set background color :
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) {
widget::elementPL* tmpEmement = new widget::elementPL(_label, _refId, _image, false);
if (NULL != tmpEmement) {
m_list.pushBack(tmpEmement);
m_list.push_back(tmpEmement);
if (m_idSelected == -1 && _label != "---" && _refId>0) {
m_idSelected = m_list.size()-1;
}
@ -222,7 +222,7 @@ void widget::ParameterList::menuAddGroup(etk::UString& _label) {
etk::UString image = "";
widget::elementPL* tmpEmement = new widget::elementPL(_label, -1, image, true);
if (NULL != tmpEmement) {
m_list.pushBack(tmpEmement);
m_list.push_back(tmpEmement);
markToRedraw();
}
}

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

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

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

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