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