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