chart.cpp

Go to the documentation of this file.

//----------------------------------------------------------------
#ifdef __GNUG__
    #pragma implementation "chart.h"
#endif

#ifdef __BORLANDC__
        #pragma hdrstop
#endif

//-------------------------------------------------------------------
#include "wx/wxprec.h"
#ifndef WX_PRECOMP
        #include "wx/wx.h"
#endif


#include "chart.h"
#include <math.h>

//----------------------------------------------------------------
// DataSet : Constructor & Destructor
//-------------------------------------------------------------------
wxDataSet::wxDataSet(wxPen *lStyle, wxBrush *dStyle, int dWidth,
                     int lWidth, int dGap, int pMark, int disValues)
{
   m_lineStyle = lStyle;
   m_dataStyle = dStyle;
   m_dataWidth = dWidth;
   m_lineWidth = lWidth;
   m_pointMark = pMark;
   m_displayValues = disValues;
   m_display = false;
   m_rowsList = NULL;
   m_text = NULL;
}

wxDataSet::wxDataSet(wxPen *lStyle, wxBrush *dStyle,
             wxString *lText, bool lDisplay)
{
   m_lineStyle = lStyle;
   m_dataStyle = dStyle;
   m_display = lDisplay;
   m_text = lText;
   m_rowsList = NULL;
   m_dataWidth = 0;
   m_lineWidth = 0;
   m_pointMark = 0;
   m_displayValues = 0;
}



wxDataSet::wxDataSet()
{
   m_lineStyle = NULL;
   m_dataStyle = NULL;
   m_dataWidth = 0;
   m_lineWidth = 0;
   m_pointMark = 0;
   m_displayValues = 0;
   m_display = false;
   m_rowsList = NULL;
   m_text = NULL;
}


wxDataSet::~wxDataSet()
{
  // Nothing
}




//-----------------------------------------------------------------
// Chart
//-------------------------------------------------------------------
BEGIN_EVENT_TABLE(wxChart, wxWindow)
  EVT_PAINT(wxChart::OnPaint)
END_EVENT_TABLE()

//---------------------------------------------------------------------
// Constructor & Destructor
wxChart::wxChart(wxFrame *parent, wxWindowID id,
                const wxPoint& pos, const wxSize& size,
                long  style, const wxString& name)
 : wxWindow(parent, id, pos, size, style, name)
{

    SetMaxWidthHeight(size.GetWidth(), size.GetHeight());
        SetCenterChart(pos.x + (GetLargeur()/2), pos.y + (GetHauteur()/2));

    InitDataSet();

    InitChart();
}



wxChart::~wxChart()
{
  // nothing
}



void  wxChart::InitChart()
{
    SetShowPer(false); //not display line % per default

    for(int i=0; i<m_NumDataSet ; i++)
                ShowDataSet(false, i);

        InitData();
}



// Static Function
//--------------------------------------------------------------
static double st_difference(double val, int multi, bool sens=true)
{
    double retour=0;
    div_t result;

        result = div(int(val), multi);
        // multiple sup
        if ( sens )
        {
       if ( val > 1)
           {
          if ( result.rem == 0 )
          {
             if (val - (int)val > 0 )
                 retour =  (multi - result.rem) - (val - int(val));
                  }
          else
                  {
              retour =  (multi - result.rem) - (val - int(val));
                  }
           }
        }
    // multiple inf
        else
                retour = result.rem + (val - (int)val);

        return retour;
}

static double st_decalage(double IncX, double MinX)
{
  double retour = 0.00;
  div_t result;

  if (IncX >= 1)
  {
     result = div(MinX, IncX);
     if ( result.rem == 0 )
     {
        if (MinX - (int)MinX > 0 )
           retour = ((result.quot + 1) * IncX) - MinX;
         }
         else
         {
        retour = ((result.quot+1) * IncX) - MinX;
         }
  }
  return retour;
}


static double st_origine(double IncX, double MinX)
{
   double retour = MinX;
   div_t result;

   if (IncX >=1)
   {
      result = div(MinX, IncX);
          if (result.rem == 0)
      {
                  if (MinX - (int)MinX > 0 )
                          retour = (result.quot + 1) * IncX;
      }
      else
          {
          retour = (result.quot + 1) * IncX;
          }
   }
   return retour;
}


static void st_InverseCol(double *l_MinCol, double  *l_MaxCol)
{
   if  (*l_MinCol > *l_MaxCol)
   {
     int tempo = *l_MaxCol;
         *l_MaxCol = *l_MinCol;
         *l_MinCol = tempo;
   }

}


//--------------------------------------------------------------
void wxChart::SetInfX(double inf)
{
   m_InfX = inf;
}

void wxChart::SetSupX(double sup)
{
   m_SupX = sup;
}


void wxChart::SetSupY(double sup)
{
   m_SupY = sup;
}



void wxChart::SetIncAxisX(double minor, double major)
{
    m_MinorIncX = minor;
    m_MajorIncX = major;
}

void wxChart::SetIncAxisY(double minor, double major)
{
    m_MinorIncY = minor;
    m_MajorIncY = major;
}


void wxChart::SetInitEdge()
{
   SetEdgeTop(15);
   SetEdgeBottom(35);
   SetEdgeLeft(37);
   SetEdgeRight(15);
}



void wxChart::SetChartBounds()
{
   m_Top = m_CenterY - (m_MaxHauteur/2) + m_EdgeTop;
   m_Bottom = m_CenterY + (m_MaxHauteur/2) - m_EdgeBottom;
   m_Left = m_CenterX - (m_MaxLargeur/2) + m_EdgeLeft;
   m_Right = m_CenterX + (m_MaxLargeur/2) - m_EdgeRight;

}

void wxChart::SetChartBoundsLegend()
{
   m_TopLegend = m_CenterY - (m_MaxHauteur/2) + m_EdgeTopLegend;
   m_BottomLegend = m_CenterY + (m_MaxHauteur/2) - m_EdgeBottomLegend;
   m_LeftLegend = m_CenterX - (m_MaxLargeur/2) + m_EdgeLeftLegend;
   m_RightLegend = m_CenterX + (m_MaxLargeur/2) - m_EdgeRightLegend;
}


void wxChart::SetCadreLegend(int nbr, int *bottom)
{
    int val=GetEdgeBottom();
        div_t result = div(nbr, 2);

        if (result.rem == 0)
        val+= (nbr * 10) + 5;
    else
                val+= (( nbr + 1 ) * 10) + 5;

    *bottom = val;

    SetEdgeTopLegend(m_CenterY + (m_MaxHauteur/2) - val + 33);
    SetEdgeBottomLegend(8);

        int l_left = GetEdgeLeft();
        int l_right = GetEdgeRight();

        // more small for only 1 line
        if (nbr == 1)
        {
       l_left+=m_CenterX - (m_MaxLargeur/3);
       l_right+=m_CenterX - (m_MaxLargeur/3);
        }

        SetEdgeLeftLegend(l_left);
    SetEdgeRightLegend(l_right);
}



void wxChart::SetShowPer(bool per)
{
  m_ShowPer = per;

}


void  wxChart::SetMaxValue(double max)
{
   // Axe Y
   m_MaxValue = max;
}




double wxChart::MaxValue()
{
   double data, val = 1.00;
   int maxdata = GetNumDataSet()-1;
   int maxitem = GetNumItem();

   // Exclure Stenosis for calcul MaxValue
   for(int a=0; a < maxdata; a++)
   {
      if (GetShowDataSet(a))
          {
                for(int j=0; j<=maxitem; j++)
                {
           if ( IsEmpty(a,j) == false )
                   {
             data = GetDataY(a,j);
                 if (data > val)
               val = data;
                   }
                }
          }
   }
   return val;
}



double wxChart::MinCol(double min)
{
    double retour = 0.00;
        int maxdata = GetNumDataSet()-1;

        // Exclure Stenosis for calcul MaxValue
        for(int a=0; a < maxdata; a++)
    {
      if (GetShowDataSet(a))
          {
             if (min > retour)
                         retour = min;
                 a = maxdata - 1;
          }
        }

    return retour;
}


double wxChart::MaxCol(double max)
{
    double retour = 1.00;
        int maxdata = GetNumDataSet()-1;

        // Exclure Stenosis for calcul MaxValue
        for(int a=0; a < maxdata; a++)
    {
      if (GetShowDataSet(a))
          {
             if (max > retour)
                         retour = max;
                 a = maxdata - 1;
          }
        }

    return retour;
}



void  wxChart::SetStepSizeX(double stepX)
{
        m_StepSizeX = stepX;
}

void  wxChart::SetStepSizeY(double stepY)
{
        m_StepSizeY = stepY;
}


void  wxChart::SetStepSizePer(double stepPer)
{
        m_StepSizePer = stepPer;
}


void   wxChart::SetCenterChart(int x, int y)
{
   m_CenterX = x;
   m_CenterY = y;
}

void wxChart::SetMaxWidthHeight(int x,int y)
{
   m_MaxLargeur = x;
   m_MaxHauteur = y;
}


void wxChart::SetMinX(double MinX)
{
   m_MinX = MinX;
}


void wxChart::SetMaxX(double MaxX)
{
   m_MaxX = MaxX;
}



void wxChart::SetEdgeTop(int top)
{
  m_EdgeTop = top;
}

void wxChart::SetEdgeBottom(int bottom)
{
  m_EdgeBottom = bottom;
}

void wxChart::SetEdgeLeft(int left)
{
  m_EdgeLeft = left;
}

void wxChart::SetEdgeRight(int right)
{
  m_EdgeRight = right;
}


void  wxChart::SetEdgeTopLegend(int top)
{
        m_EdgeTopLegend = top;
}

void  wxChart::SetEdgeBottomLegend(int bottom)
{
        m_EdgeBottomLegend = bottom;
}

void  wxChart::SetEdgeLeftLegend(int left)
{
        m_EdgeLeftLegend = left;
}


void  wxChart::SetEdgeRightLegend(int right)
{
        m_EdgeRightLegend = right;
}



void   wxChart::SetNumDataSet(int num)
{
        m_NumDataSet = num;
}

void   wxChart::SetNumItem(int num)
{
        m_NumItem = num;
}


int  wxChart::GetShow()
{
   int retour = 0;

   for(int i=0; i < m_NumDataSet ; i++)
   {
           if (GetShowDataSet(i))
          retour++;
   }
   return retour;
}


void wxChart::InitDataSet()
{

        // Initialization
        SetNumDataSet(8);
        for(int i=0; i<MAX_DATASET ; i++)
                m_dataSetArray[i]=NULL;

    // Colour
        wxColour *BlueColour       = new wxColour(0,0,255);
        wxColour *GreyColour       = new wxColour(192,192,192);
        wxColour *YellowColour     = new wxColour(255,255,0);
    wxColour *VioletColour     = new wxColour(255,0,255);
    wxColour *CyanColour       = new wxColour(0,255,255);


        // Create All DataSet
        // Per default : Show(false)
        m_dataSetArray[wxArea] =
          new wxDataSet(wxRED_PEN, wxRED_BRUSH, (wxString*)"Area");

        m_dataSetArray[wxPerimeter] =
          new wxDataSet(new wxPen(*BlueColour, 1, wxSOLID),
                            new wxBrush(*BlueColour, wxSOLID),
                                        (wxString*)"Perimeter");

        m_dataSetArray[wxDiameterArea] =
          new wxDataSet(new wxPen(*GreyColour, 1, wxSOLID),
                        new wxBrush(*GreyColour, wxSOLID),
                    (wxString*)"Diameter from area");

        m_dataSetArray[wxDiameterPerimeter] =
          new wxDataSet(new wxPen(*YellowColour, 1, wxSOLID),
                            new wxBrush(*YellowColour, wxSOLID),
                                (wxString*)"Diameter from perimeter");

        m_dataSetArray[wxMinimumDiameter] =
          new wxDataSet(new wxPen(*VioletColour, 1, wxSOLID),
                        new wxBrush(*VioletColour, wxSOLID),
                        (wxString*)"Minimum diameter");

        m_dataSetArray[wxMaximumDiameter] =
          new wxDataSet(new wxPen(*CyanColour, 1, wxSOLID),
                            new wxBrush(*CyanColour, wxSOLID),
                        (wxString*)"Maximum diameter");

        m_dataSetArray[wxAverageDiameter] =
          new wxDataSet(wxBLACK_PEN, wxBLACK_BRUSH, (wxString*)"Average diameter");

        m_dataSetArray[wxStenosis] =
          new wxDataSet(wxGREEN_PEN, wxGREEN_BRUSH, (wxString*)"Stenosis");

}


// Paint
//---------------------------------------------------------------------
void wxChart::OnPaint(wxPaintEvent& event)
{
    wxPaintDC dc(this);
        Draw(dc);
}



void wxChart::Draw(wxDC& dc)
{
   wxBrush  *dataBrush;
   wxPen    *dataPen;

   //----------------------------------------------------------------------------
   // Begin
   dc.BeginDrawing();
   dc.Clear();


   //----------------------------------------------------------------------------
   // Font : one for all chart
   dc.SetFont(*(new wxFont(1, wxDEFAULT, wxNORMAL, wxLIGHT)));

   //----------------------------------------------------------------------------
   // Dimension
   wxSize size = GetClientSize();
   SetMaxWidthHeight(size.GetWidth(), size.GetHeight());
   SetCenterChart((GetLargeur()/2), (GetHauteur()/2));
   SetInitEdge();

   //-----------------------------------------------------------------------------
   // Show Line
   ShowDataSet(true,wxArea);
   ShowDataSet(true,wxPerimeter);
   ShowDataSet(true,wxDiameterArea);
   ShowDataSet(false,wxDiameterPerimeter);
   ShowDataSet(false,wxMinimumDiameter);
   ShowDataSet(false,wxMaximumDiameter);
   ShowDataSet(false,wxAverageDiameter);
   ShowDataSet(false,wxStenosis);

   m_ShowPer = true;

   // Show Axe %
   if (m_ShowPer)
   {
           SetEdgeRight(45);
           ShowDataSet(true,wxStenosis);
   }


   //--------------------------------------------------------------------
   // Legend
   int nbr = GetShow();
   if (nbr > 0)
   {
          SetCadreLegend(nbr, &m_EdgeBottom);
      SetChartBoundsLegend();
      DrawLegend(dc, nbr);
   }

   //-------------------------------------------------------------------
   // Valeur Min et Max des abscisses
   SetMinX(MinCol(0));
   SetMaxX(MaxCol(1));
   SetInfX(st_difference(m_MinX,10,false));
   SetSupX(st_difference(m_MaxX,10,true));

   //------------------------------------------------------------------
   // Data
   // Stenosis
   SetNumItem(6);
   SetData(wxStenosis, 0,   0,  -45);
   SetData(wxStenosis, 1, 0.4,    0);
   SetData(wxStenosis, 2, 0.6,  -15);
   SetData(wxStenosis, 3, 0.8,    0);
   SetData(wxStenosis, 4, 0.9,  100);
   SetData(wxStenosis, 5,   1,    0);

   // Area
   SetData(wxArea,0,   0, 0.8);
   SetData(wxArea,1, 0.2, 0.6);
   SetData(wxArea,2, 0.3, 0.8);
   SetData(wxArea,3, 0.4,   1);
   SetData(wxArea,4, 0.8, 0.4);
   SetData(wxArea,5,   1, 0.2);

   //-----------------------------------------------------------------
   // Valeur Max du chart
   SetMaxValue(MaxValue());
   SetSupY(st_difference(m_MaxValue, 10, true));

   //-------------------------------------------------------------------------------
   // Scale
   SetIncAxisX((m_MaxX + m_SupX  -  (m_MinX - m_InfX)) / (double)MINOR_STEP,
                   (m_MaxX + m_SupX  -  (m_MinX - m_InfX)) / (double)MAJOR_STEP);
   SetIncAxisY((m_MaxValue + m_SupY) / (double)MINOR_STEP,
                   (m_MaxValue + m_SupY) / (double)MAJOR_STEP);

   SetStepSizeX(( m_MaxLargeur - (m_EdgeLeft + m_EdgeRight + m_SupX + m_InfX)) /
                    (m_MaxX - m_MinX));
   SetStepSizeY(( m_MaxHauteur - (m_EdgeBottom + m_EdgeTop + m_SupY )) /
                    (m_MaxValue));
   SetStepSizePer(( m_MaxHauteur - (m_EdgeBottom + m_EdgeTop)) /
                    (double)MAX_PER);


   //-----------------------------------------------------------------------------
   // Empty Chart
   //---------------------------------------------------------------------------
   SetChartBounds();
   DrawGrille(dc);
   DrawAxe(dc);
   if (m_ShowPer)
           DrawAxePer(dc);

   //-----------------------------------------------------------------------------
   // Clipping
   //---------------------------------------------------------------------------
   dc.DestroyClippingRegion();
   dc.SetClippingRegion(m_Left , m_Top ,
                            GetLargeur() - (m_EdgeRight + m_EdgeLeft   ),
                                                GetHauteur() - (m_EdgeTop   + m_EdgeBottom ));

   //---------------------------------------------------------------------------
   // Draw line
   //---------------------------------------------------------------------------
   int maxdataset = GetNumDataSet();
   for(int a=0; a < maxdataset; a++)
   {
           if(m_dataSetArray[a] && m_dataSetArray[a]->GetShow())
       {
         dataBrush = m_dataSetArray[a]->GetDataStyle();
         dataPen = m_dataSetArray[a]->GetLineStyle();
                 dc.SetBrush(*dataBrush);
         dc.SetPen(*dataPen);
                 DrawLine(dc, a);
           }
   }

   //---------------------------------------
   // end
   dc.DestroyClippingRegion();
   dc.EndDrawing();
}



void wxChart::DrawAxe(wxDC& dc)
{
   double x,y;
   double val, supx;
   char text[20];
   int widthx,heighty;

   double minorIncStepY= m_MinorIncY * m_StepSizeY;
   double majorIncStepY= m_MajorIncY * m_StepSizeY;

   double minorIncStepX= m_MinorIncX * m_StepSizeX;
   double majorIncStepX= m_MajorIncX * m_StepSizeX;

   dc.SetPen(*wxBLACK_PEN);
   dc.SetBrush(*wxBLACK_BRUSH);

   // Axe X
   dc.DrawLine(m_Left, m_Bottom+(7*MARGE/4), m_Right, m_Bottom+(7*MARGE/4));
   // Axe Y
   dc.DrawLine(m_Left-(7*MARGE/4), m_Bottom, m_Left-(7*MARGE/4), m_Top);

   // AXE Y
   // Major Tick Marks with values
   val=0.00;
   for(x=m_Left,y=m_Bottom; y >= m_Top; y-=majorIncStepY, val+=m_MajorIncY)
   {
      dc.DrawLine(m_Left-7-(7*MARGE/4),y,m_Left-(7*MARGE/4),y);
          sprintf(text,"%g", val);
      dc.GetTextExtent(text,&widthx,&heighty);
      dc.DrawText(text,m_Left-10-widthx-(7*MARGE/4),y-(heighty/2));
   }
   // Ne pas Depasser
   if (m_SupY == 0 )
   {
      dc.DrawLine(m_Left-7-(7*MARGE/4),m_Top,m_Left-(7*MARGE/4),m_Top);
      sprintf(text,"%g", val);
      dc.GetTextExtent(text,&widthx,&heighty);
      dc.DrawText(text,m_Left-10-widthx-(7*MARGE/4),m_Top-(heighty/2));
   }

   // Minor Tick Marks
   for(x=m_Left,y=m_Bottom; y >= m_Top; y-=minorIncStepY)
   {
          dc.DrawLine(m_Left-3-(7*MARGE/4),y,m_Left-(7*MARGE/4),y);
   }

   // AXE X
   // Major Tick Marks with values
   supx = st_decalage(m_MajorIncX, m_MinX) * m_StepSizeX;
   val = st_origine(m_MajorIncX, m_MinX);
   for(y=m_Bottom,x=m_Left + supx; x <= m_Right; x+=majorIncStepX, val+=m_MajorIncX)
   {
      dc.DrawLine(x,m_Bottom+7+(7*MARGE/4),x,m_Bottom+(7*MARGE/4));
      sprintf(text,"%g", val);
      dc.GetTextExtent(text,&widthx,&heighty);
      dc.DrawText(text,x-(widthx/2),y+3+heighty);
   }
   // Ne pas Depasser
   if ( m_SupX == 0 )
   {
         dc.DrawLine(m_Right,m_Bottom+7+(7*MARGE/4),m_Right,m_Bottom+(7*MARGE/4));
     sprintf(text,"%g", val);
     dc.GetTextExtent(text,&widthx,&heighty);
     dc.DrawText(text,m_Right-(widthx/2),m_Right+3+heighty);
   }

   supx = st_decalage(m_MinorIncX, m_MinX) * m_StepSizeX;
   //Minor Tick Marks
   for(y=m_Bottom,x=m_Left + supx; x <= m_Right; x+=minorIncStepX)
   {
     dc.DrawLine(x,m_Bottom+3+(7*MARGE/4),x,m_Bottom+(7*MARGE/4));
   }
}


void wxChart::DrawAxePer(wxDC& dc)
{
   double x,y;
   double val;
   char text[20];
   int widthx,heighty;

   double minorIncStepPer= MINOR_PER * m_StepSizePer;
   double majorIncStepPer= MAJOR_PER * m_StepSizePer;

   dc.SetPen(*wxBLACK_PEN);
   dc.SetBrush(*wxBLACK_BRUSH);

   // AXE Per
   dc.DrawLine(m_Right+(7*MARGE/4), m_Bottom, m_Right+(7*MARGE/4), m_Top);

   // Major Tick Marks with values
   val=0.00;
   for(x=m_Right,y=m_Bottom; y >= m_Top; y-=majorIncStepPer, val+=MAJOR_PER)
   {
         dc.DrawLine(m_Right+(7*MARGE/4),y,m_Right+7+(7*MARGE/4),y);
         sprintf(text,"%g",(val-(MAX_PER/2)));
         dc.GetTextExtent(text,&widthx,&heighty);
         dc.DrawText(text,m_Right+10+(7*MARGE/4),y-(heighty/2));
   }
   dc.DrawLine(m_Right+(7*MARGE/4),m_Top,m_Right+7+(7*MARGE/4),m_Top);
   sprintf(text,"%g",(val-(MAX_PER/2)));
   dc.GetTextExtent(text,&widthx,&heighty);
   dc.DrawText(text,m_Right+10+(7*MARGE/4),m_Top-(heighty/2));

   // Minor Tick Marks
   for(x=m_Right,y=m_Bottom; y >= m_Top; y-=minorIncStepPer)
   {
          dc.DrawLine(m_Right+(7*MARGE/4),y,m_Right+3+(7*MARGE/4),y);
   }
}



void wxChart::DrawGrille(wxDC& dc)
{
   double x,y;
   double val;
   double minorIncStepY = m_MinorIncY * m_StepSizeY;
   double minorIncStepX = m_MinorIncX * m_StepSizeX;

   dc.SetBrush(*wxLIGHT_GREY_BRUSH);

   // Tracer DOT
   wxPen *Pen = new wxPen(*wxLIGHT_GREY, 1, wxDOT);
   dc.SetPen(*Pen);

   // quadrillage en point
   // axe Y
   for(x=m_Left,y=m_Bottom; y >= m_Top; y-=minorIncStepY)
      dc.DrawLine(m_Left-MARGE,y,m_Right+MARGE,y);
   if (m_SupY == 0)
     dc.DrawLine(m_Left-MARGE,m_Top,m_Right+MARGE,m_Top);

   // axe X
   val = st_decalage(m_MinorIncX, m_MinX) * m_StepSizeX;
   for(y=m_Bottom, x=m_Left + val ; x <= m_Right; x+=minorIncStepX)
      dc.DrawLine(x,m_Bottom+MARGE,x,m_Top-MARGE);
   if (m_SupX == 0)
      dc.DrawLine(m_Right,m_Bottom+MARGE,m_Right,m_Top-MARGE);

   // Contour
   Pen->SetStyle(wxSOLID);
   dc.SetPen(*Pen);
   dc.DrawLine(m_Left-MARGE, m_Top-MARGE, m_Right+MARGE, m_Top-MARGE);
   dc.DrawLine(m_Right+MARGE, m_Top-MARGE, m_Right+MARGE, m_Bottom+MARGE);
   dc.DrawLine(m_Right+MARGE, m_Bottom+MARGE, m_Left-MARGE, m_Bottom+MARGE);
   dc.DrawLine(m_Left-MARGE, m_Bottom+MARGE, m_Left-MARGE, m_Top-MARGE);
}



void wxChart::DrawLegend(wxDC& dc, int nbre)
{
        // Init
        wxString  *string;
    wxPen     *dataPen;
    wxBrush   *dataBrush;
        int widthx, heighty, l_posx, l_posy;
        char text[30];
        int haut_ligne, compt = 0;
        int l_haut = m_BottomLegend - m_TopLegend;
    int l_larg = m_RightLegend - m_LeftLegend;
        div_t result = div(nbre,2);
        div_t resulta;
    int l_debut = 30, l_trait = 15, l_space = 10;

        if (result.rem == 0)
           haut_ligne = l_haut / result.quot;
        else
       haut_ligne = l_haut / (result.quot+1);

        // Contour
        dc.SetPen(*wxBLACK_PEN);
    dc.SetBrush(*wxBLACK_BRUSH);
    dc.DrawLine(m_LeftLegend, m_TopLegend, m_RightLegend, m_TopLegend);
    dc.DrawLine(m_RightLegend, m_TopLegend, m_RightLegend, m_BottomLegend);
    dc.DrawLine(m_RightLegend, m_BottomLegend, m_LeftLegend, m_BottomLegend);
    dc.DrawLine(m_LeftLegend, m_BottomLegend, m_LeftLegend, m_TopLegend);

        // For each dataset
        int maxdataset = GetNumDataSet();
        for (int a=0; a < maxdataset; a++)
        {
           if (m_dataSetArray[a] && m_dataSetArray[a]->GetShow())
       {
          compt++;
          // Text
              string = m_dataSetArray[a]->GetText();
                  sprintf(text,"%s",string);
          dc.GetTextExtent(text,&widthx,&heighty);

          resulta = div(compt, 2);
          l_posx = m_LeftLegend;
          l_posy =  m_TopLegend;
                  if (resulta.rem == 0)
          {
                         l_posx+= l_larg/2;
                     l_posy+= (haut_ligne * resulta.quot);
                  }
                  else
             l_posy+= (haut_ligne * (resulta.quot+1));

                  l_posy-= (haut_ligne/2);

          // proportion
              if (nbre==1)
            l_posx = m_LeftLegend + ((l_larg - l_trait - l_space - widthx)/2) - l_debut;

              // ligne
                  dataBrush = m_dataSetArray[a]->GetDataStyle();
          dataPen = m_dataSetArray[a]->GetLineStyle();
                  dataPen->SetWidth(2);
                  dc.SetBrush(*dataBrush);
          dc.SetPen(*dataPen);
          dc.DrawLine(l_posx + l_debut, l_posy, l_posx + l_debut + 15, l_posy);
          dataPen->SetWidth(1);
                  // text
                  dc.SetFont(*(new wxFont(1, wxDEFAULT, wxNORMAL, wxBOLD)));
                  dc.SetPen(*wxBLACK_PEN);
          dc.SetBrush(*wxBLACK_BRUSH);
          dc.DrawText(text,l_posx + l_debut + l_trait + l_space ,l_posy - (heighty/2));
              dc.SetFont(*(new wxFont(1, wxDEFAULT, wxNORMAL, wxLIGHT)));
           }
        }
}



void wxChart::DrawLine(wxDC &dc, int a)
{
   int compt=0;
   double val;
   double mid = m_Bottom - ((m_Bottom-m_Top)/2);
   int maxitem = GetNumItem();

   float yprec, xprec;
   float xsuiv, ysuiv;

   for(int j=0; j < maxitem; j++)
   {
      if ( IsEmpty(a,j) == false )
      {
         compt++;
                 xsuiv = m_Left + ((GetDataX(a,j) - m_MinX ) * m_StepSizeX);
         val = GetDataY(a,j);
             if ( a == wxStenosis)
               // Axe Per for Stenosis
           ysuiv = mid - (val * m_StepSizePer);
         else
           // Axe X
               ysuiv = m_Bottom - (val * m_StepSizeY);
               // Draw line
         if (compt > 1)
                    dc.DrawLine(xprec, yprec, xsuiv, ysuiv);

         // save point prec
         xprec = xsuiv;
                 yprec = ysuiv;
          }
   }
}


// Click Mouse
//-----------------------------------------------------------------
void wxChart::OnLeftClick(wxDC &dc, double x, double y, int keys)
{
  // TO IMPLEMENT
}

void wxChart::OnRightClick(wxDC &dc, double x, double y, int keys)
{
  // TO IMPLEMENT
}


// Data
//--------------------------------------------------------------------
void wxChart::InitData()
{
  SetNumItem(0);
  for(int a=0; a<MAX_DATASET; a++)
  {
         for(int j=0; j<MAX_ITEM; j++)
         {
         m_table[a][j].x=0.00;
         m_table[a][j].y=0.00;
                 m_table[a][j].empty = true;
     }
  }
}

bool  wxChart::IsEmpty(int a, int j)
{
   return m_table[a][j].empty;
}


double wxChart::GetDataX(int a, int j)
{

   return  m_table[a][j].x;
}

double wxChart::GetDataY(int a, int j)
{

   return  m_table[a][j].y;
}


void wxChart::SetData(int a, int j, double x, double y)
{
     m_table[a][j].x = x;
     m_table[a][j].y = y;
         m_table[a][j].empty = false;
}


void wxChart::ShowDataSet(bool show,int dataset)
{
   if(m_dataSetArray[dataset])
      m_dataSetArray[dataset]->Show(show);
}

bool wxChart::GetShowDataSet(int dataset)
{

   if(m_dataSetArray[dataset])
      return m_dataSetArray[dataset]->GetShow();
   else
      return 1;
}