mBarRange.cxx

Go to the documentation of this file.

//----------------------------------------------------------------------------
#include "mBarRange.h"


//const wxEventType wxEVT_TSBAR = wxNewEventType();

DEFINE_EVENT_TYPE(wxEVT_TSBAR)
DEFINE_EVENT_TYPE(wxEVT_TSBAR_ACTUAL)
DEFINE_EVENT_TYPE(wxEVT_TSBAR_START)
DEFINE_EVENT_TYPE(wxEVT_TSBAR_END)
DEFINE_EVENT_TYPE(wxEVT_TSBAR_MOVED)
DEFINE_EVENT_TYPE(wxEVT_SELECTION_END)



//----------------------------------------------------------------------------
//EVENT TABLE
//----------------------------------------------------------------------------

IMPLEMENT_CLASS(mBarRange, wxScrolledWindow)
BEGIN_EVENT_TABLE(mBarRange, wxScrolledWindow)
        EVT_PAINT (mBarRange::OnPaint)
        EVT_SIZE  (mBarRange::OnSize)
        EVT_MOTION (mBarRange::OnMouseMove)
        EVT_RIGHT_DOWN (mBarRange :: onShowPopupMenu)
        EVT_MENU(cntID_CHANGE_COLOR, mBarRange :: onChangePartColor)
        EVT_MENU(cntID_ENABLE_ACTUAL, mBarRange :: onEnableRange_Actual)
        EVT_MENU(cntID_MOVABLE_ACTUAL_BAR, mBarRange :: onMovable_ActualWithBar)

        //
        EVT_LEFT_DOWN( mBarRange :: onLeftClicDown)
        EVT_LEFT_UP( mBarRange :: onLeftClickUp)

        //how to catch the new event (our event)
        //EVT_COMMAND  (ID_MY_WINDOW, wxEVT_MY_EVENT, MyFrame::OnMyEvent)
END_EVENT_TABLE()


//----------------------------------------------------------------------------
//CONSTRUCTOR
//----------------------------------------------------------------------------

mBarRange::mBarRange(wxWindow *parent, int w, int h)
:wxScrolledWindow(parent,-1,wxDefaultPosition,wxDefaultSize,wxTAB_TRAVERSAL)
{
        acceptedClick = true;
        _bitmap_bar                     =       NULL;
        SetWidth (w);
        SetHeight(h);
        _initialPoint           =       0;
        trianglesHalfWidth = 5;
        
        wxColour start_Colour;

        // Setting the default parts colors
        start_Colour            =       wxColour(0,0,255);
        actual_Colour           =       wxColour(255,255,202);
        end_Colour                      =       wxColour(0,0,255);
        bar_Colour                      =       wxColour(255,0,255);
        backgroundColor     =   parent ->GetBackgroundColour();
        guideLineColor          =   wxColour(255,0,0);

        //actual is in _start and end
        //false means that it could be anywhere
        _moveActualWithBar      =       false;
        _in_rangeProperty       =       false;
        _selectionMoveId        =       -1;
        realX_vertical_line =   -1;
        activeState                     =       false;
        _actual=0;
        deviceEndMargin = 0;

        SetOrientation(true);
        setIfWithActualDrawed(true);

        b_popmenu.Append (cntID_CHANGE_COLOR, _("Change Color"), _("Changes the color of the selected part"));
        b_popmenu.Append (cntID_ENABLE_ACTUAL, _("Enable actual in range"), _("Enables/Disables the actual triangle to be or not in range"));
        b_popmenu.Append (cntID_MOVABLE_ACTUAL_BAR, _("Move actual-bar simultaneously"), _("Disables the actual triangle to move with the bar"));

        SetSize(w,h);
}

//----------------------------------------------------------------------------
//DESTRUCTOR
//----------------------------------------------------------------------------

mBarRange::~mBarRange()
{
}
//---------------------------------------------------------------------------
//Draw bar: vertical or Horizontal
//---------------------------------------------------------------------------
void mBarRange::DrawBar()
{
        //Horizontal
        if(_orientation)
        {
                SetWindowStyle(wxNO_FULL_REPAINT_ON_RESIZE);
                _bitmap_bar             = new wxBitmap(_w+1280,_h+100);
                //SIL//_bitmap_info     = new wxBitmap(_w+100+1280, _h+100);
        }
        //vertical
        else
        {
                SetWindowStyle(wxNO_FULL_REPAINT_ON_RESIZE);
                _bitmap_bar = new wxBitmap(_h+deviceStart_y+100,_w+1280);
                _bitmap_info = new wxBitmap(_h+deviceStart_y+100, _w+1280);
        }
}
//----------------------------------------------------------------------------
//Getters & Setters
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//the property condition on actual triangle
//----------------------------------------------------------------------------
bool mBarRange::GetInRangeProperty()
{
        return _in_rangeProperty;
}
//----------------------------------------------------------------------------
void mBarRange::SetInRangeProperty(bool in)
{
        _in_rangeProperty=in;
}
//----------------------------------------------------------------------------
//the information about the actual triangle in range or not, true if is between start and end
//----------------------------------------------------------------------------
bool mBarRange::IsActualInRange()
{
        return ( _actual <= _end && _actual >= _start );
}

//----------------------------------------------------------------------------
// the position of the rectangle, vertical or horizontal
//----------------------------------------------------------------------------
bool mBarRange::GetOrientation()
{
        return _orientation;
}
//-----------------------------------------------------------------------------
void mBarRange::SetOrientation(bool orientation)
{
        if(_orientation)
        {
                SetSize(_h,_w);
        }
        _orientation=orientation;

}
//----------------------------------------------------------------------------
// _start of the pixel rectangle
//----------------------------------------------------------------------------

int mBarRange::GetPixelStart()
{
        return ((_start - _min)*(_w-deviceEndMargin))/(_max - _min);    
}
//----------------------------------------------------------------------------
// param i: value in pixels
//----------------------------------------------------------------------------
void mBarRange::SetPixelStart(int i)
{
        _start = _min+((i - deviceStart_x)*( _max - _min))/(_w-deviceEndMargin);
        
}
//----------------------------------------------------------------------------
// _actual of the pixel rectangle
//----------------------------------------------------------------------------
int mBarRange::GetPixelActual()
{
        return ((_actual - _min)*(_w-deviceEndMargin))/(_max - _min);
}
//----------------------------------------------------------------------------
// param i: value in pixels
//----------------------------------------------------------------------------
void mBarRange::SetPixelActual(int i)
{
        _actual = _min + (i-deviceStart_x)*(_max-_min)/(_w-deviceEndMargin);
}
//----------------------------------------------------------------------------
// _end of the pixel rectangle
//----------------------------------------------------------------------------
int mBarRange::GetPixelEnd()
{
        return ((_end - _min)*(_w-deviceEndMargin))/(_max - _min);
}
//----------------------------------------------------------------------------
// param i: value in pixels to be converted to real logical value
//----------------------------------------------------------------------------
void mBarRange::SetPixelEnd(int i)
{
        _end = _min + (i-deviceStart_x)*(_max-_min)/(_w-deviceEndMargin);
}
//----------------------------------------------------------------------------
// Logical max of the triangle
//----------------------------------------------------------------------------

double mBarRange::GetMax()
{
        return _max;
}

//----------------------------------------------------------------------------
void mBarRange::SetMax(double i)
{
        _max=i;
}
//----------------------------------------------------------------------------
// Logical min of the triangle
//----------------------------------------------------------------------------

double mBarRange::GetMin()
{
        return _min;
}

//----------------------------------------------------------------------------
void mBarRange::SetMin(double i)
{
        _min=i;
}

//----------------------------------------------------------------------------
// pixel dimensions of the rectangle
//----------------------------------------------------------------------------

int mBarRange::GetWidth()
{
        return _w;
}
//----------------------------------------------------------------------------
void mBarRange::SetWidth(int w)
{
        _w=w;
}
//----------------------------------------------------------------------------
int mBarRange::GetHeight()
{
        return _h;
}

//----------------------------------------------------------------------------
void mBarRange::SetHeight(int h)
{
        _h=h;   
}

//----------------------------------------------------------------------------
// Logical  Start of the rectangle
//----------------------------------------------------------------------------

int mBarRange::GetStart()
{
        return _start;

}
//----------------------------------------------------------------------------
// param start: value real units
//----------------------------------------------------------------------------
void mBarRange::SetStart(int newstart)
{
        if(newstart<_min)
                newstart = _min;
        _start = newstart;
        RefreshForce(); 
}
//----------------------------------------------------------------------------
// Logical End of the rectangle
//----------------------------------------------------------------------------

int mBarRange::GetEnd()
{
        return _end;
}
//----------------------------------------------------------------------------
// param end: value pixel units
//----------------------------------------------------------------------------
void mBarRange::SetEnd(int nwend)
{
        if(nwend>_max)
                _end = _max;
        _end=nwend;
        RefreshForce(); 
}
//----------------------------------------------------------------------------
// logical  Actual of the rectangle
//----------------------------------------------------------------------------
int mBarRange::GetActual()
{
        return _actual;
}
//----------------------------------------------------------------------------
void mBarRange::SetActual(int actual)
{
        if(actual<_min)
                _actual = _min;
        else if (actual>_max)
                _actual = _max;
        _actual=actual;
        RefreshForce();
}

//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
int mBarRange::GetTrianglesHalfWidth()
{
        return trianglesHalfWidth;
}
//----------------------------------------------------------------------------
void mBarRange::SetTrianglesHalfWidth(int nwTriHalfWidth)
{
        trianglesHalfWidth = nwTriHalfWidth;
}

void mBarRange::OnSize( wxSizeEvent &WXUNUSED(event) )
{
        wxRect rectTotal = GetClientRect(); 
        if(_orientation)
        {               
                SetWidth( rectTotal.GetWidth() - deviceEndMargin );                     
        } 
        else 
        {
                SetWidth( rectTotal.GetHeight() - deviceEndMargin);                             
        }
        _selectionMoveId = -1;
        Refresh();              
}

//----------------------------------------------------------------------------

void mBarRange::Refresh(bool eraseBackground, const wxRect* rect)
{
// EED Borrame
//FILE *ff;
//ff=fopen ("c:/temp/xxx.txt", "a+");
//fprintf( ff , "mBarRange :: Refresh 01\n" );
//fclose(ff);

        wxScrolledWindow::Refresh(false);


// EED Borrame
//ff=fopen ("c:/temp/xx.txt", "a+");
//fprintf( ff , "mBarRange :: Refresh 02\n" );
//fclose(ff);
}


//----------------------------------------------------------------------------
//Bar Methods
//----------------------------------------------------------------------------
void mBarRange::OnPaint( wxPaintEvent &WXUNUSED(event) )
{

// EED Borrame
//FILE *ff;
//ff=fopen ("c:/temp/xx.txt", "a+");
//fprintf( ff , "pColorBar :: OnPaint 01\n" );
//fclose(ff);

        if (_bitmap_bar!=NULL){
                //repaint rectangle
                if(_orientation)
                {
                        RefreshHorizontalView();
                        wxMemoryDC temp_dc;
                        temp_dc.SelectObject( *_bitmap_bar );
                        wxPaintDC dc( this );
                        dc.Blit(deviceStart_x-(trianglesHalfWidth+2), deviceStart_y, _w-deviceEndMargin+2*(trianglesHalfWidth+2), _h, &temp_dc, 0, 0);
                        //repaint info
//                      if (_visibleLables)
//                      {
//                              temp_dc.SelectObject( *_bitmap_info );                          
//                              dc.Blit(deviceStart_x,deviceStart_y+_h, _w+deviceStart_x-deviceEndMargin, _h+deviceStart_y+200, &temp_dc, deviceStart_x, deviceStart_y);
//                              //dc.Blit(deviceStart_x,deviceStart_y+_h, _w+deviceStart_x-deviceEndMargin, _h+deviceStart_y+60, &temp_dc, 0, 0);
//                      }
        
                } else {
                        RefreshVerticalView();
                        wxMemoryDC temp_dc;
                        temp_dc.SelectObject( *_bitmap_bar );
                        wxPaintDC dc( this );                   
//                      dc.Blit(deviceStart_y,deviceStart_x, _h+deviceStart_y-deviceEndMargin,_w+deviceStart_x-deviceEndMargin, &temp_dc, 0, 0);        
                        dc.Blit(deviceStart_y,deviceStart_x-(trianglesHalfWidth+2), _h,_w-deviceEndMargin+2*(trianglesHalfWidth+2), &temp_dc, 0, 0);    
                        
                        //repaint info
//                      if (_visibleLables)
//                      {
//                              temp_dc.SelectObject( *_bitmap_info );
//                              dc.Blit(0,_w, _h+deviceStart_y+200, _w+deviceStart_x+200-deviceEndMargin, &temp_dc, deviceStart_y,_w+deviceStart_x);
//                      }


                } 
        } 

// EED Borrame
//ff=fopen ("c:/temp/xx.txt", "a+");
//fprintf( ff , "pColorBar :: OnPaint 02\n" );
//fclose(ff);


}
//----------------------------------------------------------------------------
//Repaint the bar if it is horizontal
//----------------------------------------------------------------------------
void mBarRange::RefreshHorizontalView()
{

// EED Borrame
//FILE *ff;
//ff=fopen ("c:/temp/xxx.txt", "a+");
//fprintf( ff , "mBarRange :: RefreshHorizontalView 01\n" );
//fclose(ff);

        wxPoint points[3];

        //int largestNumberWidthInPixels = 15; // JPRx
        int pxStart=GetPixelStart();
        int pxEnd=GetPixelEnd();
        int pxActual=GetPixelActual();

        
        int letterHeight = 9;
        int barHeight = 2*letterHeight;
        int tempHeight = _h-(6*letterHeight);
        
        
        if (_visibleLables)
        {
                barHeight = (tempHeight>0)  ? tempHeight : (int) _h/2;
        }
        else
                barHeight = _h; 

        wxMemoryDC temp_dc;
        temp_dc.SelectObject( *_bitmap_bar );

        
        // Background of this widget
        
        
        temp_dc.SetPen(wxPen( backgroundColor ));
        temp_dc.SetBrush(wxBrush( backgroundColor ,wxSOLID  ));
        
        temp_dc.DrawRectangle(0,0,_w+2*trianglesHalfWidth,_h);
        

        temp_dc.SetPen(wxPen( wxColour(167,165,191) ,1,wxSOLID  ));
        temp_dc.DrawLine(trianglesHalfWidth+2, 0, _w-deviceEndMargin, 0);
        temp_dc.DrawLine(trianglesHalfWidth+2, barHeight, (_w-deviceEndMargin-trianglesHalfWidth-2), barHeight);
        temp_dc.SetDeviceOrigin(trianglesHalfWidth+2,0);


        // Filling the bar
        temp_dc.SetBrush(wxBrush( wxColour(104,104,104),wxSOLID  ));
        temp_dc.SetPen(wxPen( wxColour(104,104,104),1,wxSOLID  ));
        temp_dc.DrawRectangle( pxStart , 0, pxEnd-pxStart, barHeight);


        //  The Bar
        if( _selectionMoveId==4 )
        {
                temp_dc.SetBrush(wxBrush( wxColour(128,255,0),wxSOLID  ));
                temp_dc.SetPen(wxPen(  wxColour(0,128,0),1,wxSOLID  ));
        }
        else
        {
                temp_dc.SetBrush(wxBrush( bar_Colour,wxSOLID  ));
                temp_dc.SetPen(wxPen( wxColour(164,0,164),1,wxSOLID  ));
        }
        temp_dc.DrawRectangle( pxStart,1, pxEnd-pxStart, barHeight );

        // 2 Shadow Triangles: Start and End 
        temp_dc.SetBrush(wxBrush( wxColour(104,104,104),wxSOLID  ));
        temp_dc.SetPen(wxPen( wxColour(104,104,104),1,wxSOLID  ));
        points[0].x= 0;
        points[0].y= barHeight;
        points[1].x= -trianglesHalfWidth-1;
        points[1].y= 0;
        points[2].x= trianglesHalfWidth+2;
        points[2].y= 0;
        temp_dc.DrawPolygon(3,points,pxStart,0);
        temp_dc.DrawPolygon(3,points,pxEnd,0);

        // 2 Triangles: Start and End 
        points[1].x = -trianglesHalfWidth;      
        points[2].x = trianglesHalfWidth;
        
        //first triangle (start)
        if( _selectionMoveId == 1 )
        {
                temp_dc.SetBrush(wxBrush( wxColour(128,255,0),wxSOLID  ));
                temp_dc.SetPen(wxPen(  wxColour(0,128,0),1,wxSOLID  ));
        }
        else
        {
                temp_dc.SetBrush(wxBrush( start_Colour,wxSOLID  ));
                temp_dc.SetPen(wxPen( wxColour(0,51,204),1,wxSOLID  ));
        }
        temp_dc.DrawPolygon(3,points,pxStart,0);
        //second triangle (end)
        if( _selectionMoveId == 2 )
        {
                temp_dc.SetBrush(wxBrush( wxColour(128,255,0),wxSOLID  ));
                temp_dc.SetPen(wxPen(  wxColour(0,128,0),1,wxSOLID  ));
        }
        else
        {
                temp_dc.SetBrush(wxBrush( end_Colour,wxSOLID  ));
                temp_dc.SetPen(wxPen( wxColour(0,0,255),1,wxSOLID  ));
        }
        temp_dc.DrawPolygon(3,points,pxEnd,0);

        if( withActualDrawed )
        {
                // 1 Shadow Triangle: Actual
                temp_dc.SetBrush(wxBrush( wxColour(104,104,104),wxSOLID  ));
                temp_dc.SetPen(wxPen( wxColour(104,104,104),1,wxSOLID  ));
                points[1].x = -trianglesHalfWidth-1;
                points[2].x = trianglesHalfWidth+2;
                
                temp_dc.DrawPolygon(3,points,pxActual,0);

                // 1 Triangle: Actual (red)
                if( _selectionMoveId==3 )
                {
                        temp_dc.SetBrush(wxBrush( wxColour(128,255,0),wxSOLID  ));
                        temp_dc.SetPen(wxPen(  wxColour(0,128,0),1,wxSOLID  ));
                }
                else
                {
                        temp_dc.SetBrush(wxBrush( actual_Colour,wxSOLID  ));
                        temp_dc.SetPen(wxPen( wxColour(205,160,5),1,wxSOLID  ));
                }
                points[1].x = -trianglesHalfWidth;
                points[2].x = trianglesHalfWidth;
                temp_dc.DrawPolygon(3,points,pxActual,0);
        }

        if (realX_vertical_line!=-1)
        {
                temp_dc.SetPen(wxPen(  guideLineColor,1,wxDOT ));
                int pixelX_guide = ((realX_vertical_line - _min)*(_w-deviceEndMargin))/(_max - _min) ; 
                temp_dc.DrawLine(pixelX_guide, 0, pixelX_guide, barHeight);
        }

        //Information Device drawing

        if (_visibleLables)
        {
                //temp_dc.SelectObject( *_bitmap_info );
                /*temp_dc.SetBrush(wxBrush( colourParent ,wxSOLID  ));
                temp_dc.SetPen(wxPen( colourParent ,1,wxSOLID  ));*/
                //temp_dc.DrawRectangle(deviceStart_x,_h+deviceStart_y,_w+deviceStart_x+40,_h+deviceStart_y+40);
                //temp_dc.DrawRectangle(0,_h,_w+40-deviceEndMargin,_h+40);

                wxFont font(letterHeight-1, wxFONTFAMILY_SWISS, wxNORMAL, wxNORMAL);
                temp_dc.SetFont(font);
                temp_dc.SetTextForeground(*wxBLACK);


                //the **MIN** value, always at the same y level that corresponds to barHeight+1
                wxString text_min;
//              text_min<< GetMin();
                text_min.Printf(_T("%d"), (int)GetMin() );
                
                temp_dc.DrawText(text_min,0,barHeight+1);

                //the **MAX** value always at the same place
                wxString text_max;
//              text_max << GetMax();
                text_max.Printf(_T("%d"), (int)GetMax() );

                //As there is a margin of 40 extra most numbers (max) should be visibles
//              stringSize = temp_dc.GetTextExtent(text_max);
        wxCoord tmpX,tmpY;
                temp_dc.GetTextExtent(text_max,&tmpX,&tmpY);
                wxSize stringSize(tmpX,tmpY);
                
                temp_dc.DrawText(text_max,_w-deviceEndMargin -(stringSize.GetWidth())/*2*trianglesHalfWidth*/,barHeight+1);     
                
                //show logical values
                //show the **START TRIANGLE** value 
                wxString text_start;
//              text_start << GetStart();               
                text_start.Printf(_T("%d"), (int)GetStart() );

                temp_dc.DrawText(text_start, pxStart,barHeight+2*letterHeight);
                //show the **END TRIANGLE** value
                wxString text_end;
//              text_end << GetEnd();
                text_end.Printf(_T("%d"), (int)GetEnd() );

//              stringSize = temp_dc.GetTextExtent(text_end);
                temp_dc.GetTextExtent(text_end,&tmpX,&tmpY);
                stringSize.SetHeight(tmpY);
                stringSize.SetWidth(tmpX);
                temp_dc.DrawText(text_end, pxEnd-stringSize.GetWidth(),barHeight+3*letterHeight);
                if( withActualDrawed )
                {
                        //show the actual value of actual
                        wxString text_actual;
//                      text_actual << GetActual();
                        text_actual.Printf(_T("%d"), (int)GetActual() );
//                      stringSize = temp_dc.GetTextExtent(text_actual);
                        temp_dc.GetTextExtent(text_actual,&tmpX,&tmpY);
                    stringSize.SetHeight(tmpY);
                    stringSize.SetWidth(tmpX);
                        temp_dc.DrawText(text_actual, pxActual-(stringSize.GetWidth()/2),barHeight+letterHeight);                       
                }                       
        }

// EED Borrame
//ff=fopen ("c:/temp/xxx.txt", "a+");
//fprintf( ff , "mBarRange :: RefreshHorizontalView 02\n" );
//fclose(ff);
}

//----------------------------------------------------------------------------
//Repaint the bar if it is vertical
//----------------------------------------------------------------------------

void mBarRange::RefreshVerticalView()
{

// EED Borrame
//FILE *ff;
//ff=fopen ("c:/temp/xxx.txt", "a+");
//fprintf( ff , "mBarRange :: RefreshVerticalView 01\n" );
//fclose(ff);
        wxPoint points[3];

        int px1=GetPixelStart();
        int px2=GetPixelEnd();
        int px3=GetPixelActual();
        int letterHeight = 9;
        int panelHeight = 9*3+_w;

        int barWidth;
        if (_visibleLables)
        {
                barWidth = (_w-30)>0 ? _w-30 : (int) _w/2;
        }
        else
                barWidth = _w;  

        wxMemoryDC temp_dc;
        temp_dc.SelectObject( *_bitmap_bar );

        // Background
        temp_dc.SetBrush(wxBrush( backgroundColor ,wxSOLID  ));
        temp_dc.SetPen(wxPen( backgroundColor ));

        temp_dc.DrawRectangle(0,0,_h,_w+2*trianglesHalfWidth);
        

        temp_dc.SetPen(wxPen( wxColour(167,165,191) ,1,wxSOLID  ));
        temp_dc.DrawLine(0,trianglesHalfWidth+2, 0, _w-deviceEndMargin);
        temp_dc.DrawLine(barWidth, trianglesHalfWidth+2, barWidth, (_w-deviceEndMargin-trianglesHalfWidth-2));
        temp_dc.SetDeviceOrigin(0,trianglesHalfWidth+2);

        // Filling the bar
        temp_dc.SetBrush(wxBrush( wxColour(104,104,104),wxSOLID  ));
        temp_dc.SetPen(wxPen( wxColour(104,104,104),1,wxSOLID  ));
        temp_dc.DrawRectangle( 0,px1 ,_h, px2-px1 );


        //  The Bar
                if( _selectionMoveId==4 )
        {
                temp_dc.SetBrush(wxBrush( wxColour(128,255,0),wxSOLID  ));
                temp_dc.SetPen(wxPen(  wxColour(0,128,0),1,wxSOLID  ));
        }
        else
        {
                temp_dc.SetBrush(wxBrush( bar_Colour,wxSOLID  ));
                temp_dc.SetPen(wxPen( wxColour(164,0,164),1,wxSOLID  ));
        }
        temp_dc.DrawRectangle( 1,px1,_h, px2-px1);


        // 2 Shadow Triangles: Start and End 
        points[0].x=_h;
        points[0].y=0;
        points[1].x=0;
        points[1].y=-trianglesHalfWidth-1;
        points[2].x=0;
        points[2].y=trianglesHalfWidth+2;
        temp_dc.SetBrush(wxBrush( wxColour(104,104,104),wxSOLID  ));
        temp_dc.SetPen(wxPen( wxColour(104,104,104),1,wxSOLID  ));
        temp_dc.DrawPolygon(3,points,0,px1);
        temp_dc.DrawPolygon(3,points,0,px2);

        // 2 Triangles: Start and End 
        points[0].x=_h;
        points[0].y=0;
        points[1].x=0;
        points[1].y=-trianglesHalfWidth;
        points[2].x=0;
        points[2].y=trianglesHalfWidth;
        //first triangle (start)
        if( _selectionMoveId==1 )
        {
                temp_dc.SetBrush(wxBrush( wxColour(128,255,0),wxSOLID  ));
                temp_dc.SetPen(wxPen(  wxColour(0,128,0),1,wxSOLID  ));
        }
        else
        {
                temp_dc.SetBrush(wxBrush( start_Colour,wxSOLID  ));
                temp_dc.SetPen(wxPen( wxColour(0,51,204),1,wxSOLID  ));
        }
        temp_dc.DrawPolygon(3,points,0,px1);
        //second triangle (end)
        if( _selectionMoveId==2 )
        {
                temp_dc.SetBrush(wxBrush( wxColour(128,255,0),wxSOLID  ));
                temp_dc.SetPen(wxPen(  wxColour(0,128,0),1,wxSOLID  ));
        }
        else
        {
                temp_dc.SetBrush(wxBrush( end_Colour,wxSOLID  ));
                temp_dc.SetPen(wxPen( wxColour(0,0,255),1,wxSOLID  ));
        }
        temp_dc.DrawPolygon(3,points,0,px2);

        if( withActualDrawed )
        {
                // 1 Shadow Triangle: Actual
                temp_dc.SetBrush(wxBrush( wxColour(104,104,104),wxSOLID  ));
                temp_dc.SetPen(wxPen( wxColour(104,104,104),1,wxSOLID  ));
                points[0].x=_h;
                points[0].y=0;
                points[1].x=0;
                points[1].y=-trianglesHalfWidth-1;
                points[2].x=0;
                points[2].y=trianglesHalfWidth+2;
                temp_dc.DrawPolygon(3,points,0,px3);

                // 1 Triangle: Actual (red)
                points[0].x = _h;
                points[0].y = 0;
                points[1].x = 0;
                points[1].y = -trianglesHalfWidth;
                points[2].x = 0;
                points[2].y = trianglesHalfWidth;
                if( _selectionMoveId==3 )
                {
                        temp_dc.SetBrush(wxBrush( wxColour(128,255,0),wxSOLID  ));
                        temp_dc.SetPen(wxPen(  wxColour(0,128,0),1,wxSOLID  ));
                }
                else
                {
                        temp_dc.SetBrush(wxBrush( actual_Colour,wxSOLID  ));
                        temp_dc.SetPen(wxPen( wxColour(205,160,5),1,wxSOLID  ));
                }
                temp_dc.DrawPolygon(3,points,0,px3);
        }

        if (realX_vertical_line!=-1)
        {
                temp_dc.SetPen(wxPen(  guideLineColor,1,wxDOT  ));
                int pixelX_guide = realX_vertical_line*_w/(_max-_min)+deviceStart_x; 
                temp_dc.DrawLine(0,pixelX_guide, _h, pixelX_guide);
        }

        //Information Device drawing
        if (_visibleLables)
        {
                /*temp_dc.SelectObject( *_bitmap_info );

                temp_dc.SetBrush(wxBrush( backgroundColor ,wxSOLID  ));
                temp_dc.SetPen(wxPen( backgroundColor ,1,wxSOLID  ));
                temp_dc.DrawRectangle(deviceStart_y,_w+deviceStart_x,_h+deviceStart_y+200,_w+deviceStart_x+200);
*/

                temp_dc.SetBackgroundMode(wxTRANSPARENT);
                wxFont font(letterHeight-1, wxFONTFAMILY_SWISS, wxNORMAL, wxNORMAL);
                temp_dc.SetFont(font);
                temp_dc.SetTextForeground(*wxBLACK);

                //show logical values
                //show the actual value of start
                wxString text_start;
//              text_start<<"Start:"<< GetStart();
                text_start.Printf(_T("%s %d"),_T("Start: "), (int)GetStart() );
                temp_dc.DrawText( text_start ,deviceStart_y, _w+deviceStart_x+letterHeight+1);
                //show the actual value of end
                wxString text_end;
//              text_end <<"End: "<<GetEnd();
                text_end.Printf(_T("%s %d"),_T("End: "), (int)GetEnd() );
                temp_dc.DrawText( text_end ,deviceStart_y,_w+deviceStart_x+letterHeight*2 );
                if( withActualDrawed )
                {
                        //show the actual value of actual
                        wxString text_actual;
//                      text_actual <<"Actual: " <<GetActual();
                        text_actual.Printf(_T("%s %d"),_T("Actual: "), (int)GetActual() );
                        temp_dc.DrawText( text_actual ,deviceStart_y,_w+deviceStart_x+letterHeight*3);
                }
                //the min value, always at the same place
                wxString text_min;
//              text_min<<"Min: " << GetMin();
                text_min.Printf(_T("%s %d"),_T("Min: "), (int)GetMin() );
                temp_dc.DrawText( text_min ,deviceStart_y,_w+deviceStart_x+3);
                //the max value always at the samen place
                wxString text_max;
//              text_max <<"Max: "<< GetMax();
                text_max.Printf(_T("%s %d"),_T("Max: "), (int)GetMax() );
                //toca calcular cuantol lo corremos
                temp_dc.DrawText(text_max,deviceStart_y,_w+deviceStart_x+43);           
        }

}

//----------------------------------------------------------------------------
void mBarRange::RefreshForce()
{
        Refresh();
        Update();
}
//----------------------------------------------------------------------------
void mBarRange::OnMouseMove(wxMouseEvent& event )
{
// EED Borrame
//FILE *ff;
//ff=fopen ("c:/temp/xxx.txt", "a+");
//fprintf( ff , "mBarRange :: OnMouseMove 01\n" );
//fclose(ff);

        //int px1=GetPixelStart(); // JPRx
        //int px2=GetPixelEnd(); // JPRx
        //int px3=GetPixelActual(); // JPRx
        if (activeState)
        {
                wxPoint point = event.GetPosition();
                int barHeight;
                if (_orientation)
                {
                        setClickedX(point.x);
                        barHeight = point.y;
                }
                else
                {
                        setClickedX(point.y);
                        barHeight = point.x;
                }
                int logicClick = getLogicValueofPixel(clickedX);
                        
                if( _selectionMoveId==-1 )
                {
                        if (barHeight <=_h)
                        {
                                bool in_StartTri = (clickedX>=GetPixelStart()-5+ deviceStart_x) && (clickedX<=GetPixelStart()+5+ deviceStart_x);
                                bool in_EndTri = (clickedX>=GetPixelEnd()-5+ deviceStart_x) && (clickedX<=GetPixelEnd()+5+ deviceStart_x);
                                bool in_actualT= withActualDrawed && (clickedX>=GetPixelActual()-5+ deviceStart_x) && (clickedX<=GetPixelActual()+5+ deviceStart_x);
                                bool in_movingBar = (clickedX>GetPixelStart()+5+ deviceStart_x) && (clickedX<GetPixelEnd()-5+ deviceStart_x);

                                if( in_actualT )
                                        _selectionMoveId = 3;
                                else if(in_StartTri)
                                        _selectionMoveId = 1;  
                                else if( in_EndTri )
                                        _selectionMoveId = 2;
                                else if( in_movingBar )
                                        _selectionMoveId = 4;
                        }
                }
                else
                {
                        if(acceptedClick)
                        {
                                //is in start triagle
                                if( _selectionMoveId ==1 && event.LeftIsDown())
                                {
                                        bool validPos_StartTri = (logicClick<GetEnd() && logicClick >=_min);
                                        if( validPos_StartTri && !_in_rangeProperty)
                                        {       
                                                SetPixelStart(clickedX);
                                                RefreshForce();
                                                RefreshHorizontalView();
                                                //-------------------------------------------
                                                // Sending the event of start triangle moved
                                                //-------------------------------------------
                                                createAndSendEvent( wxEVT_TSBAR_START );
                                        }
                                        //start has to be less than actual
                                        else if (validPos_StartTri && _in_rangeProperty)
                                        {
                                                if(logicClick<=GetActual())
                                                {
                                                        SetPixelStart(clickedX);
                                                        RefreshForce();
                                                //      RefreshHorizontalView();
                                                        //-------------------------------------------
                                                        // Sending the event of start triangle moved
                                                        //-------------------------------------------
                                                createAndSendEvent( wxEVT_TSBAR_START );
                                                }
                                        }
                                } // _selectionMoveId == 1
                                //is in end triangle
                                else if( _selectionMoveId == 2 && event.LeftIsDown() )
                                {
                                        bool validPos_EndTri = logicClick>GetStart()&& logicClick<=_max;  
                                        if( validPos_EndTri && !_in_rangeProperty )
                                        {                                       
                                                SetPixelEnd(clickedX);
                                                RefreshForce();
        //                                      RefreshHorizontalView();        
                                                //-------------------------------------------
                                                //Sending the event of end triangle moved
                                                //-------------------------------------------
                                                createAndSendEvent( wxEVT_TSBAR_END );
                                        }
                                        //the end triangle cant be less than actual
                                        else if( validPos_EndTri && _in_rangeProperty )
                                        {
                                                if(logicClick>=GetActual())
                                                {
                                                        SetPixelEnd(clickedX);
                                                        RefreshForce();
                                                //      RefreshHorizontalView();
                                                        //-------------------------------------------
                                                        //Sending the event of end triangle moved
                                                        //-------------------------------------------
                                                        createAndSendEvent( wxEVT_TSBAR_END );
                                                }
                                        }
                                } 
                                //is the actual triangle
                                else if( _selectionMoveId == 3 && event.LeftIsDown())
                                {
                                        bool validPos_ActualTri=(logicClick<=_max) && (logicClick>=_min);
                                        //is in actual triangle but it could be anywhere
                                        if( validPos_ActualTri && !_in_rangeProperty )
                                        {
                                                SetPixelActual(clickedX);
                                                RefreshForce();
                                                RefreshHorizontalView();
                                                //-------------------------------------------
                                                //Sending the event of actual triangle moved
                                                //-------------------------------------------
                                                createAndSendEvent( wxEVT_TSBAR_ACTUAL );       
//                                              createAndSendEvent( 98765 );

//printf("EED creaMaracasVisu mBarRange::OnMouseMove XXXXXXX \n");

                                        }
                                        else if( validPos_ActualTri && _in_rangeProperty )
                                        // the tringle in between start and end
                                        {
                                                if( logicClick>=GetStart() && logicClick<=GetEnd())
                                                {
                                                        SetPixelActual(clickedX);
                                                        RefreshForce();
                                                        RefreshHorizontalView();
                                                        //-------------------------------------------
                                                        //Sending the event of actual triangle moved
                                                        //-------------------------------------------
                                                        createAndSendEvent( wxEVT_TSBAR_ACTUAL );
                                                }
                                        } 
                                } 
                                //is the bar
                                else if ( _selectionMoveId == 4 &&  event.LeftIsDown() )
                                {       
                                        //FILE * f=fopen("E:/borrar/file.txt","a+");
                                        if(_initialPoint == 0)
                                        {
                                                _initialPoint = logicClick;
                                                logicInitial_start = GetStart(); 
                                                logicInitial_end = GetEnd();
                                                logicInitial_actual = GetActual();
                                                //SIL//fprintf(f,"\n\n---- Inicia draggin:\n  logicInitial_start:%d, logicInitial_end:%d,logicInitial_actual:%d \n", _initialPoint,logicInitial_start,logicInitial_end,logicInitial_actual);
                                        }
                                        int difference = logicClick -_initialPoint;
                                        int next_end = difference + logicInitial_end;
                                        int next_start = difference + logicInitial_start;
                                        int next_actual = difference + logicInitial_actual;
                                        
                                        /*SIL//fprintf(f,"diff:%d, next_end%d, next_start%d, next_actual%d \n", difference,next_end,next_start,next_actual);
                                        fclose(f);*/
                                        
                                        //if actual is not fixed to be in the middle
                                        if( ((logicClick>next_start) && (logicClick<next_end)&& (next_end<=_max)&& (next_start>=_min)) && !_in_rangeProperty)
                                        {
                                                SetStart(next_start);
                                                SetEnd(next_end);
                                                if( _moveActualWithBar )
                                                {
                                                        SetActual (next_actual);
                                                        //-------------------------------------------
                                                        //Sending the event of actual triangle moved
                                                        //-------------------------------------------
                                                        createAndSendEvent( wxEVT_TSBAR_ACTUAL );
                                                }
                                                RefreshForce();
                                                RefreshHorizontalView();        
                                                                                        
                                                //-------------------------------------------
                                                // Sending the event that the bar ahs being moved
                                                //-------------------------------------------
                                                createAndSendEvent( wxEVT_TSBAR_MOVED );
                                        }
                                        //if actual has to be between start and end
                                        else if(_in_rangeProperty && ((next_start<=GetActual()) && (next_end>=GetActual()) && (next_end<=_max)&& (next_start>=_min)) )
                                        {
                                                SetStart(next_start);
                                                SetEnd(next_end);
                                                if( _moveActualWithBar )
                                                {
                                                        SetActual (next_actual);
                                                        //-------------------------------------------
                                                        //Sending the event of actual triangle moved
                                                        //-------------------------------------------
                                                        createAndSendEvent( wxEVT_TSBAR_ACTUAL );
                                                }
                                                RefreshForce();
                                                RefreshHorizontalView();        
                                                
                                                //-------------------------------------------
                                                // Sending the event that the bar ahs being moved
                                                //-------------------------------------------
                                                createAndSendEvent( wxEVT_TSBAR_MOVED );
                                        }
                                }                       
                        }
                        if( !event.LeftIsDown())
                        {
                                _initialPoint=0;
                                _selectionMoveId = -1;
                                RefreshForce();
                                //-------------------------------------------
                                //Sending a general event just because
                                //-------------------------------------------
                                //SIL//createAndSendEvent( wxEVT_TSBAR );
                                createAndSendEvent(wxEVT_SELECTION_END);
                        }
                }                               
        }       

// EED Borrame
//ff=fopen ("c:/temp/xxx.txt", "a+");
//fprintf( ff , "  mBarRange :: OnMouseMove 02\n" );
//fclose(ff);

}
/*
* Sets the represented minimum and maximunm values
* param minRealValue The minimum represented value (real value)
* param maxRealValue The maximum represented value (real value)
*/
void mBarRange :: setRepresentedValues ( double minRealValue, double maxRealValue)
{
        _min = minRealValue;
        _max = maxRealValue;
        _start=_min;
        _end=_max;
}

/*
* Sets the property for viewing or not the bar labels information
*/
void mBarRange :: setVisibleLabels ( bool setVisibleLB )
{
        _visibleLables = setVisibleLB;
}

/*
        * Sets the property for viewing or not the bar labels information
        * return _visibleLables The state of visible labels or not 
        */
        bool mBarRange ::getIfVisibleLabels ()
        {
                return _visibleLables;
        }

        void mBarRange :: setDeviceBlitStart ( wxCoord devStart_x, wxCoord devStart_y )
        {
                deviceStart_x = devStart_x;
                deviceStart_y = devStart_y;
                // For the initialization case
                if (GetPixelEnd()<0)
                {
                        if (_orientation)
                        {
                                SetPixelStart(deviceStart_x);
                                SetPixelEnd(_w+deviceStart_x);
                                SetPixelActual(deviceStart_x);
                        }
                        else
                        {
                                SetPixelStart(deviceStart_x);
                                SetPixelEnd(_h+deviceStart_x);
                                SetPixelActual(deviceStart_x);
                        }
                }
                DrawBar();
        }
        
        void mBarRange :: onShowPopupMenu (wxMouseEvent& event)
        {
                if (activeState)
                {
                        bool validClic = false;
                        if (_orientation)
                        {
                                validClic = event.GetX() >= deviceStart_x && event.GetY()<= (_h + deviceStart_y);
                        }
                        else
                        {
                                validClic = event.GetX()>=deviceStart_y && event.GetX()<= (_h+deviceStart_y) && event.GetY()>deviceStart_x;
                        }
                        if (validClic)
                        {
                                if(_orientation)
                                        setClickedX(event.GetX());
                                else
                                        setClickedX(event.GetY());

                                if (getClickedX()<=_h)
                                {                                               
                                        bool in_StartTri = (clickedX>=GetPixelStart()-5+ deviceStart_x) && (clickedX<=GetPixelStart()+5+ deviceStart_x);
                                        bool in_EndTri = (clickedX>=GetPixelEnd()-5+ deviceStart_x) && (clickedX<=GetPixelEnd()+5+ deviceStart_x);
                                        bool in_actualT= (clickedX>=GetPixelActual()-5+ deviceStart_x) && (clickedX<=GetPixelActual()+5+ deviceStart_x);
                                        bool in_movingBar = (clickedX>GetPixelStart()+5+ deviceStart_x) && (clickedX<GetPixelEnd()-5+ deviceStart_x);

                                        if(in_StartTri)
                                                _selectionMoveId = 1;
                                        else if( in_EndTri )
                                                _selectionMoveId = 2;
                                        else if( in_actualT )
                                                _selectionMoveId = 3;
                                        else if( in_movingBar )
                                                _selectionMoveId = 4;
                                }                               
                                PopupMenu( &b_popmenu, event.GetX(), event.GetY());
                        }               
                }
        }
        
        void mBarRange :: onChangePartColor ( wxCommandEvent& anEvent )
        {
                bool okSelectedColor = false;
                wxColour selectedColour;
                wxColourData data;
                wxColourDialog dialog( GetParent(), &data);

                if ( dialog.ShowModal() == wxID_OK )
                {
                        selectedColour = dialog.GetColourData().GetColour();
                        okSelectedColor = true;
                }
                if( okSelectedColor )
                {
                        if (_selectionMoveId==1 )
                                start_Colour = selectedColour;
                        else if (_selectionMoveId==2 )
                                end_Colour = selectedColour;
                        else if( _selectionMoveId==3 )
                                actual_Colour = selectedColour;
                        else if( _selectionMoveId==4 )
                                bar_Colour = selectedColour;            
                }
                _selectionMoveId = -1;
        RefreshForce();
                
        }
        
        void mBarRange :: onEnableRange_Actual ( wxCommandEvent& anEvent )
        {
                if (!_in_rangeProperty)
                {
                        if(IsActualInRange())
                        {
                                SetInRangeProperty (true);
                                b_popmenu.SetLabel (cntID_ENABLE_ACTUAL, _T("Disable actual in range"));
                        }
                }
                else
                {
                        SetInRangeProperty (false);
                        b_popmenu.SetLabel (cntID_ENABLE_ACTUAL, _T("Enable actual in range"));                 
                }
        }

        void  mBarRange :: onMovable_ActualWithBar ( wxCommandEvent& anEvent )
        {
                if (_moveActualWithBar )
                {
                        _moveActualWithBar = false;
                        b_popmenu.SetLabel (cntID_MOVABLE_ACTUAL_BAR, _T("Move actual+bar simultaneously"));
                }
                else
                {
                        if(IsActualInRange())
                        {
                                _moveActualWithBar = true;
                                b_popmenu.SetLabel (cntID_MOVABLE_ACTUAL_BAR, _T("Move actual-bar independent"));
                        }
                }
        }

                /*
        * Set active state 
        * param activeNow The new state
        */
        void mBarRange :: setActiveStateTo (bool activeNow)
        {
                activeState = activeNow;
        }
        
        /*
        * Gets the active state of the bar
        *  return activeState The actual state
        */
        bool mBarRange :: isActive()
        {
                return activeState;
        }

        /*
        * Gets the real-x value to draw a vertical line
        * return realX_vertical_line The real x value for the vertical line
        */
        int     mBarRange :: getRealX_vertical_line()
        {
                return realX_vertical_line;
        }

        /*
        * Sets the real-x value to draw a vertical line
        * param newReal_x The new real x value for the vertical line
        */
        void mBarRange :: setRealX_vertical_line(int newReal_x)
        {
                realX_vertical_line = newReal_x;
        }

        /*
        * Gets the device value form the end of this panel to the end of the drawing area in the device in pixels
        * return deviceEndMargin The value asigned to the right margin
        */
        int     mBarRange :: getDeviceEndX()
        {
                return deviceEndMargin;
        }

        /*
        * Sets the new device (deviceEndMargin) value form the end of this panel to the end of the drawing area in the device
        * param newDeviceEnd_pixels The new pixel value to asign to the right(horizontal view), underneath(vertical view) margin in pixels
        */
        void mBarRange :: setDeviceEndMargin(int newDeviceEnd_pixels)
        {
                deviceEndMargin = newDeviceEnd_pixels;
        }

        /*
        * Gets the last clickedX pixel coord inside the bar with respect to the container panel.
        * return clickedX The x-coord pixel value
        */
        int mBarRange :: getClickedX()
        {
                return clickedX;
        }

        /*
        * Sets the last clickedX pixel coord inside the bar with respect to the container panel.
        * param nwClickX The x-coord pixel value
        */
        void mBarRange :: setClickedX(int nwClickX)
        {
                clickedX = nwClickX;
        }


                /*
        * Gets the start porcentage with respect to the represented values of the bar
        * return The porcentage represented by the start  showing point
        */
        float mBarRange :: getStartShowPorcentage()
        {
                return (float)( 1+(_start - _max)/(_max-_min));
        }

        /*
        * Gets the end porcentage with respect to the represented values of the bar
        * return The porcentage represented by the end showing point
        */
        float mBarRange :: getEndShowPorcentage()
        {
                return (float) (1+(_end - _max)/(_max-_min));
        }

        /*
        * Gets the actual porcentage with respect to the represented values of the bar
        * return The porcentage represented by the actual  showing point
        */
        float mBarRange :: getActualShowPorcentage()
        {
                return (float) (1+(_actual - _max)/(_max-_min));
        }

        int mBarRange :: getLogicValueofPixel(int thePixel)
        {
                return _min+((thePixel - deviceStart_x)*( _max - _min))/(_w-deviceEndMargin);
        }

        /*
        * Sets the condition for knowing if the actual triangle is being drawed or not
        * param drawActual The condition to set for drawing or not the actual control (true for drawing)
        */
        void mBarRange :: setIfWithActualDrawed(bool drawActual)
        {
                if(!withActualDrawed && drawActual)
                {       
                        b_popmenu.Append (cntID_ENABLE_ACTUAL, _("Enable actual in range"), _("Enables/Disables the actual triangle to be or not in range"));
                        b_popmenu.Append (cntID_MOVABLE_ACTUAL_BAR, _("Move actual-bar simultaneously"), _("Disables the actual triangle to move with the bar"));               
                }
                else if (withActualDrawed && !drawActual)
                {
                        b_popmenu.Remove(cntID_ENABLE_ACTUAL);
                        b_popmenu.Remove(cntID_MOVABLE_ACTUAL_BAR);
                }
                withActualDrawed = drawActual;
                Refresh();      
        }

        /*
        * Gets the condition for knowing if the actual triangle is being drawed or not
        * return withActualDrawed The condition for drawing or not the actual control
        */
        bool mBarRange :: getIfWithActualDrawed()
        {
                return withActualDrawed;
        }

        void mBarRange::createAndSendEvent(WXTYPE theEventType)
        {
                wxCommandEvent cevent( theEventType, GetId() );
                cevent.SetEventObject( this );
                GetEventHandler()->ProcessEvent( cevent );
        }

        /*
        * Sets the background color od the bar
        * theColor The color to set to the backgroundColor
        */
        void mBarRange :: setBackgroundColor(wxColour theColor)
        {
                backgroundColor = theColor;
        }

        /*
        * Sets the guide line color
        * param theNwGuideLineColor The color to set to the guideLineColor
        */
        void mBarRange :: setGuideLineColour(wxColour theNwGuideLineColor)
        {
                guideLineColor = theNwGuideLineColor;
        }

        /*
        * Gets the guide line color
        * return guideLineColor The color of the guideLine
        */
        wxColour mBarRange :: getGuideLineColour()
        {
                return guideLineColor;
        }

        void  mBarRange ::onLeftClicDown(wxMouseEvent& event )
        {
                acceptedClick = true;           
        }

        void  mBarRange ::onLeftClickUp(wxMouseEvent& event )
        {       
                acceptedClick = false;
        }