]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/common/dcgraph.cpp
abandon attempts to make wxAnyStrPtr behave as bool: user-defined logical operators...
[wxWidgets.git] / src / common / dcgraph.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/common/graphcmn.cpp
3// Purpose: graphics context methods common to all platforms
4// Author: Stefan Csomor
5// Modified by:
6// Created:
7// RCS-ID: $Id$
8// Copyright: (c) Stefan Csomor
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12// For compilers that support precompilation, includes "wx.h".
13#include "wx/wxprec.h"
14
15#if defined(__BORLANDC__)
16 #pragma hdrstop
17#endif
18
19#if wxUSE_GRAPHICS_CONTEXT
20
21#include "wx/graphics.h"
22#include "wx/dcgraph.h"
23
24#ifndef WX_PRECOMP
25 #include "wx/icon.h"
26 #include "wx/bitmap.h"
27 #include "wx/dcmemory.h"
28 #include "wx/region.h"
29#endif
30
31#include "wx/dcclient.h"
32
33#ifdef __WXOSX_OR_COCOA__
34#ifdef __WXOSX_IPHONE__
35 #include <CoreGraphics/CoreGraphics.h>
36#else
37 #include <ApplicationServices/ApplicationServices.h>
38#endif
39#endif
40
41//-----------------------------------------------------------------------------
42// constants
43//-----------------------------------------------------------------------------
44
45static const double RAD2DEG = 180.0 / M_PI;
46
47//-----------------------------------------------------------------------------
48// Local functions
49//-----------------------------------------------------------------------------
50
51static inline double DegToRad(double deg)
52{
53 return (deg * M_PI) / 180.0;
54}
55
56static bool TranslateRasterOp(wxRasterOperationMode function, wxCompositionMode *op)
57{
58 switch ( function )
59 {
60 case wxCOPY: // (default) src
61 *op = wxCOMPOSITION_SOURCE; //
62 break;
63 case wxOR: // src OR dst
64 *op = wxCOMPOSITION_ADD;
65 break;
66 case wxNO_OP: // dst
67 *op = wxCOMPOSITION_DEST; // ignore the source
68 break;
69 case wxCLEAR: // 0
70 *op = wxCOMPOSITION_CLEAR;// clear dst
71 break;
72 case wxXOR: // src XOR dst
73 *op = wxCOMPOSITION_XOR;
74 break;
75
76 case wxAND: // src AND dst
77 case wxAND_INVERT: // (NOT src) AND dst
78 case wxAND_REVERSE:// src AND (NOT dst)
79 case wxEQUIV: // (NOT src) XOR dst
80 case wxINVERT: // NOT dst
81 case wxNAND: // (NOT src) OR (NOT dst)
82 case wxNOR: // (NOT src) AND (NOT dst)
83 case wxOR_INVERT: // (NOT src) OR dst
84 case wxOR_REVERSE: // src OR (NOT dst)
85 case wxSET: // 1
86 case wxSRC_INVERT: // NOT src
87 default:
88 return false;
89 }
90 return true;
91}
92
93//-----------------------------------------------------------------------------
94// wxDC bridge class
95//-----------------------------------------------------------------------------
96
97IMPLEMENT_DYNAMIC_CLASS(wxGCDC, wxDC)
98
99wxGCDC::wxGCDC(const wxWindowDC& dc) :
100 wxDC( new wxGCDCImpl( this, dc ) )
101{
102}
103
104wxGCDC::wxGCDC( const wxMemoryDC& dc) :
105 wxDC( new wxGCDCImpl( this, dc ) )
106{
107}
108
109#if wxUSE_PRINTING_ARCHITECTURE
110wxGCDC::wxGCDC( const wxPrinterDC& dc) :
111 wxDC( new wxGCDCImpl( this, dc ) )
112{
113}
114#endif
115
116wxGCDC::wxGCDC() :
117 wxDC( new wxGCDCImpl( this ) )
118{
119}
120
121wxGCDC::~wxGCDC()
122{
123}
124
125wxGraphicsContext* wxGCDC::GetGraphicsContext()
126{
127 if (!m_pimpl) return NULL;
128 wxGCDCImpl *gc_impl = (wxGCDCImpl*) m_pimpl;
129 return gc_impl->GetGraphicsContext();
130}
131
132void wxGCDC::SetGraphicsContext( wxGraphicsContext* ctx )
133{
134 if (!m_pimpl) return;
135 wxGCDCImpl *gc_impl = (wxGCDCImpl*) m_pimpl;
136 gc_impl->SetGraphicsContext( ctx );
137}
138
139IMPLEMENT_ABSTRACT_CLASS(wxGCDCImpl, wxDCImpl)
140
141wxGCDCImpl::wxGCDCImpl( wxDC *owner ) :
142 wxDCImpl( owner )
143{
144 Init();
145}
146
147void wxGCDCImpl::SetGraphicsContext( wxGraphicsContext* ctx )
148{
149 delete m_graphicContext;
150 m_graphicContext = ctx;
151 if ( m_graphicContext )
152 {
153 m_matrixOriginal = m_graphicContext->GetTransform();
154 m_ok = true;
155 // apply the stored transformations to the passed in context
156 ComputeScaleAndOrigin();
157 m_graphicContext->SetFont( m_font , m_textForegroundColour );
158 m_graphicContext->SetPen( m_pen );
159 m_graphicContext->SetBrush( m_brush);
160 }
161}
162
163wxGCDCImpl::wxGCDCImpl( wxDC *owner, const wxWindowDC& dc ) :
164 wxDCImpl( owner )
165{
166 Init();
167 SetGraphicsContext( wxGraphicsContext::Create(dc) );
168 m_window = dc.GetWindow();
169}
170
171wxGCDCImpl::wxGCDCImpl( wxDC *owner, const wxMemoryDC& dc ) :
172 wxDCImpl( owner )
173{
174 Init();
175 SetGraphicsContext( wxGraphicsContext::Create(dc) );
176}
177
178#if wxUSE_PRINTING_ARCHITECTURE
179wxGCDCImpl::wxGCDCImpl( wxDC *owner, const wxPrinterDC& dc ) :
180 wxDCImpl( owner )
181{
182 Init();
183 SetGraphicsContext( wxGraphicsContext::Create(dc) );
184}
185#endif
186
187void wxGCDCImpl::Init()
188{
189 m_ok = false;
190 m_colour = true;
191 m_mm_to_pix_x = mm2pt;
192 m_mm_to_pix_y = mm2pt;
193
194 m_pen = *wxBLACK_PEN;
195 m_font = *wxNORMAL_FONT;
196 m_brush = *wxWHITE_BRUSH;
197
198 m_graphicContext = NULL;
199 m_logicalFunctionSupported = true;
200}
201
202
203wxGCDCImpl::~wxGCDCImpl()
204{
205 delete m_graphicContext;
206}
207
208void wxGCDCImpl::DoDrawBitmap( const wxBitmap &bmp, wxCoord x, wxCoord y,
209 bool useMask )
210{
211 wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawBitmap - invalid DC") );
212 wxCHECK_RET( bmp.IsOk(), wxT("wxGCDC(cg)::DoDrawBitmap - invalid bitmap") );
213
214 int w = bmp.GetWidth();
215 int h = bmp.GetHeight();
216 if ( bmp.GetDepth() == 1 )
217 {
218 m_graphicContext->SetPen(*wxTRANSPARENT_PEN);
219 m_graphicContext->SetBrush( wxBrush( m_textBackgroundColour , wxSOLID ) );
220 m_graphicContext->DrawRectangle( x, y, w, h );
221 m_graphicContext->SetBrush( wxBrush( m_textForegroundColour , wxSOLID ) );
222 m_graphicContext->DrawBitmap( bmp, x, y, w, h );
223 m_graphicContext->SetBrush( m_graphicContext->CreateBrush(m_brush));
224 m_graphicContext->SetPen( m_graphicContext->CreatePen(m_pen));
225 }
226 else // not a monochrome bitmap, handle it normally
227 {
228 // make a copy in case we need to remove its mask, if we don't modify
229 // it the copy is cheap as bitmaps are reference-counted
230 wxBitmap bmpCopy(bmp);
231 if ( !useMask && bmp.GetMask() )
232 bmpCopy.SetMask(NULL);
233
234 m_graphicContext->DrawBitmap( bmpCopy, x, y, w, h );
235 }
236}
237
238void wxGCDCImpl::DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y )
239{
240 wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawIcon - invalid DC") );
241 wxCHECK_RET( icon.IsOk(), wxT("wxGCDC(cg)::DoDrawIcon - invalid icon") );
242
243 wxCoord w = icon.GetWidth();
244 wxCoord h = icon.GetHeight();
245
246 m_graphicContext->DrawIcon( icon , x, y, w, h );
247}
248
249bool wxGCDCImpl::StartDoc( const wxString& WXUNUSED(message) )
250{
251 return true;
252}
253
254void wxGCDCImpl::EndDoc()
255{
256}
257
258void wxGCDCImpl::StartPage()
259{
260}
261
262void wxGCDCImpl::EndPage()
263{
264}
265
266void wxGCDCImpl::Flush()
267{
268#ifdef __WXOSX_OR_COCOA__
269 CGContextFlush( (CGContextRef) m_graphicContext->GetNativeContext() );
270#endif
271}
272
273void wxGCDCImpl::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord w, wxCoord h )
274{
275 wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoSetClippingRegion - invalid DC") );
276
277 m_graphicContext->Clip( x, y, w, h );
278 if ( m_clipping )
279 {
280 m_clipX1 = wxMax( m_clipX1, x );
281 m_clipY1 = wxMax( m_clipY1, y );
282 m_clipX2 = wxMin( m_clipX2, (x + w) );
283 m_clipY2 = wxMin( m_clipY2, (y + h) );
284 }
285 else
286 {
287 m_clipping = true;
288
289 m_clipX1 = x;
290 m_clipY1 = y;
291 m_clipX2 = x + w;
292 m_clipY2 = y + h;
293 }
294}
295
296void wxGCDCImpl::DoSetDeviceClippingRegion( const wxRegion &region )
297{
298 // region is in device coordinates
299 wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoSetDeviceClippingRegion - invalid DC") );
300
301 if (region.Empty())
302 {
303 //DestroyClippingRegion();
304 return;
305 }
306
307 wxRegion logRegion( region );
308 wxCoord x, y, w, h;
309
310 logRegion.Offset( DeviceToLogicalX(0), DeviceToLogicalY(0) );
311 logRegion.GetBox( x, y, w, h );
312
313 m_graphicContext->Clip( logRegion );
314 if ( m_clipping )
315 {
316 m_clipX1 = wxMax( m_clipX1, x );
317 m_clipY1 = wxMax( m_clipY1, y );
318 m_clipX2 = wxMin( m_clipX2, (x + w) );
319 m_clipY2 = wxMin( m_clipY2, (y + h) );
320 }
321 else
322 {
323 m_clipping = true;
324
325 m_clipX1 = x;
326 m_clipY1 = y;
327 m_clipX2 = x + w;
328 m_clipY2 = y + h;
329 }
330}
331
332void wxGCDCImpl::DestroyClippingRegion()
333{
334 m_graphicContext->ResetClip();
335 // currently the clip eg of a window extends to the area between the scrollbars
336 // so we must explicitely make sure it only covers the area we want it to draw
337 int width, height ;
338 GetOwner()->GetSize( &width , &height ) ;
339 m_graphicContext->Clip( DeviceToLogicalX(0) , DeviceToLogicalY(0) , DeviceToLogicalXRel(width), DeviceToLogicalYRel(height) );
340
341 m_graphicContext->SetPen( m_pen );
342 m_graphicContext->SetBrush( m_brush );
343
344 m_clipping = false;
345}
346
347void wxGCDCImpl::DoGetSizeMM( int* width, int* height ) const
348{
349 int w = 0, h = 0;
350
351 GetOwner()->GetSize( &w, &h );
352 if (width)
353 *width = long( double(w) / (m_scaleX * m_mm_to_pix_x) );
354 if (height)
355 *height = long( double(h) / (m_scaleY * m_mm_to_pix_y) );
356}
357
358void wxGCDCImpl::SetTextForeground( const wxColour &col )
359{
360 wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::SetTextForeground - invalid DC") );
361
362 if ( col != m_textForegroundColour )
363 {
364 m_textForegroundColour = col;
365 m_graphicContext->SetFont( m_font, m_textForegroundColour );
366 }
367}
368
369void wxGCDCImpl::SetTextBackground( const wxColour &col )
370{
371 wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::SetTextBackground - invalid DC") );
372
373 m_textBackgroundColour = col;
374}
375
376void wxGCDCImpl::SetMapMode( wxMappingMode mode )
377{
378 switch (mode)
379 {
380 case wxMM_TWIPS:
381 SetLogicalScale( twips2mm * m_mm_to_pix_x, twips2mm * m_mm_to_pix_y );
382 break;
383
384 case wxMM_POINTS:
385 SetLogicalScale( pt2mm * m_mm_to_pix_x, pt2mm * m_mm_to_pix_y );
386 break;
387
388 case wxMM_METRIC:
389 SetLogicalScale( m_mm_to_pix_x, m_mm_to_pix_y );
390 break;
391
392 case wxMM_LOMETRIC:
393 SetLogicalScale( m_mm_to_pix_x / 10.0, m_mm_to_pix_y / 10.0 );
394 break;
395
396 case wxMM_TEXT:
397 default:
398 SetLogicalScale( 1.0, 1.0 );
399 break;
400 }
401
402 ComputeScaleAndOrigin();
403}
404
405wxSize wxGCDCImpl::GetPPI() const
406{
407 return wxSize(72, 72);
408}
409
410int wxGCDCImpl::GetDepth() const
411{
412 return 32;
413}
414
415void wxGCDCImpl::ComputeScaleAndOrigin()
416{
417 wxDCImpl::ComputeScaleAndOrigin();
418
419 if ( m_graphicContext )
420 {
421 m_matrixCurrent = m_graphicContext->CreateMatrix();
422
423 // the logical origin sets the origin to have new coordinates
424 m_matrixCurrent.Translate( m_deviceOriginX - m_logicalOriginX * m_signX * m_scaleX,
425 m_deviceOriginY-m_logicalOriginY * m_signY * m_scaleY);
426
427 m_matrixCurrent.Scale( m_scaleX * m_signX, m_scaleY * m_signY );
428
429 m_graphicContext->SetTransform( m_matrixOriginal );
430 m_graphicContext->ConcatTransform( m_matrixCurrent );
431 }
432}
433
434void wxGCDCImpl::SetPalette( const wxPalette& WXUNUSED(palette) )
435{
436
437}
438
439void wxGCDCImpl::SetBackgroundMode( int mode )
440{
441 m_backgroundMode = mode;
442}
443
444void wxGCDCImpl::SetFont( const wxFont &font )
445{
446 m_font = font;
447 if ( m_graphicContext )
448 {
449 wxFont f = font;
450 if ( f.IsOk() )
451 f.SetPointSize( /*LogicalToDeviceYRel*/(font.GetPointSize()));
452 m_graphicContext->SetFont( f, m_textForegroundColour );
453#if defined(__WXGTK__) || defined(__WXOSX__)
454 if ( m_font.GetNoAntiAliasing() )
455 {
456 m_graphicContext->SetAntialiasMode(wxANTIALIAS_NONE);
457 }
458#endif
459 }
460}
461
462void wxGCDCImpl::SetPen( const wxPen &pen )
463{
464 if ( m_pen == pen )
465 return;
466
467 m_pen = pen;
468 if ( m_graphicContext )
469 {
470 m_graphicContext->SetPen( m_pen );
471 }
472}
473
474void wxGCDCImpl::SetBrush( const wxBrush &brush )
475{
476 if (m_brush == brush)
477 return;
478
479 m_brush = brush;
480 if ( m_graphicContext )
481 {
482 m_graphicContext->SetBrush( m_brush );
483 }
484}
485
486void wxGCDCImpl::SetBackground( const wxBrush &brush )
487{
488 if (m_backgroundBrush == brush)
489 return;
490
491 m_backgroundBrush = brush;
492 if (!m_backgroundBrush.IsOk())
493 return;
494}
495
496void wxGCDCImpl::SetLogicalFunction( wxRasterOperationMode function )
497{
498 if (m_logicalFunction == function)
499 return;
500
501 m_logicalFunction = function;
502
503 wxCompositionMode mode;
504 m_logicalFunctionSupported = TranslateRasterOp( function, &mode);
505 if (m_logicalFunctionSupported)
506 m_logicalFunctionSupported = m_graphicContext->SetCompositionMode(mode);
507
508 if (mode == wxCOMPOSITION_XOR)
509 m_graphicContext->SetAntialiasMode(wxANTIALIAS_NONE);
510 else
511 m_graphicContext->SetAntialiasMode(wxANTIALIAS_DEFAULT);
512}
513
514bool wxGCDCImpl::DoFloodFill(wxCoord WXUNUSED(x), wxCoord WXUNUSED(y),
515 const wxColour& WXUNUSED(col),
516 wxFloodFillStyle WXUNUSED(style))
517{
518 return false;
519}
520
521bool wxGCDCImpl::DoGetPixel( wxCoord WXUNUSED(x), wxCoord WXUNUSED(y), wxColour *WXUNUSED(col) ) const
522{
523 // wxCHECK_MSG( 0 , false, wxT("wxGCDC(cg)::DoGetPixel - not implemented") );
524 return false;
525}
526
527void wxGCDCImpl::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )
528{
529 wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawLine - invalid DC") );
530
531 if ( !m_logicalFunctionSupported )
532 return;
533
534 m_graphicContext->StrokeLine(x1,y1,x2,y2);
535
536 CalcBoundingBox(x1, y1);
537 CalcBoundingBox(x2, y2);
538}
539
540void wxGCDCImpl::DoCrossHair( wxCoord x, wxCoord y )
541{
542 wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoCrossHair - invalid DC") );
543
544 if ( !m_logicalFunctionSupported )
545 return;
546
547 int w = 0, h = 0;
548
549 GetOwner()->GetSize( &w, &h );
550
551 m_graphicContext->StrokeLine(0,y,w,y);
552 m_graphicContext->StrokeLine(x,0,x,h);
553
554 CalcBoundingBox(0, 0);
555 CalcBoundingBox(0+w, 0+h);
556}
557
558void wxGCDCImpl::DoDrawArc( wxCoord x1, wxCoord y1,
559 wxCoord x2, wxCoord y2,
560 wxCoord xc, wxCoord yc )
561{
562 wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawArc - invalid DC") );
563
564 if ( !m_logicalFunctionSupported )
565 return;
566
567 double dx = x1 - xc;
568 double dy = y1 - yc;
569 double radius = sqrt((double)(dx * dx + dy * dy));
570 wxCoord rad = (wxCoord)radius;
571 double sa, ea;
572 if (x1 == x2 && y1 == y2)
573 {
574 sa = 0.0;
575 ea = 360.0;
576 }
577 else if (radius == 0.0)
578 {
579 sa = ea = 0.0;
580 }
581 else
582 {
583 sa = (x1 - xc == 0) ?
584 (y1 - yc < 0) ? 90.0 : -90.0 :
585 -atan2(double(y1 - yc), double(x1 - xc)) * RAD2DEG;
586 ea = (x2 - xc == 0) ?
587 (y2 - yc < 0) ? 90.0 : -90.0 :
588 -atan2(double(y2 - yc), double(x2 - xc)) * RAD2DEG;
589 }
590
591 bool fill = m_brush.GetStyle() != wxTRANSPARENT;
592
593 wxGraphicsPath path = m_graphicContext->CreatePath();
594 if ( fill && ((x1!=x2)||(y1!=y2)) )
595 path.MoveToPoint( xc, yc );
596 // since these angles (ea,sa) are measured counter-clockwise, we invert them to
597 // get clockwise angles
598 path.AddArc( xc, yc , rad , DegToRad(-sa) , DegToRad(-ea), false );
599 if ( fill && ((x1!=x2)||(y1!=y2)) )
600 path.AddLineToPoint( xc, yc );
601 m_graphicContext->DrawPath(path);
602}
603
604void wxGCDCImpl::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord w, wxCoord h,
605 double sa, double ea )
606{
607 wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawEllipticArc - invalid DC") );
608
609 if ( !m_logicalFunctionSupported )
610 return;
611
612 m_graphicContext->PushState();
613 m_graphicContext->Translate(x+w/2.0,y+h/2.0);
614 wxDouble factor = ((wxDouble) w) / h;
615 m_graphicContext->Scale( factor , 1.0);
616
617 // since these angles (ea,sa) are measured counter-clockwise, we invert them to
618 // get clockwise angles
619 if ( m_brush.GetStyle() != wxTRANSPARENT )
620 {
621 wxGraphicsPath path = m_graphicContext->CreatePath();
622 path.MoveToPoint( 0, 0 );
623 path.AddArc( 0, 0, h/2.0 , DegToRad(-sa) , DegToRad(-ea), sa > ea );
624 path.AddLineToPoint( 0, 0 );
625 m_graphicContext->FillPath( path );
626
627 path = m_graphicContext->CreatePath();
628 path.AddArc( 0, 0, h/2.0 , DegToRad(-sa) , DegToRad(-ea), sa > ea );
629 m_graphicContext->StrokePath( path );
630 }
631 else
632 {
633 wxGraphicsPath path = m_graphicContext->CreatePath();
634 path.AddArc( 0, 0, h/2.0 , DegToRad(-sa) , DegToRad(-ea), sa > ea );
635 m_graphicContext->DrawPath( path );
636 }
637
638 m_graphicContext->PopState();
639}
640
641void wxGCDCImpl::DoDrawPoint( wxCoord x, wxCoord y )
642{
643 wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawPoint - invalid DC") );
644
645 DoDrawLine( x , y , x + 1 , y + 1 );
646}
647
648void wxGCDCImpl::DoDrawLines(int n, wxPoint points[],
649 wxCoord xoffset, wxCoord yoffset)
650{
651 wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawLines - invalid DC") );
652
653 if ( !m_logicalFunctionSupported )
654 return;
655
656 wxPoint2DDouble* pointsD = new wxPoint2DDouble[n];
657 for( int i = 0; i < n; ++i)
658 {
659 pointsD[i].m_x = points[i].x + xoffset;
660 pointsD[i].m_y = points[i].y + yoffset;
661 }
662
663 m_graphicContext->StrokeLines( n , pointsD);
664 delete[] pointsD;
665}
666
667#if wxUSE_SPLINES
668void wxGCDCImpl::DoDrawSpline(const wxPointList *points)
669{
670 wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawSpline - invalid DC") );
671
672 if ( !m_logicalFunctionSupported )
673 return;
674
675 wxGraphicsPath path = m_graphicContext->CreatePath();
676
677 wxPointList::compatibility_iterator node = points->GetFirst();
678 if (node == wxPointList::compatibility_iterator())
679 // empty list
680 return;
681
682 wxPoint *p = node->GetData();
683
684 wxCoord x1 = p->x;
685 wxCoord y1 = p->y;
686
687 node = node->GetNext();
688 p = node->GetData();
689
690 wxCoord x2 = p->x;
691 wxCoord y2 = p->y;
692 wxCoord cx1 = ( x1 + x2 ) / 2;
693 wxCoord cy1 = ( y1 + y2 ) / 2;
694
695 path.MoveToPoint( x1 , y1 );
696 path.AddLineToPoint( cx1 , cy1 );
697#if !wxUSE_STL
698
699 while ((node = node->GetNext()) != NULL)
700#else
701
702 while ((node = node->GetNext()))
703#endif // !wxUSE_STL
704
705 {
706 p = node->GetData();
707 x1 = x2;
708 y1 = y2;
709 x2 = p->x;
710 y2 = p->y;
711 wxCoord cx4 = (x1 + x2) / 2;
712 wxCoord cy4 = (y1 + y2) / 2;
713
714 path.AddQuadCurveToPoint(x1 , y1 ,cx4 , cy4 );
715
716 cx1 = cx4;
717 cy1 = cy4;
718 }
719
720 path.AddLineToPoint( x2 , y2 );
721
722 m_graphicContext->StrokePath( path );
723}
724#endif // wxUSE_SPLINES
725
726void wxGCDCImpl::DoDrawPolygon( int n, wxPoint points[],
727 wxCoord xoffset, wxCoord yoffset,
728 wxPolygonFillMode fillStyle )
729{
730 wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawPolygon - invalid DC") );
731
732 if ( n <= 0 || (m_brush.GetStyle() == wxTRANSPARENT && m_pen.GetStyle() == wxTRANSPARENT ) )
733 return;
734 if ( !m_logicalFunctionSupported )
735 return;
736
737 bool closeIt = false;
738 if (points[n-1] != points[0])
739 closeIt = true;
740
741 wxPoint2DDouble* pointsD = new wxPoint2DDouble[n+(closeIt?1:0)];
742 for( int i = 0; i < n; ++i)
743 {
744 pointsD[i].m_x = points[i].x + xoffset;
745 pointsD[i].m_y = points[i].y + yoffset;
746 }
747 if ( closeIt )
748 pointsD[n] = pointsD[0];
749
750 m_graphicContext->DrawLines( n+(closeIt?1:0) , pointsD, fillStyle);
751 delete[] pointsD;
752}
753
754void wxGCDCImpl::DoDrawPolyPolygon(int n,
755 int count[],
756 wxPoint points[],
757 wxCoord xoffset,
758 wxCoord yoffset,
759 wxPolygonFillMode fillStyle)
760{
761 wxASSERT(n > 1);
762 wxGraphicsPath path = m_graphicContext->CreatePath();
763
764 int i = 0;
765 for ( int j = 0; j < n; ++j)
766 {
767 wxPoint start = points[i];
768 path.MoveToPoint( start.x+ xoffset, start.y+ yoffset);
769 ++i;
770 int l = count[j];
771 for ( int k = 1; k < l; ++k)
772 {
773 path.AddLineToPoint( points[i].x+ xoffset, points[i].y+ yoffset);
774 ++i;
775 }
776 // close the polygon
777 if ( start != points[i-1])
778 path.AddLineToPoint( start.x+ xoffset, start.y+ yoffset);
779 }
780 m_graphicContext->DrawPath( path , fillStyle);
781}
782
783void wxGCDCImpl::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
784{
785 wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawRectangle - invalid DC") );
786
787 if ( !m_logicalFunctionSupported )
788 return;
789
790 // CMB: draw nothing if transformed w or h is 0
791 if (w == 0 || h == 0)
792 return;
793
794 if ( m_graphicContext->ShouldOffset() )
795 {
796 // if we are offsetting the entire rectangle is moved 0.5, so the
797 // border line gets off by 1
798 w -= 1;
799 h -= 1;
800 }
801 m_graphicContext->DrawRectangle(x,y,w,h);
802}
803
804void wxGCDCImpl::DoDrawRoundedRectangle(wxCoord x, wxCoord y,
805 wxCoord w, wxCoord h,
806 double radius)
807{
808 wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawRoundedRectangle - invalid DC") );
809
810 if ( !m_logicalFunctionSupported )
811 return;
812
813 if (radius < 0.0)
814 radius = - radius * ((w < h) ? w : h);
815
816 // CMB: draw nothing if transformed w or h is 0
817 if (w == 0 || h == 0)
818 return;
819
820 if ( m_graphicContext->ShouldOffset() )
821 {
822 // if we are offsetting the entire rectangle is moved 0.5, so the
823 // border line gets off by 1
824 w -= 1;
825 h -= 1;
826 }
827 m_graphicContext->DrawRoundedRectangle( x,y,w,h,radius);
828}
829
830void wxGCDCImpl::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
831{
832 wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawEllipse - invalid DC") );
833
834 if ( !m_logicalFunctionSupported )
835 return;
836
837 if ( m_graphicContext->ShouldOffset() )
838 {
839 // if we are offsetting the entire rectangle is moved 0.5, so the
840 // border line gets off by 1
841 w -= 1;
842 h -= 1;
843 }
844 m_graphicContext->DrawEllipse(x,y,w,h);
845}
846
847bool wxGCDCImpl::CanDrawBitmap() const
848{
849 return true;
850}
851
852bool wxGCDCImpl::DoBlit(
853 wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
854 wxDC *source, wxCoord xsrc, wxCoord ysrc,
855 wxRasterOperationMode logical_func , bool useMask,
856 wxCoord xsrcMask, wxCoord ysrcMask )
857{
858 return DoStretchBlit( xdest, ydest, width, height,
859 source, xsrc, ysrc, width, height, logical_func, useMask,
860 xsrcMask,ysrcMask );
861}
862
863bool wxGCDCImpl::DoStretchBlit(
864 wxCoord xdest, wxCoord ydest, wxCoord dstWidth, wxCoord dstHeight,
865 wxDC *source, wxCoord xsrc, wxCoord ysrc, wxCoord srcWidth, wxCoord srcHeight,
866 wxRasterOperationMode logical_func , bool useMask,
867 wxCoord xsrcMask, wxCoord ysrcMask )
868{
869 wxCHECK_MSG( IsOk(), false, wxT("wxGCDC(cg)::DoStretchBlit - invalid DC") );
870 wxCHECK_MSG( source->IsOk(), false, wxT("wxGCDC(cg)::DoStretchBlit - invalid source DC") );
871
872 if ( logical_func == wxNO_OP )
873 return true;
874
875 wxCompositionMode mode;
876 if ( !TranslateRasterOp(logical_func, &mode) )
877 {
878 wxFAIL_MSG( wxT("Blitting is not supported with this logical operation.") );
879 return false;
880 }
881
882 bool retval = true;
883
884 wxCompositionMode formerMode = m_graphicContext->GetCompositionMode();
885 if (m_graphicContext->SetCompositionMode(mode))
886 {
887 wxAntialiasMode formerAa = m_graphicContext->GetAntialiasMode();
888 if (mode == wxCOMPOSITION_XOR)
889 {
890 m_graphicContext->SetAntialiasMode(wxANTIALIAS_NONE);
891 }
892
893 if (xsrcMask == -1 && ysrcMask == -1)
894 {
895 xsrcMask = xsrc;
896 ysrcMask = ysrc;
897 }
898
899 wxRect subrect(source->LogicalToDeviceX(xsrc),
900 source->LogicalToDeviceY(ysrc),
901 source->LogicalToDeviceXRel(srcWidth),
902 source->LogicalToDeviceYRel(srcHeight));
903
904 // if needed clip the subrect down to the size of the source DC
905 wxCoord sw, sh;
906 source->GetSize(&sw, &sh);
907 sw = source->LogicalToDeviceXRel(sw);
908 sh = source->LogicalToDeviceYRel(sh);
909 if (subrect.x + subrect.width > sw)
910 subrect.width = sw - subrect.x;
911 if (subrect.y + subrect.height > sh)
912 subrect.height = sh - subrect.y;
913
914 wxBitmap blit = source->GetAsBitmap( &subrect );
915
916 if ( blit.IsOk() )
917 {
918 if ( !useMask && blit.GetMask() )
919 blit.SetMask(NULL);
920
921 m_graphicContext->DrawBitmap( blit, xdest, ydest,
922 dstWidth, dstHeight);
923 }
924 else
925 {
926 wxFAIL_MSG( wxT("Cannot Blit. Unable to get contents of DC as bitmap.") );
927 retval = false;
928 }
929
930 if (mode == wxCOMPOSITION_XOR)
931 {
932 m_graphicContext->SetAntialiasMode(formerAa);
933 }
934 }
935 // reset composition
936 m_graphicContext->SetCompositionMode(formerMode);
937
938 return retval;
939}
940
941void wxGCDCImpl::DoDrawRotatedText(const wxString& str, wxCoord x, wxCoord y,
942 double angle)
943{
944 wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawRotatedText - invalid DC") );
945
946 if ( str.length() == 0 )
947 return;
948 if ( !m_logicalFunctionSupported )
949 return;
950
951 if ( m_backgroundMode == wxTRANSPARENT )
952 m_graphicContext->DrawText( str, x ,y , DegToRad(angle ));
953 else
954 m_graphicContext->DrawText( str, x ,y , DegToRad(angle ), m_graphicContext->CreateBrush( wxBrush(m_textBackgroundColour,wxSOLID) ) );
955}
956
957void wxGCDCImpl::DoDrawText(const wxString& str, wxCoord x, wxCoord y)
958{
959 wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawText - invalid DC") );
960
961 if ( str.length() == 0 )
962 return;
963
964 if ( !m_logicalFunctionSupported )
965 return;
966
967 if ( m_backgroundMode == wxTRANSPARENT )
968 m_graphicContext->DrawText( str, x ,y);
969 else
970 m_graphicContext->DrawText( str, x ,y , m_graphicContext->CreateBrush( wxBrush(m_textBackgroundColour,wxSOLID) ) );
971}
972
973bool wxGCDCImpl::CanGetTextExtent() const
974{
975 wxCHECK_MSG( IsOk(), false, wxT("wxGCDC(cg)::CanGetTextExtent - invalid DC") );
976
977 return true;
978}
979
980void wxGCDCImpl::DoGetTextExtent( const wxString &str, wxCoord *width, wxCoord *height,
981 wxCoord *descent, wxCoord *externalLeading ,
982 const wxFont *theFont ) const
983{
984 wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoGetTextExtent - invalid DC") );
985
986 if ( theFont )
987 {
988 m_graphicContext->SetFont( *theFont, m_textForegroundColour );
989 }
990
991 wxDouble h , d , e , w;
992
993 m_graphicContext->GetTextExtent( str, &w, &h, &d, &e );
994
995 if ( height )
996 *height = (wxCoord)(h+0.5);
997 if ( descent )
998 *descent = (wxCoord)(d+0.5);
999 if ( externalLeading )
1000 *externalLeading = (wxCoord)(e+0.5);
1001 if ( width )
1002 *width = (wxCoord)(w+0.5);
1003
1004 if ( theFont )
1005 {
1006 m_graphicContext->SetFont( m_font, m_textForegroundColour );
1007 }
1008}
1009
1010bool wxGCDCImpl::DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const
1011{
1012 wxCHECK_MSG( IsOk(), false, wxT("wxGCDC(cg)::DoGetPartialTextExtents - invalid DC") );
1013 widths.Clear();
1014 widths.Add(0,text.Length());
1015 if ( text.IsEmpty() )
1016 return true;
1017
1018 wxArrayDouble widthsD;
1019
1020 m_graphicContext->GetPartialTextExtents( text, widthsD );
1021 for ( size_t i = 0; i < widths.GetCount(); ++i )
1022 widths[i] = (wxCoord)(widthsD[i] + 0.5);
1023
1024 return true;
1025}
1026
1027wxCoord wxGCDCImpl::GetCharWidth(void) const
1028{
1029 wxCoord width;
1030 DoGetTextExtent( wxT("g") , &width , NULL , NULL , NULL , NULL );
1031
1032 return width;
1033}
1034
1035wxCoord wxGCDCImpl::GetCharHeight(void) const
1036{
1037 wxCoord height;
1038 DoGetTextExtent( wxT("g") , NULL , &height , NULL , NULL , NULL );
1039
1040 return height;
1041}
1042
1043void wxGCDCImpl::Clear(void)
1044{
1045 wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::Clear - invalid DC") );
1046 // TODO better implementation / incorporate size info into wxGCDC or context
1047 m_graphicContext->SetBrush( m_backgroundBrush );
1048 wxPen p = *wxTRANSPARENT_PEN;
1049 m_graphicContext->SetPen( p );
1050 DoDrawRectangle( 0, 0, 32000 , 32000 );
1051 m_graphicContext->SetPen( m_pen );
1052 m_graphicContext->SetBrush( m_brush );
1053}
1054
1055void wxGCDCImpl::DoGetSize(int *width, int *height) const
1056{
1057 wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoGetSize - invalid DC") );
1058 wxDouble w,h;
1059 m_graphicContext->GetSize( &w, &h );
1060 if ( height )
1061 *height = (int) (h+0.5);
1062 if ( width )
1063 *width = (int) (w+0.5);
1064}
1065
1066void wxGCDCImpl::DoGradientFillLinear(const wxRect& rect,
1067 const wxColour& initialColour,
1068 const wxColour& destColour,
1069 wxDirection nDirection )
1070{
1071 wxPoint start;
1072 wxPoint end;
1073 switch( nDirection)
1074 {
1075 case wxWEST :
1076 start = rect.GetRightBottom();
1077 start.x++;
1078 end = rect.GetLeftBottom();
1079 break;
1080 case wxEAST :
1081 start = rect.GetLeftBottom();
1082 end = rect.GetRightBottom();
1083 end.x++;
1084 break;
1085 case wxNORTH :
1086 start = rect.GetLeftBottom();
1087 start.y++;
1088 end = rect.GetLeftTop();
1089 break;
1090 case wxSOUTH :
1091 start = rect.GetLeftTop();
1092 end = rect.GetLeftBottom();
1093 end.y++;
1094 break;
1095 default :
1096 break;
1097 }
1098
1099 if (rect.width == 0 || rect.height == 0)
1100 return;
1101
1102 m_graphicContext->SetBrush( m_graphicContext->CreateLinearGradientBrush(
1103 start.x,start.y,end.x,end.y, initialColour, destColour));
1104 m_graphicContext->SetPen(*wxTRANSPARENT_PEN);
1105 m_graphicContext->DrawRectangle(rect.x,rect.y,rect.width,rect.height);
1106 m_graphicContext->SetPen(m_pen);
1107}
1108
1109void wxGCDCImpl::DoGradientFillConcentric(const wxRect& rect,
1110 const wxColour& initialColour,
1111 const wxColour& destColour,
1112 const wxPoint& circleCenter)
1113{
1114 //Radius
1115 wxInt32 cx = rect.GetWidth() / 2;
1116 wxInt32 cy = rect.GetHeight() / 2;
1117 wxInt32 nRadius;
1118 if (cx < cy)
1119 nRadius = cx;
1120 else
1121 nRadius = cy;
1122
1123 // make sure the background is filled (todo move into specific platform implementation ?)
1124 m_graphicContext->SetPen(*wxTRANSPARENT_PEN);
1125 m_graphicContext->SetBrush( wxBrush( destColour) );
1126 m_graphicContext->DrawRectangle(rect.x,rect.y,rect.width,rect.height);
1127
1128 m_graphicContext->SetBrush( m_graphicContext->CreateRadialGradientBrush(
1129 rect.x+circleCenter.x,rect.y+circleCenter.y,
1130 rect.x+circleCenter.x,rect.y+circleCenter.y,
1131 nRadius,initialColour,destColour));
1132
1133 m_graphicContext->DrawRectangle(rect.x,rect.y,rect.width,rect.height);
1134 m_graphicContext->SetPen(m_pen);
1135}
1136
1137void wxGCDCImpl::DoDrawCheckMark(wxCoord x, wxCoord y,
1138 wxCoord width, wxCoord height)
1139{
1140 wxDCImpl::DoDrawCheckMark(x,y,width,height);
1141}
1142
1143#endif // wxUSE_GRAPHICS_CONTEXT