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