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