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

basic widget button and sizer

Browse Source
This commit is contained in:
Edouard Dupin 2011-11-08 15:59:25 +01:00
parent 6d28038192
commit e3668827e6
18 changed files with 689 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
Sources/Main.cpp
View File

@ -25,6 +25,9 @@
#include <ewol.h> #include <ewol.h>
#include <ewolFont.h> #include <ewolFont.h>
#include <widget/ewolButton.h>
#include <widget/ewolSizerHori.h>
#include <widget/ewolSizerVert.h>
#include <unistd.h> #include <unistd.h>
#include <stdlib.h> #include <stdlib.h>
@ -38,7 +41,27 @@ class Plop :public ewol::Windows
public: public:
Plop(void) Plop(void)
{ {
// generate the display :
ewol::SizerHori * mySizer = new ewol::SizerHori();
SetSubWidget(mySizer);
ewol::Button * myButton = new ewol::Button("Mon Labell 1");
mySizer->SubWidgetAdd(myButton);
ewol::SizerVert * mySizerVert = new ewol::SizerVert();
mySizer->SubWidgetAdd(mySizerVert);
myButton = new ewol::Button("BT 3");
myButton->SetExpendX(true);
myButton->SetExpendY(true);
mySizerVert->SubWidgetAdd(myButton);
myButton = new ewol::Button(" 4 4 BT");
myButton->SetExpendY(true);
mySizerVert->SubWidgetAdd(myButton);
myButton = new ewol::Button("Exemple 2");
myButton->SetExpendX(true);
mySizer->SubWidgetAdd(myButton);
}; };
~Plop(void) ~Plop(void)
@ -60,7 +83,7 @@ int main(int argc, char *argv[])
} }
*/ */
ewol::SetFontFolder("Font"); ewol::SetFontFolder("Font");
ewol::SetDefaultFont("freefont/FreeMono", 16); ewol::SetDefaultFont("freefont/FreeMono", 14);
Plop * myWindowsExample = new Plop(); Plop * myWindowsExample = new Plop();

2
Sources/ewolFont.h
View File

@ -58,8 +58,6 @@ namespace ewol
// get the size of a long string in UTF8 (note that \n and \r represent unknown char...) // get the size of a long string in UTF8 (note that \n and \r represent unknown char...)
int32_t GetWidth(int32_t fontID, const uniChar_t * unicodeString); int32_t GetWidth(int32_t fontID, const uniChar_t * unicodeString);
int32_t GetWidth(int32_t fontID, const char * utf8String); int32_t GetWidth(int32_t fontID, const char * utf8String);
int32_t GetWidth(int32_t fontID, const uniChar_t unicodeChar);
int32_t GetWidth(int32_t fontID, const char utf8Char);
int32_t GetHeight(int32_t fontID); int32_t GetHeight(int32_t fontID);

56
Sources/ewolFontFreeType.cpp
View File

@ -202,15 +202,16 @@ class FTFontInternal
} }
public: public:
etk::String GetFontName(void) {return m_fontName;}; etk::String GetFontName(void) {return m_fontName;};
bool GenerateBitmapFont(int32_t size, int32_t textureId, etk::VectorType<freeTypeFontElement_ts> & listElement) bool GenerateBitmapFont(int32_t size, int32_t &height, int32_t textureId, etk::VectorType<freeTypeFontElement_ts> & listElement)
{ {
// 300dpi (hight quality) 96 dpi (normal quality) // 300dpi (hight quality) 96 dpi (normal quality)
int32_t fontQuality = 96; int32_t fontQuality = 96;
//int32_t fontQuality = 300;
// Select Size ... // Select Size ...
// note tha <<6==*64 corespond with the 1/64th of points calculation of freetype // note tha <<6==*64 corespond with the 1/64th of points calculation of freetype
int32_t error = FT_Set_Char_Size(m_fftFace, size<<6, size<<6, fontQuality, fontQuality); int32_t error = FT_Set_Char_Size(m_fftFace, size<<6, size<<6, fontQuality, fontQuality);
// the line height to have a correct display // the line height to have a correct display
//float lineHeight = size*1.43f; height = size*1.43f;
// a small shortcut // a small shortcut
FT_GlyphSlot slot = m_fftFace->glyph; FT_GlyphSlot slot = m_fftFace->glyph;
@ -355,7 +356,7 @@ class FTFont{
m_size = size; m_size = size;
//generate font //generate font
glGenTextures(1, &m_textureId); glGenTextures(1, &m_textureId);
m_listLoadedTTFont[m_trueTypeFontId]->GenerateBitmapFont(m_size, m_textureId, m_elements); m_listLoadedTTFont[m_trueTypeFontId]->GenerateBitmapFont(m_size, m_lineHeight, m_textureId, m_elements);
} }
~FTFont(void) ~FTFont(void)
{ {
@ -389,10 +390,16 @@ class FTFont{
return m_size; return m_size;
}; };
int32_t GetHeight(void)
{
return m_lineHeight;
};
private: private:
int32_t m_trueTypeFontId; int32_t m_trueTypeFontId;
uint32_t m_textureId; // internal texture ID uint32_t m_textureId; // internal texture ID
int32_t m_size; // nb pixel height int32_t m_size; // nb pixel height
int32_t m_lineHeight; // nb pixel height
int32_t m_interline; // nb pixel between 2 lines int32_t m_interline; // nb pixel between 2 lines
etk::VectorType<freeTypeFontElement_ts> m_elements; // etk::VectorType<freeTypeFontElement_ts> m_elements; //
@ -606,3 +613,46 @@ void ewol::DrawText(int32_t fontID,
drawPosition.x = posDrawX; drawPosition.x = posDrawX;
} }
int32_t ewol::GetWidth(int32_t fontID, const char * utf8String)
{
if(fontID>=m_listLoadedFont.Size() || fontID < 0) {
EWOL_WARNING("try to display text with an fontID that does not existed " << fontID);
return 0;
}
etk::VectorType<freeTypeFontElement_ts> & listOfElement = m_listLoadedFont[fontID]->GetRefOnElement();
char * tmpVal = (char*)utf8String;
float posDrawX = 0.0;
while(*tmpVal != 0) {
int32_t tmpChar = *tmpVal++;
int32_t charIndex;
if (tmpChar >= 0x80) {
charIndex = 0;
} else if (tmpChar < 0x20) {
charIndex = 0;
} else if (tmpChar < 0x80) {
charIndex = tmpChar - 0x1F;
} else {
for (int32_t iii=0x80-0x20; iii < listOfElement.Size(); iii++) {
if (listOfElement[iii].unicodeCharVal == tmpChar) {
charIndex = iii;
break;
}
}
// TODO : Update if possible the mapping
charIndex = 0;
}
posDrawX += listOfElement[charIndex].width;
}
return posDrawX;
}
int32_t ewol::GetHeight(int32_t fontID)
{
if(fontID>=m_listLoadedFont.Size() || fontID < 0) {
EWOL_WARNING("try to display text with an fontID that does not existed " << fontID);
return 10;
}
return m_listLoadedFont[fontID]->GetHeight();
}

34
Sources/ewolOObject.cpp
View File

@ -101,6 +101,15 @@ void ewol::OObject2DColored::Rectangle(float x, float y, float w, float h, float
} }
void ewol::OObject2DColored::UpdateOrigin(float x, float y)
{
for (int32_t iii=0; iii<m_coord.Size(); iii++) {
m_coord[iii].x += x;
m_coord[iii].y += y;
}
}
#undef __class__ #undef __class__
@ -187,6 +196,15 @@ void ewol::OObject2DTextured::Rectangle(float x, float y, float w, float h, floa
m_coordTex.PushBack(tex); m_coordTex.PushBack(tex);
} }
void ewol::OObject2DTextured::UpdateOrigin(float x, float y)
{
for (int32_t iii=0; iii<m_coord.Size(); iii++) {
m_coord[iii].x += x;
m_coord[iii].y += y;
}
}
#undef __class__ #undef __class__
#define __class__ "ewol::OObject2DText" #define __class__ "ewol::OObject2DText"
@ -228,8 +246,13 @@ void ewol::OObject2DText::Text(float x, float y, etk::String FontName, int32_t s
m_coord.Clear(); m_coord.Clear();
m_coordTex.Clear(); m_coordTex.Clear();
// get font Name : // get font Name :
//m_FontId = GetFontIdWithName(FontName); if (FontName == "") {
m_FontId = GetDefaultFontId(); m_FontId = GetDefaultFontId();
} else {
EWOL_TODO("pas encore fait...");
//m_FontId = GetFontIdWithName(FontName);
return;
}
if (m_FontId == -1) { if (m_FontId == -1) {
EWOL_ERROR("Can not find the font with the name : " << FontName); EWOL_ERROR("Can not find the font with the name : " << FontName);
} }
@ -241,6 +264,13 @@ void ewol::OObject2DText::Text(float x, float y, etk::String FontName, int32_t s
ewol::DrawText(m_FontId, drawPosition, utf8String, m_FontTextureId, m_coord, m_coordTex); ewol::DrawText(m_FontId, drawPosition, utf8String, m_FontTextureId, m_coord, m_coordTex);
} }
void ewol::OObject2DText::UpdateOrigin(float x, float y)
{
for (int32_t iii=0; iii<m_coord.Size(); iii++) {
m_coord[iii].x += x;
m_coord[iii].y += y;
}
}
/* /*
uint32_t m_FontId; //!< font internal ID uint32_t m_FontId; //!< font internal ID

8
Sources/ewolOObject.h
View File

@ -61,6 +61,8 @@ namespace ewol {
{ {
return m_name; return m_name;
} }
public:
virtual void UpdateOrigin(float x, float y) {};
private: private:
etk::String m_name; etk::String m_name;
}; };
@ -78,6 +80,8 @@ namespace ewol {
//etk::VectorType<linkCoord_ts> m_linkCoord; //!< internal link between point to generate triangle //etk::VectorType<linkCoord_ts> m_linkCoord; //!< internal link between point to generate triangle
public: public:
void Rectangle(float x, float y, float w, float h, float red, float green, float blue, float alpha); void Rectangle(float x, float y, float w, float h, float red, float green, float blue, float alpha);
public:
virtual void UpdateOrigin(float x, float y);
}; };
/* /*
class OObjectFile :public ewol::OObject class OObjectFile :public ewol::OObject
@ -106,6 +110,8 @@ namespace ewol {
uint32_t m_textureId; //!< texture internal ID uint32_t m_textureId; //!< texture internal ID
etk::VectorType<coord2D_ts> m_coord; //!< internal coord of the object etk::VectorType<coord2D_ts> m_coord; //!< internal coord of the object
etk::VectorType<texCoord_ts> m_coordTex; //!< internal texture coordinate for every point etk::VectorType<texCoord_ts> m_coordTex; //!< internal texture coordinate for every point
public:
virtual void UpdateOrigin(float x, float y);
}; };
@ -124,6 +130,8 @@ namespace ewol {
uint32_t m_FontTextureId; //!< font internal Texture ID uint32_t m_FontTextureId; //!< font internal Texture ID
etk::VectorType<coord2D_ts> m_coord; //!< internal coord of the object etk::VectorType<coord2D_ts> m_coord; //!< internal coord of the object
etk::VectorType<texCoord_ts> m_coordTex; //!< internal texture coordinate for every point etk::VectorType<texCoord_ts> m_coordTex; //!< internal texture coordinate for every point
public:
virtual void UpdateOrigin(float x, float y);
}; };
/* /*

18
Sources/ewolWidget.cpp
View File

@ -31,15 +31,17 @@ ewol::Widget::Widget(void)
{ {
m_origin.x = 0.0; m_origin.x = 0.0;
m_origin.y = 0.0; m_origin.y = 0.0;
m_minSize.x = -1.0;
m_minSize.y = -1.0;
m_size.x = 10.0; m_size.x = 10.0;
m_size.y = 10.0; m_size.y = 10.0;
m_maxSize.x = -1.0; m_minSize.x = -1.0;
m_maxSize.y = -1.0; m_minSize.y = -1.0;
m_expendX = false; // user settings :
m_expendY = false; m_userMinSize.x = -1.0;
m_userMinSize.y = -1.0;
m_userExpendX = false;
m_userExpendY = false;
m_genericDraw = true; m_genericDraw = true;
m_specificDraw = false;
} }
ewol::Widget::~Widget(void) ewol::Widget::~Widget(void)
@ -51,6 +53,8 @@ ewol::Widget::~Widget(void)
bool ewol::Widget::CalculateSize(double availlableX, double availlableY) bool ewol::Widget::CalculateSize(double availlableX, double availlableY)
{ {
m_size.x = availlableX;
m_size.y = availlableY;
return true; return true;
} }
@ -175,6 +179,8 @@ void ewol::Widget::AddOObject(ewol::OObject* newObject, etk::String name)
return; return;
} }
newObject->SetName(name); newObject->SetName(name);
EWOL_INFO("UPDATE AT origin : (" << m_origin.x << "," << m_origin.y << ")");
newObject->UpdateOrigin(m_origin.x, m_origin.y);
m_listOObject.PushBack(newObject); m_listOObject.PushBack(newObject);
} }

56
Sources/ewolWidget.h
View File

@ -146,23 +146,27 @@ namespace ewol {
// -- Widget Size: // -- Widget Size:
// ---------------------------------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------------------------------
protected: protected:
coord m_origin; // internal element calculated by the system
coord m_minSize; coord m_origin; //!< internal ... I do not really known how i can use it ...
coord m_size; coord m_size; //!< internal : current size of the widget
coord m_maxSize; coord m_minSize; //!< user define the minimum size of the widget
bool m_expendX; // user configuaration
bool m_expendY; coord m_userMinSize; //!< user define the minimum size of the widget
void SetExpendX(bool newExpend=false) { m_expendX = newExpend; }; bool m_userExpendX;
void SetExpendY(bool newExpend=false) { m_expendY = newExpend; }; bool m_userExpendY;
void SetMinSise(double x=-1, double y=-1) { m_minSize.x = x; m_minSize.y = y; };
void SetMaxSise(double x=-1, double y=-1) { m_maxSize.x = x; m_maxSize.y = y; };
void SetCurrentSise(double x=-1, double y=-1) { m_size.x = x; m_size.y = y; };
public: public:
void SetOrigin(double x, double y) { m_origin.x=x; m_origin.y=y; }; void SetOrigin(double x, double y) { m_origin.x=x; m_origin.y=y; };
virtual bool CalculateSize(double availlableX, double availlableY); // this generate the current size ... virtual bool CalculateSize(double availlableX, double availlableY); // this generate the current size ...
coord GetMinSize(void) { return m_minSize; }; virtual bool CalculateMinSize(void) {m_minSize.x = m_userMinSize.x; m_minSize.y = m_userMinSize.y; return true; }; //update the min Size ... and the expend parameters for the sizer
coord GetMaxSize(void) { return m_maxSize; }; virtual void SetMinSise(double x=-1, double y=-1) { m_userMinSize.x = x; m_userMinSize.y = y; };
coord GetCurrentSize(void) { return m_size; }; coord GetMinSize(void) { return m_minSize; };
coord GetSize(void) { return m_size; };
void SetCurrentSise(double x=-1, double y=-1) { m_size.x = x; m_size.y = y; };
coord GetCurrentSize(void) { return m_size; };
virtual void SetExpendX(bool newExpend=false) { m_userExpendX = newExpend; };
bool CanExpentX(void) { return m_userExpendX; };
virtual void SetExpendY(bool newExpend=false) { m_userExpendY = newExpend; };
bool CanExpentY(void) { return m_userExpendY; };
// ---------------------------------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------------------------------
// -- Focus Area // -- Focus Area
@ -239,6 +243,7 @@ namespace ewol {
// ---------------------------------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------------------------------
private: private:
bool m_genericDraw; bool m_genericDraw;
bool m_specificDraw;
etk::VectorType<ewol::OObject*> m_listOObject; //!< generic element to display... etk::VectorType<ewol::OObject*> m_listOObject; //!< generic element to display...
bool GenericDraw(void); bool GenericDraw(void);
protected: protected:
@ -246,19 +251,24 @@ namespace ewol {
ewol::OObject* GetOObject(etk::String name); ewol::OObject* GetOObject(etk::String name);
void RmOObjectElem(etk::String name); void RmOObjectElem(etk::String name);
void ClearOObjectList(void); void ClearOObjectList(void);
void SetNotGenericDraw(void) { m_genericDraw = false; }; void GenericDrawDisable(void) { m_genericDraw = false; };
void SetGenericDraw(void) { m_genericDraw = true; }; void GenericDrawEnable(void) { m_genericDraw = true; };
virtual bool OnDraw(void) { return true; }; void SpecificDrawDisable(void) { m_specificDraw = false; };
void SpecificDrawEnable(void) { m_specificDraw = true; };
virtual bool OnDraw(void) { /*EWOL_ERROR("plop");*/ return true; };
public: public:
virtual void OnRegenerateDisplay(void) { };
bool GenDraw(void) bool GenDraw(void)
{ {
if (true == m_genericDraw) { if (true == m_genericDraw) {
//EWOL_DEBUG("Draw generic..."); //EWOL_DEBUG("Draw generic...");
return GenericDraw(); GenericDraw();
} else {
//EWOL_DEBUG("Draw Custum...");
return OnDraw();
} }
if (true == m_specificDraw) {
//EWOL_DEBUG("Draw Custum...");
OnDraw();
}
return true;
}; };
}; // end of the class Widget declaration }; // end of the class Widget declaration

86
Sources/ewolWindows.cpp
View File

@ -46,16 +46,27 @@ const char * ewolEventWindowsExpend = "ewol Windows expend/unExpend";
ewol::Windows::Windows(void) ewol::Windows::Windows(void)
{ {
m_subWidget = NULL;
// enable specific drawing system ...
SpecificDrawEnable();
SetDecorationDisable(); SetDecorationDisable();
if (true == m_hasDecoration) { if (true == m_hasDecoration) {
ewol::OObject2DColored * myOObject = new ewol::OObject2DColored(); ewol::OObject2DColored * myOObject = new ewol::OObject2DColored();
myOObject->Rectangle( 0, 0, 20, 20, 1.0, 0.0, 0.0, 1.0); // Close myOObject->Rectangle( 0, 0, 20, 20, 1.0, 0.0, 0.0, 1.0); // Close
myOObject->Rectangle(20, 0, 20, 20, 0.0, 1.0, 0.0, 1.0); // Reduce myOObject->Rectangle(20, 0, 20, 20, 0.0, 1.0, 0.0, 1.0); // Reduce
myOObject->Rectangle(40, 0, 20, 20, 0.0, 0.0, 1.0, 1.0); // Expend - Un-expend myOObject->Rectangle(40, 0, 20, 20, 0.0, 0.0, 1.0, 1.0); // Expend - Un-expend
coord origin;
AddEventArea({ 0.0,0.0}, {20, 20}, FLAG_EVENT_INPUT_1 | FLAG_EVENT_INPUT_CLICKED_ALL, ewolEventWindowsClose); coord size;
AddEventArea({20.0,0.0}, {20, 20}, FLAG_EVENT_INPUT_1 | FLAG_EVENT_INPUT_CLICKED_ALL, ewolEventWindowsMinimize); origin.x = 0.0;
AddEventArea({40.0,0.0}, {20, 20}, FLAG_EVENT_INPUT_1 | FLAG_EVENT_INPUT_CLICKED_ALL, ewolEventWindowsExpend); origin.y = 0.0;
size.x = 20;
size.y = 20;
AddEventArea(origin, size, FLAG_EVENT_INPUT_1 | FLAG_EVENT_INPUT_CLICKED_ALL, ewolEventWindowsClose);
origin.x = 20.0;
AddEventArea(origin, size, FLAG_EVENT_INPUT_1 | FLAG_EVENT_INPUT_CLICKED_ALL, ewolEventWindowsMinimize);
origin.x = 40.0;
AddEventArea(origin, size, FLAG_EVENT_INPUT_1 | FLAG_EVENT_INPUT_CLICKED_ALL, ewolEventWindowsExpend);
AddOObject(myOObject, "leftBoutton"); AddOObject(myOObject, "leftBoutton");
@ -69,12 +80,26 @@ ewol::Windows::Windows(void)
} }
} }
ewol::Windows::~Windows(void)
{
if (NULL != m_subWidget) {
delete(m_subWidget);
m_subWidget=NULL;
}
}
bool ewol::Windows::CalculateSize(double availlableX, double availlableY) bool ewol::Windows::CalculateSize(double availlableX, double availlableY)
{ {
m_size.x = availlableX; m_size.x = availlableX;
m_size.y = availlableY; m_size.y = availlableY;
if (NULL != m_subWidget) {
m_subWidget->CalculateMinSize();
// TODO : Check if min Size is possible ...
// TODO : Herited from MinSize .. and expand ???
m_subWidget->CalculateSize(m_size.x, m_size.y);
}
// regenerate all the display ...
OnRegenerateDisplay();
return true; return true;
} }
@ -112,17 +137,10 @@ bool ewol::Windows::OnEventInput(int32_t IdInput, eventInputType_te typeEvent, d
# include <X11/extensions/Xrender.h> # include <X11/extensions/Xrender.h>
#endif #endif
#include <ft2build.h>
#include FT_FREETYPE_H
FT_Library library; // handle to library
FT_Face face; // handle to face object
void ewol::Windows::SysDraw(void) void ewol::Windows::SysDraw(void)
{ {
//EWOL_DEBUG("Drow on (" << m_size.x << "," << m_size.y << ")"); EWOL_DEBUG("Drow on (" << m_size.x << "," << m_size.y << ")");
// set the size of the open GL system // set the size of the open GL system
glViewport(0,0,m_size.x,m_size.y); glViewport(0,0,m_size.x,m_size.y);
@ -146,10 +164,29 @@ void ewol::Windows::SysDraw(void)
GenDraw(); GenDraw();
glDisable(GL_BLEND);
return;
}
void ewol::Windows::OnRegenerateDisplay(void)
{
if (NULL != m_subWidget) {
m_subWidget->OnRegenerateDisplay();
}
}
bool ewol::Windows::OnDraw(void)
{
if (NULL != m_subWidget) {
m_subWidget->GenDraw();
}
/*
// Test AREA :
ewol::OObject2DColored tmpOObjects; ewol::OObject2DColored tmpOObjects;
tmpOObjects.Rectangle( 50, 50, 200, 300, 1.0, 0.0, 0.0, 1.0); tmpOObjects.Rectangle( 50, 50, 200, 300, 1.0, 0.0, 0.0, 1.0);
tmpOObjects.Draw(); tmpOObjects.Draw();
glColor4f(0.0, 0.0, 0.0, 1.0); glColor4f(0.0, 0.0, 0.0, 1.0);
glEnable(GL_TEXTURE_2D); glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, 1); glBindTexture(GL_TEXTURE_2D, 1);
@ -164,13 +201,10 @@ void ewol::Windows::SysDraw(void)
glVertex3f(50.0, 350.0, 0.0); glVertex3f(50.0, 350.0, 0.0);
glEnd(); glEnd();
glDisable(GL_TEXTURE_2D); glDisable(GL_TEXTURE_2D);
*/
return true;
glDisable(GL_BLEND);
return;
} }
bool ewol::Windows::OnEventArea(const char * generateEventId, double x, double y) bool ewol::Windows::OnEventArea(const char * generateEventId, double x, double y)
{ {
bool eventIsOK = false; bool eventIsOK = false;
@ -189,3 +223,17 @@ bool ewol::Windows::OnEventArea(const char * generateEventId, double x, double y
return eventIsOK; return eventIsOK;
} }
void ewol::Windows::SetSubWidget(ewol::Widget * widget)
{
if (NULL != m_subWidget) {
EWOL_INFO("Remove current main windows Widget...");
delete(m_subWidget);
m_subWidget = NULL;
}
m_subWidget = widget;
// Regenerate the size calculation :
CalculateSize(m_size.x, m_size.y);
}

10
Sources/ewolWindows.h
View File

@ -36,7 +36,7 @@ namespace ewol {
{ {
public: public:
Windows(void); Windows(void);
virtual ~Windows(void) {}; virtual ~Windows(void);
// internal event at ewol system : // internal event at ewol system :
public: public:
void SysDraw(void); void SysDraw(void);
@ -68,6 +68,14 @@ namespace ewol {
{ {
m_hasDecoration = true; m_hasDecoration = true;
} }
private:
ewol::Widget * m_subWidget;
public:
void SetSubWidget(ewol::Widget * widget);
protected:
virtual bool OnDraw(void);
public:
virtual void OnRegenerateDisplay(void);
}; };
}; };

72
Sources/widget/ewolButton.cpp
View File

@ -24,3 +24,75 @@
#include <widget/ewolButton.h> #include <widget/ewolButton.h>
#include <ewolOObject.h>
#undef __class__
#define __class__ "ewol::Button"
ewol::Button::Button(void)
{
m_label = "No Label";
}
ewol::Button::Button(etk::String newLabel)
{
m_label = newLabel;
}
ewol::Button::~Button(void)
{
}
bool ewol::Button::CalculateMinSize(void)
{
//SetMinSise(55, 24);
int32_t fontId = GetDefaultFontId();
int32_t minWidth = ewol::GetWidth(fontId, m_label.c_str());
int32_t minHeight = ewol::GetHeight(fontId);
m_minSize.x = 10+minWidth;
m_minSize.y = 10+minHeight;
return true;
}
void ewol::Button::SetLabel(etk::String newLabel)
{
m_label = newLabel;
}
void ewol::Button::SetValue(bool val)
{
}
bool ewol::Button::GetValue(void)
{
return false;
}
void ewol::Button::OnRegenerateDisplay(void)
{
// clean the object list ...
ClearOObjectList();
ewol::OObject2DColored * tmpOObjects = new ewol::OObject2DColored;
tmpOObjects->Rectangle( 2, 2, m_size.x-4, m_size.y-4, 0.0, 0.0, 0.0, 1.0);
tmpOObjects->Rectangle( 3, 3, m_size.x-6, m_size.y-6, 1.0, 1.0, 1.0, 1.0);
AddOObject(tmpOObjects, "BouttonDecoration");
color_ts textColorFg;
textColorFg.red = 0.0;
textColorFg.green = 0.0;
textColorFg.blue = 0.0;
textColorFg.alpha = 1.0;
int32_t fontId = GetDefaultFontId();
int32_t fontHeight = ewol::GetHeight(fontId);
int32_t pos = (m_size.y - fontHeight)/2;
ewol::OObject2DText * tmpText = new ewol::OObject2DText(5, pos, "", -1, FONT_MODE_BOLD, textColorFg, m_label.c_str());
AddOObject(tmpText, "BouttonText");
}

17
Sources/widget/ewolButton.h
View File

@ -33,8 +33,21 @@ namespace ewol {
class Button :public ewol::Widget class Button :public ewol::Widget
{ {
public: public:
Button(void) { }; Button(void);
virtual ~Button(void) { }; Button(etk::String newLabel);
virtual ~Button(void);
virtual bool CalculateMinSize(void);
void SetLabel(etk::String newLabel);
// TODO :
//void SetSize(int32_t size);
//void SetFont(etk::String fontName);
//void ResetDefaultParameters(void);
void SetValue(bool val);
bool GetValue(void);
private:
etk::String m_label;
public:
virtual void OnRegenerateDisplay(void);
}; };
}; };

3
Sources/widget/ewolCheckBox.cpp
View File

@ -24,3 +24,6 @@
#include <widget/ewolCheckBox.h> #include <widget/ewolCheckBox.h>
#undef __class__
#define __class__ "ewol::CheckBox"

3
Sources/widget/ewolEntry.cpp
View File

@ -24,3 +24,6 @@
#include <widget/ewolEntry.h> #include <widget/ewolEntry.h>
#undef __class__
#define __class__ "ewol::Entry"

4
Sources/widget/ewolList.cpp
View File

@ -24,3 +24,7 @@
#include <widget/ewolList.h> #include <widget/ewolList.h>
#undef __class__
#define __class__ "ewol::List"

149
Sources/widget/ewolSizerHori.cpp
View File

@ -26,10 +26,13 @@
#include <widget/ewolSizerHori.h> #include <widget/ewolSizerHori.h>
#undef __class__
#define __class__ "ewol::SizerHori"
ewol::SizerHori::SizerHori(void) ewol::SizerHori::SizerHori(void)
{ {
GenericDrawDisable();
SpecificDrawEnable();
} }
ewol::SizerHori::~SizerHori(void) ewol::SizerHori::~SizerHori(void)
@ -41,20 +44,109 @@ ewol::SizerHori::~SizerHori(void)
bool ewol::SizerHori::CalculateSize(double availlableX, double availlableY) bool ewol::SizerHori::CalculateSize(double availlableX, double availlableY)
{ {
EWOL_DEBUG("Update Size"); EWOL_DEBUG("Update Size");
m_size.x = availlableX;
m_size.y = availlableY;
// calculate unExpendable Size :
double unexpendableSize=0.0;
int32_t nbWidgetFixedSize=0;
int32_t nbWidgetNotFixedSize=0;
for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
if (NULL != m_subWidget[iii]) {
coord tmpSize = m_subWidget[iii]->GetMinSize();
unexpendableSize += tmpSize.x;
if (false == m_subWidget[iii]->CanExpentX()) {
nbWidgetFixedSize++;
} else {
nbWidgetNotFixedSize++;
}
}
}
double sizeToAddAtEveryOne = 0;
// 2 cases : 1 or more can Expend, or all is done ...
if (0 != nbWidgetNotFixedSize) {
sizeToAddAtEveryOne = (m_size.x - unexpendableSize) / nbWidgetNotFixedSize;
if (sizeToAddAtEveryOne<0.0) {
sizeToAddAtEveryOne=0;
}
}
coord tmpOrigin;
tmpOrigin.x = m_origin.x;
tmpOrigin.y = m_origin.y;
for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
if (NULL != m_subWidget[iii]) {
coord tmpSize = m_subWidget[iii]->GetMinSize();
// Set the origin :
EWOL_DEBUG("Set ORIGIN : " << tmpOrigin.x << "," << tmpOrigin.y << ")");
m_subWidget[iii]->SetOrigin(tmpOrigin.x, tmpOrigin.y);
// Now Update his Size his size in X and the curent sizer size in Y:
if (true == m_subWidget[iii]->CanExpentX()) {
m_subWidget[iii]->CalculateSize(tmpSize.x+sizeToAddAtEveryOne, m_size.y);
tmpOrigin.x += tmpSize.x+sizeToAddAtEveryOne;
} else {
m_subWidget[iii]->CalculateSize(tmpSize.x, m_size.y);
tmpOrigin.x += tmpSize.x;
}
}
}
return true;
} }
bool ewol::SizerHori::CalculateMinSize(void)
{
EWOL_DEBUG("Update minimum Size");
m_userExpendX=false;
m_userExpendY=false;
m_minSize.x = 0.0;
m_minSize.y = 0.0;
for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
if (NULL != m_subWidget[iii]) {
m_subWidget[iii]->CalculateMinSize();
if (true == m_subWidget[iii]->CanExpentX()) {
m_userExpendX = true;
}
if (true == m_subWidget[iii]->CanExpentY()) {
m_userExpendY = true;
}
coord tmpSize = m_subWidget[iii]->GetMinSize();
m_minSize.x += tmpSize.x;
if (tmpSize.y>m_minSize.y) {
m_minSize.y = tmpSize.y;
}
}
}
EWOL_DEBUG("Result : expend X="<< m_userExpendX << " Y=" << m_userExpendY);
EWOL_DEBUG(" minSize ("<< m_minSize.x << "," << m_minSize.y << ")");
return true;
}
void ewol::SizerHori::SetMinSise(double x, double y)
{
EWOL_ERROR("Sizer can not have a user Minimum size (herited from under elements)");
}
void ewol::SizerHori::SetExpendX(bool newExpend)
{
EWOL_ERROR("Sizer can not have a user expend settings X (herited from under elements)");
}
void ewol::SizerHori::SetExpendY(bool newExpend)
{
EWOL_ERROR("Sizer can not have a user expend settings Y (herited from under elements)");
}
//etk::VectorType<ewol::Widget*> m_SubWidget; //etk::VectorType<ewol::Widget*> m_SubWidget;
void ewol::SizerHori::SubWidgetRemoveAll(void) void ewol::SizerHori::SubWidgetRemoveAll(void)
{ {
for (int32_t iii=0; iii<m_SubWidget.Size(); iii++) { for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
delete(m_SubWidget[iii]); if (NULL != m_subWidget[iii]) {
m_SubWidget[iii] = NULL; delete(m_subWidget[iii]);
m_subWidget[iii] = NULL;
}
} }
m_SubWidget.Clear(); m_subWidget.Clear();
} }
@ -63,7 +155,7 @@ void ewol::SizerHori::SubWidgetAdd(ewol::Widget* newWidget)
if (NULL == newWidget) { if (NULL == newWidget) {
return; return;
} }
m_SubWidget.PushBack(newWidget); m_subWidget.PushBack(newWidget);
newWidget->SetParrent(this); newWidget->SetParrent(this);
} }
@ -73,11 +165,13 @@ void ewol::SizerHori::SubWidgetRemove(ewol::Widget* newWidget)
if (NULL == newWidget) { if (NULL == newWidget) {
return; return;
} }
for (int32_t iii=0; iii<m_SubWidget.Size(); iii++) { for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
if (newWidget == m_SubWidget[iii]) { if (newWidget == m_subWidget[iii]) {
delete(m_SubWidget[iii]); if (NULL != m_subWidget[iii]) {
m_SubWidget[iii] = NULL; delete(m_subWidget[iii]);
m_SubWidget.Erase(iii); m_subWidget[iii] = NULL;
}
m_subWidget.Erase(iii);
return; return;
} }
} }
@ -88,11 +182,34 @@ void ewol::SizerHori::SubWidgetUnLink(ewol::Widget* newWidget)
if (NULL == newWidget) { if (NULL == newWidget) {
return; return;
} }
for (int32_t iii=0; iii<m_SubWidget.Size(); iii++) { for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
if (newWidget == m_SubWidget[iii]) { if (newWidget == m_subWidget[iii]) {
m_SubWidget[iii] = NULL; m_subWidget[iii] = NULL;
m_SubWidget.Erase(iii); m_subWidget.Erase(iii);
return; return;
} }
} }
} }
bool ewol::SizerHori::OnDraw(void)
{
for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
if (NULL != m_subWidget[iii]) {
m_subWidget[iii]->GenDraw();
}
}
return true;
}
void ewol::SizerHori::OnRegenerateDisplay(void)
{
for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
if (NULL != m_subWidget[iii]) {
m_subWidget[iii]->OnRegenerateDisplay();
}
}
}

20
Sources/widget/ewolSizerHori.h
View File

@ -36,14 +36,22 @@ namespace ewol {
SizerHori(void); SizerHori(void);
virtual ~SizerHori(void); virtual ~SizerHori(void);
public: public:
virtual bool CalculateSize(double availlableX, double availlableY); // this generate the current size ... virtual bool CalculateSize(double availlableX, double availlableY); // this generate the current size ...
virtual bool CalculateMinSize(void); //update the min Size ... and the expend parameters for the sizer
virtual void SetMinSise(double x=-1, double y=-1);
virtual void SetExpendX(bool newExpend=false);
virtual void SetExpendY(bool newExpend=false);
private: private:
etk::VectorType<ewol::Widget*> m_SubWidget; etk::VectorType<ewol::Widget*> m_subWidget;
public: public:
void SubWidgetRemoveAll(void); void SubWidgetRemoveAll(void);
void SubWidgetAdd(ewol::Widget* newWidget); void SubWidgetAdd(ewol::Widget* newWidget);
void SubWidgetRemove(ewol::Widget* newWidget); void SubWidgetRemove(ewol::Widget* newWidget);
void SubWidgetUnLink(ewol::Widget* newWidget); void SubWidgetUnLink(ewol::Widget* newWidget);
protected:
virtual bool OnDraw(void);
public:
virtual void OnRegenerateDisplay(void);
}; };
}; };

188
Sources/widget/ewolSizerVert.cpp
View File

@ -24,3 +24,191 @@
#include <widget/ewolSizerVert.h> #include <widget/ewolSizerVert.h>
#undef __class__
#define __class__ "ewol::SizerVert"
ewol::SizerVert::SizerVert(void)
{
GenericDrawDisable();
SpecificDrawEnable();
}
ewol::SizerVert::~SizerVert(void)
{
SubWidgetRemoveAll();
}
bool ewol::SizerVert::CalculateSize(double availlableX, double availlableY)
{
EWOL_DEBUG("Update Size");
m_size.x = availlableX;
m_size.y = availlableY;
// calculate unExpendable Size :
double unexpendableSize=0.0;
int32_t nbWidgetFixedSize=0;
int32_t nbWidgetNotFixedSize=0;
for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
if (NULL != m_subWidget[iii]) {
coord tmpSize = m_subWidget[iii]->GetMinSize();
unexpendableSize += tmpSize.y;
if (false == m_subWidget[iii]->CanExpentY()) {
nbWidgetFixedSize++;
} else {
nbWidgetNotFixedSize++;
}
}
}
// 2 cases : 1 or more can Expend, or all is done ...
double sizeToAddAtEveryOne = 0;
// 2 cases : 1 or more can Expend, or all is done ...
if (0 != nbWidgetNotFixedSize) {
sizeToAddAtEveryOne = (m_size.y - unexpendableSize) / nbWidgetNotFixedSize;
if (sizeToAddAtEveryOne<0.0) {
sizeToAddAtEveryOne=0;
}
}
coord tmpOrigin;
tmpOrigin.x = m_origin.x;
tmpOrigin.y = m_origin.y;
for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
if (NULL != m_subWidget[iii]) {
coord tmpSize = m_subWidget[iii]->GetMinSize();
// Set the origin :
EWOL_DEBUG("Set ORIGIN : " << tmpOrigin.x << "," << tmpOrigin.y << ")");
m_subWidget[iii]->SetOrigin(tmpOrigin.x, tmpOrigin.y);
// Now Update his Size his size in X and the curent sizer size in Y:
if (true == m_subWidget[iii]->CanExpentY()) {
m_subWidget[iii]->CalculateSize(m_size.x, tmpSize.y+sizeToAddAtEveryOne);
tmpOrigin.y += tmpSize.y+sizeToAddAtEveryOne;
} else {
m_subWidget[iii]->CalculateSize(m_size.x, tmpSize.y);
tmpOrigin.y += tmpSize.y;
}
}
}
return true;
}
bool ewol::SizerVert::CalculateMinSize(void)
{
EWOL_DEBUG("Update minimum Size");
m_userExpendX=false;
m_userExpendY=false;
m_minSize.x = 0.0;
m_minSize.y = 0.0;
for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
if (NULL != m_subWidget[iii]) {
m_subWidget[iii]->CalculateMinSize();
if (true == m_subWidget[iii]->CanExpentX()) {
m_userExpendX = true;
}
if (true == m_subWidget[iii]->CanExpentY()) {
m_userExpendY = true;
}
coord tmpSize = m_subWidget[iii]->GetMinSize();
m_minSize.y += tmpSize.y;
if (tmpSize.x>m_minSize.x) {
m_minSize.x = tmpSize.x;
}
}
}
EWOL_DEBUG("Result : expend X="<< m_userExpendX << " Y=" << m_userExpendY);
EWOL_DEBUG(" minSize ("<< m_minSize.x << "," << m_minSize.y << ")");
return true;
}
void ewol::SizerVert::SetMinSise(double x, double y)
{
EWOL_ERROR("Sizer can not have a user Minimum size (herited from under elements)");
}
void ewol::SizerVert::SetExpendX(bool newExpend)
{
EWOL_ERROR("Sizer can not have a user expend settings X (herited from under elements)");
}
void ewol::SizerVert::SetExpendY(bool newExpend)
{
EWOL_ERROR("Sizer can not have a user expend settings Y (herited from under elements)");
}
//etk::VectorType<ewol::Widget*> m_SubWidget;
void ewol::SizerVert::SubWidgetRemoveAll(void)
{
for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
delete(m_subWidget[iii]);
m_subWidget[iii] = NULL;
}
m_subWidget.Clear();
}
void ewol::SizerVert::SubWidgetAdd(ewol::Widget* newWidget)
{
if (NULL == newWidget) {
return;
}
m_subWidget.PushBack(newWidget);
newWidget->SetParrent(this);
}
void ewol::SizerVert::SubWidgetRemove(ewol::Widget* newWidget)
{
if (NULL == newWidget) {
return;
}
for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
if (newWidget == m_subWidget[iii]) {
delete(m_subWidget[iii]);
m_subWidget[iii] = NULL;
m_subWidget.Erase(iii);
return;
}
}
}
void ewol::SizerVert::SubWidgetUnLink(ewol::Widget* newWidget)
{
if (NULL == newWidget) {
return;
}
for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
if (newWidget == m_subWidget[iii]) {
m_subWidget[iii] = NULL;
m_subWidget.Erase(iii);
return;
}
}
}
bool ewol::SizerVert::OnDraw(void)
{
for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
if (NULL != m_subWidget[iii]) {
m_subWidget[iii]->GenDraw();
}
}
return true;
}
void ewol::SizerVert::OnRegenerateDisplay(void)
{
for (int32_t iii=0; iii<m_subWidget.Size(); iii++) {
if (NULL != m_subWidget[iii]) {
m_subWidget[iii]->OnRegenerateDisplay();
}
}
}

21
Sources/widget/ewolSizerVert.h
View File

@ -33,8 +33,25 @@ namespace ewol {
class SizerVert :public ewol::Widget class SizerVert :public ewol::Widget
{ {
public: public:
SizerVert(void) { }; SizerVert(void);
virtual ~SizerVert(void) { }; virtual ~SizerVert(void);
public:
virtual bool CalculateSize(double availlableX, double availlableY); // this generate the current size ...
virtual bool CalculateMinSize(void); //update the min Size ... and the expend parameters for the sizer
virtual void SetMinSise(double x=-1, double y=-1);
virtual void SetExpendX(bool newExpend=false);
virtual void SetExpendY(bool newExpend=false);
private:
etk::VectorType<ewol::Widget*> m_subWidget;
public:
void SubWidgetRemoveAll(void);
void SubWidgetAdd(ewol::Widget* newWidget);
void SubWidgetRemove(ewol::Widget* newWidget);
void SubWidgetUnLink(ewol::Widget* newWidget);
protected:
virtual bool OnDraw(void);
public:
virtual void OnRegenerateDisplay(void);
}; };
}; };