]> 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
header cleanup
[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 // 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
wxWidgets (Impactor)