projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
more DC changes for wxX11
[wxWidgets.git] / src / common / dcbase.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/dcbase.cpp
3 // Purpose: generic methods of the wxDC Class
4 // Author: Vadim Zeitlin
5 // Modified by:
6 // Created: 05/25/99
7 // RCS-ID: $Id$
8 // Copyright: (c) wxWidgets team
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
22
23 #ifdef __BORLANDC__
24 #pragma hdrstop
25 #endif
26
27 #include "wx/dc.h"
28 #include "wx/dcclient.h"
29 #include "wx/dcmemory.h"
30 #include "wx/dcscreen.h"
31 #include "wx/dcprint.h"
32 #include "wx/dcbuffer.h" // for IMPLEMENT_DYNAMIC_CLASS
33 #include "wx/prntbase.h"
34
35 #ifndef WX_PRECOMP
36 #include "wx/math.h"
37 #endif
38
39 #if wxUSE_NEW_DC
40
41 #ifdef __WXMSW__
42 #include "wx/msw/dcclient.h"
43 #include "wx/msw/dcmemory.h"
44 #include "wx/msw/dcscreen.h"
45 #endif
46
47 #ifdef __WXGTK__
48 #include "wx/gtk/dcclient.h"
49 #include "wx/gtk/dcmemory.h"
50 #include "wx/gtk/dcscreen.h"
51 #endif
52
53 #ifdef __WXMAC__
54 #include "wx/mac/dcclient.h"
55 #include "wx/mac/dcmemory.h"
56 #include "wx/mac/dcscreen.h"
57 #endif
58
59 #ifdef __WXX11__
60 #include "wx/x11/dcclient.h"
61 #include "wx/x11/dcmemory.h"
62 #include "wx/x11/dcscreen.h"
63 #endif
64
65 //----------------------------------------------------------------------------
66 // wxDCFactory
67 //----------------------------------------------------------------------------
68
69 wxDCFactory *wxDCFactory::m_factory = NULL;
70
71 void wxDCFactory::SetDCFactory( wxDCFactory *factory )
72 {
73 if (wxDCFactory::m_factory)
74 delete wxDCFactory::m_factory;
75
76 wxDCFactory::m_factory = factory;
77 }
78
79 wxDCFactory *wxDCFactory::GetFactory()
80 {
81 if (!wxDCFactory::m_factory)
82 wxDCFactory::m_factory = new wxNativeDCFactory;
83
84 return wxDCFactory::m_factory;
85 }
86
87 //-----------------------------------------------------------------------------
88 // wxNativeDCFactory
89 //-----------------------------------------------------------------------------
90
91 wxDCImpl* wxNativeDCFactory::CreateWindowDC( wxWindowDC *owner )
92 {
93 return new wxWindowDCImpl( owner );
94 }
95
96 wxDCImpl* wxNativeDCFactory::CreateWindowDC( wxWindowDC *owner, wxWindow *window )
97 {
98 return new wxWindowDCImpl( owner, window );
99 }
100
101 wxDCImpl* wxNativeDCFactory::CreateClientDC( wxClientDC *owner )
102 {
103 return new wxClientDCImpl( owner );
104 }
105
106 wxDCImpl* wxNativeDCFactory::CreateClientDC( wxClientDC *owner, wxWindow *window )
107 {
108 return new wxClientDCImpl( owner, window );
109 }
110
111 wxDCImpl* wxNativeDCFactory::CreatePaintDC( wxPaintDC *owner )
112 {
113 return new wxPaintDCImpl( owner );
114 }
115
116 wxDCImpl* wxNativeDCFactory::CreatePaintDC( wxPaintDC *owner, wxWindow *window )
117 {
118 return new wxPaintDCImpl( owner, window );
119 }
120
121 wxDCImpl* wxNativeDCFactory::CreateMemoryDC( wxMemoryDC *owner )
122 {
123 return new wxMemoryDCImpl( owner );
124 }
125
126 wxDCImpl* wxNativeDCFactory::CreateMemoryDC( wxMemoryDC *owner, wxBitmap &bitmap )
127 {
128 return new wxMemoryDCImpl( owner, bitmap );
129 }
130
131 wxDCImpl* wxNativeDCFactory::CreateMemoryDC( wxMemoryDC *owner, wxDC *dc )
132 {
133 return new wxMemoryDCImpl( owner, dc );
134 }
135
136 wxDCImpl* wxNativeDCFactory::CreateScreenDC( wxScreenDC *owner )
137 {
138 return new wxScreenDCImpl( owner );
139 }
140
141 wxDCImpl *wxNativeDCFactory::CreatePrinterDC( wxPrinterDC *owner, const wxPrintData &data )
142 {
143 wxPrintFactory *factory = wxPrintFactory::GetFactory();
144 return factory->CreatePrinterDCImpl( owner, data );
145 }
146
147 //-----------------------------------------------------------------------------
148 // wxWindowDC
149 //-----------------------------------------------------------------------------
150
151 IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
152
153 wxWindowDC::wxWindowDC()
154 {
155 }
156
157 wxWindowDC::wxWindowDC( wxWindow *win )
158 {
159 wxDCFactory *factory = wxDCFactory::GetFactory();
160 m_pimpl = factory->CreateWindowDC( this, win );
161 }
162
163 //-----------------------------------------------------------------------------
164 // wxClientDC
165 //-----------------------------------------------------------------------------
166
167 IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxWindowDC)
168
169 wxClientDC::wxClientDC()
170 {
171 }
172
173 wxClientDC::wxClientDC( wxWindow *win )
174 {
175 wxDCFactory *factory = wxDCFactory::GetFactory();
176 m_pimpl = factory->CreateClientDC( this, win );
177 }
178
179 //-----------------------------------------------------------------------------
180 // wxMemoryDC
181 //-----------------------------------------------------------------------------
182
183 IMPLEMENT_DYNAMIC_CLASS(wxMemoryDC, wxDC)
184
185 wxMemoryDC::wxMemoryDC()
186 {
187 wxDCFactory *factory = wxDCFactory::GetFactory();
188 m_pimpl = factory->CreateMemoryDC( this );
189 }
190
191 wxMemoryDC::wxMemoryDC( wxBitmap& bitmap )
192 {
193 wxDCFactory *factory = wxDCFactory::GetFactory();
194 m_pimpl = factory->CreateMemoryDC( this, bitmap );
195 }
196
197 wxMemoryDC::wxMemoryDC( wxDC *dc )
198 {
199 wxDCFactory *factory = wxDCFactory::GetFactory();
200 m_pimpl = factory->CreateMemoryDC( this, dc );
201 }
202
203 void wxMemoryDC::SelectObject(wxBitmap& bmp)
204 {
205 // make sure that the given wxBitmap is not sharing its data with other
206 // wxBitmap instances as its contents will be modified by any drawing
207 // operation done on this DC
208 if (bmp.IsOk())
209 bmp.UnShare();
210
211 GetImpl()->DoSelect(bmp);
212 }
213
214 void wxMemoryDC::SelectObjectAsSource(const wxBitmap& bmp)
215 {
216 GetImpl()->DoSelect(bmp);
217 }
218
219 const wxBitmap& wxMemoryDC::GetSelectedBitmap() const
220 {
221 return GetImpl()->GetSelectedBitmap();
222 }
223
224 wxBitmap& wxMemoryDC::GetSelectedBitmap()
225 {
226 return GetImpl()->GetSelectedBitmap();
227 }
228
229
230 //-----------------------------------------------------------------------------
231 // wxPaintDC
232 //-----------------------------------------------------------------------------
233
234 IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxClientDC)
235
236 wxPaintDC::wxPaintDC()
237 {
238 }
239
240 wxPaintDC::wxPaintDC( wxWindow *win )
241 {
242 wxDCFactory *factory = wxDCFactory::GetFactory();
243 m_pimpl = factory->CreatePaintDC( this, win );
244 }
245
246 //-----------------------------------------------------------------------------
247 // wxScreenDC
248 //-----------------------------------------------------------------------------
249
250 IMPLEMENT_DYNAMIC_CLASS(wxScreenDC, wxWindowDC)
251
252 wxScreenDC::wxScreenDC()
253 {
254 wxDCFactory *factory = wxDCFactory::GetFactory();
255 m_pimpl = factory->CreateScreenDC( this );
256 }
257
258 //-----------------------------------------------------------------------------
259 // wxPrinterDC
260 //-----------------------------------------------------------------------------
261
262 IMPLEMENT_DYNAMIC_CLASS(wxPrinterDC, wxDC)
263
264 wxPrinterDC::wxPrinterDC()
265 {
266 wxPrintData data; // Does this make sense?
267 wxDCFactory *factory = wxDCFactory::GetFactory();
268 m_pimpl = factory->CreatePrinterDC( this, data );
269 }
270
271 wxPrinterDC::wxPrinterDC( const wxPrintData &data )
272 {
273 wxDCFactory *factory = wxDCFactory::GetFactory();
274 m_pimpl = factory->CreatePrinterDC( this, data );
275 }
276
277 wxPrinterDC::~wxPrinterDC()
278 {
279 }
280
281 wxRect wxPrinterDC::GetPaperRect()
282 {
283 return GetImpl()->GetPaperRect();
284 }
285
286 int wxPrinterDC::GetResolution()
287 {
288 return GetImpl()->GetResolution();
289 }
290
291
292 //-----------------------------------------------------------------------------
293 // wxDCImpl
294 //-----------------------------------------------------------------------------
295
296 IMPLEMENT_ABSTRACT_CLASS(wxDCImpl, wxObject)
297
298 wxDCImpl::wxDCImpl( wxDC *owner )
299 : m_window(NULL)
300 , m_colour(wxColourDisplay())
301 , m_ok(true)
302 , m_clipping(false)
303 , m_isInteractive(0)
304 , m_isBBoxValid(false)
305 , m_logicalOriginX(0), m_logicalOriginY(0)
306 , m_deviceOriginX(0), m_deviceOriginY(0)
307 , m_deviceLocalOriginX(0), m_deviceLocalOriginY(0)
308 , m_logicalScaleX(1.0), m_logicalScaleY(1.0)
309 , m_userScaleX(1.0), m_userScaleY(1.0)
310 , m_scaleX(1.0), m_scaleY(1.0)
311 , m_signX(1), m_signY(1)
312 , m_minX(0), m_minY(0), m_maxX(0), m_maxY(0)
313 , m_clipX1(0), m_clipY1(0), m_clipX2(0), m_clipY2(0)
314 , m_logicalFunction(wxCOPY)
315 , m_backgroundMode(wxTRANSPARENT)
316 , m_mappingMode(wxMM_TEXT)
317 , m_pen()
318 , m_brush()
319 , m_backgroundBrush(*wxTRANSPARENT_BRUSH)
320 , m_textForegroundColour(*wxBLACK)
321 , m_textBackgroundColour(*wxWHITE)
322 , m_font()
323 #if wxUSE_PALETTE
324 , m_palette()
325 , m_hasCustomPalette(false)
326 #endif // wxUSE_PALETTE
327 {
328 m_owner = owner;
329
330 m_mm_to_pix_x = (double)wxGetDisplaySize().GetWidth() /
331 (double)wxGetDisplaySizeMM().GetWidth();
332 m_mm_to_pix_y = (double)wxGetDisplaySize().GetHeight() /
333 (double)wxGetDisplaySizeMM().GetHeight();
334
335 ResetBoundingBox();
336 ResetClipping();
337 }
338
339 wxDCImpl::~wxDCImpl()
340 {
341 }
342
343 // ----------------------------------------------------------------------------
344 // coordinate conversions and transforms
345 // ----------------------------------------------------------------------------
346
347 wxCoord wxDCImpl::DeviceToLogicalX(wxCoord x) const
348 {
349 return wxRound((double)(x - m_deviceOriginX - m_deviceLocalOriginX) / m_scaleX) * m_signX + m_logicalOriginX;
350 }
351
352 wxCoord wxDCImpl::DeviceToLogicalY(wxCoord y) const
353 {
354 return wxRound((double)(y - m_deviceOriginY - m_deviceLocalOriginY) / m_scaleY) * m_signY + m_logicalOriginY;
355 }
356
357 wxCoord wxDCImpl::DeviceToLogicalXRel(wxCoord x) const
358 {
359 return wxRound((double)(x) / m_scaleX);
360 }
361
362 wxCoord wxDCImpl::DeviceToLogicalYRel(wxCoord y) const
363 {
364 return wxRound((double)(y) / m_scaleY);
365 }
366
367 wxCoord wxDCImpl::LogicalToDeviceX(wxCoord x) const
368 {
369 return wxRound((double)(x - m_logicalOriginX) * m_scaleX) * m_signX + m_deviceOriginX * m_signY + m_deviceLocalOriginX;
370 }
371
372 wxCoord wxDCImpl::LogicalToDeviceY(wxCoord y) const
373 {
374 return wxRound((double)(y - m_logicalOriginY) * m_scaleY) * m_signY + m_deviceOriginY * m_signY + m_deviceLocalOriginY;
375 }
376
377 wxCoord wxDCImpl::LogicalToDeviceXRel(wxCoord x) const
378 {
379 return wxRound((double)(x) * m_scaleX);
380 }
381
382 wxCoord wxDCImpl::LogicalToDeviceYRel(wxCoord y) const
383 {
384 return wxRound((double)(y) * m_scaleY);
385 }
386
387 void wxDCImpl::ComputeScaleAndOrigin()
388 {
389 m_scaleX = m_logicalScaleX * m_userScaleX;
390 m_scaleY = m_logicalScaleY * m_userScaleY;
391 }
392
393 void wxDCImpl::SetMapMode( int mode )
394 {
395 switch (mode)
396 {
397 case wxMM_TWIPS:
398 SetLogicalScale( twips2mm*m_mm_to_pix_x, twips2mm*m_mm_to_pix_y );
399 break;
400 case wxMM_POINTS:
401 SetLogicalScale( pt2mm*m_mm_to_pix_x, pt2mm*m_mm_to_pix_y );
402 break;
403 case wxMM_METRIC:
404 SetLogicalScale( m_mm_to_pix_x, m_mm_to_pix_y );
405 break;
406 case wxMM_LOMETRIC:
407 SetLogicalScale( m_mm_to_pix_x/10.0, m_mm_to_pix_y/10.0 );
408 break;
409 default:
410 case wxMM_TEXT:
411 SetLogicalScale( 1.0, 1.0 );
412 break;
413 }
414 m_mappingMode = mode;
415 }
416
417 void wxDCImpl::SetUserScale( double x, double y )
418 {
419 // allow negative ? -> no
420 m_userScaleX = x;
421 m_userScaleY = y;
422 ComputeScaleAndOrigin();
423 }
424
425 void wxDCImpl::SetLogicalScale( double x, double y )
426 {
427 // allow negative ?
428 m_logicalScaleX = x;
429 m_logicalScaleY = y;
430 ComputeScaleAndOrigin();
431 }
432
433 void wxDCImpl::SetLogicalOrigin( wxCoord x, wxCoord y )
434 {
435 m_logicalOriginX = x * m_signX;
436 m_logicalOriginY = y * m_signY;
437 ComputeScaleAndOrigin();
438 }
439
440 void wxDCImpl::SetDeviceOrigin( wxCoord x, wxCoord y )
441 {
442 m_deviceOriginX = x;
443 m_deviceOriginY = y;
444 ComputeScaleAndOrigin();
445 }
446
447 void wxDCImpl::SetDeviceLocalOrigin( wxCoord x, wxCoord y )
448 {
449 m_deviceLocalOriginX = x;
450 m_deviceLocalOriginY = y;
451 ComputeScaleAndOrigin();
452 }
453
454 void wxDCImpl::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
455 {
456 // only wxPostScripDC has m_signX = -1, we override SetAxisOrientation there
457 // wxWidgets 2.9: no longer override it
458 m_signX = (xLeftRight ? 1 : -1);
459 m_signY = (yBottomUp ? -1 : 1);
460 ComputeScaleAndOrigin();
461 }
462
463
464 // Each element of the widths array will be the width of the string up to and
465 // including the corresponding character in text. This is the generic
466 // implementation, the port-specific classes should do this with native APIs
467 // if available and if faster. Note: pango_layout_index_to_pos is much slower
468 // than calling GetTextExtent!!
469
470 #define FWC_SIZE 256
471
472 class FontWidthCache
473 {
474 public:
475 FontWidthCache() : m_scaleX(1), m_widths(NULL) { }
476 ~FontWidthCache() { delete []m_widths; }
477
478 void Reset()
479 {
480 if (!m_widths)
481 m_widths = new int[FWC_SIZE];
482
483 memset(m_widths, 0, sizeof(int)*FWC_SIZE);
484 }
485
486 wxFont m_font;
487 double m_scaleX;
488 int *m_widths;
489 };
490
491 static FontWidthCache s_fontWidthCache;
492
493 bool wxDCImpl::DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const
494 {
495 int totalWidth = 0;
496
497 const size_t len = text.length();
498 widths.Empty();
499 widths.Add(0, len);
500
501 // reset the cache if font or horizontal scale have changed
502 if ( !s_fontWidthCache.m_widths ||
503 !wxIsSameDouble(s_fontWidthCache.m_scaleX, m_scaleX) ||
504 (s_fontWidthCache.m_font != GetFont()) )
505 {
506 s_fontWidthCache.Reset();
507 s_fontWidthCache.m_font = GetFont();
508 s_fontWidthCache.m_scaleX = m_scaleX;
509 }
510
511 // Calculate the position of each character based on the widths of
512 // the previous characters
513 int w, h;
514 for ( size_t i = 0; i < len; i++ )
515 {
516 const wxChar c = text[i];
517 unsigned int c_int = (unsigned int)c;
518
519 if ((c_int < FWC_SIZE) && (s_fontWidthCache.m_widths[c_int] != 0))
520 {
521 w = s_fontWidthCache.m_widths[c_int];
522 }
523 else
524 {
525 DoGetTextExtent(c, &w, &h);
526 if (c_int < FWC_SIZE)
527 s_fontWidthCache.m_widths[c_int] = w;
528 }
529
530 totalWidth += w;
531 widths[i] = totalWidth;
532 }
533
534 return true;
535 }
536
537 void wxDCImpl::GetMultiLineTextExtent(const wxString& text,
538 wxCoord *x,
539 wxCoord *y,
540 wxCoord *h,
541 const wxFont *font) const
542 {
543 wxCoord widthTextMax = 0, widthLine,
544 heightTextTotal = 0, heightLineDefault = 0, heightLine = 0;
545
546 wxString curLine;
547 for ( wxString::const_iterator pc = text.begin(); ; ++pc )
548 {
549 if ( pc == text.end() || *pc == _T('\n') )
550 {
551 if ( curLine.empty() )
552 {
553 // we can't use GetTextExtent - it will return 0 for both width
554 // and height and an empty line should count in height
555 // calculation
556
557 // assume that this line has the same height as the previous
558 // one
559 if ( !heightLineDefault )
560 heightLineDefault = heightLine;
561
562 if ( !heightLineDefault )
563 {
564 // but we don't know it yet - choose something reasonable
565 DoGetTextExtent(_T("W"), NULL, &heightLineDefault,
566 NULL, NULL, font);
567 }
568
569 heightTextTotal += heightLineDefault;
570 }
571 else
572 {
573 DoGetTextExtent(curLine, &widthLine, &heightLine,
574 NULL, NULL, font);
575 if ( widthLine > widthTextMax )
576 widthTextMax = widthLine;
577 heightTextTotal += heightLine;
578 }
579
580 if ( pc == text.end() )
581 {
582 break;
583 }
584 else // '\n'
585 {
586 curLine.clear();
587 }
588 }
589 else
590 {
591 curLine += *pc;
592 }
593 }
594
595 if ( x )
596 *x = widthTextMax;
597 if ( y )
598 *y = heightTextTotal;
599 if ( h )
600 *h = heightLine;
601 }
602
603 void wxDCImpl::DoDrawCheckMark(wxCoord x1, wxCoord y1,
604 wxCoord width, wxCoord height)
605 {
606 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
607
608 wxCoord x2 = x1 + width,
609 y2 = y1 + height;
610
611 // the pen width is calibrated to give 3 for width == height == 10
612 wxDCPenChanger pen( *m_owner, wxPen(GetTextForeground(), (width + height + 1)/7));
613
614 // we're drawing a scaled version of wx/generic/tick.xpm here
615 wxCoord x3 = x1 + (4*width) / 10, // x of the tick bottom
616 y3 = y1 + height / 2; // y of the left tick branch
617 DoDrawLine(x1, y3, x3, y2);
618 DoDrawLine(x3, y2, x2, y1);
619
620 CalcBoundingBox(x1, y1);
621 CalcBoundingBox(x2, y2);
622 }
623
624 bool
625 wxDCImpl::DoStretchBlit(wxCoord xdest, wxCoord ydest,
626 wxCoord dstWidth, wxCoord dstHeight,
627 wxDC *source,
628 wxCoord xsrc, wxCoord ysrc,
629 wxCoord srcWidth, wxCoord srcHeight,
630 int rop,
631 bool useMask,
632 wxCoord xsrcMask,
633 wxCoord ysrcMask)
634 {
635 wxCHECK_MSG( srcWidth && srcHeight && dstWidth && dstHeight, false,
636 _T("invalid blit size") );
637
638 // emulate the stretching by modifying the DC scale
639 double xscale = (double)srcWidth/dstWidth,
640 yscale = (double)srcHeight/dstHeight;
641
642 double xscaleOld, yscaleOld;
643 GetUserScale(&xscaleOld, &yscaleOld);
644 SetUserScale(xscaleOld/xscale, yscaleOld/yscale);
645
646 bool rc = DoBlit(wxCoord(xdest*xscale), wxCoord(ydest*yscale),
647 wxCoord(dstWidth*xscale), wxCoord(dstHeight*yscale),
648 source,
649 xsrc, ysrc, rop, useMask, xsrcMask, ysrcMask);
650
651 SetUserScale(xscaleOld, yscaleOld);
652
653 return rc;
654 }
655
656 void wxDCImpl::DrawLines(const wxPointList *list, wxCoord xoffset, wxCoord yoffset)
657 {
658 int n = list->GetCount();
659 wxPoint *points = new wxPoint[n];
660
661 int i = 0;
662 for ( wxPointList::compatibility_iterator node = list->GetFirst(); node; node = node->GetNext(), i++ )
663 {
664 wxPoint *point = node->GetData();
665 points[i].x = point->x;
666 points[i].y = point->y;
667 }
668
669 DoDrawLines(n, points, xoffset, yoffset);
670
671 delete [] points;
672 }
673
674 void wxDCImpl::DrawPolygon(const wxPointList *list,
675 wxCoord xoffset, wxCoord yoffset,
676 int fillStyle)
677 {
678 int n = list->GetCount();
679 wxPoint *points = new wxPoint[n];
680
681 int i = 0;
682 for ( wxPointList::compatibility_iterator node = list->GetFirst(); node; node = node->GetNext(), i++ )
683 {
684 wxPoint *point = node->GetData();
685 points[i].x = point->x;
686 points[i].y = point->y;
687 }
688
689 DoDrawPolygon(n, points, xoffset, yoffset, fillStyle);
690
691 delete [] points;
692 }
693
694 void
695 wxDCImpl::DoDrawPolyPolygon(int n,
696 int count[],
697 wxPoint points[],
698 wxCoord xoffset, wxCoord yoffset,
699 int fillStyle)
700 {
701 if ( n == 1 )
702 {
703 DoDrawPolygon(count[0], points, xoffset, yoffset, fillStyle);
704 return;
705 }
706
707 int i, j, lastOfs;
708 wxPoint* pts;
709 wxPen pen;
710
711 for (i = j = lastOfs = 0; i < n; i++)
712 {
713 lastOfs = j;
714 j += count[i];
715 }
716 pts = new wxPoint[j+n-1];
717 for (i = 0; i < j; i++)
718 pts[i] = points[i];
719 for (i = 2; i <= n; i++)
720 {
721 lastOfs -= count[n-i];
722 pts[j++] = pts[lastOfs];
723 }
724
725 pen = GetPen();
726 SetPen(wxPen(*wxBLACK, 0, wxTRANSPARENT));
727 DoDrawPolygon(j, pts, xoffset, yoffset, fillStyle);
728 SetPen(pen);
729 for (i = j = 0; i < n; i++)
730 {
731 DoDrawLines(count[i], pts+j, xoffset, yoffset);
732 j += count[i];
733 }
734 delete[] pts;
735 }
736
737 #if wxUSE_SPLINES
738
739 void wxDCImpl::DoDrawSpline(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord x3, wxCoord y3)
740 {
741 wxPointList point_list;
742
743 wxPoint *point1 = new wxPoint;
744 point1->x = x1; point1->y = y1;
745 point_list.Append( point1 );
746
747 wxPoint *point2 = new wxPoint;
748 point2->x = x2; point2->y = y2;
749 point_list.Append( point2 );
750
751 wxPoint *point3 = new wxPoint;
752 point3->x = x3; point3->y = y3;
753 point_list.Append( point3 );
754
755 DoDrawSpline(&point_list);
756
757 for( wxPointList::compatibility_iterator node = point_list.GetFirst(); node; node = node->GetNext() )
758 {
759 wxPoint *p = node->GetData();
760 delete p;
761 }
762 }
763
764 void wxDCImpl::DoDrawSpline(int n, wxPoint points[])
765 {
766 wxPointList list;
767 for (int i =0; i < n; i++)
768 list.Append( &points[i] );
769
770 DoDrawSpline(&list);
771 }
772
773 // ----------------------------------- spline code ----------------------------------------
774
775 void wx_quadratic_spline(double a1, double b1, double a2, double b2,
776 double a3, double b3, double a4, double b4);
777 void wx_clear_stack();
778 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2, double *x3,
779 double *y3, double *x4, double *y4);
780 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3,
781 double x4, double y4);
782 static bool wx_spline_add_point(double x, double y);
783 static void wx_spline_draw_point_array(wxDC *dc);
784
785 wxPointList wx_spline_point_list;
786
787 #define half(z1, z2) ((z1+z2)/2.0)
788 #define THRESHOLD 5
789
790 /* iterative version */
791
792 void wx_quadratic_spline(double a1, double b1, double a2, double b2, double a3, double b3, double a4,
793 double b4)
794 {
795 register double xmid, ymid;
796 double x1, y1, x2, y2, x3, y3, x4, y4;
797
798 wx_clear_stack();
799 wx_spline_push(a1, b1, a2, b2, a3, b3, a4, b4);
800
801 while (wx_spline_pop(&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4)) {
802 xmid = (double)half(x2, x3);
803 ymid = (double)half(y2, y3);
804 if (fabs(x1 - xmid) < THRESHOLD && fabs(y1 - ymid) < THRESHOLD &&
805 fabs(xmid - x4) < THRESHOLD && fabs(ymid - y4) < THRESHOLD) {
806 wx_spline_add_point( x1, y1 );
807 wx_spline_add_point( xmid, ymid );
808 } else {
809 wx_spline_push(xmid, ymid, (double)half(xmid, x3), (double)half(ymid, y3),
810 (double)half(x3, x4), (double)half(y3, y4), x4, y4);
811 wx_spline_push(x1, y1, (double)half(x1, x2), (double)half(y1, y2),
812 (double)half(x2, xmid), (double)half(y2, ymid), xmid, ymid);
813 }
814 }
815 }
816
817 /* utilities used by spline drawing routines */
818
819 typedef struct wx_spline_stack_struct {
820 double x1, y1, x2, y2, x3, y3, x4, y4;
821 } Stack;
822
823 #define SPLINE_STACK_DEPTH 20
824 static Stack wx_spline_stack[SPLINE_STACK_DEPTH];
825 static Stack *wx_stack_top;
826 static int wx_stack_count;
827
828 void wx_clear_stack()
829 {
830 wx_stack_top = wx_spline_stack;
831 wx_stack_count = 0;
832 }
833
834 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
835 {
836 wx_stack_top->x1 = x1;
837 wx_stack_top->y1 = y1;
838 wx_stack_top->x2 = x2;
839 wx_stack_top->y2 = y2;
840 wx_stack_top->x3 = x3;
841 wx_stack_top->y3 = y3;
842 wx_stack_top->x4 = x4;
843 wx_stack_top->y4 = y4;
844 wx_stack_top++;
845 wx_stack_count++;
846 }
847
848 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2,
849 double *x3, double *y3, double *x4, double *y4)
850 {
851 if (wx_stack_count == 0)
852 return (0);
853 wx_stack_top--;
854 wx_stack_count--;
855 *x1 = wx_stack_top->x1;
856 *y1 = wx_stack_top->y1;
857 *x2 = wx_stack_top->x2;
858 *y2 = wx_stack_top->y2;
859 *x3 = wx_stack_top->x3;
860 *y3 = wx_stack_top->y3;
861 *x4 = wx_stack_top->x4;
862 *y4 = wx_stack_top->y4;
863 return (1);
864 }
865
866 static bool wx_spline_add_point(double x, double y)
867 {
868 wxPoint *point = new wxPoint( wxRound(x), wxRound(y) );
869 wx_spline_point_list.Append(point );
870 return true;
871 }
872
873 static void wx_spline_draw_point_array(wxDC *dc)
874 {
875 dc->DrawLines(&wx_spline_point_list, 0, 0 );
876 wxPointList::compatibility_iterator node = wx_spline_point_list.GetFirst();
877 while (node)
878 {
879 wxPoint *point = node->GetData();
880 delete point;
881 wx_spline_point_list.Erase(node);
882 node = wx_spline_point_list.GetFirst();
883 }
884 }
885
886 void wxDCImpl::DoDrawSpline( const wxPointList *points )
887 {
888 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
889
890 wxPoint *p;
891 double cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
892 double x1, y1, x2, y2;
893
894 wxPointList::compatibility_iterator node = points->GetFirst();
895 if (!node)
896 // empty list
897 return;
898
899 p = (wxPoint *)node->GetData();
900
901 x1 = p->x;
902 y1 = p->y;
903
904 node = node->GetNext();
905 p = node->GetData();
906
907 x2 = p->x;
908 y2 = p->y;
909 cx1 = (double)((x1 + x2) / 2);
910 cy1 = (double)((y1 + y2) / 2);
911 cx2 = (double)((cx1 + x2) / 2);
912 cy2 = (double)((cy1 + y2) / 2);
913
914 wx_spline_add_point(x1, y1);
915
916 while ((node = node->GetNext())
917 #if !wxUSE_STL
918 != NULL
919 #endif // !wxUSE_STL
920 )
921 {
922 p = node->GetData();
923 x1 = x2;
924 y1 = y2;
925 x2 = p->x;
926 y2 = p->y;
927 cx4 = (double)(x1 + x2) / 2;
928 cy4 = (double)(y1 + y2) / 2;
929 cx3 = (double)(x1 + cx4) / 2;
930 cy3 = (double)(y1 + cy4) / 2;
931
932 wx_quadratic_spline(cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4);
933
934 cx1 = cx4;
935 cy1 = cy4;
936 cx2 = (double)(cx1 + x2) / 2;
937 cy2 = (double)(cy1 + y2) / 2;
938 }
939
940 wx_spline_add_point( cx1, cy1 );
941 wx_spline_add_point( x2, y2 );
942
943 wx_spline_draw_point_array( m_owner );
944 }
945
946 #endif // wxUSE_SPLINES
947
948
949
950 void wxDCImpl::DoGradientFillLinear(const wxRect& rect,
951 const wxColour& initialColour,
952 const wxColour& destColour,
953 wxDirection nDirection)
954 {
955 // save old pen
956 wxPen oldPen = m_pen;
957 wxBrush oldBrush = m_brush;
958
959 wxUint8 nR1 = initialColour.Red();
960 wxUint8 nG1 = initialColour.Green();
961 wxUint8 nB1 = initialColour.Blue();
962 wxUint8 nR2 = destColour.Red();
963 wxUint8 nG2 = destColour.Green();
964 wxUint8 nB2 = destColour.Blue();
965 wxUint8 nR, nG, nB;
966
967 if ( nDirection == wxEAST || nDirection == wxWEST )
968 {
969 wxInt32 x = rect.GetWidth();
970 wxInt32 w = x; // width of area to shade
971 wxInt32 xDelta = w/256; // height of one shade bend
972 if (xDelta < 1)
973 xDelta = 1;
974
975 while (x >= xDelta)
976 {
977 x -= xDelta;
978 if (nR1 > nR2)
979 nR = nR1 - (nR1-nR2)*(w-x)/w;
980 else
981 nR = nR1 + (nR2-nR1)*(w-x)/w;
982
983 if (nG1 > nG2)
984 nG = nG1 - (nG1-nG2)*(w-x)/w;
985 else
986 nG = nG1 + (nG2-nG1)*(w-x)/w;
987
988 if (nB1 > nB2)
989 nB = nB1 - (nB1-nB2)*(w-x)/w;
990 else
991 nB = nB1 + (nB2-nB1)*(w-x)/w;
992
993 wxColour colour(nR,nG,nB);
994 SetPen(wxPen(colour, 1, wxSOLID));
995 SetBrush(wxBrush(colour));
996 if(nDirection == wxEAST)
997 DoDrawRectangle(rect.GetRight()-x-xDelta+1, rect.GetTop(),
998 xDelta, rect.GetHeight());
999 else //nDirection == wxWEST
1000 DoDrawRectangle(rect.GetLeft()+x, rect.GetTop(),
1001 xDelta, rect.GetHeight());
1002 }
1003 }
1004 else // nDirection == wxNORTH || nDirection == wxSOUTH
1005 {
1006 wxInt32 y = rect.GetHeight();
1007 wxInt32 w = y; // height of area to shade
1008 wxInt32 yDelta = w/255; // height of one shade bend
1009 if (yDelta < 1)
1010 yDelta = 1;
1011
1012 while (y > 0)
1013 {
1014 y -= yDelta;
1015 if (nR1 > nR2)
1016 nR = nR1 - (nR1-nR2)*(w-y)/w;
1017 else
1018 nR = nR1 + (nR2-nR1)*(w-y)/w;
1019
1020 if (nG1 > nG2)
1021 nG = nG1 - (nG1-nG2)*(w-y)/w;
1022 else
1023 nG = nG1 + (nG2-nG1)*(w-y)/w;
1024
1025 if (nB1 > nB2)
1026 nB = nB1 - (nB1-nB2)*(w-y)/w;
1027 else
1028 nB = nB1 + (nB2-nB1)*(w-y)/w;
1029
1030 wxColour colour(nR,nG,nB);
1031 SetPen(wxPen(colour, 1, wxSOLID));
1032 SetBrush(wxBrush(colour));
1033 if(nDirection == wxNORTH)
1034 DoDrawRectangle(rect.GetLeft(), rect.GetTop()+y,
1035 rect.GetWidth(), yDelta);
1036 else //nDirection == wxSOUTH
1037 DoDrawRectangle(rect.GetLeft(), rect.GetBottom()-y-yDelta+1,
1038 rect.GetWidth(), yDelta);
1039 }
1040 }
1041
1042 SetPen(oldPen);
1043 SetBrush(oldBrush);
1044 }
1045
1046 void wxDCImpl::DoGradientFillConcentric(const wxRect& rect,
1047 const wxColour& initialColour,
1048 const wxColour& destColour,
1049 const wxPoint& circleCenter)
1050 {
1051 //save the old pen color
1052 wxColour oldPenColour = m_pen.GetColour();
1053
1054 wxUint8 nR1 = destColour.Red();
1055 wxUint8 nG1 = destColour.Green();
1056 wxUint8 nB1 = destColour.Blue();
1057 wxUint8 nR2 = initialColour.Red();
1058 wxUint8 nG2 = initialColour.Green();
1059 wxUint8 nB2 = initialColour.Blue();
1060 wxUint8 nR, nG, nB;
1061
1062
1063 //Radius
1064 wxInt32 cx = rect.GetWidth() / 2;
1065 wxInt32 cy = rect.GetHeight() / 2;
1066 wxInt32 nRadius;
1067 if (cx < cy)
1068 nRadius = cx;
1069 else
1070 nRadius = cy;
1071
1072 //Offset of circle
1073 wxInt32 nCircleOffX = circleCenter.x - (rect.GetWidth() / 2);
1074 wxInt32 nCircleOffY = circleCenter.y - (rect.GetHeight() / 2);
1075
1076 for ( wxInt32 x = 0; x < rect.GetWidth(); x++ )
1077 {
1078 for ( wxInt32 y = 0; y < rect.GetHeight(); y++ )
1079 {
1080 //get color difference
1081 wxInt32 nGradient = ((nRadius -
1082 (wxInt32)sqrt(
1083 pow((double)(x - cx - nCircleOffX), 2) +
1084 pow((double)(y - cy - nCircleOffY), 2)
1085 )) * 100) / nRadius;
1086
1087 //normalize Gradient
1088 if (nGradient < 0 )
1089 nGradient = 0;
1090
1091 //get dest colors
1092 nR = (wxUint8)(nR1 + ((nR2 - nR1) * nGradient / 100));
1093 nG = (wxUint8)(nG1 + ((nG2 - nG1) * nGradient / 100));
1094 nB = (wxUint8)(nB1 + ((nB2 - nB1) * nGradient / 100));
1095
1096 //set the pixel
1097 m_pen.SetColour(wxColour(nR,nG,nB));
1098 DoDrawPoint(x + rect.GetLeft(), y + rect.GetTop());
1099 }
1100 }
1101 //return old pen color
1102 m_pen.SetColour(oldPenColour);
1103 }
1104
1105 //-----------------------------------------------------------------------------
1106 // wxDC
1107 //-----------------------------------------------------------------------------
1108
1109 IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
1110
1111 void wxDC::DrawLabel(const wxString& text,
1112 const wxBitmap& bitmap,
1113 const wxRect& rect,
1114 int alignment,
1115 int indexAccel,
1116 wxRect *rectBounding)
1117 {
1118 // find the text position
1119 wxCoord widthText, heightText, heightLine;
1120 GetMultiLineTextExtent(text, &widthText, &heightText, &heightLine);
1121
1122 wxCoord width, height;
1123 if ( bitmap.Ok() )
1124 {
1125 width = widthText + bitmap.GetWidth();
1126 height = bitmap.GetHeight();
1127 }
1128 else // no bitmap
1129 {
1130 width = widthText;
1131 height = heightText;
1132 }
1133
1134 wxCoord x, y;
1135 if ( alignment & wxALIGN_RIGHT )
1136 {
1137 x = rect.GetRight() - width;
1138 }
1139 else if ( alignment & wxALIGN_CENTRE_HORIZONTAL )
1140 {
1141 x = (rect.GetLeft() + rect.GetRight() + 1 - width) / 2;
1142 }
1143 else // alignment & wxALIGN_LEFT
1144 {
1145 x = rect.GetLeft();
1146 }
1147
1148 if ( alignment & wxALIGN_BOTTOM )
1149 {
1150 y = rect.GetBottom() - height;
1151 }
1152 else if ( alignment & wxALIGN_CENTRE_VERTICAL )
1153 {
1154 y = (rect.GetTop() + rect.GetBottom() + 1 - height) / 2;
1155 }
1156 else // alignment & wxALIGN_TOP
1157 {
1158 y = rect.GetTop();
1159 }
1160
1161 // draw the bitmap first
1162 wxCoord x0 = x,
1163 y0 = y,
1164 width0 = width;
1165 if ( bitmap.Ok() )
1166 {
1167 DrawBitmap(bitmap, x, y, true /* use mask */);
1168
1169 wxCoord offset = bitmap.GetWidth() + 4;
1170 x += offset;
1171 width -= offset;
1172
1173 y += (height - heightText) / 2;
1174 }
1175
1176 // we will draw the underscore under the accel char later
1177 wxCoord startUnderscore = 0,
1178 endUnderscore = 0,
1179 yUnderscore = 0;
1180
1181 // split the string into lines and draw each of them separately
1182 wxString curLine;
1183 for ( wxString::const_iterator pc = text.begin(); ; ++pc )
1184 {
1185 if ( *pc == _T('\n') || pc == text.end() )
1186 {
1187 int xRealStart = x; // init it here to avoid compielr warnings
1188
1189 if ( !curLine.empty() )
1190 {
1191 // NB: can't test for !(alignment & wxALIGN_LEFT) because
1192 // wxALIGN_LEFT is 0
1193 if ( alignment & (wxALIGN_RIGHT | wxALIGN_CENTRE_HORIZONTAL) )
1194 {
1195 wxCoord widthLine;
1196 GetTextExtent(curLine, &widthLine, NULL);
1197
1198 if ( alignment & wxALIGN_RIGHT )
1199 {
1200 xRealStart += width - widthLine;
1201 }
1202 else // if ( alignment & wxALIGN_CENTRE_HORIZONTAL )
1203 {
1204 xRealStart += (width - widthLine) / 2;
1205 }
1206 }
1207 //else: left aligned, nothing to do
1208
1209 DrawText(curLine, xRealStart, y);
1210 }
1211
1212 y += heightLine;
1213
1214 // do we have underscore in this line? we can check yUnderscore
1215 // because it is set below to just y + heightLine if we do
1216 if ( y == yUnderscore )
1217 {
1218 // adjust the horz positions to account for the shift
1219 startUnderscore += xRealStart;
1220 endUnderscore += xRealStart;
1221 }
1222
1223 if ( pc == text.end() )
1224 break;
1225
1226 curLine.clear();
1227 }
1228 else // not end of line
1229 {
1230 if ( pc - text.begin() == indexAccel )
1231 {
1232 // remeber to draw underscore here
1233 GetTextExtent(curLine, &startUnderscore, NULL);
1234 curLine += *pc;
1235 GetTextExtent(curLine, &endUnderscore, NULL);
1236
1237 yUnderscore = y + heightLine;
1238 }
1239 else
1240 {
1241 curLine += *pc;
1242 }
1243 }
1244 }
1245
1246 // draw the underscore if found
1247 if ( startUnderscore != endUnderscore )
1248 {
1249 // it should be of the same colour as text
1250 SetPen(wxPen(GetTextForeground(), 0, wxSOLID));
1251
1252 yUnderscore--;
1253
1254 DrawLine(startUnderscore, yUnderscore, endUnderscore, yUnderscore);
1255 }
1256
1257 // return bounding rect if requested
1258 if ( rectBounding )
1259 {
1260 *rectBounding = wxRect(x, y - heightText, widthText, heightText);
1261 }
1262
1263 CalcBoundingBox(x0, y0);
1264 CalcBoundingBox(x0 + width0, y0 + height);
1265 }
1266
1267 #if WXWIN_COMPATIBILITY_2_8
1268 // for compatibility with the old code when wxCoord was long everywhere
1269 void wxDC::GetTextExtent(const wxString& string,
1270 long *x, long *y,
1271 long *descent,
1272 long *externalLeading,
1273 const wxFont *theFont) const
1274 {
1275 wxCoord x2, y2, descent2, externalLeading2;
1276 m_pimpl->DoGetTextExtent(string, &x2, &y2,
1277 &descent2, &externalLeading2,
1278 theFont);
1279 if ( x )
1280 *x = x2;
1281 if ( y )
1282 *y = y2;
1283 if ( descent )
1284 *descent = descent2;
1285 if ( externalLeading )
1286 *externalLeading = externalLeading2;
1287 }
1288
1289 void wxDC::GetLogicalOrigin(long *x, long *y) const
1290 {
1291 wxCoord x2, y2;
1292 m_pimpl->DoGetLogicalOrigin(&x2, &y2);
1293 if ( x )
1294 *x = x2;
1295 if ( y )
1296 *y = y2;
1297 }
1298
1299 void wxDC::GetDeviceOrigin(long *x, long *y) const
1300 {
1301 wxCoord x2, y2;
1302 m_pimpl->DoGetDeviceOrigin(&x2, &y2);
1303 if ( x )
1304 *x = x2;
1305 if ( y )
1306 *y = y2;
1307 }
1308
1309 void wxDC::GetClippingBox(long *x, long *y, long *w, long *h) const
1310 {
1311 wxCoord xx,yy,ww,hh;
1312 m_pimpl->DoGetClippingBox(&xx, &yy, &ww, &hh);
1313 if (x) *x = xx;
1314 if (y) *y = yy;
1315 if (w) *w = ww;
1316 if (h) *h = hh;
1317 }
1318
1319 #endif // WXWIN_COMPATIBILITY_2_8
1320
1321
1322 #else // wxUSE_NEW_DC
1323
1324
1325 // bool wxDCBase::sm_cacheing = false;
1326
1327 IMPLEMENT_ABSTRACT_CLASS(wxDCBase, wxObject)
1328
1329 // ============================================================================
1330 // implementation
1331 // ============================================================================
1332
1333 IMPLEMENT_DYNAMIC_CLASS(wxBufferedDC, wxMemoryDC)
1334 IMPLEMENT_ABSTRACT_CLASS(wxBufferedPaintDC, wxBufferedDC)
1335
1336 wxDCBase::wxDCBase()
1337 : m_colour(wxColourDisplay())
1338 , m_ok(true)
1339 , m_clipping(false)
1340 , m_isInteractive(0)
1341 , m_isBBoxValid(false)
1342 , m_logicalOriginX(0), m_logicalOriginY(0)
1343 , m_deviceOriginX(0), m_deviceOriginY(0)
1344 , m_deviceLocalOriginX(0), m_deviceLocalOriginY(0)
1345 , m_logicalScaleX(1.0), m_logicalScaleY(1.0)
1346 , m_userScaleX(1.0), m_userScaleY(1.0)
1347 , m_scaleX(1.0), m_scaleY(1.0)
1348 , m_signX(1), m_signY(1)
1349 , m_minX(0), m_minY(0), m_maxX(0), m_maxY(0)
1350 , m_clipX1(0), m_clipY1(0), m_clipX2(0), m_clipY2(0)
1351 , m_logicalFunction(wxCOPY)
1352 , m_backgroundMode(wxTRANSPARENT)
1353 , m_mappingMode(wxMM_TEXT)
1354 , m_pen()
1355 , m_brush()
1356 , m_backgroundBrush(*wxTRANSPARENT_BRUSH)
1357 , m_textForegroundColour(*wxBLACK)
1358 , m_textBackgroundColour(*wxWHITE)
1359 , m_font()
1360 #if wxUSE_PALETTE
1361 , m_palette()
1362 , m_hasCustomPalette(false)
1363 #endif // wxUSE_PALETTE
1364 {
1365 m_mm_to_pix_x = (double)wxGetDisplaySize().GetWidth() /
1366 (double)wxGetDisplaySizeMM().GetWidth();
1367 m_mm_to_pix_y = (double)wxGetDisplaySize().GetHeight() /
1368 (double)wxGetDisplaySizeMM().GetHeight();
1369
1370 ResetBoundingBox();
1371 ResetClipping();
1372 }
1373
1374 wxDCBase::~wxDCBase()
1375 {
1376 }
1377
1378 #if WXWIN_COMPATIBILITY_2_6
1379 void wxDCBase::BeginDrawing()
1380 {
1381 }
1382
1383 void wxDCBase::EndDrawing()
1384 {
1385 }
1386 #endif // WXWIN_COMPATIBILITY_2_6
1387
1388 #if WXWIN_COMPATIBILITY_2_8
1389 // for compatibility with the old code when wxCoord was long everywhere
1390 void wxDCBase::GetTextExtent(const wxString& string,
1391 long *x, long *y,
1392 long *descent,
1393 long *externalLeading,
1394 const wxFont *theFont) const
1395 {
1396 wxCoord x2, y2, descent2, externalLeading2;
1397 DoGetTextExtent(string, &x2, &y2,
1398 &descent2, &externalLeading2,
1399 theFont);
1400 if ( x )
1401 *x = x2;
1402 if ( y )
1403 *y = y2;
1404 if ( descent )
1405 *descent = descent2;
1406 if ( externalLeading )
1407 *externalLeading = externalLeading2;
1408 }
1409
1410 void wxDCBase::GetLogicalOrigin(long *x, long *y) const
1411 {
1412 wxCoord x2, y2;
1413 DoGetLogicalOrigin(&x2, &y2);
1414 if ( x )
1415 *x = x2;
1416 if ( y )
1417 *y = y2;
1418 }
1419
1420 void wxDCBase::GetDeviceOrigin(long *x, long *y) const
1421 {
1422 wxCoord x2, y2;
1423 DoGetDeviceOrigin(&x2, &y2);
1424 if ( x )
1425 *x = x2;
1426 if ( y )
1427 *y = y2;
1428 }
1429
1430 void wxDCBase::GetClippingBox(long *x, long *y, long *w, long *h) const
1431 {
1432 wxCoord xx,yy,ww,hh;
1433 DoGetClippingBox(&xx, &yy, &ww, &hh);
1434 if (x) *x = xx;
1435 if (y) *y = yy;
1436 if (w) *w = ww;
1437 if (h) *h = hh;
1438 }
1439 #endif // WXWIN_COMPATIBILITY_2_8
1440
1441
1442
1443 // ----------------------------------------------------------------------------
1444 // coordinate conversions and transforms
1445 // ----------------------------------------------------------------------------
1446
1447 wxCoord wxDCBase::DeviceToLogicalX(wxCoord x) const
1448 {
1449 return wxRound((double)(x - m_deviceOriginX - m_deviceLocalOriginX) / m_scaleX) * m_signX + m_logicalOriginX;
1450 }
1451
1452 wxCoord wxDCBase::DeviceToLogicalY(wxCoord y) const
1453 {
1454 return wxRound((double)(y - m_deviceOriginY - m_deviceLocalOriginY) / m_scaleY) * m_signY + m_logicalOriginY;
1455 }
1456
1457 wxCoord wxDCBase::DeviceToLogicalXRel(wxCoord x) const
1458 {
1459 return wxRound((double)(x) / m_scaleX);
1460 }
1461
1462 wxCoord wxDCBase::DeviceToLogicalYRel(wxCoord y) const
1463 {
1464 return wxRound((double)(y) / m_scaleY);
1465 }
1466
1467 wxCoord wxDCBase::LogicalToDeviceX(wxCoord x) const
1468 {
1469 return wxRound((double)(x - m_logicalOriginX) * m_scaleX) * m_signX + m_deviceOriginX + m_deviceLocalOriginX;
1470 }
1471
1472 wxCoord wxDCBase::LogicalToDeviceY(wxCoord y) const
1473 {
1474 return wxRound((double)(y - m_logicalOriginY) * m_scaleY) * m_signY + m_deviceOriginY + m_deviceLocalOriginY;
1475 }
1476
1477 wxCoord wxDCBase::LogicalToDeviceXRel(wxCoord x) const
1478 {
1479 return wxRound((double)(x) * m_scaleX);
1480 }
1481
1482 wxCoord wxDCBase::LogicalToDeviceYRel(wxCoord y) const
1483 {
1484 return wxRound((double)(y) * m_scaleY);
1485 }
1486
1487 void wxDCBase::ComputeScaleAndOrigin()
1488 {
1489 m_scaleX = m_logicalScaleX * m_userScaleX;
1490 m_scaleY = m_logicalScaleY * m_userScaleY;
1491 }
1492
1493 void wxDCBase::SetMapMode( int mode )
1494 {
1495 switch (mode)
1496 {
1497 case wxMM_TWIPS:
1498 SetLogicalScale( twips2mm*m_mm_to_pix_x, twips2mm*m_mm_to_pix_y );
1499 break;
1500 case wxMM_POINTS:
1501 SetLogicalScale( pt2mm*m_mm_to_pix_x, pt2mm*m_mm_to_pix_y );
1502 break;
1503 case wxMM_METRIC:
1504 SetLogicalScale( m_mm_to_pix_x, m_mm_to_pix_y );
1505 break;
1506 case wxMM_LOMETRIC:
1507 SetLogicalScale( m_mm_to_pix_x/10.0, m_mm_to_pix_y/10.0 );
1508 break;
1509 default:
1510 case wxMM_TEXT:
1511 SetLogicalScale( 1.0, 1.0 );
1512 break;
1513 }
1514 m_mappingMode = mode;
1515 }
1516
1517 void wxDCBase::SetUserScale( double x, double y )
1518 {
1519 // allow negative ? -> no
1520 m_userScaleX = x;
1521 m_userScaleY = y;
1522 ComputeScaleAndOrigin();
1523 }
1524
1525 void wxDCBase::SetLogicalScale( double x, double y )
1526 {
1527 // allow negative ?
1528 m_logicalScaleX = x;
1529 m_logicalScaleY = y;
1530 ComputeScaleAndOrigin();
1531 }
1532
1533 void wxDCBase::SetLogicalOrigin( wxCoord x, wxCoord y )
1534 {
1535 m_logicalOriginX = x * m_signX;
1536 m_logicalOriginY = y * m_signY;
1537 ComputeScaleAndOrigin();
1538 }
1539
1540 void wxDCBase::SetDeviceOrigin( wxCoord x, wxCoord y )
1541 {
1542 m_deviceOriginX = x;
1543 m_deviceOriginY = y;
1544 ComputeScaleAndOrigin();
1545 }
1546
1547 void wxDCBase::SetDeviceLocalOrigin( wxCoord x, wxCoord y )
1548 {
1549 m_deviceLocalOriginX = x;
1550 m_deviceLocalOriginY = y;
1551 ComputeScaleAndOrigin();
1552 }
1553
1554 void wxDCBase::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
1555 {
1556 // only wxPostScripDC has m_signX = -1, we override SetAxisOrientation there
1557 // wxWidgets 2.9: no longer override it
1558 m_signX = (xLeftRight ? 1 : -1);
1559 m_signY = (yBottomUp ? -1 : 1);
1560 ComputeScaleAndOrigin();
1561 }
1562
1563 // ----------------------------------------------------------------------------
1564 // special symbols
1565 // ----------------------------------------------------------------------------
1566
1567 void wxDCBase::DoDrawCheckMark(wxCoord x1, wxCoord y1,
1568 wxCoord width, wxCoord height)
1569 {
1570 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1571
1572 wxCoord x2 = x1 + width,
1573 y2 = y1 + height;
1574
1575 // the pen width is calibrated to give 3 for width == height == 10
1576 wxDCPenChanger pen((wxDC&)*this,
1577 wxPen(GetTextForeground(), (width + height + 1)/7));
1578
1579 // we're drawing a scaled version of wx/generic/tick.xpm here
1580 wxCoord x3 = x1 + (4*width) / 10, // x of the tick bottom
1581 y3 = y1 + height / 2; // y of the left tick branch
1582 DoDrawLine(x1, y3, x3, y2);
1583 DoDrawLine(x3, y2, x2, y1);
1584
1585 CalcBoundingBox(x1, y1);
1586 CalcBoundingBox(x2, y2);
1587 }
1588
1589 // ----------------------------------------------------------------------------
1590 // stubs for functions not implemented in all ports
1591 // ----------------------------------------------------------------------------
1592
1593 bool
1594 wxDCBase::DoStretchBlit(wxCoord xdest, wxCoord ydest,
1595 wxCoord dstWidth, wxCoord dstHeight,
1596 wxDC *source,
1597 wxCoord xsrc, wxCoord ysrc,
1598 wxCoord srcWidth, wxCoord srcHeight,
1599 int rop,
1600 bool useMask,
1601 wxCoord xsrcMask,
1602 wxCoord ysrcMask)
1603 {
1604 wxCHECK_MSG( srcWidth && srcHeight && dstWidth && dstHeight, false,
1605 _T("invalid blit size") );
1606
1607 // emulate the stretching by modifying the DC scale
1608 double xscale = (double)srcWidth/dstWidth,
1609 yscale = (double)srcHeight/dstHeight;
1610
1611 double xscaleOld, yscaleOld;
1612 GetUserScale(&xscaleOld, &yscaleOld);
1613 SetUserScale(xscaleOld/xscale, yscaleOld/yscale);
1614
1615 bool rc = DoBlit(wxCoord(xdest*xscale), wxCoord(ydest*yscale),
1616 wxCoord(dstWidth*xscale), wxCoord(dstHeight*yscale),
1617 source,
1618 xsrc, ysrc, rop, useMask, xsrcMask, ysrcMask);
1619
1620 SetUserScale(xscaleOld, yscaleOld);
1621
1622 return rc;
1623 }
1624
1625 // ----------------------------------------------------------------------------
1626 // line/polygons
1627 // ----------------------------------------------------------------------------
1628
1629 void wxDCBase::DrawLines(const wxPointList *list, wxCoord xoffset, wxCoord yoffset)
1630 {
1631 unsigned int n = list->GetCount();
1632 wxPoint *points = new wxPoint[n];
1633
1634 unsigned int i = 0;
1635 wxPointList::compatibility_iterator node;
1636 for ( node = list->GetFirst(); node; node = node->GetNext(), i++ )
1637 {
1638 wxPoint *point = node->GetData();
1639 points[i].x = point->x;
1640 points[i].y = point->y;
1641 }
1642
1643 DoDrawLines(n, points, xoffset, yoffset);
1644
1645 delete [] points;
1646 }
1647
1648 #if WXWIN_COMPATIBILITY_2_8
1649 void wxDCBase::DrawLines(const wxList *list, wxCoord xoffset, wxCoord yoffset )
1650 {
1651 unsigned int n = list->GetCount();
1652 wxPoint *points = new wxPoint[n];
1653
1654 unsigned int i = 0;
1655 wxObjectList::compatibility_iterator node;
1656 for ( node = list->GetFirst(); node; node = node->GetNext(), i++ )
1657 {
1658 wxPoint *point = (wxPoint*) node->GetData();
1659 points[i].x = point->x;
1660 points[i].y = point->y;
1661 }
1662
1663 DoDrawLines(n, points, xoffset, yoffset);
1664
1665 delete [] points;
1666 }
1667 #endif // WXWIN_COMPATIBILITY_2_8
1668
1669
1670 void wxDCBase::DrawPolygon(const wxPointList *list,
1671 wxCoord xoffset, wxCoord yoffset,
1672 int fillStyle)
1673 {
1674 unsigned int n = list->GetCount();
1675 wxPoint *points = new wxPoint[n];
1676
1677 unsigned int i = 0;
1678 wxPointList::compatibility_iterator node;
1679 for ( node = list->GetFirst(); node; node = node->GetNext(), i++ )
1680 {
1681 wxPoint *point = node->GetData();
1682 points[i].x = point->x;
1683 points[i].y = point->y;
1684 }
1685
1686 DoDrawPolygon(n, points, xoffset, yoffset, fillStyle);
1687
1688 delete [] points;
1689 }
1690
1691
1692 #if WXWIN_COMPATIBILITY_2_8
1693 void wxDCBase::DrawPolygon(const wxList *list,
1694 wxCoord xoffset, wxCoord yoffset,
1695 int fillStyle )
1696 {
1697 unsigned int n = list->GetCount();
1698 wxPoint *points = new wxPoint[n];
1699
1700 unsigned int i = 0;
1701 wxObjectList::compatibility_iterator node;
1702 for ( node = list->GetFirst(); node; node = node->GetNext(), i++ )
1703 {
1704 wxPoint *point = (wxPoint*) node->GetData();
1705 points[i].x = point->x;
1706 points[i].y = point->y;
1707 }
1708
1709 DoDrawPolygon(n, points, xoffset, yoffset, fillStyle);
1710
1711 delete [] points;
1712 }
1713 #endif // WXWIN_COMPATIBILITY_2_8
1714
1715 void
1716 wxDCBase::DoDrawPolyPolygon(int n,
1717 int count[],
1718 wxPoint points[],
1719 wxCoord xoffset, wxCoord yoffset,
1720 int fillStyle)
1721 {
1722 if ( n == 1 )
1723 {
1724 DoDrawPolygon(count[0], points, xoffset, yoffset, fillStyle);
1725 return;
1726 }
1727
1728 int i, j, lastOfs;
1729 wxPoint* pts;
1730 wxPen pen;
1731
1732 for (i = j = lastOfs = 0; i < n; i++)
1733 {
1734 lastOfs = j;
1735 j += count[i];
1736 }
1737 pts = new wxPoint[j+n-1];
1738 for (i = 0; i < j; i++)
1739 pts[i] = points[i];
1740 for (i = 2; i <= n; i++)
1741 {
1742 lastOfs -= count[n-i];
1743 pts[j++] = pts[lastOfs];
1744 }
1745
1746 pen = GetPen();
1747 SetPen(wxPen(*wxBLACK, 0, wxTRANSPARENT));
1748 DoDrawPolygon(j, pts, xoffset, yoffset, fillStyle);
1749 SetPen(pen);
1750 for (i = j = 0; i < n; i++)
1751 {
1752 DoDrawLines(count[i], pts+j, xoffset, yoffset);
1753 j += count[i];
1754 }
1755 delete[] pts;
1756 }
1757
1758 // ----------------------------------------------------------------------------
1759 // splines
1760 // ----------------------------------------------------------------------------
1761
1762 #if wxUSE_SPLINES
1763
1764 void wxDCBase::DrawSpline(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord x3, wxCoord y3)
1765 {
1766 wxPointList point_list;
1767
1768 wxPoint *point1 = new wxPoint;
1769 point1->x = x1; point1->y = y1;
1770 point_list.Append( point1 );
1771
1772 wxPoint *point2 = new wxPoint;
1773 point2->x = x2; point2->y = y2;
1774 point_list.Append( point2 );
1775
1776 wxPoint *point3 = new wxPoint;
1777 point3->x = x3; point3->y = y3;
1778 point_list.Append( point3 );
1779
1780 DrawSpline(&point_list);
1781
1782 for( wxPointList::compatibility_iterator node = point_list.GetFirst(); node; node = node->GetNext() )
1783 {
1784 wxPoint *p = node->GetData();
1785 delete p;
1786 }
1787 }
1788
1789 void wxDCBase::DrawSpline(int n, wxPoint points[])
1790 {
1791 wxPointList list;
1792 for (int i =0; i < n; i++)
1793 list.Append( &points[i] );
1794
1795 DrawSpline(&list);
1796 }
1797
1798 // ----------------------------------- spline code ----------------------------------------
1799
1800 void wx_quadratic_spline(double a1, double b1, double a2, double b2,
1801 double a3, double b3, double a4, double b4);
1802 void wx_clear_stack();
1803 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2, double *x3,
1804 double *y3, double *x4, double *y4);
1805 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3,
1806 double x4, double y4);
1807 static bool wx_spline_add_point(double x, double y);
1808 static void wx_spline_draw_point_array(wxDCBase *dc);
1809
1810 wxPointList wx_spline_point_list;
1811
1812 #define half(z1, z2) ((z1+z2)/2.0)
1813 #define THRESHOLD 5
1814
1815 /* iterative version */
1816
1817 void wx_quadratic_spline(double a1, double b1, double a2, double b2, double a3, double b3, double a4,
1818 double b4)
1819 {
1820 register double xmid, ymid;
1821 double x1, y1, x2, y2, x3, y3, x4, y4;
1822
1823 wx_clear_stack();
1824 wx_spline_push(a1, b1, a2, b2, a3, b3, a4, b4);
1825
1826 while (wx_spline_pop(&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4)) {
1827 xmid = (double)half(x2, x3);
1828 ymid = (double)half(y2, y3);
1829 if (fabs(x1 - xmid) < THRESHOLD && fabs(y1 - ymid) < THRESHOLD &&
1830 fabs(xmid - x4) < THRESHOLD && fabs(ymid - y4) < THRESHOLD) {
1831 wx_spline_add_point( x1, y1 );
1832 wx_spline_add_point( xmid, ymid );
1833 } else {
1834 wx_spline_push(xmid, ymid, (double)half(xmid, x3), (double)half(ymid, y3),
1835 (double)half(x3, x4), (double)half(y3, y4), x4, y4);
1836 wx_spline_push(x1, y1, (double)half(x1, x2), (double)half(y1, y2),
1837 (double)half(x2, xmid), (double)half(y2, ymid), xmid, ymid);
1838 }
1839 }
1840 }
1841
1842 /* utilities used by spline drawing routines */
1843
1844 typedef struct wx_spline_stack_struct {
1845 double x1, y1, x2, y2, x3, y3, x4, y4;
1846 } Stack;
1847
1848 #define SPLINE_STACK_DEPTH 20
1849 static Stack wx_spline_stack[SPLINE_STACK_DEPTH];
1850 static Stack *wx_stack_top;
1851 static int wx_stack_count;
1852
1853 void wx_clear_stack()
1854 {
1855 wx_stack_top = wx_spline_stack;
1856 wx_stack_count = 0;
1857 }
1858
1859 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
1860 {
1861 wx_stack_top->x1 = x1;
1862 wx_stack_top->y1 = y1;
1863 wx_stack_top->x2 = x2;
1864 wx_stack_top->y2 = y2;
1865 wx_stack_top->x3 = x3;
1866 wx_stack_top->y3 = y3;
1867 wx_stack_top->x4 = x4;
1868 wx_stack_top->y4 = y4;
1869 wx_stack_top++;
1870 wx_stack_count++;
1871 }
1872
1873 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2,
1874 double *x3, double *y3, double *x4, double *y4)
1875 {
1876 if (wx_stack_count == 0)
1877 return (0);
1878 wx_stack_top--;
1879 wx_stack_count--;
1880 *x1 = wx_stack_top->x1;
1881 *y1 = wx_stack_top->y1;
1882 *x2 = wx_stack_top->x2;
1883 *y2 = wx_stack_top->y2;
1884 *x3 = wx_stack_top->x3;
1885 *y3 = wx_stack_top->y3;
1886 *x4 = wx_stack_top->x4;
1887 *y4 = wx_stack_top->y4;
1888 return (1);
1889 }
1890
1891 static bool wx_spline_add_point(double x, double y)
1892 {
1893 wxPoint *point = new wxPoint( wxRound(x), wxRound(y) );
1894 wx_spline_point_list.Append( point );
1895 return true;
1896 }
1897
1898 static void wx_spline_draw_point_array(wxDCBase *dc)
1899 {
1900 dc->DrawLines(&wx_spline_point_list, 0, 0 );
1901 wxPointList::compatibility_iterator node = wx_spline_point_list.GetFirst();
1902 while (node)
1903 {
1904 wxPoint *point = node->GetData();
1905 delete point;
1906 wx_spline_point_list.Erase(node);
1907 node = wx_spline_point_list.GetFirst();
1908 }
1909 }
1910
1911 #if WXWIN_COMPATIBILITY_2_8
1912 void wxDCBase::DrawSpline(const wxList *points)
1913 {
1914 wxPointList list;
1915 wxObjectList::compatibility_iterator node = points->GetFirst();
1916 while (node)
1917 {
1918 list.Append( (wxPoint*) node->GetData() );
1919 node = node->GetNext();
1920 }
1921 DoDrawSpline( &list );
1922 }
1923 #endif // WXWIN_COMPATIBILITY_2_8
1924
1925 void wxDCBase::DoDrawSpline( const wxPointList *points )
1926 {
1927 wxCHECK_RET( Ok(), wxT("invalid window dc") );
1928
1929 wxPoint *p;
1930 double cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
1931 double x1, y1, x2, y2;
1932
1933 wxPointList::compatibility_iterator node = points->GetFirst();
1934 if (!node)
1935 // empty list
1936 return;
1937
1938 p = node->GetData();
1939
1940 x1 = p->x;
1941 y1 = p->y;
1942
1943 node = node->GetNext();
1944 p = node->GetData();
1945
1946 x2 = p->x;
1947 y2 = p->y;
1948 cx1 = (double)((x1 + x2) / 2);
1949 cy1 = (double)((y1 + y2) / 2);
1950 cx2 = (double)((cx1 + x2) / 2);
1951 cy2 = (double)((cy1 + y2) / 2);
1952
1953 wx_spline_add_point(x1, y1);
1954
1955 while ((node = node->GetNext())
1956 #if !wxUSE_STL
1957 != NULL
1958 #endif // !wxUSE_STL
1959 )
1960 {
1961 p = node->GetData();
1962 x1 = x2;
1963 y1 = y2;
1964 x2 = p->x;
1965 y2 = p->y;
1966 cx4 = (double)(x1 + x2) / 2;
1967 cy4 = (double)(y1 + y2) / 2;
1968 cx3 = (double)(x1 + cx4) / 2;
1969 cy3 = (double)(y1 + cy4) / 2;
1970
1971 wx_quadratic_spline(cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4);
1972
1973 cx1 = cx4;
1974 cy1 = cy4;
1975 cx2 = (double)(cx1 + x2) / 2;
1976 cy2 = (double)(cy1 + y2) / 2;
1977 }
1978
1979 wx_spline_add_point( cx1, cy1 );
1980 wx_spline_add_point( x2, y2 );
1981
1982 wx_spline_draw_point_array( this );
1983 }
1984
1985 #endif // wxUSE_SPLINES
1986
1987 // ----------------------------------------------------------------------------
1988 // Partial Text Extents
1989 // ----------------------------------------------------------------------------
1990
1991
1992 // Each element of the widths array will be the width of the string up to and
1993 // including the corresponding character in text. This is the generic
1994 // implementation, the port-specific classes should do this with native APIs
1995 // if available and if faster. Note: pango_layout_index_to_pos is much slower
1996 // than calling GetTextExtent!!
1997
1998 #define FWC_SIZE 256
1999
2000 class FontWidthCache
2001 {
2002 public:
2003 FontWidthCache() : m_scaleX(1), m_widths(NULL) { }
2004 ~FontWidthCache() { delete []m_widths; }
2005
2006 void Reset()
2007 {
2008 if (!m_widths)
2009 m_widths = new int[FWC_SIZE];
2010
2011 memset(m_widths, 0, sizeof(int)*FWC_SIZE);
2012 }
2013
2014 wxFont m_font;
2015 double m_scaleX;
2016 int *m_widths;
2017 };
2018
2019 static FontWidthCache s_fontWidthCache;
2020
2021 bool wxDCBase::DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const
2022 {
2023 int totalWidth = 0;
2024
2025 const size_t len = text.length();
2026 widths.Empty();
2027 widths.Add(0, len);
2028
2029 // reset the cache if font or horizontal scale have changed
2030 if ( !s_fontWidthCache.m_widths ||
2031 !wxIsSameDouble(s_fontWidthCache.m_scaleX, m_scaleX) ||
2032 (s_fontWidthCache.m_font != GetFont()) )
2033 {
2034 s_fontWidthCache.Reset();
2035 s_fontWidthCache.m_font = GetFont();
2036 s_fontWidthCache.m_scaleX = m_scaleX;
2037 }
2038
2039 // Calculate the position of each character based on the widths of
2040 // the previous characters
2041 int w, h;
2042 for ( size_t i = 0; i < len; i++ )
2043 {
2044 const wxChar c = text[i];
2045 unsigned int c_int = (unsigned int)c;
2046
2047 if ((c_int < FWC_SIZE) && (s_fontWidthCache.m_widths[c_int] != 0))
2048 {
2049 w = s_fontWidthCache.m_widths[c_int];
2050 }
2051 else
2052 {
2053 GetTextExtent(c, &w, &h);
2054 if (c_int < FWC_SIZE)
2055 s_fontWidthCache.m_widths[c_int] = w;
2056 }
2057
2058 totalWidth += w;
2059 widths[i] = totalWidth;
2060 }
2061
2062 return true;
2063 }
2064
2065
2066 // ----------------------------------------------------------------------------
2067 // enhanced text drawing
2068 // ----------------------------------------------------------------------------
2069
2070 void wxDCBase::GetMultiLineTextExtent(const wxString& text,
2071 wxCoord *x,
2072 wxCoord *y,
2073 wxCoord *h,
2074 const wxFont *font) const
2075 {
2076 wxCoord widthTextMax = 0, widthLine,
2077 heightTextTotal = 0, heightLineDefault = 0, heightLine = 0;
2078
2079 wxString curLine;
2080 for ( wxString::const_iterator pc = text.begin(); ; ++pc )
2081 {
2082 if ( pc == text.end() || *pc == _T('\n') )
2083 {
2084 if ( curLine.empty() )
2085 {
2086 // we can't use GetTextExtent - it will return 0 for both width
2087 // and height and an empty line should count in height
2088 // calculation
2089
2090 // assume that this line has the same height as the previous
2091 // one
2092 if ( !heightLineDefault )
2093 heightLineDefault = heightLine;
2094
2095 if ( !heightLineDefault )
2096 {
2097 // but we don't know it yet - choose something reasonable
2098 GetTextExtent(_T("W"), NULL, &heightLineDefault,
2099 NULL, NULL, font);
2100 }
2101
2102 heightTextTotal += heightLineDefault;
2103 }
2104 else
2105 {
2106 GetTextExtent(curLine, &widthLine, &heightLine,
2107 NULL, NULL, font);
2108 if ( widthLine > widthTextMax )
2109 widthTextMax = widthLine;
2110 heightTextTotal += heightLine;
2111 }
2112
2113 if ( pc == text.end() )
2114 {
2115 break;
2116 }
2117 else // '\n'
2118 {
2119 curLine.clear();
2120 }
2121 }
2122 else
2123 {
2124 curLine += *pc;
2125 }
2126 }
2127
2128 if ( x )
2129 *x = widthTextMax;
2130 if ( y )
2131 *y = heightTextTotal;
2132 if ( h )
2133 *h = heightLine;
2134 }
2135
2136 void wxDCBase::DrawLabel(const wxString& text,
2137 const wxBitmap& bitmap,
2138 const wxRect& rect,
2139 int alignment,
2140 int indexAccel,
2141 wxRect *rectBounding)
2142 {
2143 // find the text position
2144 wxCoord widthText, heightText, heightLine;
2145 GetMultiLineTextExtent(text, &widthText, &heightText, &heightLine);
2146
2147 wxCoord width, height;
2148 if ( bitmap.Ok() )
2149 {
2150 width = widthText + bitmap.GetWidth();
2151 height = bitmap.GetHeight();
2152 }
2153 else // no bitmap
2154 {
2155 width = widthText;
2156 height = heightText;
2157 }
2158
2159 wxCoord x, y;
2160 if ( alignment & wxALIGN_RIGHT )
2161 {
2162 x = rect.GetRight() - width;
2163 }
2164 else if ( alignment & wxALIGN_CENTRE_HORIZONTAL )
2165 {
2166 x = (rect.GetLeft() + rect.GetRight() + 1 - width) / 2;
2167 }
2168 else // alignment & wxALIGN_LEFT
2169 {
2170 x = rect.GetLeft();
2171 }
2172
2173 if ( alignment & wxALIGN_BOTTOM )
2174 {
2175 y = rect.GetBottom() - height;
2176 }
2177 else if ( alignment & wxALIGN_CENTRE_VERTICAL )
2178 {
2179 y = (rect.GetTop() + rect.GetBottom() + 1 - height) / 2;
2180 }
2181 else // alignment & wxALIGN_TOP
2182 {
2183 y = rect.GetTop();
2184 }
2185
2186 // draw the bitmap first
2187 wxCoord x0 = x,
2188 y0 = y,
2189 width0 = width;
2190 if ( bitmap.Ok() )
2191 {
2192 DrawBitmap(bitmap, x, y, true /* use mask */);
2193
2194 wxCoord offset = bitmap.GetWidth() + 4;
2195 x += offset;
2196 width -= offset;
2197
2198 y += (height - heightText) / 2;
2199 }
2200
2201 // we will draw the underscore under the accel char later
2202 wxCoord startUnderscore = 0,
2203 endUnderscore = 0,
2204 yUnderscore = 0;
2205
2206 // split the string into lines and draw each of them separately
2207 wxString curLine;
2208 for ( wxString::const_iterator pc = text.begin(); ; ++pc )
2209 {
2210 if ( pc == text.end() || *pc == _T('\n') )
2211 {
2212 int xRealStart = x; // init it here to avoid compielr warnings
2213
2214 if ( !curLine.empty() )
2215 {
2216 // NB: can't test for !(alignment & wxALIGN_LEFT) because
2217 // wxALIGN_LEFT is 0
2218 if ( alignment & (wxALIGN_RIGHT | wxALIGN_CENTRE_HORIZONTAL) )
2219 {
2220 wxCoord widthLine;
2221 GetTextExtent(curLine, &widthLine, NULL);
2222
2223 if ( alignment & wxALIGN_RIGHT )
2224 {
2225 xRealStart += width - widthLine;
2226 }
2227 else // if ( alignment & wxALIGN_CENTRE_HORIZONTAL )
2228 {
2229 xRealStart += (width - widthLine) / 2;
2230 }
2231 }
2232 //else: left aligned, nothing to do
2233
2234 DrawText(curLine, xRealStart, y);
2235 }
2236
2237 y += heightLine;
2238
2239 // do we have underscore in this line? we can check yUnderscore
2240 // because it is set below to just y + heightLine if we do
2241 if ( y == yUnderscore )
2242 {
2243 // adjust the horz positions to account for the shift
2244 startUnderscore += xRealStart;
2245 endUnderscore += xRealStart;
2246 }
2247
2248 if ( pc == text.end() )
2249 break;
2250
2251 curLine.clear();
2252 }
2253 else // not end of line
2254 {
2255 if ( pc - text.begin() == indexAccel )
2256 {
2257 // remeber to draw underscore here
2258 GetTextExtent(curLine, &startUnderscore, NULL);
2259 curLine += *pc;
2260 GetTextExtent(curLine, &endUnderscore, NULL);
2261
2262 yUnderscore = y + heightLine;
2263 }
2264 else
2265 {
2266 curLine += *pc;
2267 }
2268 }
2269 }
2270
2271 // draw the underscore if found
2272 if ( startUnderscore != endUnderscore )
2273 {
2274 // it should be of the same colour as text
2275 SetPen(wxPen(GetTextForeground(), 0, wxSOLID));
2276
2277 yUnderscore--;
2278
2279 DrawLine(startUnderscore, yUnderscore, endUnderscore, yUnderscore);
2280 }
2281
2282 // return bounding rect if requested
2283 if ( rectBounding )
2284 {
2285 *rectBounding = wxRect(x, y - heightText, widthText, heightText);
2286 }
2287
2288 CalcBoundingBox(x0, y0);
2289 CalcBoundingBox(x0 + width0, y0 + height);
2290 }
2291
2292
2293 void wxDCBase::DoGradientFillLinear(const wxRect& rect,
2294 const wxColour& initialColour,
2295 const wxColour& destColour,
2296 wxDirection nDirection)
2297 {
2298 // save old pen
2299 wxPen oldPen = m_pen;
2300 wxBrush oldBrush = m_brush;
2301
2302 wxUint8 nR1 = initialColour.Red();
2303 wxUint8 nG1 = initialColour.Green();
2304 wxUint8 nB1 = initialColour.Blue();
2305 wxUint8 nR2 = destColour.Red();
2306 wxUint8 nG2 = destColour.Green();
2307 wxUint8 nB2 = destColour.Blue();
2308 wxUint8 nR, nG, nB;
2309
2310 if ( nDirection == wxEAST || nDirection == wxWEST )
2311 {
2312 wxInt32 x = rect.GetWidth();
2313 wxInt32 w = x; // width of area to shade
2314 wxInt32 xDelta = w/256; // height of one shade bend
2315 if (xDelta < 1)
2316 xDelta = 1;
2317
2318 while (x >= xDelta)
2319 {
2320 x -= xDelta;
2321 if (nR1 > nR2)
2322 nR = nR1 - (nR1-nR2)*(w-x)/w;
2323 else
2324 nR = nR1 + (nR2-nR1)*(w-x)/w;
2325
2326 if (nG1 > nG2)
2327 nG = nG1 - (nG1-nG2)*(w-x)/w;
2328 else
2329 nG = nG1 + (nG2-nG1)*(w-x)/w;
2330
2331 if (nB1 > nB2)
2332 nB = nB1 - (nB1-nB2)*(w-x)/w;
2333 else
2334 nB = nB1 + (nB2-nB1)*(w-x)/w;
2335
2336 wxColour colour(nR,nG,nB);
2337 SetPen(wxPen(colour, 1, wxSOLID));
2338 SetBrush(wxBrush(colour));
2339 if(nDirection == wxEAST)
2340 DrawRectangle(rect.GetRight()-x-xDelta+1, rect.GetTop(),
2341 xDelta, rect.GetHeight());
2342 else //nDirection == wxWEST
2343 DrawRectangle(rect.GetLeft()+x, rect.GetTop(),
2344 xDelta, rect.GetHeight());
2345 }
2346 }
2347 else // nDirection == wxNORTH || nDirection == wxSOUTH
2348 {
2349 wxInt32 y = rect.GetHeight();
2350 wxInt32 w = y; // height of area to shade
2351 wxInt32 yDelta = w/255; // height of one shade bend
2352 if (yDelta < 1)
2353 yDelta = 1;
2354
2355 while (y > 0)
2356 {
2357 y -= yDelta;
2358 if (nR1 > nR2)
2359 nR = nR1 - (nR1-nR2)*(w-y)/w;
2360 else
2361 nR = nR1 + (nR2-nR1)*(w-y)/w;
2362
2363 if (nG1 > nG2)
2364 nG = nG1 - (nG1-nG2)*(w-y)/w;
2365 else
2366 nG = nG1 + (nG2-nG1)*(w-y)/w;
2367
2368 if (nB1 > nB2)
2369 nB = nB1 - (nB1-nB2)*(w-y)/w;
2370 else
2371 nB = nB1 + (nB2-nB1)*(w-y)/w;
2372
2373 wxColour colour(nR,nG,nB);
2374 SetPen(wxPen(colour, 1, wxSOLID));
2375 SetBrush(wxBrush(colour));
2376 if(nDirection == wxNORTH)
2377 DrawRectangle(rect.GetLeft(), rect.GetTop()+y,
2378 rect.GetWidth(), yDelta);
2379 else //nDirection == wxSOUTH
2380 DrawRectangle(rect.GetLeft(), rect.GetBottom()-y-yDelta+1,
2381 rect.GetWidth(), yDelta);
2382 }
2383 }
2384
2385 SetPen(oldPen);
2386 SetBrush(oldBrush);
2387 }
2388
2389 void wxDCBase::DoGradientFillConcentric(const wxRect& rect,
2390 const wxColour& initialColour,
2391 const wxColour& destColour,
2392 const wxPoint& circleCenter)
2393 {
2394 //save the old pen color
2395 wxColour oldPenColour = m_pen.GetColour();
2396
2397 wxUint8 nR1 = destColour.Red();
2398 wxUint8 nG1 = destColour.Green();
2399 wxUint8 nB1 = destColour.Blue();
2400 wxUint8 nR2 = initialColour.Red();
2401 wxUint8 nG2 = initialColour.Green();
2402 wxUint8 nB2 = initialColour.Blue();
2403 wxUint8 nR, nG, nB;
2404
2405
2406 //Radius
2407 wxInt32 cx = rect.GetWidth() / 2;
2408 wxInt32 cy = rect.GetHeight() / 2;
2409 wxInt32 nRadius;
2410 if (cx < cy)
2411 nRadius = cx;
2412 else
2413 nRadius = cy;
2414
2415 //Offset of circle
2416 wxInt32 nCircleOffX = circleCenter.x - (rect.GetWidth() / 2);
2417 wxInt32 nCircleOffY = circleCenter.y - (rect.GetHeight() / 2);
2418
2419 for ( wxInt32 x = 0; x < rect.GetWidth(); x++ )
2420 {
2421 for ( wxInt32 y = 0; y < rect.GetHeight(); y++ )
2422 {
2423 //get color difference
2424 wxInt32 nGradient = ((nRadius -
2425 (wxInt32)sqrt(
2426 pow((double)(x - cx - nCircleOffX), 2) +
2427 pow((double)(y - cy - nCircleOffY), 2)
2428 )) * 100) / nRadius;
2429
2430 //normalize Gradient
2431 if (nGradient < 0 )
2432 nGradient = 0;
2433
2434 //get dest colors
2435 nR = (wxUint8)(nR1 + ((nR2 - nR1) * nGradient / 100));
2436 nG = (wxUint8)(nG1 + ((nG2 - nG1) * nGradient / 100));
2437 nB = (wxUint8)(nB1 + ((nB2 - nB1) * nGradient / 100));
2438
2439 //set the pixel
2440 m_pen.SetColour(wxColour(nR,nG,nB));
2441 DrawPoint(wxPoint(x + rect.GetLeft(), y + rect.GetTop()));
2442 }
2443 }
2444 //return old pen color
2445 m_pen.SetColour(oldPenColour);
2446 }
2447
2448 /*
2449 Notes for wxWidgets DrawEllipticArcRot(...)
2450
2451 wxDCBase::DrawEllipticArcRot(...) draws a rotated elliptic arc or an ellipse.
2452 It uses wxDCBase::CalculateEllipticPoints(...) and wxDCBase::Rotate(...),
2453 which are also new.
2454
2455 All methods are generic, so they can be implemented in wxDCBase.
2456 DoDrawEllipticArcRot(...) is virtual, so it can be called from deeper
2457 methods like (WinCE) wxDC::DoDrawArc(...).
2458
2459 CalculateEllipticPoints(...) fills a given list of wxPoints with some points
2460 of an elliptic arc. The algorithm is pixel-based: In every row (in flat
2461 parts) or every column (in steep parts) only one pixel is calculated.
2462 Trigonometric calculation (sin, cos, tan, atan) is only done if the
2463 starting angle is not equal to the ending angle. The calculation of the
2464 pixels is done using simple arithmetic only and should perform not too
2465 bad even on devices without floating point processor. I didn't test this yet.
2466
2467 Rotate(...) rotates a list of point pixel-based, you will see rounding errors.
2468 For instance: an ellipse rotated 180 degrees is drawn
2469 slightly different from the original.
2470
2471 The points are then moved to an array and used to draw a polyline and/or polygon
2472 (with center added, the pie).
2473 The result looks quite similar to the native ellipse, only e few pixels differ.
2474
2475 The performance on a desktop system (Athlon 1800, WinXP) is about 7 times
2476 slower as DrawEllipse(...), which calls the native API.
2477 An rotated ellipse outside the clipping region takes nearly the same time,
2478 while an native ellipse outside takes nearly no time to draw.
2479
2480 If you draw an arc with this new method, you will see the starting and ending angles
2481 are calculated properly.
2482 If you use DrawEllipticArc(...), you will see they are only correct for circles
2483 and not properly calculated for ellipses.
2484
2485 Peter Lenhard
2486 p.lenhard@t-online.de
2487 */
2488
2489 #ifdef __WXWINCE__
2490 void wxDCBase::DoDrawEllipticArcRot( wxCoord x, wxCoord y,
2491 wxCoord w, wxCoord h,
2492 double sa, double ea, double angle )
2493 {
2494 wxPointList list;
2495
2496 CalculateEllipticPoints( &list, x, y, w, h, sa, ea );
2497 Rotate( &list, angle, wxPoint( x+w/2, y+h/2 ) );
2498
2499 // Add center (for polygon/pie)
2500 list.Append( new wxPoint( x+w/2, y+h/2 ) );
2501
2502 // copy list into array and delete list elements
2503 int n = list.GetCount();
2504 wxPoint *points = new wxPoint[n];
2505 int i = 0;
2506 wxPointList::compatibility_iterator node;
2507 for ( node = list.GetFirst(); node; node = node->GetNext(), i++ )
2508 {
2509 wxPoint *point = node->GetData();
2510 points[i].x = point->x;
2511 points[i].y = point->y;
2512 delete point;
2513 }
2514
2515 // first draw the pie without pen, if necessary
2516 if( GetBrush() != *wxTRANSPARENT_BRUSH )
2517 {
2518 wxPen tempPen( GetPen() );
2519 SetPen( *wxTRANSPARENT_PEN );
2520 DoDrawPolygon( n, points, 0, 0 );
2521 SetPen( tempPen );
2522 }
2523
2524 // then draw the arc without brush, if necessary
2525 if( GetPen() != *wxTRANSPARENT_PEN )
2526 {
2527 // without center
2528 DoDrawLines( n-1, points, 0, 0 );
2529 }
2530
2531 delete [] points;
2532
2533 } // DrawEllipticArcRot
2534
2535 void wxDCBase::Rotate( wxPointList* points, double angle, wxPoint center )
2536 {
2537 if( angle != 0.0 )
2538 {
2539 double pi(M_PI);
2540 double dSinA = -sin(angle*2.0*pi/360.0);
2541 double dCosA = cos(angle*2.0*pi/360.0);
2542 wxPointList::compatibility_iterator node;
2543 for ( node = points->GetFirst(); node; node = node->GetNext() )
2544 {
2545 wxPoint* point = node->GetData();
2546
2547 // transform coordinates, if necessary
2548 if( center.x ) point->x -= center.x;
2549 if( center.y ) point->y -= center.y;
2550
2551 // calculate rotation, rounding simply by implicit cast to integer
2552 int xTemp = point->x * dCosA - point->y * dSinA;
2553 point->y = point->x * dSinA + point->y * dCosA;
2554 point->x = xTemp;
2555
2556 // back transform coordinates, if necessary
2557 if( center.x ) point->x += center.x;
2558 if( center.y ) point->y += center.y;
2559 }
2560 }
2561 }
2562
2563 void wxDCBase::CalculateEllipticPoints( wxPointList* points,
2564 wxCoord xStart, wxCoord yStart,
2565 wxCoord w, wxCoord h,
2566 double sa, double ea )
2567 {
2568 double pi = M_PI;
2569 double sar = 0;
2570 double ear = 0;
2571 int xsa = 0;
2572 int ysa = 0;
2573 int xea = 0;
2574 int yea = 0;
2575 int sq = 0;
2576 int eq = 0;
2577 bool bUseAngles = false;
2578 if( w<0 ) w = -w;
2579 if( h<0 ) h = -h;
2580 // half-axes
2581 wxCoord a = w/2;
2582 wxCoord b = h/2;
2583 // decrement 1 pixel if ellipse is smaller than 2*a, 2*b
2584 int decrX = 0;
2585 if( 2*a == w ) decrX = 1;
2586 int decrY = 0;
2587 if( 2*b == h ) decrY = 1;
2588 // center
2589 wxCoord xCenter = xStart + a;
2590 wxCoord yCenter = yStart + b;
2591 // calculate data for start and end, if necessary
2592 if( sa != ea )
2593 {
2594 bUseAngles = true;
2595 // normalisation of angles
2596 while( sa<0 ) sa += 360;
2597 while( ea<0 ) ea += 360;
2598 while( sa>=360 ) sa -= 360;
2599 while( ea>=360 ) ea -= 360;
2600 // calculate quadrant numbers
2601 if( sa > 270 ) sq = 3;
2602 else if( sa > 180 ) sq = 2;
2603 else if( sa > 90 ) sq = 1;
2604 if( ea > 270 ) eq = 3;
2605 else if( ea > 180 ) eq = 2;
2606 else if( ea > 90 ) eq = 1;
2607 sar = sa * pi / 180.0;
2608 ear = ea * pi / 180.0;
2609 // correct angle circle -> ellipse
2610 sar = atan( -a/(double)b * tan( sar ) );
2611 if ( sq == 1 || sq == 2 ) sar += pi;
2612 ear = atan( -a/(double)b * tan( ear ) );
2613 if ( eq == 1 || eq == 2 ) ear += pi;
2614 // coordinates of points
2615 xsa = xCenter + a * cos( sar );
2616 if( sq == 0 || sq == 3 ) xsa -= decrX;
2617 ysa = yCenter + b * sin( sar );
2618 if( sq == 2 || sq == 3 ) ysa -= decrY;
2619 xea = xCenter + a * cos( ear );
2620 if( eq == 0 || eq == 3 ) xea -= decrX;
2621 yea = yCenter + b * sin( ear );
2622 if( eq == 2 || eq == 3 ) yea -= decrY;
2623 } // if iUseAngles
2624 // calculate c1 = b^2, c2 = b^2/a^2 with a = w/2, b = h/2
2625 double c1 = b * b;
2626 double c2 = 2.0 / w;
2627 c2 *= c2;
2628 c2 *= c1;
2629 wxCoord x = 0;
2630 wxCoord y = b;
2631 long x2 = 1;
2632 long y2 = y*y;
2633 long y2_old = 0;
2634 long y_old = 0;
2635 // Lists for quadrant 1 to 4
2636 wxPointList pointsarray[4];
2637 // Calculate points for first quadrant and set in all quadrants
2638 for( x = 0; x <= a; ++x )
2639 {
2640 x2 = x2+x+x-1;
2641 y2_old = y2;
2642 y_old = y;
2643 bool bNewPoint = false;
2644 while( y2 > c1 - c2 * x2 && y > 0 )
2645 {
2646 bNewPoint = true;
2647 y2 = y2-y-y+1;
2648 --y;
2649 }
2650 // old y now to big: set point with old y, old x
2651 if( bNewPoint && x>1)
2652 {
2653 int x1 = x - 1;
2654 // remove points on the same line
2655 pointsarray[0].Insert( new wxPoint( xCenter + x1 - decrX, yCenter - y_old ) );
2656 pointsarray[1].Append( new wxPoint( xCenter - x1, yCenter - y_old ) );
2657 pointsarray[2].Insert( new wxPoint( xCenter - x1, yCenter + y_old - decrY ) );
2658 pointsarray[3].Append( new wxPoint( xCenter + x1 - decrX, yCenter + y_old - decrY ) );
2659 } // set point
2660 } // calculate point
2661
2662 // Starting and/or ending points for the quadrants, first quadrant gets both.
2663 pointsarray[0].Insert( new wxPoint( xCenter + a - decrX, yCenter ) );
2664 pointsarray[0].Append( new wxPoint( xCenter, yCenter - b ) );
2665 pointsarray[1].Append( new wxPoint( xCenter - a, yCenter ) );
2666 pointsarray[2].Append( new wxPoint( xCenter, yCenter + b - decrY ) );
2667 pointsarray[3].Append( new wxPoint( xCenter + a - decrX, yCenter ) );
2668
2669 // copy quadrants in original list
2670 if( bUseAngles )
2671 {
2672 // Copy the right part of the points in the lists
2673 // and delete the wxPoints, because they do not leave this method.
2674 points->Append( new wxPoint( xsa, ysa ) );
2675 int q = sq;
2676 bool bStarted = false;
2677 bool bReady = false;
2678 bool bForceTurn = ( sq == eq && sa > ea );
2679 while( !bReady )
2680 {
2681 wxPointList::compatibility_iterator node;
2682 for( node = pointsarray[q].GetFirst(); node; node = node->GetNext() )
2683 {
2684 // once: go to starting point in start quadrant
2685 if( !bStarted &&
2686 (
2687 node->GetData()->x < xsa+1 && q <= 1
2688 ||
2689 node->GetData()->x > xsa-1 && q >= 2
2690 )
2691 )
2692 {
2693 bStarted = true;
2694 }
2695
2696 // copy point, if not at ending point
2697 if( bStarted )
2698 {
2699 if( q != eq || bForceTurn
2700 ||
2701 ( (wxPoint*) node->GetData() )->x > xea+1 && q <= 1
2702 ||
2703 ( (wxPoint*) node->GetData() )->x < xea-1 && q >= 2
2704 )
2705 {
2706 // copy point
2707 wxPoint* pPoint = new wxPoint( *(node->GetData()) );
2708 points->Append( pPoint );
2709 }
2710 else if( q == eq && !bForceTurn || node->GetData()->x == xea)
2711 {
2712 bReady = true;
2713 }
2714 }
2715 } // for node
2716 ++q;
2717 if( q > 3 ) q = 0;
2718 bForceTurn = false;
2719 bStarted = true;
2720 } // while not bReady
2721 points->Append( new wxPoint( xea, yea ) );
2722
2723 // delete points
2724 for( q = 0; q < 4; ++q )
2725 {
2726 wxPointList::compatibility_iterator node;
2727 for( node = pointsarray[q].GetFirst(); node; node = node->GetNext() )
2728 {
2729 wxPoint *p = node->GetData();
2730 delete p;
2731 }
2732 }
2733 }
2734 else
2735 {
2736 wxPointList::compatibility_iterator node;
2737 // copy whole ellipse, wxPoints will be deleted outside
2738 for( node = pointsarray[0].GetFirst(); node; node = node->GetNext() )
2739 {
2740 wxPoint *p = node->GetData();
2741 points->Append( p );
2742 }
2743 for( node = pointsarray[1].GetFirst(); node; node = node->GetNext() )
2744 {
2745 wxPoint *p = node->GetData();
2746 points->Append( p );
2747 }
2748 for( node = pointsarray[2].GetFirst(); node; node = node->GetNext() )
2749 {
2750 wxPoint *p = node->GetData();
2751 points->Append( p );
2752 }
2753 for( node = pointsarray[3].GetFirst(); node; node = node->GetNext() )
2754 {
2755 wxPoint *p = node->GetData();
2756 points->Append( p );
2757 }
2758 } // not iUseAngles
2759 } // CalculateEllipticPoints
2760
2761 #endif // __WXWINCE__
2762
2763 #endif // wxUSE_NEW_DC
wxWidgets (Impactor)