contrib/src/plot/plot.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        plot.cpp
   3 // Purpose:     wxPlotWindow
   4 // Author:      Robert Roebling
   5 // Modified by:
   6 // Created:     12/01/2000
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Robert Roebling
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // For compilers that support precompilation, includes "wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifdef __BORLANDC__
  16 #pragma hdrstop
  17 #endif
  18
  19 #ifndef WX_PRECOMP
  20 #include "wx/object.h"
  21 #include "wx/font.h"
  22 #include "wx/colour.h"
  23 #include "wx/settings.h"
  24 #include "wx/sizer.h"
  25 #include "wx/log.h"
  26 #include "wx/intl.h"
  27 #include "wx/dcclient.h"
  28 #include "wx/stattext.h"
  29 #endif
  30
  31 #include "wx/plot/plot.h"
  32 #include "wx/bmpbuttn.h"
  33 #include "wx/module.h"
  34
  35 #include <math.h>
  36
  37 // ----------------------------------------------------------------------------
  38 // XPMs
  39 // ----------------------------------------------------------------------------
  40
  41 #if !defined(__WXMSW__) && !defined(__WXPM__)
  42     #include "wx/plot/plot_enl.xpm"
  43     #include "wx/plot/plot_shr.xpm"
  44     #include "wx/plot/plot_zin.xpm"
  45     #include "wx/plot/plot_zot.xpm"
  46     #include "wx/plot/plot_up.xpm"
  47     #include "wx/plot/plot_dwn.xpm"
  48 #endif
  49
  50 //----------------------------------------------------------------------------
  51 // event types
  52 //----------------------------------------------------------------------------
  53
  54 DEFINE_EVENT_TYPE(wxEVT_PLOT_SEL_CHANGING)
  55 DEFINE_EVENT_TYPE(wxEVT_PLOT_SEL_CHANGED)
  56 DEFINE_EVENT_TYPE(wxEVT_PLOT_CLICKED)
  57 DEFINE_EVENT_TYPE(wxEVT_PLOT_DOUBLECLICKED)
  58 DEFINE_EVENT_TYPE(wxEVT_PLOT_ZOOM_IN)
  59 DEFINE_EVENT_TYPE(wxEVT_PLOT_ZOOM_OUT)
  60 DEFINE_EVENT_TYPE(wxEVT_PLOT_VALUE_SEL_CREATING)
  61 DEFINE_EVENT_TYPE(wxEVT_PLOT_VALUE_SEL_CREATED)
  62 DEFINE_EVENT_TYPE(wxEVT_PLOT_VALUE_SEL_CHANGING)
  63 DEFINE_EVENT_TYPE(wxEVT_PLOT_VALUE_SEL_CHANGED)
  64 DEFINE_EVENT_TYPE(wxEVT_PLOT_AREA_SEL_CREATING)
  65 DEFINE_EVENT_TYPE(wxEVT_PLOT_AREA_SEL_CREATED)
  66 DEFINE_EVENT_TYPE(wxEVT_PLOT_AREA_SEL_CHANGING)
  67 DEFINE_EVENT_TYPE(wxEVT_PLOT_AREA_SEL_CHANGED)
  68 DEFINE_EVENT_TYPE(wxEVT_PLOT_BEGIN_X_LABEL_EDIT)
  69 DEFINE_EVENT_TYPE(wxEVT_PLOT_END_X_LABEL_EDIT)
  70 DEFINE_EVENT_TYPE(wxEVT_PLOT_BEGIN_Y_LABEL_EDIT)
  71 DEFINE_EVENT_TYPE(wxEVT_PLOT_END_Y_LABEL_EDIT)
  72 DEFINE_EVENT_TYPE(wxEVT_PLOT_BEGIN_TITLE_EDIT)
  73 DEFINE_EVENT_TYPE(wxEVT_PLOT_END_TITLE_EDIT)
  74 DEFINE_EVENT_TYPE(wxEVT_PLOT_AREA_CREATE)
  75
  76 //----------------------------------------------------------------------------
  77 // accessor functions for the bitmaps (may return NULL, check for it!)
  78 //----------------------------------------------------------------------------
  79
  80 static wxBitmap *GetEnlargeBitmap();
  81 static wxBitmap *GetShrinkBitmap();
  82 static wxBitmap *GetZoomInBitmap();
  83 static wxBitmap *GetZoomOutBitmap();
  84 static wxBitmap *GetUpBitmap();
  85 static wxBitmap *GetDownBitmap();
  86
  87 //-----------------------------------------------------------------------------
  88 // consts
  89 //-----------------------------------------------------------------------------
  90
  91 #define wxPLOT_SCROLL_STEP  30
  92
  93 //-----------------------------------------------------------------------------
  94 // wxPlotEvent
  95 //-----------------------------------------------------------------------------
  96
  97 wxPlotEvent::wxPlotEvent( wxEventType commandType, int id )
  98     : wxNotifyEvent( commandType, id )
  99 {
 100     m_curve = (wxPlotCurve*) NULL;
 101     m_zoom = 1.0;
 102     m_position = 0;
 103 }
 104
 105 //-----------------------------------------------------------------------------
 106 // wxPlotCurve
 107 //-----------------------------------------------------------------------------
 108
 109 IMPLEMENT_ABSTRACT_CLASS(wxPlotCurve, wxObject)
 110
 111 wxPlotCurve::wxPlotCurve( int offsetY, double startY, double endY )
 112 : m_penNormal(*wxGREY_PEN), m_penSelected(*wxBLACK_PEN)
 113 {
 114     m_offsetY = offsetY;
 115     m_startY = startY;
 116     m_endY = endY;
 117 }
 118
 119 //-----------------------------------------------------------------------------
 120 // wxPlotOnOffCurve
 121 //-----------------------------------------------------------------------------
 122
 123 IMPLEMENT_CLASS(wxPlotOnOffCurve, wxObject)
 124
 125 #include "wx/arrimpl.cpp"
 126 WX_DEFINE_OBJARRAY(wxArrayPlotOnOff);
 127
 128 wxPlotOnOffCurve::wxPlotOnOffCurve( int offsetY )
 129 {
 130     m_offsetY = offsetY;
 131     m_minX = -1;
 132     m_maxX = -1;
 133 }
 134
 135 void wxPlotOnOffCurve::Add( wxInt32 on, wxInt32 off, void *clientData )
 136 {
 137     wxASSERT_MSG( on > 0, _T("plot index < 0") );
 138     wxASSERT( on <= off );
 139
 140     if (m_minX == -1)
 141         m_minX = on;
 142     if (off > m_maxX)
 143         m_maxX = off;
 144
 145     wxPlotOnOff *v = new wxPlotOnOff;
 146     v->m_on = on;
 147     v->m_off = off;
 148     v->m_clientData = clientData;
 149     m_marks.Add( v );
 150 }
 151
 152 size_t wxPlotOnOffCurve::GetCount()
 153 {
 154     return m_marks.GetCount();
 155 }
 156
 157 wxInt32 wxPlotOnOffCurve::GetOn( size_t index )
 158 {
 159     wxPlotOnOff *v = &m_marks.Item( index );
 160     return v->m_on;
 161 }
 162
 163 wxInt32 wxPlotOnOffCurve::GetOff( size_t index )
 164 {
 165     wxPlotOnOff *v = &m_marks.Item( index );
 166     return v->m_off;
 167 }
 168
 169 void* wxPlotOnOffCurve::GetClientData( size_t index )
 170 {
 171     wxPlotOnOff *v = &m_marks.Item( index );
 172     return v->m_clientData;
 173 }
 174
 175 wxPlotOnOff *wxPlotOnOffCurve::GetAt( size_t index )
 176 {
 177     return &m_marks.Item( index );
 178 }
 179
 180 void wxPlotOnOffCurve::DrawOnLine( wxDC &dc, wxCoord y, wxCoord start, wxCoord end, void *WXUNUSED(clientData) )
 181 {
 182     dc.DrawLine( start, y, start, y-30 );
 183     dc.DrawLine( start, y-30, end, y-30 );
 184     dc.DrawLine( end, y-30, end, y );
 185 }
 186
 187 void wxPlotOnOffCurve::DrawOffLine( wxDC &dc, wxCoord y, wxCoord start, wxCoord end )
 188 {
 189     dc.DrawLine( start, y, end, y );
 190 }
 191
 192 //-----------------------------------------------------------------------------
 193 // wxPlotArea
 194 //-----------------------------------------------------------------------------
 195
 196 IMPLEMENT_DYNAMIC_CLASS(wxPlotArea, wxWindow)
 197
 198 BEGIN_EVENT_TABLE(wxPlotArea, wxWindow)
 199     EVT_PAINT(        wxPlotArea::OnPaint)
 200     EVT_LEFT_DOWN(    wxPlotArea::OnMouse)
 201     EVT_LEFT_DCLICK(  wxPlotArea::OnMouse)
 202 END_EVENT_TABLE()
 203
 204 wxPlotArea::wxPlotArea( wxPlotWindow *parent )
 205         : wxWindow( parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxSIMPLE_BORDER, _T("plotarea") )
 206 {
 207     m_owner = parent;
 208
 209     m_zooming = false;
 210
 211     SetBackgroundColour( *wxWHITE );
 212 }
 213
 214 void wxPlotArea::OnMouse( wxMouseEvent &event )
 215 {
 216     int client_width;
 217     int client_height;
 218     GetClientSize( &client_width, &client_height);
 219     int view_x;
 220     int view_y;
 221     m_owner->GetViewStart( &view_x, &view_y );
 222     view_x *= wxPLOT_SCROLL_STEP;
 223     view_y *= wxPLOT_SCROLL_STEP;
 224
 225     wxCoord x = event.GetX();
 226     wxCoord y = event.GetY();
 227     x += view_x;
 228     y += view_y;
 229
 230     wxList::compatibility_iterator node = m_owner->m_curves.GetFirst();
 231     while (node)
 232     {
 233         wxPlotCurve *curve = (wxPlotCurve*)node->GetData();
 234
 235         double double_client_height = (double)client_height;
 236         double range = curve->GetEndY() - curve->GetStartY();
 237         double end = curve->GetEndY();
 238         wxCoord offset_y = curve->GetOffsetY();
 239
 240         double dy = (end - curve->GetY( (wxInt32)(x/m_owner->GetZoom()) )) / range;
 241         wxCoord curve_y = (wxCoord)(dy * double_client_height) - offset_y - 1;
 242
 243         if ((y-curve_y < 4) && (y-curve_y > -4))
 244         {
 245             wxPlotEvent event1( event.ButtonDClick() ? wxEVT_PLOT_DOUBLECLICKED : wxEVT_PLOT_CLICKED, m_owner->GetId() );
 246             event1.SetEventObject( m_owner );
 247             event1.SetZoom( m_owner->GetZoom() );
 248             event1.SetCurve( curve );
 249             event1.SetPosition( (int)floor(x/m_owner->GetZoom()) );
 250             m_owner->GetEventHandler()->ProcessEvent( event1 );
 251
 252             if (curve != m_owner->GetCurrentCurve())
 253             {
 254                 wxPlotEvent event2( wxEVT_PLOT_SEL_CHANGING, m_owner->GetId() );
 255                 event2.SetEventObject( m_owner );
 256                 event2.SetZoom( m_owner->GetZoom() );
 257                 event2.SetCurve( curve );
 258                 if (!m_owner->GetEventHandler()->ProcessEvent( event2 ) || event2.IsAllowed())
 259                 {
 260                     m_owner->SetCurrentCurve( curve );
 261                 }
 262             }
 263             return;
 264         }
 265
 266         node = node->GetNext();
 267     }
 268 }
 269
 270 void wxPlotArea::DeleteCurve( wxPlotCurve *curve, int from, int to )
 271 {
 272     wxClientDC dc(this);
 273     m_owner->PrepareDC( dc );
 274     dc.SetPen( *wxWHITE_PEN );
 275     DrawCurve( &dc, curve, from, to );
 276 }
 277
 278 void wxPlotArea::DrawCurve( wxDC *dc, wxPlotCurve *curve, int from, int to )
 279 {
 280     int view_x;
 281     int view_y;
 282     m_owner->GetViewStart( &view_x, &view_y );
 283     view_x *= wxPLOT_SCROLL_STEP;
 284
 285     if (from == -1)
 286         from = view_x;
 287
 288     int client_width;
 289     int client_height;
 290     GetClientSize( &client_width, &client_height);
 291
 292     if (to == -1)
 293         to = view_x + client_width;
 294
 295     double zoom = m_owner->GetZoom();
 296
 297     int start_x = wxMax( from, (int)floor(curve->GetStartX()*zoom) );
 298     int end_x = wxMin( to, (int)floor(curve->GetEndX()*zoom) );
 299
 300     start_x = wxMax( view_x, start_x );
 301     end_x = wxMin( view_x + client_width, end_x );
 302
 303     end_x++;
 304
 305     double double_client_height = (double)client_height;
 306     double range = curve->GetEndY() - curve->GetStartY();
 307     double end = curve->GetEndY();
 308     wxCoord offset_y = curve->GetOffsetY();
 309
 310     wxCoord last_y=0;
 311     for (int x = start_x; x < end_x; x++)
 312     {
 313         double dy = (end - curve->GetY( (wxInt32)(x/zoom) )) / range;
 314         wxCoord y = (wxCoord)(dy * double_client_height) - offset_y - 1;
 315
 316         if (x != start_x)
 317            dc->DrawLine( x-1, last_y, x, y );
 318
 319         last_y = y;
 320     }
 321 }
 322
 323 void wxPlotArea::DrawOnOffCurve( wxDC *dc, wxPlotOnOffCurve *curve, int from, int to )
 324 {
 325     int view_x;
 326     int view_y;
 327     m_owner->GetViewStart( &view_x, &view_y );
 328     view_x *= wxPLOT_SCROLL_STEP;
 329
 330     if (from == -1)
 331         from = view_x;
 332
 333     int client_width;
 334     int client_height;
 335     GetClientSize( &client_width, &client_height);
 336
 337     if (to == -1)
 338         to = view_x + client_width;
 339
 340     double zoom = m_owner->GetZoom();
 341
 342     int start_x = wxMax( from, (int)floor(curve->GetStartX()*zoom) );
 343     int end_x = wxMin( to, (int)floor(curve->GetEndX()*zoom) );
 344
 345     start_x = wxMax( view_x, start_x );
 346     end_x = wxMin( view_x + client_width, end_x );
 347
 348     end_x++;
 349
 350     wxCoord offset_y = curve->GetOffsetY();
 351     wxCoord last_off = -5;
 352
 353     if (curve->GetCount() == 0)
 354         return;
 355
 356     for (size_t index = 0; index < curve->GetCount(); index++)
 357     {
 358         wxPlotOnOff *p = curve->GetAt( index );
 359
 360         wxCoord on = (wxCoord)(p->m_on*zoom);
 361         wxCoord off = (wxCoord)(p->m_off*zoom);
 362
 363         if (end_x < on)
 364         {
 365             curve->DrawOffLine( *dc, client_height-offset_y, last_off, on );
 366             break;
 367         }
 368
 369         if (off >= start_x)
 370         {
 371             curve->DrawOffLine( *dc, client_height-offset_y, last_off, on );
 372             curve->DrawOnLine( *dc, client_height-offset_y, on, off, p->m_clientData );
 373         }
 374         last_off = off;
 375     }
 376
 377     wxPlotOnOff *p = curve->GetAt( curve->GetCount()-1 );
 378     wxCoord off = (wxCoord)(p->m_off*zoom);
 379     if (off < end_x)
 380         curve->DrawOffLine( *dc, client_height-offset_y, off, to );
 381 }
 382
 383 void wxPlotArea::OnPaint( wxPaintEvent &WXUNUSED(event) )
 384 {
 385     int view_x;
 386     int view_y;
 387     m_owner->GetViewStart( &view_x, &view_y );
 388     view_x *= wxPLOT_SCROLL_STEP;
 389     view_y *= wxPLOT_SCROLL_STEP;
 390
 391     wxPaintDC dc( this );
 392     m_owner->PrepareDC( dc );
 393
 394     wxRegionIterator upd( GetUpdateRegion() );
 395
 396     while (upd)
 397     {
 398         int update_x = upd.GetX() + view_x;
 399         int update_width = upd.GetWidth();
 400
 401 /*
 402         if (m_owner->m_current)
 403         {
 404             dc.SetPen( *wxLIGHT_GREY_PEN );
 405             int base_line = client_height - m_owner->m_current->GetOffsetY();
 406             dc.DrawLine( update_x-1, base_line-1, update_x+update_width+2, base_line-1 );
 407         }
 408 */
 409
 410         wxList::compatibility_iterator node = m_owner->m_curves.GetFirst();
 411         while (node)
 412         {
 413             wxPlotCurve *curve = (wxPlotCurve*) node->GetData();
 414
 415             if (curve == m_owner->GetCurrentCurve())
 416                 dc.SetPen( curve->GetPenSelected() );
 417             else
 418                 dc.SetPen( curve->GetPenNormal() );
 419
 420             DrawCurve( &dc, curve, update_x-1, update_x+update_width+2 );
 421
 422             node = node->GetNext();
 423         }
 424
 425         dc.SetPen( *wxRED_PEN );
 426
 427         node = m_owner->m_onOffCurves.GetFirst();
 428         while (node)
 429         {
 430             wxPlotOnOffCurve *curve = (wxPlotOnOffCurve*) node->GetData();
 431
 432             DrawOnOffCurve( &dc, curve, update_x-1, update_x+update_width+2 );
 433
 434             node = node->GetNext();
 435         }
 436
 437         upd ++;
 438     }
 439 }
 440
 441 void wxPlotArea::ScrollWindow( int dx, int dy, const wxRect *rect )
 442 {
 443     wxWindow::ScrollWindow( dx, dy, rect );
 444 //    m_owner->m_xaxis->ScrollWindow( dx, 0 );
 445 }
 446
 447 //-----------------------------------------------------------------------------
 448 // wxPlotXAxisArea
 449 //-----------------------------------------------------------------------------
 450
 451 IMPLEMENT_DYNAMIC_CLASS(wxPlotXAxisArea, wxWindow)
 452
 453 BEGIN_EVENT_TABLE(wxPlotXAxisArea, wxWindow)
 454   EVT_PAINT(        wxPlotXAxisArea::OnPaint)
 455   EVT_LEFT_DOWN(    wxPlotXAxisArea::OnMouse)
 456 END_EVENT_TABLE()
 457
 458 wxPlotXAxisArea::wxPlotXAxisArea( wxPlotWindow *parent )
 459         : wxWindow( parent, wxID_ANY, wxDefaultPosition, wxSize(wxDefaultCoord,40), 0, _T("plotxaxisarea") )
 460 {
 461     m_owner = parent;
 462
 463     SetBackgroundColour( *wxWHITE );
 464     SetFont( *wxSMALL_FONT );
 465 }
 466
 467 void wxPlotXAxisArea::OnMouse( wxMouseEvent &event )
 468 {
 469     int client_width;
 470     int client_height;
 471     GetClientSize( &client_width, &client_height);
 472     int view_x;
 473     int view_y;
 474     m_owner->GetViewStart( &view_x, &view_y );
 475     view_x *= wxPLOT_SCROLL_STEP;
 476     view_y *= wxPLOT_SCROLL_STEP;
 477
 478     wxCoord x = event.GetX() + view_x;
 479     wxCoord y = event.GetY() + view_y;
 480
 481     /* TO DO: do something here */
 482     wxUnusedVar(x);
 483     wxUnusedVar(y);
 484 }
 485
 486 void wxPlotXAxisArea::OnPaint( wxPaintEvent &WXUNUSED(event) )
 487 {
 488     int view_x;
 489     int view_y;
 490     m_owner->GetViewStart( &view_x, &view_y );
 491     view_x *= wxPLOT_SCROLL_STEP;
 492     view_y *= wxPLOT_SCROLL_STEP;
 493
 494     wxPaintDC dc( this );
 495
 496     int client_width;
 497     int client_height;
 498     GetClientSize( &client_width, &client_height);
 499
 500     double zoom = m_owner->GetZoom();
 501
 502     double ups = m_owner->GetUnitsPerValue() / zoom;
 503
 504     double start = view_x * ups;
 505     double end = (view_x + client_width) * ups;
 506     double range = end - start;
 507
 508     int int_log_range = (int)floor( log10( range ) );
 509     double step = 1.0;
 510     if (int_log_range > 0)
 511     {
 512         for (int i = 0; i < int_log_range; i++)
 513            step *= 10;
 514     }
 515     if (int_log_range < 0)
 516     {
 517         for (int i = 0; i < -int_log_range; i++)
 518            step /= 10;
 519     }
 520     double lower = ceil(start / step) * step;
 521     double upper = floor(end / step) * step;
 522
 523     // if too few values, shrink size
 524     if ((range/step) < 4)
 525     {
 526         step /= 2;
 527         if (lower-step > start) lower -= step;
 528         if (upper+step < end) upper += step;
 529     }
 530
 531     // if still too few, again
 532     if ((range/step) < 4)
 533     {
 534         step /= 2;
 535         if (lower-step > start) lower -= step;
 536         if (upper+step < end) upper += step;
 537     }
 538
 539     dc.SetBrush( *wxWHITE_BRUSH );
 540     dc.SetPen( *wxTRANSPARENT_PEN );
 541     dc.DrawRectangle( 4, 5, client_width-14, 10 );
 542     dc.DrawRectangle( 0, 20, client_width, 20 );
 543     dc.SetPen( *wxBLACK_PEN );
 544
 545     double current = lower;
 546     while (current < upper+(step/2))
 547     {
 548         int x = (int)ceil((current-start) / range * (double)client_width) - 1;
 549         if ((x > 4) && (x < client_width-25))
 550         {
 551             dc.DrawLine( x, 5, x, 15 );
 552             wxString label;
 553             if (range < 50)
 554             {
 555                 label.Printf( _T("%f"), current );
 556                 while (label.Last() == _T('0'))
 557                     label.RemoveLast();
 558                 if ((label.Last() == _T('.')) || (label.Last() == _T(',')))
 559                     label.Append( _T('0') );
 560             }
 561             else
 562                 label.Printf( _T("%d"), (int)floor(current) );
 563             dc.DrawText( label, x-4, 20 );
 564         }
 565
 566         current += step;
 567     }
 568
 569     dc.DrawLine( 0, 15, client_width-8, 15 );
 570     dc.DrawLine( client_width-4, 15, client_width-10, 10 );
 571     dc.DrawLine( client_width-4, 15, client_width-10, 20 );
 572 }
 573
 574 //-----------------------------------------------------------------------------
 575 // wxPlotYAxisArea
 576 //-----------------------------------------------------------------------------
 577
 578 IMPLEMENT_DYNAMIC_CLASS(wxPlotYAxisArea, wxWindow)
 579
 580 BEGIN_EVENT_TABLE(wxPlotYAxisArea, wxWindow)
 581   EVT_PAINT(        wxPlotYAxisArea::OnPaint)
 582   EVT_LEFT_DOWN(    wxPlotYAxisArea::OnMouse)
 583 END_EVENT_TABLE()
 584
 585 wxPlotYAxisArea::wxPlotYAxisArea( wxPlotWindow *parent )
 586         : wxWindow( parent, wxID_ANY, wxDefaultPosition, wxSize(60,wxDefaultCoord), 0, _T("plotyaxisarea") )
 587 {
 588     m_owner = parent;
 589
 590     SetBackgroundColour( *wxWHITE );
 591     SetFont( *wxSMALL_FONT );
 592 }
 593
 594 void wxPlotYAxisArea::OnMouse( wxMouseEvent &WXUNUSED(event) )
 595 {
 596     /* do something here */
 597 }
 598
 599 void wxPlotYAxisArea::OnPaint( wxPaintEvent &WXUNUSED(event) )
 600 {
 601     wxPaintDC dc( this );
 602
 603     wxPlotCurve *curve = m_owner->GetCurrentCurve();
 604
 605     if (!curve) return;
 606
 607     int client_width;
 608     int client_height;
 609     GetClientSize( &client_width, &client_height);
 610
 611
 612     double range = curve->GetEndY() - curve->GetStartY();
 613     double offset = ((double) curve->GetOffsetY() / (double)client_height ) * range;
 614     double start = curve->GetStartY() - offset;
 615     double end = curve->GetEndY() - offset;
 616
 617     int int_log_range = (int)floor( log10( range ) );
 618     double step = 1.0;
 619     if (int_log_range > 0)
 620     {
 621         for (int i = 0; i < int_log_range; i++)
 622            step *= 10;
 623     }
 624     if (int_log_range < 0)
 625     {
 626         for (int i = 0; i < -int_log_range; i++)
 627            step /= 10;
 628     }
 629     double lower = ceil(start / step) * step;
 630     double upper = floor(end / step) * step;
 631
 632     // if too few values, shrink size
 633     if ((range/step) < 4)
 634     {
 635         step /= 2;
 636         if (lower-step > start) lower -= step;
 637         if (upper+step < end) upper += step;
 638     }
 639
 640     // if still too few, again
 641     if ((range/step) < 4)
 642     {
 643         step /= 2;
 644         if (lower-step > start) lower -= step;
 645         if (upper+step < end) upper += step;
 646     }
 647
 648     dc.SetPen( *wxBLACK_PEN );
 649
 650     double current = lower;
 651     while (current < upper+(step/2))
 652     {
 653         int y = (int)((curve->GetEndY()-current) / range * (double)client_height) - 1;
 654         y -= curve->GetOffsetY();
 655         if ((y > 10) && (y < client_height-7))
 656         {
 657             dc.DrawLine( client_width-15, y, client_width-7, y );
 658             wxString label;
 659             if (range < 50)
 660             {
 661                 label.Printf( _T("%f"), current );
 662                 while (label.Last() == _T('0'))
 663                     label.RemoveLast();
 664                 if ((label.Last() == _T('.')) || (label.Last() == _T(',')))
 665                     label.Append( _T('0') );
 666             }
 667             else
 668                 label.Printf( _T("%d"), (int)floor(current) );
 669             dc.DrawText( label, 5, y-7 );
 670         }
 671
 672         current += step;
 673     }
 674
 675     dc.DrawLine( client_width-15, 6, client_width-15, client_height );
 676     dc.DrawLine( client_width-15, 2, client_width-20, 8 );
 677     dc.DrawLine( client_width-15, 2, client_width-10, 8 );
 678 }
 679
 680 //-----------------------------------------------------------------------------
 681 // wxPlotWindow
 682 //-----------------------------------------------------------------------------
 683
 684 #define  ID_ENLARGE       1000
 685 #define  ID_SHRINK        1002
 686
 687 #define  ID_MOVE_UP       1006
 688 #define  ID_MOVE_DOWN     1007
 689
 690 #define  ID_ZOOM_IN       1010
 691 #define  ID_ZOOM_OUT      1011
 692
 693
 694 IMPLEMENT_DYNAMIC_CLASS(wxPlotWindow, wxScrolledWindow)
 695
 696 BEGIN_EVENT_TABLE(wxPlotWindow, wxScrolledWindow)
 697     EVT_BUTTON(  ID_MOVE_UP,     wxPlotWindow::OnMoveUp)
 698     EVT_BUTTON(  ID_MOVE_DOWN,   wxPlotWindow::OnMoveDown)
 699
 700     EVT_BUTTON(  ID_ENLARGE,  wxPlotWindow::OnEnlarge)
 701     EVT_BUTTON(  ID_SHRINK,   wxPlotWindow::OnShrink)
 702
 703     EVT_BUTTON(  ID_ZOOM_IN,     wxPlotWindow::OnZoomIn)
 704     EVT_BUTTON(  ID_ZOOM_OUT,    wxPlotWindow::OnZoomOut)
 705
 706     EVT_SCROLLWIN( wxPlotWindow::OnScroll2)
 707 END_EVENT_TABLE()
 708
 709 wxPlotWindow::wxPlotWindow( wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size, int flag )
 710         : wxScrolledWindow( parent, id, pos, size, flag, _T("plotcanvas") ),
 711           m_titleStaticText( NULL )
 712 {
 713     m_xUnitsPerValue = 1.0;
 714     m_xZoom = 1.0;
 715
 716     m_enlargeAroundWindowCentre = false;
 717     m_scrollOnThumbRelease = false;
 718
 719     m_area = new wxPlotArea( this );
 720     wxBoxSizer *mainsizer = new wxBoxSizer( wxHORIZONTAL );
 721
 722     if ((GetWindowStyleFlag() & wxPLOT_BUTTON_ALL) != 0)
 723     {
 724         wxBoxSizer *buttonlist = new wxBoxSizer( wxVERTICAL );
 725         if ((GetWindowStyleFlag() & wxPLOT_BUTTON_ENLARGE) != 0)
 726         {
 727             buttonlist->Add( new wxBitmapButton( this, ID_ENLARGE, *GetEnlargeBitmap() ), 0, wxEXPAND|wxALL, 2 );
 728             buttonlist->Add( new wxBitmapButton( this, ID_SHRINK, *GetShrinkBitmap() ), 0, wxEXPAND|wxALL, 2 );
 729             buttonlist->Add( 20,10, 0 );
 730         }
 731         if ((GetWindowStyleFlag() & wxPLOT_BUTTON_MOVE) != 0)
 732         {
 733             buttonlist->Add( new wxBitmapButton( this, ID_MOVE_UP, *GetUpBitmap() ), 0, wxEXPAND|wxALL, 2 );
 734             buttonlist->Add( new wxBitmapButton( this, ID_MOVE_DOWN, *GetDownBitmap() ), 0, wxEXPAND|wxALL, 2 );
 735             buttonlist->Add( 20,10, 0 );
 736         }
 737         if ((GetWindowStyleFlag() & wxPLOT_BUTTON_ZOOM) != 0)
 738         {
 739             buttonlist->Add( new wxBitmapButton( this, ID_ZOOM_IN, *GetZoomInBitmap() ), 0, wxEXPAND|wxALL, 2 );
 740             buttonlist->Add( new wxBitmapButton( this, ID_ZOOM_OUT, *GetZoomOutBitmap() ), 0, wxEXPAND|wxALL, 2 );
 741         }
 742         mainsizer->Add( buttonlist, 0, wxEXPAND|wxALL, 4 );
 743     }
 744
 745     wxBoxSizer *plotsizer = new wxBoxSizer( wxHORIZONTAL );
 746
 747     //Add sizer to hold the title and plot.
 748     //Title to be added later.
 749     m_plotAndTitleSizer = new wxBoxSizer( wxVERTICAL );
 750     m_plotAndTitleSizer->Add( plotsizer, 1, wxEXPAND | wxTOP, 10 );
 751
 752     if ((GetWindowStyleFlag() & wxPLOT_Y_AXIS) != 0)
 753     {
 754         m_yaxis = new wxPlotYAxisArea( this );
 755
 756         wxBoxSizer *vert1 = new wxBoxSizer( wxVERTICAL );
 757         plotsizer->Add( vert1, 1, wxEXPAND|wxTOP,10 );
 758         vert1->Add( m_yaxis, 1 );
 759         if ((GetWindowStyleFlag() & wxPLOT_X_AXIS) != 0)
 760             vert1->Add( 60, 40 );
 761     }
 762     else
 763     {
 764         m_yaxis = (wxPlotYAxisArea*) NULL;
 765     }
 766
 767     if ((GetWindowStyleFlag() & wxPLOT_X_AXIS) != 0)
 768     {
 769         m_xaxis = new wxPlotXAxisArea( this );
 770
 771         wxBoxSizer *vert2 = new wxBoxSizer( wxVERTICAL );
 772         plotsizer->Add( vert2, 5, wxEXPAND);
 773         vert2->Add( m_area, 1, wxEXPAND|wxTOP,10 );
 774         vert2->Add( m_xaxis, 0, wxEXPAND );
 775     }
 776     else
 777     {
 778         plotsizer->Add( m_area, 1, wxEXPAND );
 779         m_xaxis = (wxPlotXAxisArea*) NULL;
 780     }
 781
 782     mainsizer->Add( m_plotAndTitleSizer, 1, wxEXPAND );
 783
 784     SetSizerAndFit( mainsizer );
 785
 786     SetTargetWindow( m_area );
 787
 788     SetBackgroundColour( *wxWHITE );
 789
 790     m_current = (wxPlotCurve*) NULL;
 791 }
 792
 793 wxPlotWindow::~wxPlotWindow()
 794 {
 795 }
 796
 797 void wxPlotWindow::Add( wxPlotCurve *curve )
 798 {
 799     m_curves.Append( curve );
 800     if (!m_current) m_current = curve;
 801
 802     ResetScrollbar();
 803 }
 804
 805 size_t wxPlotWindow::GetCount()
 806 {
 807     return m_curves.GetCount();
 808 }
 809
 810 wxPlotCurve *wxPlotWindow::GetAt( size_t n )
 811 {
 812     wxList::compatibility_iterator node = m_curves.Item( n );
 813     if (!node)
 814         return (wxPlotCurve*) NULL;
 815
 816     return (wxPlotCurve*) node->GetData();
 817 }
 818
 819 void wxPlotWindow::SetCurrentCurve( wxPlotCurve* current )
 820 {
 821     m_current = current;
 822     m_area->Refresh( false );
 823
 824     RedrawYAxis();
 825
 826     wxPlotEvent event( wxEVT_PLOT_SEL_CHANGED, GetId() );
 827     event.SetEventObject( this );
 828     event.SetZoom( GetZoom() );
 829     event.SetCurve( m_current );
 830     GetEventHandler()->ProcessEvent( event );
 831 }
 832
 833 void wxPlotWindow::Delete( wxPlotCurve* curve )
 834 {
 835     wxList::compatibility_iterator node = m_curves.Find( curve );
 836     if (!node) return;
 837
 838     m_curves.DeleteObject( curve );
 839
 840     m_area->DeleteCurve( curve );
 841     m_area->Refresh( false );
 842
 843     if (curve == m_current) m_current = (wxPlotCurve *) NULL;
 844 }
 845
 846 wxPlotCurve *wxPlotWindow::GetCurrentCurve()
 847 {
 848     return m_current;
 849 }
 850
 851 void wxPlotWindow::Add( wxPlotOnOffCurve *curve )
 852 {
 853     m_onOffCurves.Append( curve );
 854 }
 855
 856 void wxPlotWindow::Delete( wxPlotOnOffCurve* curve )
 857 {
 858     wxList::compatibility_iterator node = m_onOffCurves.Find( curve );
 859     if (!node) return;
 860
 861     m_onOffCurves.DeleteObject( curve );
 862 }
 863
 864 size_t wxPlotWindow::GetOnOffCurveCount()
 865 {
 866     return m_onOffCurves.GetCount();
 867 }
 868
 869 wxPlotOnOffCurve *wxPlotWindow::GetOnOffCurveAt( size_t n )
 870 {
 871     wxList::compatibility_iterator node = m_onOffCurves.Item( n );
 872     if (!node)
 873         return (wxPlotOnOffCurve*) NULL;
 874
 875     return (wxPlotOnOffCurve*) node->GetData();
 876 }
 877
 878 void wxPlotWindow::Move( wxPlotCurve* curve, int pixels_up )
 879 {
 880     m_area->DeleteCurve( curve );
 881
 882     curve->SetOffsetY( curve->GetOffsetY() + pixels_up );
 883
 884     m_area->Refresh( false );
 885
 886     RedrawYAxis();
 887 }
 888
 889 void wxPlotWindow::OnMoveUp( wxCommandEvent& WXUNUSED(event) )
 890 {
 891     if (!m_current) return;
 892
 893     Move( m_current, 25 );
 894 }
 895
 896 void wxPlotWindow::OnMoveDown( wxCommandEvent& WXUNUSED(event) )
 897 {
 898     if (!m_current) return;
 899
 900     Move( m_current, -25 );
 901 }
 902
 903 void wxPlotWindow::Enlarge( wxPlotCurve *curve, double factor )
 904 {
 905     m_area->DeleteCurve( curve );
 906
 907     int client_width;
 908     int client_height;
 909     m_area->GetClientSize( &client_width, &client_height);
 910     double offset = (double)curve->GetOffsetY() / (double)client_height;
 911
 912     double range = curve->GetEndY() - curve->GetStartY();
 913     offset *= range;
 914
 915     double new_range = range / factor;
 916     double new_offset = offset / factor;
 917
 918     if (m_enlargeAroundWindowCentre)
 919     {
 920         double middle = curve->GetStartY() - offset + range/2;
 921
 922         curve->SetStartY( middle - new_range / 2 + new_offset );
 923         curve->SetEndY( middle + new_range / 2 + new_offset  );
 924     }
 925     else
 926     {
 927         curve->SetStartY( (curve->GetStartY() - offset)/factor + new_offset );
 928         curve->SetEndY( (curve->GetEndY() - offset)/factor + new_offset );
 929     }
 930
 931     m_area->Refresh( false );
 932     RedrawYAxis();
 933 }
 934
 935 void wxPlotWindow::SetUnitsPerValue( double upv )
 936 {
 937     m_xUnitsPerValue = upv;
 938
 939     RedrawXAxis();
 940 }
 941
 942 void wxPlotWindow::SetZoom( double zoom )
 943 {
 944     double old_zoom = m_xZoom;
 945     m_xZoom = zoom;
 946
 947     int view_x = 0;
 948     int view_y = 0;
 949     GetViewStart( &view_x, &view_y );
 950
 951     wxInt32 max = 0;
 952     wxList::compatibility_iterator node = m_curves.GetFirst();
 953     while (node)
 954     {
 955         wxPlotCurve *curve = (wxPlotCurve*) node->GetData();
 956         if (curve->GetEndX() > max)
 957             max = curve->GetEndX();
 958         node = node->GetNext();
 959     }
 960     SetScrollbars( wxPLOT_SCROLL_STEP, wxPLOT_SCROLL_STEP,
 961                    (int)((max*m_xZoom)/wxPLOT_SCROLL_STEP)+1, 0,
 962                    (int)(view_x*zoom/old_zoom), 0,
 963                    true );
 964
 965     RedrawXAxis();
 966     m_area->Refresh( true );
 967 }
 968
 969 void wxPlotWindow::ResetScrollbar()
 970 {
 971     wxInt32 max = 0;
 972     wxList::compatibility_iterator node = m_curves.GetFirst();
 973     while (node)
 974     {
 975         wxPlotCurve *curve = (wxPlotCurve*) node->GetData();
 976         if (curve->GetEndX() > max)
 977             max = curve->GetEndX();
 978         node = node->GetNext();
 979     }
 980
 981     SetScrollbars( wxPLOT_SCROLL_STEP, wxPLOT_SCROLL_STEP,
 982                    (int)(((max*m_xZoom)/wxPLOT_SCROLL_STEP)+1), 0 );
 983 }
 984
 985 void wxPlotWindow::AddChartTitle(const wxString& title, wxFont font,
 986                                  wxColour colour)
 987 {
 988     m_title = title;
 989     m_titleFont = font;
 990     m_titleColour = colour;
 991     DrawChartTitle();
 992 }
 993
 994 void wxPlotWindow::DrawChartTitle()
 995 {
 996     if(m_title.size() != 0)
 997     {
 998         //If it is already added, remove child and delete
 999         if(m_titleStaticText)
1000         {
1001             RemoveChild( m_titleStaticText );
1002             m_titleStaticText->Destroy();
1003         }
1004
1005         //Create the text control and set the font, colour
1006         m_titleStaticText = new wxStaticText( this, -1, m_title );
1007         m_titleStaticText->SetFont( m_titleFont );
1008         m_titleStaticText->SetForegroundColour( m_titleColour );
1009
1010         //Create a sizer for the title. Prepend it to the Plot + Title sizer.
1011         wxBoxSizer* titleSizer = new wxBoxSizer( wxHORIZONTAL );
1012         titleSizer->Add( m_titleStaticText, 0, wxALIGN_CENTER | wxALL, 10 );
1013         m_plotAndTitleSizer->Prepend( titleSizer, 0, wxALIGN_CENTER_HORIZONTAL );
1014
1015         //Finally, force layout
1016         m_plotAndTitleSizer->Layout();
1017     }
1018 }
1019
1020 void wxPlotWindow::RedrawXAxis()
1021 {
1022     if (m_xaxis)
1023         m_xaxis->Refresh( true );
1024 }
1025
1026 void wxPlotWindow::RedrawYAxis()
1027 {
1028     if (m_yaxis)
1029        m_yaxis->Refresh( true );
1030 }
1031
1032 void wxPlotWindow::RedrawEverything()
1033 {
1034     if (m_xaxis)
1035         m_xaxis->Refresh( true );
1036     if (m_yaxis)
1037         m_yaxis->Refresh( true );
1038     m_area->Refresh( true );
1039
1040     DrawChartTitle();
1041 }
1042
1043 void wxPlotWindow::OnZoomIn( wxCommandEvent& WXUNUSED(event) )
1044 {
1045     SetZoom( m_xZoom * 1.5 );
1046 }
1047
1048 void wxPlotWindow::OnZoomOut( wxCommandEvent& WXUNUSED(event) )
1049 {
1050     SetZoom( m_xZoom * 0.6666 );
1051 }
1052
1053 void wxPlotWindow::OnEnlarge( wxCommandEvent& WXUNUSED(event) )
1054 {
1055     if (!m_current) return;
1056
1057     Enlarge( m_current, 1.5 );
1058 }
1059
1060 void wxPlotWindow::OnShrink( wxCommandEvent& WXUNUSED(event) )
1061 {
1062     if (!m_current) return;
1063
1064     Enlarge( m_current, 0.6666666 );
1065 }
1066
1067 void wxPlotWindow::OnScroll2( wxScrollWinEvent& event )
1068 {
1069     if ((!m_scrollOnThumbRelease) || (event.GetEventType() != wxEVT_SCROLLWIN_THUMBTRACK))
1070     {
1071         wxScrolledWindow::OnScroll( event );
1072         RedrawXAxis();
1073     }
1074 }
1075
1076 // ----------------------------------------------------------------------------
1077 // global functions
1078 // ----------------------------------------------------------------------------
1079
1080 // FIXME MT-UNSAFE
1081 static wxBitmap *GetEnlargeBitmap()
1082 {
1083     static wxBitmap* s_bitmap = (wxBitmap *) NULL;
1084     static bool s_loaded = false;
1085
1086     if ( !s_loaded )
1087     {
1088         s_loaded = true; // set it to true anyhow, we won't try again
1089
1090         #if defined(__WXMSW__) || defined(__WXPM__)
1091             s_bitmap = new wxBitmap(_T("plot_enl_bmp"), wxBITMAP_TYPE_RESOURCE);
1092         #else
1093             s_bitmap = new wxBitmap( plot_enl_xpm );
1094         #endif
1095     }
1096
1097     return s_bitmap;
1098 }
1099
1100 static wxBitmap *GetShrinkBitmap()
1101 {
1102     static wxBitmap* s_bitmap = (wxBitmap *) NULL;
1103     static bool s_loaded = false;
1104
1105     if ( !s_loaded )
1106     {
1107         s_loaded = true; // set it to true anyhow, we won't try again
1108
1109         #if defined(__WXMSW__) || defined(__WXPM__)
1110             s_bitmap = new wxBitmap(_T("plot_shr_bmp"), wxBITMAP_TYPE_RESOURCE);
1111         #else
1112             s_bitmap = new wxBitmap( plot_shr_xpm );
1113         #endif
1114     }
1115
1116     return s_bitmap;
1117 }
1118
1119 static wxBitmap *GetZoomInBitmap()
1120 {
1121     static wxBitmap* s_bitmap = (wxBitmap *) NULL;
1122     static bool s_loaded = false;
1123
1124     if ( !s_loaded )
1125     {
1126         s_loaded = true; // set it to true anyhow, we won't try again
1127
1128         #if defined(__WXMSW__) || defined(__WXPM__)
1129             s_bitmap = new wxBitmap(_T("plot_zin_bmp"), wxBITMAP_TYPE_RESOURCE);
1130         #else
1131             s_bitmap = new wxBitmap( plot_zin_xpm );
1132         #endif
1133     }
1134
1135     return s_bitmap;
1136 }
1137
1138 static wxBitmap *GetZoomOutBitmap()
1139 {
1140     static wxBitmap* s_bitmap = (wxBitmap *) NULL;
1141     static bool s_loaded = false;
1142
1143     if ( !s_loaded )
1144     {
1145         s_loaded = true; // set it to true anyhow, we won't try again
1146
1147         #if defined(__WXMSW__) || defined(__WXPM__)
1148             s_bitmap = new wxBitmap(_T("plot_zot_bmp"), wxBITMAP_TYPE_RESOURCE);
1149         #else
1150             s_bitmap = new wxBitmap( plot_zot_xpm );
1151         #endif
1152     }
1153
1154     return s_bitmap;
1155 }
1156
1157 static wxBitmap *GetUpBitmap()
1158 {
1159     static wxBitmap* s_bitmap = (wxBitmap *) NULL;
1160     static bool s_loaded = false;
1161
1162     if ( !s_loaded )
1163     {
1164         s_loaded = true; // set it to true anyhow, we won't try again
1165
1166         #if defined(__WXMSW__) || defined(__WXPM__)
1167             s_bitmap = new wxBitmap(_T("plot_up_bmp"), wxBITMAP_TYPE_RESOURCE);
1168         #else
1169             s_bitmap = new wxBitmap( plot_up_xpm );
1170         #endif
1171     }
1172
1173     return s_bitmap;
1174 }
1175
1176 static wxBitmap *GetDownBitmap()
1177 {
1178     static wxBitmap* s_bitmap = (wxBitmap *) NULL;
1179     static bool s_loaded = false;
1180
1181     if ( !s_loaded )
1182     {
1183         s_loaded = true; // set it to true anyhow, we won't try again
1184
1185         #if defined(__WXMSW__) || defined(__WXPM__)
1186             s_bitmap = new wxBitmap(_T("plot_dwn_bmp"), wxBITMAP_TYPE_RESOURCE);
1187         #else
1188             s_bitmap = new wxBitmap( plot_dwn_xpm );
1189         #endif
1190     }
1191
1192     return s_bitmap;
1193 }
1194