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