projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
OSX regrouping
[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/prntbase.h"
33
34 #ifndef WX_PRECOMP
35 #include "wx/math.h"
36 #include "wx/module.h"
37 #endif
38
39 #ifdef __WXMSW__
40 #include "wx/msw/dcclient.h"
41 #include "wx/msw/dcmemory.h"
42 #include "wx/msw/dcscreen.h"
43 #endif
44
45 #ifdef __WXGTK20__
46 #include "wx/gtk/dcclient.h"
47 #include "wx/gtk/dcmemory.h"
48 #include "wx/gtk/dcscreen.h"
49 #elif defined(__WXGTK__)
50 #include "wx/gtk1/dcclient.h"
51 #include "wx/gtk1/dcmemory.h"
52 #include "wx/gtk1/dcscreen.h"
53 #endif
54
55 #ifdef __WXMAC__
56 #include "wx/osx/dcclient.h"
57 #include "wx/osx/dcmemory.h"
58 #include "wx/osx/dcscreen.h"
59 #endif
60
61 #ifdef __WXPM__
62 #include "wx/os2/dcclient.h"
63 #include "wx/os2/dcmemory.h"
64 #include "wx/os2/dcscreen.h"
65 #endif
66
67 #ifdef __WXCOCOA__
68 #include "wx/cocoa/dcclient.h"
69 #include "wx/cocoa/dcmemory.h"
70 #include "wx/cocoa/dcscreen.h"
71 #endif
72
73 #ifdef __WXMOTIF__
74 #include "wx/motif/dcclient.h"
75 #include "wx/motif/dcmemory.h"
76 #include "wx/motif/dcscreen.h"
77 #endif
78
79 #ifdef __WXX11__
80 #include "wx/x11/dcclient.h"
81 #include "wx/x11/dcmemory.h"
82 #include "wx/x11/dcscreen.h"
83 #endif
84
85 #ifdef __WXDFB__
86 #include "wx/dfb/dcclient.h"
87 #include "wx/dfb/dcmemory.h"
88 #include "wx/dfb/dcscreen.h"
89 #endif
90
91 #ifdef __WXPALMOS__
92 #include "wx/palmos/dcclient.h"
93 #include "wx/palmos/dcmemory.h"
94 #include "wx/palmos/dcscreen.h"
95 #endif
96
97 //----------------------------------------------------------------------------
98 // wxDCFactory
99 //----------------------------------------------------------------------------
100
101 wxDCFactory *wxDCFactory::m_factory = NULL;
102
103 void wxDCFactory::Set(wxDCFactory *factory)
104 {
105 delete m_factory;
106
107 m_factory = factory;
108 }
109
110 wxDCFactory *wxDCFactory::Get()
111 {
112 if ( !m_factory )
113 m_factory = new wxNativeDCFactory;
114
115 return m_factory;
116 }
117
118 class wxDCFactoryCleanupModule : public wxModule
119 {
120 public:
121 virtual bool OnInit() { return true; }
122 virtual void OnExit() { wxDCFactory::Set(NULL); }
123
124 private:
125 DECLARE_DYNAMIC_CLASS(wxDCFactoryCleanupModule)
126 };
127
128 IMPLEMENT_DYNAMIC_CLASS(wxDCFactoryCleanupModule, wxModule)
129
130 //-----------------------------------------------------------------------------
131 // wxNativeDCFactory
132 //-----------------------------------------------------------------------------
133
134 wxDCImpl* wxNativeDCFactory::CreateWindowDC( wxWindowDC *owner, wxWindow *window )
135 {
136 wxDCImpl * const impl = new wxWindowDCImpl( owner, window );
137 impl->InheritAttributes(window);
138 return impl;
139 }
140
141 wxDCImpl* wxNativeDCFactory::CreateClientDC( wxClientDC *owner, wxWindow *window )
142 {
143 wxDCImpl * const impl = new wxClientDCImpl( owner, window );
144 impl->InheritAttributes(window);
145 return impl;
146 }
147
148 wxDCImpl* wxNativeDCFactory::CreatePaintDC( wxPaintDC *owner, wxWindow *window )
149 {
150 wxDCImpl * const impl = new wxPaintDCImpl( owner, window );
151 impl->InheritAttributes(window);
152 return impl;
153 }
154
155 wxDCImpl* wxNativeDCFactory::CreateMemoryDC( wxMemoryDC *owner )
156 {
157 return new wxMemoryDCImpl( owner );
158 }
159
160 wxDCImpl* wxNativeDCFactory::CreateMemoryDC( wxMemoryDC *owner, wxBitmap &bitmap )
161 {
162 return new wxMemoryDCImpl( owner, bitmap );
163 }
164
165 wxDCImpl* wxNativeDCFactory::CreateMemoryDC( wxMemoryDC *owner, wxDC *dc )
166 {
167 return new wxMemoryDCImpl( owner, dc );
168 }
169
170 wxDCImpl* wxNativeDCFactory::CreateScreenDC( wxScreenDC *owner )
171 {
172 return new wxScreenDCImpl( owner );
173 }
174
175 #if wxUSE_PRINTING_ARCHITECTURE
176 wxDCImpl *wxNativeDCFactory::CreatePrinterDC( wxPrinterDC *owner, const wxPrintData &data )
177 {
178 wxPrintFactory *factory = wxPrintFactory::GetFactory();
179 return factory->CreatePrinterDCImpl( owner, data );
180 }
181 #endif
182
183 //-----------------------------------------------------------------------------
184 // wxWindowDC
185 //-----------------------------------------------------------------------------
186
187 IMPLEMENT_ABSTRACT_CLASS(wxWindowDC, wxDC)
188
189 wxWindowDC::wxWindowDC(wxWindow *win)
190 : wxDC(wxDCFactory::Get()->CreateWindowDC(this, win))
191 {
192 }
193
194 //-----------------------------------------------------------------------------
195 // wxClientDC
196 //-----------------------------------------------------------------------------
197
198 IMPLEMENT_ABSTRACT_CLASS(wxClientDC, wxWindowDC)
199
200 wxClientDC::wxClientDC(wxWindow *win)
201 : wxWindowDC(wxDCFactory::Get()->CreateClientDC(this, win))
202 {
203 }
204
205 //-----------------------------------------------------------------------------
206 // wxMemoryDC
207 //-----------------------------------------------------------------------------
208
209 IMPLEMENT_DYNAMIC_CLASS(wxMemoryDC, wxDC)
210
211 wxMemoryDC::wxMemoryDC()
212 : wxDC(wxDCFactory::Get()->CreateMemoryDC(this))
213 {
214 }
215
216 wxMemoryDC::wxMemoryDC(wxBitmap& bitmap)
217 : wxDC(wxDCFactory::Get()->CreateMemoryDC(this, bitmap))
218 {
219 }
220
221 wxMemoryDC::wxMemoryDC(wxDC *dc)
222 : wxDC(wxDCFactory::Get()->CreateMemoryDC(this, dc))
223 {
224 }
225
226 void wxMemoryDC::SelectObject(wxBitmap& bmp)
227 {
228 // make sure that the given wxBitmap is not sharing its data with other
229 // wxBitmap instances as its contents will be modified by any drawing
230 // operation done on this DC
231 if (bmp.IsOk())
232 bmp.UnShare();
233
234 GetImpl()->DoSelect(bmp);
235 }
236
237 void wxMemoryDC::SelectObjectAsSource(const wxBitmap& bmp)
238 {
239 GetImpl()->DoSelect(bmp);
240 }
241
242 const wxBitmap& wxMemoryDC::GetSelectedBitmap() const
243 {
244 return GetImpl()->GetSelectedBitmap();
245 }
246
247 wxBitmap& wxMemoryDC::GetSelectedBitmap()
248 {
249 return GetImpl()->GetSelectedBitmap();
250 }
251
252
253 //-----------------------------------------------------------------------------
254 // wxPaintDC
255 //-----------------------------------------------------------------------------
256
257 IMPLEMENT_ABSTRACT_CLASS(wxPaintDC, wxClientDC)
258
259 wxPaintDC::wxPaintDC(wxWindow *win)
260 : wxClientDC(wxDCFactory::Get()->CreatePaintDC(this, win))
261 {
262 }
263
264 //-----------------------------------------------------------------------------
265 // wxScreenDC
266 //-----------------------------------------------------------------------------
267
268 IMPLEMENT_DYNAMIC_CLASS(wxScreenDC, wxWindowDC)
269
270 wxScreenDC::wxScreenDC()
271 : wxDC(wxDCFactory::Get()->CreateScreenDC(this))
272 {
273 }
274
275 //-----------------------------------------------------------------------------
276 // wxPrinterDC
277 //-----------------------------------------------------------------------------
278
279 #if wxUSE_PRINTING_ARCHITECTURE
280
281 IMPLEMENT_DYNAMIC_CLASS(wxPrinterDC, wxDC)
282
283 wxPrinterDC::wxPrinterDC()
284 : wxDC(wxDCFactory::Get()->CreatePrinterDC(this, wxPrintData()))
285 {
286 }
287
288 wxPrinterDC::wxPrinterDC(const wxPrintData& data)
289 : wxDC(wxDCFactory::Get()->CreatePrinterDC(this, data))
290 {
291 }
292
293 wxRect wxPrinterDC::GetPaperRect()
294 {
295 return GetImpl()->GetPaperRect();
296 }
297
298 int wxPrinterDC::GetResolution()
299 {
300 return GetImpl()->GetResolution();
301 }
302
303 #endif // wxUSE_PRINTING_ARCHITECTURE
304
305 //-----------------------------------------------------------------------------
306 // wxDCImpl
307 //-----------------------------------------------------------------------------
308
309 IMPLEMENT_ABSTRACT_CLASS(wxDCImpl, wxObject)
310
311 wxDCImpl::wxDCImpl( wxDC *owner )
312 : m_window(NULL)
313 , m_colour(wxColourDisplay())
314 , m_ok(true)
315 , m_clipping(false)
316 , m_isInteractive(0)
317 , m_isBBoxValid(false)
318 , m_logicalOriginX(0), m_logicalOriginY(0)
319 , m_deviceOriginX(0), m_deviceOriginY(0)
320 , m_deviceLocalOriginX(0), m_deviceLocalOriginY(0)
321 , m_logicalScaleX(1.0), m_logicalScaleY(1.0)
322 , m_userScaleX(1.0), m_userScaleY(1.0)
323 , m_scaleX(1.0), m_scaleY(1.0)
324 , m_signX(1), m_signY(1)
325 , m_minX(0), m_minY(0), m_maxX(0), m_maxY(0)
326 , m_clipX1(0), m_clipY1(0), m_clipX2(0), m_clipY2(0)
327 , m_logicalFunction(wxCOPY)
328 , m_backgroundMode(wxBRUSHSTYLE_TRANSPARENT)
329 , m_mappingMode(wxMM_TEXT)
330 , m_pen()
331 , m_brush()
332 , m_backgroundBrush()
333 , m_textForegroundColour(*wxBLACK)
334 , m_textBackgroundColour(*wxWHITE)
335 , m_font()
336 #if wxUSE_PALETTE
337 , m_palette()
338 , m_hasCustomPalette(false)
339 #endif // wxUSE_PALETTE
340 {
341 m_owner = owner;
342
343 m_mm_to_pix_x = (double)wxGetDisplaySize().GetWidth() /
344 (double)wxGetDisplaySizeMM().GetWidth();
345 m_mm_to_pix_y = (double)wxGetDisplaySize().GetHeight() /
346 (double)wxGetDisplaySizeMM().GetHeight();
347
348 ResetBoundingBox();
349 ResetClipping();
350 }
351
352 wxDCImpl::~wxDCImpl()
353 {
354 }
355
356 // ----------------------------------------------------------------------------
357 // coordinate conversions and transforms
358 // ----------------------------------------------------------------------------
359
360 wxCoord wxDCImpl::DeviceToLogicalX(wxCoord x) const
361 {
362 return wxRound( (double)((x - m_deviceOriginX - m_deviceLocalOriginX) * m_signX) / m_scaleX ) + m_logicalOriginX ;
363 }
364
365 wxCoord wxDCImpl::DeviceToLogicalY(wxCoord y) const
366 {
367 return wxRound( (double)((y - m_deviceOriginY - m_deviceLocalOriginY) * m_signY) / m_scaleY ) + m_logicalOriginY ;
368 }
369
370 wxCoord wxDCImpl::DeviceToLogicalXRel(wxCoord x) const
371 {
372 return wxRound((double)(x) / m_scaleX);
373 }
374
375 wxCoord wxDCImpl::DeviceToLogicalYRel(wxCoord y) const
376 {
377 return wxRound((double)(y) / m_scaleY);
378 }
379
380 wxCoord wxDCImpl::LogicalToDeviceX(wxCoord x) const
381 {
382 return wxRound( (double)((x - m_logicalOriginX) * m_signX) * m_scaleX) + m_deviceOriginX + m_deviceLocalOriginX;
383 }
384
385 wxCoord wxDCImpl::LogicalToDeviceY(wxCoord y) const
386 {
387 return wxRound( (double)((y - m_logicalOriginY) * m_signY) * m_scaleY) + m_deviceOriginY + m_deviceLocalOriginY;
388 }
389
390 wxCoord wxDCImpl::LogicalToDeviceXRel(wxCoord x) const
391 {
392 return wxRound((double)(x) * m_scaleX);
393 }
394
395 wxCoord wxDCImpl::LogicalToDeviceYRel(wxCoord y) const
396 {
397 return wxRound((double)(y) * m_scaleY);
398 }
399
400 void wxDCImpl::ComputeScaleAndOrigin()
401 {
402 m_scaleX = m_logicalScaleX * m_userScaleX;
403 m_scaleY = m_logicalScaleY * m_userScaleY;
404 }
405
406 void wxDCImpl::SetMapMode( int mode )
407 {
408 switch (mode)
409 {
410 case wxMM_TWIPS:
411 SetLogicalScale( twips2mm*m_mm_to_pix_x, twips2mm*m_mm_to_pix_y );
412 break;
413 case wxMM_POINTS:
414 SetLogicalScale( pt2mm*m_mm_to_pix_x, pt2mm*m_mm_to_pix_y );
415 break;
416 case wxMM_METRIC:
417 SetLogicalScale( m_mm_to_pix_x, m_mm_to_pix_y );
418 break;
419 case wxMM_LOMETRIC:
420 SetLogicalScale( m_mm_to_pix_x/10.0, m_mm_to_pix_y/10.0 );
421 break;
422 default:
423 case wxMM_TEXT:
424 SetLogicalScale( 1.0, 1.0 );
425 break;
426 }
427 m_mappingMode = mode;
428 }
429
430 void wxDCImpl::SetUserScale( double x, double y )
431 {
432 // allow negative ? -> no
433 m_userScaleX = x;
434 m_userScaleY = y;
435 ComputeScaleAndOrigin();
436 }
437
438 void wxDCImpl::SetLogicalScale( double x, double y )
439 {
440 // allow negative ?
441 m_logicalScaleX = x;
442 m_logicalScaleY = y;
443 ComputeScaleAndOrigin();
444 }
445
446 void wxDCImpl::SetLogicalOrigin( wxCoord x, wxCoord y )
447 {
448 m_logicalOriginX = x * m_signX;
449 m_logicalOriginY = y * m_signY;
450 ComputeScaleAndOrigin();
451 }
452
453 void wxDCImpl::SetDeviceOrigin( wxCoord x, wxCoord y )
454 {
455 m_deviceOriginX = x;
456 m_deviceOriginY = y;
457 ComputeScaleAndOrigin();
458 }
459
460 void wxDCImpl::SetDeviceLocalOrigin( wxCoord x, wxCoord y )
461 {
462 m_deviceLocalOriginX = x;
463 m_deviceLocalOriginY = y;
464 ComputeScaleAndOrigin();
465 }
466
467 void wxDCImpl::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
468 {
469 // only wxPostScripDC has m_signX = -1, we override SetAxisOrientation there
470 // wxWidgets 2.9: no longer override it
471 m_signX = (xLeftRight ? 1 : -1);
472 m_signY = (yBottomUp ? -1 : 1);
473 ComputeScaleAndOrigin();
474 }
475
476
477 // Each element of the widths array will be the width of the string up to and
478 // including the corresponding character in text. This is the generic
479 // implementation, the port-specific classes should do this with native APIs
480 // if available and if faster. Note: pango_layout_index_to_pos is much slower
481 // than calling GetTextExtent!!
482
483 #define FWC_SIZE 256
484
485 class FontWidthCache
486 {
487 public:
488 FontWidthCache() : m_scaleX(1), m_widths(NULL) { }
489 ~FontWidthCache() { delete []m_widths; }
490
491 void Reset()
492 {
493 if (!m_widths)
494 m_widths = new int[FWC_SIZE];
495
496 memset(m_widths, 0, sizeof(int)*FWC_SIZE);
497 }
498
499 wxFont m_font;
500 double m_scaleX;
501 int *m_widths;
502 };
503
504 static FontWidthCache s_fontWidthCache;
505
506 bool wxDCImpl::DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const
507 {
508 int totalWidth = 0;
509
510 const size_t len = text.length();
511 widths.Empty();
512 widths.Add(0, len);
513
514 // reset the cache if font or horizontal scale have changed
515 if ( !s_fontWidthCache.m_widths ||
516 !wxIsSameDouble(s_fontWidthCache.m_scaleX, m_scaleX) ||
517 (s_fontWidthCache.m_font != GetFont()) )
518 {
519 s_fontWidthCache.Reset();
520 s_fontWidthCache.m_font = GetFont();
521 s_fontWidthCache.m_scaleX = m_scaleX;
522 }
523
524 // Calculate the position of each character based on the widths of
525 // the previous characters
526 int w, h;
527 for ( size_t i = 0; i < len; i++ )
528 {
529 const wxChar c = text[i];
530 unsigned int c_int = (unsigned int)c;
531
532 if ((c_int < FWC_SIZE) && (s_fontWidthCache.m_widths[c_int] != 0))
533 {
534 w = s_fontWidthCache.m_widths[c_int];
535 }
536 else
537 {
538 DoGetTextExtent(c, &w, &h);
539 if (c_int < FWC_SIZE)
540 s_fontWidthCache.m_widths[c_int] = w;
541 }
542
543 totalWidth += w;
544 widths[i] = totalWidth;
545 }
546
547 return true;
548 }
549
550 void wxDCImpl::GetMultiLineTextExtent(const wxString& text,
551 wxCoord *x,
552 wxCoord *y,
553 wxCoord *h,
554 const wxFont *font) const
555 {
556 wxCoord widthTextMax = 0, widthLine,
557 heightTextTotal = 0, heightLineDefault = 0, heightLine = 0;
558
559 wxString curLine;
560 for ( wxString::const_iterator pc = text.begin(); ; ++pc )
561 {
562 if ( pc == text.end() || *pc == _T('\n') )
563 {
564 if ( curLine.empty() )
565 {
566 // we can't use GetTextExtent - it will return 0 for both width
567 // and height and an empty line should count in height
568 // calculation
569
570 // assume that this line has the same height as the previous
571 // one
572 if ( !heightLineDefault )
573 heightLineDefault = heightLine;
574
575 if ( !heightLineDefault )
576 {
577 // but we don't know it yet - choose something reasonable
578 DoGetTextExtent(_T("W"), NULL, &heightLineDefault,
579 NULL, NULL, font);
580 }
581
582 heightTextTotal += heightLineDefault;
583 }
584 else
585 {
586 DoGetTextExtent(curLine, &widthLine, &heightLine,
587 NULL, NULL, font);
588 if ( widthLine > widthTextMax )
589 widthTextMax = widthLine;
590 heightTextTotal += heightLine;
591 }
592
593 if ( pc == text.end() )
594 {
595 break;
596 }
597 else // '\n'
598 {
599 curLine.clear();
600 }
601 }
602 else
603 {
604 curLine += *pc;
605 }
606 }
607
608 if ( x )
609 *x = widthTextMax;
610 if ( y )
611 *y = heightTextTotal;
612 if ( h )
613 *h = heightLine;
614 }
615
616 void wxDCImpl::DoDrawCheckMark(wxCoord x1, wxCoord y1,
617 wxCoord width, wxCoord height)
618 {
619 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
620
621 wxCoord x2 = x1 + width,
622 y2 = y1 + height;
623
624 // the pen width is calibrated to give 3 for width == height == 10
625 wxDCPenChanger pen( *m_owner, wxPen(GetTextForeground(), (width + height + 1)/7));
626
627 // we're drawing a scaled version of wx/generic/tick.xpm here
628 wxCoord x3 = x1 + (4*width) / 10, // x of the tick bottom
629 y3 = y1 + height / 2; // y of the left tick branch
630 DoDrawLine(x1, y3, x3, y2);
631 DoDrawLine(x3, y2, x2, y1);
632
633 CalcBoundingBox(x1, y1);
634 CalcBoundingBox(x2, y2);
635 }
636
637 bool
638 wxDCImpl::DoStretchBlit(wxCoord xdest, wxCoord ydest,
639 wxCoord dstWidth, wxCoord dstHeight,
640 wxDC *source,
641 wxCoord xsrc, wxCoord ysrc,
642 wxCoord srcWidth, wxCoord srcHeight,
643 int rop,
644 bool useMask,
645 wxCoord xsrcMask,
646 wxCoord ysrcMask)
647 {
648 wxCHECK_MSG( srcWidth && srcHeight && dstWidth && dstHeight, false,
649 _T("invalid blit size") );
650
651 // emulate the stretching by modifying the DC scale
652 double xscale = (double)srcWidth/dstWidth,
653 yscale = (double)srcHeight/dstHeight;
654
655 double xscaleOld, yscaleOld;
656 GetUserScale(&xscaleOld, &yscaleOld);
657 SetUserScale(xscaleOld/xscale, yscaleOld/yscale);
658
659 bool rc = DoBlit(wxCoord(xdest*xscale), wxCoord(ydest*yscale),
660 wxCoord(dstWidth*xscale), wxCoord(dstHeight*yscale),
661 source,
662 xsrc, ysrc, rop, useMask, xsrcMask, ysrcMask);
663
664 SetUserScale(xscaleOld, yscaleOld);
665
666 return rc;
667 }
668
669 void wxDCImpl::DrawLines(const wxPointList *list, wxCoord xoffset, wxCoord yoffset)
670 {
671 int n = list->GetCount();
672 wxPoint *points = new wxPoint[n];
673
674 int i = 0;
675 for ( wxPointList::compatibility_iterator node = list->GetFirst(); node; node = node->GetNext(), i++ )
676 {
677 wxPoint *point = node->GetData();
678 points[i].x = point->x;
679 points[i].y = point->y;
680 }
681
682 DoDrawLines(n, points, xoffset, yoffset);
683
684 delete [] points;
685 }
686
687 void wxDCImpl::DrawPolygon(const wxPointList *list,
688 wxCoord xoffset, wxCoord yoffset,
689 int fillStyle)
690 {
691 int n = list->GetCount();
692 wxPoint *points = new wxPoint[n];
693
694 int i = 0;
695 for ( wxPointList::compatibility_iterator node = list->GetFirst(); node; node = node->GetNext(), i++ )
696 {
697 wxPoint *point = node->GetData();
698 points[i].x = point->x;
699 points[i].y = point->y;
700 }
701
702 DoDrawPolygon(n, points, xoffset, yoffset, fillStyle);
703
704 delete [] points;
705 }
706
707 void
708 wxDCImpl::DoDrawPolyPolygon(int n,
709 int count[],
710 wxPoint points[],
711 wxCoord xoffset, wxCoord yoffset,
712 int fillStyle)
713 {
714 if ( n == 1 )
715 {
716 DoDrawPolygon(count[0], points, xoffset, yoffset, fillStyle);
717 return;
718 }
719
720 int i, j, lastOfs;
721 wxPoint* pts;
722 wxPen pen;
723
724 for (i = j = lastOfs = 0; i < n; i++)
725 {
726 lastOfs = j;
727 j += count[i];
728 }
729 pts = new wxPoint[j+n-1];
730 for (i = 0; i < j; i++)
731 pts[i] = points[i];
732 for (i = 2; i <= n; i++)
733 {
734 lastOfs -= count[n-i];
735 pts[j++] = pts[lastOfs];
736 }
737
738 pen = GetPen();
739 SetPen(wxPen(*wxBLACK, 0, wxPENSTYLE_TRANSPARENT));
740 DoDrawPolygon(j, pts, xoffset, yoffset, fillStyle);
741 SetPen(pen);
742 for (i = j = 0; i < n; i++)
743 {
744 DoDrawLines(count[i], pts+j, xoffset, yoffset);
745 j += count[i];
746 }
747 delete[] pts;
748 }
749
750 #if wxUSE_SPLINES
751
752 void wxDCImpl::DrawSpline(wxCoord x1, wxCoord y1,
753 wxCoord x2, wxCoord y2,
754 wxCoord x3, wxCoord y3)
755 {
756 wxPoint points[] = { wxPoint(x1, y1), wxPoint(x2, y2), wxPoint(x3, y3) };
757 DrawSpline(WXSIZEOF(points), points);
758 }
759
760 void wxDCImpl::DrawSpline(int n, wxPoint points[])
761 {
762 wxPointList list;
763 for ( int i = 0; i < n; i++ )
764 list.Append(&points[i]);
765
766 DrawSpline(&list);
767 }
768
769 // ----------------------------------- spline code ----------------------------------------
770
771 void wx_quadratic_spline(double a1, double b1, double a2, double b2,
772 double a3, double b3, double a4, double b4);
773 void wx_clear_stack();
774 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2, double *x3,
775 double *y3, double *x4, double *y4);
776 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3,
777 double x4, double y4);
778 static bool wx_spline_add_point(double x, double y);
779 static void wx_spline_draw_point_array(wxDC *dc);
780
781 wxPointList wx_spline_point_list;
782
783 #define half(z1, z2) ((z1+z2)/2.0)
784 #define THRESHOLD 5
785
786 /* iterative version */
787
788 void wx_quadratic_spline(double a1, double b1, double a2, double b2, double a3, double b3, double a4,
789 double b4)
790 {
791 register double xmid, ymid;
792 double x1, y1, x2, y2, x3, y3, x4, y4;
793
794 wx_clear_stack();
795 wx_spline_push(a1, b1, a2, b2, a3, b3, a4, b4);
796
797 while (wx_spline_pop(&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4)) {
798 xmid = (double)half(x2, x3);
799 ymid = (double)half(y2, y3);
800 if (fabs(x1 - xmid) < THRESHOLD && fabs(y1 - ymid) < THRESHOLD &&
801 fabs(xmid - x4) < THRESHOLD && fabs(ymid - y4) < THRESHOLD) {
802 wx_spline_add_point( x1, y1 );
803 wx_spline_add_point( xmid, ymid );
804 } else {
805 wx_spline_push(xmid, ymid, (double)half(xmid, x3), (double)half(ymid, y3),
806 (double)half(x3, x4), (double)half(y3, y4), x4, y4);
807 wx_spline_push(x1, y1, (double)half(x1, x2), (double)half(y1, y2),
808 (double)half(x2, xmid), (double)half(y2, ymid), xmid, ymid);
809 }
810 }
811 }
812
813 /* utilities used by spline drawing routines */
814
815 typedef struct wx_spline_stack_struct {
816 double x1, y1, x2, y2, x3, y3, x4, y4;
817 } Stack;
818
819 #define SPLINE_STACK_DEPTH 20
820 static Stack wx_spline_stack[SPLINE_STACK_DEPTH];
821 static Stack *wx_stack_top;
822 static int wx_stack_count;
823
824 void wx_clear_stack()
825 {
826 wx_stack_top = wx_spline_stack;
827 wx_stack_count = 0;
828 }
829
830 void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
831 {
832 wx_stack_top->x1 = x1;
833 wx_stack_top->y1 = y1;
834 wx_stack_top->x2 = x2;
835 wx_stack_top->y2 = y2;
836 wx_stack_top->x3 = x3;
837 wx_stack_top->y3 = y3;
838 wx_stack_top->x4 = x4;
839 wx_stack_top->y4 = y4;
840 wx_stack_top++;
841 wx_stack_count++;
842 }
843
844 int wx_spline_pop(double *x1, double *y1, double *x2, double *y2,
845 double *x3, double *y3, double *x4, double *y4)
846 {
847 if (wx_stack_count == 0)
848 return (0);
849 wx_stack_top--;
850 wx_stack_count--;
851 *x1 = wx_stack_top->x1;
852 *y1 = wx_stack_top->y1;
853 *x2 = wx_stack_top->x2;
854 *y2 = wx_stack_top->y2;
855 *x3 = wx_stack_top->x3;
856 *y3 = wx_stack_top->y3;
857 *x4 = wx_stack_top->x4;
858 *y4 = wx_stack_top->y4;
859 return (1);
860 }
861
862 static bool wx_spline_add_point(double x, double y)
863 {
864 wxPoint *point = new wxPoint( wxRound(x), wxRound(y) );
865 wx_spline_point_list.Append(point );
866 return true;
867 }
868
869 static void wx_spline_draw_point_array(wxDC *dc)
870 {
871 dc->DrawLines(&wx_spline_point_list, 0, 0 );
872 wxPointList::compatibility_iterator node = wx_spline_point_list.GetFirst();
873 while (node)
874 {
875 wxPoint *point = node->GetData();
876 delete point;
877 wx_spline_point_list.Erase(node);
878 node = wx_spline_point_list.GetFirst();
879 }
880 }
881
882 void wxDCImpl::DoDrawSpline( const wxPointList *points )
883 {
884 wxCHECK_RET( IsOk(), wxT("invalid window dc") );
885
886 wxPoint *p;
887 double cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
888 double x1, y1, x2, y2;
889
890 wxPointList::compatibility_iterator node = points->GetFirst();
891 if (!node)
892 // empty list
893 return;
894
895 p = (wxPoint *)node->GetData();
896
897 x1 = p->x;
898 y1 = p->y;
899
900 node = node->GetNext();
901 p = node->GetData();
902
903 x2 = p->x;
904 y2 = p->y;
905 cx1 = (double)((x1 + x2) / 2);
906 cy1 = (double)((y1 + y2) / 2);
907 cx2 = (double)((cx1 + x2) / 2);
908 cy2 = (double)((cy1 + y2) / 2);
909
910 wx_spline_add_point(x1, y1);
911
912 while ((node = node->GetNext())
913 #if !wxUSE_STL
914 != NULL
915 #endif // !wxUSE_STL
916 )
917 {
918 p = node->GetData();
919 x1 = x2;
920 y1 = y2;
921 x2 = p->x;
922 y2 = p->y;
923 cx4 = (double)(x1 + x2) / 2;
924 cy4 = (double)(y1 + y2) / 2;
925 cx3 = (double)(x1 + cx4) / 2;
926 cy3 = (double)(y1 + cy4) / 2;
927
928 wx_quadratic_spline(cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4);
929
930 cx1 = cx4;
931 cy1 = cy4;
932 cx2 = (double)(cx1 + x2) / 2;
933 cy2 = (double)(cy1 + y2) / 2;
934 }
935
936 wx_spline_add_point( cx1, cy1 );
937 wx_spline_add_point( x2, y2 );
938
939 wx_spline_draw_point_array( m_owner );
940 }
941
942 #endif // wxUSE_SPLINES
943
944
945
946 void wxDCImpl::DoGradientFillLinear(const wxRect& rect,
947 const wxColour& initialColour,
948 const wxColour& destColour,
949 wxDirection nDirection)
950 {
951 // save old pen
952 wxPen oldPen = m_pen;
953 wxBrush oldBrush = m_brush;
954
955 wxUint8 nR1 = initialColour.Red();
956 wxUint8 nG1 = initialColour.Green();
957 wxUint8 nB1 = initialColour.Blue();
958 wxUint8 nR2 = destColour.Red();
959 wxUint8 nG2 = destColour.Green();
960 wxUint8 nB2 = destColour.Blue();
961 wxUint8 nR, nG, nB;
962
963 if ( nDirection == wxEAST || nDirection == wxWEST )
964 {
965 wxInt32 x = rect.GetWidth();
966 wxInt32 w = x; // width of area to shade
967 wxInt32 xDelta = w/256; // height of one shade bend
968 if (xDelta < 1)
969 xDelta = 1;
970
971 while (x >= xDelta)
972 {
973 x -= xDelta;
974 if (nR1 > nR2)
975 nR = nR1 - (nR1-nR2)*(w-x)/w;
976 else
977 nR = nR1 + (nR2-nR1)*(w-x)/w;
978
979 if (nG1 > nG2)
980 nG = nG1 - (nG1-nG2)*(w-x)/w;
981 else
982 nG = nG1 + (nG2-nG1)*(w-x)/w;
983
984 if (nB1 > nB2)
985 nB = nB1 - (nB1-nB2)*(w-x)/w;
986 else
987 nB = nB1 + (nB2-nB1)*(w-x)/w;
988
989 wxColour colour(nR,nG,nB);
990 SetPen(wxPen(colour, 1, wxPENSTYLE_SOLID));
991 SetBrush(wxBrush(colour));
992 if(nDirection == wxEAST)
993 DoDrawRectangle(rect.GetRight()-x-xDelta+1, rect.GetTop(),
994 xDelta, rect.GetHeight());
995 else //nDirection == wxWEST
996 DoDrawRectangle(rect.GetLeft()+x, rect.GetTop(),
997 xDelta, rect.GetHeight());
998 }
999 }
1000 else // nDirection == wxNORTH || nDirection == wxSOUTH
1001 {
1002 wxInt32 y = rect.GetHeight();
1003 wxInt32 w = y; // height of area to shade
1004 wxInt32 yDelta = w/255; // height of one shade bend
1005 if (yDelta < 1)
1006 yDelta = 1;
1007
1008 while (y > 0)
1009 {
1010 y -= yDelta;
1011 if (nR1 > nR2)
1012 nR = nR1 - (nR1-nR2)*(w-y)/w;
1013 else
1014 nR = nR1 + (nR2-nR1)*(w-y)/w;
1015
1016 if (nG1 > nG2)
1017 nG = nG1 - (nG1-nG2)*(w-y)/w;
1018 else
1019 nG = nG1 + (nG2-nG1)*(w-y)/w;
1020
1021 if (nB1 > nB2)
1022 nB = nB1 - (nB1-nB2)*(w-y)/w;
1023 else
1024 nB = nB1 + (nB2-nB1)*(w-y)/w;
1025
1026 wxColour colour(nR,nG,nB);
1027 SetPen(wxPen(colour, 1, wxPENSTYLE_SOLID));
1028 SetBrush(wxBrush(colour));
1029 if(nDirection == wxNORTH)
1030 DoDrawRectangle(rect.GetLeft(), rect.GetTop()+y,
1031 rect.GetWidth(), yDelta);
1032 else //nDirection == wxSOUTH
1033 DoDrawRectangle(rect.GetLeft(), rect.GetBottom()-y-yDelta+1,
1034 rect.GetWidth(), yDelta);
1035 }
1036 }
1037
1038 SetPen(oldPen);
1039 SetBrush(oldBrush);
1040 }
1041
1042 void wxDCImpl::DoGradientFillConcentric(const wxRect& rect,
1043 const wxColour& initialColour,
1044 const wxColour& destColour,
1045 const wxPoint& circleCenter)
1046 {
1047 //save the old pen color
1048 wxColour oldPenColour = m_pen.GetColour();
1049
1050 wxUint8 nR1 = destColour.Red();
1051 wxUint8 nG1 = destColour.Green();
1052 wxUint8 nB1 = destColour.Blue();
1053 wxUint8 nR2 = initialColour.Red();
1054 wxUint8 nG2 = initialColour.Green();
1055 wxUint8 nB2 = initialColour.Blue();
1056 wxUint8 nR, nG, nB;
1057
1058
1059 //Radius
1060 wxInt32 cx = rect.GetWidth() / 2;
1061 wxInt32 cy = rect.GetHeight() / 2;
1062 wxInt32 nRadius;
1063 if (cx < cy)
1064 nRadius = cx;
1065 else
1066 nRadius = cy;
1067
1068 //Offset of circle
1069 wxInt32 nCircleOffX = circleCenter.x - (rect.GetWidth() / 2);
1070 wxInt32 nCircleOffY = circleCenter.y - (rect.GetHeight() / 2);
1071
1072 for ( wxInt32 x = 0; x < rect.GetWidth(); x++ )
1073 {
1074 for ( wxInt32 y = 0; y < rect.GetHeight(); y++ )
1075 {
1076 //get color difference
1077 wxInt32 nGradient = ((nRadius -
1078 (wxInt32)sqrt(
1079 pow((double)(x - cx - nCircleOffX), 2) +
1080 pow((double)(y - cy - nCircleOffY), 2)
1081 )) * 100) / nRadius;
1082
1083 //normalize Gradient
1084 if (nGradient < 0 )
1085 nGradient = 0;
1086
1087 //get dest colors
1088 nR = (wxUint8)(nR1 + ((nR2 - nR1) * nGradient / 100));
1089 nG = (wxUint8)(nG1 + ((nG2 - nG1) * nGradient / 100));
1090 nB = (wxUint8)(nB1 + ((nB2 - nB1) * nGradient / 100));
1091
1092 //set the pixel
1093 m_pen.SetColour(wxColour(nR,nG,nB));
1094 DoDrawPoint(x + rect.GetLeft(), y + rect.GetTop());
1095 }
1096 }
1097 //return old pen color
1098 m_pen.SetColour(oldPenColour);
1099 }
1100
1101 void wxDCImpl::InheritAttributes(wxWindow *win)
1102 {
1103 wxCHECK_RET( win, "window can't be NULL" );
1104
1105 SetFont(win->GetFont());
1106 SetTextForeground(win->GetForegroundColour());
1107 SetTextBackground(win->GetBackgroundColour());
1108 SetBackground(wxBrush(win->GetBackgroundColour()));
1109 }
1110
1111 //-----------------------------------------------------------------------------
1112 // wxDC
1113 //-----------------------------------------------------------------------------
1114
1115 IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
1116
1117 void wxDC::DrawLabel(const wxString& text,
1118 const wxBitmap& bitmap,
1119 const wxRect& rect,
1120 int alignment,
1121 int indexAccel,
1122 wxRect *rectBounding)
1123 {
1124 // find the text position
1125 wxCoord widthText, heightText, heightLine;
1126 GetMultiLineTextExtent(text, &widthText, &heightText, &heightLine);
1127
1128 wxCoord width, height;
1129 if ( bitmap.Ok() )
1130 {
1131 width = widthText + bitmap.GetWidth();
1132 height = bitmap.GetHeight();
1133 }
1134 else // no bitmap
1135 {
1136 width = widthText;
1137 height = heightText;
1138 }
1139
1140 wxCoord x, y;
1141 if ( alignment & wxALIGN_RIGHT )
1142 {
1143 x = rect.GetRight() - width;
1144 }
1145 else if ( alignment & wxALIGN_CENTRE_HORIZONTAL )
1146 {
1147 x = (rect.GetLeft() + rect.GetRight() + 1 - width) / 2;
1148 }
1149 else // alignment & wxALIGN_LEFT
1150 {
1151 x = rect.GetLeft();
1152 }
1153
1154 if ( alignment & wxALIGN_BOTTOM )
1155 {
1156 y = rect.GetBottom() - height;
1157 }
1158 else if ( alignment & wxALIGN_CENTRE_VERTICAL )
1159 {
1160 y = (rect.GetTop() + rect.GetBottom() + 1 - height) / 2;
1161 }
1162 else // alignment & wxALIGN_TOP
1163 {
1164 y = rect.GetTop();
1165 }
1166
1167 // draw the bitmap first
1168 wxCoord x0 = x,
1169 y0 = y,
1170 width0 = width;
1171 if ( bitmap.Ok() )
1172 {
1173 DrawBitmap(bitmap, x, y, true /* use mask */);
1174
1175 wxCoord offset = bitmap.GetWidth() + 4;
1176 x += offset;
1177 width -= offset;
1178
1179 y += (height - heightText) / 2;
1180 }
1181
1182 // we will draw the underscore under the accel char later
1183 wxCoord startUnderscore = 0,
1184 endUnderscore = 0,
1185 yUnderscore = 0;
1186
1187 // split the string into lines and draw each of them separately
1188 wxString curLine;
1189 for ( wxString::const_iterator pc = text.begin(); ; ++pc )
1190 {
1191 if ( pc == text.end() || *pc == '\n' )
1192 {
1193 int xRealStart = x; // init it here to avoid compielr warnings
1194
1195 if ( !curLine.empty() )
1196 {
1197 // NB: can't test for !(alignment & wxALIGN_LEFT) because
1198 // wxALIGN_LEFT is 0
1199 if ( alignment & (wxALIGN_RIGHT | wxALIGN_CENTRE_HORIZONTAL) )
1200 {
1201 wxCoord widthLine;
1202 GetTextExtent(curLine, &widthLine, NULL);
1203
1204 if ( alignment & wxALIGN_RIGHT )
1205 {
1206 xRealStart += width - widthLine;
1207 }
1208 else // if ( alignment & wxALIGN_CENTRE_HORIZONTAL )
1209 {
1210 xRealStart += (width - widthLine) / 2;
1211 }
1212 }
1213 //else: left aligned, nothing to do
1214
1215 DrawText(curLine, xRealStart, y);
1216 }
1217
1218 y += heightLine;
1219
1220 // do we have underscore in this line? we can check yUnderscore
1221 // because it is set below to just y + heightLine if we do
1222 if ( y == yUnderscore )
1223 {
1224 // adjust the horz positions to account for the shift
1225 startUnderscore += xRealStart;
1226 endUnderscore += xRealStart;
1227 }
1228
1229 if ( pc == text.end() )
1230 break;
1231
1232 curLine.clear();
1233 }
1234 else // not end of line
1235 {
1236 if ( pc - text.begin() == indexAccel )
1237 {
1238 // remeber to draw underscore here
1239 GetTextExtent(curLine, &startUnderscore, NULL);
1240 curLine += *pc;
1241 GetTextExtent(curLine, &endUnderscore, NULL);
1242
1243 yUnderscore = y + heightLine;
1244 }
1245 else
1246 {
1247 curLine += *pc;
1248 }
1249 }
1250 }
1251
1252 // draw the underscore if found
1253 if ( startUnderscore != endUnderscore )
1254 {
1255 // it should be of the same colour as text
1256 SetPen(wxPen(GetTextForeground(), 0, wxPENSTYLE_SOLID));
1257
1258 yUnderscore--;
1259
1260 DrawLine(startUnderscore, yUnderscore, endUnderscore, yUnderscore);
1261 }
1262
1263 // return bounding rect if requested
1264 if ( rectBounding )
1265 {
1266 *rectBounding = wxRect(x, y - heightText, widthText, heightText);
1267 }
1268
1269 CalcBoundingBox(x0, y0);
1270 CalcBoundingBox(x0 + width0, y0 + height);
1271 }
1272
1273 #if WXWIN_COMPATIBILITY_2_8
1274 // for compatibility with the old code when wxCoord was long everywhere
1275 void wxDC::GetTextExtent(const wxString& string,
1276 long *x, long *y,
1277 long *descent,
1278 long *externalLeading,
1279 const wxFont *theFont) const
1280 {
1281 wxCoord x2, y2, descent2, externalLeading2;
1282 m_pimpl->DoGetTextExtent(string, &x2, &y2,
1283 &descent2, &externalLeading2,
1284 theFont);
1285 if ( x )
1286 *x = x2;
1287 if ( y )
1288 *y = y2;
1289 if ( descent )
1290 *descent = descent2;
1291 if ( externalLeading )
1292 *externalLeading = externalLeading2;
1293 }
1294
1295 void wxDC::GetLogicalOrigin(long *x, long *y) const
1296 {
1297 wxCoord x2, y2;
1298 m_pimpl->DoGetLogicalOrigin(&x2, &y2);
1299 if ( x )
1300 *x = x2;
1301 if ( y )
1302 *y = y2;
1303 }
1304
1305 void wxDC::GetDeviceOrigin(long *x, long *y) const
1306 {
1307 wxCoord x2, y2;
1308 m_pimpl->DoGetDeviceOrigin(&x2, &y2);
1309 if ( x )
1310 *x = x2;
1311 if ( y )
1312 *y = y2;
1313 }
1314
1315 void wxDC::GetClippingBox(long *x, long *y, long *w, long *h) const
1316 {
1317 wxCoord xx,yy,ww,hh;
1318 m_pimpl->DoGetClippingBox(&xx, &yy, &ww, &hh);
1319 if (x) *x = xx;
1320 if (y) *y = yy;
1321 if (w) *w = ww;
1322 if (h) *h = hh;
1323 }
1324
1325 #endif // WXWIN_COMPATIBILITY_2_8
1326
1327 /*
1328 Notes for wxWidgets DrawEllipticArcRot(...)
1329
1330 wxDCBase::DrawEllipticArcRot(...) draws a rotated elliptic arc or an ellipse.
1331 It uses wxDCBase::CalculateEllipticPoints(...) and wxDCBase::Rotate(...),
1332 which are also new.
1333
1334 All methods are generic, so they can be implemented in wxDCBase.
1335 DoDrawEllipticArcRot(...) is virtual, so it can be called from deeper
1336 methods like (WinCE) wxDC::DoDrawArc(...).
1337
1338 CalculateEllipticPoints(...) fills a given list of wxPoints with some points
1339 of an elliptic arc. The algorithm is pixel-based: In every row (in flat
1340 parts) or every column (in steep parts) only one pixel is calculated.
1341 Trigonometric calculation (sin, cos, tan, atan) is only done if the
1342 starting angle is not equal to the ending angle. The calculation of the
1343 pixels is done using simple arithmetic only and should perform not too
1344 bad even on devices without floating point processor. I didn't test this yet.
1345
1346 Rotate(...) rotates a list of point pixel-based, you will see rounding errors.
1347 For instance: an ellipse rotated 180 degrees is drawn
1348 slightly different from the original.
1349
1350 The points are then moved to an array and used to draw a polyline and/or polygon
1351 (with center added, the pie).
1352 The result looks quite similar to the native ellipse, only e few pixels differ.
1353
1354 The performance on a desktop system (Athlon 1800, WinXP) is about 7 times
1355 slower as DrawEllipse(...), which calls the native API.
1356 An rotated ellipse outside the clipping region takes nearly the same time,
1357 while an native ellipse outside takes nearly no time to draw.
1358
1359 If you draw an arc with this new method, you will see the starting and ending angles
1360 are calculated properly.
1361 If you use DrawEllipticArc(...), you will see they are only correct for circles
1362 and not properly calculated for ellipses.
1363
1364 Peter Lenhard
1365 p.lenhard@t-online.de
1366 */
1367
1368 #ifdef __WXWINCE__
1369 void wxDCImpl::DoDrawEllipticArcRot( wxCoord x, wxCoord y,
1370 wxCoord w, wxCoord h,
1371 double sa, double ea, double angle )
1372 {
1373 wxPointList list;
1374
1375 CalculateEllipticPoints( &list, x, y, w, h, sa, ea );
1376 Rotate( &list, angle, wxPoint( x+w/2, y+h/2 ) );
1377
1378 // Add center (for polygon/pie)
1379 list.Append( new wxPoint( x+w/2, y+h/2 ) );
1380
1381 // copy list into array and delete list elements
1382 int n = list.GetCount();
1383 wxPoint *points = new wxPoint[n];
1384 int i = 0;
1385 wxPointList::compatibility_iterator node;
1386 for ( node = list.GetFirst(); node; node = node->GetNext(), i++ )
1387 {
1388 wxPoint *point = node->GetData();
1389 points[i].x = point->x;
1390 points[i].y = point->y;
1391 delete point;
1392 }
1393
1394 // first draw the pie without pen, if necessary
1395 if( GetBrush() != *wxTRANSPARENT_BRUSH )
1396 {
1397 wxPen tempPen( GetPen() );
1398 SetPen( *wxTRANSPARENT_PEN );
1399 DoDrawPolygon( n, points, 0, 0 );
1400 SetPen( tempPen );
1401 }
1402
1403 // then draw the arc without brush, if necessary
1404 if( GetPen() != *wxTRANSPARENT_PEN )
1405 {
1406 // without center
1407 DoDrawLines( n-1, points, 0, 0 );
1408 }
1409
1410 delete [] points;
1411
1412 } // DrawEllipticArcRot
1413
1414 void wxDCImpl::Rotate( wxPointList* points, double angle, wxPoint center )
1415 {
1416 if( angle != 0.0 )
1417 {
1418 double pi(M_PI);
1419 double dSinA = -sin(angle*2.0*pi/360.0);
1420 double dCosA = cos(angle*2.0*pi/360.0);
1421 wxPointList::compatibility_iterator node;
1422 for ( node = points->GetFirst(); node; node = node->GetNext() )
1423 {
1424 wxPoint* point = node->GetData();
1425
1426 // transform coordinates, if necessary
1427 if( center.x ) point->x -= center.x;
1428 if( center.y ) point->y -= center.y;
1429
1430 // calculate rotation, rounding simply by implicit cast to integer
1431 int xTemp = point->x * dCosA - point->y * dSinA;
1432 point->y = point->x * dSinA + point->y * dCosA;
1433 point->x = xTemp;
1434
1435 // back transform coordinates, if necessary
1436 if( center.x ) point->x += center.x;
1437 if( center.y ) point->y += center.y;
1438 }
1439 }
1440 }
1441
1442 void wxDCImpl::CalculateEllipticPoints( wxPointList* points,
1443 wxCoord xStart, wxCoord yStart,
1444 wxCoord w, wxCoord h,
1445 double sa, double ea )
1446 {
1447 double pi = M_PI;
1448 double sar = 0;
1449 double ear = 0;
1450 int xsa = 0;
1451 int ysa = 0;
1452 int xea = 0;
1453 int yea = 0;
1454 int sq = 0;
1455 int eq = 0;
1456 bool bUseAngles = false;
1457 if( w<0 ) w = -w;
1458 if( h<0 ) h = -h;
1459 // half-axes
1460 wxCoord a = w/2;
1461 wxCoord b = h/2;
1462 // decrement 1 pixel if ellipse is smaller than 2*a, 2*b
1463 int decrX = 0;
1464 if( 2*a == w ) decrX = 1;
1465 int decrY = 0;
1466 if( 2*b == h ) decrY = 1;
1467 // center
1468 wxCoord xCenter = xStart + a;
1469 wxCoord yCenter = yStart + b;
1470 // calculate data for start and end, if necessary
1471 if( sa != ea )
1472 {
1473 bUseAngles = true;
1474 // normalisation of angles
1475 while( sa<0 ) sa += 360;
1476 while( ea<0 ) ea += 360;
1477 while( sa>=360 ) sa -= 360;
1478 while( ea>=360 ) ea -= 360;
1479 // calculate quadrant numbers
1480 if( sa > 270 ) sq = 3;
1481 else if( sa > 180 ) sq = 2;
1482 else if( sa > 90 ) sq = 1;
1483 if( ea > 270 ) eq = 3;
1484 else if( ea > 180 ) eq = 2;
1485 else if( ea > 90 ) eq = 1;
1486 sar = sa * pi / 180.0;
1487 ear = ea * pi / 180.0;
1488 // correct angle circle -> ellipse
1489 sar = atan( -a/(double)b * tan( sar ) );
1490 if ( sq == 1 || sq == 2 ) sar += pi;
1491 ear = atan( -a/(double)b * tan( ear ) );
1492 if ( eq == 1 || eq == 2 ) ear += pi;
1493 // coordinates of points
1494 xsa = xCenter + a * cos( sar );
1495 if( sq == 0 || sq == 3 ) xsa -= decrX;
1496 ysa = yCenter + b * sin( sar );
1497 if( sq == 2 || sq == 3 ) ysa -= decrY;
1498 xea = xCenter + a * cos( ear );
1499 if( eq == 0 || eq == 3 ) xea -= decrX;
1500 yea = yCenter + b * sin( ear );
1501 if( eq == 2 || eq == 3 ) yea -= decrY;
1502 } // if iUseAngles
1503 // calculate c1 = b^2, c2 = b^2/a^2 with a = w/2, b = h/2
1504 double c1 = b * b;
1505 double c2 = 2.0 / w;
1506 c2 *= c2;
1507 c2 *= c1;
1508 wxCoord x = 0;
1509 wxCoord y = b;
1510 long x2 = 1;
1511 long y2 = y*y;
1512 long y2_old = 0;
1513 long y_old = 0;
1514 // Lists for quadrant 1 to 4
1515 wxPointList pointsarray[4];
1516 // Calculate points for first quadrant and set in all quadrants
1517 for( x = 0; x <= a; ++x )
1518 {
1519 x2 = x2+x+x-1;
1520 y2_old = y2;
1521 y_old = y;
1522 bool bNewPoint = false;
1523 while( y2 > c1 - c2 * x2 && y > 0 )
1524 {
1525 bNewPoint = true;
1526 y2 = y2-y-y+1;
1527 --y;
1528 }
1529 // old y now to big: set point with old y, old x
1530 if( bNewPoint && x>1)
1531 {
1532 int x1 = x - 1;
1533 // remove points on the same line
1534 pointsarray[0].Insert( new wxPoint( xCenter + x1 - decrX, yCenter - y_old ) );
1535 pointsarray[1].Append( new wxPoint( xCenter - x1, yCenter - y_old ) );
1536 pointsarray[2].Insert( new wxPoint( xCenter - x1, yCenter + y_old - decrY ) );
1537 pointsarray[3].Append( new wxPoint( xCenter + x1 - decrX, yCenter + y_old - decrY ) );
1538 } // set point
1539 } // calculate point
1540
1541 // Starting and/or ending points for the quadrants, first quadrant gets both.
1542 pointsarray[0].Insert( new wxPoint( xCenter + a - decrX, yCenter ) );
1543 pointsarray[0].Append( new wxPoint( xCenter, yCenter - b ) );
1544 pointsarray[1].Append( new wxPoint( xCenter - a, yCenter ) );
1545 pointsarray[2].Append( new wxPoint( xCenter, yCenter + b - decrY ) );
1546 pointsarray[3].Append( new wxPoint( xCenter + a - decrX, yCenter ) );
1547
1548 // copy quadrants in original list
1549 if( bUseAngles )
1550 {
1551 // Copy the right part of the points in the lists
1552 // and delete the wxPoints, because they do not leave this method.
1553 points->Append( new wxPoint( xsa, ysa ) );
1554 int q = sq;
1555 bool bStarted = false;
1556 bool bReady = false;
1557 bool bForceTurn = ( sq == eq && sa > ea );
1558 while( !bReady )
1559 {
1560 wxPointList::compatibility_iterator node;
1561 for( node = pointsarray[q].GetFirst(); node; node = node->GetNext() )
1562 {
1563 // once: go to starting point in start quadrant
1564 if( !bStarted &&
1565 (
1566 node->GetData()->x < xsa+1 && q <= 1
1567 ||
1568 node->GetData()->x > xsa-1 && q >= 2
1569 )
1570 )
1571 {
1572 bStarted = true;
1573 }
1574
1575 // copy point, if not at ending point
1576 if( bStarted )
1577 {
1578 if( q != eq || bForceTurn
1579 ||
1580 ( (wxPoint*) node->GetData() )->x > xea+1 && q <= 1
1581 ||
1582 ( (wxPoint*) node->GetData() )->x < xea-1 && q >= 2
1583 )
1584 {
1585 // copy point
1586 wxPoint* pPoint = new wxPoint( *(node->GetData()) );
1587 points->Append( pPoint );
1588 }
1589 else if( q == eq && !bForceTurn || node->GetData()->x == xea)
1590 {
1591 bReady = true;
1592 }
1593 }
1594 } // for node
1595 ++q;
1596 if( q > 3 ) q = 0;
1597 bForceTurn = false;
1598 bStarted = true;
1599 } // while not bReady
1600 points->Append( new wxPoint( xea, yea ) );
1601
1602 // delete points
1603 for( q = 0; q < 4; ++q )
1604 {
1605 wxPointList::compatibility_iterator node;
1606 for( node = pointsarray[q].GetFirst(); node; node = node->GetNext() )
1607 {
1608 wxPoint *p = node->GetData();
1609 delete p;
1610 }
1611 }
1612 }
1613 else
1614 {
1615 wxPointList::compatibility_iterator node;
1616 // copy whole ellipse, wxPoints will be deleted outside
1617 for( node = pointsarray[0].GetFirst(); node; node = node->GetNext() )
1618 {
1619 wxPoint *p = node->GetData();
1620 points->Append( p );
1621 }
1622 for( node = pointsarray[1].GetFirst(); node; node = node->GetNext() )
1623 {
1624 wxPoint *p = node->GetData();
1625 points->Append( p );
1626 }
1627 for( node = pointsarray[2].GetFirst(); node; node = node->GetNext() )
1628 {
1629 wxPoint *p = node->GetData();
1630 points->Append( p );
1631 }
1632 for( node = pointsarray[3].GetFirst(); node; node = node->GetNext() )
1633 {
1634 wxPoint *p = node->GetData();
1635 points->Append( p );
1636 }
1637 } // not iUseAngles
1638 } // CalculateEllipticPoints
1639
1640 #endif // __WXWINCE__
wxWidgets (Impactor)