File content as of revision 0:65fd8b1cbf86:

#include "ObjetGraphic.h"

PicasoSerial* ps=0;

Screen::Screen(PicasoSerial* serial,UINT16 _x,UINT16 _y,UINT16 _w,UINT16 _h,Color _colorBkg):
    myXpos(_x),myYpos(_y),myWidth(_w),myHeight(_h),myColorBkg(_colorBkg)
{
    mySerial=serial;
}
//------------------------------------
Screen::~Screen(void)
{
    ps=0;

    for(int i=0; i<myVectorObjet.size(); i++) {
        delete  myVectorObjet[i];
        myVectorObjet[i]=0;
    }
}
//------------------------------------
UINT16 Screen::getXpos(void)
{
    return this->myXpos;
}
//----------------------------------
UINT16 Screen::getYpos(void)
{
    return this->myYpos;
}
//------------------------------------
UINT16 Screen::getWidth(void)
{
    return this->myWidth;
}
//-------------------------------------
UINT16 Screen::getHeight(void)
{
    return this->myHeight;
}
//------------------------------------
void Screen::drawObj(ObjetHeader* pObj)
{
    pObj->draw();

}
//------------------------------------
void Screen::drawAll(void)
{
    mySerial->draw_filled_rectangle(myXpos,myYpos,myXpos+myWidth,myYpos+myHeight,myColorBkg);

    //
    for(int i=0; i<myVectorObjet.size(); i++) {
        drawObj(myVectorObjet[i]);
    }
}
//-------------------------------------
void Screen::drawCells(void)
{
    for(int i=1; i<3; i++) {
        mySerial->draw_line(80*i,0,80*i,320,BLACK);
    }
    //
    for(int i=1; i<4; i++) {
        mySerial->draw_line(0,80*i,240,80*i,BLACK);
    }

}
//-------------------------------------
void Screen::addObj(ObjetHeader* pObj)
{
    myVectorObjet.push_back(pObj);
}
//---------------------------------------
PicasoSerial* Screen::getPicasoSerial(void)
{
    return  mySerial;
}
//---------------------------------------
Color Screen::getColorBkg(void)
{
    return myColorBkg;
}
//--------------------------------------
bool Screen::isContent(ObjetHeader* pObj, UINT16 _x,UINT16 _y)
{
    UINT16 xd=pObj->getXpos();
    UINT16 w=pObj->getWidth();
    UINT16 xf=xd+w;

    UINT16 yd=pObj->getYpos();
    UINT16 h=pObj->getHeight();
    UINT16 yf=yd+h;

    if(_x >= xd && _x<= xf && _y>=yd && _y<= yf) {
        return true;
    }

    return false;

}
//-------------------------------------
ObjetHeader* Screen::getObjetPosition(UINT16 _x,UINT16 _y)
{

    if(myVectorObjet.size()==0)
        return NULL;

    //
    for(int i=0; i<myVectorObjet.size(); i++) {
        if(isContent(myVectorObjet[i],_x,_y))
            return myVectorObjet[i];
    }
    return NULL;
}
//-------------------------------------
ObjetHeader* Screen::getObjetById(UINT16 _id)
{
    if(myVectorObjet.size()==0)
        return NULL;

    //
    for(int i=0; i<myVectorObjet.size(); i++) {
        if((myVectorObjet[i]->getElementId())== _id)
            return myVectorObjet[i];
    }
    return NULL;

}
//-------------------------------------
TouchEvent Screen::getTouchEvent(GraphicMessage* msg)
{
    TouchEvent ev=EVENT_NO_ACTIVITY;
    UINT16 xp=0;
    UINT16 yp=0;

    ev=mySerial->touch_get_status();

    //
    if(ev >EVENT_NO_ACTIVITY) {
        xp=mySerial->touch_get_x();
        yp=mySerial->touch_get_y();

        msg->event=ev;
        msg->posiX=xp;
        msg->posiY=yp;
        msg->objId=0;

        return ev;
    } else {
        
        msg->event=EVENT_NO_ACTIVITY;
        msg->posiX=0;
        msg->posiY=0;
        msg->objId=0;
    }
    //
    return ev;
}
//-------------------------------------
void Screen::getProcessMessage(GraphicMessage* msg)
{
    UINT16 xt=msg->posiX;
    UINT16 yt=msg->posiY;
    UINT16 res=0;

    ObjetHeader* obj=NULL;

    obj=getObjetPosition(xt,yt);

    if(obj!=NULL && obj->getIsVisible()==true) {
        res=obj->getElementId();
        msg->objId=res;
    } else {
        msg->objId=0;
    }

}
//-------------------------------------
//
//
//
//---------------------------------------
ObjetHeader::ObjetHeader(Screen* mScreen,UINT16 _id,UINT16 _x,UINT16 _y,UINT16 _w,UINT16 _h,Color _color,bool _isVisible):
    myScreen(mScreen),myElementId(_id),myX(_x),myY(_y),myWidth(_w),myHeight(_h),myColor(_color),myElementIsVisible(_isVisible)
{

    myElementState=STATE_ON;
    myIsUpdateAutomatic=true;

    myXMoveMin=myScreen->getXpos();
    myYMoveMin=myScreen->getYpos();

    myXMoveMax=myXMoveMin+myScreen->getWidth();
    myYMoveMax= myYMoveMin+myScreen->getHeight();

    mySpeedX=0.0;
    mySpeedY=0.0;
}
//-------------------------------------
ObjetHeader::~ObjetHeader(void)
{
}
//-------------------------------------
void ObjetHeader::updateCellId(void)
{
    UINT16 cellX=myX/(ObjetHeader::CELL_DIM);
    UINT16 cellY=myY/(ObjetHeader::CELL_DIM);

    myCellId=cellX+(cellY*ObjetHeader::CELL_COL);
}
//-------------------------------------
UINT16 ObjetHeader::getCellId(void)
{
    return this->myCellId;
}
//-------------------------------------
void ObjetHeader::setUpdateAutomatic(bool _state)
{
    myIsUpdateAutomatic=_state;
}
//---------------------------------------
bool ObjetHeader::getUpdateAutomatic(void)
{
    return this->myIsUpdateAutomatic;
}
//-------------------------------------
bool ObjetHeader::overlapWith(ObjetHeader* pObj)
{
    return overlap(this,pObj);
}
//-------------------------------------
bool ObjetHeader::overlap(ObjetHeader* pObj1,ObjetHeader* pObj2)
{
    UINT16 x1=pObj1->getXpos();
    UINT16 x2=pObj2->getXpos();

    UINT16 y1=pObj1->getYpos();
    UINT16 y2=pObj2->getYpos();

    UINT16 xa=pObj1->getXpos()+pObj1->getWidth();
    UINT16 xb=pObj2->getXpos()+pObj2->getWidth();

    UINT16 ya=pObj1->getYpos()+pObj1->getHeight();
    UINT16 yb=pObj2->getYpos()+pObj2->getHeight();

    //
    if(x1 <xb && xa>x2 && y1<yb && ya>y2) {

        return true;
    } else {
        return false;
    }

}
//-------------------------------------
void ObjetHeader::elementUpdate(void)
{
    switch(myElementState) {
            //
        case BUMP_DOWN:
            setInvertSpeedY();
            myElementState=STATE_ON;
            break;
            //
        case BUMP_LEFT:
            setInvertSpeedX();
            myElementState=STATE_ON;
            break;
            //
        case BUMP_RIGHT:
            setInvertSpeedX();
            myElementState=STATE_ON;
            break;
            //
        case BUMP_UP:
            setInvertSpeedY();
            myElementState=STATE_ON;
            break;
            //
        case STATE_OFF:
            break;
            //
        default:
            break;
    }
    //
}
//-------------------------------------
void ObjetHeader::draw(void)
{
//to do
}
//-------------------------------------
UINT16 ObjetHeader::getXpos(void)
{
    return this->myX;
}
//---------------------------------------
UINT16 ObjetHeader::getYpos(void)
{
    return this->myY;
}
//----------------------------------------
UINT16 ObjetHeader::getWidth(void)
{
    return this->myWidth;
}
//----------------------------------------
UINT16 ObjetHeader::getHeight(void)
{
    return this->myHeight;
}
//----------------------------------------
UINT16 ObjetHeader::getElementId(void)
{
    return this->myElementId;
}
//----------------------------------------
GRAPHIC_OBJ_TYPE ObjetHeader::getElementType(void)
{
    return this->myElementType;
}
//----------------------------------------
bool ObjetHeader::getIsVisible(void)
{
    return this->myElementIsVisible;
}
//----------------------------------------
float ObjetHeader::getSpeedX(void)
{
    return this->mySpeedX;
}
//----------------------------------------
float ObjetHeader::getSpeedY(void)
{
    return this->mySpeedY;
}
//----------------------------------------
Color ObjetHeader::getColor(void)
{
    return myColor;
}
//----------------------------------------
void ObjetHeader::setVisibility(bool _val)
{
    (this->myElementIsVisible)=_val;
}
//----------------------------------------
State ObjetHeader::getElementState(void)
{
    return this->myElementState;
}
//----------------------------------------
void ObjetHeader::setInvertSpeedX(void)
{
    mySpeedX=-(this->mySpeedX);
}
//----------------------------------------
void ObjetHeader::setInvertSpeedY(void)
{
    mySpeedY=-(this->mySpeedY);
}
//----------------------------------------
void ObjetHeader::setSpeedX(float _speedX)
{
    mySpeedX=_speedX;
}
//----------------------------------------
void ObjetHeader::setSpeedY(float _speedY)
{
    mySpeedY=_speedY;
}
//----------------------------------------
void ObjetHeader::setSpeedXY(float _speedX,float _speedY)
{
    mySpeedX=_speedX;
    mySpeedY=_speedY;
}
//------------------------------------------
void ObjetHeader::setColor(Color _color)
{
    myColor=_color;
}
//------------------------------------------
void ObjetHeader::setElementState(State _state)
{
    myElementState=_state;
}
//------------------------------------------
void ObjetHeader::setElementId(UINT16 _id)
{
    myElementId=_id;
}
//------------------------------------------
void ObjetHeader::setXpos(UINT16 _xpos)
{
    this->myX=_xpos;
}
//------------------------------------------
void ObjetHeader::setYpos(UINT16 _ypos)
{
    this->myY=_ypos;
}
//-------------------------------------------
//
//
//
//--------------------------------------------
void Isocele::updateOrientation(void)
{
    switch(myOrientation) {
            //
        case Isocele::ORIENTATION_UP:
            mySpeedX=0.0;
            mySpeedY=-mySpeed;

            myX=myXcenter-myRadius;
            myY=myYcenter-myRadius;
            myWidth=myRadius+myRadius;
            myHeight=myRadius;

            myX1=myXcenter;
            myY1=myYcenter-myRadius;

            myX2=myXcenter-myRadius;
            myY2=myYcenter;

            myX3=myXcenter+myRadius;
            myY3=myYcenter;
            break;

            //
        case Isocele::ORIENTATION_RIGHT:
            mySpeedX=mySpeed;
            mySpeedY=0.0;

            myX=myXcenter;
            myY=myYcenter-myRadius;
            myWidth=myRadius;
            myHeight=myRadius+myRadius;

            myX1=myXcenter;
            myY1=myYcenter-myRadius;

            myX2=myXcenter;
            myY2=myYcenter+myRadius;

            myX3=myXcenter+myRadius;
            myY3=myYcenter;
            break;

            //
        case Isocele::ORIENTATION_DOWN:
            mySpeedX=0.0;
            mySpeedY=mySpeed;

            myX=myXcenter-myRadius;
            myY=myYcenter;
            myWidth=myRadius+myRadius;
            myHeight=myRadius;

            myX1=myXcenter-myRadius;
            myY1=myYcenter;

            myX2=myXcenter;
            myY2=myYcenter+myRadius;

            myX3=myXcenter+myRadius;
            myY3=myYcenter;
            break;

            //
        case Isocele::ORIENTATION_LEFT:
            mySpeedX=-mySpeed;
            mySpeedY=0.0;

            myX=myXcenter-myRadius;
            myY=myYcenter-myRadius;
            myWidth=myRadius;
            myHeight=myRadius+myRadius;

            myX1=myXcenter-myRadius;
            myY1=myYcenter;

            myX2=myXcenter;
            myY2=myYcenter+myRadius;

            myX3=myXcenter;
            myY3=myYcenter-myRadius;
            break;

            //
        default:
            break;

    }

}
//--------------------------------------------
Isocele::Isocele(Screen* mScreen,UINT16 _id,UINT16 xc,UINT16 yc,UINT16 radius,int orientation,float _speed,
                 Color color,bool isVisible): ObjetHeader(mScreen,_id,xc-radius,yc-radius,radius+radius,radius,color,isVisible)
{
    myXcenter=xc;
    myYcenter=yc;
    myRadius=radius;
    myOrientation=orientation;
    mySpeed=_speed;

    updateOrientation();

    myIsUpdateAutomatic=false;

    myElementType=OBJ_ISOCELE;

    myScreen->addObj((ObjetHeader*) this);
}
//--------------------------------------------
void Isocele::draw(void)
{
    // isVisible ?
    if(myElementIsVisible==false) {
        return;
    }
    //
    ps=myScreen->getPicasoSerial();

    if(ps!=0) {
        ps->draw_filled_triangle(myX1,myY1,myX2,myY2,myX3,myY3,myColor);
        //
        //ps->draw_rectangle(myX,myY,myX+myWidth,myY+myHeight,BLACK);
    }
}
//---------------------------------------------
Isocele::~Isocele(void)
{
}
//--------------------------------------------
void Isocele:: setInvisible(bool _state)
{
    // element devient invisible
    if(_state==true) {
        if(myElementIsVisible==false)
            return;

        myElementIsVisible=false;

        Color c= myScreen->getColorBkg();

        ps=myScreen->getPicasoSerial();

        if(ps!=0) {
            ps->draw_filled_triangle(myX1,myY1,myX2,myY2,myX3,myY3,c);
            //ps->draw_rectangle(myX,myY,myX+myWidth,myY+myHeight,c);
        }
    }

    // element devient visible
    else {
        myElementIsVisible=true;

        this->draw();
    }
}
//-------------------------------------------
void Isocele::setNewPosition(INT16 _xcnew,INT16 _ycnew)
{
    if(myElementIsVisible==false)
        return;
    //
    if(myXcenter==_xcnew && myYcenter==_ycnew)
        return;
    //
    this->setInvisible(true); // colorie le cir avec couleur de la screen

    myElementIsVisible=true;

    //test Xmax
    if(_xcnew+myRadius >= myXMoveMax) {
        _xcnew=myXMoveMax-myRadius;

        if(myElementState==STATE_ON)
            myElementState=BUMP_RIGHT;
    }

    //test Xmin
    if(_xcnew <= myRadius) {
        _xcnew=myXMoveMin+myRadius;

        if(myElementState==STATE_ON)
            myElementState=BUMP_LEFT;
    }
    //test Ymax
    if(_ycnew +myRadius >= myYMoveMax && _ycnew >0) {
        _ycnew = myYMoveMax- myRadius;

        if(myElementState==STATE_ON)
            myElementState=BUMP_DOWN;
    }
    //test yminMin;
    if(_ycnew <= myRadius) {
        _ycnew=myYMoveMin+myRadius;

        if(myElementState==STATE_ON)
            myElementState=BUMP_UP;
    }
    //
    myXcenter=_xcnew;
    myYcenter=_ycnew;

    updateOrientation();


    this->draw();
}
//--------------------------------------------
void Isocele::myElementUpdate(void)
{
    switch(myElementState) {
            //
        case BUMP_DOWN:
            setInvertSpeedY();
            myElementState=STATE_ON;
            myOrientation=Isocele::ORIENTATION_UP;
            break;
            //
        case BUMP_LEFT:
            setInvertSpeedX();
            myElementState=STATE_ON;
            myOrientation=Isocele::ORIENTATION_RIGHT;
            break;
            //
        case BUMP_RIGHT:
            setInvertSpeedX();
            myElementState=STATE_ON;
            myOrientation=Isocele::ORIENTATION_LEFT;
            break;
            //
        case BUMP_UP:
            setInvertSpeedY();
            myElementState=STATE_ON;
            myOrientation=Isocele::ORIENTATION_DOWN;
            break;
            //
        case STATE_OFF:
            break;
            //
        default:
            break;
    }
}
//--------------------------------------------
void Isocele::update(float delta)
{
    if(myIsUpdateAutomatic)
        myElementUpdate();
    //
    float xnew=myXcenter+mySpeedX*delta;
    float ynew=myYcenter+mySpeedY*delta;

    this->setNewPosition((INT16)xnew,(INT16)ynew);

    updateCellId();
}
//--------------------------------------------
void Isocele::setOrientation(int _orientation)
{
    myOrientation=_orientation;

}
//--------------------------------------------
int Isocele::getOrientation(void)
{
    return this->myOrientation;
}
//--------------------------------------------
UINT16 Isocele::getXcenter(void)
{
    return this->myXcenter;
}
//--------------------------------------------
UINT16 Isocele::getYcenter(void)
{
    return this->myYcenter;
}
//--------------------------------------------
void Isocele::turnLeft(void)
{
    myOrientation+=1;

    if(myOrientation >Isocele::ORIENTATION_RIGHT)
        myOrientation=ORIENTATION_UP;

}
//--------------------------------------------
void Isocele::turnRight(void)
{
    myOrientation-=1;

    if(myOrientation <Isocele::ORIENTATION_UP)
        myOrientation=ORIENTATION_RIGHT;

}
//--------------------------------------------
//
//
//
Rectangle::Rectangle(Screen* mScreen,UINT16 _id,UINT16 _x,UINT16 _y,UINT16 _w,UINT16 _h,Color _color,bool _isVisible):
    ObjetHeader(mScreen,_id,_x,_y,_w,_h,_color,_isVisible)
{
    myElementType=OBJ_RECTANGLE;

    myScreen->addObj((ObjetHeader*) this);
}
//------------------------------------
Rectangle::~Rectangle(void)
{
}
//------------------------------------
void Rectangle::draw(void)
{
    // isVisible ?
    if(myElementIsVisible==false) {
        return;
    }
    //

    ps=myScreen->getPicasoSerial();

    if(ps!=0) {
        ps->draw_filled_rectangle(myX,myY,myX+myWidth,myY+myHeight,myColor);
    }
}
//-------------------------------------
void Rectangle::setInvisible(bool _state)
{
    // element devient invisible
    if(_state==true) {
        if(myElementIsVisible==false)
            return;

        myElementIsVisible=false;

        Color c= myScreen->getColorBkg();

        ps=myScreen->getPicasoSerial();

        if(ps!=0) {
            ps->draw_filled_rectangle(myX,myY,myX+myWidth,myY+myHeight,c);
        }
    }

    // element devient visible
    else {
        myElementIsVisible=true;

        this->draw();
    }
}
//--------------------------------------
void Rectangle::setNewPosition(INT16 _xnew,INT16 _ynew)
{
    if(myElementIsVisible==false)
        return;

    //
    if(myX==_xnew && myY==_ynew)
        return;

    setInvisible(true); // colorie le rec avec couleur de la screen

    myElementIsVisible=true;

    //test Xmax
    if(_xnew+myWidth >= myXMoveMax) {
        _xnew=myXMoveMax-myWidth;

        if(myElementState==STATE_ON)
            myElementState=BUMP_RIGHT;

    }

    //test Xmin
    if(_xnew <= myXMoveMin) {
        _xnew=myXMoveMin;

        if(myElementState==STATE_ON)
            myElementState=BUMP_LEFT;

    }
    //test Ymax
    if(_ynew +myHeight >= myYMoveMax && _ynew >0) {
        _ynew = myYMoveMax- myHeight;

        if(myElementState==STATE_ON)
            myElementState=BUMP_DOWN;
    }
    //test yminMin;
    if(_ynew <= myYMoveMin) {
        _ynew=myYMoveMin;

        if(myElementState==STATE_ON)
            myElementState=BUMP_UP;

    }
    //
    myX=_xnew;
    myY=_ynew;


    this->draw();
}
//--------------------------------------
void Rectangle::update(float delta)
{
    if(myIsUpdateAutomatic)
        elementUpdate();
    //
    float xnew=myX+mySpeedX*delta;
    float ynew=myY+mySpeedY*delta;

    this->setNewPosition((INT16)xnew,(INT16)ynew);

    updateCellId();
}
//-------------------------------------
//
//
Circle::Circle(Screen* mScreen,UINT16 _id,UINT16 _xc,UINT16 _yc,UINT16 _radius,Color _color,bool _isVisible):
    ObjetHeader(mScreen,_id,_xc-_radius,_yc-_radius,_radius+_radius,_radius+_radius,_color,_isVisible)
{
    myRadius=_radius;
    myCenterX=_xc;
    myCenterY=_yc;
    myElementType=OBJ_CIRCLE;

    myScreen->addObj((ObjetHeader*) this);

}
//-----------------------------------------
Circle::~Circle(void)
{
}
//------------------------------------------
void Circle::draw(void)
{
// isVisible ?
    if(myElementIsVisible==false) {
        return;
    }
    //

    ps=myScreen->getPicasoSerial();

    if(ps!=0) {
        ps->draw_filled_circle(myCenterX,myCenterY,myRadius,myColor);
    }
}
//------------------------------------------
void Circle::setCenterX(UINT16 _xcenter)
{
    this->myCenterX=_xcenter;
}
//------------------------------------------
void Circle::setCenterY(UINT16 _ycenter)
{
    this->myCenterY=_ycenter;
}
//------------------------------------------
UINT16 Circle::getCenterX(void)
{
    return this->myCenterX;
}
//-------------------------------------------
UINT16 Circle::getCenterY(void)
{
    return this->myCenterY;
}
//--------------------------------------------
void Circle::setInvisible(bool _state)
{
    // element devient invisible
    if(_state==true) {
        if(myElementIsVisible==false)
            return;

        myElementIsVisible=false;

        Color c= myScreen->getColorBkg();


        ps=myScreen->getPicasoSerial();

        if(ps!=0) {
            ps->draw_filled_circle(myCenterX,myCenterY,myRadius,c);
        }
    }

    // element devient visible
    else {
        myElementIsVisible=true;


        this->draw();
    }
}
//---------------------------------------------
void Circle::setNewPosition(INT16 _xcnew,INT16 _ycnew)
{
    if(myElementIsVisible==false)
        return;
    //
    if(myCenterX==_xcnew && myCenterY==_ycnew)
        return;
    //
    this->setInvisible(true); // colorie le cir avec couleur de la screen

    myElementIsVisible=true;

    //test Xmax
    if(_xcnew+myRadius >= myXMoveMax) {
        _xcnew=myXMoveMax-myRadius;

        if(myElementState==STATE_ON)
            myElementState=BUMP_RIGHT;
    }

    //test Xmin
    if(_xcnew <= myRadius) {
        _xcnew=myXMoveMin+myRadius;

        if(myElementState==STATE_ON)
            myElementState=BUMP_LEFT;
    }
    //test Ymax
    if(_ycnew +myRadius >= myYMoveMax && _ycnew >0) {
        _ycnew = myYMoveMax- myRadius;

        if(myElementState==STATE_ON)
            myElementState=BUMP_DOWN;
    }
    //test yminMin;
    if(_ycnew <= myRadius) {
        _ycnew=myYMoveMin+myRadius;

        if(myElementState==STATE_ON)
            myElementState=BUMP_UP;
    }
    //
    myCenterX=_xcnew;
    myCenterY=_ycnew;

    myX=_xcnew-myRadius;
    myY=_ycnew-myRadius;


    this->draw();
}
//----------------------------------------------
void Circle::update(float delta)
{
    if(myIsUpdateAutomatic)
        elementUpdate();

    float xcnew=myCenterX+mySpeedX*delta;
    float ycnew=myCenterY+mySpeedY*delta;

    this->setNewPosition((INT16)xcnew,(INT16)ycnew);

    updateCellId();
}
//----------------------------------------------
//
//
//
Ellipse::Ellipse(Screen* mScreen,UINT16 _id,UINT16 _xc,UINT16 _yc,UINT16 _radiusX,UINT16 _radiusY,Color _color,
                 bool _isVisible):ObjetHeader(mScreen,_id,_xc-_radiusX,_yc-_radiusY,_radiusX+_radiusX,_radiusY+_radiusY,_color,_isVisible)
{
    myCenterX=_xc;
    myCenterY=_yc;
    myRadiusX=_radiusX;
    myRadiusY=_radiusY;

    myElementType=OBJ_ELLIPSE;

    myScreen->addObj((ObjetHeader*) this);
}
//----------------------------------------------
void Ellipse::draw(void)
{
    // isVisible ?
    if(myElementIsVisible==false) {
        return;
    }
    //
    ps=myScreen->getPicasoSerial();

    if(ps!=0) {
        ps->draw_filled_ellipse(myCenterX,myCenterY,myRadiusX,myRadiusY,myColor);
    }
}
//----------------------------------------------
void Ellipse::update(float delta)
{
    if(myIsUpdateAutomatic)
        elementUpdate();

    float xcnew=myCenterX+mySpeedX*delta;
    float ycnew=myCenterY+mySpeedY*delta;

    this->setNewPosition((INT16)xcnew,(INT16)ycnew);

    updateCellId();
}
//-----------------------------------------------
void Ellipse::setInvisible(bool _state)
{
    // element devient invisible
    if(_state==true) {
        if(myElementIsVisible==false)
            return;

        myElementIsVisible=false;

        Color c= myScreen->getColorBkg();


        ps=myScreen->getPicasoSerial();

        if(ps!=0) {
            ps->draw_filled_ellipse(myCenterX,myCenterY,myRadiusX,myRadiusY,c);
        }
    }

    // element devient visible
    else {
        myElementIsVisible=true;


        this->draw();
    }
}
//-----------------------------------------------
void Ellipse::setNewPosition(INT16 _xcnew,INT16 _ycnew)
{
    if(myElementIsVisible==false)
        return;
    //
    if(myCenterX==_xcnew && myCenterY==_ycnew)
        return;
    //
    this->setInvisible(true); // colorie le cir avec couleur de la screen

    myElementIsVisible=true;

    //test Xmax
    if(_xcnew+myRadiusX >= myXMoveMax) {
        _xcnew=myXMoveMax-myRadiusX;

        if(myElementState==STATE_ON)
            myElementState=BUMP_RIGHT;
    }

    //test Xmin
    if(_xcnew <= myRadiusX) {
        _xcnew=myXMoveMin+myRadiusX;

        if(myElementState==STATE_ON)
            myElementState=BUMP_LEFT;
    }
    //test Ymax
    if(_ycnew +myRadiusY >= myYMoveMax && _ycnew >0) {
        _ycnew = myYMoveMax- myRadiusY;

        if(myElementState==STATE_ON)
            myElementState=BUMP_DOWN;
    }
    //test yminMin;
    if(_ycnew <= myRadiusY) {
        _ycnew=myYMoveMin+myRadiusY;

        if(myElementState==STATE_ON)
            myElementState=BUMP_UP;
    }
    //
    myCenterX=_xcnew;
    myCenterY=_ycnew;

    myX=_xcnew-myRadiusX;
    myY=_ycnew-myRadiusY;


    this->draw();
}
//-----------------------------------------------
Ellipse::~Ellipse(void)
{
}
//----------------------------------------------
UINT16 Ellipse::getCenterX(void)
{
    return this->myCenterX;
}
//---------------------------------------------
UINT16 Ellipse::getCenterY(void)
{
    return this->myCenterY;
}
//----------------------------------------------
void Ellipse::setCenterX(UINT16 _xcenter)
{
    myCenterX=_xcenter;
}
//----------------------------------------------
void Ellipse::setCenterY(UINT16 _ycenter)
{
    myCenterY=_ycenter;
}
//----------------------------------------------
//
//
//
Triangle::Triangle(Screen* mScreen,UINT16 _id,UINT16 _x1,UINT16 _y1,
                   UINT16 _x2,UINT16 _y2,
                   UINT16 _x3,UINT16 _y3,Color _color,bool _isVisible):
    ObjetHeader(mScreen,_id,_x2,_y1,_x3-_x2,_y3-_y1,_color,_isVisible)
{
    myX1=_x1;
    myY1=_y1;
    myX2=_x2;
    myY2=_y2;
    myX3=_x3;
    myY3=_y3;
    myU=_x1-_x2;
    myV=_y2-_y1;

    myElementType=OBJ_TRIANGLE;

    myScreen->addObj((ObjetHeader*) this);
}
//-----------------------------------------------
Triangle::~Triangle(void)
{
}
//-----------------------------------------------
void Triangle::draw(void)
{
// isVisible ?
    if(myElementIsVisible==false) {
        return;
    }
    //
    ps=myScreen->getPicasoSerial();

    if(ps!=0) {
        ps->draw_filled_triangle(myX1,myY1,myX2,myY2,myX3,myY3,myColor);
    }
}
//------------------------------------------------
void Triangle::setInvisible(bool _state)
{
// element devient invisible
    if(_state==true) {
        if(myElementIsVisible==false)
            return;

        myElementIsVisible=false;

        Color c= myScreen->getColorBkg();


        ps=myScreen->getPicasoSerial();

        if(ps!=0) {
            ps->draw_filled_triangle(myX1,myY1,myX2,myY2,myX3,myY3,c);
        }
    }

    // element devient visible
    else {
        myElementIsVisible=true;

        this->draw();
    }
}
//------------------------------------------------
void Triangle::setNewPosition(INT16 _xnew,INT16 _ynew)
{
    if(myElementIsVisible==false)
        return;
    //
    if(myX==_xnew && myY==_ynew)
        return;
    setInvisible(true); // colorie le tri avec couleur de la screen

    myElementIsVisible=true;

    //test Xmax
    if(_xnew+myWidth >= myXMoveMax) {
        _xnew=myXMoveMax-myWidth;

        if(myElementState==STATE_ON)
            myElementState=BUMP_RIGHT;
    }
    //
    //test Xmin
    if(_xnew <= myXMoveMin) {
        _xnew=myXMoveMin;

        if(myElementState==STATE_ON)
            myElementState=BUMP_LEFT;
    }
    //test Ymax
    if(_ynew +myHeight >= myYMoveMax && _ynew >0) {
        _ynew = myYMoveMax- myHeight;

        if(myElementState==STATE_ON)
            myElementState=BUMP_DOWN;
    }
    //test yminMin;
    if(_ynew <= myYMoveMin) {
        _ynew=myYMoveMin;

        if(myElementState==STATE_ON)
            myElementState=BUMP_UP;
    }

    //
    myX=_xnew;
    myY=_ynew;

    myX1=_xnew+myU;
    myY1=_ynew;

    myX2=_xnew;
    myY2=_ynew+myV;

    myX3=_xnew+myWidth;
    myY3=_ynew+myHeight;

    this->draw();
}
//------------------------------------------------
void Triangle::update(float delta)
{
    if(myIsUpdateAutomatic)
        elementUpdate();
    //
    float xnew=myX+mySpeedX*delta;
    float ynew=myY+mySpeedY*delta;

    this->setNewPosition((INT16)xnew,(INT16)ynew);

    updateCellId();
}
//-------------------------------------------------
//
//
Diamond::Diamond(Screen* mScreen,UINT16 _id,UINT16 x1,UINT16 y1,UINT16 x2,UINT16 y2,
                 UINT16 x3,UINT16 y3,UINT16 x4,UINT16 y4,Color _color,bool _isVisible):ObjetHeader(mScreen,_id,x1,y4,x3-x1,y2-y4,_color,_isVisible)
{
    myX1=x1;
    myY1=y1;

    myX2=x2;
    myY2=y2;

    myX3=x3;
    myY3=y3;

    myX4=x4;
    myY4=y4;

    myU1=x4-x1;
    myU2=x2-x1;

    myV1=y1-y4;
    myV2=y3-y4;


    myElementType=OBJ_DIAMOND;

    myScreen->addObj((ObjetHeader*) this);
}
//-----------------------------------------
void Diamond::draw(void)
{
    // isVisible ?
    if(myElementIsVisible==false) {
        return;
    }
    //
    ps=myScreen->getPicasoSerial();

    if(ps!=0) {
        ps->draw_filled_diamond(myX1,myY1,myX2,myY2,myX3,myY3,myX4,myY4,myColor);
    }
}
//-----------------------------------------
Diamond::~Diamond(void)
{
}
//----------------------------
void Diamond::update(float delta)
{
    if(myIsUpdateAutomatic)
        elementUpdate();
    //
    float xnew=myX+mySpeedX*delta;
    float ynew=myY+mySpeedY*delta;

    this->setNewPosition((INT16)xnew,(INT16)ynew);

    updateCellId();
}
//-------------------------------
void Diamond::setInvisible(bool _state)
{
    // element devient invisible
    if(_state==true) {
        if(myElementIsVisible==false)
            return;

        myElementIsVisible=false;

        Color c= myScreen->getColorBkg();

        ps=myScreen->getPicasoSerial();

        if(ps!=0) {
            ps->draw_filled_diamond(myX1,myY1,myX2,myY2,myX3,myY3,myX4,myY4,c);
        }
    }

    // element devient visible
    else {
        myElementIsVisible=true;

        this->draw();
    }
}
//---------------------------------
void Diamond::setNewPosition(INT16 _xnew,INT16 _ynew)
{
    if(myElementIsVisible==false)
        return;
    //
    if(myX==_xnew && myY==_ynew)
        return;
    setInvisible(true); // colorie le tri avec couleur de la screen

    myElementIsVisible=true;

    //test Xmax
    if(_xnew+myWidth >= myXMoveMax) {
        _xnew=myXMoveMax-myWidth;

        if(myElementState==STATE_ON)
            myElementState=BUMP_RIGHT;
    }
    //
    //test Xmin
    if(_xnew <= myXMoveMin) {
        _xnew=myXMoveMin;

        if(myElementState==STATE_ON)
            myElementState=BUMP_LEFT;
    }
    //test Ymax
    if(_ynew +myHeight >= myYMoveMax && _ynew >0) {
        _ynew = myYMoveMax- myHeight;

        if(myElementState==STATE_ON)
            myElementState=BUMP_DOWN;
    }
    //test yminMin;
    if(_ynew <= myYMoveMin) {
        _ynew=myYMoveMin;

        if(myElementState==STATE_ON)
            myElementState=BUMP_UP;
    }

    //
    myX=_xnew;
    myY=_ynew;

    myX1=_xnew;
    myY1=_ynew+myV1;

    myX2=_xnew+myU2;
    myY2=_ynew+myHeight;

    myX3=_xnew+myWidth;
    myY3=_ynew+myV2;

    myX4=_xnew+myU1;
    myY4=_ynew;

    this->draw();
}
//---------------------------------
//
//
//
Label::Label(Screen* mScreen,UINT16 _id,UINT16 _x,UINT16 _y,
             string _text,Font _font,Color _colorText,Color _colorBkg,
             bool _isVisible):ObjetHeader(mScreen,_id,_x,_y,10,10,_colorBkg,_isVisible)

{
    myText=_text;
    myFont=_font;
    myColorText=_colorText;

    myElementType=OBJ_LABEL;

    //
    UINT16 largeur=0;
    UINT16 hauteur=16;
    UINT16 taille=0;
    UINT16 incLargeur=12;

    switch(_font) {
            //
        case FONT_2:
            incLargeur=8;
            hauteur=8;
            largeur=8;
            break;

            //
        case FONT_3:
            incLargeur=8;
            hauteur=12;
            largeur=8;
            break;
            //
        case FONT_1:
            incLargeur=5;
            hauteur=7;
            largeur=5;
            break;

            //
        default:
            incLargeur=12;
            hauteur=16;
            largeur=8;
            break;
    }
    //cherche taille
    
    /*
    while(*_text) 
    {
        taille++;
        largeur=largeur+incLargeur;
        _text++;
    }
    _text=_text-taille;
    
    */
    taille=_text.size();
    largeur=incLargeur*taille;
    
    if(largeur > incLargeur)
        largeur=largeur-incLargeur;

    myWidth=largeur;
    myHeight=hauteur;

    myScreen->addObj((ObjetHeader*) this);
}
//-----------------------------------------------------
Label::~Label(void)
{
    //myText=0;
}
//-----------------------------------------------------
void Label::draw(void)
{
    // isVisible ?
    if(myElementIsVisible==false) {
        return;
    }
    //

    ps=myScreen->getPicasoSerial();

    if(ps!=0) {

        ps->draw_string(myText,myX,myY,myFont,myColorText,myColor);
    }
}
//------------------------------------------------------
void Label::setInvisible(bool _state)
{
    // element devient invisible
    if(_state==true) {
        if(myElementIsVisible==false)
            return;

        myElementIsVisible=false;

        Color c= myScreen->getColorBkg();

        ps=myScreen->getPicasoSerial();

        if(ps!=0) {
            ps->draw_filled_rectangle(myX,myY,myX+myWidth,myY+myHeight,c);
        }
    }

    // element devient visible
    else {
        myElementIsVisible=true;

        this->draw();
    }
}
//-------------------------------------------------------
void Label::setNewText(string _newText)
{
    //if(myElementIsVisible==false)
    //    return;

    UINT16 hauteur=16;
    UINT16 incLargeur=12;
    UINT16 taille=0;

    switch(myFont) {
            //
        case FONT_2:
            incLargeur=8;
            hauteur=8;
            break;

            //
        case FONT_3:
            incLargeur=8;
            hauteur=12;
            break;
            //
        case FONT_1:
            incLargeur=5;
            hauteur=7;
            break;

            //
        default:
            incLargeur=12;
            hauteur=16;
            break;
    }
    
    taille=_newText.size();
    
    //myWidth=_nbChar*incLargeur;
    myWidth=taille*incLargeur;
    myHeight=hauteur;
    myText=_newText;

    setInvisible(true);
    setInvisible(false);
    // this->draw();
}
//-------------------------------------------------------
GraphicLed::GraphicLed(Screen* mScreen,UINT16 _id,UINT16 _xc,UINT16 _yc,UINT16 _radius,
                       Color _colorOn,Color _colorOff,State _state,
                       bool _isVisible):ObjetHeader(mScreen,_id,_xc-_radius,_yc-_radius,_radius+_radius,_radius+_radius,_colorOn,_isVisible)
{
    myColorOn=_colorOn;
    myColorOff=_colorOff;
    myRadius=_radius;
    myCenterX=_xc;
    myCenterY=_yc;

    myElementState=_state;
    myElementType=OBJ_LED;
    myScreen->addObj((ObjetHeader*) this);
}
//---------------------------------------
GraphicLed::~GraphicLed(void)
{
}
//---------------------------------------
void GraphicLed::draw(void)
{
    if(myElementIsVisible==false)
        return;

    UINT16 state=getElementState();

    //static PicasoSerial* ps=0;
    ps=myScreen->getPicasoSerial();

    switch(state) {
            //
        case LED_STATE_ON:
            if(ps!=0) {
                ps->draw_filled_circle(myCenterX,myCenterY,myRadius,myColorOn);
                ps->draw_circle(myCenterX,myCenterY,myRadius,BLACK);
            }
            return;
            //
        case LED_STATE_OFF:
            if(ps!=0) {
                ps->draw_filled_circle(myCenterX,myCenterY,myRadius,myColorOff);
                ps->draw_circle(myCenterX,myCenterY,myRadius,BLACK);
            }
            return;
            //
        default:
            break;
    }
}
//---------------------------------------
void GraphicLed::setInvisible(bool _state)
{
    // element devient invisible
    if(_state==true) {
        if(myElementIsVisible==false)
            return;

        myElementIsVisible=false;

        Color c= myScreen->getColorBkg();

        //static PicasoSerial* ps=0;
        ps=myScreen->getPicasoSerial();

        if(ps!=0) {
            ps->draw_filled_circle(myCenterX,myCenterY,myRadius,c);
        }
    }

    // element devient visible
    else {
        myElementIsVisible=true;


        this->draw();
    }
}
//---------------------------------------
void GraphicLed::setState(State _state)
{
    if(myElementIsVisible==false)
        return;

    if(myElementState==_state)
        return;

    myElementState=_state;

    this->draw();
}
//---------------------------------------
Button::Button(Screen* mScreen,UINT16 _id,UINT16 _x,UINT16 _y,string _text,Font _font,
               Color _colorText,Color _colorBtn,State _state,
               bool _isVisible):ObjetHeader(mScreen,_id,_x,_y,0,0,_colorBtn,_isVisible)

{
    myText=_text;
    myFont=_font;
    myColorText=_colorText;

    myElementState=_state;
    myElementType=OBJ_BUTTON;

    //
    UINT16 largeur=0;
    UINT16 hauteur=16;
    UINT16 taille=0;
    UINT16 incLargeur=12;

    switch(_font) {
            //
        case FONT_2:
            incLargeur=8;
            hauteur=8;
            largeur=8;
            break;

            //
        case FONT_3:
            incLargeur=8;
            hauteur=12;
            largeur=8;
            break;
            //
        case FONT_1:
            incLargeur=5;
            hauteur=7;
            largeur=5;
            break;

            //
        default:
            incLargeur=12;
            hauteur=16;
            largeur=8;
            break;
    }
    
    //cherche taille
    /*
    while(*_text) {
        taille++;
        largeur=largeur+incLargeur;
        _text++;
    }
    _text=_text-taille;
    */
    taille=_text.size();
    
    largeur=taille*incLargeur;
    
    if(largeur > incLargeur)
        largeur=largeur-incLargeur;

    myWidth=largeur+incLargeur+incLargeur;
    myHeight=hauteur+incLargeur+incLargeur;

    myScreen->addObj((ObjetHeader*) this);
    
    //
    
}
//--------------------------------------
Button::~Button(void)
{
}
//---------------------------------------
void Button::draw(void)
{
    if(myElementIsVisible==false)
        return;

    UINT16 state=getElementState();

    ps=myScreen->getPicasoSerial();

    switch(state) {
            //
        case BUTTON_STATE_PRESSED:
            if(ps!=0) {
                ps->draw_button(myText,myX,myY,myFont,BUTTON_STATE_PRESSED,myColor,WHITE);

            }
            return;
            //
        case BUTTON_STATE_RELEASED:
            if(ps!=0) {
                ps->draw_button(myText,myX,myY,myFont,BUTTON_STATE_RELEASED,myColor,myColorText);

            }
            return;
            //
        default:
            break;
    }
}

//-----------------------------------
void Button::setInvisible(bool _state)
{
    // element devient invisible
    if(_state==true) {
        if(myElementIsVisible==false)
            return;

        myElementIsVisible=false;

        Color c= myScreen->getColorBkg();

        ps=myScreen->getPicasoSerial();

        if(ps!=0) {
            ps->draw_filled_rectangle(myX,myY,myX+myWidth,myY+myHeight,c);
        }
    }

    // element devient visible
    else {
        myElementIsVisible=true;


        this->draw();
    }
}
//------------------------------------
void Button::setState(State _state)
{
    if(myElementIsVisible==false)
        return;

    if(myElementState==_state)
        return;

    myElementState=_state;

    this->draw();
}
//-------------------------------------
Slider::Slider(Screen* mScreen,UINT16 _id,UINT16 _x,UINT16 _y,UINT16 _width,UINT16 _height,int _valMax,int _value,
               Color _colorBkg,bool _isVisible):ObjetHeader(mScreen,_id,_x,_y,_width,_height,_colorBkg,_isVisible)
{

    myValueMax=_valMax;
    myValue=_value;

    myElementType=OBJ_SLIDER;
    myElementState=SLIDER_STATE_RELEASED;

    myScreen->addObj((ObjetHeader*) this);
}
//---------------------------------------
Slider::~Slider(void)
{
}
//---------------------------------------
void Slider::draw(void)
{
    if(myElementIsVisible==false)
        return;


    ps=myScreen->getPicasoSerial();

    if(ps!=0) {
        ps->draw_slider(0x0000,myX,myY,myX+myWidth,myY+myHeight,myColor,myValueMax,myValue);
    }

}
//--------------------------------------
void Slider::setInvisible(bool _state)
{
    // element devient invisible
    if(_state==true) {
        if(myElementIsVisible==false)
            return;

        myElementIsVisible=false;

        Color c= myScreen->getColorBkg();

        ps=myScreen->getPicasoSerial();

        if(ps!=0) {
            ps->draw_filled_rectangle(myX,myY,myX+myWidth,myY+myHeight,c);
        }
    }

    // element devient visible
    else {
        myElementIsVisible=true;


        this->draw();
    }
}
//-------------------------------------
int Slider::getValue(GraphicMessage* pmsg)
{
    TouchEvent msgEvent=pmsg->event;

    UINT16 xn=pmsg->posiX;


    if(myElementIsVisible==false)
        return 0;
    //

    if(msgEvent==EVENT_RELEASE) {
        myElementState=SLIDER_STATE_RELEASED;
    }
    //
    if(msgEvent==EVENT_MOVE) {
        myElementState=SLIDER_STATE_MOVE;
        UINT16 dis=xn-myX;
        UINT16 a=dis*myValueMax;
        myValue=(a/myWidth);

        this->draw();
    }
    return myValue;
}
//-------------------------------------
Input::Input(Screen* mScreen,UINT16 _id,UINT16 _x,UINT16 _y,UINT16 _width,UINT16 _height,float _valMin,float _valInc,
             float _valMax,bool _isVisible):ObjetHeader(mScreen,_id,_x,_y,_width,_height,WHITE,_isVisible)
{
    myValMin=_valMin;
    myValInc=_valInc;
    myValMax=_valMax;
    myValue=0.0;
    myColorBkg=WHITE;
    myColorCursorUp=BLUE;
    myColorCursorDown=BLUE;

    myElementType=OBJ_INPUT;
    myElementState=INPUT_STATE_RELEASED;

    myScreen->addObj((ObjetHeader*) this);
}
//-------------------------------------
Input::~Input(void)
{
}
//-------------------------------------
void Input::setColorBkg(Color _color)
{
    myColorBkg=_color;
    this->draw();
}
//--------------------------------------
void Input::setColorCursorUp(Color _color)
{
    myColorCursorUp=_color;
    this->draw();
}
//-------------------------------------
void Input::setColorCursorDown(Color _color)
{
    myColorCursorDown=_color;
    this->draw();
}
//-------------------------------------
void Input::draw(void)
{
    if(myElementIsVisible==false)
        return;
    //
    ps=myScreen->getPicasoSerial();

    //rect up
    if(ps!=0)
        ps->draw_filled_rectangle(myX,myY,myX+myWidth,myY+myHeight/2,myColorBkg);

    //rect down
    if(ps!=0)
        ps->draw_filled_rectangle(myX,myY+myHeight/2+3,myX+myWidth,myY+3+myHeight,myColorBkg);

    //fleche up
    UINT16 x1=myX+myWidth/2;
    UINT16 y1=myY;

    UINT16 x2=myX+myWidth;
    UINT16 y2=myY+myHeight/2;

    UINT16 x3=myX;
    UINT16 y3=myY+myHeight/2;
    if(ps!=0)
        ps->draw_filled_triangle(x1,y1,x2,y2,x3,y3, myColorCursorUp);

    //fleche down
    x1=myX;
    y1=myY+3+myHeight/2;

    x2=myX+myWidth;
    y2=y1;

    x3=myX+myWidth/2;
    y3=y2+myHeight/2;
    if(ps!=0)
        ps->draw_filled_triangle(x1,y1,x2,y2,x3,y3, myColorCursorDown);

    //cadre
    if(ps!=0)
        ps->draw_rectangle(myX,myY,myX+myWidth,myY+myHeight+3,BLACK);

}
//-------------------------------------
void Input::setInvisible(bool _state)
{
    // element devient invisible
    if(_state==true) {
        if(myElementIsVisible==false)
            return;

        myElementIsVisible=false;

        Color c= myScreen->getColorBkg();

        ps=myScreen->getPicasoSerial();

        if(ps!=0) {
            ps->draw_filled_rectangle(myX,myY,myX+myWidth,myY+myHeight+3,c);
        }
    }

    // element devient visible
    else {
        myElementIsVisible=true;


        this->draw();
    }
}
//--------------------------------------
float Input::getValue(GraphicMessage* msg)
{
    if(myElementIsVisible==false)
        return 0.0;
    float val=0.0;
    //
    TouchEvent ev=msg->event;
    UINT16 yn=msg->posiY;

    UINT16 y0=myY;
    UINT16 ybut1=y0+myHeight/2;
    UINT16 ybut2=y0+myHeight;
    Color couleurUp=myColorCursorUp;
    Color couleurDown=myColorCursorDown;

    if(ev==EVENT_PRESS && myElementState==INPUT_STATE_RELEASED) {
        //up ?
        if(yn >= y0 && yn <= ybut1) {
            myElementState=INPUT_STATE_PRESSED_UP;
            setColorCursorUp(WHITE);
            wait(0.1);
            setColorCursorUp(couleurUp);

            val=myValue+myValInc;
            if(val >myValMax)
                val=myValMax;

            myValue=val;
        }
        //
        //down?
        if(yn >= ybut1 && yn <= ybut2) {
            myElementState=INPUT_STATE_PRESSED_DOWN;
            setColorCursorDown(WHITE);
            wait(0.1);
            setColorCursorDown(couleurDown);

            val=myValue-myValInc;
            if(val <myValMin)
                val=myValMin;

            myValue=val;
        }
    }
    //
    if(ev==EVENT_RELEASE || ev==EVENT_MOVE) {
        myElementState=INPUT_STATE_RELEASED;
    }

    return myValue;
}
//--------------------------------------
Switch::Switch(Screen* mScreen,UINT16 _id,UINT16 _x,UINT16 _y,UINT16 _width,UINT16 _height,
               bool _isVisible):ObjetHeader(mScreen,_id,_x,_y,_width,_height,WHITE,_isVisible)
{
    myColorOn=GREEN;
    myColorOff=RED;
    myColorCursor=WHITE;

    myElementType=OBJ_SWITCH;
    myElementState=SWITCH_STATE_OFF;

    myScreen->addObj((ObjetHeader*) this);
}
//---------------------------------------
Switch::~Switch(void)
{
}
//---------------------------------------
void Switch::draw(void)
{
    if(myElementIsVisible==false)
        return;
    //
    ps=myScreen->getPicasoSerial();

    State state=myElementState;

    Color gauche=WHITE;
    Color droite=WHITE;

    switch(state) {
            //
        case SWITCH_STATE_ON:
            droite=myColorOn;
            gauche=myColorCursor;
            break;

            //
        case SWITCH_STATE_OFF:
            droite=myColorCursor;
            gauche=myColorOff;
            break;

            //
        default:
            break;
    }
    //

    //rect gauche
    if(ps!=0)
        ps->draw_filled_rectangle(myX,myY,myX+myWidth/2,myY+myHeight,gauche);

    //rect droite
    if(ps!=0)
        ps->draw_filled_rectangle(myX+myWidth/2,myY,myX+myWidth,myY+myHeight,droite);

    //cadre
    if(ps!=0) {
        ps->draw_rectangle(myX,myY,myX+myWidth,myY+myHeight,BLACK);
        ps->draw_rectangle(myX,myY,myX+myWidth/2,myY+myHeight,BLACK);

    }

}
//----------------------------------------
void Switch::setInvisible(bool _state)
{
    // element devient invisible
    if(_state==true) {
        if(myElementIsVisible==false)
            return;

        myElementIsVisible=false;

        Color c= myScreen->getColorBkg();

        ps=myScreen->getPicasoSerial();

        if(ps!=0) {
            ps->draw_filled_rectangle(myX,myY,myX+myWidth,myY+myHeight,c);
        }
    }

    // element devient visible
    else {
        myElementIsVisible=true;


        this->draw();
    }
}
//-----------------------------------------
void Switch::setState(State _state)
{
    if(myElementIsVisible==false)
        return;

    if(myElementState==_state)
        return;

    myElementState=_state;

    this->draw();
}
//-----------------------------------------
void Switch::changeState(GraphicMessage* msg)
{
    TouchEvent ev=msg->event;

    if(myElementIsVisible==false)
        return;

    if(ev==EVENT_PRESS && myElementState==SWITCH_STATE_OFF) {
        this->setState(SWITCH_STATE_ON);
        return;
    }
    //
    if(ev==EVENT_PRESS && myElementState==SWITCH_STATE_ON) {
        this->setState(SWITCH_STATE_OFF);
        return;
    }
    //
    if(ev==EVENT_MOVE || ev==EVENT_RELEASE)
        return;
}
//----------------------------------------
DigitLed::DigitLed(Screen* mScreen,UINT16 _id,UINT16 _x,UINT16 _y,bool _ptVisible,
                   bool _isVisible):ObjetHeader(mScreen,_id,_x,_y,36,52,WHITE,_isVisible)
{
    myValue=0;
    myColorBkg=YELLOW;
    myColorSeg=RED;
    myIncX=4;
    myIncY=4;

    isPtVisible=_ptVisible;

    myElementType=OBJ_DIGIT_LED;
    myElementState=DIGIT_LED_STATE_ON;

    myScreen->addObj((ObjetHeader*) this);
}
//-----------------------------------------
DigitLed::~DigitLed(void)
{
}
//-----------------------------------------
void DigitLed::setColorBkg(Color _colorBkg)
{
    if(myColorBkg==_colorBkg)
        return;

    myColorBkg=_colorBkg;
    this->draw();
}
//------------------------------------------
void DigitLed::setColorSeg(Color _colorSeg)
{
    if(myColorSeg==_colorSeg)
        return;

    myColorSeg=_colorSeg;
    this->draw();
}
//-----------------------------------------
void DigitLed::draw(void)
{
    if(myElementIsVisible==false)
        return;
    //
    ps=myScreen->getPicasoSerial();

    //rec
    if(ps!=0) {
        ps->draw_filled_rectangle(myX,myY,myX+myWidth,myY+myHeight,myColorBkg);
    }

    if(isPtVisible)
        draw_seg_pt(ps);

    //
    switch(myValue) {
        case 0:
            draw_seg_a(ps);
            draw_seg_b(ps);
            draw_seg_c(ps);
            draw_seg_d(ps);
            draw_seg_e(ps);
            draw_seg_f(ps);
            break;
            //
        case 1:
            draw_seg_b(ps);
            draw_seg_c(ps);
            break;
            //
        case 2:
            draw_seg_a(ps);
            draw_seg_b(ps);
            draw_seg_d(ps);
            draw_seg_e(ps);
            draw_seg_g(ps);
            break;
            //
        case 3:
            draw_seg_a(ps);
            draw_seg_b(ps);
            draw_seg_c(ps);
            draw_seg_d(ps);
            draw_seg_g(ps);
            break;
            //
        case 4:
            draw_seg_b(ps);
            draw_seg_c(ps);
            draw_seg_f(ps);
            draw_seg_g(ps);
            break;
            //
        case 5:
            draw_seg_a(ps);
            draw_seg_c(ps);
            draw_seg_d(ps);
            draw_seg_f(ps);
            draw_seg_g(ps);
            break;
            //
        case 6:
            draw_seg_a(ps);
            draw_seg_c(ps);
            draw_seg_d(ps);
            draw_seg_e(ps);
            draw_seg_f(ps);
            draw_seg_g(ps);
            break;
            //
        case 7:
            draw_seg_a(ps);
            draw_seg_b(ps);
            draw_seg_c(ps);
            break;
            //
        case 8:
            draw_seg_a(ps);
            draw_seg_b(ps);
            draw_seg_c(ps);
            draw_seg_d(ps);
            draw_seg_e(ps);
            draw_seg_f(ps);
            draw_seg_g(ps);
            break;
            //
        case 9:
            draw_seg_a(ps);
            draw_seg_b(ps);
            draw_seg_c(ps);
            draw_seg_d(ps);
            draw_seg_f(ps);
            draw_seg_g(ps);
            break;
    }

}
//-----------------------------------------
void DigitLed::setValue(char _value)
{
    if(myElementIsVisible==false)
        return;

    if(myValue==_value)
        return;


    if(_value >9)
        _value=9;

    myValue=_value;

    this->draw();
}
//-----------------------------------------
void DigitLed::setInvisible(bool _state)
{
    // element devient invisible
    if(_state==true) {
        if(myElementIsVisible==false)
            return;

        myElementIsVisible=false;

        Color c= myScreen->getColorBkg();

        ps=myScreen->getPicasoSerial();

        if(ps!=0) {
            ps->draw_filled_rectangle(myX,myY,myX+myWidth,myY+myHeight,c);
        }
    }

    // element devient visible
    else {
        myElementIsVisible=true;


        this->draw();
    }
}
//-----------------------------------------
void DigitLed::setPtVisible(bool _state)
{
    if(isPtVisible==_state)
        return;

    isPtVisible=_state;
}
//-----------------------------------------
void DigitLed::draw_seg_a(PicasoSerial* ps)
{
    if(ps!=0)
        ps->draw_filled_rectangle(myX+myIncX,
                                  myY,
                                  myX+7*myIncX,
                                  myY+myIncY,
                                  myColorSeg);
}
//------------------------------------------
void DigitLed::draw_seg_b(PicasoSerial* ps)
{
    if(ps!=0)
        ps->draw_filled_rectangle(myX+6*myIncX,
                                  myY,
                                  myX+7*myIncX,
                                  myY+5*myIncY,
                                  myColorSeg);
}
//-------------------------------------------
void DigitLed::draw_seg_c(PicasoSerial* ps)
{
    if(ps!=0)
        ps->draw_filled_rectangle(myX+6*myIncX,
                                  myY+8*myIncY,
                                  myX+7*myIncX,
                                  myY+myHeight,
                                  myColorSeg);
}
//--------------------------------------------
void DigitLed::draw_seg_d(PicasoSerial* ps)
{
    if(ps!=0)
        ps->draw_filled_rectangle(myX+myIncX,
                                  myY+myHeight-myIncY,
                                  myX+7*myIncX,
                                  myY+myHeight,
                                  myColorSeg);
}
//-----------------------------------------
void DigitLed::draw_seg_e(PicasoSerial* ps)
{
    if(ps!=0)
        ps->draw_filled_rectangle(myX+myIncX,
                                  myY+myHeight-5*myIncY,
                                  myX+2*myIncX,
                                  myY+myHeight,
                                  myColorSeg);
}
//-----------------------------------------
void DigitLed::draw_seg_f(PicasoSerial* ps)
{
    if(ps!=0)
        ps->draw_filled_rectangle(myX+myIncX,
                                  myY,
                                  myX+2*myIncX,
                                  myY+5*myIncY,
                                  myColorSeg);
}
//------------------------------------------
void DigitLed::draw_seg_g(PicasoSerial* ps)
{
    if(ps!=0)
        ps->draw_filled_rectangle(myX+myIncX,
                                  myY+6*myIncY,
                                  myX+7*myIncX,
                                  myY+7*myIncY,
                                  myColorSeg);
}
//------------------------------------------
void DigitLed::draw_seg_pt(PicasoSerial* ps)
{
    if(ps!=0)
        ps->draw_filled_rectangle(myX+myWidth-myIncX,
                                  myY+myHeight-myIncY,
                                  myX+myWidth,
                                  myY+myHeight,
                                  myColorSeg);
}
//-------------------------------------------
Digit3Led::Digit3Led(Screen* mScreen,UINT16 _id,UINT16 _x,UINT16 _y,
                     UINT8 _resolution,bool _isVisible):ObjetHeader(mScreen,_id,_x,_y,108,52,YELLOW,_isVisible)
{
    myColorBkg=YELLOW;
    myColorSeg=RED;
    myValue=0.0;
    myResolution=_resolution;

    myDigitLedCentaine= new DigitLed(mScreen,_id,_x,_y,false,true);
    myDigitLedDizaine=new DigitLed(mScreen,_id,_x+36,_y,false,true);
    myDigitLedUnite= new DigitLed(mScreen,_id,_x+36+36,_y,false,true);


    myElementType= OBJ_DIGITAL_3_LED;
    myElementState=DIGIT_LED_STATE_ON;

    myScreen->addObj((ObjetHeader*) this);
}
//------------------------------------------
Digit3Led::~Digit3Led(void)
{
    delete(myDigitLedCentaine);
    myDigitLedCentaine=0;
    delete(myDigitLedDizaine);
    myDigitLedDizaine=0;
    delete(myDigitLedUnite);
    myDigitLedUnite=0;
}
//------------------------------------------
void Digit3Led::draw(void)
{
    if(myElementIsVisible==false)
        return;

    myDigitLedCentaine->draw();
    myDigitLedDizaine->draw();
    myDigitLedUnite->draw();

}
//------------------------------------------
void Digit3Led::setInvisible(bool _state)
{
    // element devient invisible
    if(_state==true) {
        if(myElementIsVisible==false)
            return;

        myElementIsVisible=false;

        Color c= myScreen->getColorBkg();

        ps=myScreen->getPicasoSerial();

        if(ps!=0) {
            ps->draw_filled_rectangle(myX,myY,myX+myWidth,myY+myHeight,c);
        }
    }

    // element devient visible
    else {
        myElementIsVisible=true;


        this->draw();
    }
}
//-----------------------------------------
void Digit3Led::setValue(float _value)
{
    if(myElementIsVisible==false)
        return;
    //
    if(myValue==_value)
        return;
    //
    myValue=_value;
    UINT16 temp=0;

    char centaine=0;
    char dizaine=0;
    char unite=0;

    //the Pt?
    switch(myResolution) {
        case 1:     //xxx
            temp=(UINT16)_value;
            myDigitLedCentaine->setPtVisible(false);
            myDigitLedDizaine->setPtVisible(false);
            myDigitLedUnite->setPtVisible(false);
            break;
            //
        case 10:    //xx.x
            temp=(UINT16)(_value*10);
            myDigitLedCentaine->setPtVisible(false);
            myDigitLedDizaine->setPtVisible(true);
            myDigitLedUnite->setPtVisible(false);
            break;
            //
        case 100:   //x.xx
            temp=(UINT16)(_value*100);
            myDigitLedCentaine->setPtVisible(true);
            myDigitLedDizaine->setPtVisible(false);
            myDigitLedUnite->setPtVisible(false);
            break;

        default:
            break;
    }
    //
    if(temp <100) {
        centaine=0;
        myDigitLedCentaine->setInvisible(true);
    } else {
        myDigitLedCentaine->setInvisible(false);
        centaine=(char)(temp/100);
        temp=temp-(centaine*100);
    }
    //
    if(temp <10) {
        dizaine=0;
    } else {
        dizaine=(char)(temp/10);
        temp=temp-(dizaine*10);
    }
    //
    unite=(char)temp;

    myDigitLedCentaine->setValue(centaine);
    myDigitLedDizaine->setValue(dizaine);
    myDigitLedUnite->setValue(unite);

    this->draw();
}
//------------------------------------------
void Digit3Led::setColorBkg(Color _colorBkg)
{
    if(myColorBkg==_colorBkg)
        return;

    myColorBkg=_colorBkg;
    myDigitLedCentaine->setColorBkg(_colorBkg);
    myDigitLedDizaine->setColorBkg(_colorBkg);
    myDigitLedUnite->setColorBkg(_colorBkg);

    this->draw();
}
//------------------------------------------
void Digit3Led::setColorSeg(Color _colorSeg)
{
    if(myColorSeg==_colorSeg)
        return;

    myColorSeg=_colorSeg;
    myDigitLedCentaine->setColorSeg(_colorSeg);
    myDigitLedDizaine->setColorSeg(_colorSeg);
    myDigitLedUnite->setColorSeg(_colorSeg);

    this->draw();
}
//-----------------------------------------