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