]> git.saurik.com Git - wxWidgets.git/blob - src/generic/graphicc.cpp
projects / wxWidgets.git / blob
? search:


b21d03e9d7d80d8727c2b969f939e1ce6816c3bd
[wxWidgets.git] / src / generic / graphicc.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/generic/graphicc.cpp
3 // Purpose: cairo device context class
4 // Author: Stefan Csomor
5 // Modified by:
6 // Created: 2006-10-03
7 // RCS-ID: $Id$
8 // Copyright: (c) 2006 Stefan Csomor
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #include "wx/wxprec.h"
13
14 #ifdef __BORLANDC__
15 #pragma hdrstop
16 #endif
17
18 #if wxUSE_GRAPHICS_CONTEXT
19
20 #include "wx/graphics.h"
21
22 #if wxUSE_CAIRO
23
24 #include "wx/cairo.h"
25
26 #ifndef WX_PRECOMP
27 #include "wx/bitmap.h"
28 #include "wx/icon.h"
29 #include "wx/dcclient.h"
30 #include "wx/dcmemory.h"
31 #include "wx/dcprint.h"
32 #endif
33
34 #include "wx/private/graphics.h"
35 #include "wx/rawbmp.h"
36 #include "wx/vector.h"
37
38 using namespace std;
39
40 //-----------------------------------------------------------------------------
41 // device context implementation
42 //
43 // more and more of the dc functionality should be implemented by calling
44 // the appropricate wxCairoContext, but we will have to do that step by step
45 // also coordinate conversions should be moved to native matrix ops
46 //-----------------------------------------------------------------------------
47
48 // we always stock two context states, one at entry, to be able to preserve the
49 // state we were called with, the other one after changing to HI Graphics orientation
50 // (this one is used for getting back clippings etc)
51
52 //-----------------------------------------------------------------------------
53 // wxGraphicsPath implementation
54 //-----------------------------------------------------------------------------
55
56 // TODO remove this dependency (gdiplus needs the macros)
57
58 #ifndef max
59 #define max(a,b) (((a) > (b)) ? (a) : (b))
60 #endif
61
62 #ifndef min
63 #define min(a,b) (((a) < (b)) ? (a) : (b))
64 #endif
65
66 #include <cairo.h>
67 #ifdef __WXMSW__
68 #include <cairo-win32.h>
69 #endif
70
71 #ifdef __WXGTK__
72 #include <gtk/gtk.h>
73 #include "wx/fontutil.h"
74 #include "wx/gtk/dc.h"
75 #endif
76
77 #ifdef __WXMSW__
78 #include <cairo-win32.h>
79 #endif
80
81 #ifdef __WXMAC__
82 #include "wx/osx/private.h"
83 #include <cairo-quartz.h>
84 #include <cairo-atsui.h>
85 #endif
86
87 class WXDLLIMPEXP_CORE wxCairoPathData : public wxGraphicsPathData
88 {
89 public :
90 wxCairoPathData(wxGraphicsRenderer* renderer, cairo_t* path = NULL);
91 ~wxCairoPathData();
92
93 virtual wxGraphicsObjectRefData *Clone() const;
94
95 //
96 // These are the path primitives from which everything else can be constructed
97 //
98
99 // begins a new subpath at (x,y)
100 virtual void MoveToPoint( wxDouble x, wxDouble y );
101
102 // adds a straight line from the current point to (x,y)
103 virtual void AddLineToPoint( wxDouble x, wxDouble y );
104
105 // adds a cubic Bezier curve from the current point, using two control points and an end point
106 virtual void AddCurveToPoint( wxDouble cx1, wxDouble cy1, wxDouble cx2, wxDouble cy2, wxDouble x, wxDouble y );
107
108
109 // adds an arc of a circle centering at (x,y) with radius (r) from startAngle to endAngle
110 virtual void AddArc( wxDouble x, wxDouble y, wxDouble r, wxDouble startAngle, wxDouble endAngle, bool clockwise ) ;
111
112 // gets the last point of the current path, (0,0) if not yet set
113 virtual void GetCurrentPoint( wxDouble* x, wxDouble* y) const;
114
115 // adds another path
116 virtual void AddPath( const wxGraphicsPathData* path );
117
118 // closes the current sub-path
119 virtual void CloseSubpath();
120
121 //
122 // These are convenience functions which - if not available natively will be assembled
123 // using the primitives from above
124 //
125
126 /*
127
128 // appends a rectangle as a new closed subpath
129 virtual void AddRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h ) ;
130 // appends an ellipsis as a new closed subpath fitting the passed rectangle
131 virtual void AddEllipsis( wxDouble x, wxDouble y, wxDouble w , wxDouble h ) ;
132
133 // draws a an arc to two tangents connecting (current) to (x1,y1) and (x1,y1) to (x2,y2), also a straight line from (current) to (x1,y1)
134 virtual void AddArcToPoint( wxDouble x1, wxDouble y1 , wxDouble x2, wxDouble y2, wxDouble r ) ;
135 */
136
137 // returns the native path
138 virtual void * GetNativePath() const ;
139
140 // give the native path returned by GetNativePath() back (there might be some deallocations necessary)
141 virtual void UnGetNativePath(void *p) const;
142
143 // transforms each point of this path by the matrix
144 virtual void Transform( const wxGraphicsMatrixData* matrix ) ;
145
146 // gets the bounding box enclosing all points (possibly including control points)
147 virtual void GetBox(wxDouble *x, wxDouble *y, wxDouble *w, wxDouble *h) const;
148
149 virtual bool Contains( wxDouble x, wxDouble y, wxPolygonFillMode fillStyle = wxWINDING_RULE) const;
150
151 private :
152 cairo_t* m_pathContext;
153 };
154
155 class WXDLLIMPEXP_CORE wxCairoMatrixData : public wxGraphicsMatrixData
156 {
157 public :
158 wxCairoMatrixData(wxGraphicsRenderer* renderer, const cairo_matrix_t* matrix = NULL ) ;
159 virtual ~wxCairoMatrixData() ;
160
161 virtual wxGraphicsObjectRefData *Clone() const ;
162
163 // concatenates the matrix
164 virtual void Concat( const wxGraphicsMatrixData *t );
165
166 // sets the matrix to the respective values
167 virtual void Set(wxDouble a=1.0, wxDouble b=0.0, wxDouble c=0.0, wxDouble d=1.0,
168 wxDouble tx=0.0, wxDouble ty=0.0);
169
170 // gets the component valuess of the matrix
171 virtual void Get(wxDouble* a=NULL, wxDouble* b=NULL, wxDouble* c=NULL,
172 wxDouble* d=NULL, wxDouble* tx=NULL, wxDouble* ty=NULL) const;
173
174 // makes this the inverse matrix
175 virtual void Invert();
176
177 // returns true if the elements of the transformation matrix are equal ?
178 virtual bool IsEqual( const wxGraphicsMatrixData* t) const ;
179
180 // return true if this is the identity matrix
181 virtual bool IsIdentity() const;
182
183 //
184 // transformation
185 //
186
187 // add the translation to this matrix
188 virtual void Translate( wxDouble dx , wxDouble dy );
189
190 // add the scale to this matrix
191 virtual void Scale( wxDouble xScale , wxDouble yScale );
192
193 // add the rotation to this matrix (radians)
194 virtual void Rotate( wxDouble angle );
195
196 //
197 // apply the transforms
198 //
199
200 // applies that matrix to the point
201 virtual void TransformPoint( wxDouble *x, wxDouble *y ) const;
202
203 // applies the matrix except for translations
204 virtual void TransformDistance( wxDouble *dx, wxDouble *dy ) const;
205
206 // returns the native representation
207 virtual void * GetNativeMatrix() const;
208 private:
209 cairo_matrix_t m_matrix ;
210 } ;
211
212 class WXDLLIMPEXP_CORE wxCairoPenData : public wxGraphicsObjectRefData
213 {
214 public:
215 wxCairoPenData( wxGraphicsRenderer* renderer, const wxPen &pen );
216 ~wxCairoPenData();
217
218 void Init();
219
220 virtual void Apply( wxGraphicsContext* context );
221 virtual wxDouble GetWidth() { return m_width; }
222
223 private :
224 double m_width;
225
226 double m_red;
227 double m_green;
228 double m_blue;
229 double m_alpha;
230
231 cairo_line_cap_t m_cap;
232 cairo_line_join_t m_join;
233
234 int m_count;
235 const double *m_lengths;
236 double *m_userLengths;
237
238 wxPen m_pen;
239
240 wxDECLARE_NO_COPY_CLASS(wxCairoPenData);
241 };
242
243 class WXDLLIMPEXP_CORE wxCairoBrushData : public wxGraphicsObjectRefData
244 {
245 public:
246 wxCairoBrushData( wxGraphicsRenderer* renderer );
247 wxCairoBrushData( wxGraphicsRenderer* renderer, const wxBrush &brush );
248 ~wxCairoBrushData ();
249
250 virtual void Apply( wxGraphicsContext* context );
251
252 void CreateLinearGradientBrush(wxDouble x1, wxDouble y1,
253 wxDouble x2, wxDouble y2,
254 const wxGraphicsGradientStops& stops);
255 void CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
256 wxDouble xc, wxDouble yc, wxDouble radius,
257 const wxGraphicsGradientStops& stops);
258
259 protected:
260 virtual void Init();
261
262 // common part of Create{Linear,Radial}GradientBrush()
263 void AddGradientStops(const wxGraphicsGradientStops& stops);
264
265 private :
266 double m_red;
267 double m_green;
268 double m_blue;
269 double m_alpha;
270
271 cairo_pattern_t* m_brushPattern;
272 };
273
274 class wxCairoFontData : public wxGraphicsObjectRefData
275 {
276 public:
277 wxCairoFontData( wxGraphicsRenderer* renderer, const wxFont &font, const wxColour& col );
278 ~wxCairoFontData();
279
280 virtual void Apply( wxGraphicsContext* context );
281 #ifdef __WXGTK__
282 const PangoFontDescription* GetFont() const { return m_font; }
283 bool GetUnderlined() const { return m_underlined; }
284 #endif
285 private :
286 double m_size;
287 bool m_underlined;
288 double m_red;
289 double m_green;
290 double m_blue;
291 double m_alpha;
292 #ifdef __WXMAC__
293 cairo_font_face_t *m_font;
294 #elif defined(__WXGTK__)
295 PangoFontDescription* m_font;
296 #else
297 wxCharBuffer m_fontName;
298 cairo_font_slant_t m_slant;
299 cairo_font_weight_t m_weight;
300 #endif
301 #ifdef __WXMSW__
302 wxCairoContext( wxGraphicsRenderer* renderer, HDC context );
303 #endif
304 };
305
306 class wxCairoBitmapData : public wxGraphicsObjectRefData
307 {
308 public:
309 wxCairoBitmapData( wxGraphicsRenderer* renderer, const wxBitmap& bmp );
310 wxCairoBitmapData( wxGraphicsRenderer* renderer, cairo_surface_t* bitmap );
311 ~wxCairoBitmapData();
312
313 virtual cairo_surface_t* GetCairoSurface() { return m_surface; }
314 virtual cairo_pattern_t* GetCairoPattern() { return m_pattern; }
315 virtual wxSize GetSize() { return wxSize(m_width, m_height); }
316 private :
317 cairo_surface_t* m_surface;
318 cairo_pattern_t* m_pattern;
319 int m_width;
320 int m_height;
321 unsigned char* m_buffer;
322 };
323
324 class WXDLLIMPEXP_CORE wxCairoContext : public wxGraphicsContext
325 {
326 public:
327 wxCairoContext( wxGraphicsRenderer* renderer, const wxWindowDC& dc );
328 wxCairoContext( wxGraphicsRenderer* renderer, const wxMemoryDC& dc );
329 wxCairoContext( wxGraphicsRenderer* renderer, const wxPrinterDC& dc );
330 #ifdef __WXGTK__
331 wxCairoContext( wxGraphicsRenderer* renderer, GdkDrawable *drawable );
332 #endif
333 wxCairoContext( wxGraphicsRenderer* renderer, cairo_t *context );
334 wxCairoContext( wxGraphicsRenderer* renderer, wxWindow *window);
335 wxCairoContext();
336 virtual ~wxCairoContext();
337
338 virtual bool ShouldOffset() const
339 {
340 int penwidth = 0 ;
341 if ( !m_pen.IsNull() )
342 {
343 penwidth = (int)((wxCairoPenData*)m_pen.GetRefData())->GetWidth();
344 if ( penwidth == 0 )
345 penwidth = 1;
346 }
347 return ( penwidth % 2 ) == 1;
348 }
349
350 virtual void Clip( const wxRegion &region );
351 #ifdef __WXMSW__
352 cairo_surface_t* m_mswSurface;
353 #endif
354
355 // clips drawings to the rect
356 virtual void Clip( wxDouble x, wxDouble y, wxDouble w, wxDouble h );
357
358 // resets the clipping to original extent
359 virtual void ResetClip();
360
361 virtual void * GetNativeContext();
362
363 virtual bool SetAntialiasMode(wxAntialiasMode antialias);
364
365 virtual bool SetCompositionMode(wxCompositionMode op);
366
367 virtual void BeginLayer(wxDouble opacity);
368
369 virtual void EndLayer();
370
371 virtual void StrokePath( const wxGraphicsPath& p );
372 virtual void FillPath( const wxGraphicsPath& p , wxPolygonFillMode fillStyle = wxWINDING_RULE );
373
374 virtual void Translate( wxDouble dx , wxDouble dy );
375 virtual void Scale( wxDouble xScale , wxDouble yScale );
376 virtual void Rotate( wxDouble angle );
377
378 // concatenates this transform with the current transform of this context
379 virtual void ConcatTransform( const wxGraphicsMatrix& matrix );
380
381 // sets the transform of this context
382 virtual void SetTransform( const wxGraphicsMatrix& matrix );
383
384 // gets the matrix of this context
385 virtual wxGraphicsMatrix GetTransform() const;
386
387 virtual void DrawBitmap( const wxGraphicsBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h );
388 virtual void DrawBitmap( const wxBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h );
389 virtual void DrawIcon( const wxIcon &icon, wxDouble x, wxDouble y, wxDouble w, wxDouble h );
390 virtual void PushState();
391 virtual void PopState();
392
393 virtual void GetTextExtent( const wxString &str, wxDouble *width, wxDouble *height,
394 wxDouble *descent, wxDouble *externalLeading ) const;
395 virtual void GetPartialTextExtents(const wxString& text, wxArrayDouble& widths) const;
396
397 protected:
398 virtual void DoDrawText( const wxString &str, wxDouble x, wxDouble y );
399
400 private:
401 void Init(cairo_t *context);
402
403 cairo_t* m_context;
404
405 wxVector<float> m_layerOpacities;
406
407 wxDECLARE_NO_COPY_CLASS(wxCairoContext);
408 };
409
410 //-----------------------------------------------------------------------------
411 // wxCairoPenData implementation
412 //-----------------------------------------------------------------------------
413
414 wxCairoPenData::~wxCairoPenData()
415 {
416 delete[] m_userLengths;
417 }
418
419 void wxCairoPenData::Init()
420 {
421 m_lengths = NULL;
422 m_userLengths = NULL;
423 m_width = 0;
424 m_count = 0;
425 }
426
427 wxCairoPenData::wxCairoPenData( wxGraphicsRenderer* renderer, const wxPen &pen )
428 : wxGraphicsObjectRefData(renderer)
429 {
430 Init();
431 m_pen = pen;
432 m_width = m_pen.GetWidth();
433 if (m_width <= 0.0)
434 m_width = 0.1;
435
436 m_red = m_pen.GetColour().Red()/255.0;
437 m_green = m_pen.GetColour().Green()/255.0;
438 m_blue = m_pen.GetColour().Blue()/255.0;
439 m_alpha = m_pen.GetColour().Alpha()/255.0;
440
441 switch ( m_pen.GetCap() )
442 {
443 case wxCAP_ROUND :
444 m_cap = CAIRO_LINE_CAP_ROUND;
445 break;
446
447 case wxCAP_PROJECTING :
448 m_cap = CAIRO_LINE_CAP_SQUARE;
449 break;
450
451 case wxCAP_BUTT :
452 m_cap = CAIRO_LINE_CAP_BUTT;
453 break;
454
455 default :
456 m_cap = CAIRO_LINE_CAP_BUTT;
457 break;
458 }
459
460 switch ( m_pen.GetJoin() )
461 {
462 case wxJOIN_BEVEL :
463 m_join = CAIRO_LINE_JOIN_BEVEL;
464 break;
465
466 case wxJOIN_MITER :
467 m_join = CAIRO_LINE_JOIN_MITER;
468 break;
469
470 case wxJOIN_ROUND :
471 m_join = CAIRO_LINE_JOIN_ROUND;
472 break;
473
474 default :
475 m_join = CAIRO_LINE_JOIN_MITER;
476 break;
477 }
478
479 const double dashUnit = m_width < 1.0 ? 1.0 : m_width;
480 const double dotted[] =
481 {
482 dashUnit , dashUnit + 2.0
483 };
484 static const double short_dashed[] =
485 {
486 9.0 , 6.0
487 };
488 static const double dashed[] =
489 {
490 19.0 , 9.0
491 };
492 static const double dotted_dashed[] =
493 {
494 9.0 , 6.0 , 3.0 , 3.0
495 };
496
497 switch ( m_pen.GetStyle() )
498 {
499 case wxPENSTYLE_SOLID :
500 break;
501
502 case wxPENSTYLE_DOT :
503 m_count = WXSIZEOF(dotted);
504 m_userLengths = new double[ m_count ] ;
505 memcpy( m_userLengths, dotted, sizeof(dotted) );
506 m_lengths = m_userLengths;
507 break;
508
509 case wxPENSTYLE_LONG_DASH :
510 m_lengths = dashed ;
511 m_count = WXSIZEOF(dashed);
512 break;
513
514 case wxPENSTYLE_SHORT_DASH :
515 m_lengths = short_dashed ;
516 m_count = WXSIZEOF(short_dashed);
517 break;
518
519 case wxPENSTYLE_DOT_DASH :
520 m_lengths = dotted_dashed ;
521 m_count = WXSIZEOF(dotted_dashed);
522 break;
523
524 case wxPENSTYLE_USER_DASH :
525 {
526 wxDash *wxdashes ;
527 m_count = m_pen.GetDashes( &wxdashes ) ;
528 if ((wxdashes != NULL) && (m_count > 0))
529 {
530 m_userLengths = new double[m_count] ;
531 for ( int i = 0 ; i < m_count ; ++i )
532 {
533 m_userLengths[i] = wxdashes[i] * dashUnit ;
534
535 if ( i % 2 == 1 && m_userLengths[i] < dashUnit + 2.0 )
536 m_userLengths[i] = dashUnit + 2.0 ;
537 else if ( i % 2 == 0 && m_userLengths[i] < dashUnit )
538 m_userLengths[i] = dashUnit ;
539 }
540 }
541 m_lengths = m_userLengths ;
542 }
543 break;
544 case wxPENSTYLE_STIPPLE :
545 {
546 /*
547 wxBitmap* bmp = pen.GetStipple();
548 if ( bmp && bmp->Ok() )
549 {
550 wxDELETE( m_penImage );
551 wxDELETE( m_penBrush );
552 m_penImage = Bitmap::FromHBITMAP((HBITMAP)bmp->GetHBITMAP(),(HPALETTE)bmp->GetPalette()->GetHPALETTE());
553 m_penBrush = new TextureBrush(m_penImage);
554 m_pen->SetBrush( m_penBrush );
555 }
556 */
557 }
558 break;
559 default :
560 if ( m_pen.GetStyle() >= wxPENSTYLE_FIRST_HATCH
561 && m_pen.GetStyle() <= wxPENSTYLE_LAST_HATCH )
562 {
563 /*
564 wxDELETE( m_penBrush );
565 HatchStyle style = HatchStyleHorizontal;
566 switch( pen.GetStyle() )
567 {
568 case wxPENSTYLE_BDIAGONAL_HATCH :
569 style = HatchStyleBackwardDiagonal;
570 break ;
571 case wxPENSTYLE_CROSSDIAG_HATCH :
572 style = HatchStyleDiagonalCross;
573 break ;
574 case wxPENSTYLE_FDIAGONAL_HATCH :
575 style = HatchStyleForwardDiagonal;
576 break ;
577 case wxPENSTYLE_CROSS_HATCH :
578 style = HatchStyleCross;
579 break ;
580 case wxPENSTYLE_HORIZONTAL_HATCH :
581 style = HatchStyleHorizontal;
582 break ;
583 case wxPENSTYLE_VERTICAL_HATCH :
584 style = HatchStyleVertical;
585 break ;
586
587 }
588 m_penBrush = new HatchBrush(style,Color( pen.GetColour().Alpha() , pen.GetColour().Red() ,
589 pen.GetColour().Green() , pen.GetColour().Blue() ), Color.Transparent );
590 m_pen->SetBrush( m_penBrush )
591 */
592 }
593 break;
594 }
595 }
596
597 void wxCairoPenData::Apply( wxGraphicsContext* context )
598 {
599 cairo_t * ctext = (cairo_t*) context->GetNativeContext();
600 cairo_set_line_width(ctext,m_width);
601 cairo_set_source_rgba(ctext,m_red,m_green, m_blue,m_alpha);
602 cairo_set_line_cap(ctext,m_cap);
603 cairo_set_line_join(ctext,m_join);
604 cairo_set_dash(ctext,(double*)m_lengths,m_count,0.0);
605 }
606
607 //-----------------------------------------------------------------------------
608 // wxCairoBrushData implementation
609 //-----------------------------------------------------------------------------
610
611 wxCairoBrushData::wxCairoBrushData( wxGraphicsRenderer* renderer )
612 : wxGraphicsObjectRefData( renderer )
613 {
614 Init();
615 }
616
617 wxCairoBrushData::wxCairoBrushData( wxGraphicsRenderer* renderer, const wxBrush &brush )
618 : wxGraphicsObjectRefData(renderer)
619 {
620 Init();
621
622 m_red = brush.GetColour().Red()/255.0;
623 m_green = brush.GetColour().Green()/255.0;
624 m_blue = brush.GetColour().Blue()/255.0;
625 m_alpha = brush.GetColour().Alpha()/255.0;
626 /*
627 if ( brush.GetStyle() == wxBRUSHSTYLE_SOLID)
628 {
629 m_brush = new SolidBrush( Color( brush.GetColour().Alpha() , brush.GetColour().Red() ,
630 brush.GetColour().Green() , brush.GetColour().Blue() ) );
631 }
632 else if ( brush.IsHatch() )
633 {
634 HatchStyle style = HatchStyleHorizontal;
635 switch( brush.GetStyle() )
636 {
637 case wxBRUSHSTYLE_BDIAGONAL_HATCH :
638 style = HatchStyleBackwardDiagonal;
639 break ;
640 case wxBRUSHSTYLE_CROSSDIAG_HATCH :
641 style = HatchStyleDiagonalCross;
642 break ;
643 case wxBRUSHSTYLE_FDIAGONAL_HATCH :
644 style = HatchStyleForwardDiagonal;
645 break ;
646 case wxBRUSHSTYLE_CROSS_HATCH :
647 style = HatchStyleCross;
648 break ;
649 case wxBRUSHSTYLE_HORIZONTAL_HATCH :
650 style = HatchStyleHorizontal;
651 break ;
652 case wxBRUSHSTYLE_VERTICAL_HATCH :
653 style = HatchStyleVertical;
654 break ;
655
656 }
657 m_brush = new HatchBrush(style,Color( brush.GetColour().Alpha() , brush.GetColour().Red() ,
658 brush.GetColour().Green() , brush.GetColour().Blue() ), Color.Transparent );
659 }
660 else
661 {
662 wxBitmap* bmp = brush.GetStipple();
663 if ( bmp && bmp->Ok() )
664 {
665 wxDELETE( m_brushImage );
666 m_brushImage = Bitmap::FromHBITMAP((HBITMAP)bmp->GetHBITMAP(),(HPALETTE)bmp->GetPalette()->GetHPALETTE());
667 m_brush = new TextureBrush(m_brushImage);
668 }
669 }
670 */
671 }
672
673 wxCairoBrushData::~wxCairoBrushData ()
674 {
675 if (m_brushPattern)
676 cairo_pattern_destroy(m_brushPattern);
677 }
678
679 void wxCairoBrushData::Apply( wxGraphicsContext* context )
680 {
681 cairo_t * ctext = (cairo_t*) context->GetNativeContext();
682 if ( m_brushPattern )
683 {
684 cairo_set_source(ctext,m_brushPattern);
685 }
686 else
687 {
688 cairo_set_source_rgba(ctext,m_red,m_green, m_blue,m_alpha);
689 }
690 }
691
692 void wxCairoBrushData::AddGradientStops(const wxGraphicsGradientStops& stops)
693 {
694 // loop over all the stops, they include the beginning and ending ones
695 const unsigned numStops = stops.GetCount();
696 for ( unsigned n = 0; n < numStops; n++ )
697 {
698 const wxGraphicsGradientStop stop = stops.Item(n);
699
700 const wxColour col = stop.GetColour();
701
702 cairo_pattern_add_color_stop_rgba
703 (
704 m_brushPattern,
705 stop.GetPosition(),
706 col.Red()/255.0,
707 col.Green()/255.0,
708 col.Blue()/255.0,
709 col.Alpha()/255.0
710 );
711 }
712
713 wxASSERT_MSG(cairo_pattern_status(m_brushPattern) == CAIRO_STATUS_SUCCESS,
714 wxT("Couldn't create cairo pattern"));
715 }
716
717 void
718 wxCairoBrushData::CreateLinearGradientBrush(wxDouble x1, wxDouble y1,
719 wxDouble x2, wxDouble y2,
720 const wxGraphicsGradientStops& stops)
721 {
722 m_brushPattern = cairo_pattern_create_linear(x1,y1,x2,y2);
723
724 AddGradientStops(stops);
725 }
726
727 void
728 wxCairoBrushData::CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
729 wxDouble xc, wxDouble yc,
730 wxDouble radius,
731 const wxGraphicsGradientStops& stops)
732 {
733 m_brushPattern = cairo_pattern_create_radial(xo,yo,0.0,xc,yc,radius);
734
735 AddGradientStops(stops);
736 }
737
738 void wxCairoBrushData::Init()
739 {
740 m_brushPattern = NULL;
741 }
742
743 //-----------------------------------------------------------------------------
744 // wxCairoFontData implementation
745 //-----------------------------------------------------------------------------
746
747 wxCairoFontData::wxCairoFontData( wxGraphicsRenderer* renderer, const wxFont &font,
748 const wxColour& col ) : wxGraphicsObjectRefData(renderer)
749 {
750 m_red = col.Red()/255.0;
751 m_green = col.Green()/255.0;
752 m_blue = col.Blue()/255.0;
753 m_alpha = col.Alpha()/255.0;
754 m_size = font.GetPointSize();
755 m_underlined = font.GetUnderlined();
756
757 #ifdef __WXMAC__
758 m_font = cairo_quartz_font_face_create_for_cgfont( font.OSXGetCGFont() );
759 #elif defined(__WXGTK__)
760 m_font = pango_font_description_copy( font.GetNativeFontInfo()->description );
761 #else
762 m_fontName = font.GetFaceName().mb_str(wxConvUTF8);
763 m_slant = font.GetStyle() == wxFONTSTYLE_ITALIC ? CAIRO_FONT_SLANT_ITALIC:CAIRO_FONT_SLANT_NORMAL;
764 m_weight = font.GetWeight() == wxFONTWEIGHT_BOLD ? CAIRO_FONT_WEIGHT_BOLD:CAIRO_FONT_WEIGHT_NORMAL;
765 #endif
766 }
767
768 wxCairoFontData::~wxCairoFontData()
769 {
770 #ifdef __WXMAC__
771 cairo_font_face_destroy( m_font );
772 #elif defined(__WXGTK__)
773 pango_font_description_free( m_font );
774 #else
775 #endif
776 }
777
778 void wxCairoFontData::Apply( wxGraphicsContext* context )
779 {
780 cairo_t * ctext = (cairo_t*) context->GetNativeContext();
781 cairo_set_source_rgba(ctext,m_red,m_green, m_blue,m_alpha);
782 #ifdef __WXGTK__
783 // the rest is done using Pango layouts
784 #elif defined(__WXMAC__)
785 cairo_set_font_face(ctext, m_font);
786 cairo_set_font_size(ctext, m_size );
787 #else
788 cairo_select_font_face(ctext, m_fontName, m_slant, m_weights );
789 cairo_set_font_size(ctext, m_size );
790 #endif
791 }
792
793 //-----------------------------------------------------------------------------
794 // wxCairoPathData implementation
795 //-----------------------------------------------------------------------------
796
797 wxCairoPathData::wxCairoPathData( wxGraphicsRenderer* renderer, cairo_t* pathcontext)
798 : wxGraphicsPathData(renderer)
799 {
800 if (pathcontext)
801 {
802 m_pathContext = pathcontext;
803 }
804 else
805 {
806 cairo_surface_t* surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32,1,1);
807 m_pathContext = cairo_create(surface);
808 cairo_surface_destroy (surface);
809 }
810 }
811
812 wxCairoPathData::~wxCairoPathData()
813 {
814 cairo_destroy(m_pathContext);
815 }
816
817 wxGraphicsObjectRefData *wxCairoPathData::Clone() const
818 {
819 cairo_surface_t* surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32,1,1);
820 cairo_t* pathcontext = cairo_create(surface);
821 cairo_surface_destroy (surface);
822
823 cairo_path_t* path = cairo_copy_path(m_pathContext);
824 cairo_append_path(pathcontext, path);
825 cairo_path_destroy(path);
826 return new wxCairoPathData( GetRenderer() ,pathcontext);
827 }
828
829
830 void* wxCairoPathData::GetNativePath() const
831 {
832 return cairo_copy_path(m_pathContext) ;
833 }
834
835 void wxCairoPathData::UnGetNativePath(void *p) const
836 {
837 cairo_path_destroy((cairo_path_t*)p);
838 }
839
840 //
841 // The Primitives
842 //
843
844 void wxCairoPathData::MoveToPoint( wxDouble x , wxDouble y )
845 {
846 cairo_move_to(m_pathContext,x,y);
847 }
848
849 void wxCairoPathData::AddLineToPoint( wxDouble x , wxDouble y )
850 {
851 cairo_line_to(m_pathContext,x,y);
852 }
853
854 void wxCairoPathData::AddPath( const wxGraphicsPathData* path )
855 {
856 cairo_path_t* p = (cairo_path_t*)path->GetNativePath();
857 cairo_append_path(m_pathContext, p);
858 UnGetNativePath(p);
859 }
860
861 void wxCairoPathData::CloseSubpath()
862 {
863 cairo_close_path(m_pathContext);
864 }
865
866 void wxCairoPathData::AddCurveToPoint( wxDouble cx1, wxDouble cy1, wxDouble cx2, wxDouble cy2, wxDouble x, wxDouble y )
867 {
868 cairo_curve_to(m_pathContext,cx1,cy1,cx2,cy2,x,y);
869 }
870
871 // gets the last point of the current path, (0,0) if not yet set
872 void wxCairoPathData::GetCurrentPoint( wxDouble* x, wxDouble* y) const
873 {
874 double dx,dy;
875 cairo_get_current_point(m_pathContext,&dx,&dy);
876 if (x)
877 *x = dx;
878 if (y)
879 *y = dy;
880 }
881
882 void wxCairoPathData::AddArc( wxDouble x, wxDouble y, wxDouble r, double startAngle, double endAngle, bool clockwise )
883 {
884 // as clockwise means positive in our system (y pointing downwards)
885 // TODO make this interpretation dependent of the
886 // real device trans
887 if ( clockwise||(endAngle-startAngle)>=2*M_PI)
888 cairo_arc(m_pathContext,x,y,r,startAngle,endAngle);
889 else
890 cairo_arc_negative(m_pathContext,x,y,r,startAngle,endAngle);
891 }
892
893 // transforms each point of this path by the matrix
894 void wxCairoPathData::Transform( const wxGraphicsMatrixData* matrix )
895 {
896 // as we don't have a true path object, we have to apply the inverse
897 // matrix to the context
898 cairo_matrix_t m = *((cairo_matrix_t*) matrix->GetNativeMatrix());
899 cairo_matrix_invert( &m );
900 cairo_transform(m_pathContext,&m);
901 }
902
903 // gets the bounding box enclosing all points (possibly including control points)
904 void wxCairoPathData::GetBox(wxDouble *x, wxDouble *y, wxDouble *w, wxDouble *h) const
905 {
906 double x1,y1,x2,y2;
907
908 cairo_stroke_extents( m_pathContext, &x1, &y1, &x2, &y2 );
909 if ( x2 < x1 )
910 {
911 *x = x2;
912 *w = x1-x2;
913 }
914 else
915 {
916 *x = x1;
917 *w = x2-x1;
918 }
919
920 if( y2 < y1 )
921 {
922 *y = y2;
923 *h = y1-y2;
924 }
925 else
926 {
927 *y = y1;
928 *h = y2-y1;
929 }
930 }
931
932 bool wxCairoPathData::Contains( wxDouble x, wxDouble y, wxPolygonFillMode fillStyle ) const
933 {
934 cairo_set_fill_rule(m_pathContext,fillStyle==wxODDEVEN_RULE ? CAIRO_FILL_RULE_EVEN_ODD : CAIRO_FILL_RULE_WINDING);
935 return cairo_in_fill( m_pathContext, x, y) != 0;
936 }
937
938 //-----------------------------------------------------------------------------
939 // wxCairoMatrixData implementation
940 //-----------------------------------------------------------------------------
941
942 wxCairoMatrixData::wxCairoMatrixData(wxGraphicsRenderer* renderer, const cairo_matrix_t* matrix )
943 : wxGraphicsMatrixData(renderer)
944 {
945 if ( matrix )
946 m_matrix = *matrix;
947 }
948
949 wxCairoMatrixData::~wxCairoMatrixData()
950 {
951 // nothing to do
952 }
953
954 wxGraphicsObjectRefData *wxCairoMatrixData::Clone() const
955 {
956 return new wxCairoMatrixData(GetRenderer(),&m_matrix);
957 }
958
959 // concatenates the matrix
960 void wxCairoMatrixData::Concat( const wxGraphicsMatrixData *t )
961 {
962 cairo_matrix_multiply( &m_matrix, &m_matrix, (cairo_matrix_t*) t->GetNativeMatrix());
963 }
964
965 // sets the matrix to the respective values
966 void wxCairoMatrixData::Set(wxDouble a, wxDouble b, wxDouble c, wxDouble d,
967 wxDouble tx, wxDouble ty)
968 {
969 cairo_matrix_init( &m_matrix, a, b, c, d, tx, ty);
970 }
971
972 // gets the component valuess of the matrix
973 void wxCairoMatrixData::Get(wxDouble* a, wxDouble* b, wxDouble* c,
974 wxDouble* d, wxDouble* tx, wxDouble* ty) const
975 {
976 if (a) *a = m_matrix.xx;
977 if (b) *b = m_matrix.yx;
978 if (c) *c = m_matrix.xy;
979 if (d) *d = m_matrix.yy;
980 if (tx) *tx= m_matrix.x0;
981 if (ty) *ty= m_matrix.y0;
982 }
983
984 // makes this the inverse matrix
985 void wxCairoMatrixData::Invert()
986 {
987 cairo_matrix_invert( &m_matrix );
988 }
989
990 // returns true if the elements of the transformation matrix are equal ?
991 bool wxCairoMatrixData::IsEqual( const wxGraphicsMatrixData* t) const
992 {
993 const cairo_matrix_t* tm = (cairo_matrix_t*) t->GetNativeMatrix();
994 return (
995 m_matrix.xx == tm->xx &&
996 m_matrix.yx == tm->yx &&
997 m_matrix.xy == tm->xy &&
998 m_matrix.yy == tm->yy &&
999 m_matrix.x0 == tm->x0 &&
1000 m_matrix.y0 == tm->y0 ) ;
1001 }
1002
1003 // return true if this is the identity matrix
1004 bool wxCairoMatrixData::IsIdentity() const
1005 {
1006 return ( m_matrix.xx == 1 && m_matrix.yy == 1 &&
1007 m_matrix.yx == 0 && m_matrix.xy == 0 && m_matrix.x0 == 0 && m_matrix.y0 == 0);
1008 }
1009
1010 //
1011 // transformation
1012 //
1013
1014 // add the translation to this matrix
1015 void wxCairoMatrixData::Translate( wxDouble dx , wxDouble dy )
1016 {
1017 cairo_matrix_translate( &m_matrix, dx, dy) ;
1018 }
1019
1020 // add the scale to this matrix
1021 void wxCairoMatrixData::Scale( wxDouble xScale , wxDouble yScale )
1022 {
1023 cairo_matrix_scale( &m_matrix, xScale, yScale) ;
1024 }
1025
1026 // add the rotation to this matrix (radians)
1027 void wxCairoMatrixData::Rotate( wxDouble angle )
1028 {
1029 cairo_matrix_rotate( &m_matrix, angle) ;
1030 }
1031
1032 //
1033 // apply the transforms
1034 //
1035
1036 // applies that matrix to the point
1037 void wxCairoMatrixData::TransformPoint( wxDouble *x, wxDouble *y ) const
1038 {
1039 double lx = *x, ly = *y ;
1040 cairo_matrix_transform_point( &m_matrix, &lx, &ly);
1041 *x = lx;
1042 *y = ly;
1043 }
1044
1045 // applies the matrix except for translations
1046 void wxCairoMatrixData::TransformDistance( wxDouble *dx, wxDouble *dy ) const
1047 {
1048 double lx = *dx, ly = *dy ;
1049 cairo_matrix_transform_distance( &m_matrix, &lx, &ly);
1050 *dx = lx;
1051 *dy = ly;
1052 }
1053
1054 // returns the native representation
1055 void * wxCairoMatrixData::GetNativeMatrix() const
1056 {
1057 return (void*) &m_matrix;
1058 }
1059
1060 // wxCairoBitmap implementation
1061 //-----------------------------------------------------------------------------
1062
1063 wxCairoBitmapData::wxCairoBitmapData( wxGraphicsRenderer* renderer, cairo_surface_t* bitmap ) :
1064 wxGraphicsObjectRefData( renderer )
1065 {
1066 m_surface = bitmap;
1067 m_pattern = cairo_pattern_create_for_surface(m_surface);
1068 }
1069
1070 wxCairoBitmapData::wxCairoBitmapData( wxGraphicsRenderer* renderer, const wxBitmap& bmp ) : wxGraphicsObjectRefData( renderer )
1071 {
1072 wxCHECK_RET( bmp.IsOk(), wxT("Invalid bitmap in wxCairoContext::DrawBitmap"));
1073
1074 int bw = m_width = bmp.GetWidth();
1075 int bh = m_height = bmp.GetHeight();
1076 wxBitmap bmpSource = bmp; // we need a non-const instance
1077 m_buffer = new unsigned char[bw*bh*4];
1078 wxUint32* data = (wxUint32*)m_buffer;
1079
1080 // Create a surface object and copy the bitmap pixel data to it. if the
1081 // image has alpha (or a mask represented as alpha) then we'll use a
1082 // different format and iterator than if it doesn't...
1083 if (bmpSource.HasAlpha() || bmpSource.GetMask())
1084 {
1085 m_surface = cairo_image_surface_create_for_data(
1086 m_buffer, CAIRO_FORMAT_ARGB32, bw, bh, bw*4);
1087 wxAlphaPixelData pixData(bmpSource, wxPoint(0,0), wxSize(bw, bh));
1088 wxCHECK_RET( pixData, wxT("Failed to gain raw access to bitmap data."));
1089
1090 wxAlphaPixelData::Iterator p(pixData);
1091 for (int y=0; y<bh; y++)
1092 {
1093 wxAlphaPixelData::Iterator rowStart = p;
1094 for (int x=0; x<bw; x++)
1095 {
1096 // Each pixel in CAIRO_FORMAT_ARGB32 is a 32-bit quantity,
1097 // with alpha in the upper 8 bits, then red, then green, then
1098 // blue. The 32-bit quantities are stored native-endian.
1099 // Pre-multiplied alpha is used.
1100 unsigned char alpha = p.Alpha();
1101 if (alpha == 0)
1102 *data = 0;
1103 else
1104 *data = ( alpha << 24
1105 | (p.Red() * alpha/255) << 16
1106 | (p.Green() * alpha/255) << 8
1107 | (p.Blue() * alpha/255) );
1108 ++data;
1109 ++p;
1110 }
1111 p = rowStart;
1112 p.OffsetY(pixData, 1);
1113 }
1114 }
1115 else // no alpha
1116 {
1117 m_surface = cairo_image_surface_create_for_data(
1118 m_buffer, CAIRO_FORMAT_RGB24, bw, bh, bw*4);
1119 wxNativePixelData pixData(bmpSource, wxPoint(0,0), wxSize(bw, bh));
1120 wxCHECK_RET( pixData, wxT("Failed to gain raw access to bitmap data."));
1121
1122 wxNativePixelData::Iterator p(pixData);
1123 for (int y=0; y<bh; y++)
1124 {
1125 wxNativePixelData::Iterator rowStart = p;
1126 for (int x=0; x<bw; x++)
1127 {
1128 // Each pixel in CAIRO_FORMAT_RGB24 is a 32-bit quantity, with
1129 // the upper 8 bits unused. Red, Green, and Blue are stored in
1130 // the remaining 24 bits in that order. The 32-bit quantities
1131 // are stored native-endian.
1132 *data = ( p.Red() << 16 | p.Green() << 8 | p.Blue() );
1133 ++data;
1134 ++p;
1135 }
1136 p = rowStart;
1137 p.OffsetY(pixData, 1);
1138 }
1139 }
1140 m_pattern = cairo_pattern_create_for_surface(m_surface);
1141 }
1142
1143 wxCairoBitmapData::~wxCairoBitmapData()
1144 {
1145 if (m_pattern)
1146 cairo_pattern_destroy(m_pattern);
1147
1148 if (m_surface)
1149 cairo_surface_destroy(m_surface);
1150
1151 delete [] m_buffer;
1152 }
1153
1154
1155
1156 //-----------------------------------------------------------------------------
1157 // wxCairoContext implementation
1158 //-----------------------------------------------------------------------------
1159
1160 class wxCairoOffsetHelper
1161 {
1162 public :
1163 wxCairoOffsetHelper( cairo_t* ctx , bool offset )
1164 {
1165 m_ctx = ctx;
1166 m_offset = offset;
1167 if ( m_offset )
1168 cairo_translate( m_ctx, 0.5, 0.5 );
1169 }
1170 ~wxCairoOffsetHelper( )
1171 {
1172 if ( m_offset )
1173 cairo_translate( m_ctx, -0.5, -0.5 );
1174 }
1175 public :
1176 cairo_t* m_ctx;
1177 bool m_offset;
1178 } ;
1179
1180 wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, const wxPrinterDC& dc )
1181 : wxGraphicsContext(renderer)
1182 {
1183 #ifdef __WXGTK20__
1184 const wxDCImpl *impl = dc.GetImpl();
1185 Init( (cairo_t*) impl->GetCairoContext() );
1186
1187 wxPoint org = dc.GetDeviceOrigin();
1188 cairo_translate( m_context, org.x, org.y );
1189
1190 double sx,sy;
1191 dc.GetUserScale( &sx, &sy );
1192 cairo_scale( m_context, sx, sy );
1193
1194 org = dc.GetLogicalOrigin();
1195 cairo_translate( m_context, -org.x, -org.y );
1196 #endif
1197 }
1198
1199 wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, const wxWindowDC& dc )
1200 : wxGraphicsContext(renderer)
1201 {
1202 #ifdef __WXGTK20__
1203 wxGTKDCImpl *impldc = (wxGTKDCImpl*) dc.GetImpl();
1204 Init( gdk_cairo_create( impldc->GetGDKWindow() ) );
1205
1206 #if 0
1207 wxGraphicsMatrix matrix = CreateMatrix();
1208
1209 wxPoint org = dc.GetDeviceOrigin();
1210 matrix.Translate( org.x, org.y );
1211
1212 org = dc.GetLogicalOrigin();
1213 matrix.Translate( -org.x, -org.y );
1214
1215 double sx,sy;
1216 dc.GetUserScale( &sx, &sy );
1217 matrix.Scale( sx, sy );
1218
1219 ConcatTransform( matrix );
1220 #endif
1221 #endif
1222
1223 #ifdef __WXMAC__
1224 int width, height;
1225 dc.GetSize( &width, &height );
1226 CGContextRef cgcontext = (CGContextRef)dc.GetWindow()->MacGetCGContextRef();
1227 cairo_surface_t* surface = cairo_quartz_surface_create_for_cg_context(cgcontext, width, height);
1228 Init( cairo_create( surface ) );
1229 cairo_surface_destroy( surface );
1230 #endif
1231 }
1232
1233 wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, const wxMemoryDC& dc )
1234 : wxGraphicsContext(renderer)
1235 {
1236 #ifdef __WXGTK20__
1237 wxGTKDCImpl *impldc = (wxGTKDCImpl*) dc.GetImpl();
1238 Init( gdk_cairo_create( impldc->GetGDKWindow() ) );
1239
1240 #if 0
1241 wxGraphicsMatrix matrix = CreateMatrix();
1242
1243 wxPoint org = dc.GetDeviceOrigin();
1244 matrix.Translate( org.x, org.y );
1245
1246 org = dc.GetLogicalOrigin();
1247 matrix.Translate( -org.x, -org.y );
1248
1249 double sx,sy;
1250 dc.GetUserScale( &sx, &sy );
1251 matrix.Scale( sx, sy );
1252
1253 ConcatTransform( matrix );
1254 #endif
1255 #endif
1256
1257 #ifdef __WXMAC__
1258 int width, height;
1259 dc.GetSize( &width, &height );
1260 CGContextRef cgcontext = (CGContextRef)dc.GetWindow()->MacGetCGContextRef();
1261 cairo_surface_t* surface = cairo_quartz_surface_create_for_cg_context(cgcontext, width, height);
1262 Init( cairo_create( surface ) );
1263 cairo_surface_destroy( surface );
1264 #endif
1265 }
1266
1267 #ifdef __WXGTK20__
1268 wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, GdkDrawable *drawable )
1269 : wxGraphicsContext(renderer)
1270 {
1271 Init( gdk_cairo_create( drawable ) );
1272 }
1273 #endif
1274
1275 #ifdef __WXMSW__
1276 wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, HDC handle )
1277 : wxGraphicsContext(renderer)
1278 {
1279 m_mswSurface = cairo_win32_surface_create(handle);
1280 m_context = cairo_create(m_mswSurface);
1281 PushState();
1282 PushState();
1283 }
1284 #endif
1285
1286
1287 wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, cairo_t *context )
1288 : wxGraphicsContext(renderer)
1289 {
1290 Init( context );
1291 }
1292
1293 wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, wxWindow *window)
1294 : wxGraphicsContext(renderer)
1295 {
1296 #ifdef __WXGTK__
1297 // something along these lines (copied from dcclient)
1298
1299 // Some controls don't have m_wxwindow - like wxStaticBox, but the user
1300 // code should still be able to create wxClientDCs for them, so we will
1301 // use the parent window here then.
1302 if (window->m_wxwindow == NULL)
1303 {
1304 window = window->GetParent();
1305 }
1306
1307 wxASSERT_MSG( window->m_wxwindow, wxT("wxCairoContext needs a widget") );
1308
1309 Init(gdk_cairo_create(window->GTKGetDrawingWindow()));
1310 #endif
1311 }
1312
1313 wxCairoContext::~wxCairoContext()
1314 {
1315 if ( m_context )
1316 {
1317 PopState();
1318 #ifdef __WXMSW__
1319 m_mswSurface = cairo_win32_surface_create((HDC)window->GetHandle());
1320 m_context = cairo_create(m_mswSurface);
1321 #endif
1322 PopState();
1323 cairo_destroy(m_context);
1324 }
1325 #ifdef __WXMSW__
1326 if ( m_mswSurface )
1327 cairo_surface_destroy(m_mswSurface);
1328 #endif
1329 }
1330
1331 void wxCairoContext::Init(cairo_t *context)
1332 {
1333 m_context = context ;
1334 PushState();
1335 PushState();
1336 }
1337
1338
1339 void wxCairoContext::Clip( const wxRegion& region )
1340 {
1341 // Create a path with all the rectangles in the region
1342 wxGraphicsPath path = GetRenderer()->CreatePath();
1343 wxRegionIterator ri(region);
1344 while (ri)
1345 {
1346 path.AddRectangle(ri.GetX(), ri.GetY(), ri.GetW(), ri.GetH());
1347 ++ri;
1348 }
1349
1350 // Put it in the context
1351 cairo_path_t* cp = (cairo_path_t*) path.GetNativePath() ;
1352 cairo_append_path(m_context, cp);
1353
1354 // clip to that path
1355 cairo_clip(m_context);
1356 path.UnGetNativePath(cp);
1357 }
1358
1359 void wxCairoContext::Clip( wxDouble x, wxDouble y, wxDouble w, wxDouble h )
1360 {
1361 // Create a path with this rectangle
1362 wxGraphicsPath path = GetRenderer()->CreatePath();
1363 path.AddRectangle(x,y,w,h);
1364
1365 // Put it in the context
1366 cairo_path_t* cp = (cairo_path_t*) path.GetNativePath() ;
1367 cairo_append_path(m_context, cp);
1368
1369 // clip to that path
1370 cairo_clip(m_context);
1371 path.UnGetNativePath(cp);
1372 }
1373
1374 void wxCairoContext::ResetClip()
1375 {
1376 cairo_reset_clip(m_context);
1377 }
1378
1379
1380 void wxCairoContext::StrokePath( const wxGraphicsPath& path )
1381 {
1382 if ( !m_pen.IsNull() )
1383 {
1384 wxCairoOffsetHelper helper( m_context, ShouldOffset() ) ;
1385 cairo_path_t* cp = (cairo_path_t*) path.GetNativePath() ;
1386 cairo_append_path(m_context,cp);
1387 ((wxCairoPenData*)m_pen.GetRefData())->Apply(this);
1388 cairo_stroke(m_context);
1389 path.UnGetNativePath(cp);
1390 }
1391 }
1392
1393 void wxCairoContext::FillPath( const wxGraphicsPath& path , wxPolygonFillMode fillStyle )
1394 {
1395 if ( !m_brush.IsNull() )
1396 {
1397 wxCairoOffsetHelper helper( m_context, ShouldOffset() ) ;
1398 cairo_path_t* cp = (cairo_path_t*) path.GetNativePath() ;
1399 cairo_append_path(m_context,cp);
1400 ((wxCairoBrushData*)m_brush.GetRefData())->Apply(this);
1401 cairo_set_fill_rule(m_context,fillStyle==wxODDEVEN_RULE ? CAIRO_FILL_RULE_EVEN_ODD : CAIRO_FILL_RULE_WINDING);
1402 cairo_fill(m_context);
1403 path.UnGetNativePath(cp);
1404 }
1405 }
1406
1407 void wxCairoContext::Rotate( wxDouble angle )
1408 {
1409 cairo_rotate(m_context,angle);
1410 }
1411
1412 void wxCairoContext::Translate( wxDouble dx , wxDouble dy )
1413 {
1414 cairo_translate(m_context,dx,dy);
1415 }
1416
1417 void wxCairoContext::Scale( wxDouble xScale , wxDouble yScale )
1418 {
1419 cairo_scale(m_context,xScale,yScale);
1420 }
1421
1422 // concatenates this transform with the current transform of this context
1423 void wxCairoContext::ConcatTransform( const wxGraphicsMatrix& matrix )
1424 {
1425 cairo_transform(m_context,(const cairo_matrix_t *) matrix.GetNativeMatrix());
1426 }
1427
1428 // sets the transform of this context
1429 void wxCairoContext::SetTransform( const wxGraphicsMatrix& matrix )
1430 {
1431 cairo_set_matrix(m_context,(const cairo_matrix_t*) matrix.GetNativeMatrix());
1432 }
1433
1434 // gets the matrix of this context
1435 wxGraphicsMatrix wxCairoContext::GetTransform() const
1436 {
1437 wxGraphicsMatrix matrix = CreateMatrix();
1438 cairo_get_matrix(m_context,(cairo_matrix_t*) matrix.GetNativeMatrix());
1439 return matrix;
1440 }
1441
1442
1443
1444 void wxCairoContext::PushState()
1445 {
1446 cairo_save(m_context);
1447 }
1448
1449 void wxCairoContext::PopState()
1450 {
1451 cairo_restore(m_context);
1452 }
1453
1454 void wxCairoContext::DrawBitmap( const wxBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h )
1455 {
1456 wxGraphicsBitmap bitmap = GetRenderer()->CreateBitmap(bmp);
1457 DrawBitmap(bitmap, x, y, w, h);
1458
1459 }
1460
1461 void wxCairoContext::DrawBitmap(const wxGraphicsBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h )
1462 {
1463 PushState();
1464
1465 // In case we're scaling the image by using a width and height different
1466 // than the bitmap's size create a pattern transformation on the surface and
1467 // draw the transformed pattern.
1468 wxCairoBitmapData* data = static_cast<wxCairoBitmapData*>(bmp.GetRefData());
1469 cairo_pattern_t* pattern = data->GetCairoPattern();
1470 wxSize size = data->GetSize();
1471
1472 wxDouble scaleX = w / size.GetWidth();
1473 wxDouble scaleY = h / size.GetHeight();
1474 cairo_scale(m_context, scaleX, scaleY);
1475
1476 // prepare to draw the image
1477 cairo_translate(m_context, x, y);
1478 cairo_set_source(m_context, pattern);
1479 // use the original size here since the context is scaled already...
1480 cairo_rectangle(m_context, 0, 0, size.GetWidth(), size.GetHeight());
1481 // fill the rectangle using the pattern
1482 cairo_fill(m_context);
1483
1484 PopState();
1485 }
1486
1487 void wxCairoContext::DrawIcon( const wxIcon &icon, wxDouble x, wxDouble y, wxDouble w, wxDouble h )
1488 {
1489 // An icon is a bitmap on wxGTK, so do this the easy way. When we want to
1490 // start using the Cairo backend on other platforms then we may need to
1491 // fiddle with this...
1492 DrawBitmap(icon, x, y, w, h);
1493 }
1494
1495
1496 void wxCairoContext::DoDrawText(const wxString& str, wxDouble x, wxDouble y)
1497 {
1498 wxCHECK_RET( !m_font.IsNull(),
1499 wxT("wxCairoContext::DrawText - no valid font set") );
1500
1501 if ( str.empty())
1502 return;
1503
1504 const wxCharBuffer data = str.utf8_str();
1505 if ( !data )
1506 return;
1507
1508 ((wxCairoFontData*)m_font.GetRefData())->Apply(this);
1509
1510 #ifdef __WXGTK__
1511 size_t datalen = strlen(data);
1512
1513 PangoLayout *layout = pango_cairo_create_layout (m_context);
1514 wxCairoFontData* font_data = (wxCairoFontData*) m_font.GetRefData();
1515 pango_layout_set_font_description( layout, font_data->GetFont());
1516 pango_layout_set_text(layout, data, datalen);
1517
1518 if (font_data->GetUnderlined())
1519 {
1520 PangoAttrList *attrs = pango_attr_list_new();
1521 PangoAttribute *attr = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE);
1522 pango_attr_list_insert(attrs, attr);
1523 pango_layout_set_attributes(layout, attrs);
1524 pango_attr_list_unref(attrs);
1525 }
1526
1527 cairo_move_to(m_context, x, y);
1528 pango_cairo_show_layout (m_context, layout);
1529
1530 g_object_unref (layout);
1531 #else
1532 // Cairo's x,y for drawing text is at the baseline, so we need to adjust
1533 // the position we move to by the ascent.
1534 cairo_font_extents_t fe;
1535 cairo_font_extents(m_context, &fe);
1536 cairo_move_to(m_context, x, y+fe.ascent);
1537
1538 cairo_show_text(m_context, data);
1539 #endif
1540 }
1541
1542 void wxCairoContext::GetTextExtent( const wxString &str, wxDouble *width, wxDouble *height,
1543 wxDouble *descent, wxDouble *externalLeading ) const
1544 {
1545 wxCHECK_RET( !m_font.IsNull(), wxT("wxCairoContext::GetTextExtent - no valid font set") );
1546
1547 if ( width )
1548 *width = 0;
1549 if ( height )
1550 *height = 0;
1551 if ( descent )
1552 *descent = 0;
1553 if ( externalLeading )
1554 *externalLeading = 0;
1555
1556 if ( str.empty())
1557 return;
1558
1559 #ifdef __WXGTK__
1560 int w, h;
1561
1562 PangoLayout *layout = pango_cairo_create_layout (m_context);
1563 pango_layout_set_font_description( layout, ((wxCairoFontData*)m_font.GetRefData())->GetFont());
1564 const wxCharBuffer data = str.utf8_str();
1565 if ( !data )
1566 {
1567 return;
1568 }
1569 pango_layout_set_text( layout, data, strlen(data) );
1570 pango_layout_get_pixel_size (layout, &w, &h);
1571 if ( width )
1572 *width = w;
1573 if ( height )
1574 *height = h;
1575 if (descent)
1576 {
1577 PangoLayoutIter *iter = pango_layout_get_iter(layout);
1578 int baseline = pango_layout_iter_get_baseline(iter);
1579 pango_layout_iter_free(iter);
1580 *descent = h - PANGO_PIXELS(baseline);
1581 }
1582 g_object_unref (layout);
1583 #else
1584 ((wxCairoFontData*)m_font.GetRefData())->Apply((wxCairoContext*)this);
1585
1586 if (width)
1587 {
1588 const wxWX2MBbuf buf(str.mb_str(wxConvUTF8));
1589 cairo_text_extents_t te;
1590 cairo_text_extents(m_context, buf, &te);
1591 *width = te.width;
1592 }
1593
1594 if (height || descent || externalLeading)
1595 {
1596 cairo_font_extents_t fe;
1597 cairo_font_extents(m_context, &fe);
1598
1599 // some backends have negative descents
1600
1601 if ( fe.descent < 0 )
1602 fe.descent = -fe.descent;
1603
1604 if ( fe.height < (fe.ascent + fe.descent ) )
1605 {
1606 // some backends are broken re height ... (eg currently ATSUI)
1607 fe.height = fe.ascent + fe.descent;
1608 }
1609
1610 if (height)
1611 *height = fe.height;
1612 if ( descent )
1613 *descent = fe.descent;
1614 if ( externalLeading )
1615 *externalLeading = wxMax(0, fe.height - (fe.ascent + fe.descent));
1616 }
1617 #endif
1618 }
1619
1620 void wxCairoContext::GetPartialTextExtents(const wxString& text, wxArrayDouble& widths) const
1621 {
1622 widths.Empty();
1623 widths.Add(0, text.length());
1624
1625 wxCHECK_RET( !m_font.IsNull(), wxT("wxCairoContext::GetPartialTextExtents - no valid font set") );
1626
1627 if (text.empty())
1628 return;
1629
1630 // TODO
1631 }
1632
1633 void * wxCairoContext::GetNativeContext()
1634 {
1635 return m_context;
1636 }
1637
1638 bool wxCairoContext::SetAntialiasMode(wxAntialiasMode antialias)
1639 {
1640 if (m_antialias == antialias)
1641 return true;
1642
1643 m_antialias = antialias;
1644
1645 cairo_antialias_t antialiasMode;
1646 switch (antialias)
1647 {
1648 case wxANTIALIAS_DEFAULT:
1649 antialiasMode = CAIRO_ANTIALIAS_DEFAULT;
1650 break;
1651 case wxANTIALIAS_NONE:
1652 antialiasMode = CAIRO_ANTIALIAS_NONE;
1653 break;
1654 default:
1655 return false;
1656 }
1657 cairo_set_antialias(m_context, antialiasMode);
1658 return true;
1659 }
1660
1661 bool wxCairoContext::SetCompositionMode(wxCompositionMode op)
1662 {
1663 if ( m_composition == op )
1664 return true;
1665
1666 m_composition = op;
1667 cairo_operator_t cop;
1668 switch (op)
1669 {
1670 case wxCOMPOSITION_CLEAR:
1671 cop = CAIRO_OPERATOR_CLEAR;
1672 break;
1673 case wxCOMPOSITION_SOURCE:
1674 cop = CAIRO_OPERATOR_SOURCE;
1675 break;
1676 case wxCOMPOSITION_OVER:
1677 cop = CAIRO_OPERATOR_OVER;
1678 break;
1679 case wxCOMPOSITION_IN:
1680 cop = CAIRO_OPERATOR_IN;
1681 break;
1682 case wxCOMPOSITION_OUT:
1683 cop = CAIRO_OPERATOR_OUT;
1684 break;
1685 case wxCOMPOSITION_ATOP:
1686 cop = CAIRO_OPERATOR_ATOP;
1687 break;
1688 case wxCOMPOSITION_DEST:
1689 cop = CAIRO_OPERATOR_DEST;
1690 break;
1691 case wxCOMPOSITION_DEST_OVER:
1692 cop = CAIRO_OPERATOR_DEST_OVER;
1693 break;
1694 case wxCOMPOSITION_DEST_IN:
1695 cop = CAIRO_OPERATOR_DEST_IN;
1696 break;
1697 case wxCOMPOSITION_DEST_OUT:
1698 cop = CAIRO_OPERATOR_DEST_OUT;
1699 break;
1700 case wxCOMPOSITION_DEST_ATOP:
1701 cop = CAIRO_OPERATOR_DEST_ATOP;
1702 break;
1703 case wxCOMPOSITION_XOR:
1704 cop = CAIRO_OPERATOR_XOR;
1705 break;
1706 case wxCOMPOSITION_ADD:
1707 cop = CAIRO_OPERATOR_ADD;
1708 break;
1709 default:
1710 return false;
1711 }
1712 cairo_set_operator(m_context, cop);
1713 return true;
1714 }
1715
1716 void wxCairoContext::BeginLayer(wxDouble opacity)
1717 {
1718 m_layerOpacities.push_back(opacity);
1719 cairo_push_group(m_context);
1720 }
1721
1722 void wxCairoContext::EndLayer()
1723 {
1724 float opacity = m_layerOpacities.back();
1725 m_layerOpacities.pop_back();
1726 cairo_pop_group_to_source(m_context);
1727 cairo_paint_with_alpha(m_context,opacity);
1728 }
1729
1730 //-----------------------------------------------------------------------------
1731 // wxCairoRenderer declaration
1732 //-----------------------------------------------------------------------------
1733
1734 class WXDLLIMPEXP_CORE wxCairoRenderer : public wxGraphicsRenderer
1735 {
1736 public :
1737 wxCairoRenderer() {}
1738
1739 virtual ~wxCairoRenderer() {}
1740
1741 // Context
1742
1743 virtual wxGraphicsContext * CreateContext( const wxWindowDC& dc);
1744 virtual wxGraphicsContext * CreateContext( const wxMemoryDC& dc);
1745 virtual wxGraphicsContext * CreateContext( const wxPrinterDC& dc);
1746
1747 virtual wxGraphicsContext * CreateContextFromNativeContext( void * context );
1748
1749 virtual wxGraphicsContext * CreateContextFromNativeWindow( void * window );
1750
1751 virtual wxGraphicsContext * CreateContext( wxWindow* window );
1752
1753 virtual wxGraphicsContext * CreateMeasuringContext();
1754
1755 // Path
1756
1757 virtual wxGraphicsPath CreatePath();
1758
1759 // Matrix
1760
1761 virtual wxGraphicsMatrix CreateMatrix( wxDouble a=1.0, wxDouble b=0.0, wxDouble c=0.0, wxDouble d=1.0,
1762 wxDouble tx=0.0, wxDouble ty=0.0);
1763
1764
1765 virtual wxGraphicsPen CreatePen(const wxPen& pen) ;
1766
1767 virtual wxGraphicsBrush CreateBrush(const wxBrush& brush ) ;
1768
1769 virtual wxGraphicsBrush
1770 CreateLinearGradientBrush(wxDouble x1, wxDouble y1,
1771 wxDouble x2, wxDouble y2,
1772 const wxGraphicsGradientStops& stops);
1773
1774 virtual wxGraphicsBrush
1775 CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
1776 wxDouble xc, wxDouble yc,
1777 wxDouble radius,
1778 const wxGraphicsGradientStops& stops);
1779
1780 // sets the font
1781 virtual wxGraphicsFont CreateFont( const wxFont &font , const wxColour &col = *wxBLACK ) ;
1782
1783 // create a native bitmap representation
1784 virtual wxGraphicsBitmap CreateBitmap( const wxBitmap &bitmap );
1785
1786 // create a graphics bitmap from a native bitmap
1787 virtual wxGraphicsBitmap CreateBitmapFromNativeBitmap( void* bitmap );
1788
1789 // create a subimage from a native image representation
1790 virtual wxGraphicsBitmap CreateSubBitmap( const wxGraphicsBitmap &bitmap, wxDouble x, wxDouble y, wxDouble w, wxDouble h );
1791
1792 private :
1793 DECLARE_DYNAMIC_CLASS_NO_COPY(wxCairoRenderer)
1794 } ;
1795
1796 //-----------------------------------------------------------------------------
1797 // wxCairoRenderer implementation
1798 //-----------------------------------------------------------------------------
1799
1800 IMPLEMENT_DYNAMIC_CLASS(wxCairoRenderer,wxGraphicsRenderer)
1801
1802 static wxCairoRenderer gs_cairoGraphicsRenderer;
1803 // temporary hack to allow creating a cairo context on any platform
1804 extern wxGraphicsRenderer* gCairoRenderer;
1805 wxGraphicsRenderer* gCairoRenderer = &gs_cairoGraphicsRenderer;
1806
1807 wxGraphicsContext * wxCairoRenderer::CreateContext( const wxWindowDC& dc)
1808 {
1809 return new wxCairoContext(this,dc);
1810 }
1811
1812 wxGraphicsContext * wxCairoRenderer::CreateContext( const wxMemoryDC& dc)
1813 {
1814 return new wxCairoContext(this,dc);
1815 }
1816
1817 wxGraphicsContext * wxCairoRenderer::CreateContext( const wxPrinterDC& dc)
1818 {
1819 #ifdef __WXGTK20__
1820 const wxDCImpl *impl = dc.GetImpl();
1821 cairo_t* context = (cairo_t*) impl->GetCairoContext();
1822 if (context)
1823 return new wxCairoContext(this,dc);
1824 else
1825 #endif
1826 return NULL;
1827 }
1828
1829 wxGraphicsContext * wxCairoRenderer::CreateContextFromNativeContext( void * context )
1830 {
1831 #ifdef __WXMSW__
1832 return new wxCairoContext(this,(HDC)context);
1833 #endif
1834 #ifdef __WXGTK__
1835 return new wxCairoContext(this,(cairo_t*)context);
1836 #endif
1837 }
1838
1839
1840 wxGraphicsContext * wxCairoRenderer::CreateContextFromNativeWindow( void * window )
1841 {
1842 #ifdef __WXGTK__
1843 return new wxCairoContext(this,(GdkDrawable*)window);
1844 #else
1845 return NULL;
1846 #endif
1847 }
1848
1849 wxGraphicsContext * wxCairoRenderer::CreateMeasuringContext()
1850 {
1851 #ifdef __WXGTK__
1852 return CreateContextFromNativeWindow(gdk_get_default_root_window());
1853 #endif
1854 return NULL;
1855 // TODO
1856 }
1857
1858 wxGraphicsContext * wxCairoRenderer::CreateContext( wxWindow* window )
1859 {
1860 return new wxCairoContext(this, window );
1861 }
1862
1863 // Path
1864
1865 wxGraphicsPath wxCairoRenderer::CreatePath()
1866 {
1867 wxGraphicsPath path;
1868 path.SetRefData( new wxCairoPathData(this) );
1869 return path;
1870 }
1871
1872
1873 // Matrix
1874
1875 wxGraphicsMatrix wxCairoRenderer::CreateMatrix( wxDouble a, wxDouble b, wxDouble c, wxDouble d,
1876 wxDouble tx, wxDouble ty)
1877
1878 {
1879 wxGraphicsMatrix m;
1880 wxCairoMatrixData* data = new wxCairoMatrixData( this );
1881 data->Set( a,b,c,d,tx,ty ) ;
1882 m.SetRefData(data);
1883 return m;
1884 }
1885
1886 wxGraphicsPen wxCairoRenderer::CreatePen(const wxPen& pen)
1887 {
1888 if ( !pen.Ok() || pen.GetStyle() == wxPENSTYLE_TRANSPARENT )
1889 return wxNullGraphicsPen;
1890 else
1891 {
1892 wxGraphicsPen p;
1893 p.SetRefData(new wxCairoPenData( this, pen ));
1894 return p;
1895 }
1896 }
1897
1898 wxGraphicsBrush wxCairoRenderer::CreateBrush(const wxBrush& brush )
1899 {
1900 if ( !brush.Ok() || brush.GetStyle() == wxBRUSHSTYLE_TRANSPARENT )
1901 return wxNullGraphicsBrush;
1902 else
1903 {
1904 wxGraphicsBrush p;
1905 p.SetRefData(new wxCairoBrushData( this, brush ));
1906 return p;
1907 }
1908 }
1909
1910 wxGraphicsBrush
1911 wxCairoRenderer::CreateLinearGradientBrush(wxDouble x1, wxDouble y1,
1912 wxDouble x2, wxDouble y2,
1913 const wxGraphicsGradientStops& stops)
1914 {
1915 wxGraphicsBrush p;
1916 wxCairoBrushData* d = new wxCairoBrushData( this );
1917 d->CreateLinearGradientBrush(x1, y1, x2, y2, stops);
1918 p.SetRefData(d);
1919 return p;
1920 }
1921
1922 wxGraphicsBrush
1923 wxCairoRenderer::CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
1924 wxDouble xc, wxDouble yc, wxDouble r,
1925 const wxGraphicsGradientStops& stops)
1926 {
1927 wxGraphicsBrush p;
1928 wxCairoBrushData* d = new wxCairoBrushData( this );
1929 d->CreateRadialGradientBrush(xo, yo, xc, yc, r, stops);
1930 p.SetRefData(d);
1931 return p;
1932 }
1933
1934 // sets the font
1935 wxGraphicsFont wxCairoRenderer::CreateFont( const wxFont &font , const wxColour &col )
1936 {
1937 if ( font.Ok() )
1938 {
1939 wxGraphicsFont p;
1940 p.SetRefData(new wxCairoFontData( this , font, col ));
1941 return p;
1942 }
1943 else
1944 return wxNullGraphicsFont;
1945 }
1946
1947 wxGraphicsBitmap wxCairoRenderer::CreateBitmap( const wxBitmap& bmp )
1948 {
1949 if ( bmp.Ok() )
1950 {
1951 wxGraphicsBitmap p;
1952 p.SetRefData(new wxCairoBitmapData( this , bmp ));
1953 return p;
1954 }
1955 else
1956 return wxNullGraphicsBitmap;
1957 }
1958
1959 wxGraphicsBitmap wxCairoRenderer::CreateBitmapFromNativeBitmap( void* bitmap )
1960 {
1961 if ( bitmap != NULL )
1962 {
1963 wxGraphicsBitmap p;
1964 p.SetRefData(new wxCairoBitmapData( this , (cairo_surface_t*) bitmap ));
1965 return p;
1966 }
1967 else
1968 return wxNullGraphicsBitmap;
1969 }
1970
1971 wxGraphicsBitmap
1972 wxCairoRenderer::CreateSubBitmap(const wxGraphicsBitmap& WXUNUSED(bitmap),
1973 wxDouble WXUNUSED(x),
1974 wxDouble WXUNUSED(y),
1975 wxDouble WXUNUSED(w),
1976 wxDouble WXUNUSED(h))
1977 {
1978 wxFAIL_MSG("wxCairoRenderer::CreateSubBitmap is not implemented.");
1979 return wxNullGraphicsBitmap;
1980 }
1981
1982 wxGraphicsRenderer* wxGraphicsRenderer::GetCairoRenderer()
1983 {
1984 return &gs_cairoGraphicsRenderer;
1985 }
1986
1987 #else // !wxUSE_CAIRO
1988
1989 wxGraphicsRenderer* wxGraphicsRenderer::GetCairoRenderer()
1990 {
1991 return NULL;
1992 }
1993
1994 #endif // wxUSE_CAIRO/!wxUSE_CAIRO
1995
1996 // MSW and OS X have their own native default renderers, but the other ports
1997 // use Cairo by default
1998 #if !(defined(__WXMSW__) || defined(__WXOSX__))
1999 wxGraphicsRenderer* wxGraphicsRenderer::GetDefaultRenderer()
2000 {
2001 return GetCairoRenderer();
2002 }
2003 #endif // !(__WXMSW__ || __WXOSX__)
2004
2005 #endif // wxUSE_GRAPHICS_CONTEXT
wxWidgets (Impactor)